Lines Matching +full:- +full:f
1 //===- BuildLibCalls.cpp - Utility builder for libcalls -------------------===//
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
11 //===----------------------------------------------------------------------===//
32 #define DEBUG_TYPE "build-libcalls"
34 //- Infer Attributes ---------------------------------------------------------//
55 static bool setDoesNotAccessMemory(Function &F) {
56 if (F.doesNotAccessMemory())
58 F.setDoesNotAccessMemory();
63 static bool setIsCold(Function &F) {
64 if (F.hasFnAttribute(Attribute::Cold))
66 F.addFnAttr(Attribute::Cold);
71 static bool setNoReturn(Function &F) {
72 if (F.hasFnAttribute(Attribute::NoReturn))
74 F.addFnAttr(Attribute::NoReturn);
79 static bool setOnlyAccessesInaccessibleMemory(Function &F) {
80 if (F.onlyAccessesInaccessibleMemory())
82 F.setOnlyAccessesInaccessibleMemory();
87 static bool setOnlyReadsMemory(Function &F) {
88 if (F.onlyReadsMemory())
90 F.setOnlyReadsMemory();
95 static bool setOnlyWritesMemory(Function &F) {
96 if (F.onlyWritesMemory()) // writeonly or readnone
99 F.setOnlyWritesMemory();
103 static bool setOnlyAccessesArgMemory(Function &F) {
104 if (F.onlyAccessesArgMemory())
106 F.setOnlyAccessesArgMemory();
111 static bool setOnlyAccessesInaccessibleMemOrArgMem(Function &F) {
112 if (F.onlyAccessesInaccessibleMemOrArgMem())
114 F.setOnlyAccessesInaccessibleMemOrArgMem();
119 static bool setDoesNotThrow(Function &F) {
120 if (F.doesNotThrow())
122 F.setDoesNotThrow();
127 static bool setRetDoesNotAlias(Function &F) {
128 if (F.hasRetAttribute(Attribute::NoAlias))
130 F.addRetAttr(Attribute::NoAlias);
135 static bool setDoesNotCapture(Function &F, unsigned ArgNo) {
136 if (F.hasParamAttribute(ArgNo, Attribute::Captures))
138 F.addParamAttr(ArgNo, Attribute::getWithCaptureInfo(F.getContext(),
144 static bool setDoesNotAlias(Function &F, unsigned ArgNo) {
145 if (F.hasParamAttribute(ArgNo, Attribute::NoAlias))
147 F.addParamAttr(ArgNo, Attribute::NoAlias);
152 static bool setOnlyReadsMemory(Function &F, unsigned ArgNo) {
153 if (F.hasParamAttribute(ArgNo, Attribute::ReadOnly))
155 F.addParamAttr(ArgNo, Attribute::ReadOnly);
160 static bool setOnlyWritesMemory(Function &F, unsigned ArgNo) {
161 if (F.hasParamAttribute(ArgNo, Attribute::WriteOnly))
163 F.addParamAttr(ArgNo, Attribute::WriteOnly);
168 static bool setRetNoUndef(Function &F) {
169 if (!F.getReturnType()->isVoidTy() &&
170 !F.hasRetAttribute(Attribute::NoUndef)) {
171 F.addRetAttr(Attribute::NoUndef);
178 static bool setArgsNoUndef(Function &F) {
180 for (unsigned ArgNo = 0; ArgNo < F.arg_size(); ++ArgNo) {
181 if (!F.hasParamAttribute(ArgNo, Attribute::NoUndef)) {
182 F.addParamAttr(ArgNo, Attribute::NoUndef);
190 static bool setArgNoUndef(Function &F, unsigned ArgNo) {
191 if (F.hasParamAttribute(ArgNo, Attribute::NoUndef))
193 F.addParamAttr(ArgNo, Attribute::NoUndef);
198 static bool setRetAndArgsNoUndef(Function &F) {
200 UndefAdded |= setRetNoUndef(F);
201 UndefAdded |= setArgsNoUndef(F);
205 static bool setReturnedArg(Function &F, unsigned ArgNo) {
206 if (F.hasParamAttribute(ArgNo, Attribute::Returned))
208 F.addParamAttr(ArgNo, Attribute::Returned);
213 static bool setNonLazyBind(Function &F) {
214 if (F.hasFnAttribute(Attribute::NonLazyBind))
216 F.addFnAttr(Attribute::NonLazyBind);
220 static bool setDoesNotFreeMemory(Function &F) {
221 if (F.hasFnAttribute(Attribute::NoFree))
223 F.addFnAttr(Attribute::NoFree);
227 static bool setWillReturn(Function &F) {
228 if (F.hasFnAttribute(Attribute::WillReturn))
230 F.addFnAttr(Attribute::WillReturn);
235 static bool setAlignedAllocParam(Function &F, unsigned ArgNo) {
236 if (F.hasParamAttribute(ArgNo, Attribute::AllocAlign))
238 F.addParamAttr(ArgNo, Attribute::AllocAlign);
242 static bool setAllocatedPointerParam(Function &F, unsigned ArgNo) {
243 if (F.hasParamAttribute(ArgNo, Attribute::AllocatedPointer))
245 F.addParamAttr(ArgNo, Attribute::AllocatedPointer);
249 static bool setAllocSize(Function &F, unsigned ElemSizeArg,
251 if (F.hasFnAttribute(Attribute::AllocSize))
253 F.addFnAttr(Attribute::getWithAllocSizeArgs(F.getContext(), ElemSizeArg,
258 static bool setAllocFamily(Function &F, StringRef Family) {
259 if (F.hasFnAttribute("alloc-family"))
261 F.addFnAttr("alloc-family", Family);
265 static bool setAllocKind(Function &F, AllocFnKind K) {
266 if (F.hasFnAttribute(Attribute::AllocKind))
268 F.addFnAttr(
269 Attribute::get(F.getContext(), Attribute::AllocKind, uint64_t(K)));
275 Function *F = M->getFunction(Name);
276 if (!F)
278 return inferNonMandatoryLibFuncAttrs(*F, TLI);
281 bool llvm::inferNonMandatoryLibFuncAttrs(Function &F,
284 if (!(TLI.getLibFunc(F, TheLibFunc) && TLI.has(TheLibFunc)))
289 if (F.getParent() != nullptr && F.getParent()->getRtLibUseGOT())
290 Changed |= setNonLazyBind(F);
299 Changed |= setOnlyReadsMemory(F);
300 Changed |= setDoesNotThrow(F);
301 Changed |= setOnlyAccessesArgMemory(F);
302 Changed |= setWillReturn(F);
303 Changed |= setDoesNotCapture(F, 0);
307 Changed |= setOnlyAccessesArgMemory(F);
308 Changed |= setOnlyReadsMemory(F);
309 Changed |= setDoesNotThrow(F);
310 Changed |= setWillReturn(F);
319 Changed |= setDoesNotThrow(F);
320 Changed |= setWillReturn(F);
321 Changed |= setDoesNotCapture(F, 1);
322 Changed |= setOnlyReadsMemory(F, 0);
326 Changed |= setOnlyAccessesArgMemory(F);
327 Changed |= setDoesNotThrow(F);
328 Changed |= setWillReturn(F);
329 Changed |= setReturnedArg(F, 0);
330 Changed |= setDoesNotCapture(F, 1);
331 Changed |= setOnlyReadsMemory(F, 1);
332 Changed |= setDoesNotAlias(F, 0);
333 Changed |= setDoesNotAlias(F, 1);
337 Changed |= setReturnedArg(F, 0);
341 Changed |= setOnlyAccessesArgMemory(F);
342 Changed |= setDoesNotThrow(F);
343 Changed |= setWillReturn(F);
344 Changed |= setDoesNotCapture(F, 1);
345 Changed |= setOnlyWritesMemory(F, 0);
346 Changed |= setOnlyReadsMemory(F, 1);
347 Changed |= setDoesNotAlias(F, 0);
348 Changed |= setDoesNotAlias(F, 1);
351 Changed |= setDoesNotThrow(F);
352 Changed |= setWillReturn(F);
353 Changed |= setDoesNotCapture(F, 0);
354 Changed |= setDoesNotCapture(F, 1);
355 Changed |= setOnlyReadsMemory(F, 1);
361 Changed |= setDoesNotThrow(F);
362 Changed |= setOnlyAccessesArgMemory(F);
363 Changed |= setWillReturn(F);
364 Changed |= setOnlyReadsMemory(F);
365 Changed |= setDoesNotCapture(F, 0);
366 Changed |= setDoesNotCapture(F, 1);
373 Changed |= setOnlyReadsMemory(F);
374 Changed |= setDoesNotThrow(F);
375 Changed |= setWillReturn(F);
376 Changed |= setDoesNotCapture(F, 0);
377 Changed |= setDoesNotCapture(F, 1);
381 Changed |= setOnlyAccessesArgMemory(F);
382 Changed |= setOnlyReadsMemory(F);
383 Changed |= setDoesNotThrow(F);
384 Changed |= setWillReturn(F);
385 Changed |= setDoesNotCapture(F, 1);
389 Changed |= setDoesNotThrow(F);
390 Changed |= setWillReturn(F);
391 Changed |= setDoesNotCapture(F, 1);
392 Changed |= setOnlyReadsMemory(F, 1);
395 Changed |= setRetAndArgsNoUndef(F);
396 Changed |= setDoesNotThrow(F);
397 Changed |= setDoesNotCapture(F, 0);
398 Changed |= setOnlyReadsMemory(F, 0);
402 Changed |= setRetAndArgsNoUndef(F);
403 Changed |= setDoesNotThrow(F);
404 Changed |= setDoesNotCapture(F, 0);
407 Changed |= setArgNoUndef(F, 1);
410 Changed |= setAllocFamily(F, "malloc");
411 Changed |= setOnlyAccessesInaccessibleMemOrArgMem(F);
412 Changed |= setDoesNotThrow(F);
413 Changed |= setRetDoesNotAlias(F);
414 Changed |= setWillReturn(F);
415 Changed |= setDoesNotCapture(F, 0);
416 Changed |= setOnlyReadsMemory(F, 0);
420 Changed |= setRetAndArgsNoUndef(F);
421 Changed |= setDoesNotThrow(F);
422 Changed |= setDoesNotCapture(F, 0);
423 Changed |= setDoesNotCapture(F, 1);
424 Changed |= setOnlyReadsMemory(F, 0);
427 Changed |= setRetAndArgsNoUndef(F);
428 Changed |= setDoesNotThrow(F);
429 Changed |= setDoesNotCapture(F, 0);
430 Changed |= setDoesNotCapture(F, 1);
431 Changed |= setOnlyReadsMemory(F, 0);
432 Changed |= setOnlyReadsMemory(F, 1);
435 Changed |= setRetAndArgsNoUndef(F);
436 Changed |= setDoesNotThrow(F);
437 Changed |= setDoesNotCapture(F, 0);
438 Changed |= setDoesNotAlias(F, 0);
439 Changed |= setOnlyWritesMemory(F, 0);
440 Changed |= setDoesNotCapture(F, 1);
441 Changed |= setOnlyReadsMemory(F, 1);
444 Changed |= setRetAndArgsNoUndef(F);
445 Changed |= setDoesNotThrow(F);
446 Changed |= setDoesNotCapture(F, 0);
447 Changed |= setDoesNotAlias(F, 0);
448 Changed |= setOnlyWritesMemory(F, 0);
449 Changed |= setDoesNotCapture(F, 2);
450 Changed |= setOnlyReadsMemory(F, 2);
453 Changed |= setRetAndArgsNoUndef(F);
454 Changed |= setDoesNotThrow(F);
455 Changed |= setWillReturn(F);
456 Changed |= setDoesNotCapture(F, 1);
457 Changed |= setDoesNotCapture(F, 2);
458 Changed |= setOnlyReadsMemory(F, 1);
462 Changed |= setRetAndArgsNoUndef(F);
463 Changed |= setDoesNotCapture(F, 0);
464 Changed |= setOnlyReadsMemory(F, 0);
467 Changed |= setAlignedAllocParam(F, 0);
468 Changed |= setAllocSize(F, 1, std::nullopt);
469 Changed |= setAllocKind(F, AllocFnKind::Alloc | AllocFnKind::Uninitialized | AllocFnKind::Aligned);
474 Changed |= setAllocFamily(F, TheLibFunc == LibFunc_vec_malloc ? "vec_malloc"
476 Changed |= setAllocKind(F, AllocFnKind::Alloc | AllocFnKind::Uninitialized);
477 Changed |= setAllocSize(F, 0, std::nullopt);
478 Changed |= setOnlyAccessesInaccessibleMemory(F);
479 Changed |= setRetAndArgsNoUndef(F);
480 Changed |= setDoesNotThrow(F);
481 Changed |= setRetDoesNotAlias(F);
482 Changed |= setWillReturn(F);
485 Changed |= setOnlyAccessesArgMemory(F);
486 Changed |= setOnlyReadsMemory(F);
487 Changed |= setDoesNotThrow(F);
488 Changed |= setWillReturn(F);
489 Changed |= setDoesNotCapture(F, 0);
490 Changed |= setDoesNotCapture(F, 1);
494 Changed |= setDoesNotThrow(F);
495 Changed |= setOnlyAccessesArgMemory(F);
496 Changed |= setOnlyReadsMemory(F);
497 Changed |= setWillReturn(F);
502 Changed |= setDoesNotThrow(F);
503 Changed |= setWillReturn(F);
504 Changed |= setOnlyAccessesArgMemory(F);
505 Changed |= setOnlyWritesMemory(F);
506 Changed |= setDoesNotCapture(F, 1);
509 Changed |= setDoesNotThrow(F);
510 Changed |= setOnlyAccessesArgMemory(F);
511 Changed |= setWillReturn(F);
512 Changed |= setDoesNotAlias(F, 0);
513 Changed |= setReturnedArg(F, 0);
514 Changed |= setOnlyWritesMemory(F, 0);
515 Changed |= setDoesNotAlias(F, 1);
516 Changed |= setDoesNotCapture(F, 1);
517 Changed |= setOnlyReadsMemory(F, 1);
520 Changed |= setDoesNotThrow(F);
521 Changed |= setOnlyAccessesArgMemory(F);
522 Changed |= setWillReturn(F);
523 Changed |= setReturnedArg(F, 0);
524 Changed |= setOnlyWritesMemory(F, 0);
525 Changed |= setDoesNotCapture(F, 1);
526 Changed |= setOnlyReadsMemory(F, 1);
530 Changed |= setWillReturn(F);
533 Changed |= setDoesNotThrow(F);
534 Changed |= setOnlyAccessesArgMemory(F);
535 Changed |= setDoesNotAlias(F, 0);
536 Changed |= setOnlyWritesMemory(F, 0);
537 Changed |= setDoesNotAlias(F, 1);
538 Changed |= setDoesNotCapture(F, 1);
539 Changed |= setOnlyReadsMemory(F, 1);
542 Changed |= setAllocFamily(F, "malloc");
543 Changed |= setAllocKind(F, AllocFnKind::Alloc | AllocFnKind::Aligned |
545 Changed |= setAllocSize(F, 1, std::nullopt);
546 Changed |= setAlignedAllocParam(F, 0);
547 Changed |= setOnlyAccessesInaccessibleMemory(F);
548 Changed |= setRetNoUndef(F);
549 Changed |= setDoesNotThrow(F);
550 Changed |= setRetDoesNotAlias(F);
551 Changed |= setWillReturn(F);
554 Changed |= setRetAndArgsNoUndef(F);
555 Changed |= setDoesNotThrow(F);
556 Changed |= setDoesNotCapture(F, 0);
557 Changed |= setOnlyReadsMemory(F, 0);
560 Changed |= setRetAndArgsNoUndef(F);
561 Changed |= setDoesNotThrow(F);
562 Changed |= setWillReturn(F);
563 Changed |= setDoesNotCapture(F, 0);
569 F, TheLibFunc == LibFunc_vec_realloc ? "vec_malloc" : "malloc");
570 Changed |= setAllocKind(F, AllocFnKind::Realloc);
571 Changed |= setAllocatedPointerParam(F, 0);
572 Changed |= setAllocSize(F, 1, std::nullopt);
573 Changed |= setOnlyAccessesInaccessibleMemOrArgMem(F);
574 Changed |= setRetNoUndef(F);
575 Changed |= setDoesNotThrow(F);
576 Changed |= setRetDoesNotAlias(F);
577 Changed |= setWillReturn(F);
578 Changed |= setDoesNotCapture(F, 0);
579 Changed |= setArgNoUndef(F, 1);
582 Changed |= setAllocFamily(F, "malloc");
583 Changed |= setAllocKind(F, AllocFnKind::Realloc);
584 Changed |= setAllocatedPointerParam(F, 0);
585 Changed |= setAllocSize(F, 1, 2);
586 Changed |= setOnlyAccessesInaccessibleMemOrArgMem(F);
587 Changed |= setRetNoUndef(F);
588 Changed |= setDoesNotThrow(F);
589 Changed |= setRetDoesNotAlias(F);
590 Changed |= setWillReturn(F);
591 Changed |= setDoesNotCapture(F, 0);
592 Changed |= setArgNoUndef(F, 1);
593 Changed |= setArgNoUndef(F, 2);
597 Changed |= setRetAndArgsNoUndef(F);
598 Changed |= setDoesNotCapture(F, 1);
601 Changed |= setRetAndArgsNoUndef(F);
602 Changed |= setDoesNotThrow(F);
603 Changed |= setDoesNotCapture(F, 0);
608 Changed |= setRetAndArgsNoUndef(F);
609 Changed |= setDoesNotThrow(F);
610 Changed |= setDoesNotCapture(F, 0);
611 Changed |= setOnlyReadsMemory(F, 0);
614 Changed |= setRetAndArgsNoUndef(F);
615 Changed |= setDoesNotThrow(F);
616 Changed |= setDoesNotCapture(F, 0);
617 Changed |= setDoesNotCapture(F, 1);
618 Changed |= setOnlyReadsMemory(F, 0);
619 Changed |= setOnlyReadsMemory(F, 1);
622 Changed |= setRetAndArgsNoUndef(F);
623 Changed |= setDoesNotThrow(F);
624 Changed |= setDoesNotCapture(F, 0);
625 Changed |= setDoesNotCapture(F, 1);
626 Changed |= setOnlyReadsMemory(F, 0);
630 Changed |= setRetAndArgsNoUndef(F);
631 Changed |= setDoesNotCapture(F, 1);
632 Changed |= setOnlyReadsMemory(F, 1);
635 Changed |= setDoesNotThrow(F);
636 Changed |= setOnlyAccessesArgMemory(F);
637 Changed |= setWillReturn(F);
638 Changed |= setDoesNotCapture(F, 0);
639 Changed |= setOnlyReadsMemory(F, 0);
640 Changed |= setOnlyWritesMemory(F, 1);
641 Changed |= setDoesNotCapture(F, 1);
644 Changed |= setDoesNotThrow(F);
645 Changed |= setOnlyAccessesArgMemory(F);
646 Changed |= setOnlyReadsMemory(F);
647 Changed |= setWillReturn(F);
648 Changed |= setDoesNotCapture(F, 0);
649 Changed |= setDoesNotCapture(F, 1);
652 Changed |= setDoesNotThrow(F);
653 Changed |= setOnlyAccessesArgMemory(F);
654 Changed |= setWillReturn(F);
655 Changed |= setDoesNotCapture(F, 0);
656 Changed |= setOnlyWritesMemory(F, 0);
660 Changed |= setAllocFamily(F, TheLibFunc == LibFunc_vec_calloc ? "vec_malloc"
662 Changed |= setAllocKind(F, AllocFnKind::Alloc | AllocFnKind::Zeroed);
663 Changed |= setAllocSize(F, 0, 1);
664 Changed |= setOnlyAccessesInaccessibleMemory(F);
665 Changed |= setRetAndArgsNoUndef(F);
666 Changed |= setDoesNotThrow(F);
667 Changed |= setRetDoesNotAlias(F);
668 Changed |= setWillReturn(F);
672 Changed |= setRetAndArgsNoUndef(F);
673 Changed |= setDoesNotThrow(F);
674 Changed |= setDoesNotCapture(F, 0);
675 Changed |= setOnlyReadsMemory(F, 0);
680 Changed |= setRetAndArgsNoUndef(F);
681 Changed |= setDoesNotThrow(F);
682 Changed |= setDoesNotCapture(F, 0);
688 Changed |= setDoesNotThrow(F);
689 Changed |= setOnlyReadsMemory(F);
690 Changed |= setWillReturn(F);
691 Changed |= setDoesNotCapture(F, 0);
694 Changed |= setRetAndArgsNoUndef(F);
695 Changed |= setDoesNotThrow(F);
696 Changed |= setDoesNotCapture(F, 0);
697 Changed |= setOnlyReadsMemory(F, 0);
700 Changed |= setRetAndArgsNoUndef(F);
701 Changed |= setDoesNotThrow(F);
702 Changed |= setRetDoesNotAlias(F);
703 Changed |= setDoesNotCapture(F, 0);
704 Changed |= setDoesNotCapture(F, 1);
705 Changed |= setOnlyReadsMemory(F, 0);
706 Changed |= setOnlyReadsMemory(F, 1);
709 Changed |= setRetAndArgsNoUndef(F);
710 Changed |= setDoesNotThrow(F);
711 Changed |= setRetDoesNotAlias(F);
712 Changed |= setDoesNotCapture(F, 1);
713 Changed |= setOnlyReadsMemory(F, 1);
716 Changed |= setRetAndArgsNoUndef(F);
717 Changed |= setDoesNotThrow(F);
718 Changed |= setDoesNotCapture(F, 0);
722 Changed |= setAllocFamily(F, TheLibFunc == LibFunc_vec_free ? "vec_malloc"
724 Changed |= setAllocKind(F, AllocFnKind::Free);
725 Changed |= setAllocatedPointerParam(F, 0);
726 Changed |= setOnlyAccessesInaccessibleMemOrArgMem(F);
727 Changed |= setArgsNoUndef(F);
728 Changed |= setDoesNotThrow(F);
729 Changed |= setWillReturn(F);
730 Changed |= setDoesNotCapture(F, 0);
745 Changed |= setRetAndArgsNoUndef(F);
746 Changed |= setDoesNotThrow(F);
747 Changed |= setDoesNotCapture(F, 0);
750 Changed |= setRetAndArgsNoUndef(F);
751 Changed |= setDoesNotThrow(F);
752 Changed |= setDoesNotCapture(F, 0);
753 Changed |= setOnlyReadsMemory(F);
758 Changed |= setRetAndArgsNoUndef(F);
759 Changed |= setDoesNotThrow(F);
760 Changed |= setDoesNotCapture(F, 1);
765 Changed |= setDoesNotThrow(F);
766 Changed |= setWillReturn(F);
767 Changed |= setOnlyAccessesArgMemory(F);
768 Changed |= setOnlyWritesMemory(F);
769 Changed |= setDoesNotCapture(F, 1);
772 Changed |= setRetAndArgsNoUndef(F);
773 Changed |= setDoesNotThrow(F);
774 Changed |= setDoesNotCapture(F, 1);
778 Changed |= setRetAndArgsNoUndef(F);
779 Changed |= setDoesNotThrow(F);
780 Changed |= setDoesNotCapture(F, 2);
784 Changed |= setRetAndArgsNoUndef(F);
785 Changed |= setDoesNotThrow(F);
786 Changed |= setDoesNotCapture(F, 0);
787 Changed |= setDoesNotCapture(F, 3);
791 Changed |= setRetAndArgsNoUndef(F);
792 Changed |= setDoesNotThrow(F);
793 Changed |= setDoesNotCapture(F, 0);
794 Changed |= setDoesNotCapture(F, 3);
799 Changed |= setRetAndArgsNoUndef(F);
800 Changed |= setDoesNotThrow(F);
801 Changed |= setDoesNotCapture(F, 0);
802 Changed |= setDoesNotCapture(F, 1);
803 Changed |= setOnlyReadsMemory(F, 0);
807 Changed |= setRetAndArgsNoUndef(F);
808 Changed |= setDoesNotThrow(F);
809 Changed |= setDoesNotCapture(F, 0);
810 Changed |= setDoesNotCapture(F, 1);
811 Changed |= setOnlyReadsMemory(F, 1);
814 Changed |= setRetAndArgsNoUndef(F);
815 Changed |= setDoesNotThrow(F);
816 Changed |= setDoesNotCapture(F, 0);
817 Changed |= setDoesNotCapture(F, 1);
820 Changed |= setRetAndArgsNoUndef(F);
821 Changed |= setDoesNotThrow(F);
822 Changed |= setDoesNotCapture(F, 0);
825 Changed |= setRetAndArgsNoUndef(F);
826 Changed |= setDoesNotThrow(F);
827 Changed |= setDoesNotCapture(F, 0);
830 Changed |= setRetAndArgsNoUndef(F);
831 Changed |= setDoesNotThrow(F);
832 Changed |= setDoesNotCapture(F, 0);
835 Changed |= setRetAndArgsNoUndef(F);
836 Changed |= setDoesNotThrow(F);
837 Changed |= setOnlyReadsMemory(F);
838 Changed |= setDoesNotCapture(F, 0);
843 Changed |= setRetAndArgsNoUndef(F);
844 Changed |= setDoesNotThrow(F);
847 Changed |= setRetAndArgsNoUndef(F);
848 Changed |= setDoesNotThrow(F);
849 Changed |= setDoesNotCapture(F, 1);
852 Changed |= setRetAndArgsNoUndef(F);
853 Changed |= setDoesNotThrow(F);
854 Changed |= setDoesNotCapture(F, 0);
855 Changed |= setOnlyReadsMemory(F, 0);
858 Changed |= setRetAndArgsNoUndef(F);
859 Changed |= setDoesNotThrow(F);
860 Changed |= setDoesNotCapture(F, 1);
863 Changed |= setRetAndArgsNoUndef(F);
864 Changed |= setDoesNotThrow(F);
865 Changed |= setDoesNotCapture(F, 0);
868 Changed |= setRetAndArgsNoUndef(F);
869 Changed |= setDoesNotThrow(F);
870 Changed |= setDoesNotCapture(F, 0);
871 Changed |= setOnlyReadsMemory(F, 0);
874 Changed |= setRetAndArgsNoUndef(F);
875 Changed |= setDoesNotThrow(F);
876 Changed |= setDoesNotCapture(F, 0);
877 Changed |= setOnlyReadsMemory(F, 0);
881 Changed |= setRetAndArgsNoUndef(F);
882 Changed |= setDoesNotThrow(F);
883 Changed |= setDoesNotCapture(F, 0);
884 Changed |= setDoesNotCapture(F, 1);
885 Changed |= setOnlyReadsMemory(F, 0);
886 Changed |= setOnlyReadsMemory(F, 1);
890 Changed |= setRetAndArgsNoUndef(F);
891 Changed |= setDoesNotThrow(F);
892 Changed |= setDoesNotCapture(F, 1);
897 Changed |= setRetAndArgsNoUndef(F);
898 Changed |= setDoesNotThrow(F);
899 Changed |= setDoesNotCapture(F, 0);
900 Changed |= setOnlyReadsMemory(F, 0);
904 Changed |= setRetAndArgsNoUndef(F);
905 Changed |= setDoesNotCapture(F, 1);
909 Changed |= setRetAndArgsNoUndef(F);
910 Changed |= setDoesNotCapture(F, 1);
911 Changed |= setOnlyReadsMemory(F, 1);
915 Changed |= setRetAndArgsNoUndef(F);
916 Changed |= setDoesNotThrow(F);
919 Changed |= setRetAndArgsNoUndef(F);
920 Changed |= setDoesNotThrow(F);
921 Changed |= setRetDoesNotAlias(F);
922 Changed |= setDoesNotCapture(F, 0);
923 Changed |= setDoesNotCapture(F, 1);
924 Changed |= setOnlyReadsMemory(F, 0);
925 Changed |= setOnlyReadsMemory(F, 1);
928 Changed |= setRetAndArgsNoUndef(F);
929 Changed |= setDoesNotThrow(F);
930 Changed |= setDoesNotCapture(F, 0);
933 Changed |= setRetAndArgsNoUndef(F);
934 Changed |= setDoesNotThrow(F);
935 Changed |= setDoesNotCapture(F, 0);
936 Changed |= setOnlyReadsMemory(F, 0);
939 Changed |= setRetAndArgsNoUndef(F);
940 Changed |= setDoesNotThrow(F);
941 Changed |= setDoesNotCapture(F, 0);
942 Changed |= setDoesNotCapture(F, 1);
943 Changed |= setOnlyReadsMemory(F, 0);
944 Changed |= setOnlyReadsMemory(F, 1);
947 Changed |= setRetAndArgsNoUndef(F);
948 Changed |= setDoesNotThrow(F);
949 Changed |= setDoesNotCapture(F, 0);
950 Changed |= setDoesNotCapture(F, 1);
951 Changed |= setOnlyReadsMemory(F, 1);
954 Changed |= setRetAndArgsNoUndef(F);
955 Changed |= setDoesNotThrow(F);
956 Changed |= setDoesNotCapture(F, 0);
957 Changed |= setOnlyReadsMemory(F, 0);
961 Changed |= setRetAndArgsNoUndef(F);
962 Changed |= setDoesNotThrow(F);
963 Changed |= setDoesNotCapture(F, 0);
964 Changed |= setDoesNotCapture(F, 1);
965 Changed |= setOnlyReadsMemory(F, 1);
968 Changed |= setRetAndArgsNoUndef(F);
969 Changed |= setDoesNotThrow(F);
970 Changed |= setDoesNotCapture(F, 0);
971 Changed |= setDoesNotCapture(F, 2);
972 Changed |= setOnlyReadsMemory(F, 2);
976 Changed |= setRetAndArgsNoUndef(F);
977 Changed |= setDoesNotCapture(F, 0);
978 Changed |= setOnlyReadsMemory(F, 0);
981 Changed |= setRetAndArgsNoUndef(F);
982 Changed |= setDoesNotThrow(F);
983 Changed |= setRetDoesNotAlias(F);
984 Changed |= setDoesNotCapture(F, 0);
985 Changed |= setOnlyReadsMemory(F, 0);
988 Changed |= setRetAndArgsNoUndef(F);
989 Changed |= setDoesNotThrow(F);
990 Changed |= setRetDoesNotAlias(F);
993 Changed |= setRetAndArgsNoUndef(F);
994 Changed |= setDoesNotThrow(F);
995 Changed |= setDoesNotCapture(F, 0);
1001 Changed |= setDoesNotThrow(F);
1002 Changed |= setDoesNotAccessMemory(F);
1005 Changed |= setRetAndArgsNoUndef(F);
1006 Changed |= setDoesNotThrow(F);
1007 Changed |= setDoesNotCapture(F, 0);
1008 Changed |= setDoesNotCapture(F, 1);
1009 Changed |= setOnlyReadsMemory(F, 0);
1012 Changed |= setRetAndArgsNoUndef(F);
1013 Changed |= setDoesNotThrow(F);
1014 Changed |= setDoesNotCapture(F, 0);
1015 Changed |= setOnlyReadsMemory(F, 0);
1020 Changed |= setRetAndArgsNoUndef(F);
1021 Changed |= setDoesNotCapture(F, 3);
1024 Changed |= setArgNoUndef(F, 1);
1027 Changed |= setDoesNotThrow(F);
1028 Changed |= setRetDoesNotAlias(F);
1029 Changed |= setWillReturn(F);
1030 Changed |= setDoesNotCapture(F, 0);
1031 Changed |= setOnlyReadsMemory(F, 0);
1034 Changed |= setDoesNotThrow(F);
1035 Changed |= setDoesNotCapture(F, 1);
1036 Changed |= setOnlyReadsMemory(F, 1);
1039 Changed |= setRetAndArgsNoUndef(F);
1040 Changed |= setDoesNotThrow(F);
1041 Changed |= setDoesNotCapture(F, 0);
1044 Changed |= setRetAndArgsNoUndef(F);
1045 Changed |= setDoesNotThrow(F);
1046 Changed |= setDoesNotCapture(F, 1);
1049 Changed |= setRetAndArgsNoUndef(F);
1050 Changed |= setDoesNotThrow(F);
1051 Changed |= setDoesNotCapture(F, 0);
1052 Changed |= setOnlyReadsMemory(F, 0);
1057 Changed |= setRetAndArgsNoUndef(F);
1058 Changed |= setDoesNotThrow(F);
1059 Changed |= setDoesNotCapture(F, 0);
1060 Changed |= setDoesNotCapture(F, 1);
1061 Changed |= setOnlyReadsMemory(F, 0);
1064 Changed |= setRetAndArgsNoUndef(F);
1065 Changed |= setDoesNotThrow(F);
1066 Changed |= setDoesNotCapture(F, 0);
1067 Changed |= setDoesNotCapture(F, 1);
1068 Changed |= setOnlyReadsMemory(F, 0);
1069 Changed |= setOnlyReadsMemory(F, 1);
1072 Changed |= setRetAndArgsNoUndef(F);
1073 Changed |= setDoesNotThrow(F);
1074 Changed |= setRetDoesNotAlias(F);
1075 Changed |= setDoesNotCapture(F, 0);
1076 Changed |= setDoesNotCapture(F, 1);
1077 Changed |= setOnlyReadsMemory(F, 0);
1078 Changed |= setOnlyReadsMemory(F, 1);
1082 Changed |= setRetAndArgsNoUndef(F);
1083 Changed |= setDoesNotThrow(F);
1084 Changed |= setDoesNotCapture(F, 0);
1087 Changed |= setRetAndArgsNoUndef(F);
1088 Changed |= setDoesNotThrow(F);
1089 Changed |= setRetDoesNotAlias(F);
1093 Changed |= setRetAndArgsNoUndef(F);
1094 Changed |= setDoesNotThrow(F);
1095 Changed |= setDoesNotCapture(F, 1);
1099 Changed |= setRetAndArgsNoUndef(F);
1100 Changed |= setDoesNotCapture(F, 0);
1101 Changed |= setOnlyReadsMemory(F, 0);
1107 Changed |= setRetAndArgsNoUndef(F);
1108 Changed |= setDoesNotThrow(F);
1109 Changed |= setDoesNotCapture(F, 0);
1110 Changed |= setDoesNotCapture(F, 1);
1115 Changed |= setDoesNotCapture(F, 0);
1116 Changed |= setDoesNotCapture(F, 1);
1117 Changed |= setOnlyReadsMemory(F, 1);
1120 Changed |= setWillReturn(F);
1123 Changed |= setOnlyAccessesArgMemory(F);
1124 Changed |= setOnlyWritesMemory(F, 0);
1125 Changed |= setDoesNotThrow(F);
1128 Changed |= setIsCold(F);
1131 Changed |= setIsCold(F);
1132 Changed |= setNoReturn(F);
1135 Changed |= setIsCold(F);
1136 Changed |= setNoReturn(F);
1141 Changed |= setRetAndArgsNoUndef(F);
1142 Changed |= setDoesNotAccessMemory(F);
1143 Changed |= setDoesNotThrow(F);
1148 Changed |= setWillReturn(F);
1153 Changed |= setDoesNotCapture(F, 2);
1301 Changed |= setDoesNotThrow(F);
1302 Changed |= setDoesNotFreeMemory(F);
1303 Changed |= setOnlyWritesMemory(F);
1304 Changed |= setWillReturn(F);
1309 Changed |= setDoesNotThrow(F);
1310 Changed |= setDoesNotFreeMemory(F);
1311 Changed |= setOnlyWritesMemory(F);
1312 Changed |= setOnlyWritesMemory(F, 1);
1313 Changed |= setOnlyWritesMemory(F, 2);
1314 Changed |= setDoesNotCapture(F, 1);
1315 Changed |= setDoesNotCapture(F, 2);
1316 Changed |= setWillReturn(F);
1324 // we can reliably identify free-like and realloc-like functions.
1325 if (!isLibFreeFunction(&F, TheLibFunc) && !isReallocLikeFn(&F))
1326 Changed |= setDoesNotFreeMemory(F);
1330 static void setArgExtAttr(Function &F, unsigned ArgNo,
1333 if (ExtAttr != Attribute::None && !F.hasParamAttribute(ArgNo, ExtAttr))
1334 F.addParamAttr(ArgNo, ExtAttr);
1337 static void setRetExtAttr(Function &F,
1340 if (ExtAttr != Attribute::None && !F.hasRetAttribute(ExtAttr))
1341 F.addRetAttr(ExtAttr);
1345 void llvm::markRegisterParameterAttributes(Function *F) {
1346 if (!F->arg_size() || F->isVarArg())
1349 const CallingConv::ID CC = F->getCallingConv();
1353 const Module *M = F->getParent();
1354 unsigned N = M->getNumberRegisterParameters();
1358 const DataLayout &DL = M->getDataLayout();
1360 for (Argument &A : F->args()) {
1362 if (!T->isIntOrPtrTy())
1374 N -= NumRegs;
1375 F->addParamAttr(A.getArgNo(), Attribute::InReg);
1383 "Creating call to non-existing library function.");
1385 FunctionCallee C = M->getOrInsertFunction(Name, T, AttributeList);
1394 // zero extensions as needed. F is retreived with cast<> because we demand
1396 Function *F = cast<Function>(C.getCallee());
1397 assert(F->getFunctionType() == T && "Function type does not match.");
1401 setArgExtAttr(*F, 0, TLI);
1409 setArgExtAttr(*F, 1, TLI);
1412 setArgExtAttr(*F, 2, TLI);
1419 setRetExtAttr(*F, TLI);
1440 for (unsigned i = 0; i < T->getNumParams(); i++)
1441 assert(!isa<IntegerType>(T->getParamType(i)) &&
1447 markRegisterParameterAttributes(F);
1459 StringRef FuncName = TLI->getName(TheLibFunc);
1460 if (!TLI->has(TheLibFunc))
1465 if (GlobalValue *GV = M->getNamedValue(FuncName)) {
1466 if (auto *F = dyn_cast<Function>(GV))
1467 return TLI->isValidProtoForLibFunc(*F->getFunctionType(), TheLibFunc, *M);
1477 return TLI->getLibFunc(Name, TheLibFunc) &&
1483 switch (Ty->getTypeID()) {
1501 switch (Ty->getTypeID()) {
1506 return TLI->getName(FloatFn);
1509 return TLI->getName(DoubleFn);
1512 return TLI->getName(LongDoubleFn);
1516 //- Emit LibCalls ------------------------------------------------------------//
1519 return B.getIntNTy(TLI->getIntSize());
1523 const Module *M = B.GetInsertBlock()->getModule();
1524 return B.getIntNTy(TLI->getSizeTSize(*M));
1532 Module *M = B.GetInsertBlock()->getModule();
1536 StringRef FuncName = TLI->getName(TheLibFunc);
1541 if (const Function *F =
1542 dyn_cast<Function>(Callee.getCallee()->stripPointerCasts()))
1543 CI->setCallingConv(F->getCallingConv());
1581 Type *CharPtrTy = Dst->getType();
1612 Module *M = B.GetInsertBlock()->getModule();
1617 AS = AttributeList::get(M->getContext(), AttributeList::FunctionIndex,
1622 AttributeList::get(M->getContext(), AS), VoidPtrTy,
1625 if (const Function *F =
1626 dyn_cast<Function>(MemCpy.getCallee()->stripPointerCasts()))
1627 CI->setCallingConv(F->getCallingConv());
1757 {CharPtrTy, SizeTTy, CharPtrTy, VAList->getType()},
1766 {CharPtrTy, CharPtrTy, VAList->getType()},
1773 if (!Op->getType()->isDoubleTy()) {
1776 if (Op->getType()->isFloatTy())
1777 NameBuffer += 'f';
1791 Module *M = B.GetInsertBlock()->getModule();
1792 FunctionCallee Callee = getOrInsertLibFunc(M, *TLI, TheLibFunc, Op->getType(),
1793 Op->getType());
1799 CI->setAttributes(
1801 if (const Function *F =
1802 dyn_cast<Function>(Callee.getCallee()->stripPointerCasts()))
1803 CI->setCallingConv(F->getCallingConv());
1815 TLI->getLibFunc(Name, TheLibFunc);
1825 Module *M = B.GetInsertBlock()->getModule();
1827 StringRef Name = getFloatFn(M, TLI, Op->getType(), DoubleFn, FloatFn,
1840 Module *M = B.GetInsertBlock()->getModule();
1841 FunctionCallee Callee = getOrInsertLibFunc(M, *TLI, TheLibFunc, Op1->getType(),
1842 Op1->getType(), Op2->getType());
1849 CI->setAttributes(
1851 if (const Function *F =
1852 dyn_cast<Function>(Callee.getCallee()->stripPointerCasts()))
1853 CI->setCallingConv(F->getCallingConv());
1868 TLI->getLibFunc(Name, TheLibFunc);
1879 Module *M = B.GetInsertBlock()->getModule();
1881 StringRef Name = getFloatFn(M, TLI, Op1->getType(), DoubleFn, FloatFn,
1891 Module *M = B.GetInsertBlock()->getModule();
1896 StringRef PutCharName = TLI->getName(LibFunc_putchar);
1902 if (const Function *F =
1903 dyn_cast<Function>(PutChar.getCallee()->stripPointerCasts()))
1904 CI->setCallingConv(F->getCallingConv());
1910 Module *M = B.GetInsertBlock()->getModule();
1915 StringRef PutsName = TLI->getName(LibFunc_puts);
1920 if (const Function *F =
1921 dyn_cast<Function>(PutS.getCallee()->stripPointerCasts()))
1922 CI->setCallingConv(F->getCallingConv());
1928 Module *M = B.GetInsertBlock()->getModule();
1933 StringRef FPutcName = TLI->getName(LibFunc_fputc);
1934 FunctionCallee F = getOrInsertLibFunc(M, *TLI, LibFunc_fputc, IntTy,
1935 IntTy, File->getType());
1936 if (File->getType()->isPointerTy())
1938 CallInst *CI = B.CreateCall(F, {Char, File}, FPutcName);
1941 dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
1942 CI->setCallingConv(Fn->getCallingConv());
1948 Module *M = B.GetInsertBlock()->getModule();
1953 StringRef FPutsName = TLI->getName(LibFunc_fputs);
1954 FunctionCallee F = getOrInsertLibFunc(M, *TLI, LibFunc_fputs, IntTy,
1955 B.getPtrTy(), File->getType());
1956 if (File->getType()->isPointerTy())
1958 CallInst *CI = B.CreateCall(F, {Str, File}, FPutsName);
1961 dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
1962 CI->setCallingConv(Fn->getCallingConv());
1968 Module *M = B.GetInsertBlock()->getModule();
1973 StringRef FWriteName = TLI->getName(LibFunc_fwrite);
1974 FunctionCallee F =
1976 SizeTTy, SizeTTy, File->getType());
1978 if (File->getType()->isPointerTy())
1981 B.CreateCall(F, {Ptr, Size,
1985 dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
1986 CI->setCallingConv(Fn->getCallingConv());
1992 Module *M = B.GetInsertBlock()->getModule();
1996 StringRef MallocName = TLI->getName(LibFunc_malloc);
2003 if (const Function *F =
2004 dyn_cast<Function>(Malloc.getCallee()->stripPointerCasts()))
2005 CI->setCallingConv(F->getCallingConv());
2012 Module *M = B.GetInsertBlock()->getModule();
2023 if (const auto *F =
2024 dyn_cast<Function>(Calloc.getCallee()->stripPointerCasts()))
2025 CI->setCallingConv(F->getCallingConv());
2034 Module *M = B.GetInsertBlock()->getModule();
2038 StringRef Name = TLI->getName(SizeFeedbackNewFunc);
2042 StructType::get(M->getContext(), {B.getPtrTy(), Num->getType()});
2044 M->getOrInsertFunction(Name, SizedPtrT, Num->getType(), B.getInt8Ty());
2048 if (const Function *F = dyn_cast<Function>(Func.getCallee()))
2049 CI->setCallingConv(F->getCallingConv());
2059 Module *M = B.GetInsertBlock()->getModule();
2063 StringRef Name = TLI->getName(SizeFeedbackNewFunc);
2067 StructType::get(M->getContext(), {B.getPtrTy(), Num->getType()});
2068 FunctionCallee Func = M->getOrInsertFunction(Name, SizedPtrT, Num->getType(),
2069 Align->getType(), B.getInt8Ty());
2074 if (const Function *F = dyn_cast<Function>(Func.getCallee()))
2075 CI->setCallingConv(F->getCallingConv());
2083 Module *M = B.GetInsertBlock()->getModule();
2087 StringRef Name = TLI->getName(NewFunc);
2089 M->getOrInsertFunction(Name, B.getPtrTy(), Num->getType(), B.getInt8Ty());
2093 if (const Function *F =
2094 dyn_cast<Function>(Func.getCallee()->stripPointerCasts()))
2095 CI->setCallingConv(F->getCallingConv());
2103 Module *M = B.GetInsertBlock()->getModule();
2107 StringRef Name = TLI->getName(NewFunc);
2108 FunctionCallee Func = M->getOrInsertFunction(
2109 Name, B.getPtrTy(), Num->getType(), NoThrow->getType(), B.getInt8Ty());
2113 if (const Function *F =
2114 dyn_cast<Function>(Func.getCallee()->stripPointerCasts()))
2115 CI->setCallingConv(F->getCallingConv());
2123 Module *M = B.GetInsertBlock()->getModule();
2127 StringRef Name = TLI->getName(NewFunc);
2128 FunctionCallee Func = M->getOrInsertFunction(
2129 Name, B.getPtrTy(), Num->getType(), Align->getType(), B.getInt8Ty());
2133 if (const Function *F =
2134 dyn_cast<Function>(Func.getCallee()->stripPointerCasts()))
2135 CI->setCallingConv(F->getCallingConv());
2144 Module *M = B.GetInsertBlock()->getModule();
2148 StringRef Name = TLI->getName(NewFunc);
2149 FunctionCallee Func = M->getOrInsertFunction(
2150 Name, B.getPtrTy(), Num->getType(), Align->getType(), NoThrow->getType(),
2156 if (const Function *F =
2157 dyn_cast<Function>(Func.getCallee()->stripPointerCasts()))
2158 CI->setCallingConv(F->getCallingConv());