LLVM 17.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/MemoryBuiltins.h"
17#include "llvm/Analysis/TargetLibraryInfo.h"
18#include "llvm/IR/Argument.h"
19#include "llvm/IR/CallingConv.h"
20#include "llvm/IR/Constants.h"
21#include "llvm/IR/DataLayout.h"
22#include "llvm/IR/Function.h"
23#include "llvm/IR/IRBuilder.h"
24#include "llvm/IR/Module.h"
25#include "llvm/IR/Type.h"
26#include "llvm/Support/TypeSize.h"
27#include <optional>
28
29using namespace llvm;
30
31#define DEBUG_TYPE "build-libcalls"
32
33//- Infer Attributes ---------------------------------------------------------//
34
35STATISTIC(NumReadNone, "Number of functions inferred as readnone");
36STATISTIC(NumInaccessibleMemOnly,
37 "Number of functions inferred as inaccessiblememonly");
38STATISTIC(NumReadOnly, "Number of functions inferred as readonly");
39STATISTIC(NumWriteOnly, "Number of functions inferred as writeonly");
40STATISTIC(NumArgMemOnly, "Number of functions inferred as argmemonly");
41STATISTIC(NumInaccessibleMemOrArgMemOnly,
42 "Number of functions inferred as inaccessiblemem_or_argmemonly");
43STATISTIC(NumNoUnwind, "Number of functions inferred as nounwind");
44STATISTIC(NumNoCapture, "Number of arguments inferred as nocapture");
45STATISTIC(NumWriteOnlyArg, "Number of arguments inferred as writeonly");
46STATISTIC(NumReadOnlyArg, "Number of arguments inferred as readonly");
47STATISTIC(NumNoAlias, "Number of function returns inferred as noalias");
48STATISTIC(NumNoUndef, "Number of function returns inferred as noundef returns");
49STATISTIC(NumReturnedArg, "Number of arguments inferred as returned");
50STATISTIC(NumWillReturn, "Number of functions inferred as willreturn");
51
52static bool setDoesNotAccessMemory(Function &F) {
53 if (F.doesNotAccessMemory())
54 return false;
55 F.setDoesNotAccessMemory();
56 ++NumReadNone;
57 return true;
58}
59
60static bool setOnlyAccessesInaccessibleMemory(Function &F) {
61 if (F.onlyAccessesInaccessibleMemory())
62 return false;
63 F.setOnlyAccessesInaccessibleMemory();
64 ++NumInaccessibleMemOnly;
65 return true;
66}
67
68static bool setOnlyReadsMemory(Function &F) {
69 if (F.onlyReadsMemory())
70 return false;
71 F.setOnlyReadsMemory();
72 ++NumReadOnly;
73 return true;
74}
75
76static bool setOnlyWritesMemory(Function &F) {
77 if (F.onlyWritesMemory()) // writeonly or readnone
78 return false;
79 ++NumWriteOnly;
80 F.setOnlyWritesMemory();
81 return true;
82}
83
84static bool setOnlyAccessesArgMemory(Function &F) {
85 if (F.onlyAccessesArgMemory())
86 return false;
87 F.setOnlyAccessesArgMemory();
88 ++NumArgMemOnly;
89 return true;
90}
91
92static bool setOnlyAccessesInaccessibleMemOrArgMem(Function &F) {
93 if (F.onlyAccessesInaccessibleMemOrArgMem())
94 return false;
95 F.setOnlyAccessesInaccessibleMemOrArgMem();
96 ++NumInaccessibleMemOrArgMemOnly;
97 return true;
98}
99
100static bool setDoesNotThrow(Function &F) {
101 if (F.doesNotThrow())
102 return false;
103 F.setDoesNotThrow();
104 ++NumNoUnwind;
105 return true;
106}
107
108static bool setRetDoesNotAlias(Function &F) {
109 if (F.hasRetAttribute(Attribute::NoAlias))
110 return false;
111 F.addRetAttr(Attribute::NoAlias);
112 ++NumNoAlias;
113 return true;
114}
115
116static bool setDoesNotCapture(Function &F, unsigned ArgNo) {
117 if (F.hasParamAttribute(ArgNo, Attribute::NoCapture))
118 return false;
119 F.addParamAttr(ArgNo, Attribute::NoCapture);
120 ++NumNoCapture;
121 return true;
122}
123
124static bool setDoesNotAlias(Function &F, unsigned ArgNo) {
125 if (F.hasParamAttribute(ArgNo, Attribute::NoAlias))
126 return false;
127 F.addParamAttr(ArgNo, Attribute::NoAlias);
128 ++NumNoAlias;
129 return true;
130}
131
132static bool setOnlyReadsMemory(Function &F, unsigned ArgNo) {
133 if (F.hasParamAttribute(ArgNo, Attribute::ReadOnly))
134 return false;
135 F.addParamAttr(ArgNo, Attribute::ReadOnly);
136 ++NumReadOnlyArg;
137 return true;
138}
139
140static bool setOnlyWritesMemory(Function &F, unsigned ArgNo) {
141 if (F.hasParamAttribute(ArgNo, Attribute::WriteOnly))
142 return false;
143 F.addParamAttr(ArgNo, Attribute::WriteOnly);
144 ++NumWriteOnlyArg;
145 return true;
146}
147
148static bool setRetNoUndef(Function &F) {
149 if (!F.getReturnType()->isVoidTy() &&
150 !F.hasRetAttribute(Attribute::NoUndef)) {
151 F.addRetAttr(Attribute::NoUndef);
152 ++NumNoUndef;
153 return true;
154 }
155 return false;
156}
157
158static bool setArgsNoUndef(Function &F) {
159 bool Changed = false;
160 for (unsigned ArgNo = 0; ArgNo < F.arg_size(); ++ArgNo) {
161 if (!F.hasParamAttribute(ArgNo, Attribute::NoUndef)) {
162 F.addParamAttr(ArgNo, Attribute::NoUndef);
163 ++NumNoUndef;
164 Changed = true;
165 }
166 }
167 return Changed;
168}
169
170static bool setArgNoUndef(Function &F, unsigned ArgNo) {
171 if (F.hasParamAttribute(ArgNo, Attribute::NoUndef))
172 return false;
173 F.addParamAttr(ArgNo, Attribute::NoUndef);
174 ++NumNoUndef;
175 return true;
176}
177
178static bool setRetAndArgsNoUndef(Function &F) {
179 bool UndefAdded = false;
180 UndefAdded |= setRetNoUndef(F);
181 UndefAdded |= setArgsNoUndef(F);
182 return UndefAdded;
183}
184
185static bool setReturnedArg(Function &F, unsigned ArgNo) {
186 if (F.hasParamAttribute(ArgNo, Attribute::Returned))
187 return false;
188 F.addParamAttr(ArgNo, Attribute::Returned);
189 ++NumReturnedArg;
190 return true;
191}
192
193static bool setNonLazyBind(Function &F) {
194 if (F.hasFnAttribute(Attribute::NonLazyBind))
195 return false;
196 F.addFnAttr(Attribute::NonLazyBind);
197 return true;
198}
199
200static bool setDoesNotFreeMemory(Function &F) {
201 if (F.hasFnAttribute(Attribute::NoFree))
202 return false;
203 F.addFnAttr(Attribute::NoFree);
204 return true;
205}
206
207static bool setWillReturn(Function &F) {
208 if (F.hasFnAttribute(Attribute::WillReturn))
209 return false;
210 F.addFnAttr(Attribute::WillReturn);
211 ++NumWillReturn;
212 return true;
213}
214
215static bool setAlignedAllocParam(Function &F, unsigned ArgNo) {
216 if (F.hasParamAttribute(ArgNo, Attribute::AllocAlign))
217 return false;
218 F.addParamAttr(ArgNo, Attribute::AllocAlign);
219 return true;
220}
221
222static bool setAllocatedPointerParam(Function &F, unsigned ArgNo) {
223 if (F.hasParamAttribute(ArgNo, Attribute::AllocatedPointer))
224 return false;
225 F.addParamAttr(ArgNo, Attribute::AllocatedPointer);
226 return true;
227}
228
229static bool setAllocSize(Function &F, unsigned ElemSizeArg,
230 std::optional<unsigned> NumElemsArg) {
231 if (F.hasFnAttribute(Attribute::AllocSize))
232 return false;
233 F.addFnAttr(Attribute::getWithAllocSizeArgs(F.getContext(), ElemSizeArg,
234 NumElemsArg));
235 return true;
236}
237
238static bool setAllocFamily(Function &F, StringRef Family) {
239 if (F.hasFnAttribute("alloc-family"))
240 return false;
241 F.addFnAttr("alloc-family", Family);
242 return true;
243}
244
245static bool setAllocKind(Function &F, AllocFnKind K) {
246 if (F.hasFnAttribute(Attribute::AllocKind))
247 return false;
248 F.addFnAttr(
249 Attribute::get(F.getContext(), Attribute::AllocKind, uint64_t(K)));
250 return true;
251}
252
253bool llvm::inferNonMandatoryLibFuncAttrs(Module *M, StringRef Name,
254 const TargetLibraryInfo &TLI) {
255 Function *F = M->getFunction(Name);
256 if (!F)
257 return false;
258 return inferNonMandatoryLibFuncAttrs(*F, TLI);
259}
260
261bool llvm::inferNonMandatoryLibFuncAttrs(Function &F,
262 const TargetLibraryInfo &TLI) {
263 LibFunc TheLibFunc;
264 if (!(TLI.getLibFunc(F, TheLibFunc) && TLI.has(TheLibFunc)))
265 return false;
266
267 bool Changed = false;
268
269 if (F.getParent() != nullptr && F.getParent()->getRtLibUseGOT())
270 Changed |= setNonLazyBind(F);
271
272 switch (TheLibFunc) {
273 case LibFunc_strlen:
274 case LibFunc_strnlen:
275 case LibFunc_wcslen:
276 Changed |= setOnlyReadsMemory(F);
277 Changed |= setDoesNotThrow(F);
278 Changed |= setOnlyAccessesArgMemory(F);
279 Changed |= setWillReturn(F);
280 Changed |= setDoesNotCapture(F, 0);
281 break;
282 case LibFunc_strchr:
283 case LibFunc_strrchr:
284 Changed |= setOnlyAccessesArgMemory(F);
285 Changed |= setOnlyReadsMemory(F);
286 Changed |= setDoesNotThrow(F);
287 Changed |= setWillReturn(F);
288 break;
289 case LibFunc_strtol:
290 case LibFunc_strtod:
291 case LibFunc_strtof:
292 case LibFunc_strtoul:
293 case LibFunc_strtoll:
294 case LibFunc_strtold:
295 case LibFunc_strtoull:
296 Changed |= setDoesNotThrow(F);
297 Changed |= setWillReturn(F);
298 Changed |= setDoesNotCapture(F, 1);
299 Changed |= setOnlyReadsMemory(F, 0);
300 break;
301 case LibFunc_strcat:
302 case LibFunc_strncat:
303 Changed |= setOnlyAccessesArgMemory(F);
304 Changed |= setDoesNotThrow(F);
305 Changed |= setWillReturn(F);
306 Changed |= setReturnedArg(F, 0);
307 Changed |= setDoesNotCapture(F, 1);
308 Changed |= setOnlyReadsMemory(F, 1);
309 Changed |= setDoesNotAlias(F, 0);
310 Changed |= setDoesNotAlias(F, 1);
311 break;
312 case LibFunc_strcpy:
313 case LibFunc_strncpy:
314 Changed |= setReturnedArg(F, 0);
315 [[fallthrough]];
316 case LibFunc_stpcpy:
317 case LibFunc_stpncpy:
318 Changed |= setOnlyAccessesArgMemory(F);
319 Changed |= setDoesNotThrow(F);
320 Changed |= setWillReturn(F);
321 Changed |= setDoesNotCapture(F, 1);
322 Changed |= setOnlyWritesMemory(F, 0);
323 Changed |= setOnlyReadsMemory(F, 1);
324 Changed |= setDoesNotAlias(F, 0);
325 Changed |= setDoesNotAlias(F, 1);
326 break;
327 case LibFunc_strxfrm:
328 Changed |= setDoesNotThrow(F);
329 Changed |= setWillReturn(F);
330 Changed |= setDoesNotCapture(F, 0);
331 Changed |= setDoesNotCapture(F, 1);
332 Changed |= setOnlyReadsMemory(F, 1);
333 break;
334 case LibFunc_strcmp: // 0,1
335 case LibFunc_strspn: // 0,1
336 case LibFunc_strncmp: // 0,1
337 case LibFunc_strcspn: // 0,1
338 Changed |= setDoesNotThrow(F);
339 Changed |= setOnlyAccessesArgMemory(F);
340 Changed |= setWillReturn(F);
341 Changed |= setOnlyReadsMemory(F);
342 Changed |= setDoesNotCapture(F, 0);
343 Changed |= setDoesNotCapture(F, 1);
344 break;
345 case LibFunc_strcoll:
346 case LibFunc_strcasecmp: // 0,1
347 case LibFunc_strncasecmp: //
348 // Those functions may depend on the locale, which may be accessed through
349 // global memory.
350 Changed |= setOnlyReadsMemory(F);
351 Changed |= setDoesNotThrow(F);
352 Changed |= setWillReturn(F);
353 Changed |= setDoesNotCapture(F, 0);
354 Changed |= setDoesNotCapture(F, 1);
355 break;
356 case LibFunc_strstr:
357 case LibFunc_strpbrk:
358 Changed |= setOnlyAccessesArgMemory(F);
359 Changed |= setOnlyReadsMemory(F);
360 Changed |= setDoesNotThrow(F);
361 Changed |= setWillReturn(F);
362 Changed |= setDoesNotCapture(F, 1);
363 break;
364 case LibFunc_strtok:
365 case LibFunc_strtok_r:
366 Changed |= setDoesNotThrow(F);
367 Changed |= setWillReturn(F);
368 Changed |= setDoesNotCapture(F, 1);
369 Changed |= setOnlyReadsMemory(F, 1);
370 break;
371 case LibFunc_scanf:
372 Changed |= setRetAndArgsNoUndef(F);
373 Changed |= setDoesNotThrow(F);
374 Changed |= setDoesNotCapture(F, 0);
375 Changed |= setOnlyReadsMemory(F, 0);
376 break;
377 case LibFunc_setbuf:
378 case LibFunc_setvbuf:
379 Changed |= setRetAndArgsNoUndef(F);
380 Changed |= setDoesNotThrow(F);
381 Changed |= setDoesNotCapture(F, 0);
382 break;
383 case LibFunc_strndup:
384 Changed |= setArgNoUndef(F, 1);
385 [[fallthrough]];
386 case LibFunc_strdup:
387 Changed |= setAllocFamily(F, "malloc");
388 Changed |= setOnlyAccessesInaccessibleMemOrArgMem(F);
389 Changed |= setDoesNotThrow(F);
390 Changed |= setRetDoesNotAlias(F);
391 Changed |= setWillReturn(F);
392 Changed |= setDoesNotCapture(F, 0);
393 Changed |= setOnlyReadsMemory(F, 0);
394 break;
395 case LibFunc_stat:
396 case LibFunc_statvfs:
397 Changed |= setRetAndArgsNoUndef(F);
398 Changed |= setDoesNotThrow(F);
399 Changed |= setDoesNotCapture(F, 0);
400 Changed |= setDoesNotCapture(F, 1);
401 Changed |= setOnlyReadsMemory(F, 0);
402 break;
403 case LibFunc_sscanf:
404 Changed |= setRetAndArgsNoUndef(F);
405 Changed |= setDoesNotThrow(F);
406 Changed |= setDoesNotCapture(F, 0);
407 Changed |= setDoesNotCapture(F, 1);
408 Changed |= setOnlyReadsMemory(F, 0);
409 Changed |= setOnlyReadsMemory(F, 1);
410 break;
411 case LibFunc_sprintf:
412 Changed |= setRetAndArgsNoUndef(F);
413 Changed |= setDoesNotThrow(F);
414 Changed |= setDoesNotCapture(F, 0);
415 Changed |= setDoesNotAlias(F, 0);
416 Changed |= setOnlyWritesMemory(F, 0);
417 Changed |= setDoesNotCapture(F, 1);
418 Changed |= setOnlyReadsMemory(F, 1);
419 break;
420 case LibFunc_snprintf:
421 Changed |= setRetAndArgsNoUndef(F);
422 Changed |= setDoesNotThrow(F);
423 Changed |= setDoesNotCapture(F, 0);
424 Changed |= setDoesNotAlias(F, 0);
425 Changed |= setOnlyWritesMemory(F, 0);
426 Changed |= setDoesNotCapture(F, 2);
427 Changed |= setOnlyReadsMemory(F, 2);
428 break;
429 case LibFunc_setitimer:
430 Changed |= setRetAndArgsNoUndef(F);
431 Changed |= setDoesNotThrow(F);
432 Changed |= setWillReturn(F);
433 Changed |= setDoesNotCapture(F, 1);
434 Changed |= setDoesNotCapture(F, 2);
435 Changed |= setOnlyReadsMemory(F, 1);
436 break;
437 case LibFunc_system:
438 // May throw; "system" is a valid pthread cancellation point.
439 Changed |= setRetAndArgsNoUndef(F);
440 Changed |= setDoesNotCapture(F, 0);
441 Changed |= setOnlyReadsMemory(F, 0);
442 break;
443 case LibFunc_aligned_alloc:
444 Changed |= setAlignedAllocParam(F, 0);
445 Changed |= setAllocSize(F, 1, std::nullopt);
446 Changed |= setAllocKind(F, AllocFnKind::Alloc | AllocFnKind::Uninitialized | AllocFnKind::Aligned);
447 [[fallthrough]];
448 case LibFunc_valloc:
449 case LibFunc_malloc:
450 case LibFunc_vec_malloc:
451 Changed |= setAllocFamily(F, TheLibFunc == LibFunc_vec_malloc ? "vec_malloc"
452 : "malloc");
453 Changed |= setAllocKind(F, AllocFnKind::Alloc | AllocFnKind::Uninitialized);
454 Changed |= setAllocSize(F, 0, std::nullopt);
455 Changed |= setOnlyAccessesInaccessibleMemory(F);
456 Changed |= setRetAndArgsNoUndef(F);
457 Changed |= setDoesNotThrow(F);
458 Changed |= setRetDoesNotAlias(F);
459 Changed |= setWillReturn(F);
460 break;
461 case LibFunc_memcmp:
462 Changed |= setOnlyAccessesArgMemory(F);
463 Changed |= setOnlyReadsMemory(F);
464 Changed |= setDoesNotThrow(F);
465 Changed |= setWillReturn(F);
466 Changed |= setDoesNotCapture(F, 0);
467 Changed |= setDoesNotCapture(F, 1);
468 break;
469 case LibFunc_memchr:
470 case LibFunc_memrchr:
471 Changed |= setDoesNotThrow(F);
472 Changed |= setOnlyAccessesArgMemory(F);
473 Changed |= setOnlyReadsMemory(F);
474 Changed |= setWillReturn(F);
475 break;
476 case LibFunc_modf:
477 case LibFunc_modff:
478 case LibFunc_modfl:
479 Changed |= setDoesNotThrow(F);
480 Changed |= setWillReturn(F);
481 Changed |= setOnlyAccessesArgMemory(F);
482 Changed |= setOnlyWritesMemory(F);
483 Changed |= setDoesNotCapture(F, 1);
484 break;
485 case LibFunc_memcpy:
486 Changed |= setDoesNotThrow(F);
487 Changed |= setOnlyAccessesArgMemory(F);
488 Changed |= setWillReturn(F);
489 Changed |= setDoesNotAlias(F, 0);
490 Changed |= setReturnedArg(F, 0);
491 Changed |= setOnlyWritesMemory(F, 0);
492 Changed |= setDoesNotAlias(F, 1);
493 Changed |= setDoesNotCapture(F, 1);
494 Changed |= setOnlyReadsMemory(F, 1);
495 break;
496 case LibFunc_memmove:
497 Changed |= setDoesNotThrow(F);
498 Changed |= setOnlyAccessesArgMemory(F);
499 Changed |= setWillReturn(F);
500 Changed |= setReturnedArg(F, 0);
501 Changed |= setOnlyWritesMemory(F, 0);
502 Changed |= setDoesNotCapture(F, 1);
503 Changed |= setOnlyReadsMemory(F, 1);
504 break;
505 case LibFunc_mempcpy:
506 case LibFunc_memccpy:
507 Changed |= setWillReturn(F);
508 [[fallthrough]];
509 case LibFunc_memcpy_chk:
510 Changed |= setDoesNotThrow(F);
511 Changed |= setOnlyAccessesArgMemory(F);
512 Changed |= setDoesNotAlias(F, 0);
513 Changed |= setOnlyWritesMemory(F, 0);
514 Changed |= setDoesNotAlias(F, 1);
515 Changed |= setDoesNotCapture(F, 1);
516 Changed |= setOnlyReadsMemory(F, 1);
517 break;
518 case LibFunc_memalign:
519 Changed |= setAllocFamily(F, "malloc");
520 Changed |= setAllocKind(F, AllocFnKind::Alloc | AllocFnKind::Aligned |
521 AllocFnKind::Uninitialized);
522 Changed |= setAllocSize(F, 1, std::nullopt);
523 Changed |= setAlignedAllocParam(F, 0);
524 Changed |= setOnlyAccessesInaccessibleMemory(F);
525 Changed |= setRetNoUndef(F);
526 Changed |= setDoesNotThrow(F);
527 Changed |= setRetDoesNotAlias(F);
528 Changed |= setWillReturn(F);
529 break;
530 case LibFunc_mkdir:
531 Changed |= setRetAndArgsNoUndef(F);
532 Changed |= setDoesNotThrow(F);
533 Changed |= setDoesNotCapture(F, 0);
534 Changed |= setOnlyReadsMemory(F, 0);
535 break;
536 case LibFunc_mktime:
537 Changed |= setRetAndArgsNoUndef(F);
538 Changed |= setDoesNotThrow(F);
539 Changed |= setWillReturn(F);
540 Changed |= setDoesNotCapture(F, 0);
541 break;
542 case LibFunc_realloc:
543 case LibFunc_reallocf:
544 case LibFunc_vec_realloc:
545 Changed |= setAllocFamily(
546 F, TheLibFunc == LibFunc_vec_realloc ? "vec_malloc" : "malloc");
547 Changed |= setAllocKind(F, AllocFnKind::Realloc);
548 Changed |= setAllocatedPointerParam(F, 0);
549 Changed |= setAllocSize(F, 1, std::nullopt);
550 Changed |= setOnlyAccessesInaccessibleMemOrArgMem(F);
551 Changed |= setRetNoUndef(F);
552 Changed |= setDoesNotThrow(F);
553 Changed |= setRetDoesNotAlias(F);
554 Changed |= setWillReturn(F);
555 Changed |= setDoesNotCapture(F, 0);
556 Changed |= setArgNoUndef(F, 1);
557 break;
558 case LibFunc_read:
559 // May throw; "read" is a valid pthread cancellation point.
560 Changed |= setRetAndArgsNoUndef(F);
561 Changed |= setDoesNotCapture(F, 1);
562 break;
563 case LibFunc_rewind:
564 Changed |= setRetAndArgsNoUndef(F);
565 Changed |= setDoesNotThrow(F);
566 Changed |= setDoesNotCapture(F, 0);
567 break;
568 case LibFunc_rmdir:
569 case LibFunc_remove:
570 case LibFunc_realpath:
571 Changed |= setRetAndArgsNoUndef(F);
572 Changed |= setDoesNotThrow(F);
573 Changed |= setDoesNotCapture(F, 0);
574 Changed |= setOnlyReadsMemory(F, 0);
575 break;
576 case LibFunc_rename:
577 Changed |= setRetAndArgsNoUndef(F);
578 Changed |= setDoesNotThrow(F);
579 Changed |= setDoesNotCapture(F, 0);
580 Changed |= setDoesNotCapture(F, 1);
581 Changed |= setOnlyReadsMemory(F, 0);
582 Changed |= setOnlyReadsMemory(F, 1);
583 break;
584 case LibFunc_readlink:
585 Changed |= setRetAndArgsNoUndef(F);
586 Changed |= setDoesNotThrow(F);
587 Changed |= setDoesNotCapture(F, 0);
588 Changed |= setDoesNotCapture(F, 1);
589 Changed |= setOnlyReadsMemory(F, 0);
590 break;
591 case LibFunc_write:
592 // May throw; "write" is a valid pthread cancellation point.
593 Changed |= setRetAndArgsNoUndef(F);
594 Changed |= setDoesNotCapture(F, 1);
595 Changed |= setOnlyReadsMemory(F, 1);
596 break;
597 case LibFunc_bcopy:
598 Changed |= setDoesNotThrow(F);
599 Changed |= setOnlyAccessesArgMemory(F);
600 Changed |= setWillReturn(F);
601 Changed |= setDoesNotCapture(F, 0);
602 Changed |= setOnlyReadsMemory(F, 0);
603 Changed |= setOnlyWritesMemory(F, 1);
604 Changed |= setDoesNotCapture(F, 1);
605 break;
606 case LibFunc_bcmp:
607 Changed |= setDoesNotThrow(F);
608 Changed |= setOnlyAccessesArgMemory(F);
609 Changed |= setOnlyReadsMemory(F);
610 Changed |= setWillReturn(F);
611 Changed |= setDoesNotCapture(F, 0);
612 Changed |= setDoesNotCapture(F, 1);
613 break;
614 case LibFunc_bzero:
615 Changed |= setDoesNotThrow(F);
616 Changed |= setOnlyAccessesArgMemory(F);
617 Changed |= setWillReturn(F);
618 Changed |= setDoesNotCapture(F, 0);
619 Changed |= setOnlyWritesMemory(F, 0);
620 break;
621 case LibFunc_calloc:
622 case LibFunc_vec_calloc:
623 Changed |= setAllocFamily(F, TheLibFunc == LibFunc_vec_calloc ? "vec_malloc"
624 : "malloc");
625 Changed |= setAllocKind(F, AllocFnKind::Alloc | AllocFnKind::Zeroed);
626 Changed |= setAllocSize(F, 0, 1);
627 Changed |= setOnlyAccessesInaccessibleMemory(F);
628 Changed |= setRetAndArgsNoUndef(F);
629 Changed |= setDoesNotThrow(F);
630 Changed |= setRetDoesNotAlias(F);
631 Changed |= setWillReturn(F);
632 break;
633 case LibFunc_chmod:
634 case LibFunc_chown:
635 Changed |= setRetAndArgsNoUndef(F);
636 Changed |= setDoesNotThrow(F);
637 Changed |= setDoesNotCapture(F, 0);
638 Changed |= setOnlyReadsMemory(F, 0);
639 break;
640 case LibFunc_ctermid:
641 case LibFunc_clearerr:
642 case LibFunc_closedir:
643 Changed |= setRetAndArgsNoUndef(F);
644 Changed |= setDoesNotThrow(F);
645 Changed |= setDoesNotCapture(F, 0);
646 break;
647 case LibFunc_atoi:
648 case LibFunc_atol:
649 case LibFunc_atof:
650 case LibFunc_atoll:
651 Changed |= setDoesNotThrow(F);
652 Changed |= setOnlyReadsMemory(F);
653 Changed |= setWillReturn(F);
654 Changed |= setDoesNotCapture(F, 0);
655 break;
656 case LibFunc_access:
657 Changed |= setRetAndArgsNoUndef(F);
658 Changed |= setDoesNotThrow(F);
659 Changed |= setDoesNotCapture(F, 0);
660 Changed |= setOnlyReadsMemory(F, 0);
661 break;
662 case LibFunc_fopen:
663 Changed |= setRetAndArgsNoUndef(F);
664 Changed |= setDoesNotThrow(F);
665 Changed |= setRetDoesNotAlias(F);
666 Changed |= setDoesNotCapture(F, 0);
667 Changed |= setDoesNotCapture(F, 1);
668 Changed |= setOnlyReadsMemory(F, 0);
669 Changed |= setOnlyReadsMemory(F, 1);
670 break;
671 case LibFunc_fdopen:
672 Changed |= setRetAndArgsNoUndef(F);
673 Changed |= setDoesNotThrow(F);
674 Changed |= setRetDoesNotAlias(F);
675 Changed |= setDoesNotCapture(F, 1);
676 Changed |= setOnlyReadsMemory(F, 1);
677 break;
678 case LibFunc_feof:
679 Changed |= setRetAndArgsNoUndef(F);
680 Changed |= setDoesNotThrow(F);
681 Changed |= setDoesNotCapture(F, 0);
682 break;
683 case LibFunc_free:
684 case LibFunc_vec_free:
685 Changed |= setAllocFamily(F, TheLibFunc == LibFunc_vec_free ? "vec_malloc"
686 : "malloc");
687 Changed |= setAllocKind(F, AllocFnKind::Free);
688 Changed |= setAllocatedPointerParam(F, 0);
689 Changed |= setOnlyAccessesInaccessibleMemOrArgMem(F);
690 Changed |= setArgsNoUndef(F);
691 Changed |= setDoesNotThrow(F);
692 Changed |= setWillReturn(F);
693 Changed |= setDoesNotCapture(F, 0);
694 break;
695 case LibFunc_fseek:
696 case LibFunc_ftell:
697 case LibFunc_fgetc:
698 case LibFunc_fgetc_unlocked:
699 case LibFunc_fseeko:
700 case LibFunc_ftello:
701 case LibFunc_fileno:
702 case LibFunc_fflush:
703 case LibFunc_fclose:
704 case LibFunc_fsetpos:
705 case LibFunc_flockfile:
706 case LibFunc_funlockfile:
707 case LibFunc_ftrylockfile:
708 Changed |= setRetAndArgsNoUndef(F);
709 Changed |= setDoesNotThrow(F);
710 Changed |= setDoesNotCapture(F, 0);
711 break;
712 case LibFunc_ferror:
713 Changed |= setRetAndArgsNoUndef(F);
714 Changed |= setDoesNotThrow(F);
715 Changed |= setDoesNotCapture(F, 0);
716 Changed |= setOnlyReadsMemory(F);
717 break;
718 case LibFunc_fputc:
719 case LibFunc_fputc_unlocked:
720 case LibFunc_fstat:
721 Changed |= setRetAndArgsNoUndef(F);
722 Changed |= setDoesNotThrow(F);
723 Changed |= setDoesNotCapture(F, 1);
724 break;
725 case LibFunc_frexp:
726 case LibFunc_frexpf:
727 case LibFunc_frexpl:
728 Changed |= setDoesNotThrow(F);
729 Changed |= setWillReturn(F);
730 Changed |= setOnlyAccessesArgMemory(F);
731 Changed |= setOnlyWritesMemory(F);
732 Changed |= setDoesNotCapture(F, 1);
733 break;
734 case LibFunc_fstatvfs:
735 Changed |= setRetAndArgsNoUndef(F);
736 Changed |= setDoesNotThrow(F);
737 Changed |= setDoesNotCapture(F, 1);
738 break;
739 case LibFunc_fgets:
740 case LibFunc_fgets_unlocked:
741 Changed |= setRetAndArgsNoUndef(F);
742 Changed |= setDoesNotThrow(F);
743 Changed |= setDoesNotCapture(F, 2);
744 break;
745 case LibFunc_fread:
746 case LibFunc_fread_unlocked:
747 Changed |= setRetAndArgsNoUndef(F);
748 Changed |= setDoesNotThrow(F);
749 Changed |= setDoesNotCapture(F, 0);
750 Changed |= setDoesNotCapture(F, 3);
751 break;
752 case LibFunc_fwrite:
753 case LibFunc_fwrite_unlocked:
754 Changed |= setRetAndArgsNoUndef(F);
755 Changed |= setDoesNotThrow(F);
756 Changed |= setDoesNotCapture(F, 0);
757 Changed |= setDoesNotCapture(F, 3);
758 // FIXME: readonly #1?
759 break;
760 case LibFunc_fputs:
761 case LibFunc_fputs_unlocked:
762 Changed |= setRetAndArgsNoUndef(F);
763 Changed |= setDoesNotThrow(F);
764 Changed |= setDoesNotCapture(F, 0);
765 Changed |= setDoesNotCapture(F, 1);
766 Changed |= setOnlyReadsMemory(F, 0);
767 break;
768 case LibFunc_fscanf:
769 case LibFunc_fprintf:
770 Changed |= setRetAndArgsNoUndef(F);
771 Changed |= setDoesNotThrow(F);
772 Changed |= setDoesNotCapture(F, 0);
773 Changed |= setDoesNotCapture(F, 1);
774 Changed |= setOnlyReadsMemory(F, 1);
775 break;
776 case LibFunc_fgetpos:
777 Changed |= setRetAndArgsNoUndef(F);
778 Changed |= setDoesNotThrow(F);
779 Changed |= setDoesNotCapture(F, 0);
780 Changed |= setDoesNotCapture(F, 1);
781 break;
782 case LibFunc_getc:
783 Changed |= setRetAndArgsNoUndef(F);
784 Changed |= setDoesNotThrow(F);
785 Changed |= setDoesNotCapture(F, 0);
786 break;
787 case LibFunc_getlogin_r:
788 Changed |= setRetAndArgsNoUndef(F);
789 Changed |= setDoesNotThrow(F);
790 Changed |= setDoesNotCapture(F, 0);
791 break;
792 case LibFunc_getc_unlocked:
793 Changed |= setRetAndArgsNoUndef(F);
794 Changed |= setDoesNotThrow(F);
795 Changed |= setDoesNotCapture(F, 0);
796 break;
797 case LibFunc_getenv:
798 Changed |= setRetAndArgsNoUndef(F);
799 Changed |= setDoesNotThrow(F);
800 Changed |= setOnlyReadsMemory(F);
801 Changed |= setDoesNotCapture(F, 0);
802 break;
803 case LibFunc_gets:
804 case LibFunc_getchar:
805 case LibFunc_getchar_unlocked:
806 Changed |= setRetAndArgsNoUndef(F);
807 Changed |= setDoesNotThrow(F);
808 break;
809 case LibFunc_getitimer:
810 Changed |= setRetAndArgsNoUndef(F);
811 Changed |= setDoesNotThrow(F);
812 Changed |= setDoesNotCapture(F, 1);
813 break;
814 case LibFunc_getpwnam:
815 Changed |= setRetAndArgsNoUndef(F);
816 Changed |= setDoesNotThrow(F);
817 Changed |= setDoesNotCapture(F, 0);
818 Changed |= setOnlyReadsMemory(F, 0);
819 break;
820 case LibFunc_ungetc:
821 Changed |= setRetAndArgsNoUndef(F);
822 Changed |= setDoesNotThrow(F);
823 Changed |= setDoesNotCapture(F, 1);
824 break;
825 case LibFunc_uname:
826 Changed |= setRetAndArgsNoUndef(F);
827 Changed |= setDoesNotThrow(F);
828 Changed |= setDoesNotCapture(F, 0);
829 break;
830 case LibFunc_unlink:
831 Changed |= setRetAndArgsNoUndef(F);
832 Changed |= setDoesNotThrow(F);
833 Changed |= setDoesNotCapture(F, 0);
834 Changed |= setOnlyReadsMemory(F, 0);
835 break;
836 case LibFunc_unsetenv:
837 Changed |= setRetAndArgsNoUndef(F);
838 Changed |= setDoesNotThrow(F);
839 Changed |= setDoesNotCapture(F, 0);
840 Changed |= setOnlyReadsMemory(F, 0);
841 break;
842 case LibFunc_utime:
843 case LibFunc_utimes:
844 Changed |= setRetAndArgsNoUndef(F);
845 Changed |= setDoesNotThrow(F);
846 Changed |= setDoesNotCapture(F, 0);
847 Changed |= setDoesNotCapture(F, 1);
848 Changed |= setOnlyReadsMemory(F, 0);
849 Changed |= setOnlyReadsMemory(F, 1);
850 break;
851 case LibFunc_putc:
852 case LibFunc_putc_unlocked:
853 Changed |= setRetAndArgsNoUndef(F);
854 Changed |= setDoesNotThrow(F);
855 Changed |= setDoesNotCapture(F, 1);
856 break;
857 case LibFunc_puts:
858 case LibFunc_printf:
859 case LibFunc_perror:
860 Changed |= setRetAndArgsNoUndef(F);
861 Changed |= setDoesNotThrow(F);
862 Changed |= setDoesNotCapture(F, 0);
863 Changed |= setOnlyReadsMemory(F, 0);
864 break;
865 case LibFunc_pread:
866 // May throw; "pread" is a valid pthread cancellation point.
867 Changed |= setRetAndArgsNoUndef(F);
868 Changed |= setDoesNotCapture(F, 1);
869 break;
870 case LibFunc_pwrite:
871 // May throw; "pwrite" is a valid pthread cancellation point.
872 Changed |= setRetAndArgsNoUndef(F);
873 Changed |= setDoesNotCapture(F, 1);
874 Changed |= setOnlyReadsMemory(F, 1);
875 break;
876 case LibFunc_putchar:
877 case LibFunc_putchar_unlocked:
878 Changed |= setRetAndArgsNoUndef(F);
879 Changed |= setDoesNotThrow(F);
880 break;
881 case LibFunc_popen:
882 Changed |= setRetAndArgsNoUndef(F);
883 Changed |= setDoesNotThrow(F);
884 Changed |= setRetDoesNotAlias(F);
885 Changed |= setDoesNotCapture(F, 0);
886 Changed |= setDoesNotCapture(F, 1);
887 Changed |= setOnlyReadsMemory(F, 0);
888 Changed |= setOnlyReadsMemory(F, 1);
889 break;
890 case LibFunc_pclose:
891 Changed |= setRetAndArgsNoUndef(F);
892 Changed |= setDoesNotThrow(F);
893 Changed |= setDoesNotCapture(F, 0);
894 break;
895 case LibFunc_vscanf:
896 Changed |= setRetAndArgsNoUndef(F);
897 Changed |= setDoesNotThrow(F);
898 Changed |= setDoesNotCapture(F, 0);
899 Changed |= setOnlyReadsMemory(F, 0);
900 break;
901 case LibFunc_vsscanf:
902 Changed |= setRetAndArgsNoUndef(F);
903 Changed |= setDoesNotThrow(F);
904 Changed |= setDoesNotCapture(F, 0);
905 Changed |= setDoesNotCapture(F, 1);
906 Changed |= setOnlyReadsMemory(F, 0);
907 Changed |= setOnlyReadsMemory(F, 1);
908 break;
909 case LibFunc_vfscanf:
910 Changed |= setRetAndArgsNoUndef(F);
911 Changed |= setDoesNotThrow(F);
912 Changed |= setDoesNotCapture(F, 0);
913 Changed |= setDoesNotCapture(F, 1);
914 Changed |= setOnlyReadsMemory(F, 1);
915 break;
916 case LibFunc_vprintf:
917 Changed |= setRetAndArgsNoUndef(F);
918 Changed |= setDoesNotThrow(F);
919 Changed |= setDoesNotCapture(F, 0);
920 Changed |= setOnlyReadsMemory(F, 0);
921 break;
922 case LibFunc_vfprintf:
923 case LibFunc_vsprintf:
924 Changed |= setRetAndArgsNoUndef(F);
925 Changed |= setDoesNotThrow(F);
926 Changed |= setDoesNotCapture(F, 0);
927 Changed |= setDoesNotCapture(F, 1);
928 Changed |= setOnlyReadsMemory(F, 1);
929 break;
930 case LibFunc_vsnprintf:
931 Changed |= setRetAndArgsNoUndef(F);
932 Changed |= setDoesNotThrow(F);
933 Changed |= setDoesNotCapture(F, 0);
934 Changed |= setDoesNotCapture(F, 2);
935 Changed |= setOnlyReadsMemory(F, 2);
936 break;
937 case LibFunc_open:
938 // May throw; "open" is a valid pthread cancellation point.
939 Changed |= setRetAndArgsNoUndef(F);
940 Changed |= setDoesNotCapture(F, 0);
941 Changed |= setOnlyReadsMemory(F, 0);
942 break;
943 case LibFunc_opendir:
944 Changed |= setRetAndArgsNoUndef(F);
945 Changed |= setDoesNotThrow(F);
946 Changed |= setRetDoesNotAlias(F);
947 Changed |= setDoesNotCapture(F, 0);
948 Changed |= setOnlyReadsMemory(F, 0);
949 break;
950 case LibFunc_tmpfile:
951 Changed |= setRetAndArgsNoUndef(F);
952 Changed |= setDoesNotThrow(F);
953 Changed |= setRetDoesNotAlias(F);
954 break;
955 case LibFunc_times:
956 Changed |= setRetAndArgsNoUndef(F);
957 Changed |= setDoesNotThrow(F);
958 Changed |= setDoesNotCapture(F, 0);
959 break;
960 case LibFunc_htonl:
961 case LibFunc_htons:
962 case LibFunc_ntohl:
963 case LibFunc_ntohs:
964 Changed |= setDoesNotThrow(F);
965 Changed |= setDoesNotAccessMemory(F);
966 break;
967 case LibFunc_lstat:
968 Changed |= setRetAndArgsNoUndef(F);
969 Changed |= setDoesNotThrow(F);
970 Changed |= setDoesNotCapture(F, 0);
971 Changed |= setDoesNotCapture(F, 1);
972 Changed |= setOnlyReadsMemory(F, 0);
973 break;
974 case LibFunc_lchown:
975 Changed |= setRetAndArgsNoUndef(F);
976 Changed |= setDoesNotThrow(F);
977 Changed |= setDoesNotCapture(F, 0);
978 Changed |= setOnlyReadsMemory(F, 0);
979 break;
980 case LibFunc_qsort:
981 // May throw; places call through function pointer.
982 // Cannot give undef pointer/size
983 Changed |= setRetAndArgsNoUndef(F);
984 Changed |= setDoesNotCapture(F, 3);
985 break;
986 case LibFunc_dunder_strndup:
987 Changed |= setArgNoUndef(F, 1);
988 [[fallthrough]];
989 case LibFunc_dunder_strdup:
990 Changed |= setDoesNotThrow(F);
991 Changed |= setRetDoesNotAlias(F);
992 Changed |= setWillReturn(F);
993 Changed |= setDoesNotCapture(F, 0);
994 Changed |= setOnlyReadsMemory(F, 0);
995 break;
996 case LibFunc_dunder_strtok_r:
997 Changed |= setDoesNotThrow(F);
998 Changed |= setDoesNotCapture(F, 1);
999 Changed |= setOnlyReadsMemory(F, 1);
1000 break;
1001 case LibFunc_under_IO_getc:
1002 Changed |= setRetAndArgsNoUndef(F);
1003 Changed |= setDoesNotThrow(F);
1004 Changed |= setDoesNotCapture(F, 0);
1005 break;
1006 case LibFunc_under_IO_putc:
1007 Changed |= setRetAndArgsNoUndef(F);
1008 Changed |= setDoesNotThrow(F);
1009 Changed |= setDoesNotCapture(F, 1);
1010 break;
1011 case LibFunc_dunder_isoc99_scanf:
1012 Changed |= setRetAndArgsNoUndef(F);
1013 Changed |= setDoesNotThrow(F);
1014 Changed |= setDoesNotCapture(F, 0);
1015 Changed |= setOnlyReadsMemory(F, 0);
1016 break;
1017 case LibFunc_stat64:
1018 case LibFunc_lstat64:
1019 case LibFunc_statvfs64:
1020 Changed |= setRetAndArgsNoUndef(F);
1021 Changed |= setDoesNotThrow(F);
1022 Changed |= setDoesNotCapture(F, 0);
1023 Changed |= setDoesNotCapture(F, 1);
1024 Changed |= setOnlyReadsMemory(F, 0);
1025 break;
1026 case LibFunc_dunder_isoc99_sscanf:
1027 Changed |= setRetAndArgsNoUndef(F);
1028 Changed |= setDoesNotThrow(F);
1029 Changed |= setDoesNotCapture(F, 0);
1030 Changed |= setDoesNotCapture(F, 1);
1031 Changed |= setOnlyReadsMemory(F, 0);
1032 Changed |= setOnlyReadsMemory(F, 1);
1033 break;
1034 case LibFunc_fopen64:
1035 Changed |= setRetAndArgsNoUndef(F);
1036 Changed |= setDoesNotThrow(F);
1037 Changed |= setRetDoesNotAlias(F);
1038 Changed |= setDoesNotCapture(F, 0);
1039 Changed |= setDoesNotCapture(F, 1);
1040 Changed |= setOnlyReadsMemory(F, 0);
1041 Changed |= setOnlyReadsMemory(F, 1);
1042 break;
1043 case LibFunc_fseeko64:
1044 case LibFunc_ftello64:
1045 Changed |= setRetAndArgsNoUndef(F);
1046 Changed |= setDoesNotThrow(F);
1047 Changed |= setDoesNotCapture(F, 0);
1048 break;
1049 case LibFunc_tmpfile64:
1050 Changed |= setRetAndArgsNoUndef(F);
1051 Changed |= setDoesNotThrow(F);
1052 Changed |= setRetDoesNotAlias(F);
1053 break;
1054 case LibFunc_fstat64:
1055 case LibFunc_fstatvfs64:
1056 Changed |= setRetAndArgsNoUndef(F);
1057 Changed |= setDoesNotThrow(F);
1058 Changed |= setDoesNotCapture(F, 1);
1059 break;
1060 case LibFunc_open64:
1061 // May throw; "open" is a valid pthread cancellation point.
1062 Changed |= setRetAndArgsNoUndef(F);
1063 Changed |= setDoesNotCapture(F, 0);
1064 Changed |= setOnlyReadsMemory(F, 0);
1065 break;
1066 case LibFunc_gettimeofday:
1067 // Currently some platforms have the restrict keyword on the arguments to
1068 // gettimeofday. To be conservative, do not add noalias to gettimeofday's
1069 // arguments.
1070 Changed |= setRetAndArgsNoUndef(F);
1071 Changed |= setDoesNotThrow(F);
1072 Changed |= setDoesNotCapture(F, 0);
1073 Changed |= setDoesNotCapture(F, 1);
1074 break;
1075 case LibFunc_memset_pattern4:
1076 case LibFunc_memset_pattern8:
1077 case LibFunc_memset_pattern16:
1078 Changed |= setDoesNotCapture(F, 0);
1079 Changed |= setDoesNotCapture(F, 1);
1080 Changed |= setOnlyReadsMemory(F, 1);
1081 [[fallthrough]];
1082 case LibFunc_memset:
1083 Changed |= setWillReturn(F);
1084 [[fallthrough]];
1085 case LibFunc_memset_chk:
1086 Changed |= setOnlyAccessesArgMemory(F);
1087 Changed |= setOnlyWritesMemory(F, 0);
1088 Changed |= setDoesNotThrow(F);
1089 break;
1090 // int __nvvm_reflect(const char *)
1091 case LibFunc_nvvm_reflect:
1092 Changed |= setRetAndArgsNoUndef(F);
1093 Changed |= setDoesNotAccessMemory(F);
1094 Changed |= setDoesNotThrow(F);
1095 break;
1096 case LibFunc_ldexp:
1097 case LibFunc_ldexpf:
1098 case LibFunc_ldexpl:
1099 Changed |= setWillReturn(F);
1100 break;
1101 case LibFunc_abs:
1102 case LibFunc_acos:
1103 case LibFunc_acosf:
1104 case LibFunc_acosh:
1105 case LibFunc_acoshf:
1106 case LibFunc_acoshl:
1107 case LibFunc_acosl:
1108 case LibFunc_asin:
1109 case LibFunc_asinf:
1110 case LibFunc_asinh:
1111 case LibFunc_asinhf:
1112 case LibFunc_asinhl:
1113 case LibFunc_asinl:
1114 case LibFunc_atan:
1115 case LibFunc_atan2:
1116 case LibFunc_atan2f:
1117 case LibFunc_atan2l:
1118 case LibFunc_atanf:
1119 case LibFunc_atanh:
1120 case LibFunc_atanhf:
1121 case LibFunc_atanhl:
1122 case LibFunc_atanl:
1123 case LibFunc_cbrt:
1124 case LibFunc_cbrtf:
1125 case LibFunc_cbrtl:
1126 case LibFunc_ceil:
1127 case LibFunc_ceilf:
1128 case LibFunc_ceill:
1129 case LibFunc_copysign:
1130 case LibFunc_copysignf:
1131 case LibFunc_copysignl:
1132 case LibFunc_cos:
1133 case LibFunc_cosh:
1134 case LibFunc_coshf:
1135 case LibFunc_coshl:
1136 case LibFunc_cosf:
1137 case LibFunc_cosl:
1138 case LibFunc_cospi:
1139 case LibFunc_cospif:
1140 case LibFunc_exp:
1141 case LibFunc_expf:
1142 case LibFunc_expl:
1143 case LibFunc_exp2:
1144 case LibFunc_exp2f:
1145 case LibFunc_exp2l:
1146 case LibFunc_expm1:
1147 case LibFunc_expm1f:
1148 case LibFunc_expm1l:
1149 case LibFunc_fabs:
1150 case LibFunc_fabsf:
1151 case LibFunc_fabsl:
1152 case LibFunc_ffs:
1153 case LibFunc_ffsl:
1154 case LibFunc_ffsll:
1155 case LibFunc_floor:
1156 case LibFunc_floorf:
1157 case LibFunc_floorl:
1158 case LibFunc_fls:
1159 case LibFunc_flsl:
1160 case LibFunc_flsll:
1161 case LibFunc_fmax:
1162 case LibFunc_fmaxf:
1163 case LibFunc_fmaxl:
1164 case LibFunc_fmin:
1165 case LibFunc_fminf:
1166 case LibFunc_fminl:
1167 case LibFunc_fmod:
1168 case LibFunc_fmodf:
1169 case LibFunc_fmodl:
1170 case LibFunc_isascii:
1171 case LibFunc_isdigit:
1172 case LibFunc_labs:
1173 case LibFunc_llabs:
1174 case LibFunc_log:
1175 case LibFunc_log10:
1176 case LibFunc_log10f:
1177 case LibFunc_log10l:
1178 case LibFunc_log1p:
1179 case LibFunc_log1pf:
1180 case LibFunc_log1pl:
1181 case LibFunc_log2:
1182 case LibFunc_log2f:
1183 case LibFunc_log2l:
1184 case LibFunc_logb:
1185 case LibFunc_logbf:
1186 case LibFunc_logbl:
1187 case LibFunc_logf:
1188 case LibFunc_logl:
1189 case LibFunc_nearbyint:
1190 case LibFunc_nearbyintf:
1191 case LibFunc_nearbyintl:
1192 case LibFunc_pow:
1193 case LibFunc_powf:
1194 case LibFunc_powl:
1195 case LibFunc_rint:
1196 case LibFunc_rintf:
1197 case LibFunc_rintl:
1198 case LibFunc_round:
1199 case LibFunc_roundf:
1200 case LibFunc_roundl:
1201 case LibFunc_sin:
1202 case LibFunc_sincospif_stret:
1203 case LibFunc_sinf:
1204 case LibFunc_sinh:
1205 case LibFunc_sinhf:
1206 case LibFunc_sinhl:
1207 case LibFunc_sinl:
1208 case LibFunc_sinpi:
1209 case LibFunc_sinpif:
1210 case LibFunc_sqrt:
1211 case LibFunc_sqrtf:
1212 case LibFunc_sqrtl:
1213 case LibFunc_tan:
1214 case LibFunc_tanf:
1215 case LibFunc_tanh:
1216 case LibFunc_tanhf:
1217 case LibFunc_tanhl:
1218 case LibFunc_tanl:
1219 case LibFunc_toascii:
1220 case LibFunc_trunc:
1221 case LibFunc_truncf:
1222 case LibFunc_truncl:
1223 Changed |= setDoesNotThrow(F);
1224 Changed |= setDoesNotFreeMemory(F);
1225 Changed |= setOnlyWritesMemory(F);
1226 Changed |= setWillReturn(F);
1227 break;
1228 default:
1229 // FIXME: It'd be really nice to cover all the library functions we're
1230 // aware of here.
1231 break;
1232 }
1233 // We have to do this step after AllocKind has been inferred on functions so
1234 // we can reliably identify free-like and realloc-like functions.
1235 if (!isLibFreeFunction(&F, TheLibFunc) && !isReallocLikeFn(&F))
1236 Changed |= setDoesNotFreeMemory(F);
1237 return Changed;
1238}
1239
1240static void setArgExtAttr(Function &F, unsigned ArgNo,
1241 const TargetLibraryInfo &TLI, bool Signed = true) {
1242 Attribute::AttrKind ExtAttr = TLI.getExtAttrForI32Param(Signed);
1243 if (ExtAttr != Attribute::None && !F.hasParamAttribute(ArgNo, ExtAttr))
1244 F.addParamAttr(ArgNo, ExtAttr);
1245}
1246
1247static void setRetExtAttr(Function &F,
1248 const TargetLibraryInfo &TLI, bool Signed = true) {
1249 Attribute::AttrKind ExtAttr = TLI.getExtAttrForI32Return(Signed);
1250 if (ExtAttr != Attribute::None && !F.hasRetAttribute(ExtAttr))
1251 F.addRetAttr(ExtAttr);
1252}
1253
1254// Modeled after X86TargetLowering::markLibCallAttributes.
1255static void markRegisterParameterAttributes(Function *F) {
1256 if (!F->arg_size() || F->isVarArg())
1257 return;
1258
1259 const CallingConv::ID CC = F->getCallingConv();
1260 if (CC != CallingConv::C && CC != CallingConv::X86_StdCall)
1261 return;
1262
1263 const Module *M = F->getParent();
1264 unsigned N = M->getNumberRegisterParameters();
1265 if (!N)
1266 return;
1267
1268 const DataLayout &DL = M->getDataLayout();
1269
1270 for (Argument &A : F->args()) {
1271 Type *T = A.getType();
1272 if (!T->isIntOrPtrTy())
1273 continue;
1274
1275 const TypeSize &TS = DL.getTypeAllocSize(T);
1276 if (TS > 8)
1277 continue;
1278
1279 assert(TS <= 4 && "Need to account for parameters larger than word size");
1280 const unsigned NumRegs = TS > 4 ? 2 : 1;
1281 if (N < NumRegs)
1282 return;
1283
1284 N -= NumRegs;
1285 F->addParamAttr(A.getArgNo(), Attribute::InReg);
1286 }
1287}
1288
1289FunctionCallee llvm::getOrInsertLibFunc(Module *M, const TargetLibraryInfo &TLI,
1290 LibFunc TheLibFunc, FunctionType *T,
1291 AttributeList AttributeList) {
1292 assert(TLI.has(TheLibFunc) &&
1293 "Creating call to non-existing library function.");
1294 StringRef Name = TLI.getName(TheLibFunc);
1295 FunctionCallee C = M->getOrInsertFunction(Name, T, AttributeList);
1296
1297 // Make sure any mandatory argument attributes are added.
1298
1299 // Any outgoing i32 argument should be handled with setArgExtAttr() which
1300 // will add an extension attribute if the target ABI requires it. Adding
1301 // argument extensions is typically done by the front end but when an
1302 // optimizer is building a library call on its own it has to take care of
1303 // this. Each such generated function must be handled here with sign or
1304 // zero extensions as needed. F is retreived with cast<> because we demand
1305 // of the caller to have called isLibFuncEmittable() first.
1306 Function *F = cast<Function>(C.getCallee());
1307 assert(F->getFunctionType() == T && "Function type does not match.");
1308 switch (TheLibFunc) {
1309 case LibFunc_fputc:
1310 case LibFunc_putchar:
1311 setArgExtAttr(*F, 0, TLI);
1312 break;
1313 case LibFunc_ldexp:
1314 case LibFunc_ldexpf:
1315 case LibFunc_ldexpl:
1316 case LibFunc_memchr:
1317 case LibFunc_memrchr:
1318 case LibFunc_strchr:
1319 setArgExtAttr(*F, 1, TLI);
1320 break;
1321 case LibFunc_memccpy:
1322 setArgExtAttr(*F, 2, TLI);
1323 break;
1324
1325 // These are functions that are known to not need any argument extension
1326 // on any target: A size_t argument (which may be an i32 on some targets)
1327 // should not trigger the assert below.
1328 case LibFunc_bcmp:
1329 setRetExtAttr(*F, TLI);
1330 break;
1331 case LibFunc_calloc:
1332 case LibFunc_fwrite:
1333 case LibFunc_malloc:
1334 case LibFunc_memcmp:
1335 case LibFunc_memcpy_chk:
1336 case LibFunc_mempcpy:
1337 case LibFunc_memset_pattern16:
1338 case LibFunc_snprintf:
1339 case LibFunc_stpncpy:
1340 case LibFunc_strlcat:
1341 case LibFunc_strlcpy:
1342 case LibFunc_strncat:
1343 case LibFunc_strncmp:
1344 case LibFunc_strncpy:
1345 case LibFunc_vsnprintf:
1346 break;
1347
1348 default:
1349#ifndef NDEBUG
1350 for (unsigned i = 0; i < T->getNumParams(); i++)
1351 assert(!isa<IntegerType>(T->getParamType(i)) &&
1352 "Unhandled integer argument.");
1353#endif
1354 break;
1355 }
1356
1357 markRegisterParameterAttributes(F);
1358
1359 return C;
1360}
1361
1362FunctionCallee llvm::getOrInsertLibFunc(Module *M, const TargetLibraryInfo &TLI,
1363 LibFunc TheLibFunc, FunctionType *T) {
1364 return getOrInsertLibFunc(M, TLI, TheLibFunc, T, AttributeList());
1365}
1366
1367bool llvm::isLibFuncEmittable(const Module *M, const TargetLibraryInfo *TLI,
1368 LibFunc TheLibFunc) {
1369 StringRef FuncName = TLI->getName(TheLibFunc);
1370 if (!TLI->has(TheLibFunc))
1371 return false;
1372
1373 // Check if the Module already has a GlobalValue with the same name, in
1374 // which case it must be a Function with the expected type.
1375 if (GlobalValue *GV = M->getNamedValue(FuncName)) {
1376 if (auto *F = dyn_cast<Function>(GV))
1377 return TLI->isValidProtoForLibFunc(*F->getFunctionType(), TheLibFunc, *M);
1378 return false;
1379 }
1380
1381 return true;
1382}
1383
1384bool llvm::isLibFuncEmittable(const Module *M, const TargetLibraryInfo *TLI,
1385 StringRef Name) {
1386 LibFunc TheLibFunc;
1387 return TLI->getLibFunc(Name, TheLibFunc) &&
1388 isLibFuncEmittable(M, TLI, TheLibFunc);
1389}
1390
1391bool llvm::hasFloatFn(const Module *M, const TargetLibraryInfo *TLI, Type *Ty,
1392 LibFunc DoubleFn, LibFunc FloatFn, LibFunc LongDoubleFn) {
1393 switch (Ty->getTypeID()) {
1394 case Type::HalfTyID:
1395 return false;
1396 case Type::FloatTyID:
1397 return isLibFuncEmittable(M, TLI, FloatFn);
1398 case Type::DoubleTyID:
1399 return isLibFuncEmittable(M, TLI, DoubleFn);
1400 default:
1401 return isLibFuncEmittable(M, TLI, LongDoubleFn);
1402 }
1403}
1404
1405StringRef llvm::getFloatFn(const Module *M, const TargetLibraryInfo *TLI,
1406 Type *Ty, LibFunc DoubleFn, LibFunc FloatFn,
1407 LibFunc LongDoubleFn, LibFunc &TheLibFunc) {
1408 assert(hasFloatFn(M, TLI, Ty, DoubleFn, FloatFn, LongDoubleFn) &&
1409 "Cannot get name for unavailable function!");
1410
1411 switch (Ty->getTypeID()) {
1412 case Type::HalfTyID:
1413 llvm_unreachable("No name for HalfTy!");
1414 case Type::FloatTyID:
1415 TheLibFunc = FloatFn;
1416 return TLI->getName(FloatFn);
1417 case Type::DoubleTyID:
1418 TheLibFunc = DoubleFn;
1419 return TLI->getName(DoubleFn);
1420 default:
1421 TheLibFunc = LongDoubleFn;
1422 return TLI->getName(LongDoubleFn);
1423 }
1424}
1425
1426//- Emit LibCalls ------------------------------------------------------------//
1427
1428Value *llvm::castToCStr(Value *V, IRBuilderBase &B) {
1429 unsigned AS = V->getType()->getPointerAddressSpace();
1430 return B.CreateBitCast(V, B.getInt8PtrTy(AS), "cstr");
1431}
1432
1433static IntegerType *getIntTy(IRBuilderBase &B, const TargetLibraryInfo *TLI) {
1434 return B.getIntNTy(TLI->getIntSize());
1435}
1436
1437static IntegerType *getSizeTTy(IRBuilderBase &B, const TargetLibraryInfo *TLI) {
1438 const Module *M = B.GetInsertBlock()->getModule();
1439 return B.getIntNTy(TLI->getSizeTSize(*M));
1440}
1441
1442static Value *emitLibCall(LibFunc TheLibFunc, Type *ReturnType,
1443 ArrayRef<Type *> ParamTypes,
1444 ArrayRef<Value *> Operands, IRBuilderBase &B,
1445 const TargetLibraryInfo *TLI,
1446 bool IsVaArgs = false) {
1447 Module *M = B.GetInsertBlock()->getModule();
1448 if (!isLibFuncEmittable(M, TLI, TheLibFunc))
1449 return nullptr;
1450
1451 StringRef FuncName = TLI->getName(TheLibFunc);
1452 FunctionType *FuncType = FunctionType::get(ReturnType, ParamTypes, IsVaArgs);
1453 FunctionCallee Callee = getOrInsertLibFunc(M, *TLI, TheLibFunc, FuncType);
1454 inferNonMandatoryLibFuncAttrs(M, FuncName, *TLI);
1455 CallInst *CI = B.CreateCall(Callee, Operands, FuncName);
1456 if (const Function *F =
1457 dyn_cast<Function>(Callee.getCallee()->stripPointerCasts()))
1458 CI->setCallingConv(F->getCallingConv());
1459 return CI;
1460}
1461
1462Value *llvm::emitStrLen(Value *Ptr, IRBuilderBase &B, const DataLayout &DL,
1463 const TargetLibraryInfo *TLI) {
1464 Type *SizeTTy = getSizeTTy(B, TLI);
1465 return emitLibCall(LibFunc_strlen, SizeTTy,
1466 B.getInt8PtrTy(), castToCStr(Ptr, B), B, TLI);
1467}
1468
1469Value *llvm::emitStrDup(Value *Ptr, IRBuilderBase &B,
1470 const TargetLibraryInfo *TLI) {
1471 return emitLibCall(LibFunc_strdup, B.getInt8PtrTy(), B.getInt8PtrTy(),
1472 castToCStr(Ptr, B), B, TLI);
1473}
1474
1475Value *llvm::emitStrChr(Value *Ptr, char C, IRBuilderBase &B,
1476 const TargetLibraryInfo *TLI) {
1477 Type *I8Ptr = B.getInt8PtrTy();
1478 Type *IntTy = getIntTy(B, TLI);
1479 return emitLibCall(LibFunc_strchr, I8Ptr, {I8Ptr, IntTy},
1480 {castToCStr(Ptr, B), ConstantInt::get(IntTy, C)}, B, TLI);
1481}
1482
1483Value *llvm::emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
1484 const DataLayout &DL, const TargetLibraryInfo *TLI) {
1485 Type *IntTy = getIntTy(B, TLI);
1486 Type *SizeTTy = getSizeTTy(B, TLI);
1487 return emitLibCall(
1488 LibFunc_strncmp, IntTy,
1489 {B.getInt8PtrTy(), B.getInt8PtrTy(), SizeTTy},
1490 {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI);
1491}
1492
1493Value *llvm::emitStrCpy(Value *Dst, Value *Src, IRBuilderBase &B,
1494 const TargetLibraryInfo *TLI) {
1495 Type *I8Ptr = Dst->getType();
1496 return emitLibCall(LibFunc_strcpy, I8Ptr, {I8Ptr, I8Ptr},
1497 {castToCStr(Dst, B), castToCStr(Src, B)}, B, TLI);
1498}
1499
1500Value *llvm::emitStpCpy(Value *Dst, Value *Src, IRBuilderBase &B,
1501 const TargetLibraryInfo *TLI) {
1502 Type *I8Ptr = B.getInt8PtrTy();
1503 return emitLibCall(LibFunc_stpcpy, I8Ptr, {I8Ptr, I8Ptr},
1504 {castToCStr(Dst, B), castToCStr(Src, B)}, B, TLI);
1505}
1506
1507Value *llvm::emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B,
1508 const TargetLibraryInfo *TLI) {
1509 Type *I8Ptr = B.getInt8PtrTy();
1510 Type *SizeTTy = getSizeTTy(B, TLI);
1511 return emitLibCall(LibFunc_strncpy, I8Ptr, {I8Ptr, I8Ptr, SizeTTy},
1512 {castToCStr(Dst, B), castToCStr(Src, B), Len}, B, TLI);
1513}
1514
1515Value *llvm::emitStpNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B,
1516 const TargetLibraryInfo *TLI) {
1517 Type *I8Ptr = B.getInt8PtrTy();
1518 Type *SizeTTy = getSizeTTy(B, TLI);
1519 return emitLibCall(LibFunc_stpncpy, I8Ptr, {I8Ptr, I8Ptr, SizeTTy},
1520 {castToCStr(Dst, B), castToCStr(Src, B), Len}, B, TLI);
1521}
1522
1523Value *llvm::emitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize,
1524 IRBuilderBase &B, const DataLayout &DL,
1525 const TargetLibraryInfo *TLI) {
1526 Module *M = B.GetInsertBlock()->getModule();
1527 if (!isLibFuncEmittable(M, TLI, LibFunc_memcpy_chk))
1528 return nullptr;
1529
1530 AttributeList AS;
1531 AS = AttributeList::get(M->getContext(), AttributeList::FunctionIndex,
1532 Attribute::NoUnwind);
1533 Type *I8Ptr = B.getInt8PtrTy();
1534 Type *SizeTTy = getSizeTTy(B, TLI);
1535 FunctionCallee MemCpy = getOrInsertLibFunc(M, *TLI, LibFunc_memcpy_chk,
1536 AttributeList::get(M->getContext(), AS), I8Ptr,
1537 I8Ptr, I8Ptr, SizeTTy, SizeTTy);
1538 Dst = castToCStr(Dst, B);
1539 Src = castToCStr(Src, B);
1540 CallInst *CI = B.CreateCall(MemCpy, {Dst, Src, Len, ObjSize});
1541 if (const Function *F =
1542 dyn_cast<Function>(MemCpy.getCallee()->stripPointerCasts()))
1543 CI->setCallingConv(F->getCallingConv());
1544 return CI;
1545}
1546
1547Value *llvm::emitMemPCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B,
1548 const DataLayout &DL, const TargetLibraryInfo *TLI) {
1549 Type *I8Ptr = B.getInt8PtrTy();
1550 Type *SizeTTy = getSizeTTy(B, TLI);
1551 return emitLibCall(LibFunc_mempcpy, I8Ptr,
1552 {I8Ptr, I8Ptr, SizeTTy},
1553 {Dst, Src, Len}, B, TLI);
1554}
1555
1556Value *llvm::emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilderBase &B,
1557 const DataLayout &DL, const TargetLibraryInfo *TLI) {
1558 Type *I8Ptr = B.getInt8PtrTy();
1559 Type *IntTy = getIntTy(B, TLI);
1560 Type *SizeTTy = getSizeTTy(B, TLI);
1561 return emitLibCall(LibFunc_memchr, I8Ptr,
1562 {I8Ptr, IntTy, SizeTTy},
1563 {castToCStr(Ptr, B), Val, Len}, B, TLI);
1564}
1565
1566Value *llvm::emitMemRChr(Value *Ptr, Value *Val, Value *Len, IRBuilderBase &B,
1567 const DataLayout &DL, const TargetLibraryInfo *TLI) {
1568 Type *I8Ptr = B.getInt8PtrTy();
1569 Type *IntTy = getIntTy(B, TLI);
1570 Type *SizeTTy = getSizeTTy(B, TLI);
1571 return emitLibCall(LibFunc_memrchr, I8Ptr,
1572 {I8Ptr, IntTy, SizeTTy},
1573 {castToCStr(Ptr, B), Val, Len}, B, TLI);
1574}
1575
1576Value *llvm::emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
1577 const DataLayout &DL, const TargetLibraryInfo *TLI) {
1578 Type *I8Ptr = B.getInt8PtrTy();
1579 Type *IntTy = getIntTy(B, TLI);
1580 Type *SizeTTy = getSizeTTy(B, TLI);
1581 return emitLibCall(LibFunc_memcmp, IntTy,
1582 {I8Ptr, I8Ptr, SizeTTy},
1583 {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI);
1584}
1585
1586Value *llvm::emitBCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
1587 const DataLayout &DL, const TargetLibraryInfo *TLI) {
1588 Type *I8Ptr = B.getInt8PtrTy();
1589 Type *IntTy = getIntTy(B, TLI);
1590 Type *SizeTTy = getSizeTTy(B, TLI);
1591 return emitLibCall(LibFunc_bcmp, IntTy,
1592 {I8Ptr, I8Ptr, SizeTTy},
1593 {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI);
1594}
1595
1596Value *llvm::emitMemCCpy(Value *Ptr1, Value *Ptr2, Value *Val, Value *Len,
1597 IRBuilderBase &B, const TargetLibraryInfo *TLI) {
1598 Type *I8Ptr = B.getInt8PtrTy();
1599 Type *IntTy = getIntTy(B, TLI);
1600 Type *SizeTTy = getSizeTTy(B, TLI);
1601 return emitLibCall(LibFunc_memccpy, I8Ptr,
1602 {I8Ptr, I8Ptr, IntTy, SizeTTy},
1603 {Ptr1, Ptr2, Val, Len}, B, TLI);
1604}
1605
1606Value *llvm::emitSNPrintf(Value *Dest, Value *Size, Value *Fmt,
1607 ArrayRef<Value *> VariadicArgs, IRBuilderBase &B,
1608 const TargetLibraryInfo *TLI) {
1609 Type *I8Ptr = B.getInt8PtrTy();
1610 Type *IntTy = getIntTy(B, TLI);
1611 Type *SizeTTy = getSizeTTy(B, TLI);
1612 SmallVector<Value *, 8> Args{castToCStr(Dest, B), Size, castToCStr(Fmt, B)};
1613 llvm::append_range(Args, VariadicArgs);
1614 return emitLibCall(LibFunc_snprintf, IntTy,
1615 {I8Ptr, SizeTTy, I8Ptr},
1616 Args, B, TLI, /*IsVaArgs=*/true);
1617}
1618
1619Value *llvm::emitSPrintf(Value *Dest, Value *Fmt,
1620 ArrayRef<Value *> VariadicArgs, IRBuilderBase &B,
1621 const TargetLibraryInfo *TLI) {
1622 Type *I8Ptr = B.getInt8PtrTy();
1623 Type *IntTy = getIntTy(B, TLI);
1624 SmallVector<Value *, 8> Args{castToCStr(Dest, B), castToCStr(Fmt, B)};
1625 llvm::append_range(Args, VariadicArgs);
1626 return emitLibCall(LibFunc_sprintf, IntTy,
1627 {I8Ptr, I8Ptr}, Args, B, TLI,
1628 /*IsVaArgs=*/true);
1629}
1630
1631Value *llvm::emitStrCat(Value *Dest, Value *Src, IRBuilderBase &B,
1632 const TargetLibraryInfo *TLI) {
1633 return emitLibCall(LibFunc_strcat, B.getInt8PtrTy(),
1634 {B.getInt8PtrTy(), B.getInt8PtrTy()},
1635 {castToCStr(Dest, B), castToCStr(Src, B)}, B, TLI);
1636}
1637
1638Value *llvm::emitStrLCpy(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
1639 const TargetLibraryInfo *TLI) {
1640 Type *I8Ptr = B.getInt8PtrTy();
1641 Type *SizeTTy = getSizeTTy(B, TLI);
1642 return emitLibCall(LibFunc_strlcpy, SizeTTy,
1643 {I8Ptr, I8Ptr, SizeTTy},
1644 {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI);
1645}
1646
1647Value *llvm::emitStrLCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
1648 const TargetLibraryInfo *TLI) {
1649 Type *I8Ptr = B.getInt8PtrTy();
1650 Type *SizeTTy = getSizeTTy(B, TLI);
1651 return emitLibCall(LibFunc_strlcat, SizeTTy,
1652 {I8Ptr, I8Ptr, SizeTTy},
1653 {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI);
1654}
1655
1656Value *llvm::emitStrNCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
1657 const TargetLibraryInfo *TLI) {
1658 Type *I8Ptr = B.getInt8PtrTy();
1659 Type *SizeTTy = getSizeTTy(B, TLI);
1660 return emitLibCall(LibFunc_strncat, I8Ptr,
1661 {I8Ptr, I8Ptr, SizeTTy},
1662 {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI);
1663}
1664
1665Value *llvm::emitVSNPrintf(Value *Dest, Value *Size, Value *Fmt, Value *VAList,
1666 IRBuilderBase &B, const TargetLibraryInfo *TLI) {
1667 Type *I8Ptr = B.getInt8PtrTy();
1668 Type *IntTy = getIntTy(B, TLI);
1669 Type *SizeTTy = getSizeTTy(B, TLI);
1670 return emitLibCall(
1671 LibFunc_vsnprintf, IntTy,
1672 {I8Ptr, SizeTTy, I8Ptr, VAList->getType()},
1673 {castToCStr(Dest, B), Size, castToCStr(Fmt, B), VAList}, B, TLI);
1674}
1675
1676Value *llvm::emitVSPrintf(Value *Dest, Value *Fmt, Value *VAList,
1677 IRBuilderBase &B, const TargetLibraryInfo *TLI) {
1678 Type *I8Ptr = B.getInt8PtrTy();
1679 Type *IntTy = getIntTy(B, TLI);
1680 return emitLibCall(LibFunc_vsprintf, IntTy,
1681 {I8Ptr, I8Ptr, VAList->getType()},
1682 {castToCStr(Dest, B), castToCStr(Fmt, B), VAList}, B, TLI);
1683}
1684
1685/// Append a suffix to the function name according to the type of 'Op'.
1686static void appendTypeSuffix(Value *Op, StringRef &Name,
1687 SmallString<20> &NameBuffer) {
1688 if (!Op->getType()->isDoubleTy()) {
1689 NameBuffer += Name;
1690
1691 if (Op->getType()->isFloatTy())
1692 NameBuffer += 'f';
1693 else
1694 NameBuffer += 'l';
1695
1696 Name = NameBuffer;
1697 }
1698}
1699
1700static Value *emitUnaryFloatFnCallHelper(Value *Op, LibFunc TheLibFunc,
1701 StringRef Name, IRBuilderBase &B,
1702 const AttributeList &Attrs,
1703 const TargetLibraryInfo *TLI) {
1704 assert((Name != "") && "Must specify Name to emitUnaryFloatFnCall");
1705
1706 Module *M = B.GetInsertBlock()->getModule();
1707 FunctionCallee Callee = getOrInsertLibFunc(M, *TLI, TheLibFunc, Op->getType(),
1708 Op->getType());
1709 CallInst *CI = B.CreateCall(Callee, Op, Name);
1710
1711 // The incoming attribute set may have come from a speculatable intrinsic, but
1712 // is being replaced with a library call which is not allowed to be
1713 // speculatable.
1714 CI->setAttributes(
1715 Attrs.removeFnAttribute(B.getContext(), Attribute::Speculatable));
1716 if (const Function *F =
1717 dyn_cast<Function>(Callee.getCallee()->stripPointerCasts()))
1718 CI->setCallingConv(F->getCallingConv());
1719
1720 return CI;
1721}
1722
1723Value *llvm::emitUnaryFloatFnCall(Value *Op, const TargetLibraryInfo *TLI,
1724 StringRef Name, IRBuilderBase &B,
1725 const AttributeList &Attrs) {
1726 SmallString<20> NameBuffer;
1727 appendTypeSuffix(Op, Name, NameBuffer);
1728
1729 LibFunc TheLibFunc;
1730 TLI->getLibFunc(Name, TheLibFunc);
1731
1732 return emitUnaryFloatFnCallHelper(Op, TheLibFunc, Name, B, Attrs, TLI);
1733}
1734
1735Value *llvm::emitUnaryFloatFnCall(Value *Op, const TargetLibraryInfo *TLI,
1736 LibFunc DoubleFn, LibFunc FloatFn,
1737 LibFunc LongDoubleFn, IRBuilderBase &B,
1738 const AttributeList &Attrs) {
1739 // Get the name of the function according to TLI.
1740 Module *M = B.GetInsertBlock()->getModule();
1741 LibFunc TheLibFunc;
1742 StringRef Name = getFloatFn(M, TLI, Op->getType(), DoubleFn, FloatFn,
1743 LongDoubleFn, TheLibFunc);
1744
1745 return emitUnaryFloatFnCallHelper(Op, TheLibFunc, Name, B, Attrs, TLI);
1746}
1747
1748static Value *emitBinaryFloatFnCallHelper(Value *Op1, Value *Op2,
1749 LibFunc TheLibFunc,
1750 StringRef Name, IRBuilderBase &B,
1751 const AttributeList &Attrs,
1752 const TargetLibraryInfo *TLI) {
1753 assert((Name != "") && "Must specify Name to emitBinaryFloatFnCall");
1754
1755 Module *M = B.GetInsertBlock()->getModule();
1756 FunctionCallee Callee = getOrInsertLibFunc(M, *TLI, TheLibFunc, Op1->getType(),
1757 Op1->getType(), Op2->getType());
1758 inferNonMandatoryLibFuncAttrs(M, Name, *TLI);
1759 CallInst *CI = B.CreateCall(Callee, { Op1, Op2 }, Name);
1760
1761 // The incoming attribute set may have come from a speculatable intrinsic, but
1762 // is being replaced with a library call which is not allowed to be
1763 // speculatable.
1764 CI->setAttributes(
1765 Attrs.removeFnAttribute(B.getContext(), Attribute::Speculatable));
1766 if (const Function *F =
1767 dyn_cast<Function>(Callee.getCallee()->stripPointerCasts()))
1768 CI->setCallingConv(F->getCallingConv());
1769
1770 return CI;
1771}
1772
1773Value *llvm::emitBinaryFloatFnCall(Value *Op1, Value *Op2,
1774 const TargetLibraryInfo *TLI,
1775 StringRef Name, IRBuilderBase &B,
1776 const AttributeList &Attrs) {
1777 assert((Name != "") && "Must specify Name to emitBinaryFloatFnCall");
1778
1779 SmallString<20> NameBuffer;
1780 appendTypeSuffix(Op1, Name, NameBuffer);
1781
1782 LibFunc TheLibFunc;
1783 TLI->getLibFunc(Name, TheLibFunc);
1784
1785 return emitBinaryFloatFnCallHelper(Op1, Op2, TheLibFunc, Name, B, Attrs, TLI);
1786}
1787
1788Value *llvm::emitBinaryFloatFnCall(Value *Op1, Value *Op2,
1789 const TargetLibraryInfo *TLI,
1790 LibFunc DoubleFn, LibFunc FloatFn,
1791 LibFunc LongDoubleFn, IRBuilderBase &B,
1792 const AttributeList &Attrs) {
1793 // Get the name of the function according to TLI.
1794 Module *M = B.GetInsertBlock()->getModule();
1795 LibFunc TheLibFunc;
1796 StringRef Name = getFloatFn(M, TLI, Op1->getType(), DoubleFn, FloatFn,
1797 LongDoubleFn, TheLibFunc);
1798
1799 return emitBinaryFloatFnCallHelper(Op1, Op2, TheLibFunc, Name, B, Attrs, TLI);
1800}
1801
1802// Emit a call to putchar(int) with Char as the argument. Char must have
1803// the same precision as int, which need not be 32 bits.
1804Value *llvm::emitPutChar(Value *Char, IRBuilderBase &B,
1805 const TargetLibraryInfo *TLI) {
1806 Module *M = B.GetInsertBlock()->getModule();
1807 if (!isLibFuncEmittable(M, TLI, LibFunc_putchar))
1808 return nullptr;
1809
1810 Type *IntTy = getIntTy(B, TLI);
1811 StringRef PutCharName = TLI->getName(LibFunc_putchar);
1812 FunctionCallee PutChar = getOrInsertLibFunc(M, *TLI, LibFunc_putchar,
1813 IntTy, IntTy);
1814 inferNonMandatoryLibFuncAttrs(M, PutCharName, *TLI);
1815 CallInst *CI = B.CreateCall(PutChar, Char, PutCharName);
1816
1817 if (const Function *F =
1818 dyn_cast<Function>(PutChar.getCallee()->stripPointerCasts()))
1819 CI->setCallingConv(F->getCallingConv());
1820 return CI;
1821}
1822
1823Value *llvm::emitPutS(Value *Str, IRBuilderBase &B,
1824 const TargetLibraryInfo *TLI) {
1825 Module *M = B.GetInsertBlock()->getModule();
1826 if (!isLibFuncEmittable(M, TLI, LibFunc_puts))
1827 return nullptr;
1828
1829 Type *IntTy = getIntTy(B, TLI);
1830 StringRef PutsName = TLI->getName(LibFunc_puts);
1831 FunctionCallee PutS = getOrInsertLibFunc(M, *TLI, LibFunc_puts, IntTy,
1832 B.getInt8PtrTy());
1833 inferNonMandatoryLibFuncAttrs(M, PutsName, *TLI);
1834 CallInst *CI = B.CreateCall(PutS, castToCStr(Str, B), PutsName);
1835 if (const Function *F =
1836 dyn_cast<Function>(PutS.getCallee()->stripPointerCasts()))
1837 CI->setCallingConv(F->getCallingConv());
1838 return CI;
1839}
1840
1841Value *llvm::emitFPutC(Value *Char, Value *File, IRBuilderBase &B,
1842 const TargetLibraryInfo *TLI) {
1843 Module *M = B.GetInsertBlock()->getModule();
1844 if (!isLibFuncEmittable(M, TLI, LibFunc_fputc))
1845 return nullptr;
1846
1847 Type *IntTy = getIntTy(B, TLI);
1848 StringRef FPutcName = TLI->getName(LibFunc_fputc);
1849 FunctionCallee F = getOrInsertLibFunc(M, *TLI, LibFunc_fputc, IntTy,
1850 IntTy, File->getType());
1851 if (File->getType()->isPointerTy())
1852 inferNonMandatoryLibFuncAttrs(M, FPutcName, *TLI);
1853 CallInst *CI = B.CreateCall(F, {Char, File}, FPutcName);
1854
1855 if (const Function *Fn =
1856 dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
1857 CI->setCallingConv(Fn->getCallingConv());
1858 return CI;
1859}
1860
1861Value *llvm::emitFPutS(Value *Str, Value *File, IRBuilderBase &B,
1862 const TargetLibraryInfo *TLI) {
1863 Module *M = B.GetInsertBlock()->getModule();
1864 if (!isLibFuncEmittable(M, TLI, LibFunc_fputs))
1865 return nullptr;
1866
1867 Type *IntTy = getIntTy(B, TLI);
1868 StringRef FPutsName = TLI->getName(LibFunc_fputs);
1869 FunctionCallee F = getOrInsertLibFunc(M, *TLI, LibFunc_fputs, IntTy,
1870 B.getInt8PtrTy(), File->getType());
1871 if (File->getType()->isPointerTy())
1872 inferNonMandatoryLibFuncAttrs(M, FPutsName, *TLI);
1873 CallInst *CI = B.CreateCall(F, {castToCStr(Str, B), File}, FPutsName);
1874
1875 if (const Function *Fn =
1876 dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
1877 CI->setCallingConv(Fn->getCallingConv());
1878 return CI;
1879}
1880
1881Value *llvm::emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilderBase &B,
1882 const DataLayout &DL, const TargetLibraryInfo *TLI) {
1883 Module *M = B.GetInsertBlock()->getModule();
1884 if (!isLibFuncEmittable(M, TLI, LibFunc_fwrite))
1885 return nullptr;
1886
1887 Type *SizeTTy = getSizeTTy(B, TLI);
1888 StringRef FWriteName = TLI->getName(LibFunc_fwrite);
1889 FunctionCallee F = getOrInsertLibFunc(M, *TLI, LibFunc_fwrite,
1890 SizeTTy, B.getInt8PtrTy(), SizeTTy,
1891 SizeTTy, File->getType());
1892
1893 if (File->getType()->isPointerTy())
1894 inferNonMandatoryLibFuncAttrs(M, FWriteName, *TLI);
1895 CallInst *CI =
1896 B.CreateCall(F, {castToCStr(Ptr, B), Size,
1897 ConstantInt::get(SizeTTy, 1), File});
1898
1899 if (const Function *Fn =
1900 dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
1901 CI->setCallingConv(Fn->getCallingConv());
1902 return CI;
1903}
1904
1905Value *llvm::emitMalloc(Value *Num, IRBuilderBase &B, const DataLayout &DL,
1906 const TargetLibraryInfo *TLI) {
1907 Module *M = B.GetInsertBlock()->getModule();
1908 if (!isLibFuncEmittable(M, TLI, LibFunc_malloc))
1909 return nullptr;
1910
1911 StringRef MallocName = TLI->getName(LibFunc_malloc);
1912 Type *SizeTTy = getSizeTTy(B, TLI);
1913 FunctionCallee Malloc = getOrInsertLibFunc(M, *TLI, LibFunc_malloc,
1914 B.getInt8PtrTy(), SizeTTy);
1915 inferNonMandatoryLibFuncAttrs(M, MallocName, *TLI);
1916 CallInst *CI = B.CreateCall(Malloc, Num, MallocName);
1917
1918 if (const Function *F =
1919 dyn_cast<Function>(Malloc.getCallee()->stripPointerCasts()))
1920 CI->setCallingConv(F->getCallingConv());
1921
1922 return CI;
1923}
1924
1925Value *llvm::emitCalloc(Value *Num, Value *Size, IRBuilderBase &B,
1926 const TargetLibraryInfo &TLI) {
1927 Module *M = B.GetInsertBlock()->getModule();
1928 if (!isLibFuncEmittable(M, &TLI, LibFunc_calloc))
1929 return nullptr;
1930
1931 StringRef CallocName = TLI.getName(LibFunc_calloc);
1932 Type *SizeTTy = getSizeTTy(B, &TLI);
1933 FunctionCallee Calloc = getOrInsertLibFunc(M, TLI, LibFunc_calloc,
1934 B.getInt8PtrTy(), SizeTTy, SizeTTy);
1935 inferNonMandatoryLibFuncAttrs(M, CallocName, TLI);
1936 CallInst *CI = B.CreateCall(Calloc, {Num, Size}, CallocName);
1937
1938 if (const auto *F =
1939 dyn_cast<Function>(Calloc.getCallee()->stripPointerCasts()))
1940 CI->setCallingConv(F->getCallingConv());
1941
1942 return CI;
1943}
1944
1945Value *llvm::emitHotColdNew(Value *Num, IRBuilderBase &B,
1946 const TargetLibraryInfo *TLI, LibFunc NewFunc,
1947 uint8_t HotCold) {
1948 Module *M = B.GetInsertBlock()->getModule();
1949 if (!isLibFuncEmittable(M, TLI, NewFunc))
1950 return nullptr;
1951
1952 StringRef Name = TLI->getName(NewFunc);
1953 FunctionCallee Func = M->getOrInsertFunction(Name, B.getInt8PtrTy(),
1954 Num->getType(), B.getInt8Ty());
1955 inferNonMandatoryLibFuncAttrs(M, Name, *TLI);
1956 CallInst *CI = B.CreateCall(Func, {Num, B.getInt8(HotCold)}, Name);
1957
1958 if (const Function *F =
1959 dyn_cast<Function>(Func.getCallee()->stripPointerCasts()))
1960 CI->setCallingConv(F->getCallingConv());
1961
1962 return CI;
1963}
1964
1965Value *llvm::emitHotColdNewNoThrow(Value *Num, Value *NoThrow, IRBuilderBase &B,
1966 const TargetLibraryInfo *TLI,
1967 LibFunc NewFunc, uint8_t HotCold) {
1968 Module *M = B.GetInsertBlock()->getModule();
1969 if (!isLibFuncEmittable(M, TLI, NewFunc))
1970 return nullptr;
1971
1972 StringRef Name = TLI->getName(NewFunc);
1973 FunctionCallee Func =
1974 M->getOrInsertFunction(Name, B.getInt8PtrTy(), Num->getType(),
1975 NoThrow->getType(), B.getInt8Ty());
1976 inferNonMandatoryLibFuncAttrs(M, Name, *TLI);
1977 CallInst *CI = B.CreateCall(Func, {Num, NoThrow, B.getInt8(HotCold)}, Name);
1978
1979 if (const Function *F =
1980 dyn_cast<Function>(Func.getCallee()->stripPointerCasts()))
1981 CI->setCallingConv(F->getCallingConv());
1982
1983 return CI;
1984}
1985
1986Value *llvm::emitHotColdNewAligned(Value *Num, Value *Align, IRBuilderBase &B,
1987 const TargetLibraryInfo *TLI,
1988 LibFunc NewFunc, uint8_t HotCold) {
1989 Module *M = B.GetInsertBlock()->getModule();
1990 if (!isLibFuncEmittable(M, TLI, NewFunc))
1991 return nullptr;
1992
1993 StringRef Name = TLI->getName(NewFunc);
1994 FunctionCallee Func = M->getOrInsertFunction(
1995 Name, B.getInt8PtrTy(), Num->getType(), Align->getType(), B.getInt8Ty());
1996 inferNonMandatoryLibFuncAttrs(M, Name, *TLI);
1997 CallInst *CI = B.CreateCall(Func, {Num, Align, B.getInt8(HotCold)}, Name);
1998
1999 if (const Function *F =
2000 dyn_cast<Function>(Func.getCallee()->stripPointerCasts()))
2001 CI->setCallingConv(F->getCallingConv());
2002
2003 return CI;
2004}
2005
2006Value *llvm::emitHotColdNewAlignedNoThrow(Value *Num, Value *Align,
2007 Value *NoThrow, IRBuilderBase &B,
2008 const TargetLibraryInfo *TLI,
2009 LibFunc NewFunc, uint8_t HotCold) {
2010 Module *M = B.GetInsertBlock()->getModule();
2011 if (!isLibFuncEmittable(M, TLI, NewFunc))
2012 return nullptr;
2013
2014 StringRef Name = TLI->getName(NewFunc);
2015 FunctionCallee Func = M->getOrInsertFunction(
2016 Name, B.getInt8PtrTy(), Num->getType(), Align->getType(),
2017 NoThrow->getType(), B.getInt8Ty());
2018 inferNonMandatoryLibFuncAttrs(M, Name, *TLI);
2019 CallInst *CI =
2020 B.CreateCall(Func, {Num, Align, NoThrow, B.getInt8(HotCold)}, Name);
2021
2022 if (const Function *F =
2023 dyn_cast<Function>(Func.getCallee()->stripPointerCasts()))
2024 CI->setCallingConv(F->getCallingConv());
2025
2026 return CI;
2027}
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
Callee
amdgpu Simplify well known AMD library false FunctionCallee Callee
Definition: AMDGPULibCalls.cpp:187
setRetNoUndef
static bool setRetNoUndef(Function &F)
Definition: BuildLibCalls.cpp:148
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:1686
setDoesNotAlias
static bool setDoesNotAlias(Function &F, unsigned ArgNo)
Definition: BuildLibCalls.cpp:124
setDoesNotAccessMemory
static bool setDoesNotAccessMemory(Function &F)
Definition: BuildLibCalls.cpp:52
setArgsNoUndef
static bool setArgsNoUndef(Function &F)
Definition: BuildLibCalls.cpp:158
getSizeTTy
static IntegerType * getSizeTTy(IRBuilderBase &B, const TargetLibraryInfo *TLI)
Definition: BuildLibCalls.cpp:1437
emitUnaryFloatFnCallHelper
static Value * emitUnaryFloatFnCallHelper(Value *Op, LibFunc TheLibFunc, StringRef Name, IRBuilderBase &B, const AttributeList &Attrs, const TargetLibraryInfo *TLI)
Definition: BuildLibCalls.cpp:1700
setAllocatedPointerParam
static bool setAllocatedPointerParam(Function &F, unsigned ArgNo)
Definition: BuildLibCalls.cpp:222
setRetExtAttr
static void setRetExtAttr(Function &F, const TargetLibraryInfo &TLI, bool Signed=true)
Definition: BuildLibCalls.cpp:1247
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:1442
setNonLazyBind
static bool setNonLazyBind(Function &F)
Definition: BuildLibCalls.cpp:193
setOnlyAccessesInaccessibleMemOrArgMem
static bool setOnlyAccessesInaccessibleMemOrArgMem(Function &F)
Definition: BuildLibCalls.cpp:92
setAllocSize
static bool setAllocSize(Function &F, unsigned ElemSizeArg, std::optional< unsigned > NumElemsArg)
Definition: BuildLibCalls.cpp:229
setAlignedAllocParam
static bool setAlignedAllocParam(Function &F, unsigned ArgNo)
Definition: BuildLibCalls.cpp:215
setRetAndArgsNoUndef
static bool setRetAndArgsNoUndef(Function &F)
Definition: BuildLibCalls.cpp:178
markRegisterParameterAttributes
static void markRegisterParameterAttributes(Function *F)
Definition: BuildLibCalls.cpp:1255
setRetDoesNotAlias
static bool setRetDoesNotAlias(Function &F)
Definition: BuildLibCalls.cpp:108
setReturnedArg
static bool setReturnedArg(Function &F, unsigned ArgNo)
Definition: BuildLibCalls.cpp:185
emitBinaryFloatFnCallHelper
static Value * emitBinaryFloatFnCallHelper(Value *Op1, Value *Op2, LibFunc TheLibFunc, StringRef Name, IRBuilderBase &B, const AttributeList &Attrs, const TargetLibraryInfo *TLI)
Definition: BuildLibCalls.cpp:1748
setDoesNotCapture
static bool setDoesNotCapture(Function &F, unsigned ArgNo)
Definition: BuildLibCalls.cpp:116
setDoesNotThrow
static bool setDoesNotThrow(Function &F)
Definition: BuildLibCalls.cpp:100
setWillReturn
static bool setWillReturn(Function &F)
Definition: BuildLibCalls.cpp:207
setAllocKind
static bool setAllocKind(Function &F, AllocFnKind K)
Definition: BuildLibCalls.cpp:245
setOnlyAccessesInaccessibleMemory
static bool setOnlyAccessesInaccessibleMemory(Function &F)
Definition: BuildLibCalls.cpp:60
getIntTy
static IntegerType * getIntTy(IRBuilderBase &B, const TargetLibraryInfo *TLI)
Definition: BuildLibCalls.cpp:1433
setAllocFamily
static bool setAllocFamily(Function &F, StringRef Family)
Definition: BuildLibCalls.cpp:238
setArgNoUndef
static bool setArgNoUndef(Function &F, unsigned ArgNo)
Definition: BuildLibCalls.cpp:170
setArgExtAttr
static void setArgExtAttr(Function &F, unsigned ArgNo, const TargetLibraryInfo &TLI, bool Signed=true)
Definition: BuildLibCalls.cpp:1240
setOnlyAccessesArgMemory
static bool setOnlyAccessesArgMemory(Function &F)
Definition: BuildLibCalls.cpp:84
setOnlyWritesMemory
static bool setOnlyWritesMemory(Function &F)
Definition: BuildLibCalls.cpp:76
setOnlyReadsMemory
static bool setOnlyReadsMemory(Function &F)
Definition: BuildLibCalls.cpp:68
setDoesNotFreeMemory
static bool setDoesNotFreeMemory(Function &F)
Definition: BuildLibCalls.cpp:200
B
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
A
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
Constants.h
This file contains the declarations for the subclasses of Constant, which represent the different fla...
Name
std::string Name
Definition: ELFObjHandler.cpp:77
Size
uint64_t Size
Definition: ELFObjHandler.cpp:81
F
#define F(x, y, z)
Definition: MD5.cpp:55
Operands
mir Rename Register Operands
Definition: MIRNamerPass.cpp:74
Module.h
Module.h This file contains the declarations for the Module class.
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
SmallString.h
This file defines the SmallString class.
Statistic.h
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
STATISTIC
#define STATISTIC(VARNAME, DESC)
Definition: Statistic.h:167
llvm::Argument
This class represents an incoming formal argument to a Function.
Definition: Argument.h:28
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
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:1160
llvm::Attribute::get
static Attribute get(LLVMContext &Context, AttrKind Kind, uint64_t Val=0)
Return a uniquified Attribute object.
Definition: Attributes.cpp:91
llvm::Attribute::getWithAllocSizeArgs
static Attribute getWithAllocSizeArgs(LLVMContext &Context, unsigned ElemSizeArg, const std::optional< unsigned > &NumElemsArg)
Definition: Attributes.cpp:225
llvm::Attribute::AttrKind
AttrKind
This enumeration lists the attributes that can be associated with parameters, function results,...
Definition: Attributes.h:87
llvm::Attribute::None
@ None
No attributes have been set.
Definition: Attributes.h:89
llvm::CallBase::setCallingConv
void setCallingConv(CallingConv::ID CC)
Definition: InstrTypes.h:1475
llvm::CallBase::setAttributes
void setAttributes(AttributeList A)
Set the parameter attributes for this call.
Definition: InstrTypes.h:1494
llvm::CallInst
This class represents a function call, abstracting a target machine's calling convention.
Definition: Instructions.h:1485
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:888
llvm::DataLayout
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:110
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::FunctionType
Class to represent function types.
Definition: DerivedTypes.h:103
llvm::IRBuilderBase
Common base class shared among various IRBuilders.
Definition: IRBuilder.h:94
llvm::IntegerType
Class to represent integer types.
Definition: DerivedTypes.h:40
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
llvm::SmallString
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:26
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1200
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
llvm::TargetLibraryInfo
Provides information about what library functions are available for the current target.
Definition: TargetLibraryInfo.h:237
llvm::TargetLibraryInfo::isValidProtoForLibFunc
bool isValidProtoForLibFunc(const FunctionType &FTy, LibFunc F, const Module &M) const
Return true if the function type FTy is valid for the library function F, regardless of whether the f...
Definition: TargetLibraryInfo.h:300
llvm::TargetLibraryInfo::has
bool has(LibFunc F) const
Tests whether a library function is available.
Definition: TargetLibraryInfo.h:343
llvm::TargetLibraryInfo::getSizeTSize
unsigned getSizeTSize(const Module &M) const
Returns the size of the size_t type in bits.
Definition: TargetLibraryInfo.h:508
llvm::TargetLibraryInfo::getLibFunc
bool getLibFunc(StringRef funcName, LibFunc &F) const
Searches for a particular function name.
Definition: TargetLibraryInfo.h:309
llvm::TargetLibraryInfo::getName
StringRef getName(LibFunc F) const
Definition: TargetLibraryInfo.h:390
llvm::TargetLibraryInfo::getIntSize
unsigned getIntSize() const
Get size of a C-level int or unsigned int, in bits.
Definition: TargetLibraryInfo.h:511
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::Type::HalfTyID
@ HalfTyID
16-bit floating point type
Definition: Type.h:56
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::Type::getTypeID
TypeID getTypeID() const
Return the type id for the type.
Definition: Type.h:137
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::Value::getType
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:255
llvm::Value::stripPointerCasts
const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs and address space casts.
Definition: Value.cpp:688
uint64_t
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:143
llvm::CallingConv::X86_StdCall
@ X86_StdCall
stdcall is mostly used by the Win32 API.
Definition: CallingConv.h:96
llvm::CallingConv::C
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
llvm::emitUnaryFloatFnCall
Value * emitUnaryFloatFnCall(Value *Op, const TargetLibraryInfo *TLI, StringRef Name, IRBuilderBase &B, const AttributeList &Attrs)
Emit a call to the unary function named 'Name' (e.g.
Definition: BuildLibCalls.cpp:1723
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:1475
llvm::emitPutChar
Value * emitPutChar(Value *Char, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the putchar function. This assumes that Char is an 'int'.
Definition: BuildLibCalls.cpp:1804
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:1523
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:1507
llvm::emitHotColdNewAlignedNoThrow
Value * emitHotColdNewAlignedNoThrow(Value *Num, Value *Align, Value *NoThrow, IRBuilderBase &B, const TargetLibraryInfo *TLI, LibFunc NewFunc, uint8_t HotCold)
Definition: BuildLibCalls.cpp:2006
llvm::castToCStr
Value * castToCStr(Value *V, IRBuilderBase &B)
Return V if it is an i8*, otherwise cast it to i8*.
Definition: BuildLibCalls.cpp:1428
llvm::AllocFnKind
AllocFnKind
Definition: Attributes.h:50
llvm::emitCalloc
Value * emitCalloc(Value *Num, Value *Size, IRBuilderBase &B, const TargetLibraryInfo &TLI)
Emit a call to the calloc function.
Definition: BuildLibCalls.cpp:1925
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:1619
llvm::emitMemRChr
Value * emitMemRChr(Value *Ptr, Value *Val, Value *Len, IRBuilderBase &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the memrchr function, analogously to emitMemChr.
Definition: BuildLibCalls.cpp:1566
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:1647
llvm::append_range
void append_range(Container &C, Range &&R)
Wrapper function to append a range to a container.
Definition: STLExtras.h:2129
llvm::hasFloatFn
bool hasFloatFn(const Module *M, 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:1391
llvm::inferNonMandatoryLibFuncAttrs
bool inferNonMandatoryLibFuncAttrs(Module *M, StringRef Name, const TargetLibraryInfo &TLI)
Analyze the name and prototype of the given function and set any applicable attributes.
Definition: BuildLibCalls.cpp:253
llvm::isLibFreeFunction
bool isLibFreeFunction(const Function *F, const LibFunc TLIFn)
isLibFreeFunction - Returns true if the function is a builtin free()
Definition: MemoryBuiltins.cpp:535
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:1656
llvm::isLibFuncEmittable
bool isLibFuncEmittable(const Module *M, const TargetLibraryInfo *TLI, LibFunc TheLibFunc)
Check whether the library function is available on target and also that it in the current Module is a...
Definition: BuildLibCalls.cpp:1367
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:1665
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:1483
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:1576
llvm::emitBinaryFloatFnCall
Value * emitBinaryFloatFnCall(Value *Op1, Value *Op2, const TargetLibraryInfo *TLI, StringRef Name, IRBuilderBase &B, const AttributeList &Attrs)
Emit a call to the binary function named 'Name' (e.g.
Definition: BuildLibCalls.cpp:1773
llvm::emitFPutS
Value * emitFPutS(Value *Str, Value *File, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the fputs function.
Definition: BuildLibCalls.cpp:1861
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:1469
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:1586
llvm::getFloatFn
StringRef getFloatFn(const Module *M, const TargetLibraryInfo *TLI, Type *Ty, LibFunc DoubleFn, LibFunc FloatFn, LibFunc LongDoubleFn, LibFunc &TheLibFunc)
Get the name of the overloaded floating point function corresponding to Ty.
Definition: BuildLibCalls.cpp:1405
llvm::getOrInsertLibFunc
FunctionCallee getOrInsertLibFunc(Module *M, const TargetLibraryInfo &TLI, LibFunc TheLibFunc, FunctionType *T, AttributeList AttributeList)
Calls getOrInsertFunction() and then makes sure to add mandatory argument attributes.
Definition: BuildLibCalls.cpp:1289
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:1462
llvm::emitFPutC
Value * emitFPutC(Value *Char, Value *File, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the fputc function.
Definition: BuildLibCalls.cpp:1841
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:1515
llvm::emitStrCat
Value * emitStrCat(Value *Dest, Value *Src, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the strcat function.
Definition: BuildLibCalls.cpp:1631
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:1676
llvm::isReallocLikeFn
bool isReallocLikeFn(const Function *F)
Tests if a function is a call or invoke to a library function that reallocates memory (e....
Definition: MemoryBuiltins.cpp:328
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:1881
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:1606
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:1500
llvm::emitHotColdNewNoThrow
Value * emitHotColdNewNoThrow(Value *Num, Value *NoThrow, IRBuilderBase &B, const TargetLibraryInfo *TLI, LibFunc NewFunc, uint8_t HotCold)
Definition: BuildLibCalls.cpp:1965
llvm::emitMalloc
Value * emitMalloc(Value *Num, IRBuilderBase &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the malloc function.
Definition: BuildLibCalls.cpp:1905
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:1556
llvm::emitHotColdNewAligned
Value * emitHotColdNewAligned(Value *Num, Value *Align, IRBuilderBase &B, const TargetLibraryInfo *TLI, LibFunc NewFunc, uint8_t HotCold)
Definition: BuildLibCalls.cpp:1986
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:1823
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:1596
llvm::emitHotColdNew
Value * emitHotColdNew(Value *Num, IRBuilderBase &B, const TargetLibraryInfo *TLI, LibFunc NewFunc, uint8_t HotCold)
Emit a call to the hot/cold operator new function.
Definition: BuildLibCalls.cpp:1945
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:1638
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:1493
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:1547
N
#define N
llvm::Align
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
Generated on Thu Jun 1 2023 18:58:00 for LLVM by doxygen 1.9.6