59#include "llvm/IR/IntrinsicsWebAssembly.h"
93#define DEBUG_TYPE "local"
95STATISTIC(NumRemoved,
"Number of unreachable basic blocks removed");
96STATISTIC(NumPHICSEs,
"Number of PHI's that got CSE'd");
100#ifdef EXPENSIVE_CHECKS
106 cl::desc(
"Perform extra assertion checking to verify that PHINodes's hash "
107 "function is well-behaved w.r.t. its isEqual predicate"));
112 "When the basic block contains not more than this number of PHI nodes, "
113 "perform a (faster!) exhaustive search instead of set-driven one."));
137 if (
auto *BI = dyn_cast<BranchInst>(
T)) {
138 if (BI->isUnconditional())
return false;
143 if (Dest2 == Dest1) {
149 assert(BI->getParent() &&
"Terminator not inserted in block!");
156 NewBI->
copyMetadata(*BI, {LLVMContext::MD_loop, LLVMContext::MD_dbg,
157 LLVMContext::MD_annotation});
160 BI->eraseFromParent();
161 if (DeleteDeadConditions)
166 if (
auto *
Cond = dyn_cast<ConstantInt>(BI->getCondition())) {
180 NewBI->
copyMetadata(*BI, {LLVMContext::MD_loop, LLVMContext::MD_dbg,
181 LLVMContext::MD_annotation});
183 BI->eraseFromParent();
185 DTU->
applyUpdates({{DominatorTree::Delete, BB, OldDest}});
192 if (
auto *SI = dyn_cast<SwitchInst>(
T)) {
195 auto *CI = dyn_cast<ConstantInt>(SI->getCondition());
196 BasicBlock *DefaultDest = SI->getDefaultDest();
201 SI->getNumCases() > 0) {
202 TheOnlyDest = SI->case_begin()->getCaseSuccessor();
205 bool Changed =
false;
208 for (
auto It = SI->case_begin(),
End = SI->case_end(); It !=
End;) {
210 if (It->getCaseValue() == CI) {
211 TheOnlyDest = It->getCaseSuccessor();
217 if (It->getCaseSuccessor() == DefaultDest) {
219 unsigned NCases = SI->getNumCases();
222 if (NCases > 1 && MD) {
228 unsigned Idx = It->getCaseIndex();
230 Weights[0] += Weights[
Idx + 1];
239 It = SI->removeCase(It);
240 End = SI->case_end();
244 if (
auto *NewCI = dyn_cast<ConstantInt>(SI->getCondition())) {
246 It = SI->case_begin();
256 if (It->getCaseSuccessor() != TheOnlyDest)
257 TheOnlyDest =
nullptr;
263 if (CI && !TheOnlyDest) {
266 TheOnlyDest = SI->getDefaultDest();
281 if (DTU && Succ != TheOnlyDest)
282 RemovedSuccessors.
insert(Succ);
284 if (Succ == SuccToKeep) {
285 SuccToKeep =
nullptr;
293 SI->eraseFromParent();
294 if (DeleteDeadConditions)
297 std::vector<DominatorTree::UpdateType> Updates;
298 Updates.reserve(RemovedSuccessors.
size());
299 for (
auto *RemovedSuccessor : RemovedSuccessors)
300 Updates.push_back({DominatorTree::Delete, BB, RemovedSuccessor});
306 if (SI->getNumCases() == 1) {
309 auto FirstCase = *SI->case_begin();
311 FirstCase.getCaseValue(),
"cond");
315 FirstCase.getCaseSuccessor(),
316 SI->getDefaultDest());
328 MDNode *MakeImplicitMD = SI->getMetadata(LLVMContext::MD_make_implicit);
330 NewBr->
setMetadata(LLVMContext::MD_make_implicit, MakeImplicitMD);
333 SI->eraseFromParent();
339 if (
auto *IBI = dyn_cast<IndirectBrInst>(
T)) {
342 dyn_cast<BlockAddress>(IBI->getAddress()->stripPointerCasts())) {
343 BasicBlock *TheOnlyDest = BA->getBasicBlock();
350 for (
unsigned i = 0, e = IBI->getNumDestinations(); i != e; ++i) {
352 if (DTU && DestBB != TheOnlyDest)
353 RemovedSuccessors.
insert(DestBB);
354 if (IBI->getDestination(i) == SuccToKeep) {
355 SuccToKeep =
nullptr;
360 Value *Address = IBI->getAddress();
361 IBI->eraseFromParent();
362 if (DeleteDeadConditions)
369 BA->destroyConstant();
380 std::vector<DominatorTree::UpdateType> Updates;
381 Updates.reserve(RemovedSuccessors.
size());
382 for (
auto *RemovedSuccessor : RemovedSuccessors)
383 Updates.push_back({DominatorTree::Delete, BB, RemovedSuccessor});
412 if (
II->getIntrinsicID() == Intrinsic::stacksave ||
413 II->getIntrinsicID() == Intrinsic::launder_invariant_group ||
414 II->isLifetimeStartOrEnd())
421 if (
I->isTerminator())
430 if (isa<DbgVariableIntrinsic>(
I))
439 if (
auto *CB = dyn_cast<CallBase>(
I))
443 if (!
I->willReturn()) {
444 auto *
II = dyn_cast<IntrinsicInst>(
I);
448 switch (
II->getIntrinsicID()) {
449 case Intrinsic::experimental_guard: {
453 auto *
Cond = dyn_cast<ConstantInt>(
II->getArgOperand(0));
458 case Intrinsic::wasm_trunc_signed:
459 case Intrinsic::wasm_trunc_unsigned:
460 case Intrinsic::ptrauth_auth:
461 case Intrinsic::ptrauth_resign:
468 if (!
I->mayHaveSideEffects())
475 if (
II->getIntrinsicID() == Intrinsic::stacksave ||
476 II->getIntrinsicID() == Intrinsic::launder_invariant_group)
481 if (
II->getIntrinsicID() == Intrinsic::allow_runtime_check ||
482 II->getIntrinsicID() == Intrinsic::allow_ubsan_check)
485 if (
II->isLifetimeStartOrEnd()) {
486 auto *Arg =
II->getArgOperand(1);
488 if (isa<UndefValue>(Arg))
492 if (isa<AllocaInst>(Arg) || isa<GlobalValue>(Arg) || isa<Argument>(Arg))
494 if (IntrinsicInst *IntrinsicUse =
495 dyn_cast<IntrinsicInst>(Use.getUser()))
496 return IntrinsicUse->isLifetimeStartOrEnd();
503 if (
II->getIntrinsicID() == Intrinsic::assume &&
506 return !
Cond->isZero();
511 if (
auto *FPI = dyn_cast<ConstrainedFPIntrinsic>(
I)) {
512 std::optional<fp::ExceptionBehavior> ExBehavior =
513 FPI->getExceptionBehavior();
518 if (
auto *Call = dyn_cast<CallBase>(
I)) {
520 if (
Constant *
C = dyn_cast<Constant>(FreedOp))
521 return C->isNullValue() || isa<UndefValue>(
C);
527 if (
auto *LI = dyn_cast<LoadInst>(
I))
528 if (
auto *GV = dyn_cast<GlobalVariable>(
529 LI->getPointerOperand()->stripPointerCasts()))
530 if (!LI->isVolatile() && GV->isConstant())
542 std::function<
void(
Value *)> AboutToDeleteCallback) {
550 AboutToDeleteCallback);
558 std::function<
void(
Value *)> AboutToDeleteCallback) {
559 unsigned S = 0, E = DeadInsts.
size(), Alive = 0;
560 for (; S != E; ++S) {
561 auto *
I = dyn_cast_or_null<Instruction>(DeadInsts[S]);
563 DeadInsts[S] =
nullptr;
570 AboutToDeleteCallback);
577 std::function<
void(
Value *)> AboutToDeleteCallback) {
579 while (!DeadInsts.
empty()) {
585 "Live instruction found in dead worklist!");
586 assert(
I->use_empty() &&
"Instructions with uses are not dead.");
591 if (AboutToDeleteCallback)
592 AboutToDeleteCallback(
I);
596 for (
Use &OpU :
I->operands()) {
597 Value *OpV = OpU.get();
613 I->eraseFromParent();
621 for (
auto *DII : DbgUsers)
622 DII->setKillLocation();
623 for (
auto *DVR : DPUsers)
624 DVR->setKillLocation();
639 for (++UI; UI != UE; ++UI) {
656 I = cast<Instruction>(*
I->user_begin())) {
662 if (!Visited.
insert(
I).second) {
682 for (
unsigned i = 0, e =
I->getNumOperands(); i != e; ++i) {
683 Value *OpV =
I->getOperand(i);
684 I->setOperand(i,
nullptr);
697 I->eraseFromParent();
705 for (
User *U :
I->users()) {
707 WorkList.
insert(cast<Instruction>(U));
712 bool Changed =
false;
713 if (!
I->use_empty()) {
714 I->replaceAllUsesWith(SimpleV);
718 I->eraseFromParent();
733 bool MadeChange =
false;
750 assert(!BI->isTerminator());
760 while (!WorkList.
empty()) {
775 while (
PHINode *PN = dyn_cast<PHINode>(DestBB->
begin())) {
776 Value *NewVal = PN->getIncomingValue(0);
779 PN->replaceAllUsesWith(NewVal);
780 PN->eraseFromParent();
784 assert(PredBB &&
"Block doesn't have a single predecessor!");
798 if (PredOfPredBB != PredBB)
799 if (SeenPreds.
insert(PredOfPredBB).second)
800 Updates.
push_back({DominatorTree::Insert, PredOfPredBB, DestBB});
803 if (SeenPreds.
insert(PredOfPredBB).second)
804 Updates.
push_back({DominatorTree::Delete, PredOfPredBB, PredBB});
805 Updates.
push_back({DominatorTree::Delete, PredBB, DestBB});
835 "The successor list of PredBB isn't empty before "
836 "applying corresponding DTU updates.");
857 return First == Second || isa<UndefValue>(
First) || isa<UndefValue>(Second);
888 if (BBPreds.
count(IBB) &&
892 <<
"Can't fold, phi node " << PN->
getName() <<
" in "
893 << Succ->
getName() <<
" is conflicting with "
894 << BBPN->
getName() <<
" with regard to common predecessor "
906 if (BBPreds.
count(IBB) &&
910 <<
" is conflicting with regard to common "
911 <<
"predecessor " << IBB->
getName() <<
"\n");
938 if (!isa<UndefValue>(OldVal)) {
940 IncomingValues.
find(BB)->second == OldVal) &&
941 "Expected OldVal to match incoming value from BB!");
943 IncomingValues.
insert(std::make_pair(BB, OldVal));
948 if (It != IncomingValues.
end())
return It->second;
967 if (!isa<UndefValue>(V))
968 IncomingValues.
insert(std::make_pair(BB, V));
983 if (!isa<UndefValue>(V))
continue;
992 if (It == IncomingValues.
end()) {
1005 unsigned PoisonCount =
count_if(TrueUndefOps, [&](
unsigned i) {
1008 if (PoisonCount != 0 && PoisonCount != TrueUndefOps.
size()) {
1009 for (
unsigned i : TrueUndefOps)
1024 if (BB->
phis().empty() || Succ->
phis().empty())
1033 if (BBPreds.
count(SuccPred)) {
1036 CommonPred = SuccPred;
1056 assert(OldVal &&
"No entry in PHI for Pred BB!");
1073 if (isa<PHINode>(OldVal) && cast<PHINode>(OldVal)->
getParent() == BB) {
1074 PHINode *OldValPN = cast<PHINode>(OldVal);
1083 if (PredBB == CommonPred)
1101 if (PredBB == CommonPred)
1121 "TryToSimplifyUncondBranchFromEmptyBlock called on entry block!");
1138 bool BBPhisMergeable =
1142 if (!BBKillable && !BBPhisMergeable)
1162 while (isa<PHINode>(*BBI)) {
1163 for (
Use &U : BBI->uses()) {
1164 if (
PHINode* PN = dyn_cast<PHINode>(U.getUser())) {
1165 if (PN->getIncomingBlock(U) != BB)
1175 if (BBPhisMergeable && CommonPred)
1177 <<
" and " << Succ->
getName() <<
" : "
1178 << CommonPred->
getName() <<
"\n");
1246 if (TI->hasMetadata(LLVMContext::MD_loop))
1249 if (PredTI->hasMetadata(LLVMContext::MD_loop))
1254 else if (BBPhisMergeable)
1269 if (SeenPreds.
insert(PredOfBB).second)
1270 Updates.
push_back({DominatorTree::Insert, PredOfBB, Succ});
1278 if (SeenPreds.
insert(PredOfBB).second && PredOfBB != CommonPred)
1279 Updates.
push_back({DominatorTree::Delete, PredOfBB, BB});
1282 Updates.
push_back({DominatorTree::Delete, BB, Succ});
1285 if (isa<PHINode>(Succ->
begin())) {
1305 while (
PHINode *PN = dyn_cast<PHINode>(&BB->
front())) {
1307 assert(PN->use_empty() &&
"There shouldn't be any uses here!");
1308 PN->eraseFromParent();
1315 if (
MDNode *LoopMD = TI->getMetadata(LLVMContext::MD_loop))
1317 Pred->getTerminator()->setMetadata(LLVMContext::MD_loop, LoopMD);
1332 "applying corresponding DTU updates.");
1333 }
else if (BBPhisMergeable) {
1336 if (
Instruction *UseInst = dyn_cast<Instruction>(U.getUser()))
1337 return UseInst->
getParent() != CommonPred &&
1338 BBPreds.
contains(UseInst->getParent());
1359 bool Changed =
false;
1364 for (
auto I = BB->
begin();
PHINode *PN = dyn_cast<PHINode>(
I);) {
1369 for (
auto J =
I;
PHINode *DuplicatePN = dyn_cast<PHINode>(J); ++J) {
1370 if (
ToRemove.contains(DuplicatePN))
1395 struct PHIDenseMapInfo {
1396 static PHINode *getEmptyKey() {
1400 static PHINode *getTombstoneKey() {
1405 return PN == getEmptyKey() || PN == getTombstoneKey();
1419 static unsigned getHashValue(
PHINode *PN) {
1434 return LHS->isIdenticalTo(
RHS);
1452 bool Changed =
false;
1453 for (
auto I = BB->
begin();
PHINode *PN = dyn_cast<PHINode>(
I++);) {
1456 auto Inserted = PHISet.
insert(PN);
1457 if (!Inserted.second) {
1460 PN->replaceAllUsesWith(*Inserted.first);
1489 PN->eraseFromParent();
1495 V = V->stripPointerCasts();
1497 if (
AllocaInst *AI = dyn_cast<AllocaInst>(V)) {
1503 Align CurrentAlign = AI->getAlign();
1504 if (PrefAlign <= CurrentAlign)
1505 return CurrentAlign;
1509 if (
DL.exceedsNaturalStackAlignment(PrefAlign))
1510 return CurrentAlign;
1511 AI->setAlignment(PrefAlign);
1515 if (
auto *GO = dyn_cast<GlobalObject>(V)) {
1517 Align CurrentAlign = GO->getPointerAlignment(
DL);
1518 if (PrefAlign <= CurrentAlign)
1519 return CurrentAlign;
1525 if (!GO->canIncreaseAlignment())
1526 return CurrentAlign;
1528 if (GO->isThreadLocal()) {
1529 unsigned MaxTLSAlign = GO->getParent()->getMaxTLSAlignment() / CHAR_BIT;
1530 if (MaxTLSAlign && PrefAlign >
Align(MaxTLSAlign))
1531 PrefAlign =
Align(MaxTLSAlign);
1534 GO->setAlignment(PrefAlign);
1546 assert(V->getType()->isPointerTy() &&
1547 "getOrEnforceKnownAlignment expects a pointer!");
1559 if (PrefAlign && *PrefAlign > Alignment)
1580 for (
auto *DVI : DbgValues) {
1582 if ((DVI->getVariable() == DIVar) && (DVI->getExpression() == DIExpr))
1585 for (
auto *DVR : DbgVariableRecords) {
1587 if ((DVR->getVariable() == DIVar) && (DVR->getExpression() == DIExpr))
1603 TypeSize ValueSize =
DL.getTypeAllocSizeInBits(ValTy);
1604 if (std::optional<uint64_t> FragmentSize =
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);
1631 if (std::optional<uint64_t> FragmentSize =
1641 "address of variable must have exactly 1 location operand.");
1644 if (std::optional<TypeSize> FragmentSize = AI->getAllocationSizeInBits(
DL)) {
1645 return TypeSize::isKnownGE(ValueSize, *FragmentSize);
1659 auto DbgVal = Builder.insertDbgValueIntrinsic(DV, DIVar, DIExpr, NewLoc,
1668 Instr->getParent()->insertDbgRecordBefore(DV, Instr);
1676 auto DbgVal = Builder.insertDbgValueIntrinsic(DV, DIVar, DIExpr, NewLoc,
1685 Instr->getParent()->insertDbgRecordAfter(DV, &*Instr);
1695 assert(DIVar &&
"Missing variable");
1697 Value *DV = SI->getValueOperand();
1714 DIExpr->isDeref() || (!DIExpr->startsWithDeref() &&
1724 LLVM_DEBUG(
dbgs() <<
"Failed to convert dbg.declare to dbg.value: " << *DII
1740 assert(DIVar &&
"Missing variable");
1746 LLVM_DEBUG(
dbgs() <<
"Failed to convert dbg.declare to dbg.value: "
1765 assert(DIVar &&
"Missing variable");
1767 Value *DV = SI->getValueOperand();
1784 DIExpr->isDeref() || (!DIExpr->startsWithDeref() &&
1794 LLVM_DEBUG(
dbgs() <<
"Failed to convert dbg.declare to dbg.value: " << *DVR
1805 SI->getParent()->insertDbgRecordBefore(NewDVR, SI->getIterator());
1814 assert(DIVar &&
"Missing variable");
1823 LLVM_DEBUG(
dbgs() <<
"Failed to convert dbg.declare to dbg.value: "
1836 if (InsertionPt != BB->
end()) {
1846 assert(DIVar &&
"Missing variable");
1852 LLVM_DEBUG(
dbgs() <<
"Failed to convert dbg.declare to DbgVariableRecord: "
1869 LI->
getParent()->insertDbgRecordAfter(DV, LI);
1886 assert(DIVar &&
"Missing variable");
1895 LLVM_DEBUG(
dbgs() <<
"Failed to convert dbg.declare to DbgVariableRecord: "
1908 if (InsertionPt != BB->
end()) {
1917 bool Changed =
false;
1921 for (
auto &FI :
F) {
1923 if (
auto *DDI = dyn_cast<DbgDeclareInst>(&BI))
1926 if (DVR.getType() == DbgVariableRecord::LocationType::Declare)
1935 auto LowerOne = [&](
auto *DDI) {
1937 dyn_cast_or_null<AllocaInst>(DDI->getVariableLocationOp(0));
1949 if (LoadInst *LI = dyn_cast<LoadInst>(U))
1950 return LI->isVolatile();
1951 if (StoreInst *SI = dyn_cast<StoreInst>(U))
1952 return SI->isVolatile();
1959 while (!WorkList.
empty()) {
1961 for (
const auto &AIUse : V->uses()) {
1962 User *U = AIUse.getUser();
1963 if (
StoreInst *SI = dyn_cast<StoreInst>(U)) {
1964 if (AIUse.getOperandNo() == 1)
1966 }
else if (
LoadInst *LI = dyn_cast<LoadInst>(U)) {
1968 }
else if (
CallInst *CI = dyn_cast<CallInst>(U)) {
1972 if (!CI->isLifetimeStartOrEnd()) {
1980 }
else if (
BitCastInst *BI = dyn_cast<BitCastInst>(U)) {
1981 if (BI->getType()->isPointerTy())
1986 DDI->eraseFromParent();
2006 assert(BB &&
"No BasicBlock to clone DbgVariableRecord(s) from.");
2007 if (InsertedPHIs.
size() == 0)
2012 for (
auto &
I : *BB) {
2014 for (
Value *V : DVR.location_ops())
2015 if (
auto *Loc = dyn_cast_or_null<PHINode>(V))
2016 DbgValueMap.
insert({Loc, &DVR});
2019 if (DbgValueMap.
size() == 0)
2034 for (
auto PHI : InsertedPHIs) {
2039 for (
auto VI :
PHI->operand_values()) {
2040 auto V = DbgValueMap.
find(VI);
2041 if (V != DbgValueMap.
end()) {
2043 auto NewDI = NewDbgValueMap.
find({Parent, DbgII});
2044 if (NewDI == NewDbgValueMap.
end()) {
2046 NewDI = NewDbgValueMap.
insert({{Parent, DbgII}, NewDbgII}).first;
2057 for (
auto DI : NewDbgValueMap) {
2061 assert(InsertionPt != Parent->
end() &&
"Ill-formed basic block");
2070 assert(BB &&
"No BasicBlock to clone dbg.value(s) from.");
2071 if (InsertedPHIs.
size() == 0)
2078 for (
auto &
I : *BB) {
2079 if (
auto DbgII = dyn_cast<DbgVariableIntrinsic>(&
I)) {
2080 for (
Value *V : DbgII->location_ops())
2081 if (
auto *Loc = dyn_cast_or_null<PHINode>(V))
2082 DbgValueMap.
insert({Loc, DbgII});
2085 if (DbgValueMap.
size() == 0)
2100 for (
auto *
PHI : InsertedPHIs) {
2105 for (
auto *VI :
PHI->operand_values()) {
2106 auto V = DbgValueMap.
find(VI);
2107 if (V != DbgValueMap.
end()) {
2108 auto *DbgII = cast<DbgVariableIntrinsic>(V->second);
2109 auto NewDI = NewDbgValueMap.
find({Parent, DbgII});
2110 if (NewDI == NewDbgValueMap.
end()) {
2111 auto *NewDbgII = cast<DbgVariableIntrinsic>(DbgII->clone());
2112 NewDI = NewDbgValueMap.
insert({{Parent, DbgII}, NewDbgII}).first;
2123 for (
auto DI : NewDbgValueMap) {
2125 auto *NewDbgII = DI.second;
2127 assert(InsertionPt != Parent->
end() &&
"Ill-formed basic block");
2128 NewDbgII->insertBefore(&*InsertionPt);
2133 DIBuilder &Builder, uint8_t DIExprFlags,
2138 auto ReplaceOne = [&](
auto *DII) {
2139 assert(DII->getVariable() &&
"Missing variable");
2140 auto *DIExpr = DII->getExpression();
2142 DII->setExpression(DIExpr);
2143 DII->replaceVariableLocationOp(Address, NewAddress);
2149 return !DbgDeclares.
empty() || !DVRDeclares.
empty();
2158 assert(DIVar &&
"Missing variable");
2188 for (
auto *DVI : DbgUsers)
2190 DVI->getExpression(), NewAllocaAddress, DVI,
2191 nullptr, Builder,
Offset);
2196 DVR->getExpression(), NewAllocaAddress,
nullptr,
2210 Instruction *
I = dyn_cast<Instruction>(Assign->getAddress());
2215 assert(!Assign->getAddressExpression()->getFragmentInfo().has_value() &&
2216 "address-expression shouldn't have fragment info");
2229 Assign->getAddressExpression(), Ops, 0,
false);
2231 "address-expression shouldn't have fragment info");
2236 if (AdditionalValues.
empty()) {
2237 Assign->setAddress(NewV);
2238 Assign->setAddressExpression(SalvagedExpr);
2240 Assign->setKillAddress();
2250 const unsigned MaxDebugArgs = 16;
2251 const unsigned MaxExpressionSize = 128;
2252 bool Salvaged =
false;
2254 for (
auto *DII : DbgUsers) {
2255 if (
auto *DAI = dyn_cast<DbgAssignIntrinsic>(DII)) {
2256 if (DAI->getAddress() == &
I) {
2260 if (DAI->getValue() != &
I)
2266 bool StackValue = isa<DbgValueInst>(DII);
2267 auto DIILocation = DII->location_ops();
2270 "DbgVariableIntrinsic must use salvaged instruction as its location");
2276 Value *Op0 =
nullptr;
2278 auto LocItr =
find(DIILocation, &
I);
2279 while (SalvagedExpr && LocItr != DIILocation.end()) {
2281 unsigned LocNo = std::distance(DIILocation.begin(), LocItr);
2288 LocItr = std::find(++LocItr, DIILocation.end(), &
I);
2296 DII->replaceVariableLocationOp(&
I, Op0);
2297 bool IsValidSalvageExpr = SalvagedExpr->
getNumElements() <= MaxExpressionSize;
2298 if (AdditionalValues.
empty() && IsValidSalvageExpr) {
2299 DII->setExpression(SalvagedExpr);
2300 }
else if (isa<DbgValueInst>(DII) && IsValidSalvageExpr &&
2301 DII->getNumVariableLocationOps() + AdditionalValues.
size() <=
2303 DII->addVariableLocationOps(AdditionalValues, SalvagedExpr);
2308 DII->setKillLocation();
2314 for (
auto *DVR : DPUsers) {
2315 if (DVR->isDbgAssign()) {
2316 if (DVR->getAddress() == &
I) {
2320 if (DVR->getValue() != &
I)
2328 DVR->getType() != DbgVariableRecord::LocationType::Declare;
2329 auto DVRLocation = DVR->location_ops();
2332 "DbgVariableIntrinsic must use salvaged instruction as its location");
2338 Value *Op0 =
nullptr;
2340 auto LocItr =
find(DVRLocation, &
I);
2341 while (SalvagedExpr && LocItr != DVRLocation.end()) {
2343 unsigned LocNo = std::distance(DVRLocation.begin(), LocItr);
2350 LocItr = std::find(++LocItr, DVRLocation.end(), &
I);
2358 DVR->replaceVariableLocationOp(&
I, Op0);
2359 bool IsValidSalvageExpr =
2361 if (AdditionalValues.
empty() && IsValidSalvageExpr) {
2362 DVR->setExpression(SalvagedExpr);
2363 }
else if (DVR->getType() != DbgVariableRecord::LocationType::Declare &&
2364 IsValidSalvageExpr &&
2365 DVR->getNumVariableLocationOps() + AdditionalValues.
size() <=
2367 DVR->addVariableLocationOps(AdditionalValues, SalvagedExpr);
2373 DVR->setKillLocation();
2382 for (
auto *DII : DbgUsers)
2383 DII->setKillLocation();
2385 for (
auto *DVR : DPUsers)
2386 DVR->setKillLocation();
2393 unsigned BitWidth =
DL.getIndexSizeInBits(
GEP->getPointerAddressSpace());
2397 if (!
GEP->collectOffset(
DL,
BitWidth, VariableOffsets, ConstantOffset))
2399 if (!VariableOffsets.
empty() && !CurrentLocOps) {
2400 Opcodes.
insert(Opcodes.
begin(), {dwarf::DW_OP_LLVM_arg, 0});
2403 for (
const auto &
Offset : VariableOffsets) {
2406 "Expected strictly positive multiplier for offset.");
2408 Offset.second.getZExtValue(), dwarf::DW_OP_mul,
2409 dwarf::DW_OP_plus});
2412 return GEP->getOperand(0);
2417 case Instruction::Add:
2418 return dwarf::DW_OP_plus;
2419 case Instruction::Sub:
2420 return dwarf::DW_OP_minus;
2421 case Instruction::Mul:
2422 return dwarf::DW_OP_mul;
2423 case Instruction::SDiv:
2424 return dwarf::DW_OP_div;
2425 case Instruction::SRem:
2426 return dwarf::DW_OP_mod;
2427 case Instruction::Or:
2428 return dwarf::DW_OP_or;
2429 case Instruction::And:
2430 return dwarf::DW_OP_and;
2431 case Instruction::Xor:
2432 return dwarf::DW_OP_xor;
2433 case Instruction::Shl:
2434 return dwarf::DW_OP_shl;
2435 case Instruction::LShr:
2436 return dwarf::DW_OP_shr;
2437 case Instruction::AShr:
2438 return dwarf::DW_OP_shra;
2449 if (!CurrentLocOps) {
2454 AdditionalValues.
push_back(
I->getOperand(1));
2461 auto *ConstInt = dyn_cast<ConstantInt>(BI->
getOperand(1));
2463 if (ConstInt && ConstInt->getBitWidth() > 64)
2469 uint64_t Val = ConstInt->getSExtValue();
2472 if (BinOpcode == Instruction::Add || BinOpcode == Instruction::Sub) {
2473 uint64_t Offset = BinOpcode == Instruction::Add ? Val : -int64_t(Val);
2477 Opcodes.
append({dwarf::DW_OP_constu, Val});
2496 return dwarf::DW_OP_eq;
2498 return dwarf::DW_OP_ne;
2501 return dwarf::DW_OP_gt;
2504 return dwarf::DW_OP_ge;
2507 return dwarf::DW_OP_lt;
2510 return dwarf::DW_OP_le;
2520 auto *ConstInt = dyn_cast<ConstantInt>(Icmp->
getOperand(1));
2522 if (ConstInt && ConstInt->getBitWidth() > 64)
2530 uint64_t Val = ConstInt->getSExtValue();
2548 auto &M = *
I.getModule();
2549 auto &
DL = M.getDataLayout();
2551 if (
auto *CI = dyn_cast<CastInst>(&
I)) {
2552 Value *FromValue = CI->getOperand(0);
2554 if (CI->isNoopCast(
DL)) {
2563 !(isa<TruncInst>(&
I) || isa<SExtInst>(&
I) || isa<ZExtInst>(&
I) ||
2564 isa<IntToPtrInst>(&
I) || isa<PtrToIntInst>(&
I)))
2568 if (FromType->isPointerTy())
2569 FromType =
DL.getIntPtrType(FromType);
2571 unsigned FromTypeBitSize = FromType->getScalarSizeInBits();
2576 Ops.
append(ExtOps.begin(), ExtOps.end());
2580 if (
auto *
GEP = dyn_cast<GetElementPtrInst>(&
I))
2582 if (
auto *BI = dyn_cast<BinaryOperator>(&
I))
2584 if (
auto *IC = dyn_cast<ICmpInst>(&
I))
2611 bool Changed =
false;
2615 if (isa<Instruction>(&To)) {
2616 bool DomPointAfterFrom =
From.getNextNonDebugInstruction() == &DomPoint;
2618 for (
auto *DII :
Users) {
2628 }
else if (!DT.
dominates(&DomPoint, DII)) {
2629 UndefOrSalvage.
insert(DII);
2634 for (
auto *DVR : DPUsers) {
2638 if (isa<DbgVariableIntrinsic>(NextNonDebug))
2641 if (DomPointAfterFrom && NextNonDebug == &DomPoint) {
2645 DomPoint.
getParent()->insertDbgRecordAfter(DVR, &DomPoint);
2647 }
else if (!DT.
dominates(&DomPoint, MarkedInstr)) {
2648 UndefOrSalvageDVR.
insert(DVR);
2654 for (
auto *DII :
Users) {
2655 if (UndefOrSalvage.
count(DII))
2667 for (
auto *DVR : DPUsers) {
2668 if (UndefOrSalvageDVR.
count(DVR))
2681 if (!UndefOrSalvage.
empty() || !UndefOrSalvageDVR.
empty()) {
2705 bool SameSize =
DL.getTypeSizeInBits(FromTy) ==
DL.getTypeSizeInBits(ToTy);
2706 bool LosslessConversion = !
DL.isNonIntegralPointerType(FromTy) &&
2707 !
DL.isNonIntegralPointerType(ToTy);
2708 return SameSize && LosslessConversion;
2718 if (!
From.isUsedByMetadata())
2721 assert(&
From != &To &&
"Can't replace something with itself");
2730 return DVR.getExpression();
2744 assert(FromBits != ToBits &&
"Unexpected no-op conversion");
2748 if (FromBits < ToBits)
2759 return std::nullopt;
2761 bool Signed = *Signedness == DIBasicType::Signedness::Signed;
2773 return std::nullopt;
2775 bool Signed = *Signedness == DIBasicType::Signedness::Signed;
2789 bool Changed =
false;
2791 I->dropDbgRecords();
2792 for (
Use &U :
I->operands()) {
2794 if (isa<Instruction>(
Op) && !
Op->getType()->isTokenTy()) {
2804std::pair<unsigned, unsigned>
2806 unsigned NumDeadInst = 0;
2807 unsigned NumDeadDbgInst = 0;
2814 while (EndInst != &BB->
front()) {
2826 if (isa<DbgInfoIntrinsic>(Inst))
2834 return {NumDeadInst, NumDeadDbgInst};
2850 Successor->removePredecessor(BB, PreserveLCSSA);
2855 UI->setDebugLoc(
I->getDebugLoc());
2858 unsigned NumInstrsRemoved = 0;
2860 while (BBI != BBE) {
2861 if (!BBI->use_empty())
2863 BBI++->eraseFromParent();
2869 for (
BasicBlock *UniqueSuccessor : UniqueSuccessors)
2870 Updates.
push_back({DominatorTree::Delete, BB, UniqueSuccessor});
2874 return NumInstrsRemoved;
2880 II->getOperandBundlesAsDefs(OpBundles);
2882 II->getCalledOperand(), Args, OpBundles);
2893 auto NewWeights =
uint32_t(TotalWeight) != TotalWeight
2896 NewCall->
setMetadata(LLVMContext::MD_prof, NewWeights);
2907 II->replaceAllUsesWith(NewCall);
2917 II->eraseFromParent();
2919 DTU->
applyUpdates({{DominatorTree::Delete, BB, UnwindDestBB}});
2948 UnwindEdge, InvokeArgs, OpBundles, CI->
getName(), BB);
2952 II->setMetadata(LLVMContext::MD_prof, CI->
getMetadata(LLVMContext::MD_prof));
2955 DTU->
applyUpdates({{DominatorTree::Insert, BB, UnwindEdge}});
2962 Split->front().eraseFromParent();
2973 bool Changed =
false;
2981 if (
auto *CI = dyn_cast<CallInst>(&
I)) {
2982 Value *Callee = CI->getCalledOperand();
2984 if (
Function *
F = dyn_cast<Function>(Callee)) {
2985 auto IntrinsicID =
F->getIntrinsicID();
2990 if (IntrinsicID == Intrinsic::assume) {
2997 }
else if (IntrinsicID == Intrinsic::experimental_guard) {
3008 if (!isa<UnreachableInst>(CI->getNextNode())) {
3014 }
else if ((isa<ConstantPointerNull>(Callee) &&
3016 cast<PointerType>(Callee->getType())
3017 ->getAddressSpace())) ||
3018 isa<UndefValue>(Callee)) {
3023 if (CI->doesNotReturn() && !CI->isMustTailCall()) {
3027 if (!isa<UnreachableInst>(CI->getNextNonDebugInstruction())) {
3034 }
else if (
auto *SI = dyn_cast<StoreInst>(&
I)) {
3040 if (SI->isVolatile())
continue;
3044 if (isa<UndefValue>(
Ptr) ||
3045 (isa<ConstantPointerNull>(
Ptr) &&
3047 SI->getPointerAddressSpace()))) {
3056 if (
auto *
II = dyn_cast<InvokeInst>(Terminator)) {
3058 Value *Callee =
II->getCalledOperand();
3059 if ((isa<ConstantPointerNull>(Callee) &&
3061 isa<UndefValue>(Callee)) {
3065 if (
II->doesNotReturn() &&
3066 !isa<UnreachableInst>(
II->getNormalDest()->front())) {
3076 Ctx, OrigNormalDest->
getName() +
".unreachable",
3077 II->getFunction(), OrigNormalDest);
3079 II->setNormalDest(UnreachableNormalDest);
3082 {{DominatorTree::Delete, BB, OrigNormalDest},
3083 {DominatorTree::Insert, BB, UnreachableNormalDest}});
3087 if (
II->use_empty() && !
II->mayHaveSideEffects()) {
3093 II->eraseFromParent();
3095 DTU->applyUpdates({{DominatorTree::Delete, BB, UnwindDestBB}});
3101 }
else if (
auto *CatchSwitch = dyn_cast<CatchSwitchInst>(Terminator)) {
3103 struct CatchPadDenseMapInfo {
3118 if (
LHS == getEmptyKey() ||
LHS == getTombstoneKey() ||
3119 RHS == getEmptyKey() ||
RHS == getTombstoneKey())
3121 return LHS->isIdenticalTo(
RHS);
3132 E = CatchSwitch->handler_end();
3136 ++NumPerSuccessorCases[HandlerBB];
3137 auto *CatchPad = cast<CatchPadInst>(HandlerBB->
getFirstNonPHI());
3138 if (!HandlerSet.insert({CatchPad, Empty}).second) {
3140 --NumPerSuccessorCases[HandlerBB];
3141 CatchSwitch->removeHandler(
I);
3148 std::vector<DominatorTree::UpdateType> Updates;
3149 for (
const std::pair<BasicBlock *, int> &
I : NumPerSuccessorCases)
3151 Updates.push_back({DominatorTree::Delete, BB,
I.first});
3152 DTU->applyUpdates(Updates);
3160 }
while (!Worklist.
empty());
3167 if (
auto *
II = dyn_cast<InvokeInst>(TI))
3173 if (
auto *CRI = dyn_cast<CleanupReturnInst>(TI)) {
3175 UnwindDest = CRI->getUnwindDest();
3176 }
else if (
auto *CatchSwitch = dyn_cast<CatchSwitchInst>(TI)) {
3178 CatchSwitch->getParentPad(),
nullptr, CatchSwitch->getNumHandlers(),
3179 CatchSwitch->getName(), CatchSwitch->getIterator());
3180 for (
BasicBlock *PadBB : CatchSwitch->handlers())
3181 NewCatchSwitch->addHandler(PadBB);
3183 NewTI = NewCatchSwitch;
3184 UnwindDest = CatchSwitch->getUnwindDest();
3195 DTU->
applyUpdates({{DominatorTree::Delete, BB, UnwindDest}});
3208 if (Reachable.
size() ==
F.size())
3217 if (Reachable.
count(&BB))
3222 BlocksToRemove.
insert(&BB);
3225 if (BlocksToRemove.
empty())
3229 NumRemoved += BlocksToRemove.
size();
3242 K->dropUnknownNonDebugMetadata(KnownIDs);
3243 K->getAllMetadataOtherThanDebugLoc(
Metadata);
3245 unsigned Kind = MD.first;
3251 K->setMetadata(Kind,
nullptr);
3253 case LLVMContext::MD_dbg:
3255 case LLVMContext::MD_DIAssignID:
3256 K->mergeDIAssignID(J);
3258 case LLVMContext::MD_tbaa:
3261 case LLVMContext::MD_alias_scope:
3264 case LLVMContext::MD_noalias:
3265 case LLVMContext::MD_mem_parallel_loop_access:
3268 case LLVMContext::MD_access_group:
3269 K->setMetadata(LLVMContext::MD_access_group,
3272 case LLVMContext::MD_range:
3273 if (DoesKMove || !K->hasMetadata(LLVMContext::MD_noundef))
3276 case LLVMContext::MD_fpmath:
3279 case LLVMContext::MD_invariant_load:
3283 K->setMetadata(Kind, JMD);
3285 case LLVMContext::MD_nonnull:
3286 if (DoesKMove || !K->hasMetadata(LLVMContext::MD_noundef))
3287 K->setMetadata(Kind, JMD);
3289 case LLVMContext::MD_invariant_group:
3292 case LLVMContext::MD_mmra:
3295 case LLVMContext::MD_align:
3296 if (DoesKMove || !K->hasMetadata(LLVMContext::MD_noundef))
3300 case LLVMContext::MD_dereferenceable:
3301 case LLVMContext::MD_dereferenceable_or_null:
3303 K->setMetadata(Kind,
3306 case LLVMContext::MD_preserve_access_index:
3309 case LLVMContext::MD_noundef:
3312 K->setMetadata(Kind, JMD);
3314 case LLVMContext::MD_nontemporal:
3316 K->setMetadata(Kind, JMD);
3318 case LLVMContext::MD_prof:
3330 if (
auto *JMD = J->
getMetadata(LLVMContext::MD_invariant_group))
3331 if (isa<LoadInst>(K) || isa<StoreInst>(K))
3332 K->setMetadata(LLVMContext::MD_invariant_group, JMD);
3337 auto JMMRA = J->
getMetadata(LLVMContext::MD_mmra);
3338 auto KMMRA = K->getMetadata(LLVMContext::MD_mmra);
3339 if (JMMRA || KMMRA) {
3340 K->setMetadata(LLVMContext::MD_mmra,
3347 unsigned KnownIDs[] = {LLVMContext::MD_tbaa,
3348 LLVMContext::MD_alias_scope,
3349 LLVMContext::MD_noalias,
3350 LLVMContext::MD_range,
3351 LLVMContext::MD_fpmath,
3352 LLVMContext::MD_invariant_load,
3353 LLVMContext::MD_nonnull,
3354 LLVMContext::MD_invariant_group,
3355 LLVMContext::MD_align,
3356 LLVMContext::MD_dereferenceable,
3357 LLVMContext::MD_dereferenceable_or_null,
3358 LLVMContext::MD_access_group,
3359 LLVMContext::MD_preserve_access_index,
3360 LLVMContext::MD_prof,
3361 LLVMContext::MD_nontemporal,
3362 LLVMContext::MD_noundef,
3363 LLVMContext::MD_mmra};
3369 Source.getAllMetadata(MD);
3373 for (
const auto &MDPair : MD) {
3374 unsigned ID = MDPair.first;
3384 case LLVMContext::MD_dbg:
3385 case LLVMContext::MD_tbaa:
3386 case LLVMContext::MD_prof:
3387 case LLVMContext::MD_fpmath:
3388 case LLVMContext::MD_tbaa_struct:
3389 case LLVMContext::MD_invariant_load:
3390 case LLVMContext::MD_alias_scope:
3391 case LLVMContext::MD_noalias:
3392 case LLVMContext::MD_nontemporal:
3393 case LLVMContext::MD_mem_parallel_loop_access:
3394 case LLVMContext::MD_access_group:
3395 case LLVMContext::MD_noundef:
3400 case LLVMContext::MD_nonnull:
3404 case LLVMContext::MD_align:
3405 case LLVMContext::MD_dereferenceable:
3406 case LLVMContext::MD_dereferenceable_or_null:
3412 case LLVMContext::MD_range:
3420 auto *ReplInst = dyn_cast<Instruction>(Repl);
3429 if (isa<OverflowingBinaryOperator>(ReplInst) &&
3436 else if (!isa<LoadInst>(
I))
3437 ReplInst->andIRFlags(
I);
3451template <
typename RootType,
typename ShouldReplaceFn>
3453 const RootType &Root,
3454 const ShouldReplaceFn &ShouldReplace) {
3459 if (!ShouldReplace(Root, U))
3463 dbgs() <<
"' with " << *To <<
" in " << *U.getUser() <<
"\n");
3472 auto *BB =
From->getParent();
3476 auto *
I = cast<Instruction>(U.getUser());
3477 if (
I->getParent() == BB)
3491 return ::replaceDominatedUsesWith(
From, To, Root, Dominates);
3497 auto Dominates = [&DT](
const BasicBlock *BB,
const Use &U) {
3500 return ::replaceDominatedUsesWith(
From, To, BB, Dominates);
3506 auto DominatesAndShouldReplace =
3508 return DT.
dominates(Root, U) && ShouldReplace(U, To);
3510 return ::replaceDominatedUsesWith(
From, To, Root, DominatesAndShouldReplace);
3516 auto DominatesAndShouldReplace = [&DT, &ShouldReplace,
3518 return DT.
dominates(BB, U) && ShouldReplace(U, To);
3520 return ::replaceDominatedUsesWith(
From, To, BB, DominatesAndShouldReplace);
3526 if (Call->hasFnAttr(
"gc-leaf-function"))
3528 if (
const Function *
F = Call->getCalledFunction()) {
3529 if (
F->hasFnAttribute(
"gc-leaf-function"))
3532 if (
auto IID =
F->getIntrinsicID()) {
3534 return IID != Intrinsic::experimental_gc_statepoint &&
3535 IID != Intrinsic::experimental_deoptimize &&
3536 IID != Intrinsic::memcpy_element_unordered_atomic &&
3537 IID != Intrinsic::memmove_element_unordered_atomic;
3554 auto *NewTy = NewLI.
getType();
3557 if (NewTy->isPointerTy()) {
3564 if (!NewTy->isIntegerTy())
3569 auto *ITy = cast<IntegerType>(NewTy);
3579 auto *NewTy = NewLI.
getType();
3581 if (NewTy == OldLI.
getType()) {
3590 if (!NewTy->isPointerTy())
3593 unsigned BitWidth =
DL.getPointerTypeSizeInBits(NewTy);
3605 for (
auto *DII : DbgUsers)
3607 for (
auto *DVR : DPUsers)
3608 DVR->eraseFromParent();
3637 I->dropUBImplyingAttrsAndMetadata();
3638 if (
I->isUsedByMetadata())
3641 I->dropDbgRecords();
3642 if (
I->isDebugOrPseudoInst()) {
3644 II =
I->eraseFromParent();
3658 const APInt &API = cast<ConstantInt>(&CV)->getValue();
3659 std::optional<int64_t> InitIntOpt = API.
trySExtValue();
3661 static_cast<uint64_t>(*InitIntOpt))
3665 if (isa<ConstantInt>(
C))
3666 return createIntegerExpression(
C);
3668 auto *
FP = dyn_cast<ConstantFP>(&
C);
3680 if (isa<ConstantPointerNull>(
C))
3684 if (CE->getOpcode() == Instruction::IntToPtr) {
3685 const Value *V = CE->getOperand(0);
3686 if (
auto CI = dyn_cast_or_null<ConstantInt>(V))
3687 return createIntegerExpression(*CI);
3693 auto RemapDebugOperands = [&Mapping](
auto *DV,
auto Set) {
3694 for (
auto *
Op : Set) {
3696 if (
I != Mapping.
end())
3697 DV->replaceVariableLocationOp(
Op,
I->second,
true);
3700 auto RemapAssignAddress = [&Mapping](
auto *DA) {
3701 auto I = Mapping.
find(DA->getAddress());
3702 if (
I != Mapping.
end())
3703 DA->setAddress(
I->second);
3705 if (
auto DVI = dyn_cast<DbgVariableIntrinsic>(Inst))
3706 RemapDebugOperands(DVI, DVI->location_ops());
3707 if (
auto DAI = dyn_cast<DbgAssignIntrinsic>(Inst))
3708 RemapAssignAddress(DAI);
3710 RemapDebugOperands(&DVR, DVR.location_ops());
3711 if (DVR.isDbgAssign())
3712 RemapAssignAddress(&DVR);
3721 BitPart(
Value *
P,
unsigned BW) : Provider(
P) {
3722 Provenance.resize(BW);
3732 enum { Unset = -1 };
3764static const std::optional<BitPart> &
3766 std::map<
Value *, std::optional<BitPart>> &BPS,
int Depth,
3768 auto I = BPS.find(V);
3772 auto &Result = BPS[V] = std::nullopt;
3773 auto BitWidth = V->getType()->getScalarSizeInBits();
3781 LLVM_DEBUG(
dbgs() <<
"collectBitParts max recursion depth reached.\n");
3785 if (
auto *
I = dyn_cast<Instruction>(V)) {
3793 Depth + 1, FoundRoot);
3794 if (!
A || !
A->Provider)
3798 Depth + 1, FoundRoot);
3799 if (!
B ||
A->Provider !=
B->Provider)
3803 Result = BitPart(
A->Provider,
BitWidth);
3804 for (
unsigned BitIdx = 0; BitIdx <
BitWidth; ++BitIdx) {
3805 if (
A->Provenance[BitIdx] != BitPart::Unset &&
3806 B->Provenance[BitIdx] != BitPart::Unset &&
3807 A->Provenance[BitIdx] !=
B->Provenance[BitIdx])
3808 return Result = std::nullopt;
3810 if (
A->Provenance[BitIdx] == BitPart::Unset)
3811 Result->Provenance[BitIdx] =
B->Provenance[BitIdx];
3813 Result->Provenance[BitIdx] =
A->Provenance[BitIdx];
3821 const APInt &BitShift = *
C;
3828 if (!MatchBitReversals && (BitShift.
getZExtValue() % 8) != 0)
3832 Depth + 1, FoundRoot);
3838 auto &
P = Result->Provenance;
3839 if (
I->getOpcode() == Instruction::Shl) {
3853 const APInt &AndMask = *
C;
3857 unsigned NumMaskedBits = AndMask.
popcount();
3858 if (!MatchBitReversals && (NumMaskedBits % 8) != 0)
3862 Depth + 1, FoundRoot);
3867 for (
unsigned BitIdx = 0; BitIdx <
BitWidth; ++BitIdx)
3869 if (AndMask[BitIdx] == 0)
3870 Result->Provenance[BitIdx] = BitPart::Unset;
3877 Depth + 1, FoundRoot);
3881 Result = BitPart(Res->Provider,
BitWidth);
3882 auto NarrowBitWidth =
X->getType()->getScalarSizeInBits();
3883 for (
unsigned BitIdx = 0; BitIdx < NarrowBitWidth; ++BitIdx)
3884 Result->Provenance[BitIdx] = Res->Provenance[BitIdx];
3885 for (
unsigned BitIdx = NarrowBitWidth; BitIdx <
BitWidth; ++BitIdx)
3886 Result->Provenance[BitIdx] = BitPart::Unset;
3893 Depth + 1, FoundRoot);
3897 Result = BitPart(Res->Provider,
BitWidth);
3898 for (
unsigned BitIdx = 0; BitIdx <
BitWidth; ++BitIdx)
3899 Result->Provenance[BitIdx] = Res->Provenance[BitIdx];
3907 Depth + 1, FoundRoot);
3911 Result = BitPart(Res->Provider,
BitWidth);
3912 for (
unsigned BitIdx = 0; BitIdx <
BitWidth; ++BitIdx)
3913 Result->Provenance[(
BitWidth - 1) - BitIdx] = Res->Provenance[BitIdx];
3920 Depth + 1, FoundRoot);
3925 Result = BitPart(Res->Provider,
BitWidth);
3926 for (
unsigned ByteIdx = 0; ByteIdx < ByteWidth; ++ByteIdx) {
3927 unsigned ByteBitOfs = ByteIdx * 8;
3928 for (
unsigned BitIdx = 0; BitIdx < 8; ++BitIdx)
3929 Result->Provenance[(
BitWidth - 8 - ByteBitOfs) + BitIdx] =
3930 Res->Provenance[ByteBitOfs + BitIdx];
3947 if (!MatchBitReversals && (ModAmt % 8) != 0)
3952 Depth + 1, FoundRoot);
3953 if (!
LHS || !
LHS->Provider)
3957 Depth + 1, FoundRoot);
3958 if (!
RHS ||
LHS->Provider !=
RHS->Provider)
3961 unsigned StartBitRHS =
BitWidth - ModAmt;
3963 for (
unsigned BitIdx = 0; BitIdx < StartBitRHS; ++BitIdx)
3964 Result->Provenance[BitIdx + ModAmt] =
LHS->Provenance[BitIdx];
3965 for (
unsigned BitIdx = 0; BitIdx < ModAmt; ++BitIdx)
3966 Result->Provenance[BitIdx] =
RHS->Provenance[BitIdx + StartBitRHS];
3980 for (
unsigned BitIdx = 0; BitIdx <
BitWidth; ++BitIdx)
3981 Result->Provenance[BitIdx] = BitIdx;
3987 if (
From % 8 != To % 8)
4002 Instruction *
I,
bool MatchBSwaps,
bool MatchBitReversals,
4009 if (!MatchBSwaps && !MatchBitReversals)
4011 Type *ITy =
I->getType();
4016 bool FoundRoot =
false;
4017 std::map<Value *, std::optional<BitPart>> BPS;
4024 [](int8_t
I) {
return I == BitPart::Unset || 0 <=
I; }) &&
4025 "Illegal bit provenance index");
4028 Type *DemandedTy = ITy;
4029 if (BitProvenance.
back() == BitPart::Unset) {
4030 while (!BitProvenance.
empty() && BitProvenance.
back() == BitPart::Unset)
4031 BitProvenance = BitProvenance.
drop_back();
4032 if (BitProvenance.
empty())
4035 if (
auto *IVecTy = dyn_cast<VectorType>(ITy))
4036 DemandedTy = VectorType::get(DemandedTy, IVecTy);
4047 bool OKForBSwap = MatchBSwaps && (DemandedBW % 16) == 0;
4048 bool OKForBitReverse = MatchBitReversals;
4049 for (
unsigned BitIdx = 0;
4050 (BitIdx < DemandedBW) && (OKForBSwap || OKForBitReverse); ++BitIdx) {
4051 if (BitProvenance[BitIdx] == BitPart::Unset) {
4058 BitIdx, DemandedBW);
4063 Intrin = Intrinsic::bswap;
4064 else if (OKForBitReverse)
4065 Intrin = Intrinsic::bitreverse;
4070 Value *Provider = Res->Provider;
4073 if (DemandedTy != Provider->
getType()) {
4084 auto *Mask = ConstantInt::get(DemandedTy, DemandedMask);
4090 if (ITy != Result->getType()) {
4107 if (
F && !
F->hasLocalLinkage() &&
F->hasName() &&
4109 !
F->doesNotAccessMemory())
4115 if (
I->getOperand(OpIdx)->getType()->isMetadataTy())
4119 if (!isa<Constant>(
I->getOperand(OpIdx)))
4122 switch (
I->getOpcode()) {
4125 case Instruction::Call:
4126 case Instruction::Invoke: {
4127 const auto &CB = cast<CallBase>(*
I);
4130 if (CB.isInlineAsm())
4135 if (CB.isBundleOperand(OpIdx))
4138 if (OpIdx < CB.arg_size()) {
4141 if (isa<IntrinsicInst>(CB) &&
4142 OpIdx >= CB.getFunctionType()->getNumParams()) {
4144 return CB.getIntrinsicID() == Intrinsic::experimental_stackmap;
4149 if (CB.getIntrinsicID() == Intrinsic::gcroot)
4153 return !CB.paramHasAttr(OpIdx, Attribute::ImmArg);
4158 return !isa<IntrinsicInst>(CB);
4160 case Instruction::ShuffleVector:
4163 case Instruction::Switch:
4164 case Instruction::ExtractValue:
4167 case Instruction::InsertValue:
4170 case Instruction::Alloca:
4174 return !cast<AllocaInst>(
I)->isStaticAlloca();
4175 case Instruction::GetElementPtr:
4179 for (
auto E = std::next(It, OpIdx); It != E; ++It)
4188 if (
Constant *
C = dyn_cast<Constant>(Condition))
4192 Value *NotCondition;
4194 return NotCondition;
4197 Instruction *Inst = dyn_cast<Instruction>(Condition);
4200 else if (
Argument *Arg = dyn_cast<Argument>(Condition))
4202 assert(Parent &&
"Unsupported condition to invert");
4213 if (Inst && !isa<PHINode>(Inst))
4214 Inverted->insertAfter(Inst);
4224 bool Changed =
false;
4226 if (!
F.hasFnAttribute(Attribute::NoSync) &&
4227 F.doesNotAccessMemory() && !
F.isConvergent()) {
4233 if (!
F.hasFnAttribute(Attribute::NoFree) &&
F.onlyReadsMemory()) {
4234 F.setDoesNotFreeMemory();
4239 if (!
F.hasFnAttribute(Attribute::MustProgress) &&
F.willReturn()) {
4240 F.setMustProgress();
for(const MachineOperand &MO :llvm::drop_begin(OldMI.operands(), Desc.getNumOperands()))
static unsigned getIntrinsicID(const SDNode *N)
This file implements a class to represent arbitrary precision integral constant values and operations...
ReachingDefAnalysis InstSet & ToRemove
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
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...
This defines the Use class.
iv Induction Variable Users
This file provides utility for Memory Model Relaxation Annotations (MMRAs).
Module.h This file contains the declarations for the Module class.
uint64_t IntrinsicInst * II
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)
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.
const DataLayout & getDataLayout() const
Get the data layout of the module this basic block belongs to.
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...
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
void removePredecessor(BasicBlock *Pred, bool KeepOneInputPHIs=false)
Update PHI nodes in this BasicBlock before removal of predecessor Pred.
BinaryOps getOpcode() const
static BinaryOperator * CreateNot(Value *Op, const Twine &Name="", InsertPosition InsertBefore=nullptr)
static BinaryOperator * Create(BinaryOps Op, Value *S1, Value *S2, const Twine &Name=Twine(), InsertPosition InsertBefore=nullptr)
Construct a binary instruction, given the opcode and the two operands.
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, InsertPosition 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="", InsertPosition InsertBefore=nullptr)
static CastInst * CreateIntegerCast(Value *S, Type *Ty, bool isSigned, const Twine &Name="", InsertPosition InsertBefore=nullptr)
Create a ZExt, BitCast, or Trunc for int -> int casts.
static CatchSwitchInst * Create(Value *ParentPad, BasicBlock *UnwindDest, unsigned NumHandlers, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
static CleanupReturnInst * Create(Value *CleanupPad, BasicBlock *UnwindBB=nullptr, InsertPosition 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.
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.
DIExpression * foldConstantMath()
Try to shorten an expression with constant math operations that can be evaluated at compile time.
uint64_t getNumLocationOperands() const
Return the number of unique location operands referred to (via DW_OP_LLVM_arg) in this expression; th...
std::optional< uint64_t > getActiveBits(DIVariable *Var)
Return the number of bits that have an active value, i.e.
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, bool AllowEmpty=false)
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.
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.
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 deleteBB(BasicBlock *DelBB)
Delete DelBB.
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
void applyUpdatesPermissive(ArrayRef< typename DomTreeT::UpdateType > Updates)
Submit updates to all available trees.
void applyUpdates(ArrayRef< typename DomTreeT::UpdateType > Updates)
Submit updates to all available trees.
bool hasDomTree() const
Returns true if it holds a DomTreeT.
bool isBBPendingDeletion(BasicBlockT *DelBB) const
Returns true if DelBB is awaiting deletion.
void recalculate(FuncT &F)
Notify DTU that the entry block was replaced.
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...
iterator_range< simple_ilist< DbgRecord >::iterator > getDbgRecordRange() const
Return a range over the DbgRecords attached to this instruction.
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.
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.
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.
const DataLayout & getDataLayout() const
Get the data layout of the module this instruction belongs to.
A wrapper class for inspecting calls to intrinsic functions.
static InvokeInst * Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal, BasicBlock *IfException, ArrayRef< Value * > Args, const Twine &NameStr, InsertPosition InsertBefore=nullptr)
This is an important class for using LLVM in a threaded context.
An instruction for reading from memory.
Value * getPointerOperand()
MDNode * createBranchWeights(uint32_t TrueWeight, uint32_t FalseWeight, bool IsExpected=false)
Return metadata containing two branch weights.
MDNode * createRange(const APInt &Lo, const APInt &Hi)
Return metadata describing the range [Lo, Hi).
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)