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