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