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