78#define DEBUG_TYPE "inline-function"
87 cl::desc(
"Convert noalias attributes to metadata during inlining."));
92 cl::desc(
"Use the llvm.experimental.noalias.scope.decl "
93 "intrinsic during inlining."));
101 cl::desc(
"Convert align attributes to assumptions during inlining."));
104 "max-inst-checked-for-throw-during-inlining",
cl::Hidden,
105 cl::desc(
"the maximum number of instructions analyzed for may throw during "
106 "attribute inference in inlined body"),
112 class LandingPadInliningInfo {
123 PHINode *InnerEHValuesPHI =
nullptr;
129 : OuterResumeDest(II->getUnwindDest()) {
135 for (; isa<PHINode>(
I); ++
I) {
138 UnwindDestPHIValues.
push_back(
PHI->getIncomingValueForBlock(InvokeBB));
141 CallerLPad = cast<LandingPadInst>(
I);
147 return OuterResumeDest;
164 void addIncomingPHIValuesFor(
BasicBlock *BB)
const {
165 addIncomingPHIValuesForInto(BB, OuterResumeDest);
170 for (
unsigned i = 0, e = UnwindDestPHIValues.
size(); i != e; ++i, ++
I) {
172 phi->addIncoming(UnwindDestPHIValues[i], src);
180BasicBlock *LandingPadInliningInfo::getInnerResumeDest() {
181 if (InnerResumeDest)
return InnerResumeDest;
187 OuterResumeDest->
getName() +
".body");
190 const unsigned PHICapacity = 2;
195 for (
unsigned i = 0, e = UnwindDestPHIValues.
size(); i != e; ++i, ++
I) {
196 PHINode *OuterPHI = cast<PHINode>(
I);
198 OuterPHI->
getName() +
".lpad-body");
209 InnerEHValuesPHI->
addIncoming(CallerLPad, OuterResumeDest);
212 return InnerResumeDest;
219void LandingPadInliningInfo::forwardResume(
228 addIncomingPHIValuesForInto(Src, Dest);
236 if (
auto *FPI = dyn_cast<FuncletPadInst>(EHPad))
237 return FPI->getParentPad();
238 return cast<CatchSwitchInst>(EHPad)->getParentPad();
249 while (!Worklist.
empty()) {
256 Value *UnwindDestToken =
nullptr;
257 if (
auto *CatchSwitch = dyn_cast<CatchSwitchInst>(CurrentPad)) {
258 if (CatchSwitch->hasUnwindDest()) {
259 UnwindDestToken = CatchSwitch->getUnwindDest()->getFirstNonPHI();
267 for (
auto HI = CatchSwitch->handler_begin(),
268 HE = CatchSwitch->handler_end();
269 HI != HE && !UnwindDestToken; ++HI) {
271 auto *CatchPad = cast<CatchPadInst>(HandlerBlock->
getFirstNonPHI());
277 if (!isa<CleanupPadInst>(Child) && !isa<CatchSwitchInst>(Child))
281 auto Memo = MemoMap.
find(ChildPad);
282 if (Memo == MemoMap.
end()) {
289 Value *ChildUnwindDestToken = Memo->second;
290 if (!ChildUnwindDestToken)
296 if (isa<ConstantTokenNone>(ChildUnwindDestToken)) {
297 UnwindDestToken = ChildUnwindDestToken;
305 auto *CleanupPad = cast<CleanupPadInst>(CurrentPad);
306 for (
User *U : CleanupPad->users()) {
307 if (
auto *CleanupRet = dyn_cast<CleanupReturnInst>(U)) {
308 if (
BasicBlock *RetUnwindDest = CleanupRet->getUnwindDest())
309 UnwindDestToken = RetUnwindDest->getFirstNonPHI();
314 Value *ChildUnwindDestToken;
315 if (
auto *Invoke = dyn_cast<InvokeInst>(U)) {
316 ChildUnwindDestToken = Invoke->getUnwindDest()->getFirstNonPHI();
317 }
else if (isa<CleanupPadInst>(U) || isa<CatchSwitchInst>(U)) {
319 auto Memo = MemoMap.
find(ChildPad);
320 if (Memo == MemoMap.
end()) {
327 ChildUnwindDestToken = Memo->second;
328 if (!ChildUnwindDestToken)
337 if (isa<Instruction>(ChildUnwindDestToken) &&
340 UnwindDestToken = ChildUnwindDestToken;
346 if (!UnwindDestToken)
354 if (
auto *UnwindPad = dyn_cast<Instruction>(UnwindDestToken))
357 UnwindParent =
nullptr;
358 bool ExitedOriginalPad =
false;
360 ExitedPad && ExitedPad != UnwindParent;
361 ExitedPad = dyn_cast<Instruction>(
getParentPad(ExitedPad))) {
363 if (isa<CatchPadInst>(ExitedPad))
365 MemoMap[ExitedPad] = UnwindDestToken;
366 ExitedOriginalPad |= (ExitedPad == EHPad);
369 if (ExitedOriginalPad)
370 return UnwindDestToken;
401 if (
auto *CPI = dyn_cast<CatchPadInst>(EHPad))
402 EHPad = CPI->getCatchSwitch();
405 auto Memo = MemoMap.
find(EHPad);
406 if (Memo != MemoMap.
end())
411 assert((UnwindDestToken ==
nullptr) != (MemoMap.
count(EHPad) != 0));
413 return UnwindDestToken;
420 MemoMap[EHPad] =
nullptr;
426 Value *AncestorToken;
428 auto *AncestorPad = dyn_cast<Instruction>(AncestorToken);
431 if (isa<CatchPadInst>(AncestorPad))
440 assert(!MemoMap.
count(AncestorPad) || MemoMap[AncestorPad]);
441 auto AncestorMemo = MemoMap.
find(AncestorPad);
442 if (AncestorMemo == MemoMap.
end()) {
445 UnwindDestToken = AncestorMemo->second;
449 LastUselessPad = AncestorPad;
450 MemoMap[LastUselessPad] =
nullptr;
452 TempMemos.
insert(LastUselessPad);
470 while (!Worklist.
empty()) {
472 auto Memo = MemoMap.
find(UselessPad);
473 if (Memo != MemoMap.
end() && Memo->second) {
501 MemoMap[UselessPad] = UnwindDestToken;
502 if (
auto *CatchSwitch = dyn_cast<CatchSwitchInst>(UselessPad)) {
503 assert(CatchSwitch->getUnwindDest() ==
nullptr &&
"Expected useless pad");
504 for (
BasicBlock *HandlerBlock : CatchSwitch->handlers()) {
505 auto *CatchPad = HandlerBlock->getFirstNonPHI();
506 for (
User *U : CatchPad->users()) {
508 (!isa<InvokeInst>(U) ||
510 cast<InvokeInst>(U)->getUnwindDest()->getFirstNonPHI()) ==
512 "Expected useless pad");
513 if (isa<CatchSwitchInst>(U) || isa<CleanupPadInst>(U))
514 Worklist.
push_back(cast<Instruction>(U));
518 assert(isa<CleanupPadInst>(UselessPad));
520 assert(!isa<CleanupReturnInst>(U) &&
"Expected useless pad");
521 assert((!isa<InvokeInst>(U) ||
523 cast<InvokeInst>(U)->getUnwindDest()->getFirstNonPHI()) ==
525 "Expected useless pad");
526 if (isa<CatchSwitchInst>(U) || isa<CleanupPadInst>(U))
527 Worklist.
push_back(cast<Instruction>(U));
532 return UnwindDestToken;
558 if (
F->getIntrinsicID() == Intrinsic::experimental_deoptimize ||
559 F->getIntrinsicID() == Intrinsic::experimental_guard)
570 auto *FuncletPad = cast<Instruction>(FuncletBundle->Inputs[0]);
571 Value *UnwindDestToken =
573 if (UnwindDestToken && !isa<ConstantTokenNone>(UnwindDestToken))
577 if (
auto *CatchPad = dyn_cast<CatchPadInst>(FuncletPad))
578 MemoKey = CatchPad->getCatchSwitch();
580 MemoKey = FuncletPad;
581 assert(FuncletUnwindMap->count(MemoKey) &&
582 (*FuncletUnwindMap)[MemoKey] == UnwindDestToken &&
583 "must get memoized to avoid confusing later searches");
608 LandingPadInliningInfo Invoke(II);
614 if (
InvokeInst *II = dyn_cast<InvokeInst>(
I->getTerminator()))
622 InlinedLPad->reserveClauses(OuterNum);
623 for (
unsigned OuterIdx = 0; OuterIdx != OuterNum; ++OuterIdx)
624 InlinedLPad->addClause(OuterLPad->
getClause(OuterIdx));
626 InlinedLPad->setCleanup(
true);
633 &*BB, Invoke.getOuterResumeDest()))
636 Invoke.addIncomingPHIValuesFor(NewBB);
639 if (
ResumeInst *RI = dyn_cast<ResumeInst>(BB->getTerminator()))
640 Invoke.forwardResume(RI, InlinedLPads);
670 UnwindDestPHIValues.
push_back(
PHI.getIncomingValueForBlock(InvokeBB));
677 for (
Value *V : UnwindDestPHIValues) {
679 PHI->addIncoming(V, Src);
689 if (
auto *CRI = dyn_cast<CleanupReturnInst>(BB->getTerminator())) {
690 if (CRI->unwindsToCaller()) {
691 auto *CleanupPad = CRI->getCleanupPad();
693 CRI->eraseFromParent();
700 isa<ConstantTokenNone>(FuncletUnwindMap[CleanupPad]));
701 FuncletUnwindMap[CleanupPad] =
711 if (
auto *CatchSwitch = dyn_cast<CatchSwitchInst>(
I)) {
712 if (CatchSwitch->unwindsToCaller()) {
713 Value *UnwindDestToken;
714 if (
auto *ParentPad =
715 dyn_cast<Instruction>(CatchSwitch->getParentPad())) {
725 if (UnwindDestToken && !isa<ConstantTokenNone>(UnwindDestToken))
738 CatchSwitch->getParentPad(), UnwindDest,
739 CatchSwitch->getNumHandlers(), CatchSwitch->
getName(),
741 for (
BasicBlock *PadBB : CatchSwitch->handlers())
742 NewCatchSwitch->addHandler(PadBB);
747 FuncletUnwindMap[NewCatchSwitch] = UnwindDestToken;
748 Replacement = NewCatchSwitch;
750 }
else if (!isa<FuncletPadInst>(
I)) {
756 I->replaceAllUsesWith(Replacement);
757 I->eraseFromParent();
767 &*BB, UnwindDest, &FuncletUnwindMap))
780 MDNode *CallsiteStackContext) {
786 for (
auto MIBStackIter = MIBStackContext->
op_begin(),
787 CallsiteStackIter = CallsiteStackContext->
op_begin();
788 MIBStackIter != MIBStackContext->
op_end() &&
789 CallsiteStackIter != CallsiteStackContext->
op_end();
790 MIBStackIter++, CallsiteStackIter++) {
791 auto *Val1 = mdconst::dyn_extract<ConstantInt>(*MIBStackIter);
792 auto *Val2 = mdconst::dyn_extract<ConstantInt>(*CallsiteStackIter);
794 if (Val1->getZExtValue() != Val2->getZExtValue())
801 Call->setMetadata(LLVMContext::MD_memprof,
nullptr);
805 Call->setMetadata(LLVMContext::MD_callsite,
nullptr);
809 const std::vector<Metadata *> &MIBList) {
816 CallStack.addCallStack(cast<MDNode>(MIB));
817 bool MemprofMDAttached =
CallStack.buildAndAttachMIBMetadata(CI);
819 if (!MemprofMDAttached)
829 MDNode *InlinedCallsiteMD) {
831 MDNode *ClonedCallsiteMD =
nullptr;
834 if (OrigCallsiteMD) {
839 ClonedCall->
setMetadata(LLVMContext::MD_callsite, ClonedCallsiteMD);
851 std::vector<Metadata *> NewMIBList;
856 for (
auto &MIBOp : OrigMemProfMD->
operands()) {
857 MDNode *MIB = dyn_cast<MDNode>(MIBOp);
864 NewMIBList.push_back(MIB);
866 if (NewMIBList.empty()) {
882 bool ContainsMemProfMetadata,
887 if (!CallsiteMD && !ContainsMemProfMetadata)
891 for (
const auto &Entry : VMap) {
894 auto *OrigCall = dyn_cast_or_null<CallBase>(Entry.first);
895 auto *ClonedCall = dyn_cast_or_null<CallBase>(Entry.second);
896 if (!OrigCall || !ClonedCall)
915 MDNode *MemParallelLoopAccess =
916 CB.
getMetadata(LLVMContext::MD_mem_parallel_loop_access);
920 if (!MemParallelLoopAccess && !AccessGroup && !AliasScope && !NoAlias)
926 if (!
I.mayReadOrWriteMemory())
929 if (MemParallelLoopAccess) {
932 I.getMetadata(LLVMContext::MD_mem_parallel_loop_access),
933 MemParallelLoopAccess);
934 I.setMetadata(LLVMContext::MD_mem_parallel_loop_access,
935 MemParallelLoopAccess);
940 I.getMetadata(LLVMContext::MD_access_group), AccessGroup));
944 I.getMetadata(LLVMContext::MD_alias_scope), AliasScope));
948 I.getMetadata(LLVMContext::MD_noalias), NoAlias));
966 dyn_cast<Function>(
I->getCalledOperand()->stripPointerCasts());
967 if (CalledFn && CalledFn->isIntrinsic() &&
I->doesNotThrow() &&
972 I->getOperandBundlesAsDefs(OpBundles);
977 I->replaceAllUsesWith(NewInst);
978 I->eraseFromParent();
987class ScopedAliasMetadataDeepCloner {
991 void addRecursiveMetadataUses();
994 ScopedAliasMetadataDeepCloner(
const Function *
F);
1006ScopedAliasMetadataDeepCloner::ScopedAliasMetadataDeepCloner(
1010 if (
const MDNode *M =
I.getMetadata(LLVMContext::MD_alias_scope))
1012 if (
const MDNode *M =
I.getMetadata(LLVMContext::MD_noalias))
1016 if (
const auto *Decl = dyn_cast<NoAliasScopeDeclInst>(&
I))
1017 MD.insert(Decl->getScopeList());
1020 addRecursiveMetadataUses();
1023void ScopedAliasMetadataDeepCloner::addRecursiveMetadataUses() {
1025 while (!
Queue.empty()) {
1028 if (
const MDNode *OpMD = dyn_cast<MDNode>(
Op))
1029 if (MD.insert(OpMD))
1030 Queue.push_back(OpMD);
1034void ScopedAliasMetadataDeepCloner::clone() {
1035 assert(MDMap.empty() &&
"clone() already called ?");
1040 MDMap[
I].reset(DummyNodes.
back().get());
1049 if (
const MDNode *M = dyn_cast<MDNode>(
Op))
1056 MDTuple *TempM = cast<MDTuple>(MDMap[
I]);
1073 if (
MDNode *M =
I.getMetadata(LLVMContext::MD_alias_scope))
1074 if (
MDNode *MNew = MDMap.lookup(M))
1075 I.setMetadata(LLVMContext::MD_alias_scope, MNew);
1077 if (
MDNode *M =
I.getMetadata(LLVMContext::MD_noalias))
1078 if (
MDNode *MNew = MDMap.lookup(M))
1079 I.setMetadata(LLVMContext::MD_noalias, MNew);
1081 if (
auto *Decl = dyn_cast<NoAliasScopeDeclInst>(&
I))
1082 if (
MDNode *MNew = MDMap.lookup(Decl->getScopeList()))
1083 Decl->setScopeList(MNew);
1102 if (CB.
paramHasAttr(Arg.getArgNo(), Attribute::NoAlias) && !Arg.use_empty())
1105 if (NoAliasArgs.
empty())
1125 for (
unsigned i = 0, e = NoAliasArgs.
size(); i != e; ++i) {
1128 std::string
Name = std::string(CalledFunc->
getName());
1131 Name +=
A->getName();
1133 Name +=
": argument ";
1141 NewScopes.
insert(std::make_pair(
A, NewScope));
1158 VMI != VMIE; ++VMI) {
1159 if (
const Instruction *
I = dyn_cast<Instruction>(VMI->first)) {
1163 Instruction *NI = dyn_cast<Instruction>(VMI->second);
1167 bool IsArgMemOnlyCall =
false, IsFuncCall =
false;
1170 if (
const LoadInst *LI = dyn_cast<LoadInst>(
I))
1171 PtrArgs.
push_back(LI->getPointerOperand());
1172 else if (
const StoreInst *SI = dyn_cast<StoreInst>(
I))
1173 PtrArgs.
push_back(SI->getPointerOperand());
1174 else if (
const VAArgInst *VAAI = dyn_cast<VAArgInst>(
I))
1175 PtrArgs.
push_back(VAAI->getPointerOperand());
1177 PtrArgs.
push_back(CXI->getPointerOperand());
1179 PtrArgs.
push_back(RMWI->getPointerOperand());
1180 else if (
const auto *Call = dyn_cast<CallBase>(
I)) {
1184 if (Call->doesNotAccessMemory())
1196 IsArgMemOnlyCall =
true;
1199 for (
Value *Arg : Call->args()) {
1203 if (!Arg->getType()->isPointerTy())
1214 if (PtrArgs.
empty() && !IsFuncCall)
1224 for (
const Value *V : PtrArgs) {
1228 for (
const Value *O : Objects)
1234 bool RequiresNoCaptureBefore =
false, UsesAliasingPtr =
false,
1235 UsesUnknownObject =
false;
1236 for (
const Value *V : ObjSet) {
1240 bool IsNonPtrConst = isa<ConstantInt>(V) || isa<ConstantFP>(V) ||
1241 isa<ConstantPointerNull>(V) ||
1242 isa<ConstantDataVector>(V) || isa<UndefValue>(V);
1249 if (
const Argument *
A = dyn_cast<Argument>(V)) {
1251 UsesAliasingPtr =
true;
1253 UsesAliasingPtr =
true;
1259 RequiresNoCaptureBefore =
true;
1265 UsesUnknownObject =
true;
1271 if (UsesUnknownObject)
1276 if (IsFuncCall && !IsArgMemOnlyCall)
1277 RequiresNoCaptureBefore =
true;
1295 if (!RequiresNoCaptureBefore ||
1317 bool CanAddScopes = !UsesAliasingPtr;
1318 if (CanAddScopes && IsFuncCall)
1319 CanAddScopes = IsArgMemOnlyCall;
1324 Scopes.push_back(NewScopes[
A]);
1327 if (!Scopes.empty())
1329 LLVMContext::MD_alias_scope,
1340 "Expected to be in same basic block!");
1342 assert(BeginIt !=
End->getIterator() &&
"Non-empty BB has empty iterator");
1368 auto &
Context = CalledFunction->getContext();
1370 for (
auto &BB : *CalledFunction) {
1371 auto *RI = dyn_cast<ReturnInst>(BB.getTerminator());
1372 if (!RI || !isa<CallBase>(RI->
getOperand(0)))
1374 auto *RetVal = cast<CallBase>(RI->
getOperand(0));
1378 auto *NewRetVal = dyn_cast_or_null<CallBase>(VMap.
lookup(RetVal));
1410 NewRetVal->setAttributes(NewAL);
1426 bool DTCalculated =
false;
1430 if (!Arg.getType()->isPointerTy() || Arg.hasPassPointeeByValueCopyAttr() ||
1437 if (!DTCalculated) {
1439 DTCalculated =
true;
1448 DL, ArgVal, Alignment->value());
1460 Builder.getInt64(M->getDataLayout().getTypeStoreSize(ByValType));
1473 CI->
setDebugLoc(DILocation::get(SP->getContext(), 0, 0, SP));
1484 const DataLayout &
DL = Caller->getParent()->getDataLayout();
1510 Align Alignment =
DL.getPrefTypeAlign(ByValType);
1516 Alignment = std::max(Alignment, *ByValAlignment);
1519 nullptr, Alignment, Arg->
getName());
1530 for (
User *U : V->users())
1543 if (Ty == Int8PtrTy)
1548 if (U->getType() != Int8PtrTy)
continue;
1549 if (U->stripPointerCasts() != AI)
continue;
1569 return DILocation::get(Ctx, OrigDL.
getLine(), OrigDL.
getCol(),
1586 InlinedAtNode = DILocation::getDistinct(
1587 Ctx, InlinedAtNode->getLine(), InlinedAtNode->getColumn(),
1588 InlinedAtNode->getScope(), InlinedAtNode->getInlinedAt());
1597 bool NoInlineLineTables = Fn->
hasFnAttribute(
"no-inline-line-tables");
1599 for (; FI != Fn->
end(); ++FI) {
1604 auto updateLoopInfoLoc = [&Ctx, &InlinedAtNode,
1606 if (
auto *Loc = dyn_cast_or_null<DILocation>(MD))
1612 if (!NoInlineLineTables)
1616 BI->setDebugLoc(IDL);
1620 if (CalleeHasDebugInfo && !NoInlineLineTables)
1630 if (
auto *AI = dyn_cast<AllocaInst>(BI))
1637 if (isa<PseudoProbeInst>(BI))
1640 BI->setDebugLoc(TheCallDL);
1644 if (NoInlineLineTables) {
1646 while (BI != FI->end()) {
1647 if (isa<DbgInfoIntrinsic>(BI)) {
1648 BI = BI->eraseFromParent();
1659#define DEBUG_TYPE "assignment-tracking"
1667 errs() <<
"# Finding caller local variables escaped by callee\n");
1670 if (!Arg->getType()->isPointerTy()) {
1682 assert(Arg->getType()->isPtrOrPtrVectorTy());
1683 APInt TmpOffset(
DL.getIndexTypeSizeInBits(Arg->getType()), 0,
false);
1685 Arg->stripAndAccumulateConstantOffsets(
DL, TmpOffset,
true));
1687 LLVM_DEBUG(
errs() <<
" | SKIP: Couldn't walk back to base storage\n");
1700 if (DAI->getDebugLoc().getInlinedAt())
1706 return EscapedLocals;
1712 << Start->getParent()->getName() <<
" from "
1714 std::unique_ptr<DataLayout>
DL = std::make_unique<DataLayout>(CB.
getModule());
1724 auto GetNewID = [&Map](
Metadata *Old) {
1734 for (
auto BBI = Start; BBI !=
End; ++BBI) {
1736 if (
auto *
ID =
I.getMetadata(LLVMContext::MD_DIAssignID))
1737 I.setMetadata(LLVMContext::MD_DIAssignID, GetNewID(
ID));
1738 else if (
auto *DAI = dyn_cast<DbgAssignIntrinsic>(&
I))
1739 DAI->setAssignId(GetNewID(DAI->getAssignID()));
1744#define DEBUG_TYPE "inline-function"
1758 for (
auto Entry : VMap) {
1759 if (!isa<BasicBlock>(Entry.first) || !Entry.second)
1761 auto *OrigBB = cast<BasicBlock>(Entry.first);
1762 auto *ClonedBB = cast<BasicBlock>(Entry.second);
1764 if (!ClonedBBs.
insert(ClonedBB).second) {
1787 auto CallSiteCount =
1790 std::min(CallSiteCount.value_or(0), CalleeEntryCount.
getCount());
1795 Function *Callee, int64_t EntryDelta,
1797 auto CalleeCount = Callee->getEntryCount();
1801 const uint64_t PriorEntryCount = CalleeCount->getCount();
1806 (EntryDelta < 0 && static_cast<uint64_t>(-EntryDelta) > PriorEntryCount)
1808 : PriorEntryCount + EntryDelta;
1812 uint64_t CloneEntryCount = PriorEntryCount - NewEntryCount;
1813 for (
auto Entry : *VMap)
1814 if (isa<CallInst>(Entry.first))
1815 if (
auto *CI = dyn_cast_or_null<CallInst>(Entry.second))
1816 CI->updateProfWeight(CloneEntryCount, PriorEntryCount);
1820 Callee->setEntryCount(NewEntryCount);
1824 if (!VMap || VMap->
count(&BB))
1826 if (
CallInst *CI = dyn_cast<CallInst>(&
I))
1827 CI->updateProfWeight(NewEntryCount, PriorEntryCount);
1853 bool IsRetainRV = RVCallKind == objcarc::ARCInstKind::RetainRV,
1854 IsUnsafeClaimRV = !IsRetainRV;
1856 for (
auto *RI : Returns) {
1858 bool InsertRetainCall = IsRetainRV;
1867 if (isa<CastInst>(
I))
1870 if (
auto *II = dyn_cast<IntrinsicInst>(&
I)) {
1871 if (II->
getIntrinsicID() != Intrinsic::objc_autoreleaseReturnValue ||
1881 if (IsUnsafeClaimRV) {
1886 Builder.CreateCall(IFn, BC,
"");
1889 InsertRetainCall =
false;
1893 auto *CI = dyn_cast<CallInst>(&
I);
1908 NewCall->copyMetadata(*CI);
1909 CI->replaceAllUsesWith(NewCall);
1910 CI->eraseFromParent();
1911 InsertRetainCall =
false;
1915 if (InsertRetainCall) {
1922 Builder.CreateCall(IFn, BC,
"");
1936 bool MergeAttributes,
1938 bool InsertLifetime,
1943 if (isa<CallBrInst>(CB))
1956 Value *ConvergenceControlToken =
nullptr;
1972 ConvergenceControlToken = OBUse.Inputs[0].get();
1991 if (
auto *IntrinsicCall = dyn_cast<IntrinsicInst>(
I)) {
1992 if (IntrinsicCall->getIntrinsicID() ==
1993 Intrinsic::experimental_convergence_entry) {
1994 if (!ConvergenceControlToken) {
1996 "convergent call needs convergencectrl operand");
2012 !Caller->getAttributes().hasFnAttr(Attribute::StrictFP)) {
2020 if (CalledFunc->
hasGC()) {
2021 if (!Caller->hasGC())
2022 Caller->setGC(CalledFunc->
getGC());
2023 else if (CalledFunc->
getGC() != Caller->getGC())
2037 Caller->hasPersonalityFn()
2038 ? Caller->getPersonalityFn()->stripPointerCasts()
2040 if (CalledPersonality) {
2041 if (!CallerPersonality)
2042 Caller->setPersonalityFn(CalledPersonality);
2047 else if (CalledPersonality != CallerPersonality)
2054 if (CallerPersonality) {
2057 std::optional<OperandBundleUse> ParentFunclet =
2060 CallSiteEHPad = cast<FuncletPadInst>(ParentFunclet->Inputs.front());
2064 if (CallSiteEHPad) {
2065 if (Personality == EHPersonality::MSVC_CXX) {
2068 if (isa<CleanupPadInst>(CallSiteEHPad)) {
2071 for (
const BasicBlock &CalledBB : *CalledFunc) {
2072 if (isa<CatchSwitchInst>(CalledBB.getFirstNonPHI()))
2079 for (
const BasicBlock &CalledBB : *CalledFunc) {
2080 if (CalledBB.isEHPad())
2090 bool EHPadForCallUnwindsLocally =
false;
2091 if (CallSiteEHPad && isa<CallInst>(CB)) {
2093 Value *CallSiteUnwindDestToken =
2096 EHPadForCallUnwindsLocally =
2097 CallSiteUnwindDestToken &&
2098 !isa<ConstantTokenNone>(CallSiteUnwindDestToken);
2129 auto &
DL = Caller->getParent()->getDataLayout();
2136 E = CalledFunc->
arg_end();
I !=
E; ++
I, ++AI, ++ArgNo) {
2137 Value *ActualArg = *AI;
2145 &CB, CalledFunc, IFI,
2147 if (ActualArg != *AI)
2152 VMap[&*
I] = ActualArg;
2172 false, Returns,
".i",
2173 &InlinedFunctionInfo);
2175 FirstNewBlock = LastBlock; ++FirstNewBlock;
2179 if (RVCallKind != objcarc::ARCInstKind::None)
2190 CalledFunc->
front());
2198 for (ByValInit &
Init : ByValInits)
2200 &*FirstNewBlock, IFI, CalledFunc);
2202 std::optional<OperandBundleUse> ParentDeopt =
2208 CallBase *ICS = dyn_cast_or_null<CallBase>(VH);
2229 std::vector<Value *> MergedDeoptArgs;
2230 MergedDeoptArgs.reserve(ParentDeopt->Inputs.size() +
2231 ChildOB.Inputs.size());
2236 OpDefs.
emplace_back(
"deopt", std::move(MergedDeoptArgs));
2266 SAMetadataCloner.clone();
2267 SAMetadataCloner.remap(FirstNewBlock, Caller->end());
2285 make_range(FirstNewBlock->getIterator(), Caller->end()))
2287 if (
auto *II = dyn_cast<AssumeInst>(&
I))
2291 if (ConvergenceControlToken) {
2292 auto *
I = FirstNewBlock->getFirstNonPHI();
2293 if (
auto *IntrinsicCall = dyn_cast<IntrinsicInst>(
I)) {
2294 if (IntrinsicCall->getIntrinsicID() ==
2295 Intrinsic::experimental_convergence_entry) {
2296 IntrinsicCall->replaceAllUsesWith(ConvergenceControlToken);
2297 IntrinsicCall->eraseFromParent();
2309 E = FirstNewBlock->end();
I !=
E; ) {
2328 while (isa<AllocaInst>(
I) &&
2329 !cast<AllocaInst>(
I)->use_empty() &&
2338 Caller->getEntryBlock().splice(InsertPoint, &*FirstNewBlock,
2351 bool InlinedMustTailCalls =
false, InlinedDeoptimizeCalls =
false;
2354 if (
CallInst *CI = dyn_cast<CallInst>(&CB))
2355 CallSiteTailKind = CI->getTailCallKind();
2370 if (!VarArgsToForward.
empty() &&
2371 ((ForwardVarArgsTo &&
2377 if (!Attrs.isEmpty() || !VarArgsAttrs.
empty()) {
2378 for (
unsigned ArgNo = 0;
2380 ArgAttrs.
push_back(Attrs.getParamAttrs(ArgNo));
2386 Attrs.getRetAttrs(), ArgAttrs);
2401 InlinedDeoptimizeCalls |=
2402 F->getIntrinsicID() == Intrinsic::experimental_deoptimize;
2421 ChildTCK = std::min(CallSiteTailKind, ChildTCK);
2440 if ((InsertLifetime || Caller->isPresplitCoroutine()) &&
2443 for (
unsigned ai = 0, ae = IFI.
StaticAllocas.size(); ai != ae; ++ai) {
2458 auto &
DL = Caller->getParent()->getDataLayout();
2460 TypeSize AllocaTypeSize =
DL.getTypeAllocSize(AllocaType);
2461 uint64_t AllocaArraySize = AIArraySize->getLimitedValue();
2464 if (AllocaArraySize == 0)
2470 AllocaArraySize != std::numeric_limits<uint64_t>::max() &&
2471 std::numeric_limits<uint64_t>::max() / AllocaArraySize >=
2474 AllocaArraySize * AllocaTypeSize);
2478 builder.CreateLifetimeStart(AI, AllocaSize);
2482 if (InlinedMustTailCalls &&
2485 if (InlinedDeoptimizeCalls &&
2517 if (
auto *II = dyn_cast<InvokeInst>(&CB)) {
2520 if (isa<LandingPadInst>(FirstNonPHI)) {
2530 if (CallSiteEHPad) {
2541 if (
auto *CleanupRet = dyn_cast<CleanupReturnInst>(BB->getTerminator()))
2542 if (CleanupRet->unwindsToCaller() && EHPadForCallUnwindsLocally)
2549 if (
auto *CatchSwitch = dyn_cast<CatchSwitchInst>(
I)) {
2550 if (isa<ConstantTokenNone>(CatchSwitch->getParentPad()))
2551 CatchSwitch->setParentPad(CallSiteEHPad);
2553 auto *FPI = cast<FuncletPadInst>(
I);
2554 if (isa<ConstantTokenNone>(FPI->getParentPad()))
2555 FPI->setParentPad(CallSiteEHPad);
2560 if (InlinedDeoptimizeCalls) {
2566 if (Caller->getReturnType() == CB.
getType()) {
2568 return RI->
getParent()->getTerminatingDeoptimizeCall() !=
nullptr;
2573 Caller->getParent(), Intrinsic::experimental_deoptimize,
2574 {Caller->getReturnType()});
2600 "Expected at least the deopt operand bundle");
2604 Builder.CreateCall(NewDeoptIntrinsic, CallArgs, OpBundles);
2610 Builder.CreateRet(NewDeoptCall);
2625 if (InlinedMustTailCalls) {
2627 Type *NewRetTy = Caller->getReturnType();
2635 if (!ReturnedMustTail) {
2644 auto *OldCast = dyn_cast_or_null<BitCastInst>(RI->getReturnValue());
2647 OldCast->eraseFromParent();
2651 Builder.CreateRet(
Builder.CreateBitCast(ReturnedMustTail, NewRetTy));
2667 make_range(FirstNewBlock->getIterator(), Caller->end()))
2669 if (
auto *CB = dyn_cast<CallBase>(&
I))
2678 if (Returns.
size() == 1 && std::distance(FirstNewBlock, Caller->end()) == 1) {
2681 FirstNewBlock->end());
2683 Caller->back().eraseFromParent();
2687 if (
InvokeInst *II = dyn_cast<InvokeInst>(&CB)) {
2696 if (&CB == R->getReturnValue())
2705 Returns[0]->eraseFromParent();
2707 if (MergeAttributes)
2721 BranchInst *CreatedBranchToNormalDest =
nullptr;
2722 if (
InvokeInst *II = dyn_cast<InvokeInst>(&CB)) {
2732 CalledFunc->
getName() +
".exit");
2739 CalledFunc->
getName() +
".exit");
2753 "splitBasicBlock broken!");
2759 Caller->splice(AfterCallBB->
getIterator(), Caller, FirstNewBlock,
2767 if (Returns.
size() > 1) {
2772 PHI->insertBefore(AfterCallBB->
begin());
2781 for (
unsigned i = 0, e = Returns.
size(); i != e; ++i) {
2784 "Ret value not consistent in function!");
2791 for (
unsigned i = 0, e = Returns.
size(); i != e; ++i) {
2802 if (CreatedBranchToNormalDest)
2804 }
else if (!Returns.
empty()) {
2808 if (&CB == Returns[0]->getReturnValue())
2815 BasicBlock *ReturnBB = Returns[0]->getParent();
2820 AfterCallBB->
splice(AfterCallBB->
begin(), ReturnBB);
2822 if (CreatedBranchToNormalDest)
2826 Returns[0]->eraseFromParent();
2839 if (InlinedMustTailCalls &&
pred_empty(AfterCallBB))
2844 assert(cast<BranchInst>(Br)->isUnconditional() &&
"splitBasicBlock broken!");
2845 BasicBlock *CalleeEntry = cast<BranchInst>(Br)->getSuccessor(0);
2864 auto &
DL = Caller->getParent()->getDataLayout();
2866 PHI->replaceAllUsesWith(V);
2867 PHI->eraseFromParent();
2871 if (MergeAttributes)
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static void UpdatePHINodes(BasicBlock *OrigBB, BasicBlock *NewBB, ArrayRef< BasicBlock * > Preds, BranchInst *BI, bool HasLoopExit)
Update the PHI nodes in OrigBB to include the values coming from NewBB.
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
static cl::opt< bool > NoAliases("csky-no-aliases", cl::desc("Disable the emission of assembler pseudo instructions"), cl::init(false), cl::Hidden)
This file provides interfaces used to build and manipulate a call graph, which is a very useful tool ...
This file contains the declarations for the subclasses of Constant, which represent the different fla...
This file defines the DenseMap class.
This file provides various utilities for inspecting and working with the control flow graph in LLVM I...
static at::StorageToVarsMap collectEscapedLocals(const DataLayout &DL, const CallBase &CB)
Find Alloca and linked DbgAssignIntrinsic for locals escaped by CB.
static void fixupLineNumbers(Function *Fn, Function::iterator FI, Instruction *TheCall, bool CalleeHasDebugInfo)
Update inlined instructions' line numbers to to encode location where these instructions are inlined.
static void removeCallsiteMetadata(CallBase *Call)
static void propagateMemProfHelper(const CallBase *OrigCall, CallBase *ClonedCall, MDNode *InlinedCallsiteMD)
static Value * getUnwindDestToken(Instruction *EHPad, UnwindDestMemoTy &MemoMap)
Given an EH pad, find where it unwinds.
static cl::opt< bool > PreserveAlignmentAssumptions("preserve-alignment-assumptions-during-inlining", cl::init(false), cl::Hidden, cl::desc("Convert align attributes to assumptions during inlining."))
static void AddReturnAttributes(CallBase &CB, ValueToValueMapTy &VMap)
static void HandleInlinedLandingPad(InvokeInst *II, BasicBlock *FirstNewBlock, ClonedCodeInfo &InlinedCodeInfo)
If we inlined an invoke site, we need to convert calls in the body of the inlined function into invok...
static Value * getUnwindDestTokenHelper(Instruction *EHPad, UnwindDestMemoTy &MemoMap)
Helper for getUnwindDestToken that does the descendant-ward part of the search.
static BasicBlock * HandleCallsInBlockInlinedThroughInvoke(BasicBlock *BB, BasicBlock *UnwindEdge, UnwindDestMemoTy *FuncletUnwindMap=nullptr)
When we inline a basic block into an invoke, we have to turn all of the calls that can throw into inv...
static DebugLoc inlineDebugLoc(DebugLoc OrigDL, DILocation *InlinedAt, LLVMContext &Ctx, DenseMap< const MDNode *, MDNode * > &IANodes)
Returns a DebugLoc for a new DILocation which is a clone of OrigDL inlined at InlinedAt.
static cl::opt< bool > UseNoAliasIntrinsic("use-noalias-intrinsic-during-inlining", cl::Hidden, cl::init(true), cl::desc("Use the llvm.experimental.noalias.scope.decl " "intrinsic during inlining."))
static AttrBuilder IdentifyValidAttributes(CallBase &CB)
static void PropagateCallSiteMetadata(CallBase &CB, Function::iterator FStart, Function::iterator FEnd)
When inlining a call site that has !llvm.mem.parallel_loop_access, !llvm.access.group,...
static void propagateMemProfMetadata(Function *Callee, CallBase &CB, bool ContainsMemProfMetadata, const ValueMap< const Value *, WeakTrackingVH > &VMap)
static void updateCallProfile(Function *Callee, const ValueToValueMapTy &VMap, const ProfileCount &CalleeEntryCount, const CallBase &TheCall, ProfileSummaryInfo *PSI, BlockFrequencyInfo *CallerBFI)
Update the branch metadata for cloned call instructions.
static void updateCallerBFI(BasicBlock *CallSiteBlock, const ValueToValueMapTy &VMap, BlockFrequencyInfo *CallerBFI, BlockFrequencyInfo *CalleeBFI, const BasicBlock &CalleeEntryBlock)
Update the block frequencies of the caller after a callee has been inlined.
static bool MayContainThrowingOrExitingCallAfterCB(CallBase *Begin, ReturnInst *End)
static void HandleByValArgumentInit(Type *ByValType, Value *Dst, Value *Src, Module *M, BasicBlock *InsertBlock, InlineFunctionInfo &IFI, Function *CalledFunc)
static cl::opt< bool > EnableNoAliasConversion("enable-noalias-to-md-conversion", cl::init(true), cl::Hidden, cl::desc("Convert noalias attributes to metadata during inlining."))
static void AddAliasScopeMetadata(CallBase &CB, ValueToValueMapTy &VMap, const DataLayout &DL, AAResults *CalleeAAR, ClonedCodeInfo &InlinedFunctionInfo)
If the inlined function has noalias arguments, then add new alias scopes for each noalias argument,...
static void HandleInlinedEHPad(InvokeInst *II, BasicBlock *FirstNewBlock, ClonedCodeInfo &InlinedCodeInfo)
If we inlined an invoke site, we need to convert calls in the body of the inlined function into invok...
static void inlineRetainOrClaimRVCalls(CallBase &CB, objcarc::ARCInstKind RVCallKind, const SmallVectorImpl< ReturnInst * > &Returns)
An operand bundle "clang.arc.attachedcall" on a call indicates the call result is implicitly consumed...
static Value * getParentPad(Value *EHPad)
Helper for getUnwindDestToken/getUnwindDestTokenHelper.
static void fixupAssignments(Function::iterator Start, Function::iterator End)
Update inlined instructions' DIAssignID metadata.
static bool allocaWouldBeStaticInEntry(const AllocaInst *AI)
Return the result of AI->isStaticAlloca() if AI were moved to the entry block.
static bool isUsedByLifetimeMarker(Value *V)
static void removeMemProfMetadata(CallBase *Call)
static Value * HandleByValArgument(Type *ByValType, Value *Arg, Instruction *TheCall, const Function *CalledFunc, InlineFunctionInfo &IFI, MaybeAlign ByValAlignment)
When inlining a call site that has a byval argument, we have to make the implicit memcpy explicit by ...
static void AddAlignmentAssumptions(CallBase &CB, InlineFunctionInfo &IFI)
If the inlined function has non-byval align arguments, then add @llvm.assume-based alignment assumpti...
static void trackInlinedStores(Function::iterator Start, Function::iterator End, const CallBase &CB)
static cl::opt< unsigned > InlinerAttributeWindow("max-inst-checked-for-throw-during-inlining", cl::Hidden, cl::desc("the maximum number of instructions analyzed for may throw during " "attribute inference in inlined body"), cl::init(4))
static bool haveCommonPrefix(MDNode *MIBStackContext, MDNode *CallsiteStackContext)
static void PropagateOperandBundles(Function::iterator InlinedBB, Instruction *CallSiteEHPad)
Bundle operands of the inlined function must be added to inlined call sites.
static bool hasLifetimeMarkers(AllocaInst *AI)
static void updateMemprofMetadata(CallBase *CI, const std::vector< Metadata * > &MIBList)
static DebugLoc getDebugLoc(MachineBasicBlock::instr_iterator FirstMI, MachineBasicBlock::instr_iterator LastMI)
Return the first found DebugLoc that has a DILocation, given a range of instructions.
Module.h This file contains the declarations for the Module class.
This file defines common analysis utilities used by the ObjC ARC Optimizer.
This file defines ARC utility functions which are used by various parts of the compiler.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file implements a set that has insertion order iteration characteristics.
This file defines the SmallPtrSet class.
This file defines the SmallVector class.
MemoryEffects getMemoryEffects(const CallBase *Call)
Return the behavior of the given call site.
Class for arbitrary precision integers.
an instruction to allocate memory on the stack
bool isSwiftError() const
Return true if this alloca is used as a swifterror argument to a call.
PointerType * getType() const
Overload to return most specific pointer type.
Type * getAllocatedType() const
Return the type that is being allocated by the instruction.
bool isUsedWithInAlloca() const
Return true if this alloca is used as an inalloca argument to a call.
const Value * getArraySize() const
Get the number of elements allocated.
This class represents an incoming formal argument to a Function.
A cache of @llvm.assume calls within a function.
void registerAssumption(AssumeInst *CI)
Add an @llvm.assume intrinsic to this function's cache.
An instruction that atomically checks whether a specified value is in a memory location,...
an instruction that atomically reads a memory location, combines it with another value,...
bool hasAttributes() const
Return true if the builder has IR-level attributes.
AttrBuilder & addAttribute(Attribute::AttrKind Val)
Add an attribute to the builder.
AttrBuilder & addDereferenceableAttr(uint64_t Bytes)
This turns the number of dereferenceable bytes into the form used internally in Attribute.
AttrBuilder & addDereferenceableOrNullAttr(uint64_t Bytes)
This turns the number of dereferenceable_or_null bytes into the form used internally in Attribute.
static AttributeList get(LLVMContext &C, ArrayRef< std::pair< unsigned, Attribute > > Attrs)
Create an AttributeList with the specified parameters in it.
bool hasFnAttr(Attribute::AttrKind Kind) const
Return true if the attribute exists for the function.
AttributeSet getParamAttrs(unsigned ArgNo) const
The attributes for the argument or parameter at the given index are returned.
LLVM Basic Block Representation.
iterator begin()
Instruction iterator methods.
iterator_range< const_phi_iterator > phis() const
Returns a range that iterates over the phis in the basic block.
const Instruction * getFirstNonPHI() const
Returns a pointer to the first instruction in this block that is not a PHINode instruction.
BasicBlock * splitBasicBlock(iterator I, const Twine &BBName="", bool Before=false)
Split the basic block into two basic blocks at the specified instruction.
const CallInst * getTerminatingDeoptimizeCall() const
Returns the call instruction calling @llvm.experimental.deoptimize prior to the terminating return in...
const Function * getParent() const
Return the enclosing method, or null if none.
SymbolTableList< BasicBlock >::iterator eraseFromParent()
Unlink 'this' from the containing function and delete it.
InstListType::iterator iterator
Instruction iterators...
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
const CallInst * getTerminatingMustTailCall() const
Returns the call instruction marked 'musttail' prior to the terminating return instruction of this ba...
void splice(BasicBlock::iterator ToIt, BasicBlock *FromBB)
Transfer all instructions from FromBB to this basic block at ToIt.
void removePredecessor(BasicBlock *Pred, bool KeepOneInputPHIs=false)
Update PHI nodes in this BasicBlock before removal of predecessor Pred.
BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate IR basic block frequen...
void setBlockFreq(const BasicBlock *BB, uint64_t Freq)
void setBlockFreqAndScale(const BasicBlock *ReferenceBB, uint64_t Freq, SmallPtrSetImpl< BasicBlock * > &BlocksToScale)
Set the frequency of ReferenceBB to Freq and scale the frequencies of the blocks in BlocksToScale suc...
BlockFrequency getBlockFreq(const BasicBlock *BB) const
getblockFreq - Return block frequency.
uint64_t getFrequency() const
Returns the frequency as a fixpoint number scaled by the entry frequency.
Conditional or Unconditional Branch instruction.
static BranchInst * Create(BasicBlock *IfTrue, Instruction *InsertBefore=nullptr)
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
void setCallingConv(CallingConv::ID CC)
void getOperandBundlesAsDefs(SmallVectorImpl< OperandBundleDef > &Defs) const
Return the list of operand bundles attached to this instruction as a vector of OperandBundleDefs.
OperandBundleUse getOperandBundleAt(unsigned Index) const
Return the operand bundle at a specific index.
std::optional< OperandBundleUse > getOperandBundle(StringRef Name) const
Return an operand bundle by name, if present.
Function * getCalledFunction() const
Returns the function called, or null if this is an indirect function invocation or the function signa...
void removeRetAttrs(const AttributeMask &AttrsToRemove)
Removes the attributes from the return value.
bool hasRetAttr(Attribute::AttrKind Kind) const
Determine whether the return value has the given attribute.
unsigned getNumOperandBundles() const
Return the number of operand bundles associated with this User.
CallingConv::ID getCallingConv() const
bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const
Determine whether the argument or parameter has the given attribute.
User::op_iterator arg_begin()
Return the iterator pointing to the beginning of the argument list.
bool isByValArgument(unsigned ArgNo) const
Determine whether this argument is passed by value.
static CallBase * Create(CallBase *CB, ArrayRef< OperandBundleDef > Bundles, Instruction *InsertPt=nullptr)
Create a clone of CB with a different set of operand bundles and insert it before InsertPt.
Type * getParamByValType(unsigned ArgNo) const
Extract the byval type for a call or parameter.
Value * getCalledOperand() const
void setAttributes(AttributeList A)
Set the parameter attributes for this call.
bool doesNotThrow() const
Determine if the call cannot unwind.
Value * getArgOperand(unsigned i) const
uint64_t getRetDereferenceableBytes() const
Extract the number of dereferenceable bytes for a call or parameter (0=unknown).
bool isConvergent() const
Determine if the invoke is convergent.
FunctionType * getFunctionType() const
Intrinsic::ID getIntrinsicID() const
Returns the intrinsic ID of the intrinsic called or Intrinsic::not_intrinsic if the called function i...
uint64_t getRetDereferenceableOrNullBytes() const
Extract the number of dereferenceable_or_null bytes for a call (0=unknown).
iterator_range< User::op_iterator > args()
Iteration adapter for range-for loops.
unsigned arg_size() const
AttributeList getAttributes() const
Return the parameter attributes for this call.
static CallBase * addOperandBundle(CallBase *CB, uint32_t ID, OperandBundleDef OB, Instruction *InsertPt=nullptr)
Create a clone of CB with operand bundle OB added.
bool hasOperandBundles() const
Return true if this User has any operand bundles.
Function * getCaller()
Helper to get the caller (the parent function).
This class represents a function call, abstracting a target machine's calling convention.
void setTailCallKind(TailCallKind TCK)
TailCallKind getTailCallKind() const
bool isMustTailCall() const
static CallInst * Create(FunctionType *Ty, Value *F, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
static CatchSwitchInst * Create(Value *ParentPad, BasicBlock *UnwindDest, unsigned NumHandlers, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
static CleanupReturnInst * Create(Value *CleanupPad, BasicBlock *UnwindBB=nullptr, Instruction *InsertBefore=nullptr)
This is the shared class of boolean and integer constants.
static Constant * get(Type *Ty, uint64_t V, bool IsSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
static ConstantTokenNone * get(LLVMContext &Context)
Return the ConstantTokenNone.
This is an important base class in LLVM.
const Constant * stripPointerCasts() const
static DIAssignID * getDistinct(LLVMContext &Context)
This class represents an Operation in the Expression.
A parsed version of the target data layout string in and methods for querying it.
DILocation * get() const
Get the underlying DILocation.
MDNode * getScope() const
static DebugLoc appendInlinedAt(const DebugLoc &DL, DILocation *InlinedAt, LLVMContext &Ctx, DenseMap< const MDNode *, MDNode * > &Cache)
Rebuild the entire inlined-at chain for this instruction so that the top of the chain now is inlined-...
iterator find(const_arg_type_t< KeyT > Val)
size_type count(const_arg_type_t< KeyT > Val) const
Return 1 if the specified key is in the map, 0 otherwise.
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
void recalculate(ParentType &Func)
recalculate - compute a dominator tree for the given function
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
unsigned getNumParams() const
Return the number of fixed parameters this function type requires.
Class to represent profile counts.
uint64_t getCount() const
const BasicBlock & getEntryBlock() const
BasicBlockListType::iterator iterator
FunctionType * getFunctionType() const
Returns the FunctionType for me.
const BasicBlock & front() const
iterator_range< arg_iterator > args()
DISubprogram * getSubprogram() const
Get the attached subprogram.
bool hasGC() const
hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm to use during code generatio...
CallingConv::ID getCallingConv() const
getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...
bool hasPersonalityFn() const
Check whether this function has a personality function.
Constant * getPersonalityFn() const
Get the personality function associated with this function.
AttributeList getAttributes() const
Return the attribute list for this Function.
bool isIntrinsic() const
isIntrinsic - Returns true if the function's name starts with "llvm.".
MaybeAlign getParamAlign(unsigned ArgNo) const
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function.
const std::string & getGC() const
std::optional< ProfileCount > getEntryCount(bool AllowSynthetic=false) const
Get the entry count for this function.
Type * getReturnType() const
Returns the type of the ret val.
void setCallingConv(CallingConv::ID CC)
Argument * getArg(unsigned i) const
bool onlyReadsMemory() const
Determine if the function does not access or only reads memory.
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Module * getParent()
Get the module that this global value is contained inside of...
CallInst * CreateStackSave(const Twine &Name="")
Create a call to llvm.stacksave.
CallInst * CreateAlignmentAssumption(const DataLayout &DL, Value *PtrValue, unsigned Alignment, Value *OffsetValue=nullptr)
Create an assume intrinsic call that represents an alignment assumption on the provided pointer.
CallInst * CreateLifetimeEnd(Value *Ptr, ConstantInt *Size=nullptr)
Create a lifetime.end intrinsic.
CallInst * CreateStackRestore(Value *Ptr, const Twine &Name="")
Create a call to llvm.stackrestore.
Instruction * CreateNoAliasScopeDeclaration(Value *Scope)
Create a llvm.experimental.noalias.scope.decl intrinsic call.
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
This class captures the data input to the InlineFunction call, and records the auxiliary results prod...
bool UpdateProfile
Update profile for callee as well as cloned version.
function_ref< AssumptionCache &(Function &)> GetAssumptionCache
If non-null, InlineFunction will update the callgraph to reflect the changes it makes.
BlockFrequencyInfo * CalleeBFI
SmallVector< AllocaInst *, 4 > StaticAllocas
InlineFunction fills this in with all static allocas that get copied into the caller.
BlockFrequencyInfo * CallerBFI
SmallVector< CallBase *, 8 > InlinedCallSites
All of the new call sites inlined into the caller.
InlineResult is basically true or false.
static InlineResult success()
static InlineResult failure(const char *Reason)
bool isLifetimeStartOrEnd() const LLVM_READONLY
Return true if the instruction is a llvm.lifetime.start or llvm.lifetime.end marker.
void insertBefore(Instruction *InsertPos)
Insert an unlinked instruction into a basic block immediately before the specified instruction.
const DebugLoc & getDebugLoc() const
Return the debug location for this node as a DebugLoc.
const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
bool hasMetadata() const
Return true if this instruction has any metadata attached to it.
bool isEHPad() const
Return true if the instruction is a variety of EH-block.
const BasicBlock * getParent() const
const Function * getFunction() const
Return the function this instruction belongs to.
MDNode * getMetadata(unsigned KindID) const
Get the metadata of given kind attached to this Instruction.
void setMetadata(unsigned KindID, MDNode *Node)
Set the metadata of the specified kind to the specified node.
unsigned getOpcode() const
Returns a member of one of the enums like Instruction::Add.
SymbolTableList< Instruction >::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
void setDebugLoc(DebugLoc Loc)
Set the debug location information for this instruction.
A wrapper class for inspecting calls to intrinsic functions.
static bool mayLowerToFunctionCall(Intrinsic::ID IID)
Check if the intrinsic might lower into a regular function call in the course of IR transformations.
BasicBlock * getUnwindDest() const
LandingPadInst * getLandingPadInst() const
Get the landingpad instruction from the landing pad block (the unwind destination).
BasicBlock * getNormalDest() const
This is an important class for using LLVM in a threaded context.
@ OB_clang_arc_attachedcall
The landingpad instruction holds all of the information necessary to generate correct exception handl...
bool isCleanup() const
Return 'true' if this landingpad instruction is a cleanup.
unsigned getNumClauses() const
Get the number of clauses for this landing pad.
Constant * getClause(unsigned Idx) const
Get the value of the clause at index Idx.
An instruction for reading from memory.
MDNode * createAnonymousAliasScope(MDNode *Domain, StringRef Name=StringRef())
Return metadata appropriate for an alias scope root node.
MDNode * createAnonymousAliasScopeDomain(StringRef Name=StringRef())
Return metadata appropriate for an alias scope domain node.
void replaceAllUsesWith(Metadata *MD)
RAUW a temporary.
static MDNode * concatenate(MDNode *A, MDNode *B)
Methods for metadata merging.
ArrayRef< MDOperand > operands() const
op_iterator op_end() const
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
unsigned getNumOperands() const
Return number of MDNode operands.
op_iterator op_begin() const
LLVMContext & getContext() const
static TempMDTuple getTemporary(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Return a temporary node.
bool onlyAccessesInaccessibleMem() const
Whether this function only (at most) accesses inaccessible memory.
bool onlyAccessesArgPointees() const
Whether this function only (at most) accesses argument memory.
A Module instance is used to store all the information related to an LLVM module.
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
A container for an operand bundle being viewed as a set of values rather than a set of uses.
void addIncoming(Value *V, BasicBlock *BB)
Add an incoming value to the end of the PHI list.
static PHINode * Create(Type *Ty, unsigned NumReservedValues, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Constructors - NumReservedValues is a hint for the number of incoming edges that this phi node will h...
static PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
Analysis providing profile information.
std::optional< uint64_t > getProfileCount(const CallBase &CallInst, BlockFrequencyInfo *BFI, bool AllowSynthetic=false) const
Returns the profile count for CallInst.
Resume the propagation of an exception.
Return a value (possibly void), from a function.
Value * getReturnValue() const
Convenience accessor. Returns null if there is no return value.
A vector that has set insertion semantics.
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
size_type count(ConstPtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
bool contains(ConstPtrType Ptr) const
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
A SetVector that performs no allocations if smaller than a certain size.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
reference emplace_back(ArgTypes &&... Args)
void reserve(size_type N)
void append(ItTy in_start, ItTy in_end)
Add the specified range to the end of the SmallVector.
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
An instruction for storing to memory.
The instances of the Type class are immutable: once they are created, they are never changed.
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
LLVMContext & getContext() const
Return the LLVMContext in which this type was uniqued.
static PointerType * getInt8PtrTy(LLVMContext &C, unsigned AS=0)
static IntegerType * getInt64Ty(LLVMContext &C)
bool isVoidTy() const
Return true if this is 'void'.
void setOperand(unsigned i, Value *Val)
Value * getOperand(unsigned i) const
This class represents the va_arg llvm instruction, which returns an argument of the specified type gi...
ValueT lookup(const KeyT &Val) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
size_type count(const KeyT &Val) const
Return 1 if the specified key is in the map, 0 otherwise.
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
iterator_range< user_iterator > users()
bool hasNUses(unsigned N) const
Return true if this Value has exactly N uses.
LLVMContext & getContext() const
All values hold a context through their type.
StringRef getName() const
Return a constant reference to the value's name.
void takeName(Value *V)
Transfer the name from V to this value.
constexpr ScalarTy getFixedValue() const
constexpr bool isScalable() const
Returns whether the quantity is scaled by a runtime quantity (vscale).
ilist_iterator< OptionsT, !IsReverse, IsConst > getReverse() const
Get a reverse iterator to the same node.
self_iterator getIterator()
Class to build a trie of call stack contexts for a particular profiled allocation call,...
Helper class to iterate through stack ids in both metadata (memprof MIB and callsite) and the corresp...
This provides a very simple, boring adaptor for a begin and end iterator into a range type.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
void mergeAttributesForInlining(Function &Caller, const Function &Callee)
Merge caller's and callee's attributes.
AttributeMask typeIncompatible(Type *Ty, AttributeSafetyKind ASK=ASK_ALL)
Which attributes cannot be applied to a type.
Function * getDeclaration(Module *M, ID id, ArrayRef< Type * > Tys=std::nullopt)
Create or insert an LLVM Function declaration for an intrinsic, and return it.
AssignmentMarkerRange getAssignmentMarkers(DIAssignID *ID)
Return a range of dbg.assign intrinsics which use \ID as an operand.
void trackAssignments(Function::iterator Start, Function::iterator End, const StorageToVarsMap &Vars, const DataLayout &DL, bool DebugPrints=false)
Track assignments to Vars between Start and End.
initializer< Ty > init(const Ty &Val)
MDNode * getMIBStackNode(const MDNode *MIB)
Returns the stack node from an MIB metadata node.
ARCInstKind getAttachedARCFunctionKind(const CallBase *CB)
This function returns the ARCInstKind of the function attached to operand bundle clang_arc_attachedca...
ARCInstKind
Equivalence classes of instructions in the ARC Model.
std::optional< Function * > getAttachedARCFunction(const CallBase *CB)
This function returns operand bundle clang_arc_attachedcall's argument, which is the address of the A...
bool isRetainOrClaimRV(ARCInstKind Kind)
Check whether the function is retainRV/unsafeClaimRV.
const Value * GetRCIdentityRoot(const Value *V)
The RCIdentity root of a value V is a dominating value U for which retaining or releasing U is equiva...
bool hasAttachedCallOpBundle(const CallBase *CB)
This is an optimization pass for GlobalISel generic memory operations.
BasicBlock * changeToInvokeAndSplitBasicBlock(CallInst *CI, BasicBlock *UnwindEdge, DomTreeUpdater *DTU=nullptr)
Convert the CallInst to InvokeInst with the specified unwind edge basic block.
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
bool PointerMayBeCapturedBefore(const Value *V, bool ReturnCaptures, bool StoreCaptures, const Instruction *I, const DominatorTree *DT, bool IncludeI=false, unsigned MaxUsesToExplore=0, const LoopInfo *LI=nullptr)
PointerMayBeCapturedBefore - Return true if this pointer value may be captured by the enclosing funct...
void append_range(Container &C, Range &&R)
Wrapper function to append a range to a container.
iterator_range< early_inc_iterator_impl< detail::IterOfRange< RangeT > > > make_early_inc_range(RangeT &&Range)
Make a range that does early increment to allow mutation of the underlying range without disrupting i...
bool isScopedEHPersonality(EHPersonality Pers)
Returns true if this personality uses scope-style EH IR instructions: catchswitch,...
Value * simplifyInstruction(Instruction *I, const SimplifyQuery &Q)
See if we can compute a simplified version of this instruction.
Align getKnownAlignment(Value *V, const DataLayout &DL, const Instruction *CxtI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr)
Try to infer an alignment for the specified pointer.
Align getOrEnforceKnownAlignment(Value *V, MaybeAlign PrefAlign, const DataLayout &DL, const Instruction *CxtI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr)
Try to ensure that the alignment of V is at least PrefAlign bytes.
void CloneAndPruneFunctionInto(Function *NewFunc, const Function *OldFunc, ValueToValueMapTy &VMap, bool ModuleLevelChanges, SmallVectorImpl< ReturnInst * > &Returns, const char *NameSuffix="", ClonedCodeInfo *CodeInfo=nullptr)
This works exactly like CloneFunctionInto, except that it does some simple constant prop and DCE on t...
EHPersonality classifyEHPersonality(const Value *Pers)
See if the given exception handling personality function is one that we understand.
unsigned changeToUnreachable(Instruction *I, bool PreserveLCSSA=false, DomTreeUpdater *DTU=nullptr, MemorySSAUpdater *MSSAU=nullptr)
Insert an unreachable instruction before the specified instruction, making it and the rest of the cod...
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
void getUnderlyingObjects(const Value *V, SmallVectorImpl< const Value * > &Objects, LoopInfo *LI=nullptr, unsigned MaxLookup=6)
This method is similar to getUnderlyingObject except that it can look through phi and select instruct...
bool salvageKnowledge(Instruction *I, AssumptionCache *AC=nullptr, DominatorTree *DT=nullptr)
Calls BuildAssumeFromInst and if the resulting llvm.assume is valid insert if before I.
void updateProfileCallee(Function *Callee, int64_t EntryDelta, const ValueMap< const Value *, WeakTrackingVH > *VMap=nullptr)
Updates profile information by adjusting the entry count by adding EntryDelta then scaling callsite i...
bool isAssignmentTrackingEnabled(const Module &M)
Return true if assignment tracking is enabled for module M.
MDNode * uniteAccessGroups(MDNode *AccGroups1, MDNode *AccGroups2)
Compute the union of two access-group lists.
InlineResult InlineFunction(CallBase &CB, InlineFunctionInfo &IFI, bool MergeAttributes=false, AAResults *CalleeAAR=nullptr, bool InsertLifetime=true, Function *ForwardVarArgsTo=nullptr)
This function inlines the called function into the basic block of the caller.
bool isAsynchronousEHPersonality(EHPersonality Pers)
Returns true if this personality function catches asynchronous exceptions.
bool isGuaranteedToTransferExecutionToSuccessor(const Instruction *I)
Return true if this function can prove that the instruction I will always transfer execution to one o...
bool isEscapeSource(const Value *V)
Returns true if the pointer is one which would have been considered an escape by isNonEscapingLocalOb...
void erase_if(Container &C, UnaryPredicate P)
Provide a container algorithm similar to C++ Library Fundamentals v2's erase_if which is equivalent t...
bool pred_empty(const BasicBlock *BB)
void updateLoopMetadataDebugLocations(Instruction &I, function_ref< Metadata *(Metadata *)> Updater)
Update the debug locations contained within the MD_loop metadata attached to the instruction I,...
bool isIdentifiedObject(const Value *V)
Return true if this pointer refers to a distinct and identifiable object.
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
This struct is a compact representation of a valid (non-zero power of two) alignment.
This struct can be used to capture information about code being cloned, while it is being cloned.
bool ContainsDynamicAllocas
This is set to true if the cloned code contains a 'dynamic' alloca.
bool isSimplified(const Value *From, const Value *To) const
bool ContainsCalls
This is set to true if the cloned code contains a normal call instruction.
bool ContainsMemProfMetadata
This is set to true if there is memprof related metadata (memprof or callsite metadata) in the cloned...
std::vector< WeakTrackingVH > OperandBundleCallSites
All cloned call sites that have operand bundles attached are appended to this vector.
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
Align valueOrOne() const
For convenience, returns a valid alignment or 1 if undefined.
Helper struct for trackAssignments, below.