caio/clang-p2996
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Reland [NFC] Move DroppedVariableStats to its own file and redesign it to be extensible. (#117042)

Browse Source 
Moved the IR unit test to the CodeGen folder to resolve linker errors:

`error: undefined reference to 'vtable for
llvm::DroppedVariableStatsIR'`

This patch is trying to reland
https://github.com/llvm/llvm-project/pull/115563
This commit is contained in:
Shubham Sandeep Rastogi
2024-12-03 10:39:40 -08:00
committed by GitHub
parent 9791f25807
commit acf3b1aa93
8 changed files with 456 additions and 299 deletions
Download Patch File Download Diff File Expand all files Collapse all files

226
llvm/include/llvm/CodeGen/DroppedVariableStats.h Normal file
View File

@@ -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

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

@@ -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 @@ private:
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;

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

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

194
llvm/lib/CodeGen/DroppedVariableStats.cpp Normal file
View File

@@ -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)
InlinedAtsMap[FuncName].try_emplace(Key, DbgLoc.getInlinedAt());
}
void DroppedVariableStatsIR::runOnFunction(const Function *F, bool Before) {
auto &DebugVariables = DebugVariablesStack.back()[F];
auto FuncName = F->getName();
Func = F;
run(DebugVariables, FuncName, Before);
}
void DroppedVariableStatsIR::calculateDroppedVarStatsOnFunction(
const Function *F, StringRef PassID, StringRef FuncOrModName,
StringRef PassLevel) {
Func = F;
StringRef FuncName = F->getName();
DebugVariables &DbgVariables = DebugVariablesStack.back()[F];
calculateDroppedStatsAndPrint(DbgVariables, FuncName, PassID, FuncOrModName,
PassLevel, Func);
}
void DroppedVariableStatsIR::runOnModule(const Module *M, bool Before) {
for (auto &F : *M)
runOnFunction(&F, Before);
}
void DroppedVariableStatsIR::calculateDroppedVarStatsOnModule(
const Module *M, StringRef PassID, StringRef FuncOrModName,
StringRef PassLevel) {
for (auto &F : *M) {
calculateDroppedVarStatsOnFunction(&F, PassID, FuncOrModName, PassLevel);
}
}
void DroppedVariableStatsIR::registerCallbacks(
PassInstrumentationCallbacks &PIC) {
if (!DroppedVariableStatsEnabled)
return;
PIC.registerBeforeNonSkippedPassCallback(
[this](StringRef P, Any IR) { return runBeforePass(IR); });
PIC.registerAfterPassCallback(
[this](StringRef P, Any IR, const PreservedAnalyses &PA) {
return runAfterPass(P, IR);
});
PIC.registerAfterPassInvalidatedCallback(
[this](StringRef P, const PreservedAnalyses &PA) { return cleanup(); });
}
void DroppedVariableStatsIR::visitEveryInstruction(
unsigned &DroppedCount, DenseMap<VarID, DILocation *> &InlinedAtsMap,
VarID Var) {
const DIScope *DbgValScope = std::get<0>(Var);
for (const auto &I : instructions(Func)) {
auto *DbgLoc = I.getDebugLoc().get();
if (!DbgLoc)
continue;
if (updateDroppedCount(DbgLoc, DbgLoc->getScope(), DbgValScope,
InlinedAtsMap, Var, DroppedCount))
break;
}
}
void DroppedVariableStatsIR::visitEveryDebugRecord(
DenseSet<VarID> &VarIDSet,
DenseMap<StringRef, DenseMap<VarID, DILocation *>> &InlinedAtsMap,
StringRef FuncName, bool Before) {
for (const auto &I : instructions(Func)) {
for (DbgRecord &DR : I.getDbgRecordRange()) {
if (auto *Dbg = dyn_cast<DbgVariableRecord>(&DR)) {
auto *DbgVar = Dbg->getVariable();
auto DbgLoc = DR.getDebugLoc();
populateVarIDSetAndInlinedMap(DbgVar, DbgLoc, VarIDSet, InlinedAtsMap,
FuncName, Before);
}
}
}
}

178
llvm/lib/Passes/StandardInstrumentations.cpp
View File

