[llvm] 4fd319a - Revert#2 "[RemoveDIs] Load into new debug info format by default in LLVM (#89799)"
Stephen Tozer via llvm-commits
llvm-commits at lists.llvm.org
Thu May 2 09:52:23 PDT 2024
Author: Stephen Tozer
Date: 2024-05-02T17:52:02+01:00
New Revision: 4fd319ae273ed6c252f2067909c1abd9f6d97efa
URL: https://github.com/llvm/llvm-project/commit/4fd319ae273ed6c252f2067909c1abd9f6d97efa
DIFF: https://github.com/llvm/llvm-project/commit/4fd319ae273ed6c252f2067909c1abd9f6d97efa.diff
LOG: Revert#2 "[RemoveDIs] Load into new debug info format by default in LLVM (#89799)"
Reverted following probably-causing failures on some clang buildbots:
https://lab.llvm.org/buildbot/#/builders/245/builds/24037
This reverts commit a12622543de15df45fb9ad64e8ab723289d55169.
Added:
Modified:
llvm/docs/ReleaseNotes.rst
llvm/include/llvm/AsmParser/LLParser.h
llvm/lib/AsmParser/LLParser.cpp
llvm/lib/Bitcode/Reader/BitcodeReader.cpp
llvm/lib/IR/BasicBlock.cpp
llvm/lib/IR/DebugProgramInstruction.cpp
llvm/lib/IR/Function.cpp
llvm/lib/IR/Module.cpp
llvm/tools/llvm-as/llvm-as.cpp
llvm/tools/llvm-dis/llvm-dis.cpp
llvm/tools/llvm-link/llvm-link.cpp
llvm/unittests/Analysis/IRSimilarityIdentifierTest.cpp
llvm/unittests/IR/BasicBlockDbgInfoTest.cpp
llvm/unittests/IR/DebugInfoTest.cpp
llvm/unittests/IR/IRBuilderTest.cpp
llvm/unittests/IR/InstructionsTest.cpp
llvm/unittests/IR/ValueTest.cpp
llvm/unittests/Transforms/Utils/CloningTest.cpp
llvm/unittests/Transforms/Utils/LocalTest.cpp
Removed:
################################################################################
diff --git a/llvm/docs/ReleaseNotes.rst b/llvm/docs/ReleaseNotes.rst
index 941097e4965147..102dca1b11aba3 100644
--- a/llvm/docs/ReleaseNotes.rst
+++ b/llvm/docs/ReleaseNotes.rst
@@ -171,13 +171,6 @@ Changes to the Metadata Info
Changes to the Debug Info
---------------------------------
-* LLVM has switched from using debug intrinsics internally to using debug
- records by default. This should happen transparently when using the DIBuilder
- to construct debug variable information, but will require changes for any code
- that interacts with debug intrinsics directly. Debug intrinsics will only be
- supported on a best-effort basis from here onwards; for more information, see
- the `migration docs <https://llvm.org/docs/RemoveDIsDebugInfo.html>`_.
-
Changes to the LLVM tools
---------------------------------
* llvm-nm and llvm-objdump can now print symbol information from linked
diff --git a/llvm/include/llvm/AsmParser/LLParser.h b/llvm/include/llvm/AsmParser/LLParser.h
index e687254f6c4c70..b2dcdfad0a04b4 100644
--- a/llvm/include/llvm/AsmParser/LLParser.h
+++ b/llvm/include/llvm/AsmParser/LLParser.h
@@ -337,6 +337,7 @@ namespace llvm {
// Top-Level Entities
bool parseTopLevelEntities();
+ bool finalizeDebugInfoFormat(Module *M);
void dropUnknownMetadataReferences();
bool validateEndOfModule(bool UpgradeDebugInfo);
bool validateEndOfIndex();
diff --git a/llvm/lib/AsmParser/LLParser.cpp b/llvm/lib/AsmParser/LLParser.cpp
index 34053a5ca9c8e8..2902bd9fe17c48 100644
--- a/llvm/lib/AsmParser/LLParser.cpp
+++ b/llvm/lib/AsmParser/LLParser.cpp
@@ -74,6 +74,23 @@ static std::string getTypeString(Type *T) {
return Tmp.str();
}
+// Whatever debug info format we parsed, we should convert to the expected debug
+// info format immediately afterwards.
+bool LLParser::finalizeDebugInfoFormat(Module *M) {
+ // We should have already returned an error if we observed both intrinsics and
+ // records in this IR.
+ assert(!(SeenNewDbgInfoFormat && SeenOldDbgInfoFormat) &&
+ "Mixed debug intrinsics/records seen without a parsing error?");
+ if (PreserveInputDbgFormat == cl::boolOrDefault::BOU_TRUE) {
+ UseNewDbgInfoFormat = SeenNewDbgInfoFormat;
+ WriteNewDbgInfoFormatToBitcode = SeenNewDbgInfoFormat;
+ WriteNewDbgInfoFormat = SeenNewDbgInfoFormat;
+ } else if (M) {
+ M->setIsNewDbgInfoFormat(false);
+ }
+ return false;
+}
+
/// Run: module ::= toplevelentity*
bool LLParser::Run(bool UpgradeDebugInfo,
DataLayoutCallbackTy DataLayoutCallback) {
@@ -91,7 +108,7 @@ bool LLParser::Run(bool UpgradeDebugInfo,
}
return parseTopLevelEntities() || validateEndOfModule(UpgradeDebugInfo) ||
- validateEndOfIndex();
+ validateEndOfIndex() || finalizeDebugInfoFormat(M);
}
bool LLParser::parseStandaloneConstantValue(Constant *&C,
@@ -190,18 +207,6 @@ void LLParser::dropUnknownMetadataReferences() {
bool LLParser::validateEndOfModule(bool UpgradeDebugInfo) {
if (!M)
return false;
-
- // We should have already returned an error if we observed both intrinsics and
- // records in this IR.
- assert(!(SeenNewDbgInfoFormat && SeenOldDbgInfoFormat) &&
- "Mixed debug intrinsics/records seen without a parsing error?");
- if (PreserveInputDbgFormat == cl::boolOrDefault::BOU_TRUE) {
- UseNewDbgInfoFormat = SeenNewDbgInfoFormat;
- WriteNewDbgInfoFormatToBitcode = SeenNewDbgInfoFormat;
- WriteNewDbgInfoFormat = SeenNewDbgInfoFormat;
- M->setNewDbgInfoFormatFlag(SeenNewDbgInfoFormat);
- }
-
// Handle any function attribute group forward references.
for (const auto &RAG : ForwardRefAttrGroups) {
Value *V = RAG.first;
@@ -434,9 +439,6 @@ bool LLParser::validateEndOfModule(bool UpgradeDebugInfo) {
UpgradeModuleFlags(*M);
UpgradeSectionAttributes(*M);
- if (PreserveInputDbgFormat != cl::boolOrDefault::BOU_TRUE)
- M->setIsNewDbgInfoFormat(UseNewDbgInfoFormat);
-
if (!Slots)
return false;
// Initialize the slot mapping.
diff --git a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp
index 95f553b4f8ecc0..a0779f955cf28d 100644
--- a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -4319,7 +4319,7 @@ Error BitcodeReader::parseModule(uint64_t ResumeBit,
if (PreserveInputDbgFormat != cl::boolOrDefault::BOU_TRUE) {
TheModule->IsNewDbgInfoFormat =
UseNewDbgInfoFormat &&
- LoadBitcodeIntoNewDbgInfoFormat != cl::boolOrDefault::BOU_FALSE;
+ LoadBitcodeIntoNewDbgInfoFormat == cl::boolOrDefault::BOU_TRUE;
}
this->ValueTypeCallback = std::move(Callbacks.ValueType);
diff --git a/llvm/lib/IR/BasicBlock.cpp b/llvm/lib/IR/BasicBlock.cpp
index aea9425ebebaab..29f2cbf611fa3a 100644
--- a/llvm/lib/IR/BasicBlock.cpp
+++ b/llvm/lib/IR/BasicBlock.cpp
@@ -181,7 +181,7 @@ template class llvm::SymbolTableListTraits<Instruction,
BasicBlock::BasicBlock(LLVMContext &C, const Twine &Name, Function *NewParent,
BasicBlock *InsertBefore)
: Value(Type::getLabelTy(C), Value::BasicBlockVal),
- IsNewDbgInfoFormat(UseNewDbgInfoFormat), Parent(nullptr) {
+ IsNewDbgInfoFormat(false), Parent(nullptr) {
if (NewParent)
insertInto(NewParent, InsertBefore);
diff --git a/llvm/lib/IR/DebugProgramInstruction.cpp b/llvm/lib/IR/DebugProgramInstruction.cpp
index 9a4926c81dca27..fbca7cdfcf3f55 100644
--- a/llvm/lib/IR/DebugProgramInstruction.cpp
+++ b/llvm/lib/IR/DebugProgramInstruction.cpp
@@ -366,8 +366,8 @@ void DbgVariableRecord::setKillLocation() {
}
bool DbgVariableRecord::isKillLocation() const {
- return (!hasArgList() && isa<MDNode>(getRawLocation())) ||
- (getNumVariableLocationOps() == 0 && !getExpression()->isComplex()) ||
+ return (getNumVariableLocationOps() == 0 &&
+ !getExpression()->isComplex()) ||
any_of(location_ops(), [](Value *V) { return isa<UndefValue>(V); });
}
diff --git a/llvm/lib/IR/Function.cpp b/llvm/lib/IR/Function.cpp
index e42248da17422b..6901840806576b 100644
--- a/llvm/lib/IR/Function.cpp
+++ b/llvm/lib/IR/Function.cpp
@@ -83,8 +83,6 @@ static cl::opt<unsigned> NonGlobalValueMaxNameSize(
"non-global-value-max-name-size", cl::Hidden, cl::init(1024),
cl::desc("Maximum size for the name of non-global values."));
-extern cl::opt<bool> UseNewDbgInfoFormat;
-
void Function::convertToNewDbgValues() {
IsNewDbgInfoFormat = true;
for (auto &BB : *this) {
@@ -440,7 +438,7 @@ Function::Function(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace,
: GlobalObject(Ty, Value::FunctionVal,
OperandTraits<Function>::op_begin(this), 0, Linkage, name,
computeAddrSpace(AddrSpace, ParentModule)),
- NumArgs(Ty->getNumParams()), IsNewDbgInfoFormat(UseNewDbgInfoFormat) {
+ NumArgs(Ty->getNumParams()), IsNewDbgInfoFormat(false) {
assert(FunctionType::isValidReturnType(getReturnType()) &&
"invalid return type");
setGlobalObjectSubClassData(0);
diff --git a/llvm/lib/IR/Module.cpp b/llvm/lib/IR/Module.cpp
index 915fa5097383cc..a8696ed9e3ce5d 100644
--- a/llvm/lib/IR/Module.cpp
+++ b/llvm/lib/IR/Module.cpp
@@ -54,8 +54,6 @@
using namespace llvm;
-extern cl::opt<bool> UseNewDbgInfoFormat;
-
//===----------------------------------------------------------------------===//
// Methods to implement the globals and functions lists.
//
@@ -74,7 +72,7 @@ template class llvm::SymbolTableListTraits<GlobalIFunc>;
Module::Module(StringRef MID, LLVMContext &C)
: Context(C), ValSymTab(std::make_unique<ValueSymbolTable>(-1)),
ModuleID(std::string(MID)), SourceFileName(std::string(MID)), DL(""),
- IsNewDbgInfoFormat(UseNewDbgInfoFormat) {
+ IsNewDbgInfoFormat(false) {
Context.addModule(this);
}
diff --git a/llvm/tools/llvm-as/llvm-as.cpp b/llvm/tools/llvm-as/llvm-as.cpp
index 0958e16c2197ac..e48e3f4d22c123 100644
--- a/llvm/tools/llvm-as/llvm-as.cpp
+++ b/llvm/tools/llvm-as/llvm-as.cpp
@@ -142,10 +142,11 @@ int main(int argc, char **argv) {
}
// Convert to new debug format if requested.
- M->setIsNewDbgInfoFormat(UseNewDbgInfoFormat &&
- WriteNewDbgInfoFormatToBitcode);
- if (M->IsNewDbgInfoFormat)
+ assert(!M->IsNewDbgInfoFormat && "Unexpectedly in new debug mode");
+ if (UseNewDbgInfoFormat && WriteNewDbgInfoFormatToBitcode) {
+ M->convertToNewDbgValues();
M->removeDebugIntrinsicDeclarations();
+ }
std::unique_ptr<ModuleSummaryIndex> Index = std::move(ModuleAndIndex.Index);
diff --git a/llvm/tools/llvm-dis/llvm-dis.cpp b/llvm/tools/llvm-dis/llvm-dis.cpp
index d28af85bc739eb..fbbb5506e43e05 100644
--- a/llvm/tools/llvm-dis/llvm-dis.cpp
+++ b/llvm/tools/llvm-dis/llvm-dis.cpp
@@ -258,7 +258,7 @@ int main(int argc, char **argv) {
// All that llvm-dis does is write the assembly to a file.
if (!DontPrint) {
if (M) {
- M->setIsNewDbgInfoFormat(WriteNewDbgInfoFormat);
+ ScopedDbgInfoFormatSetter FormatSetter(*M, WriteNewDbgInfoFormat);
if (WriteNewDbgInfoFormat)
M->removeDebugIntrinsicDeclarations();
M->print(Out->os(), Annotator.get(), PreserveAssemblyUseListOrder);
diff --git a/llvm/tools/llvm-link/llvm-link.cpp b/llvm/tools/llvm-link/llvm-link.cpp
index b84469d1c757f8..7794f2d81ed064 100644
--- a/llvm/tools/llvm-link/llvm-link.cpp
+++ b/llvm/tools/llvm-link/llvm-link.cpp
@@ -489,6 +489,12 @@ int main(int argc, char **argv) {
if (LoadBitcodeIntoNewDbgInfoFormat == cl::boolOrDefault::BOU_UNSET)
LoadBitcodeIntoNewDbgInfoFormat = cl::boolOrDefault::BOU_TRUE;
+ // RemoveDIs debug-info transition: tests may request that we /try/ to use the
+ // new debug-info format.
+ if (TryUseNewDbgInfoFormat) {
+ // Turn the new debug-info format on.
+ UseNewDbgInfoFormat = true;
+ }
// Since llvm-link collects multiple IR modules together, for simplicity's
// sake we disable the "PreserveInputDbgFormat" flag to enforce a single
// debug info format.
@@ -550,7 +556,7 @@ int main(int argc, char **argv) {
SetFormat(WriteNewDbgInfoFormat);
Composite->print(Out.os(), nullptr, PreserveAssemblyUseListOrder);
} else if (Force || !CheckBitcodeOutputToConsole(Out.os())) {
- SetFormat(UseNewDbgInfoFormat && WriteNewDbgInfoFormatToBitcode);
+ SetFormat(WriteNewDbgInfoFormatToBitcode);
WriteBitcodeToFile(*Composite, Out.os(), PreserveBitcodeUseListOrder);
}
diff --git a/llvm/unittests/Analysis/IRSimilarityIdentifierTest.cpp b/llvm/unittests/Analysis/IRSimilarityIdentifierTest.cpp
index 0a08ca3cb99db9..f6a053792f8529 100644
--- a/llvm/unittests/Analysis/IRSimilarityIdentifierTest.cpp
+++ b/llvm/unittests/Analysis/IRSimilarityIdentifierTest.cpp
@@ -12,7 +12,6 @@
//===----------------------------------------------------------------------===//
#include "llvm/Analysis/IRSimilarityIdentifier.h"
-#include "llvm/ADT/ScopeExit.h"
#include "llvm/AsmParser/Parser.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
@@ -23,27 +22,6 @@
using namespace llvm;
using namespace IRSimilarity;
-extern llvm::cl::opt<bool> UseNewDbgInfoFormat;
-extern cl::opt<cl::boolOrDefault> PreserveInputDbgFormat;
-extern bool WriteNewDbgInfoFormatToBitcode;
-extern cl::opt<bool> WriteNewDbgInfoFormat;
-
-// Backup all of the existing settings that may be modified when
-// PreserveInputDbgFormat=true, so that when the test is finished we return them
-// (and the "preserve" setting) to their original values.
-static auto SaveDbgInfoFormat() {
- return make_scope_exit(
- [OldPreserveInputDbgFormat = PreserveInputDbgFormat.getValue(),
- OldUseNewDbgInfoFormat = UseNewDbgInfoFormat.getValue(),
- OldWriteNewDbgInfoFormatToBitcode = WriteNewDbgInfoFormatToBitcode,
- OldWriteNewDbgInfoFormat = WriteNewDbgInfoFormat.getValue()] {
- PreserveInputDbgFormat = OldPreserveInputDbgFormat;
- UseNewDbgInfoFormat = OldUseNewDbgInfoFormat;
- WriteNewDbgInfoFormatToBitcode = OldWriteNewDbgInfoFormatToBitcode;
- WriteNewDbgInfoFormat = OldWriteNewDbgInfoFormat;
- });
-}
-
static std::unique_ptr<Module> makeLLVMModule(LLVMContext &Context,
StringRef ModuleStr) {
SMDiagnostic Err;
@@ -1330,9 +1308,6 @@ TEST(IRInstructionMapper, CallBrInstIllegal) {
// Checks that an debuginfo intrinsics are mapped to be invisible. Since they
// do not semantically change the program, they can be recognized as similar.
-// FIXME: PreserveInputDbgFormat is set to true because this test contains
-// malformed debug info that cannot be converted to the new debug info format;
-// this test should be updated later to use valid debug info.
TEST(IRInstructionMapper, DebugInfoInvisible) {
StringRef ModuleString = R"(
define i32 @f(i32 %a, i32 %b) {
@@ -1345,8 +1320,6 @@ TEST(IRInstructionMapper, DebugInfoInvisible) {
declare void @llvm.dbg.value(metadata)
!0 = distinct !{!"test\00", i32 10})";
- auto SettingGuard = SaveDbgInfoFormat();
- PreserveInputDbgFormat = cl::boolOrDefault::BOU_TRUE;
LLVMContext Context;
std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleString);
@@ -1943,9 +1916,6 @@ TEST(IRSimilarityCandidate, CheckRegionsDifferentTypes) {
// Check that debug instructions do not impact similarity. They are marked as
// invisible.
-// FIXME: PreserveInputDbgFormat is set to true because this test contains
-// malformed debug info that cannot be converted to the new debug info format;
-// this test should be updated later to use valid debug info.
TEST(IRSimilarityCandidate, IdenticalWithDebug) {
StringRef ModuleString = R"(
define i32 @f(i32 %a, i32 %b) {
@@ -1968,8 +1938,6 @@ TEST(IRSimilarityCandidate, IdenticalWithDebug) {
declare void @llvm.dbg.value(metadata)
!0 = distinct !{!"test\00", i32 10}
!1 = distinct !{!"test\00", i32 11})";
- auto SettingGuard = SaveDbgInfoFormat();
- PreserveInputDbgFormat = cl::boolOrDefault::BOU_TRUE;
LLVMContext Context;
std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleString);
diff --git a/llvm/unittests/IR/BasicBlockDbgInfoTest.cpp b/llvm/unittests/IR/BasicBlockDbgInfoTest.cpp
index 91a0745a0cc76e..f873bbd4293af5 100644
--- a/llvm/unittests/IR/BasicBlockDbgInfoTest.cpp
+++ b/llvm/unittests/IR/BasicBlockDbgInfoTest.cpp
@@ -25,6 +25,8 @@
using namespace llvm;
+extern cl::opt<bool> UseNewDbgInfoFormat;
+
static std::unique_ptr<Module> parseIR(LLVMContext &C, const char *IR) {
SMDiagnostic Err;
std::unique_ptr<Module> Mod = parseAssemblyString(IR, Err, C);
@@ -42,6 +44,8 @@ namespace {
// by DbgVariableRecords, the dbg.value replacement.
TEST(BasicBlockDbgInfoTest, InsertAfterSelf) {
LLVMContext C;
+ UseNewDbgInfoFormat = true;
+
std::unique_ptr<Module> M = parseIR(C, R"(
define i16 @f(i16 %a) !dbg !6 {
call void @llvm.dbg.value(metadata i16 %a, metadata !9, metadata !DIExpression()), !dbg !11
@@ -68,6 +72,8 @@ TEST(BasicBlockDbgInfoTest, InsertAfterSelf) {
!11 = !DILocation(line: 1, column: 1, scope: !6)
)");
+ // Convert the module to "new" form debug-info.
+ M->convertToNewDbgValues();
// Fetch the entry block.
BasicBlock &BB = M->getFunction("f")->getEntryBlock();
@@ -97,10 +103,16 @@ TEST(BasicBlockDbgInfoTest, InsertAfterSelf) {
EXPECT_TRUE(RetInst->hasDbgRecords());
auto Range2 = RetInst->getDbgRecordRange();
EXPECT_EQ(std::distance(Range2.begin(), Range2.end()), 1u);
+
+ M->convertFromNewDbgValues();
+
+ UseNewDbgInfoFormat = false;
}
TEST(BasicBlockDbgInfoTest, SplitBasicBlockBefore) {
LLVMContext C;
+ UseNewDbgInfoFormat = true;
+
std::unique_ptr<Module> M = parseIR(C, R"---(
define dso_local void @func() #0 !dbg !10 {
%1 = alloca i32, align 4
@@ -138,6 +150,8 @@ TEST(BasicBlockDbgInfoTest, SplitBasicBlockBefore) {
)---");
ASSERT_TRUE(M);
+ M->convertToNewDbgValues();
+
Function *F = M->getFunction("func");
BasicBlock &BB = F->getEntryBlock();
@@ -147,10 +161,14 @@ TEST(BasicBlockDbgInfoTest, SplitBasicBlockBefore) {
BasicBlock &BBBefore = F->getEntryBlock();
auto I2 = std::prev(BBBefore.end(), 2);
ASSERT_TRUE(I2->hasDbgRecords());
+
+ UseNewDbgInfoFormat = false;
}
TEST(BasicBlockDbgInfoTest, MarkerOperations) {
LLVMContext C;
+ UseNewDbgInfoFormat = true;
+
std::unique_ptr<Module> M = parseIR(C, R"(
define i16 @f(i16 %a) !dbg !6 {
call void @llvm.dbg.value(metadata i16 %a, metadata !9, metadata !DIExpression()), !dbg !11
@@ -178,6 +196,8 @@ TEST(BasicBlockDbgInfoTest, MarkerOperations) {
// Fetch the entry block,
BasicBlock &BB = M->getFunction("f")->getEntryBlock();
+ // Convert the module to "new" form debug-info.
+ M->convertToNewDbgValues();
EXPECT_EQ(BB.size(), 2u);
// Fetch out our two markers,
@@ -275,10 +295,14 @@ TEST(BasicBlockDbgInfoTest, MarkerOperations) {
// Teardown,
Instr1->insertBefore(BB, BB.begin());
+
+ UseNewDbgInfoFormat = false;
}
TEST(BasicBlockDbgInfoTest, HeadBitOperations) {
LLVMContext C;
+ UseNewDbgInfoFormat = true;
+
std::unique_ptr<Module> M = parseIR(C, R"(
define i16 @f(i16 %a) !dbg !6 {
%b = add i16 %a, 1, !dbg !11
@@ -308,6 +332,8 @@ TEST(BasicBlockDbgInfoTest, HeadBitOperations) {
// Test that the movement of debug-data when using moveBefore etc and
// insertBefore etc are governed by the "head" bit of iterators.
BasicBlock &BB = M->getFunction("f")->getEntryBlock();
+ // Convert the module to "new" form debug-info.
+ M->convertToNewDbgValues();
// Test that the head bit behaves as expected: it should be set when the
// code wants the _start_ of the block, but not otherwise.
@@ -378,10 +404,14 @@ TEST(BasicBlockDbgInfoTest, HeadBitOperations) {
DInst->DebugMarker->StoredDbgRecords.empty());
EXPECT_FALSE(CInst->DebugMarker->StoredDbgRecords.empty());
EXPECT_EQ(&*BB.begin(), CInst);
+
+ UseNewDbgInfoFormat = false;
}
TEST(BasicBlockDbgInfoTest, InstrDbgAccess) {
LLVMContext C;
+ UseNewDbgInfoFormat = true;
+
std::unique_ptr<Module> M = parseIR(C, R"(
define i16 @f(i16 %a) !dbg !6 {
%b = add i16 %a, 1, !dbg !11
@@ -411,6 +441,8 @@ TEST(BasicBlockDbgInfoTest, InstrDbgAccess) {
// Check that DbgVariableRecords can be accessed from Instructions without
// digging into the depths of DbgMarkers.
BasicBlock &BB = M->getFunction("f")->getEntryBlock();
+ // Convert the module to "new" form debug-info.
+ M->convertToNewDbgValues();
Instruction *BInst = &*BB.begin();
Instruction *CInst = BInst->getNextNode();
@@ -451,6 +483,8 @@ TEST(BasicBlockDbgInfoTest, InstrDbgAccess) {
CInst->dropOneDbgRecord(DVR1);
EXPECT_FALSE(CInst->hasDbgRecords());
EXPECT_EQ(CInst->DebugMarker->StoredDbgRecords.size(), 0u);
+
+ UseNewDbgInfoFormat = false;
}
/* Let's recall the big illustration from BasicBlock::spliceDebugInfo:
@@ -543,7 +577,9 @@ class DbgSpliceTest : public ::testing::Test {
DbgVariableRecord *DVRA, *DVRB, *DVRConst;
void SetUp() override {
+ UseNewDbgInfoFormat = true;
M = parseIR(C, SpliceTestIR.c_str());
+ M->convertToNewDbgValues();
BBEntry = &M->getFunction("f")->getEntryBlock();
BBExit = BBEntry->getNextNode();
@@ -563,6 +599,8 @@ class DbgSpliceTest : public ::testing::Test {
cast<DbgVariableRecord>(&*CInst->DebugMarker->StoredDbgRecords.begin());
}
+ void TearDown() override { UseNewDbgInfoFormat = false; }
+
bool InstContainsDbgVariableRecord(Instruction *I, DbgVariableRecord *DVR) {
for (DbgRecord &D : I->getDbgRecordRange()) {
if (&D == DVR) {
@@ -1149,6 +1187,8 @@ metadata !9, metadata !DIExpression()), !dbg !11 Dest %c = add i16 %b, 1,
// then the trailing DbgVariableRecords should get flushed back out.
TEST(BasicBlockDbgInfoTest, DbgSpliceTrailing) {
LLVMContext C;
+ UseNewDbgInfoFormat = true;
+
std::unique_ptr<Module> M = parseIR(C, R"(
define i16 @f(i16 %a) !dbg !6 {
entry:
@@ -1179,6 +1219,7 @@ TEST(BasicBlockDbgInfoTest, DbgSpliceTrailing) {
BasicBlock &Entry = M->getFunction("f")->getEntryBlock();
BasicBlock &Exit = *Entry.getNextNode();
+ M->convertToNewDbgValues();
// Begin by forcing entry block to have dangling DbgVariableRecord.
Entry.getTerminator()->eraseFromParent();
@@ -1193,6 +1234,8 @@ TEST(BasicBlockDbgInfoTest, DbgSpliceTrailing) {
Instruction *BInst = &*Entry.begin();
ASSERT_TRUE(BInst->DebugMarker);
EXPECT_EQ(BInst->DebugMarker->StoredDbgRecords.size(), 1u);
+
+ UseNewDbgInfoFormat = false;
}
// When we remove instructions from the program, adjacent DbgVariableRecords
@@ -1201,6 +1244,8 @@ TEST(BasicBlockDbgInfoTest, DbgSpliceTrailing) {
// dbg.values. Test that this can be replicated correctly by DbgVariableRecords
TEST(BasicBlockDbgInfoTest, RemoveInstAndReinsert) {
LLVMContext C;
+ UseNewDbgInfoFormat = true;
+
std::unique_ptr<Module> M = parseIR(C, R"(
define i16 @f(i16 %a) !dbg !6 {
entry:
@@ -1228,6 +1273,7 @@ TEST(BasicBlockDbgInfoTest, RemoveInstAndReinsert) {
)");
BasicBlock &Entry = M->getFunction("f")->getEntryBlock();
+ M->convertToNewDbgValues();
// Fetch the relevant instructions from the converted function.
Instruction *SubInst = &*Entry.begin();
@@ -1270,12 +1316,16 @@ TEST(BasicBlockDbgInfoTest, RemoveInstAndReinsert) {
EXPECT_EQ(std::distance(R4.begin(), R4.end()), 1u);
auto R5 = RetInst->getDbgRecordRange();
EXPECT_EQ(std::distance(R5.begin(), R5.end()), 1u);
+
+ UseNewDbgInfoFormat = false;
}
// Test instruction removal and re-insertion, this time with one
// DbgVariableRecord that should hop up one instruction.
TEST(BasicBlockDbgInfoTest, RemoveInstAndReinsertForOneDbgVariableRecord) {
LLVMContext C;
+ UseNewDbgInfoFormat = true;
+
std::unique_ptr<Module> M = parseIR(C, R"(
define i16 @f(i16 %a) !dbg !6 {
entry:
@@ -1302,6 +1352,7 @@ TEST(BasicBlockDbgInfoTest, RemoveInstAndReinsertForOneDbgVariableRecord) {
)");
BasicBlock &Entry = M->getFunction("f")->getEntryBlock();
+ M->convertToNewDbgValues();
// Fetch the relevant instructions from the converted function.
Instruction *SubInst = &*Entry.begin();
@@ -1340,6 +1391,8 @@ TEST(BasicBlockDbgInfoTest, RemoveInstAndReinsertForOneDbgVariableRecord) {
EXPECT_FALSE(RetInst->hasDbgRecords());
auto R3 = AddInst->getDbgRecordRange();
EXPECT_EQ(std::distance(R3.begin(), R3.end()), 1u);
+
+ UseNewDbgInfoFormat = false;
}
// Similar to the above, what if we splice into an empty block with debug-info,
@@ -1348,6 +1401,8 @@ TEST(BasicBlockDbgInfoTest, RemoveInstAndReinsertForOneDbgVariableRecord) {
// of the i16 0 dbg.value.
TEST(BasicBlockDbgInfoTest, DbgSpliceToEmpty1) {
LLVMContext C;
+ UseNewDbgInfoFormat = true;
+
std::unique_ptr<Module> M = parseIR(C, R"(
define i16 @f(i16 %a) !dbg !6 {
entry:
@@ -1381,6 +1436,7 @@ TEST(BasicBlockDbgInfoTest, DbgSpliceToEmpty1) {
Function &F = *M->getFunction("f");
BasicBlock &Entry = F.getEntryBlock();
BasicBlock &Exit = *Entry.getNextNode();
+ M->convertToNewDbgValues();
// Begin by forcing entry block to have dangling DbgVariableRecord.
Entry.getTerminator()->eraseFromParent();
@@ -1407,12 +1463,16 @@ TEST(BasicBlockDbgInfoTest, DbgSpliceToEmpty1) {
// No trailing DbgVariableRecords in the entry block now.
EXPECT_EQ(Entry.getTrailingDbgRecords(), nullptr);
+
+ UseNewDbgInfoFormat = false;
}
// Similar test again, but this time: splice the contents of exit into entry,
// with the intention of leaving the first dbg.value (i16 0) behind.
TEST(BasicBlockDbgInfoTest, DbgSpliceToEmpty2) {
LLVMContext C;
+ UseNewDbgInfoFormat = true;
+
std::unique_ptr<Module> M = parseIR(C, R"(
define i16 @f(i16 %a) !dbg !6 {
entry:
@@ -1446,6 +1506,7 @@ TEST(BasicBlockDbgInfoTest, DbgSpliceToEmpty2) {
Function &F = *M->getFunction("f");
BasicBlock &Entry = F.getEntryBlock();
BasicBlock &Exit = *Entry.getNextNode();
+ M->convertToNewDbgValues();
// Begin by forcing entry block to have dangling DbgVariableRecord.
Entry.getTerminator()->eraseFromParent();
@@ -1476,12 +1537,16 @@ TEST(BasicBlockDbgInfoTest, DbgSpliceToEmpty2) {
EXPECT_FALSE(Exit.getTrailingDbgRecords()->empty());
Exit.getTrailingDbgRecords()->eraseFromParent();
Exit.deleteTrailingDbgRecords();
+
+ UseNewDbgInfoFormat = false;
}
// What if we moveBefore end() -- there might be no debug-info there, in which
// case we shouldn't crash.
TEST(BasicBlockDbgInfoTest, DbgMoveToEnd) {
LLVMContext C;
+ UseNewDbgInfoFormat = true;
+
std::unique_ptr<Module> M = parseIR(C, R"(
define i16 @f(i16 %a) !dbg !6 {
entry:
@@ -1511,6 +1576,7 @@ TEST(BasicBlockDbgInfoTest, DbgMoveToEnd) {
Function &F = *M->getFunction("f");
BasicBlock &Entry = F.getEntryBlock();
BasicBlock &Exit = *Entry.getNextNode();
+ M->convertToNewDbgValues();
// Move the return to the end of the entry block.
Instruction *Br = Entry.getTerminator();
@@ -1523,6 +1589,8 @@ TEST(BasicBlockDbgInfoTest, DbgMoveToEnd) {
EXPECT_EQ(Entry.getTrailingDbgRecords(), nullptr);
EXPECT_EQ(Exit.getTrailingDbgRecords(), nullptr);
EXPECT_FALSE(Ret->hasDbgRecords());
+
+ UseNewDbgInfoFormat = false;
}
} // End anonymous namespace.
diff --git a/llvm/unittests/IR/DebugInfoTest.cpp b/llvm/unittests/IR/DebugInfoTest.cpp
index ad7735acc8e08d..d06b979bf4a1c4 100644
--- a/llvm/unittests/IR/DebugInfoTest.cpp
+++ b/llvm/unittests/IR/DebugInfoTest.cpp
@@ -154,7 +154,7 @@ TEST(StripTest, LoopMetadata) {
EXPECT_FALSE(BrokenDebugInfo);
}
-TEST(MetadataTest, DeleteInstUsedByDbgRecord) {
+TEST(MetadataTest, DeleteInstUsedByDbgValue) {
LLVMContext C;
std::unique_ptr<Module> M = parseIR(C, R"(
define i16 @f(i16 %a) !dbg !6 {
@@ -185,13 +185,12 @@ TEST(MetadataTest, DeleteInstUsedByDbgRecord) {
// Find the dbg.value using %b.
SmallVector<DbgValueInst *, 1> DVIs;
- SmallVector<DbgVariableRecord *, 1> DVRs;
- findDbgValues(DVIs, &I, &DVRs);
+ findDbgValues(DVIs, &I);
// Delete %b. The dbg.value should now point to undef.
I.eraseFromParent();
- EXPECT_EQ(DVRs[0]->getNumVariableLocationOps(), 1u);
- EXPECT_TRUE(isa<UndefValue>(DVRs[0]->getValue(0)));
+ EXPECT_EQ(DVIs[0]->getNumVariableLocationOps(), 1u);
+ EXPECT_TRUE(isa<UndefValue>(DVIs[0]->getValue(0)));
}
TEST(DbgVariableIntrinsic, EmptyMDIsKillLocation) {
@@ -229,8 +228,8 @@ TEST(DbgVariableIntrinsic, EmptyMDIsKillLocation) {
// Get the dbg.declare.
Function &F = *cast<Function>(M->getNamedValue("fun"));
- DbgVariableRecord *DbgDeclare =
- cast<DbgVariableRecord>(&*F.front().front().getDbgRecordRange().begin());
+ DbgVariableIntrinsic *DbgDeclare =
+ cast<DbgVariableIntrinsic>(&F.front().front());
// Check that this form counts as a "no location" marker.
EXPECT_TRUE(DbgDeclare->isKillLocation());
}
@@ -238,9 +237,6 @@ TEST(DbgVariableIntrinsic, EmptyMDIsKillLocation) {
// Duplicate of above test, but in DbgVariableRecord representation.
TEST(MetadataTest, DeleteInstUsedByDbgVariableRecord) {
LLVMContext C;
- bool OldDbgValueMode = UseNewDbgInfoFormat;
- UseNewDbgInfoFormat = true;
-
std::unique_ptr<Module> M = parseIR(C, R"(
define i16 @f(i16 %a) !dbg !6 {
%b = add i16 %a, 1, !dbg !11
@@ -266,7 +262,10 @@ TEST(MetadataTest, DeleteInstUsedByDbgVariableRecord) {
!11 = !DILocation(line: 1, column: 1, scope: !6)
)");
+ bool OldDbgValueMode = UseNewDbgInfoFormat;
+ UseNewDbgInfoFormat = true;
Instruction &I = *M->getFunction("f")->getEntryBlock().getFirstNonPHI();
+ M->convertToNewDbgValues();
// Find the DbgVariableRecords using %b.
SmallVector<DbgValueInst *, 2> DVIs;
@@ -288,8 +287,6 @@ TEST(MetadataTest, DeleteInstUsedByDbgVariableRecord) {
// Ensure that the order of dbg.value intrinsics returned by findDbgValues, and
// their corresponding DbgVariableRecord representation, are consistent.
TEST(MetadataTest, OrderingOfDbgVariableRecords) {
- bool OldDbgValueMode = UseNewDbgInfoFormat;
- UseNewDbgInfoFormat = false;
LLVMContext C;
std::unique_ptr<Module> M = parseIR(C, R"(
define i16 @f(i16 %a) !dbg !6 {
@@ -317,6 +314,8 @@ TEST(MetadataTest, OrderingOfDbgVariableRecords) {
!12 = !DILocalVariable(name: "bar", scope: !6, file: !1, line: 1, type: !10)
)");
+ bool OldDbgValueMode = UseNewDbgInfoFormat;
+ UseNewDbgInfoFormat = true;
Instruction &I = *M->getFunction("f")->getEntryBlock().getFirstNonPHI();
SmallVector<DbgValueInst *, 2> DVIs;
@@ -514,15 +513,14 @@ TEST(DbgAssignIntrinsicTest, replaceVariableLocationOp) {
Value *V1 = Fun.getArg(0);
Value *P1 = Fun.getArg(1);
Value *P2 = Fun.getArg(2);
- DbgVariableRecord *DbgAssign = cast<DbgVariableRecord>(
- &*Fun.front().front().getDbgRecordRange().begin());
- ASSERT_TRUE(V1 == DbgAssign->getVariableLocationOp(0));
- ASSERT_TRUE(P1 == DbgAssign->getAddress());
+ DbgAssignIntrinsic *DAI = cast<DbgAssignIntrinsic>(Fun.begin()->begin());
+ ASSERT_TRUE(V1 == DAI->getVariableLocationOp(0));
+ ASSERT_TRUE(P1 == DAI->getAddress());
#define TEST_REPLACE(Old, New, ExpectedValue, ExpectedAddr) \
- DbgAssign->replaceVariableLocationOp(Old, New); \
- EXPECT_EQ(DbgAssign->getVariableLocationOp(0), ExpectedValue); \
- EXPECT_EQ(DbgAssign->getAddress(), ExpectedAddr);
+ DAI->replaceVariableLocationOp(Old, New); \
+ EXPECT_EQ(DAI->getVariableLocationOp(0), ExpectedValue); \
+ EXPECT_EQ(DAI->getAddress(), ExpectedAddr);
// Replace address only.
TEST_REPLACE(/*Old*/ P1, /*New*/ P2, /*Value*/ V1, /*Address*/ P2);
@@ -533,8 +531,8 @@ TEST(DbgAssignIntrinsicTest, replaceVariableLocationOp) {
// Replace address only, value uses a DIArgList.
// Value = {DIArgList(V1)}, Addr = P1.
- DbgAssign->setRawLocation(DIArgList::get(C, ValueAsMetadata::get(V1)));
- DbgAssign->setExpression(DIExpression::get(
+ DAI->setRawLocation(DIArgList::get(C, ValueAsMetadata::get(V1)));
+ DAI->setExpression(DIExpression::get(
C, {dwarf::DW_OP_LLVM_arg, 0, dwarf::DW_OP_stack_value}));
TEST_REPLACE(/*Old*/ P1, /*New*/ P2, /*Value*/ V1, /*Address*/ P2);
#undef TEST_REPLACE
@@ -620,11 +618,11 @@ TEST(AssignmentTrackingTest, Utils) {
//
// Check there are two llvm.dbg.assign intrinsics linked to Alloca.
auto CheckFun1Mapping = [&Alloca]() {
- auto Markers = at::getDVRAssignmentMarkers(&Alloca);
+ auto Markers = at::getAssignmentMarkers(&Alloca);
EXPECT_TRUE(std::distance(Markers.begin(), Markers.end()) == 2);
// Check those two entries are distinct.
- DbgVariableRecord *First = *Markers.begin();
- DbgVariableRecord *Second = *std::next(Markers.begin());
+ DbgAssignIntrinsic *First = *Markers.begin();
+ DbgAssignIntrinsic *Second = *std::next(Markers.begin());
EXPECT_NE(First, Second);
// Check that we can get back to Alloca from each llvm.dbg.assign.
@@ -660,7 +658,7 @@ TEST(AssignmentTrackingTest, Utils) {
DIAssignID *Fun2ID = cast_or_null<DIAssignID>(
Fun2Alloca.getMetadata(LLVMContext::MD_DIAssignID));
EXPECT_NE(New, Fun2ID);
- auto Fun2Markers = at::getDVRAssignmentMarkers(&Fun2Alloca);
+ auto Fun2Markers = at::getAssignmentMarkers(&Fun2Alloca);
ASSERT_TRUE(std::distance(Fun2Markers.begin(), Fun2Markers.end()) == 1);
auto Fun2Insts = at::getAssignmentInsts(*Fun2Markers.begin());
ASSERT_TRUE(std::distance(Fun2Insts.begin(), Fun2Insts.end()) == 1);
@@ -669,10 +667,10 @@ TEST(AssignmentTrackingTest, Utils) {
// 3. Check that deleting dbg.assigns from a specific instruction works.
Instruction &Fun3Alloca =
*M->getFunction("fun3")->getEntryBlock().getFirstNonPHIOrDbg();
- auto Fun3Markers = at::getDVRAssignmentMarkers(&Fun3Alloca);
+ auto Fun3Markers = at::getAssignmentMarkers(&Fun3Alloca);
ASSERT_TRUE(std::distance(Fun3Markers.begin(), Fun3Markers.end()) == 1);
at::deleteAssignmentMarkers(&Fun3Alloca);
- Fun3Markers = at::getDVRAssignmentMarkers(&Fun3Alloca);
+ Fun3Markers = at::getAssignmentMarkers(&Fun3Alloca);
EXPECT_EQ(Fun3Markers.empty(), true);
// 4. Check that deleting works and applies only to the target function.
@@ -683,7 +681,7 @@ TEST(AssignmentTrackingTest, Utils) {
// llvm.dbg.assign.
EXPECT_EQ(Fun2ID, cast_or_null<DIAssignID>(
Fun2Alloca.getMetadata(LLVMContext::MD_DIAssignID)));
- EXPECT_FALSE(at::getDVRAssignmentMarkers(&Fun2Alloca).empty());
+ EXPECT_FALSE(at::getAssignmentMarkers(&Fun2Alloca).empty());
}
TEST(IRBuilder, GetSetInsertionPointWithEmptyBasicBlock) {
@@ -769,12 +767,12 @@ TEST(AssignmentTrackingTest, InstrMethods) {
// Use SetVectors to check that the attachments and markers are unique
// (another test requirement).
SetVector<Metadata *> OrigIDs;
- SetVector<DbgVariableRecord *> Markers;
+ SetVector<DbgAssignIntrinsic *> Markers;
for (const Instruction *SI : Stores) {
Metadata *ID = SI->getMetadata(LLVMContext::MD_DIAssignID);
ASSERT_TRUE(OrigIDs.insert(ID));
ASSERT_TRUE(ID != nullptr);
- auto Range = at::getDVRAssignmentMarkers(SI);
+ auto Range = at::getAssignmentMarkers(SI);
ASSERT_TRUE(std::distance(Range.begin(), Range.end()) == 1);
ASSERT_TRUE(Markers.insert(*Range.begin()));
}
@@ -867,8 +865,6 @@ TEST(AssignmentTrackingTest, InstrMethods) {
// dbg.values that have been converted to a non-instruction format.
TEST(MetadataTest, ConvertDbgToDbgVariableRecord) {
LLVMContext C;
- bool OldDbgValueMode = UseNewDbgInfoFormat;
- UseNewDbgInfoFormat = false;
std::unique_ptr<Module> M = parseIR(C, R"(
define i16 @f(i16 %a) !dbg !6 {
call void @llvm.dbg.value(metadata i16 %a, metadata !9, metadata !DIExpression()), !dbg !11
@@ -1043,14 +1039,14 @@ TEST(MetadataTest, ConvertDbgToDbgVariableRecord) {
// The record of those trailing DbgVariableRecords would dangle and cause an
// assertion failure if it lived until the end of the LLVMContext.
ExitBlock->deleteTrailingDbgRecords();
- UseNewDbgInfoFormat = OldDbgValueMode;
}
TEST(MetadataTest, DbgVariableRecordConversionRoutines) {
LLVMContext C;
- bool OldDbgValueMode = UseNewDbgInfoFormat;
- UseNewDbgInfoFormat = false;
+ // For the purpose of this test, set and un-set the command line option
+ // corresponding to UseNewDbgInfoFormat.
+ UseNewDbgInfoFormat = true;
std::unique_ptr<Module> M = parseIR(C, R"(
define i16 @f(i16 %a) !dbg !6 {
@@ -1081,11 +1077,6 @@ TEST(MetadataTest, DbgVariableRecordConversionRoutines) {
!11 = !DILocation(line: 1, column: 1, scope: !6)
)");
- // For the purpose of this test, set and un-set the command line option
- // corresponding to UseNewDbgInfoFormat, but only after parsing, to ensure
- // that the IR starts off in the old format.
- UseNewDbgInfoFormat = true;
-
// Check that the conversion routines and utilities between dbg.value
// debug-info format and DbgVariableRecords works.
Function *F = M->getFunction("f");
@@ -1190,7 +1181,7 @@ TEST(MetadataTest, DbgVariableRecordConversionRoutines) {
EXPECT_EQ(DVI2->getVariable(), DLV2);
EXPECT_EQ(DVI2->getExpression(), Expr2);
- UseNewDbgInfoFormat = OldDbgValueMode;
+ UseNewDbgInfoFormat = false;
}
} // end namespace
diff --git a/llvm/unittests/IR/IRBuilderTest.cpp b/llvm/unittests/IR/IRBuilderTest.cpp
index ff96df85812002..2001df090aed53 100644
--- a/llvm/unittests/IR/IRBuilderTest.cpp
+++ b/llvm/unittests/IR/IRBuilderTest.cpp
@@ -994,17 +994,17 @@ TEST_F(IRBuilderTest, DIBuilder) {
EXPECT_TRUE(verifyModule(*M));
};
- // Test in new-debug mode.
- EXPECT_TRUE(M->IsNewDbgInfoFormat);
+ // Test in old-debug mode.
+ EXPECT_FALSE(M->IsNewDbgInfoFormat);
RunTest();
- // Test in old-debug mode.
- // Reset the test then call convertFromNewDbgValues to flip the flag
+ // Test in new-debug mode.
+ // Reset the test then call convertToNewDbgValues to flip the flag
// on the test's Module, Function and BasicBlock.
TearDown();
SetUp();
- M->convertFromNewDbgValues();
- EXPECT_FALSE(M->IsNewDbgInfoFormat);
+ M->convertToNewDbgValues();
+ EXPECT_TRUE(M->IsNewDbgInfoFormat);
RunTest();
}
diff --git a/llvm/unittests/IR/InstructionsTest.cpp b/llvm/unittests/IR/InstructionsTest.cpp
index b6044b28629204..b47c73f0b329ae 100644
--- a/llvm/unittests/IR/InstructionsTest.cpp
+++ b/llvm/unittests/IR/InstructionsTest.cpp
@@ -25,15 +25,12 @@
#include "llvm/IR/Module.h"
#include "llvm/IR/NoFolder.h"
#include "llvm/IR/Operator.h"
-#include "llvm/Support/CommandLine.h"
#include "llvm/Support/SourceMgr.h"
#include "llvm-c/Core.h"
#include "gmock/gmock-matchers.h"
#include "gtest/gtest.h"
#include <memory>
-extern llvm::cl::opt<bool> UseNewDbgInfoFormat;
-
namespace llvm {
namespace {
@@ -1463,8 +1460,6 @@ TEST(InstructionsTest, GetSplat) {
TEST(InstructionsTest, SkipDebug) {
LLVMContext C;
- bool OldDbgValueMode = UseNewDbgInfoFormat;
- UseNewDbgInfoFormat = false;
std::unique_ptr<Module> M = parseIR(C,
R"(
declare void @llvm.dbg.value(metadata, metadata, metadata)
@@ -1500,7 +1495,6 @@ TEST(InstructionsTest, SkipDebug) {
// After the terminator, there are no non-debug instructions.
EXPECT_EQ(nullptr, Term->getNextNonDebugInstruction());
- UseNewDbgInfoFormat = OldDbgValueMode;
}
TEST(InstructionsTest, PhiMightNotBeFPMathOperator) {
diff --git a/llvm/unittests/IR/ValueTest.cpp b/llvm/unittests/IR/ValueTest.cpp
index 33a86d510d45cb..246c2fc7fe4063 100644
--- a/llvm/unittests/IR/ValueTest.cpp
+++ b/llvm/unittests/IR/ValueTest.cpp
@@ -13,7 +13,6 @@
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/ModuleSlotTracker.h"
-#include "llvm/Support/CommandLine.h"
#include "llvm/Support/SourceMgr.h"
#include "gtest/gtest.h"
using namespace llvm;
@@ -256,8 +255,6 @@ TEST(ValueTest, getLocalSlotDeath) {
TEST(ValueTest, replaceUsesOutsideBlock) {
// Check that Value::replaceUsesOutsideBlock(New, BB) replaces uses outside
// BB, including dbg.* uses of MetadataAsValue(ValueAsMetadata(this)).
- bool OldDbgValueMode = UseNewDbgInfoFormat;
- UseNewDbgInfoFormat = false;
const auto *IR = R"(
define i32 @f() !dbg !6 {
entry:
@@ -318,7 +315,6 @@ TEST(ValueTest, replaceUsesOutsideBlock) {
// These users are outside Entry so should be changed.
ASSERT_TRUE(ExitDbg->getValue(0) == cast<Value>(B));
ASSERT_TRUE(Ret->getOperand(0) == cast<Value>(B));
- UseNewDbgInfoFormat = OldDbgValueMode;
}
TEST(ValueTest, replaceUsesOutsideBlockDbgVariableRecord) {
@@ -363,6 +359,10 @@ TEST(ValueTest, replaceUsesOutsideBlockDbgVariableRecord) {
if (!M)
Err.print("ValueTest", errs());
+ bool OldDbgValueMode = UseNewDbgInfoFormat;
+ UseNewDbgInfoFormat = true;
+ M->convertToNewDbgValues();
+
auto GetNext = [](auto *I) { return &*++I->getIterator(); };
Function *F = M->getFunction("f");
@@ -389,6 +389,7 @@ TEST(ValueTest, replaceUsesOutsideBlockDbgVariableRecord) {
EXPECT_TRUE(DVR1->getVariableLocationOp(0) == cast<Value>(A));
// These users are outside Entry so should be changed.
EXPECT_TRUE(DVR2->getVariableLocationOp(0) == cast<Value>(B));
+ UseNewDbgInfoFormat = OldDbgValueMode;
}
} // end anonymous namespace
diff --git a/llvm/unittests/Transforms/Utils/CloningTest.cpp b/llvm/unittests/Transforms/Utils/CloningTest.cpp
index 6f4e860d604680..025771f07ce5d4 100644
--- a/llvm/unittests/Transforms/Utils/CloningTest.cpp
+++ b/llvm/unittests/Transforms/Utils/CloningTest.cpp
@@ -844,9 +844,8 @@ TEST(CloneFunction, CloneFunctionWithInlinedSubprograms) {
EXPECT_FALSE(verifyModule(*ImplModule, &errs()));
// Check that DILexicalBlock of inlined function was not cloned.
- auto DbgDeclareI = Func->begin()->begin()->getDbgRecordRange().begin();
- auto ClonedDbgDeclareI =
- ClonedFunc->begin()->begin()->getDbgRecordRange().begin();
+ auto DbgDeclareI = Func->begin()->begin();
+ auto ClonedDbgDeclareI = ClonedFunc->begin()->begin();
const DebugLoc &DbgLoc = DbgDeclareI->getDebugLoc();
const DebugLoc &ClonedDbgLoc = ClonedDbgDeclareI->getDebugLoc();
EXPECT_NE(DbgLoc.get(), ClonedDbgLoc.get());
diff --git a/llvm/unittests/Transforms/Utils/LocalTest.cpp b/llvm/unittests/Transforms/Utils/LocalTest.cpp
index b871603328b202..a0119ed5159d5a 100644
--- a/llvm/unittests/Transforms/Utils/LocalTest.cpp
+++ b/llvm/unittests/Transforms/Utils/LocalTest.cpp
@@ -7,7 +7,6 @@
//===----------------------------------------------------------------------===//
#include "llvm/Transforms/Utils/Local.h"
-#include "llvm/ADT/ScopeExit.h"
#include "llvm/Analysis/DomTreeUpdater.h"
#include "llvm/Analysis/InstructionSimplify.h"
#include "llvm/Analysis/PostDominators.h"
@@ -27,27 +26,6 @@
using namespace llvm;
-extern llvm::cl::opt<bool> UseNewDbgInfoFormat;
-extern cl::opt<cl::boolOrDefault> PreserveInputDbgFormat;
-extern bool WriteNewDbgInfoFormatToBitcode;
-extern cl::opt<bool> WriteNewDbgInfoFormat;
-
-// Backup all of the existing settings that may be modified when
-// PreserveInputDbgFormat=true, so that when the test is finished we return them
-// (and the "preserve" setting) to their original values.
-static auto SaveDbgInfoFormat() {
- return make_scope_exit(
- [OldPreserveInputDbgFormat = PreserveInputDbgFormat.getValue(),
- OldUseNewDbgInfoFormat = UseNewDbgInfoFormat.getValue(),
- OldWriteNewDbgInfoFormatToBitcode = WriteNewDbgInfoFormatToBitcode,
- OldWriteNewDbgInfoFormat = WriteNewDbgInfoFormat.getValue()] {
- PreserveInputDbgFormat = OldPreserveInputDbgFormat;
- UseNewDbgInfoFormat = OldUseNewDbgInfoFormat;
- WriteNewDbgInfoFormatToBitcode = OldWriteNewDbgInfoFormatToBitcode;
- WriteNewDbgInfoFormat = OldWriteNewDbgInfoFormat;
- });
-}
-
TEST(Local, RecursivelyDeleteDeadPHINodes) {
LLVMContext C;
@@ -138,11 +116,6 @@ static std::unique_ptr<Module> parseIR(LLVMContext &C, const char *IR) {
TEST(Local, ReplaceDbgDeclare) {
LLVMContext C;
- // FIXME: PreserveInputDbgFormat is set to true because this test has
- // been written to expect debug intrinsics rather than debug records; use the
- // intrinsic format until we update the test checks.
- auto SettingGuard = SaveDbgInfoFormat();
- PreserveInputDbgFormat = cl::boolOrDefault::BOU_TRUE;
// Original C source to get debug info for a local variable:
// void f() { int x; }
@@ -520,14 +493,6 @@ struct SalvageDebugInfoTest : ::testing::Test {
Function *F = nullptr;
void SetUp() override {
- // FIXME: PreserveInputDbgFormat is set to true because this test has
- // been written to expect debug intrinsics rather than debug records; use
- // the intrinsic format until we update the test checks. Note that the
- // temporary setting of this flag only needs to cover the parsing step, not
- // the test body itself.
- auto SettingGuard = SaveDbgInfoFormat();
- PreserveInputDbgFormat = cl::boolOrDefault::BOU_TRUE;
-
M = parseIR(C,
R"(
define void @f() !dbg !8 {
@@ -626,12 +591,6 @@ TEST_F(SalvageDebugInfoTest, RecursiveBlockSimplification) {
TEST(Local, wouldInstructionBeTriviallyDead) {
LLVMContext Ctx;
- // FIXME: PreserveInputDbgFormat is set to true because this test has
- // been written to expect debug intrinsics rather than debug records.
- // TODO: This test doesn't have a DbgRecord equivalent form so delete
- // it when debug intrinsics are removed.
- auto SettingGuard = SaveDbgInfoFormat();
- PreserveInputDbgFormat = cl::boolOrDefault::BOU_TRUE;
std::unique_ptr<Module> M = parseIR(Ctx,
R"(
define dso_local void @fun() local_unnamed_addr #0 !dbg !9 {
@@ -721,11 +680,6 @@ TEST(Local, ChangeToUnreachable) {
TEST(Local, FindDbgUsers) {
LLVMContext Ctx;
- // FIXME: PreserveInputDbgFormat is set to true because this test has
- // been written to expect debug intrinsics rather than debug records; use the
- // intrinsic format until we update the test checks.
- auto SettingGuard = SaveDbgInfoFormat();
- PreserveInputDbgFormat = cl::boolOrDefault::BOU_TRUE;
std::unique_ptr<Module> M = parseIR(Ctx,
R"(
define dso_local void @fun(ptr %a) #0 !dbg !11 {
@@ -814,6 +768,9 @@ TEST(Local, FindDbgRecords) {
bool BrokenDebugInfo = true;
verifyModule(*M, &errs(), &BrokenDebugInfo);
ASSERT_FALSE(BrokenDebugInfo);
+ bool NewDbgInfoFormat = UseNewDbgInfoFormat;
+ UseNewDbgInfoFormat = true;
+ M->convertToNewDbgValues();
Function &Fun = *cast<Function>(M->getNamedValue("fun"));
Value *Arg = Fun.getArg(0);
@@ -833,17 +790,13 @@ TEST(Local, FindDbgRecords) {
findDbgValues(Vals, Arg, &Records);
EXPECT_EQ(Vals.size(), 0u);
EXPECT_EQ(Records.size(), 1u);
+ UseNewDbgInfoFormat = NewDbgInfoFormat;
}
TEST(Local, ReplaceAllDbgUsesWith) {
using namespace llvm::dwarf;
LLVMContext Ctx;
- // FIXME: PreserveInputDbgFormat is set to true because this test has
- // been written to expect debug intrinsics rather than debug records; use the
- // intrinsic format until we update the test checks.
- auto SettingGuard = SaveDbgInfoFormat();
- PreserveInputDbgFormat = cl::boolOrDefault::BOU_TRUE;
// Note: The datalayout simulates Darwin/x86_64.
std::unique_ptr<Module> M = parseIR(Ctx,
@@ -1392,11 +1345,6 @@ TEST(Local, ExpressionForConstant) {
TEST(Local, ReplaceDbgVariableRecord) {
LLVMContext C;
- // FIXME: PreserveInputDbgFormat is set to true because this test has
- // been written to expect debug intrinsics rather than debug records; use the
- // intrinsic format until we update the test checks.
- auto SettingGuard = SaveDbgInfoFormat();
- PreserveInputDbgFormat = cl::boolOrDefault::BOU_TRUE;
// Test that RAUW also replaces the operands of DbgVariableRecord objects,
// i.e. non-instruction stored debugging information.
More information about the llvm-commits
mailing list