LLVM  7.0.0svn
DwarfCompileUnit.cpp
Go to the documentation of this file.
1 //===- llvm/CodeGen/DwarfCompileUnit.cpp - Dwarf Compile Units ------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file contains support for constructing a dwarf compile unit.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "DwarfCompileUnit.h"
15 #include "AddressPool.h"
16 #include "DwarfDebug.h"
17 #include "DwarfExpression.h"
18 #include "DwarfUnit.h"
19 #include "llvm/ADT/None.h"
20 #include "llvm/ADT/STLExtras.h"
21 #include "llvm/ADT/SmallVector.h"
22 #include "llvm/ADT/StringRef.h"
25 #include "llvm/CodeGen/DIE.h"
33 #include "llvm/IR/DataLayout.h"
34 #include "llvm/IR/DebugInfo.h"
36 #include "llvm/IR/GlobalVariable.h"
37 #include "llvm/MC/MCSection.h"
38 #include "llvm/MC/MCStreamer.h"
39 #include "llvm/MC/MCSymbol.h"
41 #include "llvm/Support/Casting.h"
45 #include <algorithm>
46 #include <cassert>
47 #include <cstdint>
48 #include <iterator>
49 #include <memory>
50 #include <string>
51 #include <utility>
52 
53 using namespace llvm;
54 
56  AsmPrinter *A, DwarfDebug *DW,
57  DwarfFile *DWU)
58  : DwarfUnit(dwarf::DW_TAG_compile_unit, Node, A, DW, DWU), UniqueID(UID) {
59  insertDIE(Node, &getUnitDie());
60  MacroLabelBegin = Asm->createTempSymbol("cu_macro_begin");
61 }
62 
63 /// addLabelAddress - Add a dwarf label attribute data and value using
64 /// DW_FORM_addr or DW_FORM_GNU_addr_index.
66  const MCSymbol *Label) {
67  // Don't use the address pool in non-fission or in the skeleton unit itself.
68  // FIXME: Once GDB supports this, it's probably worthwhile using the address
69  // pool from the skeleton - maybe even in non-fission (possibly fewer
70  // relocations by sharing them in the pool, but we have other ideas about how
71  // to reduce the number of relocations as well/instead).
72  if (!DD->useSplitDwarf() || !Skeleton)
73  return addLocalLabelAddress(Die, Attribute, Label);
74 
75  if (Label)
76  DD->addArangeLabel(SymbolCU(this, Label));
77 
78  unsigned idx = DD->getAddressPool().getIndex(Label);
79  Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_GNU_addr_index,
80  DIEInteger(idx));
81 }
82 
85  const MCSymbol *Label) {
86  if (Label)
87  DD->addArangeLabel(SymbolCU(this, Label));
88 
89  if (Label)
90  Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_addr,
91  DIELabel(Label));
92  else
93  Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_addr,
94  DIEInteger(0));
95 }
96 
98  // If we print assembly, we can't separate .file entries according to
99  // compile units. Thus all files will belong to the default compile unit.
100 
101  // FIXME: add a better feature test than hasRawTextSupport. Even better,
102  // extend .file to support this.
103  unsigned CUID = Asm->OutStreamer->hasRawTextSupport() ? 0 : getUniqueID();
104  if (!File)
105  return Asm->OutStreamer->EmitDwarfFileDirective(0, "", "", nullptr, None, CUID);
106  return Asm->OutStreamer->EmitDwarfFileDirective(
107  0, File->getDirectory(), File->getFilename(), getMD5AsBytes(File),
108  File->getSource(), CUID);
109 }
110 
112  const DIGlobalVariable *GV, ArrayRef<GlobalExpr> GlobalExprs) {
113  // Check for pre-existence.
114  if (DIE *Die = getDIE(GV))
115  return Die;
116 
117  assert(GV);
118 
119  auto *GVContext = GV->getScope();
120  auto *GTy = DD->resolve(GV->getType());
121 
122  // Construct the context before querying for the existence of the DIE in
123  // case such construction creates the DIE.
124  DIE *ContextDIE = getOrCreateContextDIE(GVContext);
125 
126  // Add to map.
127  DIE *VariableDIE = &createAndAddDIE(GV->getTag(), *ContextDIE, GV);
128  DIScope *DeclContext;
129  if (auto *SDMDecl = GV->getStaticDataMemberDeclaration()) {
130  DeclContext = resolve(SDMDecl->getScope());
131  assert(SDMDecl->isStaticMember() && "Expected static member decl");
132  assert(GV->isDefinition());
133  // We need the declaration DIE that is in the static member's class.
134  DIE *VariableSpecDIE = getOrCreateStaticMemberDIE(SDMDecl);
135  addDIEEntry(*VariableDIE, dwarf::DW_AT_specification, *VariableSpecDIE);
136  // If the global variable's type is different from the one in the class
137  // member type, assume that it's more specific and also emit it.
138  if (GTy != DD->resolve(SDMDecl->getBaseType()))
139  addType(*VariableDIE, GTy);
140  } else {
141  DeclContext = GV->getScope();
142  // Add name and type.
143  addString(*VariableDIE, dwarf::DW_AT_name, GV->getDisplayName());
144  addType(*VariableDIE, GTy);
145 
146  // Add scoping info.
147  if (!GV->isLocalToUnit())
148  addFlag(*VariableDIE, dwarf::DW_AT_external);
149 
150  // Add line number info.
151  addSourceLine(*VariableDIE, GV);
152  }
153 
154  if (!GV->isDefinition())
155  addFlag(*VariableDIE, dwarf::DW_AT_declaration);
156  else
157  addGlobalName(GV->getName(), *VariableDIE, DeclContext);
158 
159  if (uint32_t AlignInBytes = GV->getAlignInBytes())
160  addUInt(*VariableDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
161  AlignInBytes);
162 
163  // Add location.
164  bool addToAccelTable = false;
165  DIELoc *Loc = nullptr;
166  std::unique_ptr<DIEDwarfExpression> DwarfExpr;
167  for (const auto &GE : GlobalExprs) {
168  const GlobalVariable *Global = GE.Var;
169  const DIExpression *Expr = GE.Expr;
170 
171  // For compatibility with DWARF 3 and earlier,
172  // DW_AT_location(DW_OP_constu, X, DW_OP_stack_value) becomes
173  // DW_AT_const_value(X).
174  if (GlobalExprs.size() == 1 && Expr && Expr->isConstant()) {
175  addToAccelTable = true;
176  addConstantValue(*VariableDIE, /*Unsigned=*/true, Expr->getElement(1));
177  break;
178  }
179 
180  // We cannot describe the location of dllimport'd variables: the
181  // computation of their address requires loads from the IAT.
182  if (Global && Global->hasDLLImportStorageClass())
183  continue;
184 
185  // Nothing to describe without address or constant.
186  if (!Global && (!Expr || !Expr->isConstant()))
187  continue;
188 
189  if (!Loc) {
190  addToAccelTable = true;
191  Loc = new (DIEValueAllocator) DIELoc;
192  DwarfExpr = llvm::make_unique<DIEDwarfExpression>(*Asm, *this, *Loc);
193  }
194 
195  if (Expr)
196  DwarfExpr->addFragmentOffset(Expr);
197 
198  if (Global) {
199  const MCSymbol *Sym = Asm->getSymbol(Global);
200  if (Global->isThreadLocal()) {
201  if (Asm->TM.useEmulatedTLS()) {
202  // TODO: add debug info for emulated thread local mode.
203  } else {
204  // FIXME: Make this work with -gsplit-dwarf.
205  unsigned PointerSize = Asm->getDataLayout().getPointerSize();
206  assert((PointerSize == 4 || PointerSize == 8) &&
207  "Add support for other sizes if necessary");
208  // Based on GCC's support for TLS:
209  if (!DD->useSplitDwarf()) {
210  // 1) Start with a constNu of the appropriate pointer size
211  addUInt(*Loc, dwarf::DW_FORM_data1,
212  PointerSize == 4 ? dwarf::DW_OP_const4u
213  : dwarf::DW_OP_const8u);
214  // 2) containing the (relocated) offset of the TLS variable
215  // within the module's TLS block.
216  addExpr(*Loc, dwarf::DW_FORM_udata,
218  } else {
219  addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
220  addUInt(*Loc, dwarf::DW_FORM_udata,
221  DD->getAddressPool().getIndex(Sym, /* TLS */ true));
222  }
223  // 3) followed by an OP to make the debugger do a TLS lookup.
224  addUInt(*Loc, dwarf::DW_FORM_data1,
225  DD->useGNUTLSOpcode() ? dwarf::DW_OP_GNU_push_tls_address
226  : dwarf::DW_OP_form_tls_address);
227  }
228  } else {
229  DD->addArangeLabel(SymbolCU(this, Sym));
230  addOpAddress(*Loc, Sym);
231  }
232  }
233  // Global variables attached to symbols are memory locations.
234  // It would be better if this were unconditional, but malformed input that
235  // mixes non-fragments and fragments for the same variable is too expensive
236  // to detect in the verifier.
237  if (DwarfExpr->isUnknownLocation())
238  DwarfExpr->setMemoryLocationKind();
239  DwarfExpr->addExpression(Expr);
240  }
241  if (Loc)
242  addBlock(*VariableDIE, dwarf::DW_AT_location, DwarfExpr->finalize());
243 
244  if (DD->useAllLinkageNames())
245  addLinkageName(*VariableDIE, GV->getLinkageName());
246 
247  if (addToAccelTable) {
248  DD->addAccelName(GV->getName(), *VariableDIE);
249 
250  // If the linkage name is different than the name, go ahead and output
251  // that as well into the name table.
252  if (GV->getLinkageName() != "" && GV->getName() != GV->getLinkageName() &&
254  DD->addAccelName(GV->getLinkageName(), *VariableDIE);
255  }
256 
257  return VariableDIE;
258 }
259 
261  bool SameAsPrevCU = this == DD->getPrevCU();
262  DD->setPrevCU(this);
263  // If we have no current ranges just add the range and return, otherwise,
264  // check the current section and CU against the previous section and CU we
265  // emitted into and the subprogram was contained within. If these are the
266  // same then extend our current range, otherwise add this as a new range.
267  if (CURanges.empty() || !SameAsPrevCU ||
268  (&CURanges.back().getEnd()->getSection() !=
269  &Range.getEnd()->getSection())) {
270  CURanges.push_back(Range);
271  return;
272  }
273 
274  CURanges.back().setEnd(Range.getEnd());
275 }
276 
278  // Define start line table label for each Compile Unit.
279  MCSymbol *LineTableStartSym;
281  if (DD->useSectionsAsReferences()) {
282  LineTableStartSym = TLOF.getDwarfLineSection()->getBeginSymbol();
283  } else {
284  LineTableStartSym =
285  Asm->OutStreamer->getDwarfLineTableSymbol(getUniqueID());
286  }
287 
288  // DW_AT_stmt_list is a offset of line number information for this
289  // compile unit in debug_line section. For split dwarf this is
290  // left in the skeleton CU and so not included.
291  // The line table entries are not always emitted in assembly, so it
292  // is not okay to use line_table_start here.
293  StmtListValue =
294  addSectionLabel(getUnitDie(), dwarf::DW_AT_stmt_list, LineTableStartSym,
296 }
297 
299  D.addValue(DIEValueAllocator, *StmtListValue);
300 }
301 
303  const MCSymbol *End) {
304  assert(Begin && "Begin label should not be null!");
305  assert(End && "End label should not be null!");
306  assert(Begin->isDefined() && "Invalid starting label");
307  assert(End->isDefined() && "Invalid end label");
308 
309  addLabelAddress(D, dwarf::DW_AT_low_pc, Begin);
310  if (DD->getDwarfVersion() < 4)
311  addLabelAddress(D, dwarf::DW_AT_high_pc, End);
312  else
313  addLabelDelta(D, dwarf::DW_AT_high_pc, End, Begin);
314 }
315 
316 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
317 // and DW_AT_high_pc attributes. If there are global variables in this
318 // scope then create and insert DIEs for these variables.
321 
325  *DD->getCurrentFunction()))
326  addFlag(*SPDie, dwarf::DW_AT_APPLE_omit_frame_ptr);
327 
328  // Only include DW_AT_frame_base in full debug info
331  MachineLocation Location(RI->getFrameRegister(*Asm->MF));
332  if (RI->isPhysicalRegister(Location.getReg()))
333  addAddress(*SPDie, dwarf::DW_AT_frame_base, Location);
334  }
335 
336  // Add name to the name table, we do this here because we're guaranteed
337  // to have concrete versions of our DW_TAG_subprogram nodes.
338  DD->addSubprogramNames(SP, *SPDie);
339 
340  return *SPDie;
341 }
342 
343 // Construct a DIE for this scope.
345  LexicalScope *Scope, SmallVectorImpl<DIE *> &FinalChildren) {
346  if (!Scope || !Scope->getScopeNode())
347  return;
348 
349  auto *DS = Scope->getScopeNode();
350 
351  assert((Scope->getInlinedAt() || !isa<DISubprogram>(DS)) &&
352  "Only handle inlined subprograms here, use "
353  "constructSubprogramScopeDIE for non-inlined "
354  "subprograms");
355 
356  SmallVector<DIE *, 8> Children;
357 
358  // We try to create the scope DIE first, then the children DIEs. This will
359  // avoid creating un-used children then removing them later when we find out
360  // the scope DIE is null.
361  DIE *ScopeDIE;
362  if (Scope->getParent() && isa<DISubprogram>(DS)) {
363  ScopeDIE = constructInlinedScopeDIE(Scope);
364  if (!ScopeDIE)
365  return;
366  // We create children when the scope DIE is not null.
367  createScopeChildrenDIE(Scope, Children);
368  } else {
369  // Early exit when we know the scope DIE is going to be null.
370  if (DD->isLexicalScopeDIENull(Scope))
371  return;
372 
373  bool HasNonScopeChildren = false;
374 
375  // We create children here when we know the scope DIE is not going to be
376  // null and the children will be added to the scope DIE.
377  createScopeChildrenDIE(Scope, Children, &HasNonScopeChildren);
378 
379  // If there are only other scopes as children, put them directly in the
380  // parent instead, as this scope would serve no purpose.
381  if (!HasNonScopeChildren) {
382  FinalChildren.insert(FinalChildren.end(),
383  std::make_move_iterator(Children.begin()),
384  std::make_move_iterator(Children.end()));
385  return;
386  }
387  ScopeDIE = constructLexicalScopeDIE(Scope);
388  assert(ScopeDIE && "Scope DIE should not be null.");
389  }
390 
391  // Add children
392  for (auto &I : Children)
393  ScopeDIE->addChild(std::move(I));
394 
395  FinalChildren.push_back(std::move(ScopeDIE));
396 }
397 
401 
402  // Emit the offset into .debug_ranges or .debug_rnglists as a relocatable
403  // label. emitDIE() will handle emitting it appropriately.
404  const MCSymbol *RangeSectionSym =
405  DD->getDwarfVersion() >= 5
408 
409  RangeSpanList List(Asm->createTempSymbol("debug_ranges"), std::move(Range));
410 
411  // Under fission, ranges are specified by constant offsets relative to the
412  // CU's DW_AT_GNU_ranges_base.
413  // FIXME: For DWARF v5, do not generate the DW_AT_ranges attribute under
414  // fission until we support the forms using the .debug_addr section
415  // (DW_RLE_startx_endx etc.).
416  if (isDwoUnit()) {
417  if (DD->getDwarfVersion() < 5)
418  addSectionDelta(ScopeDIE, dwarf::DW_AT_ranges, List.getSym(),
419  RangeSectionSym);
420  } else {
421  addSectionLabel(ScopeDIE, dwarf::DW_AT_ranges, List.getSym(),
422  RangeSectionSym);
423  if (DD->getDwarfVersion() >= 5)
424  addRnglistsBase();
425  }
426 
427  // Add the range list to the set of ranges to be emitted.
428  (Skeleton ? Skeleton : this)->CURangeLists.push_back(std::move(List));
429 }
430 
432  DIE &Die, SmallVector<RangeSpan, 2> Ranges) {
433  if (Ranges.size() == 1 || !DD->useRangesSection()) {
434  const RangeSpan &Front = Ranges.front();
435  const RangeSpan &Back = Ranges.back();
436  attachLowHighPC(Die, Front.getStart(), Back.getEnd());
437  } else
438  addScopeRangeList(Die, std::move(Ranges));
439 }
440 
442  DIE &Die, const SmallVectorImpl<InsnRange> &Ranges) {
444  List.reserve(Ranges.size());
445  for (const InsnRange &R : Ranges)
446  List.push_back(RangeSpan(DD->getLabelBeforeInsn(R.first),
447  DD->getLabelAfterInsn(R.second)));
448  attachRangesOrLowHighPC(Die, std::move(List));
449 }
450 
451 // This scope represents inlined body of a function. Construct DIE to
452 // represent this concrete inlined copy of the function.
454  assert(Scope->getScopeNode());
455  auto *DS = Scope->getScopeNode();
456  auto *InlinedSP = getDISubprogram(DS);
457  // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
458  // was inlined from another compile unit.
459  DIE *OriginDIE = getAbstractSPDies()[InlinedSP];
460  assert(OriginDIE && "Unable to find original DIE for an inlined subprogram.");
461 
462  auto ScopeDIE = DIE::get(DIEValueAllocator, dwarf::DW_TAG_inlined_subroutine);
463  addDIEEntry(*ScopeDIE, dwarf::DW_AT_abstract_origin, *OriginDIE);
464 
465  attachRangesOrLowHighPC(*ScopeDIE, Scope->getRanges());
466 
467  // Add the call site information to the DIE.
468  const DILocation *IA = Scope->getInlinedAt();
469  addUInt(*ScopeDIE, dwarf::DW_AT_call_file, None,
470  getOrCreateSourceID(IA->getFile()));
471  addUInt(*ScopeDIE, dwarf::DW_AT_call_line, None, IA->getLine());
472  if (IA->getDiscriminator() && DD->getDwarfVersion() >= 4)
473  addUInt(*ScopeDIE, dwarf::DW_AT_GNU_discriminator, None,
474  IA->getDiscriminator());
475 
476  // Add name to the name table, we do this here because we're guaranteed
477  // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
478  DD->addSubprogramNames(InlinedSP, *ScopeDIE);
479 
480  return ScopeDIE;
481 }
482 
483 // Construct new DW_TAG_lexical_block for this scope and attach
484 // DW_AT_low_pc/DW_AT_high_pc labels.
486  if (DD->isLexicalScopeDIENull(Scope))
487  return nullptr;
488 
489  auto ScopeDIE = DIE::get(DIEValueAllocator, dwarf::DW_TAG_lexical_block);
490  if (Scope->isAbstractScope())
491  return ScopeDIE;
492 
493  attachRangesOrLowHighPC(*ScopeDIE, Scope->getRanges());
494 
495  return ScopeDIE;
496 }
497 
498 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
500  auto D = constructVariableDIEImpl(DV, Abstract);
501  DV.setDIE(*D);
502  return D;
503 }
504 
505 DIE *DwarfCompileUnit::constructVariableDIEImpl(const DbgVariable &DV,
506  bool Abstract) {
507  // Define variable debug information entry.
508  auto VariableDie = DIE::get(DIEValueAllocator, DV.getTag());
509  insertDIE(DV.getVariable(), VariableDie);
510 
511  if (Abstract) {
512  applyVariableAttributes(DV, *VariableDie);
513  return VariableDie;
514  }
515 
516  // Add variable address.
517 
518  unsigned Offset = DV.getDebugLocListIndex();
519  if (Offset != ~0U) {
520  addLocationList(*VariableDie, dwarf::DW_AT_location, Offset);
521  return VariableDie;
522  }
523 
524  // Check if variable is described by a DBG_VALUE instruction.
525  if (const MachineInstr *DVInsn = DV.getMInsn()) {
526  assert(DVInsn->getNumOperands() == 4);
527  if (DVInsn->getOperand(0).isReg()) {
528  auto RegOp = DVInsn->getOperand(0);
529  auto Op1 = DVInsn->getOperand(1);
530  // If the second operand is an immediate, this is an indirect value.
531  assert((!Op1.isImm() || (Op1.getImm() == 0)) && "unexpected offset");
532  MachineLocation Location(RegOp.getReg(), Op1.isImm());
533  addVariableAddress(DV, *VariableDie, Location);
534  } else if (DVInsn->getOperand(0).isImm()) {
535  // This variable is described by a single constant.
536  // Check whether it has a DIExpression.
537  auto *Expr = DV.getSingleExpression();
538  if (Expr && Expr->getNumElements()) {
539  DIELoc *Loc = new (DIEValueAllocator) DIELoc;
540  DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
541  // If there is an expression, emit raw unsigned bytes.
542  DwarfExpr.addFragmentOffset(Expr);
543  DwarfExpr.addUnsignedConstant(DVInsn->getOperand(0).getImm());
544  DwarfExpr.addExpression(Expr);
545  addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize());
546  } else
547  addConstantValue(*VariableDie, DVInsn->getOperand(0), DV.getType());
548  } else if (DVInsn->getOperand(0).isFPImm())
549  addConstantFPValue(*VariableDie, DVInsn->getOperand(0));
550  else if (DVInsn->getOperand(0).isCImm())
551  addConstantValue(*VariableDie, DVInsn->getOperand(0).getCImm(),
552  DV.getType());
553 
554  return VariableDie;
555  }
556 
557  // .. else use frame index.
558  if (!DV.hasFrameIndexExprs())
559  return VariableDie;
560 
561  DIELoc *Loc = new (DIEValueAllocator) DIELoc;
562  DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
563  for (auto &Fragment : DV.getFrameIndexExprs()) {
564  unsigned FrameReg = 0;
565  const DIExpression *Expr = Fragment.Expr;
567  int Offset = TFI->getFrameIndexReference(*Asm->MF, Fragment.FI, FrameReg);
568  DwarfExpr.addFragmentOffset(Expr);
570  Ops.push_back(dwarf::DW_OP_plus_uconst);
571  Ops.push_back(Offset);
572  Ops.append(Expr->elements_begin(), Expr->elements_end());
573  DIExpressionCursor Cursor(Ops);
574  DwarfExpr.setMemoryLocationKind();
575  DwarfExpr.addMachineRegExpression(
576  *Asm->MF->getSubtarget().getRegisterInfo(), Cursor, FrameReg);
577  DwarfExpr.addExpression(std::move(Cursor));
578  }
579  addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize());
580 
581  return VariableDie;
582 }
583 
585  const LexicalScope &Scope,
586  DIE *&ObjectPointer) {
587  auto Var = constructVariableDIE(DV, Scope.isAbstractScope());
588  if (DV.isObjectPointer())
589  ObjectPointer = Var;
590  return Var;
591 }
592 
593 /// Return all DIVariables that appear in count: expressions.
596  auto *Array = dyn_cast<DICompositeType>(Var->getType());
597  if (!Array || Array->getTag() != dwarf::DW_TAG_array_type)
598  return Result;
599  for (auto *El : Array->getElements()) {
600  if (auto *Subrange = dyn_cast<DISubrange>(El)) {
601  auto Count = Subrange->getCount();
602  if (auto *Dependency = Count.dyn_cast<DIVariable *>())
603  Result.push_back(Dependency);
604  }
605  }
606  return Result;
607 }
608 
609 /// Sort local variables so that variables appearing inside of helper
610 /// expressions come first.
615  // Map back from a DIVariable to its containing DbgVariable.
617  // Set of DbgVariables in Result.
619  // For cycle detection.
621 
622  // Initialize the worklist and the DIVariable lookup table.
623  for (auto Var : reverse(Input)) {
624  DbgVar.insert({Var->getVariable(), Var});
625  WorkList.push_back({Var, 0});
626  }
627 
628  // Perform a stable topological sort by doing a DFS.
629  while (!WorkList.empty()) {
630  auto Item = WorkList.back();
631  DbgVariable *Var = Item.getPointer();
632  bool visitedAllDependencies = Item.getInt();
633  WorkList.pop_back();
634 
635  // Dependency is in a different lexical scope or a global.
636  if (!Var)
637  continue;
638 
639  // Already handled.
640  if (Visited.count(Var))
641  continue;
642 
643  // Add to Result if all dependencies are visited.
644  if (visitedAllDependencies) {
645  Visited.insert(Var);
646  Result.push_back(Var);
647  continue;
648  }
649 
650  // Detect cycles.
651  auto Res = Visiting.insert(Var);
652  if (!Res.second) {
653  assert(false && "dependency cycle in local variables");
654  return Result;
655  }
656 
657  // Push dependencies and this node onto the worklist, so that this node is
658  // visited again after all of its dependencies are handled.
659  WorkList.push_back({Var, 1});
660  for (auto *Dependency : dependencies(Var)) {
661  auto Dep = dyn_cast_or_null<const DILocalVariable>(Dependency);
662  WorkList.push_back({DbgVar[Dep], 0});
663  }
664  }
665  return Result;
666 }
667 
669  SmallVectorImpl<DIE *> &Children,
670  bool *HasNonScopeChildren) {
671  assert(Children.empty());
672  DIE *ObjectPointer = nullptr;
673 
674  // Emit function arguments (order is significant).
675  auto Vars = DU->getScopeVariables().lookup(Scope);
676  for (auto &DV : Vars.Args)
677  Children.push_back(constructVariableDIE(*DV.second, *Scope, ObjectPointer));
678 
679  // Emit local variables.
680  auto Locals = sortLocalVars(Vars.Locals);
681  for (DbgVariable *DV : Locals)
682  Children.push_back(constructVariableDIE(*DV, *Scope, ObjectPointer));
683 
684  // Skip imported directives in gmlt-like data.
686  // There is no need to emit empty lexical block DIE.
687  for (const auto *IE : ImportedEntities[Scope->getScopeNode()])
688  Children.push_back(
689  constructImportedEntityDIE(cast<DIImportedEntity>(IE)));
690  }
691 
692  if (HasNonScopeChildren)
693  *HasNonScopeChildren = !Children.empty();
694 
695  for (LexicalScope *LS : Scope->getChildren())
696  constructScopeDIE(LS, Children);
697 
698  return ObjectPointer;
699 }
700 
702  DIE &ScopeDIE = updateSubprogramScopeDIE(Sub);
703 
704  if (Scope) {
705  assert(!Scope->getInlinedAt());
706  assert(!Scope->isAbstractScope());
707  // Collect lexical scope children first.
708  // ObjectPointer might be a local (non-argument) local variable if it's a
709  // block's synthetic this pointer.
710  if (DIE *ObjectPointer = createAndAddScopeChildren(Scope, ScopeDIE))
711  addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, *ObjectPointer);
712  }
713 
714  // If this is a variadic function, add an unspecified parameter.
715  DITypeRefArray FnArgs = Sub->getType()->getTypeArray();
716 
717  // If we have a single element of null, it is a function that returns void.
718  // If we have more than one elements and the last one is null, it is a
719  // variadic function.
720  if (FnArgs.size() > 1 && !FnArgs[FnArgs.size() - 1] &&
722  ScopeDIE.addChild(
723  DIE::get(DIEValueAllocator, dwarf::DW_TAG_unspecified_parameters));
724 }
725 
727  DIE &ScopeDIE) {
728  // We create children when the scope DIE is not null.
729  SmallVector<DIE *, 8> Children;
730  DIE *ObjectPointer = createScopeChildrenDIE(Scope, Children);
731 
732  // Add children
733  for (auto &I : Children)
734  ScopeDIE.addChild(std::move(I));
735 
736  return ObjectPointer;
737 }
738 
740  LexicalScope *Scope) {
741  DIE *&AbsDef = getAbstractSPDies()[Scope->getScopeNode()];
742  if (AbsDef)
743  return;
744 
745  auto *SP = cast<DISubprogram>(Scope->getScopeNode());
746 
747  DIE *ContextDIE;
748  DwarfCompileUnit *ContextCU = this;
749 
751  ContextDIE = &getUnitDie();
752  // Some of this is duplicated from DwarfUnit::getOrCreateSubprogramDIE, with
753  // the important distinction that the debug node is not associated with the
754  // DIE (since the debug node will be associated with the concrete DIE, if
755  // any). It could be refactored to some common utility function.
756  else if (auto *SPDecl = SP->getDeclaration()) {
757  ContextDIE = &getUnitDie();
758  getOrCreateSubprogramDIE(SPDecl);
759  } else {
760  ContextDIE = getOrCreateContextDIE(resolve(SP->getScope()));
761  // The scope may be shared with a subprogram that has already been
762  // constructed in another CU, in which case we need to construct this
763  // subprogram in the same CU.
764  ContextCU = DD->lookupCU(ContextDIE->getUnitDie());
765  }
766 
767  // Passing null as the associated node because the abstract definition
768  // shouldn't be found by lookup.
769  AbsDef = &ContextCU->createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, nullptr);
770  ContextCU->applySubprogramAttributesToDefinition(SP, *AbsDef);
771 
772  if (!ContextCU->includeMinimalInlineScopes())
773  ContextCU->addUInt(*AbsDef, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
774  if (DIE *ObjectPointer = ContextCU->createAndAddScopeChildren(Scope, *AbsDef))
775  ContextCU->addDIEEntry(*AbsDef, dwarf::DW_AT_object_pointer, *ObjectPointer);
776 }
777 
779  const DIImportedEntity *Module) {
780  DIE *IMDie = DIE::get(DIEValueAllocator, (dwarf::Tag)Module->getTag());
781  insertDIE(Module, IMDie);
782  DIE *EntityDie;
783  auto *Entity = resolve(Module->getEntity());
784  if (auto *NS = dyn_cast<DINamespace>(Entity))
785  EntityDie = getOrCreateNameSpace(NS);
786  else if (auto *M = dyn_cast<DIModule>(Entity))
787  EntityDie = getOrCreateModule(M);
788  else if (auto *SP = dyn_cast<DISubprogram>(Entity))
789  EntityDie = getOrCreateSubprogramDIE(SP);
790  else if (auto *T = dyn_cast<DIType>(Entity))
791  EntityDie = getOrCreateTypeDIE(T);
792  else if (auto *GV = dyn_cast<DIGlobalVariable>(Entity))
793  EntityDie = getOrCreateGlobalVariableDIE(GV, {});
794  else
795  EntityDie = getDIE(Entity);
796  assert(EntityDie);
797  addSourceLine(*IMDie, Module->getLine(), Module->getFile());
798  addDIEEntry(*IMDie, dwarf::DW_AT_import, *EntityDie);
799  StringRef Name = Module->getName();
800  if (!Name.empty())
801  addString(*IMDie, dwarf::DW_AT_name, Name);
802 
803  return IMDie;
804 }
805 
807  DIE *D = getDIE(SP);
808  if (DIE *AbsSPDIE = getAbstractSPDies().lookup(SP)) {
809  if (D)
810  // If this subprogram has an abstract definition, reference that
811  addDIEEntry(*D, dwarf::DW_AT_abstract_origin, *AbsSPDIE);
812  } else {
814  if (D)
815  // And attach the attributes
817  }
818 }
819 
823  auto *VariableDie = Var.getDIE();
824  if (AbsVar && AbsVar->getDIE()) {
825  addDIEEntry(*VariableDie, dwarf::DW_AT_abstract_origin,
826  *AbsVar->getDIE());
827  } else
828  applyVariableAttributes(Var, *VariableDie);
829 }
830 
832  const DILocalVariable *Cleansed;
833  return getExistingAbstractVariable(IV, Cleansed);
834 }
835 
836 // Find abstract variable, if any, associated with Var.
838  InlinedVariable IV, const DILocalVariable *&Cleansed) {
839  // More then one inlined variable corresponds to one abstract variable.
840  Cleansed = IV.first;
841  auto &AbstractVariables = getAbstractVariables();
842  auto I = AbstractVariables.find(Cleansed);
843  if (I != AbstractVariables.end())
844  return I->second.get();
845  return nullptr;
846 }
847 
849  LexicalScope *Scope) {
850  assert(Scope && Scope->isAbstractScope());
851  auto AbsDbgVariable = llvm::make_unique<DbgVariable>(Var, /* IA */ nullptr);
852  DU->addScopeVariable(Scope, AbsDbgVariable.get());
853  getAbstractVariables()[Var] = std::move(AbsDbgVariable);
854 }
855 
856 void DwarfCompileUnit::emitHeader(bool UseOffsets) {
857  // Don't bother labeling the .dwo unit, as its offset isn't used.
858  if (!Skeleton && !DD->useSectionsAsReferences()) {
859  LabelBegin = Asm->createTempSymbol("cu_begin");
860  Asm->OutStreamer->EmitLabel(LabelBegin);
861  }
862 
863  dwarf::UnitType UT = Skeleton ? dwarf::DW_UT_split_compile
864  : DD->useSplitDwarf() ? dwarf::DW_UT_skeleton
865  : dwarf::DW_UT_compile;
866  DwarfUnit::emitCommonHeader(UseOffsets, UT);
867  if (DD->getDwarfVersion() >= 5 && UT != dwarf::DW_UT_compile)
868  Asm->emitInt64(getDWOId());
869 }
870 
872  // Opting in to GNU Pubnames/types overrides the default to ensure these are
873  // generated for things like Gold's gdb_index generation.
874  if (CUNode->getGnuPubnames())
875  return true;
876 
877  return DD->tuneForGDB() && DD->usePubSections() &&
879 }
880 
881 /// addGlobalName - Add a new global name to the compile unit.
883  const DIScope *Context) {
884  if (!hasDwarfPubSections())
885  return;
886  std::string FullName = getParentContextString(Context) + Name.str();
887  GlobalNames[FullName] = &Die;
888 }
889 
891  const DIScope *Context) {
892  if (!hasDwarfPubSections())
893  return;
894  std::string FullName = getParentContextString(Context) + Name.str();
895  // Insert, allowing the entry to remain as-is if it's already present
896  // This way the CU-level type DIE is preferred over the "can't describe this
897  // type as a unit offset because it's not really in the CU at all, it's only
898  // in a type unit"
899  GlobalNames.insert(std::make_pair(std::move(FullName), &getUnitDie()));
900 }
901 
902 /// Add a new global type to the unit.
903 void DwarfCompileUnit::addGlobalType(const DIType *Ty, const DIE &Die,
904  const DIScope *Context) {
905  if (!hasDwarfPubSections())
906  return;
907  std::string FullName = getParentContextString(Context) + Ty->getName().str();
908  GlobalTypes[FullName] = &Die;
909 }
910 
912  const DIScope *Context) {
913  if (!hasDwarfPubSections())
914  return;
915  std::string FullName = getParentContextString(Context) + Ty->getName().str();
916  // Insert, allowing the entry to remain as-is if it's already present
917  // This way the CU-level type DIE is preferred over the "can't describe this
918  // type as a unit offset because it's not really in the CU at all, it's only
919  // in a type unit"
920  GlobalTypes.insert(std::make_pair(std::move(FullName), &getUnitDie()));
921 }
922 
923 /// addVariableAddress - Add DW_AT_location attribute for a
924 /// DbgVariable based on provided MachineLocation.
926  MachineLocation Location) {
927  // addBlockByrefAddress is obsolete and will be removed soon.
928  // The clang frontend always generates block byref variables with a
929  // complex expression that encodes exactly what addBlockByrefAddress
930  // would do.
932  "block byref variable without a complex expression");
933  if (DV.hasComplexAddress())
934  addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
935  else if (DV.isBlockByrefVariable())
936  addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
937  else
938  addAddress(Die, dwarf::DW_AT_location, Location);
939 }
940 
941 /// Add an address attribute to a die based on the location provided.
943  const MachineLocation &Location) {
944  DIELoc *Loc = new (DIEValueAllocator) DIELoc;
945  DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
946  if (Location.isIndirect())
947  DwarfExpr.setMemoryLocationKind();
948 
949  DIExpressionCursor Cursor({});
951  if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg()))
952  return;
953  DwarfExpr.addExpression(std::move(Cursor));
954 
955  // Now attach the location information to the DIE.
956  addBlock(Die, Attribute, DwarfExpr.finalize());
957 }
958 
959 /// Start with the address based on the location provided, and generate the
960 /// DWARF information necessary to find the actual variable given the extra
961 /// address information encoded in the DbgVariable, starting from the starting
962 /// location. Add the DWARF information to the die.
965  const MachineLocation &Location) {
966  DIELoc *Loc = new (DIEValueAllocator) DIELoc;
967  DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
968  const DIExpression *DIExpr = DV.getSingleExpression();
969  DwarfExpr.addFragmentOffset(DIExpr);
970  if (Location.isIndirect())
971  DwarfExpr.setMemoryLocationKind();
972 
973  DIExpressionCursor Cursor(DIExpr);
975  if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg()))
976  return;
977  DwarfExpr.addExpression(std::move(Cursor));
978 
979  // Now attach the location information to the DIE.
980  addBlock(Die, Attribute, DwarfExpr.finalize());
981 }
982 
983 /// Add a Dwarf loclistptr attribute data and value.
985  unsigned Index) {
986  dwarf::Form Form = DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
987  : dwarf::DW_FORM_data4;
988  Die.addValue(DIEValueAllocator, Attribute, Form, DIELocList(Index));
989 }
990 
992  DIE &VariableDie) {
993  StringRef Name = Var.getName();
994  if (!Name.empty())
995  addString(VariableDie, dwarf::DW_AT_name, Name);
996  const auto *DIVar = Var.getVariable();
997  if (DIVar)
998  if (uint32_t AlignInBytes = DIVar->getAlignInBytes())
999  addUInt(VariableDie, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
1000  AlignInBytes);
1001 
1002  addSourceLine(VariableDie, DIVar);
1003  addType(VariableDie, Var.getType());
1004  if (Var.isArtificial())
1005  addFlag(VariableDie, dwarf::DW_AT_artificial);
1006 }
1007 
1008 /// Add a Dwarf expression attribute data and value.
1010  const MCExpr *Expr) {
1011  Die.addValue(DIEValueAllocator, (dwarf::Attribute)0, Form, DIEExpr(Expr));
1012 }
1013 
1015  const DISubprogram *SP, DIE &SPDie) {
1016  auto *SPDecl = SP->getDeclaration();
1017  auto *Context = resolve(SPDecl ? SPDecl->getScope() : SP->getScope());
1019  addGlobalName(SP->getName(), SPDie, Context);
1020 }
1021 
1022 bool DwarfCompileUnit::isDwoUnit() const {
1023  return DD->useSplitDwarf() && Skeleton;
1024 }
1025 
1028  (DD->useSplitDwarf() && !Skeleton);
1029 }
const DICompileUnit * getCUNode() const
Definition: DwarfUnit.h:113
const TargetLoweringObjectFile & getObjFileLowering() const
Return information about object file lowering.
Definition: AsmPrinter.cpp:208
const DILocation * getInlinedAt() const
Definition: DwarfDebug.h:125
void emitInt64(uint64_t Value) const
Emit a long long directive and value.
DIE::value_iterator addSectionDelta(DIE &Die, dwarf::Attribute Attribute, const MCSymbol *Hi, const MCSymbol *Lo)
addSectionDelta - Add a label delta attribute data and value.
Definition: DwarfUnit.cpp:1706
const DILocalScope * getScopeNode() const
Definition: LexicalScopes.h:64
bool isConstant() const
Determine whether this represents a standalone constant value.
void addFlag(DIE &Die, dwarf::Attribute Attribute)
Add a flag that is true to the DIE.
Definition: DwarfUnit.cpp:200
LLVM_NODISCARD std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:228
LLVMContext & Context
unsigned getDebugLocListIndex() const
Definition: DwarfDebug.h:135
void addLabelDelta(DIE &Die, dwarf::Attribute Attribute, const MCSymbol *Hi, const MCSymbol *Lo)
Add a label delta attribute data and value.
Definition: DwarfUnit.cpp:320
std::unique_ptr< MCStreamer > OutStreamer
This is the MCStreamer object for the file we are generating.
Definition: AsmPrinter.h:93
DIELoc - Represents an expression location.
Definition: DIE.h:846
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
bool isAbstractScope() const
Definition: LexicalScopes.h:65
MCSection * getDwarfLineSection() const
void addUnsignedConstant(uint64_t Value)
Emit an unsigned constant.
DIE * getOrCreateStaticMemberDIE(const DIDerivedType *DT)
Create new static data member DIE.
Definition: DwarfUnit.cpp:1612
void addOpAddress(DIELoc &Die, const MCSymbol *Sym)
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:309
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:42
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:63
unsigned size() const
void setMemoryLocationKind()
Lock this down to become a memory location description.
virtual int getFrameIndexReference(const MachineFunction &MF, int FI, unsigned &FrameReg) const
getFrameIndexReference - This method should return the base register and offset used to reference a f...
virtual const TargetRegisterInfo * getRegisterInfo() const
getRegisterInfo - If register information is available, return it.
void addGlobalName(StringRef Name, const DIE &Die, const DIScope *Context) override
Add a new global name to the compile unit.
const DIType * getType() const
Definition: DwarfDebug.cpp:195
DIE * getDIE() const
Definition: DwarfDebug.h:133
Attribute
Attributes.
Definition: Dwarf.h:114
void insertDIE(const DINode *Desc, DIE *D)
Insert DIE into the map.
Definition: DwarfUnit.cpp:192
unsigned getReg() const
Collects and handles dwarf debug information.
Definition: DwarfDebug.h:204
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:529
DbgValueHistoryMap::InlinedVariable InlinedVariable
Find abstract variable associated with Var.
MD5::MD5Result * getMD5AsBytes(const DIFile *File) const
If the File has an MD5 checksum, return it as an MD5Result allocated in the MCContext.
Definition: DwarfUnit.cpp:280
SmallVectorImpl< InsnRange > & getRanges()
Definition: LexicalScopes.h:67
void addRange(RangeSpan Range)
addRange - Add an address range to the list of ranges for this unit.
bool hasDLLImportStorageClass() const
Definition: GlobalValue.h:261
void attachLowHighPC(DIE &D, const MCSymbol *Begin, const MCSymbol *End)
unsigned const TargetRegisterInfo * TRI
MachineFunction * MF
The current machine function.
Definition: AsmPrinter.h:96
void reserve(size_type N)
Definition: SmallVector.h:371
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:798
DIE::value_iterator addSectionLabel(DIE &Die, dwarf::Attribute Attribute, const MCSymbol *Label, const MCSymbol *Sec)
Add a Dwarf section label attribute data and value.
Definition: DwarfUnit.cpp:1715
const MachineFunction * getCurrentFunction() const
Definition: DwarfDebug.h:615
StringRef getName() const
AsmPrinter * Asm
Target of Dwarf emission.
Definition: DwarfUnit.h:77
bool useSplitDwarf() const
Returns whether or not to change the current debug info for the split dwarf proposal support...
Definition: DwarfDebug.h:566
DIE * getDIE(const DINode *D) const
Returns the DIE map slot for the specified debug variable.
Definition: DwarfUnit.cpp:186
MCSection * getDwarfRnglistsSection() const
T * resolve(TypedDINodeRef< T > Ref) const
Look in the DwarfDebug map for the MDNode that corresponds to the reference.
Definition: DwarfUnit.h:330
void attachRangesOrLowHighPC(DIE &D, SmallVector< RangeSpan, 2 > Ranges)
StringRef getName() const
void addArangeLabel(SymbolCU SCU)
Add a label so that arange data can be generated for it.
Definition: DwarfDebug.h:515
StringRef getName() const
SmallVectorImpl< LexicalScope * > & getChildren()
Definition: LexicalScopes.h:66
unsigned getTag() const
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...
LexicalScope * getParent() const
Definition: LexicalScopes.h:61
const TargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
bool isObjectPointer() const
Definition: DwarfDebug.h:161
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:42
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:36
void addConstantFPValue(DIE &Die, const MachineOperand &MO)
Add constant value entry in variable DIE.
Definition: DwarfUnit.cpp:598
void emitHeader(bool UseOffsets) override
Emit the header for this unit, not including the initial length field.
void addGlobalTypeUnitType(const DIType *Ty, const DIScope *Context)
Add a new global type present in a type unit to this compile unit.
bool isLexicalScopeDIENull(LexicalScope *Scope)
A helper function to check whether the DIE for a given Scope is going to be null. ...
Definition: DwarfDebug.cpp:451
DenseMap< LexicalScope *, ScopeVars > & getScopeVariables()
Definition: DwarfFile.h:128
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:44
static const uint16_t * lookup(unsigned opcode, unsigned domain, ArrayRef< uint16_t[3]> Table)
StringRef getFilename() const
DIE * getOrCreateTypeDIE(const MDNode *TyNode)
Find existing DIE or create new DIE for the given type.
Definition: DwarfUnit.cpp:733
void addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc)
Add block data.
Definition: DwarfUnit.cpp:362
void addString(DIE &Die, dwarf::Attribute Attribute, StringRef Str)
Add a string attribute data and value.
Definition: DwarfUnit.cpp:235
DIE * constructInlinedScopeDIE(LexicalScope *Scope)
This scope represents inlined body of a function.
auto reverse(ContainerTy &&C, typename std::enable_if< has_rbegin< ContainerTy >::value >::type *=nullptr) -> decltype(make_range(C.rbegin(), C.rend()))
Definition: STLExtras.h:250
AddressPool & getAddressPool()
Definition: DwarfDebug.h:605
Subprogram description.
unsigned getUniqueID() const
const DIExpression * getSingleExpression() const
Definition: DwarfDebug.h:127
MCSymbol * getFunctionBegin() const
Definition: AsmPrinter.h:204
uint64_t getDWOId() const
This class is used to track local variable information.
Definition: DwarfDebug.h:76
bool DisableFramePointerElim(const MachineFunction &MF) const
DisableFramePointerElim - This returns true if frame pointer elimination optimization should be disab...
const DILocalVariable * getVariable() const
Definition: DwarfDebug.h:124
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:133
DIE * constructVariableDIE(DbgVariable &DV, bool Abstract=false)
constructVariableDIE - Construct a DIE for the given DbgVariable.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
void addGlobalNameForTypeUnit(StringRef Name, const DIScope *Context)
Add a new global name present in a type unit to this compile unit.
const MachineInstr * getMInsn() const
Definition: DwarfDebug.h:137
DIE * getOrCreateNameSpace(const DINamespace *NS)
Definition: DwarfUnit.cpp:1144
Debug location.
DIE & addChild(DIE *Child)
Add a child to the DIE.
Definition: DIE.h:769
DIScope * getScope() const
void addExpr(DIELoc &Die, dwarf::Form Form, const MCExpr *Expr)
Add a Dwarf expression attribute data and value.
const DwarfCompileUnit * getPrevCU() const
Returns the previous CU that was being updated.
Definition: DwarfDebug.h:584
bool hasComplexAddress() const
Definition: DwarfDebug.h:169
void addConstantValue(DIE &Die, const MachineOperand &MO, const DIType *Ty)
Add constant value entry in variable DIE.
Definition: DwarfUnit.cpp:630
bool useEmulatedTLS() const
Returns true if this target uses emulated TLS.
static DIE * get(BumpPtrAllocator &Alloc, dwarf::Tag Tag)
Definition: DIE.h:692
void applySubprogramAttributes(const DISubprogram *SP, DIE &SPDie, bool SkipSPAttributes=false)
Definition: DwarfUnit.cpp:1263
void addSourceLine(DIE &Die, unsigned Line, const DIFile *File)
Add location information to specified debug information entry.
Definition: DwarfUnit.cpp:376
This dwarf writer support class manages information associated with a source file.
Definition: DwarfUnit.h:68
void addLocationList(DIE &Die, dwarf::Attribute Attribute, unsigned Index)
Add a Dwarf loclistptr attribute data and value.
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
void constructSubprogramScopeDIE(const DISubprogram *Sub, LexicalScope *Scope)
Construct a DIE for this subprogram scope.
const DILocation * getInlinedAt() const
Definition: LexicalScopes.h:63
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:629
void setDIE(DIE &D)
Definition: DwarfDebug.h:132
A structured debug information entry.
Definition: DIE.h:662
DIE & getUnitDie()
Definition: DIE.h:834
TargetMachine & TM
Target machine description.
Definition: AsmPrinter.h:81
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:78
An expression DIE.
Definition: DIE.h:201
unsigned getOrCreateSourceID(const DIFile *File) override
Look up the source ID for the given file.
DIE * createScopeChildrenDIE(LexicalScope *Scope, SmallVectorImpl< DIE *> &Children, bool *HasNonScopeChildren=nullptr)
A helper function to create children of a Scope DIE.
DwarfCompileUnit(unsigned UID, const DICompileUnit *Node, AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
DIDerivedType * getStaticDataMemberDeclaration() const
void emitCommonHeader(bool UseOffsets, dwarf::UnitType UT)
Emit the common part of the header for this unit.
Definition: DwarfUnit.cpp:1659
void addAddress(DIE &Die, dwarf::Attribute Attribute, const MachineLocation &Location)
Add an address attribute to a die based on the location provided.
A label DIE.
Definition: DIE.h:218
DIE * getOrCreateSubprogramDIE(const DISubprogram *SP, bool Minimal=false)
Definition: DwarfUnit.cpp:1189
bool hasFrameIndexExprs() const
Definition: DwarfDebug.h:140
Base class for variables.
DIE * createAndAddScopeChildren(LexicalScope *Scope, DIE &ScopeDIE)
bool addScopeVariable(LexicalScope *LS, DbgVariable *Var)
Definition: DwarfFile.cpp:105
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...
dwarf::Tag getTag() const
Definition: DwarfDebug.h:144
T * resolve(TypedDINodeRef< T > Ref) const
Find the MDNode for the given reference.
Definition: DwarfDebug.h:599
Helper used to pair up a symbol and its DWARF compile unit.
Definition: DwarfDebug.h:188
StringRef getDirectory() const
bool useAllLinkageNames() const
Returns whether we should emit all DW_AT_[MIPS_]linkage_name.
Definition: DwarfDebug.h:525
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...
element_iterator elements_end() const
size_t size() const
Definition: SmallVector.h:53
void addScopeRangeList(DIE &ScopeDIE, SmallVector< RangeSpan, 2 > Range)
A helper function to construct a RangeSpanList for a given lexical scope.
uint64_t getElement(unsigned I) const
const MCSymbol * getStart() const
Definition: DwarfUnit.h:42
ArrayRef< FrameIndexExpr > getFrameIndexExprs() const
Get the FI entries, sorted by fragment offset.
Definition: DwarfDebug.cpp:240
An imported module (C++ using directive or similar).
Base class for scope-like contexts.
DIE * constructImportedEntityDIE(const DIImportedEntity *Module)
Construct import_module DIE.
std::string getParentContextString(const DIScope *Context) const
Get string containing language specific context for a global name.
Definition: DwarfUnit.cpp:804
UnitType
Constants for unit types in DWARF v5.
Definition: Dwarf.h:328
void addExpression(DIExpressionCursor &&Expr, unsigned FragmentOffsetInBits=0)
Emit all remaining operations in the DIExpressionCursor.
bool tuneForGDB() const
Definition: DwarfDebug.h:631
void constructAbstractSubprogramScopeDIE(LexicalScope *Scope)
bool useSectionsAsReferences() const
Returns whether to use sections as labels rather than temp symbols.
Definition: DwarfDebug.h:545
void setPrevCU(const DwarfCompileUnit *PrevCU)
Definition: DwarfDebug.h:585
Base class for types.
static Optional< DebugEmissionKind > getEmissionKind(StringRef Str)
StringRef getName() const
MCSymbol * getSymbol(const GlobalValue *GV) const
Definition: AsmPrinter.cpp:426
DwarfCompileUnit * lookupCU(const DIE *Die)
Find the matching DwarfCompileUnit for the given CU DIE.
Definition: DwarfDebug.h:622
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:841
Information about stack frame layout on the target.
void addLinkageName(DIE &Die, StringRef LinkageName)
Add a linkage name, if it isn&#39;t empty.
Definition: DwarfUnit.cpp:677
void applySubprogramAttributesToDefinition(const DISubprogram *SP, DIE &SPDie)
MCSymbol * getBeginSymbol()
Definition: MCSection.h:106
void finishSubprogramDefinition(const DISubprogram *SP)
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
bool useAppleExtensionAttributes() const
Definition: DwarfDebug.h:560
void addAccelName(StringRef Name, const DIE &Die)
MCSymbol * getFunctionEnd() const
Definition: AsmPrinter.h:205
static SmallVector< const DIVariable *, 2 > dependencies(DbgVariable *Var)
Return all DIVariables that appear in count: expressions.
StringRef getDisplayName() const
DWARF expression.
void addRnglistsBase()
Add the DW_AT_rnglists_base attribute to the unit DIE.
Definition: DwarfUnit.cpp:1756
Implements a dense probed hash-table based set with some number of buckets stored inline...
Definition: DenseSet.h:239
StringRef getLinkageName() const
This file contains constants used for implementing Dwarf debug support.
bool isDefined() const
isDefined - Check if this symbol is defined (i.e., it has an address).
Definition: MCSymbol.h:248
DwarfDebug * DD
Definition: DwarfUnit.h:80
StringRef getName() const
Definition: DwarfDebug.h:136
MCSection & getSection() const
Get the section associated with a defined, non-absolute symbol.
Definition: MCSymbol.h:267
void addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry)
Add a DIE attribute data and value.
Definition: DwarfUnit.cpp:326
iterator insert(iterator I, T &&Elt)
Definition: SmallVector.h:473
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
Definition: SmallVector.h:389
DIE * getOrCreateContextDIE(const DIScope *Context)
Get context owner&#39;s DIE.
Definition: DwarfUnit.cpp:703
Representation of each machine instruction.
Definition: MachineInstr.h:60
An integer value DIE.
Definition: DIE.h:163
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:128
DIE * getOrCreateGlobalVariableDIE(const DIGlobalVariable *GV, ArrayRef< GlobalExpr > GlobalExprs)
Get or create global variable DIE.
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:355
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:56
bool useRangesSection() const
Returns whether ranges section should be emitted.
Definition: DwarfDebug.h:542
bool isBlockByrefVariable() const
Definition: DwarfDebug.cpp:190
void addVariableAddress(const DbgVariable &DV, DIE &Die, MachineLocation Location)
Add DW_AT_location attribute for a DbgVariable based on provided MachineLocation. ...
TargetOptions Options
Definition: TargetMachine.h:98
const NodeList & List
Definition: RDFGraph.cpp:210
#define I(x, y, z)
Definition: MD5.cpp:58
void addGlobalType(const DIType *Ty, const DIE &Die, const DIScope *Context) override
Add a new global type to the compile unit.
virtual const TargetFrameLowering * getFrameLowering() const
void applyVariableAttributes(const DbgVariable &Var, DIE &VariableDie)
Optional< StringRef > getSource() const
element_iterator elements_begin() const
DIE * getOrCreateModule(const DIModule *M)
Definition: DwarfUnit.cpp:1165
static SmallVector< DbgVariable *, 8 > sortLocalVars(SmallVectorImpl< DbgVariable *> &Input)
Sort local variables so that variables appearing inside of helper expressions come first...
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:323
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:470
bool includeMinimalInlineScopes() const
bool usePubSections() const
Returns whether GNU pub sections should be emitted.
Definition: DwarfDebug.h:539
size_type count(const_arg_type_t< ValueT > V) const
Return 1 if the specified key is in the set, 0 otherwise.
Definition: DenseSet.h:91
const DICompileUnit * CUNode
MDNode for the compile unit.
Definition: DwarfUnit.h:71
DwarfExpression implementation for singular DW_AT_location.
void addSubprogramNames(const DISubprogram *SP, DIE &Die)
Definition: DwarfDebug.cpp:422
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...
DITypeRef getType() const
MCSymbol * getLabelBeforeInsn(const MachineInstr *MI)
Return Label preceding the instruction.
BumpPtrAllocator DIEValueAllocator
Definition: DwarfUnit.h:74
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
const MCSymbol * getEnd() const
Definition: DwarfUnit.h:43
uint32_t getAlignInBytes() const
void finishVariableDefinition(const DbgVariable &Var)
DINodeRef getEntity() const
void addLocalLabelAddress(DIE &Die, dwarf::Attribute Attribute, const MCSymbol *Label)
addLocalLabelAddress - Add a dwarf label attribute data and value using DW_FORM_addr only...
DbgVariable * getExistingAbstractVariable(InlinedVariable IV, const DILocalVariable *&Cleansed)
uint16_t getDwarfVersion() const
Returns the Dwarf Version.
DIE & updateSubprogramScopeDIE(const DISubprogram *SP)
Find DIE for the given subprogram and attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes...
void constructScopeDIE(LexicalScope *Scope, SmallVectorImpl< DIE *> &FinalChildren)
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:209
const DataLayout & getDataLayout() const
Return information about data layout.
Definition: AsmPrinter.cpp:212
bool isThreadLocal() const
If the value is "Thread Local", its value isn&#39;t shared by the threads.
Definition: GlobalValue.h:246
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
MCSection * getDwarfRangesSection() const
DwarfFile * DU
Definition: DwarfUnit.h:81
void createAbstractVariable(const DILocalVariable *Var, LexicalScope *Scope)
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...
void applyStmtList(DIE &D)
Apply the DW_AT_stmt_list from this compile unit to the specified DIE.
MCSymbol * createTempSymbol(const Twine &Name) const
bool addMachineRegExpression(const TargetRegisterInfo &TRI, DIExpressionCursor &Expr, unsigned MachineReg, unsigned FragmentOffsetInBits=0)
Emit a machine register location.
bool isArtificial() const
Return true if DbgVariable is artificial.
Definition: DwarfDebug.h:153
value_iterator addValue(BumpPtrAllocator &Alloc, const DIEValue &V)
Definition: DIE.h:640
std::pair< const MachineInstr *, const MachineInstr * > InsnRange
InsnRange - This is used to track range of instructions with identical lexical scope.
Definition: LexicalScopes.h:40
DIE * constructLexicalScopeDIE(LexicalScope *Scope)
Construct new DW_TAG_lexical_block for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels...
DIScopeRef getScope() const
unsigned getIndex(const MCSymbol *Sym, bool TLS=false)
Returns the index into the address pool with the given label/symbol.
Definition: AddressPool.cpp:20