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