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