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