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