[llvm] [RemoveDIs][NFC] Rename DPMarker->DbgMarker (PR #85931)
Stephen Tozer via llvm-commits
llvm-commits at lists.llvm.org
Wed Mar 20 06:55:36 PDT 2024
https://github.com/SLTozer created https://github.com/llvm/llvm-project/pull/85931
Another trivial rename patch, the last big one for now, which renamed DPMarkers to DbgMarkers. This required the field `DbgMarker` in `Instruction` to be renamed to `DebugMarker` to avoid a clash, but otherwise was a simple string substitution of `s/DPMarker/DbgMarker` and a manual renaming of `DPM` to `DM` in the few places where that acronym was used for debug markers.
>From b036f2fd392cf163e724046e99a9bfd2207ae282 Mon Sep 17 00:00:00 2001
From: Stephen Tozer <stephen.tozer at sony.com>
Date: Wed, 20 Mar 2024 13:48:23 +0000
Subject: [PATCH 1/4] Rename DPMarker->DbgMarker
---
llvm/docs/RemoveDIsDebugInfo.md | 8 +-
llvm/include/llvm/IR/BasicBlock.h | 28 +++---
.../include/llvm/IR/DebugProgramInstruction.h | 68 ++++++-------
llvm/include/llvm/IR/Instruction.h | 10 +-
llvm/lib/Bitcode/Writer/BitcodeWriter.cpp | 2 +-
llvm/lib/IR/AsmWriter.cpp | 18 ++--
llvm/lib/IR/BasicBlock.cpp | 98 +++++++++----------
llvm/lib/IR/DebugProgramInstruction.cpp | 68 ++++++-------
llvm/lib/IR/Instruction.cpp | 42 ++++----
llvm/lib/IR/LLVMContextImpl.h | 8 +-
llvm/lib/IR/Value.cpp | 2 +-
llvm/lib/IR/Verifier.cpp | 6 +-
llvm/lib/Transforms/Scalar/JumpThreading.cpp | 4 +-
.../Transforms/Utils/LoopRotationUtils.cpp | 4 +-
llvm/unittests/IR/BasicBlockDbgInfoTest.cpp | 72 +++++++-------
llvm/unittests/IR/DebugInfoTest.cpp | 82 ++++++++--------
llvm/unittests/Transforms/Utils/LocalTest.cpp | 8 +-
17 files changed, 264 insertions(+), 264 deletions(-)
diff --git a/llvm/docs/RemoveDIsDebugInfo.md b/llvm/docs/RemoveDIsDebugInfo.md
index f8405767a57908..7515435cc4691f 100644
--- a/llvm/docs/RemoveDIsDebugInfo.md
+++ b/llvm/docs/RemoveDIsDebugInfo.md
@@ -82,9 +82,9 @@ Like so:
|
|
v
- +------------+
- <-------+ DPMarker |<-------
- / +------------+ \
+ +-------------+
+ <-------+ DbgMarker |<-------
+ / +-------------+ \
/ \
/ \
v ^
@@ -93,7 +93,7 @@ Like so:
+-------------+ +-------------+ +-------------+
```
-Each instruction has a pointer to a `DPMarker` (which will become optional), that contains a list of `DbgRecord` objects. No debugging records appear in the instruction list at all. `DbgRecord`s have a parent pointer to their owning `DPMarker`, and each `DPMarker` has a pointer back to it's owning instruction.
+Each instruction has a pointer to a `DbgMarker` (which will become optional), that contains a list of `DbgRecord` objects. No debugging records appear in the instruction list at all. `DbgRecord`s have a parent pointer to their owning `DbgMarker`, and each `DbgMarker` has a pointer back to it's owning instruction.
Not shown are the links from DbgRecord to other parts of the `Value`/`Metadata` hierachy: `DbgRecord` subclasses have tracking pointers to the DIMetadata that they use, and `DbgVariableRecord` has references to `Value`s that are stored in a `DebugValueUser` base class. This refers to a `ValueAsMetadata` object referring to `Value`s, via the `TrackingMetadata` facility.
diff --git a/llvm/include/llvm/IR/BasicBlock.h b/llvm/include/llvm/IR/BasicBlock.h
index 51444c7f8c9ccd..0eea4cdccca5bb 100644
--- a/llvm/include/llvm/IR/BasicBlock.h
+++ b/llvm/include/llvm/IR/BasicBlock.h
@@ -39,7 +39,7 @@ class Module;
class PHINode;
class ValueSymbolTable;
class DbgVariableRecord;
-class DPMarker;
+class DbgMarker;
/// LLVM Basic Block Representation
///
@@ -72,18 +72,18 @@ class BasicBlock final : public Value, // Basic blocks are data objects also
Function *Parent;
public:
- /// Attach a DPMarker to the given instruction. Enables the storage of any
+ /// Attach a DbgMarker to the given instruction. Enables the storage of any
/// debug-info at this position in the program.
- DPMarker *createMarker(Instruction *I);
- DPMarker *createMarker(InstListType::iterator It);
+ DbgMarker *createMarker(Instruction *I);
+ DbgMarker *createMarker(InstListType::iterator It);
/// Convert variable location debugging information stored in dbg.value
- /// intrinsics into DPMarkers / DbgRecords. Deletes all dbg.values in
+ /// intrinsics into DbgMarkers / DbgRecords. Deletes all dbg.values in
/// the process and sets IsNewDbgInfoFormat = true. Only takes effect if
/// the UseNewDbgInfoFormat LLVM command line option is given.
void convertToNewDbgValues();
- /// Convert variable location debugging information stored in DPMarkers and
+ /// Convert variable location debugging information stored in DbgMarkers and
/// DbgRecords into the dbg.value intrinsic representation. Sets
/// IsNewDbgInfoFormat = false.
void convertFromNewDbgValues();
@@ -97,12 +97,12 @@ class BasicBlock final : public Value, // Basic blocks are data objects also
/// instruction of this block. These are equivalent to dbg.value intrinsics
/// that exist at the end of a basic block with no terminator (a transient
/// state that occurs regularly).
- void setTrailingDbgRecords(DPMarker *M);
+ void setTrailingDbgRecords(DbgMarker *M);
/// Fetch the collection of DbgRecords that "trail" after the last instruction
/// of this block, see \ref setTrailingDbgRecords. If there are none, returns
/// nullptr.
- DPMarker *getTrailingDbgRecords();
+ DbgMarker *getTrailingDbgRecords();
/// Delete any trailing DbgRecords at the end of this block, see
/// \ref setTrailingDbgRecords.
@@ -110,15 +110,15 @@ class BasicBlock final : public Value, // Basic blocks are data objects also
void dumpDbgValues() const;
- /// Return the DPMarker for the position given by \p It, so that DbgRecords
+ /// Return the DbgMarker for the position given by \p It, so that DbgRecords
/// can be inserted there. This will either be nullptr if not present, a
- /// DPMarker, or TrailingDbgRecords if It is end().
- DPMarker *getMarker(InstListType::iterator It);
+ /// DbgMarker, or TrailingDbgRecords if It is end().
+ DbgMarker *getMarker(InstListType::iterator It);
- /// Return the DPMarker for the position that comes after \p I. \see
- /// BasicBlock::getMarker, this can be nullptr, a DPMarker, or
+ /// Return the DbgMarker for the position that comes after \p I. \see
+ /// BasicBlock::getMarker, this can be nullptr, a DbgMarker, or
/// TrailingDbgRecords if there is no next instruction.
- DPMarker *getNextMarker(Instruction *I);
+ DbgMarker *getNextMarker(Instruction *I);
/// Insert a DbgRecord into a block at the position given by \p I.
void insertDbgRecordAfter(DbgRecord *DR, Instruction *I);
diff --git a/llvm/include/llvm/IR/DebugProgramInstruction.h b/llvm/include/llvm/IR/DebugProgramInstruction.h
index 8bd6331a9a3ef2..b9be443c28de0a 100644
--- a/llvm/include/llvm/IR/DebugProgramInstruction.h
+++ b/llvm/include/llvm/IR/DebugProgramInstruction.h
@@ -16,22 +16,22 @@
//
// and all information is stored in the Value / Metadata hierachy defined
// elsewhere in LLVM. In the "DbgRecord" design, each instruction /may/ have a
-// connection with a DPMarker, which identifies a position immediately before
-// the instruction, and each DPMarker /may/ then have connections to DbgRecords
+// connection with a DbgMarker, which identifies a position immediately before
+// the instruction, and each DbgMarker /may/ then have connections to DbgRecords
// which record the variable assignment information. To illustrate:
//
// %foo = add i32 1, %0
-// ; foo->DbgMarker == nullptr
+// ; foo->DebugMarker == nullptr
// ;; There are no variable assignments / debug records "in front" of
-// ;; the instruction for %foo, therefore it has no DbgMarker.
+// ;; the instruction for %foo, therefore it has no DebugMarker.
// %bar = void call @ext(%foo)
-// ; bar->DbgMarker = {
+// ; bar->DebugMarker = {
// ; StoredDbgRecords = {
// ; DbgVariableRecord(metadata i32 %foo, ...)
// ; }
// ; }
// ;; There is a debug-info record in front of the %bar instruction,
-// ;; thus it points at a DPMarker object. That DPMarker contains a
+// ;; thus it points at a DbgMarker object. That DbgMarker contains a
// ;; DbgVariableRecord in it's ilist, storing the equivalent information
// to the
// ;; dbg.value above: the Value, DILocalVariable, etc.
@@ -66,7 +66,7 @@ class DbgVariableIntrinsic;
class DbgInfoIntrinsic;
class DbgLabelInst;
class DIAssignID;
-class DPMarker;
+class DbgMarker;
class DbgVariableRecord;
class raw_ostream;
@@ -120,7 +120,7 @@ template <typename T> class DbgRecordParamRef {
/// Base class for non-instruction debug metadata records that have positions
/// within IR. Features various methods copied across from the Instruction
/// class to aid ease-of-use. DbgRecords should always be linked into a
-/// DPMarker's StoredDbgRecords list. The marker connects a DbgRecord back to
+/// DbgMarker's StoredDbgRecords list. The marker connects a DbgRecord back to
/// it's position in the BasicBlock.
///
/// We need a discriminator for dyn/isa casts. In order to avoid paying for a
@@ -134,7 +134,7 @@ template <typename T> class DbgRecordParamRef {
class DbgRecord : public ilist_node<DbgRecord> {
public:
/// Marker that this DbgRecord is linked into.
- DPMarker *Marker = nullptr;
+ DbgMarker *Marker = nullptr;
/// Subclass discriminator.
enum Kind : uint8_t { ValueKind, LabelKind };
@@ -166,10 +166,10 @@ class DbgRecord : public ilist_node<DbgRecord> {
Kind getRecordKind() const { return RecordKind; }
- void setMarker(DPMarker *M) { Marker = M; }
+ void setMarker(DbgMarker *M) { Marker = M; }
- DPMarker *getMarker() { return Marker; }
- const DPMarker *getMarker() const { return Marker; }
+ DbgMarker *getMarker() { return Marker; }
+ const DbgMarker *getMarker() const { return Marker; }
BasicBlock *getBlock();
const BasicBlock *getBlock() const;
@@ -539,7 +539,7 @@ filterDbgVars(iterator_range<simple_ilist<DbgRecord>::iterator> R) {
}
/// Per-instruction record of debug-info. If an Instruction is the position of
-/// some debugging information, it points at a DPMarker storing that info. Each
+/// some debugging information, it points at a DbgMarker storing that info. Each
/// marker points back at the instruction that owns it. Various utilities are
/// provided for manipulating the DbgRecords contained within this marker.
///
@@ -559,9 +559,9 @@ filterDbgVars(iterator_range<simple_ilist<DbgRecord>::iterator> R) {
/// which we can improve in the future. Additionally, many improvements in the
/// way that debug-info is stored can be achieved in this class, at a future
/// date.
-class DPMarker {
+class DbgMarker {
public:
- DPMarker() {}
+ DbgMarker() {}
/// Link back to the Instruction that owns this marker. Can be null during
/// operations that move a marker from one instruction to another.
Instruction *MarkedInstr = nullptr;
@@ -585,7 +585,7 @@ class DPMarker {
void removeFromParent();
void eraseFromParent();
- /// Implement operator<< on DPMarker.
+ /// Implement operator<< on DbgMarker.
void print(raw_ostream &O, bool IsForDebug = false) const;
void print(raw_ostream &ROS, ModuleSlotTracker &MST, bool IsForDebug) const;
@@ -593,22 +593,22 @@ class DPMarker {
iterator_range<simple_ilist<DbgRecord>::iterator> getDbgRecordRange();
iterator_range<simple_ilist<DbgRecord>::const_iterator>
getDbgRecordRange() const;
- /// Transfer any DbgRecords from \p Src into this DPMarker. If \p InsertAtHead
+ /// Transfer any DbgRecords from \p Src into this DbgMarker. If \p InsertAtHead
/// is true, place them before existing DbgRecords, otherwise afterwards.
- void absorbDebugValues(DPMarker &Src, bool InsertAtHead);
- /// Transfer the DbgRecords in \p Range from \p Src into this DPMarker. If
+ void absorbDebugValues(DbgMarker &Src, bool InsertAtHead);
+ /// Transfer the DbgRecords in \p Range from \p Src into this DbgMarker. If
/// \p InsertAtHead is true, place them before existing DbgRecords, otherwise
// afterwards.
void absorbDebugValues(iterator_range<DbgRecord::self_iterator> Range,
- DPMarker &Src, bool InsertAtHead);
- /// Insert a DbgRecord into this DPMarker, at the end of the list. If
+ DbgMarker &Src, bool InsertAtHead);
+ /// Insert a DbgRecord into this DbgMarker, at the end of the list. If
/// \p InsertAtHead is true, at the start.
void insertDbgRecord(DbgRecord *New, bool InsertAtHead);
/// Insert a DbgRecord prior to a DbgRecord contained within this marker.
void insertDbgRecord(DbgRecord *New, DbgRecord *InsertBefore);
/// Insert a DbgRecord after a DbgRecord contained within this marker.
void insertDbgRecordAfter(DbgRecord *New, DbgRecord *InsertAfter);
- /// Clone all DPMarkers from \p From into this marker. There are numerous
+ /// Clone all DbgMarkers from \p From into this marker. There are numerous
/// options to customise the source/destination, due to gnarliness, see class
/// comment.
/// \p FromHere If non-null, copy from FromHere to the end of From's
@@ -617,10 +617,10 @@ class DPMarker {
/// StoredDbgRecords
/// \returns Range over all the newly cloned DbgRecords
iterator_range<simple_ilist<DbgRecord>::iterator>
- cloneDebugInfoFrom(DPMarker *From,
+ cloneDebugInfoFrom(DbgMarker *From,
std::optional<simple_ilist<DbgRecord>::iterator> FromHere,
bool InsertAtHead = false);
- /// Erase all DbgRecords in this DPMarker.
+ /// Erase all DbgRecords in this DbgMarker.
void dropDbgRecords();
/// Erase a single DbgRecord from this marker. In an ideal future, we would
/// never erase an assignment in this way, but it's the equivalent to
@@ -628,34 +628,34 @@ class DPMarker {
void dropOneDbgRecord(DbgRecord *DR);
/// We generally act like all llvm Instructions have a range of DbgRecords
- /// attached to them, but in reality sometimes we don't allocate the DPMarker
+ /// attached to them, but in reality sometimes we don't allocate the DbgMarker
/// to save time and memory, but still have to return ranges of DbgRecords.
/// When we need to describe such an unallocated DbgRecord range, use this
/// static markers range instead. This will bite us if someone tries to insert
/// a DbgRecord in that range, but they should be using the Official (TM) API
/// for that.
- static DPMarker EmptyDPMarker;
+ static DbgMarker EmptyDbgMarker;
static iterator_range<simple_ilist<DbgRecord>::iterator>
getEmptyDbgRecordRange() {
- return make_range(EmptyDPMarker.StoredDbgRecords.end(),
- EmptyDPMarker.StoredDbgRecords.end());
+ return make_range(EmptyDbgMarker.StoredDbgRecords.end(),
+ EmptyDbgMarker.StoredDbgRecords.end());
}
};
-inline raw_ostream &operator<<(raw_ostream &OS, const DPMarker &Marker) {
+inline raw_ostream &operator<<(raw_ostream &OS, const DbgMarker &Marker) {
Marker.print(OS);
return OS;
}
/// Inline helper to return a range of DbgRecords attached to a marker. It needs
/// to be inlined as it's frequently called, but also come after the declaration
-/// of DPMarker. Thus: it's pre-declared by users like Instruction, then an
+/// of DbgMarker. Thus: it's pre-declared by users like Instruction, then an
/// inlineable body defined here.
inline iterator_range<simple_ilist<DbgRecord>::iterator>
-getDbgRecordRange(DPMarker *DbgMarker) {
- if (!DbgMarker)
- return DPMarker::getEmptyDbgRecordRange();
- return DbgMarker->getDbgRecordRange();
+getDbgRecordRange(DbgMarker *DebugMarker) {
+ if (!DebugMarker)
+ return DbgMarker::getEmptyDbgRecordRange();
+ return DebugMarker->getDbgRecordRange();
}
DEFINE_ISA_CONVERSION_FUNCTIONS(DbgRecord, LLVMDbgRecordRef)
diff --git a/llvm/include/llvm/IR/Instruction.h b/llvm/include/llvm/IR/Instruction.h
index d6cf1557752386..e627b58623dc1e 100644
--- a/llvm/include/llvm/IR/Instruction.h
+++ b/llvm/include/llvm/IR/Instruction.h
@@ -29,19 +29,19 @@
namespace llvm {
class BasicBlock;
-class DPMarker;
+class DbgMarker;
class FastMathFlags;
class MDNode;
class Module;
struct AAMDNodes;
-class DPMarker;
+class DbgMarker;
class DbgRecord;
template <> struct ilist_alloc_traits<Instruction> {
static inline void deleteNode(Instruction *V);
};
-iterator_range<simple_ilist<DbgRecord>::iterator> getDbgRecordRange(DPMarker *);
+iterator_range<simple_ilist<DbgRecord>::iterator> getDbgRecordRange(DbgMarker *);
class Instruction : public User,
public ilist_node_with_parent<Instruction, BasicBlock,
@@ -60,7 +60,7 @@ class Instruction : public User,
/// Optional marker recording the position for debugging information that
/// takes effect immediately before this instruction. Null unless there is
/// debugging information present.
- DPMarker *DbgMarker = nullptr;
+ DbgMarker *DebugMarker = nullptr;
/// Clone any debug-info attached to \p From onto this instruction. Used to
/// copy debugging information from one block to another, when copying entire
@@ -81,7 +81,7 @@ class Instruction : public User,
/// Return a range over the DbgRecords attached to this instruction.
iterator_range<simple_ilist<DbgRecord>::iterator> getDbgRecordRange() const {
- return llvm::getDbgRecordRange(DbgMarker);
+ return llvm::getDbgRecordRange(DebugMarker);
}
/// Return an iterator to the position of the "Next" DbgRecord after this
diff --git a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
index 5addf0ac33c4ed..a8b69f89e7deff 100644
--- a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -3569,7 +3569,7 @@ void ModuleBitcodeWriter::writeFunction(
// Write out non-instruction debug information attached to this
// instruction. Write it after the instruction so that it's easy to
// re-attach to the instruction reading the records in.
- for (DbgRecord &DR : I.DbgMarker->getDbgRecordRange()) {
+ for (DbgRecord &DR : I.DebugMarker->getDbgRecordRange()) {
if (DbgLabelRecord *DLR = dyn_cast<DbgLabelRecord>(&DR)) {
Vals.push_back(VE.getMetadataID(&*DLR->getDebugLoc()));
Vals.push_back(VE.getMetadataID(DLR->getLabel()));
diff --git a/llvm/lib/IR/AsmWriter.cpp b/llvm/lib/IR/AsmWriter.cpp
index 8ce6fabb30f232..9728802a7b3e34 100644
--- a/llvm/lib/IR/AsmWriter.cpp
+++ b/llvm/lib/IR/AsmWriter.cpp
@@ -286,7 +286,7 @@ static const Module *getModuleFromVal(const Value *V) {
return nullptr;
}
-static const Module *getModuleFromDPI(const DPMarker *Marker) {
+static const Module *getModuleFromDPI(const DbgMarker *Marker) {
const Function *M =
Marker->getParent() ? Marker->getParent()->getParent() : nullptr;
return M ? M->getParent() : nullptr;
@@ -2717,7 +2717,7 @@ class AssemblyWriter {
void printBasicBlock(const BasicBlock *BB);
void printInstructionLine(const Instruction &I);
void printInstruction(const Instruction &I);
- void printDPMarker(const DPMarker &DPI);
+ void printDbgMarker(const DbgMarker &DPI);
void printDbgVariableRecord(const DbgVariableRecord &DVR);
void printDbgLabelRecord(const DbgLabelRecord &DLR);
void printDbgRecord(const DbgRecord &DR);
@@ -4604,15 +4604,15 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
printInfoComment(I);
}
-void AssemblyWriter::printDPMarker(const DPMarker &Marker) {
- // There's no formal representation of a DPMarker -- print purely as a
+void AssemblyWriter::printDbgMarker(const DbgMarker &Marker) {
+ // There's no formal representation of a DbgMarker -- print purely as a
// debugging aid.
for (const DbgRecord &DPR : Marker.StoredDbgRecords) {
printDbgRecord(DPR);
Out << "\n";
}
- Out << " DPMarker -> { ";
+ Out << " DbgMarker -> { ";
printInstruction(*Marker.MarkedInstr);
Out << " }";
return;
@@ -4907,7 +4907,7 @@ static bool isReferencingMDNode(const Instruction &I) {
return false;
}
-void DPMarker::print(raw_ostream &ROS, bool IsForDebug) const {
+void DbgMarker::print(raw_ostream &ROS, bool IsForDebug) const {
ModuleSlotTracker MST(getModuleFromDPI(this), true);
print(ROS, MST, IsForDebug);
@@ -4919,7 +4919,7 @@ void DbgVariableRecord::print(raw_ostream &ROS, bool IsForDebug) const {
print(ROS, MST, IsForDebug);
}
-void DPMarker::print(raw_ostream &ROS, ModuleSlotTracker &MST,
+void DbgMarker::print(raw_ostream &ROS, ModuleSlotTracker &MST,
bool IsForDebug) const {
formatted_raw_ostream OS(ROS);
SlotTracker EmptySlotTable(static_cast<const Module *>(nullptr));
@@ -4931,7 +4931,7 @@ void DPMarker::print(raw_ostream &ROS, ModuleSlotTracker &MST,
};
incorporateFunction(getParent() ? getParent()->getParent() : nullptr);
AssemblyWriter W(OS, SlotTable, getModuleFromDPI(this), nullptr, IsForDebug);
- W.printDPMarker(*this);
+ W.printDbgMarker(*this);
}
void DbgLabelRecord::print(raw_ostream &ROS, bool IsForDebug) const {
@@ -5220,7 +5220,7 @@ void Value::dump() const { print(dbgs(), /*IsForDebug=*/true); dbgs() << '\n'; }
// Value::dump - allow easy printing of Values from the debugger.
LLVM_DUMP_METHOD
-void DPMarker::dump() const { print(dbgs(), /*IsForDebug=*/true); dbgs() << '\n'; }
+void DbgMarker::dump() const { print(dbgs(), /*IsForDebug=*/true); dbgs() << '\n'; }
// Value::dump - allow easy printing of Values from the debugger.
LLVM_DUMP_METHOD
diff --git a/llvm/lib/IR/BasicBlock.cpp b/llvm/lib/IR/BasicBlock.cpp
index 2fa9b3330d184f..25b01986a693b1 100644
--- a/llvm/lib/IR/BasicBlock.cpp
+++ b/llvm/lib/IR/BasicBlock.cpp
@@ -41,26 +41,26 @@ cl::opt<bool, true> WriteNewDbgInfoFormatToBitcode2(
"write-experimental-debuginfo-iterators-to-bitcode", cl::Hidden,
cl::location(WriteNewDbgInfoFormatToBitcode), cl::init(false));
-DPMarker *BasicBlock::createMarker(Instruction *I) {
+DbgMarker *BasicBlock::createMarker(Instruction *I) {
assert(IsNewDbgInfoFormat &&
"Tried to create a marker in a non new debug-info block!");
- if (I->DbgMarker)
- return I->DbgMarker;
- DPMarker *Marker = new DPMarker();
+ if (I->DebugMarker)
+ return I->DebugMarker;
+ DbgMarker *Marker = new DbgMarker();
Marker->MarkedInstr = I;
- I->DbgMarker = Marker;
+ I->DebugMarker = Marker;
return Marker;
}
-DPMarker *BasicBlock::createMarker(InstListType::iterator It) {
+DbgMarker *BasicBlock::createMarker(InstListType::iterator It) {
assert(IsNewDbgInfoFormat &&
"Tried to create a marker in a non new debug-info block!");
if (It != end())
return createMarker(&*It);
- DPMarker *DPM = getTrailingDbgRecords();
+ DbgMarker *DPM = getTrailingDbgRecords();
if (DPM)
return DPM;
- DPM = new DPMarker();
+ DPM = new DbgMarker();
setTrailingDbgRecords(DPM);
return DPM;
}
@@ -70,10 +70,10 @@ void BasicBlock::convertToNewDbgValues() {
// Iterate over all instructions in the instruction list, collecting debug
// info intrinsics and converting them to DbgRecords. Once we find a "real"
- // instruction, attach all those DbgRecords to a DPMarker in that instruction.
+ // instruction, attach all those DbgRecords to a DbgMarker in that instruction.
SmallVector<DbgRecord *, 4> DbgVarRecs;
for (Instruction &I : make_early_inc_range(InstList)) {
- assert(!I.DbgMarker && "DbgMarker already set on old-format instrs?");
+ assert(!I.DebugMarker && "DebugMarker already set on old-format instrs?");
if (DbgVariableIntrinsic *DVI = dyn_cast<DbgVariableIntrinsic>(&I)) {
// Convert this dbg.value to a DbgVariableRecord.
DbgVariableRecord *Value = new DbgVariableRecord(DVI);
@@ -94,7 +94,7 @@ void BasicBlock::convertToNewDbgValues() {
// Create a marker to store DbgRecords in.
createMarker(&I);
- DPMarker *Marker = I.DbgMarker;
+ DbgMarker *Marker = I.DebugMarker;
for (DbgRecord *DVR : DbgVarRecs)
Marker->insertDbgRecord(DVR, false);
@@ -107,14 +107,14 @@ void BasicBlock::convertFromNewDbgValues() {
invalidateOrders();
IsNewDbgInfoFormat = false;
- // Iterate over the block, finding instructions annotated with DPMarkers.
+ // Iterate over the block, finding instructions annotated with DbgMarkers.
// Convert any attached DbgRecords to debug intrinsics and insert ahead of the
// instruction.
for (auto &Inst : *this) {
- if (!Inst.DbgMarker)
+ if (!Inst.DebugMarker)
continue;
- DPMarker &Marker = *Inst.DbgMarker;
+ DbgMarker &Marker = *Inst.DebugMarker;
for (DbgRecord &DR : Marker.getDbgRecordRange())
InstList.insert(Inst.getIterator(),
DR.createDebugIntrinsic(getModule(), nullptr));
@@ -131,11 +131,11 @@ void BasicBlock::convertFromNewDbgValues() {
#ifndef NDEBUG
void BasicBlock::dumpDbgValues() const {
for (auto &Inst : *this) {
- if (!Inst.DbgMarker)
+ if (!Inst.DebugMarker)
continue;
- dbgs() << "@ " << Inst.DbgMarker << " ";
- Inst.DbgMarker->dump();
+ dbgs() << "@ " << Inst.DebugMarker << " ";
+ Inst.DebugMarker->dump();
};
}
#endif
@@ -218,9 +218,9 @@ BasicBlock::~BasicBlock() {
assert(getParent() == nullptr && "BasicBlock still linked into the program!");
dropAllReferences();
for (auto &Inst : *this) {
- if (!Inst.DbgMarker)
+ if (!Inst.DebugMarker)
continue;
- Inst.DbgMarker->eraseFromParent();
+ Inst.DebugMarker->eraseFromParent();
}
InstList.clear();
}
@@ -717,13 +717,13 @@ void BasicBlock::flushTerminatorDbgRecords() {
return;
// Are there any dangling DbgRecords?
- DPMarker *TrailingDbgRecords = getTrailingDbgRecords();
+ DbgMarker *TrailingDbgRecords = getTrailingDbgRecords();
if (!TrailingDbgRecords)
return;
// Transfer DbgRecords from the trailing position onto the terminator.
createMarker(Term);
- Term->DbgMarker->absorbDebugValues(*TrailingDbgRecords, false);
+ Term->DebugMarker->absorbDebugValues(*TrailingDbgRecords, false);
TrailingDbgRecords->eraseFromParent();
deleteTrailingDbgRecords();
}
@@ -760,7 +760,7 @@ void BasicBlock::spliceDebugInfoEmptyBlock(BasicBlock::iterator Dest,
// occur when a block is optimised away and the terminator has been moved
// somewhere else.
if (Src->empty()) {
- DPMarker *SrcTrailingDbgRecords = Src->getTrailingDbgRecords();
+ DbgMarker *SrcTrailingDbgRecords = Src->getTrailingDbgRecords();
if (!SrcTrailingDbgRecords)
return;
@@ -780,7 +780,7 @@ void BasicBlock::spliceDebugInfoEmptyBlock(BasicBlock::iterator Dest,
if (!First->hasDbgRecords())
return;
- createMarker(Dest)->absorbDebugValues(*First->DbgMarker, InsertAtHead);
+ createMarker(Dest)->absorbDebugValues(*First->DebugMarker, InsertAtHead);
return;
}
@@ -822,8 +822,8 @@ void BasicBlock::spliceDebugInfo(BasicBlock::iterator Dest, BasicBlock *Src,
// If we're inserting at end(), and not in front of dangling DbgRecords, then
// move the DbgRecords onto "First". They'll then be moved naturally in the
// splice process.
- DPMarker *MoreDanglingDbgRecords = nullptr;
- DPMarker *OurTrailingDbgRecords = getTrailingDbgRecords();
+ DbgMarker *MoreDanglingDbgRecords = nullptr;
+ DbgMarker *OurTrailingDbgRecords = getTrailingDbgRecords();
if (Dest == end() && !Dest.getHeadBit() && OurTrailingDbgRecords) {
// Are the "+" DbgRecords not supposed to move? If so, detach them
// temporarily.
@@ -844,7 +844,7 @@ void BasicBlock::spliceDebugInfo(BasicBlock::iterator Dest, BasicBlock *Src,
} else {
// No current marker, create one and absorb in. (FIXME: we can avoid an
// allocation in the future).
- DPMarker *CurMarker = Src->createMarker(&*First);
+ DbgMarker *CurMarker = Src->createMarker(&*First);
CurMarker->absorbDebugValues(*OurTrailingDbgRecords, false);
OurTrailingDbgRecords->eraseFromParent();
}
@@ -862,7 +862,7 @@ void BasicBlock::spliceDebugInfo(BasicBlock::iterator Dest, BasicBlock *Src,
// FIXME: we could avoid an allocation here sometimes. (adoptDbgRecords
// requires an iterator).
- DPMarker *LastMarker = Src->createMarker(Last);
+ DbgMarker *LastMarker = Src->createMarker(Last);
LastMarker->absorbDebugValues(*MoreDanglingDbgRecords, true);
MoreDanglingDbgRecords->eraseFromParent();
}
@@ -943,7 +943,7 @@ void BasicBlock::spliceDebugInfoImpl(BasicBlock::iterator Dest, BasicBlock *Src,
// Detach the marker at Dest -- this lets us move the "====" DbgRecords
// around.
- DPMarker *DestMarker = nullptr;
+ DbgMarker *DestMarker = nullptr;
if (Dest != end()) {
if ((DestMarker = getMarker(Dest)))
DestMarker->removeFromParent();
@@ -952,14 +952,14 @@ void BasicBlock::spliceDebugInfoImpl(BasicBlock::iterator Dest, BasicBlock *Src,
// If we're moving the tail range of DbgRecords (":::"), absorb them into the
// front of the DbgRecords at Dest.
if (ReadFromTail && Src->getMarker(Last)) {
- DPMarker *FromLast = Src->getMarker(Last);
+ DbgMarker *FromLast = Src->getMarker(Last);
if (LastIsEnd) {
Dest->adoptDbgRecords(Src, Last, true);
// adoptDbgRecords will release any trailers.
assert(!Src->getTrailingDbgRecords());
} else {
// FIXME: can we use adoptDbgRecords here to reduce allocations?
- DPMarker *OntoDest = createMarker(Dest);
+ DbgMarker *OntoDest = createMarker(Dest);
OntoDest->absorbDebugValues(*FromLast, true);
}
}
@@ -971,8 +971,8 @@ void BasicBlock::spliceDebugInfoImpl(BasicBlock::iterator Dest, BasicBlock *Src,
if (Last != Src->end()) {
Last->adoptDbgRecords(Src, First, true);
} else {
- DPMarker *OntoLast = Src->createMarker(Last);
- DPMarker *FromFirst = Src->createMarker(First);
+ DbgMarker *OntoLast = Src->createMarker(Last);
+ DbgMarker *FromFirst = Src->createMarker(First);
// Always insert at front of Last.
OntoLast->absorbDebugValues(*FromFirst, true);
}
@@ -983,12 +983,12 @@ void BasicBlock::spliceDebugInfoImpl(BasicBlock::iterator Dest, BasicBlock *Src,
if (InsertAtHead) {
// Insert them at the end of the DbgRecords at Dest. The "::::" DbgRecords
// might be in front of them.
- DPMarker *NewDestMarker = createMarker(Dest);
+ DbgMarker *NewDestMarker = createMarker(Dest);
NewDestMarker->absorbDebugValues(*DestMarker, false);
} else {
// Insert them right at the start of the range we moved, ahead of First
// and the "++++" DbgRecords.
- DPMarker *FirstMarker = createMarker(First);
+ DbgMarker *FirstMarker = createMarker(First);
FirstMarker->absorbDebugValues(*DestMarker, true);
}
DestMarker->eraseFromParent();
@@ -997,8 +997,8 @@ void BasicBlock::spliceDebugInfoImpl(BasicBlock::iterator Dest, BasicBlock *Src,
// generate the iterator with begin() / getFirstInsertionPt(), it means
// any trailing debug-info at the end of the block would "normally" have
// been pushed in front of "First". Move it there now.
- DPMarker *FirstMarker = getMarker(First);
- DPMarker *TrailingDbgRecords = getTrailingDbgRecords();
+ DbgMarker *FirstMarker = getMarker(First);
+ DbgMarker *TrailingDbgRecords = getTrailingDbgRecords();
if (TrailingDbgRecords) {
FirstMarker->absorbDebugValues(*TrailingDbgRecords, true);
TrailingDbgRecords->eraseFromParent();
@@ -1040,7 +1040,7 @@ void BasicBlock::insertDbgRecordAfter(DbgRecord *DR, Instruction *I) {
assert(I->getParent() == this);
iterator NextIt = std::next(I->getIterator());
- DPMarker *NextMarker = createMarker(NextIt);
+ DbgMarker *NextMarker = createMarker(NextIt);
NextMarker->insertDbgRecord(DR, true);
}
@@ -1048,20 +1048,20 @@ void BasicBlock::insertDbgRecordBefore(DbgRecord *DR,
InstListType::iterator Where) {
assert(Where == end() || Where->getParent() == this);
bool InsertAtHead = Where.getHeadBit();
- DPMarker *M = createMarker(Where);
+ DbgMarker *M = createMarker(Where);
M->insertDbgRecord(DR, InsertAtHead);
}
-DPMarker *BasicBlock::getNextMarker(Instruction *I) {
+DbgMarker *BasicBlock::getNextMarker(Instruction *I) {
return getMarker(std::next(I->getIterator()));
}
-DPMarker *BasicBlock::getMarker(InstListType::iterator It) {
+DbgMarker *BasicBlock::getMarker(InstListType::iterator It) {
if (It == end()) {
- DPMarker *DPM = getTrailingDbgRecords();
+ DbgMarker *DPM = getTrailingDbgRecords();
return DPM;
}
- return It->DbgMarker;
+ return It->DebugMarker;
}
void BasicBlock::reinsertInstInDbgRecords(
@@ -1095,25 +1095,25 @@ void BasicBlock::reinsertInstInDbgRecords(
// This happens if there were no DbgRecords on I0. Are there now DbgRecords
// there?
if (!Pos) {
- DPMarker *NextMarker = getNextMarker(I);
+ DbgMarker *NextMarker = getNextMarker(I);
if (!NextMarker)
return;
if (NextMarker->StoredDbgRecords.empty())
return;
- // There are DPMarkers there now -- they fell down from "I".
- DPMarker *ThisMarker = createMarker(I);
+ // There are DbgMarkers there now -- they fell down from "I".
+ DbgMarker *ThisMarker = createMarker(I);
ThisMarker->absorbDebugValues(*NextMarker, false);
return;
}
// Is there even a range of DbgRecords to move?
- DPMarker *DPM = (*Pos)->getMarker();
+ DbgMarker *DPM = (*Pos)->getMarker();
auto Range = make_range(DPM->StoredDbgRecords.begin(), (*Pos));
if (Range.begin() == Range.end())
return;
// Otherwise: splice.
- DPMarker *ThisMarker = createMarker(I);
+ DbgMarker *ThisMarker = createMarker(I);
assert(ThisMarker->StoredDbgRecords.empty());
ThisMarker->absorbDebugValues(Range, *DPM, true);
}
@@ -1133,11 +1133,11 @@ void BasicBlock::validateInstrOrdering() const {
}
#endif
-void BasicBlock::setTrailingDbgRecords(DPMarker *foo) {
+void BasicBlock::setTrailingDbgRecords(DbgMarker *foo) {
getContext().pImpl->setTrailingDbgRecords(this, foo);
}
-DPMarker *BasicBlock::getTrailingDbgRecords() {
+DbgMarker *BasicBlock::getTrailingDbgRecords() {
return getContext().pImpl->getTrailingDbgRecords(this);
}
diff --git a/llvm/lib/IR/DebugProgramInstruction.cpp b/llvm/lib/IR/DebugProgramInstruction.cpp
index 1c0be6f598ccd5..3848eba7bac2cc 100644
--- a/llvm/lib/IR/DebugProgramInstruction.cpp
+++ b/llvm/lib/IR/DebugProgramInstruction.cpp
@@ -1,4 +1,4 @@
-//=====-- DebugProgramInstruction.cpp - Implement DbgRecords/DPMarkers --=====//
+//=====-- DebugProgramInstruction.cpp - Implement DbgRecords/DbgMarkers --=====//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
@@ -529,40 +529,40 @@ const LLVMContext &DbgRecord::getContext() const {
void DbgRecord::insertBefore(DbgRecord *InsertBefore) {
assert(!getMarker() &&
- "Cannot insert a DbgRecord that is already has a DPMarker!");
+ "Cannot insert a DbgRecord that is already has a DbgMarker!");
assert(InsertBefore->getMarker() &&
"Cannot insert a DbgRecord before a DbgRecord that does not have a "
- "DPMarker!");
+ "DbgMarker!");
InsertBefore->getMarker()->insertDbgRecord(this, InsertBefore);
}
void DbgRecord::insertAfter(DbgRecord *InsertAfter) {
assert(!getMarker() &&
- "Cannot insert a DbgRecord that is already has a DPMarker!");
+ "Cannot insert a DbgRecord that is already has a DbgMarker!");
assert(InsertAfter->getMarker() &&
"Cannot insert a DbgRecord after a DbgRecord that does not have a "
- "DPMarker!");
+ "DbgMarker!");
InsertAfter->getMarker()->insertDbgRecordAfter(this, InsertAfter);
}
void DbgRecord::moveBefore(DbgRecord *MoveBefore) {
assert(getMarker() &&
- "Canot move a DbgRecord that does not currently have a DPMarker!");
+ "Canot move a DbgRecord that does not currently have a DbgMarker!");
removeFromParent();
insertBefore(MoveBefore);
}
void DbgRecord::moveAfter(DbgRecord *MoveAfter) {
assert(getMarker() &&
- "Canot move a DbgRecord that does not currently have a DPMarker!");
+ "Canot move a DbgRecord that does not currently have a DbgMarker!");
removeFromParent();
insertAfter(MoveAfter);
}
///////////////////////////////////////////////////////////////////////////////
-// An empty, global, DPMarker for the purpose of describing empty ranges of
+// An empty, global, DbgMarker for the purpose of describing empty ranges of
// DbgRecords.
-DPMarker DPMarker::EmptyDPMarker;
+DbgMarker DbgMarker::EmptyDbgMarker;
-void DPMarker::dropDbgRecords() {
+void DbgMarker::dropDbgRecords() {
while (!StoredDbgRecords.empty()) {
auto It = StoredDbgRecords.begin();
DbgRecord *DR = &*It;
@@ -571,31 +571,31 @@ void DPMarker::dropDbgRecords() {
}
}
-void DPMarker::dropOneDbgRecord(DbgRecord *DR) {
+void DbgMarker::dropOneDbgRecord(DbgRecord *DR) {
assert(DR->getMarker() == this);
StoredDbgRecords.erase(DR->getIterator());
DR->deleteRecord();
}
-const BasicBlock *DPMarker::getParent() const {
+const BasicBlock *DbgMarker::getParent() const {
return MarkedInstr->getParent();
}
-BasicBlock *DPMarker::getParent() { return MarkedInstr->getParent(); }
+BasicBlock *DbgMarker::getParent() { return MarkedInstr->getParent(); }
-void DPMarker::removeMarker() {
- // Are there any DbgRecords in this DPMarker? If not, nothing to preserve.
+void DbgMarker::removeMarker() {
+ // Are there any DbgRecords in this DbgMarker? If not, nothing to preserve.
Instruction *Owner = MarkedInstr;
if (StoredDbgRecords.empty()) {
eraseFromParent();
- Owner->DbgMarker = nullptr;
+ Owner->DebugMarker = nullptr;
return;
}
// The attached DbgRecords need to be preserved; attach them to the next
// instruction. If there isn't a next instruction, put them on the
// "trailing" list.
- DPMarker *NextMarker = Owner->getParent()->getNextMarker(Owner);
+ DbgMarker *NextMarker = Owner->getParent()->getNextMarker(Owner);
if (NextMarker) {
NextMarker->absorbDebugValues(*this, true);
eraseFromParent();
@@ -608,30 +608,30 @@ void DPMarker::removeMarker() {
getParent()->setTrailingDbgRecords(this);
MarkedInstr = nullptr;
} else {
- NextIt->DbgMarker = this;
+ NextIt->DebugMarker = this;
MarkedInstr = &*NextIt;
}
}
- Owner->DbgMarker = nullptr;
+ Owner->DebugMarker = nullptr;
}
-void DPMarker::removeFromParent() {
- MarkedInstr->DbgMarker = nullptr;
+void DbgMarker::removeFromParent() {
+ MarkedInstr->DebugMarker = nullptr;
MarkedInstr = nullptr;
}
-void DPMarker::eraseFromParent() {
+void DbgMarker::eraseFromParent() {
if (MarkedInstr)
removeFromParent();
dropDbgRecords();
delete this;
}
-iterator_range<DbgRecord::self_iterator> DPMarker::getDbgRecordRange() {
+iterator_range<DbgRecord::self_iterator> DbgMarker::getDbgRecordRange() {
return make_range(StoredDbgRecords.begin(), StoredDbgRecords.end());
}
iterator_range<DbgRecord::const_self_iterator>
-DPMarker::getDbgRecordRange() const {
+DbgMarker::getDbgRecordRange() const {
return make_range(StoredDbgRecords.begin(), StoredDbgRecords.end());
}
@@ -645,25 +645,25 @@ void DbgRecord::eraseFromParent() {
deleteRecord();
}
-void DPMarker::insertDbgRecord(DbgRecord *New, bool InsertAtHead) {
+void DbgMarker::insertDbgRecord(DbgRecord *New, bool InsertAtHead) {
auto It = InsertAtHead ? StoredDbgRecords.begin() : StoredDbgRecords.end();
StoredDbgRecords.insert(It, *New);
New->setMarker(this);
}
-void DPMarker::insertDbgRecord(DbgRecord *New, DbgRecord *InsertBefore) {
+void DbgMarker::insertDbgRecord(DbgRecord *New, DbgRecord *InsertBefore) {
assert(InsertBefore->getMarker() == this &&
- "DbgRecord 'InsertBefore' must be contained in this DPMarker!");
+ "DbgRecord 'InsertBefore' must be contained in this DbgMarker!");
StoredDbgRecords.insert(InsertBefore->getIterator(), *New);
New->setMarker(this);
}
-void DPMarker::insertDbgRecordAfter(DbgRecord *New, DbgRecord *InsertAfter) {
+void DbgMarker::insertDbgRecordAfter(DbgRecord *New, DbgRecord *InsertAfter) {
assert(InsertAfter->getMarker() == this &&
- "DbgRecord 'InsertAfter' must be contained in this DPMarker!");
+ "DbgRecord 'InsertAfter' must be contained in this DbgMarker!");
StoredDbgRecords.insert(++(InsertAfter->getIterator()), *New);
New->setMarker(this);
}
-void DPMarker::absorbDebugValues(DPMarker &Src, bool InsertAtHead) {
+void DbgMarker::absorbDebugValues(DbgMarker &Src, bool InsertAtHead) {
auto It = InsertAtHead ? StoredDbgRecords.begin() : StoredDbgRecords.end();
for (DbgRecord &DVR : Src.StoredDbgRecords)
DVR.setMarker(this);
@@ -671,8 +671,8 @@ void DPMarker::absorbDebugValues(DPMarker &Src, bool InsertAtHead) {
StoredDbgRecords.splice(It, Src.StoredDbgRecords);
}
-void DPMarker::absorbDebugValues(iterator_range<DbgRecord::self_iterator> Range,
- DPMarker &Src, bool InsertAtHead) {
+void DbgMarker::absorbDebugValues(iterator_range<DbgRecord::self_iterator> Range,
+ DbgMarker &Src, bool InsertAtHead) {
for (DbgRecord &DR : Range)
DR.setMarker(this);
@@ -683,8 +683,8 @@ void DPMarker::absorbDebugValues(iterator_range<DbgRecord::self_iterator> Range,
Range.end());
}
-iterator_range<simple_ilist<DbgRecord>::iterator> DPMarker::cloneDebugInfoFrom(
- DPMarker *From, std::optional<simple_ilist<DbgRecord>::iterator> from_here,
+iterator_range<simple_ilist<DbgRecord>::iterator> DbgMarker::cloneDebugInfoFrom(
+ DbgMarker *From, std::optional<simple_ilist<DbgRecord>::iterator> from_here,
bool InsertAtHead) {
DbgRecord *First = nullptr;
// Work out what range of DbgRecords to clone: normally all the contents of
diff --git a/llvm/lib/IR/Instruction.cpp b/llvm/lib/IR/Instruction.cpp
index 9744eb32d27a5e..3b6ac948640794 100644
--- a/llvm/lib/IR/Instruction.cpp
+++ b/llvm/lib/IR/Instruction.cpp
@@ -93,10 +93,10 @@ void Instruction::removeFromParent() {
}
void Instruction::handleMarkerRemoval() {
- if (!Parent->IsNewDbgInfoFormat || !DbgMarker)
+ if (!Parent->IsNewDbgInfoFormat || !DebugMarker)
return;
- DbgMarker->removeMarker();
+ DebugMarker->removeMarker();
}
BasicBlock::iterator Instruction::eraseFromParent() {
@@ -135,7 +135,7 @@ extern cl::opt<bool> UseNewDbgInfoFormat;
void Instruction::insertBefore(BasicBlock &BB,
InstListType::iterator InsertPos) {
- assert(!DbgMarker);
+ assert(!DebugMarker);
BB.getInstList().insert(InsertPos, this);
@@ -147,7 +147,7 @@ void Instruction::insertBefore(BasicBlock &BB,
// DbgRecords should now come before "this".
bool InsertAtHead = InsertPos.getHeadBit();
if (!InsertAtHead) {
- DPMarker *SrcMarker = BB.getMarker(InsertPos);
+ DbgMarker *SrcMarker = BB.getMarker(InsertPos);
if (SrcMarker && !SrcMarker->empty()) {
// If this assertion fires, the calling code is about to insert a PHI
// after debug-records, which would form a sequence like:
@@ -214,7 +214,7 @@ void Instruction::moveBeforeImpl(BasicBlock &BB, InstListType::iterator I,
// If we've been given the "Preserve" flag, then just move the DbgRecords with
// the instruction, no more special handling needed.
- if (BB.IsNewDbgInfoFormat && DbgMarker && !Preserve) {
+ if (BB.IsNewDbgInfoFormat && DebugMarker && !Preserve) {
if (I != this->getIterator() || InsertAtHead) {
// "this" is definitely moving in the list, or it's moving ahead of its
// attached DbgVariableRecords. Detach any existing DbgRecords.
@@ -227,7 +227,7 @@ void Instruction::moveBeforeImpl(BasicBlock &BB, InstListType::iterator I,
BB.getInstList().splice(I, getParent()->getInstList(), getIterator());
if (BB.IsNewDbgInfoFormat && !Preserve) {
- DPMarker *NextMarker = getParent()->getNextMarker(this);
+ DbgMarker *NextMarker = getParent()->getNextMarker(this);
// If we're inserting at point I, and not in front of the DbgRecords
// attached there, then we should absorb the DbgRecords attached to I.
@@ -243,23 +243,23 @@ void Instruction::moveBeforeImpl(BasicBlock &BB, InstListType::iterator I,
iterator_range<DbgRecord::self_iterator> Instruction::cloneDebugInfoFrom(
const Instruction *From, std::optional<DbgRecord::self_iterator> FromHere,
bool InsertAtHead) {
- if (!From->DbgMarker)
- return DPMarker::getEmptyDbgRecordRange();
+ if (!From->DebugMarker)
+ return DbgMarker::getEmptyDbgRecordRange();
assert(getParent()->IsNewDbgInfoFormat);
assert(getParent()->IsNewDbgInfoFormat ==
From->getParent()->IsNewDbgInfoFormat);
- if (!DbgMarker)
+ if (!DebugMarker)
getParent()->createMarker(this);
- return DbgMarker->cloneDebugInfoFrom(From->DbgMarker, FromHere, InsertAtHead);
+ return DebugMarker->cloneDebugInfoFrom(From->DebugMarker, FromHere, InsertAtHead);
}
std::optional<DbgRecord::self_iterator>
Instruction::getDbgReinsertionPosition() {
// Is there a marker on the next instruction?
- DPMarker *NextMarker = getParent()->getNextMarker(this);
+ DbgMarker *NextMarker = getParent()->getNextMarker(this);
if (!NextMarker)
return std::nullopt;
@@ -274,7 +274,7 @@ bool Instruction::hasDbgRecords() const { return !getDbgRecordRange().empty(); }
void Instruction::adoptDbgRecords(BasicBlock *BB, BasicBlock::iterator It,
bool InsertAtHead) {
- DPMarker *SrcMarker = BB->getMarker(It);
+ DbgMarker *SrcMarker = BB->getMarker(It);
auto ReleaseTrailingDbgRecords = [BB, It, SrcMarker]() {
if (BB->end() == It) {
SrcMarker->eraseFromParent();
@@ -287,13 +287,13 @@ void Instruction::adoptDbgRecords(BasicBlock *BB, BasicBlock::iterator It,
return;
}
- // If we have DPMarkers attached to this instruction, we have to honour the
+ // If we have DbgMarkers attached to this instruction, we have to honour the
// ordering of DbgRecords between this and the other marker. Fall back to just
// absorbing from the source.
- if (DbgMarker || It == BB->end()) {
+ if (DebugMarker || It == BB->end()) {
// Ensure we _do_ have a marker.
getParent()->createMarker(this);
- DbgMarker->absorbDebugValues(*SrcMarker, InsertAtHead);
+ DebugMarker->absorbDebugValues(*SrcMarker, InsertAtHead);
// Having transferred everything out of SrcMarker, we _could_ clean it up
// and free the marker now. However, that's a lot of heap-accounting for a
@@ -309,19 +309,19 @@ void Instruction::adoptDbgRecords(BasicBlock *BB, BasicBlock::iterator It,
// Optimisation: we're transferring all the DbgRecords from the source
// marker onto this empty location: just adopt the other instructions
// marker.
- DbgMarker = SrcMarker;
- DbgMarker->MarkedInstr = this;
- It->DbgMarker = nullptr;
+ DebugMarker = SrcMarker;
+ DebugMarker->MarkedInstr = this;
+ It->DebugMarker = nullptr;
}
}
void Instruction::dropDbgRecords() {
- if (DbgMarker)
- DbgMarker->dropDbgRecords();
+ if (DebugMarker)
+ DebugMarker->dropDbgRecords();
}
void Instruction::dropOneDbgRecord(DbgRecord *DVR) {
- DbgMarker->dropOneDbgRecord(DVR);
+ DebugMarker->dropOneDbgRecord(DVR);
}
bool Instruction::comesBefore(const Instruction *Other) const {
diff --git a/llvm/lib/IR/LLVMContextImpl.h b/llvm/lib/IR/LLVMContextImpl.h
index 4542e16e59fd69..58e0f21244f786 100644
--- a/llvm/lib/IR/LLVMContextImpl.h
+++ b/llvm/lib/IR/LLVMContextImpl.h
@@ -58,7 +58,7 @@ class AttributeSetNode;
class BasicBlock;
class ConstantRangeAttributeImpl;
struct DiagnosticHandler;
-class DPMarker;
+class DbgMarker;
class ElementCount;
class Function;
class GlobalObject;
@@ -1689,15 +1689,15 @@ class LLVMContextImpl {
/// "trail" in such a way. These are stored in LLVMContext because typically
/// LLVM only edits a small number of blocks at a time, so there's no need to
/// bloat BasicBlock with such a data structure.
- SmallDenseMap<BasicBlock *, DPMarker *> TrailingDbgRecords;
+ SmallDenseMap<BasicBlock *, DbgMarker *> TrailingDbgRecords;
// Set, get and delete operations for TrailingDbgRecords.
- void setTrailingDbgRecords(BasicBlock *B, DPMarker *M) {
+ void setTrailingDbgRecords(BasicBlock *B, DbgMarker *M) {
assert(!TrailingDbgRecords.count(B));
TrailingDbgRecords[B] = M;
}
- DPMarker *getTrailingDbgRecords(BasicBlock *B) {
+ DbgMarker *getTrailingDbgRecords(BasicBlock *B) {
return TrailingDbgRecords.lookup(B);
}
diff --git a/llvm/lib/IR/Value.cpp b/llvm/lib/IR/Value.cpp
index 61e1c35ba4a3a2..8522747ccf1288 100644
--- a/llvm/lib/IR/Value.cpp
+++ b/llvm/lib/IR/Value.cpp
@@ -581,7 +581,7 @@ static void replaceDbgUsesOutsideBlock(Value *V, Value *New, BasicBlock *BB) {
DVI->replaceVariableLocationOp(V, New);
}
for (auto *DVR : DPUsers) {
- DPMarker *Marker = DVR->getMarker();
+ DbgMarker *Marker = DVR->getMarker();
if (Marker->getParent() != BB)
DVR->replaceVariableLocationOp(V, New);
}
diff --git a/llvm/lib/IR/Verifier.cpp b/llvm/lib/IR/Verifier.cpp
index a99b307a3536da..a5674fb0b1425b 100644
--- a/llvm/lib/IR/Verifier.cpp
+++ b/llvm/lib/IR/Verifier.cpp
@@ -678,14 +678,14 @@ class Verifier : public InstVisitor<Verifier>, VerifierSupport {
} while (false)
void Verifier::visitDbgRecords(Instruction &I) {
- if (!I.DbgMarker)
+ if (!I.DebugMarker)
return;
- CheckDI(I.DbgMarker->MarkedInstr == &I, "Instruction has invalid DbgMarker",
+ CheckDI(I.DebugMarker->MarkedInstr == &I, "Instruction has invalid DebugMarker",
&I);
CheckDI(!isa<PHINode>(&I) || !I.hasDbgRecords(),
"PHI Node must not have any attached DbgRecords", &I);
for (DbgRecord &DR : I.getDbgRecordRange()) {
- CheckDI(DR.getMarker() == I.DbgMarker, "DbgRecord had invalid DbgMarker",
+ CheckDI(DR.getMarker() == I.DebugMarker, "DbgRecord had invalid DebugMarker",
&I, &DR);
if (auto *Loc =
dyn_cast_or_null<DILocation>(DR.getDebugLoc().getAsMDNode()))
diff --git a/llvm/lib/Transforms/Scalar/JumpThreading.cpp b/llvm/lib/Transforms/Scalar/JumpThreading.cpp
index fd68359525707f..ffcb511e6a8312 100644
--- a/llvm/lib/Transforms/Scalar/JumpThreading.cpp
+++ b/llvm/lib/Transforms/Scalar/JumpThreading.cpp
@@ -2113,8 +2113,8 @@ JumpThreadingPass::cloneInstructions(BasicBlock::iterator BI,
// marker to marker as there isn't an instruction there.
if (BE != RangeBB->end() && BE->hasDbgRecords()) {
// Dump them at the end.
- DPMarker *Marker = RangeBB->getMarker(BE);
- DPMarker *EndMarker = NewBB->createMarker(NewBB->end());
+ DbgMarker *Marker = RangeBB->getMarker(BE);
+ DbgMarker *EndMarker = NewBB->createMarker(NewBB->end());
auto DVRRange = EndMarker->cloneDebugInfoFrom(Marker, std::nullopt);
for (DbgVariableRecord &DVR : filterDbgVars(DVRRange))
RetargetDbgVariableRecordIfPossible(&DVR);
diff --git a/llvm/lib/Transforms/Utils/LoopRotationUtils.cpp b/llvm/lib/Transforms/Utils/LoopRotationUtils.cpp
index 4470c5af870ae2..bc671171137199 100644
--- a/llvm/lib/Transforms/Utils/LoopRotationUtils.cpp
+++ b/llvm/lib/Transforms/Utils/LoopRotationUtils.cpp
@@ -601,7 +601,7 @@ bool LoopRotate::rotateLoop(Loop *L, bool SimplifiedLatch) {
// a range because it gives us a natural way of testing whether
// there were DbgRecords on the next instruction before we hoisted things).
iterator_range<DbgRecord::self_iterator> NextDbgInsts =
- (I != E) ? I->getDbgRecordRange() : DPMarker::getEmptyDbgRecordRange();
+ (I != E) ? I->getDbgRecordRange() : DbgMarker::getEmptyDbgRecordRange();
while (I != E) {
Instruction *Inst = &*I++;
@@ -659,7 +659,7 @@ bool LoopRotate::rotateLoop(Loop *L, bool SimplifiedLatch) {
RemapDbgVariableRecordRange(M, Range, ValueMap,
RF_NoModuleLevelChanges |
RF_IgnoreMissingLocals);
- NextDbgInsts = DPMarker::getEmptyDbgRecordRange();
+ NextDbgInsts = DbgMarker::getEmptyDbgRecordRange();
// Erase anything we've seen before.
for (DbgVariableRecord &DVR :
make_early_inc_range(filterDbgVars(Range)))
diff --git a/llvm/unittests/IR/BasicBlockDbgInfoTest.cpp b/llvm/unittests/IR/BasicBlockDbgInfoTest.cpp
index 92658b7b6895f5..c68f5dcb7b15cd 100644
--- a/llvm/unittests/IR/BasicBlockDbgInfoTest.cpp
+++ b/llvm/unittests/IR/BasicBlockDbgInfoTest.cpp
@@ -147,10 +147,10 @@ TEST(BasicBlockDbgInfoTest, MarkerOperations) {
// Fetch out our two markers,
Instruction *Instr1 = &*BB.begin();
Instruction *Instr2 = Instr1->getNextNode();
- DPMarker *Marker1 = Instr1->DbgMarker;
- DPMarker *Marker2 = Instr2->DbgMarker;
+ DbgMarker *Marker1 = Instr1->DebugMarker;
+ DbgMarker *Marker2 = Instr2->DebugMarker;
// There's no TrailingDbgRecords marker allocated yet.
- DPMarker *EndMarker = nullptr;
+ DbgMarker *EndMarker = nullptr;
// Check that the "getMarker" utilities operate as expected.
EXPECT_EQ(BB.getMarker(Instr1->getIterator()), Marker1);
@@ -219,7 +219,7 @@ TEST(BasicBlockDbgInfoTest, MarkerOperations) {
// Inserting at end(): should dislodge the DbgVariableRecords, if they were
// dbg.values then they would sit "above" the new instruction.
Instr1->insertBefore(BB, BB.end());
- EXPECT_EQ(Instr1->DbgMarker->StoredDbgRecords.size(), 2u);
+ EXPECT_EQ(Instr1->DebugMarker->StoredDbgRecords.size(), 2u);
// We should de-allocate the trailing marker when something is inserted
// at end().
EXPECT_EQ(BB.getTrailingDbgRecords(), nullptr);
@@ -234,7 +234,7 @@ TEST(BasicBlockDbgInfoTest, MarkerOperations) {
// this be the final instr in the block, and DbgVariableRecords aren't allowed
// to live off the end forever.
Instr2->insertBefore(BB, BB.begin());
- EXPECT_EQ(Instr2->DbgMarker->StoredDbgRecords.size(), 2u);
+ EXPECT_EQ(Instr2->DebugMarker->StoredDbgRecords.size(), 2u);
EXPECT_EQ(BB.getTrailingDbgRecords(), nullptr);
// Teardown,
@@ -297,26 +297,26 @@ TEST(BasicBlockDbgInfoTest, HeadBitOperations) {
Instruction *CInst = BInst->getNextNode();
Instruction *DInst = CInst->getNextNode();
// CInst should have debug-info.
- ASSERT_TRUE(CInst->DbgMarker);
- EXPECT_FALSE(CInst->DbgMarker->StoredDbgRecords.empty());
+ ASSERT_TRUE(CInst->DebugMarker);
+ EXPECT_FALSE(CInst->DebugMarker->StoredDbgRecords.empty());
// If we move "c" to the start of the block, just normally, then the
// DbgVariableRecords should fall down to "d".
CInst->moveBefore(BB, BeginIt2);
- EXPECT_TRUE(!CInst->DbgMarker || CInst->DbgMarker->StoredDbgRecords.empty());
- ASSERT_TRUE(DInst->DbgMarker);
- EXPECT_FALSE(DInst->DbgMarker->StoredDbgRecords.empty());
+ EXPECT_TRUE(!CInst->DebugMarker || CInst->DebugMarker->StoredDbgRecords.empty());
+ ASSERT_TRUE(DInst->DebugMarker);
+ EXPECT_FALSE(DInst->DebugMarker->StoredDbgRecords.empty());
// Wheras if we move D to the start of the block with moveBeforePreserving,
// the DbgVariableRecords should move with it.
DInst->moveBeforePreserving(BB, BB.begin());
- EXPECT_FALSE(DInst->DbgMarker->StoredDbgRecords.empty());
+ EXPECT_FALSE(DInst->DebugMarker->StoredDbgRecords.empty());
EXPECT_EQ(&*BB.begin(), DInst);
// Similarly, moveAfterPreserving "D" to "C" should move DbgVariableRecords
// with "D".
DInst->moveAfterPreserving(CInst);
- EXPECT_FALSE(DInst->DbgMarker->StoredDbgRecords.empty());
+ EXPECT_FALSE(DInst->DebugMarker->StoredDbgRecords.empty());
// (move back to the start...)
DInst->moveBeforePreserving(BB, BB.begin());
@@ -325,8 +325,8 @@ TEST(BasicBlockDbgInfoTest, HeadBitOperations) {
// If we move "C" to the beginning of the block, it should go before the
// DbgVariableRecords. They'll stay on "D".
CInst->moveBefore(BB, BB.begin());
- EXPECT_TRUE(!CInst->DbgMarker || CInst->DbgMarker->StoredDbgRecords.empty());
- EXPECT_FALSE(DInst->DbgMarker->StoredDbgRecords.empty());
+ EXPECT_TRUE(!CInst->DebugMarker || CInst->DebugMarker->StoredDbgRecords.empty());
+ EXPECT_FALSE(DInst->DebugMarker->StoredDbgRecords.empty());
EXPECT_EQ(&*BB.begin(), CInst);
EXPECT_EQ(CInst->getNextNode(), DInst);
@@ -342,8 +342,8 @@ TEST(BasicBlockDbgInfoTest, HeadBitOperations) {
// run of dbg.values and the next instruction.
CInst->moveBefore(BB, DInst->getIterator());
// CInst gains the DbgVariableRecords.
- EXPECT_TRUE(!DInst->DbgMarker || DInst->DbgMarker->StoredDbgRecords.empty());
- EXPECT_FALSE(CInst->DbgMarker->StoredDbgRecords.empty());
+ EXPECT_TRUE(!DInst->DebugMarker || DInst->DebugMarker->StoredDbgRecords.empty());
+ EXPECT_FALSE(CInst->DebugMarker->StoredDbgRecords.empty());
EXPECT_EQ(&*BB.begin(), CInst);
UseNewDbgInfoFormat = false;
@@ -380,7 +380,7 @@ TEST(BasicBlockDbgInfoTest, InstrDbgAccess) {
)");
// Check that DbgVariableRecords can be accessed from Instructions without
- // digging into the depths of DPMarkers.
+ // digging into the depths of DbgMarkers.
BasicBlock &BB = M->getFunction("f")->getEntryBlock();
// Convert the module to "new" form debug-info.
M->convertToNewDbgValues();
@@ -389,18 +389,18 @@ TEST(BasicBlockDbgInfoTest, InstrDbgAccess) {
Instruction *CInst = BInst->getNextNode();
Instruction *DInst = CInst->getNextNode();
- ASSERT_FALSE(BInst->DbgMarker);
- ASSERT_TRUE(CInst->DbgMarker);
- ASSERT_EQ(CInst->DbgMarker->StoredDbgRecords.size(), 1u);
- DbgRecord *DVR1 = &*CInst->DbgMarker->StoredDbgRecords.begin();
+ ASSERT_FALSE(BInst->DebugMarker);
+ ASSERT_TRUE(CInst->DebugMarker);
+ ASSERT_EQ(CInst->DebugMarker->StoredDbgRecords.size(), 1u);
+ DbgRecord *DVR1 = &*CInst->DebugMarker->StoredDbgRecords.begin();
ASSERT_TRUE(DVR1);
EXPECT_FALSE(BInst->hasDbgRecords());
// Clone DbgVariableRecords from one inst to another. Other arguments to clone
- // are tested in DPMarker test.
+ // are tested in DbgMarker test.
auto Range1 = BInst->cloneDebugInfoFrom(CInst);
- EXPECT_EQ(BInst->DbgMarker->StoredDbgRecords.size(), 1u);
- DbgRecord *DVR2 = &*BInst->DbgMarker->StoredDbgRecords.begin();
+ EXPECT_EQ(BInst->DebugMarker->StoredDbgRecords.size(), 1u);
+ DbgRecord *DVR2 = &*BInst->DebugMarker->StoredDbgRecords.begin();
EXPECT_EQ(std::distance(Range1.begin(), Range1.end()), 1u);
EXPECT_EQ(&*Range1.begin(), DVR2);
EXPECT_NE(DVR1, DVR2);
@@ -418,12 +418,12 @@ TEST(BasicBlockDbgInfoTest, InstrDbgAccess) {
// Dropping should be easy,
BInst->dropDbgRecords();
EXPECT_FALSE(BInst->hasDbgRecords());
- EXPECT_EQ(BInst->DbgMarker->StoredDbgRecords.size(), 0u);
+ EXPECT_EQ(BInst->DebugMarker->StoredDbgRecords.size(), 0u);
// And we should be able to drop individual DbgVariableRecords.
CInst->dropOneDbgRecord(DVR1);
EXPECT_FALSE(CInst->hasDbgRecords());
- EXPECT_EQ(CInst->DbgMarker->StoredDbgRecords.size(), 0u);
+ EXPECT_EQ(CInst->DebugMarker->StoredDbgRecords.size(), 0u);
UseNewDbgInfoFormat = false;
}
@@ -533,11 +533,11 @@ class DbgSpliceTest : public ::testing::Test {
CInst = &*Dest;
DVRA =
- cast<DbgVariableRecord>(&*BInst->DbgMarker->StoredDbgRecords.begin());
+ cast<DbgVariableRecord>(&*BInst->DebugMarker->StoredDbgRecords.begin());
DVRB =
- cast<DbgVariableRecord>(&*Branch->DbgMarker->StoredDbgRecords.begin());
+ cast<DbgVariableRecord>(&*Branch->DebugMarker->StoredDbgRecords.begin());
DVRConst =
- cast<DbgVariableRecord>(&*CInst->DbgMarker->StoredDbgRecords.begin());
+ cast<DbgVariableRecord>(&*CInst->DebugMarker->StoredDbgRecords.begin());
}
void TearDown() override { UseNewDbgInfoFormat = false; }
@@ -546,8 +546,8 @@ class DbgSpliceTest : public ::testing::Test {
for (DbgRecord &D : I->getDbgRecordRange()) {
if (&D == DVR) {
// Confirm too that the links between the records are correct.
- EXPECT_EQ(DVR->Marker, I->DbgMarker);
- EXPECT_EQ(I->DbgMarker->MarkedInstr, I);
+ EXPECT_EQ(DVR->Marker, I->DebugMarker);
+ EXPECT_EQ(I->DebugMarker->MarkedInstr, I);
return true;
}
}
@@ -1173,14 +1173,14 @@ TEST(BasicBlockDbgInfoTest, DbgSpliceTrailing) {
// The trailing DbgVariableRecord should have been placed at the front of
// what's been spliced in.
Instruction *BInst = &*Entry.begin();
- ASSERT_TRUE(BInst->DbgMarker);
- EXPECT_EQ(BInst->DbgMarker->StoredDbgRecords.size(), 1u);
+ ASSERT_TRUE(BInst->DebugMarker);
+ EXPECT_EQ(BInst->DebugMarker->StoredDbgRecords.size(), 1u);
UseNewDbgInfoFormat = false;
}
// When we remove instructions from the program, adjacent DbgVariableRecords
-// coalesce together into one DPMarker. In "old" dbg.value mode you could
+// coalesce together into one DbgMarker. In "old" dbg.value mode you could
// re-insert the removed instruction back into the middle of a sequence of
// dbg.values. Test that this can be replicated correctly by DbgVariableRecords
TEST(BasicBlockDbgInfoTest, RemoveInstAndReinsert) {
@@ -1392,7 +1392,7 @@ TEST(BasicBlockDbgInfoTest, DbgSpliceToEmpty1) {
// should be in the correct order of %a, then 0.
Instruction *BInst = &*Entry.begin();
ASSERT_TRUE(BInst->hasDbgRecords());
- EXPECT_EQ(BInst->DbgMarker->StoredDbgRecords.size(), 2u);
+ EXPECT_EQ(BInst->DebugMarker->StoredDbgRecords.size(), 2u);
SmallVector<DbgVariableRecord *, 2> DbgVariableRecords;
for (DbgRecord &DVR : BInst->getDbgRecordRange())
DbgVariableRecords.push_back(cast<DbgVariableRecord>(&DVR));
@@ -1462,7 +1462,7 @@ TEST(BasicBlockDbgInfoTest, DbgSpliceToEmpty2) {
// We should now have one dbg.values on the first instruction, %a.
Instruction *BInst = &*Entry.begin();
ASSERT_TRUE(BInst->hasDbgRecords());
- EXPECT_EQ(BInst->DbgMarker->StoredDbgRecords.size(), 1u);
+ EXPECT_EQ(BInst->DebugMarker->StoredDbgRecords.size(), 1u);
SmallVector<DbgVariableRecord *, 2> DbgVariableRecords;
for (DbgRecord &DVR : BInst->getDbgRecordRange())
DbgVariableRecords.push_back(cast<DbgVariableRecord>(&DVR));
diff --git a/llvm/unittests/IR/DebugInfoTest.cpp b/llvm/unittests/IR/DebugInfoTest.cpp
index 3672f2bccfecd7..ebbd8af906ebec 100644
--- a/llvm/unittests/IR/DebugInfoTest.cpp
+++ b/llvm/unittests/IR/DebugInfoTest.cpp
@@ -947,67 +947,67 @@ TEST(MetadataTest, ConvertDbgToDbgVariableRecord) {
Instruction *FirstInst = &ExitBlock->front();
Instruction *RetInst = &*std::next(FirstInst->getIterator());
- // Set-up DPMarkers in this block.
+ // Set-up DbgMarkers in this block.
ExitBlock->IsNewDbgInfoFormat = true;
ExitBlock->createMarker(FirstInst);
ExitBlock->createMarker(RetInst);
// Insert DbgRecords into markers, order should come out DVR2, DVR1.
- FirstInst->DbgMarker->insertDbgRecord(DVR1, false);
- FirstInst->DbgMarker->insertDbgRecord(DVR2, true);
+ FirstInst->DebugMarker->insertDbgRecord(DVR1, false);
+ FirstInst->DebugMarker->insertDbgRecord(DVR2, true);
unsigned int ItCount = 0;
- for (DbgRecord &Item : FirstInst->DbgMarker->getDbgRecordRange()) {
+ for (DbgRecord &Item : FirstInst->DebugMarker->getDbgRecordRange()) {
EXPECT_TRUE((&Item == DVR2 && ItCount == 0) ||
(&Item == DVR1 && ItCount == 1));
- EXPECT_EQ(Item.getMarker(), FirstInst->DbgMarker);
+ EXPECT_EQ(Item.getMarker(), FirstInst->DebugMarker);
++ItCount;
}
// Clone them onto the second marker -- should allocate new DVRs.
- RetInst->DbgMarker->cloneDebugInfoFrom(FirstInst->DbgMarker, std::nullopt, false);
- EXPECT_EQ(RetInst->DbgMarker->StoredDbgRecords.size(), 2u);
+ RetInst->DebugMarker->cloneDebugInfoFrom(FirstInst->DebugMarker, std::nullopt, false);
+ EXPECT_EQ(RetInst->DebugMarker->StoredDbgRecords.size(), 2u);
ItCount = 0;
// Check these things store the same information; but that they're not the same
// objects.
for (DbgVariableRecord &Item :
- filterDbgVars(RetInst->DbgMarker->getDbgRecordRange())) {
+ filterDbgVars(RetInst->DebugMarker->getDbgRecordRange())) {
EXPECT_TRUE(
(Item.getRawLocation() == DVR2->getRawLocation() && ItCount == 0) ||
(Item.getRawLocation() == DVR1->getRawLocation() && ItCount == 1));
- EXPECT_EQ(Item.getMarker(), RetInst->DbgMarker);
+ EXPECT_EQ(Item.getMarker(), RetInst->DebugMarker);
EXPECT_NE(&Item, DVR1);
EXPECT_NE(&Item, DVR2);
++ItCount;
}
- RetInst->DbgMarker->dropDbgRecords();
- EXPECT_EQ(RetInst->DbgMarker->StoredDbgRecords.size(), 0u);
+ RetInst->DebugMarker->dropDbgRecords();
+ EXPECT_EQ(RetInst->DebugMarker->StoredDbgRecords.size(), 0u);
// Try cloning one single DbgVariableRecord.
- auto DIIt = std::next(FirstInst->DbgMarker->getDbgRecordRange().begin());
- RetInst->DbgMarker->cloneDebugInfoFrom(FirstInst->DbgMarker, DIIt, false);
- EXPECT_EQ(RetInst->DbgMarker->StoredDbgRecords.size(), 1u);
+ auto DIIt = std::next(FirstInst->DebugMarker->getDbgRecordRange().begin());
+ RetInst->DebugMarker->cloneDebugInfoFrom(FirstInst->DebugMarker, DIIt, false);
+ EXPECT_EQ(RetInst->DebugMarker->StoredDbgRecords.size(), 1u);
// The second DbgVariableRecord should have been cloned; it should have the
// same values as DVR1.
EXPECT_EQ(
- cast<DbgVariableRecord>(RetInst->DbgMarker->StoredDbgRecords.begin())
+ cast<DbgVariableRecord>(RetInst->DebugMarker->StoredDbgRecords.begin())
->getRawLocation(),
DVR1->getRawLocation());
// We should be able to drop individual DbgRecords.
- RetInst->DbgMarker->dropOneDbgRecord(
- &*RetInst->DbgMarker->StoredDbgRecords.begin());
+ RetInst->DebugMarker->dropOneDbgRecord(
+ &*RetInst->DebugMarker->StoredDbgRecords.begin());
- // "Aborb" a DPMarker: this means pretend that the instruction it's attached
+ // "Aborb" a DbgMarker: this means pretend that the instruction it's attached
// to is disappearing so it needs to be transferred into "this" marker.
- RetInst->DbgMarker->absorbDebugValues(*FirstInst->DbgMarker, true);
- EXPECT_EQ(RetInst->DbgMarker->StoredDbgRecords.size(), 2u);
+ RetInst->DebugMarker->absorbDebugValues(*FirstInst->DebugMarker, true);
+ EXPECT_EQ(RetInst->DebugMarker->StoredDbgRecords.size(), 2u);
// Should be the DVR1 and DVR2 objects.
ItCount = 0;
- for (DbgRecord &Item : RetInst->DbgMarker->getDbgRecordRange()) {
+ for (DbgRecord &Item : RetInst->DebugMarker->getDbgRecordRange()) {
EXPECT_TRUE((&Item == DVR2 && ItCount == 0) ||
(&Item == DVR1 && ItCount == 1));
- EXPECT_EQ(Item.getMarker(), RetInst->DbgMarker);
+ EXPECT_EQ(Item.getMarker(), RetInst->DebugMarker);
++ItCount;
}
@@ -1015,12 +1015,12 @@ TEST(MetadataTest, ConvertDbgToDbgVariableRecord) {
// evrything in the basic block, then they should sink down into the
// "TrailingDbgRecords" container for dangling debug-info. Future facilities
// will restore them back when a terminator is inserted.
- FirstInst->DbgMarker->removeMarker();
+ FirstInst->DebugMarker->removeMarker();
FirstInst->eraseFromParent();
- RetInst->DbgMarker->removeMarker();
+ RetInst->DebugMarker->removeMarker();
RetInst->eraseFromParent();
- DPMarker *EndMarker = ExitBlock->getTrailingDbgRecords();
+ DbgMarker *EndMarker = ExitBlock->getTrailingDbgRecords();
ASSERT_NE(EndMarker, nullptr);
EXPECT_EQ(EndMarker->StoredDbgRecords.size(), 2u);
// Test again that it's those two DbgVariableRecords, DVR1 and DVR2.
@@ -1083,7 +1083,7 @@ TEST(MetadataTest, DbgVariableRecordConversionRoutines) {
// First instruction should be a dbg.value.
EXPECT_TRUE(isa<DbgValueInst>(BB1->front()));
EXPECT_FALSE(BB1->IsNewDbgInfoFormat);
- // Validating the block for DbgVariableRecords / DPMarkers shouldn't fail --
+ // Validating the block for DbgVariableRecords / DbgMarkers shouldn't fail --
// there's no data stored right now.
bool BrokenDebugInfo = false;
bool Error = verifyModule(*M, &errs(), &BrokenDebugInfo);
@@ -1107,38 +1107,38 @@ TEST(MetadataTest, DbgVariableRecordConversionRoutines) {
for (auto &I : BB)
EXPECT_FALSE(isa<DbgValueInst>(I));
- // There should be a DPMarker on each of the two instructions in the entry
+ // There should be a DbgMarker on each of the two instructions in the entry
// block, each containing one DbgVariableRecord.
EXPECT_EQ(BB1->size(), 2u);
Instruction *FirstInst = &BB1->front();
Instruction *SecondInst = FirstInst->getNextNode();
- ASSERT_TRUE(FirstInst->DbgMarker);
- ASSERT_TRUE(SecondInst->DbgMarker);
- EXPECT_NE(FirstInst->DbgMarker, SecondInst->DbgMarker);
- EXPECT_EQ(FirstInst, FirstInst->DbgMarker->MarkedInstr);
- EXPECT_EQ(SecondInst, SecondInst->DbgMarker->MarkedInstr);
+ ASSERT_TRUE(FirstInst->DebugMarker);
+ ASSERT_TRUE(SecondInst->DebugMarker);
+ EXPECT_NE(FirstInst->DebugMarker, SecondInst->DebugMarker);
+ EXPECT_EQ(FirstInst, FirstInst->DebugMarker->MarkedInstr);
+ EXPECT_EQ(SecondInst, SecondInst->DebugMarker->MarkedInstr);
- EXPECT_EQ(FirstInst->DbgMarker->StoredDbgRecords.size(), 1u);
+ EXPECT_EQ(FirstInst->DebugMarker->StoredDbgRecords.size(), 1u);
DbgVariableRecord *DVR1 = cast<DbgVariableRecord>(
- &*FirstInst->DbgMarker->getDbgRecordRange().begin());
- EXPECT_EQ(DVR1->getMarker(), FirstInst->DbgMarker);
+ &*FirstInst->DebugMarker->getDbgRecordRange().begin());
+ EXPECT_EQ(DVR1->getMarker(), FirstInst->DebugMarker);
// Should point at %a, an argument.
EXPECT_TRUE(isa<Argument>(DVR1->getVariableLocationOp(0)));
- EXPECT_EQ(SecondInst->DbgMarker->StoredDbgRecords.size(), 1u);
+ EXPECT_EQ(SecondInst->DebugMarker->StoredDbgRecords.size(), 1u);
DbgVariableRecord *DVR2 = cast<DbgVariableRecord>(
- &*SecondInst->DbgMarker->getDbgRecordRange().begin());
- EXPECT_EQ(DVR2->getMarker(), SecondInst->DbgMarker);
+ &*SecondInst->DebugMarker->getDbgRecordRange().begin());
+ EXPECT_EQ(DVR2->getMarker(), SecondInst->DebugMarker);
// Should point at FirstInst.
EXPECT_EQ(DVR2->getVariableLocationOp(0), FirstInst);
- // There should be no DbgVariableRecords / DPMarkers in the second block, but
+ // There should be no DbgVariableRecords / DbgMarkers in the second block, but
// it should be marked as being in the new format.
BasicBlock *BB2 = BB1->getNextNode();
EXPECT_TRUE(BB2->IsNewDbgInfoFormat);
for (auto &Inst : *BB2)
// Either there should be no marker, or it should be empty.
- EXPECT_TRUE(!Inst.DbgMarker || Inst.DbgMarker->StoredDbgRecords.empty());
+ EXPECT_TRUE(!Inst.DebugMarker || Inst.DebugMarker->StoredDbgRecords.empty());
// Validating the first block should continue to not be a problem,
Error = verifyModule(*M, &errs(), &BrokenDebugInfo);
@@ -1152,7 +1152,7 @@ TEST(MetadataTest, DbgVariableRecordConversionRoutines) {
Error = verifyModule(*M, &errs(), &BrokenDebugInfo);
EXPECT_FALSE(Error);
EXPECT_TRUE(BrokenDebugInfo);
- DVR1->setMarker(FirstInst->DbgMarker);
+ DVR1->setMarker(FirstInst->DebugMarker);
DILocalVariable *DLV1 = DVR1->getVariable();
DIExpression *Expr1 = DVR1->getExpression();
diff --git a/llvm/unittests/Transforms/Utils/LocalTest.cpp b/llvm/unittests/Transforms/Utils/LocalTest.cpp
index 4258f218794f84..a86775a1366b05 100644
--- a/llvm/unittests/Transforms/Utils/LocalTest.cpp
+++ b/llvm/unittests/Transforms/Utils/LocalTest.cpp
@@ -1324,10 +1324,10 @@ TEST(Local, ReplaceDbgVariableRecord) {
Instruction *RetInst = &*It;
// Convert DVI into a DbgVariableRecord.
- RetInst->DbgMarker = new DPMarker();
- RetInst->DbgMarker->MarkedInstr = RetInst;
+ RetInst->DebugMarker = new DbgMarker();
+ RetInst->DebugMarker->MarkedInstr = RetInst;
DbgVariableRecord *DVR = new DbgVariableRecord(DVI);
- RetInst->DbgMarker->insertDbgRecord(DVR, false);
+ RetInst->DebugMarker->insertDbgRecord(DVR, false);
// ... and erase the dbg.value.
DVI->eraseFromParent();
@@ -1341,5 +1341,5 @@ TEST(Local, ReplaceDbgVariableRecord) {
EXPECT_EQ(DVR->getVariableLocationOp(0), FooInst);
// Teardown.
- RetInst->DbgMarker->eraseFromParent();
+ RetInst->DebugMarker->eraseFromParent();
}
>From 000da025e807353f925ae5a581f3879ac7ec3808 Mon Sep 17 00:00:00 2001
From: Stephen Tozer <stephen.tozer at sony.com>
Date: Wed, 20 Mar 2024 13:49:08 +0000
Subject: [PATCH 2/4] clang-format
---
llvm/include/llvm/IR/DebugProgramInstruction.h | 5 +++--
llvm/include/llvm/IR/Instruction.h | 3 ++-
llvm/lib/IR/AsmWriter.cpp | 7 +++++--
llvm/lib/IR/BasicBlock.cpp | 3 ++-
llvm/lib/IR/DebugProgramInstruction.cpp | 8 +++++---
llvm/lib/IR/Instruction.cpp | 3 ++-
llvm/lib/IR/Verifier.cpp | 8 ++++----
llvm/unittests/IR/BasicBlockDbgInfoTest.cpp | 13 ++++++++-----
llvm/unittests/IR/DebugInfoTest.cpp | 6 ++++--
9 files changed, 35 insertions(+), 21 deletions(-)
diff --git a/llvm/include/llvm/IR/DebugProgramInstruction.h b/llvm/include/llvm/IR/DebugProgramInstruction.h
index b9be443c28de0a..7214d7ad65da67 100644
--- a/llvm/include/llvm/IR/DebugProgramInstruction.h
+++ b/llvm/include/llvm/IR/DebugProgramInstruction.h
@@ -593,8 +593,9 @@ class DbgMarker {
iterator_range<simple_ilist<DbgRecord>::iterator> getDbgRecordRange();
iterator_range<simple_ilist<DbgRecord>::const_iterator>
getDbgRecordRange() const;
- /// Transfer any DbgRecords from \p Src into this DbgMarker. If \p InsertAtHead
- /// is true, place them before existing DbgRecords, otherwise afterwards.
+ /// Transfer any DbgRecords from \p Src into this DbgMarker. If \p
+ /// InsertAtHead is true, place them before existing DbgRecords, otherwise
+ /// afterwards.
void absorbDebugValues(DbgMarker &Src, bool InsertAtHead);
/// Transfer the DbgRecords in \p Range from \p Src into this DbgMarker. If
/// \p InsertAtHead is true, place them before existing DbgRecords, otherwise
diff --git a/llvm/include/llvm/IR/Instruction.h b/llvm/include/llvm/IR/Instruction.h
index e627b58623dc1e..6e0874c5b04f29 100644
--- a/llvm/include/llvm/IR/Instruction.h
+++ b/llvm/include/llvm/IR/Instruction.h
@@ -41,7 +41,8 @@ template <> struct ilist_alloc_traits<Instruction> {
static inline void deleteNode(Instruction *V);
};
-iterator_range<simple_ilist<DbgRecord>::iterator> getDbgRecordRange(DbgMarker *);
+iterator_range<simple_ilist<DbgRecord>::iterator>
+getDbgRecordRange(DbgMarker *);
class Instruction : public User,
public ilist_node_with_parent<Instruction, BasicBlock,
diff --git a/llvm/lib/IR/AsmWriter.cpp b/llvm/lib/IR/AsmWriter.cpp
index 9728802a7b3e34..38c191a2dec60e 100644
--- a/llvm/lib/IR/AsmWriter.cpp
+++ b/llvm/lib/IR/AsmWriter.cpp
@@ -4920,7 +4920,7 @@ void DbgVariableRecord::print(raw_ostream &ROS, bool IsForDebug) const {
}
void DbgMarker::print(raw_ostream &ROS, ModuleSlotTracker &MST,
- bool IsForDebug) const {
+ bool IsForDebug) const {
formatted_raw_ostream OS(ROS);
SlotTracker EmptySlotTable(static_cast<const Module *>(nullptr));
SlotTracker &SlotTable =
@@ -5220,7 +5220,10 @@ void Value::dump() const { print(dbgs(), /*IsForDebug=*/true); dbgs() << '\n'; }
// Value::dump - allow easy printing of Values from the debugger.
LLVM_DUMP_METHOD
-void DbgMarker::dump() const { print(dbgs(), /*IsForDebug=*/true); dbgs() << '\n'; }
+void DbgMarker::dump() const {
+ print(dbgs(), /*IsForDebug=*/true);
+ dbgs() << '\n';
+}
// Value::dump - allow easy printing of Values from the debugger.
LLVM_DUMP_METHOD
diff --git a/llvm/lib/IR/BasicBlock.cpp b/llvm/lib/IR/BasicBlock.cpp
index 25b01986a693b1..9f417a085ee5ac 100644
--- a/llvm/lib/IR/BasicBlock.cpp
+++ b/llvm/lib/IR/BasicBlock.cpp
@@ -70,7 +70,8 @@ void BasicBlock::convertToNewDbgValues() {
// Iterate over all instructions in the instruction list, collecting debug
// info intrinsics and converting them to DbgRecords. Once we find a "real"
- // instruction, attach all those DbgRecords to a DbgMarker in that instruction.
+ // instruction, attach all those DbgRecords to a DbgMarker in that
+ // instruction.
SmallVector<DbgRecord *, 4> DbgVarRecs;
for (Instruction &I : make_early_inc_range(InstList)) {
assert(!I.DebugMarker && "DebugMarker already set on old-format instrs?");
diff --git a/llvm/lib/IR/DebugProgramInstruction.cpp b/llvm/lib/IR/DebugProgramInstruction.cpp
index 3848eba7bac2cc..e10ae4b8ecf28a 100644
--- a/llvm/lib/IR/DebugProgramInstruction.cpp
+++ b/llvm/lib/IR/DebugProgramInstruction.cpp
@@ -1,4 +1,5 @@
-//=====-- DebugProgramInstruction.cpp - Implement DbgRecords/DbgMarkers --=====//
+//=====-- DebugProgramInstruction.cpp - Implement DbgRecords/DbgMarkers
+//--=====//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
@@ -671,8 +672,9 @@ void DbgMarker::absorbDebugValues(DbgMarker &Src, bool InsertAtHead) {
StoredDbgRecords.splice(It, Src.StoredDbgRecords);
}
-void DbgMarker::absorbDebugValues(iterator_range<DbgRecord::self_iterator> Range,
- DbgMarker &Src, bool InsertAtHead) {
+void DbgMarker::absorbDebugValues(
+ iterator_range<DbgRecord::self_iterator> Range, DbgMarker &Src,
+ bool InsertAtHead) {
for (DbgRecord &DR : Range)
DR.setMarker(this);
diff --git a/llvm/lib/IR/Instruction.cpp b/llvm/lib/IR/Instruction.cpp
index 3b6ac948640794..47a7f2c9de790f 100644
--- a/llvm/lib/IR/Instruction.cpp
+++ b/llvm/lib/IR/Instruction.cpp
@@ -253,7 +253,8 @@ iterator_range<DbgRecord::self_iterator> Instruction::cloneDebugInfoFrom(
if (!DebugMarker)
getParent()->createMarker(this);
- return DebugMarker->cloneDebugInfoFrom(From->DebugMarker, FromHere, InsertAtHead);
+ return DebugMarker->cloneDebugInfoFrom(From->DebugMarker, FromHere,
+ InsertAtHead);
}
std::optional<DbgRecord::self_iterator>
diff --git a/llvm/lib/IR/Verifier.cpp b/llvm/lib/IR/Verifier.cpp
index a5674fb0b1425b..819722566831c6 100644
--- a/llvm/lib/IR/Verifier.cpp
+++ b/llvm/lib/IR/Verifier.cpp
@@ -680,13 +680,13 @@ class Verifier : public InstVisitor<Verifier>, VerifierSupport {
void Verifier::visitDbgRecords(Instruction &I) {
if (!I.DebugMarker)
return;
- CheckDI(I.DebugMarker->MarkedInstr == &I, "Instruction has invalid DebugMarker",
- &I);
+ CheckDI(I.DebugMarker->MarkedInstr == &I,
+ "Instruction has invalid DebugMarker", &I);
CheckDI(!isa<PHINode>(&I) || !I.hasDbgRecords(),
"PHI Node must not have any attached DbgRecords", &I);
for (DbgRecord &DR : I.getDbgRecordRange()) {
- CheckDI(DR.getMarker() == I.DebugMarker, "DbgRecord had invalid DebugMarker",
- &I, &DR);
+ CheckDI(DR.getMarker() == I.DebugMarker,
+ "DbgRecord had invalid DebugMarker", &I, &DR);
if (auto *Loc =
dyn_cast_or_null<DILocation>(DR.getDebugLoc().getAsMDNode()))
visitMDNode(*Loc, AreDebugLocsAllowed::Yes);
diff --git a/llvm/unittests/IR/BasicBlockDbgInfoTest.cpp b/llvm/unittests/IR/BasicBlockDbgInfoTest.cpp
index c68f5dcb7b15cd..905928819dda80 100644
--- a/llvm/unittests/IR/BasicBlockDbgInfoTest.cpp
+++ b/llvm/unittests/IR/BasicBlockDbgInfoTest.cpp
@@ -303,7 +303,8 @@ TEST(BasicBlockDbgInfoTest, HeadBitOperations) {
// If we move "c" to the start of the block, just normally, then the
// DbgVariableRecords should fall down to "d".
CInst->moveBefore(BB, BeginIt2);
- EXPECT_TRUE(!CInst->DebugMarker || CInst->DebugMarker->StoredDbgRecords.empty());
+ EXPECT_TRUE(!CInst->DebugMarker ||
+ CInst->DebugMarker->StoredDbgRecords.empty());
ASSERT_TRUE(DInst->DebugMarker);
EXPECT_FALSE(DInst->DebugMarker->StoredDbgRecords.empty());
@@ -325,7 +326,8 @@ TEST(BasicBlockDbgInfoTest, HeadBitOperations) {
// If we move "C" to the beginning of the block, it should go before the
// DbgVariableRecords. They'll stay on "D".
CInst->moveBefore(BB, BB.begin());
- EXPECT_TRUE(!CInst->DebugMarker || CInst->DebugMarker->StoredDbgRecords.empty());
+ EXPECT_TRUE(!CInst->DebugMarker ||
+ CInst->DebugMarker->StoredDbgRecords.empty());
EXPECT_FALSE(DInst->DebugMarker->StoredDbgRecords.empty());
EXPECT_EQ(&*BB.begin(), CInst);
EXPECT_EQ(CInst->getNextNode(), DInst);
@@ -342,7 +344,8 @@ TEST(BasicBlockDbgInfoTest, HeadBitOperations) {
// run of dbg.values and the next instruction.
CInst->moveBefore(BB, DInst->getIterator());
// CInst gains the DbgVariableRecords.
- EXPECT_TRUE(!DInst->DebugMarker || DInst->DebugMarker->StoredDbgRecords.empty());
+ EXPECT_TRUE(!DInst->DebugMarker ||
+ DInst->DebugMarker->StoredDbgRecords.empty());
EXPECT_FALSE(CInst->DebugMarker->StoredDbgRecords.empty());
EXPECT_EQ(&*BB.begin(), CInst);
@@ -534,8 +537,8 @@ class DbgSpliceTest : public ::testing::Test {
DVRA =
cast<DbgVariableRecord>(&*BInst->DebugMarker->StoredDbgRecords.begin());
- DVRB =
- cast<DbgVariableRecord>(&*Branch->DebugMarker->StoredDbgRecords.begin());
+ DVRB = cast<DbgVariableRecord>(
+ &*Branch->DebugMarker->StoredDbgRecords.begin());
DVRConst =
cast<DbgVariableRecord>(&*CInst->DebugMarker->StoredDbgRecords.begin());
}
diff --git a/llvm/unittests/IR/DebugInfoTest.cpp b/llvm/unittests/IR/DebugInfoTest.cpp
index ebbd8af906ebec..d06b979bf4a1c4 100644
--- a/llvm/unittests/IR/DebugInfoTest.cpp
+++ b/llvm/unittests/IR/DebugInfoTest.cpp
@@ -964,7 +964,8 @@ TEST(MetadataTest, ConvertDbgToDbgVariableRecord) {
}
// Clone them onto the second marker -- should allocate new DVRs.
- RetInst->DebugMarker->cloneDebugInfoFrom(FirstInst->DebugMarker, std::nullopt, false);
+ RetInst->DebugMarker->cloneDebugInfoFrom(FirstInst->DebugMarker, std::nullopt,
+ false);
EXPECT_EQ(RetInst->DebugMarker->StoredDbgRecords.size(), 2u);
ItCount = 0;
// Check these things store the same information; but that they're not the same
@@ -1138,7 +1139,8 @@ TEST(MetadataTest, DbgVariableRecordConversionRoutines) {
EXPECT_TRUE(BB2->IsNewDbgInfoFormat);
for (auto &Inst : *BB2)
// Either there should be no marker, or it should be empty.
- EXPECT_TRUE(!Inst.DebugMarker || Inst.DebugMarker->StoredDbgRecords.empty());
+ EXPECT_TRUE(!Inst.DebugMarker ||
+ Inst.DebugMarker->StoredDbgRecords.empty());
// Validating the first block should continue to not be a problem,
Error = verifyModule(*M, &errs(), &BrokenDebugInfo);
>From f5129c4b2628864235f2098cd5cbab797670bbb4 Mon Sep 17 00:00:00 2001
From: Stephen Tozer <stephen.tozer at sony.com>
Date: Wed, 20 Mar 2024 13:50:20 +0000
Subject: [PATCH 3/4] Fix misaligned text
---
llvm/docs/RemoveDIsDebugInfo.md | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/llvm/docs/RemoveDIsDebugInfo.md b/llvm/docs/RemoveDIsDebugInfo.md
index 7515435cc4691f..a2f1e173d9d935 100644
--- a/llvm/docs/RemoveDIsDebugInfo.md
+++ b/llvm/docs/RemoveDIsDebugInfo.md
@@ -85,9 +85,9 @@ Like so:
+-------------+
<-------+ DbgMarker |<-------
/ +-------------+ \
- / \
- / \
- v ^
+ / \
+ / \
+ v ^
+-------------+ +-------------+ +-------------+
| DbgRecord +--->| DbgRecord +-->| DbgRecord |
+-------------+ +-------------+ +-------------+
>From 74f240e44bc50af1c99f8e17effd40816a159b70 Mon Sep 17 00:00:00 2001
From: Stephen Tozer <stephen.tozer at sony.com>
Date: Wed, 20 Mar 2024 13:52:20 +0000
Subject: [PATCH 4/4] Rename DPM->DM
---
llvm/lib/IR/BasicBlock.cpp | 22 +++++++++++-----------
1 file changed, 11 insertions(+), 11 deletions(-)
diff --git a/llvm/lib/IR/BasicBlock.cpp b/llvm/lib/IR/BasicBlock.cpp
index 9f417a085ee5ac..f088c7a2cc4e77 100644
--- a/llvm/lib/IR/BasicBlock.cpp
+++ b/llvm/lib/IR/BasicBlock.cpp
@@ -57,12 +57,12 @@ DbgMarker *BasicBlock::createMarker(InstListType::iterator It) {
"Tried to create a marker in a non new debug-info block!");
if (It != end())
return createMarker(&*It);
- DbgMarker *DPM = getTrailingDbgRecords();
- if (DPM)
- return DPM;
- DPM = new DbgMarker();
- setTrailingDbgRecords(DPM);
- return DPM;
+ DbgMarker *DM = getTrailingDbgRecords();
+ if (DM)
+ return DM;
+ DM = new DbgMarker();
+ setTrailingDbgRecords(DM);
+ return DM;
}
void BasicBlock::convertToNewDbgValues() {
@@ -1059,8 +1059,8 @@ DbgMarker *BasicBlock::getNextMarker(Instruction *I) {
DbgMarker *BasicBlock::getMarker(InstListType::iterator It) {
if (It == end()) {
- DbgMarker *DPM = getTrailingDbgRecords();
- return DPM;
+ DbgMarker *DM = getTrailingDbgRecords();
+ return DM;
}
return It->DebugMarker;
}
@@ -1108,15 +1108,15 @@ void BasicBlock::reinsertInstInDbgRecords(
}
// Is there even a range of DbgRecords to move?
- DbgMarker *DPM = (*Pos)->getMarker();
- auto Range = make_range(DPM->StoredDbgRecords.begin(), (*Pos));
+ DbgMarker *DM = (*Pos)->getMarker();
+ auto Range = make_range(DM->StoredDbgRecords.begin(), (*Pos));
if (Range.begin() == Range.end())
return;
// Otherwise: splice.
DbgMarker *ThisMarker = createMarker(I);
assert(ThisMarker->StoredDbgRecords.empty());
- ThisMarker->absorbDebugValues(Range, *DPM, true);
+ ThisMarker->absorbDebugValues(Range, *DM, true);
}
#ifndef NDEBUG
More information about the llvm-commits
mailing list