diff --git a/llvm/include/llvm/CodeGen/DroppedVariableStats.h b/llvm/include/llvm/CodeGen/DroppedVariableStats.h index 4ce432cb81c13a..371d775b02e876 100644 --- a/llvm/include/llvm/CodeGen/DroppedVariableStats.h +++ b/llvm/include/llvm/CodeGen/DroppedVariableStats.h @@ -23,9 +23,16 @@ namespace llvm { -/// 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. +/// 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; + +/// A base class to collect and print dropped debug information variable +/// statistics. class DroppedVariableStats { public: DroppedVariableStats(bool DroppedVarStatsEnabled) @@ -35,23 +42,32 @@ class DroppedVariableStats { << "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; - 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; - bool DroppedVariableStatsEnabled = false; - /// A unique key that represents a #dbg_value. - using VarID = - std::tuple; +protected: + void setup() { + DebugVariablesStack.push_back( + {DenseMap()}); + InlinedAts.push_back( + {DenseMap>()}); + } + 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 DebugVariablesBefore; @@ -59,6 +75,7 @@ class DroppedVariableStats { DenseSet 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. @@ -70,36 +87,134 @@ class DroppedVariableStats { /// DenseMap of VarIDs and their inlinedAt locations before an optimization /// pass has run. SmallVector>> 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); - /// 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); + /// 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 &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 &VarIDSet, + DenseMap> &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 &InlinedAtsMap, + VarID Var) = 0; + /// Visit every debug record in an llvm::Function or llvm::MachineFunction + /// and call populateVarIDSetAndInlinedMap on it. + virtual void visitEveryDebugRecord( + DenseSet &VarIDSet, + DenseMap> &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(IR)) + return this->runOnModule(M, true); + if (const auto *F = unwrapIR(IR)) + return this->runOnFunction(F, true); + } + + void runAfterPass(StringRef P, Any IR) { + if (const auto *M = unwrapIR(IR)) + runAfterPassModule(P, M); + else if (const auto *F = unwrapIR(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); - /// 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); + /// 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 &InlinedAtsMap, + VarID Var) override; + /// Override base class method to run on #dbg_values specifically. + virtual void visitEveryDebugRecord( + DenseSet &VarIDSet, + DenseMap> &InlinedAtsMap, + StringRef FuncName, bool Before) override; + template static const IRUnitT *unwrapIR(Any IR) { const IRUnitT **IRPtr = llvm::any_cast(&IR); return IRPtr ? *IRPtr : nullptr; diff --git a/llvm/include/llvm/Passes/StandardInstrumentations.h b/llvm/include/llvm/Passes/StandardInstrumentations.h index 9a8d09c264f08d..12a34c099eaffe 100644 --- a/llvm/include/llvm/Passes/StandardInstrumentations.h +++ b/llvm/include/llvm/Passes/StandardInstrumentations.h @@ -597,7 +597,7 @@ class StandardInstrumentations { PrintCrashIRInstrumentation PrintCrashIR; IRChangedTester ChangeTester; VerifyInstrumentation Verify; - DroppedVariableStats DroppedStats; + DroppedVariableStatsIR DroppedStatsIR; bool VerifyEach; diff --git a/llvm/lib/CodeGen/DroppedVariableStats.cpp b/llvm/lib/CodeGen/DroppedVariableStats.cpp index a1c6b5fccc139d..122fcad1293f1e 100644 --- a/llvm/lib/CodeGen/DroppedVariableStats.cpp +++ b/llvm/lib/CodeGen/DroppedVariableStats.cpp @@ -18,81 +18,43 @@ using namespace llvm; -void DroppedVariableStats::registerCallbacks( - PassInstrumentationCallbacks &PIC) { - if (!DroppedVariableStatsEnabled) - 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()}); - InlinedAts.push_back({DenseMap>()}); - if (auto *M = unwrapIR(IR)) - return this->runOnModule(M, true); - if (auto *F = unwrapIR(IR)) - return this->runOnFunction(F, true); - return; -} - -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()); - VarIDSet = DenseSet(); - for (const auto &I : instructions(F)) { - for (DbgRecord &DR : I.getDbgRecordRange()) { - if (auto *Dbg = dyn_cast(&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()); +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; } -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); +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::calculateDroppedVarStatsOnFunction( - const Function *F, StringRef PassID, std::string FuncOrModName, - std::string PassLevel) { +void DroppedVariableStats::calculateDroppedStatsAndPrint( + DebugVariables &DbgVariables, StringRef FuncName, StringRef PassID, + StringRef FuncOrModName, StringRef PassLevel, const Function *Func) { unsigned DroppedCount = 0; - StringRef FuncName = F->getName(); - DebugVariables &DbgVariables = DebugVariablesStack.back()[F]; DenseSet &DebugVariablesBeforeSet = DbgVariables.DebugVariablesBefore; DenseSet &DebugVariablesAfterSet = DbgVariables.DebugVariablesAfter; DenseMap &InlinedAtsMap = InlinedAts.back()[FuncName]; @@ -104,25 +66,8 @@ void DroppedVariableStats::calculateDroppedVarStatsOnFunction( 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); + visitEveryInstruction(DroppedCount, InlinedAtsMap, Var); + removeVarFromAllSets(Var, Func); } if (DroppedCount > 0) { llvm::outs() << PassLevel << ", " << PassID << ", " << DroppedCount << ", " @@ -132,64 +77,118 @@ void DroppedVariableStats::calculateDroppedVarStatsOnFunction( PassDroppedVariables = false; } -void DroppedVariableStats::runAfterPassInvalidated( - StringRef PassID, const PreservedAnalyses &PA) { - DebugVariablesStack.pop_back(); - InlinedAts.pop_back(); +bool DroppedVariableStats::updateDroppedCount( + DILocation *DbgLoc, const DIScope *Scope, const DIScope *DbgValScope, + DenseMap &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()); + VarIDSet = DenseSet(); + visitEveryDebugRecord(VarIDSet, InlinedAtsMap, FuncName, Before); } -void DroppedVariableStats::runAfterPass(StringRef PassID, Any IR, - const PreservedAnalyses &PA) { - std::string PassLevel; - std::string FuncOrModName; - if (auto *M = unwrapIR(IR)) { - this->runOnModule(M, false); - PassLevel = "Module"; - FuncOrModName = M->getName(); - calculateDroppedVarStatsOnModule(M, PassID, FuncOrModName, PassLevel); - } else if (auto *F = unwrapIR(IR)) { - this->runOnFunction(F, false); - PassLevel = "Function"; - FuncOrModName = F->getName(); - calculateDroppedVarStatsOnFunction(F, PassID, FuncOrModName, PassLevel); +void DroppedVariableStats::populateVarIDSetAndInlinedMap( + const DILocalVariable *DbgVar, DebugLoc DbgLoc, DenseSet &VarIDSet, + DenseMap> &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; - DebugVariablesStack.pop_back(); - InlinedAts.pop_back(); - 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(); }); } -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; - } +void DroppedVariableStatsIR::visitEveryInstruction( + unsigned &DroppedCount, DenseMap &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; } - 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(); +void DroppedVariableStatsIR::visitEveryDebugRecord( + DenseSet &VarIDSet, + DenseMap> &InlinedAtsMap, + StringRef FuncName, bool Before) { + for (const auto &I : instructions(Func)) { + for (DbgRecord &DR : I.getDbgRecordRange()) { + if (auto *Dbg = dyn_cast(&DR)) { + auto *DbgVar = Dbg->getVariable(); + auto DbgLoc = DR.getDebugLoc(); + populateVarIDSetAndInlinedMap(DbgVar, DbgLoc, VarIDSet, InlinedAtsMap, + FuncName, Before); + } + } } - return false; } diff --git a/llvm/lib/Passes/StandardInstrumentations.cpp b/llvm/lib/Passes/StandardInstrumentations.cpp index 70825bfa91da25..b766517e68eba5 100644 --- a/llvm/lib/Passes/StandardInstrumentations.cpp +++ b/llvm/lib/Passes/StandardInstrumentations.cpp @@ -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 = @@ -2538,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); diff --git a/llvm/unittests/IR/CMakeLists.txt b/llvm/unittests/IR/CMakeLists.txt index ed93ee547d2231..ffa989bec269e4 100644 --- a/llvm/unittests/IR/CMakeLists.txt +++ b/llvm/unittests/IR/CMakeLists.txt @@ -43,7 +43,7 @@ add_llvm_unittest(IRTests ShuffleVectorInstTest.cpp StructuralHashTest.cpp TimePassesTest.cpp - DroppedVariableStatsTest.cpp + DroppedVariableStatsIRTest.cpp TypesTest.cpp UseTest.cpp UserTest.cpp diff --git a/llvm/unittests/IR/DroppedVariableStatsTest.cpp b/llvm/unittests/IR/DroppedVariableStatsIRTest.cpp similarity index 91% rename from llvm/unittests/IR/DroppedVariableStatsTest.cpp rename to llvm/unittests/IR/DroppedVariableStatsIRTest.cpp index 61f3a87bb355e0..34803a9771850a 100644 --- a/llvm/unittests/IR/DroppedVariableStatsTest.cpp +++ b/llvm/unittests/IR/DroppedVariableStatsIRTest.cpp @@ -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. @@ -44,7 +43,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 +78,8 @@ TEST(DroppedVariableStats, BothDeleted) { std::unique_ptr M = parseIR(C, IR); ASSERT_TRUE(M); - DroppedVariableStats Stats(true); - Stats.runBeforePass("Test", - llvm::Any(const_cast(M.get()))); + DroppedVariableStatsIR Stats(true); + Stats.runBeforePass(llvm::Any(const_cast(M.get()))); // This loop simulates an IR pass that drops debug information. for (auto &F : *M) { @@ -92,16 +90,15 @@ TEST(DroppedVariableStats, BothDeleted) { } break; } - PreservedAnalyses PA; Stats.runAfterPass("Test", - llvm::Any(const_cast(M.get())), PA); + llvm::Any(const_cast(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 +133,8 @@ TEST(DroppedVariableStats, DbgValLost) { std::unique_ptr M = parseIR(C, IR); ASSERT_TRUE(M); - DroppedVariableStats Stats(true); - Stats.runBeforePass("Test", - llvm::Any(const_cast(M.get()))); + DroppedVariableStatsIR Stats(true); + Stats.runBeforePass(llvm::Any(const_cast(M.get()))); // This loop simulates an IR pass that drops debug information. for (auto &F : *M) { @@ -148,16 +144,15 @@ TEST(DroppedVariableStats, DbgValLost) { } break; } - PreservedAnalyses PA; Stats.runAfterPass("Test", - llvm::Any(const_cast(M.get())), PA); + llvm::Any(const_cast(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 +188,8 @@ TEST(DroppedVariableStats, UnrelatedScopes) { std::unique_ptr M = parseIR(C, IR); ASSERT_TRUE(M); - DroppedVariableStats Stats(true); - Stats.runBeforePass("Test", - llvm::Any(const_cast(M.get()))); + DroppedVariableStatsIR Stats(true); + Stats.runBeforePass(llvm::Any(const_cast(M.get()))); // This loop simulates an IR pass that drops debug information. for (auto &F : *M) { @@ -205,16 +199,15 @@ TEST(DroppedVariableStats, UnrelatedScopes) { } break; } - PreservedAnalyses PA; Stats.runAfterPass("Test", - llvm::Any(const_cast(M.get())), PA); + llvm::Any(const_cast(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 +243,8 @@ TEST(DroppedVariableStats, ChildScopes) { std::unique_ptr M = parseIR(C, IR); ASSERT_TRUE(M); - DroppedVariableStats Stats(true); - Stats.runBeforePass("Test", - llvm::Any(const_cast(M.get()))); + DroppedVariableStatsIR Stats(true); + Stats.runBeforePass(llvm::Any(const_cast(M.get()))); // This loop simulates an IR pass that drops debug information. for (auto &F : *M) { @@ -262,9 +254,8 @@ TEST(DroppedVariableStats, ChildScopes) { } break; } - PreservedAnalyses PA; Stats.runAfterPass("Test", - llvm::Any(const_cast(M.get())), PA); + llvm::Any(const_cast(M.get()))); ASSERT_EQ(Stats.getPassDroppedVariables(), true); } @@ -272,7 +263,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 +299,8 @@ TEST(DroppedVariableStats, InlinedAt) { std::unique_ptr M = parseIR(C, IR); ASSERT_TRUE(M); - DroppedVariableStats Stats(true); - Stats.runBeforePass("Test", - llvm::Any(const_cast(M.get()))); + DroppedVariableStatsIR Stats(true); + Stats.runBeforePass(llvm::Any(const_cast(M.get()))); // This loop simulates an IR pass that drops debug information. for (auto &F : *M) { @@ -320,9 +310,8 @@ TEST(DroppedVariableStats, InlinedAt) { } break; } - PreservedAnalyses PA; Stats.runAfterPass("Test", - llvm::Any(const_cast(M.get())), PA); + llvm::Any(const_cast(M.get()))); ASSERT_EQ(Stats.getPassDroppedVariables(), false); } @@ -330,7 +319,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 +355,8 @@ TEST(DroppedVariableStats, InlinedAtShared) { std::unique_ptr M = parseIR(C, IR); ASSERT_TRUE(M); - DroppedVariableStats Stats(true); - Stats.runBeforePass("Test", - llvm::Any(const_cast(M.get()))); + DroppedVariableStatsIR Stats(true); + Stats.runBeforePass(llvm::Any(const_cast(M.get()))); // This loop simulates an IR pass that drops debug information. for (auto &F : *M) { @@ -378,9 +366,8 @@ TEST(DroppedVariableStats, InlinedAtShared) { } break; } - PreservedAnalyses PA; Stats.runAfterPass("Test", - llvm::Any(const_cast(M.get())), PA); + llvm::Any(const_cast(M.get()))); ASSERT_EQ(Stats.getPassDroppedVariables(), true); } @@ -388,7 +375,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 +412,8 @@ TEST(DroppedVariableStats, InlinedAtChild) { std::unique_ptr M = parseIR(C, IR); ASSERT_TRUE(M); - DroppedVariableStats Stats(true); - Stats.runBeforePass("Test", - llvm::Any(const_cast(M.get()))); + DroppedVariableStatsIR Stats(true); + Stats.runBeforePass(llvm::Any(const_cast(M.get()))); // This loop simulates an IR pass that drops debug information. for (auto &F : *M) { @@ -437,9 +423,8 @@ TEST(DroppedVariableStats, InlinedAtChild) { } break; } - PreservedAnalyses PA; Stats.runAfterPass("Test", - llvm::Any(const_cast(M.get())), PA); + llvm::Any(const_cast(M.get()))); ASSERT_EQ(Stats.getPassDroppedVariables(), true); }