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(NumReadOnly, "Number of functions inferred as readonly");
35 STATISTIC(NumArgMemOnly, "Number of functions inferred as argmemonly");
36 STATISTIC(NumNoUnwind, "Number of functions inferred as nounwind");
37 STATISTIC(NumNoCapture, "Number of arguments inferred as nocapture");
38 STATISTIC(NumReadOnlyArg, "Number of arguments inferred as readonly");
39 STATISTIC(NumNoAlias, "Number of function returns inferred as noalias");
40 STATISTIC(NumNoUndef, "Number of function returns inferred as noundef returns");
41 STATISTIC(NumNonNull, "Number of function returns inferred as nonnull returns");
42 STATISTIC(NumReturnedArg, "Number of arguments inferred as returned");
43 
44 static bool setDoesNotAccessMemory(Function &F) {
45   if (F.doesNotAccessMemory())
46     return false;
47   F.setDoesNotAccessMemory();
48   ++NumReadNone;
49   return true;
50 }
51 
52 static bool setOnlyReadsMemory(Function &F) {
53   if (F.onlyReadsMemory())
54     return false;
55   F.setOnlyReadsMemory();
56   ++NumReadOnly;
57   return true;
58 }
59 
60 static bool setOnlyAccessesArgMemory(Function &F) {
61   if (F.onlyAccessesArgMemory())
62     return false;
63   F.setOnlyAccessesArgMemory();
64   ++NumArgMemOnly;
65   return true;
66 }
67 
68 static bool setDoesNotThrow(Function &F) {
69   if (F.doesNotThrow())
70     return false;
71   F.setDoesNotThrow();
72   ++NumNoUnwind;
73   return true;
74 }
75 
76 static bool setRetDoesNotAlias(Function &F) {
77   if (F.hasAttribute(AttributeList::ReturnIndex, Attribute::NoAlias))
78     return false;
79   F.addAttribute(AttributeList::ReturnIndex, Attribute::NoAlias);
80   ++NumNoAlias;
81   return true;
82 }
83 
84 static bool setDoesNotCapture(Function &F, unsigned ArgNo) {
85   if (F.hasParamAttribute(ArgNo, Attribute::NoCapture))
86     return false;
87   F.addParamAttr(ArgNo, Attribute::NoCapture);
88   ++NumNoCapture;
89   return true;
90 }
91 
92 static bool setDoesNotAlias(Function &F, unsigned ArgNo) {
93   if (F.hasParamAttribute(ArgNo, Attribute::NoAlias))
94     return false;
95   F.addParamAttr(ArgNo, Attribute::NoAlias);
96   ++NumNoAlias;
97   return true;
98 }
99 
100 static bool setOnlyReadsMemory(Function &F, unsigned ArgNo) {
101   if (F.hasParamAttribute(ArgNo, Attribute::ReadOnly))
102     return false;
103   F.addParamAttr(ArgNo, Attribute::ReadOnly);
104   ++NumReadOnlyArg;
105   return true;
106 }
107 
108 static bool setRetAndArgsNoUndef(Function &F) {
109   bool Changed = false;
110   if (!F.getReturnType()->isVoidTy() &&
111       !F.hasAttribute(AttributeList::ReturnIndex, Attribute::NoUndef)) {
112     F.addAttribute(AttributeList::ReturnIndex, Attribute::NoUndef);
113     ++NumNoUndef;
114     Changed = true;
115   }
116   for (unsigned ArgNo = 0; ArgNo < F.arg_size(); ++ArgNo) {
117     if (!F.hasParamAttribute(ArgNo, Attribute::NoUndef)) {
118       F.addParamAttr(ArgNo, Attribute::NoUndef);
119       ++NumNoUndef;
120       Changed = true;
121     }
122   }
123   return Changed;
124 }
125 
126 static bool setRetNonNull(Function &F) {
127   assert(F.getReturnType()->isPointerTy() &&
128          "nonnull applies only to pointers");
129   if (F.hasAttribute(AttributeList::ReturnIndex, Attribute::NonNull))
130     return false;
131   F.addAttribute(AttributeList::ReturnIndex, Attribute::NonNull);
132   ++NumNonNull;
133   return true;
134 }
135 
136 static bool setReturnedArg(Function &F, unsigned ArgNo) {
137   if (F.hasParamAttribute(ArgNo, Attribute::Returned))
138     return false;
139   F.addParamAttr(ArgNo, Attribute::Returned);
140   ++NumReturnedArg;
141   return true;
142 }
143 
144 static bool setNonLazyBind(Function &F) {
145   if (F.hasFnAttribute(Attribute::NonLazyBind))
146     return false;
147   F.addFnAttr(Attribute::NonLazyBind);
148   return true;
149 }
150 
151 static bool setDoesNotFreeMemory(Function &F) {
152   if (F.hasFnAttribute(Attribute::NoFree))
153     return false;
154   F.addFnAttr(Attribute::NoFree);
155   return true;
156 }
157 
158 bool llvm::inferLibFuncAttributes(Module *M, StringRef Name,
159                                   const TargetLibraryInfo &TLI) {
160   Function *F = M->getFunction(Name);
161   if (!F)
162     return false;
163   return inferLibFuncAttributes(*F, TLI);
164 }
165 
166 bool llvm::inferLibFuncAttributes(Function &F, const TargetLibraryInfo &TLI) {
167   LibFunc TheLibFunc;
168   if (!(TLI.getLibFunc(F, TheLibFunc) && TLI.has(TheLibFunc)))
169     return false;
170 
171   bool Changed = false;
172 
173   if(!isLibFreeFunction(&F, TheLibFunc) && !isReallocLikeFn(&F,  &TLI))
174     Changed |= setDoesNotFreeMemory(F);
175 
176   if (F.getParent() != nullptr && F.getParent()->getRtLibUseGOT())
177     Changed |= setNonLazyBind(F);
178 
179   switch (TheLibFunc) {
180   case LibFunc_strlen:
181   case LibFunc_wcslen:
182     Changed |= setOnlyReadsMemory(F);
183     Changed |= setDoesNotThrow(F);
184     Changed |= setOnlyAccessesArgMemory(F);
185     Changed |= setDoesNotCapture(F, 0);
186     return Changed;
187   case LibFunc_strchr:
188   case LibFunc_strrchr:
189     Changed |= setOnlyAccessesArgMemory(F);
190     Changed |= setOnlyReadsMemory(F);
191     Changed |= setDoesNotThrow(F);
192     return Changed;
193   case LibFunc_strtol:
194   case LibFunc_strtod:
195   case LibFunc_strtof:
196   case LibFunc_strtoul:
197   case LibFunc_strtoll:
198   case LibFunc_strtold:
199   case LibFunc_strtoull:
200     Changed |= setDoesNotThrow(F);
201     Changed |= setDoesNotCapture(F, 1);
202     Changed |= setOnlyReadsMemory(F, 0);
203     return Changed;
204   case LibFunc_strcpy:
205   case LibFunc_strncpy:
206     Changed |= setDoesNotAlias(F, 0);
207     Changed |= setDoesNotAlias(F, 1);
208     LLVM_FALLTHROUGH;
209   case LibFunc_strcat:
210   case LibFunc_strncat:
211     Changed |= setReturnedArg(F, 0);
212     LLVM_FALLTHROUGH;
213   case LibFunc_stpcpy:
214   case LibFunc_stpncpy:
215     Changed |= setDoesNotThrow(F);
216     Changed |= setDoesNotCapture(F, 1);
217     Changed |= setOnlyReadsMemory(F, 1);
218     return Changed;
219   case LibFunc_strxfrm:
220     Changed |= setDoesNotThrow(F);
221     Changed |= setDoesNotCapture(F, 0);
222     Changed |= setDoesNotCapture(F, 1);
223     Changed |= setOnlyReadsMemory(F, 1);
224     return Changed;
225   case LibFunc_strcmp:      // 0,1
226   case LibFunc_strspn:      // 0,1
227   case LibFunc_strncmp:     // 0,1
228   case LibFunc_strcspn:     // 0,1
229     Changed |= setDoesNotThrow(F);
230     Changed |= setOnlyAccessesArgMemory(F);
231     Changed |= setOnlyReadsMemory(F);
232     Changed |= setDoesNotCapture(F, 0);
233     Changed |= setDoesNotCapture(F, 1);
234     return Changed;
235   case LibFunc_strcoll:
236   case LibFunc_strcasecmp:  // 0,1
237   case LibFunc_strncasecmp: //
238     // Those functions may depend on the locale, which may be accessed through
239     // global memory.
240     Changed |= setOnlyReadsMemory(F);
241     Changed |= setDoesNotThrow(F);
242     Changed |= setDoesNotCapture(F, 0);
243     Changed |= setDoesNotCapture(F, 1);
244     return Changed;
245   case LibFunc_strstr:
246   case LibFunc_strpbrk:
247     Changed |= setOnlyReadsMemory(F);
248     Changed |= setDoesNotThrow(F);
249     Changed |= setDoesNotCapture(F, 1);
250     return Changed;
251   case LibFunc_strtok:
252   case LibFunc_strtok_r:
253     Changed |= setDoesNotThrow(F);
254     Changed |= setDoesNotCapture(F, 1);
255     Changed |= setOnlyReadsMemory(F, 1);
256     return Changed;
257   case LibFunc_scanf:
258     Changed |= setRetAndArgsNoUndef(F);
259     Changed |= setDoesNotThrow(F);
260     Changed |= setDoesNotCapture(F, 0);
261     Changed |= setOnlyReadsMemory(F, 0);
262     return Changed;
263   case LibFunc_setbuf:
264   case LibFunc_setvbuf:
265     Changed |= setRetAndArgsNoUndef(F);
266     Changed |= setDoesNotThrow(F);
267     Changed |= setDoesNotCapture(F, 0);
268     return Changed;
269   case LibFunc_strdup:
270   case LibFunc_strndup:
271     Changed |= setDoesNotThrow(F);
272     Changed |= setRetDoesNotAlias(F);
273     Changed |= setDoesNotCapture(F, 0);
274     Changed |= setOnlyReadsMemory(F, 0);
275     return Changed;
276   case LibFunc_stat:
277   case LibFunc_statvfs:
278     Changed |= setRetAndArgsNoUndef(F);
279     Changed |= setDoesNotThrow(F);
280     Changed |= setDoesNotCapture(F, 0);
281     Changed |= setDoesNotCapture(F, 1);
282     Changed |= setOnlyReadsMemory(F, 0);
283     return Changed;
284   case LibFunc_sscanf:
285     Changed |= setRetAndArgsNoUndef(F);
286     Changed |= setDoesNotThrow(F);
287     Changed |= setDoesNotCapture(F, 0);
288     Changed |= setDoesNotCapture(F, 1);
289     Changed |= setOnlyReadsMemory(F, 0);
290     Changed |= setOnlyReadsMemory(F, 1);
291     return Changed;
292   case LibFunc_sprintf:
293     Changed |= setRetAndArgsNoUndef(F);
294     Changed |= setDoesNotThrow(F);
295     Changed |= setDoesNotCapture(F, 0);
296     Changed |= setDoesNotAlias(F, 0);
297     Changed |= setDoesNotCapture(F, 1);
298     Changed |= setOnlyReadsMemory(F, 1);
299     return Changed;
300   case LibFunc_snprintf:
301     Changed |= setRetAndArgsNoUndef(F);
302     Changed |= setDoesNotThrow(F);
303     Changed |= setDoesNotCapture(F, 0);
304     Changed |= setDoesNotAlias(F, 0);
305     Changed |= setDoesNotCapture(F, 2);
306     Changed |= setOnlyReadsMemory(F, 2);
307     return Changed;
308   case LibFunc_setitimer:
309     Changed |= setRetAndArgsNoUndef(F);
310     Changed |= setDoesNotThrow(F);
311     Changed |= setDoesNotCapture(F, 1);
312     Changed |= setDoesNotCapture(F, 2);
313     Changed |= setOnlyReadsMemory(F, 1);
314     return Changed;
315   case LibFunc_system:
316     // May throw; "system" is a valid pthread cancellation point.
317     Changed |= setRetAndArgsNoUndef(F);
318     Changed |= setDoesNotCapture(F, 0);
319     Changed |= setOnlyReadsMemory(F, 0);
320     return Changed;
321   case LibFunc_malloc:
322     Changed |= setDoesNotThrow(F);
323     Changed |= setRetDoesNotAlias(F);
324     return Changed;
325   case LibFunc_memcmp:
326     Changed |= setOnlyAccessesArgMemory(F);
327     Changed |= setOnlyReadsMemory(F);
328     Changed |= setDoesNotThrow(F);
329     Changed |= setDoesNotCapture(F, 0);
330     Changed |= setDoesNotCapture(F, 1);
331     return Changed;
332   case LibFunc_memchr:
333   case LibFunc_memrchr:
334     Changed |= setDoesNotThrow(F);
335     Changed |= setOnlyAccessesArgMemory(F);
336     Changed |= setOnlyReadsMemory(F);
337     return Changed;
338   case LibFunc_modf:
339   case LibFunc_modff:
340   case LibFunc_modfl:
341     Changed |= setDoesNotThrow(F);
342     Changed |= setDoesNotCapture(F, 1);
343     return Changed;
344   case LibFunc_memcpy:
345     Changed |= setDoesNotThrow(F);
346     Changed |= setOnlyAccessesArgMemory(F);
347     Changed |= setDoesNotAlias(F, 0);
348     Changed |= setReturnedArg(F, 0);
349     Changed |= setDoesNotAlias(F, 1);
350     Changed |= setDoesNotCapture(F, 1);
351     Changed |= setOnlyReadsMemory(F, 1);
352     return Changed;
353   case LibFunc_memmove:
354     Changed |= setDoesNotThrow(F);
355     Changed |= setOnlyAccessesArgMemory(F);
356     Changed |= setReturnedArg(F, 0);
357     Changed |= setDoesNotCapture(F, 1);
358     Changed |= setOnlyReadsMemory(F, 1);
359     return Changed;
360   case LibFunc_mempcpy:
361   case LibFunc_memccpy:
362     Changed |= setDoesNotThrow(F);
363     Changed |= setOnlyAccessesArgMemory(F);
364     Changed |= setDoesNotAlias(F, 0);
365     Changed |= setDoesNotAlias(F, 1);
366     Changed |= setDoesNotCapture(F, 1);
367     Changed |= setOnlyReadsMemory(F, 1);
368     return Changed;
369   case LibFunc_memcpy_chk:
370     Changed |= setDoesNotThrow(F);
371     return Changed;
372   case LibFunc_memalign:
373     Changed |= setRetDoesNotAlias(F);
374     return Changed;
375   case LibFunc_mkdir:
376     Changed |= setRetAndArgsNoUndef(F);
377     Changed |= setDoesNotThrow(F);
378     Changed |= setDoesNotCapture(F, 0);
379     Changed |= setOnlyReadsMemory(F, 0);
380     return Changed;
381   case LibFunc_mktime:
382     Changed |= setRetAndArgsNoUndef(F);
383     Changed |= setDoesNotThrow(F);
384     Changed |= setDoesNotCapture(F, 0);
385     return Changed;
386   case LibFunc_realloc:
387     Changed |= setDoesNotThrow(F);
388     Changed |= setRetDoesNotAlias(F);
389     Changed |= setDoesNotCapture(F, 0);
390     return Changed;
391   case LibFunc_read:
392     // May throw; "read" is a valid pthread cancellation point.
393     Changed |= setRetAndArgsNoUndef(F);
394     Changed |= setDoesNotCapture(F, 1);
395     return Changed;
396   case LibFunc_rewind:
397     Changed |= setRetAndArgsNoUndef(F);
398     Changed |= setDoesNotThrow(F);
399     Changed |= setDoesNotCapture(F, 0);
400     return Changed;
401   case LibFunc_rmdir:
402   case LibFunc_remove:
403   case LibFunc_realpath:
404     Changed |= setRetAndArgsNoUndef(F);
405     Changed |= setDoesNotThrow(F);
406     Changed |= setDoesNotCapture(F, 0);
407     Changed |= setOnlyReadsMemory(F, 0);
408     return Changed;
409   case LibFunc_rename:
410     Changed |= setRetAndArgsNoUndef(F);
411     Changed |= setDoesNotThrow(F);
412     Changed |= setDoesNotCapture(F, 0);
413     Changed |= setDoesNotCapture(F, 1);
414     Changed |= setOnlyReadsMemory(F, 0);
415     Changed |= setOnlyReadsMemory(F, 1);
416     return Changed;
417   case LibFunc_readlink:
418     Changed |= setRetAndArgsNoUndef(F);
419     Changed |= setDoesNotThrow(F);
420     Changed |= setDoesNotCapture(F, 0);
421     Changed |= setDoesNotCapture(F, 1);
422     Changed |= setOnlyReadsMemory(F, 0);
423     return Changed;
424   case LibFunc_write:
425     // May throw; "write" is a valid pthread cancellation point.
426     Changed |= setRetAndArgsNoUndef(F);
427     Changed |= setDoesNotCapture(F, 1);
428     Changed |= setOnlyReadsMemory(F, 1);
429     return Changed;
430   case LibFunc_aligned_alloc:
431     Changed |= setDoesNotThrow(F);
432     Changed |= setRetDoesNotAlias(F);
433     return Changed;
434   case LibFunc_bcopy:
435     Changed |= setDoesNotThrow(F);
436     Changed |= setDoesNotCapture(F, 0);
437     Changed |= setDoesNotCapture(F, 1);
438     Changed |= setOnlyReadsMemory(F, 0);
439     return Changed;
440   case LibFunc_bcmp:
441     Changed |= setDoesNotThrow(F);
442     Changed |= setOnlyAccessesArgMemory(F);
443     Changed |= setOnlyReadsMemory(F);
444     Changed |= setDoesNotCapture(F, 0);
445     Changed |= setDoesNotCapture(F, 1);
446     return Changed;
447   case LibFunc_bzero:
448     Changed |= setDoesNotThrow(F);
449     Changed |= setDoesNotCapture(F, 0);
450     return Changed;
451   case LibFunc_calloc:
452     Changed |= setDoesNotThrow(F);
453     Changed |= setRetDoesNotAlias(F);
454     return Changed;
455   case LibFunc_chmod:
456   case LibFunc_chown:
457     Changed |= setRetAndArgsNoUndef(F);
458     Changed |= setDoesNotThrow(F);
459     Changed |= setDoesNotCapture(F, 0);
460     Changed |= setOnlyReadsMemory(F, 0);
461     return Changed;
462   case LibFunc_ctermid:
463   case LibFunc_clearerr:
464   case LibFunc_closedir:
465     Changed |= setRetAndArgsNoUndef(F);
466     Changed |= setDoesNotThrow(F);
467     Changed |= setDoesNotCapture(F, 0);
468     return Changed;
469   case LibFunc_atoi:
470   case LibFunc_atol:
471   case LibFunc_atof:
472   case LibFunc_atoll:
473     Changed |= setDoesNotThrow(F);
474     Changed |= setOnlyReadsMemory(F);
475     Changed |= setDoesNotCapture(F, 0);
476     return Changed;
477   case LibFunc_access:
478     Changed |= setRetAndArgsNoUndef(F);
479     Changed |= setDoesNotThrow(F);
480     Changed |= setDoesNotCapture(F, 0);
481     Changed |= setOnlyReadsMemory(F, 0);
482     return Changed;
483   case LibFunc_fopen:
484     Changed |= setRetAndArgsNoUndef(F);
485     Changed |= setDoesNotThrow(F);
486     Changed |= setRetDoesNotAlias(F);
487     Changed |= setDoesNotCapture(F, 0);
488     Changed |= setDoesNotCapture(F, 1);
489     Changed |= setOnlyReadsMemory(F, 0);
490     Changed |= setOnlyReadsMemory(F, 1);
491     return Changed;
492   case LibFunc_fdopen:
493     Changed |= setRetAndArgsNoUndef(F);
494     Changed |= setDoesNotThrow(F);
495     Changed |= setRetDoesNotAlias(F);
496     Changed |= setDoesNotCapture(F, 1);
497     Changed |= setOnlyReadsMemory(F, 1);
498     return Changed;
499   case LibFunc_feof:
500     Changed |= setRetAndArgsNoUndef(F);
501     Changed |= setDoesNotThrow(F);
502     Changed |= setDoesNotCapture(F, 0);
503     return Changed;
504   case LibFunc_free:
505     Changed |= setDoesNotThrow(F);
506     Changed |= setDoesNotCapture(F, 0);
507     return Changed;
508   case LibFunc_fseek:
509   case LibFunc_ftell:
510   case LibFunc_fgetc:
511   case LibFunc_fgetc_unlocked:
512   case LibFunc_fseeko:
513   case LibFunc_ftello:
514   case LibFunc_fileno:
515   case LibFunc_fflush:
516   case LibFunc_fclose:
517   case LibFunc_fsetpos:
518   case LibFunc_flockfile:
519   case LibFunc_funlockfile:
520   case LibFunc_ftrylockfile:
521     Changed |= setRetAndArgsNoUndef(F);
522     Changed |= setDoesNotThrow(F);
523     Changed |= setDoesNotCapture(F, 0);
524     return Changed;
525   case LibFunc_ferror:
526     Changed |= setRetAndArgsNoUndef(F);
527     Changed |= setDoesNotThrow(F);
528     Changed |= setDoesNotCapture(F, 0);
529     Changed |= setOnlyReadsMemory(F);
530     return Changed;
531   case LibFunc_fputc:
532   case LibFunc_fputc_unlocked:
533   case LibFunc_fstat:
534     Changed |= setRetAndArgsNoUndef(F);
535     Changed |= setDoesNotThrow(F);
536     Changed |= setDoesNotCapture(F, 1);
537     return Changed;
538   case LibFunc_frexp:
539   case LibFunc_frexpf:
540   case LibFunc_frexpl:
541     Changed |= setDoesNotThrow(F);
542     Changed |= setDoesNotCapture(F, 1);
543     return Changed;
544   case LibFunc_fstatvfs:
545     Changed |= setRetAndArgsNoUndef(F);
546     Changed |= setDoesNotThrow(F);
547     Changed |= setDoesNotCapture(F, 1);
548     return Changed;
549   case LibFunc_fgets:
550   case LibFunc_fgets_unlocked:
551     Changed |= setRetAndArgsNoUndef(F);
552     Changed |= setDoesNotThrow(F);
553     Changed |= setDoesNotCapture(F, 2);
554     return Changed;
555   case LibFunc_fread:
556   case LibFunc_fread_unlocked:
557     Changed |= setRetAndArgsNoUndef(F);
558     Changed |= setDoesNotThrow(F);
559     Changed |= setDoesNotCapture(F, 0);
560     Changed |= setDoesNotCapture(F, 3);
561     return Changed;
562   case LibFunc_fwrite:
563   case LibFunc_fwrite_unlocked:
564     Changed |= setRetAndArgsNoUndef(F);
565     Changed |= setDoesNotThrow(F);
566     Changed |= setDoesNotCapture(F, 0);
567     Changed |= setDoesNotCapture(F, 3);
568     // FIXME: readonly #1?
569     return Changed;
570   case LibFunc_fputs:
571   case LibFunc_fputs_unlocked:
572     Changed |= setRetAndArgsNoUndef(F);
573     Changed |= setDoesNotThrow(F);
574     Changed |= setDoesNotCapture(F, 0);
575     Changed |= setDoesNotCapture(F, 1);
576     Changed |= setOnlyReadsMemory(F, 0);
577     return Changed;
578   case LibFunc_fscanf:
579   case LibFunc_fprintf:
580     Changed |= setRetAndArgsNoUndef(F);
581     Changed |= setDoesNotThrow(F);
582     Changed |= setDoesNotCapture(F, 0);
583     Changed |= setDoesNotCapture(F, 1);
584     Changed |= setOnlyReadsMemory(F, 1);
585     return Changed;
586   case LibFunc_fgetpos:
587     Changed |= setRetAndArgsNoUndef(F);
588     Changed |= setDoesNotThrow(F);
589     Changed |= setDoesNotCapture(F, 0);
590     Changed |= setDoesNotCapture(F, 1);
591     return Changed;
592   case LibFunc_getc:
593     Changed |= setRetAndArgsNoUndef(F);
594     Changed |= setDoesNotThrow(F);
595     Changed |= setDoesNotCapture(F, 0);
596     return Changed;
597   case LibFunc_getlogin_r:
598     Changed |= setRetAndArgsNoUndef(F);
599     Changed |= setDoesNotThrow(F);
600     Changed |= setDoesNotCapture(F, 0);
601     return Changed;
602   case LibFunc_getc_unlocked:
603     Changed |= setRetAndArgsNoUndef(F);
604     Changed |= setDoesNotThrow(F);
605     Changed |= setDoesNotCapture(F, 0);
606     return Changed;
607   case LibFunc_getenv:
608     Changed |= setRetAndArgsNoUndef(F);
609     Changed |= setDoesNotThrow(F);
610     Changed |= setOnlyReadsMemory(F);
611     Changed |= setDoesNotCapture(F, 0);
612     return Changed;
613   case LibFunc_gets:
614   case LibFunc_getchar:
615   case LibFunc_getchar_unlocked:
616     Changed |= setRetAndArgsNoUndef(F);
617     Changed |= setDoesNotThrow(F);
618     return Changed;
619   case LibFunc_getitimer:
620     Changed |= setRetAndArgsNoUndef(F);
621     Changed |= setDoesNotThrow(F);
622     Changed |= setDoesNotCapture(F, 1);
623     return Changed;
624   case LibFunc_getpwnam:
625     Changed |= setRetAndArgsNoUndef(F);
626     Changed |= setDoesNotThrow(F);
627     Changed |= setDoesNotCapture(F, 0);
628     Changed |= setOnlyReadsMemory(F, 0);
629     return Changed;
630   case LibFunc_ungetc:
631     Changed |= setRetAndArgsNoUndef(F);
632     Changed |= setDoesNotThrow(F);
633     Changed |= setDoesNotCapture(F, 1);
634     return Changed;
635   case LibFunc_uname:
636     Changed |= setRetAndArgsNoUndef(F);
637     Changed |= setDoesNotThrow(F);
638     Changed |= setDoesNotCapture(F, 0);
639     return Changed;
640   case LibFunc_unlink:
641     Changed |= setRetAndArgsNoUndef(F);
642     Changed |= setDoesNotThrow(F);
643     Changed |= setDoesNotCapture(F, 0);
644     Changed |= setOnlyReadsMemory(F, 0);
645     return Changed;
646   case LibFunc_unsetenv:
647     Changed |= setRetAndArgsNoUndef(F);
648     Changed |= setDoesNotThrow(F);
649     Changed |= setDoesNotCapture(F, 0);
650     Changed |= setOnlyReadsMemory(F, 0);
651     return Changed;
652   case LibFunc_utime:
653   case LibFunc_utimes:
654     Changed |= setRetAndArgsNoUndef(F);
655     Changed |= setDoesNotThrow(F);
656     Changed |= setDoesNotCapture(F, 0);
657     Changed |= setDoesNotCapture(F, 1);
658     Changed |= setOnlyReadsMemory(F, 0);
659     Changed |= setOnlyReadsMemory(F, 1);
660     return Changed;
661   case LibFunc_putc:
662   case LibFunc_putc_unlocked:
663     Changed |= setRetAndArgsNoUndef(F);
664     Changed |= setDoesNotThrow(F);
665     Changed |= setDoesNotCapture(F, 1);
666     return Changed;
667   case LibFunc_puts:
668   case LibFunc_printf:
669   case LibFunc_perror:
670     Changed |= setRetAndArgsNoUndef(F);
671     Changed |= setDoesNotThrow(F);
672     Changed |= setDoesNotCapture(F, 0);
673     Changed |= setOnlyReadsMemory(F, 0);
674     return Changed;
675   case LibFunc_pread:
676     // May throw; "pread" is a valid pthread cancellation point.
677     Changed |= setRetAndArgsNoUndef(F);
678     Changed |= setDoesNotCapture(F, 1);
679     return Changed;
680   case LibFunc_pwrite:
681     // May throw; "pwrite" is a valid pthread cancellation point.
682     Changed |= setRetAndArgsNoUndef(F);
683     Changed |= setDoesNotCapture(F, 1);
684     Changed |= setOnlyReadsMemory(F, 1);
685     return Changed;
686   case LibFunc_putchar:
687   case LibFunc_putchar_unlocked:
688     Changed |= setRetAndArgsNoUndef(F);
689     Changed |= setDoesNotThrow(F);
690     return Changed;
691   case LibFunc_popen:
692     Changed |= setRetAndArgsNoUndef(F);
693     Changed |= setDoesNotThrow(F);
694     Changed |= setRetDoesNotAlias(F);
695     Changed |= setDoesNotCapture(F, 0);
696     Changed |= setDoesNotCapture(F, 1);
697     Changed |= setOnlyReadsMemory(F, 0);
698     Changed |= setOnlyReadsMemory(F, 1);
699     return Changed;
700   case LibFunc_pclose:
701     Changed |= setRetAndArgsNoUndef(F);
702     Changed |= setDoesNotThrow(F);
703     Changed |= setDoesNotCapture(F, 0);
704     return Changed;
705   case LibFunc_vscanf:
706     Changed |= setRetAndArgsNoUndef(F);
707     Changed |= setDoesNotThrow(F);
708     Changed |= setDoesNotCapture(F, 0);
709     Changed |= setOnlyReadsMemory(F, 0);
710     return Changed;
711   case LibFunc_vsscanf:
712     Changed |= setRetAndArgsNoUndef(F);
713     Changed |= setDoesNotThrow(F);
714     Changed |= setDoesNotCapture(F, 0);
715     Changed |= setDoesNotCapture(F, 1);
716     Changed |= setOnlyReadsMemory(F, 0);
717     Changed |= setOnlyReadsMemory(F, 1);
718     return Changed;
719   case LibFunc_vfscanf:
720     Changed |= setRetAndArgsNoUndef(F);
721     Changed |= setDoesNotThrow(F);
722     Changed |= setDoesNotCapture(F, 0);
723     Changed |= setDoesNotCapture(F, 1);
724     Changed |= setOnlyReadsMemory(F, 1);
725     return Changed;
726   case LibFunc_valloc:
727     Changed |= setDoesNotThrow(F);
728     Changed |= setRetDoesNotAlias(F);
729     return Changed;
730   case LibFunc_vprintf:
731     Changed |= setRetAndArgsNoUndef(F);
732     Changed |= setDoesNotThrow(F);
733     Changed |= setDoesNotCapture(F, 0);
734     Changed |= setOnlyReadsMemory(F, 0);
735     return Changed;
736   case LibFunc_vfprintf:
737   case LibFunc_vsprintf:
738     Changed |= setRetAndArgsNoUndef(F);
739     Changed |= setDoesNotThrow(F);
740     Changed |= setDoesNotCapture(F, 0);
741     Changed |= setDoesNotCapture(F, 1);
742     Changed |= setOnlyReadsMemory(F, 1);
743     return Changed;
744   case LibFunc_vsnprintf:
745     Changed |= setRetAndArgsNoUndef(F);
746     Changed |= setDoesNotThrow(F);
747     Changed |= setDoesNotCapture(F, 0);
748     Changed |= setDoesNotCapture(F, 2);
749     Changed |= setOnlyReadsMemory(F, 2);
750     return Changed;
751   case LibFunc_open:
752     // May throw; "open" is a valid pthread cancellation point.
753     Changed |= setRetAndArgsNoUndef(F);
754     Changed |= setDoesNotCapture(F, 0);
755     Changed |= setOnlyReadsMemory(F, 0);
756     return Changed;
757   case LibFunc_opendir:
758     Changed |= setRetAndArgsNoUndef(F);
759     Changed |= setDoesNotThrow(F);
760     Changed |= setRetDoesNotAlias(F);
761     Changed |= setDoesNotCapture(F, 0);
762     Changed |= setOnlyReadsMemory(F, 0);
763     return Changed;
764   case LibFunc_tmpfile:
765     Changed |= setRetAndArgsNoUndef(F);
766     Changed |= setDoesNotThrow(F);
767     Changed |= setRetDoesNotAlias(F);
768     return Changed;
769   case LibFunc_times:
770     Changed |= setRetAndArgsNoUndef(F);
771     Changed |= setDoesNotThrow(F);
772     Changed |= setDoesNotCapture(F, 0);
773     return Changed;
774   case LibFunc_htonl:
775   case LibFunc_htons:
776   case LibFunc_ntohl:
777   case LibFunc_ntohs:
778     Changed |= setDoesNotThrow(F);
779     Changed |= setDoesNotAccessMemory(F);
780     return Changed;
781   case LibFunc_lstat:
782     Changed |= setRetAndArgsNoUndef(F);
783     Changed |= setDoesNotThrow(F);
784     Changed |= setDoesNotCapture(F, 0);
785     Changed |= setDoesNotCapture(F, 1);
786     Changed |= setOnlyReadsMemory(F, 0);
787     return Changed;
788   case LibFunc_lchown:
789     Changed |= setRetAndArgsNoUndef(F);
790     Changed |= setDoesNotThrow(F);
791     Changed |= setDoesNotCapture(F, 0);
792     Changed |= setOnlyReadsMemory(F, 0);
793     return Changed;
794   case LibFunc_qsort:
795     // May throw; places call through function pointer.
796     // Cannot give undef pointer/size
797     Changed |= setRetAndArgsNoUndef(F);
798     Changed |= setDoesNotCapture(F, 3);
799     return Changed;
800   case LibFunc_dunder_strdup:
801   case LibFunc_dunder_strndup:
802     Changed |= setDoesNotThrow(F);
803     Changed |= setRetDoesNotAlias(F);
804     Changed |= setDoesNotCapture(F, 0);
805     Changed |= setOnlyReadsMemory(F, 0);
806     return Changed;
807   case LibFunc_dunder_strtok_r:
808     Changed |= setDoesNotThrow(F);
809     Changed |= setDoesNotCapture(F, 1);
810     Changed |= setOnlyReadsMemory(F, 1);
811     return Changed;
812   case LibFunc_under_IO_getc:
813     Changed |= setRetAndArgsNoUndef(F);
814     Changed |= setDoesNotThrow(F);
815     Changed |= setDoesNotCapture(F, 0);
816     return Changed;
817   case LibFunc_under_IO_putc:
818     Changed |= setRetAndArgsNoUndef(F);
819     Changed |= setDoesNotThrow(F);
820     Changed |= setDoesNotCapture(F, 1);
821     return Changed;
822   case LibFunc_dunder_isoc99_scanf:
823     Changed |= setRetAndArgsNoUndef(F);
824     Changed |= setDoesNotThrow(F);
825     Changed |= setDoesNotCapture(F, 0);
826     Changed |= setOnlyReadsMemory(F, 0);
827     return Changed;
828   case LibFunc_stat64:
829   case LibFunc_lstat64:
830   case LibFunc_statvfs64:
831     Changed |= setRetAndArgsNoUndef(F);
832     Changed |= setDoesNotThrow(F);
833     Changed |= setDoesNotCapture(F, 0);
834     Changed |= setDoesNotCapture(F, 1);
835     Changed |= setOnlyReadsMemory(F, 0);
836     return Changed;
837   case LibFunc_dunder_isoc99_sscanf:
838     Changed |= setRetAndArgsNoUndef(F);
839     Changed |= setDoesNotThrow(F);
840     Changed |= setDoesNotCapture(F, 0);
841     Changed |= setDoesNotCapture(F, 1);
842     Changed |= setOnlyReadsMemory(F, 0);
843     Changed |= setOnlyReadsMemory(F, 1);
844     return Changed;
845   case LibFunc_fopen64:
846     Changed |= setRetAndArgsNoUndef(F);
847     Changed |= setDoesNotThrow(F);
848     Changed |= setRetDoesNotAlias(F);
849     Changed |= setDoesNotCapture(F, 0);
850     Changed |= setDoesNotCapture(F, 1);
851     Changed |= setOnlyReadsMemory(F, 0);
852     Changed |= setOnlyReadsMemory(F, 1);
853     return Changed;
854   case LibFunc_fseeko64:
855   case LibFunc_ftello64:
856     Changed |= setRetAndArgsNoUndef(F);
857     Changed |= setDoesNotThrow(F);
858     Changed |= setDoesNotCapture(F, 0);
859     return Changed;
860   case LibFunc_tmpfile64:
861     Changed |= setRetAndArgsNoUndef(F);
862     Changed |= setDoesNotThrow(F);
863     Changed |= setRetDoesNotAlias(F);
864     return Changed;
865   case LibFunc_fstat64:
866   case LibFunc_fstatvfs64:
867     Changed |= setRetAndArgsNoUndef(F);
868     Changed |= setDoesNotThrow(F);
869     Changed |= setDoesNotCapture(F, 1);
870     return Changed;
871   case LibFunc_open64:
872     // May throw; "open" is a valid pthread cancellation point.
873     Changed |= setRetAndArgsNoUndef(F);
874     Changed |= setDoesNotCapture(F, 0);
875     Changed |= setOnlyReadsMemory(F, 0);
876     return Changed;
877   case LibFunc_gettimeofday:
878     // Currently some platforms have the restrict keyword on the arguments to
879     // gettimeofday. To be conservative, do not add noalias to gettimeofday's
880     // arguments.
881     Changed |= setRetAndArgsNoUndef(F);
882     Changed |= setDoesNotThrow(F);
883     Changed |= setDoesNotCapture(F, 0);
884     Changed |= setDoesNotCapture(F, 1);
885     return Changed;
886   case LibFunc_Znwj: // new(unsigned int)
887   case LibFunc_Znwm: // new(unsigned long)
888   case LibFunc_Znaj: // new[](unsigned int)
889   case LibFunc_Znam: // new[](unsigned long)
890   case LibFunc_msvc_new_int: // new(unsigned int)
891   case LibFunc_msvc_new_longlong: // new(unsigned long long)
892   case LibFunc_msvc_new_array_int: // new[](unsigned int)
893   case LibFunc_msvc_new_array_longlong: // new[](unsigned long long)
894     // Operator new always returns a nonnull noalias pointer
895     Changed |= setRetNonNull(F);
896     Changed |= setRetDoesNotAlias(F);
897     return Changed;
898   // TODO: add LibFunc entries for:
899   // case LibFunc_memset_pattern4:
900   // case LibFunc_memset_pattern8:
901   case LibFunc_memset_pattern16:
902     Changed |= setOnlyAccessesArgMemory(F);
903     Changed |= setDoesNotCapture(F, 0);
904     Changed |= setDoesNotCapture(F, 1);
905     Changed |= setOnlyReadsMemory(F, 1);
906     return Changed;
907   // int __nvvm_reflect(const char *)
908   case LibFunc_nvvm_reflect:
909     Changed |= setRetAndArgsNoUndef(F);
910     Changed |= setDoesNotAccessMemory(F);
911     Changed |= setDoesNotThrow(F);
912     return Changed;
913 
914   default:
915     // FIXME: It'd be really nice to cover all the library functions we're
916     // aware of here.
917     return false;
918   }
919 }
920 
921 bool llvm::hasFloatFn(const TargetLibraryInfo *TLI, Type *Ty,
922                       LibFunc DoubleFn, LibFunc FloatFn, LibFunc LongDoubleFn) {
923   switch (Ty->getTypeID()) {
924   case Type::HalfTyID:
925     return false;
926   case Type::FloatTyID:
927     return TLI->has(FloatFn);
928   case Type::DoubleTyID:
929     return TLI->has(DoubleFn);
930   default:
931     return TLI->has(LongDoubleFn);
932   }
933 }
934 
935 StringRef llvm::getFloatFnName(const TargetLibraryInfo *TLI, Type *Ty,
936                                LibFunc DoubleFn, LibFunc FloatFn,
937                                LibFunc LongDoubleFn) {
938   assert(hasFloatFn(TLI, Ty, DoubleFn, FloatFn, LongDoubleFn) &&
939          "Cannot get name for unavailable function!");
940 
941   switch (Ty->getTypeID()) {
942   case Type::HalfTyID:
943     llvm_unreachable("No name for HalfTy!");
944   case Type::FloatTyID:
945     return TLI->getName(FloatFn);
946   case Type::DoubleTyID:
947     return TLI->getName(DoubleFn);
948   default:
949     return TLI->getName(LongDoubleFn);
950   }
951 }
952 
953 //- Emit LibCalls ------------------------------------------------------------//
954 
955 Value *llvm::castToCStr(Value *V, IRBuilderBase &B) {
956   unsigned AS = V->getType()->getPointerAddressSpace();
957   return B.CreateBitCast(V, B.getInt8PtrTy(AS), "cstr");
958 }
959 
960 static Value *emitLibCall(LibFunc TheLibFunc, Type *ReturnType,
961                           ArrayRef<Type *> ParamTypes,
962                           ArrayRef<Value *> Operands, IRBuilderBase &B,
963                           const TargetLibraryInfo *TLI,
964                           bool IsVaArgs = false) {
965   if (!TLI->has(TheLibFunc))
966     return nullptr;
967 
968   Module *M = B.GetInsertBlock()->getModule();
969   StringRef FuncName = TLI->getName(TheLibFunc);
970   FunctionType *FuncType = FunctionType::get(ReturnType, ParamTypes, IsVaArgs);
971   FunctionCallee Callee = M->getOrInsertFunction(FuncName, FuncType);
972   inferLibFuncAttributes(M, FuncName, *TLI);
973   CallInst *CI = B.CreateCall(Callee, Operands, FuncName);
974   if (const Function *F =
975           dyn_cast<Function>(Callee.getCallee()->stripPointerCasts()))
976     CI->setCallingConv(F->getCallingConv());
977   return CI;
978 }
979 
980 Value *llvm::emitStrLen(Value *Ptr, IRBuilderBase &B, const DataLayout &DL,
981                         const TargetLibraryInfo *TLI) {
982   LLVMContext &Context = B.GetInsertBlock()->getContext();
983   return emitLibCall(LibFunc_strlen, DL.getIntPtrType(Context),
984                      B.getInt8PtrTy(), castToCStr(Ptr, B), B, TLI);
985 }
986 
987 Value *llvm::emitStrDup(Value *Ptr, IRBuilderBase &B,
988                         const TargetLibraryInfo *TLI) {
989   return emitLibCall(LibFunc_strdup, B.getInt8PtrTy(), B.getInt8PtrTy(),
990                      castToCStr(Ptr, B), B, TLI);
991 }
992 
993 Value *llvm::emitStrChr(Value *Ptr, char C, IRBuilderBase &B,
994                         const TargetLibraryInfo *TLI) {
995   Type *I8Ptr = B.getInt8PtrTy();
996   Type *I32Ty = B.getInt32Ty();
997   return emitLibCall(LibFunc_strchr, I8Ptr, {I8Ptr, I32Ty},
998                      {castToCStr(Ptr, B), ConstantInt::get(I32Ty, C)}, B, TLI);
999 }
1000 
1001 Value *llvm::emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
1002                          const DataLayout &DL, const TargetLibraryInfo *TLI) {
1003   LLVMContext &Context = B.GetInsertBlock()->getContext();
1004   return emitLibCall(
1005       LibFunc_strncmp, B.getInt32Ty(),
1006       {B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context)},
1007       {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI);
1008 }
1009 
1010 Value *llvm::emitStrCpy(Value *Dst, Value *Src, IRBuilderBase &B,
1011                         const TargetLibraryInfo *TLI) {
1012   Type *I8Ptr = B.getInt8PtrTy();
1013   return emitLibCall(LibFunc_strcpy, I8Ptr, {I8Ptr, I8Ptr},
1014                      {castToCStr(Dst, B), castToCStr(Src, B)}, B, TLI);
1015 }
1016 
1017 Value *llvm::emitStpCpy(Value *Dst, Value *Src, IRBuilderBase &B,
1018                         const TargetLibraryInfo *TLI) {
1019   Type *I8Ptr = B.getInt8PtrTy();
1020   return emitLibCall(LibFunc_stpcpy, I8Ptr, {I8Ptr, I8Ptr},
1021                      {castToCStr(Dst, B), castToCStr(Src, B)}, B, TLI);
1022 }
1023 
1024 Value *llvm::emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B,
1025                          const TargetLibraryInfo *TLI) {
1026   Type *I8Ptr = B.getInt8PtrTy();
1027   return emitLibCall(LibFunc_strncpy, I8Ptr, {I8Ptr, I8Ptr, Len->getType()},
1028                      {castToCStr(Dst, B), castToCStr(Src, B), Len}, B, TLI);
1029 }
1030 
1031 Value *llvm::emitStpNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B,
1032                          const TargetLibraryInfo *TLI) {
1033   Type *I8Ptr = B.getInt8PtrTy();
1034   return emitLibCall(LibFunc_stpncpy, I8Ptr, {I8Ptr, I8Ptr, Len->getType()},
1035                      {castToCStr(Dst, B), castToCStr(Src, B), Len}, B, TLI);
1036 }
1037 
1038 Value *llvm::emitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize,
1039                            IRBuilderBase &B, const DataLayout &DL,
1040                            const TargetLibraryInfo *TLI) {
1041   if (!TLI->has(LibFunc_memcpy_chk))
1042     return nullptr;
1043 
1044   Module *M = B.GetInsertBlock()->getModule();
1045   AttributeList AS;
1046   AS = AttributeList::get(M->getContext(), AttributeList::FunctionIndex,
1047                           Attribute::NoUnwind);
1048   LLVMContext &Context = B.GetInsertBlock()->getContext();
1049   FunctionCallee MemCpy = M->getOrInsertFunction(
1050       "__memcpy_chk", AttributeList::get(M->getContext(), AS), B.getInt8PtrTy(),
1051       B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context),
1052       DL.getIntPtrType(Context));
1053   Dst = castToCStr(Dst, B);
1054   Src = castToCStr(Src, B);
1055   CallInst *CI = B.CreateCall(MemCpy, {Dst, Src, Len, ObjSize});
1056   if (const Function *F =
1057           dyn_cast<Function>(MemCpy.getCallee()->stripPointerCasts()))
1058     CI->setCallingConv(F->getCallingConv());
1059   return CI;
1060 }
1061 
1062 Value *llvm::emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilderBase &B,
1063                         const DataLayout &DL, const TargetLibraryInfo *TLI) {
1064   LLVMContext &Context = B.GetInsertBlock()->getContext();
1065   return emitLibCall(
1066       LibFunc_memchr, B.getInt8PtrTy(),
1067       {B.getInt8PtrTy(), B.getInt32Ty(), DL.getIntPtrType(Context)},
1068       {castToCStr(Ptr, B), Val, Len}, B, TLI);
1069 }
1070 
1071 Value *llvm::emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
1072                         const DataLayout &DL, const TargetLibraryInfo *TLI) {
1073   LLVMContext &Context = B.GetInsertBlock()->getContext();
1074   return emitLibCall(
1075       LibFunc_memcmp, B.getInt32Ty(),
1076       {B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context)},
1077       {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI);
1078 }
1079 
1080 Value *llvm::emitBCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
1081                       const DataLayout &DL, const TargetLibraryInfo *TLI) {
1082   LLVMContext &Context = B.GetInsertBlock()->getContext();
1083   return emitLibCall(
1084       LibFunc_bcmp, B.getInt32Ty(),
1085       {B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context)},
1086       {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI);
1087 }
1088 
1089 Value *llvm::emitMemCCpy(Value *Ptr1, Value *Ptr2, Value *Val, Value *Len,
1090                          IRBuilderBase &B, const TargetLibraryInfo *TLI) {
1091   return emitLibCall(
1092       LibFunc_memccpy, B.getInt8PtrTy(),
1093       {B.getInt8PtrTy(), B.getInt8PtrTy(), B.getInt32Ty(), Len->getType()},
1094       {Ptr1, Ptr2, Val, Len}, B, TLI);
1095 }
1096 
1097 Value *llvm::emitSNPrintf(Value *Dest, Value *Size, Value *Fmt,
1098                           ArrayRef<Value *> VariadicArgs, IRBuilderBase &B,
1099                           const TargetLibraryInfo *TLI) {
1100   SmallVector<Value *, 8> Args{castToCStr(Dest, B), Size, castToCStr(Fmt, B)};
1101   Args.insert(Args.end(), VariadicArgs.begin(), VariadicArgs.end());
1102   return emitLibCall(LibFunc_snprintf, B.getInt32Ty(),
1103                      {B.getInt8PtrTy(), Size->getType(), B.getInt8PtrTy()},
1104                      Args, B, TLI, /*IsVaArgs=*/true);
1105 }
1106 
1107 Value *llvm::emitSPrintf(Value *Dest, Value *Fmt,
1108                          ArrayRef<Value *> VariadicArgs, IRBuilderBase &B,
1109                          const TargetLibraryInfo *TLI) {
1110   SmallVector<Value *, 8> Args{castToCStr(Dest, B), castToCStr(Fmt, B)};
1111   Args.insert(Args.end(), VariadicArgs.begin(), VariadicArgs.end());
1112   return emitLibCall(LibFunc_sprintf, B.getInt32Ty(),
1113                      {B.getInt8PtrTy(), B.getInt8PtrTy()}, Args, B, TLI,
1114                      /*IsVaArgs=*/true);
1115 }
1116 
1117 Value *llvm::emitStrCat(Value *Dest, Value *Src, IRBuilderBase &B,
1118                         const TargetLibraryInfo *TLI) {
1119   return emitLibCall(LibFunc_strcat, B.getInt8PtrTy(),
1120                      {B.getInt8PtrTy(), B.getInt8PtrTy()},
1121                      {castToCStr(Dest, B), castToCStr(Src, B)}, B, TLI);
1122 }
1123 
1124 Value *llvm::emitStrLCpy(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
1125                          const TargetLibraryInfo *TLI) {
1126   return emitLibCall(LibFunc_strlcpy, Size->getType(),
1127                      {B.getInt8PtrTy(), B.getInt8PtrTy(), Size->getType()},
1128                      {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI);
1129 }
1130 
1131 Value *llvm::emitStrLCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
1132                          const TargetLibraryInfo *TLI) {
1133   return emitLibCall(LibFunc_strlcat, Size->getType(),
1134                      {B.getInt8PtrTy(), B.getInt8PtrTy(), Size->getType()},
1135                      {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI);
1136 }
1137 
1138 Value *llvm::emitStrNCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
1139                          const TargetLibraryInfo *TLI) {
1140   return emitLibCall(LibFunc_strncat, B.getInt8PtrTy(),
1141                      {B.getInt8PtrTy(), B.getInt8PtrTy(), Size->getType()},
1142                      {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI);
1143 }
1144 
1145 Value *llvm::emitVSNPrintf(Value *Dest, Value *Size, Value *Fmt, Value *VAList,
1146                            IRBuilderBase &B, const TargetLibraryInfo *TLI) {
1147   return emitLibCall(
1148       LibFunc_vsnprintf, B.getInt32Ty(),
1149       {B.getInt8PtrTy(), Size->getType(), B.getInt8PtrTy(), VAList->getType()},
1150       {castToCStr(Dest, B), Size, castToCStr(Fmt, B), VAList}, B, TLI);
1151 }
1152 
1153 Value *llvm::emitVSPrintf(Value *Dest, Value *Fmt, Value *VAList,
1154                           IRBuilderBase &B, const TargetLibraryInfo *TLI) {
1155   return emitLibCall(LibFunc_vsprintf, B.getInt32Ty(),
1156                      {B.getInt8PtrTy(), B.getInt8PtrTy(), VAList->getType()},
1157                      {castToCStr(Dest, B), castToCStr(Fmt, B), VAList}, B, TLI);
1158 }
1159 
1160 /// Append a suffix to the function name according to the type of 'Op'.
1161 static void appendTypeSuffix(Value *Op, StringRef &Name,
1162                              SmallString<20> &NameBuffer) {
1163   if (!Op->getType()->isDoubleTy()) {
1164       NameBuffer += Name;
1165 
1166     if (Op->getType()->isFloatTy())
1167       NameBuffer += 'f';
1168     else
1169       NameBuffer += 'l';
1170 
1171     Name = NameBuffer;
1172   }
1173 }
1174 
1175 static Value *emitUnaryFloatFnCallHelper(Value *Op, StringRef Name,
1176                                          IRBuilderBase &B,
1177                                          const AttributeList &Attrs) {
1178   assert((Name != "") && "Must specify Name to emitUnaryFloatFnCall");
1179 
1180   Module *M = B.GetInsertBlock()->getModule();
1181   FunctionCallee Callee =
1182       M->getOrInsertFunction(Name, Op->getType(), Op->getType());
1183   CallInst *CI = B.CreateCall(Callee, Op, Name);
1184 
1185   // The incoming attribute set may have come from a speculatable intrinsic, but
1186   // is being replaced with a library call which is not allowed to be
1187   // speculatable.
1188   CI->setAttributes(Attrs.removeAttribute(B.getContext(),
1189                                           AttributeList::FunctionIndex,
1190                                           Attribute::Speculatable));
1191   if (const Function *F =
1192           dyn_cast<Function>(Callee.getCallee()->stripPointerCasts()))
1193     CI->setCallingConv(F->getCallingConv());
1194 
1195   return CI;
1196 }
1197 
1198 Value *llvm::emitUnaryFloatFnCall(Value *Op, StringRef Name, IRBuilderBase &B,
1199                                   const AttributeList &Attrs) {
1200   SmallString<20> NameBuffer;
1201   appendTypeSuffix(Op, Name, NameBuffer);
1202 
1203   return emitUnaryFloatFnCallHelper(Op, Name, B, Attrs);
1204 }
1205 
1206 Value *llvm::emitUnaryFloatFnCall(Value *Op, const TargetLibraryInfo *TLI,
1207                                   LibFunc DoubleFn, LibFunc FloatFn,
1208                                   LibFunc LongDoubleFn, IRBuilderBase &B,
1209                                   const AttributeList &Attrs) {
1210   // Get the name of the function according to TLI.
1211   StringRef Name = getFloatFnName(TLI, Op->getType(),
1212                                   DoubleFn, FloatFn, LongDoubleFn);
1213 
1214   return emitUnaryFloatFnCallHelper(Op, Name, B, Attrs);
1215 }
1216 
1217 static Value *emitBinaryFloatFnCallHelper(Value *Op1, Value *Op2,
1218                                           StringRef Name, IRBuilderBase &B,
1219                                           const AttributeList &Attrs) {
1220   assert((Name != "") && "Must specify Name to emitBinaryFloatFnCall");
1221 
1222   Module *M = B.GetInsertBlock()->getModule();
1223   FunctionCallee Callee = M->getOrInsertFunction(Name, Op1->getType(),
1224                                                  Op1->getType(), Op2->getType());
1225   CallInst *CI = B.CreateCall(Callee, { Op1, Op2 }, Name);
1226 
1227   // The incoming attribute set may have come from a speculatable intrinsic, but
1228   // is being replaced with a library call which is not allowed to be
1229   // speculatable.
1230   CI->setAttributes(Attrs.removeAttribute(B.getContext(),
1231                                           AttributeList::FunctionIndex,
1232                                           Attribute::Speculatable));
1233   if (const Function *F =
1234           dyn_cast<Function>(Callee.getCallee()->stripPointerCasts()))
1235     CI->setCallingConv(F->getCallingConv());
1236 
1237   return CI;
1238 }
1239 
1240 Value *llvm::emitBinaryFloatFnCall(Value *Op1, Value *Op2, StringRef Name,
1241                                    IRBuilderBase &B,
1242                                    const AttributeList &Attrs) {
1243   assert((Name != "") && "Must specify Name to emitBinaryFloatFnCall");
1244 
1245   SmallString<20> NameBuffer;
1246   appendTypeSuffix(Op1, Name, NameBuffer);
1247 
1248   return emitBinaryFloatFnCallHelper(Op1, Op2, Name, B, Attrs);
1249 }
1250 
1251 Value *llvm::emitBinaryFloatFnCall(Value *Op1, Value *Op2,
1252                                    const TargetLibraryInfo *TLI,
1253                                    LibFunc DoubleFn, LibFunc FloatFn,
1254                                    LibFunc LongDoubleFn, IRBuilderBase &B,
1255                                    const AttributeList &Attrs) {
1256   // Get the name of the function according to TLI.
1257   StringRef Name = getFloatFnName(TLI, Op1->getType(),
1258                                   DoubleFn, FloatFn, LongDoubleFn);
1259 
1260   return emitBinaryFloatFnCallHelper(Op1, Op2, Name, B, Attrs);
1261 }
1262 
1263 Value *llvm::emitPutChar(Value *Char, IRBuilderBase &B,
1264                          const TargetLibraryInfo *TLI) {
1265   if (!TLI->has(LibFunc_putchar))
1266     return nullptr;
1267 
1268   Module *M = B.GetInsertBlock()->getModule();
1269   StringRef PutCharName = TLI->getName(LibFunc_putchar);
1270   FunctionCallee PutChar =
1271       M->getOrInsertFunction(PutCharName, B.getInt32Ty(), B.getInt32Ty());
1272   inferLibFuncAttributes(M, PutCharName, *TLI);
1273   CallInst *CI = B.CreateCall(PutChar,
1274                               B.CreateIntCast(Char,
1275                               B.getInt32Ty(),
1276                               /*isSigned*/true,
1277                               "chari"),
1278                               PutCharName);
1279 
1280   if (const Function *F =
1281           dyn_cast<Function>(PutChar.getCallee()->stripPointerCasts()))
1282     CI->setCallingConv(F->getCallingConv());
1283   return CI;
1284 }
1285 
1286 Value *llvm::emitPutS(Value *Str, IRBuilderBase &B,
1287                       const TargetLibraryInfo *TLI) {
1288   if (!TLI->has(LibFunc_puts))
1289     return nullptr;
1290 
1291   Module *M = B.GetInsertBlock()->getModule();
1292   StringRef PutsName = TLI->getName(LibFunc_puts);
1293   FunctionCallee PutS =
1294       M->getOrInsertFunction(PutsName, B.getInt32Ty(), B.getInt8PtrTy());
1295   inferLibFuncAttributes(M, PutsName, *TLI);
1296   CallInst *CI = B.CreateCall(PutS, castToCStr(Str, B), PutsName);
1297   if (const Function *F =
1298           dyn_cast<Function>(PutS.getCallee()->stripPointerCasts()))
1299     CI->setCallingConv(F->getCallingConv());
1300   return CI;
1301 }
1302 
1303 Value *llvm::emitFPutC(Value *Char, Value *File, IRBuilderBase &B,
1304                        const TargetLibraryInfo *TLI) {
1305   if (!TLI->has(LibFunc_fputc))
1306     return nullptr;
1307 
1308   Module *M = B.GetInsertBlock()->getModule();
1309   StringRef FPutcName = TLI->getName(LibFunc_fputc);
1310   FunctionCallee F = M->getOrInsertFunction(FPutcName, B.getInt32Ty(),
1311                                             B.getInt32Ty(), File->getType());
1312   if (File->getType()->isPointerTy())
1313     inferLibFuncAttributes(M, FPutcName, *TLI);
1314   Char = B.CreateIntCast(Char, B.getInt32Ty(), /*isSigned*/true,
1315                          "chari");
1316   CallInst *CI = B.CreateCall(F, {Char, File}, FPutcName);
1317 
1318   if (const Function *Fn =
1319           dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
1320     CI->setCallingConv(Fn->getCallingConv());
1321   return CI;
1322 }
1323 
1324 Value *llvm::emitFPutS(Value *Str, Value *File, IRBuilderBase &B,
1325                        const TargetLibraryInfo *TLI) {
1326   if (!TLI->has(LibFunc_fputs))
1327     return nullptr;
1328 
1329   Module *M = B.GetInsertBlock()->getModule();
1330   StringRef FPutsName = TLI->getName(LibFunc_fputs);
1331   FunctionCallee F = M->getOrInsertFunction(FPutsName, B.getInt32Ty(),
1332                                             B.getInt8PtrTy(), File->getType());
1333   if (File->getType()->isPointerTy())
1334     inferLibFuncAttributes(M, FPutsName, *TLI);
1335   CallInst *CI = B.CreateCall(F, {castToCStr(Str, B), File}, FPutsName);
1336 
1337   if (const Function *Fn =
1338           dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
1339     CI->setCallingConv(Fn->getCallingConv());
1340   return CI;
1341 }
1342 
1343 Value *llvm::emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilderBase &B,
1344                         const DataLayout &DL, const TargetLibraryInfo *TLI) {
1345   if (!TLI->has(LibFunc_fwrite))
1346     return nullptr;
1347 
1348   Module *M = B.GetInsertBlock()->getModule();
1349   LLVMContext &Context = B.GetInsertBlock()->getContext();
1350   StringRef FWriteName = TLI->getName(LibFunc_fwrite);
1351   FunctionCallee F = M->getOrInsertFunction(
1352       FWriteName, DL.getIntPtrType(Context), B.getInt8PtrTy(),
1353       DL.getIntPtrType(Context), DL.getIntPtrType(Context), File->getType());
1354 
1355   if (File->getType()->isPointerTy())
1356     inferLibFuncAttributes(M, FWriteName, *TLI);
1357   CallInst *CI =
1358       B.CreateCall(F, {castToCStr(Ptr, B), Size,
1359                        ConstantInt::get(DL.getIntPtrType(Context), 1), File});
1360 
1361   if (const Function *Fn =
1362           dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
1363     CI->setCallingConv(Fn->getCallingConv());
1364   return CI;
1365 }
1366 
1367 Value *llvm::emitMalloc(Value *Num, IRBuilderBase &B, const DataLayout &DL,
1368                         const TargetLibraryInfo *TLI) {
1369   if (!TLI->has(LibFunc_malloc))
1370     return nullptr;
1371 
1372   Module *M = B.GetInsertBlock()->getModule();
1373   StringRef MallocName = TLI->getName(LibFunc_malloc);
1374   LLVMContext &Context = B.GetInsertBlock()->getContext();
1375   FunctionCallee Malloc = M->getOrInsertFunction(MallocName, B.getInt8PtrTy(),
1376                                                  DL.getIntPtrType(Context));
1377   inferLibFuncAttributes(M, MallocName, *TLI);
1378   CallInst *CI = B.CreateCall(Malloc, Num, MallocName);
1379 
1380   if (const Function *F =
1381           dyn_cast<Function>(Malloc.getCallee()->stripPointerCasts()))
1382     CI->setCallingConv(F->getCallingConv());
1383 
1384   return CI;
1385 }
1386 
1387 Value *llvm::emitCalloc(Value *Num, Value *Size, const AttributeList &Attrs,
1388                         IRBuilderBase &B, const TargetLibraryInfo &TLI) {
1389   if (!TLI.has(LibFunc_calloc))
1390     return nullptr;
1391 
1392   Module *M = B.GetInsertBlock()->getModule();
1393   StringRef CallocName = TLI.getName(LibFunc_calloc);
1394   const DataLayout &DL = M->getDataLayout();
1395   IntegerType *PtrType = DL.getIntPtrType((B.GetInsertBlock()->getContext()));
1396   FunctionCallee Calloc = M->getOrInsertFunction(
1397       CallocName, Attrs, B.getInt8PtrTy(), PtrType, PtrType);
1398   inferLibFuncAttributes(M, CallocName, TLI);
1399   CallInst *CI = B.CreateCall(Calloc, {Num, Size}, CallocName);
1400 
1401   if (const auto *F =
1402           dyn_cast<Function>(Calloc.getCallee()->stripPointerCasts()))
1403     CI->setCallingConv(F->getCallingConv());
1404 
1405   return CI;
1406 }
1407