59#include "llvm/IR/IntrinsicsWebAssembly.h"
89#define DEBUG_TYPE "local"
91STATISTIC(NumRemoved,
"Number of unreachable basic blocks removed");
92STATISTIC(NumPHICSEs,
"Number of PHI's that got CSE'd");
96#ifdef EXPENSIVE_CHECKS
102 cl::desc(
"Perform extra assertion checking to verify that PHINodes's hash "
103 "function is well-behaved w.r.t. its isEqual predicate"));
108 "When the basic block contains not more than this number of PHI nodes, "
109 "perform a (faster!) exhaustive search instead of set-driven one."));
133 if (
auto *BI = dyn_cast<BranchInst>(
T)) {
134 if (BI->isUnconditional())
return false;
139 if (Dest2 == Dest1) {
145 assert(BI->getParent() &&
"Terminator not inserted in block!");
152 NewBI->
copyMetadata(*BI, {LLVMContext::MD_loop, LLVMContext::MD_dbg,
153 LLVMContext::MD_annotation});
156 BI->eraseFromParent();
157 if (DeleteDeadConditions)
162 if (
auto *
Cond = dyn_cast<ConstantInt>(BI->getCondition())) {
176 NewBI->
copyMetadata(*BI, {LLVMContext::MD_loop, LLVMContext::MD_dbg,
177 LLVMContext::MD_annotation});
179 BI->eraseFromParent();
181 DTU->
applyUpdates({{DominatorTree::Delete, BB, OldDest}});
188 if (
auto *SI = dyn_cast<SwitchInst>(
T)) {
191 auto *CI = dyn_cast<ConstantInt>(SI->getCondition());
192 BasicBlock *DefaultDest = SI->getDefaultDest();
197 SI->getNumCases() > 0) {
198 TheOnlyDest = SI->case_begin()->getCaseSuccessor();
201 bool Changed =
false;
204 for (
auto It = SI->case_begin(),
End = SI->case_end(); It !=
End;) {
206 if (It->getCaseValue() == CI) {
207 TheOnlyDest = It->getCaseSuccessor();
213 if (It->getCaseSuccessor() == DefaultDest) {
215 unsigned NCases = SI->getNumCases();
218 if (NCases > 1 && MD) {
224 unsigned Idx = It->getCaseIndex();
226 Weights[0] += Weights[
Idx + 1];
230 SI->setMetadata(LLVMContext::MD_prof,
232 createBranchWeights(Weights));
237 It = SI->removeCase(It);
238 End = SI->case_end();
242 if (
auto *NewCI = dyn_cast<ConstantInt>(SI->getCondition())) {
244 It = SI->case_begin();
254 if (It->getCaseSuccessor() != TheOnlyDest)
255 TheOnlyDest =
nullptr;
261 if (CI && !TheOnlyDest) {
264 TheOnlyDest = SI->getDefaultDest();
279 if (DTU && Succ != TheOnlyDest)
280 RemovedSuccessors.
insert(Succ);
282 if (Succ == SuccToKeep) {
283 SuccToKeep =
nullptr;
291 SI->eraseFromParent();
292 if (DeleteDeadConditions)
295 std::vector<DominatorTree::UpdateType> Updates;
296 Updates.reserve(RemovedSuccessors.
size());
297 for (
auto *RemovedSuccessor : RemovedSuccessors)
298 Updates.push_back({DominatorTree::Delete, BB, RemovedSuccessor});
304 if (SI->getNumCases() == 1) {
307 auto FirstCase = *SI->case_begin();
309 FirstCase.getCaseValue(),
"cond");
313 FirstCase.getCaseSuccessor(),
314 SI->getDefaultDest());
326 MDNode *MakeImplicitMD = SI->getMetadata(LLVMContext::MD_make_implicit);
328 NewBr->
setMetadata(LLVMContext::MD_make_implicit, MakeImplicitMD);
331 SI->eraseFromParent();
337 if (
auto *IBI = dyn_cast<IndirectBrInst>(
T)) {
340 dyn_cast<BlockAddress>(IBI->getAddress()->stripPointerCasts())) {
341 BasicBlock *TheOnlyDest = BA->getBasicBlock();
348 for (
unsigned i = 0, e = IBI->getNumDestinations(); i != e; ++i) {
350 if (DTU && DestBB != TheOnlyDest)
351 RemovedSuccessors.
insert(DestBB);
352 if (IBI->getDestination(i) == SuccToKeep) {
353 SuccToKeep =
nullptr;
358 Value *Address = IBI->getAddress();
359 IBI->eraseFromParent();
360 if (DeleteDeadConditions)
367 BA->destroyConstant();
378 std::vector<DominatorTree::UpdateType> Updates;
379 Updates.reserve(RemovedSuccessors.
size());
380 for (
auto *RemovedSuccessor : RemovedSuccessors)
381 Updates.push_back({DominatorTree::Delete, BB, RemovedSuccessor});
410 if (II->getIntrinsicID() == Intrinsic::stacksave ||
411 II->getIntrinsicID() == Intrinsic::launder_invariant_group ||
412 II->isLifetimeStartOrEnd())
419 if (
I->isTerminator())
428 if (isa<DbgVariableIntrinsic>(
I))
437 if (
auto *CB = dyn_cast<CallBase>(
I))
441 if (!
I->willReturn()) {
442 auto *II = dyn_cast<IntrinsicInst>(
I);
448 switch (II->getIntrinsicID()) {
449 case Intrinsic::wasm_trunc_signed:
450 case Intrinsic::wasm_trunc_unsigned:
451 case Intrinsic::ptrauth_auth:
452 case Intrinsic::ptrauth_resign:
459 if (!
I->mayHaveSideEffects())
466 if (II->getIntrinsicID() == Intrinsic::stacksave ||
467 II->getIntrinsicID() == Intrinsic::launder_invariant_group)
470 if (II->isLifetimeStartOrEnd()) {
471 auto *Arg = II->getArgOperand(1);
473 if (isa<UndefValue>(Arg))
477 if (isa<AllocaInst>(Arg) || isa<GlobalValue>(Arg) || isa<Argument>(Arg))
479 if (IntrinsicInst *IntrinsicUse =
480 dyn_cast<IntrinsicInst>(Use.getUser()))
481 return IntrinsicUse->isLifetimeStartOrEnd();
491 if ((II->getIntrinsicID() == Intrinsic::assume &&
493 II->getIntrinsicID() == Intrinsic::experimental_guard) {
495 return !
Cond->isZero();
500 if (
auto *FPI = dyn_cast<ConstrainedFPIntrinsic>(
I)) {
501 std::optional<fp::ExceptionBehavior> ExBehavior =
502 FPI->getExceptionBehavior();
507 if (
auto *Call = dyn_cast<CallBase>(
I)) {
509 if (
Constant *
C = dyn_cast<Constant>(FreedOp))
510 return C->isNullValue() || isa<UndefValue>(
C);
516 if (
auto *LI = dyn_cast<LoadInst>(
I))
517 if (
auto *GV = dyn_cast<GlobalVariable>(
518 LI->getPointerOperand()->stripPointerCasts()))
519 if (!LI->isVolatile() && GV->isConstant())
531 std::function<
void(
Value *)> AboutToDeleteCallback) {
539 AboutToDeleteCallback);
547 std::function<
void(
Value *)> AboutToDeleteCallback) {
548 unsigned S = 0,
E = DeadInsts.
size(), Alive = 0;
549 for (; S !=
E; ++S) {
550 auto *
I = dyn_cast_or_null<Instruction>(DeadInsts[S]);
552 DeadInsts[S] =
nullptr;
559 AboutToDeleteCallback);
566 std::function<
void(
Value *)> AboutToDeleteCallback) {
568 while (!DeadInsts.
empty()) {
574 "Live instruction found in dead worklist!");
575 assert(
I->use_empty() &&
"Instructions with uses are not dead.");
580 if (AboutToDeleteCallback)
581 AboutToDeleteCallback(
I);
585 for (
Use &OpU :
I->operands()) {
586 Value *OpV = OpU.get();
602 I->eraseFromParent();
609 for (
auto *DII : DbgUsers)
610 DII->setKillLocation();
611 return !DbgUsers.
empty();
625 for (++UI; UI != UE; ++UI) {
642 I = cast<Instruction>(*
I->user_begin())) {
648 if (!Visited.
insert(
I).second) {
668 for (
unsigned i = 0, e =
I->getNumOperands(); i != e; ++i) {
669 Value *OpV =
I->getOperand(i);
670 I->setOperand(i,
nullptr);
683 I->eraseFromParent();
691 for (
User *U :
I->users()) {
693 WorkList.
insert(cast<Instruction>(U));
698 bool Changed =
false;
699 if (!
I->use_empty()) {
700 I->replaceAllUsesWith(SimpleV);
704 I->eraseFromParent();
719 bool MadeChange =
false;
736 assert(!BI->isTerminator());
746 while (!WorkList.
empty()) {
761 while (
PHINode *PN = dyn_cast<PHINode>(DestBB->
begin())) {
762 Value *NewVal = PN->getIncomingValue(0);
765 PN->replaceAllUsesWith(NewVal);
766 PN->eraseFromParent();
770 assert(PredBB &&
"Block doesn't have a single predecessor!");
784 if (PredOfPredBB != PredBB)
785 if (SeenPreds.
insert(PredOfPredBB).second)
786 Updates.
push_back({DominatorTree::Insert, PredOfPredBB, DestBB});
789 if (SeenPreds.
insert(PredOfPredBB).second)
790 Updates.
push_back({DominatorTree::Delete, PredOfPredBB, PredBB});
791 Updates.
push_back({DominatorTree::Delete, PredBB, DestBB});
821 "The successor list of PredBB isn't empty before "
822 "applying corresponding DTU updates.");
843 return First == Second || isa<UndefValue>(
First) || isa<UndefValue>(Second);
874 if (BBPreds.
count(IBB) &&
878 <<
"Can't fold, phi node " << PN->
getName() <<
" in "
879 << Succ->
getName() <<
" is conflicting with "
880 << BBPN->
getName() <<
" with regard to common predecessor "
892 if (BBPreds.
count(IBB) &&
896 <<
" is conflicting with regard to common "
897 <<
"predecessor " << IBB->
getName() <<
"\n");
924 if (!isa<UndefValue>(OldVal)) {
926 IncomingValues.
find(BB)->second == OldVal) &&
927 "Expected OldVal to match incoming value from BB!");
929 IncomingValues.
insert(std::make_pair(BB, OldVal));
934 if (It != IncomingValues.
end())
return It->second;
953 if (!isa<UndefValue>(V))
954 IncomingValues.
insert(std::make_pair(BB, V));
969 if (!isa<UndefValue>(V))
continue;
978 if (It == IncomingValues.
end()) {
991 unsigned PoisonCount =
count_if(TrueUndefOps, [&](
unsigned i) {
994 if (PoisonCount != 0 && PoisonCount != TrueUndefOps.
size()) {
995 for (
unsigned i : TrueUndefOps)
1011 assert(OldVal &&
"No entry in PHI for Pred BB!");
1028 if (isa<PHINode>(OldVal) && cast<PHINode>(OldVal)->
getParent() == BB) {
1029 PHINode *OldValPN = cast<PHINode>(OldVal);
1046 for (
unsigned i = 0, e = BBPreds.
size(); i != e; ++i) {
1065 "TryToSimplifyUncondBranchFromEmptyBlock called on entry block!");
1069 if (BB == Succ)
return false;
1089 while (isa<PHINode>(*BBI)) {
1090 for (
Use &U : BBI->uses()) {
1091 if (
PHINode* PN = dyn_cast<PHINode>(U.getUser())) {
1092 if (PN->getIncomingBlock(U) != BB)
1168 if (TI->hasMetadata(LLVMContext::MD_loop))
1171 if (PredTI->hasMetadata(LLVMContext::MD_loop))
1185 if (!PredsOfSucc.
contains(PredOfBB))
1186 if (SeenPreds.
insert(PredOfBB).second)
1187 Updates.
push_back({DominatorTree::Insert, PredOfBB, Succ});
1190 if (SeenPreds.
insert(PredOfBB).second)
1191 Updates.
push_back({DominatorTree::Delete, PredOfBB, BB});
1192 Updates.
push_back({DominatorTree::Delete, BB, Succ});
1195 if (isa<PHINode>(Succ->
begin())) {
1217 while (
PHINode *PN = dyn_cast<PHINode>(&BB->
front())) {
1219 assert(PN->use_empty() &&
"There shouldn't be any uses here!");
1220 PN->eraseFromParent();
1227 if (
MDNode *LoopMD = TI->getMetadata(LLVMContext::MD_loop))
1229 Pred->getTerminator()->setMetadata(LLVMContext::MD_loop, LoopMD);
1240 "applying corresponding DTU updates.");
1257 bool Changed =
false;
1262 for (
auto I = BB->
begin();
PHINode *PN = dyn_cast<PHINode>(
I);) {
1267 for (
auto J =
I;
PHINode *DuplicatePN = dyn_cast<PHINode>(J); ++J) {
1268 if (
ToRemove.contains(DuplicatePN))
1293 struct PHIDenseMapInfo {
1294 static PHINode *getEmptyKey() {
1298 static PHINode *getTombstoneKey() {
1303 return PN == getEmptyKey() || PN == getTombstoneKey();
1317 static unsigned getHashValue(
PHINode *PN) {
1332 return LHS->isIdenticalTo(
RHS);
1350 bool Changed =
false;
1351 for (
auto I = BB->
begin();
PHINode *PN = dyn_cast<PHINode>(
I++);) {
1354 auto Inserted = PHISet.
insert(PN);
1355 if (!Inserted.second) {
1358 PN->replaceAllUsesWith(*Inserted.first);
1387 PN->eraseFromParent();
1393 V = V->stripPointerCasts();
1395 if (
AllocaInst *AI = dyn_cast<AllocaInst>(V)) {
1401 Align CurrentAlign = AI->getAlign();
1402 if (PrefAlign <= CurrentAlign)
1403 return CurrentAlign;
1407 if (
DL.exceedsNaturalStackAlignment(PrefAlign))
1408 return CurrentAlign;
1409 AI->setAlignment(PrefAlign);
1413 if (
auto *GO = dyn_cast<GlobalObject>(V)) {
1415 Align CurrentAlign = GO->getPointerAlignment(
DL);
1416 if (PrefAlign <= CurrentAlign)
1417 return CurrentAlign;
1423 if (!GO->canIncreaseAlignment())
1424 return CurrentAlign;
1426 if (GO->isThreadLocal()) {
1427 unsigned MaxTLSAlign = GO->getParent()->getMaxTLSAlignment() / CHAR_BIT;
1428 if (MaxTLSAlign && PrefAlign >
Align(MaxTLSAlign))
1429 PrefAlign =
Align(MaxTLSAlign);
1432 GO->setAlignment(PrefAlign);
1444 assert(V->getType()->isPointerTy() &&
1445 "getOrEnforceKnownAlignment expects a pointer!");
1457 if (PrefAlign && *PrefAlign > Alignment)
1477 for (
auto *DVI : DbgValues) {
1479 if ((DVI->getVariable() == DIVar) && (DVI->getExpression() == DIExpr))
1495 TypeSize ValueSize =
DL.getTypeAllocSizeInBits(ValTy);
1505 "address of variable must have exactly 1 location operand.");
1508 if (std::optional<TypeSize> FragmentSize =
1509 AI->getAllocationSizeInBits(
DL)) {
1510 return TypeSize::isKnownGE(ValueSize, *FragmentSize);
1524 assert(DIVar &&
"Missing variable");
1526 Value *DV = SI->getValueOperand();
1543 DIExpr->isDeref() || (!DIExpr->startsWithDeref() &&
1546 Builder.insertDbgValueIntrinsic(DV, DIVar, DIExpr, NewLoc, SI);
1552 LLVM_DEBUG(
dbgs() <<
"Failed to convert dbg.declare to dbg.value: " << *DII
1558 Builder.insertDbgValueIntrinsic(DV, DIVar, DIExpr, NewLoc, SI);
1567 assert(DIVar &&
"Missing variable");
1573 LLVM_DEBUG(
dbgs() <<
"Failed to convert dbg.declare to dbg.value: "
1585 LI, DIVar, DIExpr, NewLoc, (
Instruction *)
nullptr);
1595 assert(DIVar &&
"Missing variable");
1604 LLVM_DEBUG(
dbgs() <<
"Failed to convert dbg.declare to dbg.value: "
1617 if (InsertionPt != BB->
end())
1618 Builder.insertDbgValueIntrinsic(APN, DIVar, DIExpr, NewLoc, &*InsertionPt);
1635 bool Changed =
false;
1640 if (
auto DDI = dyn_cast<DbgDeclareInst>(&BI))
1646 for (
auto &
I : Dbgs) {
1660 if (LoadInst *LI = dyn_cast<LoadInst>(U))
1661 return LI->isVolatile();
1662 if (StoreInst *SI = dyn_cast<StoreInst>(U))
1663 return SI->isVolatile();
1670 while (!WorkList.
empty()) {
1672 for (
const auto &AIUse : V->uses()) {
1673 User *U = AIUse.getUser();
1674 if (
StoreInst *SI = dyn_cast<StoreInst>(U)) {
1675 if (AIUse.getOperandNo() == 1)
1677 }
else if (
LoadInst *LI = dyn_cast<LoadInst>(U)) {
1679 }
else if (
CallInst *CI = dyn_cast<CallInst>(U)) {
1683 if (!CI->isLifetimeStartOrEnd()) {
1687 DIB.insertDbgValueIntrinsic(AI, DDI->
getVariable(), DerefExpr,
1690 }
else if (
BitCastInst *BI = dyn_cast<BitCastInst>(U)) {
1691 if (BI->getType()->isPointerTy())
1710 assert(BB &&
"No BasicBlock to clone dbg.value(s) from.");
1711 if (InsertedPHIs.
size() == 0)
1716 for (
auto &
I : *BB) {
1717 if (
auto DbgII = dyn_cast<DbgVariableIntrinsic>(&
I)) {
1718 for (
Value *V : DbgII->location_ops())
1719 if (
auto *Loc = dyn_cast_or_null<PHINode>(V))
1720 DbgValueMap.
insert({Loc, DbgII});
1723 if (DbgValueMap.
size() == 0)
1738 for (
auto *
PHI : InsertedPHIs) {
1743 for (
auto *VI :
PHI->operand_values()) {
1744 auto V = DbgValueMap.
find(VI);
1745 if (V != DbgValueMap.
end()) {
1746 auto *DbgII = cast<DbgVariableIntrinsic>(V->second);
1747 auto NewDI = NewDbgValueMap.
find({Parent, DbgII});
1748 if (NewDI == NewDbgValueMap.
end()) {
1749 auto *NewDbgII = cast<DbgVariableIntrinsic>(DbgII->clone());
1750 NewDI = NewDbgValueMap.
insert({{Parent, DbgII}, NewDbgII}).first;
1761 for (
auto DI : NewDbgValueMap) {
1763 auto *NewDbgII = DI.second;
1765 assert(InsertionPt != Parent->
end() &&
"Ill-formed basic block");
1766 NewDbgII->insertBefore(&*InsertionPt);
1771 DIBuilder &Builder, uint8_t DIExprFlags,
1775 const DebugLoc &Loc = DII->getDebugLoc();
1776 auto *DIVar = DII->getVariable();
1777 auto *DIExpr = DII->getExpression();
1778 assert(DIVar &&
"Missing variable");
1782 Builder.insertDeclare(NewAddress, DIVar, DIExpr, Loc, DII);
1783 DII->eraseFromParent();
1785 return !DbgDeclares.empty();
1793 assert(DIVar &&
"Missing variable");
1798 if (!DIExpr || DIExpr->getNumElements() < 1 ||
1799 DIExpr->getElement(0) != dwarf::DW_OP_deref)
1807 Builder.insertDbgValueIntrinsic(NewAddress, DIVar, DIExpr, Loc, DVI);
1816 if (
auto *DVI = dyn_cast<DbgValueInst>(U.getUser()))
1836 "address-expression shouldn't have fragment info");
1851 "address-expression shouldn't have fragment info");
1854 if (AdditionalValues.
empty()) {
1867 const unsigned MaxDebugArgs = 16;
1868 const unsigned MaxExpressionSize = 128;
1869 bool Salvaged =
false;
1871 for (
auto *DII : DbgUsers) {
1872 if (
auto *DAI = dyn_cast<DbgAssignIntrinsic>(DII)) {
1873 if (DAI->getAddress() == &
I) {
1877 if (DAI->getValue() != &
I)
1883 bool StackValue = isa<DbgValueInst>(DII);
1884 auto DIILocation = DII->location_ops();
1887 "DbgVariableIntrinsic must use salvaged instruction as its location");
1893 Value *Op0 =
nullptr;
1895 auto LocItr =
find(DIILocation, &
I);
1896 while (SalvagedExpr && LocItr != DIILocation.end()) {
1898 unsigned LocNo = std::distance(DIILocation.begin(), LocItr);
1905 LocItr = std::find(++LocItr, DIILocation.end(), &
I);
1912 DII->replaceVariableLocationOp(&
I, Op0);
1913 bool IsValidSalvageExpr = SalvagedExpr->
getNumElements() <= MaxExpressionSize;
1914 if (AdditionalValues.
empty() && IsValidSalvageExpr) {
1915 DII->setExpression(SalvagedExpr);
1916 }
else if (isa<DbgValueInst>(DII) && IsValidSalvageExpr &&
1917 DII->getNumVariableLocationOps() + AdditionalValues.
size() <=
1919 DII->addVariableLocationOps(AdditionalValues, SalvagedExpr);
1924 DII->setKillLocation();
1933 for (
auto *DII : DbgUsers)
1934 DII->setKillLocation();
1941 unsigned BitWidth =
DL.getIndexSizeInBits(
GEP->getPointerAddressSpace());
1945 if (!
GEP->collectOffset(
DL,
BitWidth, VariableOffsets, ConstantOffset))
1947 if (!VariableOffsets.
empty() && !CurrentLocOps) {
1948 Opcodes.
insert(Opcodes.
begin(), {dwarf::DW_OP_LLVM_arg, 0});
1951 for (
const auto &
Offset : VariableOffsets) {
1954 "Expected strictly positive multiplier for offset.");
1956 Offset.second.getZExtValue(), dwarf::DW_OP_mul,
1957 dwarf::DW_OP_plus});
1960 return GEP->getOperand(0);
1965 case Instruction::Add:
1966 return dwarf::DW_OP_plus;
1967 case Instruction::Sub:
1968 return dwarf::DW_OP_minus;
1969 case Instruction::Mul:
1970 return dwarf::DW_OP_mul;
1971 case Instruction::SDiv:
1972 return dwarf::DW_OP_div;
1973 case Instruction::SRem:
1974 return dwarf::DW_OP_mod;
1975 case Instruction::Or:
1976 return dwarf::DW_OP_or;
1977 case Instruction::And:
1978 return dwarf::DW_OP_and;
1979 case Instruction::Xor:
1980 return dwarf::DW_OP_xor;
1981 case Instruction::Shl:
1982 return dwarf::DW_OP_shl;
1983 case Instruction::LShr:
1984 return dwarf::DW_OP_shr;
1985 case Instruction::AShr:
1986 return dwarf::DW_OP_shra;
1997 if (!CurrentLocOps) {
2002 AdditionalValues.
push_back(
I->getOperand(1));
2009 auto *ConstInt = dyn_cast<ConstantInt>(BI->
getOperand(1));
2011 if (ConstInt && ConstInt->getBitWidth() > 64)
2017 uint64_t Val = ConstInt->getSExtValue();
2020 if (BinOpcode == Instruction::Add || BinOpcode == Instruction::Sub) {
2021 uint64_t Offset = BinOpcode == Instruction::Add ? Val : -int64_t(Val);
2025 Opcodes.
append({dwarf::DW_OP_constu, Val});
2044 return dwarf::DW_OP_eq;
2046 return dwarf::DW_OP_ne;
2049 return dwarf::DW_OP_gt;
2052 return dwarf::DW_OP_ge;
2055 return dwarf::DW_OP_lt;
2058 return dwarf::DW_OP_le;
2068 auto *ConstInt = dyn_cast<ConstantInt>(Icmp->
getOperand(1));
2070 if (ConstInt && ConstInt->getBitWidth() > 64)
2078 uint64_t Val = ConstInt->getSExtValue();
2096 auto &M = *
I.getModule();
2097 auto &
DL = M.getDataLayout();
2099 if (
auto *CI = dyn_cast<CastInst>(&
I)) {
2100 Value *FromValue = CI->getOperand(0);
2102 if (CI->isNoopCast(
DL)) {
2111 !(isa<TruncInst>(&
I) || isa<SExtInst>(&
I) || isa<ZExtInst>(&
I) ||
2112 isa<IntToPtrInst>(&
I) || isa<PtrToIntInst>(&
I)))
2116 if (FromType->isPointerTy())
2117 FromType =
DL.getIntPtrType(FromType);
2119 unsigned FromTypeBitSize = FromType->getScalarSizeInBits();
2124 Ops.
append(ExtOps.begin(), ExtOps.end());
2128 if (
auto *
GEP = dyn_cast<GetElementPtrInst>(&
I))
2130 if (
auto *BI = dyn_cast<BinaryOperator>(&
I))
2132 if (
auto *IC = dyn_cast<ICmpInst>(&
I))
2157 bool Changed =
false;
2159 if (isa<Instruction>(&To)) {
2160 bool DomPointAfterFrom =
From.getNextNonDebugInstruction() == &DomPoint;
2162 for (
auto *DII :
Users) {
2172 }
else if (!DT.
dominates(&DomPoint, DII)) {
2173 UndefOrSalvage.
insert(DII);
2179 for (
auto *DII :
Users) {
2180 if (UndefOrSalvage.
count(DII))
2193 if (!UndefOrSalvage.
empty()) {
2217 bool SameSize =
DL.getTypeSizeInBits(FromTy) ==
DL.getTypeSizeInBits(ToTy);
2218 bool LosslessConversion = !
DL.isNonIntegralPointerType(FromTy) &&
2219 !
DL.isNonIntegralPointerType(ToTy);
2220 return SameSize && LosslessConversion;
2230 if (!
From.isUsedByMetadata())
2233 assert(&
From != &To &&
"Can't replace something with itself");
2239 return DII.getExpression();
2253 assert(FromBits != ToBits &&
"Unexpected no-op conversion");
2257 if (FromBits < ToBits)
2268 return std::nullopt;
2270 bool Signed = *Signedness == DIBasicType::Signedness::Signed;
2281std::pair<unsigned, unsigned>
2283 unsigned NumDeadInst = 0;
2284 unsigned NumDeadDbgInst = 0;
2288 while (EndInst != &BB->
front()) {
2297 if (isa<DbgInfoIntrinsic>(Inst))
2303 return {NumDeadInst, NumDeadDbgInst};
2319 Successor->removePredecessor(BB, PreserveLCSSA);
2324 UI->setDebugLoc(
I->getDebugLoc());
2327 unsigned NumInstrsRemoved = 0;
2329 while (BBI != BBE) {
2330 if (!BBI->use_empty())
2332 BBI++->eraseFromParent();
2338 for (
BasicBlock *UniqueSuccessor : UniqueSuccessors)
2339 Updates.
push_back({DominatorTree::Delete, BB, UniqueSuccessor});
2342 return NumInstrsRemoved;
2361 auto NewWeights =
uint32_t(TotalWeight) != TotalWeight
2364 NewCall->
setMetadata(LLVMContext::MD_prof, NewWeights);
2387 DTU->
applyUpdates({{DominatorTree::Delete, BB, UnwindDestBB}});
2416 UnwindEdge, InvokeArgs, OpBundles, CI->
getName(), BB);
2423 DTU->
applyUpdates({{DominatorTree::Insert, BB, UnwindEdge}});
2430 Split->front().eraseFromParent();
2441 bool Changed =
false;
2449 if (
auto *CI = dyn_cast<CallInst>(&
I)) {
2450 Value *Callee = CI->getCalledOperand();
2452 if (
Function *
F = dyn_cast<Function>(Callee)) {
2453 auto IntrinsicID =
F->getIntrinsicID();
2458 if (IntrinsicID == Intrinsic::assume) {
2465 }
else if (IntrinsicID == Intrinsic::experimental_guard) {
2476 if (!isa<UnreachableInst>(CI->getNextNode())) {
2482 }
else if ((isa<ConstantPointerNull>(Callee) &&
2484 cast<PointerType>(Callee->getType())
2485 ->getAddressSpace())) ||
2486 isa<UndefValue>(Callee)) {
2491 if (CI->doesNotReturn() && !CI->isMustTailCall()) {
2495 if (!isa<UnreachableInst>(CI->getNextNode())) {
2502 }
else if (
auto *SI = dyn_cast<StoreInst>(&
I)) {
2508 if (SI->isVolatile())
continue;
2512 if (isa<UndefValue>(
Ptr) ||
2513 (isa<ConstantPointerNull>(
Ptr) &&
2515 SI->getPointerAddressSpace()))) {
2524 if (
auto *II = dyn_cast<InvokeInst>(Terminator)) {
2526 Value *Callee = II->getCalledOperand();
2527 if ((isa<ConstantPointerNull>(Callee) &&
2529 isa<UndefValue>(Callee)) {
2533 if (II->doesNotReturn() &&
2534 !isa<UnreachableInst>(II->getNormalDest()->front())) {
2540 BasicBlock *OrigNormalDest = II->getNormalDest();
2544 Ctx, OrigNormalDest->
getName() +
".unreachable",
2545 II->getFunction(), OrigNormalDest);
2547 II->setNormalDest(UnreachableNormalDest);
2550 {{DominatorTree::Delete, BB, OrigNormalDest},
2551 {DominatorTree::Insert, BB, UnreachableNormalDest}});
2555 if (II->use_empty() && !II->mayHaveSideEffects()) {
2557 BasicBlock *NormalDestBB = II->getNormalDest();
2558 BasicBlock *UnwindDestBB = II->getUnwindDest();
2561 II->eraseFromParent();
2563 DTU->applyUpdates({{DominatorTree::Delete, BB, UnwindDestBB}});
2569 }
else if (
auto *CatchSwitch = dyn_cast<CatchSwitchInst>(Terminator)) {
2571 struct CatchPadDenseMapInfo {
2586 if (
LHS == getEmptyKey() ||
LHS == getTombstoneKey() ||
2587 RHS == getEmptyKey() ||
RHS == getTombstoneKey())
2589 return LHS->isIdenticalTo(
RHS);
2600 E = CatchSwitch->handler_end();
2604 ++NumPerSuccessorCases[HandlerBB];
2605 auto *CatchPad = cast<CatchPadInst>(HandlerBB->
getFirstNonPHI());
2606 if (!HandlerSet.insert({CatchPad, Empty}).second) {
2608 --NumPerSuccessorCases[HandlerBB];
2609 CatchSwitch->removeHandler(
I);
2616 std::vector<DominatorTree::UpdateType> Updates;
2617 for (
const std::pair<BasicBlock *, int> &
I : NumPerSuccessorCases)
2619 Updates.push_back({DominatorTree::Delete, BB,
I.first});
2620 DTU->applyUpdates(Updates);
2628 }
while (!Worklist.
empty());
2635 if (
auto *II = dyn_cast<InvokeInst>(TI))
2641 if (
auto *CRI = dyn_cast<CleanupReturnInst>(TI)) {
2643 UnwindDest = CRI->getUnwindDest();
2644 }
else if (
auto *CatchSwitch = dyn_cast<CatchSwitchInst>(TI)) {
2646 CatchSwitch->getParentPad(),
nullptr, CatchSwitch->getNumHandlers(),
2647 CatchSwitch->getName(), CatchSwitch);
2648 for (
BasicBlock *PadBB : CatchSwitch->handlers())
2649 NewCatchSwitch->addHandler(PadBB);
2651 NewTI = NewCatchSwitch;
2652 UnwindDest = CatchSwitch->getUnwindDest();
2663 DTU->
applyUpdates({{DominatorTree::Delete, BB, UnwindDest}});
2676 if (Reachable.
size() ==
F.size())
2685 if (Reachable.
count(&BB))
2690 BlocksToRemove.
insert(&BB);
2693 if (BlocksToRemove.
empty())
2697 NumRemoved += BlocksToRemove.
size();
2710 K->dropUnknownNonDebugMetadata(KnownIDs);
2711 K->getAllMetadataOtherThanDebugLoc(
Metadata);
2713 unsigned Kind = MD.first;
2719 K->setMetadata(Kind,
nullptr);
2721 case LLVMContext::MD_dbg:
2723 case LLVMContext::MD_DIAssignID:
2724 K->mergeDIAssignID(J);
2726 case LLVMContext::MD_tbaa:
2729 case LLVMContext::MD_alias_scope:
2732 case LLVMContext::MD_noalias:
2733 case LLVMContext::MD_mem_parallel_loop_access:
2736 case LLVMContext::MD_access_group:
2737 K->setMetadata(LLVMContext::MD_access_group,
2740 case LLVMContext::MD_range:
2741 if (DoesKMove || !K->hasMetadata(LLVMContext::MD_noundef))
2744 case LLVMContext::MD_fpmath:
2747 case LLVMContext::MD_invariant_load:
2751 K->setMetadata(Kind, JMD);
2753 case LLVMContext::MD_nonnull:
2754 if (DoesKMove || !K->hasMetadata(LLVMContext::MD_noundef))
2755 K->setMetadata(Kind, JMD);
2757 case LLVMContext::MD_invariant_group:
2760 case LLVMContext::MD_align:
2761 if (DoesKMove || !K->hasMetadata(LLVMContext::MD_noundef))
2765 case LLVMContext::MD_dereferenceable:
2766 case LLVMContext::MD_dereferenceable_or_null:
2768 K->setMetadata(Kind,
2771 case LLVMContext::MD_preserve_access_index:
2774 case LLVMContext::MD_noundef:
2777 K->setMetadata(Kind, JMD);
2779 case LLVMContext::MD_nontemporal:
2781 K->setMetadata(Kind, JMD);
2783 case LLVMContext::MD_prof:
2795 if (
auto *JMD = J->
getMetadata(LLVMContext::MD_invariant_group))
2796 if (isa<LoadInst>(K) || isa<StoreInst>(K))
2797 K->setMetadata(LLVMContext::MD_invariant_group, JMD);
2802 unsigned KnownIDs[] = {LLVMContext::MD_tbaa,
2803 LLVMContext::MD_alias_scope,
2804 LLVMContext::MD_noalias,
2805 LLVMContext::MD_range,
2806 LLVMContext::MD_fpmath,
2807 LLVMContext::MD_invariant_load,
2808 LLVMContext::MD_nonnull,
2809 LLVMContext::MD_invariant_group,
2810 LLVMContext::MD_align,
2811 LLVMContext::MD_dereferenceable,
2812 LLVMContext::MD_dereferenceable_or_null,
2813 LLVMContext::MD_access_group,
2814 LLVMContext::MD_preserve_access_index,
2815 LLVMContext::MD_prof,
2816 LLVMContext::MD_nontemporal,
2817 LLVMContext::MD_noundef};
2823 Source.getAllMetadata(MD);
2826 const DataLayout &
DL = Source.getModule()->getDataLayout();
2827 for (
const auto &MDPair : MD) {
2828 unsigned ID = MDPair.first;
2838 case LLVMContext::MD_dbg:
2839 case LLVMContext::MD_tbaa:
2840 case LLVMContext::MD_prof:
2841 case LLVMContext::MD_fpmath:
2842 case LLVMContext::MD_tbaa_struct:
2843 case LLVMContext::MD_invariant_load:
2844 case LLVMContext::MD_alias_scope:
2845 case LLVMContext::MD_noalias:
2846 case LLVMContext::MD_nontemporal:
2847 case LLVMContext::MD_mem_parallel_loop_access:
2848 case LLVMContext::MD_access_group:
2849 case LLVMContext::MD_noundef:
2854 case LLVMContext::MD_nonnull:
2858 case LLVMContext::MD_align:
2859 case LLVMContext::MD_dereferenceable:
2860 case LLVMContext::MD_dereferenceable_or_null:
2866 case LLVMContext::MD_range:
2874 auto *ReplInst = dyn_cast<Instruction>(Repl);
2884 if (!isa<LoadInst>(
I))
2885 ReplInst->andIRFlags(
I);
2899template <
typename RootType,
typename DominatesFn>
2901 const RootType &Root,
2902 const DominatesFn &Dominates) {
2907 if (!Dominates(Root, U))
2911 dbgs() <<
"' with " << *To <<
" in " << *U.getUser() <<
"\n");
2920 auto *BB =
From->getParent();
2924 auto *
I = cast<Instruction>(U.getUser());
2925 if (
I->getParent() == BB)
2939 return ::replaceDominatedUsesWith(
From, To, Root, Dominates);
2945 auto Dominates = [&DT](
const BasicBlock *BB,
const Use &U) {
2948 return ::replaceDominatedUsesWith(
From, To, BB, Dominates);
2954 if (Call->hasFnAttr(
"gc-leaf-function"))
2956 if (
const Function *
F = Call->getCalledFunction()) {
2957 if (
F->hasFnAttribute(
"gc-leaf-function"))
2960 if (
auto IID =
F->getIntrinsicID()) {
2962 return IID != Intrinsic::experimental_gc_statepoint &&
2963 IID != Intrinsic::experimental_deoptimize &&
2964 IID != Intrinsic::memcpy_element_unordered_atomic &&
2965 IID != Intrinsic::memmove_element_unordered_atomic;
2982 auto *NewTy = NewLI.
getType();
2985 if (NewTy->isPointerTy()) {
2992 if (!NewTy->isIntegerTy())
2997 auto *ITy = cast<IntegerType>(NewTy);
3007 auto *NewTy = NewLI.
getType();
3009 if (NewTy == OldLI.
getType()) {
3018 if (!NewTy->isPointerTy())
3021 unsigned BitWidth =
DL.getPointerTypeSizeInBits(NewTy);
3032 for (
auto *DII : DbgUsers)
3033 DII->eraseFromParent();
3062 I->dropUBImplyingAttrsAndMetadata();
3063 if (
I->isUsedByMetadata())
3065 if (
I->isDebugOrPseudoInst()) {
3067 II =
I->eraseFromParent();
3082 BitPart(
Value *
P,
unsigned BW) : Provider(
P) {
3083 Provenance.resize(BW);
3093 enum { Unset = -1 };
3125static const std::optional<BitPart> &
3127 std::map<
Value *, std::optional<BitPart>> &BPS,
int Depth,
3129 auto I = BPS.find(V);
3133 auto &Result = BPS[V] = std::nullopt;
3134 auto BitWidth = V->getType()->getScalarSizeInBits();
3142 LLVM_DEBUG(
dbgs() <<
"collectBitParts max recursion depth reached.\n");
3146 if (
auto *
I = dyn_cast<Instruction>(V)) {
3154 Depth + 1, FoundRoot);
3155 if (!
A || !
A->Provider)
3159 Depth + 1, FoundRoot);
3160 if (!
B ||
A->Provider !=
B->Provider)
3164 Result = BitPart(
A->Provider,
BitWidth);
3165 for (
unsigned BitIdx = 0; BitIdx <
BitWidth; ++BitIdx) {
3166 if (
A->Provenance[BitIdx] != BitPart::Unset &&
3167 B->Provenance[BitIdx] != BitPart::Unset &&
3168 A->Provenance[BitIdx] !=
B->Provenance[BitIdx])
3169 return Result = std::nullopt;
3171 if (
A->Provenance[BitIdx] == BitPart::Unset)
3172 Result->Provenance[BitIdx] =
B->Provenance[BitIdx];
3174 Result->Provenance[BitIdx] =
A->Provenance[BitIdx];
3182 const APInt &BitShift = *
C;
3189 if (!MatchBitReversals && (BitShift.
getZExtValue() % 8) != 0)
3193 Depth + 1, FoundRoot);
3199 auto &
P = Result->Provenance;
3200 if (
I->getOpcode() == Instruction::Shl) {
3214 const APInt &AndMask = *
C;
3218 unsigned NumMaskedBits = AndMask.
popcount();
3219 if (!MatchBitReversals && (NumMaskedBits % 8) != 0)
3223 Depth + 1, FoundRoot);
3228 for (
unsigned BitIdx = 0; BitIdx <
BitWidth; ++BitIdx)
3230 if (AndMask[BitIdx] == 0)
3231 Result->Provenance[BitIdx] = BitPart::Unset;
3238 Depth + 1, FoundRoot);
3242 Result = BitPart(Res->Provider,
BitWidth);
3243 auto NarrowBitWidth =
X->getType()->getScalarSizeInBits();
3244 for (
unsigned BitIdx = 0; BitIdx < NarrowBitWidth; ++BitIdx)
3245 Result->Provenance[BitIdx] = Res->Provenance[BitIdx];
3246 for (
unsigned BitIdx = NarrowBitWidth; BitIdx <
BitWidth; ++BitIdx)
3247 Result->Provenance[BitIdx] = BitPart::Unset;
3254 Depth + 1, FoundRoot);
3258 Result = BitPart(Res->Provider,
BitWidth);
3259 for (
unsigned BitIdx = 0; BitIdx <
BitWidth; ++BitIdx)
3260 Result->Provenance[BitIdx] = Res->Provenance[BitIdx];
3268 Depth + 1, FoundRoot);
3272 Result = BitPart(Res->Provider,
BitWidth);
3273 for (
unsigned BitIdx = 0; BitIdx <
BitWidth; ++BitIdx)
3274 Result->Provenance[(
BitWidth - 1) - BitIdx] = Res->Provenance[BitIdx];
3281 Depth + 1, FoundRoot);
3286 Result = BitPart(Res->Provider,
BitWidth);
3287 for (
unsigned ByteIdx = 0; ByteIdx < ByteWidth; ++ByteIdx) {
3288 unsigned ByteBitOfs = ByteIdx * 8;
3289 for (
unsigned BitIdx = 0; BitIdx < 8; ++BitIdx)
3290 Result->Provenance[(
BitWidth - 8 - ByteBitOfs) + BitIdx] =
3291 Res->Provenance[ByteBitOfs + BitIdx];
3308 if (!MatchBitReversals && (ModAmt % 8) != 0)
3313 Depth + 1, FoundRoot);
3314 if (!
LHS || !
LHS->Provider)
3318 Depth + 1, FoundRoot);
3319 if (!
RHS ||
LHS->Provider !=
RHS->Provider)
3322 unsigned StartBitRHS =
BitWidth - ModAmt;
3324 for (
unsigned BitIdx = 0; BitIdx < StartBitRHS; ++BitIdx)
3325 Result->Provenance[BitIdx + ModAmt] =
LHS->Provenance[BitIdx];
3326 for (
unsigned BitIdx = 0; BitIdx < ModAmt; ++BitIdx)
3327 Result->Provenance[BitIdx] =
RHS->Provenance[BitIdx + StartBitRHS];
3341 for (
unsigned BitIdx = 0; BitIdx <
BitWidth; ++BitIdx)
3342 Result->Provenance[BitIdx] = BitIdx;
3348 if (
From % 8 != To % 8)
3363 Instruction *
I,
bool MatchBSwaps,
bool MatchBitReversals,
3369 if (!MatchBSwaps && !MatchBitReversals)
3371 Type *ITy =
I->getType();
3376 bool FoundRoot =
false;
3377 std::map<Value *, std::optional<BitPart>> BPS;
3384 [](int8_t
I) {
return I == BitPart::Unset || 0 <=
I; }) &&
3385 "Illegal bit provenance index");
3388 Type *DemandedTy = ITy;
3389 if (BitProvenance.
back() == BitPart::Unset) {
3390 while (!BitProvenance.
empty() && BitProvenance.
back() == BitPart::Unset)
3391 BitProvenance = BitProvenance.
drop_back();
3392 if (BitProvenance.
empty())
3395 if (
auto *IVecTy = dyn_cast<VectorType>(ITy))
3396 DemandedTy = VectorType::get(DemandedTy, IVecTy);
3407 bool OKForBSwap = MatchBSwaps && (DemandedBW % 16) == 0;
3408 bool OKForBitReverse = MatchBitReversals;
3409 for (
unsigned BitIdx = 0;
3410 (BitIdx < DemandedBW) && (OKForBSwap || OKForBitReverse); ++BitIdx) {
3411 if (BitProvenance[BitIdx] == BitPart::Unset) {
3418 BitIdx, DemandedBW);
3423 Intrin = Intrinsic::bswap;
3424 else if (OKForBitReverse)
3425 Intrin = Intrinsic::bitreverse;
3430 Value *Provider = Res->Provider;
3433 if (DemandedTy != Provider->
getType()) {
3450 if (ITy != Result->getType()) {
3467 if (
F && !
F->hasLocalLinkage() &&
F->hasName() &&
3469 !
F->doesNotAccessMemory())
3475 if (
I->getOperand(OpIdx)->getType()->isMetadataTy())
3479 if (!isa<Constant>(
I->getOperand(OpIdx)))
3482 switch (
I->getOpcode()) {
3485 case Instruction::Call:
3486 case Instruction::Invoke: {
3487 const auto &CB = cast<CallBase>(*
I);
3490 if (CB.isInlineAsm())
3495 if (CB.isBundleOperand(OpIdx))
3498 if (OpIdx < CB.arg_size()) {
3501 if (isa<IntrinsicInst>(CB) &&
3502 OpIdx >= CB.getFunctionType()->getNumParams()) {
3504 return CB.getIntrinsicID() == Intrinsic::experimental_stackmap;
3509 if (CB.getIntrinsicID() == Intrinsic::gcroot)
3513 return !CB.paramHasAttr(OpIdx, Attribute::ImmArg);
3518 return !isa<IntrinsicInst>(CB);
3520 case Instruction::ShuffleVector:
3523 case Instruction::Switch:
3524 case Instruction::ExtractValue:
3527 case Instruction::InsertValue:
3530 case Instruction::Alloca:
3534 return !cast<AllocaInst>(
I)->isStaticAlloca();
3535 case Instruction::GetElementPtr:
3539 for (
auto E = std::next(It, OpIdx); It !=
E; ++It)
3548 if (
Constant *
C = dyn_cast<Constant>(Condition))
3552 Value *NotCondition;
3554 return NotCondition;
3557 Instruction *Inst = dyn_cast<Instruction>(Condition);
3560 else if (
Argument *Arg = dyn_cast<Argument>(Condition))
3562 assert(Parent &&
"Unsupported condition to invert");
3573 if (Inst && !isa<PHINode>(Inst))
3574 Inverted->insertAfter(Inst);
3584 bool Changed =
false;
3586 if (!
F.hasFnAttribute(Attribute::NoSync) &&
3587 F.doesNotAccessMemory() && !
F.isConvergent()) {
3593 if (!
F.hasFnAttribute(Attribute::NoFree) &&
F.onlyReadsMemory()) {
3594 F.setDoesNotFreeMemory();
3599 if (!
F.hasFnAttribute(Attribute::MustProgress) &&
F.willReturn()) {
3600 F.setMustProgress();
for(const MachineOperand &MO :llvm::drop_begin(OldMI.operands(), Desc.getNumOperands()))
static unsigned getIntrinsicID(const SDNode *N)
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
This file implements a class to represent arbitrary precision integral constant values and operations...
ReachingDefAnalysis InstSet & ToRemove
static bool isEqual(const Function &Caller, const Function &Callee)
This file contains the simple types necessary to represent the attributes associated with functions a...
static const Function * getParent(const Value *V)
BlockVerifier::State From
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
static bool isSentinel(const DWARFDebugNames::AttributeEncoding &AE)
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
This file defines DenseMapInfo traits for DenseMap.
This file defines the DenseMap class.
This file defines the DenseSet and SmallDenseSet classes.
This file contains constants used for implementing Dwarf debug support.
static unsigned getHashValueImpl(SimpleValue Val)
static bool isEqualImpl(SimpleValue LHS, SimpleValue RHS)
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
This file provides various utilities for inspecting and working with the control flow graph in LLVM I...
iv Induction Variable Users
Module.h This file contains the declarations for the Module class.
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
This file contains the declarations for profiling metadata utility functions.
const SmallVectorImpl< MachineOperand > & Cond
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.
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
This defines the Use class.
Class recording the (high level) value of a variable.
Class for arbitrary precision integers.
static APInt getAllOnes(unsigned numBits)
Return an APInt of a specified width with all bits set.
void clearBit(unsigned BitPosition)
Set a given bit to 0.
uint64_t getZExtValue() const
Get zero extended value.
unsigned popcount() const
Count the number of bits set.
bool isAllOnes() const
Determine if all bits are set. This is true for zero-width values.
int64_t getSExtValue() const
Get sign extended value.
bool uge(const APInt &RHS) const
Unsigned greater or equal comparison.
an instruction to allocate memory on the stack
Type * getAllocatedType() const
Return the type that is being allocated by the instruction.
bool isArrayAllocation() const
Return true if there is an allocation size parameter to the allocation instruction that is not 1.
This class represents an incoming formal argument to a Function.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
const T & back() const
back - Get the last element.
size_t size() const
size - Get the array size.
ArrayRef< T > drop_back(size_t N=1) const
Drop the last N elements of the array.
bool empty() const
empty - Check if the array is empty.
Value handle that asserts if the Value is deleted.
A cache of @llvm.assume calls within a function.
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_iterator getFirstInsertionPt() const
Returns an iterator to the first instruction in this block that is suitable for inserting a non-PHI i...
bool hasAddressTaken() const
Returns true if there are any uses of this basic block other than direct branches,...
const Instruction * getFirstNonPHI() const
Returns a pointer to the first instruction in this block that is not a PHINode instruction.
const Instruction & front() const
static BasicBlock * Create(LLVMContext &Context, const Twine &Name="", Function *Parent=nullptr, BasicBlock *InsertBefore=nullptr)
Creates a new BasicBlock.
bool isEntryBlock() const
Return true if this is the entry block of the containing function.
void moveAfter(BasicBlock *MovePos)
Unlink this basic block from its current function and insert it right after MovePos in the function M...
const BasicBlock * getSinglePredecessor() const
Return the predecessor of this block if it has a single predecessor block.
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.
const Instruction * getFirstNonPHIOrDbg(bool SkipPseudoOp=true) const
Returns a pointer to the first instruction in this block that is not a PHINode or a debug intrinsic,...
InstListType::iterator iterator
Instruction iterators...
LLVMContext & getContext() const
Get the context in which this basic block lives.
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...
void splice(BasicBlock::iterator ToIt, BasicBlock *FromBB)
Transfer all instructions from FromBB to this basic block at ToIt.
const Instruction & back() const
const Module * getModule() const
Return the module owning the function this basic block belongs to, or nullptr if the function does no...
void removePredecessor(BasicBlock *Pred, bool KeepOneInputPHIs=false)
Update PHI nodes in this BasicBlock before removal of predecessor Pred.
static BinaryOperator * Create(BinaryOps Op, Value *S1, Value *S2, const Twine &Name=Twine(), Instruction *InsertBefore=nullptr)
Construct a binary instruction, given the opcode and the two operands.
BinaryOps getOpcode() const
static BinaryOperator * CreateNot(Value *Op, const Twine &Name="", Instruction *InsertBefore=nullptr)
This class represents a no-op cast from one type to another.
The address of a basic block.
static BlockAddress * get(Function *F, BasicBlock *BB)
Return a BlockAddress for the specified function and basic block.
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 addFnAttr(Attribute::AttrKind Kind)
Adds the attribute to the function.
void getOperandBundlesAsDefs(SmallVectorImpl< OperandBundleDef > &Defs) const
Return the list of operand bundles attached to this instruction as a vector of OperandBundleDefs.
Function * getCalledFunction() const
Returns the function called, or null if this is an indirect function invocation or the function signa...
CallingConv::ID getCallingConv() const
Value * getCalledOperand() const
void setAttributes(AttributeList A)
Set the parameter attributes for this call.
FunctionType * getFunctionType() const
iterator_range< User::op_iterator > args()
Iteration adapter for range-for loops.
AttributeList getAttributes() const
Return the parameter attributes for this call.
This class represents a function call, abstracting a target machine's calling convention.
static CallInst * Create(FunctionType *Ty, Value *F, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
static CastInst * CreateIntegerCast(Value *S, Type *Ty, bool isSigned, const Twine &Name="", Instruction *InsertBefore=nullptr)
Create a ZExt, BitCast, or Trunc for int -> int casts.
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)
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
@ ICMP_SLT
signed less than
@ ICMP_SLE
signed less or equal
@ ICMP_UGE
unsigned greater or equal
@ ICMP_UGT
unsigned greater than
@ ICMP_SGT
signed greater than
@ ICMP_ULT
unsigned less than
@ ICMP_SGE
signed greater or equal
@ ICMP_ULE
unsigned less or equal
Predicate getPredicate() const
Return the predicate for this instruction.
static Constant * getIntToPtr(Constant *C, Type *Ty, bool OnlyIfReduced=false)
static Constant * getNot(Constant *C)
static Constant * getPtrToInt(Constant *C, Type *Ty, bool OnlyIfReduced=false)
static Constant * getAdd(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
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 ConstantPointerNull * get(PointerType *T)
Static factory methods - Return objects of the specified value.
bool contains(const APInt &Val) const
Return true if the specified value is in the set.
This is an important base class in LLVM.
void destroyConstant()
Called if some element of this constant is no longer valid.
static DIExpression * append(const DIExpression *Expr, ArrayRef< uint64_t > Ops)
Append the opcodes Ops to DIExpr.
unsigned getNumElements() const
static ExtOps getExtOps(unsigned FromSize, unsigned ToSize, bool Signed)
Returns the ops for a zero- or sign-extension in a DIExpression.
static void appendOffset(SmallVectorImpl< uint64_t > &Ops, int64_t Offset)
Append Ops with operations to apply the Offset.
static DIExpression * appendOpsToArg(const DIExpression *Expr, ArrayRef< uint64_t > Ops, unsigned ArgNo, bool StackValue=false)
Create a copy of Expr by appending the given list of Ops to each instance of the operand DW_OP_LLVM_a...
static std::optional< FragmentInfo > getFragmentInfo(expr_op_iterator Start, expr_op_iterator End)
Retrieve the details of this fragment expression.
uint64_t getNumLocationOperands() const
Return the number of unique location operands referred to (via DW_OP_LLVM_arg) in this expression; th...
static DIExpression * prepend(const DIExpression *Expr, uint8_t Flags, int64_t Offset=0)
Prepend DIExpr with a deref and offset operation and optionally turn it into a stack value or/and an ...
static DIExpression * appendExt(const DIExpression *Expr, unsigned FromSize, unsigned ToSize, bool Signed)
Append a zero- or sign-extension to Expr.
std::optional< DIBasicType::Signedness > getSignedness() const
Return the signedness of this variable's type, or std::nullopt if this type is neither signed nor uns...
A parsed version of the target data layout string in and methods for querying it.
This represents the llvm.dbg.assign instruction.
void setKillAddress()
Kill the address component.
DIExpression * getAddressExpression() const
Value * getAddress() const
void setAddress(Value *V)
void setAddressExpression(DIExpression *NewExpr)
This represents the llvm.dbg.declare instruction.
Value * getAddress() const
This represents the llvm.dbg.label instruction.
This represents the llvm.dbg.value instruction.
This is the common base class for debug info intrinsics for variables.
iterator_range< location_op_iterator > location_ops() const
Get the locations corresponding to the variable referenced by the debug info intrinsic.
void replaceVariableLocationOp(Value *OldValue, Value *NewValue)
Value * getVariableLocationOp(unsigned OpIdx) const
void setExpression(DIExpression *NewExpr)
DILocalVariable * getVariable() const
unsigned getNumVariableLocationOps() const
bool isAddressOfVariable() const
Does this describe the address of a local variable.
std::optional< uint64_t > getFragmentSizeInBits() const
Get the size (in bits) of the variable, or fragment of the variable that is described.
DIExpression * getExpression() const
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)
Implements a dense probed hash-table based set.
void recalculate(Function &F)
Notify DTU that the entry block was replaced.
bool hasDomTree() const
Returns true if it holds a DominatorTree.
bool isBBPendingDeletion(BasicBlock *DelBB) const
Returns true if DelBB is awaiting deletion.
void applyUpdates(ArrayRef< DominatorTree::UpdateType > Updates)
Submit updates to all available trees.
void deleteBB(BasicBlock *DelBB)
Delete DelBB.
void applyUpdatesPermissive(ArrayRef< DominatorTree::UpdateType > Updates)
Submit updates to all available trees.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
bool dominates(const BasicBlock *BB, const Use &U) const
Return true if the (end of the) basic block BB dominates the use U.
const BasicBlock & getEntryBlock() const
an instruction for type-safe pointer arithmetic to access elements of arrays and structs
This instruction compares its operands according to the predicate given to the constructor.
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
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 extractProfTotalWeight(uint64_t &TotalVal) const
Retrieve total raw weight values of a branch.
void moveAfter(Instruction *MovePos)
Unlink this instruction from its current basic block and insert it into the basic block that MovePos ...
bool isEHPad() const
Return true if the instruction is a variety of EH-block.
const BasicBlock * getParent() const
bool isIdenticalToWhenDefined(const Instruction *I) const LLVM_READONLY
This is like isIdenticalTo, except that it ignores the SubclassOptionalData flags,...
MDNode * getMetadata(unsigned KindID) const
Get the metadata of given kind attached to this Instruction.
const Instruction * getNextNonDebugInstruction(bool SkipPseudoOp=false) const
Return a pointer to the next non-debug instruction in the same basic block as 'this',...
void setMetadata(unsigned KindID, MDNode *Node)
Set the metadata of the specified kind to the specified node.
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.
void copyMetadata(const Instruction &SrcInst, ArrayRef< unsigned > WL=ArrayRef< unsigned >())
Copy metadata from SrcInst to this instruction.
A wrapper class for inspecting calls to intrinsic functions.
BasicBlock * getUnwindDest() const
BasicBlock * getNormalDest() const
static InvokeInst * Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal, BasicBlock *IfException, ArrayRef< Value * > Args, const Twine &NameStr, Instruction *InsertBefore=nullptr)
This is an important class for using LLVM in a threaded context.
An instruction for reading from memory.
Value * getPointerOperand()
MDNode * createRange(const APInt &Lo, const APInt &Hi)
Return metadata describing the range [Lo, Hi).
MDNode * createBranchWeights(uint32_t TrueWeight, uint32_t FalseWeight)
Return metadata containing two branch weights.
static MDNode * getMostGenericAliasScope(MDNode *A, MDNode *B)
static MDNode * getMostGenericTBAA(MDNode *A, MDNode *B)
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
static MDNode * getMergedProfMetadata(MDNode *A, MDNode *B, const Instruction *AInstr, const Instruction *BInstr)
Merge !prof metadata from two instructions.
static MDNode * getMostGenericFPMath(MDNode *A, MDNode *B)
static MDNode * getMostGenericRange(MDNode *A, MDNode *B)
static MDNode * intersect(MDNode *A, MDNode *B)
static MDNode * getMostGenericAlignmentOrDereferenceable(MDNode *A, MDNode *B)
This class implements a map that also provides access to all stored values in a deterministic order.
iterator find(const KeyT &Key)
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
void changeToUnreachable(const Instruction *I)
Instruction I will be changed to an unreachable.
void removeBlocks(const SmallSetVector< BasicBlock *, 8 > &DeadBlocks)
Remove all MemoryAcceses in a set of BasicBlocks about to be deleted.
void removeMemoryAccess(MemoryAccess *, bool OptimizePhis=false)
Remove a MemoryAccess from MemorySSA, including updating all definitions and uses.
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.
void addIncoming(Value *V, BasicBlock *BB)
Add an incoming value to the end of the PHI list.
const_block_iterator block_begin() const
Value * removeIncomingValue(unsigned Idx, bool DeletePHIIfEmpty=true)
Remove an incoming value.
void setIncomingValue(unsigned i, Value *V)
const_block_iterator block_end() const
Value * getIncomingValueForBlock(const BasicBlock *BB) const
BasicBlock * getIncomingBlock(unsigned i) const
Return incoming basic block number i.
Value * getIncomingValue(unsigned i) const
Return incoming value number x.
unsigned getNumIncomingValues() const
Return the number of incoming edges.
static PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
size_type size() const
Determine the number of elements in the SetVector.
Vector takeVector()
Clear the SetVector and return the underlying vector.
size_type count(const key_type &key) const
Count the number of elements of a given key in the SetVector.
bool empty() const
Determine if the SetVector is empty or not.
bool insert(const value_type &X)
Insert a new element into the SetVector.
value_type pop_back_val()
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.
SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less...
std::pair< const_iterator, bool > insert(const T &V)
insert - Insert an element into the set if it isn't already there.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void reserve(size_type N)
void append(ItTy in_start, ItTy in_end)
Add the specified range to the end of the SmallVector.
iterator insert(iterator I, T &&Elt)
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.
Provides information about what library functions are available for the current target.
bool hasOptimizedCodeGen(LibFunc F) const
Tests if the function is both available and a candidate for optimized code generation.
bool has(LibFunc F) const
Tests whether a library function is available.
bool getLibFunc(StringRef funcName, LibFunc &F) const
Searches for a particular function name.
static constexpr TypeSize getFixed(ScalarTy ExactSize)
The instances of the Type class are immutable: once they are created, they are never changed.
bool isVectorTy() const
True if this is an instance of VectorType.
bool isArrayTy() const
True if this is an instance of ArrayType.
bool isIntOrIntVectorTy() const
Return true if this is an integer type or a vector of integer types.
bool isPointerTy() const
True if this is an instance of PointerType.
static IntegerType * getIntNTy(LLVMContext &C, unsigned N)
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
bool isStructTy() const
True if this is an instance of StructType.
bool isIntOrPtrTy() const
Return true if this is an integer type or a pointer type.
static IntegerType * getInt32Ty(LLVMContext &C)
bool isIntegerTy() const
True if this is an instance of IntegerType.
bool isTokenTy() const
Return true if this is 'token'.
TypeSize getPrimitiveSizeInBits() const LLVM_READONLY
Return the basic size of this type if it is a primitive type.
static UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
This function has undefined behavior.
A Use represents the edge between a Value definition and its users.
value_op_iterator value_op_end()
Value * getOperand(unsigned i) const
value_op_iterator value_op_begin()
iterator find(const KeyT &Val)
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
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()
LLVMContext & getContext() const
All values hold a context through their type.
static constexpr unsigned MaxAlignmentExponent
The maximum alignment for instructions.
user_iterator_impl< User > user_iterator
StringRef getName() const
Return a constant reference to the value's name.
void takeName(Value *V)
Transfer the name from V to this value.
std::pair< iterator, bool > insert(const ValueT &V)
void reserve(size_t Size)
Grow the DenseSet so that it can contain at least NumEntries items before resizing again.
An efficient, type-erasing, non-owning reference to a callable.
self_iterator getIterator()
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
Function * getDeclaration(Module *M, ID id, ArrayRef< Type * > Tys=std::nullopt)
Create or insert an LLVM Function declaration for an intrinsic, and return it.
BinaryOp_match< LHS, RHS, Instruction::And > m_And(const LHS &L, const RHS &R)
m_Intrinsic_Ty< Opnd0 >::Ty m_BitReverse(const Opnd0 &Op0)
CastClass_match< OpTy, Instruction::ZExt > m_ZExt(const OpTy &Op)
Matches ZExt.
bool match(Val *V, const Pattern &P)
specificval_ty m_Specific(const Value *V)
Match if we have a specific specified value.
BinOpPred_match< LHS, RHS, is_logical_shift_op > m_LogicalShift(const LHS &L, const RHS &R)
Matches logical shift operations.
CastClass_match< OpTy, Instruction::Trunc > m_Trunc(const OpTy &Op)
Matches Trunc.
m_Intrinsic_Ty< Opnd0, Opnd1, Opnd2 >::Ty m_FShl(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2)
apint_match m_APInt(const APInt *&Res)
Match a ConstantInt or splatted ConstantVector, binding the specified pointer to the contained APInt.
class_match< Value > m_Value()
Match an arbitrary value and ignore it.
m_Intrinsic_Ty< Opnd0, Opnd1, Opnd2 >::Ty m_FShr(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2)
auto m_Undef()
Match an arbitrary undef constant.
BinaryOp_match< cst_pred_ty< is_all_ones >, ValTy, Instruction::Xor, true > m_Not(const ValTy &V)
Matches a 'Not' as 'xor V, -1' or 'xor -1, V'.
BinaryOp_match< LHS, RHS, Instruction::Or > m_Or(const LHS &L, const RHS &R)
m_Intrinsic_Ty< Opnd0 >::Ty m_BSwap(const Opnd0 &Op0)
is_zero m_Zero()
Match any null constant or a vector with all elements equal to 0.
match_combine_or< LTy, RTy > m_CombineOr(const LTy &L, const RTy &R)
Combine two pattern matchers matching L || R.
initializer< Ty > init(const Ty &Val)
@ DW_OP_LLVM_arg
Only used in LLVM metadata.
@ ebStrict
This corresponds to "fpexcept.strict".
This is an optimization pass for GlobalISel generic memory operations.
TinyPtrVector< DbgDeclareInst * > FindDbgDeclareUses(Value *V)
Finds dbg.declare intrinsics declaring local variables as living in the memory that 'V' points to.
auto find(R &&Range, const T &Val)
Provide wrappers to std::find which take ranges instead of having to pass begin/end explicitly.
bool RemoveRedundantDbgInstrs(BasicBlock *BB)
Try to remove redundant dbg.value instructions from given basic block.
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
bool RecursivelyDeleteTriviallyDeadInstructions(Value *V, const TargetLibraryInfo *TLI=nullptr, MemorySSAUpdater *MSSAU=nullptr, std::function< void(Value *)> AboutToDeleteCallback=std::function< void(Value *)>())
If the specified value is a trivially dead instruction, delete it.
bool succ_empty(const Instruction *I)
BasicBlock * changeToInvokeAndSplitBasicBlock(CallInst *CI, BasicBlock *UnwindEdge, DomTreeUpdater *DTU=nullptr)
Convert the CallInst to InvokeInst with the specified unwind edge basic block.
bool ConstantFoldTerminator(BasicBlock *BB, bool DeleteDeadConditions=false, const TargetLibraryInfo *TLI=nullptr, DomTreeUpdater *DTU=nullptr)
If a terminator instruction is predicated on a constant value, convert it into an unconditional branc...
std::pair< unsigned, unsigned > removeAllNonTerminatorAndEHPadInstructions(BasicBlock *BB)
Remove all instructions from a basic block other than its terminator and any present EH pad instructi...
unsigned replaceNonLocalUsesWith(Instruction *From, Value *To)
void salvageDebugInfoForDbgValues(Instruction &I, ArrayRef< DbgVariableIntrinsic * > Insns)
Implementation of salvageDebugInfo, applying only to instructions in Insns, rather than all debug use...
void salvageDebugInfo(const MachineRegisterInfo &MRI, MachineInstr &MI)
Assuming the instruction MI is going to be deleted, attempt to salvage debug users of MI by writing t...
auto successors(const MachineBasicBlock *BB)
bool isRemovableAlloc(const CallBase *V, const TargetLibraryInfo *TLI)
Return true if this is a call to an allocation function that does not have side effects that we are r...
CallInst * changeToCall(InvokeInst *II, DomTreeUpdater *DTU=nullptr)
This function converts the specified invoke into a normal call.
bool isMathLibCallNoop(const CallBase *Call, const TargetLibraryInfo *TLI)
Check whether the given call has no side-effects.
void copyMetadataForLoad(LoadInst &Dest, const LoadInst &Source)
Copy the metadata from the source instruction to the destination (the replacement for the source inst...
Interval::succ_iterator succ_begin(Interval *I)
succ_begin/succ_end - define methods so that Intervals may be used just like BasicBlocks can with the...
bool hasNItemsOrLess(IterTy &&Begin, IterTy &&End, unsigned N, Pred &&ShouldBeCounted=[](const decltype(*std::declval< IterTy >()) &) { return true;})
Returns true if the sequence [Begin, End) has N or less items.
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 SimplifyInstructionsInBlock(BasicBlock *BB, const TargetLibraryInfo *TLI=nullptr)
Scan the specified basic block and try to simplify any instructions in it and recursively delete dead...
bool isAssumeWithEmptyBundle(const AssumeInst &Assume)
Return true iff the operand bundles of the provided llvm.assume doesn't contain any valuable informat...
void DeleteDeadBlock(BasicBlock *BB, DomTreeUpdater *DTU=nullptr, bool KeepOneInputPHIs=false)
Delete the specified block, which must have no predecessors.
void insertDebugValuesForPHIs(BasicBlock *BB, SmallVectorImpl< PHINode * > &InsertedPHIs)
Propagate dbg.value intrinsics through the newly inserted PHIs.
ConstantRange getConstantRangeFromMetadata(const MDNode &RangeMD)
Parse out a conservative ConstantRange from !range metadata.
MDNode * intersectAccessGroups(const Instruction *Inst1, const Instruction *Inst2)
Compute the access-group list of access groups that Inst1 and Inst2 are both in.
bool canSimplifyInvokeNoUnwind(const Function *F)
Value * simplifyInstruction(Instruction *I, const SimplifyQuery &Q)
See if we can compute a simplified version of this instruction.
Interval::pred_iterator pred_end(Interval *I)
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
bool isInstructionTriviallyDead(Instruction *I, const TargetLibraryInfo *TLI=nullptr)
Return true if the result produced by the instruction is not used, and the instruction will return.
bool TryToSimplifyUncondBranchFromEmptyBlock(BasicBlock *BB, DomTreeUpdater *DTU=nullptr)
BB is known to contain an unconditional branch, and contains no instructions other than PHI nodes,...
void findDbgUsers(SmallVectorImpl< DbgVariableIntrinsic * > &DbgInsts, Value *V)
Finds the debug info intrinsics describing a value.
bool recognizeBSwapOrBitReverseIdiom(Instruction *I, bool MatchBSwaps, bool MatchBitReversals, SmallVectorImpl< Instruction * > &InsertedInsts)
Try to match a bswap or bitreverse idiom.
MDNode * getValidBranchWeightMDNode(const Instruction &I)
Get the valid branch weights metadata node.
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.
bool wouldInstructionBeTriviallyDeadOnUnusedPaths(Instruction *I, const TargetLibraryInfo *TLI=nullptr)
Return true if the result produced by the instruction has no side effects on any paths other than whe...
bool LowerDbgDeclare(Function &F)
Lowers llvm.dbg.declare intrinsics into appropriate set of llvm.dbg.value intrinsics.
bool NullPointerIsDefined(const Function *F, unsigned AS=0)
Check whether null pointer dereferencing is considered undefined behavior for a given function or an ...
CallInst * createCallMatchingInvoke(InvokeInst *II)
Create a call that matches the invoke II in terms of arguments, attributes, debug information,...
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Interval::pred_iterator pred_begin(Interval *I)
pred_begin/pred_end - define methods so that Intervals may be used just like BasicBlocks can with the...
Instruction * removeUnwindEdge(BasicBlock *BB, DomTreeUpdater *DTU=nullptr)
Replace 'BB's terminator with one that does not have an unwind successor block.
bool wouldInstructionBeTriviallyDead(const Instruction *I, const TargetLibraryInfo *TLI=nullptr)
Return true if the result produced by the instruction would have no side effects if it was not used.
void patchReplacementInstruction(Instruction *I, Value *Repl)
Patch the replacement so that it is not more restrictive than the value being replaced.
DebugLoc getDebugValueLoc(DbgVariableIntrinsic *DII)
Produce a DebugLoc to use for each dbg.declare that is promoted to a dbg.value.
void findDbgValues(SmallVectorImpl< DbgValueInst * > &DbgValues, Value *V)
Finds the llvm.dbg.value intrinsics describing a value.
void ConvertDebugDeclareToDebugValue(DbgVariableIntrinsic *DII, StoreInst *SI, DIBuilder &Builder)
===------------------------------------------------------------------—===// Dbg Intrinsic utilities
unsigned replaceDominatedUsesWith(Value *From, Value *To, DominatorTree &DT, const BasicBlockEdge &Edge)
Replace each use of 'From' with 'To' if that use is dominated by the given edge.
void combineMetadata(Instruction *K, const Instruction *J, ArrayRef< unsigned > KnownIDs, bool DoesKMove)
Combine the metadata of two instructions so that K can replace J.
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...
bool replaceAllDbgUsesWith(Instruction &From, Value &To, Instruction &DomPoint, DominatorTree &DT)
Point debug users of From to To or salvage them.
Value * salvageDebugInfoImpl(Instruction &I, uint64_t CurrentLocOps, SmallVectorImpl< uint64_t > &Ops, SmallVectorImpl< Value * > &AdditionalValues)
void combineMetadataForCSE(Instruction *K, const Instruction *J, bool DoesKMove)
Combine the metadata of two instructions so that K can replace J.
void dropDebugUsers(Instruction &I)
Remove the debug intrinsic instructions for the given instruction.
@ First
Helpers to iterate all locations in the MemoryEffectsBase class.
void MergeBasicBlockIntoOnlyPred(BasicBlock *BB, DomTreeUpdater *DTU=nullptr)
BB is a block with one predecessor and its predecessor is known to have one successor (BB!...
bool replaceDbgUsesWithUndef(Instruction *I)
Replace all the uses of an SSA value in @llvm.dbg intrinsics with undef.
void hoistAllInstructionsInto(BasicBlock *DomBlock, Instruction *InsertPt, BasicBlock *BB)
Hoist all of the instructions in the IfBlock to the dominant block DomBlock, by moving its instructio...
void copyRangeMetadata(const DataLayout &DL, const LoadInst &OldLI, MDNode *N, LoadInst &NewLI)
Copy a range metadata node to a new load instruction.
void copyNonnullMetadata(const LoadInst &OldLI, MDNode *N, LoadInst &NewLI)
Copy a nonnull metadata node to a new load instruction.
void computeKnownBits(const Value *V, KnownBits &Known, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Determine which bits of V are known to be either zero or one and return them in the KnownZero/KnownOn...
bool canReplaceOperandWithVariable(const Instruction *I, unsigned OpIdx)
Given an instruction, is it legal to set operand OpIdx to a non-constant value?
void replaceDbgValueForAlloca(AllocaInst *AI, Value *NewAllocaAddress, DIBuilder &Builder, int Offset=0)
Replaces multiple llvm.dbg.value instructions when the alloca it describes is replaced with a new val...
Align tryEnforceAlignment(Value *V, Align PrefAlign, const DataLayout &DL)
If the specified pointer points to an object that we control, try to modify the object's alignment to...
Value * getFreedOperand(const CallBase *CB, const TargetLibraryInfo *TLI)
If this if a call to a free function, return the freed operand.
bool RecursivelyDeleteTriviallyDeadInstructionsPermissive(SmallVectorImpl< WeakTrackingVH > &DeadInsts, const TargetLibraryInfo *TLI=nullptr, MemorySSAUpdater *MSSAU=nullptr, std::function< void(Value *)> AboutToDeleteCallback=std::function< void(Value *)>())
Same functionality as RecursivelyDeleteTriviallyDeadInstructions, but allow instructions that are not...
constexpr unsigned BitWidth
bool extractBranchWeights(const MDNode *ProfileData, SmallVectorImpl< uint32_t > &Weights)
Extract branch weights from MD_prof metadata.
auto count_if(R &&Range, UnaryPredicate P)
Wrapper function around std::count_if to count the number of times an element satisfying a given pred...
BasicBlock * SplitBlock(BasicBlock *Old, BasicBlock::iterator SplitPt, DominatorTree *DT, LoopInfo *LI=nullptr, MemorySSAUpdater *MSSAU=nullptr, const Twine &BBName="", bool Before=false)
Split the specified block at the specified instruction.
gep_type_iterator gep_type_begin(const User *GEP)
auto predecessors(const MachineBasicBlock *BB)
bool is_contained(R &&Range, const E &Element)
Returns true if Element is found in Range.
bool RecursivelyDeleteDeadPHINode(PHINode *PN, const TargetLibraryInfo *TLI=nullptr, MemorySSAUpdater *MSSAU=nullptr)
If the specified value is an effectively dead PHI node, due to being a def-use chain of single-use no...
bool inferAttributesFromOthers(Function &F)
If we can infer one attribute from another on the declaration of a function, explicitly materialize t...
Value * invertCondition(Value *Condition)
Invert the given true/false value, possibly reusing an existing copy.
hash_code hash_combine(const Ts &...args)
Combine values into a single hash_code.
void DeleteDeadBlocks(ArrayRef< BasicBlock * > BBs, DomTreeUpdater *DTU=nullptr, bool KeepOneInputPHIs=false)
Delete the specified blocks from BB.
void maybeMarkSanitizerLibraryCallNoBuiltin(CallInst *CI, const TargetLibraryInfo *TLI)
Given a CallInst, check if it calls a string function known to CodeGen, and mark it with NoBuiltin if...
unsigned pred_size(const MachineBasicBlock *BB)
bool removeUnreachableBlocks(Function &F, DomTreeUpdater *DTU=nullptr, MemorySSAUpdater *MSSAU=nullptr)
Remove all blocks that can not be reached from the function's entry.
bool EliminateDuplicatePHINodes(BasicBlock *BB)
Check for and eliminate duplicate PHI nodes in this block.
bool callsGCLeafFunction(const CallBase *Call, const TargetLibraryInfo &TLI)
Return true if this call calls a gc leaf function.
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last)
Compute a hash_code for a sequence of values.
bool replaceDbgDeclare(Value *Address, Value *NewAddress, DIBuilder &Builder, uint8_t DIExprFlags, int Offset)
Replaces llvm.dbg.declare instruction when the address it describes is replaced with a new value.
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.
An information struct used to provide DenseMap with the various necessary components for a given valu...
unsigned countMinTrailingZeros() const
Returns the minimum number of trailing zero bits.
unsigned getBitWidth() const
Get the bit width of this value.
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.