shylie/llvm-project
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add a pass to collect dropped var statistics for MIR (#126686)

Browse Source 
This patch attempts to reland
https://github.com/llvm/llvm-project/pull/120780 while addressing the
issues that caused the patch to be reverted.

Namely:

1. The patch had included code from the llvm/Passes directory in the
llvm/CodeGen directory.

2. The patch increased the backend compile time by 2% due to adding a
very expensive include in MachineFunctionPass.h

The patch has been re-structured so that there is no dependency between
the llvm/Passes and llvm/CodeGen directory, by moving the base class,
`class DroppedVariableStats` to the llvm/IR directory.

The expensive include in MachineFunctionPass.h has been changed to
contain forward declarations instead of other header includes which was
pulling a ton of code into MachineFunctionPass.h and should resolve any
issues when it comes to compile time increase.
This commit is contained in:
Shubham Sandeep Rastogi 2025-02-12 14:08:18 -08:00 committed by GitHub
parent 65ed4fa57e
commit 92f916faba
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
13 changed files with 1486 additions and 152 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
llvm/include/llvm/CodeGen/DroppedVariableStatsMIR.h Normal file
View File

@ -0,0 +1,59 @@
///===- DroppedVariableStatsMIR.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_VALUEs that get dropped due to an optimization pass.
///
///===---------------------------------------------------------------------===//
#ifndef LLVM_CODEGEN_DROPPEDVARIABLESTATSMIR_H
#define LLVM_CODEGEN_DROPPEDVARIABLESTATSMIR_H
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/IR/DroppedVariableStats.h"
namespace llvm {
/// A class to collect and print dropped debug information due to MIR
/// optimization passes. After every MIR pass is run, it will print how many
/// #DBG_VALUEs were dropped due to that pass.
class DroppedVariableStatsMIR : public DroppedVariableStats {
public:
DroppedVariableStatsMIR() : DroppedVariableStats(false) {}
void runBeforePass(StringRef PassID, MachineFunction *MF);
void runAfterPass(StringRef PassID, MachineFunction *MF);
private:
const MachineFunction *MFunc;
/// Populate DebugVariablesBefore, DebugVariablesAfter, InlinedAts before or
/// after a pass has run to facilitate dropped variable calculation for an
/// llvm::MachineFunction.
void runOnMachineFunction(const MachineFunction *MF, bool Before);
/// Iterate over all Instructions in a MachineFunction and report any dropped
/// debug information.
void calculateDroppedVarStatsOnMachineFunction(const MachineFunction *MF,
StringRef PassID,
StringRef FuncOrModName);
/// Override base class method to run on an llvm::MachineFunction
/// 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;
};
} // namespace llvm
#endif

144
llvm/include/llvm/Passes/DroppedVariableStats.h → llvm/include/llvm/IR/DroppedVariableStats.h
View File

@ -14,13 +14,19 @@
#ifndef LLVM_CODEGEN_DROPPEDVARIABLESTATS_H
#define LLVM_CODEGEN_DROPPEDVARIABLESTATS_H
#include "llvm/IR/DebugInfoMetadata.h"
#include "llvm/IR/DiagnosticInfo.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/PassInstrumentation.h"
#include "llvm/ADT/DenseSet.h"
#include "llvm/ADT/SmallVector.h"
#include <tuple>
namespace llvm {
class DIScope;
class DILocalVariable;
class Function;
class DILocation;
class DebugLoc;
class StringRef;
/// 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
@ -33,13 +39,7 @@ using VarID =
/// 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";
};
DroppedVariableStats(bool DroppedVarStatsEnabled);
virtual ~DroppedVariableStats() {}
@ -50,20 +50,9 @@ public:
bool getPassDroppedVariables() { return PassDroppedVariables; }
protected:
void setup() {
DebugVariablesStack.push_back(
{DenseMap<const Function *, DebugVariables>()});
InlinedAts.push_back(
{DenseMap<StringRef, DenseMap<VarID, DILocation *>>()});
}
void setup();
void cleanup() {
assert(!DebugVariablesStack.empty() &&
"DebugVariablesStack shouldn't be empty!");
assert(!InlinedAts.empty() && "InlinedAts shouldn't be empty!");
DebugVariablesStack.pop_back();
InlinedAts.pop_back();
}
void cleanup();
bool DroppedVariableStatsEnabled = false;
struct DebugVariables {
@ -73,7 +62,6 @@ protected:
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.
@ -90,78 +78,27 @@ protected:
void 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;
auto It = InlinedAts.back().find(FuncName);
if (It == InlinedAts.back().end())
return;
DenseMap<VarID, DILocation *> &InlinedAtsMap = It->second;
// 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;
}
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) {
// 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;
}
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) {
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 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) {
VarID Key{DbgVar->getScope(), DbgLoc->getInlinedAtScope(), DbgVar};
VarIDSet.insert(Key);
if (Before)
InlinedAtsMap[FuncName].try_emplace(Key, DbgLoc.getInlinedAt());
}
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.
@ -179,47 +116,18 @@ protected:
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);
}
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(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;
}
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) {
if (DbgValInlinedAt == InlinedAt)
return true;
if (!DbgValInlinedAt)
return false;
auto *IA = InlinedAt;
while (IA) {
if (IA == DbgValInlinedAt)
return true;
IA = IA->getInlinedAt();
}
return false;
}
const DILocation *DbgValInlinedAt);
bool PassDroppedVariables = false;
};

