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