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