Skip to content

Commit fc4a352

Browse files
rastogishubhamrastogishubham
committed
Gather dropped debug info variable statistics.
This patch adds the class DroppedVariableStats to StandardInstrumentations which gathers information on whether debug information was dropped by an optimization pass in llvm. This runs on every Function-level and Module-level IR pass.
1 parent d617371 commit fc4a352

File tree

5 files changed

+738
-3
lines changed

5 files changed

+738
-3
lines changed

‎llvm/include/llvm/Passes/StandardInstrumentations.h

Lines changed: 80 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -21,6 +21,7 @@
2121
#include "llvm/ADT/StringSet.h"
2222
#include "llvm/CodeGen/MachineBasicBlock.h"
2323
#include "llvm/IR/BasicBlock.h"
24+
#include "llvm/IR/DebugInfoMetadata.h"
2425
#include "llvm/IR/OptBisect.h"
2526
#include "llvm/IR/PassTimingInfo.h"
2627
#include "llvm/IR/ValueHandle.h"
@@ -578,6 +579,84 @@ class PrintCrashIRInstrumentation {
578579
static void SignalHandler(void *);
579580
};
580581

582+
/// A class to collect and print dropped debug information variable statistics.
583+
/// After every LLVM IR pass is run, it will print how many #dbg_values were
584+
/// dropped due to that pass.
585+
class DroppedVariableStats {
586+
public:
587+
DroppedVariableStats(bool DroppedVarStatsEnabled) {
588+
if (DroppedVarStatsEnabled)
589+
llvm::outs()
590+
<< "Pass Level, Pass Name, Num of Dropped Variables, Func or "
591+
"Module Name\n";
592+
};
593+
// We intend this to be unique per-compilation, thus no copies.
594+
DroppedVariableStats(const DroppedVariableStats &) = delete;
595+
void operator=(const DroppedVariableStats &) = delete;
596+
597+
void registerCallbacks(PassInstrumentationCallbacks &PIC);
598+
void runBeforePass(StringRef PassID, Any IR);
599+
void runAfterPass(StringRef PassID, Any IR, const PreservedAnalyses &PA);
600+
void runAfterPassInvalidated(StringRef PassID, const PreservedAnalyses &PA);
601+
bool getPassDroppedVariables() { return PassDroppedVariables; }
602+
603+
private:
604+
bool PassDroppedVariables = false;
605+
/// VarID is a unique key that represents a #dbg_value
606+
using VarID =
607+
std::tuple<const DIScope *, const DIScope *, const DILocalVariable *>;
608+
609+
struct DebugVariables {
610+
/// Maps the name of an llvm::Function to a DenseSet of VarIDs before an
611+
/// optimization pass has run.
612+
DenseMap<const Function *, DenseSet<VarID>> DebugVariablesBefore;
613+
/// Maps the name of an llvm::Function to a DenseSet of VarIDs after an
614+
/// optimization pass has run.
615+
DenseMap<const Function *, DenseSet<VarID>> DebugVariablesAfter;
616+
};
617+
618+
/// A stack of DebugVariables for every pass. A stack is used because an
619+
/// optimization pass can call other passes.
620+
SmallVector<DebugVariables> DebugVariablesStack;
621+
622+
/// A DenseSet tracking whether a scope was visited before.
623+
DenseSet<const DIScope *> VisitedScope;
624+
/// A stack of DenseMaps, which map the name of an llvm::Function to a
625+
/// DenseMap of VarIDs and their inlinedAt locations before an optimization
626+
/// pass has run.
627+
SmallVector<DenseMap<StringRef, DenseMap<VarID, DILocation *>>> InlinedAts;
628+
629+
/// Iterate over all Functions in a Module and report any dropped debug
630+
/// information. Will call calculateDroppedVarStatsOnFunction on every
631+
/// Function.
632+
void calculateDroppedVarStatsOnModule(const Module *M, StringRef PassID,
633+
std::string FuncOrModName,
634+
std::string PassLevel);
635+
/// Iterate over all Instructions in a Function and report any dropped debug
636+
/// information.
637+
void calculateDroppedVarStatsOnFunction(const Function *F, StringRef PassID,
638+
std::string FuncOrModName,
639+
std::string PassLevel);
640+
/// Populate DebugVariablesBefore, DebugVariablesAfter, InlinedAts before or
641+
/// after a pass has run to facilitate dropped variable calculation for an
642+
/// llvm::Function.
643+
void runOnFunction(const Function *F, bool Before);
644+
/// Populate DebugVariablesBefore, DebugVariablesAfter, InlinedAts before or
645+
/// after a pass has run to facilitate dropped variable calculation for an
646+
/// llvm::Module. Calls runOnFunction on every Function in the Module.
647+
void runOnModule(const Module *M, bool Before);
648+
/// Remove a dropped #dbg_value VarID from all Sets in the
649+
/// DroppedVariablesBefore stack.
650+
void removeVarFromAllSets(VarID Var, const Function *F);
651+
/// Return true if \p Scope is the same as \p DbgValScope or a child scope of
652+
/// \p DbgValScope, return false otherwise.
653+
bool isScopeChildOfOrEqualTo(DIScope *Scope, const DIScope *DbgValScope);
654+
/// Return true if \p InlinedAt is the same as \p DbgValInlinedAt or part of
655+
/// the InlinedAt chain, return false otherwise.
656+
bool isInlinedAtChildOfOrEqualTo(const DILocation *InlinedAt,
657+
const DILocation *DbgValInlinedAt);
658+
};
659+
581660
/// This class provides an interface to register all the standard pass
582661
/// instrumentations and manages their state (if any).
583662
class StandardInstrumentations {
@@ -595,6 +674,7 @@ class StandardInstrumentations {
595674
PrintCrashIRInstrumentation PrintCrashIR;
596675
IRChangedTester ChangeTester;
597676
VerifyInstrumentation Verify;
677+
DroppedVariableStats DroppedStats;
598678

599679
bool VerifyEach;
600680

‎llvm/lib/Passes/StandardInstrumentations.cpp

Lines changed: 186 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -24,6 +24,8 @@
2424
#include "llvm/CodeGen/MachineVerifier.h"
2525
#include "llvm/IR/Constants.h"
2626
#include "llvm/IR/Function.h"
27+
#include "llvm/IR/InstIterator.h"
28+
#include "llvm/IR/IntrinsicInst.h"
2729
#include "llvm/IR/Module.h"
2830
#include "llvm/IR/PassInstrumentation.h"
2931
#include "llvm/IR/PassManager.h"
@@ -138,6 +140,11 @@ static cl::opt<std::string> IRDumpDirectory(
138140
"files in this directory rather than written to stderr"),
139141
cl::Hidden, cl::value_desc("filename"));
140142

143+
static cl::opt<bool>
144+
DroppedVarStats("dropped-variable-stats", cl::Hidden,
145+
cl::desc("Dump dropped debug variables stats"),
146+
cl::init(false));
147+
141148
template <typename IRUnitT> static const IRUnitT *unwrapIR(Any IR) {
142149
const IRUnitT **IRPtr = llvm::any_cast<const IRUnitT *>(&IR);
143150
return IRPtr ? *IRPtr : nullptr;
@@ -2445,16 +2452,16 @@ void DotCfgChangeReporter::registerCallbacks(
24452452
StandardInstrumentations::StandardInstrumentations(
24462453
LLVMContext &Context, bool DebugLogging, bool VerifyEach,
24472454
PrintPassOptions PrintPassOpts)
2448-
: PrintPass(DebugLogging, PrintPassOpts),
2449-
OptNone(DebugLogging),
2455+
: PrintPass(DebugLogging, PrintPassOpts), OptNone(DebugLogging),
24502456
OptPassGate(Context),
24512457
PrintChangedIR(PrintChanged == ChangePrinter::Verbose),
24522458
PrintChangedDiff(PrintChanged == ChangePrinter::DiffVerbose ||
24532459
PrintChanged == ChangePrinter::ColourDiffVerbose,
24542460
PrintChanged == ChangePrinter::ColourDiffVerbose ||
24552461
PrintChanged == ChangePrinter::ColourDiffQuiet),
24562462
WebsiteChangeReporter(PrintChanged == ChangePrinter::DotCfgVerbose),
2457-
Verify(DebugLogging), VerifyEach(VerifyEach) {}
2463+
Verify(DebugLogging), DroppedStats(DroppedVarStats),
2464+
VerifyEach(VerifyEach) {}
24582465

24592466
PrintCrashIRInstrumentation *PrintCrashIRInstrumentation::CrashReporter =
24602467
nullptr;
@@ -2514,6 +2521,181 @@ void PrintCrashIRInstrumentation::registerCallbacks(
25142521
});
25152522
}
25162523

2524+
void DroppedVariableStats::registerCallbacks(
2525+
PassInstrumentationCallbacks &PIC) {
2526+
if (!DroppedVarStats)
2527+
return;
2528+
2529+
PIC.registerBeforeNonSkippedPassCallback(
2530+
[this](StringRef P, Any IR) { return this->runBeforePass(P, IR); });
2531+
PIC.registerAfterPassCallback(
2532+
[this](StringRef P, Any IR, const PreservedAnalyses &PA) {
2533+
return this->runAfterPass(P, IR, PA);
2534+
});
2535+
PIC.registerAfterPassInvalidatedCallback(
2536+
[this](StringRef P, const PreservedAnalyses &PA) {
2537+
return this->runAfterPassInvalidated(P, PA);
2538+
});
2539+
}
2540+
2541+
void DroppedVariableStats::runBeforePass(StringRef PassID, Any IR) {
2542+
DebugVariablesStack.push_back(
2543+
{DenseMap<const Function *, DenseSet<VarID>>(),
2544+
DenseMap<const Function *, DenseSet<VarID>>()});
2545+
InlinedAts.push_back(DenseMap<StringRef, DenseMap<VarID, DILocation *>>());
2546+
if (auto *M = unwrapIR<Module>(IR))
2547+
return this->runOnModule(M, true);
2548+
if (auto *F = unwrapIR<Function>(IR))
2549+
return this->runOnFunction(F, true);
2550+
return;
2551+
}
2552+
2553+
void DroppedVariableStats::runOnFunction(const Function *F, bool Before) {
2554+
auto &DebugVariables = DebugVariablesStack.back();
2555+
auto &VarIDMap = (Before ? DebugVariables.DebugVariablesBefore
2556+
: DebugVariables.DebugVariablesAfter);
2557+
auto &InlinedAtsMap = InlinedAts.back();
2558+
auto FuncName = F->getName();
2559+
if (Before)
2560+
InlinedAtsMap.try_emplace(FuncName, DenseMap<VarID, DILocation *>());
2561+
VarIDMap.try_emplace(F, DenseSet<VarID>());
2562+
auto &VarIDs = VarIDMap[F];
2563+
for (const auto &I : instructions(F)) {
2564+
for (DbgRecord &DR : I.getDbgRecordRange()) {
2565+
if (auto *Dbg = dyn_cast<DbgVariableRecord>(&DR)) {
2566+
auto *DbgVar = Dbg->getVariable();
2567+
auto DbgLoc = DR.getDebugLoc();
2568+
VarID Key{DbgVar->getScope(), DbgLoc->getInlinedAtScope(), DbgVar};
2569+
VarIDs.insert(Key);
2570+
if (Before)
2571+
InlinedAtsMap[FuncName].try_emplace(Key, DbgLoc.getInlinedAt());
2572+
}
2573+
}
2574+
}
2575+
}
2576+
2577+
void DroppedVariableStats::runOnModule(const Module *M, bool Before) {
2578+
for (auto &F : *M)
2579+
runOnFunction(&F, Before);
2580+
}
2581+
2582+
void DroppedVariableStats::removeVarFromAllSets(VarID Var, const Function *F) {
2583+
// Do not remove Var from the last element, it will be popped from the stack.
2584+
for (auto &DebugVariables : llvm::drop_end(DebugVariablesStack))
2585+
DebugVariables.DebugVariablesBefore[F].erase(Var);
2586+
}
2587+
2588+
void DroppedVariableStats::calculateDroppedVarStatsOnModule(
2589+
const Module *M, StringRef PassID, std::string FuncOrModName,
2590+
std::string PassLevel) {
2591+
for (auto &F : *M) {
2592+
calculateDroppedVarStatsOnFunction(&F, PassID, FuncOrModName, PassLevel);
2593+
}
2594+
}
2595+
2596+
void DroppedVariableStats::calculateDroppedVarStatsOnFunction(
2597+
const Function *F, StringRef PassID, std::string FuncOrModName,
2598+
std::string PassLevel) {
2599+
unsigned DroppedCount = 0;
2600+
auto FuncName = F->getName();
2601+
auto &DebugVariables = DebugVariablesStack.back();
2602+
auto &DebugVariablesBeforeMap = DebugVariables.DebugVariablesBefore[F];
2603+
auto &DebugVariablesAfterMap = DebugVariables.DebugVariablesAfter[F];
2604+
auto &InlinedAtsMap = InlinedAts.back()[FuncName];
2605+
// Find an Instruction that shares the same scope as the dropped #dbg_value or
2606+
// has a scope that is the child of the scope of the #dbg_value, and has an
2607+
// inlinedAt equal to the inlinedAt of the #dbg_value or it's inlinedAt chain
2608+
// contains the inlinedAt of the #dbg_value, if such an Instruction is found,
2609+
// debug information is dropped.
2610+
for (auto Var : DebugVariablesBeforeMap) {
2611+
if (!DebugVariablesAfterMap.contains(Var)) {
2612+
const auto *DbgValScope = std::get<0>(Var);
2613+
for (const auto &I : instructions(F)) {
2614+
auto *DbgLoc = I.getDebugLoc().get();
2615+
if (DbgLoc) {
2616+
auto *Scope = DbgLoc->getScope();
2617+
if (isScopeChildOfOrEqualTo(Scope, DbgValScope)) {
2618+
if (isInlinedAtChildOfOrEqualTo(DbgLoc->getInlinedAt(),
2619+
InlinedAtsMap[Var])) {
2620+
DroppedCount++;
2621+
break;
2622+
}
2623+
}
2624+
}
2625+
}
2626+
removeVarFromAllSets(Var, F);
2627+
}
2628+
}
2629+
if (DroppedCount > 0) {
2630+
llvm::outs() << PassLevel << ", " << PassID << ", " << DroppedCount << ", "
2631+
<< FuncOrModName << "\n";
2632+
PassDroppedVariables = true;
2633+
} else
2634+
PassDroppedVariables = false;
2635+
}
2636+
2637+
void DroppedVariableStats::runAfterPassInvalidated(
2638+
StringRef PassID, const PreservedAnalyses &PA) {
2639+
DebugVariablesStack.pop_back();
2640+
InlinedAts.pop_back();
2641+
}
2642+
2643+
void DroppedVariableStats::runAfterPass(StringRef PassID, Any IR,
2644+
const PreservedAnalyses &PA) {
2645+
std::string PassLevel;
2646+
std::string FuncOrModName;
2647+
if (auto *M = unwrapIR<Module>(IR)) {
2648+
this->runOnModule(M, false);
2649+
PassLevel = "Module";
2650+
FuncOrModName = M->getName();
2651+
calculateDroppedVarStatsOnModule(M, PassID, FuncOrModName, PassLevel);
2652+
} else if (auto *F = unwrapIR<Function>(IR)) {
2653+
this->runOnFunction(F, false);
2654+
PassLevel = "Function";
2655+
FuncOrModName = F->getName();
2656+
calculateDroppedVarStatsOnFunction(F, PassID, FuncOrModName, PassLevel);
2657+
}
2658+
2659+
DebugVariablesStack.pop_back();
2660+
InlinedAts.pop_back();
2661+
return;
2662+
}
2663+
2664+
bool DroppedVariableStats::isScopeChildOfOrEqualTo(DIScope *Scope,
2665+
const DIScope *DbgValScope) {
2666+
while (Scope != nullptr) {
2667+
if (VisitedScope.find(Scope) == VisitedScope.end()) {
2668+
VisitedScope.insert(Scope);
2669+
if (Scope == DbgValScope) {
2670+
VisitedScope.clear();
2671+
return true;
2672+
}
2673+
Scope = Scope->getScope();
2674+
} else {
2675+
VisitedScope.clear();
2676+
return false;
2677+
}
2678+
}
2679+
return false;
2680+
}
2681+
2682+
bool DroppedVariableStats::isInlinedAtChildOfOrEqualTo(
2683+
const DILocation *InlinedAt, const DILocation *DbgValInlinedAt) {
2684+
if (DbgValInlinedAt == InlinedAt)
2685+
return true;
2686+
if (!DbgValInlinedAt)
2687+
return false;
2688+
if (!InlinedAt)
2689+
return false;
2690+
auto *IA = InlinedAt;
2691+
while (IA) {
2692+
if (IA == DbgValInlinedAt)
2693+
return true;
2694+
IA = IA->getInlinedAt();
2695+
}
2696+
return false;
2697+
}
2698+
25172699
void StandardInstrumentations::registerCallbacks(
25182700
PassInstrumentationCallbacks &PIC, ModuleAnalysisManager *MAM) {
25192701
PrintIR.registerCallbacks(PIC);
@@ -2529,6 +2711,7 @@ void StandardInstrumentations::registerCallbacks(
25292711
WebsiteChangeReporter.registerCallbacks(PIC);
25302712
ChangeTester.registerCallbacks(PIC);
25312713
PrintCrashIR.registerCallbacks(PIC);
2714+
DroppedStats.registerCallbacks(PIC);
25322715
if (MAM)
25332716
PreservedCFGChecker.registerCallbacks(PIC, *MAM);
25342717

‎llvm/test/Other/dropped-var-stats.ll

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
; RUN: opt -dropped-variable-stats %s -passes='verify' -S | FileCheck %s --check-prefix=NOT-DROPPED
2+
; NOT-DROPPED: Pass Level, Pass Name, Num of Dropped Variables, Func or Module Name
3+
; NOT-DROPPED-NOT: Function, ADCEPass, 1, _Z3bari
4+
5+
; ModuleID = '/tmp/dropped.cpp'
6+
define noundef range(i32 -2147483646, -2147483648) i32 @_Z3bari(i32 noundef %y) local_unnamed_addr #1 !dbg !19 {
7+
#dbg_value(i32 %y, !15, !DIExpression(), !23)
8+
%add = add nsw i32 %y, 2,!dbg !25
9+
ret i32 %add,!dbg !26
10+
}
11+
!llvm.module.flags = !{ !3, !7}
12+
!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 20.0.0git ([email protected]:llvm/llvm-project.git 7fc8398aaad65c4c29f1511c374d07308e667af5)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: Apple, sysroot: "/")
13+
!1 = !DIFile(filename: "/tmp/dropped.cpp", directory: "/Users/shubham/Development/llvm-project")
14+
!3 = !{i32 2, !"Debug Info Version", i32 3}
15+
!7 = !{i32 7, !"frame-pointer", i32 1}
16+
!9 = distinct !DISubprogram( unit: !0, retainedNodes: !14)
17+
!13 = !DIBasicType()
18+
!14 = !{}
19+
!15 = !DILocalVariable( scope: !9, type: !13)
20+
!19 = distinct !DISubprogram( unit: !0, retainedNodes: !20)
21+
!20 = !{}
22+
!23 = !DILocation( scope: !9, inlinedAt: !24)
23+
!24 = distinct !DILocation( scope: !19)
24+
!25 = !DILocation( scope: !19)
25+
!26 = !DILocation( scope: !19)

‎llvm/unittests/IR/CMakeLists.txt

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -43,6 +43,7 @@ add_llvm_unittest(IRTests
4343
ShuffleVectorInstTest.cpp
4444
StructuralHashTest.cpp
4545
TimePassesTest.cpp
46+
DroppedVariableStatsTest.cpp
4647
TypesTest.cpp
4748
UseTest.cpp
4849
UserTest.cpp

0 commit comments

Comments
 (0)