LLVM  14.0.0git
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(NumInaccessibleMemOnly,
35  "Number of functions inferred as inaccessiblememonly");
36 STATISTIC(NumReadOnly, "Number of functions inferred as readonly");
37 STATISTIC(NumArgMemOnly, "Number of functions inferred as argmemonly");
38 STATISTIC(NumInaccessibleMemOrArgMemOnly,
39  "Number of functions inferred as inaccessiblemem_or_argmemonly");
40 STATISTIC(NumNoUnwind, "Number of functions inferred as nounwind");
41 STATISTIC(NumNoCapture, "Number of arguments inferred as nocapture");
42 STATISTIC(NumWriteOnlyArg, "Number of arguments inferred as writeonly");
43 STATISTIC(NumSExtArg, "Number of arguments inferred as signext");
44 STATISTIC(NumReadOnlyArg, "Number of arguments inferred as readonly");
45 STATISTIC(NumNoAlias, "Number of function returns inferred as noalias");
46 STATISTIC(NumNoUndef, "Number of function returns inferred as noundef returns");
47 STATISTIC(NumReturnedArg, "Number of arguments inferred as returned");
48 STATISTIC(NumWillReturn, "Number of functions inferred as willreturn");
49 
50 static bool setDoesNotAccessMemory(Function &F) {
51  if (F.doesNotAccessMemory())
52  return false;
53  F.setDoesNotAccessMemory();
54  ++NumReadNone;
55  return true;
56 }
57 
58 static bool setOnlyAccessesInaccessibleMemory(Function &F) {
59  if (F.onlyAccessesInaccessibleMemory())
60  return false;
61  F.setOnlyAccessesInaccessibleMemory();
62  ++NumInaccessibleMemOnly;
63  return true;
64 }
65 
66 static bool setOnlyReadsMemory(Function &F) {
67  if (F.onlyReadsMemory())
68  return false;
69  F.setOnlyReadsMemory();
70  ++NumReadOnly;
71  return true;
72 }
73 
74 static bool setOnlyAccessesArgMemory(Function &F) {
75  if (F.onlyAccessesArgMemory())
76  return false;
77  F.setOnlyAccessesArgMemory();
78  ++NumArgMemOnly;
79  return true;
80 }
81 
82 static bool setOnlyAccessesInaccessibleMemOrArgMem(Function &F) {
83  if (F.onlyAccessesInaccessibleMemOrArgMem())
84  return false;
85  F.setOnlyAccessesInaccessibleMemOrArgMem();
86  ++NumInaccessibleMemOrArgMemOnly;
87  return true;
88 }
89 
90 static bool setDoesNotThrow(Function &F) {
91  if (F.doesNotThrow())
92  return false;
93  F.setDoesNotThrow();
94  ++NumNoUnwind;
95  return true;
96 }
97 
98 static bool setRetDoesNotAlias(Function &F) {
99  if (F.hasRetAttribute(Attribute::NoAlias))
100  return false;
101  F.addRetAttr(Attribute::NoAlias);
102  ++NumNoAlias;
103  return true;
104 }
105 
106 static bool setDoesNotCapture(Function &F, unsigned ArgNo) {
107  if (F.hasParamAttribute(ArgNo, Attribute::NoCapture))
108  return false;
109  F.addParamAttr(ArgNo, Attribute::NoCapture);
110  ++NumNoCapture;
111  return true;
112 }
113 
114 static bool setDoesNotAlias(Function &F, unsigned ArgNo) {
115  if (F.hasParamAttribute(ArgNo, Attribute::NoAlias))
116  return false;
117  F.addParamAttr(ArgNo, Attribute::NoAlias);
118  ++NumNoAlias;
119  return true;
120 }
121 
122 static bool setOnlyReadsMemory(Function &F, unsigned ArgNo) {
123  if (F.hasParamAttribute(ArgNo, Attribute::ReadOnly))
124  return false;
125  F.addParamAttr(ArgNo, Attribute::ReadOnly);
126  ++NumReadOnlyArg;
127  return true;
128 }
129 
130 static bool setOnlyWritesMemory(Function &F, unsigned ArgNo) {
131  if (F.hasParamAttribute(ArgNo, Attribute::WriteOnly))
132  return false;
133  F.addParamAttr(ArgNo, Attribute::WriteOnly);
134  ++NumWriteOnlyArg;
135  return true;
136 }
137 
138 static bool setSignExtendedArg(Function &F, unsigned ArgNo) {
139  if (F.hasParamAttribute(ArgNo, Attribute::SExt))
140  return false;
141  F.addParamAttr(ArgNo, Attribute::SExt);
142  ++NumSExtArg;
143  return true;
144 }
145 
146 static bool setRetNoUndef(Function &F) {
147  if (!F.getReturnType()->isVoidTy() &&
148  !F.hasRetAttribute(Attribute::NoUndef)) {
149  F.addRetAttr(Attribute::NoUndef);
150  ++NumNoUndef;
151  return true;
152  }
153  return false;
154 }
155 
156 static bool setArgsNoUndef(Function &F) {
157  bool Changed = false;
158  for (unsigned ArgNo = 0; ArgNo < F.arg_size(); ++ArgNo) {
159  if (!F.hasParamAttribute(ArgNo, Attribute::NoUndef)) {
160  F.addParamAttr(ArgNo, Attribute::NoUndef);
161  ++NumNoUndef;
162  Changed = true;
163  }
164  }
165  return Changed;
166 }
167 
168 static bool setArgNoUndef(Function &F, unsigned ArgNo) {
169  if (F.hasParamAttribute(ArgNo, Attribute::NoUndef))
170  return false;
171  F.addParamAttr(ArgNo, Attribute::NoUndef);
172  ++NumNoUndef;
173  return true;
174 }
175 
176 static bool setRetAndArgsNoUndef(Function &F) {
177  return setRetNoUndef(F) | setArgsNoUndef(F);
178 }
179 
180 static bool setReturnedArg(Function &F, unsigned ArgNo) {
181  if (F.hasParamAttribute(ArgNo, Attribute::Returned))
182  return false;
183  F.addParamAttr(ArgNo, Attribute::Returned);
184  ++NumReturnedArg;
185  return true;
186 }
187 
188 static bool setNonLazyBind(Function &F) {
189  if (F.hasFnAttribute(Attribute::NonLazyBind))
190  return false;
191  F.addFnAttr(Attribute::NonLazyBind);
192  return true;
193 }
194 
195 static bool setDoesNotFreeMemory(Function &F) {
196  if (F.hasFnAttribute(Attribute::NoFree))
197  return false;
198  F.addFnAttr(Attribute::NoFree);
199  return true;
200 }
201 
202 static bool setWillReturn(Function &F) {
203  if (F.hasFnAttribute(Attribute::WillReturn))
204  return false;
205  F.addFnAttr(Attribute::WillReturn);
206  ++NumWillReturn;
207  return true;
208 }
209 
210 bool llvm::inferLibFuncAttributes(Module *M, StringRef Name,
211  const TargetLibraryInfo &TLI) {
212  Function *F = M->getFunction(Name);
213  if (!F)
214  return false;
215  return inferLibFuncAttributes(*F, TLI);
216 }
217 
218 bool llvm::inferLibFuncAttributes(Function &F, const TargetLibraryInfo &TLI) {
219  LibFunc TheLibFunc;
220  if (!(TLI.getLibFunc(F, TheLibFunc) && TLI.has(TheLibFunc)))
221  return false;
222 
223  bool Changed = false;
224 
225  if(!isLibFreeFunction(&F, TheLibFunc) && !isReallocLikeFn(&F, &TLI))
226  Changed |= setDoesNotFreeMemory(F);
227 
228  if (F.getParent() != nullptr && F.getParent()->getRtLibUseGOT())
229  Changed |= setNonLazyBind(F);
230 
231  switch (TheLibFunc) {
232  case LibFunc_strlen:
233  case LibFunc_wcslen:
234  Changed |= setOnlyReadsMemory(F);
235  Changed |= setDoesNotThrow(F);
236  Changed |= setOnlyAccessesArgMemory(F);
237  Changed |= setWillReturn(F);
238  Changed |= setDoesNotCapture(F, 0);
239  return Changed;
240  case LibFunc_strchr:
241  case LibFunc_strrchr:
242  Changed |= setOnlyAccessesArgMemory(F);
243  Changed |= setOnlyReadsMemory(F);
244  Changed |= setDoesNotThrow(F);
245  Changed |= setWillReturn(F);
246  return Changed;
247  case LibFunc_strtol:
248  case LibFunc_strtod:
249  case LibFunc_strtof:
250  case LibFunc_strtoul:
251  case LibFunc_strtoll:
252  case LibFunc_strtold:
253  case LibFunc_strtoull:
254  Changed |= setDoesNotThrow(F);
255  Changed |= setWillReturn(F);
256  Changed |= setDoesNotCapture(F, 1);
257  Changed |= setOnlyReadsMemory(F, 0);
258  return Changed;
259  case LibFunc_strcat:
260  case LibFunc_strncat:
261  Changed |= setOnlyAccessesArgMemory(F);
262  Changed |= setDoesNotThrow(F);
263  Changed |= setWillReturn(F);
264  Changed |= setReturnedArg(F, 0);
265  Changed |= setDoesNotCapture(F, 1);
266  Changed |= setOnlyReadsMemory(F, 1);
267  Changed |= setDoesNotAlias(F, 0);
268  Changed |= setDoesNotAlias(F, 1);
269  return Changed;
270  case LibFunc_strcpy:
271  case LibFunc_strncpy:
272  Changed |= setReturnedArg(F, 0);
273  LLVM_FALLTHROUGH;
274  case LibFunc_stpcpy:
275  case LibFunc_stpncpy:
276  Changed |= setOnlyAccessesArgMemory(F);
277  Changed |= setDoesNotThrow(F);
278  Changed |= setWillReturn(F);
279  Changed |= setDoesNotCapture(F, 1);
280  Changed |= setOnlyWritesMemory(F, 0);
281  Changed |= setOnlyReadsMemory(F, 1);
282  Changed |= setDoesNotAlias(F, 0);
283  Changed |= setDoesNotAlias(F, 1);
284  return Changed;
285  case LibFunc_strxfrm:
286  Changed |= setDoesNotThrow(F);
287  Changed |= setWillReturn(F);
288  Changed |= setDoesNotCapture(F, 0);
289  Changed |= setDoesNotCapture(F, 1);
290  Changed |= setOnlyReadsMemory(F, 1);
291  return Changed;
292  case LibFunc_strcmp: // 0,1
293  case LibFunc_strspn: // 0,1
294  case LibFunc_strncmp: // 0,1
295  case LibFunc_strcspn: // 0,1
296  Changed |= setDoesNotThrow(F);
297  Changed |= setOnlyAccessesArgMemory(F);
298  Changed |= setWillReturn(F);
299  Changed |= setOnlyReadsMemory(F);
300  Changed |= setDoesNotCapture(F, 0);
301  Changed |= setDoesNotCapture(F, 1);
302  return Changed;
303  case LibFunc_strcoll:
304  case LibFunc_strcasecmp: // 0,1
305  case LibFunc_strncasecmp: //
306  // Those functions may depend on the locale, which may be accessed through
307  // global memory.
308  Changed |= setOnlyReadsMemory(F);
309  Changed |= setDoesNotThrow(F);
310  Changed |= setWillReturn(F);
311  Changed |= setDoesNotCapture(F, 0);
312  Changed |= setDoesNotCapture(F, 1);
313  return Changed;
314  case LibFunc_strstr:
315  case LibFunc_strpbrk:
316  Changed |= setOnlyAccessesArgMemory(F);
317  Changed |= setOnlyReadsMemory(F);
318  Changed |= setDoesNotThrow(F);
319  Changed |= setWillReturn(F);
320  Changed |= setDoesNotCapture(F, 1);
321  return Changed;
322  case LibFunc_strtok:
323  case LibFunc_strtok_r:
324  Changed |= setDoesNotThrow(F);
325  Changed |= setWillReturn(F);
326  Changed |= setDoesNotCapture(F, 1);
327  Changed |= setOnlyReadsMemory(F, 1);
328  return Changed;
329  case LibFunc_scanf:
330  Changed |= setRetAndArgsNoUndef(F);
331  Changed |= setDoesNotThrow(F);
332  Changed |= setDoesNotCapture(F, 0);
333  Changed |= setOnlyReadsMemory(F, 0);
334  return Changed;
335  case LibFunc_setbuf:
336  case LibFunc_setvbuf:
337  Changed |= setRetAndArgsNoUndef(F);
338  Changed |= setDoesNotThrow(F);
339  Changed |= setDoesNotCapture(F, 0);
340  return Changed;
341  case LibFunc_strndup:
342  Changed |= setArgNoUndef(F, 1);
343  LLVM_FALLTHROUGH;
344  case LibFunc_strdup:
345  Changed |= setOnlyAccessesInaccessibleMemOrArgMem(F);
346  Changed |= setDoesNotThrow(F);
347  Changed |= setRetDoesNotAlias(F);
348  Changed |= setWillReturn(F);
349  Changed |= setDoesNotCapture(F, 0);
350  Changed |= setOnlyReadsMemory(F, 0);
351  return Changed;
352  case LibFunc_stat:
353  case LibFunc_statvfs:
354  Changed |= setRetAndArgsNoUndef(F);
355  Changed |= setDoesNotThrow(F);
356  Changed |= setDoesNotCapture(F, 0);
357  Changed |= setDoesNotCapture(F, 1);
358  Changed |= setOnlyReadsMemory(F, 0);
359  return Changed;
360  case LibFunc_sscanf:
361  Changed |= setRetAndArgsNoUndef(F);
362  Changed |= setDoesNotThrow(F);
363  Changed |= setDoesNotCapture(F, 0);
364  Changed |= setDoesNotCapture(F, 1);
365  Changed |= setOnlyReadsMemory(F, 0);
366  Changed |= setOnlyReadsMemory(F, 1);
367  return Changed;
368  case LibFunc_sprintf:
369  Changed |= setRetAndArgsNoUndef(F);
370  Changed |= setDoesNotThrow(F);
371  Changed |= setDoesNotCapture(F, 0);
372  Changed |= setDoesNotAlias(F, 0);
373  Changed |= setOnlyWritesMemory(F, 0);
374  Changed |= setDoesNotCapture(F, 1);
375  Changed |= setOnlyReadsMemory(F, 1);
376  return Changed;
377  case LibFunc_snprintf:
378  Changed |= setRetAndArgsNoUndef(F);
379  Changed |= setDoesNotThrow(F);
380  Changed |= setDoesNotCapture(F, 0);
381  Changed |= setDoesNotAlias(F, 0);
382  Changed |= setOnlyWritesMemory(F, 0);
383  Changed |= setDoesNotCapture(F, 2);
384  Changed |= setOnlyReadsMemory(F, 2);
385  return Changed;
386  case LibFunc_setitimer:
387  Changed |= setRetAndArgsNoUndef(F);
388  Changed |= setDoesNotThrow(F);
389  Changed |= setWillReturn(F);
390  Changed |= setDoesNotCapture(F, 1);
391  Changed |= setDoesNotCapture(F, 2);
392  Changed |= setOnlyReadsMemory(F, 1);
393  return Changed;
394  case LibFunc_system:
395  // May throw; "system" is a valid pthread cancellation point.
396  Changed |= setRetAndArgsNoUndef(F);
397  Changed |= setDoesNotCapture(F, 0);
398  Changed |= setOnlyReadsMemory(F, 0);
399  return Changed;
400  case LibFunc_malloc:
401  case LibFunc_vec_malloc:
402  Changed |= setOnlyAccessesInaccessibleMemory(F);
403  Changed |= setRetAndArgsNoUndef(F);
404  Changed |= setDoesNotThrow(F);
405  Changed |= setRetDoesNotAlias(F);
406  Changed |= setWillReturn(F);
407  return Changed;
408  case LibFunc_memcmp:
409  Changed |= setOnlyAccessesArgMemory(F);
410  Changed |= setOnlyReadsMemory(F);
411  Changed |= setDoesNotThrow(F);
412  Changed |= setWillReturn(F);
413  Changed |= setDoesNotCapture(F, 0);
414  Changed |= setDoesNotCapture(F, 1);
415  return Changed;
416  case LibFunc_memchr:
417  case LibFunc_memrchr:
418  Changed |= setDoesNotThrow(F);
419  Changed |= setOnlyAccessesArgMemory(F);
420  Changed |= setOnlyReadsMemory(F);
421  Changed |= setWillReturn(F);
422  return Changed;
423  case LibFunc_modf:
424  case LibFunc_modff:
425  case LibFunc_modfl:
426  Changed |= setDoesNotThrow(F);
427  Changed |= setWillReturn(F);
428  Changed |= setDoesNotCapture(F, 1);
429  return Changed;
430  case LibFunc_memcpy:
431  Changed |= setDoesNotThrow(F);
432  Changed |= setOnlyAccessesArgMemory(F);
433  Changed |= setWillReturn(F);
434  Changed |= setDoesNotAlias(F, 0);
435  Changed |= setReturnedArg(F, 0);
436  Changed |= setOnlyWritesMemory(F, 0);
437  Changed |= setDoesNotAlias(F, 1);
438  Changed |= setDoesNotCapture(F, 1);
439  Changed |= setOnlyReadsMemory(F, 1);
440  return Changed;
441  case LibFunc_memmove:
442  Changed |= setDoesNotThrow(F);
443  Changed |= setOnlyAccessesArgMemory(F);
444  Changed |= setWillReturn(F);
445  Changed |= setReturnedArg(F, 0);
446  Changed |= setOnlyWritesMemory(F, 0);
447  Changed |= setDoesNotCapture(F, 1);
448  Changed |= setOnlyReadsMemory(F, 1);
449  return Changed;
450  case LibFunc_mempcpy:
451  case LibFunc_memccpy:
452  Changed |= setDoesNotThrow(F);
453  Changed |= setOnlyAccessesArgMemory(F);
454  Changed |= setWillReturn(F);
455  Changed |= setDoesNotAlias(F, 0);
456  Changed |= setOnlyWritesMemory(F, 0);
457  Changed |= setDoesNotAlias(F, 1);
458  Changed |= setDoesNotCapture(F, 1);
459  Changed |= setOnlyReadsMemory(F, 1);
460  return Changed;
461  case LibFunc_memcpy_chk:
462  Changed |= setDoesNotThrow(F);
463  return Changed;
464  case LibFunc_memalign:
465  Changed |= setOnlyAccessesInaccessibleMemory(F);
466  Changed |= setRetNoUndef(F);
467  Changed |= setDoesNotThrow(F);
468  Changed |= setRetDoesNotAlias(F);
469  Changed |= setWillReturn(F);
470  return Changed;
471  case LibFunc_mkdir:
472  Changed |= setRetAndArgsNoUndef(F);
473  Changed |= setDoesNotThrow(F);
474  Changed |= setDoesNotCapture(F, 0);
475  Changed |= setOnlyReadsMemory(F, 0);
476  return Changed;
477  case LibFunc_mktime:
478  Changed |= setRetAndArgsNoUndef(F);
479  Changed |= setDoesNotThrow(F);
480  Changed |= setWillReturn(F);
481  Changed |= setDoesNotCapture(F, 0);
482  return Changed;
483  case LibFunc_realloc:
484  case LibFunc_vec_realloc:
485  Changed |= setOnlyAccessesInaccessibleMemOrArgMem(F);
486  Changed |= setRetNoUndef(F);
487  Changed |= setDoesNotThrow(F);
488  Changed |= setRetDoesNotAlias(F);
489  Changed |= setWillReturn(F);
490  Changed |= setDoesNotCapture(F, 0);
491  Changed |= setArgNoUndef(F, 1);
492  return Changed;
493  case LibFunc_reallocf:
494  Changed |= setRetNoUndef(F);
495  Changed |= setWillReturn(F);
496  Changed |= setArgNoUndef(F, 1);
497  return Changed;
498  case LibFunc_read:
499  // May throw; "read" is a valid pthread cancellation point.
500  Changed |= setRetAndArgsNoUndef(F);
501  Changed |= setDoesNotCapture(F, 1);
502  return Changed;
503  case LibFunc_rewind:
504  Changed |= setRetAndArgsNoUndef(F);
505  Changed |= setDoesNotThrow(F);
506  Changed |= setDoesNotCapture(F, 0);
507  return Changed;
508  case LibFunc_rmdir:
509  case LibFunc_remove:
510  case LibFunc_realpath:
511  Changed |= setRetAndArgsNoUndef(F);
512  Changed |= setDoesNotThrow(F);
513  Changed |= setDoesNotCapture(F, 0);
514  Changed |= setOnlyReadsMemory(F, 0);
515  return Changed;
516  case LibFunc_rename:
517  Changed |= setRetAndArgsNoUndef(F);
518  Changed |= setDoesNotThrow(F);
519  Changed |= setDoesNotCapture(F, 0);
520  Changed |= setDoesNotCapture(F, 1);
521  Changed |= setOnlyReadsMemory(F, 0);
522  Changed |= setOnlyReadsMemory(F, 1);
523  return Changed;
524  case LibFunc_readlink:
525  Changed |= setRetAndArgsNoUndef(F);
526  Changed |= setDoesNotThrow(F);
527  Changed |= setDoesNotCapture(F, 0);
528  Changed |= setDoesNotCapture(F, 1);
529  Changed |= setOnlyReadsMemory(F, 0);
530  return Changed;
531  case LibFunc_write:
532  // May throw; "write" is a valid pthread cancellation point.
533  Changed |= setRetAndArgsNoUndef(F);
534  Changed |= setDoesNotCapture(F, 1);
535  Changed |= setOnlyReadsMemory(F, 1);
536  return Changed;
537  case LibFunc_aligned_alloc:
538  Changed |= setOnlyAccessesInaccessibleMemory(F);
539  Changed |= setRetAndArgsNoUndef(F);
540  Changed |= setDoesNotThrow(F);
541  Changed |= setRetDoesNotAlias(F);
542  Changed |= setWillReturn(F);
543  return Changed;
544  case LibFunc_bcopy:
545  Changed |= setDoesNotThrow(F);
546  Changed |= setOnlyAccessesArgMemory(F);
547  Changed |= setWillReturn(F);
548  Changed |= setDoesNotCapture(F, 0);
549  Changed |= setOnlyReadsMemory(F, 0);
550  Changed |= setOnlyWritesMemory(F, 1);
551  Changed |= setDoesNotCapture(F, 1);
552  return Changed;
553  case LibFunc_bcmp:
554  Changed |= setDoesNotThrow(F);
555  Changed |= setOnlyAccessesArgMemory(F);
556  Changed |= setOnlyReadsMemory(F);
557  Changed |= setWillReturn(F);
558  Changed |= setDoesNotCapture(F, 0);
559  Changed |= setDoesNotCapture(F, 1);
560  return Changed;
561  case LibFunc_bzero:
562  Changed |= setDoesNotThrow(F);
563  Changed |= setOnlyAccessesArgMemory(F);
564  Changed |= setWillReturn(F);
565  Changed |= setDoesNotCapture(F, 0);
566  Changed |= setOnlyWritesMemory(F, 0);
567  return Changed;
568  case LibFunc_calloc:
569  case LibFunc_vec_calloc:
570  Changed |= setRetAndArgsNoUndef(F);
571  Changed |= setDoesNotThrow(F);
572  Changed |= setRetDoesNotAlias(F);
573  Changed |= setWillReturn(F);
574  return Changed;
575  case LibFunc_chmod:
576  case LibFunc_chown:
577  Changed |= setRetAndArgsNoUndef(F);
578  Changed |= setDoesNotThrow(F);
579  Changed |= setDoesNotCapture(F, 0);
580  Changed |= setOnlyReadsMemory(F, 0);
581  return Changed;
582  case LibFunc_ctermid:
583  case LibFunc_clearerr:
584  case LibFunc_closedir:
585  Changed |= setRetAndArgsNoUndef(F);
586  Changed |= setDoesNotThrow(F);
587  Changed |= setDoesNotCapture(F, 0);
588  return Changed;
589  case LibFunc_atoi:
590  case LibFunc_atol:
591  case LibFunc_atof:
592  case LibFunc_atoll:
593  Changed |= setDoesNotThrow(F);
594  Changed |= setOnlyReadsMemory(F);
595  Changed |= setWillReturn(F);
596  Changed |= setDoesNotCapture(F, 0);
597  return Changed;
598  case LibFunc_access:
599  Changed |= setRetAndArgsNoUndef(F);
600  Changed |= setDoesNotThrow(F);
601  Changed |= setDoesNotCapture(F, 0);
602  Changed |= setOnlyReadsMemory(F, 0);
603  return Changed;
604  case LibFunc_fopen:
605  Changed |= setRetAndArgsNoUndef(F);
606  Changed |= setDoesNotThrow(F);
607  Changed |= setRetDoesNotAlias(F);
608  Changed |= setDoesNotCapture(F, 0);
609  Changed |= setDoesNotCapture(F, 1);
610  Changed |= setOnlyReadsMemory(F, 0);
611  Changed |= setOnlyReadsMemory(F, 1);
612  return Changed;
613  case LibFunc_fdopen:
614  Changed |= setRetAndArgsNoUndef(F);
615  Changed |= setDoesNotThrow(F);
616  Changed |= setRetDoesNotAlias(F);
617  Changed |= setDoesNotCapture(F, 1);
618  Changed |= setOnlyReadsMemory(F, 1);
619  return Changed;
620  case LibFunc_feof:
621  Changed |= setRetAndArgsNoUndef(F);
622  Changed |= setDoesNotThrow(F);
623  Changed |= setDoesNotCapture(F, 0);
624  return Changed;
625  case LibFunc_free:
626  case LibFunc_vec_free:
627  Changed |= setOnlyAccessesInaccessibleMemOrArgMem(F);
628  Changed |= setArgsNoUndef(F);
629  Changed |= setDoesNotThrow(F);
630  Changed |= setWillReturn(F);
631  Changed |= setDoesNotCapture(F, 0);
632  return Changed;
633  case LibFunc_fseek:
634  case LibFunc_ftell:
635  case LibFunc_fgetc:
636  case LibFunc_fgetc_unlocked:
637  case LibFunc_fseeko:
638  case LibFunc_ftello:
639  case LibFunc_fileno:
640  case LibFunc_fflush:
641  case LibFunc_fclose:
642  case LibFunc_fsetpos:
643  case LibFunc_flockfile:
644  case LibFunc_funlockfile:
645  case LibFunc_ftrylockfile:
646  Changed |= setRetAndArgsNoUndef(F);
647  Changed |= setDoesNotThrow(F);
648  Changed |= setDoesNotCapture(F, 0);
649  return Changed;
650  case LibFunc_ferror:
651  Changed |= setRetAndArgsNoUndef(F);
652  Changed |= setDoesNotThrow(F);
653  Changed |= setDoesNotCapture(F, 0);
654  Changed |= setOnlyReadsMemory(F);
655  return Changed;
656  case LibFunc_fputc:
657  case LibFunc_fputc_unlocked:
658  case LibFunc_fstat:
659  Changed |= setRetAndArgsNoUndef(F);
660  Changed |= setDoesNotThrow(F);
661  Changed |= setDoesNotCapture(F, 1);
662  return Changed;
663  case LibFunc_frexp:
664  case LibFunc_frexpf:
665  case LibFunc_frexpl:
666  Changed |= setDoesNotThrow(F);
667  Changed |= setWillReturn(F);
668  Changed |= setDoesNotCapture(F, 1);
669  return Changed;
670  case LibFunc_fstatvfs:
671  Changed |= setRetAndArgsNoUndef(F);
672  Changed |= setDoesNotThrow(F);
673  Changed |= setDoesNotCapture(F, 1);
674  return Changed;
675  case LibFunc_fgets:
676  case LibFunc_fgets_unlocked:
677  Changed |= setRetAndArgsNoUndef(F);
678  Changed |= setDoesNotThrow(F);
679  Changed |= setDoesNotCapture(F, 2);
680  return Changed;
681  case LibFunc_fread:
682  case LibFunc_fread_unlocked:
683  Changed |= setRetAndArgsNoUndef(F);
684  Changed |= setDoesNotThrow(F);
685  Changed |= setDoesNotCapture(F, 0);
686  Changed |= setDoesNotCapture(F, 3);
687  return Changed;
688  case LibFunc_fwrite:
689  case LibFunc_fwrite_unlocked:
690  Changed |= setRetAndArgsNoUndef(F);
691  Changed |= setDoesNotThrow(F);
692  Changed |= setDoesNotCapture(F, 0);
693  Changed |= setDoesNotCapture(F, 3);
694  // FIXME: readonly #1?
695  return Changed;
696  case LibFunc_fputs:
697  case LibFunc_fputs_unlocked:
698  Changed |= setRetAndArgsNoUndef(F);
699  Changed |= setDoesNotThrow(F);
700  Changed |= setDoesNotCapture(F, 0);
701  Changed |= setDoesNotCapture(F, 1);
702  Changed |= setOnlyReadsMemory(F, 0);
703  return Changed;
704  case LibFunc_fscanf:
705  case LibFunc_fprintf:
706  Changed |= setRetAndArgsNoUndef(F);
707  Changed |= setDoesNotThrow(F);
708  Changed |= setDoesNotCapture(F, 0);
709  Changed |= setDoesNotCapture(F, 1);
710  Changed |= setOnlyReadsMemory(F, 1);
711  return Changed;
712  case LibFunc_fgetpos:
713  Changed |= setRetAndArgsNoUndef(F);
714  Changed |= setDoesNotThrow(F);
715  Changed |= setDoesNotCapture(F, 0);
716  Changed |= setDoesNotCapture(F, 1);
717  return Changed;
718  case LibFunc_getc:
719  Changed |= setRetAndArgsNoUndef(F);
720  Changed |= setDoesNotThrow(F);
721  Changed |= setDoesNotCapture(F, 0);
722  return Changed;
723  case LibFunc_getlogin_r:
724  Changed |= setRetAndArgsNoUndef(F);
725  Changed |= setDoesNotThrow(F);
726  Changed |= setDoesNotCapture(F, 0);
727  return Changed;
728  case LibFunc_getc_unlocked:
729  Changed |= setRetAndArgsNoUndef(F);
730  Changed |= setDoesNotThrow(F);
731  Changed |= setDoesNotCapture(F, 0);
732  return Changed;
733  case LibFunc_getenv:
734  Changed |= setRetAndArgsNoUndef(F);
735  Changed |= setDoesNotThrow(F);
736  Changed |= setOnlyReadsMemory(F);
737  Changed |= setDoesNotCapture(F, 0);
738  return Changed;
739  case LibFunc_gets:
740  case LibFunc_getchar:
741  case LibFunc_getchar_unlocked:
742  Changed |= setRetAndArgsNoUndef(F);
743  Changed |= setDoesNotThrow(F);
744  return Changed;
745  case LibFunc_getitimer:
746  Changed |= setRetAndArgsNoUndef(F);
747  Changed |= setDoesNotThrow(F);
748  Changed |= setDoesNotCapture(F, 1);
749  return Changed;
750  case LibFunc_getpwnam:
751  Changed |= setRetAndArgsNoUndef(F);
752  Changed |= setDoesNotThrow(F);
753  Changed |= setDoesNotCapture(F, 0);
754  Changed |= setOnlyReadsMemory(F, 0);
755  return Changed;
756  case LibFunc_ungetc:
757  Changed |= setRetAndArgsNoUndef(F);
758  Changed |= setDoesNotThrow(F);
759  Changed |= setDoesNotCapture(F, 1);
760  return Changed;
761  case LibFunc_uname:
762  Changed |= setRetAndArgsNoUndef(F);
763  Changed |= setDoesNotThrow(F);
764  Changed |= setDoesNotCapture(F, 0);
765  return Changed;
766  case LibFunc_unlink:
767  Changed |= setRetAndArgsNoUndef(F);
768  Changed |= setDoesNotThrow(F);
769  Changed |= setDoesNotCapture(F, 0);
770  Changed |= setOnlyReadsMemory(F, 0);
771  return Changed;
772  case LibFunc_unsetenv:
773  Changed |= setRetAndArgsNoUndef(F);
774  Changed |= setDoesNotThrow(F);
775  Changed |= setDoesNotCapture(F, 0);
776  Changed |= setOnlyReadsMemory(F, 0);
777  return Changed;
778  case LibFunc_utime:
779  case LibFunc_utimes:
780  Changed |= setRetAndArgsNoUndef(F);
781  Changed |= setDoesNotThrow(F);
782  Changed |= setDoesNotCapture(F, 0);
783  Changed |= setDoesNotCapture(F, 1);
784  Changed |= setOnlyReadsMemory(F, 0);
785  Changed |= setOnlyReadsMemory(F, 1);
786  return Changed;
787  case LibFunc_putc:
788  case LibFunc_putc_unlocked:
789  Changed |= setRetAndArgsNoUndef(F);
790  Changed |= setDoesNotThrow(F);
791  Changed |= setDoesNotCapture(F, 1);
792  return Changed;
793  case LibFunc_puts:
794  case LibFunc_printf:
795  case LibFunc_perror:
796  Changed |= setRetAndArgsNoUndef(F);
797  Changed |= setDoesNotThrow(F);
798  Changed |= setDoesNotCapture(F, 0);
799  Changed |= setOnlyReadsMemory(F, 0);
800  return Changed;
801  case LibFunc_pread:
802  // May throw; "pread" is a valid pthread cancellation point.
803  Changed |= setRetAndArgsNoUndef(F);
804  Changed |= setDoesNotCapture(F, 1);
805  return Changed;
806  case LibFunc_pwrite:
807  // May throw; "pwrite" is a valid pthread cancellation point.
808  Changed |= setRetAndArgsNoUndef(F);
809  Changed |= setDoesNotCapture(F, 1);
810  Changed |= setOnlyReadsMemory(F, 1);
811  return Changed;
812  case LibFunc_putchar:
813  case LibFunc_putchar_unlocked:
814  Changed |= setRetAndArgsNoUndef(F);
815  Changed |= setDoesNotThrow(F);
816  return Changed;
817  case LibFunc_popen:
818  Changed |= setRetAndArgsNoUndef(F);
819  Changed |= setDoesNotThrow(F);
820  Changed |= setRetDoesNotAlias(F);
821  Changed |= setDoesNotCapture(F, 0);
822  Changed |= setDoesNotCapture(F, 1);
823  Changed |= setOnlyReadsMemory(F, 0);
824  Changed |= setOnlyReadsMemory(F, 1);
825  return Changed;
826  case LibFunc_pclose:
827  Changed |= setRetAndArgsNoUndef(F);
828  Changed |= setDoesNotThrow(F);
829  Changed |= setDoesNotCapture(F, 0);
830  return Changed;
831  case LibFunc_vscanf:
832  Changed |= setRetAndArgsNoUndef(F);
833  Changed |= setDoesNotThrow(F);
834  Changed |= setDoesNotCapture(F, 0);
835  Changed |= setOnlyReadsMemory(F, 0);
836  return Changed;
837  case LibFunc_vsscanf:
838  Changed |= setRetAndArgsNoUndef(F);
839  Changed |= setDoesNotThrow(F);
840  Changed |= setDoesNotCapture(F, 0);
841  Changed |= setDoesNotCapture(F, 1);
842  Changed |= setOnlyReadsMemory(F, 0);
843  Changed |= setOnlyReadsMemory(F, 1);
844  return Changed;
845  case LibFunc_vfscanf:
846  Changed |= setRetAndArgsNoUndef(F);
847  Changed |= setDoesNotThrow(F);
848  Changed |= setDoesNotCapture(F, 0);
849  Changed |= setDoesNotCapture(F, 1);
850  Changed |= setOnlyReadsMemory(F, 1);
851  return Changed;
852  case LibFunc_valloc:
853  Changed |= setOnlyAccessesInaccessibleMemory(F);
854  Changed |= setRetAndArgsNoUndef(F);
855  Changed |= setDoesNotThrow(F);
856  Changed |= setRetDoesNotAlias(F);
857  Changed |= setWillReturn(F);
858  return Changed;
859  case LibFunc_vprintf:
860  Changed |= setRetAndArgsNoUndef(F);
861  Changed |= setDoesNotThrow(F);
862  Changed |= setDoesNotCapture(F, 0);
863  Changed |= setOnlyReadsMemory(F, 0);
864  return Changed;
865  case LibFunc_vfprintf:
866  case LibFunc_vsprintf:
867  Changed |= setRetAndArgsNoUndef(F);
868  Changed |= setDoesNotThrow(F);
869  Changed |= setDoesNotCapture(F, 0);
870  Changed |= setDoesNotCapture(F, 1);
871  Changed |= setOnlyReadsMemory(F, 1);
872  return Changed;
873  case LibFunc_vsnprintf:
874  Changed |= setRetAndArgsNoUndef(F);
875  Changed |= setDoesNotThrow(F);
876  Changed |= setDoesNotCapture(F, 0);
877  Changed |= setDoesNotCapture(F, 2);
878  Changed |= setOnlyReadsMemory(F, 2);
879  return Changed;
880  case LibFunc_open:
881  // May throw; "open" is a valid pthread cancellation point.
882  Changed |= setRetAndArgsNoUndef(F);
883  Changed |= setDoesNotCapture(F, 0);
884  Changed |= setOnlyReadsMemory(F, 0);
885  return Changed;
886  case LibFunc_opendir:
887  Changed |= setRetAndArgsNoUndef(F);
888  Changed |= setDoesNotThrow(F);
889  Changed |= setRetDoesNotAlias(F);
890  Changed |= setDoesNotCapture(F, 0);
891  Changed |= setOnlyReadsMemory(F, 0);
892  return Changed;
893  case LibFunc_tmpfile:
894  Changed |= setRetAndArgsNoUndef(F);
895  Changed |= setDoesNotThrow(F);
896  Changed |= setRetDoesNotAlias(F);
897  return Changed;
898  case LibFunc_times:
899  Changed |= setRetAndArgsNoUndef(F);
900  Changed |= setDoesNotThrow(F);
901  Changed |= setDoesNotCapture(F, 0);
902  return Changed;
903  case LibFunc_htonl:
904  case LibFunc_htons:
905  case LibFunc_ntohl:
906  case LibFunc_ntohs:
907  Changed |= setDoesNotThrow(F);
908  Changed |= setDoesNotAccessMemory(F);
909  return Changed;
910  case LibFunc_lstat:
911  Changed |= setRetAndArgsNoUndef(F);
912  Changed |= setDoesNotThrow(F);
913  Changed |= setDoesNotCapture(F, 0);
914  Changed |= setDoesNotCapture(F, 1);
915  Changed |= setOnlyReadsMemory(F, 0);
916  return Changed;
917  case LibFunc_lchown:
918  Changed |= setRetAndArgsNoUndef(F);
919  Changed |= setDoesNotThrow(F);
920  Changed |= setDoesNotCapture(F, 0);
921  Changed |= setOnlyReadsMemory(F, 0);
922  return Changed;
923  case LibFunc_qsort:
924  // May throw; places call through function pointer.
925  // Cannot give undef pointer/size
926  Changed |= setRetAndArgsNoUndef(F);
927  Changed |= setDoesNotCapture(F, 3);
928  return Changed;
929  case LibFunc_dunder_strndup:
930  Changed |= setArgNoUndef(F, 1);
931  LLVM_FALLTHROUGH;
932  case LibFunc_dunder_strdup:
933  Changed |= setDoesNotThrow(F);
934  Changed |= setRetDoesNotAlias(F);
935  Changed |= setWillReturn(F);
936  Changed |= setDoesNotCapture(F, 0);
937  Changed |= setOnlyReadsMemory(F, 0);
938  return Changed;
939  case LibFunc_dunder_strtok_r:
940  Changed |= setDoesNotThrow(F);
941  Changed |= setDoesNotCapture(F, 1);
942  Changed |= setOnlyReadsMemory(F, 1);
943  return Changed;
944  case LibFunc_under_IO_getc:
945  Changed |= setRetAndArgsNoUndef(F);
946  Changed |= setDoesNotThrow(F);
947  Changed |= setDoesNotCapture(F, 0);
948  return Changed;
949  case LibFunc_under_IO_putc:
950  Changed |= setRetAndArgsNoUndef(F);
951  Changed |= setDoesNotThrow(F);
952  Changed |= setDoesNotCapture(F, 1);
953  return Changed;
954  case LibFunc_dunder_isoc99_scanf:
955  Changed |= setRetAndArgsNoUndef(F);
956  Changed |= setDoesNotThrow(F);
957  Changed |= setDoesNotCapture(F, 0);
958  Changed |= setOnlyReadsMemory(F, 0);
959  return Changed;
960  case LibFunc_stat64:
961  case LibFunc_lstat64:
962  case LibFunc_statvfs64:
963  Changed |= setRetAndArgsNoUndef(F);
964  Changed |= setDoesNotThrow(F);
965  Changed |= setDoesNotCapture(F, 0);
966  Changed |= setDoesNotCapture(F, 1);
967  Changed |= setOnlyReadsMemory(F, 0);
968  return Changed;
969  case LibFunc_dunder_isoc99_sscanf:
970  Changed |= setRetAndArgsNoUndef(F);
971  Changed |= setDoesNotThrow(F);
972  Changed |= setDoesNotCapture(F, 0);
973  Changed |= setDoesNotCapture(F, 1);
974  Changed |= setOnlyReadsMemory(F, 0);
975  Changed |= setOnlyReadsMemory(F, 1);
976  return Changed;
977  case LibFunc_fopen64:
978  Changed |= setRetAndArgsNoUndef(F);
979  Changed |= setDoesNotThrow(F);
980  Changed |= setRetDoesNotAlias(F);
981  Changed |= setDoesNotCapture(F, 0);
982  Changed |= setDoesNotCapture(F, 1);
983  Changed |= setOnlyReadsMemory(F, 0);
984  Changed |= setOnlyReadsMemory(F, 1);
985  return Changed;
986  case LibFunc_fseeko64:
987  case LibFunc_ftello64:
988  Changed |= setRetAndArgsNoUndef(F);
989  Changed |= setDoesNotThrow(F);
990  Changed |= setDoesNotCapture(F, 0);
991  return Changed;
992  case LibFunc_tmpfile64:
993  Changed |= setRetAndArgsNoUndef(F);
994  Changed |= setDoesNotThrow(F);
995  Changed |= setRetDoesNotAlias(F);
996  return Changed;
997  case LibFunc_fstat64:
998  case LibFunc_fstatvfs64:
999  Changed |= setRetAndArgsNoUndef(F);
1000  Changed |= setDoesNotThrow(F);
1001  Changed |= setDoesNotCapture(F, 1);
1002  return Changed;
1003  case LibFunc_open64:
1004  // May throw; "open" is a valid pthread cancellation point.
1005  Changed |= setRetAndArgsNoUndef(F);
1006  Changed |= setDoesNotCapture(F, 0);
1007  Changed |= setOnlyReadsMemory(F, 0);
1008  return Changed;
1009  case LibFunc_gettimeofday:
1010  // Currently some platforms have the restrict keyword on the arguments to
1011  // gettimeofday. To be conservative, do not add noalias to gettimeofday's
1012  // arguments.
1013  Changed |= setRetAndArgsNoUndef(F);
1014  Changed |= setDoesNotThrow(F);
1015  Changed |= setDoesNotCapture(F, 0);
1016  Changed |= setDoesNotCapture(F, 1);
1017  return Changed;
1018  // TODO: add LibFunc entries for:
1019  // case LibFunc_memset_pattern4:
1020  // case LibFunc_memset_pattern8:
1021  case LibFunc_memset_pattern16:
1022  Changed |= setOnlyAccessesArgMemory(F);
1023  Changed |= setDoesNotCapture(F, 0);
1024  Changed |= setOnlyWritesMemory(F, 0);
1025  Changed |= setDoesNotCapture(F, 1);
1026  Changed |= setOnlyReadsMemory(F, 1);
1027  return Changed;
1028  case LibFunc_memset:
1029  Changed |= setOnlyAccessesArgMemory(F);
1030  Changed |= setWillReturn(F);
1031  Changed |= setDoesNotThrow(F);
1032  Changed |= setOnlyWritesMemory(F, 0);
1033  return Changed;
1034  // int __nvvm_reflect(const char *)
1035  case LibFunc_nvvm_reflect:
1036  Changed |= setRetAndArgsNoUndef(F);
1037  Changed |= setDoesNotAccessMemory(F);
1038  Changed |= setDoesNotThrow(F);
1039  return Changed;
1040  case LibFunc_ldexp:
1041  case LibFunc_ldexpf:
1042  case LibFunc_ldexpl:
1043  Changed |= setSignExtendedArg(F, 1);
1044  Changed |= setWillReturn(F);
1045  return Changed;
1046  case LibFunc_abs:
1047  case LibFunc_acos:
1048  case LibFunc_acosf:
1049  case LibFunc_acosh:
1050  case LibFunc_acoshf:
1051  case LibFunc_acoshl:
1052  case LibFunc_acosl:
1053  case LibFunc_asin:
1054  case LibFunc_asinf:
1055  case LibFunc_asinh:
1056  case LibFunc_asinhf:
1057  case LibFunc_asinhl:
1058  case LibFunc_asinl:
1059  case LibFunc_atan:
1060  case LibFunc_atan2:
1061  case LibFunc_atan2f:
1062  case LibFunc_atan2l:
1063  case LibFunc_atanf:
1064  case LibFunc_atanh:
1065  case LibFunc_atanhf:
1066  case LibFunc_atanhl:
1067  case LibFunc_atanl:
1068  case LibFunc_cbrt:
1069  case LibFunc_cbrtf:
1070  case LibFunc_cbrtl:
1071  case LibFunc_ceil:
1072  case LibFunc_ceilf:
1073  case LibFunc_ceill:
1074  case LibFunc_copysign:
1075  case LibFunc_copysignf:
1076  case LibFunc_copysignl:
1077  case LibFunc_cos:
1078  case LibFunc_cosh:
1079  case LibFunc_coshf:
1080  case LibFunc_coshl:
1081  case LibFunc_cosf:
1082  case LibFunc_cosl:
1083  case LibFunc_cospi:
1084  case LibFunc_cospif:
1085  case LibFunc_exp:
1086  case LibFunc_expf:
1087  case LibFunc_expl:
1088  case LibFunc_exp2:
1089  case LibFunc_exp2f:
1090  case LibFunc_exp2l:
1091  case LibFunc_expm1:
1092  case LibFunc_expm1f:
1093  case LibFunc_expm1l:
1094  case LibFunc_fabs:
1095  case LibFunc_fabsf:
1096  case LibFunc_fabsl:
1097  case LibFunc_ffs:
1098  case LibFunc_ffsl:
1099  case LibFunc_ffsll:
1100  case LibFunc_floor:
1101  case LibFunc_floorf:
1102  case LibFunc_floorl:
1103  case LibFunc_fls:
1104  case LibFunc_flsl:
1105  case LibFunc_flsll:
1106  case LibFunc_fmax:
1107  case LibFunc_fmaxf:
1108  case LibFunc_fmaxl:
1109  case LibFunc_fmin:
1110  case LibFunc_fminf:
1111  case LibFunc_fminl:
1112  case LibFunc_fmod:
1113  case LibFunc_fmodf:
1114  case LibFunc_fmodl:
1115  case LibFunc_isascii:
1116  case LibFunc_isdigit:
1117  case LibFunc_labs:
1118  case LibFunc_llabs:
1119  case LibFunc_log:
1120  case LibFunc_log10:
1121  case LibFunc_log10f:
1122  case LibFunc_log10l:
1123  case LibFunc_log1p:
1124  case LibFunc_log1pf:
1125  case LibFunc_log1pl:
1126  case LibFunc_log2:
1127  case LibFunc_log2f:
1128  case LibFunc_log2l:
1129  case LibFunc_logb:
1130  case LibFunc_logbf:
1131  case LibFunc_logbl:
1132  case LibFunc_logf:
1133  case LibFunc_logl:
1134  case LibFunc_nearbyint:
1135  case LibFunc_nearbyintf:
1136  case LibFunc_nearbyintl:
1137  case LibFunc_pow:
1138  case LibFunc_powf:
1139  case LibFunc_powl:
1140  case LibFunc_rint:
1141  case LibFunc_rintf:
1142  case LibFunc_rintl:
1143  case LibFunc_round:
1144  case LibFunc_roundf:
1145  case LibFunc_roundl:
1146  case LibFunc_sin:
1147  case LibFunc_sincospif_stret:
1148  case LibFunc_sinf:
1149  case LibFunc_sinh:
1150  case LibFunc_sinhf:
1151  case LibFunc_sinhl:
1152  case LibFunc_sinl:
1153  case LibFunc_sinpi:
1154  case LibFunc_sinpif:
1155  case LibFunc_sqrt:
1156  case LibFunc_sqrtf:
1157  case LibFunc_sqrtl:
1158  case LibFunc_strnlen:
1159  case LibFunc_tan:
1160  case LibFunc_tanf:
1161  case LibFunc_tanh:
1162  case LibFunc_tanhf:
1163  case LibFunc_tanhl:
1164  case LibFunc_tanl:
1165  case LibFunc_toascii:
1166  case LibFunc_trunc:
1167  case LibFunc_truncf:
1168  case LibFunc_truncl:
1169  Changed |= setDoesNotThrow(F);
1170  Changed |= setDoesNotFreeMemory(F);
1171  Changed |= setWillReturn(F);
1172  return Changed;
1173  default:
1174  // FIXME: It'd be really nice to cover all the library functions we're
1175  // aware of here.
1176  return false;
1177  }
1178 }
1179 
1180 bool llvm::hasFloatFn(const TargetLibraryInfo *TLI, Type *Ty,
1181  LibFunc DoubleFn, LibFunc FloatFn, LibFunc LongDoubleFn) {
1182  switch (Ty->getTypeID()) {
1183  case Type::HalfTyID:
1184  return false;
1185  case Type::FloatTyID:
1186  return TLI->has(FloatFn);
1187  case Type::DoubleTyID:
1188  return TLI->has(DoubleFn);
1189  default:
1190  return TLI->has(LongDoubleFn);
1191  }
1192 }
1193 
1194 StringRef llvm::getFloatFnName(const TargetLibraryInfo *TLI, Type *Ty,
1195  LibFunc DoubleFn, LibFunc FloatFn,
1196  LibFunc LongDoubleFn) {
1197  assert(hasFloatFn(TLI, Ty, DoubleFn, FloatFn, LongDoubleFn) &&
1198  "Cannot get name for unavailable function!");
1199 
1200  switch (Ty->getTypeID()) {
1201  case Type::HalfTyID:
1202  llvm_unreachable("No name for HalfTy!");
1203  case Type::FloatTyID:
1204  return TLI->getName(FloatFn);
1205  case Type::DoubleTyID:
1206  return TLI->getName(DoubleFn);
1207  default:
1208  return TLI->getName(LongDoubleFn);
1209  }
1210 }
1211 
1212 //- Emit LibCalls ------------------------------------------------------------//
1213 
1214 Value *llvm::castToCStr(Value *V, IRBuilderBase &B) {
1215  unsigned AS = V->getType()->getPointerAddressSpace();
1216  return B.CreateBitCast(V, B.getInt8PtrTy(AS), "cstr");
1217 }
1218 
1219 static Value *emitLibCall(LibFunc TheLibFunc, Type *ReturnType,
1220  ArrayRef<Type *> ParamTypes,
1221  ArrayRef<Value *> Operands, IRBuilderBase &B,
1222  const TargetLibraryInfo *TLI,
1223  bool IsVaArgs = false) {
1224  if (!TLI->has(TheLibFunc))
1225  return nullptr;
1226 
1227  Module *M = B.GetInsertBlock()->getModule();
1228  StringRef FuncName = TLI->getName(TheLibFunc);
1229  FunctionType *FuncType = FunctionType::get(ReturnType, ParamTypes, IsVaArgs);
1230  FunctionCallee Callee = M->getOrInsertFunction(FuncName, FuncType);
1231  inferLibFuncAttributes(M, FuncName, *TLI);
1232  CallInst *CI = B.CreateCall(Callee, Operands, FuncName);
1233  if (const Function *F =
1234  dyn_cast<Function>(Callee.getCallee()->stripPointerCasts()))
1235  CI->setCallingConv(F->getCallingConv());
1236  return CI;
1237 }
1238 
1239 Value *llvm::emitStrLen(Value *Ptr, IRBuilderBase &B, const DataLayout &DL,
1240  const TargetLibraryInfo *TLI) {
1241  LLVMContext &Context = B.GetInsertBlock()->getContext();
1242  return emitLibCall(LibFunc_strlen, DL.getIntPtrType(Context),
1243  B.getInt8PtrTy(), castToCStr(Ptr, B), B, TLI);
1244 }
1245 
1246 Value *llvm::emitStrDup(Value *Ptr, IRBuilderBase &B,
1247  const TargetLibraryInfo *TLI) {
1248  return emitLibCall(LibFunc_strdup, B.getInt8PtrTy(), B.getInt8PtrTy(),
1249  castToCStr(Ptr, B), B, TLI);
1250 }
1251 
1252 Value *llvm::emitStrChr(Value *Ptr, char C, IRBuilderBase &B,
1253  const TargetLibraryInfo *TLI) {
1254  Type *I8Ptr = B.getInt8PtrTy();
1255  Type *I32Ty = B.getInt32Ty();
1256  return emitLibCall(LibFunc_strchr, I8Ptr, {I8Ptr, I32Ty},
1257  {castToCStr(Ptr, B), ConstantInt::get(I32Ty, C)}, B, TLI);
1258 }
1259 
1260 Value *llvm::emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
1261  const DataLayout &DL, const TargetLibraryInfo *TLI) {
1262  LLVMContext &Context = B.GetInsertBlock()->getContext();
1263  return emitLibCall(
1264  LibFunc_strncmp, B.getInt32Ty(),
1265  {B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context)},
1266  {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI);
1267 }
1268 
1269 Value *llvm::emitStrCpy(Value *Dst, Value *Src, IRBuilderBase &B,
1270  const TargetLibraryInfo *TLI) {
1271  Type *I8Ptr = Dst->getType();
1272  return emitLibCall(LibFunc_strcpy, I8Ptr, {I8Ptr, I8Ptr},
1273  {castToCStr(Dst, B), castToCStr(Src, B)}, B, TLI);
1274 }
1275 
1276 Value *llvm::emitStpCpy(Value *Dst, Value *Src, IRBuilderBase &B,
1277  const TargetLibraryInfo *TLI) {
1278  Type *I8Ptr = B.getInt8PtrTy();
1279  return emitLibCall(LibFunc_stpcpy, I8Ptr, {I8Ptr, I8Ptr},
1280  {castToCStr(Dst, B), castToCStr(Src, B)}, B, TLI);
1281 }
1282 
1283 Value *llvm::emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B,
1284  const TargetLibraryInfo *TLI) {
1285  Type *I8Ptr = B.getInt8PtrTy();
1286  return emitLibCall(LibFunc_strncpy, I8Ptr, {I8Ptr, I8Ptr, Len->getType()},
1287  {castToCStr(Dst, B), castToCStr(Src, B), Len}, B, TLI);
1288 }
1289 
1290 Value *llvm::emitStpNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B,
1291  const TargetLibraryInfo *TLI) {
1292  Type *I8Ptr = B.getInt8PtrTy();
1293  return emitLibCall(LibFunc_stpncpy, I8Ptr, {I8Ptr, I8Ptr, Len->getType()},
1294  {castToCStr(Dst, B), castToCStr(Src, B), Len}, B, TLI);
1295 }
1296 
1297 Value *llvm::emitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize,
1298  IRBuilderBase &B, const DataLayout &DL,
1299  const TargetLibraryInfo *TLI) {
1300  if (!TLI->has(LibFunc_memcpy_chk))
1301  return nullptr;
1302 
1303  Module *M = B.GetInsertBlock()->getModule();
1304  AttributeList AS;
1305  AS = AttributeList::get(M->getContext(), AttributeList::FunctionIndex,
1306  Attribute::NoUnwind);
1307  LLVMContext &Context = B.GetInsertBlock()->getContext();
1308  FunctionCallee MemCpy = M->getOrInsertFunction(
1309  "__memcpy_chk", AttributeList::get(M->getContext(), AS), B.getInt8PtrTy(),
1310  B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context),
1311  DL.getIntPtrType(Context));
1312  Dst = castToCStr(Dst, B);
1313  Src = castToCStr(Src, B);
1314  CallInst *CI = B.CreateCall(MemCpy, {Dst, Src, Len, ObjSize});
1315  if (const Function *F =
1316  dyn_cast<Function>(MemCpy.getCallee()->stripPointerCasts()))
1317  CI->setCallingConv(F->getCallingConv());
1318  return CI;
1319 }
1320 
1321 Value *llvm::emitMemPCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B,
1322  const DataLayout &DL, const TargetLibraryInfo *TLI) {
1323  LLVMContext &Context = B.GetInsertBlock()->getContext();
1324  return emitLibCall(
1325  LibFunc_mempcpy, B.getInt8PtrTy(),
1326  {B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context)},
1327  {Dst, Src, Len}, B, TLI);
1328 }
1329 
1330 Value *llvm::emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilderBase &B,
1331  const DataLayout &DL, const TargetLibraryInfo *TLI) {
1332  LLVMContext &Context = B.GetInsertBlock()->getContext();
1333  return emitLibCall(
1334  LibFunc_memchr, B.getInt8PtrTy(),
1335  {B.getInt8PtrTy(), B.getInt32Ty(), DL.getIntPtrType(Context)},
1336  {castToCStr(Ptr, B), Val, Len}, B, TLI);
1337 }
1338 
1339 Value *llvm::emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
1340  const DataLayout &DL, const TargetLibraryInfo *TLI) {
1341  LLVMContext &Context = B.GetInsertBlock()->getContext();
1342  return emitLibCall(
1343  LibFunc_memcmp, B.getInt32Ty(),
1344  {B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context)},
1345  {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI);
1346 }
1347 
1348 Value *llvm::emitBCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
1349  const DataLayout &DL, const TargetLibraryInfo *TLI) {
1350  LLVMContext &Context = B.GetInsertBlock()->getContext();
1351  return emitLibCall(
1352  LibFunc_bcmp, B.getInt32Ty(),
1353  {B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context)},
1354  {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI);
1355 }
1356 
1357 Value *llvm::emitMemCCpy(Value *Ptr1, Value *Ptr2, Value *Val, Value *Len,
1358  IRBuilderBase &B, const TargetLibraryInfo *TLI) {
1359  return emitLibCall(
1360  LibFunc_memccpy, B.getInt8PtrTy(),
1361  {B.getInt8PtrTy(), B.getInt8PtrTy(), B.getInt32Ty(), Len->getType()},
1362  {Ptr1, Ptr2, Val, Len}, B, TLI);
1363 }
1364 
1365 Value *llvm::emitSNPrintf(Value *Dest, Value *Size, Value *Fmt,
1366  ArrayRef<Value *> VariadicArgs, IRBuilderBase &B,
1367  const TargetLibraryInfo *TLI) {
1368  SmallVector<Value *, 8> Args{castToCStr(Dest, B), Size, castToCStr(Fmt, B)};
1369  llvm::append_range(Args, VariadicArgs);
1370  return emitLibCall(LibFunc_snprintf, B.getInt32Ty(),
1371  {B.getInt8PtrTy(), Size->getType(), B.getInt8PtrTy()},
1372  Args, B, TLI, /*IsVaArgs=*/true);
1373 }
1374 
1375 Value *llvm::emitSPrintf(Value *Dest, Value *Fmt,
1376  ArrayRef<Value *> VariadicArgs, IRBuilderBase &B,
1377  const TargetLibraryInfo *TLI) {
1378  SmallVector<Value *, 8> Args{castToCStr(Dest, B), castToCStr(Fmt, B)};
1379  llvm::append_range(Args, VariadicArgs);
1380  return emitLibCall(LibFunc_sprintf, B.getInt32Ty(),
1381  {B.getInt8PtrTy(), B.getInt8PtrTy()}, Args, B, TLI,
1382  /*IsVaArgs=*/true);
1383 }
1384 
1385 Value *llvm::emitStrCat(Value *Dest, Value *Src, IRBuilderBase &B,
1386  const TargetLibraryInfo *TLI) {
1387  return emitLibCall(LibFunc_strcat, B.getInt8PtrTy(),
1388  {B.getInt8PtrTy(), B.getInt8PtrTy()},
1389  {castToCStr(Dest, B), castToCStr(Src, B)}, B, TLI);
1390 }
1391 
1392 Value *llvm::emitStrLCpy(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
1393  const TargetLibraryInfo *TLI) {
1394  return emitLibCall(LibFunc_strlcpy, Size->getType(),
1395  {B.getInt8PtrTy(), B.getInt8PtrTy(), Size->getType()},
1396  {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI);
1397 }
1398 
1399 Value *llvm::emitStrLCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
1400  const TargetLibraryInfo *TLI) {
1401  return emitLibCall(LibFunc_strlcat, Size->getType(),
1402  {B.getInt8PtrTy(), B.getInt8PtrTy(), Size->getType()},
1403  {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI);
1404 }
1405 
1406 Value *llvm::emitStrNCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
1407  const TargetLibraryInfo *TLI) {
1408  return emitLibCall(LibFunc_strncat, B.getInt8PtrTy(),
1409  {B.getInt8PtrTy(), B.getInt8PtrTy(), Size->getType()},
1410  {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI);
1411 }
1412 
1413 Value *llvm::emitVSNPrintf(Value *Dest, Value *Size, Value *Fmt, Value *VAList,
1414  IRBuilderBase &B, const TargetLibraryInfo *TLI) {
1415  return emitLibCall(
1416  LibFunc_vsnprintf, B.getInt32Ty(),
1417  {B.getInt8PtrTy(), Size->getType(), B.getInt8PtrTy(), VAList->getType()},
1418  {castToCStr(Dest, B), Size, castToCStr(Fmt, B), VAList}, B, TLI);
1419 }
1420 
1421 Value *llvm::emitVSPrintf(Value *Dest, Value *Fmt, Value *VAList,
1422  IRBuilderBase &B, const TargetLibraryInfo *TLI) {
1423  return emitLibCall(LibFunc_vsprintf, B.getInt32Ty(),
1424  {B.getInt8PtrTy(), B.getInt8PtrTy(), VAList->getType()},
1425  {castToCStr(Dest, B), castToCStr(Fmt, B), VAList}, B, TLI);
1426 }
1427 
1428 /// Append a suffix to the function name according to the type of 'Op'.
1429 static void appendTypeSuffix(Value *Op, StringRef &Name,
1430  SmallString<20> &NameBuffer) {
1431  if (!Op->getType()->isDoubleTy()) {
1432  NameBuffer += Name;
1433 
1434  if (Op->getType()->isFloatTy())
1435  NameBuffer += 'f';
1436  else
1437  NameBuffer += 'l';
1438 
1439  Name = NameBuffer;
1440  }
1441 }
1442 
1443 static Value *emitUnaryFloatFnCallHelper(Value *Op, StringRef Name,
1444  IRBuilderBase &B,
1445  const AttributeList &Attrs) {
1446  assert((Name != "") && "Must specify Name to emitUnaryFloatFnCall");
1447 
1448  Module *M = B.GetInsertBlock()->getModule();
1449  FunctionCallee Callee =
1450  M->getOrInsertFunction(Name, Op->getType(), Op->getType());
1451  CallInst *CI = B.CreateCall(Callee, Op, Name);
1452 
1453  // The incoming attribute set may have come from a speculatable intrinsic, but
1454  // is being replaced with a library call which is not allowed to be
1455  // speculatable.
1456  CI->setAttributes(
1457  Attrs.removeFnAttribute(B.getContext(), Attribute::Speculatable));
1458  if (const Function *F =
1459  dyn_cast<Function>(Callee.getCallee()->stripPointerCasts()))
1460  CI->setCallingConv(F->getCallingConv());
1461 
1462  return CI;
1463 }
1464 
1465 Value *llvm::emitUnaryFloatFnCall(Value *Op, StringRef Name, IRBuilderBase &B,
1466  const AttributeList &Attrs) {
1467  SmallString<20> NameBuffer;
1468  appendTypeSuffix(Op, Name, NameBuffer);
1469 
1470  return emitUnaryFloatFnCallHelper(Op, Name, B, Attrs);
1471 }
1472 
1473 Value *llvm::emitUnaryFloatFnCall(Value *Op, const TargetLibraryInfo *TLI,
1474  LibFunc DoubleFn, LibFunc FloatFn,
1475  LibFunc LongDoubleFn, IRBuilderBase &B,
1476  const AttributeList &Attrs) {
1477  // Get the name of the function according to TLI.
1478  StringRef Name = getFloatFnName(TLI, Op->getType(),
1479  DoubleFn, FloatFn, LongDoubleFn);
1480 
1481  return emitUnaryFloatFnCallHelper(Op, Name, B, Attrs);
1482 }
1483 
1484 static Value *emitBinaryFloatFnCallHelper(Value *Op1, Value *Op2,
1485  StringRef Name, IRBuilderBase &B,
1486  const AttributeList &Attrs,
1487  const TargetLibraryInfo *TLI = nullptr) {
1488  assert((Name != "") && "Must specify Name to emitBinaryFloatFnCall");
1489 
1490  Module *M = B.GetInsertBlock()->getModule();
1491  FunctionCallee Callee = M->getOrInsertFunction(Name, Op1->getType(),
1492  Op1->getType(), Op2->getType());
1493  if (TLI != nullptr)
1494  inferLibFuncAttributes(M, Name, *TLI);
1495  CallInst *CI = B.CreateCall(Callee, { Op1, Op2 }, Name);
1496 
1497  // The incoming attribute set may have come from a speculatable intrinsic, but
1498  // is being replaced with a library call which is not allowed to be
1499  // speculatable.
1500  CI->setAttributes(
1501  Attrs.removeFnAttribute(B.getContext(), Attribute::Speculatable));
1502  if (const Function *F =
1503  dyn_cast<Function>(Callee.getCallee()->stripPointerCasts()))
1504  CI->setCallingConv(F->getCallingConv());
1505 
1506  return CI;
1507 }
1508 
1509 Value *llvm::emitBinaryFloatFnCall(Value *Op1, Value *Op2, StringRef Name,
1510  IRBuilderBase &B,
1511  const AttributeList &Attrs) {
1512  assert((Name != "") && "Must specify Name to emitBinaryFloatFnCall");
1513 
1514  SmallString<20> NameBuffer;
1515  appendTypeSuffix(Op1, Name, NameBuffer);
1516 
1517  return emitBinaryFloatFnCallHelper(Op1, Op2, Name, B, Attrs);
1518 }
1519 
1520 Value *llvm::emitBinaryFloatFnCall(Value *Op1, Value *Op2,
1521  const TargetLibraryInfo *TLI,
1522  LibFunc DoubleFn, LibFunc FloatFn,
1523  LibFunc LongDoubleFn, IRBuilderBase &B,
1524  const AttributeList &Attrs) {
1525  // Get the name of the function according to TLI.
1526  StringRef Name = getFloatFnName(TLI, Op1->getType(),
1527  DoubleFn, FloatFn, LongDoubleFn);
1528 
1529  return emitBinaryFloatFnCallHelper(Op1, Op2, Name, B, Attrs, TLI);
1530 }
1531 
1532 Value *llvm::emitPutChar(Value *Char, IRBuilderBase &B,
1533  const TargetLibraryInfo *TLI) {
1534  if (!TLI->has(LibFunc_putchar))
1535  return nullptr;
1536 
1537  Module *M = B.GetInsertBlock()->getModule();
1538  StringRef PutCharName = TLI->getName(LibFunc_putchar);
1539  FunctionCallee PutChar =
1540  M->getOrInsertFunction(PutCharName, B.getInt32Ty(), B.getInt32Ty());
1541  inferLibFuncAttributes(M, PutCharName, *TLI);
1542  CallInst *CI = B.CreateCall(PutChar,
1543  B.CreateIntCast(Char,
1544  B.getInt32Ty(),
1545  /*isSigned*/true,
1546  "chari"),
1547  PutCharName);
1548 
1549  if (const Function *F =
1550  dyn_cast<Function>(PutChar.getCallee()->stripPointerCasts()))
1551  CI->setCallingConv(F->getCallingConv());
1552  return CI;
1553 }
1554 
1555 Value *llvm::emitPutS(Value *Str, IRBuilderBase &B,
1556  const TargetLibraryInfo *TLI) {
1557  if (!TLI->has(LibFunc_puts))
1558  return nullptr;
1559 
1560  Module *M = B.GetInsertBlock()->getModule();
1561  StringRef PutsName = TLI->getName(LibFunc_puts);
1562  FunctionCallee PutS =
1563  M->getOrInsertFunction(PutsName, B.getInt32Ty(), B.getInt8PtrTy());
1564  inferLibFuncAttributes(M, PutsName, *TLI);
1565  CallInst *CI = B.CreateCall(PutS, castToCStr(Str, B), PutsName);
1566  if (const Function *F =
1567  dyn_cast<Function>(PutS.getCallee()->stripPointerCasts()))
1568  CI->setCallingConv(F->getCallingConv());
1569  return CI;
1570 }
1571 
1572 Value *llvm::emitFPutC(Value *Char, Value *File, IRBuilderBase &B,
1573  const TargetLibraryInfo *TLI) {
1574  if (!TLI->has(LibFunc_fputc))
1575  return nullptr;
1576 
1577  Module *M = B.GetInsertBlock()->getModule();
1578  StringRef FPutcName = TLI->getName(LibFunc_fputc);
1579  FunctionCallee F = M->getOrInsertFunction(FPutcName, B.getInt32Ty(),
1580  B.getInt32Ty(), File->getType());
1581  if (File->getType()->isPointerTy())
1582  inferLibFuncAttributes(M, FPutcName, *TLI);
1583  Char = B.CreateIntCast(Char, B.getInt32Ty(), /*isSigned*/true,
1584  "chari");
1585  CallInst *CI = B.CreateCall(F, {Char, File}, FPutcName);
1586 
1587  if (const Function *Fn =
1588  dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
1589  CI->setCallingConv(Fn->getCallingConv());
1590  return CI;
1591 }
1592 
1593 Value *llvm::emitFPutS(Value *Str, Value *File, IRBuilderBase &B,
1594  const TargetLibraryInfo *TLI) {
1595  if (!TLI->has(LibFunc_fputs))
1596  return nullptr;
1597 
1598  Module *M = B.GetInsertBlock()->getModule();
1599  StringRef FPutsName = TLI->getName(LibFunc_fputs);
1600  FunctionCallee F = M->getOrInsertFunction(FPutsName, B.getInt32Ty(),
1601  B.getInt8PtrTy(), File->getType());
1602  if (File->getType()->isPointerTy())
1603  inferLibFuncAttributes(M, FPutsName, *TLI);
1604  CallInst *CI = B.CreateCall(F, {castToCStr(Str, B), File}, FPutsName);
1605 
1606  if (const Function *Fn =
1607  dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
1608  CI->setCallingConv(Fn->getCallingConv());
1609  return CI;
1610 }
1611 
1612 Value *llvm::emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilderBase &B,
1613  const DataLayout &DL, const TargetLibraryInfo *TLI) {
1614  if (!TLI->has(LibFunc_fwrite))
1615  return nullptr;
1616 
1617  Module *M = B.GetInsertBlock()->getModule();
1618  LLVMContext &Context = B.GetInsertBlock()->getContext();
1619  StringRef FWriteName = TLI->getName(LibFunc_fwrite);
1620  FunctionCallee F = M->getOrInsertFunction(
1621  FWriteName, DL.getIntPtrType(Context), B.getInt8PtrTy(),
1622  DL.getIntPtrType(Context), DL.getIntPtrType(Context), File->getType());
1623 
1624  if (File->getType()->isPointerTy())
1625  inferLibFuncAttributes(M, FWriteName, *TLI);
1626  CallInst *CI =
1627  B.CreateCall(F, {castToCStr(Ptr, B), Size,
1628  ConstantInt::get(DL.getIntPtrType(Context), 1), File});
1629 
1630  if (const Function *Fn =
1631  dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
1632  CI->setCallingConv(Fn->getCallingConv());
1633  return CI;
1634 }
1635 
1636 Value *llvm::emitMalloc(Value *Num, IRBuilderBase &B, const DataLayout &DL,
1637  const TargetLibraryInfo *TLI) {
1638  if (!TLI->has(LibFunc_malloc))
1639  return nullptr;
1640 
1641  Module *M = B.GetInsertBlock()->getModule();
1642  StringRef MallocName = TLI->getName(LibFunc_malloc);
1643  LLVMContext &Context = B.GetInsertBlock()->getContext();
1644  FunctionCallee Malloc = M->getOrInsertFunction(MallocName, B.getInt8PtrTy(),
1645  DL.getIntPtrType(Context));
1646  inferLibFuncAttributes(M, MallocName, *TLI);
1647  CallInst *CI = B.CreateCall(Malloc, Num, MallocName);
1648 
1649  if (const Function *F =
1650  dyn_cast<Function>(Malloc.getCallee()->stripPointerCasts()))
1651  CI->setCallingConv(F->getCallingConv());
1652 
1653  return CI;
1654 }
1655 
1656 Value *llvm::emitCalloc(Value *Num, Value *Size, IRBuilderBase &B,
1657  const TargetLibraryInfo &TLI) {
1658  if (!TLI.has(LibFunc_calloc))
1659  return nullptr;
1660 
1661  Module *M = B.GetInsertBlock()->getModule();
1662  StringRef CallocName = TLI.getName(LibFunc_calloc);
1663  const DataLayout &DL = M->getDataLayout();
1664  IntegerType *PtrType = DL.getIntPtrType((B.GetInsertBlock()->getContext()));
1665  FunctionCallee Calloc =
1666  M->getOrInsertFunction(CallocName, B.getInt8PtrTy(), PtrType, PtrType);
1667  inferLibFuncAttributes(M, CallocName, TLI);
1668  CallInst *CI = B.CreateCall(Calloc, {Num, Size}, CallocName);
1669 
1670  if (const auto *F =
1671  dyn_cast<Function>(Calloc.getCallee()->stripPointerCasts()))
1672  CI->setCallingConv(F->getCallingConv());
1673 
1674  return CI;
1675 }
llvm::Check::Size
@ Size
Definition: FileCheck.h:73
setSignExtendedArg
static bool setSignExtendedArg(Function &F, unsigned ArgNo)
Definition: BuildLibCalls.cpp:138
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:1194
Attrs
Function Attrs
Definition: README_ALTIVEC.txt:215
llvm::Type::FloatTyID
@ FloatTyID
32-bit floating point type
Definition: Type.h:58
llvm::Type::DoubleTyID
@ DoubleTyID
64-bit floating point type
Definition: Type.h:59
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::DataLayout
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:112
llvm::Function
Definition: Function.h:61
llvm::emitCalloc
Value * emitCalloc(Value *Num, Value *Size, IRBuilderBase &B, const TargetLibraryInfo &TLI)
Emit a call to the calloc function.
Definition: BuildLibCalls.cpp:1656
llvm::SmallVector< Value *, 8 >
Statistic.h
llvm::emitMemCmp
Value * emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the memcmp function.
Definition: BuildLibCalls.cpp:1339
llvm::emitFWrite
Value * emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilderBase &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the fwrite function.
Definition: BuildLibCalls.cpp:1612
llvm::Type::getPointerAddressSpace
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
Definition: DerivedTypes.h:734
setOnlyAccessesArgMemory
static bool setOnlyAccessesArgMemory(Function &F)
Definition: BuildLibCalls.cpp:74
appendTypeSuffix
static void appendTypeSuffix(Value *Op, StringRef &Name, SmallString< 20 > &NameBuffer)
Append a suffix to the function name according to the type of 'Op'.
Definition: BuildLibCalls.cpp:1429
llvm::emitMemCCpy
Value * emitMemCCpy(Value *Ptr1, Value *Ptr2, Value *Val, Value *Len, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the memccpy function.
Definition: BuildLibCalls.cpp:1357
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:325
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:1040
llvm::Type::getTypeID
TypeID getTypeID() const
Return the type id for the type.
Definition: Type.h:135
setDoesNotCapture
static bool setDoesNotCapture(Function &F, unsigned ArgNo)
Definition: BuildLibCalls.cpp:106
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
Module.h
setOnlyReadsMemory
static bool setOnlyReadsMemory(Function &F)
Definition: BuildLibCalls.cpp:66
setArgNoUndef
static bool setArgNoUndef(Function &F, unsigned ArgNo)
Definition: BuildLibCalls.cpp:168
MemoryBuiltins.h
llvm::AttributeList
Definition: Attributes.h:398
setDoesNotAccessMemory
static bool setDoesNotAccessMemory(Function &F)
Definition: BuildLibCalls.cpp:50
emitLibCall
static Value * emitLibCall(LibFunc TheLibFunc, Type *ReturnType, ArrayRef< Type * > ParamTypes, ArrayRef< Value * > Operands, IRBuilderBase &B, const TargetLibraryInfo *TLI, bool IsVaArgs=false)
Definition: BuildLibCalls.cpp:1219
F
#define F(x, y, z)
Definition: MD5.cpp:56
Context
LLVMContext & Context
Definition: NVVMIntrRange.cpp:66
setWillReturn
static bool setWillReturn(Function &F)
Definition: BuildLibCalls.cpp:202
llvm::emitStrDup
Value * emitStrDup(Value *Ptr, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the strdup function to the builder, for the specified pointer.
Definition: BuildLibCalls.cpp:1246
llvm::emitFPutC
Value * emitFPutC(Value *Char, Value *File, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the fputc function.
Definition: BuildLibCalls.cpp:1572
Constants.h
SmallString.h
setRetNoUndef
static bool setRetNoUndef(Function &F)
Definition: BuildLibCalls.cpp:146
llvm::LibFunc
LibFunc
Definition: TargetLibraryInfo.h:34
Intrinsics.h
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::CallBase::setAttributes
void setAttributes(AttributeList A)
Set the parameter attributes for this call.
Definition: InstrTypes.h:1472
llvm::emitStrCat
Value * emitStrCat(Value *Dest, Value *Src, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the strcat function.
Definition: BuildLibCalls.cpp:1385
llvm::emitStrLCpy
Value * emitStrLCpy(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the strlcpy function.
Definition: BuildLibCalls.cpp:1392
TargetLibraryInfo.h
emitBinaryFloatFnCallHelper
static Value * emitBinaryFloatFnCallHelper(Value *Op1, Value *Op2, StringRef Name, IRBuilderBase &B, const AttributeList &Attrs, const TargetLibraryInfo *TLI=nullptr)
Definition: BuildLibCalls.cpp:1484
B
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
llvm::IntegerType
Class to represent integer types.
Definition: DerivedTypes.h:40
llvm::TargetLibraryInfo::getLibFunc
bool getLibFunc(StringRef funcName, LibFunc &F) const
Searches for a particular function name.
Definition: TargetLibraryInfo.h:289
llvm::STATISTIC
STATISTIC(NumFunctions, "Total number of functions")
llvm::emitPutChar
Value * emitPutChar(Value *Char, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the putchar function. This assumes that Char is an integer.
Definition: BuildLibCalls.cpp:1532
emitUnaryFloatFnCallHelper
static Value * emitUnaryFloatFnCallHelper(Value *Op, StringRef Name, IRBuilderBase &B, const AttributeList &Attrs)
Definition: BuildLibCalls.cpp:1443
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:900
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:313
llvm::TargetLibraryInfo::getName
StringRef getName(LibFunc F) const
Definition: TargetLibraryInfo.h:369
llvm::emitBinaryFloatFnCall
Value * emitBinaryFloatFnCall(Value *Op1, Value *Op2, StringRef Name, IRBuilderBase &B, const AttributeList &Attrs)
Emit a call to the binary function named 'Name' (e.g.
Definition: BuildLibCalls.cpp:1509
llvm::emitStrNCmp
Value * emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the strncmp function to the builder.
Definition: BuildLibCalls.cpp:1260
Type.h
llvm::SmallString
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:25
Operands
mir Rename Register Operands
Definition: MIRNamerPass.cpp:78
setOnlyWritesMemory
static bool setOnlyWritesMemory(Function &F, unsigned ArgNo)
Definition: BuildLibCalls.cpp:130
setDoesNotAlias
static bool setDoesNotAlias(Function &F, unsigned ArgNo)
Definition: BuildLibCalls.cpp:114
llvm::emitSPrintf
Value * emitSPrintf(Value *Dest, Value *Fmt, ArrayRef< Value * > VariadicArgs, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the sprintf function.
Definition: BuildLibCalls.cpp:1375
llvm::emitMemCpyChk
Value * emitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize, IRBuilderBase &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the __memcpy_chk function to the builder.
Definition: BuildLibCalls.cpp:1297
setReturnedArg
static bool setReturnedArg(Function &F, unsigned ArgNo)
Definition: BuildLibCalls.cpp:180
llvm::LLVMContext
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:68
llvm::emitStrLCat
Value * emitStrLCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the strlcat function.
Definition: BuildLibCalls.cpp:1399
setOnlyAccessesInaccessibleMemory
static bool setOnlyAccessesInaccessibleMemory(Function &F)
Definition: BuildLibCalls.cpp:58
llvm::emitBCmp
Value * emitBCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the bcmp function.
Definition: BuildLibCalls.cpp:1348
IRBuilder.h
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
setArgsNoUndef
static bool setArgsNoUndef(Function &F)
Definition: BuildLibCalls.cpp:156
llvm::emitMemPCpy
Value * emitMemPCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the mempcpy function.
Definition: BuildLibCalls.cpp:1321
llvm::emitStpNCpy
Value * emitStpNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the stpncpy function to the builder, for the specified pointer arguments and length.
Definition: BuildLibCalls.cpp:1290
llvm::TargetLibraryInfo::has
bool has(LibFunc F) const
Tests whether a library function is available.
Definition: TargetLibraryInfo.h:323
llvm::emitStrNCat
Value * emitStrNCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the strncat function.
Definition: BuildLibCalls.cpp:1406
setDoesNotFreeMemory
static bool setDoesNotFreeMemory(Function &F)
Definition: BuildLibCalls.cpp:195
setRetAndArgsNoUndef
static bool setRetAndArgsNoUndef(Function &F)
Definition: BuildLibCalls.cpp:176
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:67
llvm::ARM::WinEH::ReturnType
ReturnType
Definition: ARMWinEH.h:25
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
setOnlyAccessesInaccessibleMemOrArgMem
static bool setOnlyAccessesInaccessibleMemOrArgMem(Function &F)
Definition: BuildLibCalls.cpp:82
DataLayout.h
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:136
llvm::Value::getType
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:256
llvm::append_range
void append_range(Container &C, Range &&R)
Wrapper function to append a range to a container.
Definition: STLExtras.h:1744
llvm::IRBuilderBase
Common base class shared among various IRBuilders.
Definition: IRBuilder.h:95
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
llvm::emitStpCpy
Value * emitStpCpy(Value *Dst, Value *Src, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the stpcpy function to the builder, for the specified pointer arguments.
Definition: BuildLibCalls.cpp:1276
llvm::emitStrLen
Value * emitStrLen(Value *Ptr, IRBuilderBase &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the strlen function to the builder, for the specified pointer.
Definition: BuildLibCalls.cpp:1239
llvm::emitStrCpy
Value * emitStrCpy(Value *Dst, Value *Src, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the strcpy function to the builder, for the specified pointer arguments.
Definition: BuildLibCalls.cpp:1269
LLVM_FALLTHROUGH
#define LLVM_FALLTHROUGH
LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.
Definition: Compiler.h:273
llvm::emitUnaryFloatFnCall
Value * emitUnaryFloatFnCall(Value *Op, StringRef Name, IRBuilderBase &B, const AttributeList &Attrs)
Emit a call to the unary function named 'Name' (e.g.
Definition: BuildLibCalls.cpp:1465
setRetDoesNotAlias
static bool setRetDoesNotAlias(Function &F)
Definition: BuildLibCalls.cpp:98
llvm::Value::stripPointerCasts
const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs and address space casts.
Definition: Value.cpp:675
llvm::FunctionCallee::getCallee
Value * getCallee()
Definition: DerivedTypes.h:184
Callee
amdgpu Simplify well known AMD library false FunctionCallee Callee
Definition: AMDGPULibCalls.cpp:206
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:1180
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
llvm::AMDGPU::SendMsg::Op
Op
Definition: SIDefines.h:321
Function.h
llvm::TargetLibraryInfo
Provides information about what library functions are available for the current target.
Definition: TargetLibraryInfo.h:219
llvm::emitFPutS
Value * emitFPutS(Value *Str, Value *File, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the fputs function.
Definition: BuildLibCalls.cpp:1593
llvm::orc::ReadOnly
static constexpr sys::Memory::ProtectionFlags ReadOnly
Definition: DebugObjectManagerPlugin.cpp:111
llvm::emitMalloc
Value * emitMalloc(Value *Num, IRBuilderBase &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the malloc function.
Definition: BuildLibCalls.cpp:1636
llvm::castToCStr
Value * castToCStr(Value *V, IRBuilderBase &B)
Return V if it is an i8*, otherwise cast it to i8*.
Definition: BuildLibCalls.cpp:1214
setDoesNotThrow
static bool setDoesNotThrow(Function &F)
Definition: BuildLibCalls.cpp:90
llvm::AttributeList::FunctionIndex
@ FunctionIndex
Definition: Attributes.h:402
llvm::emitStrNCpy
Value * emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the strncpy function to the builder, for the specified pointer arguments and length.
Definition: BuildLibCalls.cpp:1283
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:218
llvm::FunctionCallee
A handy container for a FunctionType+Callee-pointer pair, which can be passed around as a single enti...
Definition: DerivedTypes.h:165
llvm::emitSNPrintf
Value * emitSNPrintf(Value *Dest, Value *Size, Value *Fmt, ArrayRef< Value * > Args, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the snprintf function.
Definition: BuildLibCalls.cpp:1365
llvm::emitPutS
Value * emitPutS(Value *Str, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the puts function. This assumes that Str is some pointer.
Definition: BuildLibCalls.cpp:1555
llvm::emitStrChr
Value * emitStrChr(Value *Ptr, char C, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the strchr function to the builder, for the specified pointer and character.
Definition: BuildLibCalls.cpp:1252
llvm::CallInst
This class represents a function call, abstracting a target machine's calling convention.
Definition: Instructions.h:1475
LLVMContext.h
llvm::AMDGPU::HSAMD::Kernel::Key::Args
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
Definition: AMDGPUMetadata.h:389
llvm::isLibFreeFunction
bool isLibFreeFunction(const Function *F, const LibFunc TLIFn)
isLibFreeFunction - Returns true if the function is a builtin free()
Definition: MemoryBuiltins.cpp:434
setNonLazyBind
static bool setNonLazyBind(Function &F)
Definition: BuildLibCalls.cpp:188
llvm::emitVSPrintf
Value * emitVSPrintf(Value *Dest, Value *Fmt, Value *VAList, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the vsprintf function.
Definition: BuildLibCalls.cpp:1421
BuildLibCalls.h
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
llvm::emitVSNPrintf
Value * emitVSNPrintf(Value *Dest, Value *Size, Value *Fmt, Value *VAList, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the vsnprintf function.
Definition: BuildLibCalls.cpp:1413
llvm::Type::HalfTyID
@ HalfTyID
16-bit floating point type
Definition: Type.h:56
File
Instrumentation for Order File
Definition: InstrOrderFile.cpp:205
llvm::emitMemChr
Value * emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilderBase &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the memchr function.
Definition: BuildLibCalls.cpp:1330
llvm::CallBase::setCallingConv
void setCallingConv(CallingConv::ID CC)
Definition: InstrTypes.h:1453
llvm::FunctionType
Class to represent function types.
Definition: DerivedTypes.h:103
Generated on Sat Sep 18 2021 15:35:47 for LLVM by   doxygen 1.8.17