blob: de6129a912d329ca7fc81e94dec3ff97c26a39d3 [file] [log] [blame]
//===- RemoveRedundantDebugValues.cpp - Remove Redundant Debug Value MIs --===//
//
// 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
//
//===----------------------------------------------------------------------===//
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/DenseSet.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/CodeGen/MachineBasicBlock.h"
#include "llvm/CodeGen/MachineFunctionPass.h"
#include "llvm/CodeGen/Passes.h"
#include "llvm/CodeGen/TargetRegisterInfo.h"
#include "llvm/CodeGen/TargetSubtargetInfo.h"
#include "llvm/IR/DebugInfoMetadata.h"
#include "llvm/IR/Function.h"
#include "llvm/InitializePasses.h"
#include "llvm/Pass.h"
/// \file RemoveRedundantDebugValues.cpp
///
/// The RemoveRedundantDebugValues pass removes redundant DBG_VALUEs that
/// appear in MIR after the register allocator.
#define DEBUG_TYPE "removeredundantdebugvalues"
using namespace llvm;
STATISTIC(NumRemovedBackward, "Number of DBG_VALUEs removed (backward scan)");
STATISTIC(NumRemovedForward, "Number of DBG_VALUEs removed (forward scan)");
namespace {
class RemoveRedundantDebugValues : public MachineFunctionPass {
public:
static char ID;
RemoveRedundantDebugValues();
bool reduceDbgValues(MachineFunction &MF);
/// Remove redundant debug value MIs for the given machine function.
bool runOnMachineFunction(MachineFunction &MF) override;
void getAnalysisUsage(AnalysisUsage &AU) const override {
AU.setPreservesCFG();
MachineFunctionPass::getAnalysisUsage(AU);
}
};
} // namespace
//===----------------------------------------------------------------------===//
// Implementation
//===----------------------------------------------------------------------===//
char RemoveRedundantDebugValues::ID = 0;
char &llvm::RemoveRedundantDebugValuesID = RemoveRedundantDebugValues::ID;
INITIALIZE_PASS(RemoveRedundantDebugValues, DEBUG_TYPE,
"Remove Redundant DEBUG_VALUE analysis", false, false)
/// Default construct and initialize the pass.
RemoveRedundantDebugValues::RemoveRedundantDebugValues()
: MachineFunctionPass(ID) {
initializeRemoveRedundantDebugValuesPass(*PassRegistry::getPassRegistry());
}
// This analysis aims to remove redundant DBG_VALUEs by going forward
// in the basic block by considering the first DBG_VALUE as a valid
// until its first (location) operand is not clobbered/modified.
// For example:
// (1) DBG_VALUE $edi, !"var1", ...
// (2) <block of code that does affect $edi>
// (3) DBG_VALUE $edi, !"var1", ...
// ...
// in this case, we can remove (3).
// TODO: Support DBG_VALUE_LIST and other debug instructions.
static bool reduceDbgValsForwardScan(MachineBasicBlock &MBB) {
LLVM_DEBUG(dbgs() << "\n == Forward Scan == \n");
SmallVector<MachineInstr *, 8> DbgValsToBeRemoved;
DenseMap<DebugVariable, std::pair<MachineOperand *, const DIExpression *>>
VariableMap;
const auto *TRI = MBB.getParent()->getSubtarget().getRegisterInfo();
for (auto &MI : MBB) {
if (MI.isDebugValue()) {
DebugVariable Var(MI.getDebugVariable(), NoneType(),
MI.getDebugLoc()->getInlinedAt());
auto VMI = VariableMap.find(Var);
// Just stop tracking this variable, until we cover DBG_VALUE_LIST.
// 1 DBG_VALUE $rax, "x", DIExpression()
// ...
// 2 DBG_VALUE_LIST "x", DIExpression(...), $rax, $rbx
// ...
// 3 DBG_VALUE $rax, "x", DIExpression()
if (MI.isDebugValueList() && VMI != VariableMap.end()) {
VariableMap.erase(VMI);
continue;
}
MachineOperand &Loc = MI.getDebugOperand(0);
if (!Loc.isReg()) {
// If it it's not a register, just stop tracking such variable.
if (VMI != VariableMap.end())
VariableMap.erase(VMI);
continue;
}
// We have found a new value for a variable.
if (VMI == VariableMap.end() ||
VMI->second.first->getReg() != Loc.getReg() ||
VMI->second.second != MI.getDebugExpression()) {
VariableMap[Var] = {&Loc, MI.getDebugExpression()};
continue;
}
// Found an identical DBG_VALUE, so it can be considered
// for later removal.
DbgValsToBeRemoved.push_back(&MI);
}
if (MI.isMetaInstruction())
continue;
// Stop tracking any location that is clobbered by this instruction.
for (auto &Var : VariableMap) {
auto &LocOp = Var.second.first;
if (MI.modifiesRegister(LocOp->getReg(), TRI))
VariableMap.erase(Var.first);
}
}
for (auto &Instr : DbgValsToBeRemoved) {
LLVM_DEBUG(dbgs() << "removing "; Instr->dump());
Instr->eraseFromParent();
++NumRemovedForward;
}
return !DbgValsToBeRemoved.empty();
}
// This analysis aims to remove redundant DBG_VALUEs by going backward
// in the basic block and removing all but the last DBG_VALUE for any
// given variable in a set of consecutive DBG_VALUE instructions.
// For example:
// (1) DBG_VALUE $edi, !"var1", ...
// (2) DBG_VALUE $esi, !"var2", ...
// (3) DBG_VALUE $edi, !"var1", ...
// ...
// in this case, we can remove (1).
static bool reduceDbgValsBackwardScan(MachineBasicBlock &MBB) {
LLVM_DEBUG(dbgs() << "\n == Backward Scan == \n");
SmallVector<MachineInstr *, 8> DbgValsToBeRemoved;
SmallDenseSet<DebugVariable> VariableSet;
for (MachineBasicBlock::reverse_iterator I = MBB.rbegin(), E = MBB.rend();
I != E; ++I) {
MachineInstr *MI = &*I;
if (MI->isDebugValue()) {
DebugVariable Var(MI->getDebugVariable(), MI->getDebugExpression(),
MI->getDebugLoc()->getInlinedAt());
auto R = VariableSet.insert(Var);
// If it is a DBG_VALUE describing a constant as:
// DBG_VALUE 0, ...
// we just don't consider such instructions as candidates
// for redundant removal.
if (MI->isNonListDebugValue()) {
MachineOperand &Loc = MI->getDebugOperand(0);
if (!Loc.isReg()) {
// If we have already encountered this variable, just stop
// tracking it.
if (!R.second)
VariableSet.erase(Var);
continue;
}
}
// We have already encountered the value for this variable,
// so this one can be deleted.
if (!R.second)
DbgValsToBeRemoved.push_back(MI);
continue;
}
// If we encountered a non-DBG_VALUE, try to find the next
// sequence with consecutive DBG_VALUE instructions.
VariableSet.clear();
}
for (auto &Instr : DbgValsToBeRemoved) {
LLVM_DEBUG(dbgs() << "removing "; Instr->dump());
Instr->eraseFromParent();
++NumRemovedBackward;
}
return !DbgValsToBeRemoved.empty();
}
bool RemoveRedundantDebugValues::reduceDbgValues(MachineFunction &MF) {
LLVM_DEBUG(dbgs() << "\nDebug Value Reduction\n");
bool Changed = false;
for (auto &MBB : MF) {
Changed |= reduceDbgValsBackwardScan(MBB);
Changed |= reduceDbgValsForwardScan(MBB);
}
return Changed;
}
bool RemoveRedundantDebugValues::runOnMachineFunction(MachineFunction &MF) {
// Skip functions without debugging information.
if (!MF.getFunction().getSubprogram())
return false;
// Skip functions from NoDebug compilation units.
if (MF.getFunction().getSubprogram()->getUnit()->getEmissionKind() ==
DICompileUnit::NoDebug)
return false;
bool Changed = reduceDbgValues(MF);
return Changed;
}