mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2025-05-14 11:06:11 +00:00
88aa158bd7
[Debugify][Original DI] Test dbg var loc preservation
This is an improvement of [0]. This adds checking of
original llvm.dbg.values()/declares() instructions in
optimizations.
We have picked a real issue that has been found with
this (actually, picked one variable location missing
from [1] and resolved the issue), and the result is
the fix for that -- D100844.
Before applying the D100844, using the options from [0]
(but with this patch applied) on the compilation of GDB 7.11,
the final HTML report for the debug-info issues can be found
at [1] (please scroll down, and look for
"Summary of Variable Location Bugs"). After applying
the D100844, the numbers has improved a bit -- please take
a look into [2].
[0] https://llvm.org/docs/HowToUpdateDebugInfo.html#\
test-original-debug-info-preservation-in-optimizations
[1] https://djolertrk.github.io/di-check-before-adce-fix/
[2] https://djolertrk.github.io/di-check-after-adce-fix/
Differential Revision: https://reviews.llvm.org/D100845
The Unit test was failing because the pass from the test that
modifies the IR, in its runOnFunction() didn't return 'true',
so the expensive-check configuration triggered an assertion.
265 lines
9.9 KiB
C++
265 lines
9.9 KiB
C++
//===- DebugifyTest.cpp - Debugify unit tests -----------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/ADT/SmallVector.h"
|
|
#include "llvm/AsmParser/Parser.h"
|
|
#include "llvm/IR/DebugInfoMetadata.h"
|
|
#include "llvm/IR/IntrinsicInst.h"
|
|
#include "llvm/IR/LegacyPassManager.h"
|
|
#include "llvm/Support/SourceMgr.h"
|
|
#include "llvm/Transforms/Utils/Debugify.h"
|
|
#include "gtest/gtest.h"
|
|
|
|
using namespace llvm;
|
|
|
|
static std::unique_ptr<Module> parseIR(LLVMContext &C, const char *IR) {
|
|
SMDiagnostic Err;
|
|
std::unique_ptr<Module> Mod = parseAssemblyString(IR, Err, C);
|
|
if (!Mod)
|
|
Err.print("DebugifyTest", errs());
|
|
return Mod;
|
|
}
|
|
|
|
namespace llvm {
|
|
void initializeDebugInfoDropPass(PassRegistry &);
|
|
void initializeDebugInfoDummyAnalysisPass(PassRegistry &);
|
|
|
|
namespace {
|
|
struct DebugInfoDrop : public FunctionPass {
|
|
static char ID;
|
|
bool runOnFunction(Function &F) override {
|
|
// Drop DISubprogram.
|
|
F.setSubprogram(nullptr);
|
|
for (BasicBlock &BB : F) {
|
|
// Remove debug locations.
|
|
for (Instruction &I : BB)
|
|
I.setDebugLoc(DebugLoc());
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void getAnalysisUsage(AnalysisUsage &AU) const override {
|
|
AU.setPreservesCFG();
|
|
}
|
|
|
|
DebugInfoDrop() : FunctionPass(ID) {}
|
|
};
|
|
|
|
struct DebugValueDrop : public FunctionPass {
|
|
static char ID;
|
|
bool runOnFunction(Function &F) override {
|
|
SmallVector<DbgVariableIntrinsic *, 4> Dbgs;
|
|
for (BasicBlock &BB : F) {
|
|
// Remove dbg var intrinsics.
|
|
for (Instruction &I : BB) {
|
|
if (auto *DVI = dyn_cast<DbgVariableIntrinsic>(&I))
|
|
Dbgs.push_back(DVI);
|
|
}
|
|
}
|
|
|
|
for (auto &I : Dbgs)
|
|
I->eraseFromParent();
|
|
|
|
return true;
|
|
}
|
|
|
|
void getAnalysisUsage(AnalysisUsage &AU) const override {
|
|
AU.setPreservesCFG();
|
|
}
|
|
|
|
DebugValueDrop() : FunctionPass(ID) {}
|
|
};
|
|
|
|
struct DebugInfoDummyAnalysis : public FunctionPass {
|
|
static char ID;
|
|
bool runOnFunction(Function &F) override {
|
|
// Do nothing, so debug info stays untouched.
|
|
return false;
|
|
}
|
|
void getAnalysisUsage(AnalysisUsage &AU) const override {
|
|
AU.setPreservesAll();
|
|
}
|
|
|
|
DebugInfoDummyAnalysis() : FunctionPass(ID) {}
|
|
};
|
|
}
|
|
|
|
char DebugInfoDrop::ID = 0;
|
|
char DebugValueDrop::ID = 0;
|
|
char DebugInfoDummyAnalysis::ID = 0;
|
|
|
|
TEST(DebugInfoDrop, DropOriginalDebugInfo) {
|
|
LLVMContext C;
|
|
std::unique_ptr<Module> M = parseIR(C, R"(
|
|
define i16 @f(i16 %a) !dbg !6 {
|
|
%b = add i16 %a, 1, !dbg !11
|
|
call void @llvm.dbg.value(metadata i16 %b, metadata !9, metadata !DIExpression()), !dbg !11
|
|
ret i16 0, !dbg !11
|
|
}
|
|
declare void @llvm.dbg.value(metadata, metadata, metadata)
|
|
|
|
!llvm.dbg.cu = !{!0}
|
|
!llvm.module.flags = !{!5}
|
|
|
|
!0 = distinct !DICompileUnit(language: DW_LANG_C, file: !1, producer: "debugify", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
|
|
!1 = !DIFile(filename: "t.ll", directory: "/")
|
|
!2 = !{}
|
|
!5 = !{i32 2, !"Debug Info Version", i32 3}
|
|
!6 = distinct !DISubprogram(name: "f", linkageName: "f", scope: null, file: !1, line: 1, type: !7, scopeLine: 1, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !8)
|
|
!7 = !DISubroutineType(types: !2)
|
|
!8 = !{!9}
|
|
!9 = !DILocalVariable(name: "b", scope: !6, file: !1, line: 1, type: !10)
|
|
!10 = !DIBasicType(name: "ty16", size: 16, encoding: DW_ATE_unsigned)
|
|
!11 = !DILocation(line: 1, column: 1, scope: !6)
|
|
)");
|
|
|
|
DebugInfoDrop *P = new DebugInfoDrop();
|
|
|
|
DebugInfoPerPassMap DIPreservationMap;
|
|
DebugifyCustomPassManager Passes;
|
|
Passes.setDIPreservationMap(DIPreservationMap);
|
|
Passes.add(createDebugifyModulePass(DebugifyMode::OriginalDebugInfo, "",
|
|
&(Passes.getDebugInfoPerPassMap())));
|
|
Passes.add(P);
|
|
Passes.add(createCheckDebugifyModulePass(false, "", nullptr,
|
|
DebugifyMode::OriginalDebugInfo,
|
|
&(Passes.getDebugInfoPerPassMap())));
|
|
|
|
testing::internal::CaptureStderr();
|
|
Passes.run(*M);
|
|
|
|
std::string StdOut = testing::internal::GetCapturedStderr();
|
|
|
|
std::string ErrorForSP = "ERROR: dropped DISubprogram of";
|
|
std::string WarningForLoc = "WARNING: dropped DILocation of";
|
|
std::string FinalResult = "CheckModuleDebugify (original debuginfo): FAIL";
|
|
|
|
EXPECT_TRUE(StdOut.find(ErrorForSP) != std::string::npos);
|
|
EXPECT_TRUE(StdOut.find(WarningForLoc) != std::string::npos);
|
|
EXPECT_TRUE(StdOut.find(FinalResult) != std::string::npos);
|
|
}
|
|
|
|
TEST(DebugValueDrop, DropOriginalDebugValues) {
|
|
LLVMContext C;
|
|
std::unique_ptr<Module> M = parseIR(C, R"(
|
|
define i16 @f(i16 %a) !dbg !6 {
|
|
%b = add i16 %a, 1, !dbg !11
|
|
call void @llvm.dbg.value(metadata i16 %b, metadata !9, metadata !DIExpression()), !dbg !11
|
|
ret i16 0, !dbg !11
|
|
}
|
|
declare void @llvm.dbg.value(metadata, metadata, metadata)
|
|
|
|
!llvm.dbg.cu = !{!0}
|
|
!llvm.module.flags = !{!5}
|
|
|
|
!0 = distinct !DICompileUnit(language: DW_LANG_C, file: !1, producer: "debugify", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
|
|
!1 = !DIFile(filename: "t.ll", directory: "/")
|
|
!2 = !{}
|
|
!5 = !{i32 2, !"Debug Info Version", i32 3}
|
|
!6 = distinct !DISubprogram(name: "f", linkageName: "f", scope: null, file: !1, line: 1, type: !7, scopeLine: 1, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !8)
|
|
!7 = !DISubroutineType(types: !2)
|
|
!8 = !{!9}
|
|
!9 = !DILocalVariable(name: "b", scope: !6, file: !1, line: 1, type: !10)
|
|
!10 = !DIBasicType(name: "ty16", size: 16, encoding: DW_ATE_unsigned)
|
|
!11 = !DILocation(line: 1, column: 1, scope: !6)
|
|
)");
|
|
|
|
DebugValueDrop *P = new DebugValueDrop();
|
|
|
|
DebugInfoPerPassMap DIPreservationMap;
|
|
DebugifyCustomPassManager Passes;
|
|
Passes.setDIPreservationMap(DIPreservationMap);
|
|
Passes.add(createDebugifyModulePass(DebugifyMode::OriginalDebugInfo, "",
|
|
&(Passes.getDebugInfoPerPassMap())));
|
|
Passes.add(P);
|
|
Passes.add(createCheckDebugifyModulePass(false, "", nullptr,
|
|
DebugifyMode::OriginalDebugInfo,
|
|
&(Passes.getDebugInfoPerPassMap())));
|
|
|
|
testing::internal::CaptureStderr();
|
|
Passes.run(*M);
|
|
|
|
std::string StdOut = testing::internal::GetCapturedStderr();
|
|
|
|
std::string ErrorForSP = "ERROR: dropped DISubprogram of";
|
|
std::string WarningForLoc = "WARNING: dropped DILocation of";
|
|
std::string WarningForVars = "WARNING: drops dbg.value()/dbg.declare() for";
|
|
std::string FinalResult = "CheckModuleDebugify (original debuginfo): FAIL";
|
|
|
|
EXPECT_TRUE(StdOut.find(ErrorForSP) == std::string::npos);
|
|
EXPECT_TRUE(StdOut.find(WarningForLoc) == std::string::npos);
|
|
EXPECT_TRUE(StdOut.find(WarningForVars) != std::string::npos);
|
|
EXPECT_TRUE(StdOut.find(FinalResult) != std::string::npos);
|
|
}
|
|
|
|
TEST(DebugInfoDummyAnalysis, PreserveOriginalDebugInfo) {
|
|
LLVMContext C;
|
|
std::unique_ptr<Module> M = parseIR(C, R"(
|
|
define i32 @g(i32 %b) !dbg !6 {
|
|
%c = add i32 %b, 1, !dbg !11
|
|
call void @llvm.dbg.value(metadata i32 %c, metadata !9, metadata !DIExpression()), !dbg !11
|
|
ret i32 1, !dbg !11
|
|
}
|
|
declare void @llvm.dbg.value(metadata, metadata, metadata)
|
|
|
|
!llvm.dbg.cu = !{!0}
|
|
!llvm.module.flags = !{!5}
|
|
|
|
!0 = distinct !DICompileUnit(language: DW_LANG_C, file: !1, producer: "debugify", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
|
|
!1 = !DIFile(filename: "test.ll", directory: "/")
|
|
!2 = !{}
|
|
!5 = !{i32 2, !"Debug Info Version", i32 3}
|
|
!6 = distinct !DISubprogram(name: "f", linkageName: "f", scope: null, file: !1, line: 1, type: !7, scopeLine: 1, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !8)
|
|
!7 = !DISubroutineType(types: !2)
|
|
!8 = !{!9}
|
|
!9 = !DILocalVariable(name: "c", scope: !6, file: !1, line: 1, type: !10)
|
|
!10 = !DIBasicType(name: "ty32", size: 32, encoding: DW_ATE_unsigned)
|
|
!11 = !DILocation(line: 1, column: 1, scope: !6)
|
|
)");
|
|
|
|
DebugInfoDummyAnalysis *P = new DebugInfoDummyAnalysis();
|
|
|
|
DebugInfoPerPassMap DIPreservationMap;
|
|
DebugifyCustomPassManager Passes;
|
|
Passes.setDIPreservationMap(DIPreservationMap);
|
|
Passes.add(createDebugifyModulePass(DebugifyMode::OriginalDebugInfo, "",
|
|
&(Passes.getDebugInfoPerPassMap())));
|
|
Passes.add(P);
|
|
Passes.add(createCheckDebugifyModulePass(false, "", nullptr,
|
|
DebugifyMode::OriginalDebugInfo,
|
|
&(Passes.getDebugInfoPerPassMap())));
|
|
|
|
testing::internal::CaptureStderr();
|
|
Passes.run(*M);
|
|
|
|
std::string StdOut = testing::internal::GetCapturedStderr();
|
|
|
|
std::string ErrorForSP = "ERROR: dropped DISubprogram of";
|
|
std::string WarningForLoc = "WARNING: dropped DILocation of";
|
|
std::string WarningForVars = "WARNING: drops dbg.value()/dbg.declare() for";
|
|
std::string FinalResult = "CheckModuleDebugify (original debuginfo): PASS";
|
|
|
|
EXPECT_TRUE(StdOut.find(ErrorForSP) == std::string::npos);
|
|
EXPECT_TRUE(StdOut.find(WarningForLoc) == std::string::npos);
|
|
EXPECT_TRUE(StdOut.find(WarningForVars) == std::string::npos);
|
|
EXPECT_TRUE(StdOut.find(FinalResult) != std::string::npos);
|
|
}
|
|
|
|
} // end namespace llvm
|
|
|
|
INITIALIZE_PASS_BEGIN(DebugInfoDrop, "debuginfodroppass", "debuginfodroppass",
|
|
false, false)
|
|
INITIALIZE_PASS_END(DebugInfoDrop, "debuginfodroppass", "debuginfodroppass", false,
|
|
false)
|
|
|
|
INITIALIZE_PASS_BEGIN(DebugInfoDummyAnalysis, "debuginfodummyanalysispass",
|
|
"debuginfodummyanalysispass", false, false)
|
|
INITIALIZE_PASS_END(DebugInfoDummyAnalysis, "debuginfodummyanalysispass",
|
|
"debuginfodummyanalysispass", false, false)
|