59#include "llvm/IR/IntrinsicsWebAssembly.h"
92#define DEBUG_TYPE "local"
94STATISTIC(NumRemoved,
"Number of unreachable basic blocks removed");
95STATISTIC(NumPHICSEs,
"Number of PHI's that got CSE'd");
99#ifdef EXPENSIVE_CHECKS
105 cl::desc(
"Perform extra assertion checking to verify that PHINodes's hash "
106 "function is well-behaved w.r.t. its isEqual predicate"));
111 "When the basic block contains not more than this number of PHI nodes, "
112 "perform a (faster!) exhaustive search instead of set-driven one."));
136 if (
auto *BI = dyn_cast<BranchInst>(
T)) {
137 if (BI->isUnconditional())
return false;
142 if (Dest2 == Dest1) {
148 assert(BI->getParent() &&
"Terminator not inserted in block!");
155 NewBI->
copyMetadata(*BI, {LLVMContext::MD_loop, LLVMContext::MD_dbg,
156 LLVMContext::MD_annotation});
159 BI->eraseFromParent();
160 if (DeleteDeadConditions)
165 if (
auto *
Cond = dyn_cast<ConstantInt>(BI->getCondition())) {
179 NewBI->
copyMetadata(*BI, {LLVMContext::MD_loop, LLVMContext::MD_dbg,
180 LLVMContext::MD_annotation});
182 BI->eraseFromParent();
184 DTU->
applyUpdates({{DominatorTree::Delete, BB, OldDest}});
191 if (
auto *SI = dyn_cast<SwitchInst>(
T)) {
194 auto *CI = dyn_cast<ConstantInt>(SI->getCondition());
195 BasicBlock *DefaultDest = SI->getDefaultDest();
200 SI->getNumCases() > 0) {
201 TheOnlyDest = SI->case_begin()->getCaseSuccessor();
204 bool Changed =
false;
207 for (
auto It = SI->case_begin(),
End = SI->case_end(); It !=
End;) {
209 if (It->getCaseValue() == CI) {
210 TheOnlyDest = It->getCaseSuccessor();
216 if (It->getCaseSuccessor() == DefaultDest) {
218 unsigned NCases = SI->getNumCases();
221 if (NCases > 1 && MD) {
227 unsigned Idx = It->getCaseIndex();
229 Weights[0] += Weights[
Idx + 1];
238 It = SI->removeCase(It);
239 End = SI->case_end();
243 if (
auto *NewCI = dyn_cast<ConstantInt>(SI->getCondition())) {
245 It = SI->case_begin();
255 if (It->getCaseSuccessor() != TheOnlyDest)
256 TheOnlyDest =
nullptr;
262 if (CI && !TheOnlyDest) {
265 TheOnlyDest = SI->getDefaultDest();
280 if (DTU && Succ != TheOnlyDest)
281 RemovedSuccessors.
insert(Succ);
283 if (Succ == SuccToKeep) {
284 SuccToKeep =
nullptr;
292 SI->eraseFromParent();
293 if (DeleteDeadConditions)
296 std::vector<DominatorTree::UpdateType> Updates;
297 Updates.reserve(RemovedSuccessors.
size());
298 for (
auto *RemovedSuccessor : RemovedSuccessors)
299 Updates.push_back({DominatorTree::Delete, BB, RemovedSuccessor});
305 if (SI->getNumCases() == 1) {
308 auto FirstCase = *SI->case_begin();
310 FirstCase.getCaseValue(),
"cond");
314 FirstCase.getCaseSuccessor(),
315 SI->getDefaultDest());
327 MDNode *MakeImplicitMD = SI->getMetadata(LLVMContext::MD_make_implicit);
329 NewBr->
setMetadata(LLVMContext::MD_make_implicit, MakeImplicitMD);
332 SI->eraseFromParent();
338 if (
auto *IBI = dyn_cast<IndirectBrInst>(
T)) {
341 dyn_cast<BlockAddress>(IBI->getAddress()->stripPointerCasts())) {
342 BasicBlock *TheOnlyDest = BA->getBasicBlock();
349 for (
unsigned i = 0, e = IBI->getNumDestinations(); i != e; ++i) {
351 if (DTU && DestBB != TheOnlyDest)
352 RemovedSuccessors.
insert(DestBB);
353 if (IBI->getDestination(i) == SuccToKeep) {
354 SuccToKeep =
nullptr;
359 Value *Address = IBI->getAddress();
360 IBI->eraseFromParent();
361 if (DeleteDeadConditions)
368 BA->destroyConstant();
379 std::vector<DominatorTree::UpdateType> Updates;
380 Updates.reserve(RemovedSuccessors.
size());
381 for (
auto *RemovedSuccessor : RemovedSuccessors)
382 Updates.push_back({DominatorTree::Delete, BB, RemovedSuccessor});
411 if (II->getIntrinsicID() == Intrinsic::stacksave ||
412 II->getIntrinsicID() == Intrinsic::launder_invariant_group ||
413 II->isLifetimeStartOrEnd())
420 if (
I->isTerminator())
429 if (isa<DbgVariableIntrinsic>(
I))
438 if (
auto *CB = dyn_cast<CallBase>(
I))
442 if (!
I->willReturn()) {
443 auto *II = dyn_cast<IntrinsicInst>(
I);
447 switch (II->getIntrinsicID()) {
448 case Intrinsic::experimental_guard: {
452 auto *
Cond = dyn_cast<ConstantInt>(II->getArgOperand(0));
457 case Intrinsic::wasm_trunc_signed:
458 case Intrinsic::wasm_trunc_unsigned:
459 case Intrinsic::ptrauth_auth:
460 case Intrinsic::ptrauth_resign:
467 if (!
I->mayHaveSideEffects())
474 if (II->getIntrinsicID() == Intrinsic::stacksave ||
475 II->getIntrinsicID() == Intrinsic::launder_invariant_group)
480 if (II->getIntrinsicID() == Intrinsic::allow_runtime_check ||
481 II->getIntrinsicID() == Intrinsic::allow_ubsan_check)
484 if (II->isLifetimeStartOrEnd()) {
485 auto *Arg = II->getArgOperand(1);
487 if (isa<UndefValue>(Arg))
491 if (isa<AllocaInst>(Arg) || isa<GlobalValue>(Arg) || isa<Argument>(Arg))
493 if (IntrinsicInst *IntrinsicUse =
494 dyn_cast<IntrinsicInst>(Use.getUser()))
495 return IntrinsicUse->isLifetimeStartOrEnd();
502 if (II->getIntrinsicID() == Intrinsic::assume &&
505 return !
Cond->isZero();
510 if (
auto *FPI = dyn_cast<ConstrainedFPIntrinsic>(
I)) {
511 std::optional<fp::ExceptionBehavior> ExBehavior =
512 FPI->getExceptionBehavior();
517 if (
auto *Call = dyn_cast<CallBase>(
I)) {
519 if (
Constant *
C = dyn_cast<Constant>(FreedOp))
520 return C->isNullValue() || isa<UndefValue>(
C);
526 if (
auto *LI = dyn_cast<LoadInst>(
I))
527 if (
auto *GV = dyn_cast<GlobalVariable>(
528 LI->getPointerOperand()->stripPointerCasts()))
529 if (!LI->isVolatile() && GV->isConstant())
541 std::function<
void(
Value *)> AboutToDeleteCallback) {
549 AboutToDeleteCallback);
557 std::function<
void(
Value *)> AboutToDeleteCallback) {
558 unsigned S = 0, E = DeadInsts.
size(), Alive = 0;
559 for (; S != E; ++S) {
560 auto *
I = dyn_cast_or_null<Instruction>(DeadInsts[S]);
562 DeadInsts[S] =
nullptr;
569 AboutToDeleteCallback);
576 std::function<
void(
Value *)> AboutToDeleteCallback) {
578 while (!DeadInsts.
empty()) {
584 "Live instruction found in dead worklist!");
585 assert(
I->use_empty() &&
"Instructions with uses are not dead.");
590 if (AboutToDeleteCallback)
591 AboutToDeleteCallback(
I);
595 for (
Use &OpU :
I->operands()) {
596 Value *OpV = OpU.get();
612 I->eraseFromParent();
620 for (
auto *DII : DbgUsers)
621 DII->setKillLocation();
622 for (
auto *DVR : DPUsers)
623 DVR->setKillLocation();
638 for (++UI; UI != UE; ++UI) {
655 I = cast<Instruction>(*
I->user_begin())) {
661 if (!Visited.
insert(
I).second) {
681 for (
unsigned i = 0, e =
I->getNumOperands(); i != e; ++i) {
682 Value *OpV =
I->getOperand(i);
683 I->setOperand(i,
nullptr);
696 I->eraseFromParent();
704 for (
User *U :
I->users()) {
706 WorkList.
insert(cast<Instruction>(U));
711 bool Changed =
false;
712 if (!
I->use_empty()) {
713 I->replaceAllUsesWith(SimpleV);
717 I->eraseFromParent();
732 bool MadeChange =
false;
749 assert(!BI->isTerminator());
759 while (!WorkList.
empty()) {
774 while (
PHINode *PN = dyn_cast<PHINode>(DestBB->
begin())) {
775 Value *NewVal = PN->getIncomingValue(0);
778 PN->replaceAllUsesWith(NewVal);
779 PN->eraseFromParent();
783 assert(PredBB &&
"Block doesn't have a single predecessor!");
797 if (PredOfPredBB != PredBB)
798 if (SeenPreds.
insert(PredOfPredBB).second)
799 Updates.
push_back({DominatorTree::Insert, PredOfPredBB, DestBB});
802 if (SeenPreds.
insert(PredOfPredBB).second)
803 Updates.
push_back({DominatorTree::Delete, PredOfPredBB, PredBB});
804 Updates.
push_back({DominatorTree::Delete, PredBB, DestBB});
834 "The successor list of PredBB isn't empty before "
835 "applying corresponding DTU updates.");
856 return First == Second || isa<UndefValue>(
First) || isa<UndefValue>(Second);
887 if (BBPreds.
count(IBB) &&
891 <<
"Can't fold, phi node " << PN->
getName() <<
" in "
892 << Succ->
getName() <<
" is conflicting with "
893 << BBPN->
getName() <<
" with regard to common predecessor "
905 if (BBPreds.
count(IBB) &&
909 <<
" is conflicting with regard to common "
910 <<
"predecessor " << IBB->
getName() <<
"\n");
937 if (!isa<UndefValue>(OldVal)) {
939 IncomingValues.
find(BB)->second == OldVal) &&
940 "Expected OldVal to match incoming value from BB!");
942 IncomingValues.
insert(std::make_pair(BB, OldVal));
947 if (It != IncomingValues.
end())
return It->second;
966 if (!isa<UndefValue>(V))
967 IncomingValues.
insert(std::make_pair(BB, V));
982 if (!isa<UndefValue>(V))
continue;
991 if (It == IncomingValues.
end()) {
1004 unsigned PoisonCount =
count_if(TrueUndefOps, [&](
unsigned i) {
1007 if (PoisonCount != 0 && PoisonCount != TrueUndefOps.
size()) {
1008 for (
unsigned i : TrueUndefOps)
1023 if (BB->
phis().empty() || Succ->
phis().empty())
1032 if (BBPreds.
count(SuccPred)) {
1035 CommonPred = SuccPred;
1055 assert(OldVal &&
"No entry in PHI for Pred BB!");
1072 if (isa<PHINode>(OldVal) && cast<PHINode>(OldVal)->
getParent() == BB) {
1073 PHINode *OldValPN = cast<PHINode>(OldVal);
1082 if (PredBB == CommonPred)
1097 for (
unsigned i = 0, e = BBPreds.
size(); i != e; ++i) {
1102 if (PredBB == CommonPred)
1122 "TryToSimplifyUncondBranchFromEmptyBlock called on entry block!");
1139 bool BBPhisMergeable =
1143 if (!BBKillable && !BBPhisMergeable)
1163 while (isa<PHINode>(*BBI)) {
1164 for (
Use &U : BBI->uses()) {
1165 if (
PHINode* PN = dyn_cast<PHINode>(U.getUser())) {
1166 if (PN->getIncomingBlock(U) != BB)
1176 if (BBPhisMergeable && CommonPred)
1178 <<
" and " << Succ->
getName() <<
" : "
1179 << CommonPred->
getName() <<
"\n");
1247 if (TI->hasMetadata(LLVMContext::MD_loop))
1250 if (PredTI->hasMetadata(LLVMContext::MD_loop))
1255 else if (BBPhisMergeable)
1270 if (SeenPreds.
insert(PredOfBB).second)
1271 Updates.
push_back({DominatorTree::Insert, PredOfBB, Succ});
1279 if (SeenPreds.
insert(PredOfBB).second && PredOfBB != CommonPred)
1280 Updates.
push_back({DominatorTree::Delete, PredOfBB, BB});
1283 Updates.
push_back({DominatorTree::Delete, BB, Succ});
1286 if (isa<PHINode>(Succ->
begin())) {
1306 while (
PHINode *PN = dyn_cast<PHINode>(&BB->
front())) {
1308 assert(PN->use_empty() &&
"There shouldn't be any uses here!");
1309 PN->eraseFromParent();
1316 if (
MDNode *LoopMD = TI->getMetadata(LLVMContext::MD_loop))
1318 Pred->getTerminator()->setMetadata(LLVMContext::MD_loop, LoopMD);
1333 "applying corresponding DTU updates.");
1334 }
else if (BBPhisMergeable) {
1337 if (
Instruction *UseInst = dyn_cast<Instruction>(U.getUser()))
1338 return UseInst->
getParent() != CommonPred &&
1339 BBPreds.
contains(UseInst->getParent());
1360 bool Changed =
false;
1365 for (
auto I = BB->
begin();
PHINode *PN = dyn_cast<PHINode>(
I);) {
1370 for (
auto J =
I;
PHINode *DuplicatePN = dyn_cast<PHINode>(J); ++J) {
1371 if (
ToRemove.contains(DuplicatePN))
1396 struct PHIDenseMapInfo {
1397 static PHINode *getEmptyKey() {
1401 static PHINode *getTombstoneKey() {
1406 return PN == getEmptyKey() || PN == getTombstoneKey();
1420 static unsigned getHashValue(
PHINode *PN) {
1435 return LHS->isIdenticalTo(
RHS);
1453 bool Changed =
false;
1454 for (
auto I = BB->
begin();
PHINode *PN = dyn_cast<PHINode>(
I++);) {
1457 auto Inserted = PHISet.
insert(PN);
1458 if (!Inserted.second) {
1461 PN->replaceAllUsesWith(*Inserted.first);
1490 PN->eraseFromParent();
1496 V = V->stripPointerCasts();
1498 if (
AllocaInst *AI = dyn_cast<AllocaInst>(V)) {
1504 Align CurrentAlign = AI->getAlign();
1505 if (PrefAlign <= CurrentAlign)
1506 return CurrentAlign;
1510 if (
DL.exceedsNaturalStackAlignment(PrefAlign))
1511 return CurrentAlign;
1512 AI->setAlignment(PrefAlign);
1516 if (
auto *GO = dyn_cast<GlobalObject>(V)) {
1518 Align CurrentAlign = GO->getPointerAlignment(
DL);
1519 if (PrefAlign <= CurrentAlign)
1520 return CurrentAlign;
1526 if (!GO->canIncreaseAlignment())
1527 return CurrentAlign;
1529 if (GO->isThreadLocal()) {
1530 unsigned MaxTLSAlign = GO->getParent()->getMaxTLSAlignment() / CHAR_BIT;
1531 if (MaxTLSAlign && PrefAlign >
Align(MaxTLSAlign))
1532 PrefAlign =
Align(MaxTLSAlign);
1535 GO->setAlignment(PrefAlign);
1547 assert(V->getType()->isPointerTy() &&
1548 "getOrEnforceKnownAlignment expects a pointer!");
1560 if (PrefAlign && *PrefAlign > Alignment)
1581 for (
auto *DVI : DbgValues) {
1583 if ((DVI->getVariable() == DIVar) && (DVI->getExpression() == DIExpr))
1586 for (
auto *DVR : DbgVariableRecords) {
1588 if ((DVR->getVariable() == DIVar) && (DVR->getExpression() == DIExpr))
1604 TypeSize ValueSize =
DL.getTypeAllocSizeInBits(ValTy);
1614 "address of variable must have exactly 1 location operand.");
1617 if (std::optional<TypeSize> FragmentSize =
1618 AI->getAllocationSizeInBits(
DL)) {
1619 return TypeSize::isKnownGE(ValueSize, *FragmentSize);
1630 TypeSize ValueSize =
DL.getTypeAllocSizeInBits(ValTy);
1640 "address of variable must have exactly 1 location operand.");
1643 if (std::optional<TypeSize> FragmentSize = AI->getAllocationSizeInBits(
DL)) {
1644 return TypeSize::isKnownGE(ValueSize, *FragmentSize);
1658 auto DbgVal = Builder.insertDbgValueIntrinsic(DV, DIVar, DIExpr, NewLoc,
1667 Instr->getParent()->insertDbgRecordBefore(DV, Instr);
1675 auto DbgVal = Builder.insertDbgValueIntrinsic(DV, DIVar, DIExpr, NewLoc,
1684 Instr->getParent()->insertDbgRecordAfter(DV, &*Instr);
1694 assert(DIVar &&
"Missing variable");
1696 Value *DV = SI->getValueOperand();
1713 DIExpr->isDeref() || (!DIExpr->startsWithDeref() &&
1723 LLVM_DEBUG(
dbgs() <<
"Failed to convert dbg.declare to dbg.value: " << *DII
1739 assert(DIVar &&
"Missing variable");
1745 LLVM_DEBUG(
dbgs() <<
"Failed to convert dbg.declare to dbg.value: "
1764 assert(DIVar &&
"Missing variable");
1766 Value *DV = SI->getValueOperand();
1783 DIExpr->isDeref() || (!DIExpr->startsWithDeref() &&
1793 LLVM_DEBUG(
dbgs() <<
"Failed to convert dbg.declare to dbg.value: " << *DVR
1804 SI->getParent()->insertDbgRecordBefore(NewDVR, SI->getIterator());
1813 assert(DIVar &&
"Missing variable");
1822 LLVM_DEBUG(
dbgs() <<
"Failed to convert dbg.declare to dbg.value: "
1835 if (InsertionPt != BB->
end()) {
1845 assert(DIVar &&
"Missing variable");
1851 LLVM_DEBUG(
dbgs() <<
"Failed to convert dbg.declare to DbgVariableRecord: "
1885 assert(DIVar &&
"Missing variable");
1894 LLVM_DEBUG(
dbgs() <<
"Failed to convert dbg.declare to DbgVariableRecord: "
1907 if (InsertionPt != BB->
end()) {
1916 bool Changed =
false;
1920 for (
auto &FI :
F) {
1922 if (
auto *DDI = dyn_cast<DbgDeclareInst>(&BI))
1925 if (DVR.getType() == DbgVariableRecord::LocationType::Declare)
1934 auto LowerOne = [&](
auto *DDI) {
1936 dyn_cast_or_null<AllocaInst>(DDI->getVariableLocationOp(0));
1948 if (LoadInst *LI = dyn_cast<LoadInst>(U))
1949 return LI->isVolatile();
1950 if (StoreInst *SI = dyn_cast<StoreInst>(U))
1951 return SI->isVolatile();
1958 while (!WorkList.
empty()) {
1960 for (
const auto &AIUse : V->uses()) {
1961 User *U = AIUse.getUser();
1962 if (
StoreInst *SI = dyn_cast<StoreInst>(U)) {
1963 if (AIUse.getOperandNo() == 1)
1965 }
else if (
LoadInst *LI = dyn_cast<LoadInst>(U)) {
1967 }
else if (
CallInst *CI = dyn_cast<CallInst>(U)) {
1971 if (!CI->isLifetimeStartOrEnd()) {
1979 }
else if (
BitCastInst *BI = dyn_cast<BitCastInst>(U)) {
1980 if (BI->getType()->isPointerTy())
1985 DDI->eraseFromParent();
2005 assert(BB &&
"No BasicBlock to clone DbgVariableRecord(s) from.");
2006 if (InsertedPHIs.
size() == 0)
2011 for (
auto &
I : *BB) {
2013 for (
Value *V : DVR.location_ops())
2014 if (
auto *Loc = dyn_cast_or_null<PHINode>(V))
2015 DbgValueMap.
insert({Loc, &DVR});
2018 if (DbgValueMap.
size() == 0)
2033 for (
auto PHI : InsertedPHIs) {
2038 for (
auto VI :
PHI->operand_values()) {
2039 auto V = DbgValueMap.
find(VI);
2040 if (V != DbgValueMap.
end()) {
2042 auto NewDI = NewDbgValueMap.
find({Parent, DbgII});
2043 if (NewDI == NewDbgValueMap.
end()) {
2045 NewDI = NewDbgValueMap.
insert({{Parent, DbgII}, NewDbgII}).first;
2056 for (
auto DI : NewDbgValueMap) {
2060 assert(InsertionPt != Parent->
end() &&
"Ill-formed basic block");
2069 assert(BB &&
"No BasicBlock to clone dbg.value(s) from.");
2070 if (InsertedPHIs.
size() == 0)
2077 for (
auto &
I : *BB) {
2078 if (
auto DbgII = dyn_cast<DbgVariableIntrinsic>(&
I)) {
2079 for (
Value *V : DbgII->location_ops())
2080 if (
auto *Loc = dyn_cast_or_null<PHINode>(V))
2081 DbgValueMap.
insert({Loc, DbgII});
2084 if (DbgValueMap.
size() == 0)
2099 for (
auto *
PHI : InsertedPHIs) {
2104 for (
auto *VI :
PHI->operand_values()) {
2105 auto V = DbgValueMap.
find(VI);
2106 if (V != DbgValueMap.
end()) {
2107 auto *DbgII = cast<DbgVariableIntrinsic>(V->second);
2108 auto NewDI = NewDbgValueMap.
find({Parent, DbgII});
2109 if (NewDI == NewDbgValueMap.
end()) {
2110 auto *NewDbgII = cast<DbgVariableIntrinsic>(DbgII->clone());
2111 NewDI = NewDbgValueMap.
insert({{Parent, DbgII}, NewDbgII}).first;
2122 for (
auto DI : NewDbgValueMap) {
2124 auto *NewDbgII = DI.second;
2126 assert(InsertionPt != Parent->
end() &&
"Ill-formed basic block");
2127 NewDbgII->insertBefore(&*InsertionPt);
2132 DIBuilder &Builder, uint8_t DIExprFlags,
2137 auto ReplaceOne = [&](
auto *DII) {
2138 assert(DII->getVariable() &&
"Missing variable");
2139 auto *DIExpr = DII->getExpression();
2141 DII->setExpression(DIExpr);
2142 DII->replaceVariableLocationOp(Address, NewAddress);
2148 return !DbgDeclares.
empty() || !DVRDeclares.
empty();
2157 assert(DIVar &&
"Missing variable");
2187 for (
auto *DVI : DbgUsers)
2189 DVI->getExpression(), NewAllocaAddress, DVI,
2190 nullptr, Builder,
Offset);
2195 DVR->getExpression(), NewAllocaAddress,
nullptr,
2209 Instruction *
I = dyn_cast<Instruction>(Assign->getAddress());
2214 assert(!Assign->getAddressExpression()->getFragmentInfo().has_value() &&
2215 "address-expression shouldn't have fragment info");
2228 Assign->getAddressExpression(), Ops, 0,
false);
2230 "address-expression shouldn't have fragment info");
2233 if (AdditionalValues.
empty()) {
2234 Assign->setAddress(NewV);
2235 Assign->setAddressExpression(SalvagedExpr);
2237 Assign->setKillAddress();
2247 const unsigned MaxDebugArgs = 16;
2248 const unsigned MaxExpressionSize = 128;
2249 bool Salvaged =
false;
2251 for (
auto *DII : DbgUsers) {
2252 if (
auto *DAI = dyn_cast<DbgAssignIntrinsic>(DII)) {
2253 if (DAI->getAddress() == &
I) {
2257 if (DAI->getValue() != &
I)
2263 bool StackValue = isa<DbgValueInst>(DII);
2264 auto DIILocation = DII->location_ops();
2267 "DbgVariableIntrinsic must use salvaged instruction as its location");
2273 Value *Op0 =
nullptr;
2275 auto LocItr =
find(DIILocation, &
I);
2276 while (SalvagedExpr && LocItr != DIILocation.end()) {
2278 unsigned LocNo = std::distance(DIILocation.begin(), LocItr);
2285 LocItr = std::find(++LocItr, DIILocation.end(), &
I);
2292 DII->replaceVariableLocationOp(&
I, Op0);
2293 bool IsValidSalvageExpr = SalvagedExpr->
getNumElements() <= MaxExpressionSize;
2294 if (AdditionalValues.
empty() && IsValidSalvageExpr) {
2295 DII->setExpression(SalvagedExpr);
2296 }
else if (isa<DbgValueInst>(DII) && IsValidSalvageExpr &&
2297 DII->getNumVariableLocationOps() + AdditionalValues.
size() <=
2299 DII->addVariableLocationOps(AdditionalValues, SalvagedExpr);
2304 DII->setKillLocation();
2310 for (
auto *DVR : DPUsers) {
2311 if (DVR->isDbgAssign()) {
2312 if (DVR->getAddress() == &
I) {
2316 if (DVR->getValue() != &
I)
2324 DVR->getType() != DbgVariableRecord::LocationType::Declare;
2325 auto DVRLocation = DVR->location_ops();
2328 "DbgVariableIntrinsic must use salvaged instruction as its location");
2334 Value *Op0 =
nullptr;
2336 auto LocItr =
find(DVRLocation, &
I);
2337 while (SalvagedExpr && LocItr != DVRLocation.end()) {
2339 unsigned LocNo = std::distance(DVRLocation.begin(), LocItr);
2346 LocItr = std::find(++LocItr, DVRLocation.end(), &
I);
2353 DVR->replaceVariableLocationOp(&
I, Op0);
2354 bool IsValidSalvageExpr =
2356 if (AdditionalValues.
empty() && IsValidSalvageExpr) {
2357 DVR->setExpression(SalvagedExpr);
2358 }
else if (DVR->getType() != DbgVariableRecord::LocationType::Declare &&
2359 IsValidSalvageExpr &&
2360 DVR->getNumVariableLocationOps() + AdditionalValues.
size() <=
2362 DVR->addVariableLocationOps(AdditionalValues, SalvagedExpr);
2368 DVR->setKillLocation();
2377 for (
auto *DII : DbgUsers)
2378 DII->setKillLocation();
2380 for (
auto *DVR : DPUsers)
2381 DVR->setKillLocation();
2388 unsigned BitWidth =
DL.getIndexSizeInBits(
GEP->getPointerAddressSpace());
2392 if (!
GEP->collectOffset(
DL,
BitWidth, VariableOffsets, ConstantOffset))
2394 if (!VariableOffsets.
empty() && !CurrentLocOps) {
2395 Opcodes.
insert(Opcodes.
begin(), {dwarf::DW_OP_LLVM_arg, 0});
2398 for (
const auto &
Offset : VariableOffsets) {
2401 "Expected strictly positive multiplier for offset.");
2403 Offset.second.getZExtValue(), dwarf::DW_OP_mul,
2404 dwarf::DW_OP_plus});
2407 return GEP->getOperand(0);
2412 case Instruction::Add:
2413 return dwarf::DW_OP_plus;
2414 case Instruction::Sub:
2415 return dwarf::DW_OP_minus;
2416 case Instruction::Mul:
2417 return dwarf::DW_OP_mul;
2418 case Instruction::SDiv:
2419 return dwarf::DW_OP_div;
2420 case Instruction::SRem:
2421 return dwarf::DW_OP_mod;
2422 case Instruction::Or:
2423 return dwarf::DW_OP_or;
2424 case Instruction::And:
2425 return dwarf::DW_OP_and;
2426 case Instruction::Xor:
2427 return dwarf::DW_OP_xor;
2428 case Instruction::Shl:
2429 return dwarf::DW_OP_shl;
2430 case Instruction::LShr:
2431 return dwarf::DW_OP_shr;
2432 case Instruction::AShr:
2433 return dwarf::DW_OP_shra;
2444 if (!CurrentLocOps) {
2449 AdditionalValues.
push_back(
I->getOperand(1));
2456 auto *ConstInt = dyn_cast<ConstantInt>(BI->
getOperand(1));
2458 if (ConstInt && ConstInt->getBitWidth() > 64)
2464 uint64_t Val = ConstInt->getSExtValue();
2467 if (BinOpcode == Instruction::Add || BinOpcode == Instruction::Sub) {
2468 uint64_t Offset = BinOpcode == Instruction::Add ? Val : -int64_t(Val);
2472 Opcodes.
append({dwarf::DW_OP_constu, Val});
2491 return dwarf::DW_OP_eq;
2493 return dwarf::DW_OP_ne;
2496 return dwarf::DW_OP_gt;
2499 return dwarf::DW_OP_ge;
2502 return dwarf::DW_OP_lt;
2505 return dwarf::DW_OP_le;
2515 auto *ConstInt = dyn_cast<ConstantInt>(Icmp->
getOperand(1));
2517 if (ConstInt && ConstInt->getBitWidth() > 64)
2525 uint64_t Val = ConstInt->getSExtValue();
2543 auto &M = *
I.getModule();
2544 auto &
DL = M.getDataLayout();
2546 if (
auto *CI = dyn_cast<CastInst>(&
I)) {
2547 Value *FromValue = CI->getOperand(0);
2549 if (CI->isNoopCast(
DL)) {
2558 !(isa<TruncInst>(&
I) || isa<SExtInst>(&
I) || isa<ZExtInst>(&
I) ||
2559 isa<IntToPtrInst>(&
I) || isa<PtrToIntInst>(&
I)))
2563 if (FromType->isPointerTy())
2564 FromType =
DL.getIntPtrType(FromType);
2566 unsigned FromTypeBitSize = FromType->getScalarSizeInBits();
2571 Ops.
append(ExtOps.begin(), ExtOps.end());
2575 if (
auto *
GEP = dyn_cast<GetElementPtrInst>(&
I))
2577 if (
auto *BI = dyn_cast<BinaryOperator>(&
I))
2579 if (
auto *IC = dyn_cast<ICmpInst>(&
I))
2606 bool Changed =
false;
2610 if (isa<Instruction>(&To)) {
2611 bool DomPointAfterFrom =
From.getNextNonDebugInstruction() == &DomPoint;
2613 for (
auto *DII :
Users) {
2623 }
else if (!DT.
dominates(&DomPoint, DII)) {
2624 UndefOrSalvage.
insert(DII);
2629 for (
auto *DVR : DPUsers) {
2633 if (isa<DbgVariableIntrinsic>(NextNonDebug))
2636 if (DomPointAfterFrom && NextNonDebug == &DomPoint) {
2642 }
else if (!DT.
dominates(&DomPoint, MarkedInstr)) {
2643 UndefOrSalvageDVR.
insert(DVR);
2649 for (
auto *DII :
Users) {
2650 if (UndefOrSalvage.
count(DII))
2662 for (
auto *DVR : DPUsers) {
2663 if (UndefOrSalvageDVR.
count(DVR))
2676 if (!UndefOrSalvage.
empty() || !UndefOrSalvageDVR.
empty()) {
2700 bool SameSize =
DL.getTypeSizeInBits(FromTy) ==
DL.getTypeSizeInBits(ToTy);
2701 bool LosslessConversion = !
DL.isNonIntegralPointerType(FromTy) &&
2702 !
DL.isNonIntegralPointerType(ToTy);
2703 return SameSize && LosslessConversion;
2713 if (!
From.isUsedByMetadata())
2716 assert(&
From != &To &&
"Can't replace something with itself");
2725 return DVR.getExpression();
2739 assert(FromBits != ToBits &&
"Unexpected no-op conversion");
2743 if (FromBits < ToBits)
2754 return std::nullopt;
2756 bool Signed = *Signedness == DIBasicType::Signedness::Signed;
2768 return std::nullopt;
2770 bool Signed = *Signedness == DIBasicType::Signedness::Signed;
2784 bool Changed =
false;
2786 I->dropDbgRecords();
2787 for (
Use &U :
I->operands()) {
2789 if (isa<Instruction>(
Op) && !
Op->getType()->isTokenTy()) {
2799std::pair<unsigned, unsigned>
2801 unsigned NumDeadInst = 0;
2802 unsigned NumDeadDbgInst = 0;
2809 while (EndInst != &BB->
front()) {
2821 if (isa<DbgInfoIntrinsic>(Inst))
2829 return {NumDeadInst, NumDeadDbgInst};
2845 Successor->removePredecessor(BB, PreserveLCSSA);
2850 UI->setDebugLoc(
I->getDebugLoc());
2853 unsigned NumInstrsRemoved = 0;
2855 while (BBI != BBE) {
2856 if (!BBI->use_empty())
2858 BBI++->eraseFromParent();
2864 for (
BasicBlock *UniqueSuccessor : UniqueSuccessors)
2865 Updates.
push_back({DominatorTree::Delete, BB, UniqueSuccessor});
2869 return NumInstrsRemoved;
2888 auto NewWeights =
uint32_t(TotalWeight) != TotalWeight
2891 NewCall->
setMetadata(LLVMContext::MD_prof, NewWeights);
2914 DTU->
applyUpdates({{DominatorTree::Delete, BB, UnwindDestBB}});
2943 UnwindEdge, InvokeArgs, OpBundles, CI->
getName(), BB);
2950 DTU->
applyUpdates({{DominatorTree::Insert, BB, UnwindEdge}});
2957 Split->front().eraseFromParent();
2968 bool Changed =
false;
2976 if (
auto *CI = dyn_cast<CallInst>(&
I)) {
2977 Value *Callee = CI->getCalledOperand();
2979 if (
Function *
F = dyn_cast<Function>(Callee)) {
2980 auto IntrinsicID =
F->getIntrinsicID();
2985 if (IntrinsicID == Intrinsic::assume) {
2992 }
else if (IntrinsicID == Intrinsic::experimental_guard) {
3003 if (!isa<UnreachableInst>(CI->getNextNode())) {
3009 }
else if ((isa<ConstantPointerNull>(Callee) &&
3011 cast<PointerType>(Callee->getType())
3012 ->getAddressSpace())) ||
3013 isa<UndefValue>(Callee)) {
3018 if (CI->doesNotReturn() && !CI->isMustTailCall()) {
3022 if (!isa<UnreachableInst>(CI->getNextNonDebugInstruction())) {
3029 }
else if (
auto *SI = dyn_cast<StoreInst>(&
I)) {
3035 if (SI->isVolatile())
continue;
3039 if (isa<UndefValue>(
Ptr) ||
3040 (isa<ConstantPointerNull>(
Ptr) &&
3042 SI->getPointerAddressSpace()))) {
3051 if (
auto *II = dyn_cast<InvokeInst>(Terminator)) {
3053 Value *Callee = II->getCalledOperand();
3054 if ((isa<ConstantPointerNull>(Callee) &&
3056 isa<UndefValue>(Callee)) {
3060 if (II->doesNotReturn() &&
3061 !isa<UnreachableInst>(II->getNormalDest()->front())) {
3067 BasicBlock *OrigNormalDest = II->getNormalDest();
3071 Ctx, OrigNormalDest->
getName() +
".unreachable",
3072 II->getFunction(), OrigNormalDest);
3074 II->setNormalDest(UnreachableNormalDest);
3077 {{DominatorTree::Delete, BB, OrigNormalDest},
3078 {DominatorTree::Insert, BB, UnreachableNormalDest}});
3082 if (II->use_empty() && !II->mayHaveSideEffects()) {
3084 BasicBlock *NormalDestBB = II->getNormalDest();
3085 BasicBlock *UnwindDestBB = II->getUnwindDest();
3088 II->eraseFromParent();
3090 DTU->applyUpdates({{DominatorTree::Delete, BB, UnwindDestBB}});
3096 }
else if (
auto *CatchSwitch = dyn_cast<CatchSwitchInst>(Terminator)) {
3098 struct CatchPadDenseMapInfo {
3113 if (
LHS == getEmptyKey() ||
LHS == getTombstoneKey() ||
3114 RHS == getEmptyKey() ||
RHS == getTombstoneKey())
3116 return LHS->isIdenticalTo(
RHS);
3127 E = CatchSwitch->handler_end();
3131 ++NumPerSuccessorCases[HandlerBB];
3132 auto *CatchPad = cast<CatchPadInst>(HandlerBB->
getFirstNonPHI());
3133 if (!HandlerSet.insert({CatchPad, Empty}).second) {
3135 --NumPerSuccessorCases[HandlerBB];
3136 CatchSwitch->removeHandler(
I);
3143 std::vector<DominatorTree::UpdateType> Updates;
3144 for (
const std::pair<BasicBlock *, int> &
I : NumPerSuccessorCases)
3146 Updates.push_back({DominatorTree::Delete, BB,
I.first});
3147 DTU->applyUpdates(Updates);
3155 }
while (!Worklist.
empty());
3162 if (
auto *II = dyn_cast<InvokeInst>(TI))
3168 if (
auto *CRI = dyn_cast<CleanupReturnInst>(TI)) {
3170 UnwindDest = CRI->getUnwindDest();
3171 }
else if (
auto *CatchSwitch = dyn_cast<CatchSwitchInst>(TI)) {
3173 CatchSwitch->getParentPad(),
nullptr, CatchSwitch->getNumHandlers(),
3174 CatchSwitch->getName(), CatchSwitch->getIterator());
3175 for (
BasicBlock *PadBB : CatchSwitch->handlers())
3176 NewCatchSwitch->addHandler(PadBB);
3178 NewTI = NewCatchSwitch;
3179 UnwindDest = CatchSwitch->getUnwindDest();
3190 DTU->
applyUpdates({{DominatorTree::Delete, BB, UnwindDest}});
3203 if (Reachable.
size() ==
F.size())
3212 if (Reachable.
count(&BB))
3217 BlocksToRemove.
insert(&BB);
3220 if (BlocksToRemove.
empty())
3224 NumRemoved += BlocksToRemove.
size();
3237 K->dropUnknownNonDebugMetadata(KnownIDs);
3238 K->getAllMetadataOtherThanDebugLoc(
Metadata);
3240 unsigned Kind = MD.first;
3246 K->setMetadata(Kind,
nullptr);
3248 case LLVMContext::MD_dbg:
3250 case LLVMContext::MD_DIAssignID:
3251 K->mergeDIAssignID(J);
3253 case LLVMContext::MD_tbaa:
3256 case LLVMContext::MD_alias_scope:
3259 case LLVMContext::MD_noalias:
3260 case LLVMContext::MD_mem_parallel_loop_access:
3263 case LLVMContext::MD_access_group:
3264 K->setMetadata(LLVMContext::MD_access_group,
3267 case LLVMContext::MD_range:
3268 if (DoesKMove || !K->hasMetadata(LLVMContext::MD_noundef))
3271 case LLVMContext::MD_fpmath:
3274 case LLVMContext::MD_invariant_load:
3278 K->setMetadata(Kind, JMD);
3280 case LLVMContext::MD_nonnull:
3281 if (DoesKMove || !K->hasMetadata(LLVMContext::MD_noundef))
3282 K->setMetadata(Kind, JMD);
3284 case LLVMContext::MD_invariant_group:
3287 case LLVMContext::MD_align:
3288 if (DoesKMove || !K->hasMetadata(LLVMContext::MD_noundef))
3292 case LLVMContext::MD_dereferenceable:
3293 case LLVMContext::MD_dereferenceable_or_null:
3295 K->setMetadata(Kind,
3298 case LLVMContext::MD_preserve_access_index:
3301 case LLVMContext::MD_noundef:
3304 K->setMetadata(Kind, JMD);
3306 case LLVMContext::MD_nontemporal:
3308 K->setMetadata(Kind, JMD);
3310 case LLVMContext::MD_prof:
3322 if (
auto *JMD = J->
getMetadata(LLVMContext::MD_invariant_group))
3323 if (isa<LoadInst>(K) || isa<StoreInst>(K))
3324 K->setMetadata(LLVMContext::MD_invariant_group, JMD);
3329 unsigned KnownIDs[] = {LLVMContext::MD_tbaa,
3330 LLVMContext::MD_alias_scope,
3331 LLVMContext::MD_noalias,
3332 LLVMContext::MD_range,
3333 LLVMContext::MD_fpmath,
3334 LLVMContext::MD_invariant_load,
3335 LLVMContext::MD_nonnull,
3336 LLVMContext::MD_invariant_group,
3337 LLVMContext::MD_align,
3338 LLVMContext::MD_dereferenceable,
3339 LLVMContext::MD_dereferenceable_or_null,
3340 LLVMContext::MD_access_group,
3341 LLVMContext::MD_preserve_access_index,
3342 LLVMContext::MD_prof,
3343 LLVMContext::MD_nontemporal,
3344 LLVMContext::MD_noundef};
3350 Source.getAllMetadata(MD);
3353 const DataLayout &
DL = Source.getModule()->getDataLayout();
3354 for (
const auto &MDPair : MD) {
3355 unsigned ID = MDPair.first;
3365 case LLVMContext::MD_dbg:
3366 case LLVMContext::MD_tbaa:
3367 case LLVMContext::MD_prof:
3368 case LLVMContext::MD_fpmath:
3369 case LLVMContext::MD_tbaa_struct:
3370 case LLVMContext::MD_invariant_load:
3371 case LLVMContext::MD_alias_scope:
3372 case LLVMContext::MD_noalias:
3373 case LLVMContext::MD_nontemporal:
3374 case LLVMContext::MD_mem_parallel_loop_access:
3375 case LLVMContext::MD_access_group:
3376 case LLVMContext::MD_noundef:
3381 case LLVMContext::MD_nonnull:
3385 case LLVMContext::MD_align:
3386 case LLVMContext::MD_dereferenceable:
3387 case LLVMContext::MD_dereferenceable_or_null:
3393 case LLVMContext::MD_range:
3401 auto *ReplInst = dyn_cast<Instruction>(Repl);
3410 if (isa<OverflowingBinaryOperator>(ReplInst) &&
3417 else if (!isa<LoadInst>(
I))
3418 ReplInst->andIRFlags(
I);
3432template <
typename RootType,
typename DominatesFn>
3434 const RootType &Root,
3435 const DominatesFn &Dominates) {
3440 if (!Dominates(Root, U))
3444 dbgs() <<
"' with " << *To <<
" in " << *U.getUser() <<
"\n");
3453 auto *BB =
From->getParent();
3457 auto *
I = cast<Instruction>(U.getUser());
3458 if (
I->getParent() == BB)
3472 return ::replaceDominatedUsesWith(
From, To, Root, Dominates);
3478 auto Dominates = [&DT](
const BasicBlock *BB,
const Use &U) {
3481 return ::replaceDominatedUsesWith(
From, To, BB, Dominates);
3487 if (Call->hasFnAttr(
"gc-leaf-function"))
3489 if (
const Function *
F = Call->getCalledFunction()) {
3490 if (
F->hasFnAttribute(
"gc-leaf-function"))
3493 if (
auto IID =
F->getIntrinsicID()) {
3495 return IID != Intrinsic::experimental_gc_statepoint &&
3496 IID != Intrinsic::experimental_deoptimize &&
3497 IID != Intrinsic::memcpy_element_unordered_atomic &&
3498 IID != Intrinsic::memmove_element_unordered_atomic;
3515 auto *NewTy = NewLI.
getType();
3518 if (NewTy->isPointerTy()) {
3525 if (!NewTy->isIntegerTy())
3530 auto *ITy = cast<IntegerType>(NewTy);
3540 auto *NewTy = NewLI.
getType();
3542 if (NewTy == OldLI.
getType()) {
3551 if (!NewTy->isPointerTy())
3554 unsigned BitWidth =
DL.getPointerTypeSizeInBits(NewTy);
3566 for (
auto *DII : DbgUsers)
3568 for (
auto *DVR : DPUsers)
3569 DVR->eraseFromParent();
3598 I->dropUBImplyingAttrsAndMetadata();
3599 if (
I->isUsedByMetadata())
3602 I->dropDbgRecords();
3603 if (
I->isDebugOrPseudoInst()) {
3605 II =
I->eraseFromParent();
3619 const APInt &API = cast<ConstantInt>(&CV)->getValue();
3620 std::optional<int64_t> InitIntOpt = API.
trySExtValue();
3622 static_cast<uint64_t>(*InitIntOpt))
3626 if (isa<ConstantInt>(
C))
3627 return createIntegerExpression(
C);
3629 auto *
FP = dyn_cast<ConstantFP>(&
C);
3641 if (isa<ConstantPointerNull>(
C))
3645 if (CE->getOpcode() == Instruction::IntToPtr) {
3646 const Value *V = CE->getOperand(0);
3647 if (
auto CI = dyn_cast_or_null<ConstantInt>(V))
3648 return createIntegerExpression(*CI);
3658 BitPart(
Value *
P,
unsigned BW) : Provider(
P) {
3659 Provenance.resize(BW);
3669 enum { Unset = -1 };
3701static const std::optional<BitPart> &
3703 std::map<
Value *, std::optional<BitPart>> &BPS,
int Depth,
3705 auto I = BPS.find(V);
3709 auto &Result = BPS[V] = std::nullopt;
3710 auto BitWidth = V->getType()->getScalarSizeInBits();
3718 LLVM_DEBUG(
dbgs() <<
"collectBitParts max recursion depth reached.\n");
3722 if (
auto *
I = dyn_cast<Instruction>(V)) {
3730 Depth + 1, FoundRoot);
3731 if (!
A || !
A->Provider)
3735 Depth + 1, FoundRoot);
3736 if (!
B ||
A->Provider !=
B->Provider)
3740 Result = BitPart(
A->Provider,
BitWidth);
3741 for (
unsigned BitIdx = 0; BitIdx <
BitWidth; ++BitIdx) {
3742 if (
A->Provenance[BitIdx] != BitPart::Unset &&
3743 B->Provenance[BitIdx] != BitPart::Unset &&
3744 A->Provenance[BitIdx] !=
B->Provenance[BitIdx])
3745 return Result = std::nullopt;
3747 if (
A->Provenance[BitIdx] == BitPart::Unset)
3748 Result->Provenance[BitIdx] =
B->Provenance[BitIdx];
3750 Result->Provenance[BitIdx] =
A->Provenance[BitIdx];
3758 const APInt &BitShift = *
C;
3765 if (!MatchBitReversals && (BitShift.
getZExtValue() % 8) != 0)
3769 Depth + 1, FoundRoot);
3775 auto &
P = Result->Provenance;
3776 if (
I->getOpcode() == Instruction::Shl) {
3790 const APInt &AndMask = *
C;
3794 unsigned NumMaskedBits = AndMask.
popcount();
3795 if (!MatchBitReversals && (NumMaskedBits % 8) != 0)
3799 Depth + 1, FoundRoot);
3804 for (
unsigned BitIdx = 0; BitIdx <
BitWidth; ++BitIdx)
3806 if (AndMask[BitIdx] == 0)
3807 Result->Provenance[BitIdx] = BitPart::Unset;
3814 Depth + 1, FoundRoot);
3818 Result = BitPart(Res->Provider,
BitWidth);
3819 auto NarrowBitWidth =
X->getType()->getScalarSizeInBits();
3820 for (
unsigned BitIdx = 0; BitIdx < NarrowBitWidth; ++BitIdx)
3821 Result->Provenance[BitIdx] = Res->Provenance[BitIdx];
3822 for (
unsigned BitIdx = NarrowBitWidth; BitIdx <
BitWidth; ++BitIdx)
3823 Result->Provenance[BitIdx] = BitPart::Unset;
3830 Depth + 1, FoundRoot);
3834 Result = BitPart(Res->Provider,
BitWidth);
3835 for (
unsigned BitIdx = 0; BitIdx <
BitWidth; ++BitIdx)
3836 Result->Provenance[BitIdx] = Res->Provenance[BitIdx];
3844 Depth + 1, FoundRoot);
3848 Result = BitPart(Res->Provider,
BitWidth);
3849 for (
unsigned BitIdx = 0; BitIdx <
BitWidth; ++BitIdx)
3850 Result->Provenance[(
BitWidth - 1) - BitIdx] = Res->Provenance[BitIdx];
3857 Depth + 1, FoundRoot);
3862 Result = BitPart(Res->Provider,
BitWidth);
3863 for (
unsigned ByteIdx = 0; ByteIdx < ByteWidth; ++ByteIdx) {
3864 unsigned ByteBitOfs = ByteIdx * 8;
3865 for (
unsigned BitIdx = 0; BitIdx < 8; ++BitIdx)
3866 Result->Provenance[(
BitWidth - 8 - ByteBitOfs) + BitIdx] =
3867 Res->Provenance[ByteBitOfs + BitIdx];
3884 if (!MatchBitReversals && (ModAmt % 8) != 0)
3889 Depth + 1, FoundRoot);
3890 if (!
LHS || !
LHS->Provider)
3894 Depth + 1, FoundRoot);
3895 if (!
RHS ||
LHS->Provider !=
RHS->Provider)
3898 unsigned StartBitRHS =
BitWidth - ModAmt;
3900 for (
unsigned BitIdx = 0; BitIdx < StartBitRHS; ++BitIdx)
3901 Result->Provenance[BitIdx + ModAmt] =
LHS->Provenance[BitIdx];
3902 for (
unsigned BitIdx = 0; BitIdx < ModAmt; ++BitIdx)
3903 Result->Provenance[BitIdx] =
RHS->Provenance[BitIdx + StartBitRHS];
3917 for (
unsigned BitIdx = 0; BitIdx <
BitWidth; ++BitIdx)
3918 Result->Provenance[BitIdx] = BitIdx;
3924 if (
From % 8 != To % 8)
3939 Instruction *
I,
bool MatchBSwaps,
bool MatchBitReversals,
3946 if (!MatchBSwaps && !MatchBitReversals)
3948 Type *ITy =
I->getType();
3953 bool FoundRoot =
false;
3954 std::map<Value *, std::optional<BitPart>> BPS;
3961 [](int8_t
I) {
return I == BitPart::Unset || 0 <=
I; }) &&
3962 "Illegal bit provenance index");
3965 Type *DemandedTy = ITy;
3966 if (BitProvenance.
back() == BitPart::Unset) {
3967 while (!BitProvenance.
empty() && BitProvenance.
back() == BitPart::Unset)
3968 BitProvenance = BitProvenance.
drop_back();
3969 if (BitProvenance.
empty())
3972 if (
auto *IVecTy = dyn_cast<VectorType>(ITy))
3973 DemandedTy = VectorType::get(DemandedTy, IVecTy);
3984 bool OKForBSwap = MatchBSwaps && (DemandedBW % 16) == 0;
3985 bool OKForBitReverse = MatchBitReversals;
3986 for (
unsigned BitIdx = 0;
3987 (BitIdx < DemandedBW) && (OKForBSwap || OKForBitReverse); ++BitIdx) {
3988 if (BitProvenance[BitIdx] == BitPart::Unset) {
3995 BitIdx, DemandedBW);
4000 Intrin = Intrinsic::bswap;
4001 else if (OKForBitReverse)
4002 Intrin = Intrinsic::bitreverse;
4007 Value *Provider = Res->Provider;
4010 if (DemandedTy != Provider->
getType()) {
4021 auto *Mask = ConstantInt::get(DemandedTy, DemandedMask);
4027 if (ITy != Result->getType()) {
4044 if (
F && !
F->hasLocalLinkage() &&
F->hasName() &&
4046 !
F->doesNotAccessMemory())
4052 if (
I->getOperand(OpIdx)->getType()->isMetadataTy())
4056 if (!isa<Constant>(
I->getOperand(OpIdx)))
4059 switch (
I->getOpcode()) {
4062 case Instruction::Call:
4063 case Instruction::Invoke: {
4064 const auto &CB = cast<CallBase>(*
I);
4067 if (CB.isInlineAsm())
4072 if (CB.isBundleOperand(OpIdx))
4075 if (OpIdx < CB.arg_size()) {
4078 if (isa<IntrinsicInst>(CB) &&
4079 OpIdx >= CB.getFunctionType()->getNumParams()) {
4081 return CB.getIntrinsicID() == Intrinsic::experimental_stackmap;
4086 if (CB.getIntrinsicID() == Intrinsic::gcroot)
4090 return !CB.paramHasAttr(OpIdx, Attribute::ImmArg);
4095 return !isa<IntrinsicInst>(CB);
4097 case Instruction::ShuffleVector:
4100 case Instruction::Switch:
4101 case Instruction::ExtractValue:
4104 case Instruction::InsertValue:
4107 case Instruction::Alloca:
4111 return !cast<AllocaInst>(
I)->isStaticAlloca();
4112 case Instruction::GetElementPtr:
4116 for (
auto E = std::next(It, OpIdx); It != E; ++It)
4125 if (
Constant *
C = dyn_cast<Constant>(Condition))
4129 Value *NotCondition;
4131 return NotCondition;
4134 Instruction *Inst = dyn_cast<Instruction>(Condition);
4137 else if (
Argument *Arg = dyn_cast<Argument>(Condition))
4139 assert(Parent &&
"Unsupported condition to invert");
4150 if (Inst && !isa<PHINode>(Inst))
4151 Inverted->insertAfter(Inst);
4161 bool Changed =
false;
4163 if (!
F.hasFnAttribute(Attribute::NoSync) &&
4164 F.doesNotAccessMemory() && !
F.isConvergent()) {
4170 if (!
F.hasFnAttribute(Attribute::NoFree) &&
F.onlyReadsMemory()) {
4171 F.setDoesNotFreeMemory();
4176 if (!
F.hasFnAttribute(Attribute::MustProgress) &&
F.willReturn()) {
4177 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")
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")
Rewrite Partial Register Uses
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.
APInt bitcastToAPInt() const
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.
const uint64_t * getRawData() const
This function returns a pointer to the internal storage of the APInt.
std::optional< int64_t > trySExtValue() const
Get sign extended value if possible.
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,...
InstListType::const_iterator getFirstNonPHIIt() const
Iterator returning form of getFirstNonPHI.
void insertDbgRecordBefore(DbgRecord *DR, InstListType::iterator Here)
Insert a DbgRecord into a block at the position given by Here.
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.
void flushTerminatorDbgRecords()
Eject any debug-info trailing at the end of a 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.
void insertDbgRecordAfter(DbgRecord *DR, Instruction *I)
Insert a DbgRecord into a block at the position given by I.
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...
bool hasNPredecessorsOrMore(unsigned N) const
Return true if this block has N predecessors or more.
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, BasicBlock::iterator InsertBefore)
Construct a binary instruction, given the opcode and the two operands.
BinaryOps getOpcode() const
static BinaryOperator * CreateNot(Value *Op, const Twine &Name, BasicBlock::iterator InsertBefore)
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, BasicBlock::iterator InsertBefore)
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, BasicBlock::iterator InsertBefore)
static CastInst * CreateIntegerCast(Value *S, Type *Ty, bool isSigned, const Twine &Name, BasicBlock::iterator InsertBefore)
Create a ZExt, BitCast, or Trunc for int -> int casts.
static CatchSwitchInst * Create(Value *ParentPad, BasicBlock *UnwindDest, unsigned NumHandlers, const Twine &NameStr, BasicBlock::iterator InsertBefore)
static CleanupReturnInst * Create(Value *CleanupPad, BasicBlock *UnwindBB, BasicBlock::iterator InsertBefore)
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.
A constant value that is initialized with an expression using other constant values.
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 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.
DIExpression * createConstantValueExpression(uint64_t Val)
Create an expression for a variable that does not have an address, but does have a constant value.
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...
uint64_t getElement(unsigned I) const
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...
This class represents an Operation in the Expression.
A parsed version of the target data layout string in and methods for querying it.
This represents the llvm.dbg.label instruction.
Instruction * MarkedInstr
Link back to the Instruction that owns this marker.
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
Record of a variable value-assignment, aka a non instruction representation of the dbg....
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.
DbgVariableRecord * clone() const
void setExpression(DIExpression *NewExpr)
DIExpression * getExpression() const
Value * getVariableLocationOp(unsigned OpIdx) const
DILocalVariable * getVariable() const
unsigned getNumVariableLocationOps() const
void replaceVariableLocationOp(Value *OldValue, Value *NewValue, bool AllowEmpty=false)
iterator_range< location_op_iterator > location_ops() const
Get the locations corresponding to the variable referenced by the debug info intrinsic.
DILocation * get() const
Get the underlying DILocation.
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.
Value * CreateICmpEQ(Value *LHS, Value *RHS, const Twine &Name="")
BranchInst * CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False, MDNode *BranchWeights=nullptr, MDNode *Unpredictable=nullptr)
Create a conditional 'br Cond, TrueDest, FalseDest' instruction.
BranchInst * CreateBr(BasicBlock *Dest)
Create an unconditional 'br label X' instruction.
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
InstListType::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
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.
void dropPoisonGeneratingFlags()
Drops flags that may cause this instruction to evaluate to poison despite having non-poison inputs.
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.
void dropDbgRecords()
Erase any DbgRecords attached to this instruction.
A wrapper class for inspecting calls to intrinsic functions.
BasicBlock * getUnwindDest() const
static InvokeInst * Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal, BasicBlock *IfException, ArrayRef< Value * > Args, const Twine &NameStr, BasicBlock::iterator InsertBefore)
BasicBlock * getNormalDest() const
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.
T get() const
Returns the value of the specified pointer type.
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.
TinyPtrVector - This class is specialized for cases where there are normally 0 or 1 element in a vect...
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 isFloatingPointTy() const
Return true if this is one of the floating-point types.
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()
void replaceUsesWithIf(Value *New, llvm::function_ref< bool(Use &U)> ShouldReplace)
Go through the uses list for this definition and make each use point to "V" if the callback ShouldRep...
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.
Represents an op.with.overflow intrinsic.
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)
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.
CastOperator_match< OpTy, Instruction::Trunc > m_Trunc(const OpTy &Op)
Matches Trunc.
bind_ty< WithOverflowInst > m_WithOverflowInst(WithOverflowInst *&I)
Match a with overflow intrinsic, capturing it if we match.
CastInst_match< OpTy, ZExtInst > m_ZExt(const OpTy &Op)
Matches ZExt.
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.
pred_iterator pred_end(BasicBlock *BB)
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.
UnaryFunction for_each(R &&Range, UnaryFunction F)
Provide wrappers to std::for_each which take ranges instead of having to pass begin/end explicitly.
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...
TinyPtrVector< DbgDeclareInst * > findDbgDeclares(Value *V)
Finds dbg.declare intrinsics declaring local variables as living in the memory that 'V' points to.
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, ArrayRef< DbgVariableRecord * > DPInsns)
Implementation of salvageDebugInfo, applying only to instructions in Insns, rather than all debug use...
void findDbgUsers(SmallVectorImpl< DbgVariableIntrinsic * > &DbgInsts, Value *V, SmallVectorImpl< DbgVariableRecord * > *DbgVariableRecords=nullptr)
Finds the debug info intrinsics describing a value.
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...
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 findDbgValues(SmallVectorImpl< DbgValueInst * > &DbgValues, Value *V, SmallVectorImpl< DbgVariableRecord * > *DbgVariableRecords=nullptr)
Finds the llvm.dbg.value intrinsics describing a value.
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.
void setBranchWeights(Instruction &I, ArrayRef< uint32_t > Weights)
Create a new branch_weights metadata node and add or overwrite a prof metadata reference to instructi...
bool handleUnreachableTerminator(Instruction *I, SmallVectorImpl< Value * > &PoisonedValues)
If a terminator in an unreachable basic block has an operand of type Instruction, transform it into p...
bool canSimplifyInvokeNoUnwind(const Function *F)
Value * simplifyInstruction(Instruction *I, const SimplifyQuery &Q)
See if we can compute a simplified version of this instruction.
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.
pred_iterator pred_begin(BasicBlock *BB)
bool TryToSimplifyUncondBranchFromEmptyBlock(BasicBlock *BB, DomTreeUpdater *DTU=nullptr)
BB is known to contain an unconditional branch, and contains no instructions other than PHI nodes,...
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 ...
DIExpression * getExpressionForConstant(DIBuilder &DIB, const Constant &C, Type &Ty)
Given a constant, create a debug information expression.
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.
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 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)
RNSuccIterator< NodeRef, BlockT, RegionT > succ_begin(NodeRef Node)
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)
TinyPtrVector< DbgVariableRecord * > findDVRDeclares(Value *V)
As above, for DVRDeclares.
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)
static auto filterDbgVars(iterator_range< simple_ilist< DbgRecord >::iterator > R)
Filter the DbgRecord range to DbgVariableRecord types only and downcast.
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.