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