LLVM 17.0.0git
MachineDebugify.cpp
Go to the documentation of this file.
1//===- MachineDebugify.cpp - Attach synthetic debug info to everything ----===//
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/// \file This pass attaches synthetic debug info to everything. It can be used
10/// to create targeted tests for debug info preservation, or test for CodeGen
11/// differences with vs. without debug info.
12///
13/// This isn't intended to have feature parity with Debugify.
14//===----------------------------------------------------------------------===//
15
16#include "llvm/ADT/DenseMap.h"
17#include "llvm/ADT/SmallSet.h"
21#include "llvm/CodeGen/Passes.h"
27
28#define DEBUG_TYPE "mir-debugify"
29
30using namespace llvm;
31
32namespace {
33bool applyDebugifyMetadataToMachineFunction(MachineModuleInfo &MMI,
34 DIBuilder &DIB, Function &F) {
35 MachineFunction *MaybeMF = MMI.getMachineFunction(F);
36 if (!MaybeMF)
37 return false;
38 MachineFunction &MF = *MaybeMF;
40
41 DISubprogram *SP = F.getSubprogram();
42 assert(SP && "IR Debugify just created it?");
43
44 Module &M = *F.getParent();
45 LLVMContext &Ctx = M.getContext();
46
47 unsigned NextLine = SP->getLine();
48 for (MachineBasicBlock &MBB : MF) {
49 for (MachineInstr &MI : MBB) {
50 // This will likely emit line numbers beyond the end of the imagined
51 // source function and into subsequent ones. We don't do anything about
52 // that as it doesn't really matter to the compiler where the line is in
53 // the imaginary source code.
54 MI.setDebugLoc(DILocation::get(Ctx, NextLine++, 1, SP));
55 }
56 }
57
58 // Find local variables defined by debugify. No attempt is made to match up
59 // MIR-level regs to the 'correct' IR-level variables: there isn't a simple
60 // way to do that, and it isn't necessary to find interesting CodeGen bugs.
61 // Instead, simply keep track of one variable per line. Later, we can insert
62 // DBG_VALUE insts that point to these local variables. Emitting DBG_VALUEs
63 // which cover a wide range of lines can help stress the debug info passes:
64 // if we can't do that, fall back to using the local variable which precedes
65 // all the others.
66 Function *DbgValF = M.getFunction("llvm.dbg.value");
67 DbgValueInst *EarliestDVI = nullptr;
69 DIExpression *Expr = nullptr;
70 if (DbgValF) {
71 for (const Use &U : DbgValF->uses()) {
72 auto *DVI = dyn_cast<DbgValueInst>(U.getUser());
73 if (!DVI || DVI->getFunction() != &F)
74 continue;
75 unsigned Line = DVI->getDebugLoc().getLine();
76 assert(Line != 0 && "debugify should not insert line 0 locations");
77 Line2Var[Line] = DVI->getVariable();
78 if (!EarliestDVI || Line < EarliestDVI->getDebugLoc().getLine())
79 EarliestDVI = DVI;
80 Expr = DVI->getExpression();
81 }
82 }
83 if (Line2Var.empty())
84 return true;
85
86 // Now, try to insert a DBG_VALUE instruction after each real instruction.
87 // Do this by introducing debug uses of each register definition. If that is
88 // not possible (e.g. we have a phi or a meta instruction), emit a constant.
89 uint64_t NextImm = 0;
91 const MCInstrDesc &DbgValDesc = TII.get(TargetOpcode::DBG_VALUE);
92 for (MachineBasicBlock &MBB : MF) {
94 for (auto I = MBB.begin(), E = MBB.end(); I != E;) {
95 MachineInstr &MI = *I;
96 ++I;
97
98 // `I` may point to a DBG_VALUE created in the previous loop iteration.
99 if (MI.isDebugInstr())
100 continue;
101
102 // It's not allowed to insert DBG_VALUEs after a terminator.
103 if (MI.isTerminator())
104 continue;
105
106 // Find a suitable insertion point for the DBG_VALUE.
107 auto InsertBeforeIt = MI.isPHI() ? FirstNonPHIIt : I;
108
109 // Find a suitable local variable for the DBG_VALUE.
110 unsigned Line = MI.getDebugLoc().getLine();
111 if (!Line2Var.count(Line))
112 Line = EarliestDVI->getDebugLoc().getLine();
113 DILocalVariable *LocalVar = Line2Var[Line];
114 assert(LocalVar && "No variable for current line?");
115 VarSet.insert(LocalVar);
116
117 // Emit DBG_VALUEs for register definitions.
119 for (MachineOperand &MO : MI.operands())
120 if (MO.isReg() && MO.isDef() && MO.getReg())
121 RegDefs.push_back(&MO);
122 for (MachineOperand *MO : RegDefs)
123 BuildMI(MBB, InsertBeforeIt, MI.getDebugLoc(), DbgValDesc,
124 /*IsIndirect=*/false, *MO, LocalVar, Expr);
125
126 // OK, failing that, emit a constant DBG_VALUE.
127 if (RegDefs.empty()) {
128 auto ImmOp = MachineOperand::CreateImm(NextImm++);
129 BuildMI(MBB, InsertBeforeIt, MI.getDebugLoc(), DbgValDesc,
130 /*IsIndirect=*/false, ImmOp, LocalVar, Expr);
131 }
132 }
133 }
134
135 // Here we save the number of lines and variables into "llvm.mir.debugify".
136 // It is useful for mir-check-debugify.
137 NamedMDNode *NMD = M.getNamedMetadata("llvm.mir.debugify");
139 if (!NMD) {
140 NMD = M.getOrInsertNamedMetadata("llvm.mir.debugify");
141 auto addDebugifyOperand = [&](unsigned N) {
144 };
145 // Add number of lines.
146 addDebugifyOperand(NextLine - 1);
147 // Add number of variables.
148 addDebugifyOperand(VarSet.size());
149 } else {
150 assert(NMD->getNumOperands() == 2 &&
151 "llvm.mir.debugify should have exactly 2 operands!");
152 auto setDebugifyOperand = [&](unsigned Idx, unsigned N) {
155 };
156 auto getDebugifyOperand = [&](unsigned Idx) {
157 return mdconst::extract<ConstantInt>(NMD->getOperand(Idx)->getOperand(0))
158 ->getZExtValue();
159 };
160 // Set number of lines.
161 setDebugifyOperand(0, NextLine - 1);
162 // Set number of variables.
163 auto OldNumVars = getDebugifyOperand(1);
164 setDebugifyOperand(1, OldNumVars + VarSet.size());
165 }
166
167 return true;
168}
169
170/// ModulePass for attaching synthetic debug info to everything, used with the
171/// legacy module pass manager.
172struct DebugifyMachineModule : public ModulePass {
173 bool runOnModule(Module &M) override {
174 // We will insert new debugify metadata, so erasing the old one.
175 assert(!M.getNamedMetadata("llvm.mir.debugify") &&
176 "llvm.mir.debugify metadata already exists! Strip it first");
177 MachineModuleInfo &MMI =
178 getAnalysis<MachineModuleInfoWrapperPass>().getMMI();
180 M, M.functions(),
181 "ModuleDebugify: ", [&](DIBuilder &DIB, Function &F) -> bool {
182 return applyDebugifyMetadataToMachineFunction(MMI, DIB, F);
183 });
184 }
185
186 DebugifyMachineModule() : ModulePass(ID) {}
187
188 void getAnalysisUsage(AnalysisUsage &AU) const override {
191 AU.setPreservesCFG();
192 }
193
194 static char ID; // Pass identification.
195};
196char DebugifyMachineModule::ID = 0;
197
198} // end anonymous namespace
199
200INITIALIZE_PASS_BEGIN(DebugifyMachineModule, DEBUG_TYPE,
201 "Machine Debugify Module", false, false)
202INITIALIZE_PASS_END(DebugifyMachineModule, DEBUG_TYPE,
203 "Machine Debugify Module", false, false)
204
206 return new DebugifyMachineModule();
207}
MachineBasicBlock & MBB
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
This file defines the DenseMap class.
const HexagonInstrInfo * TII
IRTranslator LLVM IR MI
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
#define DEBUG_TYPE
static DebugLoc getDebugLoc(MachineBasicBlock::instr_iterator FirstMI, MachineBasicBlock::instr_iterator LastMI)
Return the first found DebugLoc that has a DILocation, given a range of instructions.
IntegerType * Int32Ty
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:59
#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:52
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallSet class.
This file defines the SmallVector class.
Represent the analysis usage information of a pass.
AnalysisUsage & addRequired()
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
void setPreservesCFG()
This function should be called by the pass, iff they do not:
Definition: Pass.cpp:265
static Constant * get(Type *Ty, uint64_t V, bool IsSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
Definition: Constants.cpp:887
DWARF expression.
Subprogram description.
This represents the llvm.dbg.value instruction.
unsigned getLine() const
Definition: DebugLoc.cpp:24
bool empty() const
Definition: DenseMap.h:98
size_type count(const_arg_type_t< KeyT > Val) const
Return 1 if the specified key is in the map, 0 otherwise.
Definition: DenseMap.h:145
const DebugLoc & getDebugLoc() const
Return the debug location for this node as a DebugLoc.
Definition: Instruction.h:358
Class to represent integer types.
Definition: DerivedTypes.h:40
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:67
Describe properties that are true of each instruction in the target description file.
Definition: MCInstrDesc.h:198
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1291
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition: Metadata.h:1399
iterator getFirstNonPHI()
Returns a pointer to the first instruction in this block that is not a PHINode instruction.
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
Representation of each machine instruction.
Definition: MachineInstr.h:68
This class contains meta information specific to a module.
MachineFunction * getMachineFunction(const Function &F) const
Returns the MachineFunction associated to IR function F if there is one, otherwise nullptr.
MachineOperand class - Representation of each machine instruction operand.
static MachineOperand CreateImm(int64_t Val)
ModulePass class - This class is used to implement unstructured interprocedural optimizations and ana...
Definition: Pass.h:248
virtual bool runOnModule(Module &M)=0
runOnModule - Virtual method overriden by subclasses to process the module being operated on.
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
A tuple of MDNodes.
Definition: Metadata.h:1587
void setOperand(unsigned I, MDNode *New)
Definition: Metadata.cpp:1223
MDNode * getOperand(unsigned i) const
Definition: Metadata.cpp:1215
unsigned getNumOperands() const
Definition: Metadata.cpp:1211
void addOperand(MDNode *M)
Definition: Metadata.cpp:1221
virtual void getAnalysisUsage(AnalysisUsage &) const
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
Definition: Pass.cpp:98
SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less...
Definition: SmallSet.h:135
std::pair< const_iterator, bool > insert(const T &V)
insert - Insert an element into the set if it isn't already there.
Definition: SmallSet.h:177
size_type size() const
Definition: SmallSet.h:159
bool empty() const
Definition: SmallVector.h:94
void push_back(const T &Elt)
Definition: SmallVector.h:416
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1200
TargetInstrInfo - Interface to description of machine instruction set.
virtual const TargetInstrInfo * getInstrInfo() const
static IntegerType * getInt32Ty(LLVMContext &C)
A Use represents the edge between a Value definition and its users.
Definition: Use.h:43
static ConstantAsMetadata * getConstant(Value *C)
Definition: Metadata.h:366
iterator_range< use_iterator > uses()
Definition: Value.h:376
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
MachineInstrBuilder BuildMI(MachineFunction &MF, const MIMetadata &MIMD, const MCInstrDesc &MCID)
Builder interface. Specify how to create the initial instruction itself.
bool applyDebugifyMetadata(Module &M, iterator_range< Module::iterator > Functions, StringRef Banner, std::function< bool(DIBuilder &, Function &)> ApplyToMF)
Add synthesized debug information to a module.
ModulePass * createDebugifyMachineModulePass()
Creates MIR Debugify pass.
#define N