xref: /freebsd/contrib/llvm-project/llvm/lib/CodeGen/RemoveRedundantDebugValues.cpp (revision 7fdf597e96a02165cfe22ff357b857d5fa15ed8a)
1 //===- RemoveRedundantDebugValues.cpp - Remove Redundant Debug Value MIs --===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "llvm/ADT/DenseMap.h"
10 #include "llvm/ADT/DenseSet.h"
11 #include "llvm/ADT/SmallVector.h"
12 #include "llvm/ADT/Statistic.h"
13 #include "llvm/CodeGen/MachineBasicBlock.h"
14 #include "llvm/CodeGen/MachineFunctionPass.h"
15 #include "llvm/CodeGen/TargetSubtargetInfo.h"
16 #include "llvm/IR/DebugInfoMetadata.h"
17 #include "llvm/IR/Function.h"
18 #include "llvm/InitializePasses.h"
19 #include "llvm/Pass.h"
20 #include "llvm/PassRegistry.h"
21 
22 /// \file RemoveRedundantDebugValues.cpp
23 ///
24 /// The RemoveRedundantDebugValues pass removes redundant DBG_VALUEs that
25 /// appear in MIR after the register allocator.
26 
27 #define DEBUG_TYPE "removeredundantdebugvalues"
28 
29 using namespace llvm;
30 
31 STATISTIC(NumRemovedBackward, "Number of DBG_VALUEs removed (backward scan)");
32 STATISTIC(NumRemovedForward, "Number of DBG_VALUEs removed (forward scan)");
33 
34 namespace {
35 
36 class RemoveRedundantDebugValues : public MachineFunctionPass {
37 public:
38   static char ID;
39 
40   RemoveRedundantDebugValues();
41 
42   bool reduceDbgValues(MachineFunction &MF);
43 
44   /// Remove redundant debug value MIs for the given machine function.
45   bool runOnMachineFunction(MachineFunction &MF) override;
46 
47   void getAnalysisUsage(AnalysisUsage &AU) const override {
48     AU.setPreservesCFG();
49     MachineFunctionPass::getAnalysisUsage(AU);
50   }
51 };
52 
53 } // namespace
54 
55 //===----------------------------------------------------------------------===//
56 //            Implementation
57 //===----------------------------------------------------------------------===//
58 
59 char RemoveRedundantDebugValues::ID = 0;
60 
61 char &llvm::RemoveRedundantDebugValuesID = RemoveRedundantDebugValues::ID;
62 
63 INITIALIZE_PASS(RemoveRedundantDebugValues, DEBUG_TYPE,
64                 "Remove Redundant DEBUG_VALUE analysis", false, false)
65 
66 /// Default construct and initialize the pass.
67 RemoveRedundantDebugValues::RemoveRedundantDebugValues()
68     : MachineFunctionPass(ID) {
69   initializeRemoveRedundantDebugValuesPass(*PassRegistry::getPassRegistry());
70 }
71 
72 // This analysis aims to remove redundant DBG_VALUEs by going forward
73 // in the basic block by considering the first DBG_VALUE as a valid
74 // until its first (location) operand is not clobbered/modified.
75 // For example:
76 //   (1) DBG_VALUE $edi, !"var1", ...
77 //   (2) <block of code that does affect $edi>
78 //   (3) DBG_VALUE $edi, !"var1", ...
79 //   ...
80 // in this case, we can remove (3).
81 // TODO: Support DBG_VALUE_LIST and other debug instructions.
82 static bool reduceDbgValsForwardScan(MachineBasicBlock &MBB) {
83   LLVM_DEBUG(dbgs() << "\n == Forward Scan == \n");
84 
85   SmallVector<MachineInstr *, 8> DbgValsToBeRemoved;
86   DenseMap<DebugVariable, std::pair<MachineOperand *, const DIExpression *>>
87       VariableMap;
88   const auto *TRI = MBB.getParent()->getSubtarget().getRegisterInfo();
89 
90   for (auto &MI : MBB) {
91     if (MI.isDebugValue()) {
92       DebugVariable Var(MI.getDebugVariable(), std::nullopt,
93                         MI.getDebugLoc()->getInlinedAt());
94       auto VMI = VariableMap.find(Var);
95       // Just stop tracking this variable, until we cover DBG_VALUE_LIST.
96       // 1  DBG_VALUE $rax, "x", DIExpression()
97       // ...
98       // 2  DBG_VALUE_LIST "x", DIExpression(...), $rax, $rbx
99       // ...
100       // 3  DBG_VALUE $rax, "x", DIExpression()
101       if (MI.isDebugValueList() && VMI != VariableMap.end()) {
102         VariableMap.erase(VMI);
103         continue;
104       }
105 
106       MachineOperand &Loc = MI.getDebugOperand(0);
107       if (!Loc.isReg()) {
108         // If it's not a register, just stop tracking such variable.
109         if (VMI != VariableMap.end())
110           VariableMap.erase(VMI);
111         continue;
112       }
113 
114       // We have found a new value for a variable.
115       if (VMI == VariableMap.end() ||
116           VMI->second.first->getReg() != Loc.getReg() ||
117           VMI->second.second != MI.getDebugExpression()) {
118         VariableMap[Var] = {&Loc, MI.getDebugExpression()};
119         continue;
120       }
121 
122       // Found an identical DBG_VALUE, so it can be considered
123       // for later removal.
124       DbgValsToBeRemoved.push_back(&MI);
125     }
126 
127     if (MI.isMetaInstruction())
128       continue;
129 
130     // Stop tracking any location that is clobbered by this instruction.
131     for (auto &Var : VariableMap) {
132       auto &LocOp = Var.second.first;
133       if (MI.modifiesRegister(LocOp->getReg(), TRI))
134         VariableMap.erase(Var.first);
135     }
136   }
137 
138   for (auto &Instr : DbgValsToBeRemoved) {
139     LLVM_DEBUG(dbgs() << "removing "; Instr->dump());
140     Instr->eraseFromParent();
141     ++NumRemovedForward;
142   }
143 
144   return !DbgValsToBeRemoved.empty();
145 }
146 
147 // This analysis aims to remove redundant DBG_VALUEs by going backward
148 // in the basic block and removing all but the last DBG_VALUE for any
149 // given variable in a set of consecutive DBG_VALUE instructions.
150 // For example:
151 //   (1) DBG_VALUE $edi, !"var1", ...
152 //   (2) DBG_VALUE $esi, !"var2", ...
153 //   (3) DBG_VALUE $edi, !"var1", ...
154 //   ...
155 // in this case, we can remove (1).
156 static bool reduceDbgValsBackwardScan(MachineBasicBlock &MBB) {
157   LLVM_DEBUG(dbgs() << "\n == Backward Scan == \n");
158   SmallVector<MachineInstr *, 8> DbgValsToBeRemoved;
159   SmallDenseSet<DebugVariable> VariableSet;
160 
161   for (MachineInstr &MI : llvm::reverse(MBB)) {
162     if (MI.isDebugValue()) {
163       DebugVariable Var(MI.getDebugVariable(), MI.getDebugExpression(),
164                         MI.getDebugLoc()->getInlinedAt());
165       auto R = VariableSet.insert(Var);
166       // If it is a DBG_VALUE describing a constant as:
167       //   DBG_VALUE 0, ...
168       // we just don't consider such instructions as candidates
169       // for redundant removal.
170       if (MI.isNonListDebugValue()) {
171         MachineOperand &Loc = MI.getDebugOperand(0);
172         if (!Loc.isReg()) {
173           // If we have already encountered this variable, just stop
174           // tracking it.
175           if (!R.second)
176             VariableSet.erase(Var);
177           continue;
178         }
179       }
180 
181       // We have already encountered the value for this variable,
182       // so this one can be deleted.
183       if (!R.second)
184         DbgValsToBeRemoved.push_back(&MI);
185       continue;
186     }
187 
188     // If we encountered a non-DBG_VALUE, try to find the next
189     // sequence with consecutive DBG_VALUE instructions.
190     VariableSet.clear();
191   }
192 
193   for (auto &Instr : DbgValsToBeRemoved) {
194     LLVM_DEBUG(dbgs() << "removing "; Instr->dump());
195     Instr->eraseFromParent();
196     ++NumRemovedBackward;
197   }
198 
199   return !DbgValsToBeRemoved.empty();
200 }
201 
202 bool RemoveRedundantDebugValues::reduceDbgValues(MachineFunction &MF) {
203   LLVM_DEBUG(dbgs() << "\nDebug Value Reduction\n");
204 
205   bool Changed = false;
206 
207   for (auto &MBB : MF) {
208     Changed |= reduceDbgValsBackwardScan(MBB);
209     Changed |= reduceDbgValsForwardScan(MBB);
210   }
211 
212   return Changed;
213 }
214 
215 bool RemoveRedundantDebugValues::runOnMachineFunction(MachineFunction &MF) {
216   // Skip functions without debugging information.
217   if (!MF.getFunction().getSubprogram())
218     return false;
219 
220   // Skip functions from NoDebug compilation units.
221   if (MF.getFunction().getSubprogram()->getUnit()->getEmissionKind() ==
222       DICompileUnit::NoDebug)
223     return false;
224 
225   bool Changed = reduceDbgValues(MF);
226   return Changed;
227 }
228