[NFC] Various Cleanup in StackColoring, StackSlotColoring, LiveStacks #143931
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
|
@llvm/pr-subscribers-llvm-binary-utilities @llvm/pr-subscribers-llvm-regalloc Author: None (Ralender) ChangesThis is an extraction of the cleanup part of #143800 Patch is 22.73 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/143931.diff 8 Files Affected:
diff --git a/llvm/include/llvm/CodeGen/LiveInterval.h b/llvm/include/llvm/CodeGen/LiveInterval.h
index e1c5717f5face..e9ca9e36c95b9 100644
--- a/llvm/include/llvm/CodeGen/LiveInterval.h
+++ b/llvm/include/llvm/CodeGen/LiveInterval.h
@@ -237,9 +237,9 @@ namespace llvm {
}
/// Constructs a new LiveRange object.
- LiveRange(bool UseSegmentSet = false)
- : segmentSet(UseSegmentSet ? std::make_unique<SegmentSet>()
- : nullptr) {}
+ explicit LiveRange(bool UseSegmentSet = false)
+ : segmentSet(UseSegmentSet ? std::make_unique<SegmentSet>() : nullptr) {
+ }
/// Constructs a new LiveRange object by copying segments and valnos from
/// another LiveRange.
diff --git a/llvm/include/llvm/CodeGen/LiveStacks.h b/llvm/include/llvm/CodeGen/LiveStacks.h
index 02c640bfc4a93..38650bf21bcf5 100644
--- a/llvm/include/llvm/CodeGen/LiveStacks.h
+++ b/llvm/include/llvm/CodeGen/LiveStacks.h
@@ -40,49 +40,42 @@ class LiveStacks {
///
VNInfo::Allocator VNInfoAllocator;
- /// S2IMap - Stack slot indices to live interval mapping.
- using SS2IntervalMap = std::unordered_map<int, LiveInterval>;
- SS2IntervalMap S2IMap;
-
- /// S2RCMap - Stack slot indices to register class mapping.
- std::map<int, const TargetRegisterClass *> S2RCMap;
+ int StartIdx = -1;
+ SmallVector<LiveInterval *> S2LI;
+ SmallVector<const TargetRegisterClass *> S2RC;
public:
- using iterator = SS2IntervalMap::iterator;
- using const_iterator = SS2IntervalMap::const_iterator;
+ using iterator = SmallVector<LiveInterval *>::iterator;
+ using const_iterator = SmallVector<LiveInterval *>::const_iterator;
- const_iterator begin() const { return S2IMap.begin(); }
- const_iterator end() const { return S2IMap.end(); }
- iterator begin() { return S2IMap.begin(); }
- iterator end() { return S2IMap.end(); }
+ const_iterator begin() const { return S2LI.begin(); }
+ const_iterator end() const { return S2LI.end(); }
+ iterator begin() { return S2LI.begin(); }
+ iterator end() { return S2LI.end(); }
- unsigned getNumIntervals() const { return (unsigned)S2IMap.size(); }
+ unsigned getNumIntervals() const { return (unsigned)S2LI.size(); }
LiveInterval &getOrCreateInterval(int Slot, const TargetRegisterClass *RC);
LiveInterval &getInterval(int Slot) {
assert(Slot >= 0 && "Spill slot indice must be >= 0");
- SS2IntervalMap::iterator I = S2IMap.find(Slot);
- assert(I != S2IMap.end() && "Interval does not exist for stack slot");
- return I->second;
+ return *S2LI[Slot - StartIdx];
}
const LiveInterval &getInterval(int Slot) const {
assert(Slot >= 0 && "Spill slot indice must be >= 0");
- SS2IntervalMap::const_iterator I = S2IMap.find(Slot);
- assert(I != S2IMap.end() && "Interval does not exist for stack slot");
- return I->second;
+ return *S2LI[Slot - StartIdx];
}
- bool hasInterval(int Slot) const { return S2IMap.count(Slot); }
+ bool hasInterval(int Slot) const {
+ if (Slot < StartIdx || StartIdx == -1)
+ return false;
+ return !getInterval(Slot).empty();
+ }
const TargetRegisterClass *getIntervalRegClass(int Slot) const {
assert(Slot >= 0 && "Spill slot indice must be >= 0");
- std::map<int, const TargetRegisterClass *>::const_iterator I =
- S2RCMap.find(Slot);
- assert(I != S2RCMap.end() &&
- "Register class info does not exist for stack slot");
- return I->second;
+ return S2RC[Slot - StartIdx];
}
VNInfo::Allocator &getVNInfoAllocator() { return VNInfoAllocator; }
diff --git a/llvm/lib/CodeGen/LiveStacks.cpp b/llvm/lib/CodeGen/LiveStacks.cpp
index c07d985a09d1f..ea158b2d96a4e 100644
--- a/llvm/lib/CodeGen/LiveStacks.cpp
+++ b/llvm/lib/CodeGen/LiveStacks.cpp
@@ -37,10 +37,12 @@ void LiveStacksWrapperLegacy::getAnalysisUsage(AnalysisUsage &AU) const {
}
void LiveStacks::releaseMemory() {
+ for (int Idx = 0; Idx < (int)S2LI.size(); ++Idx)
+ S2LI[Idx]->~LiveInterval();
// Release VNInfo memory regions, VNInfo objects don't need to be dtor'd.
VNInfoAllocator.Reset();
- S2IMap.clear();
- S2RCMap.clear();
+ S2LI.clear();
+ S2RC.clear();
}
void LiveStacks::init(MachineFunction &MF) {
@@ -52,20 +54,22 @@ void LiveStacks::init(MachineFunction &MF) {
LiveInterval &
LiveStacks::getOrCreateInterval(int Slot, const TargetRegisterClass *RC) {
assert(Slot >= 0 && "Spill slot indice must be >= 0");
- SS2IntervalMap::iterator I = S2IMap.find(Slot);
- if (I == S2IMap.end()) {
- I = S2IMap
- .emplace(
- std::piecewise_construct, std::forward_as_tuple(Slot),
- std::forward_as_tuple(Register::index2StackSlot(Slot), 0.0F))
- .first;
- S2RCMap.insert(std::make_pair(Slot, RC));
+ if (StartIdx == -1)
+ StartIdx = Slot;
+
+ int Idx = Slot - StartIdx;
+ assert(Idx >= 0 && "Slot not in order ?");
+ if (Idx < (int)S2LI.size()) {
+ S2RC[Idx] = TRI->getCommonSubClass(S2RC[Idx], RC);
} else {
- // Use the largest common subclass register class.
- const TargetRegisterClass *&OldRC = S2RCMap[Slot];
- OldRC = TRI->getCommonSubClass(OldRC, RC);
+ S2RC.resize(Idx + 1);
+ S2LI.resize(Idx + 1);
+ S2LI[Idx] = this->VNInfoAllocator.Allocate<LiveInterval>();
+ new (S2LI[Idx]) LiveInterval(Register::index2StackSlot(Slot), 0.0F);
+ S2RC[Idx] = RC;
}
- return I->second;
+ assert(S2RC.size() == S2LI.size());
+ return *S2LI[Idx];
}
AnalysisKey LiveStacksAnalysis::Key;
@@ -96,13 +100,12 @@ void LiveStacksWrapperLegacy::print(raw_ostream &OS, const Module *) const {
}
/// print - Implement the dump method.
-void LiveStacks::print(raw_ostream &OS, const Module*) const {
+void LiveStacks::print(raw_ostream &OS, const Module *) const {
OS << "********** INTERVALS **********\n";
- for (const_iterator I = begin(), E = end(); I != E; ++I) {
- I->second.print(OS);
- int Slot = I->first;
- const TargetRegisterClass *RC = getIntervalRegClass(Slot);
+ for (int Idx = 0; Idx < (int)S2LI.size(); ++Idx) {
+ S2LI[Idx]->print(OS);
+ const TargetRegisterClass *RC = S2RC[Idx];
if (RC)
OS << " [" << TRI->getRegClassName(RC) << "]\n";
else
diff --git a/llvm/lib/CodeGen/MachineFrameInfo.cpp b/llvm/lib/CodeGen/MachineFrameInfo.cpp
index e4b993850f73d..c45a64197537e 100644
--- a/llvm/lib/CodeGen/MachineFrameInfo.cpp
+++ b/llvm/lib/CodeGen/MachineFrameInfo.cpp
@@ -13,6 +13,7 @@
#include "llvm/CodeGen/MachineFrameInfo.h"
#include "llvm/ADT/BitVector.h"
+#include "llvm/IR/Instructions.h"
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
#include "llvm/CodeGen/TargetFrameLowering.h"
@@ -221,6 +222,12 @@ void MachineFrameInfo::print(const MachineFunction &MF, raw_ostream &OS) const{
if (SO.StackID != 0)
OS << "id=" << static_cast<unsigned>(SO.StackID) << ' ';
+ if (SO.Alloca)
+ OS << "alloca=" << SO.Alloca->getName() << ' ';
+
+ if (SO.isSpillSlot)
+ OS << "spill ";
+
if (SO.Size == ~0ULL) {
OS << "dead\n";
continue;
diff --git a/llvm/lib/CodeGen/MachineInstr.cpp b/llvm/lib/CodeGen/MachineInstr.cpp
index da3665b3b6a0b..3e5fd59534105 100644
--- a/llvm/lib/CodeGen/MachineInstr.cpp
+++ b/llvm/lib/CodeGen/MachineInstr.cpp
@@ -1417,10 +1417,6 @@ bool MachineInstr::isDead(const MachineRegisterInfo &MRI,
if (isInlineAsm())
return false;
- // FIXME: See issue #105950 for why LIFETIME markers are considered dead here.
- if (isLifetimeMarker())
- return true;
-
// If there are no defs with uses, then we call the instruction dead so long
// as we do not suspect it may have sideeffects.
return wouldBeTriviallyDead();
diff --git a/llvm/lib/CodeGen/StackColoring.cpp b/llvm/lib/CodeGen/StackColoring.cpp
index 0f93822d9792b..184f1eb4612c7 100644
--- a/llvm/lib/CodeGen/StackColoring.cpp
+++ b/llvm/lib/CodeGen/StackColoring.cpp
@@ -57,6 +57,7 @@
#include "llvm/Support/raw_ostream.h"
#include <algorithm>
#include <cassert>
+#include <cmath>
#include <limits>
#include <memory>
#include <utility>
@@ -396,21 +397,18 @@ class StackColoring {
/// Which slots are marked as LIVE_OUT, coming out of each basic block.
BitVector LiveOut;
- };
- /// Maps active slots (per bit) for each basic block.
- using LivenessMap = DenseMap<const MachineBasicBlock *, BlockLifetimeInfo>;
- LivenessMap BlockLiveness;
+ bool isEmpty() { return Begin.empty(); }
+ };
- /// Maps serial numbers to basic blocks.
- DenseMap<const MachineBasicBlock *, int> BasicBlocks;
+ SmallVector<BlockLifetimeInfo, 0> BlockLiveness;
/// Maps basic blocks to a serial number.
SmallVector<const MachineBasicBlock *, 8> BasicBlockNumbering;
/// Maps slots to their use interval. Outside of this interval, slots
/// values are either dead or `undef` and they will not be written to.
- SmallVector<std::unique_ptr<LiveInterval>, 16> Intervals;
+ SmallVector<std::unique_ptr<LiveRange>, 16> Intervals;
/// Maps slots to the points where they can become in-use.
SmallVector<SmallVector<SlotIndex, 4>, 16> LiveStarts;
@@ -441,14 +439,10 @@ class StackColoring {
bool run(MachineFunction &Func);
private:
- /// Used in collectMarkers
- using BlockBitVecMap = DenseMap<const MachineBasicBlock *, BitVector>;
-
/// Debug.
void dump() const;
void dumpIntervals() const;
void dumpBB(MachineBasicBlock *MBB) const;
- void dumpBV(const char *tag, const BitVector &BV) const;
/// Removes all of the lifetime marker instructions from the function.
/// \returns true if any markers were removed.
@@ -532,18 +526,43 @@ void StackColoringLegacy::getAnalysisUsage(AnalysisUsage &AU) const {
}
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void StackColoring::dumpBV(const char *tag,
- const BitVector &BV) const {
- dbgs() << tag << " : { ";
- for (unsigned I = 0, E = BV.size(); I != E; ++I)
- dbgs() << BV.test(I) << " ";
- dbgs() << "}\n";
+
+LLVM_DUMP_METHOD void dumpBV(StringRef tag, const BitVector &BV) {
+ constexpr unsigned ColumnWidth = 150;
+ unsigned LineStartOffset = tag.size() + /*" : "*/ 3;
+ unsigned WidthAfterTag = ColumnWidth - LineStartOffset;
+ unsigned NumBitsPerColumn = WidthAfterTag / 2;
+ unsigned BitsCount = BV.size();
+ for (unsigned Bits = 0; Bits < BitsCount; Bits += NumBitsPerColumn) {
+ unsigned Start = Bits;
+ unsigned End = std::min(Start + NumBitsPerColumn, BitsCount);
+
+ dbgs() << tag << " : ";
+
+ for (unsigned I = Start; I < End; ++I)
+ dbgs() << BV.test(I) << " ";
+ dbgs() << '\n';
+ dbgs() << tag << " : ";
+ unsigned next = Start;
+ for (unsigned I = Start; I < End; ++I) {
+ if (I < next)
+ continue;
+ if (BV.test(I)) {
+ int numDidgits = I != 0 ? (log10(I) + 1) : 1;
+ // Make sure number have spacing while staying aligned to the line above
+ next = I + 1 + numDidgits / 2;
+ dbgs() << I << ' ';
+ if (numDidgits % 2 == 0)
+ dbgs() << ' ';
+ } else
+ dbgs() << " ";
+ }
+ dbgs() << '\n';
+ }
}
LLVM_DUMP_METHOD void StackColoring::dumpBB(MachineBasicBlock *MBB) const {
- LivenessMap::const_iterator BI = BlockLiveness.find(MBB);
- assert(BI != BlockLiveness.end() && "Block not found");
- const BlockLifetimeInfo &BlockInfo = BI->second;
+ const BlockLifetimeInfo &BlockInfo = BlockLiveness[MBB->getNumber()];
dumpBV("BEGIN", BlockInfo.Begin);
dumpBV("END", BlockInfo.End);
@@ -561,8 +580,15 @@ LLVM_DUMP_METHOD void StackColoring::dump() const {
LLVM_DUMP_METHOD void StackColoring::dumpIntervals() const {
for (unsigned I = 0, E = Intervals.size(); I != E; ++I) {
- dbgs() << "Interval[" << I << "]:\n";
+ dbgs() << "Interval[" << I << "]:";
+ if (MFI->getObjectAllocation(I))
+ dbgs() << *MFI->getObjectAllocation(I);
+ dbgs() << "\n";
Intervals[I]->dump();
+ dbgs() << "LiveStarts:";
+ for (SlotIndex SIdx : LiveStarts[I])
+ dbgs() << " " << SIdx;
+ dbgs() << "\n";
}
}
#endif
@@ -627,7 +653,7 @@ bool StackColoring::isLifetimeStartOrEnd(const MachineInstr &MI,
unsigned StackColoring::collectMarkers(unsigned NumSlot) {
unsigned MarkersFound = 0;
- BlockBitVecMap SeenStartMap;
+ SmallVector<BitVector> SeenStartMap;
InterestingSlots.clear();
InterestingSlots.resize(NumSlot);
ConservativeSlots.clear();
@@ -637,6 +663,8 @@ unsigned StackColoring::collectMarkers(unsigned NumSlot) {
SmallVector<int, 8> NumStartLifetimes(NumSlot, 0);
SmallVector<int, 8> NumEndLifetimes(NumSlot, 0);
+ SeenStartMap.resize(MF->getNumBlockIDs());
+
// Step 1: collect markers and populate the "InterestingSlots"
// and "ConservativeSlots" sets.
for (MachineBasicBlock *MBB : depth_first(MF)) {
@@ -645,10 +673,11 @@ unsigned StackColoring::collectMarkers(unsigned NumSlot) {
// to this bb).
BitVector BetweenStartEnd;
BetweenStartEnd.resize(NumSlot);
+ SeenStartMap[MBB->getNumber()].resize(NumSlot);
for (const MachineBasicBlock *Pred : MBB->predecessors()) {
- BlockBitVecMap::const_iterator I = SeenStartMap.find(Pred);
- if (I != SeenStartMap.end()) {
- BetweenStartEnd |= I->second;
+ BitVector &PredSet = SeenStartMap[Pred->getNumber()];
+ if (!PredSet.empty()) {
+ BetweenStartEnd |= PredSet;
}
}
@@ -659,8 +688,10 @@ unsigned StackColoring::collectMarkers(unsigned NumSlot) {
if (MI.getOpcode() == TargetOpcode::LIFETIME_START ||
MI.getOpcode() == TargetOpcode::LIFETIME_END) {
int Slot = getStartOrEndSlot(MI);
- if (Slot < 0)
+ if (Slot < 0) {
+ Markers.push_back(&MI);
continue;
+ }
InterestingSlots.set(Slot);
if (MI.getOpcode() == TargetOpcode::LIFETIME_START) {
BetweenStartEnd.set(Slot);
@@ -694,7 +725,7 @@ unsigned StackColoring::collectMarkers(unsigned NumSlot) {
}
}
}
- BitVector &SeenStart = SeenStartMap[MBB];
+ BitVector &SeenStart = SeenStartMap[MBB->getNumber()];
SeenStart |= BetweenStartEnd;
}
if (!MarkersFound) {
@@ -721,17 +752,17 @@ unsigned StackColoring::collectMarkers(unsigned NumSlot) {
LLVM_DEBUG(dumpBV("Conservative slots", ConservativeSlots));
+ BlockLiveness.resize(MF->getNumBlockIDs());
// Step 2: compute begin/end sets for each block
// NOTE: We use a depth-first iteration to ensure that we obtain a
// deterministic numbering.
for (MachineBasicBlock *MBB : depth_first(MF)) {
// Assign a serial number to this basic block.
- BasicBlocks[MBB] = BasicBlockNumbering.size();
BasicBlockNumbering.push_back(MBB);
// Keep a reference to avoid repeated lookups.
- BlockLifetimeInfo &BlockInfo = BlockLiveness[MBB];
+ BlockLifetimeInfo &BlockInfo = BlockLiveness[MBB->getNumber()];
BlockInfo.Begin.resize(NumSlot);
BlockInfo.End.resize(NumSlot);
@@ -788,19 +819,19 @@ void StackColoring::calculateLocalLiveness() {
for (const MachineBasicBlock *BB : BasicBlockNumbering) {
// Use an iterator to avoid repeated lookups.
- LivenessMap::iterator BI = BlockLiveness.find(BB);
- assert(BI != BlockLiveness.end() && "Block not found");
- BlockLifetimeInfo &BlockInfo = BI->second;
+ BlockLifetimeInfo &BlockInfo = BlockLiveness[BB->getNumber()];
+ if (BlockInfo.isEmpty())
+ continue;
// Compute LiveIn by unioning together the LiveOut sets of all preds.
LocalLiveIn.clear();
for (MachineBasicBlock *Pred : BB->predecessors()) {
- LivenessMap::const_iterator I = BlockLiveness.find(Pred);
+ BlockLifetimeInfo &PrefInfo = BlockLiveness[Pred->getNumber()];
// PR37130: transformations prior to stack coloring can
// sometimes leave behind statically unreachable blocks; these
// can be safely skipped here.
- if (I != BlockLiveness.end())
- LocalLiveIn |= I->second.LiveOut;
+ if (!PrefInfo.isEmpty())
+ LocalLiveIn |= PrefInfo.LiveOut;
}
// Compute LiveOut by subtracting out lifetimes that end in this
@@ -844,7 +875,7 @@ void StackColoring::calculateLiveIntervals(unsigned NumSlots) {
DefinitelyInUse.resize(NumSlots);
// Start the interval of the slots that we previously found to be 'in-use'.
- BlockLifetimeInfo &MBBLiveness = BlockLiveness[&MBB];
+ BlockLifetimeInfo &MBBLiveness = BlockLiveness[MBB.getNumber()];
for (int pos = MBBLiveness.LiveIn.find_first(); pos != -1;
pos = MBBLiveness.LiveIn.find_next(pos)) {
Starts[pos] = Indexes->getMBBStartIdx(&MBB);
@@ -900,6 +931,17 @@ bool StackColoring::removeAllMarkers() {
}
Markers.clear();
+ for (MachineBasicBlock &MBB : *MF) {
+ if (BlockLiveness.empty() || BlockLiveness[MBB.getNumber()].isEmpty())
+ for (MachineInstr &MI : make_early_inc_range(MBB)) {
+ if (MI.getOpcode() == TargetOpcode::LIFETIME_START ||
+ MI.getOpcode() == TargetOpcode::LIFETIME_END) {
+ Count++;
+ MI.eraseFromParent();
+ }
+ }
+ }
+
LLVM_DEBUG(dbgs() << "Removed " << Count << " markers.\n");
return Count;
}
@@ -1039,7 +1081,7 @@ void StackColoring::remapInstructions(DenseMap<int, int> &SlotRemap) {
// validating the instructions.
if (!I.isDebugInstr() && TouchesMemory && ProtectFromEscapedAllocas) {
SlotIndex Index = Indexes->getInstructionIndex(I);
- const LiveInterval *Interval = &*Intervals[FromSlot];
+ const LiveRange *Interval = &*Intervals[FromSlot];
assert(Interval->find(Index) != Interval->end() &&
"Found instruction usage outside of live range.");
}
@@ -1159,7 +1201,7 @@ void StackColoring::removeInvalidSlotRanges() {
// Check that the used slot is inside the calculated lifetime range.
// If it is not, warn about it and invalidate the range.
- LiveInterval *Interval = &*Intervals[Slot];
+ LiveRange *Interval = &*Intervals[Slot];
SlotIndex Index = Indexes->getInstructionIndex(I);
if (Interval->find(Index) == Interval->end()) {
Interval->clear();
@@ -1211,7 +1253,6 @@ bool StackColoring::run(MachineFunction &Func) {
MF = &Func;
MFI = &MF->getFrameInfo();
BlockLiveness.clear();
- BasicBlocks.clear();
BasicBlockNumbering.clear();
Markers.clear();
Intervals.clear();
@@ -1221,8 +1262,8 @@ bool StackColoring::run(MachineFunction &Func) {
unsigned NumSlots = MFI->getObjectIndexEnd();
// If there are no stack slots then there are no markers to remove.
- if (!NumSlots)
- return false;
+ if (!NumSlots || DisableColoring)
+ return removeAllMarkers();
SmallVector<int, 8> SortedSlots;
SortedSlots.reserve(NumSlots);
@@ -1246,13 +1287,13 @@ bool StackColoring::run(MachineFunction &Func) {
// Don't continue because there are not enough lifetime markers, or the
// stack is too small, or we are told not to optimize the slots.
- if (NumMarkers < 2 || TotalSize < 16 || DisableColoring) {
+ if (NumMarkers < 2 || TotalSize < 16) {
LLVM_DEBUG(dbgs() << "Will not try to merge slots.\n");
return removeAllMarkers();
}
for (unsigned i=0; i < NumSlots; ++i) {
- std::unique_ptr<LiveInterval> LI(new LiveInterval(i, 0));
+ std::unique_ptr<LiveRange> LI(new LiveRange());
LI->getNextValue(Indexes->getZeroIndex(), VNInfoAllocator);
Intervals.push_back(std::move(LI));
SortedSlots.push_back(i);
@@ -1322,8 +1363,8 @@ bool StackColoring::run(MachineFunction &Func) {
if (MFI->getStackID(FirstSlot) != MFI->getStackID(SecondSlot))
continue;
- LiveInterval *First = &*Intervals[FirstSlot];
- LiveInterval *Second = &*Intervals[SecondSlot];
+ LiveRange *First = &*Intervals[FirstSlot];
+ LiveRange *Second = &*Intervals[SecondSlot];
auto &FirstS = LiveStarts[FirstSlot];
auto &SecondS = LiveStarts[SecondSlot];
assert(!First->empty() && !Second->empty() && "Found an empty range");
diff --git a/llvm/lib/CodeGen/StackSlotColoring.cpp b/llvm/lib/CodeGen/StackSlotColoring.cpp
index 2f81bea4e86ba..6fcaa81644387 100644
--- a/llvm/lib/CodeGen/StackSlotColoring.cpp
+++ b/llvm/lib/CodeGen/StackSlotColoring.cpp
@@ -262,20 +262,10 @@ void StackSlotColoring::InitializeSlots() {
Use...
[truncated]
|
|
✅ With the latest revision this PR passed the C/C++ code formatter. |
Ralender
force-pushed
the
StackColoringNFC
branch
2 times, most recently
from
611fdf7 to
f4a8e43
Compare
arsenm
reviewed
Jun 13, 2025
Without it it can lead to crazy situtation, when passing a LiveRange* to a function expecting a const LiveRange& the LiveRange* is converted to bool and a new empty LiveRange is created.
Ralender
force-pushed
the
StackColoringNFC
branch
from
f4a8e43 to
3c5f135
Compare
|
It seems like there was no consensus to always deleting lifetime annotations in StackColoring. so I removed that commit. |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
This is an extraction of the cleanup part of #143800