1 //===- BuildLibCalls.cpp - Utility builder for libcalls -------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements some functions that will create standard C libcalls.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/Transforms/Utils/BuildLibCalls.h"
15 #include "llvm/ADT/SmallString.h"
16 #include "llvm/ADT/Statistic.h"
17 #include "llvm/Analysis/TargetLibraryInfo.h"
18 #include "llvm/IR/Constants.h"
19 #include "llvm/IR/DataLayout.h"
20 #include "llvm/IR/Function.h"
21 #include "llvm/IR/IRBuilder.h"
22 #include "llvm/IR/Intrinsics.h"
23 #include "llvm/IR/LLVMContext.h"
24 #include "llvm/IR/Module.h"
25 #include "llvm/IR/Type.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 
42 static bool setDoesNotAccessMemory(Function &F) {
43   if (F.doesNotAccessMemory())
44     return false;
45   F.setDoesNotAccessMemory();
46   ++NumReadNone;
47   return true;
48 }
49 
50 static bool setOnlyReadsMemory(Function &F) {
51   if (F.onlyReadsMemory())
52     return false;
53   F.setOnlyReadsMemory();
54   ++NumReadOnly;
55   return true;
56 }
57 
58 static bool setOnlyAccessesArgMemory(Function &F) {
59   if (F.onlyAccessesArgMemory())
60     return false;
61   F.setOnlyAccessesArgMemory();
62   ++NumArgMemOnly;
63   return true;
64 }
65 
66 static bool setDoesNotThrow(Function &F) {
67   if (F.doesNotThrow())
68     return false;
69   F.setDoesNotThrow();
70   ++NumNoUnwind;
71   return true;
72 }
73 
74 static bool setRetDoesNotAlias(Function &F) {
75   if (F.hasAttribute(AttributeList::ReturnIndex, Attribute::NoAlias))
76     return false;
77   F.addAttribute(AttributeList::ReturnIndex, Attribute::NoAlias);
78   ++NumNoAlias;
79   return true;
80 }
81 
82 static bool setDoesNotCapture(Function &F, unsigned ArgNo) {
83   if (F.hasParamAttribute(ArgNo, Attribute::NoCapture))
84     return false;
85   F.addParamAttr(ArgNo, Attribute::NoCapture);
86   ++NumNoCapture;
87   return true;
88 }
89 
90 static bool setOnlyReadsMemory(Function &F, unsigned ArgNo) {
91   if (F.hasParamAttribute(ArgNo, Attribute::ReadOnly))
92     return false;
93   F.addParamAttr(ArgNo, Attribute::ReadOnly);
94   ++NumReadOnlyArg;
95   return true;
96 }
97 
98 static bool setRetNonNull(Function &F) {
99   assert(F.getReturnType()->isPointerTy() &&
100          "nonnull applies only to pointers");
101   if (F.hasAttribute(AttributeList::ReturnIndex, Attribute::NonNull))
102     return false;
103   F.addAttribute(AttributeList::ReturnIndex, Attribute::NonNull);
104   ++NumNonNull;
105   return true;
106 }
107 
108 bool llvm::inferLibFuncAttributes(Function &F, const TargetLibraryInfo &TLI) {
109   LibFunc TheLibFunc;
110   if (!(TLI.getLibFunc(F, TheLibFunc) && TLI.has(TheLibFunc)))
111     return false;
112 
113   bool Changed = false;
114   switch (TheLibFunc) {
115   case LibFunc_strlen:
116     Changed |= setOnlyReadsMemory(F);
117     Changed |= setDoesNotThrow(F);
118     Changed |= setDoesNotCapture(F, 0);
119     return Changed;
120   case LibFunc_strchr:
121   case LibFunc_strrchr:
122     Changed |= setOnlyReadsMemory(F);
123     Changed |= setDoesNotThrow(F);
124     return Changed;
125   case LibFunc_strtol:
126   case LibFunc_strtod:
127   case LibFunc_strtof:
128   case LibFunc_strtoul:
129   case LibFunc_strtoll:
130   case LibFunc_strtold:
131   case LibFunc_strtoull:
132     Changed |= setDoesNotThrow(F);
133     Changed |= setDoesNotCapture(F, 1);
134     Changed |= setOnlyReadsMemory(F, 0);
135     return Changed;
136   case LibFunc_strcpy:
137   case LibFunc_stpcpy:
138   case LibFunc_strcat:
139   case LibFunc_strncat:
140   case LibFunc_strncpy:
141   case LibFunc_stpncpy:
142     Changed |= setDoesNotThrow(F);
143     Changed |= setDoesNotCapture(F, 1);
144     Changed |= setOnlyReadsMemory(F, 1);
145     return Changed;
146   case LibFunc_strxfrm:
147     Changed |= setDoesNotThrow(F);
148     Changed |= setDoesNotCapture(F, 0);
149     Changed |= setDoesNotCapture(F, 1);
150     Changed |= setOnlyReadsMemory(F, 1);
151     return Changed;
152   case LibFunc_strcmp:      // 0,1
153   case LibFunc_strspn:      // 0,1
154   case LibFunc_strncmp:     // 0,1
155   case LibFunc_strcspn:     // 0,1
156   case LibFunc_strcoll:     // 0,1
157   case LibFunc_strcasecmp:  // 0,1
158   case LibFunc_strncasecmp: //
159     Changed |= setOnlyReadsMemory(F);
160     Changed |= setDoesNotThrow(F);
161     Changed |= setDoesNotCapture(F, 0);
162     Changed |= setDoesNotCapture(F, 1);
163     return Changed;
164   case LibFunc_strstr:
165   case LibFunc_strpbrk:
166     Changed |= setOnlyReadsMemory(F);
167     Changed |= setDoesNotThrow(F);
168     Changed |= setDoesNotCapture(F, 1);
169     return Changed;
170   case LibFunc_strtok:
171   case LibFunc_strtok_r:
172     Changed |= setDoesNotThrow(F);
173     Changed |= setDoesNotCapture(F, 1);
174     Changed |= setOnlyReadsMemory(F, 1);
175     return Changed;
176   case LibFunc_scanf:
177     Changed |= setDoesNotThrow(F);
178     Changed |= setDoesNotCapture(F, 0);
179     Changed |= setOnlyReadsMemory(F, 0);
180     return Changed;
181   case LibFunc_setbuf:
182   case LibFunc_setvbuf:
183     Changed |= setDoesNotThrow(F);
184     Changed |= setDoesNotCapture(F, 0);
185     return Changed;
186   case LibFunc_strdup:
187   case LibFunc_strndup:
188     Changed |= setDoesNotThrow(F);
189     Changed |= setRetDoesNotAlias(F);
190     Changed |= setDoesNotCapture(F, 0);
191     Changed |= setOnlyReadsMemory(F, 0);
192     return Changed;
193   case LibFunc_stat:
194   case LibFunc_statvfs:
195     Changed |= setDoesNotThrow(F);
196     Changed |= setDoesNotCapture(F, 0);
197     Changed |= setDoesNotCapture(F, 1);
198     Changed |= setOnlyReadsMemory(F, 0);
199     return Changed;
200   case LibFunc_sscanf:
201     Changed |= setDoesNotThrow(F);
202     Changed |= setDoesNotCapture(F, 0);
203     Changed |= setDoesNotCapture(F, 1);
204     Changed |= setOnlyReadsMemory(F, 0);
205     Changed |= setOnlyReadsMemory(F, 1);
206     return Changed;
207   case LibFunc_sprintf:
208     Changed |= setDoesNotThrow(F);
209     Changed |= setDoesNotCapture(F, 0);
210     Changed |= setDoesNotCapture(F, 1);
211     Changed |= setOnlyReadsMemory(F, 1);
212     return Changed;
213   case LibFunc_snprintf:
214     Changed |= setDoesNotThrow(F);
215     Changed |= setDoesNotCapture(F, 0);
216     Changed |= setDoesNotCapture(F, 2);
217     Changed |= setOnlyReadsMemory(F, 2);
218     return Changed;
219   case LibFunc_setitimer:
220     Changed |= setDoesNotThrow(F);
221     Changed |= setDoesNotCapture(F, 1);
222     Changed |= setDoesNotCapture(F, 2);
223     Changed |= setOnlyReadsMemory(F, 1);
224     return Changed;
225   case LibFunc_system:
226     // May throw; "system" is a valid pthread cancellation point.
227     Changed |= setDoesNotCapture(F, 0);
228     Changed |= setOnlyReadsMemory(F, 0);
229     return Changed;
230   case LibFunc_malloc:
231     Changed |= setDoesNotThrow(F);
232     Changed |= setRetDoesNotAlias(F);
233     return Changed;
234   case LibFunc_memcmp:
235     Changed |= setOnlyReadsMemory(F);
236     Changed |= setDoesNotThrow(F);
237     Changed |= setDoesNotCapture(F, 0);
238     Changed |= setDoesNotCapture(F, 1);
239     return Changed;
240   case LibFunc_memchr:
241   case LibFunc_memrchr:
242     Changed |= setOnlyReadsMemory(F);
243     Changed |= setDoesNotThrow(F);
244     return Changed;
245   case LibFunc_modf:
246   case LibFunc_modff:
247   case LibFunc_modfl:
248     Changed |= setDoesNotThrow(F);
249     Changed |= setDoesNotCapture(F, 1);
250     return Changed;
251   case LibFunc_memcpy:
252   case LibFunc_mempcpy:
253   case LibFunc_memccpy:
254   case LibFunc_memmove:
255     Changed |= setDoesNotThrow(F);
256     Changed |= setDoesNotCapture(F, 1);
257     Changed |= setOnlyReadsMemory(F, 1);
258     return Changed;
259   case LibFunc_memcpy_chk:
260     Changed |= setDoesNotThrow(F);
261     return Changed;
262   case LibFunc_memalign:
263     Changed |= setRetDoesNotAlias(F);
264     return Changed;
265   case LibFunc_mkdir:
266     Changed |= setDoesNotThrow(F);
267     Changed |= setDoesNotCapture(F, 0);
268     Changed |= setOnlyReadsMemory(F, 0);
269     return Changed;
270   case LibFunc_mktime:
271     Changed |= setDoesNotThrow(F);
272     Changed |= setDoesNotCapture(F, 0);
273     return Changed;
274   case LibFunc_realloc:
275     Changed |= setDoesNotThrow(F);
276     Changed |= setRetDoesNotAlias(F);
277     Changed |= setDoesNotCapture(F, 0);
278     return Changed;
279   case LibFunc_read:
280     // May throw; "read" is a valid pthread cancellation point.
281     Changed |= setDoesNotCapture(F, 1);
282     return Changed;
283   case LibFunc_rewind:
284     Changed |= setDoesNotThrow(F);
285     Changed |= setDoesNotCapture(F, 0);
286     return Changed;
287   case LibFunc_rmdir:
288   case LibFunc_remove:
289   case LibFunc_realpath:
290     Changed |= setDoesNotThrow(F);
291     Changed |= setDoesNotCapture(F, 0);
292     Changed |= setOnlyReadsMemory(F, 0);
293     return Changed;
294   case LibFunc_rename:
295     Changed |= setDoesNotThrow(F);
296     Changed |= setDoesNotCapture(F, 0);
297     Changed |= setDoesNotCapture(F, 1);
298     Changed |= setOnlyReadsMemory(F, 0);
299     Changed |= setOnlyReadsMemory(F, 1);
300     return Changed;
301   case LibFunc_readlink:
302     Changed |= setDoesNotThrow(F);
303     Changed |= setDoesNotCapture(F, 0);
304     Changed |= setDoesNotCapture(F, 1);
305     Changed |= setOnlyReadsMemory(F, 0);
306     return Changed;
307   case LibFunc_write:
308     // May throw; "write" is a valid pthread cancellation point.
309     Changed |= setDoesNotCapture(F, 1);
310     Changed |= setOnlyReadsMemory(F, 1);
311     return Changed;
312   case LibFunc_bcopy:
313     Changed |= setDoesNotThrow(F);
314     Changed |= setDoesNotCapture(F, 0);
315     Changed |= setDoesNotCapture(F, 1);
316     Changed |= setOnlyReadsMemory(F, 0);
317     return Changed;
318   case LibFunc_bcmp:
319     Changed |= setDoesNotThrow(F);
320     Changed |= setOnlyReadsMemory(F);
321     Changed |= setDoesNotCapture(F, 0);
322     Changed |= setDoesNotCapture(F, 1);
323     return Changed;
324   case LibFunc_bzero:
325     Changed |= setDoesNotThrow(F);
326     Changed |= setDoesNotCapture(F, 0);
327     return Changed;
328   case LibFunc_calloc:
329     Changed |= setDoesNotThrow(F);
330     Changed |= setRetDoesNotAlias(F);
331     return Changed;
332   case LibFunc_chmod:
333   case LibFunc_chown:
334     Changed |= setDoesNotThrow(F);
335     Changed |= setDoesNotCapture(F, 0);
336     Changed |= setOnlyReadsMemory(F, 0);
337     return Changed;
338   case LibFunc_ctermid:
339   case LibFunc_clearerr:
340   case LibFunc_closedir:
341     Changed |= setDoesNotThrow(F);
342     Changed |= setDoesNotCapture(F, 0);
343     return Changed;
344   case LibFunc_atoi:
345   case LibFunc_atol:
346   case LibFunc_atof:
347   case LibFunc_atoll:
348     Changed |= setDoesNotThrow(F);
349     Changed |= setOnlyReadsMemory(F);
350     Changed |= setDoesNotCapture(F, 0);
351     return Changed;
352   case LibFunc_access:
353     Changed |= setDoesNotThrow(F);
354     Changed |= setDoesNotCapture(F, 0);
355     Changed |= setOnlyReadsMemory(F, 0);
356     return Changed;
357   case LibFunc_fopen:
358     Changed |= setDoesNotThrow(F);
359     Changed |= setRetDoesNotAlias(F);
360     Changed |= setDoesNotCapture(F, 0);
361     Changed |= setDoesNotCapture(F, 1);
362     Changed |= setOnlyReadsMemory(F, 0);
363     Changed |= setOnlyReadsMemory(F, 1);
364     return Changed;
365   case LibFunc_fdopen:
366     Changed |= setDoesNotThrow(F);
367     Changed |= setRetDoesNotAlias(F);
368     Changed |= setDoesNotCapture(F, 1);
369     Changed |= setOnlyReadsMemory(F, 1);
370     return Changed;
371   case LibFunc_feof:
372   case LibFunc_free:
373   case LibFunc_fseek:
374   case LibFunc_ftell:
375   case LibFunc_fgetc:
376   case LibFunc_fseeko:
377   case LibFunc_ftello:
378   case LibFunc_fileno:
379   case LibFunc_fflush:
380   case LibFunc_fclose:
381   case LibFunc_fsetpos:
382   case LibFunc_flockfile:
383   case LibFunc_funlockfile:
384   case LibFunc_ftrylockfile:
385     Changed |= setDoesNotThrow(F);
386     Changed |= setDoesNotCapture(F, 0);
387     return Changed;
388   case LibFunc_ferror:
389     Changed |= setDoesNotThrow(F);
390     Changed |= setDoesNotCapture(F, 0);
391     Changed |= setOnlyReadsMemory(F);
392     return Changed;
393   case LibFunc_fputc:
394   case LibFunc_fstat:
395   case LibFunc_frexp:
396   case LibFunc_frexpf:
397   case LibFunc_frexpl:
398   case LibFunc_fstatvfs:
399     Changed |= setDoesNotThrow(F);
400     Changed |= setDoesNotCapture(F, 1);
401     return Changed;
402   case LibFunc_fgets:
403     Changed |= setDoesNotThrow(F);
404     Changed |= setDoesNotCapture(F, 2);
405     return Changed;
406   case LibFunc_fread:
407     Changed |= setDoesNotThrow(F);
408     Changed |= setDoesNotCapture(F, 0);
409     Changed |= setDoesNotCapture(F, 3);
410     return Changed;
411   case LibFunc_fwrite:
412     Changed |= setDoesNotThrow(F);
413     Changed |= setDoesNotCapture(F, 0);
414     Changed |= setDoesNotCapture(F, 3);
415     // FIXME: readonly #1?
416     return Changed;
417   case LibFunc_fputs:
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_fscanf:
424   case LibFunc_fprintf:
425     Changed |= setDoesNotThrow(F);
426     Changed |= setDoesNotCapture(F, 0);
427     Changed |= setDoesNotCapture(F, 1);
428     Changed |= setOnlyReadsMemory(F, 1);
429     return Changed;
430   case LibFunc_fgetpos:
431     Changed |= setDoesNotThrow(F);
432     Changed |= setDoesNotCapture(F, 0);
433     Changed |= setDoesNotCapture(F, 1);
434     return Changed;
435   case LibFunc_getc:
436   case LibFunc_getlogin_r:
437   case LibFunc_getc_unlocked:
438     Changed |= setDoesNotThrow(F);
439     Changed |= setDoesNotCapture(F, 0);
440     return Changed;
441   case LibFunc_getenv:
442     Changed |= setDoesNotThrow(F);
443     Changed |= setOnlyReadsMemory(F);
444     Changed |= setDoesNotCapture(F, 0);
445     return Changed;
446   case LibFunc_gets:
447   case LibFunc_getchar:
448     Changed |= setDoesNotThrow(F);
449     return Changed;
450   case LibFunc_getitimer:
451     Changed |= setDoesNotThrow(F);
452     Changed |= setDoesNotCapture(F, 1);
453     return Changed;
454   case LibFunc_getpwnam:
455     Changed |= setDoesNotThrow(F);
456     Changed |= setDoesNotCapture(F, 0);
457     Changed |= setOnlyReadsMemory(F, 0);
458     return Changed;
459   case LibFunc_ungetc:
460     Changed |= setDoesNotThrow(F);
461     Changed |= setDoesNotCapture(F, 1);
462     return Changed;
463   case LibFunc_uname:
464     Changed |= setDoesNotThrow(F);
465     Changed |= setDoesNotCapture(F, 0);
466     return Changed;
467   case LibFunc_unlink:
468     Changed |= setDoesNotThrow(F);
469     Changed |= setDoesNotCapture(F, 0);
470     Changed |= setOnlyReadsMemory(F, 0);
471     return Changed;
472   case LibFunc_unsetenv:
473     Changed |= setDoesNotThrow(F);
474     Changed |= setDoesNotCapture(F, 0);
475     Changed |= setOnlyReadsMemory(F, 0);
476     return Changed;
477   case LibFunc_utime:
478   case LibFunc_utimes:
479     Changed |= setDoesNotThrow(F);
480     Changed |= setDoesNotCapture(F, 0);
481     Changed |= setDoesNotCapture(F, 1);
482     Changed |= setOnlyReadsMemory(F, 0);
483     Changed |= setOnlyReadsMemory(F, 1);
484     return Changed;
485   case LibFunc_putc:
486     Changed |= setDoesNotThrow(F);
487     Changed |= setDoesNotCapture(F, 1);
488     return Changed;
489   case LibFunc_puts:
490   case LibFunc_printf:
491   case LibFunc_perror:
492     Changed |= setDoesNotThrow(F);
493     Changed |= setDoesNotCapture(F, 0);
494     Changed |= setOnlyReadsMemory(F, 0);
495     return Changed;
496   case LibFunc_pread:
497     // May throw; "pread" is a valid pthread cancellation point.
498     Changed |= setDoesNotCapture(F, 1);
499     return Changed;
500   case LibFunc_pwrite:
501     // May throw; "pwrite" is a valid pthread cancellation point.
502     Changed |= setDoesNotCapture(F, 1);
503     Changed |= setOnlyReadsMemory(F, 1);
504     return Changed;
505   case LibFunc_putchar:
506     Changed |= setDoesNotThrow(F);
507     return Changed;
508   case LibFunc_popen:
509     Changed |= setDoesNotThrow(F);
510     Changed |= setRetDoesNotAlias(F);
511     Changed |= setDoesNotCapture(F, 0);
512     Changed |= setDoesNotCapture(F, 1);
513     Changed |= setOnlyReadsMemory(F, 0);
514     Changed |= setOnlyReadsMemory(F, 1);
515     return Changed;
516   case LibFunc_pclose:
517     Changed |= setDoesNotThrow(F);
518     Changed |= setDoesNotCapture(F, 0);
519     return Changed;
520   case LibFunc_vscanf:
521     Changed |= setDoesNotThrow(F);
522     Changed |= setDoesNotCapture(F, 0);
523     Changed |= setOnlyReadsMemory(F, 0);
524     return Changed;
525   case LibFunc_vsscanf:
526     Changed |= setDoesNotThrow(F);
527     Changed |= setDoesNotCapture(F, 0);
528     Changed |= setDoesNotCapture(F, 1);
529     Changed |= setOnlyReadsMemory(F, 0);
530     Changed |= setOnlyReadsMemory(F, 1);
531     return Changed;
532   case LibFunc_vfscanf:
533     Changed |= setDoesNotThrow(F);
534     Changed |= setDoesNotCapture(F, 0);
535     Changed |= setDoesNotCapture(F, 1);
536     Changed |= setOnlyReadsMemory(F, 1);
537     return Changed;
538   case LibFunc_valloc:
539     Changed |= setDoesNotThrow(F);
540     Changed |= setRetDoesNotAlias(F);
541     return Changed;
542   case LibFunc_vprintf:
543     Changed |= setDoesNotThrow(F);
544     Changed |= setDoesNotCapture(F, 0);
545     Changed |= setOnlyReadsMemory(F, 0);
546     return Changed;
547   case LibFunc_vfprintf:
548   case LibFunc_vsprintf:
549     Changed |= setDoesNotThrow(F);
550     Changed |= setDoesNotCapture(F, 0);
551     Changed |= setDoesNotCapture(F, 1);
552     Changed |= setOnlyReadsMemory(F, 1);
553     return Changed;
554   case LibFunc_vsnprintf:
555     Changed |= setDoesNotThrow(F);
556     Changed |= setDoesNotCapture(F, 0);
557     Changed |= setDoesNotCapture(F, 2);
558     Changed |= setOnlyReadsMemory(F, 2);
559     return Changed;
560   case LibFunc_open:
561     // May throw; "open" is a valid pthread cancellation point.
562     Changed |= setDoesNotCapture(F, 0);
563     Changed |= setOnlyReadsMemory(F, 0);
564     return Changed;
565   case LibFunc_opendir:
566     Changed |= setDoesNotThrow(F);
567     Changed |= setRetDoesNotAlias(F);
568     Changed |= setDoesNotCapture(F, 0);
569     Changed |= setOnlyReadsMemory(F, 0);
570     return Changed;
571   case LibFunc_tmpfile:
572     Changed |= setDoesNotThrow(F);
573     Changed |= setRetDoesNotAlias(F);
574     return Changed;
575   case LibFunc_times:
576     Changed |= setDoesNotThrow(F);
577     Changed |= setDoesNotCapture(F, 0);
578     return Changed;
579   case LibFunc_htonl:
580   case LibFunc_htons:
581   case LibFunc_ntohl:
582   case LibFunc_ntohs:
583     Changed |= setDoesNotThrow(F);
584     Changed |= setDoesNotAccessMemory(F);
585     return Changed;
586   case LibFunc_lstat:
587     Changed |= setDoesNotThrow(F);
588     Changed |= setDoesNotCapture(F, 0);
589     Changed |= setDoesNotCapture(F, 1);
590     Changed |= setOnlyReadsMemory(F, 0);
591     return Changed;
592   case LibFunc_lchown:
593     Changed |= setDoesNotThrow(F);
594     Changed |= setDoesNotCapture(F, 0);
595     Changed |= setOnlyReadsMemory(F, 0);
596     return Changed;
597   case LibFunc_qsort:
598     // May throw; places call through function pointer.
599     Changed |= setDoesNotCapture(F, 3);
600     return Changed;
601   case LibFunc_dunder_strdup:
602   case LibFunc_dunder_strndup:
603     Changed |= setDoesNotThrow(F);
604     Changed |= setRetDoesNotAlias(F);
605     Changed |= setDoesNotCapture(F, 0);
606     Changed |= setOnlyReadsMemory(F, 0);
607     return Changed;
608   case LibFunc_dunder_strtok_r:
609     Changed |= setDoesNotThrow(F);
610     Changed |= setDoesNotCapture(F, 1);
611     Changed |= setOnlyReadsMemory(F, 1);
612     return Changed;
613   case LibFunc_under_IO_getc:
614     Changed |= setDoesNotThrow(F);
615     Changed |= setDoesNotCapture(F, 0);
616     return Changed;
617   case LibFunc_under_IO_putc:
618     Changed |= setDoesNotThrow(F);
619     Changed |= setDoesNotCapture(F, 1);
620     return Changed;
621   case LibFunc_dunder_isoc99_scanf:
622     Changed |= setDoesNotThrow(F);
623     Changed |= setDoesNotCapture(F, 0);
624     Changed |= setOnlyReadsMemory(F, 0);
625     return Changed;
626   case LibFunc_stat64:
627   case LibFunc_lstat64:
628   case LibFunc_statvfs64:
629     Changed |= setDoesNotThrow(F);
630     Changed |= setDoesNotCapture(F, 0);
631     Changed |= setDoesNotCapture(F, 1);
632     Changed |= setOnlyReadsMemory(F, 0);
633     return Changed;
634   case LibFunc_dunder_isoc99_sscanf:
635     Changed |= setDoesNotThrow(F);
636     Changed |= setDoesNotCapture(F, 0);
637     Changed |= setDoesNotCapture(F, 1);
638     Changed |= setOnlyReadsMemory(F, 0);
639     Changed |= setOnlyReadsMemory(F, 1);
640     return Changed;
641   case LibFunc_fopen64:
642     Changed |= setDoesNotThrow(F);
643     Changed |= setRetDoesNotAlias(F);
644     Changed |= setDoesNotCapture(F, 0);
645     Changed |= setDoesNotCapture(F, 1);
646     Changed |= setOnlyReadsMemory(F, 0);
647     Changed |= setOnlyReadsMemory(F, 1);
648     return Changed;
649   case LibFunc_fseeko64:
650   case LibFunc_ftello64:
651     Changed |= setDoesNotThrow(F);
652     Changed |= setDoesNotCapture(F, 0);
653     return Changed;
654   case LibFunc_tmpfile64:
655     Changed |= setDoesNotThrow(F);
656     Changed |= setRetDoesNotAlias(F);
657     return Changed;
658   case LibFunc_fstat64:
659   case LibFunc_fstatvfs64:
660     Changed |= setDoesNotThrow(F);
661     Changed |= setDoesNotCapture(F, 1);
662     return Changed;
663   case LibFunc_open64:
664     // May throw; "open" is a valid pthread cancellation point.
665     Changed |= setDoesNotCapture(F, 0);
666     Changed |= setOnlyReadsMemory(F, 0);
667     return Changed;
668   case LibFunc_gettimeofday:
669     // Currently some platforms have the restrict keyword on the arguments to
670     // gettimeofday. To be conservative, do not add noalias to gettimeofday's
671     // arguments.
672     Changed |= setDoesNotThrow(F);
673     Changed |= setDoesNotCapture(F, 0);
674     Changed |= setDoesNotCapture(F, 1);
675     return Changed;
676   case LibFunc_Znwj: // new(unsigned int)
677   case LibFunc_Znwm: // new(unsigned long)
678   case LibFunc_Znaj: // new[](unsigned int)
679   case LibFunc_Znam: // new[](unsigned long)
680   case LibFunc_msvc_new_int: // new(unsigned int)
681   case LibFunc_msvc_new_longlong: // new(unsigned long long)
682   case LibFunc_msvc_new_array_int: // new[](unsigned int)
683   case LibFunc_msvc_new_array_longlong: // new[](unsigned long long)
684     // Operator new always returns a nonnull noalias pointer
685     Changed |= setRetNonNull(F);
686     Changed |= setRetDoesNotAlias(F);
687     return Changed;
688   //TODO: add LibFunc entries for:
689   //case LibFunc_memset_pattern4:
690   //case LibFunc_memset_pattern8:
691   case LibFunc_memset_pattern16:
692     Changed |= setOnlyAccessesArgMemory(F);
693     Changed |= setDoesNotCapture(F, 0);
694     Changed |= setDoesNotCapture(F, 1);
695     Changed |= setOnlyReadsMemory(F, 1);
696     return Changed;
697   // int __nvvm_reflect(const char *)
698   case LibFunc_nvvm_reflect:
699     Changed |= setDoesNotAccessMemory(F);
700     Changed |= setDoesNotThrow(F);
701     return Changed;
702 
703   default:
704     // FIXME: It'd be really nice to cover all the library functions we're
705     // aware of here.
706     return false;
707   }
708 }
709 
710 //- Emit LibCalls ------------------------------------------------------------//
711 
712 Value *llvm::castToCStr(Value *V, IRBuilder<> &B) {
713   unsigned AS = V->getType()->getPointerAddressSpace();
714   return B.CreateBitCast(V, B.getInt8PtrTy(AS), "cstr");
715 }
716 
717 Value *llvm::emitStrLen(Value *Ptr, IRBuilder<> &B, const DataLayout &DL,
718                         const TargetLibraryInfo *TLI) {
719   if (!TLI->has(LibFunc_strlen))
720     return nullptr;
721 
722   Module *M = B.GetInsertBlock()->getModule();
723   LLVMContext &Context = B.GetInsertBlock()->getContext();
724   Constant *StrLen = M->getOrInsertFunction("strlen", DL.getIntPtrType(Context),
725                                             B.getInt8PtrTy());
726   inferLibFuncAttributes(*M->getFunction("strlen"), *TLI);
727   CallInst *CI = B.CreateCall(StrLen, castToCStr(Ptr, B), "strlen");
728   if (const Function *F = dyn_cast<Function>(StrLen->stripPointerCasts()))
729     CI->setCallingConv(F->getCallingConv());
730 
731   return CI;
732 }
733 
734 Value *llvm::emitStrChr(Value *Ptr, char C, IRBuilder<> &B,
735                         const TargetLibraryInfo *TLI) {
736   if (!TLI->has(LibFunc_strchr))
737     return nullptr;
738 
739   Module *M = B.GetInsertBlock()->getModule();
740   Type *I8Ptr = B.getInt8PtrTy();
741   Type *I32Ty = B.getInt32Ty();
742   Constant *StrChr =
743       M->getOrInsertFunction("strchr", I8Ptr, I8Ptr, I32Ty);
744   inferLibFuncAttributes(*M->getFunction("strchr"), *TLI);
745   CallInst *CI = B.CreateCall(
746       StrChr, {castToCStr(Ptr, B), ConstantInt::get(I32Ty, C)}, "strchr");
747   if (const Function *F = dyn_cast<Function>(StrChr->stripPointerCasts()))
748     CI->setCallingConv(F->getCallingConv());
749   return CI;
750 }
751 
752 Value *llvm::emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B,
753                          const DataLayout &DL, const TargetLibraryInfo *TLI) {
754   if (!TLI->has(LibFunc_strncmp))
755     return nullptr;
756 
757   Module *M = B.GetInsertBlock()->getModule();
758   LLVMContext &Context = B.GetInsertBlock()->getContext();
759   Value *StrNCmp = M->getOrInsertFunction("strncmp", B.getInt32Ty(),
760                                           B.getInt8PtrTy(), B.getInt8PtrTy(),
761                                           DL.getIntPtrType(Context));
762   inferLibFuncAttributes(*M->getFunction("strncmp"), *TLI);
763   CallInst *CI = B.CreateCall(
764       StrNCmp, {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, "strncmp");
765 
766   if (const Function *F = dyn_cast<Function>(StrNCmp->stripPointerCasts()))
767     CI->setCallingConv(F->getCallingConv());
768 
769   return CI;
770 }
771 
772 Value *llvm::emitStrCpy(Value *Dst, Value *Src, IRBuilder<> &B,
773                         const TargetLibraryInfo *TLI, StringRef Name) {
774   if (!TLI->has(LibFunc_strcpy))
775     return nullptr;
776 
777   Module *M = B.GetInsertBlock()->getModule();
778   Type *I8Ptr = B.getInt8PtrTy();
779   Value *StrCpy = M->getOrInsertFunction(Name, I8Ptr, I8Ptr, I8Ptr);
780   inferLibFuncAttributes(*M->getFunction(Name), *TLI);
781   CallInst *CI =
782       B.CreateCall(StrCpy, {castToCStr(Dst, B), castToCStr(Src, B)}, Name);
783   if (const Function *F = dyn_cast<Function>(StrCpy->stripPointerCasts()))
784     CI->setCallingConv(F->getCallingConv());
785   return CI;
786 }
787 
788 Value *llvm::emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilder<> &B,
789                          const TargetLibraryInfo *TLI, StringRef Name) {
790   if (!TLI->has(LibFunc_strncpy))
791     return nullptr;
792 
793   Module *M = B.GetInsertBlock()->getModule();
794   Type *I8Ptr = B.getInt8PtrTy();
795   Value *StrNCpy = M->getOrInsertFunction(Name, I8Ptr, I8Ptr, I8Ptr,
796                                           Len->getType());
797   inferLibFuncAttributes(*M->getFunction(Name), *TLI);
798   CallInst *CI = B.CreateCall(
799       StrNCpy, {castToCStr(Dst, B), castToCStr(Src, B), Len}, "strncpy");
800   if (const Function *F = dyn_cast<Function>(StrNCpy->stripPointerCasts()))
801     CI->setCallingConv(F->getCallingConv());
802   return CI;
803 }
804 
805 Value *llvm::emitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize,
806                            IRBuilder<> &B, const DataLayout &DL,
807                            const TargetLibraryInfo *TLI) {
808   if (!TLI->has(LibFunc_memcpy_chk))
809     return nullptr;
810 
811   Module *M = B.GetInsertBlock()->getModule();
812   AttributeList AS;
813   AS = AttributeList::get(M->getContext(), AttributeList::FunctionIndex,
814                           Attribute::NoUnwind);
815   LLVMContext &Context = B.GetInsertBlock()->getContext();
816   Value *MemCpy = M->getOrInsertFunction(
817       "__memcpy_chk", AttributeList::get(M->getContext(), AS), B.getInt8PtrTy(),
818       B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context),
819       DL.getIntPtrType(Context));
820   Dst = castToCStr(Dst, B);
821   Src = castToCStr(Src, B);
822   CallInst *CI = B.CreateCall(MemCpy, {Dst, Src, Len, ObjSize});
823   if (const Function *F = dyn_cast<Function>(MemCpy->stripPointerCasts()))
824     CI->setCallingConv(F->getCallingConv());
825   return CI;
826 }
827 
828 Value *llvm::emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilder<> &B,
829                         const DataLayout &DL, const TargetLibraryInfo *TLI) {
830   if (!TLI->has(LibFunc_memchr))
831     return nullptr;
832 
833   Module *M = B.GetInsertBlock()->getModule();
834   LLVMContext &Context = B.GetInsertBlock()->getContext();
835   Value *MemChr = M->getOrInsertFunction("memchr", B.getInt8PtrTy(),
836                                          B.getInt8PtrTy(), B.getInt32Ty(),
837                                          DL.getIntPtrType(Context));
838   inferLibFuncAttributes(*M->getFunction("memchr"), *TLI);
839   CallInst *CI = B.CreateCall(MemChr, {castToCStr(Ptr, B), Val, Len}, "memchr");
840 
841   if (const Function *F = dyn_cast<Function>(MemChr->stripPointerCasts()))
842     CI->setCallingConv(F->getCallingConv());
843 
844   return CI;
845 }
846 
847 Value *llvm::emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B,
848                         const DataLayout &DL, const TargetLibraryInfo *TLI) {
849   if (!TLI->has(LibFunc_memcmp))
850     return nullptr;
851 
852   Module *M = B.GetInsertBlock()->getModule();
853   LLVMContext &Context = B.GetInsertBlock()->getContext();
854   Value *MemCmp = M->getOrInsertFunction("memcmp", B.getInt32Ty(),
855                                          B.getInt8PtrTy(), B.getInt8PtrTy(),
856                                          DL.getIntPtrType(Context));
857   inferLibFuncAttributes(*M->getFunction("memcmp"), *TLI);
858   CallInst *CI = B.CreateCall(
859       MemCmp, {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, "memcmp");
860 
861   if (const Function *F = dyn_cast<Function>(MemCmp->stripPointerCasts()))
862     CI->setCallingConv(F->getCallingConv());
863 
864   return CI;
865 }
866 
867 /// Append a suffix to the function name according to the type of 'Op'.
868 static void appendTypeSuffix(Value *Op, StringRef &Name,
869                              SmallString<20> &NameBuffer) {
870   if (!Op->getType()->isDoubleTy()) {
871       NameBuffer += Name;
872 
873     if (Op->getType()->isFloatTy())
874       NameBuffer += 'f';
875     else
876       NameBuffer += 'l';
877 
878     Name = NameBuffer;
879   }
880 }
881 
882 Value *llvm::emitUnaryFloatFnCall(Value *Op, StringRef Name, IRBuilder<> &B,
883                                   const AttributeList &Attrs) {
884   SmallString<20> NameBuffer;
885   appendTypeSuffix(Op, Name, NameBuffer);
886 
887   Module *M = B.GetInsertBlock()->getModule();
888   Value *Callee = M->getOrInsertFunction(Name, Op->getType(),
889                                          Op->getType());
890   CallInst *CI = B.CreateCall(Callee, Op, Name);
891 
892   // The incoming attribute set may have come from a speculatable intrinsic, but
893   // is being replaced with a library call which is not allowed to be
894   // speculatable.
895   CI->setAttributes(Attrs.removeAttribute(B.getContext(),
896                                           AttributeList::FunctionIndex,
897                                           Attribute::Speculatable));
898   if (const Function *F = dyn_cast<Function>(Callee->stripPointerCasts()))
899     CI->setCallingConv(F->getCallingConv());
900 
901   return CI;
902 }
903 
904 Value *llvm::emitBinaryFloatFnCall(Value *Op1, Value *Op2, StringRef Name,
905                                    IRBuilder<> &B, const AttributeList &Attrs) {
906   SmallString<20> NameBuffer;
907   appendTypeSuffix(Op1, Name, NameBuffer);
908 
909   Module *M = B.GetInsertBlock()->getModule();
910   Value *Callee = M->getOrInsertFunction(Name, Op1->getType(), Op1->getType(),
911                                          Op2->getType());
912   CallInst *CI = B.CreateCall(Callee, {Op1, Op2}, Name);
913   CI->setAttributes(Attrs);
914   if (const Function *F = dyn_cast<Function>(Callee->stripPointerCasts()))
915     CI->setCallingConv(F->getCallingConv());
916 
917   return CI;
918 }
919 
920 Value *llvm::emitPutChar(Value *Char, IRBuilder<> &B,
921                          const TargetLibraryInfo *TLI) {
922   if (!TLI->has(LibFunc_putchar))
923     return nullptr;
924 
925   Module *M = B.GetInsertBlock()->getModule();
926   Value *PutChar = M->getOrInsertFunction("putchar", B.getInt32Ty(), B.getInt32Ty());
927   inferLibFuncAttributes(*M->getFunction("putchar"), *TLI);
928   CallInst *CI = B.CreateCall(PutChar,
929                               B.CreateIntCast(Char,
930                               B.getInt32Ty(),
931                               /*isSigned*/true,
932                               "chari"),
933                               "putchar");
934 
935   if (const Function *F = dyn_cast<Function>(PutChar->stripPointerCasts()))
936     CI->setCallingConv(F->getCallingConv());
937   return CI;
938 }
939 
940 Value *llvm::emitPutS(Value *Str, IRBuilder<> &B,
941                       const TargetLibraryInfo *TLI) {
942   if (!TLI->has(LibFunc_puts))
943     return nullptr;
944 
945   Module *M = B.GetInsertBlock()->getModule();
946   Value *PutS =
947       M->getOrInsertFunction("puts", B.getInt32Ty(), B.getInt8PtrTy());
948   inferLibFuncAttributes(*M->getFunction("puts"), *TLI);
949   CallInst *CI = B.CreateCall(PutS, castToCStr(Str, B), "puts");
950   if (const Function *F = dyn_cast<Function>(PutS->stripPointerCasts()))
951     CI->setCallingConv(F->getCallingConv());
952   return CI;
953 }
954 
955 Value *llvm::emitFPutC(Value *Char, Value *File, IRBuilder<> &B,
956                        const TargetLibraryInfo *TLI) {
957   if (!TLI->has(LibFunc_fputc))
958     return nullptr;
959 
960   Module *M = B.GetInsertBlock()->getModule();
961   Constant *F = M->getOrInsertFunction("fputc", B.getInt32Ty(), B.getInt32Ty(),
962                                        File->getType());
963   if (File->getType()->isPointerTy())
964     inferLibFuncAttributes(*M->getFunction("fputc"), *TLI);
965   Char = B.CreateIntCast(Char, B.getInt32Ty(), /*isSigned*/true,
966                          "chari");
967   CallInst *CI = B.CreateCall(F, {Char, File}, "fputc");
968 
969   if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
970     CI->setCallingConv(Fn->getCallingConv());
971   return CI;
972 }
973 
974 Value *llvm::emitFPutS(Value *Str, Value *File, IRBuilder<> &B,
975                        const TargetLibraryInfo *TLI) {
976   if (!TLI->has(LibFunc_fputs))
977     return nullptr;
978 
979   Module *M = B.GetInsertBlock()->getModule();
980   StringRef FPutsName = TLI->getName(LibFunc_fputs);
981   Constant *F = M->getOrInsertFunction(
982       FPutsName, B.getInt32Ty(), B.getInt8PtrTy(), File->getType());
983   if (File->getType()->isPointerTy())
984     inferLibFuncAttributes(*M->getFunction(FPutsName), *TLI);
985   CallInst *CI = B.CreateCall(F, {castToCStr(Str, B), File}, "fputs");
986 
987   if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
988     CI->setCallingConv(Fn->getCallingConv());
989   return CI;
990 }
991 
992 Value *llvm::emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilder<> &B,
993                         const DataLayout &DL, const TargetLibraryInfo *TLI) {
994   if (!TLI->has(LibFunc_fwrite))
995     return nullptr;
996 
997   Module *M = B.GetInsertBlock()->getModule();
998   LLVMContext &Context = B.GetInsertBlock()->getContext();
999   StringRef FWriteName = TLI->getName(LibFunc_fwrite);
1000   Constant *F = M->getOrInsertFunction(
1001       FWriteName, DL.getIntPtrType(Context), B.getInt8PtrTy(),
1002       DL.getIntPtrType(Context), DL.getIntPtrType(Context), File->getType());
1003 
1004   if (File->getType()->isPointerTy())
1005     inferLibFuncAttributes(*M->getFunction(FWriteName), *TLI);
1006   CallInst *CI =
1007       B.CreateCall(F, {castToCStr(Ptr, B), Size,
1008                        ConstantInt::get(DL.getIntPtrType(Context), 1), File});
1009 
1010   if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
1011     CI->setCallingConv(Fn->getCallingConv());
1012   return CI;
1013 }
1014