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