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