94#define DEBUG_TYPE "dse"
96STATISTIC(NumRemainingStores,
"Number of stores remaining after DSE");
97STATISTIC(NumRedundantStores,
"Number of redundant stores deleted");
98STATISTIC(NumFastStores,
"Number of stores deleted");
99STATISTIC(NumFastOther,
"Number of other instrs removed");
100STATISTIC(NumCompletePartials,
"Number of stores dead by later partials");
101STATISTIC(NumModifiedStores,
"Number of stores modified");
106 "Number of times a valid candidate is returned from getDomMemoryDef");
108 "Number iterations check for reads in getDomMemoryDef");
111 "Controls which MemoryDefs are eliminated.");
116 cl::desc(
"Enable partial-overwrite tracking in DSE"));
121 cl::desc(
"Enable partial store merging in DSE"));
125 cl::desc(
"The number of memory instructions to scan for "
126 "dead store elimination (default = 150)"));
129 cl::desc(
"The maximum number of steps while walking upwards to find "
130 "MemoryDefs that may be killed (default = 90)"));
134 cl::desc(
"The maximum number candidates that only partially overwrite the "
135 "killing MemoryDef to consider"
140 cl::desc(
"The number of MemoryDefs we consider as candidates to eliminated "
141 "other stores per basic block (default = 5000)"));
146 "The cost of a step in the same basic block as the killing MemoryDef"
152 cl::desc(
"The cost of a step in a different basic "
153 "block than the killing MemoryDef"
158 cl::desc(
"The maximum number of blocks to check when trying to prove that "
159 "all paths to an exit go through a killing block (default = 50)"));
169 cl::desc(
"Allow DSE to optimize memory accesses."));
174 cl::desc(
"Enable the initializes attr improvement in DSE"));
190 switch (
II->getIntrinsicID()) {
191 default:
return false;
192 case Intrinsic::memset:
193 case Intrinsic::memcpy:
194 case Intrinsic::memcpy_element_unordered_atomic:
195 case Intrinsic::memset_element_unordered_atomic:
230enum OverwriteResult {
234 OW_PartialEarlierWithFullLater,
250 if (KillingII ==
nullptr || DeadII ==
nullptr)
252 if (KillingII->getIntrinsicID() != DeadII->getIntrinsicID())
255 switch (KillingII->getIntrinsicID()) {
256 case Intrinsic::masked_store:
257 case Intrinsic::vp_store: {
259 auto *KillingTy = KillingII->getArgOperand(0)->getType();
260 auto *DeadTy = DeadII->getArgOperand(0)->getType();
261 if (
DL.getTypeSizeInBits(KillingTy) !=
DL.getTypeSizeInBits(DeadTy))
268 Value *KillingPtr = KillingII->getArgOperand(1);
269 Value *DeadPtr = DeadII->getArgOperand(1);
270 if (KillingPtr != DeadPtr && !
AA.isMustAlias(KillingPtr, DeadPtr))
272 if (KillingII->getIntrinsicID() == Intrinsic::masked_store) {
275 if (KillingII->getArgOperand(2) != DeadII->getArgOperand(2))
277 }
else if (KillingII->getIntrinsicID() == Intrinsic::vp_store) {
280 if (KillingII->getArgOperand(2) != DeadII->getArgOperand(2))
283 if (KillingII->getArgOperand(3) != DeadII->getArgOperand(3))
305 int64_t KillingOff, int64_t DeadOff,
316 KillingOff < int64_t(DeadOff + DeadSize) &&
317 int64_t(KillingOff + KillingSize) >= DeadOff) {
320 auto &IM = IOL[DeadI];
321 LLVM_DEBUG(
dbgs() <<
"DSE: Partial overwrite: DeadLoc [" << DeadOff <<
", "
322 << int64_t(DeadOff + DeadSize) <<
") KillingLoc ["
323 << KillingOff <<
", " << int64_t(KillingOff + KillingSize)
330 int64_t KillingIntStart = KillingOff;
331 int64_t KillingIntEnd = KillingOff + KillingSize;
335 auto ILI = IM.lower_bound(KillingIntStart);
336 if (ILI != IM.end() && ILI->second <= KillingIntEnd) {
340 KillingIntStart = std::min(KillingIntStart, ILI->second);
341 KillingIntEnd = std::max(KillingIntEnd, ILI->first);
350 while (ILI != IM.end() && ILI->second <= KillingIntEnd) {
351 assert(ILI->second > KillingIntStart &&
"Unexpected interval");
352 KillingIntEnd = std::max(KillingIntEnd, ILI->first);
357 IM[KillingIntEnd] = KillingIntStart;
360 if (ILI->second <= DeadOff && ILI->first >= int64_t(DeadOff + DeadSize)) {
361 LLVM_DEBUG(
dbgs() <<
"DSE: Full overwrite from partials: DeadLoc ["
362 << DeadOff <<
", " << int64_t(DeadOff + DeadSize)
363 <<
") Composite KillingLoc [" << ILI->second <<
", "
364 << ILI->first <<
")\n");
365 ++NumCompletePartials;
373 int64_t(DeadOff + DeadSize) > KillingOff &&
374 uint64_t(KillingOff - DeadOff) + KillingSize <= DeadSize) {
375 LLVM_DEBUG(
dbgs() <<
"DSE: Partial overwrite a dead load [" << DeadOff
376 <<
", " << int64_t(DeadOff + DeadSize)
377 <<
") by a killing store [" << KillingOff <<
", "
378 << int64_t(KillingOff + KillingSize) <<
")\n");
380 return OW_PartialEarlierWithFullLater;
393 (KillingOff > DeadOff && KillingOff < int64_t(DeadOff + DeadSize) &&
394 int64_t(KillingOff + KillingSize) >= int64_t(DeadOff + DeadSize)))
407 (KillingOff <= DeadOff && int64_t(KillingOff + KillingSize) > DeadOff)) {
408 assert(int64_t(KillingOff + KillingSize) < int64_t(DeadOff + DeadSize) &&
409 "Expect to be handled as OW_Complete");
429 using BlockAddressPair = std::pair<BasicBlock *, PHITransAddr>;
446 auto *MemLocPtr =
const_cast<Value *
>(MemLoc.
Ptr);
451 bool isFirstBlock =
true;
454 while (!WorkList.
empty()) {
466 assert(
B == SecondBB &&
"first block is not the store block");
468 isFirstBlock =
false;
474 for (; BI != EI; ++BI) {
476 if (
I->mayWriteToMemory() &&
I != SecondI)
482 "Should not hit the entry block because SI must be dominated by LI");
492 auto Inserted = Visited.
insert(std::make_pair(Pred, TranslatedPtr));
493 if (!Inserted.second) {
496 if (TranslatedPtr != Inserted.first->second)
501 WorkList.
push_back(std::make_pair(Pred, PredAddr));
510 uint64_t NewSizeInBits,
bool IsOverwriteEnd) {
512 uint64_t DeadSliceSizeInBits = OldSizeInBits - NewSizeInBits;
514 OldOffsetInBits + (IsOverwriteEnd ? NewSizeInBits : 0);
515 auto SetDeadFragExpr = [](
auto *Assign,
519 uint64_t RelativeOffset = DeadFragment.OffsetInBits -
520 Assign->getExpression()
525 Assign->getExpression(), RelativeOffset, DeadFragment.SizeInBits)) {
526 Assign->setExpression(*
NewExpr);
533 DeadFragment.SizeInBits);
534 Assign->setExpression(Expr);
535 Assign->setKillLocation();
542 auto GetDeadLink = [&Ctx, &LinkToNothing]() {
545 return LinkToNothing;
551 std::optional<DIExpression::FragmentInfo> NewFragment;
553 DeadSliceSizeInBits, Assign,
558 Assign->setKillAddress();
559 Assign->setAssignId(GetDeadLink());
563 if (NewFragment->SizeInBits == 0)
567 auto *NewAssign =
static_cast<decltype(Assign)
>(Assign->clone());
568 NewAssign->insertAfter(Assign->getIterator());
569 NewAssign->setAssignId(GetDeadLink());
571 SetDeadFragExpr(NewAssign, *NewFragment);
572 NewAssign->setKillAddress();
586 for (
auto &Attr : OldAttrs) {
587 if (Attr.hasKindAsEnum()) {
588 switch (Attr.getKindAsEnum()) {
591 case Attribute::Alignment:
593 if (
isAligned(Attr.getAlignment().valueOrOne(), PtrOffset))
596 case Attribute::Dereferenceable:
597 case Attribute::DereferenceableOrNull:
601 case Attribute::NonNull:
602 case Attribute::NoUndef:
610 Intrinsic->removeParamAttrs(ArgNo, AttrsToRemove);
614 uint64_t &DeadSize, int64_t KillingStart,
615 uint64_t KillingSize,
bool IsOverwriteEnd) {
617 Align PrefAlign = DeadIntrinsic->getDestAlign().valueOrOne();
633 int64_t ToRemoveStart = 0;
637 if (IsOverwriteEnd) {
642 ToRemoveStart = KillingStart + Off;
643 if (DeadSize <=
uint64_t(ToRemoveStart - DeadStart))
645 ToRemoveSize = DeadSize -
uint64_t(ToRemoveStart - DeadStart);
647 ToRemoveStart = DeadStart;
649 "Not overlapping accesses?");
650 ToRemoveSize = KillingSize -
uint64_t(DeadStart - KillingStart);
655 if (ToRemoveSize <= (PrefAlign.
value() - Off))
657 ToRemoveSize -= PrefAlign.
value() - Off;
660 "Should preserve selected alignment");
663 assert(ToRemoveSize > 0 &&
"Shouldn't reach here if nothing to remove");
664 assert(DeadSize > ToRemoveSize &&
"Can't remove more than original size");
666 uint64_t NewSize = DeadSize - ToRemoveSize;
667 if (DeadIntrinsic->isAtomic()) {
670 const uint32_t ElementSize = DeadIntrinsic->getElementSizeInBytes();
671 if (0 != NewSize % ElementSize)
676 << (IsOverwriteEnd ?
"END" :
"BEGIN") <<
": " << *DeadI
677 <<
"\n KILLER [" << ToRemoveStart <<
", "
678 << int64_t(ToRemoveStart + ToRemoveSize) <<
")\n");
680 DeadIntrinsic->setLength(NewSize);
681 DeadIntrinsic->setDestAlignment(PrefAlign);
683 Value *OrigDest = DeadIntrinsic->getRawDest();
684 if (!IsOverwriteEnd) {
685 Value *Indices[1] = {
686 ConstantInt::get(DeadIntrinsic->getLength()->getType(), ToRemoveSize)};
690 NewDestGEP->
setDebugLoc(DeadIntrinsic->getDebugLoc());
691 DeadIntrinsic->setDest(NewDestGEP);
701 DeadStart += ToRemoveSize;
708 int64_t &DeadStart,
uint64_t &DeadSize) {
713 int64_t KillingStart = OII->second;
714 uint64_t KillingSize = OII->first - KillingStart;
716 assert(OII->first - KillingStart >= 0 &&
"Size expected to be positive");
718 if (KillingStart > DeadStart &&
721 (
uint64_t)(KillingStart - DeadStart) < DeadSize &&
724 KillingSize >= DeadSize - (
uint64_t)(KillingStart - DeadStart)) {
725 if (
tryToShorten(DeadI, DeadStart, DeadSize, KillingStart, KillingSize,
736 int64_t &DeadStart,
uint64_t &DeadSize) {
741 int64_t KillingStart = OII->second;
742 uint64_t KillingSize = OII->first - KillingStart;
744 assert(OII->first - KillingStart >= 0 &&
"Size expected to be positive");
746 if (KillingStart <= DeadStart &&
749 KillingSize > (
uint64_t)(DeadStart - KillingStart)) {
752 assert(KillingSize - (
uint64_t)(DeadStart - KillingStart) < DeadSize &&
753 "Should have been handled as OW_Complete");
754 if (
tryToShorten(DeadI, DeadStart, DeadSize, KillingStart, KillingSize,
765 int64_t KillingOffset, int64_t DeadOffset,
792 unsigned BitOffsetDiff = (KillingOffset - DeadOffset) * 8;
793 unsigned LShiftAmount =
794 DL.isBigEndian() ? DeadValue.
getBitWidth() - BitOffsetDiff - KillingBits
797 LShiftAmount + KillingBits);
800 APInt Merged = (DeadValue & ~Mask) | (KillingValue << LShiftAmount);
802 <<
"\n Killing: " << *KillingI
803 <<
"\n Merged Value: " << Merged <<
'\n');
812 switch (
II->getIntrinsicID()) {
813 case Intrinsic::lifetime_start:
814 case Intrinsic::lifetime_end:
815 case Intrinsic::invariant_end:
816 case Intrinsic::launder_invariant_group:
817 case Intrinsic::assume:
819 case Intrinsic::dbg_declare:
820 case Intrinsic::dbg_label:
821 case Intrinsic::dbg_value:
836 if (CB->onlyAccessesInaccessibleMemory())
841 if (DI->
mayThrow() && !DefVisibleToCaller)
863struct MemoryLocationWrapper {
864 MemoryLocationWrapper(MemoryLocation MemLoc, MemoryDef *MemDef,
865 bool DefByInitializesAttr)
866 : MemLoc(MemLoc), MemDef(MemDef),
867 DefByInitializesAttr(DefByInitializesAttr) {
868 assert(MemLoc.Ptr &&
"MemLoc should be not null");
870 DefInst = MemDef->getMemoryInst();
873 MemoryLocation MemLoc;
874 const Value *UnderlyingObject;
877 bool DefByInitializesAttr =
false;
882struct MemoryDefWrapper {
883 MemoryDefWrapper(MemoryDef *MemDef,
884 ArrayRef<std::pair<MemoryLocation, bool>> MemLocations) {
886 for (
auto &[MemLoc, DefByInitializesAttr] : MemLocations)
887 DefinedLocations.push_back(
888 MemoryLocationWrapper(MemLoc, MemDef, DefByInitializesAttr));
894struct ArgumentInitInfo {
896 bool IsDeadOrInvisibleOnUnwind;
897 ConstantRangeList Inits;
912 bool CallHasNoUnwindAttr) {
918 for (
const auto &Arg : Args) {
919 if (!CallHasNoUnwindAttr && !Arg.IsDeadOrInvisibleOnUnwind)
921 if (Arg.Inits.empty())
926 for (
auto &Arg : Args.drop_front())
927 IntersectedIntervals = IntersectedIntervals.
intersectWith(Arg.Inits);
929 return IntersectedIntervals;
937 EarliestEscapeAnalysis EA;
946 BatchAAResults BatchAA;
950 PostDominatorTree &PDT;
951 const TargetLibraryInfo &TLI;
952 const DataLayout &DL;
957 bool ContainsIrreducibleLoops;
962 SmallPtrSet<MemoryAccess *, 4> SkipStores;
964 DenseMap<const Value *, bool> CapturedBeforeReturn;
967 DenseMap<const Value *, bool> InvisibleToCallerAfterRet;
969 SmallPtrSet<BasicBlock *, 16> ThrowingBlocks;
972 DenseMap<BasicBlock *, unsigned> PostOrderNumbers;
976 MapVector<BasicBlock *, InstOverlapIntervalsTy> IOLs;
980 bool AnyUnreachableExit;
985 bool ShouldIterateEndOfFunctionDSE;
991 DSEState(
const DSEState &) =
delete;
992 DSEState &operator=(
const DSEState &) =
delete;
995 PostDominatorTree &PDT,
const TargetLibraryInfo &TLI,
997 : F(F), AA(AA), EA(DT, &LI), BatchAA(AA, &EA), MSSA(MSSA), DT(DT),
998 PDT(PDT), TLI(TLI), DL(F.getDataLayout()), LI(LI) {
1003 PostOrderNumbers[BB] = PO++;
1004 for (Instruction &
I : *BB) {
1005 MemoryAccess *MA = MSSA.getMemoryAccess(&
I);
1006 if (
I.mayThrow() && !MA)
1007 ThrowingBlocks.insert(
I.getParent());
1011 (getLocForWrite(&
I) || isMemTerminatorInst(&
I) ||
1013 MemDefs.push_back(MD);
1019 for (Argument &AI : F.args())
1020 if (AI.hasPassPointeeByValueCopyAttr() || AI.hasDeadOnReturnAttr())
1021 InvisibleToCallerAfterRet.insert({&AI, true});
1026 AnyUnreachableExit =
any_of(PDT.roots(), [](
const BasicBlock *
E) {
1027 return isa<UnreachableInst>(E->getTerminator());
1031 static void pushMemUses(MemoryAccess *Acc,
1032 SmallVectorImpl<MemoryAccess *> &WorkList,
1033 SmallPtrSetImpl<MemoryAccess *> &Visited) {
1034 for (Use &U : Acc->
uses()) {
1036 if (Visited.
insert(MA).second)
1041 LocationSize strengthenLocationSize(
const Instruction *
I,
1042 LocationSize
Size)
const {
1045 if (TLI.getLibFunc(*CB, F) && TLI.has(F) &&
1046 (F == LibFunc_memset_chk || F == LibFunc_memcpy_chk)) {
1070 OverwriteResult isOverwrite(
const Instruction *KillingI,
1071 const Instruction *DeadI,
1072 const MemoryLocation &KillingLoc,
1073 const MemoryLocation &DeadLoc,
1074 int64_t &KillingOff, int64_t &DeadOff) {
1078 if (!isGuaranteedLoopIndependent(DeadI, KillingI, DeadLoc))
1081 LocationSize KillingLocSize =
1082 strengthenLocationSize(KillingI, KillingLoc.
Size);
1090 if (DeadUndObj == KillingUndObj && KillingLocSize.
isPrecise() &&
1092 std::optional<TypeSize> KillingUndObjSize =
1094 if (KillingUndObjSize && *KillingUndObjSize == KillingLocSize.
getValue())
1105 if (KillingMemI && DeadMemI) {
1106 const Value *KillingV = KillingMemI->getLength();
1107 const Value *DeadV = DeadMemI->getLength();
1108 if (KillingV == DeadV && BatchAA.isMustAlias(DeadLoc, KillingLoc))
1117 const TypeSize KillingSize = KillingLocSize.
getValue();
1121 const bool AnyScalable =
1127 AliasResult AAR = BatchAA.alias(KillingLoc, DeadLoc);
1133 if (KillingSize >= DeadSize)
1140 if (Off >= 0 && (uint64_t)Off + DeadSize <= KillingSize)
1146 if (DeadUndObj != KillingUndObj) {
1162 const Value *DeadBasePtr =
1164 const Value *KillingBasePtr =
1169 if (DeadBasePtr != KillingBasePtr)
1187 if (DeadOff >= KillingOff) {
1190 if (uint64_t(DeadOff - KillingOff) + DeadSize <= KillingSize)
1194 else if ((uint64_t)(DeadOff - KillingOff) < KillingSize)
1195 return OW_MaybePartial;
1199 else if ((uint64_t)(KillingOff - DeadOff) < DeadSize) {
1200 return OW_MaybePartial;
1207 bool isInvisibleToCallerAfterRet(
const Value *V) {
1211 auto I = InvisibleToCallerAfterRet.insert({
V,
false});
1212 if (
I.second && isInvisibleToCallerOnUnwind(V) &&
isNoAliasCall(V))
1214 V,
true, CaptureComponents::Provenance));
1215 return I.first->second;
1218 bool isInvisibleToCallerOnUnwind(
const Value *V) {
1219 bool RequiresNoCaptureBeforeUnwind;
1222 if (!RequiresNoCaptureBeforeUnwind)
1225 auto I = CapturedBeforeReturn.insert({
V,
true});
1232 V,
false, CaptureComponents::Provenance));
1233 return !
I.first->second;
1236 std::optional<MemoryLocation> getLocForWrite(Instruction *
I)
const {
1237 if (!
I->mayWriteToMemory())
1238 return std::nullopt;
1249 getLocForInst(Instruction *
I,
bool ConsiderInitializesAttr) {
1251 if (isMemTerminatorInst(
I)) {
1252 if (
auto Loc = getLocForTerminator(
I))
1253 Locations.push_back(std::make_pair(Loc->first,
false));
1257 if (
auto Loc = getLocForWrite(
I))
1258 Locations.push_back(std::make_pair(*Loc,
false));
1260 if (ConsiderInitializesAttr) {
1261 for (
auto &MemLoc : getInitializesArgMemLoc(
I)) {
1262 Locations.push_back(std::make_pair(MemLoc,
true));
1270 bool isRemovable(Instruction *
I) {
1271 assert(getLocForWrite(
I) &&
"Must have analyzable write");
1275 return SI->isUnordered();
1280 return !
MI->isVolatile();
1284 if (CB->isLifetimeStartOrEnd())
1287 return CB->use_empty() && CB->willReturn() && CB->doesNotThrow() &&
1288 !CB->isTerminator();
1296 bool isCompleteOverwrite(
const MemoryLocation &DefLoc, Instruction *DefInst,
1297 Instruction *UseInst) {
1305 if (CB->onlyAccessesInaccessibleMemory())
1308 int64_t InstWriteOffset, DepWriteOffset;
1309 if (
auto CC = getLocForWrite(UseInst))
1310 return isOverwrite(UseInst, DefInst, *CC, DefLoc, InstWriteOffset,
1311 DepWriteOffset) == OW_Complete;
1316 bool isWriteAtEndOfFunction(MemoryDef *Def,
const MemoryLocation &DefLoc) {
1318 << *
Def->getMemoryInst()
1319 <<
") is at the end the function \n");
1321 SmallPtrSet<MemoryAccess *, 8> Visited;
1323 pushMemUses(Def, WorkList, Visited);
1324 for (
unsigned I = 0;
I < WorkList.
size();
I++) {
1330 MemoryAccess *UseAccess = WorkList[
I];
1335 if (!isGuaranteedLoopInvariant(DefLoc.
Ptr))
1344 if (isReadClobber(DefLoc, UseInst)) {
1345 LLVM_DEBUG(
dbgs() <<
" ... hit read clobber " << *UseInst <<
".\n");
1350 pushMemUses(UseDef, WorkList, Visited);
1358 std::optional<std::pair<MemoryLocation, bool>>
1359 getLocForTerminator(Instruction *
I)
const {
1361 if (CB->getIntrinsicID() == Intrinsic::lifetime_end)
1368 return std::nullopt;
1373 bool isMemTerminatorInst(Instruction *
I)
const {
1375 return CB && (CB->getIntrinsicID() == Intrinsic::lifetime_end ||
1381 bool isMemTerminator(
const MemoryLocation &Loc, Instruction *AccessI,
1382 Instruction *MaybeTerm) {
1383 std::optional<std::pair<MemoryLocation, bool>> MaybeTermLoc =
1384 getLocForTerminator(MaybeTerm);
1395 auto TermLoc = MaybeTermLoc->first;
1396 if (MaybeTermLoc->second) {
1398 return BatchAA.isMustAlias(TermLoc.Ptr, LocUO);
1400 int64_t InstWriteOffset = 0;
1401 int64_t DepWriteOffset = 0;
1402 return isOverwrite(MaybeTerm, AccessI, TermLoc, Loc, InstWriteOffset,
1403 DepWriteOffset) == OW_Complete;
1407 bool isReadClobber(
const MemoryLocation &DefLoc, Instruction *UseInst) {
1420 if (CB->onlyAccessesInaccessibleMemory())
1423 return isRefSet(BatchAA.getModRefInfo(UseInst, DefLoc));
1431 bool isGuaranteedLoopIndependent(
const Instruction *Current,
1432 const Instruction *KillingDef,
1433 const MemoryLocation &CurrentLoc) {
1440 const Loop *CurrentLI = LI.getLoopFor(Current->
getParent());
1441 if (!ContainsIrreducibleLoops && CurrentLI &&
1442 CurrentLI == LI.getLoopFor(KillingDef->
getParent()))
1445 return isGuaranteedLoopInvariant(CurrentLoc.
Ptr);
1451 bool isGuaranteedLoopInvariant(
const Value *
Ptr) {
1452 Ptr =
Ptr->stripPointerCasts();
1454 if (
GEP->hasAllConstantIndices())
1455 Ptr =
GEP->getPointerOperand()->stripPointerCasts();
1458 return I->getParent()->isEntryBlock() ||
1459 (!ContainsIrreducibleLoops && !LI.getLoopFor(
I->getParent()));
1470 std::optional<MemoryAccess *>
1471 getDomMemoryDef(MemoryDef *KillingDef, MemoryAccess *StartAccess,
1472 const MemoryLocation &KillingLoc,
const Value *KillingUndObj,
1473 unsigned &ScanLimit,
unsigned &WalkerStepLimit,
1474 bool IsMemTerm,
unsigned &PartialLimit,
1475 bool IsInitializesAttrMemLoc) {
1476 if (ScanLimit == 0 || WalkerStepLimit == 0) {
1478 return std::nullopt;
1481 MemoryAccess *Current = StartAccess;
1495 std::optional<MemoryLocation> CurrentLoc;
1498 dbgs() <<
" visiting " << *Current;
1506 if (MSSA.isLiveOnEntryDef(Current)) {
1511 return std::nullopt;
1519 if (WalkerStepLimit <= StepCost) {
1521 return std::nullopt;
1523 WalkerStepLimit -= StepCost;
1537 if (
canSkipDef(CurrentDef, !isInvisibleToCallerOnUnwind(KillingUndObj))) {
1538 CanOptimize =
false;
1544 if (mayThrowBetween(KillingI, CurrentI, KillingUndObj)) {
1546 return std::nullopt;
1551 if (isDSEBarrier(KillingUndObj, CurrentI)) {
1553 return std::nullopt;
1561 return std::nullopt;
1564 if (
any_of(Current->
uses(), [
this, &KillingLoc, StartAccess](Use &U) {
1565 if (auto *UseOrDef = dyn_cast<MemoryUseOrDef>(U.getUser()))
1566 return !MSSA.dominates(StartAccess, UseOrDef) &&
1567 isReadClobber(KillingLoc, UseOrDef->getMemoryInst());
1571 return std::nullopt;
1576 CurrentLoc = getLocForWrite(CurrentI);
1577 if (!CurrentLoc || !isRemovable(CurrentI)) {
1578 CanOptimize =
false;
1585 if (!isGuaranteedLoopIndependent(CurrentI, KillingI, *CurrentLoc)) {
1587 CanOptimize =
false;
1595 if (!isMemTerminator(*CurrentLoc, CurrentI, KillingI)) {
1596 CanOptimize =
false;
1600 int64_t KillingOffset = 0;
1601 int64_t DeadOffset = 0;
1602 auto OR = isOverwrite(KillingI, CurrentI, KillingLoc, *CurrentLoc,
1603 KillingOffset, DeadOffset);
1609 (OR == OW_Complete || OR == OW_MaybePartial))
1615 CanOptimize =
false;
1620 if (OR == OW_Unknown || OR == OW_None)
1622 else if (OR == OW_MaybePartial) {
1627 if (PartialLimit <= 1) {
1628 WalkerStepLimit -= 1;
1629 LLVM_DEBUG(
dbgs() <<
" ... reached partial limit ... continue with next access\n");
1642 SmallPtrSet<Instruction *, 16> KillingDefs;
1644 MemoryAccess *MaybeDeadAccess = Current;
1645 MemoryLocation MaybeDeadLoc = *CurrentLoc;
1647 LLVM_DEBUG(
dbgs() <<
" Checking for reads of " << *MaybeDeadAccess <<
" ("
1648 << *MaybeDeadI <<
")\n");
1651 SmallPtrSet<MemoryAccess *, 32> Visited;
1652 pushMemUses(MaybeDeadAccess, WorkList, Visited);
1655 for (
unsigned I = 0;
I < WorkList.
size();
I++) {
1656 MemoryAccess *UseAccess = WorkList[
I];
1660 if (ScanLimit < (WorkList.
size() -
I)) {
1662 return std::nullopt;
1665 NumDomMemDefChecks++;
1668 if (
any_of(KillingDefs, [
this, UseAccess](Instruction *KI) {
1669 return DT.properlyDominates(KI->
getParent(),
1672 LLVM_DEBUG(
dbgs() <<
" ... skipping, dominated by killing block\n");
1676 pushMemUses(UseAccess, WorkList, Visited);
1683 if (
any_of(KillingDefs, [
this, UseInst](Instruction *KI) {
1684 return DT.dominates(KI, UseInst);
1686 LLVM_DEBUG(
dbgs() <<
" ... skipping, dominated by killing def\n");
1692 if (isMemTerminator(MaybeDeadLoc, MaybeDeadI, UseInst)) {
1695 <<
" ... skipping, memterminator invalidates following accesses\n");
1701 pushMemUses(UseAccess, WorkList, Visited);
1705 if (UseInst->
mayThrow() && !isInvisibleToCallerOnUnwind(KillingUndObj)) {
1707 return std::nullopt;
1714 bool IsKillingDefFromInitAttr =
false;
1715 if (IsInitializesAttrMemLoc) {
1716 if (KillingI == UseInst &&
1718 IsKillingDefFromInitAttr =
true;
1721 if (isReadClobber(MaybeDeadLoc, UseInst) && !IsKillingDefFromInitAttr) {
1723 return std::nullopt;
1729 if (MaybeDeadAccess == UseAccess &&
1730 !isGuaranteedLoopInvariant(MaybeDeadLoc.
Ptr)) {
1731 LLVM_DEBUG(
dbgs() <<
" ... found not loop invariant self access\n");
1732 return std::nullopt;
1738 if (KillingDef == UseAccess || MaybeDeadAccess == UseAccess) {
1754 if (isCompleteOverwrite(MaybeDeadLoc, MaybeDeadI, UseInst)) {
1756 if (PostOrderNumbers.find(MaybeKillingBlock)->second <
1757 PostOrderNumbers.find(MaybeDeadAccess->
getBlock())->second) {
1758 if (!isInvisibleToCallerAfterRet(KillingUndObj)) {
1760 <<
" ... found killing def " << *UseInst <<
"\n");
1761 KillingDefs.
insert(UseInst);
1765 <<
" ... found preceeding def " << *UseInst <<
"\n");
1766 return std::nullopt;
1769 pushMemUses(UseDef, WorkList, Visited);
1776 if (!isInvisibleToCallerAfterRet(KillingUndObj)) {
1777 SmallPtrSet<BasicBlock *, 16> KillingBlocks;
1778 for (Instruction *KD : KillingDefs)
1779 KillingBlocks.
insert(KD->getParent());
1781 "Expected at least a single killing block");
1788 CommonPred = PDT.findNearestCommonDominator(CommonPred, BB);
1794 if (!PDT.dominates(CommonPred, MaybeDeadAccess->
getBlock())) {
1795 if (!AnyUnreachableExit)
1796 return std::nullopt;
1800 CommonPred =
nullptr;
1804 if (KillingBlocks.
count(CommonPred))
1805 return {MaybeDeadAccess};
1807 SetVector<BasicBlock *> WorkList;
1811 WorkList.
insert(CommonPred);
1813 for (BasicBlock *R : PDT.roots()) {
1821 for (
unsigned I = 0;
I < WorkList.
size();
I++) {
1824 if (KillingBlocks.
count(Current))
1826 if (Current == MaybeDeadAccess->
getBlock())
1827 return std::nullopt;
1831 if (!DT.isReachableFromEntry(Current))
1837 return std::nullopt;
1844 return {MaybeDeadAccess};
1851 SmallPtrSetImpl<MemoryAccess *> *
Deleted =
nullptr) {
1852 MemorySSAUpdater Updater(&MSSA);
1857 while (!NowDeadInsts.
empty()) {
1866 MemoryAccess *MA = MSSA.getMemoryAccess(DeadInst);
1871 SkipStores.insert(MD);
1875 if (
SI->getValueOperand()->getType()->isPointerTy()) {
1877 if (CapturedBeforeReturn.erase(UO))
1878 ShouldIterateEndOfFunctionDSE =
true;
1879 InvisibleToCallerAfterRet.erase(UO);
1884 Updater.removeMemoryAccess(MA);
1888 if (
I != IOLs.end())
1889 I->second.erase(DeadInst);
1891 for (Use &O : DeadInst->
operands())
1898 EA.removeInstruction(DeadInst);
1907 ToRemove.push_back(DeadInst);
1915 bool mayThrowBetween(Instruction *KillingI, Instruction *DeadI,
1916 const Value *KillingUndObj) {
1920 if (KillingUndObj && isInvisibleToCallerOnUnwind(KillingUndObj))
1924 return ThrowingBlocks.count(KillingI->
getParent());
1925 return !ThrowingBlocks.empty();
1933 bool isDSEBarrier(
const Value *KillingUndObj, Instruction *DeadI) {
1936 if (DeadI->
mayThrow() && !isInvisibleToCallerOnUnwind(KillingUndObj))
1958 bool eliminateDeadWritesAtEndOfFunction() {
1959 bool MadeChange =
false;
1962 <<
"Trying to eliminate MemoryDefs at the end of the function\n");
1964 ShouldIterateEndOfFunctionDSE =
false;
1966 if (SkipStores.contains(Def))
1970 auto DefLoc = getLocForWrite(DefI);
1971 if (!DefLoc || !isRemovable(DefI)) {
1973 "instruction not removable.\n");
1983 if (!isInvisibleToCallerAfterRet(UO))
1986 if (isWriteAtEndOfFunction(Def, *DefLoc)) {
1988 LLVM_DEBUG(
dbgs() <<
" ... MemoryDef is not accessed until the end "
1989 "of the function\n");
1995 }
while (ShouldIterateEndOfFunctionDSE);
2001 bool tryFoldIntoCalloc(MemoryDef *Def,
const Value *DefUO) {
2008 if (!StoredConstant || !StoredConstant->
isNullValue())
2011 if (!isRemovable(DefI))
2015 if (F.hasFnAttribute(Attribute::SanitizeMemory) ||
2016 F.hasFnAttribute(Attribute::SanitizeAddress) ||
2017 F.hasFnAttribute(Attribute::SanitizeHWAddress) ||
2018 F.getName() ==
"calloc")
2023 auto *InnerCallee =
Malloc->getCalledFunction();
2027 StringRef ZeroedVariantName;
2028 if (!TLI.getLibFunc(*InnerCallee, Func) || !TLI.has(Func) ||
2029 Func != LibFunc_malloc) {
2034 if (ZeroedVariantName.
empty())
2043 auto shouldCreateCalloc = [](CallInst *
Malloc, CallInst *Memset) {
2046 auto *MallocBB =
Malloc->getParent(),
2047 *MemsetBB = Memset->getParent();
2048 if (MallocBB == MemsetBB)
2050 auto *
Ptr = Memset->getArgOperand(0);
2051 auto *TI = MallocBB->getTerminator();
2057 if (MemsetBB != FalseBB)
2064 if (!shouldCreateCalloc(
Malloc, MemSet) || !DT.dominates(
Malloc, MemSet) ||
2068 assert(Func == LibFunc_malloc || !ZeroedVariantName.
empty());
2069 Value *Calloc =
nullptr;
2070 if (!ZeroedVariantName.
empty()) {
2071 LLVMContext &Ctx =
Malloc->getContext();
2072 AttributeList
Attrs = InnerCallee->getAttributes();
2074 Attrs.getFnAttr(Attribute::AllocKind).getAllocKind() |
2075 AllocFnKind::Zeroed;
2078 Attrs.addFnAttribute(Ctx, Attribute::getWithAllocKind(Ctx, AllocKind))
2079 .removeFnAttribute(Ctx,
"alloc-variant-zeroed");
2080 FunctionCallee ZeroedVariant =
Malloc->getModule()->getOrInsertFunction(
2081 ZeroedVariantName, InnerCallee->getFunctionType(), Attrs);
2084 Calloc = IRB.CreateCall(ZeroedVariant, Args, ZeroedVariantName);
2086 Type *SizeTTy =
Malloc->getArgOperand(0)->getType();
2089 IRB, TLI,
Malloc->getType()->getPointerAddressSpace());
2094 MemorySSAUpdater Updater(&MSSA);
2099 Updater.insertDef(NewAccessMD,
true);
2100 Malloc->replaceAllUsesWith(Calloc);
2107 bool dominatingConditionImpliesValue(MemoryDef *Def) {
2110 Value *StorePtr = StoreI->getPointerOperand();
2111 Value *StoreVal = StoreI->getValueOperand();
2118 if (!BI || !BI->isConditional())
2124 if (BI->getSuccessor(0) == BI->getSuccessor(1))
2129 if (!
match(BI->getCondition(),
2139 if (Pred == ICmpInst::ICMP_EQ &&
2140 !DT.dominates(BasicBlockEdge(BI->getParent(), BI->getSuccessor(0)),
2144 if (Pred == ICmpInst::ICMP_NE &&
2145 !DT.dominates(BasicBlockEdge(BI->getParent(), BI->getSuccessor(1)),
2149 MemoryAccess *LoadAcc = MSSA.getMemoryAccess(ICmpL);
2150 MemoryAccess *ClobAcc =
2151 MSSA.getSkipSelfWalker()->getClobberingMemoryAccess(Def, BatchAA);
2153 return MSSA.dominates(ClobAcc, LoadAcc);
2158 bool storeIsNoop(MemoryDef *Def,
const Value *DefUO) {
2162 Constant *StoredConstant =
nullptr;
2170 if (!isRemovable(DefI))
2173 if (StoredConstant) {
2178 if (InitC && InitC == StoredConstant)
2179 return MSSA.isLiveOnEntryDef(
2180 MSSA.getSkipSelfWalker()->getClobberingMemoryAccess(Def, BatchAA));
2186 if (dominatingConditionImpliesValue(Def))
2190 if (LoadI->getPointerOperand() ==
Store->getOperand(1)) {
2192 auto *LoadAccess = MSSA.getMemoryAccess(LoadI)->getDefiningAccess();
2194 if (LoadAccess ==
Def->getDefiningAccess())
2200 SetVector<MemoryAccess *> ToCheck;
2201 MemoryAccess *Current =
2202 MSSA.getWalker()->getClobberingMemoryAccess(Def, BatchAA);
2209 for (
unsigned I = 1;
I < ToCheck.
size(); ++
I) {
2210 Current = ToCheck[
I];
2213 for (
auto &Use : PhiAccess->incoming_values())
2221 "Only MemoryDefs should reach here.");
2226 if (LoadAccess != Current)
2238 for (
auto OI : IOL) {
2240 MemoryLocation Loc = *getLocForWrite(DeadI);
2241 assert(isRemovable(DeadI) &&
"Expect only removable instruction");
2244 int64_t DeadStart = 0;
2249 if (IntervalMap.empty())
2258 bool eliminateRedundantStoresOfExistingValues() {
2259 bool MadeChange =
false;
2260 LLVM_DEBUG(
dbgs() <<
"Trying to eliminate MemoryDefs that write the "
2261 "already existing value\n");
2262 for (
auto *Def : MemDefs) {
2263 if (SkipStores.contains(Def) || MSSA.isLiveOnEntryDef(Def))
2267 auto MaybeDefLoc = getLocForWrite(DefInst);
2268 if (!MaybeDefLoc || !isRemovable(DefInst))
2271 MemoryDef *UpperDef;
2275 if (
Def->isOptimized())
2279 if (!UpperDef || MSSA.isLiveOnEntryDef(UpperDef))
2283 auto IsRedundantStore = [&]() {
2291 auto UpperLoc = getLocForWrite(UpperInst);
2294 int64_t InstWriteOffset = 0;
2295 int64_t DepWriteOffset = 0;
2296 auto OR = isOverwrite(UpperInst, DefInst, *UpperLoc, *MaybeDefLoc,
2297 InstWriteOffset, DepWriteOffset);
2299 return StoredByte && StoredByte == MemSetI->getOperand(1) &&
2306 if (!IsRedundantStore() || isReadClobber(*MaybeDefLoc, DefInst))
2308 LLVM_DEBUG(
dbgs() <<
"DSE: Remove No-Op Store:\n DEAD: " << *DefInst
2311 NumRedundantStores++;
2330 std::pair<bool, bool>
2331 eliminateDeadDefs(
const MemoryLocationWrapper &KillingLocWrapper);
2335 bool eliminateDeadDefs(
const MemoryDefWrapper &KillingDefWrapper);
2349DSEState::getInitializesArgMemLoc(
const Instruction *
I) {
2355 SmallMapVector<Value *, SmallVector<ArgumentInitInfo, 2>, 2>
Arguments;
2361 ConstantRangeList Inits;
2373 Inits = ConstantRangeList();
2381 bool IsDeadOrInvisibleOnUnwind =
2384 ArgumentInitInfo InitInfo{Idx, IsDeadOrInvisibleOnUnwind, Inits};
2385 bool FoundAliasing =
false;
2386 for (
auto &[Arg, AliasList] :
Arguments) {
2392 FoundAliasing =
true;
2393 AliasList.push_back(InitInfo);
2398 FoundAliasing =
true;
2399 AliasList.push_back(ArgumentInitInfo{Idx, IsDeadOrInvisibleOnUnwind,
2400 ConstantRangeList()});
2409 auto IntersectedRanges =
2411 if (IntersectedRanges.empty())
2414 for (
const auto &Arg : Args) {
2415 for (
const auto &
Range : IntersectedRanges) {
2429std::pair<bool, bool>
2430DSEState::eliminateDeadDefs(
const MemoryLocationWrapper &KillingLocWrapper) {
2432 bool DeletedKillingLoc =
false;
2438 SmallSetVector<MemoryAccess *, 8> ToCheck;
2442 SmallPtrSet<MemoryAccess *, 8>
Deleted;
2443 [[maybe_unused]]
unsigned OrigNumSkipStores = SkipStores.
size();
2448 for (
unsigned I = 0;
I < ToCheck.
size();
I++) {
2449 MemoryAccess *Current = ToCheck[
I];
2450 if (
Deleted.contains(Current))
2452 std::optional<MemoryAccess *> MaybeDeadAccess = getDomMemoryDef(
2453 KillingLocWrapper.MemDef, Current, KillingLocWrapper.MemLoc,
2454 KillingLocWrapper.UnderlyingObject, ScanLimit, WalkerStepLimit,
2455 isMemTerminatorInst(KillingLocWrapper.DefInst), PartialLimit,
2456 KillingLocWrapper.DefByInitializesAttr);
2458 if (!MaybeDeadAccess) {
2462 MemoryAccess *DeadAccess = *MaybeDeadAccess;
2463 LLVM_DEBUG(
dbgs() <<
" Checking if we can kill " << *DeadAccess);
2465 LLVM_DEBUG(
dbgs() <<
"\n ... adding incoming values to worklist\n");
2474 if (PostOrderNumbers[IncomingBlock] > PostOrderNumbers[PhiBlock])
2475 ToCheck.
insert(IncomingAccess);
2486 MemoryDefWrapper DeadDefWrapper(
2490 assert(DeadDefWrapper.DefinedLocations.size() == 1);
2491 MemoryLocationWrapper &DeadLocWrapper =
2492 DeadDefWrapper.DefinedLocations.front();
2495 NumGetDomMemoryDefPassed++;
2499 if (isMemTerminatorInst(KillingLocWrapper.DefInst)) {
2500 if (KillingLocWrapper.UnderlyingObject != DeadLocWrapper.UnderlyingObject)
2503 << *DeadLocWrapper.DefInst <<
"\n KILLER: "
2504 << *KillingLocWrapper.DefInst <<
'\n');
2510 int64_t KillingOffset = 0;
2511 int64_t DeadOffset = 0;
2512 OverwriteResult
OR =
2513 isOverwrite(KillingLocWrapper.DefInst, DeadLocWrapper.DefInst,
2514 KillingLocWrapper.MemLoc, DeadLocWrapper.MemLoc,
2515 KillingOffset, DeadOffset);
2516 if (OR == OW_MaybePartial) {
2517 auto &IOL = IOLs[DeadLocWrapper.DefInst->
getParent()];
2519 KillingOffset, DeadOffset,
2520 DeadLocWrapper.DefInst, IOL);
2528 if (DeadSI && KillingSI && DT.
dominates(DeadSI, KillingSI)) {
2530 KillingSI, DeadSI, KillingOffset, DeadOffset,
DL, BatchAA,
2534 DeadSI->setOperand(0, Merged);
2535 ++NumModifiedStores;
2537 DeletedKillingLoc =
true;
2542 auto I = IOLs.
find(DeadSI->getParent());
2543 if (
I != IOLs.
end())
2544 I->second.erase(DeadSI);
2549 if (OR == OW_Complete) {
2551 << *DeadLocWrapper.DefInst <<
"\n KILLER: "
2552 << *KillingLocWrapper.DefInst <<
'\n');
2561 "SkipStores and Deleted out of sync?");
2563 return {
Changed, DeletedKillingLoc};
2566bool DSEState::eliminateDeadDefs(
const MemoryDefWrapper &KillingDefWrapper) {
2567 if (KillingDefWrapper.DefinedLocations.empty()) {
2568 LLVM_DEBUG(
dbgs() <<
"Failed to find analyzable write location for "
2569 << *KillingDefWrapper.DefInst <<
"\n");
2573 bool MadeChange =
false;
2574 for (
auto &KillingLocWrapper : KillingDefWrapper.DefinedLocations) {
2576 << *KillingLocWrapper.MemDef <<
" ("
2577 << *KillingLocWrapper.DefInst <<
")\n");
2578 auto [
Changed, DeletedKillingLoc] = eliminateDeadDefs(KillingLocWrapper);
2582 if (!DeletedKillingLoc && storeIsNoop(KillingLocWrapper.MemDef,
2583 KillingLocWrapper.UnderlyingObject)) {
2585 << *KillingLocWrapper.DefInst <<
'\n');
2587 NumRedundantStores++;
2592 if (!DeletedKillingLoc &&
2593 tryFoldIntoCalloc(KillingLocWrapper.MemDef,
2594 KillingLocWrapper.UnderlyingObject)) {
2595 LLVM_DEBUG(
dbgs() <<
"DSE: Remove memset after forming calloc:\n"
2596 <<
" DEAD: " << *KillingLocWrapper.DefInst <<
'\n');
2609 bool MadeChange =
false;
2610 DSEState State(
F,
AA, MSSA, DT, PDT, TLI, LI);
2612 for (
unsigned I = 0;
I < State.MemDefs.size();
I++) {
2614 if (State.SkipStores.count(KillingDef))
2617 MemoryDefWrapper KillingDefWrapper(
2618 KillingDef, State.getLocForInst(KillingDef->
getMemoryInst(),
2620 MadeChange |= State.eliminateDeadDefs(KillingDefWrapper);
2624 for (
auto &KV : State.IOLs)
2625 MadeChange |= State.removePartiallyOverlappedStores(KV.second);
2627 MadeChange |= State.eliminateRedundantStoresOfExistingValues();
2628 MadeChange |= State.eliminateDeadWritesAtEndOfFunction();
2630 while (!State.ToRemove.empty()) {
2631 Instruction *DeadInst = State.ToRemove.pop_back_val();
2651#ifdef LLVM_ENABLE_STATS
2679 if (skipFunction(
F))
2682 AliasAnalysis &
AA = getAnalysis<AAResultsWrapperPass>().getAAResults();
2683 DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
2685 getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(
F);
2686 MemorySSA &MSSA = getAnalysis<MemorySSAWrapperPass>().getMSSA();
2688 getAnalysis<PostDominatorTreeWrapperPass>().getPostDomTree();
2689 LoopInfo &LI = getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
2693#ifdef LLVM_ENABLE_STATS
2702 void getAnalysisUsage(AnalysisUsage &AU)
const override {
2721char DSELegacyPass::ID = 0;
2738 return new DSELegacyPass();
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
AMDGPU Lower Kernel Arguments
This file implements a class to represent arbitrary precision integral constant values and operations...
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Expand Atomic instructions
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
MapVector< Instruction *, OverlapIntervalsTy > InstOverlapIntervalsTy
static bool canSkipDef(MemoryDef *D, bool DefVisibleToCaller)
static cl::opt< bool > EnableInitializesImprovement("enable-dse-initializes-attr-improvement", cl::init(true), cl::Hidden, cl::desc("Enable the initializes attr improvement in DSE"))
static void shortenAssignment(Instruction *Inst, Value *OriginalDest, uint64_t OldOffsetInBits, uint64_t OldSizeInBits, uint64_t NewSizeInBits, bool IsOverwriteEnd)
static bool isShortenableAtTheEnd(Instruction *I)
Returns true if the end of this instruction can be safely shortened in length.
static bool isNoopIntrinsic(Instruction *I)
static ConstantRangeList getIntersectedInitRangeList(ArrayRef< ArgumentInitInfo > Args, bool CallHasNoUnwindAttr)
static cl::opt< bool > EnablePartialStoreMerging("enable-dse-partial-store-merging", cl::init(true), cl::Hidden, cl::desc("Enable partial store merging in DSE"))
static bool tryToShortenBegin(Instruction *DeadI, OverlapIntervalsTy &IntervalMap, int64_t &DeadStart, uint64_t &DeadSize)
std::map< int64_t, int64_t > OverlapIntervalsTy
static bool isShortenableAtTheBeginning(Instruction *I)
Returns true if the beginning of this instruction can be safely shortened in length.
static cl::opt< unsigned > MemorySSADefsPerBlockLimit("dse-memoryssa-defs-per-block-limit", cl::init(5000), cl::Hidden, cl::desc("The number of MemoryDefs we consider as candidates to eliminated " "other stores per basic block (default = 5000)"))
static Constant * tryToMergePartialOverlappingStores(StoreInst *KillingI, StoreInst *DeadI, int64_t KillingOffset, int64_t DeadOffset, const DataLayout &DL, BatchAAResults &AA, DominatorTree *DT)
static bool memoryIsNotModifiedBetween(Instruction *FirstI, Instruction *SecondI, BatchAAResults &AA, const DataLayout &DL, DominatorTree *DT)
Returns true if the memory which is accessed by the second instruction is not modified between the fi...
static OverwriteResult isMaskedStoreOverwrite(const Instruction *KillingI, const Instruction *DeadI, BatchAAResults &AA)
Check if two instruction are masked stores that completely overwrite one another.
static cl::opt< unsigned > MemorySSAOtherBBStepCost("dse-memoryssa-otherbb-cost", cl::init(5), cl::Hidden, cl::desc("The cost of a step in a different basic " "block than the killing MemoryDef" "(default = 5)"))
static bool tryToShorten(Instruction *DeadI, int64_t &DeadStart, uint64_t &DeadSize, int64_t KillingStart, uint64_t KillingSize, bool IsOverwriteEnd)
static cl::opt< unsigned > MemorySSAScanLimit("dse-memoryssa-scanlimit", cl::init(150), cl::Hidden, cl::desc("The number of memory instructions to scan for " "dead store elimination (default = 150)"))
static bool isFuncLocalAndNotCaptured(Value *Arg, const CallBase *CB, EarliestEscapeAnalysis &EA)
static cl::opt< unsigned > MemorySSASameBBStepCost("dse-memoryssa-samebb-cost", cl::init(1), cl::Hidden, cl::desc("The cost of a step in the same basic block as the killing MemoryDef" "(default = 1)"))
static cl::opt< bool > EnablePartialOverwriteTracking("enable-dse-partial-overwrite-tracking", cl::init(true), cl::Hidden, cl::desc("Enable partial-overwrite tracking in DSE"))
static OverwriteResult isPartialOverwrite(const MemoryLocation &KillingLoc, const MemoryLocation &DeadLoc, int64_t KillingOff, int64_t DeadOff, Instruction *DeadI, InstOverlapIntervalsTy &IOL)
Return 'OW_Complete' if a store to the 'KillingLoc' location completely overwrites a store to the 'De...
static cl::opt< unsigned > MemorySSAPartialStoreLimit("dse-memoryssa-partial-store-limit", cl::init(5), cl::Hidden, cl::desc("The maximum number candidates that only partially overwrite the " "killing MemoryDef to consider" " (default = 5)"))
static std::optional< TypeSize > getPointerSize(const Value *V, const DataLayout &DL, const TargetLibraryInfo &TLI, const Function *F)
static bool tryToShortenEnd(Instruction *DeadI, OverlapIntervalsTy &IntervalMap, int64_t &DeadStart, uint64_t &DeadSize)
static void adjustArgAttributes(AnyMemIntrinsic *Intrinsic, unsigned ArgNo, uint64_t PtrOffset)
Update the attributes given that a memory access is updated (the dereferenced pointer could be moved ...
static cl::opt< unsigned > MemorySSAUpwardsStepLimit("dse-memoryssa-walklimit", cl::init(90), cl::Hidden, cl::desc("The maximum number of steps while walking upwards to find " "MemoryDefs that may be killed (default = 90)"))
static cl::opt< bool > OptimizeMemorySSA("dse-optimize-memoryssa", cl::init(true), cl::Hidden, cl::desc("Allow DSE to optimize memory accesses."))
static bool hasInitializesAttr(Instruction *I)
static cl::opt< unsigned > MemorySSAPathCheckLimit("dse-memoryssa-path-check-limit", cl::init(50), cl::Hidden, cl::desc("The maximum number of blocks to check when trying to prove that " "all paths to an exit go through a killing block (default = 50)"))
static bool eliminateDeadStores(Function &F, AliasAnalysis &AA, MemorySSA &MSSA, DominatorTree &DT, PostDominatorTree &PDT, const TargetLibraryInfo &TLI, const LoopInfo &LI)
This file provides an implementation of debug counters.
#define DEBUG_COUNTER(VARNAME, COUNTERNAME, DESC)
This file defines the DenseMap class.
early cse Early CSE w MemorySSA
static bool runOnFunction(Function &F, bool PostInlining)
This is the interface for a simple mod/ref and alias analysis over globals.
Module.h This file contains the declarations for the Module class.
This header defines various interfaces for pass management in LLVM.
static void deleteDeadInstruction(Instruction *I)
This file implements a map that provides insertion order iteration.
This file provides utility analysis objects describing memory locations.
This file exposes an interface to building/using memory SSA to walk memory instructions using a use/d...
Contains a collection of routines for determining if a given instruction is guaranteed to execute if ...
ConstantRange Range(APInt(BitWidth, Low), APInt(BitWidth, High))
uint64_t IntrinsicInst * II
#define INITIALIZE_PASS_DEPENDENCY(depName)
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)
This file builds on the ADT/GraphTraits.h file to build a generic graph post order iterator.
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)
A manager for alias analyses.
A wrapper pass to provide the legacy pass manager access to a suitably prepared AAResults object.
Class for arbitrary precision integers.
LLVM_ABI APInt zext(unsigned width) const
Zero extend to a new width.
static APInt getBitsSet(unsigned numBits, unsigned loBit, unsigned hiBit)
Get a value with a block of bits set.
unsigned getBitWidth() const
Return the number of bits in the APInt.
int64_t getSExtValue() const
Get sign extended value.
@ NoAlias
The two locations do not alias at all.
@ PartialAlias
The two locations alias, but only due to a partial overlap.
@ MustAlias
The two locations precisely alias each other.
constexpr int32_t getOffset() const
constexpr bool hasOffset() const
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
AnalysisUsage & addRequired()
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
LLVM_ABI void setPreservesCFG()
This function should be called by the pass, iff they do not:
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
An immutable pass that tracks lazily created AssumptionCache objects.
This class stores enough information to efficiently remove some attributes from an existing AttrBuild...
AttributeMask & addAttribute(Attribute::AttrKind Val)
Add an attribute to the mask.
This class holds the attributes for a particular argument, parameter, function, or return value.
LLVM_ABI ArrayRef< ConstantRange > getValueAsConstantRangeList() const
Return the attribute's value as a ConstantRange array.
LLVM_ABI StringRef getValueAsString() const
Return the attribute's value as a string.
bool isValid() const
Return true if the attribute is any kind of attribute.
LLVM Basic Block Representation.
const Function * getParent() const
Return the enclosing method, or null if none.
InstListType::iterator iterator
Instruction iterators...
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
This class is a wrapper over an AAResults, and it is intended to be used only when there are no IR ch...
AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB)
Represents analyses that only rely on functions' control flow.
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
LLVM_ABI bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const
Determine whether the argument or parameter has the given attribute.
Attribute getParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) const
Get the attribute of a given kind from a given arg.
bool isByValArgument(unsigned ArgNo) const
Determine whether this argument is passed by value.
LLVM_ABI bool onlyAccessesInaccessibleMemOrArgMem() const
Determine if the function may only access memory that is either inaccessible from the IR or pointed t...
bool doesNotThrow() const
Determine if the call cannot unwind.
Value * getArgOperand(unsigned i) const
LLVM_ABI Value * getArgOperandWithAttribute(Attribute::AttrKind Kind) const
If one of the arguments has the specified attribute, returns its operand value.
unsigned arg_size() const
This class represents a list of constant ranges.
bool empty() const
Return true if this list contains no members.
LLVM_ABI ConstantRangeList intersectWith(const ConstantRangeList &CRL) const
Return the range list that results from the intersection of this ConstantRangeList with another Const...
const APInt & getLower() const
Return the lower value for this range.
const APInt & getUpper() const
Return the upper value for this range.
This is an important base class in LLVM.
LLVM_ABI bool isNullValue() const
Return true if this is the value that would be returned by getNullValue.
static DIAssignID * getDistinct(LLVMContext &Context)
DbgVariableFragmentInfo FragmentInfo
static LLVM_ABI std::optional< DIExpression * > createFragmentExpression(const DIExpression *Expr, unsigned OffsetInBits, unsigned SizeInBits)
Create a DIExpression to describe one part of an aggregate variable that is fragmented across multipl...
PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM)
A parsed version of the target data layout string in and methods for querying it.
Record of a variable value-assignment, aka a non instruction representation of the dbg....
static bool shouldExecute(unsigned CounterName)
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
DomTreeNodeBase * getIDom() const
Analysis pass which computes a DominatorTree.
Legacy analysis pass which computes a DominatorTree.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
LLVM_ABI bool dominates(const BasicBlock *BB, const Use &U) const
Return true if the (end of the) basic block BB dominates the use U.
Context-sensitive CaptureAnalysis provider, which computes and caches the earliest common dominator c...
CaptureComponents getCapturesBefore(const Value *Object, const Instruction *I, bool OrAt) override
Return how Object may be captured before instruction I, considering only provenance captures.
FunctionPass class - This class is used to implement most global optimizations.
const BasicBlock & getEntryBlock() const
static GetElementPtrInst * CreateInBounds(Type *PointeeType, Value *Ptr, ArrayRef< Value * > IdxList, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
Create an "inbounds" getelementptr.
Legacy wrapper pass to provide the GlobalsAAResult object.
bool isEquality() const
Return true if this predicate is either EQ or NE.
LLVM_ABI bool mayThrow(bool IncludePhaseOneUnwind=false) const LLVM_READONLY
Return true if this instruction may throw an exception.
LLVM_ABI bool mayWriteToMemory() const LLVM_READONLY
Return true if this instruction may modify memory.
LLVM_ABI bool isAtomic() const LLVM_READONLY
Return true if this instruction has an AtomicOrdering of unordered or higher.
LLVM_ABI InstListType::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
LLVM_ABI bool isIdenticalToWhenDefined(const Instruction *I, bool IntersectAttrs=false) const LLVM_READONLY
This is like isIdenticalTo, except that it ignores the SubclassOptionalData flags,...
LLVM_ABI bool mayReadFromMemory() const LLVM_READONLY
Return true if this instruction may read memory.
LLVM_ABI AAMDNodes getAAMetadata() const
Returns the AA metadata for this instruction.
void setDebugLoc(DebugLoc Loc)
Set the debug location information for this instruction.
LLVM_ABI const DataLayout & getDataLayout() const
Get the data layout of the module this instruction belongs to.
const_iterator begin() const
bool empty() const
empty - Return true when no intervals are mapped.
const_iterator end() const
A wrapper class for inspecting calls to intrinsic functions.
This is an important class for using LLVM in a threaded context.
static LocationSize precise(uint64_t Value)
TypeSize getValue() const
Analysis pass that exposes the LoopInfo for a function.
The legacy pass manager's analysis pass to compute loop information.
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
This class implements a map that also provides access to all stored values in a deterministic order.
iterator find(const KeyT &Key)
Value * getLength() const
BasicBlock * getBlock() const
Represents a read-write access to memory, whether it is a must-alias, or a may-alias.
void setOptimized(MemoryAccess *MA)
A wrapper analysis pass for the legacy pass manager that exposes a MemoryDepnedenceResults instance.
Representation for a specific memory location.
static LLVM_ABI MemoryLocation get(const LoadInst *LI)
Return a location with information about the memory reference by the given instruction.
LocationSize Size
The maximum size of the location, in address-units, or UnknownSize if the size is not known.
static MemoryLocation getBeforeOrAfter(const Value *Ptr, const AAMDNodes &AATags=AAMDNodes())
Return a location that may access any location before or after Ptr, while remaining within the underl...
static MemoryLocation getAfter(const Value *Ptr, const AAMDNodes &AATags=AAMDNodes())
Return a location that may access any location after Ptr, while remaining within the underlying objec...
MemoryLocation getWithNewPtr(const Value *NewPtr) const
const Value * Ptr
The address of the start of the location.
static LLVM_ABI MemoryLocation getForDest(const MemIntrinsic *MI)
Return a location representing the destination of a memory set or transfer.
static LLVM_ABI std::optional< MemoryLocation > getOrNone(const Instruction *Inst)
static LLVM_ABI MemoryLocation getForArgument(const CallBase *Call, unsigned ArgIdx, const TargetLibraryInfo *TLI)
Return a location representing a particular argument of a call.
An analysis that produces MemorySSA for a function.
Legacy analysis pass which computes MemorySSA.
Encapsulates MemorySSA, including all data associated with memory accesses.
MemoryAccess * getDefiningAccess() const
Get the access that produces the memory state used by this Use.
Instruction * getMemoryInst() const
Get the instruction that this MemoryUse represents.
PHITransAddr - An address value which tracks and handles phi translation.
LLVM_ABI Value * translateValue(BasicBlock *CurBB, BasicBlock *PredBB, const DominatorTree *DT, bool MustDominate)
translateValue - PHI translate the current address up the CFG from CurBB to Pred, updating our state ...
LLVM_ABI bool isPotentiallyPHITranslatable() const
isPotentiallyPHITranslatable - If this needs PHI translation, return true if we have some hope of doi...
bool needsPHITranslationFromBlock(BasicBlock *BB) const
needsPHITranslationFromBlock - Return true if moving from the specified BasicBlock to its predecessor...
static LLVM_ABI PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
static LLVM_ABI PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
Analysis pass which computes a PostDominatorTree.
PostDominatorTree Class - Concrete subclass of DominatorTree that is used to compute the post-dominat...
A set of analyses that are preserved following a run of a transformation pass.
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
PreservedAnalyses & preserveSet()
Mark an analysis set as preserved.
PreservedAnalyses & preserve()
Mark an analysis as preserved.
size_type size() const
Determine the number of elements in the SetVector.
void insert_range(Range &&R)
bool insert(const value_type &X)
Insert a new element into the SetVector.
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.
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.
Value * getValueOperand()
constexpr bool empty() const
empty - Check if the string is empty.
Analysis pass providing the TargetLibraryInfo.
Provides information about what library functions are available for the current target.
static constexpr TypeSize getFixed(ScalarTy ExactSize)
bool isPointerTy() const
True if this is an instance of PointerType.
static LLVM_ABI IntegerType * getInt8Ty(LLVMContext &C)
bool isVoidTy() const
Return true if this is 'void'.
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
LLVM_ABI const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs and address space casts.
LLVM_ABI LLVMContext & getContext() const
All values hold a context through their type.
iterator_range< use_iterator > uses()
constexpr bool isScalable() const
Returns whether the quantity is scaled by a runtime quantity (vscale).
const ParentTy * getParent() const
self_iterator getIterator()
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Abstract Attribute helper functions.
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
constexpr char Attrs[]
Key for Kernel::Metadata::mAttrs.
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
@ BasicBlock
Various leaf nodes.
This namespace contains an enum with a value for every intrinsic/builtin function known by LLVM.
bool match(Val *V, const Pattern &P)
bind_ty< Instruction > m_Instruction(Instruction *&I)
Match an instruction, capturing it if we match.
specificval_ty m_Specific(const Value *V)
Match if we have a specific specified value.
CmpClass_match< LHS, RHS, ICmpInst, true > m_c_ICmp(CmpPredicate &Pred, const LHS &L, const RHS &R)
Matches an ICmp with a predicate over LHS and RHS in either order.
match_combine_and< LTy, RTy > m_CombineAnd(const LTy &L, const RTy &R)
Combine two pattern matchers matching L && R.
SpecificCmpClass_match< LHS, RHS, ICmpInst > m_SpecificICmp(CmpPredicate MatchPred, const LHS &L, const RHS &R)
OneOps_match< OpTy, Instruction::Load > m_Load(const OpTy &Op)
Matches LoadInst.
brc_match< Cond_t, bind_ty< BasicBlock >, bind_ty< BasicBlock > > m_Br(const Cond_t &C, BasicBlock *&T, BasicBlock *&F)
is_zero m_Zero()
Match any null constant or a vector with all elements equal to 0.
SmallVector< DbgVariableRecord * > getDVRAssignmentMarkers(const Instruction *Inst)
Return a range of dbg_assign records for which Inst performs the assignment they encode.
LLVM_ABI bool calculateFragmentIntersect(const DataLayout &DL, const Value *Dest, uint64_t SliceOffsetInBits, uint64_t SliceSizeInBits, const DbgVariableRecord *DVRAssign, std::optional< DIExpression::FragmentInfo > &Result)
Calculate the fragment of the variable in DAI covered from (Dest + SliceOffsetInBits) to to (Dest + S...
initializer< Ty > init(const Ty &Val)
NodeAddr< DefNode * > Def
NodeAddr< FuncNode * > Func
friend class Instruction
Iterator for Instructions in a `BasicBlock.
This is an optimization pass for GlobalISel generic memory operations.
auto drop_begin(T &&RangeOrContainer, size_t N=1)
Return a range covering RangeOrContainer with the first N elements excluded.
LLVM_ABI void initializeDSELegacyPassPass(PassRegistry &)
FunctionAddr VTableAddr Value
LLVM_ABI Constant * getInitialValueOfAllocation(const Value *V, const TargetLibraryInfo *TLI, Type *Ty)
If this is a call to an allocation function that initializes memory to a fixed value,...
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
bool isStrongerThanMonotonic(AtomicOrdering AO)
bool isAligned(Align Lhs, uint64_t SizeInBytes)
Checks that SizeInBytes is a multiple of the alignment.
LLVM_ABI 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...
Value * GetPointerBaseWithConstantOffset(Value *Ptr, int64_t &Offset, const DataLayout &DL, bool AllowNonInbounds=true)
Analyze the specified pointer to see if it can be expressed as a base pointer plus a constant offset.
iterator_range< po_iterator< T > > post_order(const T &G)
LLVM_ABI bool isNoAliasCall(const Value *V)
Return true if this pointer is returned by a noalias function.
DomTreeNodeBase< BasicBlock > DomTreeNode
auto dyn_cast_or_null(const Y &Val)
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
LLVM_ABI 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.
LLVM_ABI bool getObjectSize(const Value *Ptr, uint64_t &Size, const DataLayout &DL, const TargetLibraryInfo *TLI, ObjectSizeOpts Opts={})
Compute the size of the object pointed by Ptr.
auto reverse(ContainerTy &&C)
bool isModSet(const ModRefInfo MRI)
LLVM_ABI bool NullPointerIsDefined(const Function *F, unsigned AS=0)
Check whether null pointer dereferencing is considered undefined behavior for a given function or an ...
LLVM_ABI raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
FunctionAddr VTableAddr Count
LLVM_ABI bool AreStatisticsEnabled()
Check if statistics are enabled.
LLVM_ABI bool isNotVisibleOnUnwind(const Value *Object, bool &RequiresNoCaptureBeforeUnwind)
Return true if Object memory is not visible after an unwind, in the sense that program semantics cann...
LLVM_ABI Value * emitCalloc(Value *Num, Value *Size, IRBuilderBase &B, const TargetLibraryInfo &TLI, unsigned AddrSpace)
Emit a call to the calloc function.
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
bool isa(const From &Val)
isa<X> - Return true if the parameter to the template is an instance of one of the template type argu...
uint64_t offsetToAlignment(uint64_t Value, Align Alignment)
Returns the offset to the next integer (mod 2**64) that is greater than or equal to Value and is a mu...
IRBuilder(LLVMContext &, FolderTy, InserterTy, MDNode *, ArrayRef< OperandBundleDef >) -> IRBuilder< FolderTy, InserterTy >
LLVM_ABI bool salvageKnowledge(Instruction *I, AssumptionCache *AC=nullptr, DominatorTree *DT=nullptr)
Calls BuildAssumeFromInst and if the resulting llvm.assume is valid insert if before I.
LLVM_ABI bool PointerMayBeCaptured(const Value *V, bool ReturnCaptures, unsigned MaxUsesToExplore=0)
PointerMayBeCaptured - Return true if this pointer value may be captured by the enclosing function (w...
ArrayRef(const T &OneElt) -> ArrayRef< T >
LLVM_ABI Value * getFreedOperand(const CallBase *CB, const TargetLibraryInfo *TLI)
If this if a call to a free function, return the freed operand.
LLVM_ABI bool isIdentifiedFunctionLocal(const Value *V)
Return true if V is umabigously identified at the function-level.
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
LLVM_ABI FunctionPass * createDeadStoreEliminationPass()
LLVM_ABI Value * isBytewiseValue(Value *V, const DataLayout &DL)
If the specified value can be set by repeating the same byte in memory, return the i8 value that it i...
auto predecessors(const MachineBasicBlock *BB)
bool capturesAnything(CaptureComponents CC)
AnalysisManager< Function > FunctionAnalysisManager
Convenience typedef for the Function analysis manager.
LLVM_ABI bool mayContainIrreducibleControl(const Function &F, const LoopInfo *LI)
LLVM_ABI const Value * getUnderlyingObject(const Value *V, unsigned MaxLookup=MaxLookupSearchDepth)
This method strips off any GEP address adjustments, pointer casts or llvm.threadlocal....
AAResults AliasAnalysis
Temporary typedef for legacy code that uses a generic AliasAnalysis pointer or reference.
bool capturesNothing(CaptureComponents CC)
LLVM_ABI bool isIdentifiedObject(const Value *V)
Return true if this pointer refers to a distinct and identifiable object.
bool isStrongerThan(AtomicOrdering AO, AtomicOrdering Other)
Returns true if ao is stronger than other as defined by the AtomicOrdering lattice,...
bool isRefSet(const ModRefInfo MRI)
This struct is a compact representation of a valid (non-zero power of two) alignment.
constexpr uint64_t value() const
This is a hole in the type system and should not be abused.
Various options to control the behavior of getObjectSize.
bool NullIsUnknownSize
If this is true, null pointers in address space 0 will be treated as though they can't be evaluated.