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