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 
14 #include "llvm/ADT/SmallString.h"
15 #include "llvm/ADT/Statistic.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"
26 
27 using namespace llvm;
28 
29 #define DEBUG_TYPE "build-libcalls"
30 
31 //- Infer Attributes ---------------------------------------------------------//
32 
33 STATISTIC(NumReadNone, "Number of functions inferred as readnone");
34 STATISTIC(NumReadOnly, "Number of functions inferred as readonly");
35 STATISTIC(NumArgMemOnly, "Number of functions inferred as argmemonly");
36 STATISTIC(NumNoUnwind, "Number of functions inferred as nounwind");
37 STATISTIC(NumNoCapture, "Number of arguments inferred as nocapture");
38 STATISTIC(NumReadOnlyArg, "Number of arguments inferred as readonly");
39 STATISTIC(NumNoAlias, "Number of function returns inferred as noalias");
40 STATISTIC(NumNonNull, "Number of function returns inferred as nonnull returns");
41 STATISTIC(NumReturnedArg, "Number of arguments inferred as returned");
42 
44  if (F.doesNotAccessMemory())
45  return false;
47  ++NumReadNone;
48  return true;
49 }
50 
51 static bool setOnlyReadsMemory(Function &F) {
52  if (F.onlyReadsMemory())
53  return false;
55  ++NumReadOnly;
56  return true;
57 }
58 
60  if (F.onlyAccessesArgMemory())
61  return false;
63  ++NumArgMemOnly;
64  return true;
65 }
66 
67 static bool setDoesNotThrow(Function &F) {
68  if (F.doesNotThrow())
69  return false;
70  F.setDoesNotThrow();
71  ++NumNoUnwind;
72  return true;
73 }
74 
75 static bool setRetDoesNotAlias(Function &F) {
77  return false;
79  ++NumNoAlias;
80  return true;
81 }
82 
83 static bool setDoesNotCapture(Function &F, unsigned ArgNo) {
84  if (F.hasParamAttribute(ArgNo, Attribute::NoCapture))
85  return false;
86  F.addParamAttr(ArgNo, Attribute::NoCapture);
87  ++NumNoCapture;
88  return true;
89 }
90 
91 static bool setOnlyReadsMemory(Function &F, unsigned ArgNo) {
92  if (F.hasParamAttribute(ArgNo, Attribute::ReadOnly))
93  return false;
94  F.addParamAttr(ArgNo, Attribute::ReadOnly);
95  ++NumReadOnlyArg;
96  return true;
97 }
98 
99 static bool setRetNonNull(Function &F) {
101  "nonnull applies only to pointers");
102  if (F.hasAttribute(AttributeList::ReturnIndex, Attribute::NonNull))
103  return false;
104  F.addAttribute(AttributeList::ReturnIndex, Attribute::NonNull);
105  ++NumNonNull;
106  return true;
107 }
108 
109 static bool setReturnedArg(Function &F, unsigned ArgNo) {
110  if (F.hasParamAttribute(ArgNo, Attribute::Returned))
111  return false;
112  F.addParamAttr(ArgNo, Attribute::Returned);
113  ++NumReturnedArg;
114  return true;
115 }
116 
117 static bool setNonLazyBind(Function &F) {
118  if (F.hasFnAttribute(Attribute::NonLazyBind))
119  return false;
120  F.addFnAttr(Attribute::NonLazyBind);
121  return true;
122 }
123 
125  if (F.hasFnAttribute(Attribute::NoFree))
126  return false;
127  F.addFnAttr(Attribute::NoFree);
128  return true;
129 }
130 
132  const TargetLibraryInfo &TLI) {
133  Function *F = M->getFunction(Name);
134  if (!F)
135  return false;
136  return inferLibFuncAttributes(*F, TLI);
137 }
138 
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);
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);
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 
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 
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 
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 
824  const TargetLibraryInfo *TLI) {
826  return emitLibCall(LibFunc_strlen, DL.getIntPtrType(Context),
827  B.getInt8PtrTy(), castToCStr(Ptr, B), B, TLI);
828 }
829 
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 
839  const DataLayout &DL, const TargetLibraryInfo *TLI) {
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 
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 
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 
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 
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;
884  Attribute::NoUnwind);
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 
900  const DataLayout &DL, const TargetLibraryInfo *TLI) {
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 
909  const DataLayout &DL, const TargetLibraryInfo *TLI) {
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 
918  const DataLayout &DL, const TargetLibraryInfo *TLI) {
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 
935  ArrayRef<Value *> VariadicArgs, IRBuilder<> &B,
936  const TargetLibraryInfo *TLI) {
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 
945  ArrayRef<Value *> VariadicArgs, IRBuilder<> &B,
946  const TargetLibraryInfo *TLI) {
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 
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 
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 
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 
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 
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'.
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 
1013  IRBuilder<> &B,
1014  const AttributeList &Attrs) {
1015  assert((Name != "") && "Must specify Name to emitUnaryFloatFnCall");
1016 
1017  Module *M = B.GetInsertBlock()->getModule();
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.
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 
1036  const AttributeList &Attrs) {
1037  SmallString<20> NameBuffer;
1038  appendTypeSuffix(Op, Name, NameBuffer);
1039 
1040  return emitUnaryFloatFnCallHelper(Op, Name, B, Attrs);
1041 }
1042 
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 
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();
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 
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 
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 
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 
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 
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 
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 
1193  const DataLayout &DL, const TargetLibraryInfo *TLI) {
1194  if (!TLI->has(LibFunc_fwrite))
1195  return nullptr;
1196 
1197  Module *M = B.GetInsertBlock()->getModule();
1199  StringRef FWriteName = TLI->getName(LibFunc_fwrite);
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 
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);
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 
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 
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();
1265  StringRef FWriteUnlockedName = TLI->getName(LibFunc_fwrite_unlocked);
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 
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 
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 
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();
1327  StringRef FReadUnlockedName = TLI->getName(LibFunc_fread_unlocked);
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 }
bool onlyReadsMemory() const
Determine if the function does not access or only reads memory.
Definition: Function.h:481
uint64_t CallInst * C
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.
static bool setReturnedArg(Function &F, unsigned ArgNo)
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:110
static bool setDoesNotCapture(Function &F, unsigned ArgNo)
LLVMContext & Context
LLVMContext & getContext() const
Definition: IRBuilder.h:128
This class represents lattice values for constants.
Definition: AllocatorList.h:23
void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind)
adds the attribute to the list of attributes for the given arg.
Definition: Function.cpp:398
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:65
iterator begin() const
Definition: ArrayRef.h:136
2: 32-bit floating point type
Definition: Type.h:58
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
A handy container for a FunctionType+Callee-pointer pair, which can be passed around as a single enti...
Definition: DerivedTypes.h:165
This class represents a function call, abstracting a target machine&#39;s calling convention.
Value * emitSNPrintf(Value *Dest, Value *Size, Value *Fmt, ArrayRef< Value *> Args, IRBuilder<> &B, const TargetLibraryInfo *TLI)
Emit a call to the snprintf function.
The two locations do not alias at all.
Definition: AliasAnalysis.h:84
StringRef getName(LibFunc F) const
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.h:323
STATISTIC(NumFunctions, "Total number of functions")
F(f)
bool isLibFreeFunction(const Function *F, const LibFunc TLIFn)
isLibFreeFunction - Returns true if the function is a builtin free()
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
Definition: DerivedTypes.h:580
1: 16-bit floating point type
Definition: Type.h:57
Value * emitMemCCpy(Value *Ptr1, Value *Ptr2, Value *Val, Value *Len, IRBuilder<> &B, const TargetLibraryInfo *TLI)
Emit a call to the memccpy function.
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...
Value * emitFPutSUnlocked(Value *Str, Value *File, IRBuilder<> &B, const TargetLibraryInfo *TLI)
Emit a call to the fputs_unlocked function.
LLVMContext & getContext() const
Get the context in which this basic block lives.
Definition: BasicBlock.cpp:32
Value * emitMalloc(Value *Num, IRBuilder<> &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the malloc function.
StringRef getUnaryFloatFn(const TargetLibraryInfo *TLI, Type *Ty, LibFunc DoubleFn, LibFunc FloatFn, LibFunc LongDoubleFn)
Get the name of the overloaded unary floating point function corresponding to Ty. ...
static bool setRetDoesNotAlias(Function &F)
void setDoesNotThrow()
Definition: Function.h:536
IntegerType * getInt32Ty()
Fetch the type representing a 32-bit integer.
Definition: IRBuilder.h:383
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
const DataLayout & getDataLayout() const
Get the data layout for the module&#39;s target platform.
Definition: Module.cpp:369
static bool setNonLazyBind(Function &F)
TypeID getTypeID() const
Return the type id for the type.
Definition: Type.h:137
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:244
Value * emitPutChar(Value *Char, IRBuilder<> &B, const TargetLibraryInfo *TLI)
Emit a call to the putchar function. This assumes that Char is an integer.
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Definition: IRBuilder.h:779
bool hasParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const
check if an attributes is in the list of attributes.
Definition: Function.h:400
Value * emitStrLCpy(Value *Dest, Value *Src, Value *Size, IRBuilder<> &B, const TargetLibraryInfo *TLI)
Emit a call to the strlcpy function.
Value * emitUnaryFloatFnCall(Value *Op, StringRef Name, IRBuilder<> &B, const AttributeList &Attrs)
Emit a call to the unary function named &#39;Name&#39; (e.g.
Value * emitFPutCUnlocked(Value *Char, Value *File, IRBuilder<> &B, const TargetLibraryInfo *TLI)
Emit a call to the fputc_unlocked function.
static Value * emitUnaryFloatFnCallHelper(Value *Op, StringRef Name, IRBuilder<> &B, const AttributeList &Attrs)
Class to represent function types.
Definition: DerivedTypes.h:103
Value * CreateBitCast(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:1951
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:244
static bool setDoesNotThrow(Function &F)
BasicBlock * GetInsertBlock() const
Definition: IRBuilder.h:126
Value * emitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize, IRBuilder<> &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the __memcpy_chk function to the builder.
bool hasAttribute(unsigned i, Attribute::AttrKind Kind) const
check if an attributes is in the list of attributes.
Definition: Function.h:395
bool has(LibFunc F) const
Tests whether a library function is available.
Value * emitVSPrintf(Value *Dest, Value *Fmt, Value *VAList, IRBuilder<> &B, const TargetLibraryInfo *TLI)
Emit a call to the vsprintf function.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:32
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:25
constexpr char Attrs[]
Key for Kernel::Metadata::mAttrs.
void setOnlyAccessesArgMemory()
Definition: Function.h:501
bool doesNotAccessMemory() const
Determine if the function does not access memory.
Definition: Function.h:473
Value * emitFPutS(Value *Str, Value *File, IRBuilder<> &B, const TargetLibraryInfo *TLI)
Emit a call to the fputs function.
bool isFloatTy() const
Return true if this is &#39;float&#39;, a 32-bit IEEE fp type.
Definition: Type.h:146
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
bool inferLibFuncAttributes(Function &F, const TargetLibraryInfo &TLI)
Analyze the name and prototype of the given function and set any applicable attributes.
Type * getReturnType() const
Returns the type of the ret val.
Definition: Function.h:168
void setOnlyReadsMemory()
Definition: Function.h:484
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static void appendTypeSuffix(Value *Op, StringRef &Name, SmallString< 20 > &NameBuffer)
Append a suffix to the function name according to the type of &#39;Op&#39;.
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:64
Instrumentation for Order File
This file contains the declarations for the subclasses of Constant, which represent the different fla...
bool isPointerTy() const
True if this is an instance of PointerType.
Definition: Type.h:223
static bool setOnlyReadsMemory(Function &F)
void addAttribute(unsigned i, Attribute::AttrKind Kind)
adds the attribute to the list of attributes.
Definition: Function.cpp:380
void setCallingConv(CallingConv::ID CC)
Definition: InstrTypes.h:1348
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
Class to represent integer types.
Definition: DerivedTypes.h:40
Value * castToCStr(Value *V, IRBuilder<> &B)
Return V if it is an i8*, otherwise cast it to i8*.
static bool setDoesNotAccessMemory(Function &F)
static bool setRetNonNull(Function &F)
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.
const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs, address space casts, and aliases.
Definition: Value.cpp:535
PointerType * getInt8PtrTy(unsigned AddrSpace=0)
Fetch the type representing a pointer to an 8-bit integer value.
Definition: IRBuilder.h:421
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
bool doesNotThrow() const
Determine if the function cannot unwind.
Definition: Function.h:533
Value * emitFWriteUnlocked(Value *Ptr, Value *Size, Value *N, Value *File, IRBuilder<> &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the fwrite_unlocked function.
Value * emitStrLen(Value *Ptr, IRBuilder<> &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the strlen function to the builder, for the specified pointer.
Value * emitBinaryFloatFnCall(Value *Op1, Value *Op2, StringRef Name, IRBuilder<> &B, const AttributeList &Attrs)
Emit a call to the binary function named &#39;Name&#39; (e.g.
Value * 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...
Value * emitFGetCUnlocked(Value *File, IRBuilder<> &B, const TargetLibraryInfo *TLI)
Emit a call to the fgetc_unlocked function. File is a pointer to FILE.
Value * emitStrCat(Value *Dest, Value *Src, IRBuilder<> &B, const TargetLibraryInfo *TLI)
Emit a call to the strcat function.
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.
Value * CreateIntCast(Value *V, Type *DestTy, bool isSigned, const Twine &Name="")
Definition: IRBuilder.h:2020
Value * emitVSNPrintf(Value *Dest, Value *Size, Value *Fmt, Value *VAList, IRBuilder<> &B, const TargetLibraryInfo *TLI)
Emit a call to the vsnprintf function.
Module.h This file contains the declarations for the Module class.
Provides information about what library functions are available for the current target.
iterator end() const
Definition: ArrayRef.h:137
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
FunctionCallee getOrInsertFunction(StringRef Name, FunctionType *T, AttributeList AttributeList)
Look up the specified function in the module symbol table.
Definition: Module.cpp:143
Function * getFunction(StringRef Name) const
Look up the specified function in the module symbol table.
Definition: Module.cpp:174
amdgpu Simplify well known AMD library false FunctionCallee Callee
bool getLibFunc(StringRef funcName, LibFunc &F) const
Searches for a particular function name.
bool getRtLibUseGOT() const
Returns true if PLT should be avoided for RTLib calls.
Definition: Module.cpp:550
Value * emitFPutC(Value *Char, Value *File, IRBuilder<> &B, const TargetLibraryInfo *TLI)
Emit a call to the fputc function.
Value * emitFGetSUnlocked(Value *Str, Value *Size, Value *File, IRBuilder<> &B, const TargetLibraryInfo *TLI)
Emit a call to the fgets_unlocked function.
void setDoesNotAccessMemory()
Definition: Function.h:476
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.
LLVM_NODISCARD AttributeList removeAttribute(LLVMContext &C, unsigned Index, Attribute::AttrKind Kind) const
Remove the specified attribute at the specified index from this attribute list.
static bool setOnlyAccessesArgMemory(Function &F)
#define N
bool onlyAccessesArgMemory() const
Determine if the call can access memmory only using pointers based on its arguments.
Definition: Function.h:498
Value * emitStrLCat(Value *Dest, Value *Src, Value *Size, IRBuilder<> &B, const TargetLibraryInfo *TLI)
Emit a call to the strlcat function.
void setAttributes(AttributeList A)
Set the parameter attributes for this call.
Definition: InstrTypes.h:1370
uint32_t Size
Definition: Profile.cpp:46
CallInst * CreateCall(FunctionType *FTy, Value *Callee, ArrayRef< Value *> Args=None, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2193
Value * emitBCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the bcmp function.
Value * emitSPrintf(Value *Dest, Value *Fmt, ArrayRef< Value *> VariadicArgs, IRBuilder<> &B, const TargetLibraryInfo *TLI)
Emit a call to the sprintf function.
Value * emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilder<> &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the fwrite function.
static Value * emitLibCall(LibFunc TheLibFunc, Type *ReturnType, ArrayRef< Type *> ParamTypes, ArrayRef< Value *> Operands, IRBuilder<> &B, const TargetLibraryInfo *TLI, bool IsVaArgs=false)
3: 64-bit floating point type
Definition: Type.h:59
Value * emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the memcmp function.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Value * emitFReadUnlocked(Value *Ptr, Value *Size, Value *N, Value *File, IRBuilder<> &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the fread_unlocked function.
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:575
LLVM Value Representation.
Definition: Value.h:72
Value * emitPutS(Value *Str, IRBuilder<> &B, const TargetLibraryInfo *TLI)
Emit a call to the puts function. This assumes that Str is some pointer.
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...
#define LLVM_FALLTHROUGH
LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.
Definition: Compiler.h:250
Value * emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilder<> &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the memchr function.
Value * emitCalloc(Value *Num, Value *Size, const AttributeList &Attrs, IRBuilder<> &B, const TargetLibraryInfo &TLI)
Emit a call to the calloc function.
void addFnAttr(Attribute::AttrKind Kind)
Add function attributes to this function.
Definition: Function.h:229
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
static bool setDoesNotFreeMemory(Function &F)
bool isDoubleTy() const
Return true if this is &#39;double&#39;, a 64-bit IEEE fp type.
Definition: Type.h:149
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...
Value * emitStrNCat(Value *Dest, Value *Src, Value *Size, IRBuilder<> &B, const TargetLibraryInfo *TLI)
Emit a call to the strncat function.
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
static AttributeList get(LLVMContext &C, ArrayRef< std::pair< unsigned, Attribute >> Attrs)
Create an AttributeList with the specified parameters in it.
Definition: Attributes.cpp:973