@@ -2462,7 +2462,7 @@ StandardInstrumentations::StandardInstrumentations(
PrintChanged == ChangePrinter::ColourDiffVerbose ||
PrintChanged == ChangePrinter::ColourDiffQuiet),
WebsiteChangeReporter(PrintChanged == ChangePrinter::DotCfgVerbose),
Verify(DebugLogging), DroppedStats(DroppedVarStats),
Verify(DebugLogging), DroppedStatsIR(DroppedVarStats),
VerifyEach(VerifyEach) {}
PrintCrashIRInstrumentation *PrintCrashIRInstrumentation::CrashReporter =
@@ -2523,180 +2523,6 @@ void PrintCrashIRInstrumentation::registerCallbacks(
});
}
void DroppedVariableStats::registerCallbacks(
PassInstrumentationCallbacks &PIC) {
if (!DroppedVarStats)
return;
PIC.registerBeforeNonSkippedPassCallback(
[this](StringRef P, Any IR) { return this->runBeforePass(P, IR); });
PIC.registerAfterPassCallback(
[this](StringRef P, Any IR, const PreservedAnalyses &PA) {
return this->runAfterPass(P, IR, PA);
});
PIC.registerAfterPassInvalidatedCallback(
[this](StringRef P, const PreservedAnalyses &PA) {
return this->runAfterPassInvalidated(P, PA);
});
}
void DroppedVariableStats::runBeforePass(StringRef PassID, Any IR) {
DebugVariablesStack.push_back({DenseMap<const Function *, DebugVariables>()});
InlinedAts.push_back({DenseMap<StringRef, DenseMap<VarID, DILocation *>>()});
if (auto *M = unwrapIR<Module>(IR))
return this->runOnModule(M, true);
if (auto *F = unwrapIR<Function>(IR))
return this->runOnFunction(F, true);
}
void DroppedVariableStats::runOnFunction(const Function *F, bool Before) {
auto &DebugVariables = DebugVariablesStack.back()[F];
auto &VarIDSet = (Before ? DebugVariables.DebugVariablesBefore
: DebugVariables.DebugVariablesAfter);
auto &InlinedAtsMap = InlinedAts.back();
auto FuncName = F->getName();
if (Before)
InlinedAtsMap.try_emplace(FuncName, DenseMap<VarID, DILocation *>());
VarIDSet = DenseSet<VarID>();
for (const auto &I : instructions(F)) {
for (DbgRecord &DR : I.getDbgRecordRange()) {
if (auto *Dbg = dyn_cast<DbgVariableRecord>(&DR)) {
auto *DbgVar = Dbg->getVariable();
auto DbgLoc = DR.getDebugLoc();
VarID Key{DbgVar->getScope(), DbgLoc->getInlinedAtScope(), DbgVar};
VarIDSet.insert(Key);
if (Before)
InlinedAtsMap[FuncName].try_emplace(Key, DbgLoc.getInlinedAt());
}
}
}
}
void DroppedVariableStats::runOnModule(const Module *M, bool Before) {
for (auto &F : *M)
runOnFunction(&F, Before);
}
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);
}
void DroppedVariableStats::calculateDroppedVarStatsOnModule(
const Module *M, StringRef PassID, std::string FuncOrModName,
std::string PassLevel) {
for (auto &F : *M) {
calculateDroppedVarStatsOnFunction(&F, PassID, FuncOrModName, PassLevel);
}
}
void DroppedVariableStats::calculateDroppedVarStatsOnFunction(
const Function *F, StringRef PassID, std::string FuncOrModName,
std::string PassLevel) {
unsigned DroppedCount = 0;
StringRef FuncName = F->getName();
DebugVariables &DbgVariables = DebugVariablesStack.back()[F];
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;
const DIScope *DbgValScope = std::get<0>(Var);
for (const auto &I : instructions(F)) {
auto *DbgLoc = I.getDebugLoc().get();
if (!DbgLoc)
continue;
auto *Scope = DbgLoc->getScope();
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++;
break;
}
}
}
removeVarFromAllSets(Var, F);
}
if (DroppedCount > 0) {
llvm::outs() << PassLevel << ", " << PassID << ", " << DroppedCount << ", "
<< FuncOrModName << "\n";
PassDroppedVariables = true;
} else
PassDroppedVariables = false;
}
void DroppedVariableStats::runAfterPassInvalidated(
StringRef PassID, const PreservedAnalyses &PA) {
DebugVariablesStack.pop_back();
InlinedAts.pop_back();
}
void DroppedVariableStats::runAfterPass(StringRef PassID, Any IR,
const PreservedAnalyses &PA) {
std::string PassLevel;
std::string FuncOrModName;
if (auto *M = unwrapIR<Module>(IR)) {
this->runOnModule(M, false);
PassLevel = "Module";
FuncOrModName = M->getName();
calculateDroppedVarStatsOnModule(M, PassID, FuncOrModName, PassLevel);
} else if (auto *F = unwrapIR<Function>(IR)) {
this->runOnFunction(F, false);
PassLevel = "Function";
FuncOrModName = F->getName();
calculateDroppedVarStatsOnFunction(F, PassID, FuncOrModName, PassLevel);
}
DebugVariablesStack.pop_back();
InlinedAts.pop_back();
}
bool DroppedVariableStats::isScopeChildOfOrEqualTo(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;
if (!InlinedAt)
return false;
auto *IA = InlinedAt;
while (IA) {
if (IA == DbgValInlinedAt)
return true;
IA = IA->getInlinedAt();
}
return false;
}
void StandardInstrumentations::registerCallbacks(
PassInstrumentationCallbacks &PIC, ModuleAnalysisManager *MAM) {
PrintIR.registerCallbacks(PIC);
@@ -2712,7 +2538,7 @@ void StandardInstrumentations::registerCallbacks(
WebsiteChangeReporter.registerCallbacks(PIC);
ChangeTester.registerCallbacks(PIC);
PrintCrashIR.registerCallbacks(PIC);
DroppedStats.registerCallbacks(PIC);
DroppedStatsIR.registerCallbacks(PIC);
if (MAM)
PreservedCFGChecker.registerCallbacks(PIC, *MAM);

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

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

74
llvm/unittests/IR/DroppedVariableStatsTest.cpp → llvm/unittests/CodeGen/DroppedVariableStatsIRTest.cpp
View File

@@ -1,5 +1,4 @@
//===- unittests/IR/DroppedVariableStatsTest.cpp - TimePassesHandler tests
//----------===//
//===- unittests/IR/DroppedVariableStatsIRTest.cpp ------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
@@ -8,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "llvm/AsmParser/Parser.h"
#include "llvm/CodeGen/DroppedVariableStats.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/InstIterator.h"
#include "llvm/IR/LegacyPassManager.h"
@@ -44,7 +44,7 @@ namespace {
// This test ensures that if a #dbg_value and an instruction that exists in the
// same scope as that #dbg_value are both deleted as a result of an optimization
// pass, debug information is considered not dropped.
TEST(DroppedVariableStats, BothDeleted) {
TEST(DroppedVariableStatsIR, BothDeleted) {
PassInstrumentationCallbacks PIC;
PassInstrumentation PI(&PIC);
@@ -79,9 +79,8 @@ TEST(DroppedVariableStats, BothDeleted) {
std::unique_ptr<llvm::Module> M = parseIR(C, IR);
ASSERT_TRUE(M);
DroppedVariableStats Stats(true);
Stats.runBeforePass("Test",
llvm::Any(const_cast<const llvm::Module *>(M.get())));
DroppedVariableStatsIR Stats(true);
Stats.runBeforePass(llvm::Any(const_cast<const llvm::Module *>(M.get())));
// This loop simulates an IR pass that drops debug information.
for (auto &F : *M) {
@@ -92,16 +91,15 @@ TEST(DroppedVariableStats, BothDeleted) {
}
break;
}
PreservedAnalyses PA;
Stats.runAfterPass("Test",
llvm::Any(const_cast<const llvm::Module *>(M.get())), PA);
llvm::Any(const_cast<const llvm::Module *>(M.get())));
ASSERT_EQ(Stats.getPassDroppedVariables(), false);
}
// This test ensures that if a #dbg_value is dropped after an optimization pass,
// but an instruction that shares the same scope as the #dbg_value still exists,
// debug information is conisdered dropped.
TEST(DroppedVariableStats, DbgValLost) {
TEST(DroppedVariableStatsIR, DbgValLost) {
PassInstrumentationCallbacks PIC;
PassInstrumentation PI(&PIC);
@@ -136,9 +134,8 @@ TEST(DroppedVariableStats, DbgValLost) {
std::unique_ptr<llvm::Module> M = parseIR(C, IR);
ASSERT_TRUE(M);
DroppedVariableStats Stats(true);
Stats.runBeforePass("Test",
llvm::Any(const_cast<const llvm::Module *>(M.get())));
DroppedVariableStatsIR Stats(true);
Stats.runBeforePass(llvm::Any(const_cast<const llvm::Module *>(M.get())));
// This loop simulates an IR pass that drops debug information.
for (auto &F : *M) {
@@ -148,16 +145,15 @@ TEST(DroppedVariableStats, DbgValLost) {
}
break;
}
PreservedAnalyses PA;
Stats.runAfterPass("Test",
llvm::Any(const_cast<const llvm::Module *>(M.get())), PA);
llvm::Any(const_cast<const llvm::Module *>(M.get())));
ASSERT_EQ(Stats.getPassDroppedVariables(), true);
}
// This test ensures that if a #dbg_value is dropped after an optimization pass,
// but an instruction that has an unrelated scope as the #dbg_value still
// exists, debug information is conisdered not dropped.
TEST(DroppedVariableStats, UnrelatedScopes) {
TEST(DroppedVariableStatsIR, UnrelatedScopes) {
PassInstrumentationCallbacks PIC;
PassInstrumentation PI(&PIC);
@@ -193,9 +189,8 @@ TEST(DroppedVariableStats, UnrelatedScopes) {
std::unique_ptr<llvm::Module> M = parseIR(C, IR);
ASSERT_TRUE(M);
DroppedVariableStats Stats(true);
Stats.runBeforePass("Test",
llvm::Any(const_cast<const llvm::Module *>(M.get())));
DroppedVariableStatsIR Stats(true);
Stats.runBeforePass(llvm::Any(const_cast<const llvm::Module *>(M.get())));
// This loop simulates an IR pass that drops debug information.
for (auto &F : *M) {
@@ -205,16 +200,15 @@ TEST(DroppedVariableStats, UnrelatedScopes) {
}
break;
}
PreservedAnalyses PA;
Stats.runAfterPass("Test",
llvm::Any(const_cast<const llvm::Module *>(M.get())), PA);
llvm::Any(const_cast<const llvm::Module *>(M.get())));
ASSERT_EQ(Stats.getPassDroppedVariables(), false);
}
// This test ensures that if a #dbg_value is dropped after an optimization pass,
// but an instruction that has a scope which is a child of the #dbg_value scope
// still exists, debug information is conisdered dropped.
TEST(DroppedVariableStats, ChildScopes) {
TEST(DroppedVariableStatsIR, ChildScopes) {
PassInstrumentationCallbacks PIC;
PassInstrumentation PI(&PIC);
@@ -250,9 +244,8 @@ TEST(DroppedVariableStats, ChildScopes) {
std::unique_ptr<llvm::Module> M = parseIR(C, IR);
ASSERT_TRUE(M);
DroppedVariableStats Stats(true);
Stats.runBeforePass("Test",
llvm::Any(const_cast<const llvm::Module *>(M.get())));
DroppedVariableStatsIR Stats(true);
Stats.runBeforePass(llvm::Any(const_cast<const llvm::Module *>(M.get())));
// This loop simulates an IR pass that drops debug information.
for (auto &F : *M) {
@@ -262,9 +255,8 @@ TEST(DroppedVariableStats, ChildScopes) {
}
break;
}
PreservedAnalyses PA;
Stats.runAfterPass("Test",
llvm::Any(const_cast<const llvm::Module *>(M.get())), PA);
llvm::Any(const_cast<const llvm::Module *>(M.get())));
ASSERT_EQ(Stats.getPassDroppedVariables(), true);
}
@@ -272,7 +264,7 @@ TEST(DroppedVariableStats, ChildScopes) {
// but an instruction that has a scope which is a child of the #dbg_value scope
// still exists, and the #dbg_value is inlined at another location, debug
// information is conisdered not dropped.
TEST(DroppedVariableStats, InlinedAt) {
TEST(DroppedVariableStatsIR, InlinedAt) {
PassInstrumentationCallbacks PIC;
PassInstrumentation PI(&PIC);
@@ -308,9 +300,8 @@ TEST(DroppedVariableStats, InlinedAt) {
std::unique_ptr<llvm::Module> M = parseIR(C, IR);
ASSERT_TRUE(M);
DroppedVariableStats Stats(true);
Stats.runBeforePass("Test",
llvm::Any(const_cast<const llvm::Module *>(M.get())));
DroppedVariableStatsIR Stats(true);
Stats.runBeforePass(llvm::Any(const_cast<const llvm::Module *>(M.get())));
// This loop simulates an IR pass that drops debug information.
for (auto &F : *M) {
@@ -320,9 +311,8 @@ TEST(DroppedVariableStats, InlinedAt) {
}
break;
}
PreservedAnalyses PA;
Stats.runAfterPass("Test",
llvm::Any(const_cast<const llvm::Module *>(M.get())), PA);
llvm::Any(const_cast<const llvm::Module *>(M.get())));
ASSERT_EQ(Stats.getPassDroppedVariables(), false);
}
@@ -330,7 +320,7 @@ TEST(DroppedVariableStats, InlinedAt) {
// but an instruction that has a scope which is a child of the #dbg_value scope
// still exists, and the #dbg_value and the instruction are inlined at another
// location, debug information is conisdered dropped.
TEST(DroppedVariableStats, InlinedAtShared) {
TEST(DroppedVariableStatsIR, InlinedAtShared) {
PassInstrumentationCallbacks PIC;
PassInstrumentation PI(&PIC);
@@ -366,9 +356,8 @@ TEST(DroppedVariableStats, InlinedAtShared) {
std::unique_ptr<llvm::Module> M = parseIR(C, IR);
ASSERT_TRUE(M);
DroppedVariableStats Stats(true);
Stats.runBeforePass("Test",
llvm::Any(const_cast<const llvm::Module *>(M.get())));
DroppedVariableStatsIR Stats(true);
Stats.runBeforePass(llvm::Any(const_cast<const llvm::Module *>(M.get())));
// This loop simulates an IR pass that drops debug information.
for (auto &F : *M) {
@@ -378,9 +367,8 @@ TEST(DroppedVariableStats, InlinedAtShared) {
}
break;
}
PreservedAnalyses PA;
Stats.runAfterPass("Test",
llvm::Any(const_cast<const llvm::Module *>(M.get())), PA);
llvm::Any(const_cast<const llvm::Module *>(M.get())));
ASSERT_EQ(Stats.getPassDroppedVariables(), true);
}
@@ -388,7 +376,7 @@ TEST(DroppedVariableStats, InlinedAtShared) {
// but an instruction that has a scope which is a child of the #dbg_value scope
// still exists, and the instruction is inlined at a location that is the
// #dbg_value's inlined at location, debug information is conisdered dropped.
TEST(DroppedVariableStats, InlinedAtChild) {
TEST(DroppedVariableStatsIR, InlinedAtChild) {
PassInstrumentationCallbacks PIC;
PassInstrumentation PI(&PIC);
@@ -425,9 +413,8 @@ TEST(DroppedVariableStats, InlinedAtChild) {
std::unique_ptr<llvm::Module> M = parseIR(C, IR);
ASSERT_TRUE(M);
DroppedVariableStats Stats(true);
Stats.runBeforePass("Test",
llvm::Any(const_cast<const llvm::Module *>(M.get())));
DroppedVariableStatsIR Stats(true);
Stats.runBeforePass(llvm::Any(const_cast<const llvm::Module *>(M.get())));
// This loop simulates an IR pass that drops debug information.
for (auto &F : *M) {
@@ -437,9 +424,8 @@ TEST(DroppedVariableStats, InlinedAtChild) {
}
break;
}
PreservedAnalyses PA;
Stats.runAfterPass("Test",
llvm::Any(const_cast<const llvm::Module *>(M.get())), PA);
llvm::Any(const_cast<const llvm::Module *>(M.get())));
ASSERT_EQ(Stats.getPassDroppedVariables(), true);
}

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

@@ -43,7 +43,6 @@ add_llvm_unittest(IRTests
ShuffleVectorInstTest.cpp
StructuralHashTest.cpp
TimePassesTest.cpp
DroppedVariableStatsTest.cpp
TypesTest.cpp
UseTest.cpp
UserTest.cpp