[llvm] Reland [NFC] Move DroppedVariableStats to its own file and redesign it to be extensible. (PR #117042)
via llvm-commits
llvm-commits at lists.llvm.org
Wed Nov 20 12:19:49 PST 2024
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-llvm-ir
Author: Shubham Sandeep Rastogi (rastogishubham)
<details>
<summary>Changes</summary>
Moved the IR unit test to the CodeGen folder to resolve linker errors:
error: undefined reference to 'vtable for llvm::DroppedVariableStatsIR'
---
Patch is 40.69 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/117042.diff
8 Files Affected:
- (added) llvm/include/llvm/CodeGen/DroppedVariableStats.h (+226)
- (modified) llvm/include/llvm/Passes/StandardInstrumentations.h (+2-78)
- (modified) llvm/lib/CodeGen/CMakeLists.txt (+1)
- (added) llvm/lib/CodeGen/DroppedVariableStats.cpp (+194)
- (modified) llvm/lib/Passes/StandardInstrumentations.cpp (+2-176)
- (modified) llvm/unittests/CodeGen/CMakeLists.txt (+1)
- (renamed) llvm/unittests/CodeGen/DroppedVariableStatsIRTest.cpp (+30-44)
- (modified) llvm/unittests/IR/CMakeLists.txt (-1)
``````````diff
diff --git a/llvm/include/llvm/CodeGen/DroppedVariableStats.h b/llvm/include/llvm/CodeGen/DroppedVariableStats.h
new file mode 100644
index 00000000000000..371d775b02e876
--- /dev/null
+++ b/llvm/include/llvm/CodeGen/DroppedVariableStats.h
@@ -0,0 +1,226 @@
+///===- DroppedVariableStats.h - Opt Diagnostics -*- C++ -*----------------===//
+///
+/// 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
+///
+///===---------------------------------------------------------------------===//
+/// \file
+/// Dropped Variable Statistics for Debug Information. Reports any number
+/// of #dbg_value that get dropped due to an optimization pass.
+///
+///===---------------------------------------------------------------------===//
+
+#ifndef LLVM_CODEGEN_DROPPEDVARIABLESTATS_H
+#define LLVM_CODEGEN_DROPPEDVARIABLESTATS_H
+
+#include "llvm/CodeGen/MachinePassManager.h"
+#include "llvm/IR/DebugInfoMetadata.h"
+#include "llvm/IR/DiagnosticInfo.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/Module.h"
+#include "llvm/IR/PassInstrumentation.h"
+
+namespace llvm {
+
+/// A unique key that represents a debug variable.
+/// First const DIScope *: Represents the scope of the debug variable.
+/// Second const DIScope *: Represents the InlinedAt scope of the debug
+/// variable. const DILocalVariable *: It is a pointer to the debug variable
+/// itself.
+using VarID =
+ std::tuple<const DIScope *, const DIScope *, const DILocalVariable *>;
+
+/// A base class to collect and print dropped debug information variable
+/// statistics.
+class DroppedVariableStats {
+public:
+ DroppedVariableStats(bool DroppedVarStatsEnabled)
+ : DroppedVariableStatsEnabled(DroppedVarStatsEnabled) {
+ if (DroppedVarStatsEnabled)
+ llvm::outs()
+ << "Pass Level, Pass Name, Num of Dropped Variables, Func or "
+ "Module Name\n";
+ };
+
+ virtual ~DroppedVariableStats() = default;
+
+ // We intend this to be unique per-compilation, thus no copies.
+ DroppedVariableStats(const DroppedVariableStats &) = delete;
+ void operator=(const DroppedVariableStats &) = delete;
+
+ bool getPassDroppedVariables() { return PassDroppedVariables; }
+
+protected:
+ void setup() {
+ DebugVariablesStack.push_back(
+ {DenseMap<const Function *, DebugVariables>()});
+ InlinedAts.push_back(
+ {DenseMap<StringRef, DenseMap<VarID, DILocation *>>()});
+ }
+
+ void cleanup() {
+ assert(!DebugVariablesStack.empty() &&
+ "DebugVariablesStack shouldn't be empty!");
+ assert(!InlinedAts.empty() && "InlinedAts shouldn't be empty!");
+ DebugVariablesStack.pop_back();
+ InlinedAts.pop_back();
+ }
+
+ bool DroppedVariableStatsEnabled = false;
+ struct DebugVariables {
+ /// DenseSet of VarIDs before an optimization pass has run.
+ DenseSet<VarID> DebugVariablesBefore;
+ /// DenseSet of VarIDs after an optimization pass has run.
+ DenseSet<VarID> DebugVariablesAfter;
+ };
+
+protected:
+ /// A stack of a DenseMap, that maps DebugVariables for every pass to an
+ /// llvm::Function. A stack is used because an optimization pass can call
+ /// other passes.
+ SmallVector<DenseMap<const Function *, DebugVariables>> DebugVariablesStack;
+
+ /// A DenseSet tracking whether a scope was visited before.
+ DenseSet<const DIScope *> VisitedScope;
+ /// A stack of DenseMaps, which map the name of an llvm::Function to a
+ /// DenseMap of VarIDs and their inlinedAt locations before an optimization
+ /// pass has run.
+ SmallVector<DenseMap<StringRef, DenseMap<VarID, DILocation *>>> InlinedAts;
+ /// Calculate the number of dropped variables in an llvm::Function or
+ /// llvm::MachineFunction and print the relevant information to stdout.
+ void calculateDroppedStatsAndPrint(DebugVariables &DbgVariables,
+ StringRef FuncName, StringRef PassID,
+ StringRef FuncOrModName,
+ StringRef PassLevel, const Function *Func);
+
+ /// Check if a \p Var has been dropped or is a false positive. Also update the
+ /// \p DroppedCount if a debug variable is dropped.
+ bool updateDroppedCount(DILocation *DbgLoc, const DIScope *Scope,
+ const DIScope *DbgValScope,
+ DenseMap<VarID, DILocation *> &InlinedAtsMap,
+ VarID Var, unsigned &DroppedCount);
+ /// Run code to populate relevant data structures over an llvm::Function or
+ /// llvm::MachineFunction.
+ void run(DebugVariables &DbgVariables, StringRef FuncName, bool Before);
+ /// Populate the VarIDSet and InlinedAtMap with the relevant information
+ /// needed for before and after pass analysis to determine dropped variable
+ /// status.
+ void populateVarIDSetAndInlinedMap(
+ const DILocalVariable *DbgVar, DebugLoc DbgLoc, DenseSet<VarID> &VarIDSet,
+ DenseMap<StringRef, DenseMap<VarID, DILocation *>> &InlinedAtsMap,
+ StringRef FuncName, bool Before);
+ /// Visit every llvm::Instruction or llvm::MachineInstruction and check if the
+ /// debug variable denoted by its ID \p Var may have been dropped by an
+ /// optimization pass.
+ virtual void
+ visitEveryInstruction(unsigned &DroppedCount,
+ DenseMap<VarID, DILocation *> &InlinedAtsMap,
+ VarID Var) = 0;
+ /// Visit every debug record in an llvm::Function or llvm::MachineFunction
+ /// and call populateVarIDSetAndInlinedMap on it.
+ virtual void visitEveryDebugRecord(
+ DenseSet<VarID> &VarIDSet,
+ DenseMap<StringRef, DenseMap<VarID, DILocation *>> &InlinedAtsMap,
+ StringRef FuncName, bool Before) = 0;
+
+private:
+ /// Remove a dropped debug variable's VarID from all Sets in the
+ /// DroppedVariablesBefore stack.
+ void removeVarFromAllSets(VarID Var, const Function *F) {
+ // Do not remove Var from the last element, it will be popped from the
+ // stack.
+ for (auto &DebugVariablesMap : llvm::drop_end(DebugVariablesStack))
+ DebugVariablesMap[F].DebugVariablesBefore.erase(Var);
+ }
+ /// Return true if \p Scope is the same as \p DbgValScope or a child scope of
+ /// \p DbgValScope, return false otherwise.
+ bool isScopeChildOfOrEqualTo(const DIScope *Scope,
+ const DIScope *DbgValScope);
+ /// Return true if \p InlinedAt is the same as \p DbgValInlinedAt or part of
+ /// the InlinedAt chain, return false otherwise.
+ bool isInlinedAtChildOfOrEqualTo(const DILocation *InlinedAt,
+ const DILocation *DbgValInlinedAt);
+ bool PassDroppedVariables = false;
+};
+
+/// A class to collect and print dropped debug information due to LLVM IR
+/// optimization passes. After every LLVM IR pass is run, it will print how many
+/// #dbg_values were dropped due to that pass.
+class DroppedVariableStatsIR : public DroppedVariableStats {
+public:
+ DroppedVariableStatsIR(bool DroppedVarStatsEnabled)
+ : llvm::DroppedVariableStats(DroppedVarStatsEnabled) {}
+
+ virtual ~DroppedVariableStatsIR() = default;
+
+ void runBeforePass(Any IR) {
+ setup();
+ if (const auto *M = unwrapIR<Module>(IR))
+ return this->runOnModule(M, true);
+ if (const auto *F = unwrapIR<Function>(IR))
+ return this->runOnFunction(F, true);
+ }
+
+ void runAfterPass(StringRef P, Any IR) {
+ if (const auto *M = unwrapIR<Module>(IR))
+ runAfterPassModule(P, M);
+ else if (const auto *F = unwrapIR<Function>(IR))
+ runAfterPassFunction(P, F);
+ cleanup();
+ }
+
+ void registerCallbacks(PassInstrumentationCallbacks &PIC);
+
+private:
+ const Function *Func;
+
+ void runAfterPassFunction(StringRef PassID, const Function *F) {
+ runOnFunction(F, false);
+ calculateDroppedVarStatsOnFunction(F, PassID, F->getName().str(),
+ "Function");
+ }
+
+ void runAfterPassModule(StringRef PassID, const Module *M) {
+ runOnModule(M, false);
+ calculateDroppedVarStatsOnModule(M, PassID, M->getName().str(), "Module");
+ }
+ /// Populate DebugVariablesBefore, DebugVariablesAfter, InlinedAts before or
+ /// after a pass has run to facilitate dropped variable calculation for an
+ /// llvm::Function.
+ void runOnFunction(const Function *F, bool Before);
+ /// Iterate over all Instructions in a Function and report any dropped debug
+ /// information.
+ void calculateDroppedVarStatsOnFunction(const Function *F, StringRef PassID,
+ StringRef FuncOrModName,
+ StringRef PassLevel);
+ /// Populate DebugVariablesBefore, DebugVariablesAfter, InlinedAts before or
+ /// after a pass has run to facilitate dropped variable calculation for an
+ /// llvm::Module. Calls runOnFunction on every Function in the Module.
+ void runOnModule(const Module *M, bool Before);
+ /// Iterate over all Functions in a Module and report any dropped debug
+ /// information. Will call calculateDroppedVarStatsOnFunction on every
+ /// Function.
+ void calculateDroppedVarStatsOnModule(const Module *M, StringRef PassID,
+ StringRef FuncOrModName,
+ StringRef PassLevel);
+ /// Override base class method to run on an llvm::Function specifically.
+ virtual void
+ visitEveryInstruction(unsigned &DroppedCount,
+ DenseMap<VarID, DILocation *> &InlinedAtsMap,
+ VarID Var) override;
+ /// Override base class method to run on #dbg_values specifically.
+ virtual void visitEveryDebugRecord(
+ DenseSet<VarID> &VarIDSet,
+ DenseMap<StringRef, DenseMap<VarID, DILocation *>> &InlinedAtsMap,
+ StringRef FuncName, bool Before) override;
+
+ template <typename IRUnitT> static const IRUnitT *unwrapIR(Any IR) {
+ const IRUnitT **IRPtr = llvm::any_cast<const IRUnitT *>(&IR);
+ return IRPtr ? *IRPtr : nullptr;
+ }
+};
+
+} // namespace llvm
+
+#endif
diff --git a/llvm/include/llvm/Passes/StandardInstrumentations.h b/llvm/include/llvm/Passes/StandardInstrumentations.h
index 9301a12c740eec..12a34c099eaffe 100644
--- a/llvm/include/llvm/Passes/StandardInstrumentations.h
+++ b/llvm/include/llvm/Passes/StandardInstrumentations.h
@@ -19,6 +19,7 @@
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/StringSet.h"
+#include "llvm/CodeGen/DroppedVariableStats.h"
#include "llvm/CodeGen/MachineBasicBlock.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/DebugInfoMetadata.h"
@@ -579,83 +580,6 @@ class PrintCrashIRInstrumentation {
static void SignalHandler(void *);
};
-/// A class to collect and print dropped debug information variable statistics.
-/// After every LLVM IR pass is run, it will print how many #dbg_values were
-/// dropped due to that pass.
-class DroppedVariableStats {
-public:
- DroppedVariableStats(bool DroppedVarStatsEnabled) {
- if (DroppedVarStatsEnabled)
- llvm::outs()
- << "Pass Level, Pass Name, Num of Dropped Variables, Func or "
- "Module Name\n";
- };
- // We intend this to be unique per-compilation, thus no copies.
- DroppedVariableStats(const DroppedVariableStats &) = delete;
- void operator=(const DroppedVariableStats &) = delete;
-
- void registerCallbacks(PassInstrumentationCallbacks &PIC);
- void runBeforePass(StringRef PassID, Any IR);
- void runAfterPass(StringRef PassID, Any IR, const PreservedAnalyses &PA);
- void runAfterPassInvalidated(StringRef PassID, const PreservedAnalyses &PA);
- bool getPassDroppedVariables() { return PassDroppedVariables; }
-
-private:
- bool PassDroppedVariables = false;
- /// A unique key that represents a #dbg_value.
- using VarID =
- std::tuple<const DIScope *, const DIScope *, const DILocalVariable *>;
-
- struct DebugVariables {
- /// DenseSet of VarIDs before an optimization pass has run.
- DenseSet<VarID> DebugVariablesBefore;
- /// DenseSet of VarIDs after an optimization pass has run.
- DenseSet<VarID> DebugVariablesAfter;
- };
-
- /// A stack of a DenseMap, that maps DebugVariables for every pass to an
- /// llvm::Function. A stack is used because an optimization pass can call
- /// other passes.
- SmallVector<DenseMap<const Function *, DebugVariables>> DebugVariablesStack;
-
- /// A DenseSet tracking whether a scope was visited before.
- DenseSet<const DIScope *> VisitedScope;
- /// A stack of DenseMaps, which map the name of an llvm::Function to a
- /// DenseMap of VarIDs and their inlinedAt locations before an optimization
- /// pass has run.
- SmallVector<DenseMap<StringRef, DenseMap<VarID, DILocation *>>> InlinedAts;
-
- /// Iterate over all Functions in a Module and report any dropped debug
- /// information. Will call calculateDroppedVarStatsOnFunction on every
- /// Function.
- void calculateDroppedVarStatsOnModule(const Module *M, StringRef PassID,
- std::string FuncOrModName,
- std::string PassLevel);
- /// Iterate over all Instructions in a Function and report any dropped debug
- /// information.
- void calculateDroppedVarStatsOnFunction(const Function *F, StringRef PassID,
- std::string FuncOrModName,
- std::string PassLevel);
- /// Populate DebugVariablesBefore, DebugVariablesAfter, InlinedAts before or
- /// after a pass has run to facilitate dropped variable calculation for an
- /// llvm::Function.
- void runOnFunction(const Function *F, bool Before);
- /// Populate DebugVariablesBefore, DebugVariablesAfter, InlinedAts before or
- /// after a pass has run to facilitate dropped variable calculation for an
- /// llvm::Module. Calls runOnFunction on every Function in the Module.
- void runOnModule(const Module *M, bool Before);
- /// Remove a dropped #dbg_value VarID from all Sets in the
- /// DroppedVariablesBefore stack.
- void removeVarFromAllSets(VarID Var, const Function *F);
- /// Return true if \p Scope is the same as \p DbgValScope or a child scope of
- /// \p DbgValScope, return false otherwise.
- bool isScopeChildOfOrEqualTo(DIScope *Scope, const DIScope *DbgValScope);
- /// Return true if \p InlinedAt is the same as \p DbgValInlinedAt or part of
- /// the InlinedAt chain, return false otherwise.
- bool isInlinedAtChildOfOrEqualTo(const DILocation *InlinedAt,
- const DILocation *DbgValInlinedAt);
-};
-
/// This class provides an interface to register all the standard pass
/// instrumentations and manages their state (if any).
class StandardInstrumentations {
@@ -673,7 +597,7 @@ class StandardInstrumentations {
PrintCrashIRInstrumentation PrintCrashIR;
IRChangedTester ChangeTester;
VerifyInstrumentation Verify;
- DroppedVariableStats DroppedStats;
+ DroppedVariableStatsIR DroppedStatsIR;
bool VerifyEach;
diff --git a/llvm/lib/CodeGen/CMakeLists.txt b/llvm/lib/CodeGen/CMakeLists.txt
index 7b47c0e6f75dbe..263d4a9ee94d2e 100644
--- a/llvm/lib/CodeGen/CMakeLists.txt
+++ b/llvm/lib/CodeGen/CMakeLists.txt
@@ -50,6 +50,7 @@ add_llvm_component_library(LLVMCodeGen
DeadMachineInstructionElim.cpp
DetectDeadLanes.cpp
DFAPacketizer.cpp
+ DroppedVariableStats.cpp
DwarfEHPrepare.cpp
EarlyIfConversion.cpp
EdgeBundles.cpp
diff --git a/llvm/lib/CodeGen/DroppedVariableStats.cpp b/llvm/lib/CodeGen/DroppedVariableStats.cpp
new file mode 100644
index 00000000000000..122fcad1293f1e
--- /dev/null
+++ b/llvm/lib/CodeGen/DroppedVariableStats.cpp
@@ -0,0 +1,194 @@
+///===- DroppedVariableStats.cpp ------------------------------------------===//
+///
+/// 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
+///
+///===---------------------------------------------------------------------===//
+/// \file
+/// Dropped Variable Statistics for Debug Information. Reports any number
+/// of #dbg_value that get dropped due to an optimization pass.
+///
+///===---------------------------------------------------------------------===//
+
+#include "llvm/CodeGen/DroppedVariableStats.h"
+#include "llvm/IR/DebugInfoMetadata.h"
+#include "llvm/IR/InstIterator.h"
+#include "llvm/IR/Module.h"
+
+using namespace llvm;
+
+bool DroppedVariableStats::isScopeChildOfOrEqualTo(const DIScope *Scope,
+ const DIScope *DbgValScope) {
+ while (Scope != nullptr) {
+ if (VisitedScope.find(Scope) == VisitedScope.end()) {
+ VisitedScope.insert(Scope);
+ if (Scope == DbgValScope) {
+ VisitedScope.clear();
+ return true;
+ }
+ Scope = Scope->getScope();
+ } else {
+ VisitedScope.clear();
+ return false;
+ }
+ }
+ return false;
+}
+
+bool DroppedVariableStats::isInlinedAtChildOfOrEqualTo(
+ const DILocation *InlinedAt, const DILocation *DbgValInlinedAt) {
+ if (DbgValInlinedAt == InlinedAt)
+ return true;
+ if (!DbgValInlinedAt)
+ return false;
+ auto *IA = InlinedAt;
+ while (IA) {
+ if (IA == DbgValInlinedAt)
+ return true;
+ IA = IA->getInlinedAt();
+ }
+ return false;
+}
+
+void DroppedVariableStats::calculateDroppedStatsAndPrint(
+ DebugVariables &DbgVariables, StringRef FuncName, StringRef PassID,
+ StringRef FuncOrModName, StringRef PassLevel, const Function *Func) {
+ unsigned DroppedCount = 0;
+ DenseSet<VarID> &DebugVariablesBeforeSet = DbgVariables.DebugVariablesBefore;
+ DenseSet<VarID> &DebugVariablesAfterSet = DbgVariables.DebugVariablesAfter;
+ DenseMap<VarID, DILocation *> &InlinedAtsMap = InlinedAts.back()[FuncName];
+ // Find an Instruction that shares the same scope as the dropped #dbg_value or
+ // has a scope that is the child of the scope of the #dbg_value, and has an
+ // inlinedAt equal to the inlinedAt of the #dbg_value or it's inlinedAt chain
+ // contains the inlinedAt of the #dbg_value, if such an Instruction is found,
+ // debug information is dropped.
+ for (VarID Var : DebugVariablesBeforeSet) {
+ if (DebugVariablesAfterSet.contains(Var))
+ continue;
+ visitEveryInstruction(DroppedCount, InlinedAtsMap, Var);
+ removeVarFromAllSets(Var, Func);
+ }
+ if (DroppedCount > 0) {
+ llvm::outs() << PassLevel << ", " << PassID << ", " << DroppedCount << ", "
+ << FuncOrModName << "\n";
+ PassDroppedVariables = true;
+ } else
+ PassDroppedVariables = false;
+}
+
+bool DroppedVariableStats::updateDroppedCount(
+ DILocation *DbgLoc, const DIScope *Scope, const DIScope *DbgValScope,
+ DenseMap<VarID, DILocation *> &InlinedAtsMap, VarID Var,
+ unsigned &DroppedCount) {
+
+ // If the Scope is a child of, or equal to the DbgValScope and is inlined at
+ // the Var's InlinedAt location, return true to signify that the Var has been
+ // dropped.
+ if (isScopeChildOfOrEqualTo(Scope, DbgValScope))
+ if (isInlinedAtChildOfOrEqualTo(DbgLoc->getInlinedAt(),
+ InlinedAtsMap[Var])) {
+ // Found another instruction in the variable's scope, so there exists a
+ // break point at which the variable could be observed. Count it as
+ // dropped.
+ DroppedCount++;
+ return true;
+ }
+ return false;
+}
+
+void DroppedVariableStats::run(DebugVariables &DbgVariables, StringRef FuncName,
+ bool Before) {
+ auto &VarIDSet = (Before ? DbgVariables.DebugVariablesBefore
+ : DbgVariables.DebugVariablesAfter);
+ auto &InlinedAtsMap = InlinedAts.back();
+ if (Before)
+ InlinedAtsMap.try_emplace(FuncName, DenseMap<VarID, DILocation *>());
+ VarIDSet = DenseSet<VarID>();
+ visitEveryDebugRecord(VarIDSet, InlinedAtsMap, FuncName, Before);
+}
+
+void DroppedVariableStats::populateVarIDSetAndInlinedMap(
+ const DILocalVariable *DbgVar, DebugLoc DbgLoc, DenseSet<VarID> &VarIDSet,
+ DenseMap<StringRef, DenseMap<VarID, DILocation *>> &InlinedAtsMap,
+ StringRef FuncName, bool Before) {
+ VarID Key{DbgVar->getScope(), DbgLoc->getInlinedAtScope(), DbgVar};
+ VarIDSet.insert(Key);
+ if (Before)
+ InlinedAt...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/117042
More information about the llvm-commits
mailing list