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