48
llvm/include/llvm/Passes/DroppedVariableStatsIR.h → llvm/include/llvm/IR/DroppedVariableStatsIR.h
View File

@ -14,12 +14,17 @@
#ifndef LLVM_CODEGEN_DROPPEDVARIABLESTATSIR_H
#define LLVM_CODEGEN_DROPPEDVARIABLESTATSIR_H
#include "llvm/IR/InstIterator.h"
#include "llvm/IR/Module.h"
#include "llvm/Passes/DroppedVariableStats.h"
#include "llvm/IR/DroppedVariableStats.h"
namespace llvm {
class Any;
class StringRef;
class PassInstrumentationCallbacks;
class Function;
class Module;
class DILocation;
/// 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.
@ -28,56 +33,42 @@ public:
DroppedVariableStatsIR(bool DroppedVarStatsEnabled)
: llvm::DroppedVariableStats(DroppedVarStatsEnabled) {}
void runBeforePass(StringRef P, Any IR) {
setup();
if (const auto *M = unwrapIR<Module>(IR))
return this->runOnModule(P, M, true);
if (const auto *F = unwrapIR<Function>(IR))
return this->runOnFunction(P, F, true);
}
void runBeforePass(StringRef P, Any IR);
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 runAfterPass(StringRef P, Any IR);
void registerCallbacks(PassInstrumentationCallbacks &PIC);
private:
const Function *Func;
void runAfterPassFunction(StringRef PassID, const Function *F) {
runOnFunction(PassID, F, false);
calculateDroppedVarStatsOnFunction(F, PassID, F->getName().str(),
"Function");
}
void runAfterPassFunction(StringRef PassID, const Function *F);
void runAfterPassModule(StringRef PassID, const Module *M);
void runAfterPassModule(StringRef PassID, const Module *M) {
runOnModule(PassID, 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(StringRef PassID, 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(StringRef PassID, 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,
@ -90,10 +81,7 @@ private:
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;
}
template <typename IRUnitT> static const IRUnitT *unwrapIR(Any IR);
};
} // namespace llvm

2
llvm/include/llvm/Passes/StandardInstrumentations.h
View File

@ -22,10 +22,10 @@
#include "llvm/CodeGen/MachineBasicBlock.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/DebugInfoMetadata.h"
#include "llvm/IR/DroppedVariableStatsIR.h"
#include "llvm/IR/OptBisect.h"
#include "llvm/IR/PassTimingInfo.h"
#include "llvm/IR/ValueHandle.h"
#include "llvm/Passes/DroppedVariableStatsIR.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/TimeProfiler.h"
#include "llvm/Transforms/IPO/SampleProfileProbe.h"

1
llvm/lib/CodeGen/CMakeLists.txt
View File

@ -50,6 +50,7 @@ add_llvm_component_library(LLVMCodeGen
DeadMachineInstructionElim.cpp
DetectDeadLanes.cpp
DFAPacketizer.cpp
DroppedVariableStatsMIR.cpp
DwarfEHPrepare.cpp
EarlyIfConversion.cpp
EdgeBundles.cpp

95
llvm/lib/CodeGen/DroppedVariableStatsMIR.cpp Normal file
View File

@ -0,0 +1,95 @@
///===- DroppedVariableStatsMIR.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_VALUEs that get dropped due to an optimization pass.
///
///===---------------------------------------------------------------------===//
#include "llvm/CodeGen/DroppedVariableStatsMIR.h"
#include "llvm/IR/DebugInfoMetadata.h"
using namespace llvm;
void DroppedVariableStatsMIR::runBeforePass(StringRef PassID,
MachineFunction *MF) {
if (PassID == "Debug Variable Analysis")
return;
setup();
return runOnMachineFunction(MF, true);
}
void DroppedVariableStatsMIR::runAfterPass(StringRef PassID,
MachineFunction *MF) {
if (PassID == "Debug Variable Analysis")
return;
runOnMachineFunction(MF, false);
calculateDroppedVarStatsOnMachineFunction(MF, PassID, MF->getName().str());
cleanup();
}
void DroppedVariableStatsMIR::runOnMachineFunction(const MachineFunction *MF,
bool Before) {
auto &DebugVariables = DebugVariablesStack.back()[&MF->getFunction()];
auto FuncName = MF->getName();
MFunc = MF;
run(DebugVariables, FuncName, Before);
}
void DroppedVariableStatsMIR::calculateDroppedVarStatsOnMachineFunction(
const MachineFunction *MF, StringRef PassID, StringRef FuncOrModName) {
MFunc = MF;
StringRef FuncName = MF->getName();
const Function *Func = &MF->getFunction();
DebugVariables &DbgVariables = DebugVariablesStack.back()[Func];
calculateDroppedStatsAndPrint(DbgVariables, FuncName, PassID, FuncOrModName,
"MachineFunction", Func);
}
void DroppedVariableStatsMIR::visitEveryInstruction(
unsigned &DroppedCount, DenseMap<VarID, DILocation *> &InlinedAtsMap,
VarID Var) {
unsigned PrevDroppedCount = DroppedCount;
const DIScope *DbgValScope = std::get<0>(Var);
for (const auto &MBB : *MFunc) {
for (const auto &MI : MBB) {
if (!MI.isDebugInstr()) {
auto *DbgLoc = MI.getDebugLoc().get();
if (!DbgLoc)
continue;
auto *Scope = DbgLoc->getScope();
if (updateDroppedCount(DbgLoc, Scope, DbgValScope, InlinedAtsMap, Var,
DroppedCount))
break;
}
}
if (PrevDroppedCount != DroppedCount) {
PrevDroppedCount = DroppedCount;
break;
}
}
}
void DroppedVariableStatsMIR::visitEveryDebugRecord(
DenseSet<VarID> &VarIDSet,
DenseMap<StringRef, DenseMap<VarID, DILocation *>> &InlinedAtsMap,
StringRef FuncName, bool Before) {
for (const auto &MBB : *MFunc) {
for (const auto &MI : MBB) {
if (MI.isDebugValueLike()) {
auto *DbgVar = MI.getDebugVariable();
if (!DbgVar)
continue;
auto DbgLoc = MI.getDebugLoc();
populateVarIDSetAndInlinedMap(DbgVar, DbgLoc, VarIDSet, InlinedAtsMap,
FuncName, Before);
}
}
}
}

17
llvm/lib/CodeGen/MachineFunctionPass.cpp
View File

@ -20,6 +20,7 @@
#include "llvm/Analysis/OptimizationRemarkEmitter.h"
#include "llvm/Analysis/ScalarEvolution.h"
#include "llvm/Analysis/ScalarEvolutionAliasAnalysis.h"
#include "llvm/CodeGen/DroppedVariableStatsMIR.h"
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/CodeGen/MachineModuleInfo.h"
#include "llvm/CodeGen/MachineOptimizationRemarkEmitter.h"
@ -32,6 +33,11 @@
using namespace llvm;
using namespace ore;
static cl::opt<bool> DroppedVarStatsMIR(
"dropped-variable-stats-mir", cl::Hidden,
cl::desc("Dump dropped debug variables stats for MIR passes"),
cl::init(false));
Pass *MachineFunctionPass::createPrinterPass(raw_ostream &O,
const std::string &Banner) const {
return createMachineFunctionPrinterPass(O, Banner);
@ -91,7 +97,16 @@ bool MachineFunctionPass::runOnFunction(Function &F) {
MFProps.reset(ClearedProperties);
bool RV = runOnMachineFunction(MF);
bool RV;
if (DroppedVarStatsMIR) {
DroppedVariableStatsMIR DroppedVarStatsMF;
auto PassName = getPassName();
DroppedVarStatsMF.runBeforePass(PassName, &MF);
RV = runOnMachineFunction(MF);
DroppedVarStatsMF.runAfterPass(PassName, &MF);
} else {
RV = runOnMachineFunction(MF);
}
if (ShouldEmitSizeRemarks) {
// We wanted size remarks. Check if there was a change to the number of

2
llvm/lib/IR/CMakeLists.txt
View File

@ -26,6 +26,8 @@ add_llvm_component_library(LLVMCore
DiagnosticInfo.cpp
DiagnosticPrinter.cpp
Dominators.cpp
DroppedVariableStats.cpp
DroppedVariableStatsIR.cpp
EHPersonalities.cpp
FPEnv.cpp
Function.cpp

147
llvm/lib/IR/DroppedVariableStats.cpp Normal file
View File

@ -0,0 +1,147 @@
///===- 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/IR/DroppedVariableStats.h"
#include "llvm/IR/DebugInfoMetadata.h"
#include "llvm/IR/DiagnosticInfo.h"
#include "llvm/IR/Function.h"
using namespace llvm;
DroppedVariableStats::DroppedVariableStats(bool DroppedVarStatsEnabled)
: DroppedVariableStatsEnabled(DroppedVarStatsEnabled) {
if (DroppedVarStatsEnabled)
llvm::outs() << "Pass Level, Pass Name, Num of Dropped Variables, Func or "
"Module Name\n";
}
void DroppedVariableStats::setup() {
DebugVariablesStack.push_back({DenseMap<const Function *, DebugVariables>()});
InlinedAts.push_back({DenseMap<StringRef, DenseMap<VarID, DILocation *>>()});
}
void DroppedVariableStats::cleanup() {
assert(!DebugVariablesStack.empty() &&
"DebugVariablesStack shouldn't be empty!");
assert(!InlinedAts.empty() && "InlinedAts shouldn't be empty!");
DebugVariablesStack.pop_back();
InlinedAts.pop_back();
}
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;
if (InlinedAts.back().find(FuncName) == InlinedAts.back().end())
return;
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)
InlinedAtsMap[FuncName].try_emplace(Key, DbgLoc.getInlinedAt());
}
void DroppedVariableStats::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);
}
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;
}

40
llvm/lib/Passes/DroppedVariableStatsIR.cpp → llvm/lib/IR/DroppedVariableStatsIR.cpp
View File

@ -11,10 +11,48 @@
///
///===---------------------------------------------------------------------===//
#include "llvm/Passes/DroppedVariableStatsIR.h"
#include "llvm/IR/DroppedVariableStatsIR.h"
#include "llvm/IR/DebugInfoMetadata.h"
#include "llvm/IR/InstIterator.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/PassInstrumentation.h"
using namespace llvm;
template <typename IRUnitT>
const IRUnitT *DroppedVariableStatsIR::unwrapIR(Any IR) {
const IRUnitT **IRPtr = llvm::any_cast<const IRUnitT *>(&IR);
return IRPtr ? *IRPtr : nullptr;
}
void DroppedVariableStatsIR::runBeforePass(StringRef P, Any IR) {
setup();
if (const auto *M = unwrapIR<Module>(IR))
return this->runOnModule(P, M, true);
if (const auto *F = unwrapIR<Function>(IR))
return this->runOnFunction(P, F, true);
}
void DroppedVariableStatsIR::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 DroppedVariableStatsIR::runAfterPassFunction(StringRef PassID,
const Function *F) {
runOnFunction(PassID, F, false);
calculateDroppedVarStatsOnFunction(F, PassID, F->getName().str(), "Function");
}
void DroppedVariableStatsIR::runAfterPassModule(StringRef PassID,
const Module *M) {
runOnModule(PassID, M, false);
calculateDroppedVarStatsOnModule(M, PassID, M->getName().str(), "Module");
}
void DroppedVariableStatsIR::runOnFunction(StringRef PassID, const Function *F,
bool Before) {
auto &DebugVariables = DebugVariablesStack.back()[F];

1
llvm/lib/Passes/CMakeLists.txt
View File

@ -1,6 +1,5 @@
add_llvm_component_library(LLVMPasses
CodeGenPassBuilder.cpp
DroppedVariableStatsIR.cpp
OptimizationLevel.cpp
PassBuilder.cpp
PassBuilderBindings.cpp

1
llvm/unittests/CodeGen/CMakeLists.txt
View File

@ -27,6 +27,7 @@ add_llvm_unittest(CodeGenTests
CCStateTest.cpp
DIEHashTest.cpp
DIETest.cpp
DroppedVariableStatsMIRTest.cpp
DwarfStringPoolEntryRefTest.cpp
InstrRefLDVTest.cpp
LowLevelTypeTest.cpp

1081
llvm/unittests/CodeGen/DroppedVariableStatsMIRTest.cpp Normal file
View File

File diff suppressed because it is too large Load Diff