LLVM  8.0.0svn
BuildLibCalls.cpp
Go to the documentation of this file.
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 
15 #include "llvm/ADT/SmallString.h"
16 #include "llvm/ADT/Statistic.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 STATISTIC(NumReturnedArg, "Number of arguments inferred as returned");
42 
44  if (F.doesNotAccessMemory())
45  return false;
47  ++NumReadNone;
48  return true;
49 }
50 
51 static bool setOnlyReadsMemory(Function &F) {
52  if (F.onlyReadsMemory())
53  return false;
55  ++NumReadOnly;
56  return true;
57 }
58 
60  if (F.onlyAccessesArgMemory())
61  return false;
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) {
77  return false;
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 setOnlyReadsMemory(Function &F, unsigned ArgNo) {
92  if (F.hasParamAttribute(ArgNo, Attribute::ReadOnly))
93  return false;
94  F.addParamAttr(ArgNo, Attribute::ReadOnly);
95  ++NumReadOnlyArg;
96  return true;
97 }
98 
99 static bool setRetNonNull(Function &F) {
101  "nonnull applies only to pointers");
102  if (F.hasAttribute(AttributeList::ReturnIndex, Attribute::NonNull))
103  return false;
104  F.addAttribute(AttributeList::ReturnIndex, Attribute::NonNull);
105  ++NumNonNull;
106  return true;
107 }
108 
109 static bool setReturnedArg(Function &F, unsigned ArgNo) {
110  if (F.hasParamAttribute(ArgNo, Attribute::Returned))
111  return false;
112  F.addParamAttr(ArgNo, Attribute::Returned);
113  ++NumReturnedArg;
114  return true;
115 }
116 
117 static bool setNonLazyBind(Function &F) {
118  if (F.hasFnAttribute(Attribute::NonLazyBind))
119  return false;
120  F.addFnAttr(Attribute::NonLazyBind);
121  return true;
122 }
123 
125  const TargetLibraryInfo &TLI) {
126  Function *F = M->getFunction(Name);
127  if (!F)
128  return false;
129  return inferLibFuncAttributes(*F, TLI);
130 }
131 
133  LibFunc TheLibFunc;
134  if (!(TLI.getLibFunc(F, TheLibFunc) && TLI.has(TheLibFunc)))
135  return false;
136 
137  bool Changed = false;
138 
139  if (F.getParent() != nullptr && F.getParent()->getRtLibUseGOT())
140  Changed |= setNonLazyBind(F);
141 
142  switch (TheLibFunc) {
143  case LibFunc_strlen:
144  case LibFunc_wcslen:
145  Changed |= setOnlyReadsMemory(F);
146  Changed |= setDoesNotThrow(F);
147  Changed |= setOnlyAccessesArgMemory(F);
148  Changed |= setDoesNotCapture(F, 0);
149  return Changed;
150  case LibFunc_strchr:
151  case LibFunc_strrchr:
152  Changed |= setOnlyReadsMemory(F);
153  Changed |= setDoesNotThrow(F);
154  return Changed;
155  case LibFunc_strtol:
156  case LibFunc_strtod:
157  case LibFunc_strtof:
158  case LibFunc_strtoul:
159  case LibFunc_strtoll:
160  case LibFunc_strtold:
161  case LibFunc_strtoull:
162  Changed |= setDoesNotThrow(F);
163  Changed |= setDoesNotCapture(F, 1);
164  Changed |= setOnlyReadsMemory(F, 0);
165  return Changed;
166  case LibFunc_strcpy:
167  case LibFunc_strncpy:
168  case LibFunc_strcat:
169  case LibFunc_strncat:
170  Changed |= setReturnedArg(F, 0);
172  case LibFunc_stpcpy:
173  case LibFunc_stpncpy:
174  Changed |= setDoesNotThrow(F);
175  Changed |= setDoesNotCapture(F, 1);
176  Changed |= setOnlyReadsMemory(F, 1);
177  return Changed;
178  case LibFunc_strxfrm:
179  Changed |= setDoesNotThrow(F);
180  Changed |= setDoesNotCapture(F, 0);
181  Changed |= setDoesNotCapture(F, 1);
182  Changed |= setOnlyReadsMemory(F, 1);
183  return Changed;
184  case LibFunc_strcmp: // 0,1
185  case LibFunc_strspn: // 0,1
186  case LibFunc_strncmp: // 0,1
187  case LibFunc_strcspn: // 0,1
188  case LibFunc_strcoll: // 0,1
189  case LibFunc_strcasecmp: // 0,1
190  case LibFunc_strncasecmp: //
191  Changed |= setOnlyReadsMemory(F);
192  Changed |= setDoesNotThrow(F);
193  Changed |= setDoesNotCapture(F, 0);
194  Changed |= setDoesNotCapture(F, 1);
195  return Changed;
196  case LibFunc_strstr:
197  case LibFunc_strpbrk:
198  Changed |= setOnlyReadsMemory(F);
199  Changed |= setDoesNotThrow(F);
200  Changed |= setDoesNotCapture(F, 1);
201  return Changed;
202  case LibFunc_strtok:
203  case LibFunc_strtok_r:
204  Changed |= setDoesNotThrow(F);
205  Changed |= setDoesNotCapture(F, 1);
206  Changed |= setOnlyReadsMemory(F, 1);
207  return Changed;
208  case LibFunc_scanf:
209  Changed |= setDoesNotThrow(F);
210  Changed |= setDoesNotCapture(F, 0);
211  Changed |= setOnlyReadsMemory(F, 0);
212  return Changed;
213  case LibFunc_setbuf:
214  case LibFunc_setvbuf:
215  Changed |= setDoesNotThrow(F);
216  Changed |= setDoesNotCapture(F, 0);
217  return Changed;
218  case LibFunc_strdup:
219  case LibFunc_strndup:
220  Changed |= setDoesNotThrow(F);
221  Changed |= setRetDoesNotAlias(F);
222  Changed |= setDoesNotCapture(F, 0);
223  Changed |= setOnlyReadsMemory(F, 0);
224  return Changed;
225  case LibFunc_stat:
226  case LibFunc_statvfs:
227  Changed |= setDoesNotThrow(F);
228  Changed |= setDoesNotCapture(F, 0);
229  Changed |= setDoesNotCapture(F, 1);
230  Changed |= setOnlyReadsMemory(F, 0);
231  return Changed;
232  case LibFunc_sscanf:
233  Changed |= setDoesNotThrow(F);
234  Changed |= setDoesNotCapture(F, 0);
235  Changed |= setDoesNotCapture(F, 1);
236  Changed |= setOnlyReadsMemory(F, 0);
237  Changed |= setOnlyReadsMemory(F, 1);
238  return Changed;
239  case LibFunc_sprintf:
240  Changed |= setDoesNotThrow(F);
241  Changed |= setDoesNotCapture(F, 0);
242  Changed |= setDoesNotCapture(F, 1);
243  Changed |= setOnlyReadsMemory(F, 1);
244  return Changed;
245  case LibFunc_snprintf:
246  Changed |= setDoesNotThrow(F);
247  Changed |= setDoesNotCapture(F, 0);
248  Changed |= setDoesNotCapture(F, 2);
249  Changed |= setOnlyReadsMemory(F, 2);
250  return Changed;
251  case LibFunc_setitimer:
252  Changed |= setDoesNotThrow(F);
253  Changed |= setDoesNotCapture(F, 1);
254  Changed |= setDoesNotCapture(F, 2);
255  Changed |= setOnlyReadsMemory(F, 1);
256  return Changed;
257  case LibFunc_system:
258  // May throw; "system" is a valid pthread cancellation point.
259  Changed |= setDoesNotCapture(F, 0);
260  Changed |= setOnlyReadsMemory(F, 0);
261  return Changed;
262  case LibFunc_malloc:
263  Changed |= setDoesNotThrow(F);
264  Changed |= setRetDoesNotAlias(F);
265  return Changed;
266  case LibFunc_memcmp:
267  Changed |= setOnlyReadsMemory(F);
268  Changed |= setDoesNotThrow(F);
269  Changed |= setDoesNotCapture(F, 0);
270  Changed |= setDoesNotCapture(F, 1);
271  return Changed;
272  case LibFunc_memchr:
273  case LibFunc_memrchr:
274  Changed |= setOnlyReadsMemory(F);
275  Changed |= setDoesNotThrow(F);
276  return Changed;
277  case LibFunc_modf:
278  case LibFunc_modff:
279  case LibFunc_modfl:
280  Changed |= setDoesNotThrow(F);
281  Changed |= setDoesNotCapture(F, 1);
282  return Changed;
283  case LibFunc_memcpy:
284  case LibFunc_memmove:
285  Changed |= setReturnedArg(F, 0);
287  case LibFunc_mempcpy:
288  case LibFunc_memccpy:
289  Changed |= setDoesNotThrow(F);
290  Changed |= setDoesNotCapture(F, 1);
291  Changed |= setOnlyReadsMemory(F, 1);
292  return Changed;
293  case LibFunc_memcpy_chk:
294  Changed |= setDoesNotThrow(F);
295  return Changed;
296  case LibFunc_memalign:
297  Changed |= setRetDoesNotAlias(F);
298  return Changed;
299  case LibFunc_mkdir:
300  Changed |= setDoesNotThrow(F);
301  Changed |= setDoesNotCapture(F, 0);
302  Changed |= setOnlyReadsMemory(F, 0);
303  return Changed;
304  case LibFunc_mktime:
305  Changed |= setDoesNotThrow(F);
306  Changed |= setDoesNotCapture(F, 0);
307  return Changed;
308  case LibFunc_realloc:
309  Changed |= setDoesNotThrow(F);
310  Changed |= setRetDoesNotAlias(F);
311  Changed |= setDoesNotCapture(F, 0);
312  return Changed;
313  case LibFunc_read:
314  // May throw; "read" is a valid pthread cancellation point.
315  Changed |= setDoesNotCapture(F, 1);
316  return Changed;
317  case LibFunc_rewind:
318  Changed |= setDoesNotThrow(F);
319  Changed |= setDoesNotCapture(F, 0);
320  return Changed;
321  case LibFunc_rmdir:
322  case LibFunc_remove:
323  case LibFunc_realpath:
324  Changed |= setDoesNotThrow(F);
325  Changed |= setDoesNotCapture(F, 0);
326  Changed |= setOnlyReadsMemory(F, 0);
327  return Changed;
328  case LibFunc_rename:
329  Changed |= setDoesNotThrow(F);
330  Changed |= setDoesNotCapture(F, 0);
331  Changed |= setDoesNotCapture(F, 1);
332  Changed |= setOnlyReadsMemory(F, 0);
333  Changed |= setOnlyReadsMemory(F, 1);
334  return Changed;
335  case LibFunc_readlink:
336  Changed |= setDoesNotThrow(F);
337  Changed |= setDoesNotCapture(F, 0);
338  Changed |= setDoesNotCapture(F, 1);
339  Changed |= setOnlyReadsMemory(F, 0);
340  return Changed;
341  case LibFunc_write:
342  // May throw; "write" is a valid pthread cancellation point.
343  Changed |= setDoesNotCapture(F, 1);
344  Changed |= setOnlyReadsMemory(F, 1);
345  return Changed;
346  case LibFunc_bcopy:
347  Changed |= setDoesNotThrow(F);
348  Changed |= setDoesNotCapture(F, 0);
349  Changed |= setDoesNotCapture(F, 1);
350  Changed |= setOnlyReadsMemory(F, 0);
351  return Changed;
352  case LibFunc_bcmp:
353  Changed |= setDoesNotThrow(F);
354  Changed |= setOnlyReadsMemory(F);
355  Changed |= setDoesNotCapture(F, 0);
356  Changed |= setDoesNotCapture(F, 1);
357  return Changed;
358  case LibFunc_bzero:
359  Changed |= setDoesNotThrow(F);
360  Changed |= setDoesNotCapture(F, 0);
361  return Changed;
362  case LibFunc_calloc:
363  Changed |= setDoesNotThrow(F);
364  Changed |= setRetDoesNotAlias(F);
365  return Changed;
366  case LibFunc_chmod:
367  case LibFunc_chown:
368  Changed |= setDoesNotThrow(F);
369  Changed |= setDoesNotCapture(F, 0);
370  Changed |= setOnlyReadsMemory(F, 0);
371  return Changed;
372  case LibFunc_ctermid:
373  case LibFunc_clearerr:
374  case LibFunc_closedir:
375  Changed |= setDoesNotThrow(F);
376  Changed |= setDoesNotCapture(F, 0);
377  return Changed;
378  case LibFunc_atoi:
379  case LibFunc_atol:
380  case LibFunc_atof:
381  case LibFunc_atoll:
382  Changed |= setDoesNotThrow(F);
383  Changed |= setOnlyReadsMemory(F);
384  Changed |= setDoesNotCapture(F, 0);
385  return Changed;
386  case LibFunc_access:
387  Changed |= setDoesNotThrow(F);
388  Changed |= setDoesNotCapture(F, 0);
389  Changed |= setOnlyReadsMemory(F, 0);
390  return Changed;
391  case LibFunc_fopen:
392  Changed |= setDoesNotThrow(F);
393  Changed |= setRetDoesNotAlias(F);
394  Changed |= setDoesNotCapture(F, 0);
395  Changed |= setDoesNotCapture(F, 1);
396  Changed |= setOnlyReadsMemory(F, 0);
397  Changed |= setOnlyReadsMemory(F, 1);
398  return Changed;
399  case LibFunc_fdopen:
400  Changed |= setDoesNotThrow(F);
401  Changed |= setRetDoesNotAlias(F);
402  Changed |= setDoesNotCapture(F, 1);
403  Changed |= setOnlyReadsMemory(F, 1);
404  return Changed;
405  case LibFunc_feof:
406  case LibFunc_free:
407  case LibFunc_fseek:
408  case LibFunc_ftell:
409  case LibFunc_fgetc:
410  case LibFunc_fgetc_unlocked:
411  case LibFunc_fseeko:
412  case LibFunc_ftello:
413  case LibFunc_fileno:
414  case LibFunc_fflush:
415  case LibFunc_fclose:
416  case LibFunc_fsetpos:
417  case LibFunc_flockfile:
418  case LibFunc_funlockfile:
419  case LibFunc_ftrylockfile:
420  Changed |= setDoesNotThrow(F);
421  Changed |= setDoesNotCapture(F, 0);
422  return Changed;
423  case LibFunc_ferror:
424  Changed |= setDoesNotThrow(F);
425  Changed |= setDoesNotCapture(F, 0);
426  Changed |= setOnlyReadsMemory(F);
427  return Changed;
428  case LibFunc_fputc:
429  case LibFunc_fputc_unlocked:
430  case LibFunc_fstat:
431  case LibFunc_frexp:
432  case LibFunc_frexpf:
433  case LibFunc_frexpl:
434  case LibFunc_fstatvfs:
435  Changed |= setDoesNotThrow(F);
436  Changed |= setDoesNotCapture(F, 1);
437  return Changed;
438  case LibFunc_fgets:
439  case LibFunc_fgets_unlocked:
440  Changed |= setDoesNotThrow(F);
441  Changed |= setDoesNotCapture(F, 2);
442  return Changed;
443  case LibFunc_fread:
444  case LibFunc_fread_unlocked:
445  Changed |= setDoesNotThrow(F);
446  Changed |= setDoesNotCapture(F, 0);
447  Changed |= setDoesNotCapture(F, 3);
448  return Changed;
449  case LibFunc_fwrite:
450  case LibFunc_fwrite_unlocked:
451  Changed |= setDoesNotThrow(F);
452  Changed |= setDoesNotCapture(F, 0);
453  Changed |= setDoesNotCapture(F, 3);
454  // FIXME: readonly #1?
455  return Changed;
456  case LibFunc_fputs:
457  case LibFunc_fputs_unlocked:
458  Changed |= setDoesNotThrow(F);
459  Changed |= setDoesNotCapture(F, 0);
460  Changed |= setDoesNotCapture(F, 1);
461  Changed |= setOnlyReadsMemory(F, 0);
462  return Changed;
463  case LibFunc_fscanf:
464  case LibFunc_fprintf:
465  Changed |= setDoesNotThrow(F);
466  Changed |= setDoesNotCapture(F, 0);
467  Changed |= setDoesNotCapture(F, 1);
468  Changed |= setOnlyReadsMemory(F, 1);
469  return Changed;
470  case LibFunc_fgetpos:
471  Changed |= setDoesNotThrow(F);
472  Changed |= setDoesNotCapture(F, 0);
473  Changed |= setDoesNotCapture(F, 1);
474  return Changed;
475  case LibFunc_getc:
476  case LibFunc_getlogin_r:
477  case LibFunc_getc_unlocked:
478  Changed |= setDoesNotThrow(F);
479  Changed |= setDoesNotCapture(F, 0);
480  return Changed;
481  case LibFunc_getenv:
482  Changed |= setDoesNotThrow(F);
483  Changed |= setOnlyReadsMemory(F);
484  Changed |= setDoesNotCapture(F, 0);
485  return Changed;
486  case LibFunc_gets:
487  case LibFunc_getchar:
488  case LibFunc_getchar_unlocked:
489  Changed |= setDoesNotThrow(F);
490  return Changed;
491  case LibFunc_getitimer:
492  Changed |= setDoesNotThrow(F);
493  Changed |= setDoesNotCapture(F, 1);
494  return Changed;
495  case LibFunc_getpwnam:
496  Changed |= setDoesNotThrow(F);
497  Changed |= setDoesNotCapture(F, 0);
498  Changed |= setOnlyReadsMemory(F, 0);
499  return Changed;
500  case LibFunc_ungetc:
501  Changed |= setDoesNotThrow(F);
502  Changed |= setDoesNotCapture(F, 1);
503  return Changed;
504  case LibFunc_uname:
505  Changed |= setDoesNotThrow(F);
506  Changed |= setDoesNotCapture(F, 0);
507  return Changed;
508  case LibFunc_unlink:
509  Changed |= setDoesNotThrow(F);
510  Changed |= setDoesNotCapture(F, 0);
511  Changed |= setOnlyReadsMemory(F, 0);
512  return Changed;
513  case LibFunc_unsetenv:
514  Changed |= setDoesNotThrow(F);
515  Changed |= setDoesNotCapture(F, 0);
516  Changed |= setOnlyReadsMemory(F, 0);
517  return Changed;
518  case LibFunc_utime:
519  case LibFunc_utimes:
520  Changed |= setDoesNotThrow(F);
521  Changed |= setDoesNotCapture(F, 0);
522  Changed |= setDoesNotCapture(F, 1);
523  Changed |= setOnlyReadsMemory(F, 0);
524  Changed |= setOnlyReadsMemory(F, 1);
525  return Changed;
526  case LibFunc_putc:
527  case LibFunc_putc_unlocked:
528  Changed |= setDoesNotThrow(F);
529  Changed |= setDoesNotCapture(F, 1);
530  return Changed;
531  case LibFunc_puts:
532  case LibFunc_printf:
533  case LibFunc_perror:
534  Changed |= setDoesNotThrow(F);
535  Changed |= setDoesNotCapture(F, 0);
536  Changed |= setOnlyReadsMemory(F, 0);
537  return Changed;
538  case LibFunc_pread:
539  // May throw; "pread" is a valid pthread cancellation point.
540  Changed |= setDoesNotCapture(F, 1);
541  return Changed;
542  case LibFunc_pwrite:
543  // May throw; "pwrite" is a valid pthread cancellation point.
544  Changed |= setDoesNotCapture(F, 1);
545  Changed |= setOnlyReadsMemory(F, 1);
546  return Changed;
547  case LibFunc_putchar:
548  case LibFunc_putchar_unlocked:
549  Changed |= setDoesNotThrow(F);
550  return Changed;
551  case LibFunc_popen:
552  Changed |= setDoesNotThrow(F);
553  Changed |= setRetDoesNotAlias(F);
554  Changed |= setDoesNotCapture(F, 0);
555  Changed |= setDoesNotCapture(F, 1);
556  Changed |= setOnlyReadsMemory(F, 0);
557  Changed |= setOnlyReadsMemory(F, 1);
558  return Changed;
559  case LibFunc_pclose:
560  Changed |= setDoesNotThrow(F);
561  Changed |= setDoesNotCapture(F, 0);
562  return Changed;
563  case LibFunc_vscanf:
564  Changed |= setDoesNotThrow(F);
565  Changed |= setDoesNotCapture(F, 0);
566  Changed |= setOnlyReadsMemory(F, 0);
567  return Changed;
568  case LibFunc_vsscanf:
569  Changed |= setDoesNotThrow(F);
570  Changed |= setDoesNotCapture(F, 0);
571  Changed |= setDoesNotCapture(F, 1);
572  Changed |= setOnlyReadsMemory(F, 0);
573  Changed |= setOnlyReadsMemory(F, 1);
574  return Changed;
575  case LibFunc_vfscanf:
576  Changed |= setDoesNotThrow(F);
577  Changed |= setDoesNotCapture(F, 0);
578  Changed |= setDoesNotCapture(F, 1);
579  Changed |= setOnlyReadsMemory(F, 1);
580  return Changed;
581  case LibFunc_valloc:
582  Changed |= setDoesNotThrow(F);
583  Changed |= setRetDoesNotAlias(F);
584  return Changed;
585  case LibFunc_vprintf:
586  Changed |= setDoesNotThrow(F);
587  Changed |= setDoesNotCapture(F, 0);
588  Changed |= setOnlyReadsMemory(F, 0);
589  return Changed;
590  case LibFunc_vfprintf:
591  case LibFunc_vsprintf:
592  Changed |= setDoesNotThrow(F);
593  Changed |= setDoesNotCapture(F, 0);
594  Changed |= setDoesNotCapture(F, 1);
595  Changed |= setOnlyReadsMemory(F, 1);
596  return Changed;
597  case LibFunc_vsnprintf:
598  Changed |= setDoesNotThrow(F);
599  Changed |= setDoesNotCapture(F, 0);
600  Changed |= setDoesNotCapture(F, 2);
601  Changed |= setOnlyReadsMemory(F, 2);
602  return Changed;
603  case LibFunc_open:
604  // May throw; "open" is a valid pthread cancellation point.
605  Changed |= setDoesNotCapture(F, 0);
606  Changed |= setOnlyReadsMemory(F, 0);
607  return Changed;
608  case LibFunc_opendir:
609  Changed |= setDoesNotThrow(F);
610  Changed |= setRetDoesNotAlias(F);
611  Changed |= setDoesNotCapture(F, 0);
612  Changed |= setOnlyReadsMemory(F, 0);
613  return Changed;
614  case LibFunc_tmpfile:
615  Changed |= setDoesNotThrow(F);
616  Changed |= setRetDoesNotAlias(F);
617  return Changed;
618  case LibFunc_times:
619  Changed |= setDoesNotThrow(F);
620  Changed |= setDoesNotCapture(F, 0);
621  return Changed;
622  case LibFunc_htonl:
623  case LibFunc_htons:
624  case LibFunc_ntohl:
625  case LibFunc_ntohs:
626  Changed |= setDoesNotThrow(F);
627  Changed |= setDoesNotAccessMemory(F);
628  return Changed;
629  case LibFunc_lstat:
630  Changed |= setDoesNotThrow(F);
631  Changed |= setDoesNotCapture(F, 0);
632  Changed |= setDoesNotCapture(F, 1);
633  Changed |= setOnlyReadsMemory(F, 0);
634  return Changed;
635  case LibFunc_lchown:
636  Changed |= setDoesNotThrow(F);
637  Changed |= setDoesNotCapture(F, 0);
638  Changed |= setOnlyReadsMemory(F, 0);
639  return Changed;
640  case LibFunc_qsort:
641  // May throw; places call through function pointer.
642  Changed |= setDoesNotCapture(F, 3);
643  return Changed;
644  case LibFunc_dunder_strdup:
645  case LibFunc_dunder_strndup:
646  Changed |= setDoesNotThrow(F);
647  Changed |= setRetDoesNotAlias(F);
648  Changed |= setDoesNotCapture(F, 0);
649  Changed |= setOnlyReadsMemory(F, 0);
650  return Changed;
651  case LibFunc_dunder_strtok_r:
652  Changed |= setDoesNotThrow(F);
653  Changed |= setDoesNotCapture(F, 1);
654  Changed |= setOnlyReadsMemory(F, 1);
655  return Changed;
656  case LibFunc_under_IO_getc:
657  Changed |= setDoesNotThrow(F);
658  Changed |= setDoesNotCapture(F, 0);
659  return Changed;
660  case LibFunc_under_IO_putc:
661  Changed |= setDoesNotThrow(F);
662  Changed |= setDoesNotCapture(F, 1);
663  return Changed;
664  case LibFunc_dunder_isoc99_scanf:
665  Changed |= setDoesNotThrow(F);
666  Changed |= setDoesNotCapture(F, 0);
667  Changed |= setOnlyReadsMemory(F, 0);
668  return Changed;
669  case LibFunc_stat64:
670  case LibFunc_lstat64:
671  case LibFunc_statvfs64:
672  Changed |= setDoesNotThrow(F);
673  Changed |= setDoesNotCapture(F, 0);
674  Changed |= setDoesNotCapture(F, 1);
675  Changed |= setOnlyReadsMemory(F, 0);
676  return Changed;
677  case LibFunc_dunder_isoc99_sscanf:
678  Changed |= setDoesNotThrow(F);
679  Changed |= setDoesNotCapture(F, 0);
680  Changed |= setDoesNotCapture(F, 1);
681  Changed |= setOnlyReadsMemory(F, 0);
682  Changed |= setOnlyReadsMemory(F, 1);
683  return Changed;
684  case LibFunc_fopen64:
685  Changed |= setDoesNotThrow(F);
686  Changed |= setRetDoesNotAlias(F);
687  Changed |= setDoesNotCapture(F, 0);
688  Changed |= setDoesNotCapture(F, 1);
689  Changed |= setOnlyReadsMemory(F, 0);
690  Changed |= setOnlyReadsMemory(F, 1);
691  return Changed;
692  case LibFunc_fseeko64:
693  case LibFunc_ftello64:
694  Changed |= setDoesNotThrow(F);
695  Changed |= setDoesNotCapture(F, 0);
696  return Changed;
697  case LibFunc_tmpfile64:
698  Changed |= setDoesNotThrow(F);
699  Changed |= setRetDoesNotAlias(F);
700  return Changed;
701  case LibFunc_fstat64:
702  case LibFunc_fstatvfs64:
703  Changed |= setDoesNotThrow(F);
704  Changed |= setDoesNotCapture(F, 1);
705  return Changed;
706  case LibFunc_open64:
707  // May throw; "open" is a valid pthread cancellation point.
708  Changed |= setDoesNotCapture(F, 0);
709  Changed |= setOnlyReadsMemory(F, 0);
710  return Changed;
711  case LibFunc_gettimeofday:
712  // Currently some platforms have the restrict keyword on the arguments to
713  // gettimeofday. To be conservative, do not add noalias to gettimeofday's
714  // arguments.
715  Changed |= setDoesNotThrow(F);
716  Changed |= setDoesNotCapture(F, 0);
717  Changed |= setDoesNotCapture(F, 1);
718  return Changed;
719  case LibFunc_Znwj: // new(unsigned int)
720  case LibFunc_Znwm: // new(unsigned long)
721  case LibFunc_Znaj: // new[](unsigned int)
722  case LibFunc_Znam: // new[](unsigned long)
723  case LibFunc_msvc_new_int: // new(unsigned int)
724  case LibFunc_msvc_new_longlong: // new(unsigned long long)
725  case LibFunc_msvc_new_array_int: // new[](unsigned int)
726  case LibFunc_msvc_new_array_longlong: // new[](unsigned long long)
727  // Operator new always returns a nonnull noalias pointer
728  Changed |= setRetNonNull(F);
729  Changed |= setRetDoesNotAlias(F);
730  return Changed;
731  // TODO: add LibFunc entries for:
732  // case LibFunc_memset_pattern4:
733  // case LibFunc_memset_pattern8:
734  case LibFunc_memset_pattern16:
735  Changed |= setOnlyAccessesArgMemory(F);
736  Changed |= setDoesNotCapture(F, 0);
737  Changed |= setDoesNotCapture(F, 1);
738  Changed |= setOnlyReadsMemory(F, 1);
739  return Changed;
740  // int __nvvm_reflect(const char *)
741  case LibFunc_nvvm_reflect:
742  Changed |= setDoesNotAccessMemory(F);
743  Changed |= setDoesNotThrow(F);
744  return Changed;
745 
746  default:
747  // FIXME: It'd be really nice to cover all the library functions we're
748  // aware of here.
749  return false;
750  }
751 }
752 
754  LibFunc DoubleFn, LibFunc FloatFn,
755  LibFunc LongDoubleFn) {
756  switch (Ty->getTypeID()) {
757  case Type::HalfTyID:
758  return false;
759  case Type::FloatTyID:
760  return TLI->has(FloatFn);
761  case Type::DoubleTyID:
762  return TLI->has(DoubleFn);
763  default:
764  return TLI->has(LongDoubleFn);
765  }
766 }
767 
769  LibFunc DoubleFn, LibFunc FloatFn,
770  LibFunc LongDoubleFn) {
771  assert(hasUnaryFloatFn(TLI, Ty, DoubleFn, FloatFn, LongDoubleFn) &&
772  "Cannot get name for unavailable function!");
773 
774  switch (Ty->getTypeID()) {
775  case Type::HalfTyID:
776  llvm_unreachable("No name for HalfTy!");
777  case Type::FloatTyID:
778  return TLI->getName(FloatFn);
779  case Type::DoubleTyID:
780  return TLI->getName(DoubleFn);
781  default:
782  return TLI->getName(LongDoubleFn);
783  }
784 }
785 
786 //- Emit LibCalls ------------------------------------------------------------//
787 
789  unsigned AS = V->getType()->getPointerAddressSpace();
790  return B.CreateBitCast(V, B.getInt8PtrTy(AS), "cstr");
791 }
792 
794  const TargetLibraryInfo *TLI) {
795  if (!TLI->has(LibFunc_strlen))
796  return nullptr;
797 
798  Module *M = B.GetInsertBlock()->getModule();
799  StringRef StrlenName = TLI->getName(LibFunc_strlen);
801  Constant *StrLen = M->getOrInsertFunction(StrlenName, DL.getIntPtrType(Context),
802  B.getInt8PtrTy());
803  inferLibFuncAttributes(M, StrlenName, *TLI);
804  CallInst *CI = B.CreateCall(StrLen, castToCStr(Ptr, B), StrlenName);
805  if (const Function *F = dyn_cast<Function>(StrLen->stripPointerCasts()))
806  CI->setCallingConv(F->getCallingConv());
807 
808  return CI;
809 }
810 
812  const TargetLibraryInfo *TLI) {
813  if (!TLI->has(LibFunc_strchr))
814  return nullptr;
815 
816  Module *M = B.GetInsertBlock()->getModule();
817  StringRef StrChrName = TLI->getName(LibFunc_strchr);
818  Type *I8Ptr = B.getInt8PtrTy();
819  Type *I32Ty = B.getInt32Ty();
820  Constant *StrChr =
821  M->getOrInsertFunction(StrChrName, I8Ptr, I8Ptr, I32Ty);
822  inferLibFuncAttributes(M, StrChrName, *TLI);
823  CallInst *CI = B.CreateCall(
824  StrChr, {castToCStr(Ptr, B), ConstantInt::get(I32Ty, C)}, StrChrName);
825  if (const Function *F = dyn_cast<Function>(StrChr->stripPointerCasts()))
826  CI->setCallingConv(F->getCallingConv());
827  return CI;
828 }
829 
831  const DataLayout &DL, const TargetLibraryInfo *TLI) {
832  if (!TLI->has(LibFunc_strncmp))
833  return nullptr;
834 
835  Module *M = B.GetInsertBlock()->getModule();
836  StringRef StrNCmpName = TLI->getName(LibFunc_strncmp);
838  Value *StrNCmp = M->getOrInsertFunction(StrNCmpName, B.getInt32Ty(),
839  B.getInt8PtrTy(), B.getInt8PtrTy(),
840  DL.getIntPtrType(Context));
841  inferLibFuncAttributes(M, StrNCmpName, *TLI);
842  CallInst *CI = B.CreateCall(
843  StrNCmp, {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, StrNCmpName);
844 
845  if (const Function *F = dyn_cast<Function>(StrNCmp->stripPointerCasts()))
846  CI->setCallingConv(F->getCallingConv());
847 
848  return CI;
849 }
850 
852  const TargetLibraryInfo *TLI, StringRef Name) {
853  if (!TLI->has(LibFunc_strcpy))
854  return nullptr;
855 
856  Module *M = B.GetInsertBlock()->getModule();
857  Type *I8Ptr = B.getInt8PtrTy();
858  Value *StrCpy = M->getOrInsertFunction(Name, I8Ptr, I8Ptr, I8Ptr);
859  inferLibFuncAttributes(M, Name, *TLI);
860  CallInst *CI =
861  B.CreateCall(StrCpy, {castToCStr(Dst, B), castToCStr(Src, B)}, Name);
862  if (const Function *F = dyn_cast<Function>(StrCpy->stripPointerCasts()))
863  CI->setCallingConv(F->getCallingConv());
864  return CI;
865 }
866 
868  const TargetLibraryInfo *TLI, StringRef Name) {
869  if (!TLI->has(LibFunc_strncpy))
870  return nullptr;
871 
872  Module *M = B.GetInsertBlock()->getModule();
873  Type *I8Ptr = B.getInt8PtrTy();
874  Value *StrNCpy = M->getOrInsertFunction(Name, I8Ptr, I8Ptr, I8Ptr,
875  Len->getType());
876  inferLibFuncAttributes(M, Name, *TLI);
877  CallInst *CI = B.CreateCall(
878  StrNCpy, {castToCStr(Dst, B), castToCStr(Src, B), Len}, Name);
879  if (const Function *F = dyn_cast<Function>(StrNCpy->stripPointerCasts()))
880  CI->setCallingConv(F->getCallingConv());
881  return CI;
882 }
883 
884 Value *llvm::emitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize,
885  IRBuilder<> &B, const DataLayout &DL,
886  const TargetLibraryInfo *TLI) {
887  if (!TLI->has(LibFunc_memcpy_chk))
888  return nullptr;
889 
890  Module *M = B.GetInsertBlock()->getModule();
891  AttributeList AS;
893  Attribute::NoUnwind);
895  Value *MemCpy = M->getOrInsertFunction(
896  "__memcpy_chk", AttributeList::get(M->getContext(), AS), B.getInt8PtrTy(),
897  B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context),
898  DL.getIntPtrType(Context));
899  Dst = castToCStr(Dst, B);
900  Src = castToCStr(Src, B);
901  CallInst *CI = B.CreateCall(MemCpy, {Dst, Src, Len, ObjSize});
902  if (const Function *F = dyn_cast<Function>(MemCpy->stripPointerCasts()))
903  CI->setCallingConv(F->getCallingConv());
904  return CI;
905 }
906 
908  const DataLayout &DL, const TargetLibraryInfo *TLI) {
909  if (!TLI->has(LibFunc_memchr))
910  return nullptr;
911 
912  Module *M = B.GetInsertBlock()->getModule();
913  StringRef MemChrName = TLI->getName(LibFunc_memchr);
915  Value *MemChr = M->getOrInsertFunction(MemChrName, B.getInt8PtrTy(),
916  B.getInt8PtrTy(), B.getInt32Ty(),
917  DL.getIntPtrType(Context));
918  inferLibFuncAttributes(M, MemChrName, *TLI);
919  CallInst *CI = B.CreateCall(MemChr, {castToCStr(Ptr, B), Val, Len}, MemChrName);
920 
921  if (const Function *F = dyn_cast<Function>(MemChr->stripPointerCasts()))
922  CI->setCallingConv(F->getCallingConv());
923 
924  return CI;
925 }
926 
928  const DataLayout &DL, const TargetLibraryInfo *TLI) {
929  if (!TLI->has(LibFunc_memcmp))
930  return nullptr;
931 
932  Module *M = B.GetInsertBlock()->getModule();
933  StringRef MemCmpName = TLI->getName(LibFunc_memcmp);
935  Value *MemCmp = M->getOrInsertFunction(MemCmpName, B.getInt32Ty(),
936  B.getInt8PtrTy(), B.getInt8PtrTy(),
937  DL.getIntPtrType(Context));
938  inferLibFuncAttributes(M, MemCmpName, *TLI);
939  CallInst *CI = B.CreateCall(
940  MemCmp, {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, MemCmpName);
941 
942  if (const Function *F = dyn_cast<Function>(MemCmp->stripPointerCasts()))
943  CI->setCallingConv(F->getCallingConv());
944 
945  return CI;
946 }
947 
948 /// Append a suffix to the function name according to the type of 'Op'.
950  SmallString<20> &NameBuffer) {
951  if (!Op->getType()->isDoubleTy()) {
952  NameBuffer += Name;
953 
954  if (Op->getType()->isFloatTy())
955  NameBuffer += 'f';
956  else
957  NameBuffer += 'l';
958 
959  Name = NameBuffer;
960  }
961 }
962 
964  IRBuilder<> &B,
965  const AttributeList &Attrs) {
966  assert((Name != "") && "Must specify Name to emitUnaryFloatFnCall");
967 
968  Module *M = B.GetInsertBlock()->getModule();
969  Value *Callee = M->getOrInsertFunction(Name, Op->getType(),
970  Op->getType());
971  CallInst *CI = B.CreateCall(Callee, Op, Name);
972 
973  // The incoming attribute set may have come from a speculatable intrinsic, but
974  // is being replaced with a library call which is not allowed to be
975  // speculatable.
978  Attribute::Speculatable));
979  if (const Function *F = dyn_cast<Function>(Callee->stripPointerCasts()))
980  CI->setCallingConv(F->getCallingConv());
981 
982  return CI;
983 }
984 
986  const AttributeList &Attrs) {
987  SmallString<20> NameBuffer;
988  appendTypeSuffix(Op, Name, NameBuffer);
989 
990  return emitUnaryFloatFnCallHelper(Op, Name, B, Attrs);
991 }
992 
994  LibFunc DoubleFn, LibFunc FloatFn,
995  LibFunc LongDoubleFn, IRBuilder<> &B,
996  const AttributeList &Attrs) {
997  // Get the name of the function according to TLI.
998  StringRef Name = getUnaryFloatFn(TLI, Op->getType(),
999  DoubleFn, FloatFn, LongDoubleFn);
1000 
1001  return emitUnaryFloatFnCallHelper(Op, Name, B, Attrs);
1002 }
1003 
1005  IRBuilder<> &B, const AttributeList &Attrs) {
1006  assert((Name != "") && "Must specify Name to emitBinaryFloatFnCall");
1007 
1008  SmallString<20> NameBuffer;
1009  appendTypeSuffix(Op1, Name, NameBuffer);
1010 
1011  Module *M = B.GetInsertBlock()->getModule();
1012  Value *Callee = M->getOrInsertFunction(Name, Op1->getType(), Op1->getType(),
1013  Op2->getType());
1014  CallInst *CI = B.CreateCall(Callee, {Op1, Op2}, Name);
1015  CI->setAttributes(Attrs);
1016  if (const Function *F = dyn_cast<Function>(Callee->stripPointerCasts()))
1017  CI->setCallingConv(F->getCallingConv());
1018 
1019  return CI;
1020 }
1021 
1023  const TargetLibraryInfo *TLI) {
1024  if (!TLI->has(LibFunc_putchar))
1025  return nullptr;
1026 
1027  Module *M = B.GetInsertBlock()->getModule();
1028  StringRef PutCharName = TLI->getName(LibFunc_putchar);
1029  Value *PutChar = M->getOrInsertFunction(PutCharName, B.getInt32Ty(), B.getInt32Ty());
1030  inferLibFuncAttributes(M, PutCharName, *TLI);
1031  CallInst *CI = B.CreateCall(PutChar,
1032  B.CreateIntCast(Char,
1033  B.getInt32Ty(),
1034  /*isSigned*/true,
1035  "chari"),
1036  PutCharName);
1037 
1038  if (const Function *F = dyn_cast<Function>(PutChar->stripPointerCasts()))
1039  CI->setCallingConv(F->getCallingConv());
1040  return CI;
1041 }
1042 
1044  const TargetLibraryInfo *TLI) {
1045  if (!TLI->has(LibFunc_puts))
1046  return nullptr;
1047 
1048  Module *M = B.GetInsertBlock()->getModule();
1049  StringRef PutsName = TLI->getName(LibFunc_puts);
1050  Value *PutS =
1051  M->getOrInsertFunction(PutsName, B.getInt32Ty(), B.getInt8PtrTy());
1052  inferLibFuncAttributes(M, PutsName, *TLI);
1053  CallInst *CI = B.CreateCall(PutS, castToCStr(Str, B), PutsName);
1054  if (const Function *F = dyn_cast<Function>(PutS->stripPointerCasts()))
1055  CI->setCallingConv(F->getCallingConv());
1056  return CI;
1057 }
1058 
1060  const TargetLibraryInfo *TLI) {
1061  if (!TLI->has(LibFunc_fputc))
1062  return nullptr;
1063 
1064  Module *M = B.GetInsertBlock()->getModule();
1065  StringRef FPutcName = TLI->getName(LibFunc_fputc);
1066  Constant *F = M->getOrInsertFunction(FPutcName, B.getInt32Ty(), B.getInt32Ty(),
1067  File->getType());
1068  if (File->getType()->isPointerTy())
1069  inferLibFuncAttributes(M, FPutcName, *TLI);
1070  Char = B.CreateIntCast(Char, B.getInt32Ty(), /*isSigned*/true,
1071  "chari");
1072  CallInst *CI = B.CreateCall(F, {Char, File}, FPutcName);
1073 
1074  if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
1075  CI->setCallingConv(Fn->getCallingConv());
1076  return CI;
1077 }
1078 
1080  const TargetLibraryInfo *TLI) {
1081  if (!TLI->has(LibFunc_fputc_unlocked))
1082  return nullptr;
1083 
1084  Module *M = B.GetInsertBlock()->getModule();
1085  StringRef FPutcUnlockedName = TLI->getName(LibFunc_fputc_unlocked);
1086  Constant *F = M->getOrInsertFunction(FPutcUnlockedName, B.getInt32Ty(),
1087  B.getInt32Ty(), File->getType());
1088  if (File->getType()->isPointerTy())
1089  inferLibFuncAttributes(M, FPutcUnlockedName, *TLI);
1090  Char = B.CreateIntCast(Char, B.getInt32Ty(), /*isSigned*/ true, "chari");
1091  CallInst *CI = B.CreateCall(F, {Char, File}, FPutcUnlockedName);
1092 
1093  if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
1094  CI->setCallingConv(Fn->getCallingConv());
1095  return CI;
1096 }
1097 
1099  const TargetLibraryInfo *TLI) {
1100  if (!TLI->has(LibFunc_fputs))
1101  return nullptr;
1102 
1103  Module *M = B.GetInsertBlock()->getModule();
1104  StringRef FPutsName = TLI->getName(LibFunc_fputs);
1106  FPutsName, B.getInt32Ty(), B.getInt8PtrTy(), File->getType());
1107  if (File->getType()->isPointerTy())
1108  inferLibFuncAttributes(M, FPutsName, *TLI);
1109  CallInst *CI = B.CreateCall(F, {castToCStr(Str, B), File}, FPutsName);
1110 
1111  if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
1112  CI->setCallingConv(Fn->getCallingConv());
1113  return CI;
1114 }
1115 
1117  const TargetLibraryInfo *TLI) {
1118  if (!TLI->has(LibFunc_fputs_unlocked))
1119  return nullptr;
1120 
1121  Module *M = B.GetInsertBlock()->getModule();
1122  StringRef FPutsUnlockedName = TLI->getName(LibFunc_fputs_unlocked);
1123  Constant *F = M->getOrInsertFunction(FPutsUnlockedName, B.getInt32Ty(),
1124  B.getInt8PtrTy(), File->getType());
1125  if (File->getType()->isPointerTy())
1126  inferLibFuncAttributes(M, FPutsUnlockedName, *TLI);
1127  CallInst *CI = B.CreateCall(F, {castToCStr(Str, B), File}, FPutsUnlockedName);
1128 
1129  if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
1130  CI->setCallingConv(Fn->getCallingConv());
1131  return CI;
1132 }
1133 
1135  const DataLayout &DL, const TargetLibraryInfo *TLI) {
1136  if (!TLI->has(LibFunc_fwrite))
1137  return nullptr;
1138 
1139  Module *M = B.GetInsertBlock()->getModule();
1141  StringRef FWriteName = TLI->getName(LibFunc_fwrite);
1143  FWriteName, DL.getIntPtrType(Context), B.getInt8PtrTy(),
1144  DL.getIntPtrType(Context), DL.getIntPtrType(Context), File->getType());
1145 
1146  if (File->getType()->isPointerTy())
1147  inferLibFuncAttributes(M, FWriteName, *TLI);
1148  CallInst *CI =
1149  B.CreateCall(F, {castToCStr(Ptr, B), Size,
1150  ConstantInt::get(DL.getIntPtrType(Context), 1), File});
1151 
1152  if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
1153  CI->setCallingConv(Fn->getCallingConv());
1154  return CI;
1155 }
1156 
1158  const TargetLibraryInfo *TLI) {
1159  if (!TLI->has(LibFunc_malloc))
1160  return nullptr;
1161 
1162  Module *M = B.GetInsertBlock()->getModule();
1163  StringRef MallocName = TLI->getName(LibFunc_malloc);
1165  Value *Malloc = M->getOrInsertFunction(MallocName, B.getInt8PtrTy(),
1166  DL.getIntPtrType(Context));
1167  inferLibFuncAttributes(M, MallocName, *TLI);
1168  CallInst *CI = B.CreateCall(Malloc, Num, MallocName);
1169 
1170  if (const Function *F = dyn_cast<Function>(Malloc->stripPointerCasts()))
1171  CI->setCallingConv(F->getCallingConv());
1172 
1173  return CI;
1174 }
1175 
1177  IRBuilder<> &B, const TargetLibraryInfo &TLI) {
1178  if (!TLI.has(LibFunc_calloc))
1179  return nullptr;
1180 
1181  Module *M = B.GetInsertBlock()->getModule();
1182  StringRef CallocName = TLI.getName(LibFunc_calloc);
1183  const DataLayout &DL = M->getDataLayout();
1184  IntegerType *PtrType = DL.getIntPtrType((B.GetInsertBlock()->getContext()));
1185  Value *Calloc = M->getOrInsertFunction(CallocName, Attrs, B.getInt8PtrTy(),
1186  PtrType, PtrType);
1187  inferLibFuncAttributes(M, CallocName, TLI);
1188  CallInst *CI = B.CreateCall(Calloc, {Num, Size}, CallocName);
1189 
1190  if (const auto *F = dyn_cast<Function>(Calloc->stripPointerCasts()))
1191  CI->setCallingConv(F->getCallingConv());
1192 
1193  return CI;
1194 }
1195 
1197  IRBuilder<> &B, const DataLayout &DL,
1198  const TargetLibraryInfo *TLI) {
1199  if (!TLI->has(LibFunc_fwrite_unlocked))
1200  return nullptr;
1201 
1202  Module *M = B.GetInsertBlock()->getModule();
1204  StringRef FWriteUnlockedName = TLI->getName(LibFunc_fwrite_unlocked);
1206  FWriteUnlockedName, DL.getIntPtrType(Context), B.getInt8PtrTy(),
1207  DL.getIntPtrType(Context), DL.getIntPtrType(Context), File->getType());
1208 
1209  if (File->getType()->isPointerTy())
1210  inferLibFuncAttributes(M, FWriteUnlockedName, *TLI);
1211  CallInst *CI = B.CreateCall(F, {castToCStr(Ptr, B), Size, N, File});
1212 
1213  if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
1214  CI->setCallingConv(Fn->getCallingConv());
1215  return CI;
1216 }
1217 
1219  const TargetLibraryInfo *TLI) {
1220  if (!TLI->has(LibFunc_fgetc_unlocked))
1221  return nullptr;
1222 
1223  Module *M = B.GetInsertBlock()->getModule();
1224  StringRef FGetCUnlockedName = TLI->getName(LibFunc_fgetc_unlocked);
1225  Constant *F =
1226  M->getOrInsertFunction(FGetCUnlockedName, B.getInt32Ty(), File->getType());
1227  if (File->getType()->isPointerTy())
1228  inferLibFuncAttributes(M, FGetCUnlockedName, *TLI);
1229  CallInst *CI = B.CreateCall(F, File, FGetCUnlockedName);
1230 
1231  if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
1232  CI->setCallingConv(Fn->getCallingConv());
1233  return CI;
1234 }
1235 
1237  IRBuilder<> &B, const TargetLibraryInfo *TLI) {
1238  if (!TLI->has(LibFunc_fgets_unlocked))
1239  return nullptr;
1240 
1241  Module *M = B.GetInsertBlock()->getModule();
1242  StringRef FGetSUnlockedName = TLI->getName(LibFunc_fgets_unlocked);
1243  Constant *F =
1244  M->getOrInsertFunction(FGetSUnlockedName, B.getInt8PtrTy(),
1245  B.getInt8PtrTy(), B.getInt32Ty(), File->getType());
1246  inferLibFuncAttributes(M, FGetSUnlockedName, *TLI);
1247  CallInst *CI =
1248  B.CreateCall(F, {castToCStr(Str, B), Size, File}, FGetSUnlockedName);
1249 
1250  if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
1251  CI->setCallingConv(Fn->getCallingConv());
1252  return CI;
1253 }
1254 
1256  IRBuilder<> &B, const DataLayout &DL,
1257  const TargetLibraryInfo *TLI) {
1258  if (!TLI->has(LibFunc_fread_unlocked))
1259  return nullptr;
1260 
1261  Module *M = B.GetInsertBlock()->getModule();
1263  StringRef FReadUnlockedName = TLI->getName(LibFunc_fread_unlocked);
1265  FReadUnlockedName, DL.getIntPtrType(Context), B.getInt8PtrTy(),
1266  DL.getIntPtrType(Context), DL.getIntPtrType(Context), File->getType());
1267 
1268  if (File->getType()->isPointerTy())
1269  inferLibFuncAttributes(M, FReadUnlockedName, *TLI);
1270  CallInst *CI = B.CreateCall(F, {castToCStr(Ptr, B), Size, N, File});
1271 
1272  if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
1273  CI->setCallingConv(Fn->getCallingConv());
1274  return CI;
1275 }
bool onlyReadsMemory() const
Determine if the function does not access or only reads memory.
Definition: Function.h:468
uint64_t CallInst * C
static bool setReturnedArg(Function &F, unsigned ArgNo)
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:111
static bool setDoesNotCapture(Function &F, unsigned ArgNo)
LLVMContext & Context
LLVMContext & getContext() const
Definition: IRBuilder.h:123
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
Constant * getOrInsertFunction(StringRef Name, FunctionType *T, AttributeList AttributeList)
Look up the specified function in the module symbol table.
Definition: Module.cpp:143
void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind)
adds the attribute to the list of attributes for the given arg.
Definition: Function.cpp:387
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:64
#define LLVM_FALLTHROUGH
Definition: Compiler.h:86
2: 32-bit floating point type
Definition: Type.h:59
This class represents a function call, abstracting a target machine&#39;s calling convention.
The two locations do not alias at all.
Definition: AliasAnalysis.h:85
StringRef getName(LibFunc F) const
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.h:321
STATISTIC(NumFunctions, "Total number of functions")
F(f)
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
Definition: DerivedTypes.h:503
1: 16-bit floating point type
Definition: Type.h:58
Value * emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilder<> &B, const TargetLibraryInfo *TLI, StringRef Name="strncpy")
Emit a call to the strncpy function to the builder, for the specified pointer arguments and length...
Value * emitFPutSUnlocked(Value *Str, Value *File, IRBuilder<> &B, const TargetLibraryInfo *TLI)
Emit a call to the fputs_unlocked function.
LLVMContext & getContext() const
Get the context in which this basic block lives.
Definition: BasicBlock.cpp:33
Value * emitMalloc(Value *Num, IRBuilder<> &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the malloc function.
StringRef getUnaryFloatFn(const TargetLibraryInfo *TLI, Type *Ty, LibFunc DoubleFn, LibFunc FloatFn, LibFunc LongDoubleFn)
Get the name of the overloaded unary floating point function corresponding to Ty. ...
static bool setRetDoesNotAlias(Function &F)
void setDoesNotThrow()
Definition: Function.h:523
IntegerType * getInt32Ty()
Fetch the type representing a 32-bit integer.
Definition: IRBuilder.h:347
const Module * getModule() const
Return the module owning the function this basic block belongs to, or nullptr if the function does no...
Definition: BasicBlock.cpp:134
amdgpu Simplify well known AMD library false Value Value const Twine & Name
const DataLayout & getDataLayout() const
Get the data layout for the module&#39;s target platform.
Definition: Module.cpp:364
static bool setNonLazyBind(Function &F)
TypeID getTypeID() const
Return the type id for the type.
Definition: Type.h:138
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:243
Value * emitPutChar(Value *Char, IRBuilder<> &B, const TargetLibraryInfo *TLI)
Emit a call to the putchar function. This assumes that Char is an integer.
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Definition: IRBuilder.h:743
bool hasParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const
check if an attributes is in the list of attributes.
Definition: Function.h:398
Value * emitUnaryFloatFnCall(Value *Op, StringRef Name, IRBuilder<> &B, const AttributeList &Attrs)
Emit a call to the unary function named &#39;Name&#39; (e.g.
Value * emitFPutCUnlocked(Value *Char, Value *File, IRBuilder<> &B, const TargetLibraryInfo *TLI)
Emit a call to the fputc_unlocked function.
static Value * emitUnaryFloatFnCallHelper(Value *Op, StringRef Name, IRBuilder<> &B, const AttributeList &Attrs)
Value * CreateBitCast(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:1641
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:245
static bool setDoesNotThrow(Function &F)
BasicBlock * GetInsertBlock() const
Definition: IRBuilder.h:121
Value * emitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize, IRBuilder<> &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the __memcpy_chk function to the builder.
bool hasAttribute(unsigned i, Attribute::AttrKind Kind) const
check if an attributes is in the list of attributes.
Definition: Function.h:393
void setAttributes(AttributeList A)
Set the parameter attributes for this call.
bool has(LibFunc F) const
Tests whether a library function is available.
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:26
Value * emitStrCpy(Value *Dst, Value *Src, IRBuilder<> &B, const TargetLibraryInfo *TLI, StringRef Name="strcpy")
Emit a call to the strcpy function to the builder, for the specified pointer arguments.
constexpr char Attrs[]
Key for Kernel::Metadata::mAttrs.
amdgpu Simplify well known AMD library false Value * Callee
void setOnlyAccessesArgMemory()
Definition: Function.h:488
bool doesNotAccessMemory() const
Determine if the function does not access memory.
Definition: Function.h:460
Value * emitFPutS(Value *Str, Value *File, IRBuilder<> &B, const TargetLibraryInfo *TLI)
Emit a call to the fputs function.
bool isFloatTy() const
Return true if this is &#39;float&#39;, a 32-bit IEEE fp type.
Definition: Type.h:147
IntegerType * getIntPtrType(LLVMContext &C, unsigned AddressSpace=0) const
Returns an integer type with size at least as big as that of a pointer in the given address space...
Definition: DataLayout.cpp:742
bool inferLibFuncAttributes(Function &F, const TargetLibraryInfo &TLI)
Analyze the name and prototype of the given function and set any applicable attributes.
Type * getReturnType() const
Returns the type of the ret val.
Definition: Function.h:169
void setOnlyReadsMemory()
Definition: Function.h:471
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static void appendTypeSuffix(Value *Op, StringRef &Name, SmallString< 20 > &NameBuffer)
Append a suffix to the function name according to the type of &#39;Op&#39;.
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:69
This is an important base class in LLVM.
Definition: Constant.h:42
This file contains the declarations for the subclasses of Constant, which represent the different fla...
bool isPointerTy() const
True if this is an instance of PointerType.
Definition: Type.h:224
static bool setOnlyReadsMemory(Function &F)
void addAttribute(unsigned i, Attribute::AttrKind Kind)
adds the attribute to the list of attributes.
Definition: Function.cpp:369
Class to represent integer types.
Definition: DerivedTypes.h:40
Value * castToCStr(Value *V, IRBuilder<> &B)
Return V if it is an i8*, otherwise cast it to i8*.
static bool setDoesNotAccessMemory(Function &F)
const Constant * stripPointerCasts() const
Definition: Constant.h:173
static bool setRetNonNull(Function &F)
const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs, and aliases.
Definition: Value.cpp:539
Value * emitStrChr(Value *Ptr, char C, IRBuilder<> &B, const TargetLibraryInfo *TLI)
Emit a call to the strchr function to the builder, for the specified pointer and character.
PointerType * getInt8PtrTy(unsigned AddrSpace=0)
Fetch the type representing a pointer to an 8-bit integer value.
Definition: IRBuilder.h:385
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
void setCallingConv(CallingConv::ID CC)
bool doesNotThrow() const
Determine if the function cannot unwind.
Definition: Function.h:520
Value * emitFWriteUnlocked(Value *Ptr, Value *Size, Value *N, Value *File, IRBuilder<> &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the fwrite_unlocked function.
Value * emitStrLen(Value *Ptr, IRBuilder<> &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the strlen function to the builder, for the specified pointer.
Value * emitBinaryFloatFnCall(Value *Op1, Value *Op2, StringRef Name, IRBuilder<> &B, const AttributeList &Attrs)
Emit a call to the binary function named &#39;Name&#39; (e.g.
Value * emitFGetCUnlocked(Value *File, IRBuilder<> &B, const TargetLibraryInfo *TLI)
Emit a call to the fgetc_unlocked function. File is a pointer to FILE.
Value * CreateIntCast(Value *V, Type *DestTy, bool isSigned, const Twine &Name="")
Definition: IRBuilder.h:1710
Module.h This file contains the declarations for the Module class.
Provides information about what library functions are available for the current target.
static Constant * get(Type *Ty, uint64_t V, bool isSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
Definition: Constants.cpp:621
Function * getFunction(StringRef Name) const
Look up the specified function in the module symbol table.
Definition: Module.cpp:175
bool getLibFunc(StringRef funcName, LibFunc &F) const
Searches for a particular function name.
bool getRtLibUseGOT() const
Returns true if PLT should be avoided for RTLib calls.
Definition: Module.cpp:541
Value * emitFPutC(Value *Char, Value *File, IRBuilder<> &B, const TargetLibraryInfo *TLI)
Emit a call to the fputc function.
Value * emitFGetSUnlocked(Value *Str, Value *Size, Value *File, IRBuilder<> &B, const TargetLibraryInfo *TLI)
Emit a call to the fgets_unlocked function.
void setDoesNotAccessMemory()
Definition: Function.h:463
Value * emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the strncmp function to the builder.
AttributeList removeAttribute(LLVMContext &C, unsigned Index, Attribute::AttrKind Kind) const
Remove the specified attribute at the specified index from this attribute list.
static bool setOnlyAccessesArgMemory(Function &F)
#define N
bool onlyAccessesArgMemory() const
Determine if the call can access memmory only using pointers based on its arguments.
Definition: Function.h:485
uint32_t Size
Definition: Profile.cpp:47
Value * emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilder<> &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the fwrite function.
3: 64-bit floating point type
Definition: Type.h:60
Value * emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the memcmp function.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Value * emitFReadUnlocked(Value *Ptr, Value *Size, Value *N, Value *File, IRBuilder<> &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the fread_unlocked function.
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:566
LLVM Value Representation.
Definition: Value.h:73
Value * emitPutS(Value *Str, IRBuilder<> &B, const TargetLibraryInfo *TLI)
Emit a call to the puts function. This assumes that Str is some pointer.
Value * emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilder<> &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the memchr function.
Value * emitCalloc(Value *Num, Value *Size, const AttributeList &Attrs, IRBuilder<> &B, const TargetLibraryInfo &TLI)
Emit a call to the calloc function.
void addFnAttr(Attribute::AttrKind Kind)
Add function attributes to this function.
Definition: Function.h:230
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
bool isDoubleTy() const
Return true if this is &#39;double&#39;, a 64-bit IEEE fp type.
Definition: Type.h:150
bool hasUnaryFloatFn(const TargetLibraryInfo *TLI, Type *Ty, LibFunc DoubleFn, LibFunc FloatFn, LibFunc LongDoubleFn)
Check whether the overloaded unary floating point function corresponding to Ty is available...
static AttributeList get(LLVMContext &C, ArrayRef< std::pair< unsigned, Attribute >> Attrs)
Create an AttributeList with the specified parameters in it.
Definition: Attributes.cpp:873
CallInst * CreateCall(Value *Callee, ArrayRef< Value *> Args=None, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:1883