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