1 //===- BuildLibCalls.cpp - Utility builder for libcalls -------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements some functions that will create standard C libcalls.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "llvm/Transforms/Utils/BuildLibCalls.h"
14 #include "llvm/ADT/SmallString.h"
15 #include "llvm/ADT/Statistic.h"
16 #include "llvm/Analysis/TargetLibraryInfo.h"
17 #include "llvm/IR/Constants.h"
18 #include "llvm/IR/DataLayout.h"
19 #include "llvm/IR/Function.h"
20 #include "llvm/IR/IRBuilder.h"
21 #include "llvm/IR/Intrinsics.h"
22 #include "llvm/IR/LLVMContext.h"
23 #include "llvm/IR/Module.h"
24 #include "llvm/IR/Type.h"
25 #include "llvm/Analysis/MemoryBuiltins.h"
26 
27 using namespace llvm;
28 
29 #define DEBUG_TYPE "build-libcalls"
30 
31 //- Infer Attributes ---------------------------------------------------------//
32 
33 STATISTIC(NumReadNone, "Number of functions inferred as readnone");
34 STATISTIC(NumReadOnly, "Number of functions inferred as readonly");
35 STATISTIC(NumArgMemOnly, "Number of functions inferred as argmemonly");
36 STATISTIC(NumNoUnwind, "Number of functions inferred as nounwind");
37 STATISTIC(NumNoCapture, "Number of arguments inferred as nocapture");
38 STATISTIC(NumWriteOnlyArg, "Number of arguments inferred as writeonly");
39 STATISTIC(NumSExtArg, "Number of arguments inferred as signext");
40 STATISTIC(NumReadOnlyArg, "Number of arguments inferred as readonly");
41 STATISTIC(NumNoAlias, "Number of function returns inferred as noalias");
42 STATISTIC(NumNoUndef, "Number of function returns inferred as noundef returns");
43 STATISTIC(NumNonNull, "Number of function returns inferred as nonnull returns");
44 STATISTIC(NumReturnedArg, "Number of arguments inferred as returned");
45 STATISTIC(NumWillReturn, "Number of functions inferred as willreturn");
46 
47 static bool setDoesNotAccessMemory(Function &F) {
48   if (F.doesNotAccessMemory())
49     return false;
50   F.setDoesNotAccessMemory();
51   ++NumReadNone;
52   return true;
53 }
54 
55 static bool setOnlyReadsMemory(Function &F) {
56   if (F.onlyReadsMemory())
57     return false;
58   F.setOnlyReadsMemory();
59   ++NumReadOnly;
60   return true;
61 }
62 
63 static bool setOnlyAccessesArgMemory(Function &F) {
64   if (F.onlyAccessesArgMemory())
65     return false;
66   F.setOnlyAccessesArgMemory();
67   ++NumArgMemOnly;
68   return true;
69 }
70 
71 static bool setDoesNotThrow(Function &F) {
72   if (F.doesNotThrow())
73     return false;
74   F.setDoesNotThrow();
75   ++NumNoUnwind;
76   return true;
77 }
78 
79 static bool setRetDoesNotAlias(Function &F) {
80   if (F.hasAttribute(AttributeList::ReturnIndex, Attribute::NoAlias))
81     return false;
82   F.addAttribute(AttributeList::ReturnIndex, Attribute::NoAlias);
83   ++NumNoAlias;
84   return true;
85 }
86 
87 static bool setDoesNotCapture(Function &F, unsigned ArgNo) {
88   if (F.hasParamAttribute(ArgNo, Attribute::NoCapture))
89     return false;
90   F.addParamAttr(ArgNo, Attribute::NoCapture);
91   ++NumNoCapture;
92   return true;
93 }
94 
95 static bool setDoesNotAlias(Function &F, unsigned ArgNo) {
96   if (F.hasParamAttribute(ArgNo, Attribute::NoAlias))
97     return false;
98   F.addParamAttr(ArgNo, Attribute::NoAlias);
99   ++NumNoAlias;
100   return true;
101 }
102 
103 static bool setOnlyReadsMemory(Function &F, unsigned ArgNo) {
104   if (F.hasParamAttribute(ArgNo, Attribute::ReadOnly))
105     return false;
106   F.addParamAttr(ArgNo, Attribute::ReadOnly);
107   ++NumReadOnlyArg;
108   return true;
109 }
110 
111 static bool setOnlyWritesMemory(Function &F, unsigned ArgNo) {
112   if (F.hasParamAttribute(ArgNo, Attribute::WriteOnly))
113     return false;
114   F.addParamAttr(ArgNo, Attribute::WriteOnly);
115   ++NumWriteOnlyArg;
116   return true;
117 }
118 
119 static bool setSignExtendedArg(Function &F, unsigned ArgNo) {
120  if (F.hasParamAttribute(ArgNo, Attribute::SExt))
121     return false;
122   F.addParamAttr(ArgNo, Attribute::SExt);
123   ++NumSExtArg;
124   return true;
125 }
126 
127 static bool setRetNoUndef(Function &F) {
128   if (!F.getReturnType()->isVoidTy() &&
129       !F.hasAttribute(AttributeList::ReturnIndex, Attribute::NoUndef)) {
130     F.addAttribute(AttributeList::ReturnIndex, Attribute::NoUndef);
131     ++NumNoUndef;
132     return true;
133   }
134   return false;
135 }
136 
137 static bool setArgsNoUndef(Function &F) {
138   bool Changed = false;
139   for (unsigned ArgNo = 0; ArgNo < F.arg_size(); ++ArgNo) {
140     if (!F.hasParamAttribute(ArgNo, Attribute::NoUndef)) {
141       F.addParamAttr(ArgNo, Attribute::NoUndef);
142       ++NumNoUndef;
143       Changed = true;
144     }
145   }
146   return Changed;
147 }
148 
149 static bool setRetAndArgsNoUndef(Function &F) {
150   return setRetNoUndef(F) | setArgsNoUndef(F);
151 }
152 
153 static bool setRetNonNull(Function &F) {
154   assert(F.getReturnType()->isPointerTy() &&
155          "nonnull applies only to pointers");
156   if (F.hasAttribute(AttributeList::ReturnIndex, Attribute::NonNull))
157     return false;
158   F.addAttribute(AttributeList::ReturnIndex, Attribute::NonNull);
159   ++NumNonNull;
160   return true;
161 }
162 
163 static bool setReturnedArg(Function &F, unsigned ArgNo) {
164   if (F.hasParamAttribute(ArgNo, Attribute::Returned))
165     return false;
166   F.addParamAttr(ArgNo, Attribute::Returned);
167   ++NumReturnedArg;
168   return true;
169 }
170 
171 static bool setNonLazyBind(Function &F) {
172   if (F.hasFnAttribute(Attribute::NonLazyBind))
173     return false;
174   F.addFnAttr(Attribute::NonLazyBind);
175   return true;
176 }
177 
178 static bool setDoesNotFreeMemory(Function &F) {
179   if (F.hasFnAttribute(Attribute::NoFree))
180     return false;
181   F.addFnAttr(Attribute::NoFree);
182   return true;
183 }
184 
185 static bool setWillReturn(Function &F) {
186   if (F.hasFnAttribute(Attribute::WillReturn))
187     return false;
188   F.addFnAttr(Attribute::WillReturn);
189   ++NumWillReturn;
190   return true;
191 }
192 
193 bool llvm::inferLibFuncAttributes(Module *M, StringRef Name,
194                                   const TargetLibraryInfo &TLI) {
195   Function *F = M->getFunction(Name);
196   if (!F)
197     return false;
198   return inferLibFuncAttributes(*F, TLI);
199 }
200 
201 bool llvm::inferLibFuncAttributes(Function &F, const TargetLibraryInfo &TLI) {
202   LibFunc TheLibFunc;
203   if (!(TLI.getLibFunc(F, TheLibFunc) && TLI.has(TheLibFunc)))
204     return false;
205 
206   bool Changed = false;
207 
208   if(!isLibFreeFunction(&F, TheLibFunc) && !isReallocLikeFn(&F,  &TLI))
209     Changed |= setDoesNotFreeMemory(F);
210 
211   if (F.getParent() != nullptr && F.getParent()->getRtLibUseGOT())
212     Changed |= setNonLazyBind(F);
213 
214   switch (TheLibFunc) {
215   case LibFunc_strlen:
216   case LibFunc_wcslen:
217     Changed |= setOnlyReadsMemory(F);
218     Changed |= setDoesNotThrow(F);
219     Changed |= setOnlyAccessesArgMemory(F);
220     Changed |= setWillReturn(F);
221     Changed |= setDoesNotCapture(F, 0);
222     return Changed;
223   case LibFunc_strchr:
224   case LibFunc_strrchr:
225     Changed |= setOnlyAccessesArgMemory(F);
226     Changed |= setOnlyReadsMemory(F);
227     Changed |= setDoesNotThrow(F);
228     Changed |= setWillReturn(F);
229     return Changed;
230   case LibFunc_strtol:
231   case LibFunc_strtod:
232   case LibFunc_strtof:
233   case LibFunc_strtoul:
234   case LibFunc_strtoll:
235   case LibFunc_strtold:
236   case LibFunc_strtoull:
237     Changed |= setDoesNotThrow(F);
238     Changed |= setWillReturn(F);
239     Changed |= setDoesNotCapture(F, 1);
240     Changed |= setOnlyReadsMemory(F, 0);
241     return Changed;
242   case LibFunc_strcpy:
243   case LibFunc_strncpy:
244   case LibFunc_strcat:
245   case LibFunc_strncat:
246     Changed |= setWillReturn(F);
247     Changed |= setReturnedArg(F, 0);
248     LLVM_FALLTHROUGH;
249   case LibFunc_stpcpy:
250   case LibFunc_stpncpy:
251     Changed |= setOnlyAccessesArgMemory(F);
252     Changed |= setDoesNotThrow(F);
253     Changed |= setWillReturn(F);
254     Changed |= setDoesNotCapture(F, 1);
255     Changed |= setOnlyWritesMemory(F, 0);
256     Changed |= setOnlyReadsMemory(F, 1);
257     Changed |= setDoesNotAlias(F, 0);
258     Changed |= setDoesNotAlias(F, 1);
259     return Changed;
260   case LibFunc_strxfrm:
261     Changed |= setDoesNotThrow(F);
262     Changed |= setWillReturn(F);
263     Changed |= setDoesNotCapture(F, 0);
264     Changed |= setDoesNotCapture(F, 1);
265     Changed |= setOnlyReadsMemory(F, 1);
266     return Changed;
267   case LibFunc_strcmp:      // 0,1
268   case LibFunc_strspn:      // 0,1
269   case LibFunc_strncmp:     // 0,1
270   case LibFunc_strcspn:     // 0,1
271     Changed |= setDoesNotThrow(F);
272     Changed |= setOnlyAccessesArgMemory(F);
273     Changed |= setWillReturn(F);
274     Changed |= setOnlyReadsMemory(F);
275     Changed |= setDoesNotCapture(F, 0);
276     Changed |= setDoesNotCapture(F, 1);
277     return Changed;
278   case LibFunc_strcoll:
279   case LibFunc_strcasecmp:  // 0,1
280   case LibFunc_strncasecmp: //
281     // Those functions may depend on the locale, which may be accessed through
282     // global memory.
283     Changed |= setOnlyReadsMemory(F);
284     Changed |= setDoesNotThrow(F);
285     Changed |= setWillReturn(F);
286     Changed |= setDoesNotCapture(F, 0);
287     Changed |= setDoesNotCapture(F, 1);
288     return Changed;
289   case LibFunc_strstr:
290   case LibFunc_strpbrk:
291     Changed |= setOnlyAccessesArgMemory(F);
292     Changed |= setOnlyReadsMemory(F);
293     Changed |= setDoesNotThrow(F);
294     Changed |= setWillReturn(F);
295     Changed |= setDoesNotCapture(F, 1);
296     return Changed;
297   case LibFunc_strtok:
298   case LibFunc_strtok_r:
299     Changed |= setDoesNotThrow(F);
300     Changed |= setWillReturn(F);
301     Changed |= setDoesNotCapture(F, 1);
302     Changed |= setOnlyReadsMemory(F, 1);
303     return Changed;
304   case LibFunc_scanf:
305     Changed |= setRetAndArgsNoUndef(F);
306     Changed |= setDoesNotThrow(F);
307     Changed |= setDoesNotCapture(F, 0);
308     Changed |= setOnlyReadsMemory(F, 0);
309     return Changed;
310   case LibFunc_setbuf:
311   case LibFunc_setvbuf:
312     Changed |= setRetAndArgsNoUndef(F);
313     Changed |= setDoesNotThrow(F);
314     Changed |= setDoesNotCapture(F, 0);
315     return Changed;
316   case LibFunc_strdup:
317   case LibFunc_strndup:
318     Changed |= setDoesNotThrow(F);
319     Changed |= setRetDoesNotAlias(F);
320     Changed |= setWillReturn(F);
321     Changed |= setDoesNotCapture(F, 0);
322     Changed |= setOnlyReadsMemory(F, 0);
323     return Changed;
324   case LibFunc_stat:
325   case LibFunc_statvfs:
326     Changed |= setRetAndArgsNoUndef(F);
327     Changed |= setDoesNotThrow(F);
328     Changed |= setDoesNotCapture(F, 0);
329     Changed |= setDoesNotCapture(F, 1);
330     Changed |= setOnlyReadsMemory(F, 0);
331     return Changed;
332   case LibFunc_sscanf:
333     Changed |= setRetAndArgsNoUndef(F);
334     Changed |= setDoesNotThrow(F);
335     Changed |= setDoesNotCapture(F, 0);
336     Changed |= setDoesNotCapture(F, 1);
337     Changed |= setOnlyReadsMemory(F, 0);
338     Changed |= setOnlyReadsMemory(F, 1);
339     return Changed;
340   case LibFunc_sprintf:
341     Changed |= setRetAndArgsNoUndef(F);
342     Changed |= setDoesNotThrow(F);
343     Changed |= setDoesNotCapture(F, 0);
344     Changed |= setDoesNotAlias(F, 0);
345     Changed |= setOnlyWritesMemory(F, 0);
346     Changed |= setDoesNotCapture(F, 1);
347     Changed |= setOnlyReadsMemory(F, 1);
348     return Changed;
349   case LibFunc_snprintf:
350     Changed |= setRetAndArgsNoUndef(F);
351     Changed |= setDoesNotThrow(F);
352     Changed |= setDoesNotCapture(F, 0);
353     Changed |= setDoesNotAlias(F, 0);
354     Changed |= setOnlyWritesMemory(F, 0);
355     Changed |= setDoesNotCapture(F, 2);
356     Changed |= setOnlyReadsMemory(F, 2);
357     return Changed;
358   case LibFunc_setitimer:
359     Changed |= setRetAndArgsNoUndef(F);
360     Changed |= setDoesNotThrow(F);
361     Changed |= setWillReturn(F);
362     Changed |= setDoesNotCapture(F, 1);
363     Changed |= setDoesNotCapture(F, 2);
364     Changed |= setOnlyReadsMemory(F, 1);
365     return Changed;
366   case LibFunc_system:
367     // May throw; "system" is a valid pthread cancellation point.
368     Changed |= setRetAndArgsNoUndef(F);
369     Changed |= setDoesNotCapture(F, 0);
370     Changed |= setOnlyReadsMemory(F, 0);
371     return Changed;
372   case LibFunc_malloc:
373     Changed |= setRetNoUndef(F);
374     Changed |= setDoesNotThrow(F);
375     Changed |= setRetDoesNotAlias(F);
376     Changed |= setWillReturn(F);
377     return Changed;
378   case LibFunc_memcmp:
379     Changed |= setOnlyAccessesArgMemory(F);
380     Changed |= setOnlyReadsMemory(F);
381     Changed |= setDoesNotThrow(F);
382     Changed |= setWillReturn(F);
383     Changed |= setDoesNotCapture(F, 0);
384     Changed |= setDoesNotCapture(F, 1);
385     return Changed;
386   case LibFunc_memchr:
387   case LibFunc_memrchr:
388     Changed |= setDoesNotThrow(F);
389     Changed |= setOnlyAccessesArgMemory(F);
390     Changed |= setOnlyReadsMemory(F);
391     Changed |= setWillReturn(F);
392     return Changed;
393   case LibFunc_modf:
394   case LibFunc_modff:
395   case LibFunc_modfl:
396     Changed |= setDoesNotThrow(F);
397     Changed |= setWillReturn(F);
398     Changed |= setDoesNotCapture(F, 1);
399     return Changed;
400   case LibFunc_memcpy:
401     Changed |= setDoesNotThrow(F);
402     Changed |= setOnlyAccessesArgMemory(F);
403     Changed |= setWillReturn(F);
404     Changed |= setDoesNotAlias(F, 0);
405     Changed |= setReturnedArg(F, 0);
406     Changed |= setOnlyWritesMemory(F, 0);
407     Changed |= setDoesNotAlias(F, 1);
408     Changed |= setDoesNotCapture(F, 1);
409     Changed |= setOnlyReadsMemory(F, 1);
410     return Changed;
411   case LibFunc_memmove:
412     Changed |= setDoesNotThrow(F);
413     Changed |= setOnlyAccessesArgMemory(F);
414     Changed |= setWillReturn(F);
415     Changed |= setReturnedArg(F, 0);
416     Changed |= setOnlyWritesMemory(F, 0);
417     Changed |= setDoesNotCapture(F, 1);
418     Changed |= setOnlyReadsMemory(F, 1);
419     return Changed;
420   case LibFunc_mempcpy:
421   case LibFunc_memccpy:
422     Changed |= setDoesNotThrow(F);
423     Changed |= setOnlyAccessesArgMemory(F);
424     Changed |= setWillReturn(F);
425     Changed |= setDoesNotAlias(F, 0);
426     Changed |= setOnlyWritesMemory(F, 0);
427     Changed |= setDoesNotAlias(F, 1);
428     Changed |= setDoesNotCapture(F, 1);
429     Changed |= setOnlyReadsMemory(F, 1);
430     return Changed;
431   case LibFunc_memcpy_chk:
432     Changed |= setDoesNotThrow(F);
433     return Changed;
434   case LibFunc_memalign:
435     Changed |= setRetDoesNotAlias(F);
436     Changed |= setWillReturn(F);
437     return Changed;
438   case LibFunc_mkdir:
439     Changed |= setRetAndArgsNoUndef(F);
440     Changed |= setDoesNotThrow(F);
441     Changed |= setDoesNotCapture(F, 0);
442     Changed |= setOnlyReadsMemory(F, 0);
443     return Changed;
444   case LibFunc_mktime:
445     Changed |= setRetAndArgsNoUndef(F);
446     Changed |= setDoesNotThrow(F);
447     Changed |= setWillReturn(F);
448     Changed |= setDoesNotCapture(F, 0);
449     return Changed;
450   case LibFunc_realloc:
451     Changed |= setRetNoUndef(F);
452     Changed |= setDoesNotThrow(F);
453     Changed |= setRetDoesNotAlias(F);
454     Changed |= setWillReturn(F);
455     Changed |= setDoesNotCapture(F, 0);
456     return Changed;
457   case LibFunc_reallocf:
458     Changed |= setRetNoUndef(F);
459     Changed |= setWillReturn(F);
460     return Changed;
461   case LibFunc_read:
462     // May throw; "read" is a valid pthread cancellation point.
463     Changed |= setRetAndArgsNoUndef(F);
464     Changed |= setDoesNotCapture(F, 1);
465     return Changed;
466   case LibFunc_rewind:
467     Changed |= setRetAndArgsNoUndef(F);
468     Changed |= setDoesNotThrow(F);
469     Changed |= setDoesNotCapture(F, 0);
470     return Changed;
471   case LibFunc_rmdir:
472   case LibFunc_remove:
473   case LibFunc_realpath:
474     Changed |= setRetAndArgsNoUndef(F);
475     Changed |= setDoesNotThrow(F);
476     Changed |= setDoesNotCapture(F, 0);
477     Changed |= setOnlyReadsMemory(F, 0);
478     return Changed;
479   case LibFunc_rename:
480     Changed |= setRetAndArgsNoUndef(F);
481     Changed |= setDoesNotThrow(F);
482     Changed |= setDoesNotCapture(F, 0);
483     Changed |= setDoesNotCapture(F, 1);
484     Changed |= setOnlyReadsMemory(F, 0);
485     Changed |= setOnlyReadsMemory(F, 1);
486     return Changed;
487   case LibFunc_readlink:
488     Changed |= setRetAndArgsNoUndef(F);
489     Changed |= setDoesNotThrow(F);
490     Changed |= setDoesNotCapture(F, 0);
491     Changed |= setDoesNotCapture(F, 1);
492     Changed |= setOnlyReadsMemory(F, 0);
493     return Changed;
494   case LibFunc_write:
495     // May throw; "write" is a valid pthread cancellation point.
496     Changed |= setRetAndArgsNoUndef(F);
497     Changed |= setDoesNotCapture(F, 1);
498     Changed |= setOnlyReadsMemory(F, 1);
499     return Changed;
500   case LibFunc_aligned_alloc:
501     Changed |= setRetNoUndef(F);
502     Changed |= setDoesNotThrow(F);
503     Changed |= setRetDoesNotAlias(F);
504     Changed |= setWillReturn(F);
505     return Changed;
506   case LibFunc_bcopy:
507     Changed |= setDoesNotThrow(F);
508     Changed |= setOnlyAccessesArgMemory(F);
509     Changed |= setWillReturn(F);
510     Changed |= setDoesNotCapture(F, 0);
511     Changed |= setOnlyReadsMemory(F, 0);
512     Changed |= setOnlyWritesMemory(F, 1);
513     Changed |= setDoesNotCapture(F, 1);
514     return Changed;
515   case LibFunc_bcmp:
516     Changed |= setDoesNotThrow(F);
517     Changed |= setOnlyAccessesArgMemory(F);
518     Changed |= setOnlyReadsMemory(F);
519     Changed |= setWillReturn(F);
520     Changed |= setDoesNotCapture(F, 0);
521     Changed |= setDoesNotCapture(F, 1);
522     return Changed;
523   case LibFunc_bzero:
524     Changed |= setDoesNotThrow(F);
525     Changed |= setOnlyAccessesArgMemory(F);
526     Changed |= setWillReturn(F);
527     Changed |= setDoesNotCapture(F, 0);
528     Changed |= setOnlyWritesMemory(F, 0);
529     return Changed;
530   case LibFunc_calloc:
531     Changed |= setRetNoUndef(F);
532     Changed |= setDoesNotThrow(F);
533     Changed |= setRetDoesNotAlias(F);
534     Changed |= setWillReturn(F);
535     return Changed;
536   case LibFunc_chmod:
537   case LibFunc_chown:
538     Changed |= setRetAndArgsNoUndef(F);
539     Changed |= setDoesNotThrow(F);
540     Changed |= setDoesNotCapture(F, 0);
541     Changed |= setOnlyReadsMemory(F, 0);
542     return Changed;
543   case LibFunc_ctermid:
544   case LibFunc_clearerr:
545   case LibFunc_closedir:
546     Changed |= setRetAndArgsNoUndef(F);
547     Changed |= setDoesNotThrow(F);
548     Changed |= setDoesNotCapture(F, 0);
549     return Changed;
550   case LibFunc_atoi:
551   case LibFunc_atol:
552   case LibFunc_atof:
553   case LibFunc_atoll:
554     Changed |= setDoesNotThrow(F);
555     Changed |= setOnlyReadsMemory(F);
556     Changed |= setWillReturn(F);
557     Changed |= setDoesNotCapture(F, 0);
558     return Changed;
559   case LibFunc_access:
560     Changed |= setRetAndArgsNoUndef(F);
561     Changed |= setDoesNotThrow(F);
562     Changed |= setDoesNotCapture(F, 0);
563     Changed |= setOnlyReadsMemory(F, 0);
564     return Changed;
565   case LibFunc_fopen:
566     Changed |= setRetAndArgsNoUndef(F);
567     Changed |= setDoesNotThrow(F);
568     Changed |= setRetDoesNotAlias(F);
569     Changed |= setDoesNotCapture(F, 0);
570     Changed |= setDoesNotCapture(F, 1);
571     Changed |= setOnlyReadsMemory(F, 0);
572     Changed |= setOnlyReadsMemory(F, 1);
573     return Changed;
574   case LibFunc_fdopen:
575     Changed |= setRetAndArgsNoUndef(F);
576     Changed |= setDoesNotThrow(F);
577     Changed |= setRetDoesNotAlias(F);
578     Changed |= setDoesNotCapture(F, 1);
579     Changed |= setOnlyReadsMemory(F, 1);
580     return Changed;
581   case LibFunc_feof:
582     Changed |= setRetAndArgsNoUndef(F);
583     Changed |= setDoesNotThrow(F);
584     Changed |= setDoesNotCapture(F, 0);
585     return Changed;
586   case LibFunc_free:
587     Changed |= setArgsNoUndef(F);
588     Changed |= setDoesNotThrow(F);
589     Changed |= setWillReturn(F);
590     Changed |= setDoesNotCapture(F, 0);
591     return Changed;
592   case LibFunc_fseek:
593   case LibFunc_ftell:
594   case LibFunc_fgetc:
595   case LibFunc_fgetc_unlocked:
596   case LibFunc_fseeko:
597   case LibFunc_ftello:
598   case LibFunc_fileno:
599   case LibFunc_fflush:
600   case LibFunc_fclose:
601   case LibFunc_fsetpos:
602   case LibFunc_flockfile:
603   case LibFunc_funlockfile:
604   case LibFunc_ftrylockfile:
605     Changed |= setRetAndArgsNoUndef(F);
606     Changed |= setDoesNotThrow(F);
607     Changed |= setDoesNotCapture(F, 0);
608     return Changed;
609   case LibFunc_ferror:
610     Changed |= setRetAndArgsNoUndef(F);
611     Changed |= setDoesNotThrow(F);
612     Changed |= setDoesNotCapture(F, 0);
613     Changed |= setOnlyReadsMemory(F);
614     return Changed;
615   case LibFunc_fputc:
616   case LibFunc_fputc_unlocked:
617   case LibFunc_fstat:
618     Changed |= setRetAndArgsNoUndef(F);
619     Changed |= setDoesNotThrow(F);
620     Changed |= setDoesNotCapture(F, 1);
621     return Changed;
622   case LibFunc_frexp:
623   case LibFunc_frexpf:
624   case LibFunc_frexpl:
625     Changed |= setDoesNotThrow(F);
626     Changed |= setWillReturn(F);
627     Changed |= setDoesNotCapture(F, 1);
628     return Changed;
629   case LibFunc_fstatvfs:
630     Changed |= setRetAndArgsNoUndef(F);
631     Changed |= setDoesNotThrow(F);
632     Changed |= setDoesNotCapture(F, 1);
633     return Changed;
634   case LibFunc_fgets:
635   case LibFunc_fgets_unlocked:
636     Changed |= setRetAndArgsNoUndef(F);
637     Changed |= setDoesNotThrow(F);
638     Changed |= setDoesNotCapture(F, 2);
639     return Changed;
640   case LibFunc_fread:
641   case LibFunc_fread_unlocked:
642     Changed |= setRetAndArgsNoUndef(F);
643     Changed |= setDoesNotThrow(F);
644     Changed |= setDoesNotCapture(F, 0);
645     Changed |= setDoesNotCapture(F, 3);
646     return Changed;
647   case LibFunc_fwrite:
648   case LibFunc_fwrite_unlocked:
649     Changed |= setRetAndArgsNoUndef(F);
650     Changed |= setDoesNotThrow(F);
651     Changed |= setDoesNotCapture(F, 0);
652     Changed |= setDoesNotCapture(F, 3);
653     // FIXME: readonly #1?
654     return Changed;
655   case LibFunc_fputs:
656   case LibFunc_fputs_unlocked:
657     Changed |= setRetAndArgsNoUndef(F);
658     Changed |= setDoesNotThrow(F);
659     Changed |= setDoesNotCapture(F, 0);
660     Changed |= setDoesNotCapture(F, 1);
661     Changed |= setOnlyReadsMemory(F, 0);
662     return Changed;
663   case LibFunc_fscanf:
664   case LibFunc_fprintf:
665     Changed |= setRetAndArgsNoUndef(F);
666     Changed |= setDoesNotThrow(F);
667     Changed |= setDoesNotCapture(F, 0);
668     Changed |= setDoesNotCapture(F, 1);
669     Changed |= setOnlyReadsMemory(F, 1);
670     return Changed;
671   case LibFunc_fgetpos:
672     Changed |= setRetAndArgsNoUndef(F);
673     Changed |= setDoesNotThrow(F);
674     Changed |= setDoesNotCapture(F, 0);
675     Changed |= setDoesNotCapture(F, 1);
676     return Changed;
677   case LibFunc_getc:
678     Changed |= setRetAndArgsNoUndef(F);
679     Changed |= setDoesNotThrow(F);
680     Changed |= setDoesNotCapture(F, 0);
681     return Changed;
682   case LibFunc_getlogin_r:
683     Changed |= setRetAndArgsNoUndef(F);
684     Changed |= setDoesNotThrow(F);
685     Changed |= setDoesNotCapture(F, 0);
686     return Changed;
687   case LibFunc_getc_unlocked:
688     Changed |= setRetAndArgsNoUndef(F);
689     Changed |= setDoesNotThrow(F);
690     Changed |= setDoesNotCapture(F, 0);
691     return Changed;
692   case LibFunc_getenv:
693     Changed |= setRetAndArgsNoUndef(F);
694     Changed |= setDoesNotThrow(F);
695     Changed |= setOnlyReadsMemory(F);
696     Changed |= setDoesNotCapture(F, 0);
697     return Changed;
698   case LibFunc_gets:
699   case LibFunc_getchar:
700   case LibFunc_getchar_unlocked:
701     Changed |= setRetAndArgsNoUndef(F);
702     Changed |= setDoesNotThrow(F);
703     return Changed;
704   case LibFunc_getitimer:
705     Changed |= setRetAndArgsNoUndef(F);
706     Changed |= setDoesNotThrow(F);
707     Changed |= setDoesNotCapture(F, 1);
708     return Changed;
709   case LibFunc_getpwnam:
710     Changed |= setRetAndArgsNoUndef(F);
711     Changed |= setDoesNotThrow(F);
712     Changed |= setDoesNotCapture(F, 0);
713     Changed |= setOnlyReadsMemory(F, 0);
714     return Changed;
715   case LibFunc_ungetc:
716     Changed |= setRetAndArgsNoUndef(F);
717     Changed |= setDoesNotThrow(F);
718     Changed |= setDoesNotCapture(F, 1);
719     return Changed;
720   case LibFunc_uname:
721     Changed |= setRetAndArgsNoUndef(F);
722     Changed |= setDoesNotThrow(F);
723     Changed |= setDoesNotCapture(F, 0);
724     return Changed;
725   case LibFunc_unlink:
726     Changed |= setRetAndArgsNoUndef(F);
727     Changed |= setDoesNotThrow(F);
728     Changed |= setDoesNotCapture(F, 0);
729     Changed |= setOnlyReadsMemory(F, 0);
730     return Changed;
731   case LibFunc_unsetenv:
732     Changed |= setRetAndArgsNoUndef(F);
733     Changed |= setDoesNotThrow(F);
734     Changed |= setDoesNotCapture(F, 0);
735     Changed |= setOnlyReadsMemory(F, 0);
736     return Changed;
737   case LibFunc_utime:
738   case LibFunc_utimes:
739     Changed |= setRetAndArgsNoUndef(F);
740     Changed |= setDoesNotThrow(F);
741     Changed |= setDoesNotCapture(F, 0);
742     Changed |= setDoesNotCapture(F, 1);
743     Changed |= setOnlyReadsMemory(F, 0);
744     Changed |= setOnlyReadsMemory(F, 1);
745     return Changed;
746   case LibFunc_putc:
747   case LibFunc_putc_unlocked:
748     Changed |= setRetAndArgsNoUndef(F);
749     Changed |= setDoesNotThrow(F);
750     Changed |= setDoesNotCapture(F, 1);
751     return Changed;
752   case LibFunc_puts:
753   case LibFunc_printf:
754   case LibFunc_perror:
755     Changed |= setRetAndArgsNoUndef(F);
756     Changed |= setDoesNotThrow(F);
757     Changed |= setDoesNotCapture(F, 0);
758     Changed |= setOnlyReadsMemory(F, 0);
759     return Changed;
760   case LibFunc_pread:
761     // May throw; "pread" is a valid pthread cancellation point.
762     Changed |= setRetAndArgsNoUndef(F);
763     Changed |= setDoesNotCapture(F, 1);
764     return Changed;
765   case LibFunc_pwrite:
766     // May throw; "pwrite" is a valid pthread cancellation point.
767     Changed |= setRetAndArgsNoUndef(F);
768     Changed |= setDoesNotCapture(F, 1);
769     Changed |= setOnlyReadsMemory(F, 1);
770     return Changed;
771   case LibFunc_putchar:
772   case LibFunc_putchar_unlocked:
773     Changed |= setRetAndArgsNoUndef(F);
774     Changed |= setDoesNotThrow(F);
775     return Changed;
776   case LibFunc_popen:
777     Changed |= setRetAndArgsNoUndef(F);
778     Changed |= setDoesNotThrow(F);
779     Changed |= setRetDoesNotAlias(F);
780     Changed |= setDoesNotCapture(F, 0);
781     Changed |= setDoesNotCapture(F, 1);
782     Changed |= setOnlyReadsMemory(F, 0);
783     Changed |= setOnlyReadsMemory(F, 1);
784     return Changed;
785   case LibFunc_pclose:
786     Changed |= setRetAndArgsNoUndef(F);
787     Changed |= setDoesNotThrow(F);
788     Changed |= setDoesNotCapture(F, 0);
789     return Changed;
790   case LibFunc_vscanf:
791     Changed |= setRetAndArgsNoUndef(F);
792     Changed |= setDoesNotThrow(F);
793     Changed |= setDoesNotCapture(F, 0);
794     Changed |= setOnlyReadsMemory(F, 0);
795     return Changed;
796   case LibFunc_vsscanf:
797     Changed |= setRetAndArgsNoUndef(F);
798     Changed |= setDoesNotThrow(F);
799     Changed |= setDoesNotCapture(F, 0);
800     Changed |= setDoesNotCapture(F, 1);
801     Changed |= setOnlyReadsMemory(F, 0);
802     Changed |= setOnlyReadsMemory(F, 1);
803     return Changed;
804   case LibFunc_vfscanf:
805     Changed |= setRetAndArgsNoUndef(F);
806     Changed |= setDoesNotThrow(F);
807     Changed |= setDoesNotCapture(F, 0);
808     Changed |= setDoesNotCapture(F, 1);
809     Changed |= setOnlyReadsMemory(F, 1);
810     return Changed;
811   case LibFunc_valloc:
812     Changed |= setRetNoUndef(F);
813     Changed |= setDoesNotThrow(F);
814     Changed |= setRetDoesNotAlias(F);
815     return Changed;
816   case LibFunc_vprintf:
817     Changed |= setRetAndArgsNoUndef(F);
818     Changed |= setDoesNotThrow(F);
819     Changed |= setDoesNotCapture(F, 0);
820     Changed |= setOnlyReadsMemory(F, 0);
821     return Changed;
822   case LibFunc_vfprintf:
823   case LibFunc_vsprintf:
824     Changed |= setRetAndArgsNoUndef(F);
825     Changed |= setDoesNotThrow(F);
826     Changed |= setDoesNotCapture(F, 0);
827     Changed |= setDoesNotCapture(F, 1);
828     Changed |= setOnlyReadsMemory(F, 1);
829     return Changed;
830   case LibFunc_vsnprintf:
831     Changed |= setRetAndArgsNoUndef(F);
832     Changed |= setDoesNotThrow(F);
833     Changed |= setDoesNotCapture(F, 0);
834     Changed |= setDoesNotCapture(F, 2);
835     Changed |= setOnlyReadsMemory(F, 2);
836     return Changed;
837   case LibFunc_open:
838     // May throw; "open" is a valid pthread cancellation point.
839     Changed |= setRetAndArgsNoUndef(F);
840     Changed |= setDoesNotCapture(F, 0);
841     Changed |= setOnlyReadsMemory(F, 0);
842     return Changed;
843   case LibFunc_opendir:
844     Changed |= setRetAndArgsNoUndef(F);
845     Changed |= setDoesNotThrow(F);
846     Changed |= setRetDoesNotAlias(F);
847     Changed |= setDoesNotCapture(F, 0);
848     Changed |= setOnlyReadsMemory(F, 0);
849     return Changed;
850   case LibFunc_tmpfile:
851     Changed |= setRetAndArgsNoUndef(F);
852     Changed |= setDoesNotThrow(F);
853     Changed |= setRetDoesNotAlias(F);
854     return Changed;
855   case LibFunc_times:
856     Changed |= setRetAndArgsNoUndef(F);
857     Changed |= setDoesNotThrow(F);
858     Changed |= setDoesNotCapture(F, 0);
859     return Changed;
860   case LibFunc_htonl:
861   case LibFunc_htons:
862   case LibFunc_ntohl:
863   case LibFunc_ntohs:
864     Changed |= setDoesNotThrow(F);
865     Changed |= setDoesNotAccessMemory(F);
866     return Changed;
867   case LibFunc_lstat:
868     Changed |= setRetAndArgsNoUndef(F);
869     Changed |= setDoesNotThrow(F);
870     Changed |= setDoesNotCapture(F, 0);
871     Changed |= setDoesNotCapture(F, 1);
872     Changed |= setOnlyReadsMemory(F, 0);
873     return Changed;
874   case LibFunc_lchown:
875     Changed |= setRetAndArgsNoUndef(F);
876     Changed |= setDoesNotThrow(F);
877     Changed |= setDoesNotCapture(F, 0);
878     Changed |= setOnlyReadsMemory(F, 0);
879     return Changed;
880   case LibFunc_qsort:
881     // May throw; places call through function pointer.
882     // Cannot give undef pointer/size
883     Changed |= setRetAndArgsNoUndef(F);
884     Changed |= setDoesNotCapture(F, 3);
885     return Changed;
886   case LibFunc_dunder_strdup:
887   case LibFunc_dunder_strndup:
888     Changed |= setDoesNotThrow(F);
889     Changed |= setRetDoesNotAlias(F);
890     Changed |= setWillReturn(F);
891     Changed |= setDoesNotCapture(F, 0);
892     Changed |= setOnlyReadsMemory(F, 0);
893     return Changed;
894   case LibFunc_dunder_strtok_r:
895     Changed |= setDoesNotThrow(F);
896     Changed |= setDoesNotCapture(F, 1);
897     Changed |= setOnlyReadsMemory(F, 1);
898     return Changed;
899   case LibFunc_under_IO_getc:
900     Changed |= setRetAndArgsNoUndef(F);
901     Changed |= setDoesNotThrow(F);
902     Changed |= setDoesNotCapture(F, 0);
903     return Changed;
904   case LibFunc_under_IO_putc:
905     Changed |= setRetAndArgsNoUndef(F);
906     Changed |= setDoesNotThrow(F);
907     Changed |= setDoesNotCapture(F, 1);
908     return Changed;
909   case LibFunc_dunder_isoc99_scanf:
910     Changed |= setRetAndArgsNoUndef(F);
911     Changed |= setDoesNotThrow(F);
912     Changed |= setDoesNotCapture(F, 0);
913     Changed |= setOnlyReadsMemory(F, 0);
914     return Changed;
915   case LibFunc_stat64:
916   case LibFunc_lstat64:
917   case LibFunc_statvfs64:
918     Changed |= setRetAndArgsNoUndef(F);
919     Changed |= setDoesNotThrow(F);
920     Changed |= setDoesNotCapture(F, 0);
921     Changed |= setDoesNotCapture(F, 1);
922     Changed |= setOnlyReadsMemory(F, 0);
923     return Changed;
924   case LibFunc_dunder_isoc99_sscanf:
925     Changed |= setRetAndArgsNoUndef(F);
926     Changed |= setDoesNotThrow(F);
927     Changed |= setDoesNotCapture(F, 0);
928     Changed |= setDoesNotCapture(F, 1);
929     Changed |= setOnlyReadsMemory(F, 0);
930     Changed |= setOnlyReadsMemory(F, 1);
931     return Changed;
932   case LibFunc_fopen64:
933     Changed |= setRetAndArgsNoUndef(F);
934     Changed |= setDoesNotThrow(F);
935     Changed |= setRetDoesNotAlias(F);
936     Changed |= setDoesNotCapture(F, 0);
937     Changed |= setDoesNotCapture(F, 1);
938     Changed |= setOnlyReadsMemory(F, 0);
939     Changed |= setOnlyReadsMemory(F, 1);
940     return Changed;
941   case LibFunc_fseeko64:
942   case LibFunc_ftello64:
943     Changed |= setRetAndArgsNoUndef(F);
944     Changed |= setDoesNotThrow(F);
945     Changed |= setDoesNotCapture(F, 0);
946     return Changed;
947   case LibFunc_tmpfile64:
948     Changed |= setRetAndArgsNoUndef(F);
949     Changed |= setDoesNotThrow(F);
950     Changed |= setRetDoesNotAlias(F);
951     return Changed;
952   case LibFunc_fstat64:
953   case LibFunc_fstatvfs64:
954     Changed |= setRetAndArgsNoUndef(F);
955     Changed |= setDoesNotThrow(F);
956     Changed |= setDoesNotCapture(F, 1);
957     return Changed;
958   case LibFunc_open64:
959     // May throw; "open" is a valid pthread cancellation point.
960     Changed |= setRetAndArgsNoUndef(F);
961     Changed |= setDoesNotCapture(F, 0);
962     Changed |= setOnlyReadsMemory(F, 0);
963     return Changed;
964   case LibFunc_gettimeofday:
965     // Currently some platforms have the restrict keyword on the arguments to
966     // gettimeofday. To be conservative, do not add noalias to gettimeofday's
967     // arguments.
968     Changed |= setRetAndArgsNoUndef(F);
969     Changed |= setDoesNotThrow(F);
970     Changed |= setDoesNotCapture(F, 0);
971     Changed |= setDoesNotCapture(F, 1);
972     return Changed;
973   case LibFunc_Znwj: // new(unsigned int)
974   case LibFunc_Znwm: // new(unsigned long)
975   case LibFunc_Znaj: // new[](unsigned int)
976   case LibFunc_Znam: // new[](unsigned long)
977   case LibFunc_msvc_new_int: // new(unsigned int)
978   case LibFunc_msvc_new_longlong: // new(unsigned long long)
979   case LibFunc_msvc_new_array_int: // new[](unsigned int)
980   case LibFunc_msvc_new_array_longlong: // new[](unsigned long long)
981     // Operator new always returns a nonnull noalias pointer
982     Changed |= setRetNoUndef(F);
983     Changed |= setRetNonNull(F);
984     Changed |= setRetDoesNotAlias(F);
985     Changed |= setWillReturn(F);
986     return Changed;
987   // TODO: add LibFunc entries for:
988   // case LibFunc_memset_pattern4:
989   // case LibFunc_memset_pattern8:
990   case LibFunc_memset_pattern16:
991     Changed |= setOnlyAccessesArgMemory(F);
992     Changed |= setDoesNotCapture(F, 0);
993     Changed |= setOnlyWritesMemory(F, 0);
994     Changed |= setDoesNotCapture(F, 1);
995     Changed |= setOnlyReadsMemory(F, 1);
996     return Changed;
997   case LibFunc_memset:
998     Changed |= setOnlyAccessesArgMemory(F);
999     Changed |= setWillReturn(F);
1000     Changed |= setDoesNotThrow(F);
1001     Changed |= setOnlyWritesMemory(F, 0);
1002     return Changed;
1003   // int __nvvm_reflect(const char *)
1004   case LibFunc_nvvm_reflect:
1005     Changed |= setRetAndArgsNoUndef(F);
1006     Changed |= setDoesNotAccessMemory(F);
1007     Changed |= setDoesNotThrow(F);
1008     return Changed;
1009   case LibFunc_ldexp:
1010   case LibFunc_ldexpf:
1011   case LibFunc_ldexpl:
1012     Changed |= setSignExtendedArg(F, 1);
1013     Changed |= setWillReturn(F);
1014     return Changed;
1015   case LibFunc_abs:
1016   case LibFunc_acos:
1017   case LibFunc_acosf:
1018   case LibFunc_acosh:
1019   case LibFunc_acoshf:
1020   case LibFunc_acoshl:
1021   case LibFunc_acosl:
1022   case LibFunc_asin:
1023   case LibFunc_asinf:
1024   case LibFunc_asinh:
1025   case LibFunc_asinhf:
1026   case LibFunc_asinhl:
1027   case LibFunc_asinl:
1028   case LibFunc_atan:
1029   case LibFunc_atan2:
1030   case LibFunc_atan2f:
1031   case LibFunc_atan2l:
1032   case LibFunc_atanf:
1033   case LibFunc_atanh:
1034   case LibFunc_atanhf:
1035   case LibFunc_atanhl:
1036   case LibFunc_atanl:
1037   case LibFunc_cbrt:
1038   case LibFunc_cbrtf:
1039   case LibFunc_cbrtl:
1040   case LibFunc_ceil:
1041   case LibFunc_ceilf:
1042   case LibFunc_ceill:
1043   case LibFunc_copysign:
1044   case LibFunc_copysignf:
1045   case LibFunc_copysignl:
1046   case LibFunc_cos:
1047   case LibFunc_cosh:
1048   case LibFunc_coshf:
1049   case LibFunc_coshl:
1050   case LibFunc_cosf:
1051   case LibFunc_cosl:
1052   case LibFunc_cospi:
1053   case LibFunc_cospif:
1054   case LibFunc_exp:
1055   case LibFunc_expf:
1056   case LibFunc_expl:
1057   case LibFunc_exp2:
1058   case LibFunc_exp2f:
1059   case LibFunc_exp2l:
1060   case LibFunc_expm1:
1061   case LibFunc_expm1f:
1062   case LibFunc_expm1l:
1063   case LibFunc_fabs:
1064   case LibFunc_fabsf:
1065   case LibFunc_fabsl:
1066   case LibFunc_ffs:
1067   case LibFunc_ffsl:
1068   case LibFunc_ffsll:
1069   case LibFunc_floor:
1070   case LibFunc_floorf:
1071   case LibFunc_floorl:
1072   case LibFunc_fls:
1073   case LibFunc_flsl:
1074   case LibFunc_flsll:
1075   case LibFunc_fmax:
1076   case LibFunc_fmaxf:
1077   case LibFunc_fmaxl:
1078   case LibFunc_fmin:
1079   case LibFunc_fminf:
1080   case LibFunc_fminl:
1081   case LibFunc_fmod:
1082   case LibFunc_fmodf:
1083   case LibFunc_fmodl:
1084   case LibFunc_isascii:
1085   case LibFunc_isdigit:
1086   case LibFunc_labs:
1087   case LibFunc_llabs:
1088   case LibFunc_log:
1089   case LibFunc_log10:
1090   case LibFunc_log10f:
1091   case LibFunc_log10l:
1092   case LibFunc_log1p:
1093   case LibFunc_log1pf:
1094   case LibFunc_log1pl:
1095   case LibFunc_log2:
1096   case LibFunc_log2f:
1097   case LibFunc_log2l:
1098   case LibFunc_logb:
1099   case LibFunc_logbf:
1100   case LibFunc_logbl:
1101   case LibFunc_logf:
1102   case LibFunc_logl:
1103   case LibFunc_nearbyint:
1104   case LibFunc_nearbyintf:
1105   case LibFunc_nearbyintl:
1106   case LibFunc_pow:
1107   case LibFunc_powf:
1108   case LibFunc_powl:
1109   case LibFunc_rint:
1110   case LibFunc_rintf:
1111   case LibFunc_rintl:
1112   case LibFunc_round:
1113   case LibFunc_roundf:
1114   case LibFunc_roundl:
1115   case LibFunc_sin:
1116   case LibFunc_sincospif_stret:
1117   case LibFunc_sinf:
1118   case LibFunc_sinh:
1119   case LibFunc_sinhf:
1120   case LibFunc_sinhl:
1121   case LibFunc_sinl:
1122   case LibFunc_sinpi:
1123   case LibFunc_sinpif:
1124   case LibFunc_sqrt:
1125   case LibFunc_sqrtf:
1126   case LibFunc_sqrtl:
1127   case LibFunc_strnlen:
1128   case LibFunc_tan:
1129   case LibFunc_tanf:
1130   case LibFunc_tanh:
1131   case LibFunc_tanhf:
1132   case LibFunc_tanhl:
1133   case LibFunc_tanl:
1134   case LibFunc_toascii:
1135   case LibFunc_trunc:
1136   case LibFunc_truncf:
1137   case LibFunc_truncl:
1138     Changed |= setDoesNotThrow(F);
1139     Changed |= setDoesNotFreeMemory(F);
1140     Changed |= setWillReturn(F);
1141     return Changed;
1142   default:
1143     // FIXME: It'd be really nice to cover all the library functions we're
1144     // aware of here.
1145     return false;
1146   }
1147 }
1148 
1149 bool llvm::hasFloatFn(const TargetLibraryInfo *TLI, Type *Ty,
1150                       LibFunc DoubleFn, LibFunc FloatFn, LibFunc LongDoubleFn) {
1151   switch (Ty->getTypeID()) {
1152   case Type::HalfTyID:
1153     return false;
1154   case Type::FloatTyID:
1155     return TLI->has(FloatFn);
1156   case Type::DoubleTyID:
1157     return TLI->has(DoubleFn);
1158   default:
1159     return TLI->has(LongDoubleFn);
1160   }
1161 }
1162 
1163 StringRef llvm::getFloatFnName(const TargetLibraryInfo *TLI, Type *Ty,
1164                                LibFunc DoubleFn, LibFunc FloatFn,
1165                                LibFunc LongDoubleFn) {
1166   assert(hasFloatFn(TLI, Ty, DoubleFn, FloatFn, LongDoubleFn) &&
1167          "Cannot get name for unavailable function!");
1168 
1169   switch (Ty->getTypeID()) {
1170   case Type::HalfTyID:
1171     llvm_unreachable("No name for HalfTy!");
1172   case Type::FloatTyID:
1173     return TLI->getName(FloatFn);
1174   case Type::DoubleTyID:
1175     return TLI->getName(DoubleFn);
1176   default:
1177     return TLI->getName(LongDoubleFn);
1178   }
1179 }
1180 
1181 //- Emit LibCalls ------------------------------------------------------------//
1182 
1183 Value *llvm::castToCStr(Value *V, IRBuilderBase &B) {
1184   unsigned AS = V->getType()->getPointerAddressSpace();
1185   return B.CreateBitCast(V, B.getInt8PtrTy(AS), "cstr");
1186 }
1187 
1188 static Value *emitLibCall(LibFunc TheLibFunc, Type *ReturnType,
1189                           ArrayRef<Type *> ParamTypes,
1190                           ArrayRef<Value *> Operands, IRBuilderBase &B,
1191                           const TargetLibraryInfo *TLI,
1192                           bool IsVaArgs = false) {
1193   if (!TLI->has(TheLibFunc))
1194     return nullptr;
1195 
1196   Module *M = B.GetInsertBlock()->getModule();
1197   StringRef FuncName = TLI->getName(TheLibFunc);
1198   FunctionType *FuncType = FunctionType::get(ReturnType, ParamTypes, IsVaArgs);
1199   FunctionCallee Callee = M->getOrInsertFunction(FuncName, FuncType);
1200   inferLibFuncAttributes(M, FuncName, *TLI);
1201   CallInst *CI = B.CreateCall(Callee, Operands, FuncName);
1202   if (const Function *F =
1203           dyn_cast<Function>(Callee.getCallee()->stripPointerCasts()))
1204     CI->setCallingConv(F->getCallingConv());
1205   return CI;
1206 }
1207 
1208 Value *llvm::emitStrLen(Value *Ptr, IRBuilderBase &B, const DataLayout &DL,
1209                         const TargetLibraryInfo *TLI) {
1210   LLVMContext &Context = B.GetInsertBlock()->getContext();
1211   return emitLibCall(LibFunc_strlen, DL.getIntPtrType(Context),
1212                      B.getInt8PtrTy(), castToCStr(Ptr, B), B, TLI);
1213 }
1214 
1215 Value *llvm::emitStrDup(Value *Ptr, IRBuilderBase &B,
1216                         const TargetLibraryInfo *TLI) {
1217   return emitLibCall(LibFunc_strdup, B.getInt8PtrTy(), B.getInt8PtrTy(),
1218                      castToCStr(Ptr, B), B, TLI);
1219 }
1220 
1221 Value *llvm::emitStrChr(Value *Ptr, char C, IRBuilderBase &B,
1222                         const TargetLibraryInfo *TLI) {
1223   Type *I8Ptr = B.getInt8PtrTy();
1224   Type *I32Ty = B.getInt32Ty();
1225   return emitLibCall(LibFunc_strchr, I8Ptr, {I8Ptr, I32Ty},
1226                      {castToCStr(Ptr, B), ConstantInt::get(I32Ty, C)}, B, TLI);
1227 }
1228 
1229 Value *llvm::emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
1230                          const DataLayout &DL, const TargetLibraryInfo *TLI) {
1231   LLVMContext &Context = B.GetInsertBlock()->getContext();
1232   return emitLibCall(
1233       LibFunc_strncmp, B.getInt32Ty(),
1234       {B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context)},
1235       {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI);
1236 }
1237 
1238 Value *llvm::emitStrCpy(Value *Dst, Value *Src, IRBuilderBase &B,
1239                         const TargetLibraryInfo *TLI) {
1240   Type *I8Ptr = B.getInt8PtrTy();
1241   return emitLibCall(LibFunc_strcpy, I8Ptr, {I8Ptr, I8Ptr},
1242                      {castToCStr(Dst, B), castToCStr(Src, B)}, B, TLI);
1243 }
1244 
1245 Value *llvm::emitStpCpy(Value *Dst, Value *Src, IRBuilderBase &B,
1246                         const TargetLibraryInfo *TLI) {
1247   Type *I8Ptr = B.getInt8PtrTy();
1248   return emitLibCall(LibFunc_stpcpy, I8Ptr, {I8Ptr, I8Ptr},
1249                      {castToCStr(Dst, B), castToCStr(Src, B)}, B, TLI);
1250 }
1251 
1252 Value *llvm::emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B,
1253                          const TargetLibraryInfo *TLI) {
1254   Type *I8Ptr = B.getInt8PtrTy();
1255   return emitLibCall(LibFunc_strncpy, I8Ptr, {I8Ptr, I8Ptr, Len->getType()},
1256                      {castToCStr(Dst, B), castToCStr(Src, B), Len}, B, TLI);
1257 }
1258 
1259 Value *llvm::emitStpNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B,
1260                          const TargetLibraryInfo *TLI) {
1261   Type *I8Ptr = B.getInt8PtrTy();
1262   return emitLibCall(LibFunc_stpncpy, I8Ptr, {I8Ptr, I8Ptr, Len->getType()},
1263                      {castToCStr(Dst, B), castToCStr(Src, B), Len}, B, TLI);
1264 }
1265 
1266 Value *llvm::emitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize,
1267                            IRBuilderBase &B, const DataLayout &DL,
1268                            const TargetLibraryInfo *TLI) {
1269   if (!TLI->has(LibFunc_memcpy_chk))
1270     return nullptr;
1271 
1272   Module *M = B.GetInsertBlock()->getModule();
1273   AttributeList AS;
1274   AS = AttributeList::get(M->getContext(), AttributeList::FunctionIndex,
1275                           Attribute::NoUnwind);
1276   LLVMContext &Context = B.GetInsertBlock()->getContext();
1277   FunctionCallee MemCpy = M->getOrInsertFunction(
1278       "__memcpy_chk", AttributeList::get(M->getContext(), AS), B.getInt8PtrTy(),
1279       B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context),
1280       DL.getIntPtrType(Context));
1281   Dst = castToCStr(Dst, B);
1282   Src = castToCStr(Src, B);
1283   CallInst *CI = B.CreateCall(MemCpy, {Dst, Src, Len, ObjSize});
1284   if (const Function *F =
1285           dyn_cast<Function>(MemCpy.getCallee()->stripPointerCasts()))
1286     CI->setCallingConv(F->getCallingConv());
1287   return CI;
1288 }
1289 
1290 Value *llvm::emitMemPCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B,
1291                          const DataLayout &DL, const TargetLibraryInfo *TLI) {
1292   LLVMContext &Context = B.GetInsertBlock()->getContext();
1293   return emitLibCall(
1294       LibFunc_mempcpy, B.getInt8PtrTy(),
1295       {B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context)},
1296       {Dst, Src, Len}, B, TLI);
1297 }
1298 
1299 Value *llvm::emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilderBase &B,
1300                         const DataLayout &DL, const TargetLibraryInfo *TLI) {
1301   LLVMContext &Context = B.GetInsertBlock()->getContext();
1302   return emitLibCall(
1303       LibFunc_memchr, B.getInt8PtrTy(),
1304       {B.getInt8PtrTy(), B.getInt32Ty(), DL.getIntPtrType(Context)},
1305       {castToCStr(Ptr, B), Val, Len}, B, TLI);
1306 }
1307 
1308 Value *llvm::emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
1309                         const DataLayout &DL, const TargetLibraryInfo *TLI) {
1310   LLVMContext &Context = B.GetInsertBlock()->getContext();
1311   return emitLibCall(
1312       LibFunc_memcmp, B.getInt32Ty(),
1313       {B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context)},
1314       {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI);
1315 }
1316 
1317 Value *llvm::emitBCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
1318                       const DataLayout &DL, const TargetLibraryInfo *TLI) {
1319   LLVMContext &Context = B.GetInsertBlock()->getContext();
1320   return emitLibCall(
1321       LibFunc_bcmp, B.getInt32Ty(),
1322       {B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context)},
1323       {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI);
1324 }
1325 
1326 Value *llvm::emitMemCCpy(Value *Ptr1, Value *Ptr2, Value *Val, Value *Len,
1327                          IRBuilderBase &B, const TargetLibraryInfo *TLI) {
1328   return emitLibCall(
1329       LibFunc_memccpy, B.getInt8PtrTy(),
1330       {B.getInt8PtrTy(), B.getInt8PtrTy(), B.getInt32Ty(), Len->getType()},
1331       {Ptr1, Ptr2, Val, Len}, B, TLI);
1332 }
1333 
1334 Value *llvm::emitSNPrintf(Value *Dest, Value *Size, Value *Fmt,
1335                           ArrayRef<Value *> VariadicArgs, IRBuilderBase &B,
1336                           const TargetLibraryInfo *TLI) {
1337   SmallVector<Value *, 8> Args{castToCStr(Dest, B), Size, castToCStr(Fmt, B)};
1338   llvm::append_range(Args, VariadicArgs);
1339   return emitLibCall(LibFunc_snprintf, B.getInt32Ty(),
1340                      {B.getInt8PtrTy(), Size->getType(), B.getInt8PtrTy()},
1341                      Args, B, TLI, /*IsVaArgs=*/true);
1342 }
1343 
1344 Value *llvm::emitSPrintf(Value *Dest, Value *Fmt,
1345                          ArrayRef<Value *> VariadicArgs, IRBuilderBase &B,
1346                          const TargetLibraryInfo *TLI) {
1347   SmallVector<Value *, 8> Args{castToCStr(Dest, B), castToCStr(Fmt, B)};
1348   llvm::append_range(Args, VariadicArgs);
1349   return emitLibCall(LibFunc_sprintf, B.getInt32Ty(),
1350                      {B.getInt8PtrTy(), B.getInt8PtrTy()}, Args, B, TLI,
1351                      /*IsVaArgs=*/true);
1352 }
1353 
1354 Value *llvm::emitStrCat(Value *Dest, Value *Src, IRBuilderBase &B,
1355                         const TargetLibraryInfo *TLI) {
1356   return emitLibCall(LibFunc_strcat, B.getInt8PtrTy(),
1357                      {B.getInt8PtrTy(), B.getInt8PtrTy()},
1358                      {castToCStr(Dest, B), castToCStr(Src, B)}, B, TLI);
1359 }
1360 
1361 Value *llvm::emitStrLCpy(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
1362                          const TargetLibraryInfo *TLI) {
1363   return emitLibCall(LibFunc_strlcpy, Size->getType(),
1364                      {B.getInt8PtrTy(), B.getInt8PtrTy(), Size->getType()},
1365                      {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI);
1366 }
1367 
1368 Value *llvm::emitStrLCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
1369                          const TargetLibraryInfo *TLI) {
1370   return emitLibCall(LibFunc_strlcat, Size->getType(),
1371                      {B.getInt8PtrTy(), B.getInt8PtrTy(), Size->getType()},
1372                      {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI);
1373 }
1374 
1375 Value *llvm::emitStrNCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
1376                          const TargetLibraryInfo *TLI) {
1377   return emitLibCall(LibFunc_strncat, B.getInt8PtrTy(),
1378                      {B.getInt8PtrTy(), B.getInt8PtrTy(), Size->getType()},
1379                      {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI);
1380 }
1381 
1382 Value *llvm::emitVSNPrintf(Value *Dest, Value *Size, Value *Fmt, Value *VAList,
1383                            IRBuilderBase &B, const TargetLibraryInfo *TLI) {
1384   return emitLibCall(
1385       LibFunc_vsnprintf, B.getInt32Ty(),
1386       {B.getInt8PtrTy(), Size->getType(), B.getInt8PtrTy(), VAList->getType()},
1387       {castToCStr(Dest, B), Size, castToCStr(Fmt, B), VAList}, B, TLI);
1388 }
1389 
1390 Value *llvm::emitVSPrintf(Value *Dest, Value *Fmt, Value *VAList,
1391                           IRBuilderBase &B, const TargetLibraryInfo *TLI) {
1392   return emitLibCall(LibFunc_vsprintf, B.getInt32Ty(),
1393                      {B.getInt8PtrTy(), B.getInt8PtrTy(), VAList->getType()},
1394                      {castToCStr(Dest, B), castToCStr(Fmt, B), VAList}, B, TLI);
1395 }
1396 
1397 /// Append a suffix to the function name according to the type of 'Op'.
1398 static void appendTypeSuffix(Value *Op, StringRef &Name,
1399                              SmallString<20> &NameBuffer) {
1400   if (!Op->getType()->isDoubleTy()) {
1401       NameBuffer += Name;
1402 
1403     if (Op->getType()->isFloatTy())
1404       NameBuffer += 'f';
1405     else
1406       NameBuffer += 'l';
1407 
1408     Name = NameBuffer;
1409   }
1410 }
1411 
1412 static Value *emitUnaryFloatFnCallHelper(Value *Op, StringRef Name,
1413                                          IRBuilderBase &B,
1414                                          const AttributeList &Attrs) {
1415   assert((Name != "") && "Must specify Name to emitUnaryFloatFnCall");
1416 
1417   Module *M = B.GetInsertBlock()->getModule();
1418   FunctionCallee Callee =
1419       M->getOrInsertFunction(Name, Op->getType(), Op->getType());
1420   CallInst *CI = B.CreateCall(Callee, Op, Name);
1421 
1422   // The incoming attribute set may have come from a speculatable intrinsic, but
1423   // is being replaced with a library call which is not allowed to be
1424   // speculatable.
1425   CI->setAttributes(Attrs.removeAttribute(B.getContext(),
1426                                           AttributeList::FunctionIndex,
1427                                           Attribute::Speculatable));
1428   if (const Function *F =
1429           dyn_cast<Function>(Callee.getCallee()->stripPointerCasts()))
1430     CI->setCallingConv(F->getCallingConv());
1431 
1432   return CI;
1433 }
1434 
1435 Value *llvm::emitUnaryFloatFnCall(Value *Op, StringRef Name, IRBuilderBase &B,
1436                                   const AttributeList &Attrs) {
1437   SmallString<20> NameBuffer;
1438   appendTypeSuffix(Op, Name, NameBuffer);
1439 
1440   return emitUnaryFloatFnCallHelper(Op, Name, B, Attrs);
1441 }
1442 
1443 Value *llvm::emitUnaryFloatFnCall(Value *Op, const TargetLibraryInfo *TLI,
1444                                   LibFunc DoubleFn, LibFunc FloatFn,
1445                                   LibFunc LongDoubleFn, IRBuilderBase &B,
1446                                   const AttributeList &Attrs) {
1447   // Get the name of the function according to TLI.
1448   StringRef Name = getFloatFnName(TLI, Op->getType(),
1449                                   DoubleFn, FloatFn, LongDoubleFn);
1450 
1451   return emitUnaryFloatFnCallHelper(Op, Name, B, Attrs);
1452 }
1453 
1454 static Value *emitBinaryFloatFnCallHelper(Value *Op1, Value *Op2,
1455                                           StringRef Name, IRBuilderBase &B,
1456                                           const AttributeList &Attrs,
1457                                           const TargetLibraryInfo *TLI = nullptr) {
1458   assert((Name != "") && "Must specify Name to emitBinaryFloatFnCall");
1459 
1460   Module *M = B.GetInsertBlock()->getModule();
1461   FunctionCallee Callee = M->getOrInsertFunction(Name, Op1->getType(),
1462                                                  Op1->getType(), Op2->getType());
1463   if (TLI != nullptr)
1464     inferLibFuncAttributes(M, Name, *TLI);
1465   CallInst *CI = B.CreateCall(Callee, { Op1, Op2 }, Name);
1466 
1467   // The incoming attribute set may have come from a speculatable intrinsic, but
1468   // is being replaced with a library call which is not allowed to be
1469   // speculatable.
1470   CI->setAttributes(Attrs.removeAttribute(B.getContext(),
1471                                           AttributeList::FunctionIndex,
1472                                           Attribute::Speculatable));
1473   if (const Function *F =
1474           dyn_cast<Function>(Callee.getCallee()->stripPointerCasts()))
1475     CI->setCallingConv(F->getCallingConv());
1476 
1477   return CI;
1478 }
1479 
1480 Value *llvm::emitBinaryFloatFnCall(Value *Op1, Value *Op2, StringRef Name,
1481                                    IRBuilderBase &B,
1482                                    const AttributeList &Attrs) {
1483   assert((Name != "") && "Must specify Name to emitBinaryFloatFnCall");
1484 
1485   SmallString<20> NameBuffer;
1486   appendTypeSuffix(Op1, Name, NameBuffer);
1487 
1488   return emitBinaryFloatFnCallHelper(Op1, Op2, Name, B, Attrs);
1489 }
1490 
1491 Value *llvm::emitBinaryFloatFnCall(Value *Op1, Value *Op2,
1492                                    const TargetLibraryInfo *TLI,
1493                                    LibFunc DoubleFn, LibFunc FloatFn,
1494                                    LibFunc LongDoubleFn, IRBuilderBase &B,
1495                                    const AttributeList &Attrs) {
1496   // Get the name of the function according to TLI.
1497   StringRef Name = getFloatFnName(TLI, Op1->getType(),
1498                                   DoubleFn, FloatFn, LongDoubleFn);
1499 
1500   return emitBinaryFloatFnCallHelper(Op1, Op2, Name, B, Attrs, TLI);
1501 }
1502 
1503 Value *llvm::emitPutChar(Value *Char, IRBuilderBase &B,
1504                          const TargetLibraryInfo *TLI) {
1505   if (!TLI->has(LibFunc_putchar))
1506     return nullptr;
1507 
1508   Module *M = B.GetInsertBlock()->getModule();
1509   StringRef PutCharName = TLI->getName(LibFunc_putchar);
1510   FunctionCallee PutChar =
1511       M->getOrInsertFunction(PutCharName, B.getInt32Ty(), B.getInt32Ty());
1512   inferLibFuncAttributes(M, PutCharName, *TLI);
1513   CallInst *CI = B.CreateCall(PutChar,
1514                               B.CreateIntCast(Char,
1515                               B.getInt32Ty(),
1516                               /*isSigned*/true,
1517                               "chari"),
1518                               PutCharName);
1519 
1520   if (const Function *F =
1521           dyn_cast<Function>(PutChar.getCallee()->stripPointerCasts()))
1522     CI->setCallingConv(F->getCallingConv());
1523   return CI;
1524 }
1525 
1526 Value *llvm::emitPutS(Value *Str, IRBuilderBase &B,
1527                       const TargetLibraryInfo *TLI) {
1528   if (!TLI->has(LibFunc_puts))
1529     return nullptr;
1530 
1531   Module *M = B.GetInsertBlock()->getModule();
1532   StringRef PutsName = TLI->getName(LibFunc_puts);
1533   FunctionCallee PutS =
1534       M->getOrInsertFunction(PutsName, B.getInt32Ty(), B.getInt8PtrTy());
1535   inferLibFuncAttributes(M, PutsName, *TLI);
1536   CallInst *CI = B.CreateCall(PutS, castToCStr(Str, B), PutsName);
1537   if (const Function *F =
1538           dyn_cast<Function>(PutS.getCallee()->stripPointerCasts()))
1539     CI->setCallingConv(F->getCallingConv());
1540   return CI;
1541 }
1542 
1543 Value *llvm::emitFPutC(Value *Char, Value *File, IRBuilderBase &B,
1544                        const TargetLibraryInfo *TLI) {
1545   if (!TLI->has(LibFunc_fputc))
1546     return nullptr;
1547 
1548   Module *M = B.GetInsertBlock()->getModule();
1549   StringRef FPutcName = TLI->getName(LibFunc_fputc);
1550   FunctionCallee F = M->getOrInsertFunction(FPutcName, B.getInt32Ty(),
1551                                             B.getInt32Ty(), File->getType());
1552   if (File->getType()->isPointerTy())
1553     inferLibFuncAttributes(M, FPutcName, *TLI);
1554   Char = B.CreateIntCast(Char, B.getInt32Ty(), /*isSigned*/true,
1555                          "chari");
1556   CallInst *CI = B.CreateCall(F, {Char, File}, FPutcName);
1557 
1558   if (const Function *Fn =
1559           dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
1560     CI->setCallingConv(Fn->getCallingConv());
1561   return CI;
1562 }
1563 
1564 Value *llvm::emitFPutS(Value *Str, Value *File, IRBuilderBase &B,
1565                        const TargetLibraryInfo *TLI) {
1566   if (!TLI->has(LibFunc_fputs))
1567     return nullptr;
1568 
1569   Module *M = B.GetInsertBlock()->getModule();
1570   StringRef FPutsName = TLI->getName(LibFunc_fputs);
1571   FunctionCallee F = M->getOrInsertFunction(FPutsName, B.getInt32Ty(),
1572                                             B.getInt8PtrTy(), File->getType());
1573   if (File->getType()->isPointerTy())
1574     inferLibFuncAttributes(M, FPutsName, *TLI);
1575   CallInst *CI = B.CreateCall(F, {castToCStr(Str, B), File}, FPutsName);
1576 
1577   if (const Function *Fn =
1578           dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
1579     CI->setCallingConv(Fn->getCallingConv());
1580   return CI;
1581 }
1582 
1583 Value *llvm::emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilderBase &B,
1584                         const DataLayout &DL, const TargetLibraryInfo *TLI) {
1585   if (!TLI->has(LibFunc_fwrite))
1586     return nullptr;
1587 
1588   Module *M = B.GetInsertBlock()->getModule();
1589   LLVMContext &Context = B.GetInsertBlock()->getContext();
1590   StringRef FWriteName = TLI->getName(LibFunc_fwrite);
1591   FunctionCallee F = M->getOrInsertFunction(
1592       FWriteName, DL.getIntPtrType(Context), B.getInt8PtrTy(),
1593       DL.getIntPtrType(Context), DL.getIntPtrType(Context), File->getType());
1594 
1595   if (File->getType()->isPointerTy())
1596     inferLibFuncAttributes(M, FWriteName, *TLI);
1597   CallInst *CI =
1598       B.CreateCall(F, {castToCStr(Ptr, B), Size,
1599                        ConstantInt::get(DL.getIntPtrType(Context), 1), File});
1600 
1601   if (const Function *Fn =
1602           dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
1603     CI->setCallingConv(Fn->getCallingConv());
1604   return CI;
1605 }
1606 
1607 Value *llvm::emitMalloc(Value *Num, IRBuilderBase &B, const DataLayout &DL,
1608                         const TargetLibraryInfo *TLI) {
1609   if (!TLI->has(LibFunc_malloc))
1610     return nullptr;
1611 
1612   Module *M = B.GetInsertBlock()->getModule();
1613   StringRef MallocName = TLI->getName(LibFunc_malloc);
1614   LLVMContext &Context = B.GetInsertBlock()->getContext();
1615   FunctionCallee Malloc = M->getOrInsertFunction(MallocName, B.getInt8PtrTy(),
1616                                                  DL.getIntPtrType(Context));
1617   inferLibFuncAttributes(M, MallocName, *TLI);
1618   CallInst *CI = B.CreateCall(Malloc, Num, MallocName);
1619 
1620   if (const Function *F =
1621           dyn_cast<Function>(Malloc.getCallee()->stripPointerCasts()))
1622     CI->setCallingConv(F->getCallingConv());
1623 
1624   return CI;
1625 }
1626 
1627 Value *llvm::emitCalloc(Value *Num, Value *Size, const AttributeList &Attrs,
1628                         IRBuilderBase &B, const TargetLibraryInfo &TLI) {
1629   if (!TLI.has(LibFunc_calloc))
1630     return nullptr;
1631 
1632   Module *M = B.GetInsertBlock()->getModule();
1633   StringRef CallocName = TLI.getName(LibFunc_calloc);
1634   const DataLayout &DL = M->getDataLayout();
1635   IntegerType *PtrType = DL.getIntPtrType((B.GetInsertBlock()->getContext()));
1636   FunctionCallee Calloc = M->getOrInsertFunction(
1637       CallocName, Attrs, B.getInt8PtrTy(), PtrType, PtrType);
1638   inferLibFuncAttributes(M, CallocName, TLI);
1639   CallInst *CI = B.CreateCall(Calloc, {Num, Size}, CallocName);
1640 
1641   if (const auto *F =
1642           dyn_cast<Function>(Calloc.getCallee()->stripPointerCasts()))
1643     CI->setCallingConv(F->getCallingConv());
1644 
1645   return CI;
1646 }
1647