[llvm] [RemoveDIs] Read/write DbgRecords directly from/to bitcode (PR #83251)
Orlando Cazalet-Hyams via llvm-commits
llvm-commits at lists.llvm.org
Thu Mar 7 03:54:02 PST 2024
https://github.com/OCHyams updated https://github.com/llvm/llvm-project/pull/83251
>From c4044919f1c79f5e0c49f2fd3c4325f4011cee07 Mon Sep 17 00:00:00 2001
From: OCHyams <orlando.hyams at sony.com>
Date: Thu, 4 May 2023 17:07:25 +0100
Subject: [PATCH 1/9] [RemoveDIs] Add bitcode format
If --write-experimental-debuginfo-iterators-to-bitcode is true (default true)
and --expermental-debuginfo-iterators is also true then the new debug info
format (non-instruction records) is written to bitcode directly.
Added the following records:
FUNC_CODE_DEBUG_RECORD_LABEL
FUNC_CODE_DEBUG_RECORD_VALUE
FUNC_CODE_DEBUG_RECORD_DECLARE
FUNC_CODE_DEBUG_RECORD_ASSIGN
FUNC_CODE_DEBUG_RECORD_VALUE_SIMPLE
The last one has an abbrev in FUNCTION_BLOCK BLOCK_INFO. Incidentally, this uses
the last value available without widening the code-length for FUNCTION_BLOCK
from 4 to 5 bits.
Records are formatted as follows:
All DbgRecord start with:
1. DILocation
FUNC_CODE_DEBUG_RECORD_LABEL
2. DILabel
DPValues then share common fields:
2. DILocalVariable
3. DIExpression
FUNC_CODE_DEBUG_RECORD_VALUE
4. Location Metadata
FUNC_CODE_DEBUG_RECORD_DECLARE
4. Location Metadata
FUNC_CODE_DEBUG_RECORD_VALUE_SIMPLE
4. Location Value (single)
FUNC_CODE_DEBUG_RECORD_ASSIGN
4. Location Metadata
5. DIAssignID
6. DIExpression (address)
7. Location Metadata (address)
Encoding the DILocation metadata reference directly appeared to yield smaller
bitcode files than encoding the operands seperately (as is done with instruction
DILocations).
FUNC_CODE_DEBUG_RECORD_VALUE_SIMPLE is by far the most common DbgRecord record
in optimized code (order of 5x-10x over other kinds). Unoptimized code should
only contain FUNC_CODE_DEBUG_RECORD_DECLARE.
---
llvm/include/llvm/Bitcode/LLVMBitCodes.h | 11 ++
llvm/lib/Bitcode/Reader/BitcodeAnalyzer.cpp | 4 +
llvm/lib/Bitcode/Reader/BitcodeReader.cpp | 89 ++++++++++-
llvm/lib/Bitcode/Writer/BitcodeWriter.cpp | 118 +++++++++++---
llvm/lib/Bitcode/Writer/BitcodeWriterPass.cpp | 20 +--
llvm/lib/Bitcode/Writer/ValueEnumerator.cpp | 149 ++++++++++++------
llvm/lib/IR/BasicBlock.cpp | 5 +
llvm/lib/IR/Verifier.cpp | 11 ++
llvm/lib/Linker/IRMover.cpp | 6 +-
.../Transforms/IPO/ThinLTOBitcodeWriter.cpp | 9 +-
llvm/test/Bitcode/dbg-record-roundtrip.ll | 127 +++++++++++++++
llvm/tools/llvm-as/llvm-as.cpp | 7 +
.../verify-uselistorder.cpp | 11 ++
13 files changed, 481 insertions(+), 86 deletions(-)
create mode 100644 llvm/test/Bitcode/dbg-record-roundtrip.ll
diff --git a/llvm/include/llvm/Bitcode/LLVMBitCodes.h b/llvm/include/llvm/Bitcode/LLVMBitCodes.h
index c6f0ddf29a6da8..528a6baa4870ee 100644
--- a/llvm/include/llvm/Bitcode/LLVMBitCodes.h
+++ b/llvm/include/llvm/Bitcode/LLVMBitCodes.h
@@ -624,6 +624,17 @@ enum FunctionCodes {
// operation, align, vol,
// ordering, synchscope]
FUNC_CODE_BLOCKADDR_USERS = 60, // BLOCKADDR_USERS: [value...]
+
+ FUNC_CODE_DEBUG_RECORD_VALUE =
+ 61, // [DILocation, DILocalVariable, DIExpression, ValueAsMetadata]
+ FUNC_CODE_DEBUG_RECORD_DECLARE =
+ 62, // [DILocation, DILocalVariable, DIExpression, ValueAsMetadata]
+ FUNC_CODE_DEBUG_RECORD_ASSIGN =
+ 63, // [DILocation, DILocalVariable, DIExpression, ValueAsMetadata,
+ // DIAssignID, DIExpression (addr), ValueAsMetadata (addr)]
+ FUNC_CODE_DEBUG_RECORD_VALUE_SIMPLE =
+ 64, // [DILocation, DILocalVariable, DIExpression, Value]
+ FUNC_CODE_DEBUG_RECORD_LABEL = 65, // DPVALUE: [DILocation, DILabel]
};
enum UseListCodes {
diff --git a/llvm/lib/Bitcode/Reader/BitcodeAnalyzer.cpp b/llvm/lib/Bitcode/Reader/BitcodeAnalyzer.cpp
index 7005011980ebc9..81579a8469ddb0 100644
--- a/llvm/lib/Bitcode/Reader/BitcodeAnalyzer.cpp
+++ b/llvm/lib/Bitcode/Reader/BitcodeAnalyzer.cpp
@@ -270,6 +270,10 @@ GetCodeName(unsigned CodeID, unsigned BlockID,
STRINGIFY_CODE(FUNC_CODE, INST_CMPXCHG)
STRINGIFY_CODE(FUNC_CODE, INST_CALLBR)
STRINGIFY_CODE(FUNC_CODE, BLOCKADDR_USERS)
+ STRINGIFY_CODE(FUNC_CODE, DEBUG_RECORD_DECLARE)
+ STRINGIFY_CODE(FUNC_CODE, DEBUG_RECORD_VALUE)
+ STRINGIFY_CODE(FUNC_CODE, DEBUG_RECORD_ASSIGN)
+ STRINGIFY_CODE(FUNC_CODE, DEBUG_RECORD_VALUE_SIMPLE)
}
case bitc::VALUE_SYMTAB_BLOCK_ID:
switch (CodeID) {
diff --git a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp
index 832907a3f53f5f..f223864a4a6605 100644
--- a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -100,9 +100,6 @@ static cl::opt<bool> ExpandConstantExprs(
cl::desc(
"Expand constant expressions to instructions for testing purposes"));
-// Declare external flag for whether we're using the new debug-info format.
-extern llvm::cl::opt<bool> UseNewDbgInfoFormat;
-
namespace {
enum {
@@ -6357,6 +6354,81 @@ Error BitcodeReader::parseFunctionBody(Function *F) {
InstructionList.push_back(I);
break;
}
+ case bitc::FUNC_CODE_DEBUG_RECORD_LABEL: {
+ // DPLabels are placed after the Instructions that they are attached to.
+ Instruction *Inst = getLastInstruction();
+ if (!Inst)
+ return error("Invalid record");
+ DILocation *DIL = cast<DILocation>(getFnMetadataByID(Record[0]));
+ DILabel *Label = cast<DILabel>(getFnMetadataByID(Record[1]));
+ Inst->getParent()->insertDPValueBefore(new DPLabel(Label, DIL),
+ Inst->getIterator());
+ continue; // This isn't an instruction.
+ }
+ case bitc::FUNC_CODE_DEBUG_RECORD_VALUE_SIMPLE:
+ case bitc::FUNC_CODE_DEBUG_RECORD_VALUE:
+ case bitc::FUNC_CODE_DEBUG_RECORD_DECLARE:
+ case bitc::FUNC_CODE_DEBUG_RECORD_ASSIGN: {
+ // DPValues are placed after the Instructions that they are attached to.
+ Instruction *Inst = getLastInstruction();
+ if (!Inst)
+ return error("Invalid record");
+
+ // First 3 fields are common to all kinds:
+ // DILocation, DILocalVariable, DIExpression
+ // dbg_value (FUNC_CODE_DEBUG_RECORD_VALUE)
+ // ..., LocationMetadata
+ // dbg_value (FUNC_CODE_DEBUG_RECORD_VALUE_SIMPLE - abbrev'd)
+ // ..., Value
+ // dbg_declare (FUNC_CODE_DEBUG_RECORD_DECLARE)
+ // ..., LocationMetadata
+ // dbg_assign (FUNC_CODE_DEBUG_RECORD_ASSIGN)
+ // ..., LocationMetadata, DIAssignID, DIExpression, LocationMetadata
+ unsigned Slot = 0;
+ // Common fields (0-2).
+ DILocation *DIL = cast<DILocation>(getFnMetadataByID(Record[Slot++]));
+ DILocalVariable *Var =
+ cast<DILocalVariable>(getFnMetadataByID(Record[Slot++]));
+ DIExpression *Expr =
+ cast<DIExpression>(getFnMetadataByID(Record[Slot++]));
+
+ // Union field (3: LocationMetadata | Value).
+ Metadata *RawLocation = nullptr;
+ if (BitCode == bitc::FUNC_CODE_DEBUG_RECORD_VALUE_SIMPLE) {
+ Value *V = nullptr;
+ unsigned TyID = 0;
+ if (getValueTypePair(Record, Slot, NextValueNo, V, TyID, CurBB))
+ return error("Invalid record");
+ RawLocation = ValueAsMetadata::get(V);
+ } else {
+ RawLocation = getFnMetadataByID(Record[Slot++]);
+ }
+
+ DPValue *DPV = nullptr;
+ switch (BitCode) {
+ case bitc::FUNC_CODE_DEBUG_RECORD_VALUE:
+ case bitc::FUNC_CODE_DEBUG_RECORD_VALUE_SIMPLE:
+ DPV = new DPValue(RawLocation, Var, Expr, DIL,
+ DPValue::LocationType::Value);
+ break;
+ case bitc::FUNC_CODE_DEBUG_RECORD_DECLARE:
+ DPV = new DPValue(RawLocation, Var, Expr, DIL,
+ DPValue::LocationType::Declare);
+ break;
+ case bitc::FUNC_CODE_DEBUG_RECORD_ASSIGN: {
+ DIAssignID *ID = cast<DIAssignID>(getFnMetadataByID(Record[Slot++]));
+ DIExpression *AddrExpr =
+ cast<DIExpression>(getFnMetadataByID(Record[Slot++]));
+ Metadata *Addr = getFnMetadataByID(Record[Slot++]);
+ DPV = new DPValue(RawLocation, Var, Expr, ID, Addr, AddrExpr, DIL);
+ break;
+ }
+ default:
+ llvm_unreachable("Unknown DPValue bitcode");
+ }
+ Inst->getParent()->insertDPValueBefore(DPV, Inst->getIterator());
+ continue; // This isn't an instruction.
+ }
case bitc::FUNC_CODE_INST_CALL: {
// CALL: [paramattrs, cc, fmf, fnty, fnid, arg0, arg1...]
if (Record.size() < 3)
@@ -6636,10 +6708,21 @@ Error BitcodeReader::materialize(GlobalValue *GV) {
// Move the bit stream to the saved position of the deferred function body.
if (Error JumpFailed = Stream.JumpToBit(DFII->second))
return JumpFailed;
+
+ // Set the debug info mode to "new", forcing a mismatch between
+ // module and function debug modes. This is okay because we'll convert
+ // everything back to the old mode after parsing.
+ // FIXME: Remove this once all tools support RemoveDIs.
+ F->IsNewDbgInfoFormat = true;
+
if (Error Err = parseFunctionBody(F))
return Err;
F->setIsMaterializable(false);
+ // Convert new debug info records into intrinsics.
+ // FIXME: Remove this once all tools support RemoveDIs.
+ F->convertFromNewDbgValues();
+
if (StripDebugInfo)
stripDebugInfo(*F);
diff --git a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
index 656f2a6ce870f5..8bd5913c7ea79e 100644
--- a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -99,6 +99,9 @@ namespace llvm {
extern FunctionSummary::ForceSummaryHotnessType ForceSummaryEdgesCold;
}
+extern bool WriteNewDbgInfoFormatToBitcode;
+extern llvm::cl::opt<bool> UseNewDbgInfoFormat;
+
namespace {
/// These are manifest constants used by the bitcode writer. They do not need to
@@ -128,6 +131,7 @@ enum {
FUNCTION_INST_RET_VAL_ABBREV,
FUNCTION_INST_UNREACHABLE_ABBREV,
FUNCTION_INST_GEP_ABBREV,
+ FUNCTION_DEBUG_RECORD_VALUE_ABBREV,
};
/// Abstract class to manage the bitcode writing, subclassed for each bitcode
@@ -3491,25 +3495,93 @@ void ModuleBitcodeWriter::writeFunction(
NeedsMetadataAttachment |= I.hasMetadataOtherThanDebugLoc();
// If the instruction has a debug location, emit it.
- DILocation *DL = I.getDebugLoc();
- if (!DL)
- continue;
-
- if (DL == LastDL) {
- // Just repeat the same debug loc as last time.
- Stream.EmitRecord(bitc::FUNC_CODE_DEBUG_LOC_AGAIN, Vals);
- continue;
+ if (DILocation *DL = I.getDebugLoc()) {
+ if (DL == LastDL) {
+ // Just repeat the same debug loc as last time.
+ Stream.EmitRecord(bitc::FUNC_CODE_DEBUG_LOC_AGAIN, Vals);
+ } else {
+ Vals.push_back(DL->getLine());
+ Vals.push_back(DL->getColumn());
+ Vals.push_back(VE.getMetadataOrNullID(DL->getScope()));
+ Vals.push_back(VE.getMetadataOrNullID(DL->getInlinedAt()));
+ Vals.push_back(DL->isImplicitCode());
+ Stream.EmitRecord(bitc::FUNC_CODE_DEBUG_LOC, Vals);
+ Vals.clear();
+ LastDL = DL;
+ }
}
- Vals.push_back(DL->getLine());
- Vals.push_back(DL->getColumn());
- Vals.push_back(VE.getMetadataOrNullID(DL->getScope()));
- Vals.push_back(VE.getMetadataOrNullID(DL->getInlinedAt()));
- Vals.push_back(DL->isImplicitCode());
- Stream.EmitRecord(bitc::FUNC_CODE_DEBUG_LOC, Vals);
- Vals.clear();
-
- LastDL = DL;
+ // If the instruction has DPValues attached to it, emit them. Note that
+ // they come after the instruction so that it's easy to attach them again
+ // when reading the bitcode, even though conceptually the debug locations
+ // start "before" the instruction.
+ if (I.hasDbgValues() && WriteNewDbgInfoFormatToBitcode) {
+ /// Try to push the value only (unwrapped), otherwise push the
+ /// metadata wrapped value. Returns true if the value was pushed
+ /// without the ValueAsMetadata wrapper.
+ auto PushValueOrMetadata = [&Vals, InstID, this](Metadata *RawLocation) {
+ assert(RawLocation && "RawLocation unexpectedly null in DPValue");
+ if (ValueAsMetadata *VAM = dyn_cast<ValueAsMetadata>(RawLocation)) {
+ SmallVector<unsigned, 2> ValAndType;
+ // If the value is a fwd-ref the type is also pushed. We don't
+ // want the type, so fwd-refs are kept wrapped (pushValueAndType
+ // returns false if the value is pushed without type).
+ if (!pushValueAndType(VAM->getValue(), InstID, ValAndType)) {
+ Vals.push_back(ValAndType[0]);
+ return true;
+ }
+ }
+ // The metadata is a DIArgList, or ValueAsMetadata wrapping a
+ // fwd-ref. Push the metadata ID.
+ Vals.push_back(VE.getMetadataID(RawLocation));
+ return false;
+ };
+
+ // 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->getDbgValueRange()) {
+ if (DPLabel *DPL = dyn_cast<DPLabel>(&DR)) {
+ Vals.push_back(VE.getMetadataID(&*DPL->getDebugLoc()));
+ Vals.push_back(VE.getMetadataID(DPL->getLabel()));
+ Stream.EmitRecord(bitc::FUNC_CODE_DEBUG_RECORD_LABEL, Vals);
+ Vals.clear();
+ continue;
+ }
+
+ // First 3 fields are common to all kinds:
+ // DILocation, DILocalVariable, DIExpression
+ // dbg_value (FUNC_CODE_DEBUG_RECORD_VALUE)
+ // ..., LocationMetadata
+ // dbg_value (FUNC_CODE_DEBUG_RECORD_VALUE_SIMPLE - abbrev'd)
+ // ..., Value
+ // dbg_declare (FUNC_CODE_DEBUG_RECORD_DECLARE)
+ // ..., LocationMetadata
+ // dbg_assign (FUNC_CODE_DEBUG_RECORD_ASSIGN)
+ // ..., LocationMetadata, DIAssignID, DIExpression, LocationMetadata
+ DPValue &DPV = cast<DPValue>(DR);
+ Vals.push_back(VE.getMetadataID(&*DPV.getDebugLoc()));
+ Vals.push_back(VE.getMetadataID(DPV.getVariable()));
+ Vals.push_back(VE.getMetadataID(DPV.getExpression()));
+ if (DPV.isDbgValue()) {
+ if (PushValueOrMetadata(DPV.getRawLocation()))
+ Stream.EmitRecord(bitc::FUNC_CODE_DEBUG_RECORD_VALUE_SIMPLE, Vals, FUNCTION_DEBUG_RECORD_VALUE_ABBREV);
+ else
+ Stream.EmitRecord(bitc::FUNC_CODE_DEBUG_RECORD_VALUE, Vals);
+ } else if (DPV.isDbgDeclare()) {
+ Vals.push_back(VE.getMetadataID(DPV.getRawLocation()));
+ Stream.EmitRecord(bitc::FUNC_CODE_DEBUG_RECORD_DECLARE, Vals);
+ } else {
+ assert(DPV.isDbgAssign() && "Unexpected DbgRecord kind");
+ Vals.push_back(VE.getMetadataID(DPV.getRawLocation()));
+ Vals.push_back(VE.getMetadataID(DPV.getAssignID()));
+ Vals.push_back(VE.getMetadataID(DPV.getAddressExpression()));
+ Vals.push_back(VE.getMetadataID(DPV.getRawAddress()));
+ Stream.EmitRecord(bitc::FUNC_CODE_DEBUG_RECORD_ASSIGN, Vals);
+ }
+ Vals.clear();
+ }
+ }
}
if (BlockAddress *BA = BlockAddress::lookup(&BB)) {
@@ -3750,7 +3822,17 @@ void ModuleBitcodeWriter::writeBlockInfo() {
FUNCTION_INST_GEP_ABBREV)
llvm_unreachable("Unexpected abbrev ordering!");
}
-
+ {
+ auto Abbv = std::make_shared<BitCodeAbbrev>();
+ Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_DEBUG_RECORD_VALUE_SIMPLE));
+ Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 7)); // dbgloc
+ Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 7)); // var
+ Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 7)); // expr
+ Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // val
+ if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=
+ FUNCTION_DEBUG_RECORD_VALUE_ABBREV)
+ llvm_unreachable("Unexpected abbrev ordering! 1");
+ }
Stream.ExitBlock();
}
diff --git a/llvm/lib/Bitcode/Writer/BitcodeWriterPass.cpp b/llvm/lib/Bitcode/Writer/BitcodeWriterPass.cpp
index 93fb2a821dee74..de2396f31f6669 100644
--- a/llvm/lib/Bitcode/Writer/BitcodeWriterPass.cpp
+++ b/llvm/lib/Bitcode/Writer/BitcodeWriterPass.cpp
@@ -18,11 +18,12 @@
#include "llvm/Pass.h"
using namespace llvm;
+extern bool WriteNewDbgInfoFormatToBitcode;
+
PreservedAnalyses BitcodeWriterPass::run(Module &M, ModuleAnalysisManager &AM) {
- // RemoveDIs: there's no bitcode representation of the DPValue debug-info,
- // convert to dbg.values before writing out.
- bool IsNewDbgInfoFormat = M.IsNewDbgInfoFormat;
- if (IsNewDbgInfoFormat)
+ bool ConvertToOldDbgFormatForWrite =
+ M.IsNewDbgInfoFormat && !WriteNewDbgInfoFormatToBitcode;
+ if (ConvertToOldDbgFormatForWrite)
M.convertFromNewDbgValues();
const ModuleSummaryIndex *Index =
@@ -30,7 +31,7 @@ PreservedAnalyses BitcodeWriterPass::run(Module &M, ModuleAnalysisManager &AM) {
: nullptr;
WriteBitcodeToFile(M, OS, ShouldPreserveUseListOrder, Index, EmitModuleHash);
- if (IsNewDbgInfoFormat)
+ if (ConvertToOldDbgFormatForWrite)
M.convertToNewDbgValues();
return PreservedAnalyses::all();
@@ -56,16 +57,15 @@ namespace {
StringRef getPassName() const override { return "Bitcode Writer"; }
bool runOnModule(Module &M) override {
- // RemoveDIs: there's no bitcode representation of the DPValue debug-info,
- // convert to dbg.values before writing out.
- bool IsNewDbgInfoFormat = M.IsNewDbgInfoFormat;
- if (IsNewDbgInfoFormat)
+ bool ConvertToOldDbgFormatForWrite =
+ M.IsNewDbgInfoFormat && !WriteNewDbgInfoFormatToBitcode;
+ if (ConvertToOldDbgFormatForWrite)
M.convertFromNewDbgValues();
WriteBitcodeToFile(M, OS, ShouldPreserveUseListOrder, /*Index=*/nullptr,
/*EmitModuleHash=*/false);
- if (IsNewDbgInfoFormat)
+ if (ConvertToOldDbgFormatForWrite)
M.convertToNewDbgValues();
return false;
}
diff --git a/llvm/lib/Bitcode/Writer/ValueEnumerator.cpp b/llvm/lib/Bitcode/Writer/ValueEnumerator.cpp
index fccb2a606f7ed9..b2edb75eec8c6e 100644
--- a/llvm/lib/Bitcode/Writer/ValueEnumerator.cpp
+++ b/llvm/lib/Bitcode/Writer/ValueEnumerator.cpp
@@ -134,20 +134,28 @@ static OrderMap orderModule(const Module &M) {
// Metadata used by instructions is decoded before the actual instructions,
// so visit any constants used by it beforehand.
for (const BasicBlock &BB : F)
- for (const Instruction &I : BB)
- for (const Value *V : I.operands()) {
- if (const auto *MAV = dyn_cast<MetadataAsValue>(V)) {
- if (const auto *VAM =
- dyn_cast<ValueAsMetadata>(MAV->getMetadata())) {
+ for (const Instruction &I : BB) {
+ auto OrderConstantFromMetadata = [&](Metadata *MD) {
+ if (const auto *VAM = dyn_cast<ValueAsMetadata>(MD)) {
+ orderConstantValue(VAM->getValue());
+ } else if (const auto *AL = dyn_cast<DIArgList>(MD)) {
+ for (const auto *VAM : AL->getArgs())
orderConstantValue(VAM->getValue());
- } else if (const auto *AL =
- dyn_cast<DIArgList>(MAV->getMetadata())) {
- for (const auto *VAM : AL->getArgs())
- orderConstantValue(VAM->getValue());
- }
}
+ };
+
+ for (DPValue &DPV : DPValue::filter(I.getDbgValueRange())) {
+ OrderConstantFromMetadata(DPV.getRawLocation());
+ if (DPV.isDbgAssign())
+ OrderConstantFromMetadata(DPV.getRawAddress());
}
+ for (const Value *V : I.operands()) {
+ if (const auto *MAV = dyn_cast<MetadataAsValue>(V))
+ OrderConstantFromMetadata(MAV->getMetadata());
+ }
+ }
+
for (const Argument &A : F.args())
orderValue(&A, OM);
for (const BasicBlock &BB : F)
@@ -261,33 +269,39 @@ static UseListOrderStack predictUseListOrder(const Module &M) {
// constants in the last Function they're used in. Module-level constants
// have already been visited above.
for (const Function &F : llvm::reverse(M)) {
+ auto PredictValueOrderFromMetadata = [&](Metadata *MD) {
+ if (const auto *VAM = dyn_cast<ValueAsMetadata>(MD)) {
+ predictValueUseListOrder(VAM->getValue(), &F, OM, Stack);
+ } else if (const auto *AL = dyn_cast<DIArgList>(MD)) {
+ for (const auto *VAM : AL->getArgs())
+ predictValueUseListOrder(VAM->getValue(), &F, OM, Stack);
+ }
+ };
if (F.isDeclaration())
continue;
for (const BasicBlock &BB : F)
predictValueUseListOrder(&BB, &F, OM, Stack);
for (const Argument &A : F.args())
predictValueUseListOrder(&A, &F, OM, Stack);
- for (const BasicBlock &BB : F)
+ for (const BasicBlock &BB : F) {
for (const Instruction &I : BB) {
+ for (DPValue &DPV : DPValue::filter(I.getDbgValueRange())) {
+ PredictValueOrderFromMetadata(DPV.getRawLocation());
+ if (DPV.isDbgAssign())
+ PredictValueOrderFromMetadata(DPV.getRawAddress());
+ }
for (const Value *Op : I.operands()) {
if (isa<Constant>(*Op) || isa<InlineAsm>(*Op)) // Visit GlobalValues.
predictValueUseListOrder(Op, &F, OM, Stack);
- if (const auto *MAV = dyn_cast<MetadataAsValue>(Op)) {
- if (const auto *VAM =
- dyn_cast<ValueAsMetadata>(MAV->getMetadata())) {
- predictValueUseListOrder(VAM->getValue(), &F, OM, Stack);
- } else if (const auto *AL =
- dyn_cast<DIArgList>(MAV->getMetadata())) {
- for (const auto *VAM : AL->getArgs())
- predictValueUseListOrder(VAM->getValue(), &F, OM, Stack);
- }
- }
+ if (const auto *MAV = dyn_cast<MetadataAsValue>(Op))
+ PredictValueOrderFromMetadata(MAV->getMetadata());
}
if (auto *SVI = dyn_cast<ShuffleVectorInst>(&I))
predictValueUseListOrder(SVI->getShuffleMaskForBitcode(), &F, OM,
Stack);
predictValueUseListOrder(&I, &F, OM, Stack);
}
+ }
}
// Visit globals last, since the module-level use-list block will be seen
@@ -409,6 +423,41 @@ ValueEnumerator::ValueEnumerator(const Module &M,
for (const BasicBlock &BB : F)
for (const Instruction &I : BB) {
+ // Local metadata is enumerated during function-incorporation, but
+ // any ConstantAsMetadata arguments in a DIArgList should be examined
+ // now.
+ auto EnumerateNonLocalValuesFromMetadata = [&](Metadata *MD) {
+ assert(MD && "Metadata unexpectedly null");
+ if (const auto *AL = dyn_cast<DIArgList>(MD)) {
+ for (const auto *VAM : AL->getArgs()) {
+ if (isa<ConstantAsMetadata>(VAM))
+ EnumerateMetadata(&F, VAM);
+ }
+ return;
+ }
+
+ if (!isa<LocalAsMetadata>(MD))
+ EnumerateMetadata(&F, MD);
+ };
+
+ for (DbgRecord &DR : I.getDbgValueRange()) {
+ if (DPLabel *DPL = dyn_cast<DPLabel>(&DR)) {
+ EnumerateMetadata(&F, DPL->getLabel());
+ EnumerateMetadata(&F, &*DPL->getDebugLoc());
+ continue;
+ }
+ // Enumerate non-local location metadata.
+ DPValue &DPV = cast<DPValue>(DR);
+ EnumerateNonLocalValuesFromMetadata(DPV.getRawLocation());
+ EnumerateMetadata(&F, DPV.getExpression());
+ EnumerateMetadata(&F, DPV.getVariable());
+ EnumerateMetadata(&F, &*DPV.getDebugLoc());
+ if (DPV.isDbgAssign()) {
+ EnumerateNonLocalValuesFromMetadata(DPV.getRawAddress());
+ EnumerateMetadata(&F, DPV.getAssignID());
+ EnumerateMetadata(&F, DPV.getAddressExpression());
+ }
+ }
for (const Use &Op : I.operands()) {
auto *MD = dyn_cast<MetadataAsValue>(&Op);
if (!MD) {
@@ -416,19 +465,7 @@ ValueEnumerator::ValueEnumerator(const Module &M,
continue;
}
- // Local metadata is enumerated during function-incorporation, but
- // any ConstantAsMetadata arguments in a DIArgList should be examined
- // now.
- if (isa<LocalAsMetadata>(MD->getMetadata()))
- continue;
- if (auto *AL = dyn_cast<DIArgList>(MD->getMetadata())) {
- for (auto *VAM : AL->getArgs())
- if (isa<ConstantAsMetadata>(VAM))
- EnumerateMetadata(&F, VAM);
- continue;
- }
-
- EnumerateMetadata(&F, MD->getMetadata());
+ EnumerateNonLocalValuesFromMetadata(MD->getMetadata());
}
if (auto *SVI = dyn_cast<ShuffleVectorInst>(&I))
EnumerateType(SVI->getShuffleMaskForBitcode()->getType());
@@ -1064,27 +1101,41 @@ void ValueEnumerator::incorporateFunction(const Function &F) {
SmallVector<LocalAsMetadata *, 8> FnLocalMDVector;
SmallVector<DIArgList *, 8> ArgListMDVector;
+
+ auto AddFnLocalMetadata = [&](Metadata *MD) {
+ if (!MD)
+ return;
+ if (auto *Local = dyn_cast<LocalAsMetadata>(MD)) {
+ // Enumerate metadata after the instructions they might refer to.
+ FnLocalMDVector.push_back(Local);
+ } else if (auto *ArgList = dyn_cast<DIArgList>(MD)) {
+ ArgListMDVector.push_back(ArgList);
+ for (ValueAsMetadata *VMD : ArgList->getArgs()) {
+ if (auto *Local = dyn_cast<LocalAsMetadata>(VMD)) {
+ // Enumerate metadata after the instructions they might refer
+ // to.
+ FnLocalMDVector.push_back(Local);
+ }
+ }
+ }
+ };
+
// Add all of the instructions.
for (const BasicBlock &BB : F) {
for (const Instruction &I : BB) {
for (const Use &OI : I.operands()) {
- if (auto *MD = dyn_cast<MetadataAsValue>(&OI)) {
- if (auto *Local = dyn_cast<LocalAsMetadata>(MD->getMetadata())) {
- // Enumerate metadata after the instructions they might refer to.
- FnLocalMDVector.push_back(Local);
- } else if (auto *ArgList = dyn_cast<DIArgList>(MD->getMetadata())) {
- ArgListMDVector.push_back(ArgList);
- for (ValueAsMetadata *VMD : ArgList->getArgs()) {
- if (auto *Local = dyn_cast<LocalAsMetadata>(VMD)) {
- // Enumerate metadata after the instructions they might refer
- // to.
- FnLocalMDVector.push_back(Local);
- }
- }
- }
+ if (auto *MD = dyn_cast<MetadataAsValue>(&OI))
+ AddFnLocalMetadata(MD->getMetadata());
+ }
+ /// RemoteDIs: Add non-instruction function-local metadata uses.
+ for (DPValue &DPV : DPValue::filter(I.getDbgValueRange())) {
+ assert(DPV.getRawLocation() && "DPValue location unexpectedly null");
+ AddFnLocalMetadata(DPV.getRawLocation());
+ if (DPV.isDbgAssign()) {
+ assert(DPV.getRawAddress() && "DPValue location unexpectedly null");
+ AddFnLocalMetadata(DPV.getRawAddress());
}
}
-
if (!I.getType()->isVoidTy())
EnumerateValue(&I);
}
diff --git a/llvm/lib/IR/BasicBlock.cpp b/llvm/lib/IR/BasicBlock.cpp
index 6ea876fde5ec66..28145b407aa7f7 100644
--- a/llvm/lib/IR/BasicBlock.cpp
+++ b/llvm/lib/IR/BasicBlock.cpp
@@ -36,6 +36,11 @@ cl::opt<bool>
"through iterators, eliminating intrinsics"),
cl::init(true));
+bool WriteNewDbgInfoFormatToBitcode /*set default value in cl::init() below*/;
+cl::opt<bool, true> WriteNewDbgInfoFormatToBitcode2(
+ "write-experimental-debuginfo-iterators-to-bitcode", cl::Hidden,
+ cl::location(WriteNewDbgInfoFormatToBitcode), cl::init(true));
+
DPMarker *BasicBlock::createMarker(Instruction *I) {
assert(IsNewDbgInfoFormat &&
"Tried to create a marker in a non new debug-info block!");
diff --git a/llvm/lib/IR/Verifier.cpp b/llvm/lib/IR/Verifier.cpp
index 4f321bc516cc39..bfe3cd0664f993 100644
--- a/llvm/lib/IR/Verifier.cpp
+++ b/llvm/lib/IR/Verifier.cpp
@@ -2975,6 +2975,17 @@ void Verifier::visitBasicBlock(BasicBlock &BB) {
Check(I.getParent() == &BB, "Instruction has bogus parent pointer!");
}
+ Check(BB.IsNewDbgInfoFormat == BB.getParent()->IsNewDbgInfoFormat,
+ "BB debug format (new=" + std::to_string(BB.IsNewDbgInfoFormat) +
+ ") should match parent " + BB.getName() + " in " +
+ BB.getParent()->getName());
+ Check(BB.getParent()->IsNewDbgInfoFormat ==
+ BB.getParent()->getParent()->IsNewDbgInfoFormat,
+ "Fn debug format (new=" +
+ std::to_string(BB.getParent()->IsNewDbgInfoFormat) +
+ ") should match parent " + BB.getParent()->getName() + " in " +
+ BB.getParent()->getParent()->getName());
+
// Confirm that no issues arise from the debug program.
if (BB.IsNewDbgInfoFormat) {
// Configure the validate function to not fire assertions, instead print
diff --git a/llvm/lib/Linker/IRMover.cpp b/llvm/lib/Linker/IRMover.cpp
index 37d21119447b9c..70ea8d977f2602 100644
--- a/llvm/lib/Linker/IRMover.cpp
+++ b/llvm/lib/Linker/IRMover.cpp
@@ -615,6 +615,8 @@ Value *IRLinker::materialize(Value *V, bool ForIndirectSymbol) {
// If we already created the body, just return.
if (auto *F = dyn_cast<Function>(New)) {
+ if (auto *OldFunc = dyn_cast<Function>(SGV))
+ F->IsNewDbgInfoFormat = OldFunc->IsNewDbgInfoFormat;
if (!F->isDeclaration())
return New;
} else if (auto *V = dyn_cast<GlobalVariable>(New)) {
@@ -1135,7 +1137,7 @@ Error IRLinker::linkFunctionBody(Function &Dst, Function &Src) {
Dst.setPrologueData(Src.getPrologueData());
if (Src.hasPersonalityFn())
Dst.setPersonalityFn(Src.getPersonalityFn());
- assert(Src.IsNewDbgInfoFormat == Dst.IsNewDbgInfoFormat);
+ Src.setIsNewDbgInfoFormat(Dst.IsNewDbgInfoFormat);
// Copy over the metadata attachments without remapping.
Dst.copyMetadata(&Src, 0);
@@ -1775,7 +1777,7 @@ IRMover::IRMover(Module &M) : Composite(M) {
Error IRMover::move(std::unique_ptr<Module> Src,
ArrayRef<GlobalValue *> ValuesToLink,
LazyCallback AddLazyFor, bool IsPerformingImport) {
- if (getModule().IsNewDbgInfoFormat)
+ if (getModule().IsNewDbgInfoFormat && !Src->IsNewDbgInfoFormat)
Src->convertToNewDbgValues();
IRLinker TheIRLinker(Composite, SharedMDs, IdentifiedStructTypes,
std::move(Src), ValuesToLink, std::move(AddLazyFor),
diff --git a/llvm/lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp b/llvm/lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp
index dd6062d303d42e..6b9a1f6777fc30 100644
--- a/llvm/lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp
+++ b/llvm/lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp
@@ -575,7 +575,7 @@ bool writeThinLTOBitcode(raw_ostream &OS, raw_ostream *ThinLinkOS,
}
} // anonymous namespace
-
+extern bool WriteNewDbgInfoFormatToBitcode;
PreservedAnalyses
llvm::ThinLTOBitcodeWriterPass::run(Module &M, ModuleAnalysisManager &AM) {
FunctionAnalysisManager &FAM =
@@ -583,8 +583,9 @@ llvm::ThinLTOBitcodeWriterPass::run(Module &M, ModuleAnalysisManager &AM) {
// RemoveDIs: there's no bitcode representation of the DPValue debug-info,
// convert to dbg.values before writing out.
- bool IsNewDbgInfoFormat = M.IsNewDbgInfoFormat;
- if (IsNewDbgInfoFormat)
+ bool ConvertToOldDbgFormatForWrite =
+ M.IsNewDbgInfoFormat && !WriteNewDbgInfoFormatToBitcode;
+ if (ConvertToOldDbgFormatForWrite)
M.convertFromNewDbgValues();
bool Changed = writeThinLTOBitcode(
@@ -594,7 +595,7 @@ llvm::ThinLTOBitcodeWriterPass::run(Module &M, ModuleAnalysisManager &AM) {
},
M, &AM.getResult<ModuleSummaryIndexAnalysis>(M));
- if (IsNewDbgInfoFormat)
+ if (ConvertToOldDbgFormatForWrite)
M.convertToNewDbgValues();
return Changed ? PreservedAnalyses::none() : PreservedAnalyses::all();
diff --git a/llvm/test/Bitcode/dbg-record-roundtrip.ll b/llvm/test/Bitcode/dbg-record-roundtrip.ll
new file mode 100644
index 00000000000000..997f0268acd96b
--- /dev/null
+++ b/llvm/test/Bitcode/dbg-record-roundtrip.ll
@@ -0,0 +1,127 @@
+;; Roundtrip tests.
+; RUN: llvm-as %s -o - | llvm-dis | FileCheck %s
+;; Check that verify-uselistorder passes regardless of input format.
+; RUN: llvm-as %s -o - | verify-uselistorder
+; RUN: verify-uselistorder %s
+
+;; Confirm we're producing RemoveDI records from various tools.
+; RUN: opt %s -o - | llvm-bcanalyzer - | FileCheck %s --check-prefix=BITCODE
+; RUN: llvm-as %s -o - | llvm-bcanalyzer - | FileCheck %s --check-prefix=BITCODE
+; BITCODE-DAG: DEBUG_RECORD_VALUE
+; BITCODE-DAG: DEBUG_RECORD_ASSIGN
+; BITCODE-DAG: DEBUG_RECORD_DECLARE
+
+;; Check that llvm-link doesn't explode if we give it different formats to
+;; link.
+; RUN: llvm-link %s --experimental-debuginfo-iterators=false < llvm-as %s --experimental-debuginfo-iterators=true
+; RUN: llvm-link %s --experimental-debuginfo-iterators=true < llvm-as %s --experimental-debuginfo-iterators=false
+
+;; Checks inline.
+
+ at g = internal dso_local global i32 0, align 4, !dbg !0
+
+define internal dso_local noundef i32 @_Z3funv(i32 %p, ptr %storage) !dbg !13 {
+entry:
+;; Dbg record at top of block, check dbg.value configurations.
+; CHECK: entry:
+; CHECK-NEXT: dbg.value(metadata i32 %p, metadata ![[e:[0-9]+]], metadata !DIExpression()), !dbg ![[dbg:[0-9]+]]
+; CHECK-NEXT: dbg.value(metadata ![[empty:[0-9]+]], metadata ![[e]], metadata !DIExpression()), !dbg ![[dbg]]
+; CHECK-NEXT: dbg.value(metadata i32 poison, metadata ![[e]], metadata !DIExpression()), !dbg ![[dbg]]
+; CHECK-NEXT: dbg.value(metadata i32 1, metadata ![[f:[0-9]+]], metadata !DIExpression()), !dbg ![[dbg]]
+ tail call void @llvm.dbg.value(metadata i32 %p, metadata !32, metadata !DIExpression()), !dbg !19
+ tail call void @llvm.dbg.value(metadata !29, metadata !32, metadata !DIExpression()), !dbg !19
+ tail call void @llvm.dbg.value(metadata i32 poison, metadata !32, metadata !DIExpression()), !dbg !19
+ tail call void @llvm.dbg.value(metadata i32 1, metadata !33, metadata !DIExpression()), !dbg !19
+;; Arglist with an argument, constant, local use before def, poison.
+; CHECK-NEXT: dbg.value(metadata !DIArgList(i32 %p, i32 0, i32 %0, i32 poison), metadata ![[f]], metadata !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_arg, 1, DW_OP_plus, DW_OP_LLVM_arg, 2, DW_OP_LLVM_arg, 3, DW_OP_plus, DW_OP_minus)), !dbg ![[dbg]]
+ tail call void @llvm.dbg.value(metadata !DIArgList(i32 %p, i32 0, i32 %0, i32 poison), metadata !33, metadata !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_arg, 1, DW_OP_plus, DW_OP_LLVM_arg, 2, DW_OP_LLVM_arg, 3, DW_OP_plus, DW_OP_minus)), !dbg !19
+;; Check dbg.assign use before def (value, addr and ID). Check expression order too.
+; CHECK: dbg.assign(metadata i32 %0, metadata ![[i:[0-9]+]], metadata !DIExpression(DW_OP_plus_uconst, 0),
+; CHECK-SAME: metadata ![[ID:[0-9]+]], metadata ptr %a, metadata !DIExpression(DW_OP_plus_uconst, 1)), !dbg ![[dbg]]
+ tail call void @llvm.dbg.assign(metadata i32 %0, metadata !36, metadata !DIExpression(DW_OP_plus_uconst, 0), metadata !37, metadata ptr %a, metadata !DIExpression(DW_OP_plus_uconst, 1)), !dbg !19
+ %a = alloca i32, align 4, !DIAssignID !37
+; CHECK: %a = alloca i32, align 4, !DIAssignID ![[ID]]
+;; Check dbg.declare configurations.
+; CHECK-NEXT: dbg.declare(metadata ptr %a, metadata ![[a:[0-9]+]], metadata !DIExpression()), !dbg ![[dbg]]
+; CHECK-NEXT: dbg.declare(metadata ![[empty:[0-9]+]], metadata ![[b:[0-9]+]], metadata !DIExpression()), !dbg ![[dbg]]
+; CHECK-NEXT: dbg.declare(metadata ptr poison, metadata ![[c:[0-9]+]], metadata !DIExpression()), !dbg ![[dbg]]
+; CHECK-NEXT: dbg.declare(metadata ptr null, metadata ![[d:[0-9]+]], metadata !DIExpression()), !dbg ![[dbg]]
+; CHECK-NEXT: dbg.declare(metadata ptr @g, metadata ![[h:[0-9]+]], metadata !DIExpression()), !dbg ![[dbg]]
+ tail call void @llvm.dbg.declare(metadata ptr %a, metadata !17, metadata !DIExpression()), !dbg !19
+ tail call void @llvm.dbg.declare(metadata !29, metadata !28, metadata !DIExpression()), !dbg !19
+ tail call void @llvm.dbg.declare(metadata ptr poison, metadata !30, metadata !DIExpression()), !dbg !19
+ tail call void @llvm.dbg.declare(metadata ptr null, metadata !31, metadata !DIExpression()), !dbg !19
+ tail call void @llvm.dbg.declare(metadata ptr @g, metadata !35, metadata !DIExpression()), !dbg !19
+;; Argument value dbg.declare.
+; CHECK: dbg.declare(metadata ptr %storage, metadata ![[g:[0-9]+]], metadata !DIExpression()), !dbg ![[dbg]]
+ tail call void @llvm.dbg.declare(metadata ptr %storage, metadata !34, metadata !DIExpression()), !dbg !19
+;; Use before def dbg.value.
+; CHECK: dbg.value(metadata i32 %0, metadata ![[e]], metadata !DIExpression()), !dbg ![[dbg]]
+ tail call void @llvm.dbg.value(metadata i32 %0, metadata !32, metadata !DIExpression()), !dbg !19
+ %0 = load i32, ptr @g, align 4, !dbg !20
+;; Non-argument local value dbg.value.
+; CHECK: dbg.value(metadata i32 %0, metadata ![[e]], metadata !DIExpression()), !dbg ![[dbg]]
+ tail call void @llvm.dbg.value(metadata i32 %0, metadata !32, metadata !DIExpression()), !dbg !19
+ store i32 %0, ptr %a, align 4, !dbg !19
+ %1 = load i32, ptr %a, align 4, !dbg !25
+; CHECK: dbg.label(metadata ![[label:[0-9]+]]), !dbg ![[dbg]]
+ tail call void @llvm.dbg.label(metadata !38), !dbg !19
+ ret i32 %1, !dbg !27
+}
+
+; CHECK-DAG: ![[a]] = !DILocalVariable(name: "a",
+; CHECK-DAG: ![[b]] = !DILocalVariable(name: "b",
+; CHECK-DAG: ![[c]] = !DILocalVariable(name: "c",
+; CHECK-DAG: ![[d]] = !DILocalVariable(name: "d",
+; CHECK-DAG: ![[e]] = !DILocalVariable(name: "e",
+; CHECK-DAG: ![[f]] = !DILocalVariable(name: "f",
+; CHECK-DAG: ![[g]] = !DILocalVariable(name: "g",
+; CHECK-DAG: ![[h]] = !DILocalVariable(name: "h",
+; CHECK-DAG: ![[i]] = !DILocalVariable(name: "i",
+; CHECK-DAG: ![[empty]] = !{}
+; CHECK-DAG: ![[label]] = !DILabel
+
+declare void @llvm.dbg.declare(metadata, metadata, metadata)
+declare void @llvm.dbg.value(metadata, metadata, metadata)
+declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
+declare void @llvm.dbg.label(metadata)
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!6, !7, !8, !9, !10, !11}
+!llvm.ident = !{!12}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "g", scope: !2, file: !3, line: 1, type: !5, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !3, producer: "clang version 19.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, globals: !4, splitDebugInlining: false, nameTableKind: None)
+!3 = !DIFile(filename: "test.cpp", directory: "/")
+!4 = !{!0}
+!5 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!6 = !{i32 7, !"Dwarf Version", i32 5}
+!7 = !{i32 2, !"Debug Info Version", i32 3}
+!8 = !{i32 1, !"wchar_size", i32 4}
+!9 = !{i32 8, !"PIC Level", i32 2}
+!10 = !{i32 7, !"PIE Level", i32 2}
+!11 = !{i32 7, !"uwtable", i32 2}
+!12 = !{!"clang version 19.0.0"}
+!13 = distinct !DISubprogram(name: "fun", linkageName: "_Z3funv", scope: !3, file: !3, line: 2, type: !14, scopeLine: 2, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !16)
+!14 = !DISubroutineType(types: !15)
+!15 = !{!5}
+!16 = !{!17}
+!17 = !DILocalVariable(name: "a", scope: !13, file: !3, line: 3, type: !5)
+!18 = !DILocation(line: 3, column: 3, scope: !13)
+!19 = !DILocation(line: 3, column: 7, scope: !13)
+!20 = !DILocation(line: 3, column: 11, scope: !13)
+!25 = !DILocation(line: 4, column: 12, scope: !13)
+!26 = !DILocation(line: 5, column: 1, scope: !13)
+!27 = !DILocation(line: 4, column: 5, scope: !13)
+!28 = !DILocalVariable(name: "b", scope: !13, file: !3, line: 3, type: !5)
+!29 = !{}
+!30 = !DILocalVariable(name: "c", scope: !13, file: !3, line: 3, type: !5)
+!31 = !DILocalVariable(name: "d", scope: !13, file: !3, line: 3, type: !5)
+!32 = !DILocalVariable(name: "e", scope: !13, file: !3, line: 3, type: !5)
+!33 = !DILocalVariable(name: "f", scope: !13, file: !3, line: 3, type: !5)
+!34 = !DILocalVariable(name: "g", scope: !13, file: !3, line: 3, type: !5)
+!35 = !DILocalVariable(name: "h", scope: !13, file: !3, line: 3, type: !5)
+!36 = !DILocalVariable(name: "i", scope: !13, file: !3, line: 3, type: !5)
+!37 = distinct !DIAssignID()
+!38 = !DILabel(scope: !13, name: "label", file: !3, line: 1)
diff --git a/llvm/tools/llvm-as/llvm-as.cpp b/llvm/tools/llvm-as/llvm-as.cpp
index 1c869e1739319e..fd852563838f37 100644
--- a/llvm/tools/llvm-as/llvm-as.cpp
+++ b/llvm/tools/llvm-as/llvm-as.cpp
@@ -67,6 +67,7 @@ static cl::opt<std::string> ClDataLayout("data-layout",
cl::desc("data layout string to use"),
cl::value_desc("layout-string"),
cl::init(""), cl::cat(AsCat));
+extern bool WriteNewDbgInfoFormatToBitcode;
static void WriteOutputFile(const Module *M, const ModuleSummaryIndex *Index) {
// Infer the output filename if needed.
@@ -139,6 +140,12 @@ int main(int argc, char **argv) {
Err.print(argv[0], errs());
return 1;
}
+
+ // Convert to new debug format if requested.
+ assert(!M->IsNewDbgInfoFormat && "Unexpectedly in new debug mode");
+ if (UseNewDbgInfoFormat && WriteNewDbgInfoFormatToBitcode)
+ M->convertToNewDbgValues();
+
std::unique_ptr<ModuleSummaryIndex> Index = std::move(ModuleAndIndex.Index);
if (!DisableVerify) {
diff --git a/llvm/tools/verify-uselistorder/verify-uselistorder.cpp b/llvm/tools/verify-uselistorder/verify-uselistorder.cpp
index 9afe6817fefb9f..d929ae09958a1f 100644
--- a/llvm/tools/verify-uselistorder/verify-uselistorder.cpp
+++ b/llvm/tools/verify-uselistorder/verify-uselistorder.cpp
@@ -166,6 +166,11 @@ std::unique_ptr<Module> TempFile::readBitcode(LLVMContext &Context) const {
"verify-uselistorder: error: ");
return nullptr;
}
+
+ // verify-uselistoder currently only supports old-style debug info mode.
+ // FIXME: Update mapping code for RemoveDIs.
+ assert(!ModuleOr.get()->IsNewDbgInfoFormat &&
+ "Unexpectedly in new debug info mode");
return std::move(ModuleOr.get());
}
@@ -175,6 +180,9 @@ std::unique_ptr<Module> TempFile::readAssembly(LLVMContext &Context) const {
std::unique_ptr<Module> M = parseAssemblyFile(Filename, Err, Context);
if (!M.get())
Err.print("verify-uselistorder", errs());
+ // verify-uselistoder currently only supports old-style debug info mode.
+ // FIXME: Update mapping code for RemoveDIs.
+ assert(!M->IsNewDbgInfoFormat && "Unexpectedly in new debug info mode");
return M;
}
@@ -541,6 +549,9 @@ int main(int argc, char **argv) {
// Load the input module...
std::unique_ptr<Module> M = parseIRFile(InputFilename, Err, Context);
+ // verify-uselistoder currently only supports old-style debug info mode.
+ // FIXME: Update mapping code for RemoveDIs.
+ assert(!M->IsNewDbgInfoFormat && "Unexpectedly in new debug info mode");
if (!M.get()) {
Err.print(argv[0], errs());
>From 9dee1a8edc8d5e68bc7a950930678343e632965e Mon Sep 17 00:00:00 2001
From: Orlando Cazalet-Hyams <orlando.hyams at sony.com>
Date: Wed, 28 Feb 2024 11:35:12 +0000
Subject: [PATCH 2/9] tidy up conversion in IRMove/Linker
---
llvm/lib/Linker/IRMover.cpp | 23 +++++++++++++++++++----
1 file changed, 19 insertions(+), 4 deletions(-)
diff --git a/llvm/lib/Linker/IRMover.cpp b/llvm/lib/Linker/IRMover.cpp
index 70ea8d977f2602..0017066bf44154 100644
--- a/llvm/lib/Linker/IRMover.cpp
+++ b/llvm/lib/Linker/IRMover.cpp
@@ -8,6 +8,7 @@
#include "llvm/Linker/IRMover.h"
#include "LinkDiagnosticInfo.h"
+#include "llvm/ADT/ScopeExit.h"
#include "llvm/ADT/SetVector.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/SmallString.h"
@@ -1137,7 +1138,7 @@ Error IRLinker::linkFunctionBody(Function &Dst, Function &Src) {
Dst.setPrologueData(Src.getPrologueData());
if (Src.hasPersonalityFn())
Dst.setPersonalityFn(Src.getPersonalityFn());
- Src.setIsNewDbgInfoFormat(Dst.IsNewDbgInfoFormat);
+ assert(Src.IsNewDbgInfoFormat == Dst.IsNewDbgInfoFormat);
// Copy over the metadata attachments without remapping.
Dst.copyMetadata(&Src, 0);
@@ -1548,7 +1549,23 @@ Error IRLinker::run() {
if (Error Err = SrcM->getMaterializer()->materializeMetadata())
return Err;
- DstM.IsNewDbgInfoFormat = SrcM->IsNewDbgInfoFormat;
+ // Convert source module to match dest for the duration of the link.
+ bool SrcModuleNewDbgFormat = SrcM->IsNewDbgInfoFormat;
+ if (DstM.IsNewDbgInfoFormat != SrcM->IsNewDbgInfoFormat) {
+ if (DstM.IsNewDbgInfoFormat)
+ SrcM->convertToNewDbgValues();
+ else
+ SrcM->convertFromNewDbgValues();
+ }
+ // Undo debug mode conversion afterwards.
+ auto Cleanup = make_scope_exit([&]() {
+ if (SrcModuleNewDbgFormat != SrcM->IsNewDbgInfoFormat) {
+ if (SrcModuleNewDbgFormat)
+ SrcM->convertToNewDbgValues();
+ else
+ SrcM->convertFromNewDbgValues();
+ }
+ });
// Inherit the target data from the source module if the destination module
// doesn't have one already.
@@ -1777,8 +1794,6 @@ IRMover::IRMover(Module &M) : Composite(M) {
Error IRMover::move(std::unique_ptr<Module> Src,
ArrayRef<GlobalValue *> ValuesToLink,
LazyCallback AddLazyFor, bool IsPerformingImport) {
- if (getModule().IsNewDbgInfoFormat && !Src->IsNewDbgInfoFormat)
- Src->convertToNewDbgValues();
IRLinker TheIRLinker(Composite, SharedMDs, IdentifiedStructTypes,
std::move(Src), ValuesToLink, std::move(AddLazyFor),
IsPerformingImport);
>From 2aa349db8dd1baf5572ef03c3d2bacaebd0a312d Mon Sep 17 00:00:00 2001
From: Orlando Cazalet-Hyams <orlando.hyams at sony.com>
Date: Wed, 28 Feb 2024 11:45:50 +0000
Subject: [PATCH 3/9] Add DEBUG_RECORD_LABEL string to llvm-bcanalyzer and
update test to check for label records
---
llvm/lib/Bitcode/Reader/BitcodeAnalyzer.cpp | 1 +
llvm/test/Bitcode/dbg-record-roundtrip.ll | 1 +
2 files changed, 2 insertions(+)
diff --git a/llvm/lib/Bitcode/Reader/BitcodeAnalyzer.cpp b/llvm/lib/Bitcode/Reader/BitcodeAnalyzer.cpp
index 81579a8469ddb0..c085c715179ba6 100644
--- a/llvm/lib/Bitcode/Reader/BitcodeAnalyzer.cpp
+++ b/llvm/lib/Bitcode/Reader/BitcodeAnalyzer.cpp
@@ -274,6 +274,7 @@ GetCodeName(unsigned CodeID, unsigned BlockID,
STRINGIFY_CODE(FUNC_CODE, DEBUG_RECORD_VALUE)
STRINGIFY_CODE(FUNC_CODE, DEBUG_RECORD_ASSIGN)
STRINGIFY_CODE(FUNC_CODE, DEBUG_RECORD_VALUE_SIMPLE)
+ STRINGIFY_CODE(FUNC_CODE, DEBUG_RECORD_LABEL)
}
case bitc::VALUE_SYMTAB_BLOCK_ID:
switch (CodeID) {
diff --git a/llvm/test/Bitcode/dbg-record-roundtrip.ll b/llvm/test/Bitcode/dbg-record-roundtrip.ll
index 997f0268acd96b..6bdbb0d738d3a0 100644
--- a/llvm/test/Bitcode/dbg-record-roundtrip.ll
+++ b/llvm/test/Bitcode/dbg-record-roundtrip.ll
@@ -7,6 +7,7 @@
;; Confirm we're producing RemoveDI records from various tools.
; RUN: opt %s -o - | llvm-bcanalyzer - | FileCheck %s --check-prefix=BITCODE
; RUN: llvm-as %s -o - | llvm-bcanalyzer - | FileCheck %s --check-prefix=BITCODE
+; BITCODE-DAG: DEBUG_RECORD_LABEL
; BITCODE-DAG: DEBUG_RECORD_VALUE
; BITCODE-DAG: DEBUG_RECORD_ASSIGN
; BITCODE-DAG: DEBUG_RECORD_DECLARE
>From ed52904ea1e8b1d5601a7fd0fb8fab4f81d91635 Mon Sep 17 00:00:00 2001
From: Orlando Cazalet-Hyams <orlando.hyams at sony.com>
Date: Wed, 6 Mar 2024 11:08:48 +0000
Subject: [PATCH 4/9] improve error messages, add comment, add assert, use pipe
in test, fix typo in comment
---
llvm/lib/Bitcode/Reader/BitcodeReader.cpp | 14 +++++++++++---
llvm/lib/Bitcode/Writer/ValueEnumerator.cpp | 2 +-
llvm/test/Bitcode/dbg-record-roundtrip.ll | 4 ++--
3 files changed, 14 insertions(+), 6 deletions(-)
diff --git a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp
index f223864a4a6605..04731aeb0df5c9 100644
--- a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -6358,7 +6358,7 @@ Error BitcodeReader::parseFunctionBody(Function *F) {
// DPLabels are placed after the Instructions that they are attached to.
Instruction *Inst = getLastInstruction();
if (!Inst)
- return error("Invalid record");
+ return error("Invalid dbg record: missing instruction");
DILocation *DIL = cast<DILocation>(getFnMetadataByID(Record[0]));
DILabel *Label = cast<DILabel>(getFnMetadataByID(Record[1]));
Inst->getParent()->insertDPValueBefore(new DPLabel(Label, DIL),
@@ -6372,7 +6372,7 @@ Error BitcodeReader::parseFunctionBody(Function *F) {
// DPValues are placed after the Instructions that they are attached to.
Instruction *Inst = getLastInstruction();
if (!Inst)
- return error("Invalid record");
+ return error("Invalid dbg record: missing instruction");
// First 3 fields are common to all kinds:
// DILocation, DILocalVariable, DIExpression
@@ -6397,8 +6397,16 @@ Error BitcodeReader::parseFunctionBody(Function *F) {
if (BitCode == bitc::FUNC_CODE_DEBUG_RECORD_VALUE_SIMPLE) {
Value *V = nullptr;
unsigned TyID = 0;
+ // We never expect to see a fwd reference value here because
+ // use-before-defs are encoded with the standard non-abbrev record
+ // type (they'd require encoding the type too, and they're rare). As a
+ // result, getValueTypePair only ever increments Slot by one here (once
+ // for the value, never twice for value and type).
+ unsigned SlotBefore = Slot;
if (getValueTypePair(Record, Slot, NextValueNo, V, TyID, CurBB))
- return error("Invalid record");
+ return error("Invalid dbg record: invalid value");
+ (void)SlotBefore;
+ assert((SlotBefore == Slot - 1) && "unexpected fwd ref");
RawLocation = ValueAsMetadata::get(V);
} else {
RawLocation = getFnMetadataByID(Record[Slot++]);
diff --git a/llvm/lib/Bitcode/Writer/ValueEnumerator.cpp b/llvm/lib/Bitcode/Writer/ValueEnumerator.cpp
index b2edb75eec8c6e..646119bb92863d 100644
--- a/llvm/lib/Bitcode/Writer/ValueEnumerator.cpp
+++ b/llvm/lib/Bitcode/Writer/ValueEnumerator.cpp
@@ -1127,7 +1127,7 @@ void ValueEnumerator::incorporateFunction(const Function &F) {
if (auto *MD = dyn_cast<MetadataAsValue>(&OI))
AddFnLocalMetadata(MD->getMetadata());
}
- /// RemoteDIs: Add non-instruction function-local metadata uses.
+ /// RemoveDIs: Add non-instruction function-local metadata uses.
for (DPValue &DPV : DPValue::filter(I.getDbgValueRange())) {
assert(DPV.getRawLocation() && "DPValue location unexpectedly null");
AddFnLocalMetadata(DPV.getRawLocation());
diff --git a/llvm/test/Bitcode/dbg-record-roundtrip.ll b/llvm/test/Bitcode/dbg-record-roundtrip.ll
index 6bdbb0d738d3a0..2a2c396e9b29b1 100644
--- a/llvm/test/Bitcode/dbg-record-roundtrip.ll
+++ b/llvm/test/Bitcode/dbg-record-roundtrip.ll
@@ -14,8 +14,8 @@
;; Check that llvm-link doesn't explode if we give it different formats to
;; link.
-; RUN: llvm-link %s --experimental-debuginfo-iterators=false < llvm-as %s --experimental-debuginfo-iterators=true
-; RUN: llvm-link %s --experimental-debuginfo-iterators=true < llvm-as %s --experimental-debuginfo-iterators=false
+; RUN: llvm-as %s --experimental-debuginfo-iterators=true -o - | llvm-link %s --experimental-debuginfo-iterators=false
+; RUN: llvm-as %s --experimental-debuginfo-iterators=false -o - | llvm-link %s --experimental-debuginfo-iterators=true
;; Checks inline.
>From 6a70150239dca8182effd99984e2a92898583aac Mon Sep 17 00:00:00 2001
From: Orlando Cazalet-Hyams <orlando.hyams at sony.com>
Date: Wed, 6 Mar 2024 11:15:01 +0000
Subject: [PATCH 5/9] move verifier code around, make it idiomatic
---
llvm/lib/IR/Verifier.cpp | 17 ++++++++---------
1 file changed, 8 insertions(+), 9 deletions(-)
diff --git a/llvm/lib/IR/Verifier.cpp b/llvm/lib/IR/Verifier.cpp
index bfe3cd0664f993..03e3ec1992c3cb 100644
--- a/llvm/lib/IR/Verifier.cpp
+++ b/llvm/lib/IR/Verifier.cpp
@@ -2632,6 +2632,11 @@ void Verifier::visitFunction(const Function &F) {
Check(verifyAttributeCount(Attrs, FT->getNumParams()),
"Attribute after last parameter!", &F);
+ Check(F.IsNewDbgInfoFormat == F.getParent()->IsNewDbgInfoFormat,
+ "Fn debug format should match parent", &F,
+ F.IsNewDbgInfoFormat, F.getParent(),
+ F.getParent()->IsNewDbgInfoFormat);
+
bool IsIntrinsic = F.isIntrinsic();
// Check function attributes.
@@ -2976,15 +2981,9 @@ void Verifier::visitBasicBlock(BasicBlock &BB) {
}
Check(BB.IsNewDbgInfoFormat == BB.getParent()->IsNewDbgInfoFormat,
- "BB debug format (new=" + std::to_string(BB.IsNewDbgInfoFormat) +
- ") should match parent " + BB.getName() + " in " +
- BB.getParent()->getName());
- Check(BB.getParent()->IsNewDbgInfoFormat ==
- BB.getParent()->getParent()->IsNewDbgInfoFormat,
- "Fn debug format (new=" +
- std::to_string(BB.getParent()->IsNewDbgInfoFormat) +
- ") should match parent " + BB.getParent()->getName() + " in " +
- BB.getParent()->getParent()->getName());
+ "BB debug format should match parent", &BB,
+ BB.IsNewDbgInfoFormat, BB.getParent(),
+ BB.getParent()->IsNewDbgInfoFormat);
// Confirm that no issues arise from the debug program.
if (BB.IsNewDbgInfoFormat) {
>From 1e636d4bacf27c7dd12216fae5f46fab0d50ce43 Mon Sep 17 00:00:00 2001
From: Orlando Cazalet-Hyams <orlando.hyams at sony.com>
Date: Thu, 7 Mar 2024 10:22:56 +0000
Subject: [PATCH 6/9] Remove uneeded format-setting
---
llvm/lib/Linker/IRMover.cpp | 2 --
1 file changed, 2 deletions(-)
diff --git a/llvm/lib/Linker/IRMover.cpp b/llvm/lib/Linker/IRMover.cpp
index 0017066bf44154..a7e6db82e5c23c 100644
--- a/llvm/lib/Linker/IRMover.cpp
+++ b/llvm/lib/Linker/IRMover.cpp
@@ -616,8 +616,6 @@ Value *IRLinker::materialize(Value *V, bool ForIndirectSymbol) {
// If we already created the body, just return.
if (auto *F = dyn_cast<Function>(New)) {
- if (auto *OldFunc = dyn_cast<Function>(SGV))
- F->IsNewDbgInfoFormat = OldFunc->IsNewDbgInfoFormat;
if (!F->isDeclaration())
return New;
} else if (auto *V = dyn_cast<GlobalVariable>(New)) {
>From 43e08667edf4427335e348fe4c6b1edf9dc20b4e Mon Sep 17 00:00:00 2001
From: Orlando Cazalet-Hyams <orlando.hyams at sony.com>
Date: Thu, 7 Mar 2024 11:23:13 +0000
Subject: [PATCH 7/9] disable by default
---
llvm/lib/IR/BasicBlock.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/llvm/lib/IR/BasicBlock.cpp b/llvm/lib/IR/BasicBlock.cpp
index 28145b407aa7f7..07de379ff51827 100644
--- a/llvm/lib/IR/BasicBlock.cpp
+++ b/llvm/lib/IR/BasicBlock.cpp
@@ -39,7 +39,7 @@ cl::opt<bool>
bool WriteNewDbgInfoFormatToBitcode /*set default value in cl::init() below*/;
cl::opt<bool, true> WriteNewDbgInfoFormatToBitcode2(
"write-experimental-debuginfo-iterators-to-bitcode", cl::Hidden,
- cl::location(WriteNewDbgInfoFormatToBitcode), cl::init(true));
+ cl::location(WriteNewDbgInfoFormatToBitcode), cl::init(false));
DPMarker *BasicBlock::createMarker(Instruction *I) {
assert(IsNewDbgInfoFormat &&
>From 9f40e0e4385cd37d8fe65c8f2aefb20e93a1a0cf Mon Sep 17 00:00:00 2001
From: Orlando Cazalet-Hyams <orlando.hyams at sony.com>
Date: Thu, 7 Mar 2024 11:24:31 +0000
Subject: [PATCH 8/9] Remove verifier changes from this patch
---
llvm/lib/IR/Verifier.cpp | 10 ----------
1 file changed, 10 deletions(-)
diff --git a/llvm/lib/IR/Verifier.cpp b/llvm/lib/IR/Verifier.cpp
index 03e3ec1992c3cb..4f321bc516cc39 100644
--- a/llvm/lib/IR/Verifier.cpp
+++ b/llvm/lib/IR/Verifier.cpp
@@ -2632,11 +2632,6 @@ void Verifier::visitFunction(const Function &F) {
Check(verifyAttributeCount(Attrs, FT->getNumParams()),
"Attribute after last parameter!", &F);
- Check(F.IsNewDbgInfoFormat == F.getParent()->IsNewDbgInfoFormat,
- "Fn debug format should match parent", &F,
- F.IsNewDbgInfoFormat, F.getParent(),
- F.getParent()->IsNewDbgInfoFormat);
-
bool IsIntrinsic = F.isIntrinsic();
// Check function attributes.
@@ -2980,11 +2975,6 @@ void Verifier::visitBasicBlock(BasicBlock &BB) {
Check(I.getParent() == &BB, "Instruction has bogus parent pointer!");
}
- Check(BB.IsNewDbgInfoFormat == BB.getParent()->IsNewDbgInfoFormat,
- "BB debug format should match parent", &BB,
- BB.IsNewDbgInfoFormat, BB.getParent(),
- BB.getParent()->IsNewDbgInfoFormat);
-
// Confirm that no issues arise from the debug program.
if (BB.IsNewDbgInfoFormat) {
// Configure the validate function to not fire assertions, instead print
>From 9ed5c9c9cc06f35c589a79ff251025a3986087ba Mon Sep 17 00:00:00 2001
From: Orlando Cazalet-Hyams <orlando.hyams at sony.com>
Date: Thu, 7 Mar 2024 11:52:49 +0000
Subject: [PATCH 9/9] Add
--write-experimental-debuginfo-iterators-to-bitcode=true to test
---
llvm/test/Bitcode/dbg-record-roundtrip.ll | 10 +++++-----
1 file changed, 5 insertions(+), 5 deletions(-)
diff --git a/llvm/test/Bitcode/dbg-record-roundtrip.ll b/llvm/test/Bitcode/dbg-record-roundtrip.ll
index 2a2c396e9b29b1..be6f65c34214ea 100644
--- a/llvm/test/Bitcode/dbg-record-roundtrip.ll
+++ b/llvm/test/Bitcode/dbg-record-roundtrip.ll
@@ -1,12 +1,12 @@
;; Roundtrip tests.
-; RUN: llvm-as %s -o - | llvm-dis | FileCheck %s
+; RUN: llvm-as --write-experimental-debuginfo-iterators-to-bitcode=true %s -o - | llvm-dis | FileCheck %s
;; Check that verify-uselistorder passes regardless of input format.
-; RUN: llvm-as %s -o - | verify-uselistorder
+; RUN: llvm-as %s -o - --write-experimental-debuginfo-iterators-to-bitcode=true | verify-uselistorder
; RUN: verify-uselistorder %s
;; Confirm we're producing RemoveDI records from various tools.
-; RUN: opt %s -o - | llvm-bcanalyzer - | FileCheck %s --check-prefix=BITCODE
-; RUN: llvm-as %s -o - | llvm-bcanalyzer - | FileCheck %s --check-prefix=BITCODE
+; RUN: opt %s -o - --write-experimental-debuginfo-iterators-to-bitcode=true | llvm-bcanalyzer - | FileCheck %s --check-prefix=BITCODE
+; RUN: llvm-as %s -o - --write-experimental-debuginfo-iterators-to-bitcode=true | llvm-bcanalyzer - | FileCheck %s --check-prefix=BITCODE
; BITCODE-DAG: DEBUG_RECORD_LABEL
; BITCODE-DAG: DEBUG_RECORD_VALUE
; BITCODE-DAG: DEBUG_RECORD_ASSIGN
@@ -14,7 +14,7 @@
;; Check that llvm-link doesn't explode if we give it different formats to
;; link.
-; RUN: llvm-as %s --experimental-debuginfo-iterators=true -o - | llvm-link %s --experimental-debuginfo-iterators=false
+; RUN: llvm-as %s --experimental-debuginfo-iterators=true --write-experimental-debuginfo-iterators-to-bitcode=true -o - | llvm-link %s --experimental-debuginfo-iterators=false
; RUN: llvm-as %s --experimental-debuginfo-iterators=false -o - | llvm-link %s --experimental-debuginfo-iterators=true
;; Checks inline.
More information about the llvm-commits
mailing list