LLVM  13.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  if (!Instruction.isDebugValue())
39  return None;
40  if (!Instruction.getDebugOperand(0).isReg())
41  return None;
42  Location.Register = Instruction.getDebugOperand(0).getReg();
43  Location.FragmentInfo.reset();
44  // We only handle expressions generated by DIExpression::appendOffset,
45  // which doesn't require a full stack machine.
46  int64_t Offset = 0;
47  const DIExpression *DIExpr = Instruction.getDebugExpression();
48  auto Op = DIExpr->expr_op_begin();
49  while (Op != DIExpr->expr_op_end()) {
50  switch (Op->getOp()) {
51  case dwarf::DW_OP_constu: {
52  int Value = Op->getArg(0);
53  ++Op;
54  if (Op != DIExpr->expr_op_end()) {
55  switch (Op->getOp()) {
56  case dwarf::DW_OP_minus:
57  Offset -= Value;
58  break;
59  case dwarf::DW_OP_plus:
60  Offset += Value;
61  break;
62  default:
63  continue;
64  }
65  }
66  } break;
67  case dwarf::DW_OP_plus_uconst:
68  Offset += Op->getArg(0);
69  break;
71  Location.FragmentInfo = {Op->getArg(1), Op->getArg(0)};
72  break;
73  case dwarf::DW_OP_deref:
74  Location.LoadChain.push_back(Offset);
75  Offset = 0;
76  break;
77  default:
78  return None;
79  }
80  ++Op;
81  }
82 
83  // Do one final implicit DW_OP_deref if this was an indirect DBG_VALUE
84  // instruction.
85  // FIXME: Replace these with DIExpression.
86  if (Instruction.isIndirectDebugValue())
87  Location.LoadChain.push_back(Offset);
88 
89  return Location;
90 }
91 
93 
95  if (M->debug_compile_units().empty())
96  Asm = nullptr;
97 }
98 
99 // Each LexicalScope has first instruction and last instruction to mark
100 // beginning and end of a scope respectively. Create an inverse map that list
101 // scopes starts (and ends) with an instruction. One instruction may start (or
102 // end) multiple scopes. Ignore scopes that are not reachable.
105  WorkList.push_back(LScopes.getCurrentFunctionScope());
106  while (!WorkList.empty()) {
107  LexicalScope *S = WorkList.pop_back_val();
108 
109  const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
110  if (!Children.empty())
111  WorkList.append(Children.begin(), Children.end());
112 
113  if (S->isAbstractScope())
114  continue;
115 
116  for (const InsnRange &R : S->getRanges()) {
117  assert(R.first && "InsnRange does not have first instruction!");
118  assert(R.second && "InsnRange does not have second instruction!");
119  requestLabelBeforeInsn(R.first);
120  requestLabelAfterInsn(R.second);
121  }
122  }
123 }
124 
125 // Return Label preceding the instruction.
127  MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
128  assert(Label && "Didn't insert label before instruction");
129  return Label;
130 }
131 
132 // Return Label immediately following the instruction.
134  return LabelsAfterInsn.lookup(MI);
135 }
136 
137 /// If this type is derived from a base type then return base type size.
139  assert(Ty);
140  const DIDerivedType *DDTy = dyn_cast<DIDerivedType>(Ty);
141  if (!DDTy)
142  return Ty->getSizeInBits();
143 
144  unsigned Tag = DDTy->getTag();
145 
146  if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
147  Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
148  Tag != dwarf::DW_TAG_restrict_type && Tag != dwarf::DW_TAG_atomic_type)
149  return DDTy->getSizeInBits();
150 
151  DIType *BaseType = DDTy->getBaseType();
152 
153  if (!BaseType)
154  return 0;
155 
156  // If this is a derived type, go ahead and get the base type, unless it's a
157  // reference then it's just the size of the field. Pointer types have no need
158  // of this since they're a different type of qualification on the type.
159  if (BaseType->getTag() == dwarf::DW_TAG_reference_type ||
160  BaseType->getTag() == dwarf::DW_TAG_rvalue_reference_type)
161  return Ty->getSizeInBits();
162 
163  return getBaseTypeSize(BaseType);
164 }
165 
167  if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {
168  // FIXME: Enums without a fixed underlying type have unknown signedness
169  // here, leading to incorrectly emitted constants.
170  if (CTy->getTag() == dwarf::DW_TAG_enumeration_type)
171  return false;
172 
173  // (Pieces of) aggregate types that get hacked apart by SROA may be
174  // represented by a constant. Encode them as unsigned bytes.
175  return true;
176  }
177 
178  if (auto *DTy = dyn_cast<DIDerivedType>(Ty)) {
179  dwarf::Tag T = (dwarf::Tag)Ty->getTag();
180  // Encode pointer constants as unsigned bytes. This is used at least for
181  // null pointer constant emission.
182  // FIXME: reference and rvalue_reference /probably/ shouldn't be allowed
183  // here, but accept them for now due to a bug in SROA producing bogus
184  // dbg.values.
185  if (T == dwarf::DW_TAG_pointer_type ||
186  T == dwarf::DW_TAG_ptr_to_member_type ||
187  T == dwarf::DW_TAG_reference_type ||
188  T == dwarf::DW_TAG_rvalue_reference_type)
189  return true;
190  assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
191  T == dwarf::DW_TAG_volatile_type ||
192  T == dwarf::DW_TAG_restrict_type || T == dwarf::DW_TAG_atomic_type);
193  assert(DTy->getBaseType() && "Expected valid base type");
194  return isUnsignedDIType(DTy->getBaseType());
195  }
196 
197  auto *BTy = cast<DIBasicType>(Ty);
198  unsigned Encoding = BTy->getEncoding();
199  assert((Encoding == dwarf::DW_ATE_unsigned ||
200  Encoding == dwarf::DW_ATE_unsigned_char ||
201  Encoding == dwarf::DW_ATE_signed ||
202  Encoding == dwarf::DW_ATE_signed_char ||
203  Encoding == dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF ||
204  Encoding == dwarf::DW_ATE_boolean ||
205  (Ty->getTag() == dwarf::DW_TAG_unspecified_type &&
206  Ty->getName() == "decltype(nullptr)")) &&
207  "Unsupported encoding");
208  return Encoding == dwarf::DW_ATE_unsigned ||
209  Encoding == dwarf::DW_ATE_unsigned_char ||
210  Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
211  Ty->getTag() == dwarf::DW_TAG_unspecified_type;
212 }
213 
214 static bool hasDebugInfo(const MachineModuleInfo *MMI,
215  const MachineFunction *MF) {
216  if (!MMI->hasDebugInfo())
217  return false;
218  auto *SP = MF->getFunction().getSubprogram();
219  if (!SP)
220  return false;
221  assert(SP->getUnit());
222  auto EK = SP->getUnit()->getEmissionKind();
223  if (EK == DICompileUnit::NoDebug)
224  return false;
225  return true;
226 }
227 
229  PrevInstBB = nullptr;
230 
231  if (!Asm || !hasDebugInfo(MMI, MF)) {
233  return;
234  }
235 
236  // Grab the lexical scopes for the function, if we don't have any of those
237  // then we're not going to be able to do anything.
238  LScopes.initialize(*MF);
239  if (LScopes.empty()) {
240  beginFunctionImpl(MF);
241  return;
242  }
243 
244  // Make sure that each lexical scope will have a begin/end label.
246 
247  // Calculate history for local variables.
248  assert(DbgValues.empty() && "DbgValues map wasn't cleaned!");
249  assert(DbgLabels.empty() && "DbgLabels map wasn't cleaned!");
252  InstOrdering.initialize(*MF);
253  if (TrimVarLocs)
254  DbgValues.trimLocationRanges(*MF, LScopes, InstOrdering);
256 
257  // Request labels for the full history.
258  for (const auto &I : DbgValues) {
259  const auto &Entries = I.second;
260  if (Entries.empty())
261  continue;
262 
263  auto IsDescribedByReg = [](const MachineInstr *MI) {
264  return MI->getDebugOperand(0).isReg() && MI->getDebugOperand(0).getReg();
265  };
266 
267  // The first mention of a function argument gets the CurrentFnBegin label,
268  // so arguments are visible when breaking at function entry.
269  //
270  // We do not change the label for values that are described by registers,
271  // as that could place them above their defining instructions. We should
272  // ideally not change the labels for constant debug values either, since
273  // doing that violates the ranges that are calculated in the history map.
274  // However, we currently do not emit debug values for constant arguments
275  // directly at the start of the function, so this code is still useful.
276  // FIXME: If the first mention of an argument is in a unique section basic
277  // block, we cannot always assign the CurrentFnBeginLabel as it lies in a
278  // different section. Temporarily, we disable generating loc list
279  // information or DW_AT_const_value when the block is in a different
280  // section.
281  const DILocalVariable *DIVar =
282  Entries.front().getInstr()->getDebugVariable();
283  if (DIVar->isParameter() &&
284  getDISubprogram(DIVar->getScope())->describes(&MF->getFunction()) &&
285  Entries.front().getInstr()->getParent()->sameSection(&MF->front())) {
286  if (!IsDescribedByReg(Entries.front().getInstr()))
287  LabelsBeforeInsn[Entries.front().getInstr()] = Asm->getFunctionBegin();
288  if (Entries.front().getInstr()->getDebugExpression()->isFragment()) {
289  // Mark all non-overlapping initial fragments.
290  for (auto I = Entries.begin(); I != Entries.end(); ++I) {
291  if (!I->isDbgValue())
292  continue;
293  const DIExpression *Fragment = I->getInstr()->getDebugExpression();
294  if (std::any_of(Entries.begin(), I,
295  [&](DbgValueHistoryMap::Entry Pred) {
296  return Pred.isDbgValue() &&
297  Fragment->fragmentsOverlap(
298  Pred.getInstr()->getDebugExpression());
299  }))
300  break;
301  // The code that generates location lists for DWARF assumes that the
302  // entries' start labels are monotonically increasing, and since we
303  // don't change the label for fragments that are described by
304  // registers, we must bail out when encountering such a fragment.
305  if (IsDescribedByReg(I->getInstr()))
306  break;
307  LabelsBeforeInsn[I->getInstr()] = Asm->getFunctionBegin();
308  }
309  }
310  }
311 
312  for (const auto &Entry : Entries) {
313  if (Entry.isDbgValue())
314  requestLabelBeforeInsn(Entry.getInstr());
315  else
316  requestLabelAfterInsn(Entry.getInstr());
317  }
318  }
319 
320  // Ensure there is a symbol before DBG_LABEL.
321  for (const auto &I : DbgLabels) {
322  const MachineInstr *MI = I.second;
324  }
325 
326  PrevInstLoc = DebugLoc();
328  beginFunctionImpl(MF);
329 }
330 
332  if (!Asm || !MMI->hasDebugInfo())
333  return;
334 
335  assert(CurMI == nullptr);
336  CurMI = MI;
337 
338  // Insert labels where requested.
340  LabelsBeforeInsn.find(MI);
341 
342  // No label needed.
343  if (I == LabelsBeforeInsn.end())
344  return;
345 
346  // Label already assigned.
347  if (I->second)
348  return;
349 
350  if (!PrevLabel) {
352  Asm->OutStreamer->emitLabel(PrevLabel);
353  }
354  I->second = PrevLabel;
355 }
356 
358  if (!Asm || !MMI->hasDebugInfo())
359  return;
360 
361  assert(CurMI != nullptr);
362  // Don't create a new label after DBG_VALUE and other instructions that don't
363  // generate code.
364  if (!CurMI->isMetaInstruction()) {
365  PrevLabel = nullptr;
367  }
368 
370  LabelsAfterInsn.find(CurMI);
371  CurMI = nullptr;
372 
373  // No label needed.
374  if (I == LabelsAfterInsn.end())
375  return;
376 
377  // Label already assigned.
378  if (I->second)
379  return;
380 
381  // We need a label after this instruction.
382  if (!PrevLabel) {
384  Asm->OutStreamer->emitLabel(PrevLabel);
385  }
386  I->second = PrevLabel;
387 }
388 
390  if (Asm && hasDebugInfo(MMI, MF))
391  endFunctionImpl(MF);
392  DbgValues.clear();
393  DbgLabels.clear();
394  LabelsBeforeInsn.clear();
395  LabelsAfterInsn.clear();
396  InstOrdering.clear();
397 }
398 
400  if (!MBB.isBeginSection())
401  return;
402 
403  PrevLabel = MBB.getSymbol();
404 }
405 
407  if (!MBB.isEndSection())
408  return;
409 
410  PrevLabel = nullptr;
411 }
llvm::DebugHandlerBase::beginFunction
void beginFunction(const MachineFunction *MF) override
Gather pre-function debug information.
Definition: DebugHandlerBase.cpp:228
AsmPrinter.h
llvm::DebugHandlerBase::endInstruction
void endInstruction() override
Process end of an instruction.
Definition: DebugHandlerBase.cpp:357
llvm::InstructionOrdering::initialize
void initialize(const MachineFunction &MF)
Definition: DbgEntityHistoryCalculator.cpp:56
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:331
MI
IRTranslator LLVM IR MI
Definition: IRTranslator.cpp:100
MachineInstr.h
llvm
This class represents lattice values for constants.
Definition: AllocatorList.h:23
llvm::DIType
Base class for types.
Definition: DebugInfoMetadata.h:654
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:133
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:167
llvm::DIType::getSizeInBits
uint64_t getSizeInBits() const
Definition: DebugInfoMetadata.h:693
hasDebugInfo
static bool hasDebugInfo(const MachineModuleInfo *MMI, const MachineFunction *MF)
Definition: DebugHandlerBase.cpp:214
llvm::DbgValueHistoryMap::Entry
Specifies a change in a variable's debug value history.
Definition: DbgEntityHistoryCalculator.h:73
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1168
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:1526
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:140
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:203
llvm::DenseMapIterator
Definition: DenseMap.h:56
llvm::DebugHandlerBase::beginModule
void beginModule(Module *M) override
Definition: DebugHandlerBase.cpp:94
llvm::getDISubprogram
DISubprogram * getDISubprogram(const MDNode *Scope)
Find subprogram that is enclosing this scope.
Definition: DebugInfo.cpp:43
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
T
#define T
Definition: Mips16ISelLowering.cpp:341
llvm::DILocalVariable::isParameter
bool isParameter() const
Definition: DebugInfoMetadata.h:3079
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:81
llvm::SmallVectorImpl::pop_back_val
LLVM_NODISCARD T pop_back_val()
Definition: SmallVector.h:635
llvm::DIExpression
DWARF expression.
Definition: DebugInfoMetadata.h:2553
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:122
llvm::MachineBasicBlock::isBeginSection
bool isBeginSection() const
Returns true if this block begins any section.
Definition: MachineBasicBlock.h:473
llvm::MachineBasicBlock::getSymbol
MCSymbol * getSymbol() const
Return the MCSymbol for this basic block.
Definition: MachineBasicBlock.cpp:59
CommandLine.h
llvm::MachineFunction::front
const MachineBasicBlock & front() const
Definition: MachineFunction.h:749
llvm::DILocalVariable
Local variable.
Definition: DebugInfoMetadata.h:3022
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:648
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:700
llvm::calculateDbgEntityHistory
void calculateDbgEntityHistory(const MachineFunction *MF, const TargetRegisterInfo *TRI, DbgValueHistoryMap &DbgValues, DbgLabelInstrMap &DbgLabels)
Definition: DbgEntityHistoryCalculator.cpp:432
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:78
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:126
llvm::None
const NoneType None
Definition: None.h:23
llvm::AsmPrinter::getFunctionBegin
MCSymbol * getFunctionBegin() const
Definition: AsmPrinter.h:237
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:138
llvm::DILocalVariable::getScope
DILocalScope * getScope() const
Get the local scope for this variable.
Definition: DebugInfoMetadata.h:3075
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:555
llvm::cl::opt< bool >
llvm::DbgLabelInstrMap::empty
bool empty() const
Definition: DbgEntityHistoryCalculator.h:144
llvm::DbgValueHistoryMap::dump
LLVM_DUMP_METHOD void dump() const
Definition: DbgEntityHistoryCalculator.cpp:541
llvm::DebugHandlerBase::PrevInstBB
const MachineBasicBlock * PrevInstBB
Definition: DebugHandlerBase.h:69
llvm::MachineInstr
Representation of each machine instruction.
Definition: MachineInstr.h:63
llvm::Optional::reset
void reset()
Definition: Optional.h:276
llvm::InstructionOrdering::clear
void clear()
Definition: DbgEntityHistoryCalculator.h:34
DebugInfo.h
I
#define I(x, y, z)
Definition: MD5.cpp:59
llvm::cl::init
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:440
llvm::DebugHandlerBase::beginFunctionImpl
virtual void beginFunctionImpl(const MachineFunction *MF)=0
llvm::DbgLabelInstrMap::clear
void clear()
Definition: DbgEntityHistoryCalculator.h:145
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:406
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:1295
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:67
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:146
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:227
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:1315
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:1505
llvm::DINode::getTag
unsigned getTag() const
Definition: DebugInfoMetadata.h:151
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:285
llvm::MCContext::createTempSymbol
MCSymbol * createTempSymbol()
Create a temporary symbol with a unique name.
Definition: MCContext.cpp:268
llvm::DebugHandlerBase::beginBasicBlock
void beginBasicBlock(const MachineBasicBlock &MBB) override
Process beginning of a basic block during basic block sections.
Definition: DebugHandlerBase.cpp:399
MBB
MachineBasicBlock & MBB
Definition: AArch64SLSHardening.cpp:74
llvm::MachineFunction::getFunction
Function & getFunction()
Return the LLVM function that this machine code represents.
Definition: MachineFunction.h:521
llvm::MachineBasicBlock::isEndSection
bool isEndSection() const
Returns true if this block ends any section.
Definition: MachineBasicBlock.h:476
llvm::AMDGPU::SendMsg::Op
Op
Definition: SIDefines.h:302
llvm::TargetStackID::Value
Value
Definition: TargetFrameLowering.h:27
llvm::DbgValueHistoryMap::empty
bool empty() const
Definition: DbgEntityHistoryCalculator.h:120
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:909
llvm::DebugHandlerBase::identifyScopeMarkers
void identifyScopeMarkers()
Indentify instructions that are marking the beginning of or ending of a scope.
Definition: DebugHandlerBase.cpp:103
llvm::DebugHandlerBase::PrevLabel
MCSymbol * PrevLabel
Definition: DebugHandlerBase.h:68
llvm::DebugHandlerBase::DebugHandlerBase
DebugHandlerBase(AsmPrinter *A)
Definition: DebugHandlerBase.cpp:92
llvm::DbgValueHistoryMap::clear
void clear()
Definition: DbgEntityHistoryCalculator.h:121
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:2683
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:166
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:75
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:389
llvm::DIExpression::expr_op_begin
expr_op_iterator expr_op_begin() const
Visit the elements via ExprOperand wrappers.
Definition: DebugInfoMetadata.h:2680