LLVM  4.0.0
DwarfCompileUnit.cpp
Go to the documentation of this file.
1 #include "DwarfCompileUnit.h"
2 #include "DwarfExpression.h"
4 #include "llvm/IR/Constants.h"
5 #include "llvm/IR/DataLayout.h"
6 #include "llvm/IR/GlobalValue.h"
8 #include "llvm/IR/Instruction.h"
9 #include "llvm/MC/MCAsmInfo.h"
10 #include "llvm/MC/MCStreamer.h"
16 
17 namespace llvm {
18 
20  AsmPrinter *A, DwarfDebug *DW,
21  DwarfFile *DWU)
22  : DwarfUnit(dwarf::DW_TAG_compile_unit, Node, A, DW, DWU), UniqueID(UID),
23  Skeleton(nullptr), BaseAddress(nullptr) {
24  insertDIE(Node, &getUnitDie());
25  MacroLabelBegin = Asm->createTempSymbol("cu_macro_begin");
26 }
27 
28 /// addLabelAddress - Add a dwarf label attribute data and value using
29 /// DW_FORM_addr or DW_FORM_GNU_addr_index.
30 ///
32  const MCSymbol *Label) {
33 
34  // Don't use the address pool in non-fission or in the skeleton unit itself.
35  // FIXME: Once GDB supports this, it's probably worthwhile using the address
36  // pool from the skeleton - maybe even in non-fission (possibly fewer
37  // relocations by sharing them in the pool, but we have other ideas about how
38  // to reduce the number of relocations as well/instead).
39  if (!DD->useSplitDwarf() || !Skeleton)
40  return addLocalLabelAddress(Die, Attribute, Label);
41 
42  if (Label)
43  DD->addArangeLabel(SymbolCU(this, Label));
44 
45  unsigned idx = DD->getAddressPool().getIndex(Label);
46  Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_GNU_addr_index,
47  DIEInteger(idx));
48 }
49 
52  const MCSymbol *Label) {
53  if (Label)
54  DD->addArangeLabel(SymbolCU(this, Label));
55 
56  if (Label)
57  Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_addr,
58  DIELabel(Label));
59  else
60  Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_addr,
61  DIEInteger(0));
62 }
63 
66  // If we print assembly, we can't separate .file entries according to
67  // compile units. Thus all files will belong to the default compile unit.
68 
69  // FIXME: add a better feature test than hasRawTextSupport. Even better,
70  // extend .file to support this.
71  return Asm->OutStreamer->EmitDwarfFileDirective(
72  0, DirName, FileName,
73  Asm->OutStreamer->hasRawTextSupport() ? 0 : getUniqueID());
74 }
75 
77  const DIGlobalVariable *GV, ArrayRef<GlobalExpr> GlobalExprs) {
78  // Check for pre-existence.
79  if (DIE *Die = getDIE(GV))
80  return Die;
81 
82  assert(GV);
83 
84  auto *GVContext = GV->getScope();
85  auto *GTy = DD->resolve(GV->getType());
86 
87  // Construct the context before querying for the existence of the DIE in
88  // case such construction creates the DIE.
89  DIE *ContextDIE = getOrCreateContextDIE(GVContext);
90 
91  // Add to map.
92  DIE *VariableDIE = &createAndAddDIE(GV->getTag(), *ContextDIE, GV);
93  DIScope *DeclContext;
94  if (auto *SDMDecl = GV->getStaticDataMemberDeclaration()) {
95  DeclContext = resolve(SDMDecl->getScope());
96  assert(SDMDecl->isStaticMember() && "Expected static member decl");
97  assert(GV->isDefinition());
98  // We need the declaration DIE that is in the static member's class.
99  DIE *VariableSpecDIE = getOrCreateStaticMemberDIE(SDMDecl);
100  addDIEEntry(*VariableDIE, dwarf::DW_AT_specification, *VariableSpecDIE);
101  // If the global variable's type is different from the one in the class
102  // member type, assume that it's more specific and also emit it.
103  if (GTy != DD->resolve(SDMDecl->getBaseType()))
104  addType(*VariableDIE, GTy);
105  } else {
106  DeclContext = GV->getScope();
107  // Add name and type.
108  addString(*VariableDIE, dwarf::DW_AT_name, GV->getDisplayName());
109  addType(*VariableDIE, GTy);
110 
111  // Add scoping info.
112  if (!GV->isLocalToUnit())
113  addFlag(*VariableDIE, dwarf::DW_AT_external);
114 
115  // Add line number info.
116  addSourceLine(*VariableDIE, GV);
117  }
118 
119  if (!GV->isDefinition())
120  addFlag(*VariableDIE, dwarf::DW_AT_declaration);
121  else
122  addGlobalName(GV->getName(), *VariableDIE, DeclContext);
123 
124  if (uint32_t AlignInBytes = GV->getAlignInBytes())
125  addUInt(*VariableDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
126  AlignInBytes);
127 
128  // Add location.
129  bool addToAccelTable = false;
130  DIELoc *Loc = nullptr;
131  std::unique_ptr<DIEDwarfExpression> DwarfExpr;
132  bool AllConstant = std::all_of(
133  GlobalExprs.begin(), GlobalExprs.end(),
134  [&](const GlobalExpr GE) {
135  return GE.Expr && GE.Expr->isConstant();
136  });
137 
138  for (const auto &GE : GlobalExprs) {
139  const GlobalVariable *Global = GE.Var;
140  const DIExpression *Expr = GE.Expr;
141  // For compatibility with DWARF 3 and earlier,
142  // DW_AT_location(DW_OP_constu, X, DW_OP_stack_value) becomes
143  // DW_AT_const_value(X).
144  if (GlobalExprs.size() == 1 && Expr && Expr->isConstant()) {
145  addConstantValue(*VariableDIE, /*Unsigned=*/true, Expr->getElement(1));
146  // We cannot describe the location of dllimport'd variables: the
147  // computation of their address requires loads from the IAT.
148  } else if ((Global && !Global->hasDLLImportStorageClass()) || AllConstant) {
149  if (!Loc) {
150  Loc = new (DIEValueAllocator) DIELoc;
151  DwarfExpr = llvm::make_unique<DIEDwarfExpression>(*Asm, *this, *Loc);
152  }
153  addToAccelTable = true;
154  if (Global) {
155  const MCSymbol *Sym = Asm->getSymbol(Global);
156  if (Global->isThreadLocal()) {
157  if (Asm->TM.Options.EmulatedTLS) {
158  // TODO: add debug info for emulated thread local mode.
159  } else {
160  // FIXME: Make this work with -gsplit-dwarf.
161  unsigned PointerSize = Asm->getDataLayout().getPointerSize();
162  assert((PointerSize == 4 || PointerSize == 8) &&
163  "Add support for other sizes if necessary");
164  // Based on GCC's support for TLS:
165  if (!DD->useSplitDwarf()) {
166  // 1) Start with a constNu of the appropriate pointer size
167  addUInt(*Loc, dwarf::DW_FORM_data1,
168  PointerSize == 4 ? dwarf::DW_OP_const4u
169  : dwarf::DW_OP_const8u);
170  // 2) containing the (relocated) offset of the TLS variable
171  // within the module's TLS block.
172  addExpr(*Loc, dwarf::DW_FORM_udata,
174  } else {
175  addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
176  addUInt(*Loc, dwarf::DW_FORM_udata,
177  DD->getAddressPool().getIndex(Sym, /* TLS */ true));
178  }
179  // 3) followed by an OP to make the debugger do a TLS lookup.
180  addUInt(*Loc, dwarf::DW_FORM_data1,
181  DD->useGNUTLSOpcode() ? dwarf::DW_OP_GNU_push_tls_address
182  : dwarf::DW_OP_form_tls_address);
183  }
184  } else {
185  DD->addArangeLabel(SymbolCU(this, Sym));
186  addOpAddress(*Loc, Sym);
187  }
188  }
189  if (Expr) {
190  DwarfExpr->addFragmentOffset(Expr);
191  DwarfExpr->AddExpression(Expr);
192  }
193  }
194  }
195  if (Loc)
196  addBlock(*VariableDIE, dwarf::DW_AT_location, DwarfExpr->finalize());
197 
198  if (DD->useAllLinkageNames())
199  addLinkageName(*VariableDIE, GV->getLinkageName());
200 
201  if (addToAccelTable) {
202  DD->addAccelName(GV->getName(), *VariableDIE);
203 
204  // If the linkage name is different than the name, go ahead and output
205  // that as well into the name table.
206  if (GV->getLinkageName() != "" && GV->getName() != GV->getLinkageName())
207  DD->addAccelName(GV->getLinkageName(), *VariableDIE);
208  }
209 
210  return VariableDIE;
211 }
212 
214  bool SameAsPrevCU = this == DD->getPrevCU();
215  DD->setPrevCU(this);
216  // If we have no current ranges just add the range and return, otherwise,
217  // check the current section and CU against the previous section and CU we
218  // emitted into and the subprogram was contained within. If these are the
219  // same then extend our current range, otherwise add this as a new range.
220  if (CURanges.empty() || !SameAsPrevCU ||
221  (&CURanges.back().getEnd()->getSection() !=
222  &Range.getEnd()->getSection())) {
223  CURanges.push_back(Range);
224  return;
225  }
226 
227  CURanges.back().setEnd(Range.getEnd());
228 }
229 
232  const MCSymbol *Label, const MCSymbol *Sec) {
234  return addLabel(Die, Attribute,
235  DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
236  : dwarf::DW_FORM_data4,
237  Label);
238  return addSectionDelta(Die, Attribute, Label, Sec);
239 }
240 
242  // Define start line table label for each Compile Unit.
243  MCSymbol *LineTableStartSym =
244  Asm->OutStreamer->getDwarfLineTableSymbol(getUniqueID());
245 
246  // DW_AT_stmt_list is a offset of line number information for this
247  // compile unit in debug_line section. For split dwarf this is
248  // left in the skeleton CU and so not included.
249  // The line table entries are not always emitted in assembly, so it
250  // is not okay to use line_table_start here.
252  StmtListValue =
253  addSectionLabel(getUnitDie(), dwarf::DW_AT_stmt_list, LineTableStartSym,
255 }
256 
258  D.addValue(DIEValueAllocator, *StmtListValue);
259 }
260 
262  const MCSymbol *End) {
263  assert(Begin && "Begin label should not be null!");
264  assert(End && "End label should not be null!");
265  assert(Begin->isDefined() && "Invalid starting label");
266  assert(End->isDefined() && "Invalid end label");
267 
268  addLabelAddress(D, dwarf::DW_AT_low_pc, Begin);
269  if (DD->getDwarfVersion() < 4)
270  addLabelAddress(D, dwarf::DW_AT_high_pc, End);
271  else
272  addLabelDelta(D, dwarf::DW_AT_high_pc, End, Begin);
273 }
274 
275 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
276 // and DW_AT_high_pc attributes. If there are global variables in this
277 // scope then create and insert DIEs for these variables.
279  DIE *SPDie = getOrCreateSubprogramDIE(SP, includeMinimalInlineScopes());
280 
284  *DD->getCurrentFunction()))
285  addFlag(*SPDie, dwarf::DW_AT_APPLE_omit_frame_ptr);
286 
287  // Only include DW_AT_frame_base in full debug info
288  if (!includeMinimalInlineScopes()) {
290  MachineLocation Location(RI->getFrameRegister(*Asm->MF));
291  if (RI->isPhysicalRegister(Location.getReg()))
292  addAddress(*SPDie, dwarf::DW_AT_frame_base, Location);
293  }
294 
295  // Add name to the name table, we do this here because we're guaranteed
296  // to have concrete versions of our DW_TAG_subprogram nodes.
297  DD->addSubprogramNames(SP, *SPDie);
298 
299  return *SPDie;
300 }
301 
302 // Construct a DIE for this scope.
304  LexicalScope *Scope, SmallVectorImpl<DIE *> &FinalChildren) {
305  if (!Scope || !Scope->getScopeNode())
306  return;
307 
308  auto *DS = Scope->getScopeNode();
309 
310  assert((Scope->getInlinedAt() || !isa<DISubprogram>(DS)) &&
311  "Only handle inlined subprograms here, use "
312  "constructSubprogramScopeDIE for non-inlined "
313  "subprograms");
314 
315  SmallVector<DIE *, 8> Children;
316 
317  // We try to create the scope DIE first, then the children DIEs. This will
318  // avoid creating un-used children then removing them later when we find out
319  // the scope DIE is null.
320  DIE *ScopeDIE;
321  if (Scope->getParent() && isa<DISubprogram>(DS)) {
322  ScopeDIE = constructInlinedScopeDIE(Scope);
323  if (!ScopeDIE)
324  return;
325  // We create children when the scope DIE is not null.
326  createScopeChildrenDIE(Scope, Children);
327  } else {
328  // Early exit when we know the scope DIE is going to be null.
329  if (DD->isLexicalScopeDIENull(Scope))
330  return;
331 
332  unsigned ChildScopeCount;
333 
334  // We create children here when we know the scope DIE is not going to be
335  // null and the children will be added to the scope DIE.
336  createScopeChildrenDIE(Scope, Children, &ChildScopeCount);
337 
338  // Skip imported directives in gmlt-like data.
339  if (!includeMinimalInlineScopes()) {
340  // There is no need to emit empty lexical block DIE.
341  for (const auto *IE : ImportedEntities[DS])
342  Children.push_back(
343  constructImportedEntityDIE(cast<DIImportedEntity>(IE)));
344  }
345 
346  // If there are only other scopes as children, put them directly in the
347  // parent instead, as this scope would serve no purpose.
348  if (Children.size() == ChildScopeCount) {
349  FinalChildren.insert(FinalChildren.end(),
350  std::make_move_iterator(Children.begin()),
351  std::make_move_iterator(Children.end()));
352  return;
353  }
354  ScopeDIE = constructLexicalScopeDIE(Scope);
355  assert(ScopeDIE && "Scope DIE should not be null.");
356  }
357 
358  // Add children
359  for (auto &I : Children)
360  ScopeDIE->addChild(std::move(I));
361 
362  FinalChildren.push_back(std::move(ScopeDIE));
363 }
364 
367  const MCSymbol *Hi, const MCSymbol *Lo) {
368  return Die.addValue(DIEValueAllocator, Attribute,
369  DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
370  : dwarf::DW_FORM_data4,
371  new (DIEValueAllocator) DIEDelta(Hi, Lo));
372 }
373 
377 
378  // Emit offset in .debug_range as a relocatable label. emitDIE will handle
379  // emitting it appropriately.
380  const MCSymbol *RangeSectionSym =
382 
383  RangeSpanList List(Asm->createTempSymbol("debug_ranges"), std::move(Range));
384 
385  // Under fission, ranges are specified by constant offsets relative to the
386  // CU's DW_AT_GNU_ranges_base.
387  if (isDwoUnit())
388  addSectionDelta(ScopeDIE, dwarf::DW_AT_ranges, List.getSym(),
389  RangeSectionSym);
390  else
391  addSectionLabel(ScopeDIE, dwarf::DW_AT_ranges, List.getSym(),
392  RangeSectionSym);
393 
394  // Add the range list to the set of ranges to be emitted.
395  (Skeleton ? Skeleton : this)->CURangeLists.push_back(std::move(List));
396 }
397 
399  DIE &Die, SmallVector<RangeSpan, 2> Ranges) {
400  if (Ranges.size() == 1) {
401  const auto &single = Ranges.front();
402  attachLowHighPC(Die, single.getStart(), single.getEnd());
403  } else
404  addScopeRangeList(Die, std::move(Ranges));
405 }
406 
408  DIE &Die, const SmallVectorImpl<InsnRange> &Ranges) {
410  List.reserve(Ranges.size());
411  for (const InsnRange &R : Ranges)
412  List.push_back(RangeSpan(DD->getLabelBeforeInsn(R.first),
413  DD->getLabelAfterInsn(R.second)));
414  attachRangesOrLowHighPC(Die, std::move(List));
415 }
416 
417 // This scope represents inlined body of a function. Construct DIE to
418 // represent this concrete inlined copy of the function.
420  assert(Scope->getScopeNode());
421  auto *DS = Scope->getScopeNode();
422  auto *InlinedSP = getDISubprogram(DS);
423  // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
424  // was inlined from another compile unit.
425  DIE *OriginDIE = DU->getAbstractSPDies()[InlinedSP];
426  assert(OriginDIE && "Unable to find original DIE for an inlined subprogram.");
427 
428  auto ScopeDIE = DIE::get(DIEValueAllocator, dwarf::DW_TAG_inlined_subroutine);
429  addDIEEntry(*ScopeDIE, dwarf::DW_AT_abstract_origin, *OriginDIE);
430 
431  attachRangesOrLowHighPC(*ScopeDIE, Scope->getRanges());
432 
433  // Add the call site information to the DIE.
434  const DILocation *IA = Scope->getInlinedAt();
435  addUInt(*ScopeDIE, dwarf::DW_AT_call_file, None,
436  getOrCreateSourceID(IA->getFilename(), IA->getDirectory()));
437  addUInt(*ScopeDIE, dwarf::DW_AT_call_line, None, IA->getLine());
438  if (IA->getDiscriminator() && DD->getDwarfVersion() >= 4)
439  addUInt(*ScopeDIE, dwarf::DW_AT_GNU_discriminator, None,
440  IA->getDiscriminator());
441 
442  // Add name to the name table, we do this here because we're guaranteed
443  // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
444  DD->addSubprogramNames(InlinedSP, *ScopeDIE);
445 
446  return ScopeDIE;
447 }
448 
449 // Construct new DW_TAG_lexical_block for this scope and attach
450 // DW_AT_low_pc/DW_AT_high_pc labels.
452  if (DD->isLexicalScopeDIENull(Scope))
453  return nullptr;
454 
455  auto ScopeDIE = DIE::get(DIEValueAllocator, dwarf::DW_TAG_lexical_block);
456  if (Scope->isAbstractScope())
457  return ScopeDIE;
458 
459  attachRangesOrLowHighPC(*ScopeDIE, Scope->getRanges());
460 
461  return ScopeDIE;
462 }
463 
464 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
466  auto D = constructVariableDIEImpl(DV, Abstract);
467  DV.setDIE(*D);
468  return D;
469 }
470 
471 DIE *DwarfCompileUnit::constructVariableDIEImpl(const DbgVariable &DV,
472  bool Abstract) {
473  // Define variable debug information entry.
474  auto VariableDie = DIE::get(DIEValueAllocator, DV.getTag());
475 
476  if (Abstract) {
477  applyVariableAttributes(DV, *VariableDie);
478  return VariableDie;
479  }
480 
481  // Add variable address.
482 
483  unsigned Offset = DV.getDebugLocListIndex();
484  if (Offset != ~0U) {
485  addLocationList(*VariableDie, dwarf::DW_AT_location, Offset);
486  return VariableDie;
487  }
488 
489  // Check if variable is described by a DBG_VALUE instruction.
490  if (const MachineInstr *DVInsn = DV.getMInsn()) {
491  assert(DVInsn->getNumOperands() == 4);
492  if (DVInsn->getOperand(0).isReg()) {
493  const MachineOperand RegOp = DVInsn->getOperand(0);
494  // If the second operand is an immediate, this is an indirect value.
495  if (DVInsn->getOperand(1).isImm()) {
496  MachineLocation Location(RegOp.getReg(),
497  DVInsn->getOperand(1).getImm());
498  addVariableAddress(DV, *VariableDie, Location);
499  } else if (RegOp.getReg())
500  addVariableAddress(DV, *VariableDie, MachineLocation(RegOp.getReg()));
501  } else if (DVInsn->getOperand(0).isImm()) {
502  // This variable is described by a single constant.
503  // Check whether it has a DIExpression.
504  auto *Expr = DV.getSingleExpression();
505  if (Expr && Expr->getNumElements()) {
506  DIELoc *Loc = new (DIEValueAllocator) DIELoc;
507  DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
508  // If there is an expression, emit raw unsigned bytes.
509  DwarfExpr.addFragmentOffset(Expr);
510  DwarfExpr.AddUnsignedConstant(DVInsn->getOperand(0).getImm());
511  DwarfExpr.AddExpression(Expr);
512  addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize());
513  } else
514  addConstantValue(*VariableDie, DVInsn->getOperand(0), DV.getType());
515  } else if (DVInsn->getOperand(0).isFPImm())
516  addConstantFPValue(*VariableDie, DVInsn->getOperand(0));
517  else if (DVInsn->getOperand(0).isCImm())
518  addConstantValue(*VariableDie, DVInsn->getOperand(0).getCImm(),
519  DV.getType());
520 
521  return VariableDie;
522  }
523 
524  // .. else use frame index.
525  if (!DV.hasFrameIndexExprs())
526  return VariableDie;
527 
528  DIELoc *Loc = new (DIEValueAllocator) DIELoc;
529  DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
530  for (auto &Fragment : DV.getFrameIndexExprs()) {
531  unsigned FrameReg = 0;
532  const TargetFrameLowering *TFI = Asm->MF->getSubtarget().getFrameLowering();
533  int Offset = TFI->getFrameIndexReference(*Asm->MF, Fragment.FI, FrameReg);
534  DwarfExpr.addFragmentOffset(Fragment.Expr);
535  DwarfExpr.AddMachineRegIndirect(*Asm->MF->getSubtarget().getRegisterInfo(),
536  FrameReg, Offset);
537  DwarfExpr.AddExpression(Fragment.Expr);
538  }
539  addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize());
540 
541  return VariableDie;
542 }
543 
545  const LexicalScope &Scope,
546  DIE *&ObjectPointer) {
547  auto Var = constructVariableDIE(DV, Scope.isAbstractScope());
548  if (DV.isObjectPointer())
549  ObjectPointer = Var;
550  return Var;
551 }
552 
554  SmallVectorImpl<DIE *> &Children,
555  unsigned *ChildScopeCount) {
556  DIE *ObjectPointer = nullptr;
557 
558  for (DbgVariable *DV : DU->getScopeVariables().lookup(Scope))
559  Children.push_back(constructVariableDIE(*DV, *Scope, ObjectPointer));
560 
561  unsigned ChildCountWithoutScopes = Children.size();
562 
563  for (LexicalScope *LS : Scope->getChildren())
564  constructScopeDIE(LS, Children);
565 
566  if (ChildScopeCount)
567  *ChildScopeCount = Children.size() - ChildCountWithoutScopes;
568 
569  return ObjectPointer;
570 }
571 
573  DIE &ScopeDIE = updateSubprogramScopeDIE(Sub);
574 
575  if (Scope) {
576  assert(!Scope->getInlinedAt());
577  assert(!Scope->isAbstractScope());
578  // Collect lexical scope children first.
579  // ObjectPointer might be a local (non-argument) local variable if it's a
580  // block's synthetic this pointer.
581  if (DIE *ObjectPointer = createAndAddScopeChildren(Scope, ScopeDIE))
582  addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, *ObjectPointer);
583  }
584 
585  // If this is a variadic function, add an unspecified parameter.
586  DITypeRefArray FnArgs = Sub->getType()->getTypeArray();
587 
588  // If we have a single element of null, it is a function that returns void.
589  // If we have more than one elements and the last one is null, it is a
590  // variadic function.
591  if (FnArgs.size() > 1 && !FnArgs[FnArgs.size() - 1] &&
592  !includeMinimalInlineScopes())
593  ScopeDIE.addChild(
594  DIE::get(DIEValueAllocator, dwarf::DW_TAG_unspecified_parameters));
595 }
596 
598  DIE &ScopeDIE) {
599  // We create children when the scope DIE is not null.
600  SmallVector<DIE *, 8> Children;
601  DIE *ObjectPointer = createScopeChildrenDIE(Scope, Children);
602 
603  // Add children
604  for (auto &I : Children)
605  ScopeDIE.addChild(std::move(I));
606 
607  return ObjectPointer;
608 }
609 
611  LexicalScope *Scope) {
612  DIE *&AbsDef = DU->getAbstractSPDies()[Scope->getScopeNode()];
613  if (AbsDef)
614  return;
615 
616  auto *SP = cast<DISubprogram>(Scope->getScopeNode());
617 
618  DIE *ContextDIE;
619 
620  if (includeMinimalInlineScopes())
621  ContextDIE = &getUnitDie();
622  // Some of this is duplicated from DwarfUnit::getOrCreateSubprogramDIE, with
623  // the important distinction that the debug node is not associated with the
624  // DIE (since the debug node will be associated with the concrete DIE, if
625  // any). It could be refactored to some common utility function.
626  else if (auto *SPDecl = SP->getDeclaration()) {
627  ContextDIE = &getUnitDie();
628  getOrCreateSubprogramDIE(SPDecl);
629  } else
630  ContextDIE = getOrCreateContextDIE(resolve(SP->getScope()));
631 
632  // Passing null as the associated node because the abstract definition
633  // shouldn't be found by lookup.
634  AbsDef = &createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, nullptr);
636 
637  if (!includeMinimalInlineScopes())
638  addUInt(*AbsDef, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
639  if (DIE *ObjectPointer = createAndAddScopeChildren(Scope, *AbsDef))
640  addDIEEntry(*AbsDef, dwarf::DW_AT_object_pointer, *ObjectPointer);
641 }
642 
644  const DIImportedEntity *Module) {
645  DIE *IMDie = DIE::get(DIEValueAllocator, (dwarf::Tag)Module->getTag());
646  insertDIE(Module, IMDie);
647  DIE *EntityDie;
648  auto *Entity = resolve(Module->getEntity());
649  if (auto *NS = dyn_cast<DINamespace>(Entity))
650  EntityDie = getOrCreateNameSpace(NS);
651  else if (auto *M = dyn_cast<DIModule>(Entity))
652  EntityDie = getOrCreateModule(M);
653  else if (auto *SP = dyn_cast<DISubprogram>(Entity))
654  EntityDie = getOrCreateSubprogramDIE(SP);
655  else if (auto *T = dyn_cast<DIType>(Entity))
656  EntityDie = getOrCreateTypeDIE(T);
657  else if (auto *GV = dyn_cast<DIGlobalVariable>(Entity))
658  EntityDie = getOrCreateGlobalVariableDIE(GV, {});
659  else
660  EntityDie = getDIE(Entity);
661  assert(EntityDie);
662  addSourceLine(*IMDie, Module->getLine(), Module->getScope()->getFilename(),
663  Module->getScope()->getDirectory());
664  addDIEEntry(*IMDie, dwarf::DW_AT_import, *EntityDie);
665  StringRef Name = Module->getName();
666  if (!Name.empty())
667  addString(*IMDie, dwarf::DW_AT_name, Name);
668 
669  return IMDie;
670 }
671 
673  DIE *D = getDIE(SP);
674  if (DIE *AbsSPDIE = DU->getAbstractSPDies().lookup(SP)) {
675  if (D)
676  // If this subprogram has an abstract definition, reference that
677  addDIEEntry(*D, dwarf::DW_AT_abstract_origin, *AbsSPDIE);
678  } else {
679  assert(D || includeMinimalInlineScopes());
680  if (D)
681  // And attach the attributes
683  }
684 }
685 
686 void DwarfCompileUnit::emitHeader(bool UseOffsets) {
687  // Don't bother labeling the .dwo unit, as its offset isn't used.
688  if (!Skeleton) {
689  LabelBegin = Asm->createTempSymbol("cu_begin");
690  Asm->OutStreamer->EmitLabel(LabelBegin);
691  }
692 
693  DwarfUnit::emitHeader(UseOffsets);
694 }
695 
696 /// addGlobalName - Add a new global name to the compile unit.
698  const DIScope *Context) {
699  if (includeMinimalInlineScopes())
700  return;
701  std::string FullName = getParentContextString(Context) + Name.str();
702  GlobalNames[FullName] = &Die;
703 }
704 
705 /// Add a new global type to the unit.
706 void DwarfCompileUnit::addGlobalType(const DIType *Ty, const DIE &Die,
707  const DIScope *Context) {
708  if (includeMinimalInlineScopes())
709  return;
710  std::string FullName = getParentContextString(Context) + Ty->getName().str();
711  GlobalTypes[FullName] = &Die;
712 }
713 
714 /// addVariableAddress - Add DW_AT_location attribute for a
715 /// DbgVariable based on provided MachineLocation.
717  MachineLocation Location) {
718  if (DV.hasComplexAddress())
719  addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
720  else if (DV.isBlockByrefVariable())
721  addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
722  else
723  addAddress(Die, dwarf::DW_AT_location, Location);
724 }
725 
726 /// Add an address attribute to a die based on the location provided.
728  const MachineLocation &Location) {
729  DIELoc *Loc = new (DIEValueAllocator) DIELoc;
730  DIEDwarfExpression Expr(*Asm, *this, *Loc);
731 
732  bool validReg;
733  if (Location.isReg())
734  validReg = Expr.AddMachineReg(*Asm->MF->getSubtarget().getRegisterInfo(),
735  Location.getReg());
736  else
737  validReg =
739  Location.getReg(), Location.getOffset());
740 
741  if (!validReg)
742  return;
743 
744  // Now attach the location information to the DIE.
745  addBlock(Die, Attribute, Expr.finalize());
746 }
747 
748 /// Start with the address based on the location provided, and generate the
749 /// DWARF information necessary to find the actual variable given the extra
750 /// address information encoded in the DbgVariable, starting from the starting
751 /// location. Add the DWARF information to the die.
754  const MachineLocation &Location) {
755  DIELoc *Loc = new (DIEValueAllocator) DIELoc;
756  DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
757  const DIExpression *Expr = DV.getSingleExpression();
758  DIExpressionCursor ExprCursor(Expr);
760  auto Reg = Location.getReg();
761  DwarfExpr.addFragmentOffset(Expr);
762  bool ValidReg =
763  Location.getOffset()
764  ? DwarfExpr.AddMachineRegIndirect(TRI, Reg, Location.getOffset())
765  : DwarfExpr.AddMachineRegExpression(TRI, ExprCursor, Reg);
766 
767  if (!ValidReg)
768  return;
769 
770  DwarfExpr.AddExpression(std::move(ExprCursor));
771 
772  // Now attach the location information to the DIE.
773  addBlock(Die, Attribute, Loc);
774 }
775 
776 /// Add a Dwarf loclistptr attribute data and value.
778  unsigned Index) {
779  dwarf::Form Form = DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
780  : dwarf::DW_FORM_data4;
781  Die.addValue(DIEValueAllocator, Attribute, Form, DIELocList(Index));
782 }
783 
785  DIE &VariableDie) {
786  StringRef Name = Var.getName();
787  if (!Name.empty())
788  addString(VariableDie, dwarf::DW_AT_name, Name);
789  const auto *DIVar = Var.getVariable();
790  if (DIVar)
791  if (uint32_t AlignInBytes = DIVar->getAlignInBytes())
792  addUInt(VariableDie, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
793  AlignInBytes);
794 
795  addSourceLine(VariableDie, DIVar);
796  addType(VariableDie, Var.getType());
797  if (Var.isArtificial())
798  addFlag(VariableDie, dwarf::DW_AT_artificial);
799 }
800 
801 /// Add a Dwarf expression attribute data and value.
803  const MCExpr *Expr) {
804  Die.addValue(DIEValueAllocator, (dwarf::Attribute)0, Form, DIEExpr(Expr));
805 }
806 
808  const DISubprogram *SP, DIE &SPDie) {
809  auto *SPDecl = SP->getDeclaration();
810  auto *Context = resolve(SPDecl ? SPDecl->getScope() : SP->getScope());
811  applySubprogramAttributes(SP, SPDie, includeMinimalInlineScopes());
812  addGlobalName(SP->getName(), SPDie, Context);
813 }
814 
815 bool DwarfCompileUnit::isDwoUnit() const {
816  return DD->useSplitDwarf() && Skeleton;
817 }
818 
819 bool DwarfCompileUnit::includeMinimalInlineScopes() const {
821  (DD->useSplitDwarf() && !Skeleton);
822 }
823 } // end llvm namespace
StringRef getName() const
void addFlag(DIE &Die, dwarf::Attribute Attribute)
Add a flag that is true to the DIE.
Definition: DwarfUnit.cpp:190
const DILocalScope * getScopeNode() const
Definition: LexicalScopes.h:62
const MachineInstr * getMInsn() const
Definition: DwarfDebug.h:123
DIE * getOrCreateGlobalVariableDIE(const DIGlobalVariable *GV, ArrayRef< GlobalExpr > GlobalExprs)
Get or create global variable DIE.
LLVMContext & Context
void addLabelDelta(DIE &Die, dwarf::Attribute Attribute, const MCSymbol *Hi, const MCSymbol *Lo)
Add a label delta attribute data and value.
Definition: DwarfUnit.cpp:267
const DICompileUnit * getCUNode() const
Definition: DwarfUnit.h:112
std::unique_ptr< MCStreamer > OutStreamer
This is the MCStreamer object for the file we are generating.
Definition: AsmPrinter.h:84
MCSymbol * getSymbol(const GlobalValue *GV) const
Definition: AsmPrinter.cpp:371
DIELoc - Represents an expression location.
Definition: DIE.h:829
bool useAppleExtensionAttributes() const
Definition: DwarfDebug.h:510
unsigned getDebugLocListIndex() const
Definition: DwarfDebug.h:121
DIE * getOrCreateStaticMemberDIE(const DIDerivedType *DT)
Create new static data member DIE.
Definition: DwarfUnit.cpp:1482
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:39
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:52
const DataLayout & getDataLayout() const
Return information about data layout.
Definition: AsmPrinter.cpp:148
const MachineFunction * getCurrentFunction() const
Definition: DwarfDebug.h:553
void attachLowHighPC(DIE &D, const MCSymbol *Begin, const MCSymbol *End)
uint64_t getElement(unsigned I) const
Attribute
Attributes.
Definition: Dwarf.h:94
const DIExpression * getSingleExpression() const
Definition: DwarfDebug.h:114
void insertDIE(const DINode *Desc, DIE *D)
Insert DIE into the map.
Definition: DwarfUnit.cpp:182
iterator end() const
Definition: ArrayRef.h:130
Collects and handles dwarf debug information.
Definition: DwarfDebug.h:196
void AddExpression(DIExpressionCursor &&Expr, unsigned FragmentOffsetInBits=0)
Emit all remaining operations in the DIExpressionCursor.
const MachineFunction * MF
The current machine function.
Definition: AsmPrinter.h:87
bool AddMachineRegIndirect(const TargetRegisterInfo &TRI, unsigned MachineReg, int Offset=0)
Emit an indirect dwarf register operation for the given machine register.
SmallVectorImpl< InsnRange > & getRanges()
Definition: LexicalScopes.h:65
DenseMap< LexicalScope *, SmallVector< DbgVariable *, 8 > > & getScopeVariables()
Definition: DwarfFile.h:101
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:736
StringRef getName() const
Definition: DwarfDebug.h:122
DIScope * getScope() const
bool hasComplexAddress() const
Definition: DwarfDebug.h:170
void reserve(size_type N)
Definition: SmallVector.h:377
Represents a pointer to a location list in the debug_loc section.
Definition: DIE.h:312
LexicalScope - This class is used to track scope information.
Definition: LexicalScopes.h:45
void addType(DIE &Entity, const DIType *Ty, dwarf::Attribute Attribute=dwarf::DW_AT_type)
Add a new type attribute to the specified entity.
Definition: DwarfUnit.cpp:757
bool useGNUTLSOpcode() const
Returns whether to use DW_OP_GNU_push_tls_address, instead of the standard DW_OP_form_tls_address opc...
Definition: DwarfDebug.h:498
const DILocation * getInlinedAt() const
Definition: LexicalScopes.h:61
DIE & updateSubprogramScopeDIE(const DISubprogram *SP)
Find DIE for the given subprogram and attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes...
AsmPrinter * Asm
Target of Dwarf emission.
Definition: DwarfUnit.h:77
DIE * constructLexicalScopeDIE(LexicalScope *Scope)
Construct new DW_TAG_lexical_block for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels...
DIE * getOrCreateTypeDIE(const MDNode *N)
Find existing DIE or create new DIE for the given type.
Definition: DwarfUnit.cpp:692
ArrayRef< FrameIndexExpr > getFrameIndexExprs() const
Get the FI entries, sorted by fragment offset.
Definition: DwarfDebug.cpp:202
void addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Block)
Add block data.
Definition: DwarfUnit.cpp:316
virtual void emitHeader(bool UseOffsets)
Emit the header for this unit, not including the initial length field.
Definition: DwarfUnit.cpp:1529
void addArangeLabel(SymbolCU SCU)
Add a label so that arange data can be generated for it.
Definition: DwarfDebug.h:484
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
SmallVectorImpl< LexicalScope * > & getChildren()
Definition: LexicalScopes.h:64
void applyVariableAttributes(const DbgVariable &Var, DIE &VariableDie)
DIE * createAndAddScopeChildren(LexicalScope *Scope, DIE &ScopeDIE)
bool isArtificial() const
Return true if DbgVariable is artificial.
Definition: DwarfDebug.h:154
bool DisableFramePointerElim(const MachineFunction &MF) const
DisableFramePointerElim - This returns true if frame pointer elimination optimization should be disab...
T * resolve(TypedDINodeRef< T > Ref) const
Look in the DwarfDebug map for the MDNode that corresponds to the reference.
Definition: DwarfUnit.h:305
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:32
static GCRegistry::Add< StatepointGC > D("statepoint-example","an example strategy for statepoint")
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:34
void addConstantFPValue(DIE &Die, const MachineOperand &MO)
Add constant value entry in variable DIE.
Definition: DwarfUnit.cpp:564
void attachRangesOrLowHighPC(DIE &D, SmallVector< RangeSpan, 2 > Ranges)
Reg
All possible values of the reg field in the ModR/M byte.
bool isLexicalScopeDIENull(LexicalScope *Scope)
A helper function to check whether the DIE for a given Scope is going to be null. ...
Definition: DwarfDebug.cpp:347
StringRef getFilename() const
virtual unsigned getFrameRegister(const MachineFunction &MF) const =0
Debug information queries.
Holds a DIExpression and keeps track of how many operands have been consumed so far.
DISubprogram * getDISubprogram(const MDNode *Scope)
Find subprogram that is enclosing this scope.
Definition: DebugInfo.cpp:34
StringRef getName() const
void addScopeRangeList(DIE &ScopeDIE, SmallVector< RangeSpan, 2 > Range)
A helper function to construct a RangeSpanList for a given lexical scope.
void addString(DIE &Die, dwarf::Attribute Attribute, StringRef Str)
Add a string attribute data and value.
Definition: DwarfUnit.cpp:225
AddressPool & getAddressPool()
Definition: DwarfDebug.h:543
unsigned size() const
Subprogram description.
LexicalScope * getParent() const
Definition: LexicalScopes.h:59
void constructScopeDIE(LexicalScope *Scope, SmallVectorImpl< DIE * > &FinalChildren)
void addComplexAddress(const DbgVariable &DV, DIE &Die, dwarf::Attribute Attribute, const MachineLocation &Location)
Start with the address based on the location provided, and generate the DWARF information necessary t...
void addExpr(DIELoc &Die, dwarf::Form Form, const MCExpr *Expr)
Add a Dwarf expression attribute data and value.
DenseMap< const MDNode *, DIE * > & getAbstractSPDies()
Definition: DwarfFile.h:105
This class is used to track local variable information.
Definition: DwarfDebug.h:64
void applySubprogramAttributesToDefinition(const DISubprogram *SP, DIE &SPDie)
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
virtual const MCExpr * getDebugThreadLocalSymbol(const MCSymbol *Sym) const
Create a symbol reference to describe the given TLS variable when emitting the address in debug info...
DwarfCompileUnit(unsigned UID, const DICompileUnit *Node, AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
DIScopeRef getScope() const
void addAddress(DIE &Die, dwarf::Attribute Attribute, const MachineLocation &Location)
Add an address attribute to a die based on the location provided.
DIE * getOrCreateNameSpace(const DINamespace *NS)
Definition: DwarfUnit.cpp:1061
Debug location.
DIE & addChild(DIE *Child)
Add a child to the DIE.
Definition: DIE.h:763
DIScope * getScope() const
void addConstantValue(DIE &Die, const MachineOperand &MO, const DIType *Ty)
Add constant value entry in variable DIE.
Definition: DwarfUnit.cpp:596
unsigned getLine() const
static DIE * get(BumpPtrAllocator &Alloc, dwarf::Tag Tag)
Definition: DIE.h:681
MCSection * getDwarfLineSection() const
bool useSplitDwarf() const
Returns whether or not to change the current debug info for the split dwarf proposal support...
Definition: DwarfDebug.h:516
This dwarf writer support class manages information associated with a source file.
Definition: DwarfUnit.h:68
DIEValueList::value_iterator addLabel(DIEValueList &Die, dwarf::Attribute Attribute, dwarf::Form Form, const MCSymbol *Label)
Add a Dwarf label attribute data and value.
Definition: DwarfUnit.cpp:232
const DIType * getType() const
Definition: DwarfDebug.cpp:157
void applyStmtList(DIE &D)
Apply the DW_AT_stmt_list from this compile unit to the specified DIE.
StringRef getName() const
const MCAsmInfo * MAI
Target Asm Printer information.
Definition: AsmPrinter.h:75
void addSourceLine(DIE &Die, unsigned Line, StringRef File, StringRef Directory)
Add location information to specified debug information entry.
Definition: DwarfUnit.cpp:330
void setDIE(DIE &D)
Definition: DwarfDebug.h:118
This file contains the declarations for the subclasses of Constant, which represent the different fla...
A structured debug information entry.
Definition: DIE.h:655
DIE & getUnitDie()
Definition: DIE.h:821
TargetMachine & TM
Target machine description.
Definition: AsmPrinter.h:71
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:67
An expression DIE.
Definition: DIE.h:199
T * resolve(TypedDINodeRef< T > Ref) const
Find the MDNode for the given reference.
Definition: DwarfDebug.h:537
static const unsigned End
iterator begin() const
Definition: ArrayRef.h:129
A label DIE.
Definition: DIE.h:216
DIE * getOrCreateSubprogramDIE(const DISubprogram *SP, bool Minimal=false)
Definition: DwarfUnit.cpp:1107
void addLocalLabelAddress(DIE &Die, dwarf::Attribute Attribute, const MCSymbol *Label)
addLocalLabelAddress - Add a dwarf label attribute data and value using DW_FORM_addr only...
void constructAbstractSubprogramScopeDIE(LexicalScope *Scope)
bool isAbstractScope() const
Definition: LexicalScopes.h:63
uint32_t getAlignInBytes() const
bool isThreadLocal() const
If the value is "Thread Local", its value isn't shared by the threads.
Definition: GlobalValue.h:232
DIE::value_iterator addSectionLabel(DIE &Die, dwarf::Attribute Attribute, const MCSymbol *Label, const MCSymbol *Sec)
addSectionLabel - Add a Dwarf section label attribute data and value.
A pair of GlobalVariable and DIExpression.
DIE * constructImportedEntityDIE(const DIImportedEntity *Module)
Construct import_module DIE.
DINodeRef getEntity() const
LLVM_NODISCARD std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:225
Helper used to pair up a symbol and its DWARF compile unit.
Definition: DwarfDebug.h:189
MCSymbol * getLabelAfterInsn(const MachineInstr *MI)
Return Label immediately following the instruction.
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
DIE * constructVariableDIE(DbgVariable &DV, bool Abstract=false)
constructVariableDIE - Construct a DIE for the given DbgVariable.
DITypeRef getType() const
An imported module (C++ using directive or similar).
DIE * getDIE(const DINode *D) const
Returns the DIE map slot for the specified debug variable.
Definition: DwarfUnit.cpp:176
Base class for scope-like contexts.
A simple label difference DIE.
Definition: DIE.h:234
StringRef getDisplayName() const
StringRef getDirectory() const
virtual const TargetFrameLowering * getFrameLowering() const
unsigned getOrCreateSourceID(StringRef FileName, StringRef DirName) override
Look up the source ID with the given directory and source file names.
bool hasDLLImportStorageClass() const
Definition: GlobalValue.h:247
DIE * constructInlinedScopeDIE(LexicalScope *Scope)
This scope represents inlined body of a function.
void setPrevCU(const DwarfCompileUnit *PrevCU)
Definition: DwarfDebug.h:523
unsigned getTag() const
Base class for types.
static Optional< DebugEmissionKind > getEmissionKind(StringRef Str)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:843
void addLinkageName(DIE &Die, StringRef LinkageName)
Add a linkage name, if it isn't empty.
Definition: DwarfUnit.cpp:643
MCSymbol * getBeginSymbol()
Definition: MCSection.h:106
MCSymbol * createTempSymbol(const Twine &Name) const
bool isDefined(bool SetUsed=true) const
isDefined - Check if this symbol is defined (i.e., it has an address).
Definition: MCSymbol.h:245
void addAccelName(StringRef Name, const DIE &Die)
DWARF expression.
DwarfDebug * DD
Definition: DwarfUnit.h:80
unsigned EmulatedTLS
EmulatedTLS - This flag enables emulated TLS model, using emutls function in the runtime library...
const DILocalVariable * getVariable() const
Definition: DwarfDebug.h:112
std::string getParentContextString(const DIScope *Context) const
Get string containing language specific context for a global name.
Definition: DwarfUnit.cpp:763
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:130
void addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry)
Add a DIE attribute data and value.
Definition: DwarfUnit.cpp:273
iterator insert(iterator I, T &&Elt)
Definition: SmallVector.h:464
MCSection & getSection(bool SetUsed=true) const
Get the section associated with a defined, non-absolute symbol.
Definition: MCSymbol.h:264
bool useAllLinkageNames() const
Returns whether we should emit all DW_AT_[MIPS_]linkage_name.
Definition: DwarfDebug.h:494
void addRange(RangeSpan Range)
addRange - Add an address range to the list of ranges for this unit.
DIE * getOrCreateContextDIE(const DIScope *Context)
Get context owner's DIE.
Definition: DwarfUnit.cpp:661
bool AddMachineReg(const TargetRegisterInfo &TRI, unsigned MachineReg, unsigned MaxSize=~1U)
Emit a partial DWARF register operation.
An integer value DIE.
Definition: DIE.h:161
static bool isPhysicalRegister(unsigned Reg)
Return true if the specified register number is in the physical register namespace.
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator end()
Definition: SmallVector.h:119
void constructSubprogramScopeDIE(const DISubprogram *Sub, LexicalScope *Scope)
Construct a DIE for this subprogram scope.
DIE & createAndAddDIE(unsigned Tag, DIE &Parent, const DINode *N=nullptr)
Create a DIE with the given Tag, add the DIE to its parent, and call insertDIE if MD is not null...
Definition: DwarfUnit.cpp:309
MCSymbol * getFunctionBegin() const
Definition: AsmPrinter.h:168
uint16_t getDwarfVersion() const
Returns the Dwarf Version.
const NodeList & List
Definition: RDFGraph.cpp:205
void addVariableAddress(const DbgVariable &DV, DIE &Die, MachineLocation Location)
Add DW_AT_location attribute for a DbgVariable based on provided MachineLocation. ...
#define I(x, y, z)
Definition: MD5.cpp:54
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
Definition: SmallVector.h:135
MCSymbol * getFunctionEnd() const
Definition: AsmPrinter.h:169
const TargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
DIE * getOrCreateModule(const DIModule *M)
Definition: DwarfUnit.cpp:1083
void addBlockByrefAddress(const DbgVariable &DV, DIE &Die, dwarf::Attribute Attribute, const MachineLocation &Location)
Start with the address based on the location provided, and generate the DWARF information necessary t...
Definition: DwarfUnit.cpp:430
std::pair< const MachineInstr *, const MachineInstr * > InsnRange
InsnRange - This is used to track range of instructions with identical lexical scope.
Definition: LexicalScopes.h:34
DIE::value_iterator addSectionDelta(DIE &Die, dwarf::Attribute Attribute, const MCSymbol *Hi, const MCSymbol *Lo)
addSectionDelta - Add a label delta attribute data and value.
dwarf::Tag getTag() const
Definition: DwarfDebug.h:146
bool isConstant() const
Determine whether this represents a standalone constant value.
DwarfExpression implementation for singular DW_AT_location.
void addSubprogramNames(const DISubprogram *SP, DIE &Die)
Definition: DwarfDebug.cpp:322
void addFragmentOffset(const DIExpression *Expr)
If applicable, emit an empty DW_OP_piece / DW_OP_bit_piece to advance to the fragment described by Ex...
MCSymbol * getLabelBeforeInsn(const MachineInstr *MI)
Return Label preceding the instruction.
const DwarfCompileUnit * getPrevCU() const
Returns the previous CU that was being updated.
Definition: DwarfDebug.h:522
const TargetLoweringObjectFile & getObjFileLowering() const
Return information about object file lowering.
Definition: AsmPrinter.cpp:144
BumpPtrAllocator DIEValueAllocator
Definition: DwarfUnit.h:74
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
bool isBlockByrefVariable() const
Definition: DwarfDebug.cpp:152
bool isObjectPointer() const
Definition: DwarfDebug.h:162
std::string DirName(const std::string &FileName)
bool AddMachineRegExpression(const TargetRegisterInfo &TRI, DIExpressionCursor &Expr, unsigned MachineReg, unsigned FragmentOffsetInBits=0)
Emit a machine register location.
StringRef getName() const
DIDerivedType * getStaticDataMemberDeclaration() const
void addGlobalName(StringRef Name, DIE &Die, const DIScope *Context) override
Add a new global name to the compile unit.
void addGlobalType(const DIType *Ty, const DIE &Die, const DIScope *Context) override
Add a new global type to the compile unit.
MCSection * getDwarfRangesSection() const
void addUInt(DIEValueList &Die, dwarf::Attribute Attribute, Optional< dwarf::Form > Form, uint64_t Integer)
Add an unsigned integer attribute data and value.
Definition: DwarfUnit.cpp:199
void addOpAddress(DIELoc &Die, const MCSymbol *Label)
Add a dwarf op address data and value using the form given and an op of either DW_FORM_addr or DW_FOR...
Definition: DwarfUnit.cpp:256
virtual const TargetRegisterInfo * getRegisterInfo() const
getRegisterInfo - If register information is available, return it.
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:47
void addLocationList(DIE &Die, dwarf::Attribute Attribute, unsigned Index)
Add a Dwarf loclistptr attribute data and value.
unsigned getUniqueID() const
DwarfFile * DU
Definition: DwarfUnit.h:81
unsigned getPointerSize(unsigned AS=0) const
Layout pointer size FIXME: The defaults need to be removed once all of the backends/clients are updat...
Definition: DataLayout.cpp:608
void applySubprogramAttributes(const DISubprogram *SP, DIE &SPDie, bool Minimal=false)
Definition: DwarfUnit.cpp:1182
unsigned getReg() const
static GCRegistry::Add< ErlangGC > A("erlang","erlang-compatible garbage collector")
void finishSubprogramDefinition(const DISubprogram *SP)
void emitHeader(bool UseOffsets) override
Emit the header for this unit, not including the initial length field.
bool hasFrameIndexExprs() const
Definition: DwarfDebug.h:126
StringRef getLinkageName() const
bool doesDwarfUseRelocationsAcrossSections() const
Definition: MCAsmInfo.h:558
value_iterator addValue(BumpPtrAllocator &Alloc, const DIEValue &V)
Definition: DIE.h:633
const MCSymbol * getEnd() const
Definition: DwarfUnit.h:43
void addLabelAddress(DIE &Die, dwarf::Attribute Attribute, const MCSymbol *Label)
addLabelAddress - Add a dwarf label attribute data and value using either DW_FORM_addr or DW_FORM_GNU...
unsigned getIndex(const MCSymbol *Sym, bool TLS=false)
Returns the index into the address pool with the given label/symbol.
Definition: AddressPool.cpp:17
DIE * createScopeChildrenDIE(LexicalScope *Scope, SmallVectorImpl< DIE * > &Children, unsigned *ChildScopeCount=nullptr)
A helper function to create children of a Scope DIE.