LLVM  6.0.0svn
DwarfDebug.cpp
Go to the documentation of this file.
1 //===- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ----------------===//
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 writing dwarf debug info into asm files.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "DwarfDebug.h"
15 #include "ByteStreamer.h"
16 #include "DIEHash.h"
17 #include "DebugLocEntry.h"
18 #include "DebugLocStream.h"
19 #include "DwarfAccelTable.h"
20 #include "DwarfCompileUnit.h"
21 #include "DwarfExpression.h"
22 #include "DwarfFile.h"
23 #include "DwarfUnit.h"
24 #include "llvm/ADT/APInt.h"
25 #include "llvm/ADT/DenseMap.h"
26 #include "llvm/ADT/DenseSet.h"
27 #include "llvm/ADT/MapVector.h"
28 #include "llvm/ADT/STLExtras.h"
29 #include "llvm/ADT/SmallVector.h"
30 #include "llvm/ADT/StringRef.h"
31 #include "llvm/ADT/Triple.h"
32 #include "llvm/ADT/Twine.h"
35 #include "llvm/CodeGen/DIE.h"
42 #include "llvm/IR/Constants.h"
44 #include "llvm/IR/DebugLoc.h"
45 #include "llvm/IR/Function.h"
46 #include "llvm/IR/GlobalVariable.h"
47 #include "llvm/IR/Module.h"
48 #include "llvm/MC/MCAsmInfo.h"
49 #include "llvm/MC/MCContext.h"
50 #include "llvm/MC/MCDwarf.h"
51 #include "llvm/MC/MCSection.h"
52 #include "llvm/MC/MCStreamer.h"
53 #include "llvm/MC/MCSymbol.h"
56 #include "llvm/MC/SectionKind.h"
57 #include "llvm/Pass.h"
58 #include "llvm/Support/Casting.h"
60 #include "llvm/Support/Debug.h"
62 #include "llvm/Support/MD5.h"
64 #include "llvm/Support/Timer.h"
71 #include <algorithm>
72 #include <cassert>
73 #include <cstddef>
74 #include <cstdint>
75 #include <iterator>
76 #include <string>
77 #include <utility>
78 #include <vector>
79 
80 using namespace llvm;
81 
82 #define DEBUG_TYPE "dwarfdebug"
83 
84 static cl::opt<bool>
85 DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
86  cl::desc("Disable debug info printing"));
87 
89  "use-dwarf-ranges-base-address-specifier", cl::Hidden,
90  cl::desc("Use base address specifiers in debug_ranges"), cl::init(false));
91 
92 static cl::opt<bool> GenerateARangeSection("generate-arange-section",
93  cl::Hidden,
94  cl::desc("Generate dwarf aranges"),
95  cl::init(false));
96 
98  "split-dwarf-cross-cu-references", cl::Hidden,
99  cl::desc("Enable cross-cu references in DWO files"), cl::init(false));
100 
101 enum DefaultOnOff { Default, Enable, Disable };
102 
104  "use-unknown-locations", cl::Hidden,
105  cl::desc("Make an absence of debug location information explicit."),
106  cl::values(clEnumVal(Default, "At top of block or after label"),
107  clEnumVal(Enable, "In all cases"), clEnumVal(Disable, "Never")),
108  cl::init(Default));
109 
111 DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
112  cl::desc("Output prototype dwarf accelerator tables."),
113  cl::values(clEnumVal(Default, "Default for platform"),
114  clEnumVal(Enable, "Enabled"),
115  clEnumVal(Disable, "Disabled")),
116  cl::init(Default));
117 
122 };
123 
125  DwarfLinkageNames("dwarf-linkage-names", cl::Hidden,
126  cl::desc("Which DWARF linkage-name attributes to emit."),
128  "Default for platform"),
129  clEnumValN(AllLinkageNames, "All", "All"),
130  clEnumValN(AbstractLinkageNames, "Abstract",
131  "Abstract subprograms")),
133 
134 static const char *const DWARFGroupName = "dwarf";
135 static const char *const DWARFGroupDescription = "DWARF Emission";
136 static const char *const DbgTimerName = "writer";
137 static const char *const DbgTimerDescription = "DWARF Debug Writer";
138 
139 void DebugLocDwarfExpression::emitOp(uint8_t Op, const char *Comment) {
140  BS.EmitInt8(
141  Op, Comment ? Twine(Comment) + " " + dwarf::OperationEncodingString(Op)
143 }
144 
145 void DebugLocDwarfExpression::emitSigned(int64_t Value) {
146  BS.EmitSLEB128(Value, Twine(Value));
147 }
148 
149 void DebugLocDwarfExpression::emitUnsigned(uint64_t Value) {
150  BS.EmitULEB128(Value, Twine(Value));
151 }
152 
153 bool DebugLocDwarfExpression::isFrameRegister(const TargetRegisterInfo &TRI,
154  unsigned MachineReg) {
155  // This information is not available while emitting .debug_loc entries.
156  return false;
157 }
158 
160  assert(Var && "Invalid complex DbgVariable!");
161  return Var->getType().resolve()->isBlockByrefStruct();
162 }
163 
164 const DIType *DbgVariable::getType() const {
165  DIType *Ty = Var->getType().resolve();
166  // FIXME: isBlockByrefVariable should be reformulated in terms of complex
167  // addresses instead.
168  if (Ty->isBlockByrefStruct()) {
169  /* Byref variables, in Blocks, are declared by the programmer as
170  "SomeType VarName;", but the compiler creates a
171  __Block_byref_x_VarName struct, and gives the variable VarName
172  either the struct, or a pointer to the struct, as its type. This
173  is necessary for various behind-the-scenes things the compiler
174  needs to do with by-reference variables in blocks.
175 
176  However, as far as the original *programmer* is concerned, the
177  variable should still have type 'SomeType', as originally declared.
178 
179  The following function dives into the __Block_byref_x_VarName
180  struct to find the original type of the variable. This will be
181  passed back to the code generating the type for the Debug
182  Information Entry for the variable 'VarName'. 'VarName' will then
183  have the original type 'SomeType' in its debug information.
184 
185  The original type 'SomeType' will be the type of the field named
186  'VarName' inside the __Block_byref_x_VarName struct.
187 
188  NOTE: In order for this to not completely fail on the debugger
189  side, the Debug Information Entry for the variable VarName needs to
190  have a DW_AT_location that tells the debugger how to unwind through
191  the pointers and __Block_byref_x_VarName struct to find the actual
192  value of the variable. The function addBlockByrefType does this. */
193  DIType *subType = Ty;
194  uint16_t tag = Ty->getTag();
195 
196  if (tag == dwarf::DW_TAG_pointer_type)
197  subType = resolve(cast<DIDerivedType>(Ty)->getBaseType());
198 
199  auto Elements = cast<DICompositeType>(subType)->getElements();
200  for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
201  auto *DT = cast<DIDerivedType>(Elements[i]);
202  if (getName() == DT->getName())
203  return resolve(DT->getBaseType());
204  }
205  }
206  return Ty;
207 }
208 
210  if (FrameIndexExprs.size() == 1)
211  return FrameIndexExprs;
212 
213  assert(llvm::all_of(FrameIndexExprs,
214  [](const FrameIndexExpr &A) {
215  return A.Expr->isFragment();
216  }) &&
217  "multiple FI expressions without DW_OP_LLVM_fragment");
218  std::sort(FrameIndexExprs.begin(), FrameIndexExprs.end(),
219  [](const FrameIndexExpr &A, const FrameIndexExpr &B) -> bool {
220  return A.Expr->getFragmentInfo()->OffsetInBits <
221  B.Expr->getFragmentInfo()->OffsetInBits;
222  });
223  return FrameIndexExprs;
224 }
225 
227  DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4),
228  DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2),
229  DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1)};
230 
232  : DebugHandlerBase(A), DebugLocs(A->OutStreamer->isVerboseAsm()),
233  InfoHolder(A, "info_string", DIEValueAllocator),
234  SkeletonHolder(A, "skel_string", DIEValueAllocator),
235  IsDarwin(A->TM.getTargetTriple().isOSDarwin()),
236  AccelNames(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
237  dwarf::DW_FORM_data4)),
238  AccelObjC(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
239  dwarf::DW_FORM_data4)),
240  AccelNamespace(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
241  dwarf::DW_FORM_data4)),
242  AccelTypes(TypeAtoms) {
243  const Triple &TT = Asm->TM.getTargetTriple();
244 
245  // Make sure we know our "debugger tuning." The target option takes
246  // precedence; fall back to triple-based defaults.
248  DebuggerTuning = Asm->TM.Options.DebuggerTuning;
249  else if (IsDarwin)
250  DebuggerTuning = DebuggerKind::LLDB;
251  else if (TT.isPS4CPU())
252  DebuggerTuning = DebuggerKind::SCE;
253  else
254  DebuggerTuning = DebuggerKind::GDB;
255 
256  // Turn on accelerator tables for LLDB by default.
257  if (DwarfAccelTables == Default)
258  HasDwarfAccelTables = tuneForLLDB();
259  else
260  HasDwarfAccelTables = DwarfAccelTables == Enable;
261 
262  HasAppleExtensionAttributes = tuneForLLDB();
263 
264  // Handle split DWARF.
265  HasSplitDwarf = !Asm->TM.Options.MCOptions.SplitDwarfFile.empty();
266 
267  // SCE defaults to linkage names only for abstract subprograms.
269  UseAllLinkageNames = !tuneForSCE();
270  else
271  UseAllLinkageNames = DwarfLinkageNames == AllLinkageNames;
272 
273  unsigned DwarfVersionNumber = Asm->TM.Options.MCOptions.DwarfVersion;
274  unsigned DwarfVersion = DwarfVersionNumber ? DwarfVersionNumber
275  : MMI->getModule()->getDwarfVersion();
276  // Use dwarf 4 by default if nothing is requested.
277  DwarfVersion = DwarfVersion ? DwarfVersion : dwarf::DWARF_VERSION;
278 
279  // Work around a GDB bug. GDB doesn't support the standard opcode;
280  // SCE doesn't support GNU's; LLDB prefers the standard opcode, which
281  // is defined as of DWARF 3.
282  // See GDB bug 11616 - DW_OP_form_tls_address is unimplemented
283  // https://sourceware.org/bugzilla/show_bug.cgi?id=11616
284  UseGNUTLSOpcode = tuneForGDB() || DwarfVersion < 3;
285 
286  // GDB does not fully support the DWARF 4 representation for bitfields.
287  UseDWARF2Bitfields = (DwarfVersion < 4) || tuneForGDB();
288 
289  Asm->OutStreamer->getContext().setDwarfVersion(DwarfVersion);
290 }
291 
292 // Define out of line so we don't have to include DwarfUnit.h in DwarfDebug.h.
293 DwarfDebug::~DwarfDebug() = default;
294 
295 static bool isObjCClass(StringRef Name) {
296  return Name.startswith("+") || Name.startswith("-");
297 }
298 
300  if (!isObjCClass(Name))
301  return false;
302 
303  return Name.find(") ") != StringRef::npos;
304 }
305 
307  StringRef &Category) {
308  if (!hasObjCCategory(In)) {
309  Class = In.slice(In.find('[') + 1, In.find(' '));
310  Category = "";
311  return;
312  }
313 
314  Class = In.slice(In.find('[') + 1, In.find('('));
315  Category = In.slice(In.find('[') + 1, In.find(' '));
316 }
317 
319  return In.slice(In.find(' ') + 1, In.find(']'));
320 }
321 
322 // Add the various names to the Dwarf accelerator table names.
323 // TODO: Determine whether or not we should add names for programs
324 // that do not have a DW_AT_name or DW_AT_linkage_name field - this
325 // is only slightly different than the lookup of non-standard ObjC names.
327  if (!SP->isDefinition())
328  return;
329  addAccelName(SP->getName(), Die);
330 
331  // If the linkage name is different than the name, go ahead and output
332  // that as well into the name table.
333  if (SP->getLinkageName() != "" && SP->getName() != SP->getLinkageName())
334  addAccelName(SP->getLinkageName(), Die);
335 
336  // If this is an Objective-C selector name add it to the ObjC accelerator
337  // too.
338  if (isObjCClass(SP->getName())) {
339  StringRef Class, Category;
340  getObjCClassCategory(SP->getName(), Class, Category);
341  addAccelObjC(Class, Die);
342  if (Category != "")
343  addAccelObjC(Category, Die);
344  // Also add the base method name to the name table.
346  }
347 }
348 
349 /// Check whether we should create a DIE for the given Scope, return true
350 /// if we don't create a DIE (the corresponding DIE is null).
352  if (Scope->isAbstractScope())
353  return false;
354 
355  // We don't create a DIE if there is no Range.
356  const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
357  if (Ranges.empty())
358  return true;
359 
360  if (Ranges.size() > 1)
361  return false;
362 
363  // We don't create a DIE if we have a single Range and the end label
364  // is null.
365  return !getLabelAfterInsn(Ranges.front().second);
366 }
367 
368 template <typename Func> static void forBothCUs(DwarfCompileUnit &CU, Func F) {
369  F(CU);
370  if (auto *SkelCU = CU.getSkeleton())
371  if (CU.getCUNode()->getSplitDebugInlining())
372  F(*SkelCU);
373 }
374 
377 }
378 
379 void DwarfDebug::constructAbstractSubprogramScopeDIE(DwarfCompileUnit &SrcCU,
380  LexicalScope *Scope) {
381  assert(Scope && Scope->getScopeNode());
382  assert(Scope->isAbstractScope());
383  assert(!Scope->getInlinedAt());
384 
385  auto *SP = cast<DISubprogram>(Scope->getScopeNode());
386 
387  // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
388  // was inlined from another compile unit.
389  if (useSplitDwarf() && !shareAcrossDWOCUs() && !SP->getUnit()->getSplitDebugInlining())
390  // Avoid building the original CU if it won't be used
392  else {
393  auto &CU = getOrCreateDwarfCompileUnit(SP->getUnit());
394  if (auto *SkelCU = CU.getSkeleton()) {
395  (shareAcrossDWOCUs() ? CU : SrcCU)
396  .constructAbstractSubprogramScopeDIE(Scope);
397  if (CU.getCUNode()->getSplitDebugInlining())
398  SkelCU->constructAbstractSubprogramScopeDIE(Scope);
399  } else
400  CU.constructAbstractSubprogramScopeDIE(Scope);
401  }
402 }
403 
404 void DwarfDebug::addGnuPubAttributes(DwarfCompileUnit &U, DIE &D) const {
405  if (!U.hasDwarfPubSections())
406  return;
407 
408  U.addFlag(D, dwarf::DW_AT_GNU_pubnames);
409 }
410 
411 // Create new DwarfCompileUnit for the given metadata node with tag
412 // DW_TAG_compile_unit.
414 DwarfDebug::getOrCreateDwarfCompileUnit(const DICompileUnit *DIUnit) {
415  if (auto *CU = CUMap.lookup(DIUnit))
416  return *CU;
417  StringRef FN = DIUnit->getFilename();
418  CompilationDir = DIUnit->getDirectory();
419 
420  auto OwnedUnit = llvm::make_unique<DwarfCompileUnit>(
421  InfoHolder.getUnits().size(), DIUnit, Asm, this, &InfoHolder);
422  DwarfCompileUnit &NewCU = *OwnedUnit;
423  DIE &Die = NewCU.getUnitDie();
424  InfoHolder.addUnit(std::move(OwnedUnit));
425  if (useSplitDwarf()) {
426  NewCU.setSkeleton(constructSkeletonCU(NewCU));
427  NewCU.addString(Die, dwarf::DW_AT_GNU_dwo_name,
428  Asm->TM.Options.MCOptions.SplitDwarfFile);
429  }
430 
431  for (auto *IE : DIUnit->getImportedEntities())
432  NewCU.addImportedEntity(IE);
433 
434  // LTO with assembly output shares a single line table amongst multiple CUs.
435  // To avoid the compilation directory being ambiguous, let the line table
436  // explicitly describe the directory of all files, never relying on the
437  // compilation directory.
438  if (!Asm->OutStreamer->hasRawTextSupport() || SingleCU)
439  Asm->OutStreamer->getContext().setMCLineTableCompilationDir(
440  NewCU.getUniqueID(), CompilationDir);
441 
442  StringRef Producer = DIUnit->getProducer();
443  StringRef Flags = DIUnit->getFlags();
444  if (!Flags.empty()) {
445  std::string ProducerWithFlags = Producer.str() + " " + Flags.str();
446  NewCU.addString(Die, dwarf::DW_AT_producer, ProducerWithFlags);
447  } else
448  NewCU.addString(Die, dwarf::DW_AT_producer, Producer);
449 
450  NewCU.addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
451  DIUnit->getSourceLanguage());
452  NewCU.addString(Die, dwarf::DW_AT_name, FN);
453 
454  if (!useSplitDwarf()) {
455  NewCU.initStmtList();
456 
457  // If we're using split dwarf the compilation dir is going to be in the
458  // skeleton CU and so we don't need to duplicate it here.
459  if (!CompilationDir.empty())
460  NewCU.addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
461 
462  addGnuPubAttributes(NewCU, Die);
463  }
464 
466  if (DIUnit->isOptimized())
467  NewCU.addFlag(Die, dwarf::DW_AT_APPLE_optimized);
468 
469  StringRef Flags = DIUnit->getFlags();
470  if (!Flags.empty())
471  NewCU.addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
472 
473  if (unsigned RVer = DIUnit->getRuntimeVersion())
474  NewCU.addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
475  dwarf::DW_FORM_data1, RVer);
476  }
477 
478  if (useSplitDwarf())
479  NewCU.setSection(Asm->getObjFileLowering().getDwarfInfoDWOSection());
480  else
481  NewCU.setSection(Asm->getObjFileLowering().getDwarfInfoSection());
482 
483  if (DIUnit->getDWOId()) {
484  // This CU is either a clang module DWO or a skeleton CU.
485  NewCU.addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8,
486  DIUnit->getDWOId());
487  if (!DIUnit->getSplitDebugFilename().empty())
488  // This is a prefabricated skeleton CU.
489  NewCU.addString(Die, dwarf::DW_AT_GNU_dwo_name,
490  DIUnit->getSplitDebugFilename());
491  }
492 
493  CUMap.insert({DIUnit, &NewCU});
494  CUDieMap.insert({&Die, &NewCU});
495  return NewCU;
496 }
497 
498 void DwarfDebug::constructAndAddImportedEntityDIE(DwarfCompileUnit &TheCU,
499  const DIImportedEntity *N) {
500  if (isa<DILocalScope>(N->getScope()))
501  return;
502  if (DIE *D = TheCU.getOrCreateContextDIE(N->getScope()))
504 }
505 
506 /// Sort and unique GVEs by comparing their fragment offset.
509  std::sort(GVEs.begin(), GVEs.end(),
511  if (A.Expr != B.Expr && A.Expr && B.Expr) {
512  auto FragmentA = A.Expr->getFragmentInfo();
513  auto FragmentB = B.Expr->getFragmentInfo();
514  if (FragmentA && FragmentB)
515  return FragmentA->OffsetInBits < FragmentB->OffsetInBits;
516  }
517  return false;
518  });
519  GVEs.erase(std::unique(GVEs.begin(), GVEs.end(),
522  return A.Expr == B.Expr;
523  }),
524  GVEs.end());
525  return GVEs;
526 }
527 
528 // Emit all Dwarf sections that should come prior to the content. Create
529 // global DIEs and emit initial debug info sections. This is invoked by
530 // the target AsmPrinter.
532  NamedRegionTimer T(DbgTimerName, DbgTimerDescription, DWARFGroupName,
533  DWARFGroupDescription, TimePassesIsEnabled);
535  return;
536 
537  const Module *M = MMI->getModule();
538 
539  unsigned NumDebugCUs = std::distance(M->debug_compile_units_begin(),
541  // Tell MMI whether we have debug info.
542  MMI->setDebugInfoAvailability(NumDebugCUs > 0);
543  SingleCU = NumDebugCUs == 1;
545  GVMap;
546  for (const GlobalVariable &Global : M->globals()) {
548  Global.getDebugInfo(GVs);
549  for (auto *GVE : GVs)
550  GVMap[GVE->getVariable()].push_back({&Global, GVE->getExpression()});
551  }
552 
553  for (DICompileUnit *CUNode : M->debug_compile_units()) {
554  // FIXME: Move local imported entities into a list attached to the
555  // subprogram, then this search won't be needed and a
556  // getImportedEntities().empty() test should go below with the rest.
557  bool HasNonLocalImportedEntities = llvm::any_of(
558  CUNode->getImportedEntities(), [](const DIImportedEntity *IE) {
559  return !isa<DILocalScope>(IE->getScope());
560  });
561 
562  if (!HasNonLocalImportedEntities && CUNode->getEnumTypes().empty() &&
563  CUNode->getRetainedTypes().empty() &&
564  CUNode->getGlobalVariables().empty() && CUNode->getMacros().empty())
565  continue;
566 
567  DwarfCompileUnit &CU = getOrCreateDwarfCompileUnit(CUNode);
568 
569  // Global Variables.
570  for (auto *GVE : CUNode->getGlobalVariables()) {
571  // Don't bother adding DIGlobalVariableExpressions listed in the CU if we
572  // already know about the variable and it isn't adding a constant
573  // expression.
574  auto &GVMapEntry = GVMap[GVE->getVariable()];
575  auto *Expr = GVE->getExpression();
576  if (!GVMapEntry.size() || (Expr && Expr->isConstant()))
577  GVMapEntry.push_back({nullptr, Expr});
578  }
580  for (auto *GVE : CUNode->getGlobalVariables()) {
581  DIGlobalVariable *GV = GVE->getVariable();
582  if (Processed.insert(GV).second)
584  }
585 
586  for (auto *Ty : CUNode->getEnumTypes()) {
587  // The enum types array by design contains pointers to
588  // MDNodes rather than DIRefs. Unique them here.
589  CU.getOrCreateTypeDIE(cast<DIType>(Ty));
590  }
591  for (auto *Ty : CUNode->getRetainedTypes()) {
592  // The retained types array by design contains pointers to
593  // MDNodes rather than DIRefs. Unique them here.
594  if (DIType *RT = dyn_cast<DIType>(Ty))
595  // There is no point in force-emitting a forward declaration.
596  CU.getOrCreateTypeDIE(RT);
597  }
598  // Emit imported_modules last so that the relevant context is already
599  // available.
600  for (auto *IE : CUNode->getImportedEntities())
601  constructAndAddImportedEntityDIE(CU, IE);
602  }
603 }
604 
605 void DwarfDebug::finishVariableDefinitions() {
606  for (const auto &Var : ConcreteVariables) {
607  DIE *VariableDie = Var->getDIE();
608  assert(VariableDie);
609  // FIXME: Consider the time-space tradeoff of just storing the unit pointer
610  // in the ConcreteVariables list, rather than looking it up again here.
611  // DIE::getUnit isn't simple - it walks parent pointers, etc.
612  DwarfCompileUnit *Unit = CUDieMap.lookup(VariableDie->getUnitDie());
613  assert(Unit);
614  Unit->finishVariableDefinition(*Var);
615  }
616 }
617 
618 void DwarfDebug::finishSubprogramDefinitions() {
619  for (const DISubprogram *SP : ProcessedSPNodes) {
620  assert(SP->getUnit()->getEmissionKind() != DICompileUnit::NoDebug);
621  forBothCUs(
622  getOrCreateDwarfCompileUnit(SP->getUnit()),
624  }
625 }
626 
627 void DwarfDebug::finalizeModuleInfo() {
629 
630  finishSubprogramDefinitions();
631 
632  finishVariableDefinitions();
633 
634  // Include the DWO file name in the hash if there's more than one CU.
635  // This handles ThinLTO's situation where imported CUs may very easily be
636  // duplicate with the same CU partially imported into another ThinLTO unit.
637  StringRef DWOName;
638  if (CUMap.size() > 1)
640 
641  // Handle anything that needs to be done on a per-unit basis after
642  // all other generation.
643  for (const auto &P : CUMap) {
644  auto &TheCU = *P.second;
645  // Emit DW_AT_containing_type attribute to connect types with their
646  // vtable holding type.
648 
649  // Add CU specific attributes if we need to add any.
650  // If we're splitting the dwarf out now that we've got the entire
651  // CU then add the dwo id to it.
652  auto *SkCU = TheCU.getSkeleton();
653  if (useSplitDwarf()) {
654  // Emit a unique identifier for this CU.
655  uint64_t ID =
656  DIEHash(Asm).computeCUSignature(DWOName, TheCU.getUnitDie());
657  TheCU.addUInt(TheCU.getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
658  dwarf::DW_FORM_data8, ID);
659  SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
660  dwarf::DW_FORM_data8, ID);
661 
662  // We don't keep track of which addresses are used in which CU so this
663  // is a bit pessimistic under LTO.
664  if (!AddrPool.isEmpty()) {
665  const MCSymbol *Sym = TLOF.getDwarfAddrSection()->getBeginSymbol();
666  SkCU->addSectionLabel(SkCU->getUnitDie(), dwarf::DW_AT_GNU_addr_base,
667  Sym, Sym);
668  }
669  if (!SkCU->getRangeLists().empty()) {
670  const MCSymbol *Sym = TLOF.getDwarfRangesSection()->getBeginSymbol();
671  SkCU->addSectionLabel(SkCU->getUnitDie(), dwarf::DW_AT_GNU_ranges_base,
672  Sym, Sym);
673  }
674  }
675 
676  // If we have code split among multiple sections or non-contiguous
677  // ranges of code then emit a DW_AT_ranges attribute on the unit that will
678  // remain in the .o file, otherwise add a DW_AT_low_pc.
679  // FIXME: We should use ranges allow reordering of code ala
680  // .subsections_via_symbols in mach-o. This would mean turning on
681  // ranges for all subprogram DIEs for mach-o.
682  DwarfCompileUnit &U = SkCU ? *SkCU : TheCU;
683  if (unsigned NumRanges = TheCU.getRanges().size()) {
684  if (NumRanges > 1)
685  // A DW_AT_low_pc attribute may also be specified in combination with
686  // DW_AT_ranges to specify the default base address for use in
687  // location lists (see Section 2.6.2) and range lists (see Section
688  // 2.17.3).
689  U.addUInt(U.getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
690  else
691  U.setBaseAddress(TheCU.getRanges().front().getStart());
693  }
694 
695  auto *CUNode = cast<DICompileUnit>(P.first);
696  // If compile Unit has macros, emit "DW_AT_macro_info" attribute.
697  if (CUNode->getMacros())
698  U.addSectionLabel(U.getUnitDie(), dwarf::DW_AT_macro_info,
699  U.getMacroLabelBegin(),
701  }
702 
703  // Emit all frontend-produced Skeleton CUs, i.e., Clang modules.
704  for (auto *CUNode : MMI->getModule()->debug_compile_units())
705  if (CUNode->getDWOId())
706  getOrCreateDwarfCompileUnit(CUNode);
707 
708  // Compute DIE offsets and sizes.
709  InfoHolder.computeSizeAndOffsets();
710  if (useSplitDwarf())
711  SkeletonHolder.computeSizeAndOffsets();
712 }
713 
714 // Emit all Dwarf sections that should come after the content.
716  assert(CurFn == nullptr);
717  assert(CurMI == nullptr);
718 
719  // If we aren't actually generating debug info (check beginModule -
720  // conditionalized on !DisableDebugInfoPrinting and the presence of the
721  // llvm.dbg.cu metadata node)
722  if (!MMI->hasDebugInfo())
723  return;
724 
725  // Finalize the debug info for the module.
726  finalizeModuleInfo();
727 
728  emitDebugStr();
729 
730  if (useSplitDwarf())
731  emitDebugLocDWO();
732  else
733  // Emit info into a debug loc section.
734  emitDebugLoc();
735 
736  // Corresponding abbreviations into a abbrev section.
737  emitAbbreviations();
738 
739  // Emit all the DIEs into a debug info section.
740  emitDebugInfo();
741 
742  // Emit info into a debug aranges section.
744  emitDebugARanges();
745 
746  // Emit info into a debug ranges section.
747  emitDebugRanges();
748 
749  // Emit info into a debug macinfo section.
750  emitDebugMacinfo();
751 
752  if (useSplitDwarf()) {
753  emitDebugStrDWO();
754  emitDebugInfoDWO();
755  emitDebugAbbrevDWO();
756  emitDebugLineDWO();
757  // Emit DWO addresses.
759  }
760 
761  // Emit info into the dwarf accelerator table sections.
762  if (useDwarfAccelTables()) {
763  emitAccelNames();
764  emitAccelObjC();
765  emitAccelNamespaces();
766  emitAccelTypes();
767  }
768 
769  // Emit the pubnames and pubtypes sections if requested.
770  emitDebugPubSections();
771 
772  // clean up.
773  // FIXME: AbstractVariables.clear();
774 }
775 
776 void DwarfDebug::ensureAbstractVariableIsCreated(DwarfCompileUnit &CU, InlinedVariable IV,
777  const MDNode *ScopeNode) {
778  const DILocalVariable *Cleansed = nullptr;
779  if (CU.getExistingAbstractVariable(IV, Cleansed))
780  return;
781 
783  cast<DILocalScope>(ScopeNode)));
784 }
785 
786 void DwarfDebug::ensureAbstractVariableIsCreatedIfScoped(DwarfCompileUnit &CU,
787  InlinedVariable IV, const MDNode *ScopeNode) {
788  const DILocalVariable *Cleansed = nullptr;
789  if (CU.getExistingAbstractVariable(IV, Cleansed))
790  return;
791 
792  if (LexicalScope *Scope =
793  LScopes.findAbstractScope(cast_or_null<DILocalScope>(ScopeNode)))
794  CU.createAbstractVariable(Cleansed, Scope);
795 }
796 
797 // Collect variable information from side table maintained by MF.
798 void DwarfDebug::collectVariableInfoFromMFTable(
799  DwarfCompileUnit &TheCU, DenseSet<InlinedVariable> &Processed) {
801  for (const auto &VI : Asm->MF->getVariableDbgInfo()) {
802  if (!VI.Var)
803  continue;
804  assert(VI.Var->isValidLocationForIntrinsic(VI.Loc) &&
805  "Expected inlined-at fields to agree");
806 
807  InlinedVariable Var(VI.Var, VI.Loc->getInlinedAt());
808  Processed.insert(Var);
809  LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
810 
811  // If variable scope is not found then skip this variable.
812  if (!Scope)
813  continue;
814 
815  ensureAbstractVariableIsCreatedIfScoped(TheCU, Var, Scope->getScopeNode());
816  auto RegVar = llvm::make_unique<DbgVariable>(Var.first, Var.second);
817  RegVar->initializeMMI(VI.Expr, VI.Slot);
818  if (DbgVariable *DbgVar = MFVars.lookup(Var))
819  DbgVar->addMMIEntry(*RegVar);
820  else if (InfoHolder.addScopeVariable(Scope, RegVar.get())) {
821  MFVars.insert({Var, RegVar.get()});
822  ConcreteVariables.push_back(std::move(RegVar));
823  }
824  }
825 }
826 
827 // Get .debug_loc entry for the instruction range starting at MI.
829  const DIExpression *Expr = MI->getDebugExpression();
830  assert(MI->getNumOperands() == 4);
831  if (MI->getOperand(0).isReg()) {
832  auto RegOp = MI->getOperand(0);
833  auto Op1 = MI->getOperand(1);
834  // If the second operand is an immediate, this is a
835  // register-indirect address.
836  assert((!Op1.isImm() || (Op1.getImm() == 0)) && "unexpected offset");
837  MachineLocation MLoc(RegOp.getReg(), Op1.isImm());
838  return DebugLocEntry::Value(Expr, MLoc);
839  }
840  if (MI->getOperand(0).isImm())
841  return DebugLocEntry::Value(Expr, MI->getOperand(0).getImm());
842  if (MI->getOperand(0).isFPImm())
843  return DebugLocEntry::Value(Expr, MI->getOperand(0).getFPImm());
844  if (MI->getOperand(0).isCImm())
845  return DebugLocEntry::Value(Expr, MI->getOperand(0).getCImm());
846 
847  llvm_unreachable("Unexpected 4-operand DBG_VALUE instruction!");
848 }
849 
850 /// \brief If this and Next are describing different fragments of the same
851 /// variable, merge them by appending Next's values to the current
852 /// list of values.
853 /// Return true if the merge was successful.
855  if (Begin == Next.Begin) {
856  auto *FirstExpr = cast<DIExpression>(Values[0].Expression);
857  auto *FirstNextExpr = cast<DIExpression>(Next.Values[0].Expression);
858  if (!FirstExpr->isFragment() || !FirstNextExpr->isFragment())
859  return false;
860 
861  // We can only merge entries if none of the fragments overlap any others.
862  // In doing so, we can take advantage of the fact that both lists are
863  // sorted.
864  for (unsigned i = 0, j = 0; i < Values.size(); ++i) {
865  for (; j < Next.Values.size(); ++j) {
867  cast<DIExpression>(Values[i].Expression),
868  cast<DIExpression>(Next.Values[j].Expression));
869  if (res == 0) // The two expressions overlap, we can't merge.
870  return false;
871  // Values[i] is entirely before Next.Values[j],
872  // so go back to the next entry of Values.
873  else if (res == -1)
874  break;
875  // Next.Values[j] is entirely before Values[i], so go on to the
876  // next entry of Next.Values.
877  }
878  }
879 
880  addValues(Next.Values);
881  End = Next.End;
882  return true;
883  }
884  return false;
885 }
886 
887 /// Build the location list for all DBG_VALUEs in the function that
888 /// describe the same variable. If the ranges of several independent
889 /// fragments of the same variable overlap partially, split them up and
890 /// combine the ranges. The resulting DebugLocEntries are will have
891 /// strict monotonically increasing begin addresses and will never
892 /// overlap.
893 //
894 // Input:
895 //
896 // Ranges History [var, loc, fragment ofs size]
897 // 0 | [x, (reg0, fragment 0, 32)]
898 // 1 | | [x, (reg1, fragment 32, 32)] <- IsFragmentOfPrevEntry
899 // 2 | | ...
900 // 3 | [clobber reg0]
901 // 4 [x, (mem, fragment 0, 64)] <- overlapping with both previous fragments of
902 // x.
903 //
904 // Output:
905 //
906 // [0-1] [x, (reg0, fragment 0, 32)]
907 // [1-3] [x, (reg0, fragment 0, 32), (reg1, fragment 32, 32)]
908 // [3-4] [x, (reg1, fragment 32, 32)]
909 // [4- ] [x, (mem, fragment 0, 64)]
910 void
911 DwarfDebug::buildLocationList(SmallVectorImpl<DebugLocEntry> &DebugLoc,
912  const DbgValueHistoryMap::InstrRanges &Ranges) {
914 
915  for (auto I = Ranges.begin(), E = Ranges.end(); I != E; ++I) {
916  const MachineInstr *Begin = I->first;
917  const MachineInstr *End = I->second;
918  assert(Begin->isDebugValue() && "Invalid History entry");
919 
920  // Check if a variable is inaccessible in this range.
921  if (Begin->getNumOperands() > 1 &&
922  Begin->getOperand(0).isReg() && !Begin->getOperand(0).getReg()) {
923  OpenRanges.clear();
924  continue;
925  }
926 
927  // If this fragment overlaps with any open ranges, truncate them.
928  const DIExpression *DIExpr = Begin->getDebugExpression();
929  auto Last = remove_if(OpenRanges, [&](DebugLocEntry::Value R) {
930  return fragmentsOverlap(DIExpr, R.getExpression());
931  });
932  OpenRanges.erase(Last, OpenRanges.end());
933 
934  const MCSymbol *StartLabel = getLabelBeforeInsn(Begin);
935  assert(StartLabel && "Forgot label before DBG_VALUE starting a range!");
936 
937  const MCSymbol *EndLabel;
938  if (End != nullptr)
939  EndLabel = getLabelAfterInsn(End);
940  else if (std::next(I) == Ranges.end())
941  EndLabel = Asm->getFunctionEnd();
942  else
943  EndLabel = getLabelBeforeInsn(std::next(I)->first);
944  assert(EndLabel && "Forgot label after instruction ending a range!");
945 
946  DEBUG(dbgs() << "DotDebugLoc: " << *Begin << "\n");
947 
948  auto Value = getDebugLocValue(Begin);
949  DebugLocEntry Loc(StartLabel, EndLabel, Value);
950  bool couldMerge = false;
951 
952  // If this is a fragment, it may belong to the current DebugLocEntry.
953  if (DIExpr->isFragment()) {
954  // Add this value to the list of open ranges.
955  OpenRanges.push_back(Value);
956 
957  // Attempt to add the fragment to the last entry.
958  if (!DebugLoc.empty())
959  if (DebugLoc.back().MergeValues(Loc))
960  couldMerge = true;
961  }
962 
963  if (!couldMerge) {
964  // Need to add a new DebugLocEntry. Add all values from still
965  // valid non-overlapping fragments.
966  if (OpenRanges.size())
967  Loc.addValues(OpenRanges);
968 
969  DebugLoc.push_back(std::move(Loc));
970  }
971 
972  // Attempt to coalesce the ranges of two otherwise identical
973  // DebugLocEntries.
974  auto CurEntry = DebugLoc.rbegin();
975  DEBUG({
976  dbgs() << CurEntry->getValues().size() << " Values:\n";
977  for (auto &Value : CurEntry->getValues())
978  Value.dump();
979  dbgs() << "-----\n";
980  });
981 
982  auto PrevEntry = std::next(CurEntry);
983  if (PrevEntry != DebugLoc.rend() && PrevEntry->MergeRanges(*CurEntry))
984  DebugLoc.pop_back();
985  }
986 }
987 
988 DbgVariable *DwarfDebug::createConcreteVariable(DwarfCompileUnit &TheCU,
989  LexicalScope &Scope,
990  InlinedVariable IV) {
991  ensureAbstractVariableIsCreatedIfScoped(TheCU, IV, Scope.getScopeNode());
992  ConcreteVariables.push_back(
993  llvm::make_unique<DbgVariable>(IV.first, IV.second));
994  InfoHolder.addScopeVariable(&Scope, ConcreteVariables.back().get());
995  return ConcreteVariables.back().get();
996 }
997 
998 /// Determine whether a *singular* DBG_VALUE is valid for the entirety of its
999 /// enclosing lexical scope. The check ensures there are no other instructions
1000 /// in the same lexical scope preceding the DBG_VALUE and that its range is
1001 /// either open or otherwise rolls off the end of the scope.
1003  const MachineInstr *DbgValue,
1004  const MachineInstr *RangeEnd) {
1005  assert(DbgValue->getDebugLoc() && "DBG_VALUE without a debug location");
1006  auto MBB = DbgValue->getParent();
1007  auto DL = DbgValue->getDebugLoc();
1008  auto *LScope = LScopes.findLexicalScope(DL);
1009  // Scope doesn't exist; this is a dead DBG_VALUE.
1010  if (!LScope)
1011  return false;
1012  auto &LSRange = LScope->getRanges();
1013  if (LSRange.size() == 0)
1014  return false;
1015 
1016  // Determine if the DBG_VALUE is valid at the beginning of its lexical block.
1017  const MachineInstr *LScopeBegin = LSRange.front().first;
1018  // Early exit if the lexical scope begins outside of the current block.
1019  if (LScopeBegin->getParent() != MBB)
1020  return false;
1022  for (++Pred; Pred != MBB->rend(); ++Pred) {
1023  if (Pred->getFlag(MachineInstr::FrameSetup))
1024  break;
1025  auto PredDL = Pred->getDebugLoc();
1026  if (!PredDL || Pred->isMetaInstruction())
1027  continue;
1028  // Check whether the instruction preceding the DBG_VALUE is in the same
1029  // (sub)scope as the DBG_VALUE.
1030  if (DL->getScope() == PredDL->getScope())
1031  return false;
1032  auto *PredScope = LScopes.findLexicalScope(PredDL);
1033  if (!PredScope || LScope->dominates(PredScope))
1034  return false;
1035  }
1036 
1037  // If the range of the DBG_VALUE is open-ended, report success.
1038  if (!RangeEnd)
1039  return true;
1040 
1041  // Fail if there are instructions belonging to our scope in another block.
1042  const MachineInstr *LScopeEnd = LSRange.back().second;
1043  if (LScopeEnd->getParent() != MBB)
1044  return false;
1045 
1046  // Single, constant DBG_VALUEs in the prologue are promoted to be live
1047  // throughout the function. This is a hack, presumably for DWARF v2 and not
1048  // necessarily correct. It would be much better to use a dbg.declare instead
1049  // if we know the constant is live throughout the scope.
1050  if (DbgValue->getOperand(0).isImm() && MBB->pred_empty())
1051  return true;
1052 
1053  return false;
1054 }
1055 
1056 // Find variables for each lexical scope.
1057 void DwarfDebug::collectVariableInfo(DwarfCompileUnit &TheCU,
1058  const DISubprogram *SP,
1059  DenseSet<InlinedVariable> &Processed) {
1060  // Grab the variable info that was squirreled away in the MMI side-table.
1061  collectVariableInfoFromMFTable(TheCU, Processed);
1062 
1063  for (const auto &I : DbgValues) {
1064  InlinedVariable IV = I.first;
1065  if (Processed.count(IV))
1066  continue;
1067 
1068  // Instruction ranges, specifying where IV is accessible.
1069  const auto &Ranges = I.second;
1070  if (Ranges.empty())
1071  continue;
1072 
1073  LexicalScope *Scope = nullptr;
1074  if (const DILocation *IA = IV.second)
1075  Scope = LScopes.findInlinedScope(IV.first->getScope(), IA);
1076  else
1077  Scope = LScopes.findLexicalScope(IV.first->getScope());
1078  // If variable scope is not found then skip this variable.
1079  if (!Scope)
1080  continue;
1081 
1082  Processed.insert(IV);
1083  DbgVariable *RegVar = createConcreteVariable(TheCU, *Scope, IV);
1084 
1085  const MachineInstr *MInsn = Ranges.front().first;
1086  assert(MInsn->isDebugValue() && "History must begin with debug value");
1087 
1088  // Check if there is a single DBG_VALUE, valid throughout the var's scope.
1089  if (Ranges.size() == 1 &&
1090  validThroughout(LScopes, MInsn, Ranges.front().second)) {
1091  RegVar->initializeDbgValue(MInsn);
1092  continue;
1093  }
1094 
1095  // Handle multiple DBG_VALUE instructions describing one variable.
1096  DebugLocStream::ListBuilder List(DebugLocs, TheCU, *Asm, *RegVar, *MInsn);
1097 
1098  // Build the location list for this variable.
1100  buildLocationList(Entries, Ranges);
1101 
1102  // If the variable has a DIBasicType, extract it. Basic types cannot have
1103  // unique identifiers, so don't bother resolving the type with the
1104  // identifier map.
1105  const DIBasicType *BT = dyn_cast<DIBasicType>(
1106  static_cast<const Metadata *>(IV.first->getType()));
1107 
1108  // Finalize the entry by lowering it into a DWARF bytestream.
1109  for (auto &Entry : Entries)
1110  Entry.finalize(*Asm, List, BT);
1111  }
1112 
1113  // Collect info for variables that were optimized out.
1114  for (const DILocalVariable *DV : SP->getVariables()) {
1115  if (Processed.insert(InlinedVariable(DV, nullptr)).second)
1116  if (LexicalScope *Scope = LScopes.findLexicalScope(DV->getScope()))
1117  createConcreteVariable(TheCU, *Scope, InlinedVariable(DV, nullptr));
1118  }
1119 }
1120 
1121 // Process beginning of an instruction.
1124  assert(CurMI);
1125 
1126  const auto *SP = MI->getParent()->getParent()->getFunction()->getSubprogram();
1127  if (!SP || SP->getUnit()->getEmissionKind() == DICompileUnit::NoDebug)
1128  return;
1129 
1130  // Check if source location changes, but ignore DBG_VALUE and CFI locations.
1131  if (MI->isMetaInstruction())
1132  return;
1133  const DebugLoc &DL = MI->getDebugLoc();
1134  // When we emit a line-0 record, we don't update PrevInstLoc; so look at
1135  // the last line number actually emitted, to see if it was line 0.
1136  unsigned LastAsmLine =
1137  Asm->OutStreamer->getContext().getCurrentDwarfLoc().getLine();
1138 
1139  if (DL == PrevInstLoc) {
1140  // If we have an ongoing unspecified location, nothing to do here.
1141  if (!DL)
1142  return;
1143  // We have an explicit location, same as the previous location.
1144  // But we might be coming back to it after a line 0 record.
1145  if (LastAsmLine == 0 && DL.getLine() != 0) {
1146  // Reinstate the source location but not marked as a statement.
1147  const MDNode *Scope = DL.getScope();
1148  recordSourceLine(DL.getLine(), DL.getCol(), Scope, /*Flags=*/0);
1149  }
1150  return;
1151  }
1152 
1153  if (!DL) {
1154  // We have an unspecified location, which might want to be line 0.
1155  // If we have already emitted a line-0 record, don't repeat it.
1156  if (LastAsmLine == 0)
1157  return;
1158  // If user said Don't Do That, don't do that.
1159  if (UnknownLocations == Disable)
1160  return;
1161  // See if we have a reason to emit a line-0 record now.
1162  // Reasons to emit a line-0 record include:
1163  // - User asked for it (UnknownLocations).
1164  // - Instruction has a label, so it's referenced from somewhere else,
1165  // possibly debug information; we want it to have a source location.
1166  // - Instruction is at the top of a block; we don't want to inherit the
1167  // location from the physically previous (maybe unrelated) block.
1168  if (UnknownLocations == Enable || PrevLabel ||
1169  (PrevInstBB && PrevInstBB != MI->getParent())) {
1170  // Preserve the file and column numbers, if we can, to save space in
1171  // the encoded line table.
1172  // Do not update PrevInstLoc, it remembers the last non-0 line.
1173  const MDNode *Scope = nullptr;
1174  unsigned Column = 0;
1175  if (PrevInstLoc) {
1176  Scope = PrevInstLoc.getScope();
1177  Column = PrevInstLoc.getCol();
1178  }
1179  recordSourceLine(/*Line=*/0, Column, Scope, /*Flags=*/0);
1180  }
1181  return;
1182  }
1183 
1184  // We have an explicit location, different from the previous location.
1185  // Don't repeat a line-0 record, but otherwise emit the new location.
1186  // (The new location might be an explicit line 0, which we do emit.)
1187  if (PrevInstLoc && DL.getLine() == 0 && LastAsmLine == 0)
1188  return;
1189  unsigned Flags = 0;
1190  if (DL == PrologEndLoc) {
1192  PrologEndLoc = DebugLoc();
1193  }
1194  // If the line changed, we call that a new statement; unless we went to
1195  // line 0 and came back, in which case it is not a new statement.
1196  unsigned OldLine = PrevInstLoc ? PrevInstLoc.getLine() : LastAsmLine;
1197  if (DL.getLine() && DL.getLine() != OldLine)
1198  Flags |= DWARF2_FLAG_IS_STMT;
1199 
1200  const MDNode *Scope = DL.getScope();
1201  recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1202 
1203  // If we're not at line 0, remember this location.
1204  if (DL.getLine())
1205  PrevInstLoc = DL;
1206 }
1207 
1208 static DebugLoc findPrologueEndLoc(const MachineFunction *MF) {
1209  // First known non-DBG_VALUE and non-frame setup location marks
1210  // the beginning of the function body.
1211  for (const auto &MBB : *MF)
1212  for (const auto &MI : MBB)
1213  if (!MI.isMetaInstruction() && !MI.getFlag(MachineInstr::FrameSetup) &&
1214  MI.getDebugLoc())
1215  return MI.getDebugLoc();
1216  return DebugLoc();
1217 }
1218 
1219 // Gather pre-function debug information. Assumes being called immediately
1220 // after the function entry point has been emitted.
1222  CurFn = MF;
1223 
1224  auto *SP = MF->getFunction()->getSubprogram();
1226  if (SP->getUnit()->getEmissionKind() == DICompileUnit::NoDebug)
1227  return;
1228 
1229  DwarfCompileUnit &CU = getOrCreateDwarfCompileUnit(SP->getUnit());
1230 
1231  // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1232  // belongs to so that we add to the correct per-cu line table in the
1233  // non-asm case.
1234  if (Asm->OutStreamer->hasRawTextSupport())
1235  // Use a single line table if we are generating assembly.
1236  Asm->OutStreamer->getContext().setDwarfCompileUnitID(0);
1237  else
1238  Asm->OutStreamer->getContext().setDwarfCompileUnitID(CU.getUniqueID());
1239 
1240  // Record beginning of function.
1242  if (PrologEndLoc) {
1243  // We'd like to list the prologue as "not statements" but GDB behaves
1244  // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1245  auto *SP = PrologEndLoc->getInlinedAtScope()->getSubprogram();
1246  recordSourceLine(SP->getScopeLine(), 0, SP, DWARF2_FLAG_IS_STMT);
1247  }
1248 }
1249 
1251  // If we don't have a subprogram for this function then there will be a hole
1252  // in the range information. Keep note of this by setting the previously used
1253  // section to nullptr.
1254  PrevCU = nullptr;
1255  CurFn = nullptr;
1256 }
1257 
1258 // Gather and emit post-function debug information.
1260  const DISubprogram *SP = MF->getFunction()->getSubprogram();
1261 
1262  assert(CurFn == MF &&
1263  "endFunction should be called with the same function as beginFunction");
1264 
1265  // Set DwarfDwarfCompileUnitID in MCContext to default value.
1266  Asm->OutStreamer->getContext().setDwarfCompileUnitID(0);
1267 
1269  assert(!FnScope || SP == FnScope->getScopeNode());
1270  DwarfCompileUnit &TheCU = *CUMap.lookup(SP->getUnit());
1271 
1272  DenseSet<InlinedVariable> ProcessedVars;
1273  collectVariableInfo(TheCU, SP, ProcessedVars);
1274 
1275  // Add the range of this function to the list of ranges for the CU.
1276  TheCU.addRange(RangeSpan(Asm->getFunctionBegin(), Asm->getFunctionEnd()));
1277 
1278  // Under -gmlt, skip building the subprogram if there are no inlined
1279  // subroutines inside it. But with -fdebug-info-for-profiling, the subprogram
1280  // is still needed as we need its source location.
1281  if (!TheCU.getCUNode()->getDebugInfoForProfiling() &&
1282  TheCU.getCUNode()->getEmissionKind() == DICompileUnit::LineTablesOnly &&
1283  LScopes.getAbstractScopesList().empty() && !IsDarwin) {
1284  assert(InfoHolder.getScopeVariables().empty());
1285  PrevLabel = nullptr;
1286  CurFn = nullptr;
1287  return;
1288  }
1289 
1290 #ifndef NDEBUG
1291  size_t NumAbstractScopes = LScopes.getAbstractScopesList().size();
1292 #endif
1293  // Construct abstract scopes.
1294  for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
1295  auto *SP = cast<DISubprogram>(AScope->getScopeNode());
1296  // Collect info for variables that were optimized out.
1297  for (const DILocalVariable *DV : SP->getVariables()) {
1298  if (!ProcessedVars.insert(InlinedVariable(DV, nullptr)).second)
1299  continue;
1300  ensureAbstractVariableIsCreated(TheCU, InlinedVariable(DV, nullptr),
1301  DV->getScope());
1302  assert(LScopes.getAbstractScopesList().size() == NumAbstractScopes
1303  && "ensureAbstractVariableIsCreated inserted abstract scopes");
1304  }
1305  constructAbstractSubprogramScopeDIE(TheCU, AScope);
1306  }
1307 
1308  ProcessedSPNodes.insert(SP);
1309  TheCU.constructSubprogramScopeDIE(SP, FnScope);
1310  if (auto *SkelCU = TheCU.getSkeleton())
1311  if (!LScopes.getAbstractScopesList().empty() &&
1312  TheCU.getCUNode()->getSplitDebugInlining())
1313  SkelCU->constructSubprogramScopeDIE(SP, FnScope);
1314 
1315  // Clear debug info
1316  // Ownership of DbgVariables is a bit subtle - ScopeVariables owns all the
1317  // DbgVariables except those that are also in AbstractVariables (since they
1318  // can be used cross-function)
1319  InfoHolder.getScopeVariables().clear();
1320  PrevLabel = nullptr;
1321  CurFn = nullptr;
1322 }
1323 
1324 // Register a source line with debug info. Returns the unique label that was
1325 // emitted and which provides correspondence to the source line list.
1326 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1327  unsigned Flags) {
1328  StringRef Fn;
1329  StringRef Dir;
1330  unsigned Src = 1;
1331  unsigned Discriminator = 0;
1332  if (auto *Scope = cast_or_null<DIScope>(S)) {
1333  Fn = Scope->getFilename();
1334  Dir = Scope->getDirectory();
1335  if (Line != 0 && getDwarfVersion() >= 4)
1336  if (auto *LBF = dyn_cast<DILexicalBlockFile>(Scope))
1337  Discriminator = LBF->getDiscriminator();
1338 
1339  unsigned CUID = Asm->OutStreamer->getContext().getDwarfCompileUnitID();
1340  Src = static_cast<DwarfCompileUnit &>(*InfoHolder.getUnits()[CUID])
1341  .getOrCreateSourceID(Fn, Dir);
1342  }
1343  Asm->OutStreamer->EmitDwarfLocDirective(Src, Line, Col, Flags, 0,
1344  Discriminator, Fn);
1345 }
1346 
1347 //===----------------------------------------------------------------------===//
1348 // Emit Methods
1349 //===----------------------------------------------------------------------===//
1350 
1351 // Emit the debug info section.
1352 void DwarfDebug::emitDebugInfo() {
1353  DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1354  Holder.emitUnits(/* UseOffsets */ false);
1355 }
1356 
1357 // Emit the abbreviation section.
1358 void DwarfDebug::emitAbbreviations() {
1359  DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1360 
1362 }
1363 
1364 void DwarfDebug::emitAccel(DwarfAccelTable &Accel, MCSection *Section,
1365  StringRef TableName) {
1366  Accel.FinalizeTable(Asm, TableName);
1367  Asm->OutStreamer->SwitchSection(Section);
1368 
1369  // Emit the full data.
1370  Accel.emit(Asm, Section->getBeginSymbol(), this);
1371 }
1372 
1373 // Emit visible names into a hashed accelerator table section.
1374 void DwarfDebug::emitAccelNames() {
1375  emitAccel(AccelNames, Asm->getObjFileLowering().getDwarfAccelNamesSection(),
1376  "Names");
1377 }
1378 
1379 // Emit objective C classes and categories into a hashed accelerator table
1380 // section.
1381 void DwarfDebug::emitAccelObjC() {
1382  emitAccel(AccelObjC, Asm->getObjFileLowering().getDwarfAccelObjCSection(),
1383  "ObjC");
1384 }
1385 
1386 // Emit namespace dies into a hashed accelerator table.
1387 void DwarfDebug::emitAccelNamespaces() {
1388  emitAccel(AccelNamespace,
1390  "namespac");
1391 }
1392 
1393 // Emit type dies into a hashed accelerator table.
1394 void DwarfDebug::emitAccelTypes() {
1395  emitAccel(AccelTypes, Asm->getObjFileLowering().getDwarfAccelTypesSection(),
1396  "types");
1397 }
1398 
1399 // Public name handling.
1400 // The format for the various pubnames:
1401 //
1402 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
1403 // for the DIE that is named.
1404 //
1405 // gnu pubnames - offset/index value/name tuples where the offset is the offset
1406 // into the CU and the index value is computed according to the type of value
1407 // for the DIE that is named.
1408 //
1409 // For type units the offset is the offset of the skeleton DIE. For split dwarf
1410 // it's the offset within the debug_info/debug_types dwo section, however, the
1411 // reference in the pubname header doesn't change.
1412 
1413 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
1415  const DIE *Die) {
1416  // Entities that ended up only in a Type Unit reference the CU instead (since
1417  // the pub entry has offsets within the CU there's no real offset that can be
1418  // provided anyway). As it happens all such entities (namespaces and types,
1419  // types only in C++ at that) are rendered as TYPE+EXTERNAL. If this turns out
1420  // not to be true it would be necessary to persist this information from the
1421  // point at which the entry is added to the index data structure - since by
1422  // the time the index is built from that, the original type/namespace DIE in a
1423  // type unit has already been destroyed so it can't be queried for properties
1424  // like tag, etc.
1425  if (Die->getTag() == dwarf::DW_TAG_compile_unit)
1429 
1430  // We could have a specification DIE that has our most of our knowledge,
1431  // look for that now.
1432  if (DIEValue SpecVal = Die->findAttribute(dwarf::DW_AT_specification)) {
1433  DIE &SpecDIE = SpecVal.getDIEEntry().getEntry();
1434  if (SpecDIE.findAttribute(dwarf::DW_AT_external))
1435  Linkage = dwarf::GIEL_EXTERNAL;
1436  } else if (Die->findAttribute(dwarf::DW_AT_external))
1437  Linkage = dwarf::GIEL_EXTERNAL;
1438 
1439  switch (Die->getTag()) {
1440  case dwarf::DW_TAG_class_type:
1441  case dwarf::DW_TAG_structure_type:
1442  case dwarf::DW_TAG_union_type:
1443  case dwarf::DW_TAG_enumeration_type:
1445  dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
1448  case dwarf::DW_TAG_typedef:
1449  case dwarf::DW_TAG_base_type:
1450  case dwarf::DW_TAG_subrange_type:
1452  case dwarf::DW_TAG_namespace:
1453  return dwarf::GIEK_TYPE;
1454  case dwarf::DW_TAG_subprogram:
1456  case dwarf::DW_TAG_variable:
1458  case dwarf::DW_TAG_enumerator:
1461  default:
1462  return dwarf::GIEK_NONE;
1463  }
1464 }
1465 
1466 /// emitDebugPubSections - Emit visible names and types into debug pubnames and
1467 /// pubtypes sections.
1468 void DwarfDebug::emitDebugPubSections() {
1469  for (const auto &NU : CUMap) {
1470  DwarfCompileUnit *TheU = NU.second;
1471  if (!TheU->hasDwarfPubSections())
1472  continue;
1473 
1474  bool GnuStyle = TheU->getCUNode()->getGnuPubnames();
1475 
1476  Asm->OutStreamer->SwitchSection(
1479  emitDebugPubSection(GnuStyle, "Names", TheU, TheU->getGlobalNames());
1480 
1481  Asm->OutStreamer->SwitchSection(
1484  emitDebugPubSection(GnuStyle, "Types", TheU, TheU->getGlobalTypes());
1485  }
1486 }
1487 
1488 void DwarfDebug::emitDebugPubSection(bool GnuStyle, StringRef Name,
1489  DwarfCompileUnit *TheU,
1490  const StringMap<const DIE *> &Globals) {
1491  if (auto *Skeleton = TheU->getSkeleton())
1492  TheU = Skeleton;
1493 
1494  // Emit the header.
1495  Asm->OutStreamer->AddComment("Length of Public " + Name + " Info");
1496  MCSymbol *BeginLabel = Asm->createTempSymbol("pub" + Name + "_begin");
1497  MCSymbol *EndLabel = Asm->createTempSymbol("pub" + Name + "_end");
1498  Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
1499 
1500  Asm->OutStreamer->EmitLabel(BeginLabel);
1501 
1502  Asm->OutStreamer->AddComment("DWARF Version");
1504 
1505  Asm->OutStreamer->AddComment("Offset of Compilation Unit Info");
1507 
1508  Asm->OutStreamer->AddComment("Compilation Unit Length");
1509  Asm->EmitInt32(TheU->getLength());
1510 
1511  // Emit the pubnames for this compilation unit.
1512  for (const auto &GI : Globals) {
1513  const char *Name = GI.getKeyData();
1514  const DIE *Entity = GI.second;
1515 
1516  Asm->OutStreamer->AddComment("DIE offset");
1517  Asm->EmitInt32(Entity->getOffset());
1518 
1519  if (GnuStyle) {
1521  Asm->OutStreamer->AddComment(
1522  Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
1524  Asm->EmitInt8(Desc.toBits());
1525  }
1526 
1527  Asm->OutStreamer->AddComment("External Name");
1528  Asm->OutStreamer->EmitBytes(StringRef(Name, GI.getKeyLength() + 1));
1529  }
1530 
1531  Asm->OutStreamer->AddComment("End Mark");
1532  Asm->EmitInt32(0);
1533  Asm->OutStreamer->EmitLabel(EndLabel);
1534 }
1535 
1536 /// Emit null-terminated strings into a debug str section.
1537 void DwarfDebug::emitDebugStr() {
1538  DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1540 }
1541 
1543  const DebugLocStream::Entry &Entry) {
1544  auto &&Comments = DebugLocs.getComments(Entry);
1545  auto Comment = Comments.begin();
1546  auto End = Comments.end();
1547  for (uint8_t Byte : DebugLocs.getBytes(Entry))
1548  Streamer.EmitInt8(Byte, Comment != End ? *(Comment++) : "");
1549 }
1550 
1551 static void emitDebugLocValue(const AsmPrinter &AP, const DIBasicType *BT,
1552  ByteStreamer &Streamer,
1553  const DebugLocEntry::Value &Value,
1554  DwarfExpression &DwarfExpr) {
1555  auto *DIExpr = Value.getExpression();
1556  DIExpressionCursor ExprCursor(DIExpr);
1557  DwarfExpr.addFragmentOffset(DIExpr);
1558  // Regular entry.
1559  if (Value.isInt()) {
1560  if (BT && (BT->getEncoding() == dwarf::DW_ATE_signed ||
1561  BT->getEncoding() == dwarf::DW_ATE_signed_char))
1562  DwarfExpr.addSignedConstant(Value.getInt());
1563  else
1564  DwarfExpr.addUnsignedConstant(Value.getInt());
1565  } else if (Value.isLocation()) {
1566  MachineLocation Location = Value.getLoc();
1567  if (Location.isIndirect())
1568  DwarfExpr.setMemoryLocationKind();
1569  DIExpressionCursor Cursor(DIExpr);
1570  const TargetRegisterInfo &TRI = *AP.MF->getSubtarget().getRegisterInfo();
1571  if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg()))
1572  return;
1573  return DwarfExpr.addExpression(std::move(Cursor));
1574  } else if (Value.isConstantFP()) {
1575  APInt RawBytes = Value.getConstantFP()->getValueAPF().bitcastToAPInt();
1576  DwarfExpr.addUnsignedConstant(RawBytes);
1577  }
1578  DwarfExpr.addExpression(std::move(ExprCursor));
1579 }
1580 
1583  const DIBasicType *BT) {
1584  DebugLocStream::EntryBuilder Entry(List, Begin, End);
1585  BufferByteStreamer Streamer = Entry.getStreamer();
1586  DebugLocDwarfExpression DwarfExpr(AP.getDwarfVersion(), Streamer);
1587  const DebugLocEntry::Value &Value = Values[0];
1588  if (Value.isFragment()) {
1589  // Emit all fragments that belong to the same variable and range.
1591  return P.isFragment();
1592  }) && "all values are expected to be fragments");
1593  assert(std::is_sorted(Values.begin(), Values.end()) &&
1594  "fragments are expected to be sorted");
1595 
1596  for (auto Fragment : Values)
1597  emitDebugLocValue(AP, BT, Streamer, Fragment, DwarfExpr);
1598 
1599  } else {
1600  assert(Values.size() == 1 && "only fragments may have >1 value");
1601  emitDebugLocValue(AP, BT, Streamer, Value, DwarfExpr);
1602  }
1603  DwarfExpr.finalize();
1604 }
1605 
1607  // Emit the size.
1608  Asm->OutStreamer->AddComment("Loc expr size");
1609  Asm->EmitInt16(DebugLocs.getBytes(Entry).size());
1610 
1611  // Emit the entry.
1612  APByteStreamer Streamer(*Asm);
1613  emitDebugLocEntry(Streamer, Entry);
1614 }
1615 
1616 // Emit locations into the debug loc section.
1617 void DwarfDebug::emitDebugLoc() {
1618  if (DebugLocs.getLists().empty())
1619  return;
1620 
1621  // Start the dwarf loc section.
1622  Asm->OutStreamer->SwitchSection(
1624  unsigned char Size = Asm->MAI->getCodePointerSize();
1625  for (const auto &List : DebugLocs.getLists()) {
1626  Asm->OutStreamer->EmitLabel(List.Label);
1627  const DwarfCompileUnit *CU = List.CU;
1628  for (const auto &Entry : DebugLocs.getEntries(List)) {
1629  // Set up the range. This range is relative to the entry point of the
1630  // compile unit. This is a hard coded 0 for low_pc when we're emitting
1631  // ranges, or the DW_AT_low_pc on the compile unit otherwise.
1632  if (auto *Base = CU->getBaseAddress()) {
1633  Asm->EmitLabelDifference(Entry.BeginSym, Base, Size);
1634  Asm->EmitLabelDifference(Entry.EndSym, Base, Size);
1635  } else {
1636  Asm->OutStreamer->EmitSymbolValue(Entry.BeginSym, Size);
1637  Asm->OutStreamer->EmitSymbolValue(Entry.EndSym, Size);
1638  }
1639 
1641  }
1642  Asm->OutStreamer->EmitIntValue(0, Size);
1643  Asm->OutStreamer->EmitIntValue(0, Size);
1644  }
1645 }
1646 
1647 void DwarfDebug::emitDebugLocDWO() {
1648  Asm->OutStreamer->SwitchSection(
1650  for (const auto &List : DebugLocs.getLists()) {
1651  Asm->OutStreamer->EmitLabel(List.Label);
1652  for (const auto &Entry : DebugLocs.getEntries(List)) {
1653  // Just always use start_length for now - at least that's one address
1654  // rather than two. We could get fancier and try to, say, reuse an
1655  // address we know we've emitted elsewhere (the start of the function?
1656  // The start of the CU or CU subrange that encloses this range?)
1658  unsigned idx = AddrPool.getIndex(Entry.BeginSym);
1659  Asm->EmitULEB128(idx);
1660  Asm->EmitLabelDifference(Entry.EndSym, Entry.BeginSym, 4);
1661 
1663  }
1665  }
1666 }
1667 
1668 struct ArangeSpan {
1669  const MCSymbol *Start, *End;
1670 };
1671 
1672 // Emit a debug aranges section, containing a CU lookup for any
1673 // address we can tie back to a CU.
1674 void DwarfDebug::emitDebugARanges() {
1675  // Provides a unique id per text section.
1677 
1678  // Filter labels by section.
1679  for (const SymbolCU &SCU : ArangeLabels) {
1680  if (SCU.Sym->isInSection()) {
1681  // Make a note of this symbol and it's section.
1682  MCSection *Section = &SCU.Sym->getSection();
1683  if (!Section->getKind().isMetadata())
1684  SectionMap[Section].push_back(SCU);
1685  } else {
1686  // Some symbols (e.g. common/bss on mach-o) can have no section but still
1687  // appear in the output. This sucks as we rely on sections to build
1688  // arange spans. We can do it without, but it's icky.
1689  SectionMap[nullptr].push_back(SCU);
1690  }
1691  }
1692 
1694 
1695  for (auto &I : SectionMap) {
1696  MCSection *Section = I.first;
1697  SmallVector<SymbolCU, 8> &List = I.second;
1698  if (List.size() < 1)
1699  continue;
1700 
1701  // If we have no section (e.g. common), just write out
1702  // individual spans for each symbol.
1703  if (!Section) {
1704  for (const SymbolCU &Cur : List) {
1705  ArangeSpan Span;
1706  Span.Start = Cur.Sym;
1707  Span.End = nullptr;
1708  assert(Cur.CU);
1709  Spans[Cur.CU].push_back(Span);
1710  }
1711  continue;
1712  }
1713 
1714  // Sort the symbols by offset within the section.
1715  std::sort(
1716  List.begin(), List.end(), [&](const SymbolCU &A, const SymbolCU &B) {
1717  unsigned IA = A.Sym ? Asm->OutStreamer->GetSymbolOrder(A.Sym) : 0;
1718  unsigned IB = B.Sym ? Asm->OutStreamer->GetSymbolOrder(B.Sym) : 0;
1719 
1720  // Symbols with no order assigned should be placed at the end.
1721  // (e.g. section end labels)
1722  if (IA == 0)
1723  return false;
1724  if (IB == 0)
1725  return true;
1726  return IA < IB;
1727  });
1728 
1729  // Insert a final terminator.
1730  List.push_back(SymbolCU(nullptr, Asm->OutStreamer->endSection(Section)));
1731 
1732  // Build spans between each label.
1733  const MCSymbol *StartSym = List[0].Sym;
1734  for (size_t n = 1, e = List.size(); n < e; n++) {
1735  const SymbolCU &Prev = List[n - 1];
1736  const SymbolCU &Cur = List[n];
1737 
1738  // Try and build the longest span we can within the same CU.
1739  if (Cur.CU != Prev.CU) {
1740  ArangeSpan Span;
1741  Span.Start = StartSym;
1742  Span.End = Cur.Sym;
1743  assert(Prev.CU);
1744  Spans[Prev.CU].push_back(Span);
1745  StartSym = Cur.Sym;
1746  }
1747  }
1748  }
1749 
1750  // Start the dwarf aranges section.
1751  Asm->OutStreamer->SwitchSection(
1753 
1754  unsigned PtrSize = Asm->MAI->getCodePointerSize();
1755 
1756  // Build a list of CUs used.
1757  std::vector<DwarfCompileUnit *> CUs;
1758  for (const auto &it : Spans) {
1759  DwarfCompileUnit *CU = it.first;
1760  CUs.push_back(CU);
1761  }
1762 
1763  // Sort the CU list (again, to ensure consistent output order).
1764  std::sort(CUs.begin(), CUs.end(),
1765  [](const DwarfCompileUnit *A, const DwarfCompileUnit *B) {
1766  return A->getUniqueID() < B->getUniqueID();
1767  });
1768 
1769  // Emit an arange table for each CU we used.
1770  for (DwarfCompileUnit *CU : CUs) {
1771  std::vector<ArangeSpan> &List = Spans[CU];
1772 
1773  // Describe the skeleton CU's offset and length, not the dwo file's.
1774  if (auto *Skel = CU->getSkeleton())
1775  CU = Skel;
1776 
1777  // Emit size of content not including length itself.
1778  unsigned ContentSize =
1779  sizeof(int16_t) + // DWARF ARange version number
1780  sizeof(int32_t) + // Offset of CU in the .debug_info section
1781  sizeof(int8_t) + // Pointer Size (in bytes)
1782  sizeof(int8_t); // Segment Size (in bytes)
1783 
1784  unsigned TupleSize = PtrSize * 2;
1785 
1786  // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
1787  unsigned Padding =
1788  OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
1789 
1790  ContentSize += Padding;
1791  ContentSize += (List.size() + 1) * TupleSize;
1792 
1793  // For each compile unit, write the list of spans it covers.
1794  Asm->OutStreamer->AddComment("Length of ARange Set");
1795  Asm->EmitInt32(ContentSize);
1796  Asm->OutStreamer->AddComment("DWARF Arange version number");
1798  Asm->OutStreamer->AddComment("Offset Into Debug Info Section");
1800  Asm->OutStreamer->AddComment("Address Size (in bytes)");
1801  Asm->EmitInt8(PtrSize);
1802  Asm->OutStreamer->AddComment("Segment Size (in bytes)");
1803  Asm->EmitInt8(0);
1804 
1805  Asm->OutStreamer->emitFill(Padding, 0xff);
1806 
1807  for (const ArangeSpan &Span : List) {
1808  Asm->EmitLabelReference(Span.Start, PtrSize);
1809 
1810  // Calculate the size as being from the span start to it's end.
1811  if (Span.End) {
1812  Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
1813  } else {
1814  // For symbols without an end marker (e.g. common), we
1815  // write a single arange entry containing just that one symbol.
1816  uint64_t Size = SymSize[Span.Start];
1817  if (Size == 0)
1818  Size = 1;
1819 
1820  Asm->OutStreamer->EmitIntValue(Size, PtrSize);
1821  }
1822  }
1823 
1824  Asm->OutStreamer->AddComment("ARange terminator");
1825  Asm->OutStreamer->EmitIntValue(0, PtrSize);
1826  Asm->OutStreamer->EmitIntValue(0, PtrSize);
1827  }
1828 }
1829 
1830 /// Emit address ranges into a debug ranges section.
1831 void DwarfDebug::emitDebugRanges() {
1832  if (CUMap.empty())
1833  return;
1834 
1835  // Start the dwarf ranges section.
1836  Asm->OutStreamer->SwitchSection(
1838 
1839  // Size for our labels.
1840  unsigned char Size = Asm->MAI->getCodePointerSize();
1841 
1842  // Grab the specific ranges for the compile units in the module.
1843  for (const auto &I : CUMap) {
1844  DwarfCompileUnit *TheCU = I.second;
1845 
1846  if (auto *Skel = TheCU->getSkeleton())
1847  TheCU = Skel;
1848 
1849  // Iterate over the misc ranges for the compile units in the module.
1850  for (const RangeSpanList &List : TheCU->getRangeLists()) {
1851  // Emit our symbol so we can find the beginning of the range.
1852  Asm->OutStreamer->EmitLabel(List.getSym());
1853 
1854  // Gather all the ranges that apply to the same section so they can share
1855  // a base address entry.
1857  for (const RangeSpan &Range : List.getRanges()) {
1858  MV[&Range.getStart()->getSection()].push_back(&Range);
1859  }
1860 
1861  auto *CUBase = TheCU->getBaseAddress();
1862  bool BaseIsSet = false;
1863  for (const auto &P : MV) {
1864  // Don't bother with a base address entry if there's only one range in
1865  // this section in this range list - for example ranges for a CU will
1866  // usually consist of single regions from each of many sections
1867  // (-ffunction-sections, or just C++ inline functions) except under LTO
1868  // or optnone where there may be holes in a single CU's section
1869  // contrubutions.
1870  auto *Base = CUBase;
1871  if (!Base && P.second.size() > 1 &&
1873  BaseIsSet = true;
1874  // FIXME/use care: This may not be a useful base address if it's not
1875  // the lowest address/range in this object.
1876  Base = P.second.front()->getStart();
1877  Asm->OutStreamer->EmitIntValue(-1, Size);
1878  Asm->OutStreamer->EmitSymbolValue(Base, Size);
1879  } else if (BaseIsSet) {
1880  BaseIsSet = false;
1881  Asm->OutStreamer->EmitIntValue(-1, Size);
1882  Asm->OutStreamer->EmitIntValue(0, Size);
1883  }
1884 
1885  for (const auto *RS : P.second) {
1886  const MCSymbol *Begin = RS->getStart();
1887  const MCSymbol *End = RS->getEnd();
1888  assert(Begin && "Range without a begin symbol?");
1889  assert(End && "Range without an end symbol?");
1890  if (Base) {
1891  Asm->EmitLabelDifference(Begin, Base, Size);
1892  Asm->EmitLabelDifference(End, Base, Size);
1893  } else {
1894  Asm->OutStreamer->EmitSymbolValue(Begin, Size);
1895  Asm->OutStreamer->EmitSymbolValue(End, Size);
1896  }
1897  }
1898  }
1899 
1900  // And terminate the list with two 0 values.
1901  Asm->OutStreamer->EmitIntValue(0, Size);
1902  Asm->OutStreamer->EmitIntValue(0, Size);
1903  }
1904  }
1905 }
1906 
1907 void DwarfDebug::handleMacroNodes(DIMacroNodeArray Nodes, DwarfCompileUnit &U) {
1908  for (auto *MN : Nodes) {
1909  if (auto *M = dyn_cast<DIMacro>(MN))
1910  emitMacro(*M);
1911  else if (auto *F = dyn_cast<DIMacroFile>(MN))
1912  emitMacroFile(*F, U);
1913  else
1914  llvm_unreachable("Unexpected DI type!");
1915  }
1916 }
1917 
1918 void DwarfDebug::emitMacro(DIMacro &M) {
1920  Asm->EmitULEB128(M.getLine());
1921  StringRef Name = M.getName();
1922  StringRef Value = M.getValue();
1923  Asm->OutStreamer->EmitBytes(Name);
1924  if (!Value.empty()) {
1925  // There should be one space between macro name and macro value.
1926  Asm->EmitInt8(' ');
1927  Asm->OutStreamer->EmitBytes(Value);
1928  }
1929  Asm->EmitInt8('\0');
1930 }
1931 
1932 void DwarfDebug::emitMacroFile(DIMacroFile &F, DwarfCompileUnit &U) {
1935  Asm->EmitULEB128(F.getLine());
1936  DIFile *File = F.getFile();
1937  unsigned FID =
1938  U.getOrCreateSourceID(File->getFilename(), File->getDirectory());
1939  Asm->EmitULEB128(FID);
1940  handleMacroNodes(F.getElements(), U);
1942 }
1943 
1944 /// Emit macros into a debug macinfo section.
1945 void DwarfDebug::emitDebugMacinfo() {
1946  if (CUMap.empty())
1947  return;
1948 
1949  // Start the dwarf macinfo section.
1950  Asm->OutStreamer->SwitchSection(
1952 
1953  for (const auto &P : CUMap) {
1954  auto &TheCU = *P.second;
1955  auto *SkCU = TheCU.getSkeleton();
1956  DwarfCompileUnit &U = SkCU ? *SkCU : TheCU;
1957  auto *CUNode = cast<DICompileUnit>(P.first);
1958  Asm->OutStreamer->EmitLabel(U.getMacroLabelBegin());
1959  handleMacroNodes(CUNode->getMacros(), U);
1960  }
1961  Asm->OutStreamer->AddComment("End Of Macro List Mark");
1962  Asm->EmitInt8(0);
1963 }
1964 
1965 // DWARF5 Experimental Separate Dwarf emitters.
1966 
1967 void DwarfDebug::initSkeletonUnit(const DwarfUnit &U, DIE &Die,
1968  std::unique_ptr<DwarfCompileUnit> NewU) {
1969  NewU->addString(Die, dwarf::DW_AT_GNU_dwo_name,
1971 
1972  if (!CompilationDir.empty())
1973  NewU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
1974 
1975  addGnuPubAttributes(*NewU, Die);
1976 
1977  SkeletonHolder.addUnit(std::move(NewU));
1978 }
1979 
1980 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
1981 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
1982 // DW_AT_addr_base, DW_AT_ranges_base.
1983 DwarfCompileUnit &DwarfDebug::constructSkeletonCU(const DwarfCompileUnit &CU) {
1984 
1985  auto OwnedUnit = llvm::make_unique<DwarfCompileUnit>(
1986  CU.getUniqueID(), CU.getCUNode(), Asm, this, &SkeletonHolder);
1987  DwarfCompileUnit &NewCU = *OwnedUnit;
1989 
1990  NewCU.initStmtList();
1991 
1992  initSkeletonUnit(CU, NewCU.getUnitDie(), std::move(OwnedUnit));
1993 
1994  return NewCU;
1995 }
1996 
1997 // Emit the .debug_info.dwo section for separated dwarf. This contains the
1998 // compile units that would normally be in debug_info.
1999 void DwarfDebug::emitDebugInfoDWO() {
2000  assert(useSplitDwarf() && "No split dwarf debug info?");
2001  // Don't emit relocations into the dwo file.
2002  InfoHolder.emitUnits(/* UseOffsets */ true);
2003 }
2004 
2005 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2006 // abbreviations for the .debug_info.dwo section.
2007 void DwarfDebug::emitDebugAbbrevDWO() {
2008  assert(useSplitDwarf() && "No split dwarf?");
2009  InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
2010 }
2011 
2012 void DwarfDebug::emitDebugLineDWO() {
2013  assert(useSplitDwarf() && "No split dwarf?");
2014  Asm->OutStreamer->SwitchSection(
2016  SplitTypeUnitFileTable.Emit(*Asm->OutStreamer, MCDwarfLineTableParams());
2017 }
2018 
2019 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2020 // string section and is identical in format to traditional .debug_str
2021 // sections.
2022 void DwarfDebug::emitDebugStrDWO() {
2023  assert(useSplitDwarf() && "No split dwarf?");
2025  InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2026  OffSec);
2027 }
2028 
2029 MCDwarfDwoLineTable *DwarfDebug::getDwoLineTable(const DwarfCompileUnit &CU) {
2030  if (!useSplitDwarf())
2031  return nullptr;
2032  if (SingleCU)
2033  SplitTypeUnitFileTable.setCompilationDir(CU.getCUNode()->getDirectory());
2034  return &SplitTypeUnitFileTable;
2035 }
2036 
2038  MD5 Hash;
2039  Hash.update(Identifier);
2040  // ... take the least significant 8 bytes and return those. Our MD5
2041  // implementation always returns its results in little endian, so we actually
2042  // need the "high" word.
2043  MD5::MD5Result Result;
2044  Hash.final(Result);
2045  return Result.high();
2046 }
2047 
2049  StringRef Identifier, DIE &RefDie,
2050  const DICompositeType *CTy) {
2051  // Fast path if we're building some type units and one has already used the
2052  // address pool we know we're going to throw away all this work anyway, so
2053  // don't bother building dependent types.
2054  if (!TypeUnitsUnderConstruction.empty() && AddrPool.hasBeenUsed())
2055  return;
2056 
2057  auto Ins = TypeSignatures.insert(std::make_pair(CTy, 0));
2058  if (!Ins.second) {
2059  CU.addDIETypeSignature(RefDie, Ins.first->second);
2060  return;
2061  }
2062 
2063  bool TopLevelType = TypeUnitsUnderConstruction.empty();
2064  AddrPool.resetUsedFlag();
2065 
2066  auto OwnedUnit = llvm::make_unique<DwarfTypeUnit>(CU, Asm, this, &InfoHolder,
2067  getDwoLineTable(CU));
2068  DwarfTypeUnit &NewTU = *OwnedUnit;
2069  DIE &UnitDie = NewTU.getUnitDie();
2070  TypeUnitsUnderConstruction.emplace_back(std::move(OwnedUnit), CTy);
2071 
2072  NewTU.addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
2073  CU.getLanguage());
2074 
2075  uint64_t Signature = makeTypeSignature(Identifier);
2076  NewTU.setTypeSignature(Signature);
2077  Ins.first->second = Signature;
2078 
2079  if (useSplitDwarf())
2080  NewTU.setSection(Asm->getObjFileLowering().getDwarfTypesDWOSection());
2081  else {
2082  CU.applyStmtList(UnitDie);
2083  NewTU.setSection(Asm->getObjFileLowering().getDwarfTypesSection(Signature));
2084  }
2085 
2086  NewTU.setType(NewTU.createTypeDIE(CTy));
2087 
2088  if (TopLevelType) {
2089  auto TypeUnitsToAdd = std::move(TypeUnitsUnderConstruction);
2090  TypeUnitsUnderConstruction.clear();
2091 
2092  // Types referencing entries in the address table cannot be placed in type
2093  // units.
2094  if (AddrPool.hasBeenUsed()) {
2095 
2096  // Remove all the types built while building this type.
2097  // This is pessimistic as some of these types might not be dependent on
2098  // the type that used an address.
2099  for (const auto &TU : TypeUnitsToAdd)
2100  TypeSignatures.erase(TU.second);
2101 
2102  // Construct this type in the CU directly.
2103  // This is inefficient because all the dependent types will be rebuilt
2104  // from scratch, including building them in type units, discovering that
2105  // they depend on addresses, throwing them out and rebuilding them.
2106  CU.constructTypeDIE(RefDie, cast<DICompositeType>(CTy));
2107  return;
2108  }
2109 
2110  // If the type wasn't dependent on fission addresses, finish adding the type
2111  // and all its dependent types.
2112  for (auto &TU : TypeUnitsToAdd) {
2113  InfoHolder.computeSizeAndOffsetsForUnit(TU.first.get());
2114  InfoHolder.emitUnit(TU.first.get(), useSplitDwarf());
2115  }
2116  }
2117  CU.addDIETypeSignature(RefDie, Signature);
2118 }
2119 
2120 // Accelerator table mutators - add each name along with its companion
2121 // DIE to the proper table while ensuring that the name that we're going
2122 // to reference is in the string table. We do this since the names we
2123 // add may not only be identical to the names in the DIE.
2124 void DwarfDebug::addAccelName(StringRef Name, const DIE &Die) {
2125  if (!useDwarfAccelTables())
2126  return;
2127  AccelNames.AddName(InfoHolder.getStringPool().getEntry(*Asm, Name), &Die);
2128 }
2129 
2130 void DwarfDebug::addAccelObjC(StringRef Name, const DIE &Die) {
2131  if (!useDwarfAccelTables())
2132  return;
2133  AccelObjC.AddName(InfoHolder.getStringPool().getEntry(*Asm, Name), &Die);
2134 }
2135 
2137  if (!useDwarfAccelTables())
2138  return;
2139  AccelNamespace.AddName(InfoHolder.getStringPool().getEntry(*Asm, Name), &Die);
2140 }
2141 
2142 void DwarfDebug::addAccelType(StringRef Name, const DIE &Die, char Flags) {
2143  if (!useDwarfAccelTables())
2144  return;
2145  AccelTypes.AddName(InfoHolder.getStringPool().getEntry(*Asm, Name), &Die);
2146 }
2147 
2149  return Asm->OutStreamer->getContext().getDwarfVersion();
2150 }
const StringMap< const DIE * > & getGlobalTypes() const
const DICompileUnit * getCUNode() const
Definition: DwarfUnit.h:113
void emitDebugLocEntryLocation(const DebugLocStream::Entry &Entry)
Emit the location for a debug loc entry, including the size header.
debug_compile_units_iterator debug_compile_units_end() const
Definition: Module.h:747
const TargetLoweringObjectFile & getObjFileLowering() const
Return information about object file lowering.
Definition: AsmPrinter.cpp:193
Instances of this class represent a uniqued identifier for a section in the current translation unit...
Definition: MCSection.h:39
const SmallVectorImpl< RangeSpanList > & getRangeLists() const
getRangeLists - Get the vector of range lists.
An object containing the capability of hashing and adding hash attributes onto a DIE.
Definition: DIEHash.h:28
const DILocalScope * getScopeNode() const
Definition: LexicalScopes.h:64
Builder for DebugLocStream lists.
void addFlag(DIE &Die, dwarf::Attribute Attribute)
Add a flag that is true to the DIE.
Definition: DwarfUnit.cpp:205
SectionKind getKind() const
Definition: MCSection.h:102
static cl::opt< bool > SplitDwarfCrossCuReferences("split-dwarf-cross-cu-references", cl::Hidden, cl::desc("Enable cross-cu references in DWO files"), cl::init(false))
void addUnit(std::unique_ptr< DwarfCompileUnit > U)
Add a unit to the list of CUs.
Definition: DwarfFile.cpp:27
static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU, const DIE *Die)
computeIndexValue - Compute the gdb index value for the DIE and CU.
LLVM_NODISCARD std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:228
static cl::opt< bool > DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden, cl::desc("Disable debug info printing"))
MCSection * getDwarfAccelObjCSection() const
This struct describes location entries emitted in the .debug_loc section.
Definition: DebugLocEntry.h:25
const MCSymbol * getBaseAddress() const
std::unique_ptr< MCStreamer > OutStreamer
This is the MCStreamer object for the file we are generating.
Definition: AsmPrinter.h:93
bool hasDebugInfo() const
Returns true if valid debug info is present.
#define DWARF2_FLAG_PROLOGUE_END
Definition: MCDwarf.h:71
struct fuzzer::@309 Flags
MCSection * getDwarfStrSection() const
MCTargetOptions MCOptions
Machine level options.
static SmallVectorImpl< DwarfCompileUnit::GlobalExpr > & sortGlobalExprs(SmallVectorImpl< DwarfCompileUnit::GlobalExpr > &GVEs)
Sort and unique GVEs by comparing their fragment offset.
Definition: DwarfDebug.cpp:508
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
bool isAbstractScope() const
Definition: LexicalScopes.h:65
void addUnsignedConstant(uint64_t Value)
Emit an unsigned constant.
unsigned getRuntimeVersion() const
MCSection * getDwarfLocSection() const
void EmitInt8(int Value) const
Emit a byte directive and value.
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
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
Definition: SmallVector.h:136
void setMemoryLocationKind()
Lock this down to become a memory location description.
auto remove_if(R &&Range, UnaryPredicate P) -> decltype(std::begin(Range))
Provide wrappers to std::remove_if which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:856
virtual const TargetRegisterInfo * getRegisterInfo() const
getRegisterInfo - If register information is available, return it.
Implements a dense probed hash-table based set.
Definition: DenseSet.h:221
const DIType * getType() const
Definition: DwarfDebug.cpp:164
const DebugLoc & getDebugLoc() const
Returns the debug location id of this MachineInstr.
Definition: MachineInstr.h:257
std::string SplitDwarfFile
uint16_t getDwarfVersion() const
unsigned getReg() const
unsigned getReg() const
getReg - Returns the register number.
MCSection * getDwarfAccelNamesSection() const
const MachineFunction * MF
The current machine function.
Definition: AsmPrinter.h:96
Base class containing the logic for constructing DWARF expressions independently of whether they are ...
void createAbstractVariable(const DILocalVariable *DV, LexicalScope *Scope)
SmallVectorImpl< InsnRange > & getRanges()
Definition: LexicalScopes.h:67
static enum BaseType getBaseType(const Value *Val)
Return the baseType for Val which states whether Val is exclusively derived from constant/null, or not exclusively derived from constant.
bool useDwarfAccelTables() const
Returns whether or not to emit tables that dwarf consumers can use to accelerate lookup.
Definition: DwarfDebug.h:508
void emit(AsmPrinter *, const MCSymbol *, DwarfDebug *)
void emitDwarfSymbolReference(const MCSymbol *Label, bool ForceOffset=false) const
Emit a reference to a symbol for use in dwarf.
DenseMap< LexicalScope *, SmallVector< DbgVariable *, 8 > > & getScopeVariables()
Definition: DwarfFile.h:97
This class implements a map that also provides access to all stored values in a deterministic order...
Definition: MapVector.h:38
unsigned getLine() const
Definition: DebugLoc.cpp:26
uint64_t getDWOId() const
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:816
static const char *const DbgTimerName
Definition: DwarfDebug.cpp:136
A debug info location.
Definition: DebugLoc.h:34
Metadata node.
Definition: Metadata.h:862
F(f)
MCSection * getDwarfARangesSection() const
StringRef getProducer() const
void emitStrings(MCSection *StrSection, MCSection *OffsetSection=nullptr)
Emit all of the strings to the section given.
Definition: DwarfFile.cpp:80
bool isMetaInstruction() const
Return true if this instruction doesn&#39;t produce any output in the form of executable instructions...
Definition: MachineInstr.h:852
LexicalScope - This class is used to track scope information.
Definition: LexicalScopes.h:45
bool isImm() const
isImm - Tests if this is a MO_Immediate operand.
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:1596
static cl::opt< DefaultOnOff > DwarfAccelTables("dwarf-accel-tables", cl::Hidden, cl::desc("Output prototype dwarf accelerator tables."), cl::values(clEnumVal(Default, "Default for platform"), clEnumVal(Enable, "Enabled"), clEnumVal(Disable, "Disabled")), cl::init(Default))
const MachineInstr * CurMI
If nonnull, stores the current machine instruction we&#39;re processing.
VariableDbgInfoMapTy & getVariableDbgInfo()
DIE * getOrCreateTypeDIE(const MDNode *N)
Find existing DIE or create new DIE for the given type.
Definition: DwarfUnit.cpp:697
void addAccelNamespace(StringRef Name, const DIE &Die)
bool useSplitDwarf() const
Returns whether or not to change the current debug info for the split dwarf proposal support...
Definition: DwarfDebug.h:516
void initializeDbgValue(const MachineInstr *DbgValue)
Initialize from a DBG_VALUE instruction.
Definition: DwarfDebug.h:110
static const char *const DbgTimerDescription
Definition: DwarfDebug.cpp:137
static cl::opt< bool > GenerateARangeSection("generate-arange-section", cl::Hidden, cl::desc("Generate dwarf aranges"), cl::init(false))
MCSection * getDwarfPubNamesSection() const
virtual void EmitULEB128(uint64_t DWord, const Twine &Comment="")=0
void attachRangesOrLowHighPC(DIE &D, SmallVector< RangeSpan, 2 > Ranges)
DIScope * getScope() const
DebugLoc PrevInstLoc
Previous instruction&#39;s location information.
StringRef getSplitDebugFilename() const
#define DWARF2_FLAG_IS_STMT
Definition: MCDwarf.h:69
StringRef getFlags() const
MCSection * getDwarfMacinfoSection() const
LexicalScope * getOrCreateAbstractScope(const DILocalScope *Scope)
getOrCreateAbstractScope - Find or create an abstract lexical scope.
MCSection * getDwarfLocDWOSection() const
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
DbgValueHistoryMap DbgValues
History of DBG_VALUE and clobber instructions for each user variable.
unsigned getTag() const
const ConstantFP * getFPImm() const
unsigned getNumOperands() const
Access to explicit operands of the instruction.
Definition: MachineInstr.h:282
void update(ArrayRef< uint8_t > Data)
Updates the hash for the byte stream provided.
Definition: MD5.cpp:189
This class is basically a combination of TimeRegion and Timer.
Definition: Timer.h:160
const DIE * getUnitDie() const
Climb up the parent chain to get the compile unit or type unit DIE that this DIE belongs to...
Definition: DIE.cpp:202
MachineBasicBlock iterator that automatically skips over MIs that are inside bundles (i...
static StringRef getName(Value *V)
bool isLexicalScopeDIENull(LexicalScope *Scope)
A helper function to check whether the DIE for a given Scope is going to be null. ...
Definition: DwarfDebug.cpp:351
void constructContainingTypeDIEs()
Construct DIEs for types that contain vtables.
Definition: DwarfUnit.cpp:1373
virtual void EmitInt8(uint8_t Byte, const Twine &Comment="")=0
Holds a DIExpression and keeps track of how many operands have been consumed so far.
uint64_t computeCUSignature(StringRef DWOName, const DIE &Die)
Computes the CU signature.
Definition: DIEHash.cpp:383
#define clEnumVal(ENUMVAL, DESC)
Definition: CommandLine.h:599
StringRef getFilename() const
DwarfExpression implementation for .debug_loc entries.
This file implements a class to represent arbitrary precision integral constant values and operations...
Subprogram description.
Decsribes an entry of the various gnu_pub* debug sections.
Definition: Dwarf.h:464
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:267
unsigned getUniqueID() const
~DwarfDebug() override
MCSymbol * getFunctionBegin() const
Definition: AsmPrinter.h:197
static bool validThroughout(LexicalScopes &LScopes, const MachineInstr *DbgValue, const MachineInstr *RangeEnd)
Determine whether a singular DBG_VALUE is valid for the entirety of its enclosing lexical scope...
This class is used to track local variable information.
Definition: DwarfDebug.h:76
#define T
void setBaseAddress(const MCSymbol *Base)
void FinalizeTable(AsmPrinter *, StringRef)
void EmitInt16(int Value) const
Emit a short directive and value.
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:133
DIMacroNodeArray getElements() const
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
bool MergeValues(const DebugLocEntry &Next)
If this and Next are describing different pieces of the same variable, merge them by appending Next&#39;s...
Definition: DwarfDebug.cpp:854
static Optional< FragmentInfo > getFragmentInfo(expr_op_iterator Start, expr_op_iterator End)
Retrieve the details of this fragment expression.
bool isFPImm() const
isFPImm - Tests if this is a MO_FPImmediate operand.
debug_compile_units_iterator debug_compile_units_begin() const
Definition: Module.h:742
LexicalScope * findLexicalScope(const DILocation *DL)
findLexicalScope - Find lexical scope, either regular or inlined, for the given DebugLoc.
const SmallVectorImpl< std::unique_ptr< DwarfCompileUnit > > & getUnits()
Definition: DwarfFile.h:61
MCSection * getDwarfAccelTypesSection() const
Debug location.
DIE & addChild(DIE *Child)
Add a child to the DIE.
Definition: DIE.h:769
static cl::opt< bool > UseDwarfRangesBaseAddressSpecifier("use-dwarf-ranges-base-address-specifier", cl::Hidden, cl::desc("Use base address specifiers in debug_ranges"), cl::init(false))
MCSection * getDwarfAbbrevSection() const
MCSection * getDwarfAbbrevDWOSection() const
LexicalScope * findAbstractScope(const DILocalScope *N)
findAbstractScope - Find an abstract scope or return null.
void EmitInt32(int Value) const
Emit a long directive and value.
static void forBothCUs(DwarfCompileUnit &CU, Func F)
Definition: DwarfDebug.cpp:368
MCSection * getDwarfGnuPubTypesSection() const
DebuggerKind DebuggerTuning
Which debugger to tune for.
const MCSymbol * Start
This dwarf writer support class manages information associated with a source file.
Definition: DwarfUnit.h:68
#define P(N)
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:406
StringRef GDBIndexEntryKindString(GDBIndexEntryKind Kind)
Definition: Dwarf.cpp:506
void endModule() override
Emit all Dwarf sections that should come after the content.
Definition: DwarfDebug.cpp:715
DwarfCompileUnit * CU
Definition: DwarfDebug.h:215
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
bool tuneForLLDB() const
Definition: DwarfDebug.h:566
static bool fragmentsOverlap(const DIExpression *P1, const DIExpression *P2)
Determine whether two variable fragments overlap.
const MachineBasicBlock * PrevInstBB
LinkageNameOption
Definition: DwarfDebug.cpp:118
const MCAsmInfo * MAI
Target Asm Printer information.
Definition: AsmPrinter.h:84
static void getObjCClassCategory(StringRef In, StringRef &Class, StringRef &Category)
Definition: DwarfDebug.cpp:306
static cl::opt< LinkageNameOption > DwarfLinkageNames("dwarf-linkage-names", cl::Hidden, cl::desc("Which DWARF linkage-name attributes to emit."), cl::values(clEnumValN(DefaultLinkageNames, "Default", "Default for platform"), clEnumValN(AllLinkageNames, "All", "All"), clEnumValN(AbstractLinkageNames, "Abstract", "Abstract subprograms")), cl::init(DefaultLinkageNames))
MCSection * getDwarfAddrSection() const
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
DISubprogram * getSubprogram() const
Get the attached subprogram.
Definition: Metadata.cpp:1498
void emit(AsmPrinter &Asm, MCSection *AddrSection)
Definition: AddressPool.cpp:28
const DILocation * getInlinedAt() const
Definition: LexicalScopes.h:63
static DebugLocEntry::Value getDebugLocValue(const MachineInstr *MI)
Definition: DwarfDebug.cpp:828
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
ValuesClass values(OptsTy... Options)
Helper to build a ValuesClass by forwarding a variable number of arguments as an initializer list to ...
Definition: CommandLine.h:626
const DIExpression * getExpression() const
Definition: DebugLocEntry.h:76
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator begin()
Definition: SmallVector.h:116
This file contains the declarations for the subclasses of Constant, which represent the different fla...
A structured debug information entry.
Definition: DIE.h:662
AsmPrinter * Asm
Target of debug info emission.
DIE & getUnitDie()
Definition: DIE.h:834
ArrayRef< char > getBytes(const Entry &E) const
TargetMachine & TM
Target machine description.
Definition: AsmPrinter.h:80
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:76
bool isCImm() const
isCImm - Test if this is a MO_CImmediate operand.
void addDwarfTypeUnitType(DwarfCompileUnit &CU, StringRef Identifier, DIE &Die, const DICompositeType *CTy)
Add a DIE to the set of types that we&#39;re going to pull into type units.
bool any_of(R &&Range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:823
DIImportedEntityArray getImportedEntities() const
cl::opt< int > DwarfVersion("dwarf-version", cl::desc("Dwarf version"), cl::init(0))
MCSection * getDwarfLineDWOSection() const
bool isPS4CPU() const
Tests whether the target is the PS4 CPU.
Definition: Triple.h:600
void setCompilationDir(StringRef CompilationDir)
Definition: MCDwarf.h:222
static const unsigned End
void addAccelType(StringRef Name, const DIE &Die, char Flags)
static cl::opt< DefaultOnOff > UnknownLocations("use-unknown-locations", cl::Hidden, cl::desc("Make an absence of debug location information explicit."), cl::values(clEnumVal(Default, "At top of block or after label"), clEnumVal(Enable, "In all cases"), clEnumVal(Disable, "Never")), cl::init(Default))
DwarfDebug(AsmPrinter *A, Module *M)
Definition: DwarfDebug.cpp:231
void EmitLabelReference(const MCSymbol *Label, unsigned Size, bool IsSectionRelative=false) const
Emit something like ".long Label" where the size in bytes of the directive is specified by Size and L...
Definition: AsmPrinter.h:477
const Triple & getTargetTriple() const
void computeSizeAndOffsets()
Compute the size and offset of all the DIEs.
Definition: DwarfFile.cpp:49
ArrayRef< Entry > getEntries(const List &L) const
StringRef GDBIndexEntryLinkageString(GDBIndexEntryLinkage Linkage)
Definition: Dwarf.cpp:529
bool addScopeVariable(LexicalScope *LS, DbgVariable *Var)
Definition: DwarfFile.cpp:84
void beginInstruction(const MachineInstr *MI) override
Process beginning of an instruction.
GDBIndexEntryLinkage Linkage
Definition: Dwarf.h:466
MDNode * getScope() const
Definition: DebugLoc.cpp:36
A pair of GlobalVariable and DIExpression.
Helper used to pair up a symbol and its DWARF compile unit.
Definition: DwarfDebug.h:211
StringRef getDirectory() const
iterator erase(const_iterator CI)
Definition: SmallVector.h:449
unsigned getLine() const
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...
unsigned getDwarfVersion() const
Returns the Dwarf Version by checking module flags.
Definition: Module.cpp:453
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
StringRef OperationEncodingString(unsigned Encoding)
Definition: Dwarf.cpp:138
const DIExpression * getDebugExpression() const
Return the complex address expression referenced by this DBG_VALUE instruction.
static const char *const DWARFGroupDescription
Definition: DwarfDebug.cpp:135
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
ArrayRef< FrameIndexExpr > getFrameIndexExprs() const
Get the FI entries, sorted by fragment offset.
Definition: DwarfDebug.cpp:209
An imported module (C++ using directive or similar).
unsigned first
DIE * constructImportedEntityDIE(const DIImportedEntity *Module)
Construct import_module DIE.
const APFloat & getValueAPF() const
Definition: Constants.h:294
void addExpression(DIExpressionCursor &&Expr, unsigned FragmentOffsetInBits=0)
Emit all remaining operations in the DIExpressionCursor.
uint16_t getLanguage() const
Definition: DwarfUnit.h:112
bool tuneForGDB() const
Definition: DwarfDebug.h:565
SmallVector< RangeSpan, 2 > takeRanges()
void constructAbstractSubprogramScopeDIE(LexicalScope *Scope)
static DebugLoc findPrologueEndLoc(const MachineFunction *MF)
LexicalScope * findInlinedScope(const DILocalScope *N, const DILocation *IA)
findInlinedScope - Find an inlined scope for the given scope/inlined-at.
MCSymbol * getMacroLabelBegin() const
static bool hasObjCCategory(StringRef Name)
Definition: DwarfDebug.cpp:299
void beginInstruction(const MachineInstr *MI) override
Process beginning of an instruction.
const StringMap< const DIE * > & getGlobalNames() const
Base class for types.
void setDebugInfoAvailability(bool avail)
StringRef getName() const
unsigned getLine() const
DIFile * getFile() const
bool isDebugValue() const
Definition: MachineInstr.h:785
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:864
virtual void EmitSLEB128(uint64_t DWord, const Twine &Comment="")=0
Module.h This file contains the declarations for the Module class.
void beginModule()
Emit all Dwarf sections that should come prior to the content.
Definition: DwarfDebug.cpp:531
static ManagedStatic< CodeViewErrorCategory > Category
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE StringRef slice(size_t Start, size_t End) const
Return a reference to the substring from [Start, End).
Definition: StringRef.h:710
MCSymbol * getBeginSymbol()
Definition: MCSection.h:106
bool isMetadata() const
Definition: SectionKind.h:117
void finishSubprogramDefinition(const DISubprogram *SP)
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
MCSection * getDwarfInfoSection() const
bool useAppleExtensionAttributes() const
Definition: DwarfDebug.h:510
MCSection * getDwarfStrOffDWOSection() const
void addAccelName(StringRef Name, const DIE &Die)
MCSymbol * getFunctionEnd() const
Definition: AsmPrinter.h:198
int64_t getImm() const
void emitDebugLocEntry(ByteStreamer &Streamer, const DebugLocStream::Entry &Entry)
Emit an entry for the debug loc section.
DWARF expression.
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
unsigned getSourceLanguage() const
StringMap - This is an unconventional map that is specialized for handling keys that are "strings"...
Definition: StringMap.h:224
Class for arbitrary precision integers.
Definition: APInt.h:69
ArrayRef< std::string > getComments(const Entry &E) const
MCSection * getDwarfPubTypesSection() const
bool isBlockByrefStruct() const
DebugLoc PrologEndLoc
This location indicates end of function prologue and beginning of function body.
const SmallVectorImpl< RangeSpan > & getRanges() const
getRanges - Get the list of ranges for this unit.
dwarf::Tag getTag() const
Definition: DIE.h:698
constexpr char Size[]
Key for Kernel::Arg::Metadata::mSize.
#define clEnumValN(ENUMVAL, FLAGNAME, DESC)
Definition: CommandLine.h:601
A single location or constant.
Definition: DebugLocEntry.h:32
const MachineBasicBlock * getParent() const
Definition: MachineInstr.h:139
void finalize(const AsmPrinter &AP, DebugLocStream::ListBuilder &List, const DIBasicType *BT)
Lower this entry into a DWARF expression.
DIE * getOrCreateContextDIE(const DIScope *Context)
Get context owner&#39;s DIE.
Definition: DwarfUnit.cpp:667
unsigned getOrCreateSourceID(StringRef FileName, StringRef DirName) override
Look up the source ID with the given directory and source file names.
MCSection * getDwarfStrDWOSection() const
Representation of each machine instruction.
Definition: MachineInstr.h:59
static StringRef getObjCMethodName(StringRef In)
Definition: DwarfDebug.cpp:318
const MachineFunction * getParent() const
Return the MachineFunction containing this basic block.
bool getSplitDebugInlining() const
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator end()
Definition: SmallVector.h:120
void setSection(MCSection *Section)
Set the section that this DIEUnit will be emitted into.
Definition: DIE.h:815
unsigned getEncoding() const
static const size_t npos
Definition: StringRef.h:51
DIE * getOrCreateGlobalVariableDIE(const DIGlobalVariable *GV, ArrayRef< GlobalExpr > GlobalExprs)
Get or create global variable DIE.
LexicalScopes - This class provides interface to collect and use lexical scoping information from mac...
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:61
bool isBlockByrefVariable() const
Definition: DwarfDebug.cpp:159
TargetOptions Options
Definition: TargetMachine.h:96
void endFunctionImpl(const MachineFunction *MF) override
Gather and emit post-function debug information.
const NodeList & List
Definition: RDFGraph.cpp:210
#define I(x, y, z)
Definition: MD5.cpp:58
#define N
iterator_range< debug_compile_units_iterator > debug_compile_units() const
Return an iterator for all DICompileUnits listed in this Module&#39;s llvm.dbg.cu named metadata node and...
Definition: Module.h:755
bool shareAcrossDWOCUs() const
Definition: DwarfDebug.cpp:375
MCSection * getDwarfGnuPubNamesSection() const
Definition: MD5.h:41
void EmitLabelDifference(const MCSymbol *Hi, const MCSymbol *Lo, unsigned Size) const
Emit something like ".long Hi-Lo" where the size in bytes of the directive is specified by Size and H...
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
Base class for debug information backends.
static uint64_t makeTypeSignature(StringRef Identifier)
Perform an MD5 checksum of Identifier and return the lower 64 bits.
unsigned getMacinfoType() 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
StringRef getValue() const
DwarfCompileUnit * getSkeleton() const
void skippedNonDebugFunction() override
const Module * getModule() const
ValueT lookup(const_arg_type_t< KeyT > Val) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
Definition: DenseMap.h:181
bool isReg() const
isReg - Tests if this is a MO_Register operand.
void addDIETypeSignature(DIE &Die, uint64_t Signature)
Add a type&#39;s DW_AT_signature and set the declaration flag.
Definition: DwarfUnit.cpp:292
DIEValue findAttribute(dwarf::Attribute Attribute) const
Find a value in the DIE with the attribute given.
Definition: DIE.cpp:220
ArrayRef< LexicalScope * > getAbstractScopesList() const
getAbstractScopesList - Return a reference to list of abstract scopes.
unsigned getCol() const
Definition: DebugLoc.cpp:31
const Function * getFunction() const
getFunction - Return the LLVM function that this machine code represents
void addSubprogramNames(const DISubprogram *SP, DIE &Die)
Definition: DwarfDebug.cpp:326
std::vector< uint8_t > Unit
Definition: FuzzerDefs.h:105
const MCSymbol * End
unsigned getCodePointerSize() const
Get the code pointer size in bytes.
Definition: MCAsmInfo.h:382
void addFragmentOffset(const DIExpression *Expr)
If applicable, emit an empty DW_OP_piece / DW_OP_bit_piece to advance to the fragment described by Ex...
MCSymbol * getLabelBeforeInsn(const MachineInstr *MI)
Return Label preceding the instruction.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
MCSection * getDwarfAccelNamespaceSection() const
static const char *const DWARFGroupName
Definition: DwarfDebug.cpp:134
static int fragmentCmp(const DIExpression *P1, const DIExpression *P2)
Determine the relative position of the fragments described by P1 and P2.
void finishVariableDefinition(const DbgVariable &Var)
LLVM Value Representation.
Definition: Value.h:73
void EmitULEB128(uint64_t Value, const char *Desc=nullptr) const
Emit the specified unsigned leb128 value.
static void emitDebugLocValue(const AsmPrinter &AP, const DIBasicType *BT, ByteStreamer &Streamer, const DebugLocEntry::Value &Value, DwarfExpression &DwarfExpr)
uint64_t OffsetToAlignment(uint64_t Value, uint64_t Align)
Returns the offset to the next integer (mod 2**64) that is greater than or equal to Value and is a mu...
Definition: MathExtras.h:719
DbgVariable * getExistingAbstractVariable(InlinedVariable IV, const DILocalVariable *&Cleansed)
uint16_t getDwarfVersion() const
Returns the Dwarf Version.
static const DwarfAccelTable::Atom TypeAtoms[]
Definition: DwarfDebug.cpp:226
void emitAbbrevs(MCSection *)
Emit a set of abbreviations to the specific section.
Definition: DwarfFile.cpp:77
GDBIndexEntryLinkage
Definition: Dwarf.h:360
#define DEBUG(X)
Definition: Debug.h:118
void addSignedConstant(int64_t Value)
Emit a signed constant.
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:214
std::string Hash(const Unit &U)
Definition: FuzzerSHA1.cpp:216
MachineModuleInfo * MMI
Collected machine module information.
unsigned getOffset() const
Get the compile/type unit relative offset of this DIE.
Definition: DIE.h:700
void final(MD5Result &Result)
Finishes off the hash and puts the result in result.
Definition: MD5.cpp:234
DefaultOnOff
Definition: DwarfDebug.cpp:101
iterator_range< global_iterator > globals()
Definition: Module.h:561
IRTranslator LLVM IR MI
void addAccelObjC(StringRef Name, const DIE &Die)
MachineLocation getLoc() const
Definition: DebugLocEntry.h:74
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
APInt bitcastToAPInt() const
Definition: APFloat.h:1094
void emitUnits(bool UseOffsets)
Emit all of the units to the section listed with the given abbreviation section.
Definition: DwarfFile.cpp:33
MCSection * getDwarfRangesSection() const
void sort(Policy policy, RandomAccessIterator Start, RandomAccessIterator End, const Comparator &Comp=Comparator())
Definition: Parallel.h:199
bool tuneForSCE() const
Definition: DwarfDebug.h:567
bool TimePassesIsEnabled
If the user specifies the -time-passes argument on an LLVM tool command line then the value of this b...
Definition: IRReader.cpp:26
uint64_t high() const
Definition: MD5.h:72
static bool isObjCClass(StringRef Name)
Definition: DwarfDebug.cpp:295
void beginFunctionImpl(const MachineFunction *MF) override
Gather pre-function debug information.
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t find(char C, size_t From=0) const
Search for the first character C in the string.
Definition: StringRef.h:298
Builder for DebugLocStream entries.
for(unsigned i=Desc.getNumOperands(), e=OldMI.getNumOperands();i !=e;++i)
const MachineOperand & getOperand(unsigned i) const
Definition: MachineInstr.h:284
bool isFragment() const
Return whether this is a piece of an aggregate variable.
const ConstantInt * getCImm() const
MCSymbol * getLabelBegin() const
void addValues(ArrayRef< DebugLocEntry::Value > Vals)
Root of the metadata hierarchy.
Definition: Metadata.h:58
MCSymbol * createTempSymbol(const Twine &Name) const
bool addMachineRegExpression(const TargetRegisterInfo &TRI, DIExpressionCursor &Expr, unsigned MachineReg, unsigned FragmentOffsetInBits=0)
Emit a machine register location.
const ConstantFP * getConstantFP() const
Definition: DebugLocEntry.h:72
ArrayRef< List > getLists() const
bool empty()
empty - Return true if there is any lexical scope information available.
LexicalScope * getCurrentFunctionScope() const
getCurrentFunctionScope - Return lexical scope for the current function.
StringRef getName() const
Basic type, like &#39;int&#39; or &#39;float&#39;.
const MCSymbol * Sym
Definition: DwarfDebug.h:214
unsigned getIndex(const MCSymbol *Sym, bool TLS=false)
Returns the index into the address pool with the given label/symbol.
Definition: AddressPool.cpp:20