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