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