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