77#define DEBUG_TYPE "inline-function"
86 cl::desc(
"Convert noalias attributes to metadata during inlining."));
91 cl::desc(
"Use the llvm.experimental.noalias.scope.decl "
92 "intrinsic during inlining."));
100 cl::desc(
"Convert align attributes to assumptions during inlining."));
104 cl::desc(
"Update return attributes on calls within inlined body"));
107 "max-inst-checked-for-throw-during-inlining",
cl::Hidden,
108 cl::desc(
"the maximum number of instructions analyzed for may throw during "
109 "attribute inference in inlined body"),
115 class LandingPadInliningInfo {
126 PHINode *InnerEHValuesPHI =
nullptr;
132 : OuterResumeDest(II->getUnwindDest()) {
138 for (; isa<PHINode>(
I); ++
I) {
141 UnwindDestPHIValues.
push_back(
PHI->getIncomingValueForBlock(InvokeBB));
144 CallerLPad = cast<LandingPadInst>(
I);
150 return OuterResumeDest;
167 void addIncomingPHIValuesFor(
BasicBlock *BB)
const {
168 addIncomingPHIValuesForInto(BB, OuterResumeDest);
173 for (
unsigned i = 0, e = UnwindDestPHIValues.
size(); i != e; ++i, ++
I) {
175 phi->addIncoming(UnwindDestPHIValues[i], src);
183BasicBlock *LandingPadInliningInfo::getInnerResumeDest() {
184 if (InnerResumeDest)
return InnerResumeDest;
190 OuterResumeDest->
getName() +
".body");
193 const unsigned PHICapacity = 2;
198 for (
unsigned i = 0, e = UnwindDestPHIValues.
size(); i != e; ++i, ++
I) {
199 PHINode *OuterPHI = cast<PHINode>(
I);
201 OuterPHI->
getName() +
".lpad-body",
209 "eh.lpad-body", InsertPoint);
211 InnerEHValuesPHI->
addIncoming(CallerLPad, OuterResumeDest);
214 return InnerResumeDest;
221void LandingPadInliningInfo::forwardResume(
230 addIncomingPHIValuesForInto(Src, Dest);
238 if (
auto *FPI = dyn_cast<FuncletPadInst>(EHPad))
239 return FPI->getParentPad();
240 return cast<CatchSwitchInst>(EHPad)->getParentPad();
251 while (!Worklist.
empty()) {
258 Value *UnwindDestToken =
nullptr;
259 if (
auto *CatchSwitch = dyn_cast<CatchSwitchInst>(CurrentPad)) {
260 if (CatchSwitch->hasUnwindDest()) {
261 UnwindDestToken = CatchSwitch->getUnwindDest()->getFirstNonPHI();
269 for (
auto HI = CatchSwitch->handler_begin(),
270 HE = CatchSwitch->handler_end();
271 HI != HE && !UnwindDestToken; ++HI) {
273 auto *CatchPad = cast<CatchPadInst>(HandlerBlock->
getFirstNonPHI());
279 if (!isa<CleanupPadInst>(Child) && !isa<CatchSwitchInst>(Child))
283 auto Memo = MemoMap.
find(ChildPad);
284 if (Memo == MemoMap.
end()) {
291 Value *ChildUnwindDestToken = Memo->second;
292 if (!ChildUnwindDestToken)
298 if (isa<ConstantTokenNone>(ChildUnwindDestToken)) {
299 UnwindDestToken = ChildUnwindDestToken;
307 auto *CleanupPad = cast<CleanupPadInst>(CurrentPad);
308 for (
User *U : CleanupPad->users()) {
309 if (
auto *CleanupRet = dyn_cast<CleanupReturnInst>(U)) {
310 if (
BasicBlock *RetUnwindDest = CleanupRet->getUnwindDest())
311 UnwindDestToken = RetUnwindDest->getFirstNonPHI();
316 Value *ChildUnwindDestToken;
317 if (
auto *Invoke = dyn_cast<InvokeInst>(U)) {
318 ChildUnwindDestToken = Invoke->getUnwindDest()->getFirstNonPHI();
319 }
else if (isa<CleanupPadInst>(U) || isa<CatchSwitchInst>(U)) {
321 auto Memo = MemoMap.
find(ChildPad);
322 if (Memo == MemoMap.
end()) {
329 ChildUnwindDestToken = Memo->second;
330 if (!ChildUnwindDestToken)
339 if (isa<Instruction>(ChildUnwindDestToken) &&
342 UnwindDestToken = ChildUnwindDestToken;
348 if (!UnwindDestToken)
356 if (
auto *UnwindPad = dyn_cast<Instruction>(UnwindDestToken))
359 UnwindParent =
nullptr;
360 bool ExitedOriginalPad =
false;
362 ExitedPad && ExitedPad != UnwindParent;
363 ExitedPad = dyn_cast<Instruction>(
getParentPad(ExitedPad))) {
365 if (isa<CatchPadInst>(ExitedPad))
367 MemoMap[ExitedPad] = UnwindDestToken;
368 ExitedOriginalPad |= (ExitedPad == EHPad);
371 if (ExitedOriginalPad)
372 return UnwindDestToken;
403 if (
auto *CPI = dyn_cast<CatchPadInst>(EHPad))
404 EHPad = CPI->getCatchSwitch();
407 auto Memo = MemoMap.
find(EHPad);
408 if (Memo != MemoMap.
end())
413 assert((UnwindDestToken ==
nullptr) != (MemoMap.
count(EHPad) != 0));
415 return UnwindDestToken;
422 MemoMap[EHPad] =
nullptr;
428 Value *AncestorToken;
430 auto *AncestorPad = dyn_cast<Instruction>(AncestorToken);
433 if (isa<CatchPadInst>(AncestorPad))
442 assert(!MemoMap.
count(AncestorPad) || MemoMap[AncestorPad]);
443 auto AncestorMemo = MemoMap.
find(AncestorPad);
444 if (AncestorMemo == MemoMap.
end()) {
447 UnwindDestToken = AncestorMemo->second;
451 LastUselessPad = AncestorPad;
452 MemoMap[LastUselessPad] =
nullptr;
454 TempMemos.
insert(LastUselessPad);
472 while (!Worklist.
empty()) {
474 auto Memo = MemoMap.
find(UselessPad);
475 if (Memo != MemoMap.
end() && Memo->second) {
503 MemoMap[UselessPad] = UnwindDestToken;
504 if (
auto *CatchSwitch = dyn_cast<CatchSwitchInst>(UselessPad)) {
505 assert(CatchSwitch->getUnwindDest() ==
nullptr &&
"Expected useless pad");
506 for (
BasicBlock *HandlerBlock : CatchSwitch->handlers()) {
507 auto *CatchPad = HandlerBlock->getFirstNonPHI();
508 for (
User *U : CatchPad->users()) {
510 (!isa<InvokeInst>(U) ||
512 cast<InvokeInst>(U)->getUnwindDest()->getFirstNonPHI()) ==
514 "Expected useless pad");
515 if (isa<CatchSwitchInst>(U) || isa<CleanupPadInst>(U))
516 Worklist.
push_back(cast<Instruction>(U));
520 assert(isa<CleanupPadInst>(UselessPad));
522 assert(!isa<CleanupReturnInst>(U) &&
"Expected useless pad");
523 assert((!isa<InvokeInst>(U) ||
525 cast<InvokeInst>(U)->getUnwindDest()->getFirstNonPHI()) ==
527 "Expected useless pad");
528 if (isa<CatchSwitchInst>(U) || isa<CleanupPadInst>(U))
529 Worklist.
push_back(cast<Instruction>(U));
534 return UnwindDestToken;
560 if (
F->getIntrinsicID() == Intrinsic::experimental_deoptimize ||
561 F->getIntrinsicID() == Intrinsic::experimental_guard)
572 auto *FuncletPad = cast<Instruction>(FuncletBundle->Inputs[0]);
573 Value *UnwindDestToken =
575 if (UnwindDestToken && !isa<ConstantTokenNone>(UnwindDestToken))
579 if (
auto *CatchPad = dyn_cast<CatchPadInst>(FuncletPad))
580 MemoKey = CatchPad->getCatchSwitch();
582 MemoKey = FuncletPad;
583 assert(FuncletUnwindMap->count(MemoKey) &&
584 (*FuncletUnwindMap)[MemoKey] == UnwindDestToken &&
585 "must get memoized to avoid confusing later searches");
610 LandingPadInliningInfo Invoke(II);
616 if (
InvokeInst *II = dyn_cast<InvokeInst>(
I->getTerminator()))
624 InlinedLPad->reserveClauses(OuterNum);
625 for (
unsigned OuterIdx = 0; OuterIdx != OuterNum; ++OuterIdx)
626 InlinedLPad->addClause(OuterLPad->
getClause(OuterIdx));
628 InlinedLPad->setCleanup(
true);
635 &*BB, Invoke.getOuterResumeDest()))
638 Invoke.addIncomingPHIValuesFor(NewBB);
641 if (
ResumeInst *RI = dyn_cast<ResumeInst>(BB->getTerminator()))
642 Invoke.forwardResume(RI, InlinedLPads);
672 UnwindDestPHIValues.
push_back(
PHI.getIncomingValueForBlock(InvokeBB));
679 for (
Value *V : UnwindDestPHIValues) {
681 PHI->addIncoming(V, Src);
691 if (
auto *CRI = dyn_cast<CleanupReturnInst>(BB->getTerminator())) {
692 if (CRI->unwindsToCaller()) {
693 auto *CleanupPad = CRI->getCleanupPad();
695 CRI->eraseFromParent();
702 isa<ConstantTokenNone>(FuncletUnwindMap[CleanupPad]));
703 FuncletUnwindMap[CleanupPad] =
713 if (
auto *CatchSwitch = dyn_cast<CatchSwitchInst>(
I)) {
714 if (CatchSwitch->unwindsToCaller()) {
715 Value *UnwindDestToken;
716 if (
auto *ParentPad =
717 dyn_cast<Instruction>(CatchSwitch->getParentPad())) {
727 if (UnwindDestToken && !isa<ConstantTokenNone>(UnwindDestToken))
740 CatchSwitch->getParentPad(), UnwindDest,
741 CatchSwitch->getNumHandlers(), CatchSwitch->
getName(),
743 for (
BasicBlock *PadBB : CatchSwitch->handlers())
744 NewCatchSwitch->addHandler(PadBB);
749 FuncletUnwindMap[NewCatchSwitch] = UnwindDestToken;
750 Replacement = NewCatchSwitch;
752 }
else if (!isa<FuncletPadInst>(
I)) {
758 I->replaceAllUsesWith(Replacement);
759 I->eraseFromParent();
769 &*BB, UnwindDest, &FuncletUnwindMap))
782 MDNode *CallsiteStackContext) {
788 for (
auto MIBStackIter = MIBStackContext->
op_begin(),
789 CallsiteStackIter = CallsiteStackContext->
op_begin();
790 MIBStackIter != MIBStackContext->
op_end() &&
791 CallsiteStackIter != CallsiteStackContext->
op_end();
792 MIBStackIter++, CallsiteStackIter++) {
793 auto *Val1 = mdconst::dyn_extract<ConstantInt>(*MIBStackIter);
794 auto *Val2 = mdconst::dyn_extract<ConstantInt>(*CallsiteStackIter);
796 if (Val1->getZExtValue() != Val2->getZExtValue())
803 Call->setMetadata(LLVMContext::MD_memprof,
nullptr);
807 Call->setMetadata(LLVMContext::MD_callsite,
nullptr);
811 const std::vector<Metadata *> &MIBList) {
818 CallStack.addCallStack(cast<MDNode>(MIB));
819 bool MemprofMDAttached =
CallStack.buildAndAttachMIBMetadata(CI);
821 if (!MemprofMDAttached)
831 MDNode *InlinedCallsiteMD) {
833 MDNode *ClonedCallsiteMD =
nullptr;
836 if (OrigCallsiteMD) {
841 ClonedCall->
setMetadata(LLVMContext::MD_callsite, ClonedCallsiteMD);
853 std::vector<Metadata *> NewMIBList;
858 for (
auto &MIBOp : OrigMemProfMD->
operands()) {
859 MDNode *MIB = dyn_cast<MDNode>(MIBOp);
866 NewMIBList.push_back(MIB);
868 if (NewMIBList.empty()) {
887 bool ContainsMemProfMetadata,
892 if (!CallsiteMD && !ContainsMemProfMetadata)
896 for (
const auto &Entry : VMap) {
899 auto *OrigCall = dyn_cast_or_null<CallBase>(Entry.first);
900 auto *ClonedCall = dyn_cast_or_null<CallBase>(Entry.second);
901 if (!OrigCall || !ClonedCall)
920 MDNode *MemParallelLoopAccess =
921 CB.
getMetadata(LLVMContext::MD_mem_parallel_loop_access);
925 if (!MemParallelLoopAccess && !AccessGroup && !AliasScope && !NoAlias)
931 if (!
I.mayReadOrWriteMemory())
934 if (MemParallelLoopAccess) {
937 I.getMetadata(LLVMContext::MD_mem_parallel_loop_access),
938 MemParallelLoopAccess);
939 I.setMetadata(LLVMContext::MD_mem_parallel_loop_access,
940 MemParallelLoopAccess);
945 I.getMetadata(LLVMContext::MD_access_group), AccessGroup));
949 I.getMetadata(LLVMContext::MD_alias_scope), AliasScope));
953 I.getMetadata(LLVMContext::MD_noalias), NoAlias));
971 dyn_cast<Function>(
I->getCalledOperand()->stripPointerCasts());
972 if (CalledFn && CalledFn->isIntrinsic() &&
I->doesNotThrow() &&
977 I->getOperandBundlesAsDefs(OpBundles);
982 I->replaceAllUsesWith(NewInst);
983 I->eraseFromParent();
992class ScopedAliasMetadataDeepCloner {
996 void addRecursiveMetadataUses();
999 ScopedAliasMetadataDeepCloner(
const Function *
F);
1011ScopedAliasMetadataDeepCloner::ScopedAliasMetadataDeepCloner(
1015 if (
const MDNode *M =
I.getMetadata(LLVMContext::MD_alias_scope))
1017 if (
const MDNode *M =
I.getMetadata(LLVMContext::MD_noalias))
1021 if (
const auto *Decl = dyn_cast<NoAliasScopeDeclInst>(&
I))
1022 MD.insert(Decl->getScopeList());
1025 addRecursiveMetadataUses();
1028void ScopedAliasMetadataDeepCloner::addRecursiveMetadataUses() {
1030 while (!
Queue.empty()) {
1032 for (
const Metadata *Op :
M->operands())
1033 if (
const MDNode *OpMD = dyn_cast<MDNode>(Op))
1034 if (MD.insert(OpMD))
1035 Queue.push_back(OpMD);
1039void ScopedAliasMetadataDeepCloner::clone() {
1040 assert(MDMap.empty() &&
"clone() already called ?");
1045 MDMap[
I].reset(DummyNodes.
back().get());
1053 for (
const Metadata *Op :
I->operands()) {
1054 if (
const MDNode *M = dyn_cast<MDNode>(Op))
1061 MDTuple *TempM = cast<MDTuple>(MDMap[
I]);
1078 if (
MDNode *M =
I.getMetadata(LLVMContext::MD_alias_scope))
1079 if (
MDNode *MNew = MDMap.lookup(M))
1080 I.setMetadata(LLVMContext::MD_alias_scope, MNew);
1082 if (
MDNode *M =
I.getMetadata(LLVMContext::MD_noalias))
1083 if (
MDNode *MNew = MDMap.lookup(M))
1084 I.setMetadata(LLVMContext::MD_noalias, MNew);
1086 if (
auto *Decl = dyn_cast<NoAliasScopeDeclInst>(&
I))
1087 if (
MDNode *MNew = MDMap.lookup(Decl->getScopeList()))
1088 Decl->setScopeList(MNew);
1110 if (NoAliasArgs.
empty())
1130 for (
unsigned i = 0, e = NoAliasArgs.
size(); i != e; ++i) {
1133 std::string
Name = std::string(CalledFunc->
getName());
1136 Name +=
A->getName();
1138 Name +=
": argument ";
1146 NewScopes.
insert(std::make_pair(
A, NewScope));
1163 VMI != VMIE; ++VMI) {
1164 if (
const Instruction *
I = dyn_cast<Instruction>(VMI->first)) {
1168 Instruction *NI = dyn_cast<Instruction>(VMI->second);
1172 bool IsArgMemOnlyCall =
false, IsFuncCall =
false;
1175 if (
const LoadInst *LI = dyn_cast<LoadInst>(
I))
1176 PtrArgs.
push_back(LI->getPointerOperand());
1179 else if (
const VAArgInst *VAAI = dyn_cast<VAArgInst>(
I))
1180 PtrArgs.
push_back(VAAI->getPointerOperand());
1182 PtrArgs.
push_back(CXI->getPointerOperand());
1184 PtrArgs.
push_back(RMWI->getPointerOperand());
1185 else if (
const auto *Call = dyn_cast<CallBase>(
I)) {
1189 if (Call->doesNotAccessMemory())
1201 IsArgMemOnlyCall =
true;
1208 if (!
Arg->getType()->isPointerTy())
1219 if (PtrArgs.
empty() && !IsFuncCall)
1229 for (
const Value *V : PtrArgs) {
1233 for (
const Value *O : Objects)
1239 bool RequiresNoCaptureBefore =
false, UsesAliasingPtr =
false,
1240 UsesUnknownObject =
false;
1241 for (
const Value *V : ObjSet) {
1245 bool IsNonPtrConst = isa<ConstantInt>(V) || isa<ConstantFP>(V) ||
1246 isa<ConstantPointerNull>(V) ||
1247 isa<ConstantDataVector>(V) || isa<UndefValue>(V);
1254 if (
const Argument *
A = dyn_cast<Argument>(V)) {
1256 UsesAliasingPtr =
true;
1258 UsesAliasingPtr =
true;
1264 RequiresNoCaptureBefore =
true;
1270 UsesUnknownObject =
true;
1276 if (UsesUnknownObject)
1281 if (IsFuncCall && !IsArgMemOnlyCall)
1282 RequiresNoCaptureBefore =
true;
1300 if (!RequiresNoCaptureBefore ||
1322 bool CanAddScopes = !UsesAliasingPtr;
1323 if (CanAddScopes && IsFuncCall)
1324 CanAddScopes = IsArgMemOnlyCall;
1329 Scopes.push_back(NewScopes[
A]);
1332 if (!Scopes.empty())
1334 LLVMContext::MD_alias_scope,
1345 "Expected to be in same basic block!");
1353 if (!AB.hasAttributes())
1359 if (
auto DerefBytes = AB.getDereferenceableBytes())
1361 if (
auto DerefOrNullBytes = AB.getDereferenceableOrNullBytes())
1363 if (AB.contains(Attribute::NoAlias))
1365 if (AB.contains(Attribute::NonNull))
1378 auto &
Context = CalledFunction->getContext();
1380 for (
auto &BB : *CalledFunction) {
1381 auto *RI = dyn_cast<ReturnInst>(BB.getTerminator());
1382 if (!RI || !isa<CallBase>(RI->
getOperand(0)))
1384 auto *RetVal = cast<CallBase>(RI->
getOperand(0));
1388 auto *NewRetVal = dyn_cast_or_null<CallBase>(VMap.
lookup(RetVal));
1420 NewRetVal->setAttributes(NewAL);
1436 bool DTCalculated =
false;
1440 if (!
Arg.getType()->isPointerTy() ||
Arg.hasPassPointeeByValueCopyAttr() ||
1447 if (!DTCalculated) {
1449 DTCalculated =
true;
1458 DL, ArgVal, Alignment->value());
1470 Builder.getInt64(M->getDataLayout().getTypeStoreSize(ByValType));
1483 CI->
setDebugLoc(DILocation::get(SP->getContext(), 0, 0, SP));
1493 assert(cast<PointerType>(
Arg->getType())
1494 ->isOpaqueOrPointeeTypeMatches(ByValType));
1496 const DataLayout &
DL = Caller->getParent()->getDataLayout();
1522 Align Alignment =
DL.getPrefTypeAlign(ByValType);
1528 Alignment = std::max(Alignment, *ByValAlignment);
1531 new AllocaInst(ByValType,
DL.getAllocaAddrSpace(),
nullptr, Alignment,
1532 Arg->getName(), &*Caller->begin()->begin());
1542 for (
User *U : V->users())
1555 if (Ty == Int8PtrTy)
1560 if (U->getType() != Int8PtrTy)
continue;
1561 if (U->stripPointerCasts() != AI)
continue;
1581 return DILocation::get(Ctx, OrigDL.
getLine(), OrigDL.
getCol(),
1598 InlinedAtNode = DILocation::getDistinct(
1599 Ctx, InlinedAtNode->getLine(), InlinedAtNode->getColumn(),
1600 InlinedAtNode->getScope(), InlinedAtNode->getInlinedAt());
1609 bool NoInlineLineTables = Fn->
hasFnAttribute(
"no-inline-line-tables");
1611 for (; FI != Fn->
end(); ++FI) {
1616 auto updateLoopInfoLoc = [&Ctx, &InlinedAtNode,
1618 if (
auto *Loc = dyn_cast_or_null<DILocation>(MD))
1624 if (!NoInlineLineTables)
1628 BI->setDebugLoc(IDL);
1632 if (CalleeHasDebugInfo && !NoInlineLineTables)
1642 if (
auto *AI = dyn_cast<AllocaInst>(BI))
1646 BI->setDebugLoc(TheCallDL);
1650 if (NoInlineLineTables) {
1652 while (BI != FI->end()) {
1653 if (isa<DbgInfoIntrinsic>(BI)) {
1654 BI = BI->eraseFromParent();
1665#define DEBUG_TYPE "assignment-tracking"
1673 errs() <<
"# Finding caller local variables escaped by callee\n");
1676 if (!
Arg->getType()->isPointerTy()) {
1688 assert(
Arg->getType()->isPtrOrPtrVectorTy());
1689 APInt TmpOffset(
DL.getIndexTypeSizeInBits(
Arg->getType()), 0,
false);
1691 Arg->stripAndAccumulateConstantOffsets(
DL, TmpOffset,
true));
1693 LLVM_DEBUG(
errs() <<
" | SKIP: Couldn't walk back to base storage\n");
1706 if (DAI->getDebugLoc().getInlinedAt())
1712 return EscapedLocals;
1718 << Start->getParent()->getName() <<
" from "
1720 std::unique_ptr<DataLayout>
DL = std::make_unique<DataLayout>(CB.
getModule());
1730 auto GetNewID = [&Map](
Metadata *Old) {
1740 for (
auto BBI = Start; BBI != End; ++BBI) {
1742 if (
auto *
ID =
I.getMetadata(LLVMContext::MD_DIAssignID))
1743 I.setMetadata(LLVMContext::MD_DIAssignID, GetNewID(
ID));
1744 else if (
auto *DAI = dyn_cast<DbgAssignIntrinsic>(&
I))
1745 DAI->setAssignId(GetNewID(DAI->getAssignID()));
1750#define DEBUG_TYPE "inline-function"
1764 for (
auto Entry : VMap) {
1765 if (!isa<BasicBlock>(Entry.first) || !Entry.second)
1767 auto *OrigBB = cast<BasicBlock>(Entry.first);
1768 auto *ClonedBB = cast<BasicBlock>(Entry.second);
1770 if (!ClonedBBs.
insert(ClonedBB).second) {
1793 auto CallSiteCount =
1796 std::min(CallSiteCount.value_or(0), CalleeEntryCount.
getCount());
1803 auto CalleeCount =
Callee->getEntryCount();
1807 const uint64_t PriorEntryCount = CalleeCount->getCount();
1812 (EntryDelta < 0 && static_cast<uint64_t>(-EntryDelta) > PriorEntryCount)
1814 : PriorEntryCount + EntryDelta;
1818 uint64_t CloneEntryCount = PriorEntryCount - NewEntryCount;
1819 for (
auto Entry : *VMap)
1820 if (isa<CallInst>(Entry.first))
1821 if (
auto *CI = dyn_cast_or_null<CallInst>(Entry.second))
1822 CI->updateProfWeight(CloneEntryCount, PriorEntryCount);
1826 Callee->setEntryCount(NewEntryCount);
1830 if (!VMap || VMap->
count(&BB))
1832 if (
CallInst *CI = dyn_cast<CallInst>(&
I))
1833 CI->updateProfWeight(NewEntryCount, PriorEntryCount);
1859 bool IsRetainRV = RVCallKind == objcarc::ARCInstKind::RetainRV,
1860 IsUnsafeClaimRV = !IsRetainRV;
1862 for (
auto *RI : Returns) {
1864 bool InsertRetainCall = IsRetainRV;
1873 if (isa<CastInst>(
I))
1876 if (
auto *II = dyn_cast<IntrinsicInst>(&
I)) {
1877 if (II->
getIntrinsicID() != Intrinsic::objc_autoreleaseReturnValue ||
1887 if (IsUnsafeClaimRV) {
1892 Builder.CreateCall(IFn, BC,
"");
1895 InsertRetainCall =
false;
1899 auto *CI = dyn_cast<CallInst>(&
I);
1914 NewCall->copyMetadata(*CI);
1915 CI->replaceAllUsesWith(NewCall);
1916 CI->eraseFromParent();
1917 InsertRetainCall =
false;
1921 if (InsertRetainCall) {
1928 Builder.CreateCall(IFn, BC,
"");
1942 bool MergeAttributes,
1944 bool InsertLifetime,
1949 if (isa<CallBrInst>(CB))
1990 !Caller->getAttributes().hasFnAttr(Attribute::StrictFP)) {
1998 if (CalledFunc->
hasGC()) {
1999 if (!Caller->hasGC())
2000 Caller->setGC(CalledFunc->
getGC());
2001 else if (CalledFunc->
getGC() != Caller->getGC())
2015 Caller->hasPersonalityFn()
2016 ? Caller->getPersonalityFn()->stripPointerCasts()
2018 if (CalledPersonality) {
2019 if (!CallerPersonality)
2020 Caller->setPersonalityFn(CalledPersonality);
2025 else if (CalledPersonality != CallerPersonality)
2032 if (CallerPersonality) {
2035 std::optional<OperandBundleUse> ParentFunclet =
2038 CallSiteEHPad = cast<FuncletPadInst>(ParentFunclet->Inputs.front());
2042 if (CallSiteEHPad) {
2043 if (Personality == EHPersonality::MSVC_CXX) {
2046 if (isa<CleanupPadInst>(CallSiteEHPad)) {
2049 for (
const BasicBlock &CalledBB : *CalledFunc) {
2050 if (isa<CatchSwitchInst>(CalledBB.getFirstNonPHI()))
2057 for (
const BasicBlock &CalledBB : *CalledFunc) {
2058 if (CalledBB.isEHPad())
2068 bool EHPadForCallUnwindsLocally =
false;
2069 if (CallSiteEHPad && isa<CallInst>(CB)) {
2071 Value *CallSiteUnwindDestToken =
2074 EHPadForCallUnwindsLocally =
2075 CallSiteUnwindDestToken &&
2076 !isa<ConstantTokenNone>(CallSiteUnwindDestToken);
2107 auto &
DL = Caller->getParent()->getDataLayout();
2114 E = CalledFunc->
arg_end();
I !=
E; ++
I, ++AI, ++ArgNo) {
2115 Value *ActualArg = *AI;
2123 &CB, CalledFunc, IFI,
2125 if (ActualArg != *AI)
2130 VMap[&*
I] = ActualArg;
2150 false, Returns,
".i",
2151 &InlinedFunctionInfo);
2153 FirstNewBlock = LastBlock; ++FirstNewBlock;
2157 if (RVCallKind != objcarc::ARCInstKind::None)
2168 CalledFunc->
front());
2176 for (ByValInit &
Init : ByValInits)
2178 &*FirstNewBlock, IFI, CalledFunc);
2180 std::optional<OperandBundleUse> ParentDeopt =
2186 CallBase *ICS = dyn_cast_or_null<CallBase>(VH);
2207 std::vector<Value *> MergedDeoptArgs;
2208 MergedDeoptArgs.reserve(ParentDeopt->Inputs.size() +
2209 ChildOB.Inputs.size());
2214 OpDefs.
emplace_back(
"deopt", std::move(MergedDeoptArgs));
2244 SAMetadataCloner.clone();
2245 SAMetadataCloner.remap(FirstNewBlock, Caller->end());
2263 make_range(FirstNewBlock->getIterator(), Caller->end()))
2265 if (
auto *II = dyn_cast<AssumeInst>(&
I))
2276 E = FirstNewBlock->end();
I !=
E; ) {
2295 while (isa<AllocaInst>(
I) &&
2296 !cast<AllocaInst>(
I)->use_empty() &&
2305 Caller->getEntryBlock().splice(InsertPoint, &*FirstNewBlock,
2318 bool InlinedMustTailCalls =
false, InlinedDeoptimizeCalls =
false;
2321 if (
CallInst *CI = dyn_cast<CallInst>(&CB))
2322 CallSiteTailKind = CI->getTailCallKind();
2337 if (!VarArgsToForward.
empty() &&
2338 ((ForwardVarArgsTo &&
2344 if (!Attrs.isEmpty() || !VarArgsAttrs.
empty()) {
2345 for (
unsigned ArgNo = 0;
2347 ArgAttrs.
push_back(Attrs.getParamAttrs(ArgNo));
2353 Attrs.getRetAttrs(), ArgAttrs);
2368 InlinedDeoptimizeCalls |=
2369 F->getIntrinsicID() == Intrinsic::experimental_deoptimize;
2388 ChildTCK = std::min(CallSiteTailKind, ChildTCK);
2407 if ((InsertLifetime || Caller->isPresplitCoroutine()) &&
2410 for (
unsigned ai = 0, ae = IFI.
StaticAllocas.size(); ai != ae; ++ai) {
2425 auto &
DL = Caller->getParent()->getDataLayout();
2427 TypeSize AllocaTypeSize =
DL.getTypeAllocSize(AllocaType);
2428 uint64_t AllocaArraySize = AIArraySize->getLimitedValue();
2431 if (AllocaArraySize == 0)
2437 AllocaArraySize != std::numeric_limits<uint64_t>::max() &&
2438 std::numeric_limits<uint64_t>::max() / AllocaArraySize >=
2441 AllocaArraySize * AllocaTypeSize);
2445 builder.CreateLifetimeStart(AI, AllocaSize);
2449 if (InlinedMustTailCalls &&
2452 if (InlinedDeoptimizeCalls &&
2463 Module *M = Caller->getParent();
2489 if (
auto *II = dyn_cast<InvokeInst>(&CB)) {
2492 if (isa<LandingPadInst>(FirstNonPHI)) {
2502 if (CallSiteEHPad) {
2513 if (
auto *CleanupRet = dyn_cast<CleanupReturnInst>(BB->getTerminator()))
2514 if (CleanupRet->unwindsToCaller() && EHPadForCallUnwindsLocally)
2521 if (
auto *CatchSwitch = dyn_cast<CatchSwitchInst>(
I)) {
2522 if (isa<ConstantTokenNone>(CatchSwitch->getParentPad()))
2523 CatchSwitch->setParentPad(CallSiteEHPad);
2525 auto *FPI = cast<FuncletPadInst>(
I);
2526 if (isa<ConstantTokenNone>(FPI->getParentPad()))
2527 FPI->setParentPad(CallSiteEHPad);
2532 if (InlinedDeoptimizeCalls) {
2538 if (Caller->getReturnType() == CB.
getType()) {
2540 return RI->
getParent()->getTerminatingDeoptimizeCall() !=
nullptr;
2545 Caller->getParent(), Intrinsic::experimental_deoptimize,
2546 {Caller->getReturnType()});
2572 "Expected at least the deopt operand bundle");
2576 Builder.CreateCall(NewDeoptIntrinsic, CallArgs, OpBundles);
2582 Builder.CreateRet(NewDeoptCall);
2594 if (InlinedMustTailCalls) {
2596 Type *NewRetTy = Caller->getReturnType();
2604 if (!ReturnedMustTail) {
2613 auto *OldCast = dyn_cast_or_null<BitCastInst>(RI->getReturnValue());
2616 OldCast->eraseFromParent();
2620 Builder.CreateRet(
Builder.CreateBitCast(ReturnedMustTail, NewRetTy));
2636 make_range(FirstNewBlock->getIterator(), Caller->end()))
2638 if (
auto *CB = dyn_cast<CallBase>(&
I))
2647 if (Returns.
size() == 1 && std::distance(FirstNewBlock, Caller->end()) == 1) {
2650 FirstNewBlock->end());
2652 Caller->back().eraseFromParent();
2656 if (
InvokeInst *II = dyn_cast<InvokeInst>(&CB)) {
2665 if (&CB == R->getReturnValue())
2674 Returns[0]->eraseFromParent();
2676 if (MergeAttributes)
2690 BranchInst *CreatedBranchToNormalDest =
nullptr;
2691 if (
InvokeInst *II = dyn_cast<InvokeInst>(&CB)) {
2701 CalledFunc->
getName() +
".exit");
2708 CalledFunc->
getName() +
".exit");
2722 "splitBasicBlock broken!");
2728 Caller->splice(AfterCallBB->
getIterator(), Caller, FirstNewBlock,
2736 if (Returns.
size() > 1) {
2741 &AfterCallBB->
front());
2750 for (
unsigned i = 0, e = Returns.
size(); i != e; ++i) {
2753 "Ret value not consistent in function!");
2760 for (
unsigned i = 0, e = Returns.
size(); i != e; ++i) {
2771 if (CreatedBranchToNormalDest)
2773 }
else if (!Returns.
empty()) {
2777 if (&CB == Returns[0]->getReturnValue())
2784 BasicBlock *ReturnBB = Returns[0]->getParent();
2789 AfterCallBB->
splice(AfterCallBB->
begin(), ReturnBB);
2791 if (CreatedBranchToNormalDest)
2795 Returns[0]->eraseFromParent();
2808 if (InlinedMustTailCalls &&
pred_empty(AfterCallBB))
2813 assert(cast<BranchInst>(Br)->isUnconditional() &&
"splitBasicBlock broken!");
2814 BasicBlock *CalleeEntry = cast<BranchInst>(Br)->getSuccessor(0);
2833 auto &
DL = Caller->getParent()->getDataLayout();
2835 PHI->replaceAllUsesWith(V);
2836 PHI->eraseFromParent();
2840 if (MergeAttributes)
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
amdgpu Simplify well known AMD library false FunctionCallee Callee
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
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 > UpdateReturnAttributes("update-return-attrs", cl::init(true), cl::Hidden, cl::desc("Update return attributes on calls within inlined body"))
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 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 bool MayContainThrowingOrExitingCall(Instruction *Begin, Instruction *End)
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.
AttributeSet getRetAttrs() const
The attributes for the ret value are returned.
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.
const Instruction & front() const
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...
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
FunctionType * getFunctionType() const
Intrinsic::ID getIntrinsicID() const
Returns the intrinsic ID of the intrinsic called or Intrinsic::not_intrinsic if the called function i...
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)
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
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 * 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 * CreateCall(FunctionType *FTy, Value *Callee, ArrayRef< Value * > Args=std::nullopt, const Twine &Name="", MDNode *FPMathTag=nullptr)
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.
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.
Summary of how a function affects memory in the program.
bool onlyAccessesArgPointees() const
Whether this function only (at most) accesses argument memory.
bool onlyAccessesInaccessibleMem() const
Whether this function only (at most) accesses inaccessible 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'.
static UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
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.
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,...
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.
Value * simplifyInstruction(Instruction *I, const SimplifyQuery &Q, OptimizationRemarkEmitter *ORE=nullptr)
See if we can compute a simplified version of this instruction.
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.
uint32_t getTagID() const
Return the tag of this operand bundle as an integer.
Helper struct for trackAssignments, below.