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