LLVM 19.0.0git
DebugHandlerBase.cpp
Go to the documentation of this file.
1//===-- llvm/lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp -------*- C++ -*--===//
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// Common functionality for different debug information format backends.
10// LLVM currently supports DWARF and CodeView.
11//
12//===----------------------------------------------------------------------===//
13
20#include "llvm/IR/DebugInfo.h"
21#include "llvm/MC/MCStreamer.h"
23
24using namespace llvm;
25
26#define DEBUG_TYPE "dwarfdebug"
27
28/// If true, we drop variable location ranges which exist entirely outside the
29/// variable's lexical scope instruction ranges.
30static cl::opt<bool> TrimVarLocs("trim-var-locs", cl::Hidden, cl::init(true));
31
32std::optional<DbgVariableLocation>
35 DbgVariableLocation Location;
36 // Variables calculated from multiple locations can't be represented here.
37 if (Instruction.getNumDebugOperands() != 1)
38 return std::nullopt;
39 if (!Instruction.getDebugOperand(0).isReg())
40 return std::nullopt;
41 Location.Register = Instruction.getDebugOperand(0).getReg();
42 Location.FragmentInfo.reset();
43 // We only handle expressions generated by DIExpression::appendOffset,
44 // which doesn't require a full stack machine.
45 int64_t Offset = 0;
46 const DIExpression *DIExpr = Instruction.getDebugExpression();
47 auto Op = DIExpr->expr_op_begin();
48 // We can handle a DBG_VALUE_LIST iff it has exactly one location operand that
49 // appears exactly once at the start of the expression.
50 if (Instruction.isDebugValueList()) {
51 if (Instruction.getNumDebugOperands() == 1 &&
52 Op->getOp() == dwarf::DW_OP_LLVM_arg)
53 ++Op;
54 else
55 return std::nullopt;
56 }
57 while (Op != DIExpr->expr_op_end()) {
58 switch (Op->getOp()) {
59 case dwarf::DW_OP_constu: {
60 int Value = Op->getArg(0);
61 ++Op;
62 if (Op != DIExpr->expr_op_end()) {
63 switch (Op->getOp()) {
64 case dwarf::DW_OP_minus:
65 Offset -= Value;
66 break;
67 case dwarf::DW_OP_plus:
68 Offset += Value;
69 break;
70 default:
71 continue;
72 }
73 }
74 } break;
75 case dwarf::DW_OP_plus_uconst:
76 Offset += Op->getArg(0);
77 break;
79 Location.FragmentInfo = {Op->getArg(1), Op->getArg(0)};
80 break;
81 case dwarf::DW_OP_deref:
82 Location.LoadChain.push_back(Offset);
83 Offset = 0;
84 break;
85 default:
86 return std::nullopt;
87 }
88 ++Op;
89 }
90
91 // Do one final implicit DW_OP_deref if this was an indirect DBG_VALUE
92 // instruction.
93 // FIXME: Replace these with DIExpression.
94 if (Instruction.isIndirectDebugValue())
95 Location.LoadChain.push_back(Offset);
96
97 return Location;
98}
99
101
103 if (M->debug_compile_units().empty())
104 Asm = nullptr;
105}
106
107// Each LexicalScope has first instruction and last instruction to mark
108// beginning and end of a scope respectively. Create an inverse map that list
109// scopes starts (and ends) with an instruction. One instruction may start (or
110// end) multiple scopes. Ignore scopes that are not reachable.
114 while (!WorkList.empty()) {
115 LexicalScope *S = WorkList.pop_back_val();
116
117 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
118 if (!Children.empty())
119 WorkList.append(Children.begin(), Children.end());
120
121 if (S->isAbstractScope())
122 continue;
123
124 for (const InsnRange &R : S->getRanges()) {
125 assert(R.first && "InsnRange does not have first instruction!");
126 assert(R.second && "InsnRange does not have second instruction!");
127 requestLabelBeforeInsn(R.first);
128 requestLabelAfterInsn(R.second);
129 }
130 }
131}
132
133// Return Label preceding the instruction.
135 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
136 assert(Label && "Didn't insert label before instruction");
137 return Label;
138}
139
140// Return Label immediately following the instruction.
142 return LabelsAfterInsn.lookup(MI);
143}
144
145/// If this type is derived from a base type then return base type size.
147 assert(Ty);
148 const DIDerivedType *DDTy = dyn_cast<DIDerivedType>(Ty);
149 if (!DDTy)
150 return Ty->getSizeInBits();
151
152 unsigned Tag = DDTy->getTag();
153
154 if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
155 Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
156 Tag != dwarf::DW_TAG_restrict_type && Tag != dwarf::DW_TAG_atomic_type &&
157 Tag != dwarf::DW_TAG_immutable_type &&
158 Tag != dwarf::DW_TAG_template_alias)
159 return DDTy->getSizeInBits();
160
161 DIType *BaseType = DDTy->getBaseType();
162
163 if (!BaseType)
164 return 0;
165
166 // If this is a derived type, go ahead and get the base type, unless it's a
167 // reference then it's just the size of the field. Pointer types have no need
168 // of this since they're a different type of qualification on the type.
169 if (BaseType->getTag() == dwarf::DW_TAG_reference_type ||
170 BaseType->getTag() == dwarf::DW_TAG_rvalue_reference_type)
171 return Ty->getSizeInBits();
172
174}
175
177 if (isa<DIStringType>(Ty)) {
178 // Some transformations (e.g. instcombine) may decide to turn a Fortran
179 // character object into an integer, and later ones (e.g. SROA) may
180 // further inject a constant integer in a llvm.dbg.value call to track
181 // the object's value. Here we trust the transformations are doing the
182 // right thing, and treat the constant as unsigned to preserve that value
183 // (i.e. avoid sign extension).
184 return true;
185 }
186
187 if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {
188 if (CTy->getTag() == dwarf::DW_TAG_enumeration_type) {
189 if (!(Ty = CTy->getBaseType()))
190 // FIXME: Enums without a fixed underlying type have unknown signedness
191 // here, leading to incorrectly emitted constants.
192 return false;
193 } else
194 // (Pieces of) aggregate types that get hacked apart by SROA may be
195 // represented by a constant. Encode them as unsigned bytes.
196 return true;
197 }
198
199 if (auto *DTy = dyn_cast<DIDerivedType>(Ty)) {
200 dwarf::Tag T = (dwarf::Tag)Ty->getTag();
201 // Encode pointer constants as unsigned bytes. This is used at least for
202 // null pointer constant emission.
203 // FIXME: reference and rvalue_reference /probably/ shouldn't be allowed
204 // here, but accept them for now due to a bug in SROA producing bogus
205 // dbg.values.
206 if (T == dwarf::DW_TAG_pointer_type ||
207 T == dwarf::DW_TAG_ptr_to_member_type ||
208 T == dwarf::DW_TAG_reference_type ||
209 T == dwarf::DW_TAG_rvalue_reference_type)
210 return true;
211 assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
212 T == dwarf::DW_TAG_volatile_type ||
213 T == dwarf::DW_TAG_restrict_type || T == dwarf::DW_TAG_atomic_type ||
214 T == dwarf::DW_TAG_immutable_type ||
215 T == dwarf::DW_TAG_template_alias);
216 assert(DTy->getBaseType() && "Expected valid base type");
217 return isUnsignedDIType(DTy->getBaseType());
218 }
219
220 auto *BTy = cast<DIBasicType>(Ty);
221 unsigned Encoding = BTy->getEncoding();
222 assert((Encoding == dwarf::DW_ATE_unsigned ||
223 Encoding == dwarf::DW_ATE_unsigned_char ||
224 Encoding == dwarf::DW_ATE_signed ||
225 Encoding == dwarf::DW_ATE_signed_char ||
226 Encoding == dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF ||
227 Encoding == dwarf::DW_ATE_boolean ||
228 Encoding == dwarf::DW_ATE_complex_float ||
229 Encoding == dwarf::DW_ATE_signed_fixed ||
230 Encoding == dwarf::DW_ATE_unsigned_fixed ||
231 (Ty->getTag() == dwarf::DW_TAG_unspecified_type &&
232 Ty->getName() == "decltype(nullptr)")) &&
233 "Unsupported encoding");
234 return Encoding == dwarf::DW_ATE_unsigned ||
235 Encoding == dwarf::DW_ATE_unsigned_char ||
236 Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
237 Encoding == llvm::dwarf::DW_ATE_unsigned_fixed ||
238 Ty->getTag() == dwarf::DW_TAG_unspecified_type;
239}
240
241static bool hasDebugInfo(const MachineModuleInfo *MMI,
242 const MachineFunction *MF) {
243 if (!MMI->hasDebugInfo())
244 return false;
245 auto *SP = MF->getFunction().getSubprogram();
246 if (!SP)
247 return false;
248 assert(SP->getUnit());
249 auto EK = SP->getUnit()->getEmissionKind();
250 if (EK == DICompileUnit::NoDebug)
251 return false;
252 return true;
253}
254
256 PrevInstBB = nullptr;
257
258 if (!Asm || !hasDebugInfo(MMI, MF)) {
260 return;
261 }
262
263 // Grab the lexical scopes for the function, if we don't have any of those
264 // then we're not going to be able to do anything.
265 LScopes.initialize(*MF);
266 if (LScopes.empty()) {
268 return;
269 }
270
271 // Make sure that each lexical scope will have a begin/end label.
273
274 // Calculate history for local variables.
275 assert(DbgValues.empty() && "DbgValues map wasn't cleaned!");
276 assert(DbgLabels.empty() && "DbgLabels map wasn't cleaned!");
279 InstOrdering.initialize(*MF);
280 if (TrimVarLocs)
281 DbgValues.trimLocationRanges(*MF, LScopes, InstOrdering);
283
284 // Request labels for the full history.
285 for (const auto &I : DbgValues) {
286 const auto &Entries = I.second;
287 if (Entries.empty())
288 continue;
289
290 auto IsDescribedByReg = [](const MachineInstr *MI) {
291 return any_of(MI->debug_operands(),
292 [](auto &MO) { return MO.isReg() && MO.getReg(); });
293 };
294
295 // The first mention of a function argument gets the CurrentFnBegin label,
296 // so arguments are visible when breaking at function entry.
297 //
298 // We do not change the label for values that are described by registers,
299 // as that could place them above their defining instructions. We should
300 // ideally not change the labels for constant debug values either, since
301 // doing that violates the ranges that are calculated in the history map.
302 // However, we currently do not emit debug values for constant arguments
303 // directly at the start of the function, so this code is still useful.
304 const DILocalVariable *DIVar =
305 Entries.front().getInstr()->getDebugVariable();
306 if (DIVar->isParameter() &&
307 getDISubprogram(DIVar->getScope())->describes(&MF->getFunction())) {
308 if (!IsDescribedByReg(Entries.front().getInstr()))
309 LabelsBeforeInsn[Entries.front().getInstr()] = Asm->getFunctionBegin();
310 if (Entries.front().getInstr()->getDebugExpression()->isFragment()) {
311 // Mark all non-overlapping initial fragments.
312 for (const auto *I = Entries.begin(); I != Entries.end(); ++I) {
313 if (!I->isDbgValue())
314 continue;
315 const DIExpression *Fragment = I->getInstr()->getDebugExpression();
316 if (std::any_of(Entries.begin(), I,
317 [&](DbgValueHistoryMap::Entry Pred) {
318 return Pred.isDbgValue() &&
319 Fragment->fragmentsOverlap(
320 Pred.getInstr()->getDebugExpression());
321 }))
322 break;
323 // The code that generates location lists for DWARF assumes that the
324 // entries' start labels are monotonically increasing, and since we
325 // don't change the label for fragments that are described by
326 // registers, we must bail out when encountering such a fragment.
327 if (IsDescribedByReg(I->getInstr()))
328 break;
329 LabelsBeforeInsn[I->getInstr()] = Asm->getFunctionBegin();
330 }
331 }
332 }
333
334 for (const auto &Entry : Entries) {
335 if (Entry.isDbgValue())
336 requestLabelBeforeInsn(Entry.getInstr());
337 else
338 requestLabelAfterInsn(Entry.getInstr());
339 }
340 }
341
342 // Ensure there is a symbol before DBG_LABEL.
343 for (const auto &I : DbgLabels) {
344 const MachineInstr *MI = I.second;
346 }
347
351}
352
354 if (!Asm || !MMI->hasDebugInfo())
355 return;
356
357 assert(CurMI == nullptr);
358 CurMI = MI;
359
360 // Insert labels where requested.
362 LabelsBeforeInsn.find(MI);
363
364 // No label needed.
365 if (I == LabelsBeforeInsn.end())
366 return;
367
368 // Label already assigned.
369 if (I->second)
370 return;
371
372 if (!PrevLabel) {
374 Asm->OutStreamer->emitLabel(PrevLabel);
375 }
376 I->second = PrevLabel;
377}
378
380 if (!Asm || !MMI->hasDebugInfo())
381 return;
382
383 assert(CurMI != nullptr);
384 // Don't create a new label after DBG_VALUE and other instructions that don't
385 // generate code.
386 if (!CurMI->isMetaInstruction()) {
387 PrevLabel = nullptr;
389 }
390
393
394 // No label needed or label already assigned.
395 if (I == LabelsAfterInsn.end() || I->second) {
396 CurMI = nullptr;
397 return;
398 }
399
400 // We need a label after this instruction. With basic block sections, just
401 // use the end symbol of the section if this is the last instruction of the
402 // section. This reduces the need for an additional label and also helps
403 // merging ranges.
404 if (CurMI->getParent()->isEndSection() && CurMI->getNextNode() == nullptr) {
406 } else if (!PrevLabel) {
408 Asm->OutStreamer->emitLabel(PrevLabel);
409 }
410 I->second = PrevLabel;
411 CurMI = nullptr;
412}
413
415 if (Asm && hasDebugInfo(MMI, MF))
416 endFunctionImpl(MF);
419 LabelsBeforeInsn.clear();
420 LabelsAfterInsn.clear();
421 InstOrdering.clear();
422}
423
425 EpilogBeginBlock = nullptr;
426 if (!MBB.isEntryBlock())
428}
429
431 PrevLabel = nullptr;
432}
MachineBasicBlock & MBB
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static cl::opt< bool > TrimVarLocs("trim-var-locs", cl::Hidden, cl::init(true))
If true, we drop variable location ranges which exist entirely outside the variable's lexical scope i...
static bool hasDebugInfo(const MachineModuleInfo *MMI, const MachineFunction *MF)
#define LLVM_DEBUG(X)
Definition: Debug.h:101
IRTranslator LLVM IR MI
#define I(x, y, z)
Definition: MD5.cpp:58
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:85
MCSymbol * getFunctionBegin() const
Definition: AsmPrinter.h:275
MachineFunction * MF
The current machine function.
Definition: AsmPrinter.h:103
std::unique_ptr< MCStreamer > OutStreamer
This is the MCStreamer object for the file we are generating.
Definition: AsmPrinter.h:100
DWARF expression.
expr_op_iterator expr_op_begin() const
Visit the elements via ExprOperand wrappers.
expr_op_iterator expr_op_end() const
DILocalScope * getScope() const
Get the local scope for this variable.
dwarf::Tag getTag() const
Base class for types.
StringRef getName() const
uint64_t getSizeInBits() const
This class represents an Operation in the Expression.
Specifies a change in a variable's debug value history.
void trimLocationRanges(const MachineFunction &MF, LexicalScopes &LScopes, const InstructionOrdering &Ordering)
Drop location ranges which exist entirely outside each variable's scope.
LLVM_DUMP_METHOD void dump(StringRef FuncName) const
static bool isUnsignedDIType(const DIType *Ty)
Return true if type encoding is unsigned.
const MachineInstr * CurMI
If nonnull, stores the current machine instruction we're processing.
AsmPrinter * Asm
Target of debug info emission.
virtual void endFunctionImpl(const MachineFunction *MF)=0
MCSymbol * getLabelBeforeInsn(const MachineInstr *MI)
Return Label preceding the instruction.
MachineModuleInfo * MMI
Collected machine module information.
void endBasicBlockSection(const MachineBasicBlock &MBB) override
Process the end of a basic-block-section within a function.
void identifyScopeMarkers()
Indentify instructions that are marking the beginning of or ending of a scope.
virtual void skippedNonDebugFunction()
void endFunction(const MachineFunction *MF) override
Gather post-function debug information.
DebugLoc PrevInstLoc
Previous instruction's location information.
void beginFunction(const MachineFunction *MF) override
Gather pre-function debug information.
void endInstruction() override
Process end of an instruction.
MCSymbol * getLabelAfterInsn(const MachineInstr *MI)
Return Label immediately following the instruction.
DebugHandlerBase(AsmPrinter *A)
void beginInstruction(const MachineInstr *MI) override
Process beginning of an instruction.
const MachineBasicBlock * PrevInstBB
virtual void beginFunctionImpl(const MachineFunction *MF)=0
void requestLabelAfterInsn(const MachineInstr *MI)
Ensure that a label will be emitted after MI.
void beginBasicBlockSection(const MachineBasicBlock &MBB) override
Process the beginning of a new basic-block-section within a function.
DbgValueHistoryMap DbgValues
History of DBG_VALUE and clobber instructions for each user variable.
DbgLabelInstrMap DbgLabels
Mapping of inlined labels and DBG_LABEL machine instruction.
DenseMap< const MachineInstr *, MCSymbol * > LabelsBeforeInsn
Maps instruction with label emitted before instruction.
void beginModule(Module *M) override
DenseMap< const MachineInstr *, MCSymbol * > LabelsAfterInsn
Maps instruction with label emitted after instruction.
void requestLabelBeforeInsn(const MachineInstr *MI)
Ensure that a label will be emitted before MI.
const MachineBasicBlock * EpilogBeginBlock
This block includes epilogue instructions.
static uint64_t getBaseTypeSize(const DIType *Ty)
If this type is derived from a base type then return base type size.
A debug info location.
Definition: DebugLoc.h:33
DISubprogram * getSubprogram() const
Get the attached subprogram.
Definition: Metadata.cpp:1830
void initialize(const MachineFunction &MF)
LexicalScope - This class is used to track scope information.
Definition: LexicalScopes.h:44
SmallVectorImpl< LexicalScope * > & getChildren()
Definition: LexicalScopes.h:65
SmallVectorImpl< InsnRange > & getRanges()
Definition: LexicalScopes.h:66
bool isAbstractScope() const
Definition: LexicalScopes.h:64
void initialize(const MachineFunction &)
initialize - Scan machine function and constuct lexical scope nest, resets the instance if necessary.
bool empty()
empty - Return true if there is any lexical scope information available.
LexicalScope * getCurrentFunctionScope() const
getCurrentFunctionScope - Return lexical scope for the current function.
MCSymbol * createTempSymbol()
Create a temporary symbol with a unique name.
Definition: MCContext.cpp:331
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:40
MCSymbol * getSymbol() const
Return the MCSymbol for this basic block.
MCSymbol * getEndSymbol() const
Returns the MCSymbol marking the end of this basic block.
bool isEntryBlock() const
Returns true if this is the entry block of the function.
bool isEndSection() const
Returns true if this block ends any section.
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
StringRef getName() const
getName - Return the name of the corresponding LLVM function.
Function & getFunction()
Return the LLVM function that this machine code represents.
Representation of each machine instruction.
Definition: MachineInstr.h:69
const MachineBasicBlock * getParent() const
Definition: MachineInstr.h:343
bool isMetaInstruction(QueryType Type=IgnoreBundle) const
Return true if this instruction doesn't produce any output in the form of executable instructions.
Definition: MachineInstr.h:933
This class contains meta information specific to a module.
const MCContext & getContext() const
bool hasDebugInfo() const
Returns true if valid debug info is present.
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
bool empty() const
Definition: SmallVector.h:94
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:586
void append(ItTy in_start, ItTy in_end)
Add the specified range to the end of the SmallVector.
Definition: SmallVector.h:696
void push_back(const T &Elt)
Definition: SmallVector.h:426
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
virtual const TargetRegisterInfo * getRegisterInfo() const
getRegisterInfo - If register information is available, return it.
LLVM Value Representation.
Definition: Value.h:74
NodeTy * getNextNode()
Get the next node, or nullptr for the list tail.
Definition: ilist_node.h:316
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:450
@ DW_OP_LLVM_fragment
Only used in LLVM metadata.
Definition: Dwarf.h:142
@ DW_OP_LLVM_arg
Only used in LLVM metadata.
Definition: Dwarf.h:147
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:456
void calculateDbgEntityHistory(const MachineFunction *MF, const TargetRegisterInfo *TRI, DbgValueHistoryMap &DbgValues, DbgLabelInstrMap &DbgLabels)
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1729
DWARFExpression::Operation Op
std::pair< const MachineInstr *, const MachineInstr * > InsnRange
InsnRange - This is used to track range of instructions with identical lexical scope.
Definition: LexicalScopes.h:39
DISubprogram * getDISubprogram(const MDNode *Scope)
Find subprogram that is enclosing this scope.
Definition: DebugInfo.cpp:152
Represents the location at which a variable is stored.
static std::optional< DbgVariableLocation > extractFromMachineInstruction(const MachineInstr &Instruction)
Extract a VariableLocation from a MachineInstr.