LLVM  7.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 "DwarfCompileUnit.h"
20 #include "DwarfExpression.h"
21 #include "DwarfFile.h"
22 #include "DwarfUnit.h"
23 #include "llvm/ADT/APInt.h"
24 #include "llvm/ADT/DenseMap.h"
25 #include "llvm/ADT/DenseSet.h"
26 #include "llvm/ADT/MapVector.h"
27 #include "llvm/ADT/STLExtras.h"
28 #include "llvm/ADT/SmallVector.h"
29 #include "llvm/ADT/StringRef.h"
30 #include "llvm/ADT/Triple.h"
31 #include "llvm/ADT/Twine.h"
35 #include "llvm/CodeGen/DIE.h"
44 #include "llvm/IR/Constants.h"
46 #include "llvm/IR/DebugLoc.h"
47 #include "llvm/IR/Function.h"
48 #include "llvm/IR/GlobalVariable.h"
49 #include "llvm/IR/Module.h"
50 #include "llvm/MC/MCAsmInfo.h"
51 #include "llvm/MC/MCContext.h"
52 #include "llvm/MC/MCDwarf.h"
53 #include "llvm/MC/MCSection.h"
54 #include "llvm/MC/MCStreamer.h"
55 #include "llvm/MC/MCSymbol.h"
58 #include "llvm/MC/SectionKind.h"
59 #include "llvm/Pass.h"
60 #include "llvm/Support/Casting.h"
62 #include "llvm/Support/Debug.h"
64 #include "llvm/Support/MD5.h"
66 #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 
97 static cl::opt<bool>
98  GenerateDwarfTypeUnits("generate-type-units", cl::Hidden,
99  cl::desc("Generate DWARF4 type units."),
100  cl::init(false));
101 
103  "split-dwarf-cross-cu-references", cl::Hidden,
104  cl::desc("Enable cross-cu references in DWO files"), cl::init(false));
105 
106 enum DefaultOnOff { Default, Enable, Disable };
107 
109  "use-unknown-locations", cl::Hidden,
110  cl::desc("Make an absence of debug location information explicit."),
111  cl::values(clEnumVal(Default, "At top of block or after label"),
112  clEnumVal(Enable, "In all cases"), clEnumVal(Disable, "Never")),
113  cl::init(Default));
114 
116  "accel-tables", cl::Hidden, cl::desc("Output dwarf accelerator tables."),
118  "Default for platform"),
119  clEnumValN(AccelTableKind::None, "Disable", "Disabled."),
120  clEnumValN(AccelTableKind::Apple, "Apple", "Apple"),
121  clEnumValN(AccelTableKind::Dwarf, "Dwarf", "DWARF")),
123 
125 DwarfInlinedStrings("dwarf-inlined-strings", cl::Hidden,
126  cl::desc("Use inlined strings rather than string section."),
127  cl::values(clEnumVal(Default, "Default for platform"),
128  clEnumVal(Enable, "Enabled"),
129  clEnumVal(Disable, "Disabled")),
130  cl::init(Default));
131 
132 static cl::opt<bool>
133  NoDwarfPubSections("no-dwarf-pub-sections", cl::Hidden,
134  cl::desc("Disable emission of DWARF pub sections."),
135  cl::init(false));
136 
137 static cl::opt<bool>
138  NoDwarfRangesSection("no-dwarf-ranges-section", cl::Hidden,
139  cl::desc("Disable emission .debug_ranges section."),
140  cl::init(false));
141 
143  "dwarf-sections-as-references", cl::Hidden,
144  cl::desc("Use sections+offset as references rather than labels."),
145  cl::values(clEnumVal(Default, "Default for platform"),
146  clEnumVal(Enable, "Enabled"), clEnumVal(Disable, "Disabled")),
147  cl::init(Default));
148 
153 };
154 
156  DwarfLinkageNames("dwarf-linkage-names", cl::Hidden,
157  cl::desc("Which DWARF linkage-name attributes to emit."),
159  "Default for platform"),
160  clEnumValN(AllLinkageNames, "All", "All"),
161  clEnumValN(AbstractLinkageNames, "Abstract",
162  "Abstract subprograms")),
164 
165 static const char *const DWARFGroupName = "dwarf";
166 static const char *const DWARFGroupDescription = "DWARF Emission";
167 static const char *const DbgTimerName = "writer";
168 static const char *const DbgTimerDescription = "DWARF Debug Writer";
169 
170 void DebugLocDwarfExpression::emitOp(uint8_t Op, const char *Comment) {
171  BS.EmitInt8(
172  Op, Comment ? Twine(Comment) + " " + dwarf::OperationEncodingString(Op)
174 }
175 
176 void DebugLocDwarfExpression::emitSigned(int64_t Value) {
177  BS.EmitSLEB128(Value, Twine(Value));
178 }
179 
180 void DebugLocDwarfExpression::emitUnsigned(uint64_t Value) {
181  BS.EmitULEB128(Value, Twine(Value));
182 }
183 
184 bool DebugLocDwarfExpression::isFrameRegister(const TargetRegisterInfo &TRI,
185  unsigned MachineReg) {
186  // This information is not available while emitting .debug_loc entries.
187  return false;
188 }
189 
191  assert(Var && "Invalid complex DbgVariable!");
192  return Var->getType().resolve()->isBlockByrefStruct();
193 }
194 
195 const DIType *DbgVariable::getType() const {
196  DIType *Ty = Var->getType().resolve();
197  // FIXME: isBlockByrefVariable should be reformulated in terms of complex
198  // addresses instead.
199  if (Ty->isBlockByrefStruct()) {
200  /* Byref variables, in Blocks, are declared by the programmer as
201  "SomeType VarName;", but the compiler creates a
202  __Block_byref_x_VarName struct, and gives the variable VarName
203  either the struct, or a pointer to the struct, as its type. This
204  is necessary for various behind-the-scenes things the compiler
205  needs to do with by-reference variables in blocks.
206 
207  However, as far as the original *programmer* is concerned, the
208  variable should still have type 'SomeType', as originally declared.
209 
210  The following function dives into the __Block_byref_x_VarName
211  struct to find the original type of the variable. This will be
212  passed back to the code generating the type for the Debug
213  Information Entry for the variable 'VarName'. 'VarName' will then
214  have the original type 'SomeType' in its debug information.
215 
216  The original type 'SomeType' will be the type of the field named
217  'VarName' inside the __Block_byref_x_VarName struct.
218 
219  NOTE: In order for this to not completely fail on the debugger
220  side, the Debug Information Entry for the variable VarName needs to
221  have a DW_AT_location that tells the debugger how to unwind through
222  the pointers and __Block_byref_x_VarName struct to find the actual
223  value of the variable. The function addBlockByrefType does this. */
224  DIType *subType = Ty;
225  uint16_t tag = Ty->getTag();
226 
227  if (tag == dwarf::DW_TAG_pointer_type)
228  subType = resolve(cast<DIDerivedType>(Ty)->getBaseType());
229 
230  auto Elements = cast<DICompositeType>(subType)->getElements();
231  for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
232  auto *DT = cast<DIDerivedType>(Elements[i]);
233  if (getName() == DT->getName())
234  return resolve(DT->getBaseType());
235  }
236  }
237  return Ty;
238 }
239 
241  if (FrameIndexExprs.size() == 1)
242  return FrameIndexExprs;
243 
244  assert(llvm::all_of(FrameIndexExprs,
245  [](const FrameIndexExpr &A) {
246  return A.Expr->isFragment();
247  }) &&
248  "multiple FI expressions without DW_OP_LLVM_fragment");
249  llvm::sort(FrameIndexExprs.begin(), FrameIndexExprs.end(),
250  [](const FrameIndexExpr &A, const FrameIndexExpr &B) -> bool {
251  return A.Expr->getFragmentInfo()->OffsetInBits <
252  B.Expr->getFragmentInfo()->OffsetInBits;
253  });
254 
255  return FrameIndexExprs;
256 }
257 
259  assert(DebugLocListIndex == ~0U && !MInsn && "not an MMI entry");
260  assert(V.DebugLocListIndex == ~0U && !V.MInsn && "not an MMI entry");
261  assert(V.Var == Var && "conflicting variable");
262  assert(V.IA == IA && "conflicting inlined-at location");
263 
264  assert(!FrameIndexExprs.empty() && "Expected an MMI entry");
265  assert(!V.FrameIndexExprs.empty() && "Expected an MMI entry");
266 
267  // FIXME: This logic should not be necessary anymore, as we now have proper
268  // deduplication. However, without it, we currently run into the assertion
269  // below, which means that we are likely dealing with broken input, i.e. two
270  // non-fragment entries for the same variable at different frame indices.
271  if (FrameIndexExprs.size()) {
272  auto *Expr = FrameIndexExprs.back().Expr;
273  if (!Expr || !Expr->isFragment())
274  return;
275  }
276 
277  for (const auto &FIE : V.FrameIndexExprs)
278  // Ignore duplicate entries.
279  if (llvm::none_of(FrameIndexExprs, [&](const FrameIndexExpr &Other) {
280  return FIE.FI == Other.FI && FIE.Expr == Other.Expr;
281  }))
282  FrameIndexExprs.push_back(FIE);
283 
284  assert((FrameIndexExprs.size() == 1 ||
285  llvm::all_of(FrameIndexExprs,
286  [](FrameIndexExpr &FIE) {
287  return FIE.Expr && FIE.Expr->isFragment();
288  })) &&
289  "conflicting locations for variable");
290 }
291 
293  bool GenerateTypeUnits,
294  DebuggerKind Tuning,
295  const Triple &TT) {
296  // Honor an explicit request.
297  if (AccelTables != AccelTableKind::Default)
298  return AccelTables;
299 
300  // Accelerator tables with type units are currently not supported.
301  if (GenerateTypeUnits)
302  return AccelTableKind::None;
303 
304  // Accelerator tables get emitted if targetting DWARF v5 or LLDB. DWARF v5
305  // always implies debug_names. For lower standard versions we use apple
306  // accelerator tables on apple platforms and debug_names elsewhere.
307  if (DwarfVersion >= 5)
308  return AccelTableKind::Dwarf;
309  if (Tuning == DebuggerKind::LLDB)
312  return AccelTableKind::None;
313 }
314 
316  : DebugHandlerBase(A), DebugLocs(A->OutStreamer->isVerboseAsm()),
317  InfoHolder(A, "info_string", DIEValueAllocator),
318  SkeletonHolder(A, "skel_string", DIEValueAllocator),
319  IsDarwin(A->TM.getTargetTriple().isOSDarwin()) {
320  const Triple &TT = Asm->TM.getTargetTriple();
321 
322  // Make sure we know our "debugger tuning." The target option takes
323  // precedence; fall back to triple-based defaults.
325  DebuggerTuning = Asm->TM.Options.DebuggerTuning;
326  else if (IsDarwin)
327  DebuggerTuning = DebuggerKind::LLDB;
328  else if (TT.isPS4CPU())
329  DebuggerTuning = DebuggerKind::SCE;
330  else
331  DebuggerTuning = DebuggerKind::GDB;
332 
333  if (DwarfInlinedStrings == Default)
334  UseInlineStrings = TT.isNVPTX();
335  else
336  UseInlineStrings = DwarfInlinedStrings == Enable;
337 
338  UseLocSection = !TT.isNVPTX();
339 
340  HasAppleExtensionAttributes = tuneForLLDB();
341 
342  // Handle split DWARF.
343  HasSplitDwarf = !Asm->TM.Options.MCOptions.SplitDwarfFile.empty();
344 
345  // SCE defaults to linkage names only for abstract subprograms.
347  UseAllLinkageNames = !tuneForSCE();
348  else
349  UseAllLinkageNames = DwarfLinkageNames == AllLinkageNames;
350 
351  unsigned DwarfVersionNumber = Asm->TM.Options.MCOptions.DwarfVersion;
352  unsigned DwarfVersion = DwarfVersionNumber ? DwarfVersionNumber
353  : MMI->getModule()->getDwarfVersion();
354  // Use dwarf 4 by default if nothing is requested. For NVPTX, use dwarf 2.
355  DwarfVersion =
356  TT.isNVPTX() ? 2 : (DwarfVersion ? DwarfVersion : dwarf::DWARF_VERSION);
357 
358  UsePubSections = !NoDwarfPubSections && !TT.isNVPTX();
359  UseRangesSection = !NoDwarfRangesSection && !TT.isNVPTX();
360 
361  // Use sections as references. Force for NVPTX.
362  if (DwarfSectionsAsReferences == Default)
363  UseSectionsAsReferences = TT.isNVPTX();
364  else
365  UseSectionsAsReferences = DwarfSectionsAsReferences == Enable;
366 
367  GenerateTypeUnits = GenerateDwarfTypeUnits;
368 
369  TheAccelTableKind = computeAccelTableKind(
370  DwarfVersion, GenerateTypeUnits, DebuggerTuning, A->TM.getTargetTriple());
371 
372  // Work around a GDB bug. GDB doesn't support the standard opcode;
373  // SCE doesn't support GNU's; LLDB prefers the standard opcode, which
374  // is defined as of DWARF 3.
375  // See GDB bug 11616 - DW_OP_form_tls_address is unimplemented
376  // https://sourceware.org/bugzilla/show_bug.cgi?id=11616
377  UseGNUTLSOpcode = tuneForGDB() || DwarfVersion < 3;
378 
379  // GDB does not fully support the DWARF 4 representation for bitfields.
380  UseDWARF2Bitfields = (DwarfVersion < 4) || tuneForGDB();
381 
382  // The DWARF v5 string offsets table has - possibly shared - contributions
383  // from each compile and type unit each preceded by a header. The string
384  // offsets table used by the pre-DWARF v5 split-DWARF implementation uses
385  // a monolithic string offsets table without any header.
386  UseSegmentedStringOffsetsTable = DwarfVersion >= 5;
387 
388  Asm->OutStreamer->getContext().setDwarfVersion(DwarfVersion);
389 }
390 
391 // Define out of line so we don't have to include DwarfUnit.h in DwarfDebug.h.
392 DwarfDebug::~DwarfDebug() = default;
393 
394 static bool isObjCClass(StringRef Name) {
395  return Name.startswith("+") || Name.startswith("-");
396 }
397 
399  if (!isObjCClass(Name))
400  return false;
401 
402  return Name.find(") ") != StringRef::npos;
403 }
404 
406  StringRef &Category) {
407  if (!hasObjCCategory(In)) {
408  Class = In.slice(In.find('[') + 1, In.find(' '));
409  Category = "";
410  return;
411  }
412 
413  Class = In.slice(In.find('[') + 1, In.find('('));
414  Category = In.slice(In.find('[') + 1, In.find(' '));
415 }
416 
418  return In.slice(In.find(' ') + 1, In.find(']'));
419 }
420 
421 // Add the various names to the Dwarf accelerator table names.
423  if (!SP->isDefinition())
424  return;
425 
426  if (SP->getName() != "")
427  addAccelName(SP->getName(), Die);
428 
429  // If the linkage name is different than the name, go ahead and output that as
430  // well into the name table. Only do that if we are going to actually emit
431  // that name.
432  if (SP->getLinkageName() != "" && SP->getName() != SP->getLinkageName() &&
433  (useAllLinkageNames() || InfoHolder.getAbstractSPDies().lookup(SP)))
434  addAccelName(SP->getLinkageName(), Die);
435 
436  // If this is an Objective-C selector name add it to the ObjC accelerator
437  // too.
438  if (isObjCClass(SP->getName())) {
439  StringRef Class, Category;
440  getObjCClassCategory(SP->getName(), Class, Category);
441  addAccelObjC(Class, Die);
442  if (Category != "")
443  addAccelObjC(Category, Die);
444  // Also add the base method name to the name table.
446  }
447 }
448 
449 /// Check whether we should create a DIE for the given Scope, return true
450 /// if we don't create a DIE (the corresponding DIE is null).
452  if (Scope->isAbstractScope())
453  return false;
454 
455  // We don't create a DIE if there is no Range.
456  const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
457  if (Ranges.empty())
458  return true;
459 
460  if (Ranges.size() > 1)
461  return false;
462 
463  // We don't create a DIE if we have a single Range and the end label
464  // is null.
465  return !getLabelAfterInsn(Ranges.front().second);
466 }
467 
468 template <typename Func> static void forBothCUs(DwarfCompileUnit &CU, Func F) {
469  F(CU);
470  if (auto *SkelCU = CU.getSkeleton())
471  if (CU.getCUNode()->getSplitDebugInlining())
472  F(*SkelCU);
473 }
474 
477 }
478 
479 void DwarfDebug::constructAbstractSubprogramScopeDIE(DwarfCompileUnit &SrcCU,
480  LexicalScope *Scope) {
481  assert(Scope && Scope->getScopeNode());
482  assert(Scope->isAbstractScope());
483  assert(!Scope->getInlinedAt());
484 
485  auto *SP = cast<DISubprogram>(Scope->getScopeNode());
486 
487  // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
488  // was inlined from another compile unit.
489  if (useSplitDwarf() && !shareAcrossDWOCUs() && !SP->getUnit()->getSplitDebugInlining())
490  // Avoid building the original CU if it won't be used
492  else {
493  auto &CU = getOrCreateDwarfCompileUnit(SP->getUnit());
494  if (auto *SkelCU = CU.getSkeleton()) {
495  (shareAcrossDWOCUs() ? CU : SrcCU)
496  .constructAbstractSubprogramScopeDIE(Scope);
497  if (CU.getCUNode()->getSplitDebugInlining())
498  SkelCU->constructAbstractSubprogramScopeDIE(Scope);
499  } else
500  CU.constructAbstractSubprogramScopeDIE(Scope);
501  }
502 }
503 
504 void DwarfDebug::addGnuPubAttributes(DwarfCompileUnit &U, DIE &D) const {
505  if (!U.hasDwarfPubSections())
506  return;
507 
508  U.addFlag(D, dwarf::DW_AT_GNU_pubnames);
509 }
510 
511 // Create new DwarfCompileUnit for the given metadata node with tag
512 // DW_TAG_compile_unit.
514 DwarfDebug::getOrCreateDwarfCompileUnit(const DICompileUnit *DIUnit) {
515  if (auto *CU = CUMap.lookup(DIUnit))
516  return *CU;
517  StringRef FN = DIUnit->getFilename();
518  CompilationDir = DIUnit->getDirectory();
519 
520  auto OwnedUnit = llvm::make_unique<DwarfCompileUnit>(
521  InfoHolder.getUnits().size(), DIUnit, Asm, this, &InfoHolder);
522  DwarfCompileUnit &NewCU = *OwnedUnit;
523  DIE &Die = NewCU.getUnitDie();
524  InfoHolder.addUnit(std::move(OwnedUnit));
525  if (useSplitDwarf()) {
526  NewCU.setSkeleton(constructSkeletonCU(NewCU));
527  NewCU.addString(Die, dwarf::DW_AT_GNU_dwo_name,
528  Asm->TM.Options.MCOptions.SplitDwarfFile);
529  }
530 
531  for (auto *IE : DIUnit->getImportedEntities())
532  NewCU.addImportedEntity(IE);
533 
534  // LTO with assembly output shares a single line table amongst multiple CUs.
535  // To avoid the compilation directory being ambiguous, let the line table
536  // explicitly describe the directory of all files, never relying on the
537  // compilation directory.
538  if (!Asm->OutStreamer->hasRawTextSupport() || SingleCU)
539  Asm->OutStreamer->emitDwarfFile0Directive(
540  CompilationDir, FN, NewCU.getMD5AsBytes(DIUnit->getFile()),
541  DIUnit->getSource(), NewCU.getUniqueID());
542 
543  StringRef Producer = DIUnit->getProducer();
544  StringRef Flags = DIUnit->getFlags();
545  if (!Flags.empty()) {
546  std::string ProducerWithFlags = Producer.str() + " " + Flags.str();
547  NewCU.addString(Die, dwarf::DW_AT_producer, ProducerWithFlags);
548  } else
549  NewCU.addString(Die, dwarf::DW_AT_producer, Producer);
550 
551  NewCU.addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
552  DIUnit->getSourceLanguage());
553  NewCU.addString(Die, dwarf::DW_AT_name, FN);
554 
555  // Add DW_str_offsets_base to the unit DIE, except for split units.
557  NewCU.addStringOffsetsStart();
558 
559  if (!useSplitDwarf()) {
560  NewCU.initStmtList();
561 
562  // If we're using split dwarf the compilation dir is going to be in the
563  // skeleton CU and so we don't need to duplicate it here.
564  if (!CompilationDir.empty())
565  NewCU.addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
566 
567  addGnuPubAttributes(NewCU, Die);
568  }
569 
571  if (DIUnit->isOptimized())
572  NewCU.addFlag(Die, dwarf::DW_AT_APPLE_optimized);
573 
574  StringRef Flags = DIUnit->getFlags();
575  if (!Flags.empty())
576  NewCU.addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
577 
578  if (unsigned RVer = DIUnit->getRuntimeVersion())
579  NewCU.addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
580  dwarf::DW_FORM_data1, RVer);
581  }
582 
583  if (useSplitDwarf())
584  NewCU.setSection(Asm->getObjFileLowering().getDwarfInfoDWOSection());
585  else
586  NewCU.setSection(Asm->getObjFileLowering().getDwarfInfoSection());
587 
588  if (DIUnit->getDWOId()) {
589  // This CU is either a clang module DWO or a skeleton CU.
590  NewCU.addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8,
591  DIUnit->getDWOId());
592  if (!DIUnit->getSplitDebugFilename().empty())
593  // This is a prefabricated skeleton CU.
594  NewCU.addString(Die, dwarf::DW_AT_GNU_dwo_name,
595  DIUnit->getSplitDebugFilename());
596  }
597 
598  CUMap.insert({DIUnit, &NewCU});
599  CUDieMap.insert({&Die, &NewCU});
600  return NewCU;
601 }
602 
603 void DwarfDebug::constructAndAddImportedEntityDIE(DwarfCompileUnit &TheCU,
604  const DIImportedEntity *N) {
605  if (isa<DILocalScope>(N->getScope()))
606  return;
607  if (DIE *D = TheCU.getOrCreateContextDIE(N->getScope()))
609 }
610 
611 /// Sort and unique GVEs by comparing their fragment offset.
614  llvm::sort(GVEs.begin(), GVEs.end(),
617  // Sort order: first null exprs, then exprs without fragment
618  // info, then sort by fragment offset in bits.
619  // FIXME: Come up with a more comprehensive comparator so
620  // the sorting isn't non-deterministic, and so the following
621  // std::unique call works correctly.
622  if (!A.Expr || !B.Expr)
623  return !!B.Expr;
624  auto FragmentA = A.Expr->getFragmentInfo();
625  auto FragmentB = B.Expr->getFragmentInfo();
626  if (!FragmentA || !FragmentB)
627  return !!FragmentB;
628  return FragmentA->OffsetInBits < FragmentB->OffsetInBits;
629  });
630  GVEs.erase(std::unique(GVEs.begin(), GVEs.end(),
633  return A.Expr == B.Expr;
634  }),
635  GVEs.end());
636  return GVEs;
637 }
638 
639 // Emit all Dwarf sections that should come prior to the content. Create
640 // global DIEs and emit initial debug info sections. This is invoked by
641 // the target AsmPrinter.
643  NamedRegionTimer T(DbgTimerName, DbgTimerDescription, DWARFGroupName,
644  DWARFGroupDescription, TimePassesIsEnabled);
646  return;
647 
648  const Module *M = MMI->getModule();
649 
650  unsigned NumDebugCUs = std::distance(M->debug_compile_units_begin(),
652  // Tell MMI whether we have debug info.
653  MMI->setDebugInfoAvailability(NumDebugCUs > 0);
654  SingleCU = NumDebugCUs == 1;
656  GVMap;
657  for (const GlobalVariable &Global : M->globals()) {
659  Global.getDebugInfo(GVs);
660  for (auto *GVE : GVs)
661  GVMap[GVE->getVariable()].push_back({&Global, GVE->getExpression()});
662  }
663 
664  // Create the symbol that designates the start of the unit's contribution
665  // to the string offsets table. In a split DWARF scenario, only the skeleton
666  // unit has the DW_AT_str_offsets_base attribute (and hence needs the symbol).
668  (useSplitDwarf() ? SkeletonHolder : InfoHolder)
669  .setStringOffsetsStartSym(Asm->createTempSymbol("str_offsets_base"));
670 
671  // Create the symbol that designates the start of the DWARF v5 range list
672  // table. It is located past the header and before the offsets table.
673  if (getDwarfVersion() >= 5)
674  (useSplitDwarf() ? SkeletonHolder : InfoHolder)
675  .setRnglistsTableBaseSym(Asm->createTempSymbol("rnglists_table_base"));
676 
677  for (DICompileUnit *CUNode : M->debug_compile_units()) {
678  // FIXME: Move local imported entities into a list attached to the
679  // subprogram, then this search won't be needed and a
680  // getImportedEntities().empty() test should go below with the rest.
681  bool HasNonLocalImportedEntities = llvm::any_of(
682  CUNode->getImportedEntities(), [](const DIImportedEntity *IE) {
683  return !isa<DILocalScope>(IE->getScope());
684  });
685 
686  if (!HasNonLocalImportedEntities && CUNode->getEnumTypes().empty() &&
687  CUNode->getRetainedTypes().empty() &&
688  CUNode->getGlobalVariables().empty() && CUNode->getMacros().empty())
689  continue;
690 
691  DwarfCompileUnit &CU = getOrCreateDwarfCompileUnit(CUNode);
692 
693  // Global Variables.
694  for (auto *GVE : CUNode->getGlobalVariables()) {
695  // Don't bother adding DIGlobalVariableExpressions listed in the CU if we
696  // already know about the variable and it isn't adding a constant
697  // expression.
698  auto &GVMapEntry = GVMap[GVE->getVariable()];
699  auto *Expr = GVE->getExpression();
700  if (!GVMapEntry.size() || (Expr && Expr->isConstant()))
701  GVMapEntry.push_back({nullptr, Expr});
702  }
704  for (auto *GVE : CUNode->getGlobalVariables()) {
705  DIGlobalVariable *GV = GVE->getVariable();
706  if (Processed.insert(GV).second)
708  }
709 
710  for (auto *Ty : CUNode->getEnumTypes()) {
711  // The enum types array by design contains pointers to
712  // MDNodes rather than DIRefs. Unique them here.
713  CU.getOrCreateTypeDIE(cast<DIType>(Ty));
714  }
715  for (auto *Ty : CUNode->getRetainedTypes()) {
716  // The retained types array by design contains pointers to
717  // MDNodes rather than DIRefs. Unique them here.
718  if (DIType *RT = dyn_cast<DIType>(Ty))
719  // There is no point in force-emitting a forward declaration.
720  CU.getOrCreateTypeDIE(RT);
721  }
722  // Emit imported_modules last so that the relevant context is already
723  // available.
724  for (auto *IE : CUNode->getImportedEntities())
725  constructAndAddImportedEntityDIE(CU, IE);
726  }
727 }
728 
729 void DwarfDebug::finishVariableDefinitions() {
730  for (const auto &Var : ConcreteVariables) {
731  DIE *VariableDie = Var->getDIE();
732  assert(VariableDie);
733  // FIXME: Consider the time-space tradeoff of just storing the unit pointer
734  // in the ConcreteVariables list, rather than looking it up again here.
735  // DIE::getUnit isn't simple - it walks parent pointers, etc.
736  DwarfCompileUnit *Unit = CUDieMap.lookup(VariableDie->getUnitDie());
737  assert(Unit);
738  Unit->finishVariableDefinition(*Var);
739  }
740 }
741 
742 void DwarfDebug::finishSubprogramDefinitions() {
743  for (const DISubprogram *SP : ProcessedSPNodes) {
744  assert(SP->getUnit()->getEmissionKind() != DICompileUnit::NoDebug);
745  forBothCUs(
746  getOrCreateDwarfCompileUnit(SP->getUnit()),
748  }
749 }
750 
751 void DwarfDebug::finalizeModuleInfo() {
753 
754  finishSubprogramDefinitions();
755 
756  finishVariableDefinitions();
757 
758  // Include the DWO file name in the hash if there's more than one CU.
759  // This handles ThinLTO's situation where imported CUs may very easily be
760  // duplicate with the same CU partially imported into another ThinLTO unit.
761  StringRef DWOName;
762  if (CUMap.size() > 1)
764 
765  // Handle anything that needs to be done on a per-unit basis after
766  // all other generation.
767  for (const auto &P : CUMap) {
768  auto &TheCU = *P.second;
769  // Emit DW_AT_containing_type attribute to connect types with their
770  // vtable holding type.
772 
773  // Add CU specific attributes if we need to add any.
774  // If we're splitting the dwarf out now that we've got the entire
775  // CU then add the dwo id to it.
776  auto *SkCU = TheCU.getSkeleton();
777  if (useSplitDwarf()) {
778  // Emit a unique identifier for this CU.
779  uint64_t ID =
780  DIEHash(Asm).computeCUSignature(DWOName, TheCU.getUnitDie());
781  if (getDwarfVersion() >= 5) {
782  TheCU.setDWOId(ID);
783  SkCU->setDWOId(ID);
784  } else {
785  TheCU.addUInt(TheCU.getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
786  dwarf::DW_FORM_data8, ID);
787  SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
788  dwarf::DW_FORM_data8, ID);
789  }
790  // We don't keep track of which addresses are used in which CU so this
791  // is a bit pessimistic under LTO.
792  if (!AddrPool.isEmpty()) {
793  const MCSymbol *Sym = TLOF.getDwarfAddrSection()->getBeginSymbol();
794  SkCU->addSectionLabel(SkCU->getUnitDie(), dwarf::DW_AT_GNU_addr_base,
795  Sym, Sym);
796  }
797  if (getDwarfVersion() < 5 && !SkCU->getRangeLists().empty()) {
798  const MCSymbol *Sym = TLOF.getDwarfRangesSection()->getBeginSymbol();
799  SkCU->addSectionLabel(SkCU->getUnitDie(), dwarf::DW_AT_GNU_ranges_base,
800  Sym, Sym);
801  }
802  }
803 
804  // If we have code split among multiple sections or non-contiguous
805  // ranges of code then emit a DW_AT_ranges attribute on the unit that will
806  // remain in the .o file, otherwise add a DW_AT_low_pc.
807  // FIXME: We should use ranges allow reordering of code ala
808  // .subsections_via_symbols in mach-o. This would mean turning on
809  // ranges for all subprogram DIEs for mach-o.
810  DwarfCompileUnit &U = SkCU ? *SkCU : TheCU;
811  if (unsigned NumRanges = TheCU.getRanges().size()) {
812  if (NumRanges > 1 && useRangesSection())
813  // A DW_AT_low_pc attribute may also be specified in combination with
814  // DW_AT_ranges to specify the default base address for use in
815  // location lists (see Section 2.6.2) and range lists (see Section
816  // 2.17.3).
817  U.addUInt(U.getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
818  else
819  U.setBaseAddress(TheCU.getRanges().front().getStart());
821  }
822 
823  auto *CUNode = cast<DICompileUnit>(P.first);
824  // If compile Unit has macros, emit "DW_AT_macro_info" attribute.
825  if (CUNode->getMacros())
826  U.addSectionLabel(U.getUnitDie(), dwarf::DW_AT_macro_info,
827  U.getMacroLabelBegin(),
829  }
830 
831  // Emit all frontend-produced Skeleton CUs, i.e., Clang modules.
832  for (auto *CUNode : MMI->getModule()->debug_compile_units())
833  if (CUNode->getDWOId())
834  getOrCreateDwarfCompileUnit(CUNode);
835 
836  // Compute DIE offsets and sizes.
837  InfoHolder.computeSizeAndOffsets();
838  if (useSplitDwarf())
839  SkeletonHolder.computeSizeAndOffsets();
840 }
841 
842 // Emit all Dwarf sections that should come after the content.
844  assert(CurFn == nullptr);
845  assert(CurMI == nullptr);
846 
847  // If we aren't actually generating debug info (check beginModule -
848  // conditionalized on !DisableDebugInfoPrinting and the presence of the
849  // llvm.dbg.cu metadata node)
850  if (!MMI->hasDebugInfo())
851  return;
852 
853  // Finalize the debug info for the module.
854  finalizeModuleInfo();
855 
856  emitDebugStr();
857 
858  if (useSplitDwarf())
859  emitDebugLocDWO();
860  else
861  // Emit info into a debug loc section.
862  emitDebugLoc();
863 
864  // Corresponding abbreviations into a abbrev section.
865  emitAbbreviations();
866 
867  // Emit all the DIEs into a debug info section.
868  emitDebugInfo();
869 
870  // Emit info into a debug aranges section.
872  emitDebugARanges();
873 
874  // Emit info into a debug ranges section.
875  emitDebugRanges();
876 
877  // Emit info into a debug macinfo section.
878  emitDebugMacinfo();
879 
880  if (useSplitDwarf()) {
881  emitDebugStrDWO();
882  emitDebugInfoDWO();
883  emitDebugAbbrevDWO();
884  emitDebugLineDWO();
885  // Emit DWO addresses.
887  }
888 
889  // Emit info into the dwarf accelerator table sections.
890  switch (getAccelTableKind()) {
892  emitAccelNames();
893  emitAccelObjC();
894  emitAccelNamespaces();
895  emitAccelTypes();
896  break;
898  emitAccelDebugNames();
899  break;
901  break;
903  llvm_unreachable("Default should have already been resolved.");
904  }
905 
906  // Emit the pubnames and pubtypes sections if requested.
907  emitDebugPubSections();
908 
909  // clean up.
910  // FIXME: AbstractVariables.clear();
911 }
912 
913 void DwarfDebug::ensureAbstractVariableIsCreated(DwarfCompileUnit &CU, InlinedVariable IV,
914  const MDNode *ScopeNode) {
915  const DILocalVariable *Cleansed = nullptr;
916  if (CU.getExistingAbstractVariable(IV, Cleansed))
917  return;
918 
920  cast<DILocalScope>(ScopeNode)));
921 }
922 
923 void DwarfDebug::ensureAbstractVariableIsCreatedIfScoped(DwarfCompileUnit &CU,
924  InlinedVariable IV, const MDNode *ScopeNode) {
925  const DILocalVariable *Cleansed = nullptr;
926  if (CU.getExistingAbstractVariable(IV, Cleansed))
927  return;
928 
929  if (LexicalScope *Scope =
930  LScopes.findAbstractScope(cast_or_null<DILocalScope>(ScopeNode)))
931  CU.createAbstractVariable(Cleansed, Scope);
932 }
933 
934 // Collect variable information from side table maintained by MF.
935 void DwarfDebug::collectVariableInfoFromMFTable(
936  DwarfCompileUnit &TheCU, DenseSet<InlinedVariable> &Processed) {
938  for (const auto &VI : Asm->MF->getVariableDbgInfo()) {
939  if (!VI.Var)
940  continue;
941  assert(VI.Var->isValidLocationForIntrinsic(VI.Loc) &&
942  "Expected inlined-at fields to agree");
943 
944  InlinedVariable Var(VI.Var, VI.Loc->getInlinedAt());
945  Processed.insert(Var);
946  LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
947 
948  // If variable scope is not found then skip this variable.
949  if (!Scope)
950  continue;
951 
952  ensureAbstractVariableIsCreatedIfScoped(TheCU, Var, Scope->getScopeNode());
953  auto RegVar = llvm::make_unique<DbgVariable>(Var.first, Var.second);
954  RegVar->initializeMMI(VI.Expr, VI.Slot);
955  if (DbgVariable *DbgVar = MFVars.lookup(Var))
956  DbgVar->addMMIEntry(*RegVar);
957  else if (InfoHolder.addScopeVariable(Scope, RegVar.get())) {
958  MFVars.insert({Var, RegVar.get()});
959  ConcreteVariables.push_back(std::move(RegVar));
960  }
961  }
962 }
963 
964 // Get .debug_loc entry for the instruction range starting at MI.
966  const DIExpression *Expr = MI->getDebugExpression();
967  assert(MI->getNumOperands() == 4);
968  if (MI->getOperand(0).isReg()) {
969  auto RegOp = MI->getOperand(0);
970  auto Op1 = MI->getOperand(1);
971  // If the second operand is an immediate, this is a
972  // register-indirect address.
973  assert((!Op1.isImm() || (Op1.getImm() == 0)) && "unexpected offset");
974  MachineLocation MLoc(RegOp.getReg(), Op1.isImm());
975  return DebugLocEntry::Value(Expr, MLoc);
976  }
977  if (MI->getOperand(0).isImm())
978  return DebugLocEntry::Value(Expr, MI->getOperand(0).getImm());
979  if (MI->getOperand(0).isFPImm())
980  return DebugLocEntry::Value(Expr, MI->getOperand(0).getFPImm());
981  if (MI->getOperand(0).isCImm())
982  return DebugLocEntry::Value(Expr, MI->getOperand(0).getCImm());
983 
984  llvm_unreachable("Unexpected 4-operand DBG_VALUE instruction!");
985 }
986 
987 /// If this and Next are describing different fragments of the same
988 /// variable, merge them by appending Next's values to the current
989 /// list of values.
990 /// Return true if the merge was successful.
992  if (Begin == Next.Begin) {
993  auto *FirstExpr = cast<DIExpression>(Values[0].Expression);
994  auto *FirstNextExpr = cast<DIExpression>(Next.Values[0].Expression);
995  if (!FirstExpr->isFragment() || !FirstNextExpr->isFragment())
996  return false;
997 
998  // We can only merge entries if none of the fragments overlap any others.
999  // In doing so, we can take advantage of the fact that both lists are
1000  // sorted.
1001  for (unsigned i = 0, j = 0; i < Values.size(); ++i) {
1002  for (; j < Next.Values.size(); ++j) {
1003  int res = cast<DIExpression>(Values[i].Expression)->fragmentCmp(
1004  cast<DIExpression>(Next.Values[j].Expression));
1005  if (res == 0) // The two expressions overlap, we can't merge.
1006  return false;
1007  // Values[i] is entirely before Next.Values[j],
1008  // so go back to the next entry of Values.
1009  else if (res == -1)
1010  break;
1011  // Next.Values[j] is entirely before Values[i], so go on to the
1012  // next entry of Next.Values.
1013  }
1014  }
1015 
1016  addValues(Next.Values);
1017  End = Next.End;
1018  return true;
1019  }
1020  return false;
1021 }
1022 
1023 /// Build the location list for all DBG_VALUEs in the function that
1024 /// describe the same variable. If the ranges of several independent
1025 /// fragments of the same variable overlap partially, split them up and
1026 /// combine the ranges. The resulting DebugLocEntries are will have
1027 /// strict monotonically increasing begin addresses and will never
1028 /// overlap.
1029 //
1030 // Input:
1031 //
1032 // Ranges History [var, loc, fragment ofs size]
1033 // 0 | [x, (reg0, fragment 0, 32)]
1034 // 1 | | [x, (reg1, fragment 32, 32)] <- IsFragmentOfPrevEntry
1035 // 2 | | ...
1036 // 3 | [clobber reg0]
1037 // 4 [x, (mem, fragment 0, 64)] <- overlapping with both previous fragments of
1038 // x.
1039 //
1040 // Output:
1041 //
1042 // [0-1] [x, (reg0, fragment 0, 32)]
1043 // [1-3] [x, (reg0, fragment 0, 32), (reg1, fragment 32, 32)]
1044 // [3-4] [x, (reg1, fragment 32, 32)]
1045 // [4- ] [x, (mem, fragment 0, 64)]
1046 void
1047 DwarfDebug::buildLocationList(SmallVectorImpl<DebugLocEntry> &DebugLoc,
1048  const DbgValueHistoryMap::InstrRanges &Ranges) {
1050 
1051  for (auto I = Ranges.begin(), E = Ranges.end(); I != E; ++I) {
1052  const MachineInstr *Begin = I->first;
1053  const MachineInstr *End = I->second;
1054  assert(Begin->isDebugValue() && "Invalid History entry");
1055 
1056  // Check if a variable is inaccessible in this range.
1057  if (Begin->getNumOperands() > 1 &&
1058  Begin->getOperand(0).isReg() && !Begin->getOperand(0).getReg()) {
1059  OpenRanges.clear();
1060  continue;
1061  }
1062 
1063  // If this fragment overlaps with any open ranges, truncate them.
1064  const DIExpression *DIExpr = Begin->getDebugExpression();
1065  auto Last = remove_if(OpenRanges, [&](DebugLocEntry::Value R) {
1066  return DIExpr->fragmentsOverlap(R.getExpression());
1067  });
1068  OpenRanges.erase(Last, OpenRanges.end());
1069 
1070  const MCSymbol *StartLabel = getLabelBeforeInsn(Begin);
1071  assert(StartLabel && "Forgot label before DBG_VALUE starting a range!");
1072 
1073  const MCSymbol *EndLabel;
1074  if (End != nullptr)
1075  EndLabel = getLabelAfterInsn(End);
1076  else if (std::next(I) == Ranges.end())
1077  EndLabel = Asm->getFunctionEnd();
1078  else
1079  EndLabel = getLabelBeforeInsn(std::next(I)->first);
1080  assert(EndLabel && "Forgot label after instruction ending a range!");
1081 
1082  LLVM_DEBUG(dbgs() << "DotDebugLoc: " << *Begin << "\n");
1083 
1084  auto Value = getDebugLocValue(Begin);
1085  DebugLocEntry Loc(StartLabel, EndLabel, Value);
1086  bool couldMerge = false;
1087 
1088  // If this is a fragment, it may belong to the current DebugLocEntry.
1089  if (DIExpr->isFragment()) {
1090  // Add this value to the list of open ranges.
1091  OpenRanges.push_back(Value);
1092 
1093  // Attempt to add the fragment to the last entry.
1094  if (!DebugLoc.empty())
1095  if (DebugLoc.back().MergeValues(Loc))
1096  couldMerge = true;
1097  }
1098 
1099  if (!couldMerge) {
1100  // Need to add a new DebugLocEntry. Add all values from still
1101  // valid non-overlapping fragments.
1102  if (OpenRanges.size())
1103  Loc.addValues(OpenRanges);
1104 
1105  DebugLoc.push_back(std::move(Loc));
1106  }
1107 
1108  // Attempt to coalesce the ranges of two otherwise identical
1109  // DebugLocEntries.
1110  auto CurEntry = DebugLoc.rbegin();
1111  LLVM_DEBUG({
1112  dbgs() << CurEntry->getValues().size() << " Values:\n";
1113  for (auto &Value : CurEntry->getValues())
1114  Value.dump();
1115  dbgs() << "-----\n";
1116  });
1117 
1118  auto PrevEntry = std::next(CurEntry);
1119  if (PrevEntry != DebugLoc.rend() && PrevEntry->MergeRanges(*CurEntry))
1120  DebugLoc.pop_back();
1121  }
1122 }
1123 
1124 DbgVariable *DwarfDebug::createConcreteVariable(DwarfCompileUnit &TheCU,
1125  LexicalScope &Scope,
1126  InlinedVariable IV) {
1127  ensureAbstractVariableIsCreatedIfScoped(TheCU, IV, Scope.getScopeNode());
1128  ConcreteVariables.push_back(
1129  llvm::make_unique<DbgVariable>(IV.first, IV.second));
1130  InfoHolder.addScopeVariable(&Scope, ConcreteVariables.back().get());
1131  return ConcreteVariables.back().get();
1132 }
1133 
1134 /// Determine whether a *singular* DBG_VALUE is valid for the entirety of its
1135 /// enclosing lexical scope. The check ensures there are no other instructions
1136 /// in the same lexical scope preceding the DBG_VALUE and that its range is
1137 /// either open or otherwise rolls off the end of the scope.
1139  const MachineInstr *DbgValue,
1140  const MachineInstr *RangeEnd) {
1141  assert(DbgValue->getDebugLoc() && "DBG_VALUE without a debug location");
1142  auto MBB = DbgValue->getParent();
1143  auto DL = DbgValue->getDebugLoc();
1144  auto *LScope = LScopes.findLexicalScope(DL);
1145  // Scope doesn't exist; this is a dead DBG_VALUE.
1146  if (!LScope)
1147  return false;
1148  auto &LSRange = LScope->getRanges();
1149  if (LSRange.size() == 0)
1150  return false;
1151 
1152  // Determine if the DBG_VALUE is valid at the beginning of its lexical block.
1153  const MachineInstr *LScopeBegin = LSRange.front().first;
1154  // Early exit if the lexical scope begins outside of the current block.
1155  if (LScopeBegin->getParent() != MBB)
1156  return false;
1158  for (++Pred; Pred != MBB->rend(); ++Pred) {
1159  if (Pred->getFlag(MachineInstr::FrameSetup))
1160  break;
1161  auto PredDL = Pred->getDebugLoc();
1162  if (!PredDL || Pred->isMetaInstruction())
1163  continue;
1164  // Check whether the instruction preceding the DBG_VALUE is in the same
1165  // (sub)scope as the DBG_VALUE.
1166  if (DL->getScope() == PredDL->getScope())
1167  return false;
1168  auto *PredScope = LScopes.findLexicalScope(PredDL);
1169  if (!PredScope || LScope->dominates(PredScope))
1170  return false;
1171  }
1172 
1173  // If the range of the DBG_VALUE is open-ended, report success.
1174  if (!RangeEnd)
1175  return true;
1176 
1177  // Fail if there are instructions belonging to our scope in another block.
1178  const MachineInstr *LScopeEnd = LSRange.back().second;
1179  if (LScopeEnd->getParent() != MBB)
1180  return false;
1181 
1182  // Single, constant DBG_VALUEs in the prologue are promoted to be live
1183  // throughout the function. This is a hack, presumably for DWARF v2 and not
1184  // necessarily correct. It would be much better to use a dbg.declare instead
1185  // if we know the constant is live throughout the scope.
1186  if (DbgValue->getOperand(0).isImm() && MBB->pred_empty())
1187  return true;
1188 
1189  return false;
1190 }
1191 
1192 // Find variables for each lexical scope.
1193 void DwarfDebug::collectVariableInfo(DwarfCompileUnit &TheCU,
1194  const DISubprogram *SP,
1195  DenseSet<InlinedVariable> &Processed) {
1196  // Grab the variable info that was squirreled away in the MMI side-table.
1197  collectVariableInfoFromMFTable(TheCU, Processed);
1198 
1199  for (const auto &I : DbgValues) {
1200  InlinedVariable IV = I.first;
1201  if (Processed.count(IV))
1202  continue;
1203 
1204  // Instruction ranges, specifying where IV is accessible.
1205  const auto &Ranges = I.second;
1206  if (Ranges.empty())
1207  continue;
1208 
1209  LexicalScope *Scope = nullptr;
1210  if (const DILocation *IA = IV.second)
1211  Scope = LScopes.findInlinedScope(IV.first->getScope(), IA);
1212  else
1213  Scope = LScopes.findLexicalScope(IV.first->getScope());
1214  // If variable scope is not found then skip this variable.
1215  if (!Scope)
1216  continue;
1217 
1218  Processed.insert(IV);
1219  DbgVariable *RegVar = createConcreteVariable(TheCU, *Scope, IV);
1220 
1221  const MachineInstr *MInsn = Ranges.front().first;
1222  assert(MInsn->isDebugValue() && "History must begin with debug value");
1223 
1224  // Check if there is a single DBG_VALUE, valid throughout the var's scope.
1225  if (Ranges.size() == 1 &&
1226  validThroughout(LScopes, MInsn, Ranges.front().second)) {
1227  RegVar->initializeDbgValue(MInsn);
1228  continue;
1229  }
1230  // Do not emit location lists if .debug_loc secton is disabled.
1231  if (!useLocSection())
1232  continue;
1233 
1234  // Handle multiple DBG_VALUE instructions describing one variable.
1235  DebugLocStream::ListBuilder List(DebugLocs, TheCU, *Asm, *RegVar, *MInsn);
1236 
1237  // Build the location list for this variable.
1239  buildLocationList(Entries, Ranges);
1240 
1241  // If the variable has a DIBasicType, extract it. Basic types cannot have
1242  // unique identifiers, so don't bother resolving the type with the
1243  // identifier map.
1244  const DIBasicType *BT = dyn_cast<DIBasicType>(
1245  static_cast<const Metadata *>(IV.first->getType()));
1246 
1247  // Finalize the entry by lowering it into a DWARF bytestream.
1248  for (auto &Entry : Entries)
1249  Entry.finalize(*Asm, List, BT);
1250  }
1251 
1252  // Collect info for variables that were optimized out.
1253  for (const DINode *DN : SP->getRetainedNodes()) {
1254  if (auto *DV = dyn_cast<DILocalVariable>(DN)) {
1255  if (Processed.insert(InlinedVariable(DV, nullptr)).second)
1256  if (LexicalScope *Scope = LScopes.findLexicalScope(DV->getScope()))
1257  createConcreteVariable(TheCU, *Scope, InlinedVariable(DV, nullptr));
1258  }
1259  }
1260 }
1261 
1262 // Process beginning of an instruction.
1265  assert(CurMI);
1266 
1267  const auto *SP = MI->getMF()->getFunction().getSubprogram();
1268  if (!SP || SP->getUnit()->getEmissionKind() == DICompileUnit::NoDebug)
1269  return;
1270 
1271  // Check if source location changes, but ignore DBG_VALUE and CFI locations.
1272  // If the instruction is part of the function frame setup code, do not emit
1273  // any line record, as there is no correspondence with any user code.
1275  return;
1276  const DebugLoc &DL = MI->getDebugLoc();
1277  // When we emit a line-0 record, we don't update PrevInstLoc; so look at
1278  // the last line number actually emitted, to see if it was line 0.
1279  unsigned LastAsmLine =
1280  Asm->OutStreamer->getContext().getCurrentDwarfLoc().getLine();
1281 
1282  if (DL == PrevInstLoc) {
1283  // If we have an ongoing unspecified location, nothing to do here.
1284  if (!DL)
1285  return;
1286  // We have an explicit location, same as the previous location.
1287  // But we might be coming back to it after a line 0 record.
1288  if (LastAsmLine == 0 && DL.getLine() != 0) {
1289  // Reinstate the source location but not marked as a statement.
1290  const MDNode *Scope = DL.getScope();
1291  recordSourceLine(DL.getLine(), DL.getCol(), Scope, /*Flags=*/0);
1292  }
1293  return;
1294  }
1295 
1296  if (!DL) {
1297  // We have an unspecified location, which might want to be line 0.
1298  // If we have already emitted a line-0 record, don't repeat it.
1299  if (LastAsmLine == 0)
1300  return;
1301  // If user said Don't Do That, don't do that.
1302  if (UnknownLocations == Disable)
1303  return;
1304  // See if we have a reason to emit a line-0 record now.
1305  // Reasons to emit a line-0 record include:
1306  // - User asked for it (UnknownLocations).
1307  // - Instruction has a label, so it's referenced from somewhere else,
1308  // possibly debug information; we want it to have a source location.
1309  // - Instruction is at the top of a block; we don't want to inherit the
1310  // location from the physically previous (maybe unrelated) block.
1311  if (UnknownLocations == Enable || PrevLabel ||
1312  (PrevInstBB && PrevInstBB != MI->getParent())) {
1313  // Preserve the file and column numbers, if we can, to save space in
1314  // the encoded line table.
1315  // Do not update PrevInstLoc, it remembers the last non-0 line.
1316  const MDNode *Scope = nullptr;
1317  unsigned Column = 0;
1318  if (PrevInstLoc) {
1319  Scope = PrevInstLoc.getScope();
1320  Column = PrevInstLoc.getCol();
1321  }
1322  recordSourceLine(/*Line=*/0, Column, Scope, /*Flags=*/0);
1323  }
1324  return;
1325  }
1326 
1327  // We have an explicit location, different from the previous location.
1328  // Don't repeat a line-0 record, but otherwise emit the new location.
1329  // (The new location might be an explicit line 0, which we do emit.)
1330  if (PrevInstLoc && DL.getLine() == 0 && LastAsmLine == 0)
1331  return;
1332  unsigned Flags = 0;
1333  if (DL == PrologEndLoc) {
1335  PrologEndLoc = DebugLoc();
1336  }
1337  // If the line changed, we call that a new statement; unless we went to
1338  // line 0 and came back, in which case it is not a new statement.
1339  unsigned OldLine = PrevInstLoc ? PrevInstLoc.getLine() : LastAsmLine;
1340  if (DL.getLine() && DL.getLine() != OldLine)
1341  Flags |= DWARF2_FLAG_IS_STMT;
1342 
1343  const MDNode *Scope = DL.getScope();
1344  recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1345 
1346  // If we're not at line 0, remember this location.
1347  if (DL.getLine())
1348  PrevInstLoc = DL;
1349 }
1350 
1351 static DebugLoc findPrologueEndLoc(const MachineFunction *MF) {
1352  // First known non-DBG_VALUE and non-frame setup location marks
1353  // the beginning of the function body.
1354  for (const auto &MBB : *MF)
1355  for (const auto &MI : MBB)
1356  if (!MI.isMetaInstruction() && !MI.getFlag(MachineInstr::FrameSetup) &&
1357  MI.getDebugLoc())
1358  return MI.getDebugLoc();
1359  return DebugLoc();
1360 }
1361 
1362 // Gather pre-function debug information. Assumes being called immediately
1363 // after the function entry point has been emitted.
1365  CurFn = MF;
1366 
1367  auto *SP = MF->getFunction().getSubprogram();
1369  if (SP->getUnit()->getEmissionKind() == DICompileUnit::NoDebug)
1370  return;
1371 
1372  DwarfCompileUnit &CU = getOrCreateDwarfCompileUnit(SP->getUnit());
1373 
1374  // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1375  // belongs to so that we add to the correct per-cu line table in the
1376  // non-asm case.
1377  if (Asm->OutStreamer->hasRawTextSupport())
1378  // Use a single line table if we are generating assembly.
1379  Asm->OutStreamer->getContext().setDwarfCompileUnitID(0);
1380  else
1381  Asm->OutStreamer->getContext().setDwarfCompileUnitID(CU.getUniqueID());
1382 
1383  // Record beginning of function.
1385  if (PrologEndLoc) {
1386  // We'd like to list the prologue as "not statements" but GDB behaves
1387  // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1388  auto *SP = PrologEndLoc->getInlinedAtScope()->getSubprogram();
1389  recordSourceLine(SP->getScopeLine(), 0, SP, DWARF2_FLAG_IS_STMT);
1390  }
1391 }
1392 
1394  // If we don't have a subprogram for this function then there will be a hole
1395  // in the range information. Keep note of this by setting the previously used
1396  // section to nullptr.
1397  PrevCU = nullptr;
1398  CurFn = nullptr;
1399 }
1400 
1401 // Gather and emit post-function debug information.
1403  const DISubprogram *SP = MF->getFunction().getSubprogram();
1404 
1405  assert(CurFn == MF &&
1406  "endFunction should be called with the same function as beginFunction");
1407 
1408  // Set DwarfDwarfCompileUnitID in MCContext to default value.
1409  Asm->OutStreamer->getContext().setDwarfCompileUnitID(0);
1410 
1412  assert(!FnScope || SP == FnScope->getScopeNode());
1413  DwarfCompileUnit &TheCU = *CUMap.lookup(SP->getUnit());
1414 
1415  DenseSet<InlinedVariable> ProcessedVars;
1416  collectVariableInfo(TheCU, SP, ProcessedVars);
1417 
1418  // Add the range of this function to the list of ranges for the CU.
1419  TheCU.addRange(RangeSpan(Asm->getFunctionBegin(), Asm->getFunctionEnd()));
1420 
1421  // Under -gmlt, skip building the subprogram if there are no inlined
1422  // subroutines inside it. But with -fdebug-info-for-profiling, the subprogram
1423  // is still needed as we need its source location.
1424  if (!TheCU.getCUNode()->getDebugInfoForProfiling() &&
1425  TheCU.getCUNode()->getEmissionKind() == DICompileUnit::LineTablesOnly &&
1426  LScopes.getAbstractScopesList().empty() && !IsDarwin) {
1427  assert(InfoHolder.getScopeVariables().empty());
1428  PrevLabel = nullptr;
1429  CurFn = nullptr;
1430  return;
1431  }
1432 
1433 #ifndef NDEBUG
1434  size_t NumAbstractScopes = LScopes.getAbstractScopesList().size();
1435 #endif
1436  // Construct abstract scopes.
1437  for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
1438  auto *SP = cast<DISubprogram>(AScope->getScopeNode());
1439  for (const DINode *DN : SP->getRetainedNodes()) {
1440  if (auto *DV = dyn_cast<DILocalVariable>(DN)) {
1441  // Collect info for variables that were optimized out.
1442  if (!ProcessedVars.insert(InlinedVariable(DV, nullptr)).second)
1443  continue;
1444  ensureAbstractVariableIsCreated(TheCU, InlinedVariable(DV, nullptr),
1445  DV->getScope());
1446  assert(LScopes.getAbstractScopesList().size() == NumAbstractScopes
1447  && "ensureAbstractVariableIsCreated inserted abstract scopes");
1448  }
1449  }
1450  constructAbstractSubprogramScopeDIE(TheCU, AScope);
1451  }
1452 
1453  ProcessedSPNodes.insert(SP);
1454  TheCU.constructSubprogramScopeDIE(SP, FnScope);
1455  if (auto *SkelCU = TheCU.getSkeleton())
1456  if (!LScopes.getAbstractScopesList().empty() &&
1457  TheCU.getCUNode()->getSplitDebugInlining())
1458  SkelCU->constructSubprogramScopeDIE(SP, FnScope);
1459 
1460  // Clear debug info
1461  // Ownership of DbgVariables is a bit subtle - ScopeVariables owns all the
1462  // DbgVariables except those that are also in AbstractVariables (since they
1463  // can be used cross-function)
1464  InfoHolder.getScopeVariables().clear();
1465  PrevLabel = nullptr;
1466  CurFn = nullptr;
1467 }
1468 
1469 // Register a source line with debug info. Returns the unique label that was
1470 // emitted and which provides correspondence to the source line list.
1471 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1472  unsigned Flags) {
1473  StringRef Fn;
1474  unsigned FileNo = 1;
1475  unsigned Discriminator = 0;
1476  if (auto *Scope = cast_or_null<DIScope>(S)) {
1477  Fn = Scope->getFilename();
1478  if (Line != 0 && getDwarfVersion() >= 4)
1479  if (auto *LBF = dyn_cast<DILexicalBlockFile>(Scope))
1480  Discriminator = LBF->getDiscriminator();
1481 
1482  unsigned CUID = Asm->OutStreamer->getContext().getDwarfCompileUnitID();
1483  FileNo = static_cast<DwarfCompileUnit &>(*InfoHolder.getUnits()[CUID])
1484  .getOrCreateSourceID(Scope->getFile());
1485  }
1486  Asm->OutStreamer->EmitDwarfLocDirective(FileNo, Line, Col, Flags, 0,
1487  Discriminator, Fn);
1488 }
1489 
1490 //===----------------------------------------------------------------------===//
1491 // Emit Methods
1492 //===----------------------------------------------------------------------===//
1493 
1494 // Emit the debug info section.
1495 void DwarfDebug::emitDebugInfo() {
1496  DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1497  Holder.emitUnits(/* UseOffsets */ false);
1498 }
1499 
1500 // Emit the abbreviation section.
1501 void DwarfDebug::emitAbbreviations() {
1502  DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1503 
1505 }
1506 
1507 void DwarfDebug::emitStringOffsetsTableHeader() {
1508  DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1511 }
1512 
1513 template <typename AccelTableT>
1514 void DwarfDebug::emitAccel(AccelTableT &Accel, MCSection *Section,
1515  StringRef TableName) {
1516  Asm->OutStreamer->SwitchSection(Section);
1517 
1518  // Emit the full data.
1519  emitAppleAccelTable(Asm, Accel, TableName, Section->getBeginSymbol());
1520 }
1521 
1522 void DwarfDebug::emitAccelDebugNames() {
1523  // Don't emit anything if we have no compilation units to index.
1524  if (getUnits().empty())
1525  return;
1526 
1527  Asm->OutStreamer->SwitchSection(
1529  emitDWARF5AccelTable(Asm, AccelDebugNames, *this, getUnits());
1530 }
1531 
1532 // Emit visible names into a hashed accelerator table section.
1533 void DwarfDebug::emitAccelNames() {
1534  emitAccel(AccelNames, Asm->getObjFileLowering().getDwarfAccelNamesSection(),
1535  "Names");
1536 }
1537 
1538 // Emit objective C classes and categories into a hashed accelerator table
1539 // section.
1540 void DwarfDebug::emitAccelObjC() {
1541  emitAccel(AccelObjC, Asm->getObjFileLowering().getDwarfAccelObjCSection(),
1542  "ObjC");
1543 }
1544 
1545 // Emit namespace dies into a hashed accelerator table.
1546 void DwarfDebug::emitAccelNamespaces() {
1547  emitAccel(AccelNamespace,
1549  "namespac");
1550 }
1551 
1552 // Emit type dies into a hashed accelerator table.
1553 void DwarfDebug::emitAccelTypes() {
1554  emitAccel(AccelTypes, Asm->getObjFileLowering().getDwarfAccelTypesSection(),
1555  "types");
1556 }
1557 
1558 // Public name handling.
1559 // The format for the various pubnames:
1560 //
1561 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
1562 // for the DIE that is named.
1563 //
1564 // gnu pubnames - offset/index value/name tuples where the offset is the offset
1565 // into the CU and the index value is computed according to the type of value
1566 // for the DIE that is named.
1567 //
1568 // For type units the offset is the offset of the skeleton DIE. For split dwarf
1569 // it's the offset within the debug_info/debug_types dwo section, however, the
1570 // reference in the pubname header doesn't change.
1571 
1572 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
1574  const DIE *Die) {
1575  // Entities that ended up only in a Type Unit reference the CU instead (since
1576  // the pub entry has offsets within the CU there's no real offset that can be
1577  // provided anyway). As it happens all such entities (namespaces and types,
1578  // types only in C++ at that) are rendered as TYPE+EXTERNAL. If this turns out
1579  // not to be true it would be necessary to persist this information from the
1580  // point at which the entry is added to the index data structure - since by
1581  // the time the index is built from that, the original type/namespace DIE in a
1582  // type unit has already been destroyed so it can't be queried for properties
1583  // like tag, etc.
1584  if (Die->getTag() == dwarf::DW_TAG_compile_unit)
1588 
1589  // We could have a specification DIE that has our most of our knowledge,
1590  // look for that now.
1591  if (DIEValue SpecVal = Die->findAttribute(dwarf::DW_AT_specification)) {
1592  DIE &SpecDIE = SpecVal.getDIEEntry().getEntry();
1593  if (SpecDIE.findAttribute(dwarf::DW_AT_external))
1594  Linkage = dwarf::GIEL_EXTERNAL;
1595  } else if (Die->findAttribute(dwarf::DW_AT_external))
1596  Linkage = dwarf::GIEL_EXTERNAL;
1597 
1598  switch (Die->getTag()) {
1599  case dwarf::DW_TAG_class_type:
1600  case dwarf::DW_TAG_structure_type:
1601  case dwarf::DW_TAG_union_type:
1602  case dwarf::DW_TAG_enumeration_type:
1604  dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
1607  case dwarf::DW_TAG_typedef:
1608  case dwarf::DW_TAG_base_type:
1609  case dwarf::DW_TAG_subrange_type:
1611  case dwarf::DW_TAG_namespace:
1612  return dwarf::GIEK_TYPE;
1613  case dwarf::DW_TAG_subprogram:
1615  case dwarf::DW_TAG_variable:
1617  case dwarf::DW_TAG_enumerator:
1620  default:
1621  return dwarf::GIEK_NONE;
1622  }
1623 }
1624 
1625 /// emitDebugPubSections - Emit visible names and types into debug pubnames and
1626 /// pubtypes sections.
1627 void DwarfDebug::emitDebugPubSections() {
1628  for (const auto &NU : CUMap) {
1629  DwarfCompileUnit *TheU = NU.second;
1630  if (!TheU->hasDwarfPubSections())
1631  continue;
1632 
1633  bool GnuStyle = TheU->getCUNode()->getGnuPubnames();
1634 
1635  Asm->OutStreamer->SwitchSection(
1638  emitDebugPubSection(GnuStyle, "Names", TheU, TheU->getGlobalNames());
1639 
1640  Asm->OutStreamer->SwitchSection(
1643  emitDebugPubSection(GnuStyle, "Types", TheU, TheU->getGlobalTypes());
1644  }
1645 }
1646 
1647 void DwarfDebug::emitSectionReference(const DwarfCompileUnit &CU) {
1650  CU.getDebugSectionOffset());
1651  else
1653 }
1654 
1655 void DwarfDebug::emitDebugPubSection(bool GnuStyle, StringRef Name,
1656  DwarfCompileUnit *TheU,
1657  const StringMap<const DIE *> &Globals) {
1658  if (auto *Skeleton = TheU->getSkeleton())
1659  TheU = Skeleton;
1660 
1661  // Emit the header.
1662  Asm->OutStreamer->AddComment("Length of Public " + Name + " Info");
1663  MCSymbol *BeginLabel = Asm->createTempSymbol("pub" + Name + "_begin");
1664  MCSymbol *EndLabel = Asm->createTempSymbol("pub" + Name + "_end");
1665  Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
1666 
1667  Asm->OutStreamer->EmitLabel(BeginLabel);
1668 
1669  Asm->OutStreamer->AddComment("DWARF Version");
1671 
1672  Asm->OutStreamer->AddComment("Offset of Compilation Unit Info");
1673  emitSectionReference(*TheU);
1674 
1675  Asm->OutStreamer->AddComment("Compilation Unit Length");
1676  Asm->emitInt32(TheU->getLength());
1677 
1678  // Emit the pubnames for this compilation unit.
1679  for (const auto &GI : Globals) {
1680  const char *Name = GI.getKeyData();
1681  const DIE *Entity = GI.second;
1682 
1683  Asm->OutStreamer->AddComment("DIE offset");
1684  Asm->emitInt32(Entity->getOffset());
1685 
1686  if (GnuStyle) {
1688  Asm->OutStreamer->AddComment(
1689  Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
1691  Asm->emitInt8(Desc.toBits());
1692  }
1693 
1694  Asm->OutStreamer->AddComment("External Name");
1695  Asm->OutStreamer->EmitBytes(StringRef(Name, GI.getKeyLength() + 1));
1696  }
1697 
1698  Asm->OutStreamer->AddComment("End Mark");
1699  Asm->emitInt32(0);
1700  Asm->OutStreamer->EmitLabel(EndLabel);
1701 }
1702 
1703 /// Emit null-terminated strings into a debug str section.
1704 void DwarfDebug::emitDebugStr() {
1705  MCSection *StringOffsetsSection = nullptr;
1707  emitStringOffsetsTableHeader();
1708  StringOffsetsSection = Asm->getObjFileLowering().getDwarfStrOffSection();
1709  }
1710  DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1712  StringOffsetsSection, /* UseRelativeOffsets = */ true);
1713 }
1714 
1716  const DebugLocStream::Entry &Entry) {
1717  auto &&Comments = DebugLocs.getComments(Entry);
1718  auto Comment = Comments.begin();
1719  auto End = Comments.end();
1720  for (uint8_t Byte : DebugLocs.getBytes(Entry))
1721  Streamer.EmitInt8(Byte, Comment != End ? *(Comment++) : "");
1722 }
1723 
1724 static void emitDebugLocValue(const AsmPrinter &AP, const DIBasicType *BT,
1725  const DebugLocEntry::Value &Value,
1726  DwarfExpression &DwarfExpr) {
1727  auto *DIExpr = Value.getExpression();
1728  DIExpressionCursor ExprCursor(DIExpr);
1729  DwarfExpr.addFragmentOffset(DIExpr);
1730  // Regular entry.
1731  if (Value.isInt()) {
1732  if (BT && (BT->getEncoding() == dwarf::DW_ATE_signed ||
1733  BT->getEncoding() == dwarf::DW_ATE_signed_char))
1734  DwarfExpr.addSignedConstant(Value.getInt());
1735  else
1736  DwarfExpr.addUnsignedConstant(Value.getInt());
1737  } else if (Value.isLocation()) {
1738  MachineLocation Location = Value.getLoc();
1739  if (Location.isIndirect())
1740  DwarfExpr.setMemoryLocationKind();
1741  DIExpressionCursor Cursor(DIExpr);
1742  const TargetRegisterInfo &TRI = *AP.MF->getSubtarget().getRegisterInfo();
1743  if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg()))
1744  return;
1745  return DwarfExpr.addExpression(std::move(Cursor));
1746  } else if (Value.isConstantFP()) {
1747  APInt RawBytes = Value.getConstantFP()->getValueAPF().bitcastToAPInt();
1748  DwarfExpr.addUnsignedConstant(RawBytes);
1749  }
1750  DwarfExpr.addExpression(std::move(ExprCursor));
1751 }
1752 
1755  const DIBasicType *BT) {
1756  DebugLocStream::EntryBuilder Entry(List, Begin, End);
1757  BufferByteStreamer Streamer = Entry.getStreamer();
1758  DebugLocDwarfExpression DwarfExpr(AP.getDwarfVersion(), Streamer);
1759  const DebugLocEntry::Value &Value = Values[0];
1760  if (Value.isFragment()) {
1761  // Emit all fragments that belong to the same variable and range.
1763  return P.isFragment();
1764  }) && "all values are expected to be fragments");
1765  assert(std::is_sorted(Values.begin(), Values.end()) &&
1766  "fragments are expected to be sorted");
1767 
1768  for (auto Fragment : Values)
1769  emitDebugLocValue(AP, BT, Fragment, DwarfExpr);
1770 
1771  } else {
1772  assert(Values.size() == 1 && "only fragments may have >1 value");
1773  emitDebugLocValue(AP, BT, Value, DwarfExpr);
1774  }
1775  DwarfExpr.finalize();
1776 }
1777 
1779  // Emit the size.
1780  Asm->OutStreamer->AddComment("Loc expr size");
1781  Asm->emitInt16(DebugLocs.getBytes(Entry).size());
1782 
1783  // Emit the entry.
1784  APByteStreamer Streamer(*Asm);
1785  emitDebugLocEntry(Streamer, Entry);
1786 }
1787 
1788 // Emit locations into the debug loc section.
1789 void DwarfDebug::emitDebugLoc() {
1790  if (DebugLocs.getLists().empty())
1791  return;
1792 
1793  // Start the dwarf loc section.
1794  Asm->OutStreamer->SwitchSection(
1796  unsigned char Size = Asm->MAI->getCodePointerSize();
1797  for (const auto &List : DebugLocs.getLists()) {
1798  Asm->OutStreamer->EmitLabel(List.Label);
1799  const DwarfCompileUnit *CU = List.CU;
1800  for (const auto &Entry : DebugLocs.getEntries(List)) {
1801  // Set up the range. This range is relative to the entry point of the
1802  // compile unit. This is a hard coded 0 for low_pc when we're emitting
1803  // ranges, or the DW_AT_low_pc on the compile unit otherwise.
1804  if (auto *Base = CU->getBaseAddress()) {
1805  Asm->EmitLabelDifference(Entry.BeginSym, Base, Size);
1806  Asm->EmitLabelDifference(Entry.EndSym, Base, Size);
1807  } else {
1808  Asm->OutStreamer->EmitSymbolValue(Entry.BeginSym, Size);
1809  Asm->OutStreamer->EmitSymbolValue(Entry.EndSym, Size);
1810  }
1811 
1813  }
1814  Asm->OutStreamer->EmitIntValue(0, Size);
1815  Asm->OutStreamer->EmitIntValue(0, Size);
1816  }
1817 }
1818 
1819 void DwarfDebug::emitDebugLocDWO() {
1820  Asm->OutStreamer->SwitchSection(
1822  for (const auto &List : DebugLocs.getLists()) {
1823  Asm->OutStreamer->EmitLabel(List.Label);
1824  for (const auto &Entry : DebugLocs.getEntries(List)) {
1825  // Just always use start_length for now - at least that's one address
1826  // rather than two. We could get fancier and try to, say, reuse an
1827  // address we know we've emitted elsewhere (the start of the function?
1828  // The start of the CU or CU subrange that encloses this range?)
1830  unsigned idx = AddrPool.getIndex(Entry.BeginSym);
1831  Asm->EmitULEB128(idx);
1832  Asm->EmitLabelDifference(Entry.EndSym, Entry.BeginSym, 4);
1833 
1835  }
1837  }
1838 }
1839 
1840 struct ArangeSpan {
1841  const MCSymbol *Start, *End;
1842 };
1843 
1844 // Emit a debug aranges section, containing a CU lookup for any
1845 // address we can tie back to a CU.
1846 void DwarfDebug::emitDebugARanges() {
1847  // Provides a unique id per text section.
1849 
1850  // Filter labels by section.
1851  for (const SymbolCU &SCU : ArangeLabels) {
1852  if (SCU.Sym->isInSection()) {
1853  // Make a note of this symbol and it's section.
1854  MCSection *Section = &SCU.Sym->getSection();
1855  if (!Section->getKind().isMetadata())
1856  SectionMap[Section].push_back(SCU);
1857  } else {
1858  // Some symbols (e.g. common/bss on mach-o) can have no section but still
1859  // appear in the output. This sucks as we rely on sections to build
1860  // arange spans. We can do it without, but it's icky.
1861  SectionMap[nullptr].push_back(SCU);
1862  }
1863  }
1864 
1866 
1867  for (auto &I : SectionMap) {
1868  MCSection *Section = I.first;
1869  SmallVector<SymbolCU, 8> &List = I.second;
1870  if (List.size() < 1)
1871  continue;
1872 
1873  // If we have no section (e.g. common), just write out
1874  // individual spans for each symbol.
1875  if (!Section) {
1876  for (const SymbolCU &Cur : List) {
1877  ArangeSpan Span;
1878  Span.Start = Cur.Sym;
1879  Span.End = nullptr;
1880  assert(Cur.CU);
1881  Spans[Cur.CU].push_back(Span);
1882  }
1883  continue;
1884  }
1885 
1886  // Sort the symbols by offset within the section.
1887  std::stable_sort(
1888  List.begin(), List.end(), [&](const SymbolCU &A, const SymbolCU &B) {
1889  unsigned IA = A.Sym ? Asm->OutStreamer->GetSymbolOrder(A.Sym) : 0;
1890  unsigned IB = B.Sym ? Asm->OutStreamer->GetSymbolOrder(B.Sym) : 0;
1891 
1892  // Symbols with no order assigned should be placed at the end.
1893  // (e.g. section end labels)
1894  if (IA == 0)
1895  return false;
1896  if (IB == 0)
1897  return true;
1898  return IA < IB;
1899  });
1900 
1901  // Insert a final terminator.
1902  List.push_back(SymbolCU(nullptr, Asm->OutStreamer->endSection(Section)));
1903 
1904  // Build spans between each label.
1905  const MCSymbol *StartSym = List[0].Sym;
1906  for (size_t n = 1, e = List.size(); n < e; n++) {
1907  const SymbolCU &Prev = List[n - 1];
1908  const SymbolCU &Cur = List[n];
1909 
1910  // Try and build the longest span we can within the same CU.
1911  if (Cur.CU != Prev.CU) {
1912  ArangeSpan Span;
1913  Span.Start = StartSym;
1914  Span.End = Cur.Sym;
1915  assert(Prev.CU);
1916  Spans[Prev.CU].push_back(Span);
1917  StartSym = Cur.Sym;
1918  }
1919  }
1920  }
1921 
1922  // Start the dwarf aranges section.
1923  Asm->OutStreamer->SwitchSection(
1925 
1926  unsigned PtrSize = Asm->MAI->getCodePointerSize();
1927 
1928  // Build a list of CUs used.
1929  std::vector<DwarfCompileUnit *> CUs;
1930  for (const auto &it : Spans) {
1931  DwarfCompileUnit *CU = it.first;
1932  CUs.push_back(CU);
1933  }
1934 
1935  // Sort the CU list (again, to ensure consistent output order).
1936  llvm::sort(CUs.begin(), CUs.end(),
1937  [](const DwarfCompileUnit *A, const DwarfCompileUnit *B) {
1938  return A->getUniqueID() < B->getUniqueID();
1939  });
1940 
1941  // Emit an arange table for each CU we used.
1942  for (DwarfCompileUnit *CU : CUs) {
1943  std::vector<ArangeSpan> &List = Spans[CU];
1944 
1945  // Describe the skeleton CU's offset and length, not the dwo file's.
1946  if (auto *Skel = CU->getSkeleton())
1947  CU = Skel;
1948 
1949  // Emit size of content not including length itself.
1950  unsigned ContentSize =
1951  sizeof(int16_t) + // DWARF ARange version number
1952  sizeof(int32_t) + // Offset of CU in the .debug_info section
1953  sizeof(int8_t) + // Pointer Size (in bytes)
1954  sizeof(int8_t); // Segment Size (in bytes)
1955 
1956  unsigned TupleSize = PtrSize * 2;
1957 
1958  // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
1959  unsigned Padding =
1960  OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
1961 
1962  ContentSize += Padding;
1963  ContentSize += (List.size() + 1) * TupleSize;
1964 
1965  // For each compile unit, write the list of spans it covers.
1966  Asm->OutStreamer->AddComment("Length of ARange Set");
1967  Asm->emitInt32(ContentSize);
1968  Asm->OutStreamer->AddComment("DWARF Arange version number");
1970  Asm->OutStreamer->AddComment("Offset Into Debug Info Section");
1971  emitSectionReference(*CU);
1972  Asm->OutStreamer->AddComment("Address Size (in bytes)");
1973  Asm->emitInt8(PtrSize);
1974  Asm->OutStreamer->AddComment("Segment Size (in bytes)");
1975  Asm->emitInt8(0);
1976 
1977  Asm->OutStreamer->emitFill(Padding, 0xff);
1978 
1979  for (const ArangeSpan &Span : List) {
1980  Asm->EmitLabelReference(Span.Start, PtrSize);
1981 
1982  // Calculate the size as being from the span start to it's end.
1983  if (Span.End) {
1984  Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
1985  } else {
1986  // For symbols without an end marker (e.g. common), we
1987  // write a single arange entry containing just that one symbol.
1988  uint64_t Size = SymSize[Span.Start];
1989  if (Size == 0)
1990  Size = 1;
1991 
1992  Asm->OutStreamer->EmitIntValue(Size, PtrSize);
1993  }
1994  }
1995 
1996  Asm->OutStreamer->AddComment("ARange terminator");
1997  Asm->OutStreamer->EmitIntValue(0, PtrSize);
1998  Asm->OutStreamer->EmitIntValue(0, PtrSize);
1999  }
2000 }
2001 
2002 /// Emit a single range list. We handle both DWARF v5 and earlier.
2004  const RangeSpanList &List) {
2005 
2006  auto DwarfVersion = CU->getDwarfVersion();
2007  // Emit our symbol so we can find the beginning of the range.
2008  Asm->OutStreamer->EmitLabel(List.getSym());
2009  // Gather all the ranges that apply to the same section so they can share
2010  // a base address entry.
2012  // Size for our labels.
2013  auto Size = Asm->MAI->getCodePointerSize();
2014 
2015  for (const RangeSpan &Range : List.getRanges())
2016  SectionRanges[&Range.getStart()->getSection()].push_back(&Range);
2017 
2018  auto *CUBase = CU->getBaseAddress();
2019  bool BaseIsSet = false;
2020  for (const auto &P : SectionRanges) {
2021  // Don't bother with a base address entry if there's only one range in
2022  // this section in this range list - for example ranges for a CU will
2023  // usually consist of single regions from each of many sections
2024  // (-ffunction-sections, or just C++ inline functions) except under LTO
2025  // or optnone where there may be holes in a single CU's section
2026  // contributions.
2027  auto *Base = CUBase;
2028  if (!Base && P.second.size() > 1 &&
2029  (UseDwarfRangesBaseAddressSpecifier || DwarfVersion >= 5)) {
2030  BaseIsSet = true;
2031  // FIXME/use care: This may not be a useful base address if it's not
2032  // the lowest address/range in this object.
2033  Base = P.second.front()->getStart();
2034  if (DwarfVersion >= 5) {
2035  Asm->OutStreamer->AddComment("DW_RLE_base_address");
2036  Asm->OutStreamer->EmitIntValue(dwarf::DW_RLE_base_address, 1);
2037  } else
2038  Asm->OutStreamer->EmitIntValue(-1, Size);
2039  Asm->OutStreamer->AddComment(" base address");
2040  Asm->OutStreamer->EmitSymbolValue(Base, Size);
2041  } else if (BaseIsSet && DwarfVersion < 5) {
2042  BaseIsSet = false;
2043  assert(!Base);
2044  Asm->OutStreamer->EmitIntValue(-1, Size);
2045  Asm->OutStreamer->EmitIntValue(0, Size);
2046  }
2047 
2048  for (const auto *RS : P.second) {
2049  const MCSymbol *Begin = RS->getStart();
2050  const MCSymbol *End = RS->getEnd();
2051  assert(Begin && "Range without a begin symbol?");
2052  assert(End && "Range without an end symbol?");
2053  if (Base) {
2054  if (DwarfVersion >= 5) {
2055  // Emit DW_RLE_offset_pair when we have a base.
2056  Asm->OutStreamer->AddComment("DW_RLE_offset_pair");
2057  Asm->OutStreamer->EmitIntValue(dwarf::DW_RLE_offset_pair, 1);
2058  Asm->OutStreamer->AddComment(" starting offset");
2059  Asm->EmitLabelDifferenceAsULEB128(Begin, Base);
2060  Asm->OutStreamer->AddComment(" ending offset");
2062  } else {
2063  Asm->EmitLabelDifference(Begin, Base, Size);
2064  Asm->EmitLabelDifference(End, Base, Size);
2065  }
2066  } else if (DwarfVersion >= 5) {
2067  Asm->OutStreamer->AddComment("DW_RLE_start_length");
2068  Asm->OutStreamer->EmitIntValue(dwarf::DW_RLE_start_length, 1);
2069  Asm->OutStreamer->AddComment(" start");
2070  Asm->OutStreamer->EmitSymbolValue(Begin, Size);
2071  Asm->OutStreamer->AddComment(" length");
2072  Asm->EmitLabelDifferenceAsULEB128(End, Begin);
2073  } else {
2074  Asm->OutStreamer->EmitSymbolValue(Begin, Size);
2075  Asm->OutStreamer->EmitSymbolValue(End, Size);
2076  }
2077  }
2078  }
2079  if (DwarfVersion >= 5) {
2080  Asm->OutStreamer->AddComment("DW_RLE_end_of_list");
2081  Asm->OutStreamer->EmitIntValue(dwarf::DW_RLE_end_of_list, 1);
2082  } else {
2083  // Terminate the list with two 0 values.
2084  Asm->OutStreamer->EmitIntValue(0, Size);
2085  Asm->OutStreamer->EmitIntValue(0, Size);
2086  }
2087 }
2088 
2089 void DwarfDebug::emitDebugRnglists() {
2090 
2091  // Don't emit a rangelist table if there are no ranges.
2092  if (llvm::all_of(CUMap,
2093  [](const decltype(CUMap)::const_iterator::value_type &Pair) {
2094  DwarfCompileUnit *TheCU = Pair.second;
2095  if (auto *Skel = TheCU->getSkeleton())
2096  TheCU = Skel;
2097  return TheCU->getRangeLists().empty();
2098  }))
2099  return;
2100 
2101  assert(getDwarfVersion() >= 5 && "Dwarf version must be 5 or greater");
2102  // FIXME: As long as we don't support DW_RLE_base_addrx, we cannot generate
2103  // any tables in the .debug_rnglists.dwo section.
2104  Asm->OutStreamer->SwitchSection(
2106  // The length is described by a starting label right after the length field
2107  // and an end label.
2108  MCSymbol *TableStart = Asm->createTempSymbol("debug_rnglist_table_start");
2109  MCSymbol *TableEnd = Asm->createTempSymbol("debug_rnglist_table_end");
2110  // Build the range table header, which starts with the length field.
2111  Asm->EmitLabelDifference(TableEnd, TableStart, 4);
2112  Asm->OutStreamer->EmitLabel(TableStart);
2113  // Version number (DWARF v5 and later).
2115  // Address size.
2117  // Segment selector size.
2118  Asm->emitInt8(0);
2119 
2120  MCSymbol *RnglistTableBaseSym =
2121  (useSplitDwarf() ? SkeletonHolder : InfoHolder).getRnglistsTableBaseSym();
2122 
2123  // FIXME: Generate the offsets table and use DW_FORM_rnglistx with the
2124  // DW_AT_ranges attribute. Until then set the number of offsets to 0.
2125  Asm->emitInt32(0);
2126  Asm->OutStreamer->EmitLabel(RnglistTableBaseSym);
2127 
2128  // Emit the individual range lists.
2129  for (const auto &I : CUMap) {
2130  DwarfCompileUnit *TheCU = I.second;
2131  if (auto *Skel = TheCU->getSkeleton())
2132  TheCU = Skel;
2133  for (const RangeSpanList &List : TheCU->getRangeLists())
2134  emitRangeList(Asm, TheCU, List);
2135  }
2136 
2137  Asm->OutStreamer->EmitLabel(TableEnd);
2138 }
2139 
2140 /// Emit address ranges into the .debug_ranges section or DWARF v5 rangelists
2141 /// into the .debug_rnglists section.
2142 void DwarfDebug::emitDebugRanges() {
2143  if (CUMap.empty())
2144  return;
2145 
2146  if (!useRangesSection()) {
2148  CUMap,
2149  [](const decltype(CUMap)::const_iterator::value_type &Pair) {
2150  return Pair.second->getRangeLists().empty();
2151  }) &&
2152  "No debug ranges expected.");
2153  return;
2154  }
2155 
2156  if (getDwarfVersion() >= 5) {
2157  emitDebugRnglists();
2158  return;
2159  }
2160 
2161  // Start the dwarf ranges section.
2162  Asm->OutStreamer->SwitchSection(
2164 
2165  // Grab the specific ranges for the compile units in the module.
2166  for (const auto &I : CUMap) {
2167  DwarfCompileUnit *TheCU = I.second;
2168 
2169  if (auto *Skel = TheCU->getSkeleton())
2170  TheCU = Skel;
2171 
2172  // Iterate over the misc ranges for the compile units in the module.
2173  for (const RangeSpanList &List : TheCU->getRangeLists())
2174  emitRangeList(Asm, TheCU, List);
2175  }
2176 }
2177 
2178 void DwarfDebug::handleMacroNodes(DIMacroNodeArray Nodes, DwarfCompileUnit &U) {
2179  for (auto *MN : Nodes) {
2180  if (auto *M = dyn_cast<DIMacro>(MN))
2181  emitMacro(*M);
2182  else if (auto *F = dyn_cast<DIMacroFile>(MN))
2183  emitMacroFile(*F, U);
2184  else
2185  llvm_unreachable("Unexpected DI type!");
2186  }
2187 }
2188 
2189 void DwarfDebug::emitMacro(DIMacro &M) {
2191  Asm->EmitULEB128(M.getLine());
2192  StringRef Name = M.getName();
2193  StringRef Value = M.getValue();
2194  Asm->OutStreamer->EmitBytes(Name);
2195  if (!Value.empty()) {
2196  // There should be one space between macro name and macro value.
2197  Asm->emitInt8(' ');
2198  Asm->OutStreamer->EmitBytes(Value);
2199  }
2200  Asm->emitInt8('\0');
2201 }
2202 
2203 void DwarfDebug::emitMacroFile(DIMacroFile &F, DwarfCompileUnit &U) {
2206  Asm->EmitULEB128(F.getLine());
2208  handleMacroNodes(F.getElements(), U);
2210 }
2211 
2212 /// Emit macros into a debug macinfo section.
2213 void DwarfDebug::emitDebugMacinfo() {
2214  if (CUMap.empty())
2215  return;
2216 
2217  // Start the dwarf macinfo section.
2218  Asm->OutStreamer->SwitchSection(
2220 
2221  for (const auto &P : CUMap) {
2222  auto &TheCU = *P.second;
2223  auto *SkCU = TheCU.getSkeleton();
2224  DwarfCompileUnit &U = SkCU ? *SkCU : TheCU;
2225  auto *CUNode = cast<DICompileUnit>(P.first);
2226  DIMacroNodeArray Macros = CUNode->getMacros();
2227  if (!Macros.empty()) {
2228  Asm->OutStreamer->EmitLabel(U.getMacroLabelBegin());
2229  handleMacroNodes(Macros, U);
2230  }
2231  }
2232  Asm->OutStreamer->AddComment("End Of Macro List Mark");
2233  Asm->emitInt8(0);
2234 }
2235 
2236 // DWARF5 Experimental Separate Dwarf emitters.
2237 
2238 void DwarfDebug::initSkeletonUnit(const DwarfUnit &U, DIE &Die,
2239  std::unique_ptr<DwarfCompileUnit> NewU) {
2240  NewU->addString(Die, dwarf::DW_AT_GNU_dwo_name,
2242 
2243  if (!CompilationDir.empty())
2244  NewU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2245 
2246  addGnuPubAttributes(*NewU, Die);
2247 
2248  SkeletonHolder.addUnit(std::move(NewU));
2249 }
2250 
2251 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2252 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2253 // DW_AT_addr_base, DW_AT_ranges_base or DW_AT_rnglists_base.
2254 DwarfCompileUnit &DwarfDebug::constructSkeletonCU(const DwarfCompileUnit &CU) {
2255 
2256  auto OwnedUnit = llvm::make_unique<DwarfCompileUnit>(
2257  CU.getUniqueID(), CU.getCUNode(), Asm, this, &SkeletonHolder);
2258  DwarfCompileUnit &NewCU = *OwnedUnit;
2260 
2261  NewCU.initStmtList();
2262 
2264  NewCU.addStringOffsetsStart();
2265 
2266  initSkeletonUnit(CU, NewCU.getUnitDie(), std::move(OwnedUnit));
2267 
2268  return NewCU;
2269 }
2270 
2271 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2272 // compile units that would normally be in debug_info.
2273 void DwarfDebug::emitDebugInfoDWO() {
2274  assert(useSplitDwarf() && "No split dwarf debug info?");
2275  // Don't emit relocations into the dwo file.
2276  InfoHolder.emitUnits(/* UseOffsets */ true);
2277 }
2278 
2279 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2280 // abbreviations for the .debug_info.dwo section.
2281 void DwarfDebug::emitDebugAbbrevDWO() {
2282  assert(useSplitDwarf() && "No split dwarf?");
2283  InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
2284 }
2285 
2286 void DwarfDebug::emitDebugLineDWO() {
2287  assert(useSplitDwarf() && "No split dwarf?");
2288  SplitTypeUnitFileTable.Emit(
2291 }
2292 
2293 void DwarfDebug::emitStringOffsetsTableHeaderDWO() {
2294  assert(useSplitDwarf() && "No split dwarf?");
2295  InfoHolder.emitStringOffsetsTableHeader(
2297 }
2298 
2299 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2300 // string section and is identical in format to traditional .debug_str
2301 // sections.
2302 void DwarfDebug::emitDebugStrDWO() {
2304  emitStringOffsetsTableHeaderDWO();
2305  assert(useSplitDwarf() && "No split dwarf?");
2307  InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2308  OffSec, /* UseRelativeOffsets = */ false);
2309 }
2310 
2311 MCDwarfDwoLineTable *DwarfDebug::getDwoLineTable(const DwarfCompileUnit &CU) {
2312  if (!useSplitDwarf())
2313  return nullptr;
2314  const DICompileUnit *DIUnit = CU.getCUNode();
2315  SplitTypeUnitFileTable.maybeSetRootFile(
2316  DIUnit->getDirectory(), DIUnit->getFilename(),
2317  CU.getMD5AsBytes(DIUnit->getFile()), DIUnit->getSource());
2318  return &SplitTypeUnitFileTable;
2319 }
2320 
2322  MD5 Hash;
2323  Hash.update(Identifier);
2324  // ... take the least significant 8 bytes and return those. Our MD5
2325  // implementation always returns its results in little endian, so we actually
2326  // need the "high" word.
2328  Hash.final(Result);
2329  return Result.high();
2330 }
2331 
2333  StringRef Identifier, DIE &RefDie,
2334  const DICompositeType *CTy) {
2335  // Fast path if we're building some type units and one has already used the
2336  // address pool we know we're going to throw away all this work anyway, so
2337  // don't bother building dependent types.
2338  if (!TypeUnitsUnderConstruction.empty() && AddrPool.hasBeenUsed())
2339  return;
2340 
2341  auto Ins = TypeSignatures.insert(std::make_pair(CTy, 0));
2342  if (!Ins.second) {
2343  CU.addDIETypeSignature(RefDie, Ins.first->second);
2344  return;
2345  }
2346 
2347  bool TopLevelType = TypeUnitsUnderConstruction.empty();
2348  AddrPool.resetUsedFlag();
2349 
2350  auto OwnedUnit = llvm::make_unique<DwarfTypeUnit>(CU, Asm, this, &InfoHolder,
2351  getDwoLineTable(CU));
2352  DwarfTypeUnit &NewTU = *OwnedUnit;
2353  DIE &UnitDie = NewTU.getUnitDie();
2354  TypeUnitsUnderConstruction.emplace_back(std::move(OwnedUnit), CTy);
2355 
2356  NewTU.addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
2357  CU.getLanguage());
2358 
2359  uint64_t Signature = makeTypeSignature(Identifier);
2360  NewTU.setTypeSignature(Signature);
2361  Ins.first->second = Signature;
2362 
2363  if (useSplitDwarf())
2364  NewTU.setSection(Asm->getObjFileLowering().getDwarfTypesDWOSection());
2365  else {
2366  NewTU.setSection(Asm->getObjFileLowering().getDwarfTypesSection(Signature));
2367  // Non-split type units reuse the compile unit's line table.
2368  CU.applyStmtList(UnitDie);
2369  }
2370 
2371  // Add DW_AT_str_offsets_base to the type unit DIE, but not for split type
2372  // units.
2374  NewTU.addStringOffsetsStart();
2375 
2376  NewTU.setType(NewTU.createTypeDIE(CTy));
2377 
2378  if (TopLevelType) {
2379  auto TypeUnitsToAdd = std::move(TypeUnitsUnderConstruction);
2380  TypeUnitsUnderConstruction.clear();
2381 
2382  // Types referencing entries in the address table cannot be placed in type
2383  // units.
2384  if (AddrPool.hasBeenUsed()) {
2385 
2386  // Remove all the types built while building this type.
2387  // This is pessimistic as some of these types might not be dependent on
2388  // the type that used an address.
2389  for (const auto &TU : TypeUnitsToAdd)
2390  TypeSignatures.erase(TU.second);
2391 
2392  // Construct this type in the CU directly.
2393  // This is inefficient because all the dependent types will be rebuilt
2394  // from scratch, including building them in type units, discovering that
2395  // they depend on addresses, throwing them out and rebuilding them.
2396  CU.constructTypeDIE(RefDie, cast<DICompositeType>(CTy));
2397  return;
2398  }
2399 
2400  // If the type wasn't dependent on fission addresses, finish adding the type
2401  // and all its dependent types.
2402  for (auto &TU : TypeUnitsToAdd) {
2403  InfoHolder.computeSizeAndOffsetsForUnit(TU.first.get());
2404  InfoHolder.emitUnit(TU.first.get(), useSplitDwarf());
2405  }
2406  }
2407  CU.addDIETypeSignature(RefDie, Signature);
2408 }
2409 
2410 // Add the Name along with its companion DIE to the appropriate accelerator
2411 // table (for AccelTableKind::Dwarf it's always AccelDebugNames, for
2412 // AccelTableKind::Apple, we use the table we got as an argument). If
2413 // accelerator tables are disabled, this function does nothing.
2414 template <typename DataT>
2415 void DwarfDebug::addAccelNameImpl(AccelTable<DataT> &AppleAccel, StringRef Name,
2416  const DIE &Die) {
2418  return;
2419 
2420  DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2422  Holder.getStringPool().getEntry(*Asm, Name);
2423 
2424  switch (getAccelTableKind()) {
2425  case AccelTableKind::Apple:
2426  AppleAccel.addName(Ref, Die);
2427  break;
2428  case AccelTableKind::Dwarf:
2429  AccelDebugNames.addName(Ref, Die);
2430  break;
2432  llvm_unreachable("Default should have already been resolved.");
2433  case AccelTableKind::None:
2434  llvm_unreachable("None handled above");
2435  }
2436 }
2437 
2438 void DwarfDebug::addAccelName(StringRef Name, const DIE &Die) {
2439  addAccelNameImpl(AccelNames, Name, Die);
2440 }
2441 
2442 void DwarfDebug::addAccelObjC(StringRef Name, const DIE &Die) {
2443  // ObjC names go only into the Apple accelerator tables.
2445  addAccelNameImpl(AccelObjC, Name, Die);
2446 }
2447 
2449  addAccelNameImpl(AccelNamespace, Name, Die);
2450 }
2451 
2452 void DwarfDebug::addAccelType(StringRef Name, const DIE &Die, char Flags) {
2453  addAccelNameImpl(AccelTypes, Name, Die);
2454 }
2455 
2457  return Asm->OutStreamer->getContext().getDwarfVersion();
2458 }
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:752
const TargetLoweringObjectFile & getObjFileLowering() const
Return information about object file lowering.
Definition: AsmPrinter.cpp:208
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.
MCSection * getDwarfStrOffSection() const
void addFlag(DIE &Die, dwarf::Attribute Attribute)
Add a flag that is true to the DIE.
Definition: DwarfUnit.cpp:200
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
void emitAppleAccelTable(AsmPrinter *Asm, AccelTable< DataT > &Contents, StringRef Prefix, const MCSymbol *SecBegin)
Emit an Apple Accelerator Table consisting of entries in the specified AccelTable.
Definition: AccelTable.h:305
void addMMIEntry(const DbgVariable &V)
Definition: DwarfDebug.cpp:258
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:26
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:82
MCSection * getDwarfStrSection() const
MCTargetOptions MCOptions
Machine level options.
const MachineFunction * getMF() const
Return the function that contains the basic block that this instruction belongs to.
static SmallVectorImpl< DwarfCompileUnit::GlobalExpr > & sortGlobalExprs(SmallVectorImpl< DwarfCompileUnit::GlobalExpr > &GVEs)
Sort and unique GVEs by comparing their fragment offset.
Definition: DwarfDebug.cpp:613
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
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
void setMemoryLocationKind()
Lock this down to become a memory location description.
virtual const TargetRegisterInfo * getRegisterInfo() const
getRegisterInfo - If register information is available, return it.
DWARF v5 .debug_names.
Implements a dense probed hash-table based set.
Definition: DenseSet.h:221
const DIType * getType() const
Definition: DwarfDebug.cpp:195
AccelTableKind getAccelTableKind() const
Returns what kind (if any) of accelerator tables to emit.
Definition: DwarfDebug.h:558
DIFile * getFile() const
const DebugLoc & getDebugLoc() const
Returns the debug location id of this MachineInstr.
Definition: MachineInstr.h:285
std::string SplitDwarfFile
uint16_t getDwarfVersion() const
unsigned getReg() const
unsigned getReg() const
getReg - Returns the register number.
MCSection * getDwarfAccelNamesSection() const
This class holds an abstract representation of an Accelerator Table, consisting of a sequence of buck...
Definition: AccelTable.h:199
static cl::opt< AccelTableKind > AccelTables("accel-tables", cl::Hidden, cl::desc("Output dwarf accelerator tables."), cl::values(clEnumValN(AccelTableKind::Default, "Default", "Default for platform"), clEnumValN(AccelTableKind::None, "Disable", "Disabled."), clEnumValN(AccelTableKind::Apple, "Apple", "Apple"), clEnumValN(AccelTableKind::Dwarf, "Dwarf", "DWARF")), cl::init(AccelTableKind::Default))
Base class containing the logic for constructing DWARF expressions independently of whether they are ...
MD5::MD5Result * getMD5AsBytes(const DIFile *File) const
If the File has an MD5 checksum, return it as an MD5Result allocated in the MCContext.
Definition: DwarfUnit.cpp:280
SmallVectorImpl< InsnRange > & getRanges()
Definition: LexicalScopes.h:67
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.
unsigned getDebugSectionOffset() const
Definition: DIE.h:829
static cl::opt< bool > NoDwarfRangesSection("no-dwarf-ranges-section", cl::Hidden, cl::desc("Disable emission .debug_ranges section."), cl::init(false))
void emitDwarfSymbolReference(const MCSymbol *Label, bool ForceOffset=false) const
Emit a reference to a symbol for use in dwarf.
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:921
void addName(DwarfStringPoolEntryRef Name, Types &&... Args)
Definition: AccelTable.h:209
static const char *const DbgTimerName
Definition: DwarfDebug.cpp:167
unsigned const TargetRegisterInfo * TRI
A debug info location.
Definition: DebugLoc.h:34
Metadata node.
Definition: Metadata.h:862
F(f)
MachineFunction * MF
The current machine function.
Definition: AsmPrinter.h:96
MCSection * getDwarfARangesSection() const
StringRef getProducer() const
bool isMetaInstruction() const
Return true if this instruction doesn&#39;t produce any output in the form of executable instructions...
Definition: MachineInstr.h:918
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:1715
const MachineInstr * CurMI
If nonnull, stores the current machine instruction we&#39;re processing.
VariableDbgInfoMapTy & getVariableDbgInfo()
Tagged DWARF-like metadata node.
DebuggerKind
Identify a debugger for "tuning" the debug info.
Definition: TargetOptions.h:92
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:566
void initializeDbgValue(const MachineInstr *DbgValue)
Initialize from a DBG_VALUE instruction.
Definition: DwarfDebug.h:110
static const char *const DbgTimerDescription
Definition: DwarfDebug.cpp:168
static cl::opt< bool > GenerateARangeSection("generate-arange-section", cl::Hidden, cl::desc("Generate dwarf aranges"), cl::init(false))
MCSection * getDwarfRnglistsSection() const
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:80
static void emitDebugLocValue(const AsmPrinter &AP, const DIBasicType *BT, const DebugLocEntry::Value &Value, DwarfExpression &DwarfExpr)
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:314
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:161
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:204
String pool entry reference.
MachineBasicBlock iterator that automatically skips over MIs that are inside bundles (i...
The access may reference the value stored in memory.
bool none_of(R &&Range, UnaryPredicate P)
Provide wrappers to std::none_of which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:935
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:451
void constructContainingTypeDIEs()
Construct DIEs for types that contain vtables.
Definition: DwarfUnit.cpp:1489
void setDWOId(uint64_t DwoId)
virtual void EmitInt8(uint8_t Byte, const Twine &Comment="")=0
DenseMap< LexicalScope *, ScopeVars > & getScopeVariables()
Definition: DwarfFile.h:128
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
AccelTableKind
The kind of accelerator tables we should emit.
Definition: DwarfDebug.h:196
#define clEnumVal(ENUMVAL, DESC)
Definition: CommandLine.h:603
StringRef getFilename() const
DwarfExpression implementation for .debug_loc entries.
ELFYAML::ELF_STO Other
Definition: ELFYAML.cpp:773
This file implements a class to represent arbitrary precision integral constant values and operations...
DIE * getOrCreateTypeDIE(const MDNode *TyNode)
Find existing DIE or create new DIE for the given type.
Definition: DwarfUnit.cpp:733
const SmallVectorImpl< RangeSpan > & getRanges() const
Definition: DwarfUnit.h:61
Subprogram description.
Describes an entry of the various gnu_pub* debug sections.
Definition: Dwarf.h:557
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:204
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...
DenseMap< const MDNode *, DIE * > & getAbstractSPDies()
Definition: DwarfFile.h:132
This class is used to track local variable information.
Definition: DwarfDebug.h:76
#define T
void setBaseAddress(const MCSymbol *Base)
static AccelTableKind computeAccelTableKind(unsigned DwarfVersion, bool GenerateTypeUnits, DebuggerKind Tuning, const Triple &TT)
Definition: DwarfDebug.cpp:292
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
.apple_names, .apple_namespaces, .apple_types, .apple_objc.
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:991
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:747
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:77
static cl::opt< DefaultOnOff > DwarfInlinedStrings("dwarf-inlined-strings", cl::Hidden, cl::desc("Use inlined strings rather than string section."), cl::values(clEnumVal(Default, "Default for platform"), clEnumVal(Enable, "Enabled"), clEnumVal(Disable, "Disabled")), cl::init(Default))
MCSection * getDwarfAccelTypesSection() const
Debug location.
DIE & addChild(DIE *Child)
Add a child to the DIE.
Definition: DIE.h:769
static cl::opt< bool > GenerateDwarfTypeUnits("generate-type-units", cl::Hidden, cl::desc("Generate DWARF4 type units."), cl::init(false))
void EmitLabelDifferenceAsULEB128(const MCSymbol *Hi, const MCSymbol *Lo) const
Emit something like ".uleb128 Hi-Lo".
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
void resolve()
Resolve a unique, unresolved node.
Definition: Metadata.cpp:576
MCSection * getDwarfAbbrevDWOSection() const
LexicalScope * findAbstractScope(const DILocalScope *N)
findAbstractScope - Find an abstract scope or return null.
static void forBothCUs(DwarfCompileUnit &CU, Func F)
Definition: DwarfDebug.cpp:468
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)
DwarfStringPool & getStringPool()
Returns the string pool.
Definition: DwarfFile.h:115
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:410
StringRef GDBIndexEntryKindString(GDBIndexEntryKind Kind)
Definition: Dwarf.cpp:510
void endModule() override
Emit all Dwarf sections that should come after the content.
Definition: DwarfDebug.cpp:843
DwarfCompileUnit * CU
Definition: DwarfDebug.h:192
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
MCSymbol * getSym() const
Definition: DwarfUnit.h:60
bool tuneForLLDB() const
Definition: DwarfDebug.h:632
const MachineBasicBlock * PrevInstBB
LinkageNameOption
Definition: DwarfDebug.cpp:149
const MCAsmInfo * MAI
Target Asm Printer information.
Definition: AsmPrinter.h:84
static void getObjCClassCategory(StringRef In, StringRef &Class, StringRef &Category)
Definition: DwarfDebug.cpp:405
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:1508
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:965
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:630
const DIExpression * getExpression() const
Definition: DebugLocEntry.h:77
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator begin()
Definition: SmallVector.h:124
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:81
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:78
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.
unsigned getOrCreateSourceID(const DIFile *File) override
Look up the source ID for the given file.
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:928
DIImportedEntityArray getImportedEntities() const
MCSection * getDwarfLineDWOSection() const
bool isPS4CPU() const
Tests whether the target is the PS4 CPU.
Definition: Triple.h:608
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:315
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:487
const Triple & getTargetTriple() const
void computeSizeAndOffsets()
Compute the size and offset of all the DIEs.
Definition: DwarfFile.cpp:69
bool useSegmentedStringOffsetsTable() const
Returns whether to generate a string offsets table with (possibly shared) contributions from each CU ...
Definition: DwarfDebug.h:574
ArrayRef< Entry > getEntries(const List &L) const
StringRef GDBIndexEntryLinkageString(GDBIndexEntryLinkage Linkage)
Definition: Dwarf.cpp:533
bool addScopeVariable(LexicalScope *LS, DbgVariable *Var)
Definition: DwarfFile.cpp:105
void beginInstruction(const MachineInstr *MI) override
Process beginning of an instruction.
auto remove_if(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range))
Provide wrappers to std::remove_if which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:961
bool isOSBinFormatMachO() const
Tests whether the environment is MachO.
Definition: Triple.h:598
GDBIndexEntryLinkage Linkage
Definition: Dwarf.h:559
MDNode * getScope() const
Definition: DebugLoc.cpp:36
A pair of GlobalVariable and DIExpression.
void emitDWARF5AccelTable(AsmPrinter *Asm, AccelTable< DWARF5AccelTableData > &Contents, const DwarfDebug &DD, ArrayRef< std::unique_ptr< DwarfCompileUnit >> CUs)
Definition: AccelTable.cpp:552
Helper used to pair up a symbol and its DWARF compile unit.
Definition: DwarfDebug.h:188
StringRef getDirectory() const
iterator erase(const_iterator CI)
Definition: SmallVector.h:440
bool useAllLinkageNames() const
Returns whether we should emit all DW_AT_[MIPS_]linkage_name.
Definition: DwarfDebug.h:525
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...
size_t size() const
Definition: SmallVector.h:53
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:166
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:240
An imported module (C++ using directive or similar).
unsigned first
bool useLocSection() const
Returns whether .debug_loc section should be emitted.
Definition: DwarfDebug.h:550
void sort(IteratorTy Start, IteratorTy End)
Definition: STLExtras.h:872
DIE * constructImportedEntityDIE(const DIImportedEntity *Module)
Construct import_module DIE.
const APFloat & getValueAPF() const
Definition: Constants.h:299
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:631
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.
bool useSectionsAsReferences() const
Returns whether to use sections as labels rather than temp symbols.
Definition: DwarfDebug.h:545
MCSymbol * getMacroLabelBegin() const
static bool hasObjCCategory(StringRef Name)
Definition: DwarfDebug.cpp:398
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
MCSection * getSection() const
Return the section that this DIEUnit will be emitted into.
Definition: DIE.h:827
DIFile * getFile() const
bool isDebugValue() const
Definition: MachineInstr.h:849
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:841
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:642
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:560
void emitInt32(int Value) const
Emit a long directive and value.
MCSection * getDwarfDebugNamesSection() const
MCSection * getDwarfStrOffDWOSection() const
void addAccelName(StringRef Name, const DIE &Die)
MCSymbol * getFunctionEnd() const
Definition: AsmPrinter.h:205
int64_t getImm() const
void emitDebugLocEntry(ByteStreamer &Streamer, const DebugLocStream::Entry &Entry)
Emit an entry for the debug loc section.
DWARF expression.
const Function & getFunction() const
Return the LLVM function that this machine code represents.
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:133
static void emitRangeList(AsmPrinter *Asm, DwarfCompileUnit *CU, const RangeSpanList &List)
Emit a single range list. We handle both DWARF v5 and earlier.
unsigned getSourceLanguage() const
static cl::opt< DefaultOnOff > DwarfSectionsAsReferences("dwarf-sections-as-references", cl::Hidden, cl::desc("Use sections+offset as references rather than labels."), cl::values(clEnumVal(Default, "Default for platform"), clEnumVal(Enable, "Enabled"), clEnumVal(Disable, "Disabled")), cl::init(Default))
StringMap - This is an unconventional map that is specialized for handling keys that are "strings"...
Definition: StringMap.h:220
This file contains constants used for implementing Dwarf debug support.
Class for arbitrary precision integers.
Definition: APInt.h:69
ArrayRef< std::string > getComments(const Entry &E) const
bool fragmentsOverlap(const DIExpression *Other) const
Check if fragments overlap between this DIExpression and Other.
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
#define clEnumValN(ENUMVAL, FLAGNAME, DESC)
Definition: CommandLine.h:605
A single location or constant.
Definition: DebugLocEntry.h:33
const MachineBasicBlock * getParent() const
Definition: MachineInstr.h:156
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:703
MCSection * getDwarfStrDWOSection() const
Representation of each machine instruction.
Definition: MachineInstr.h:60
static StringRef getObjCMethodName(StringRef In)
Definition: DwarfDebug.cpp:417
bool getSplitDebugInlining() const
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator end()
Definition: SmallVector.h:128
void setSection(MCSection *Section)
Set the section that this DIEUnit will be emitted into.
Definition: DIE.h:815
unsigned getEncoding() const
EntryRef getEntry(AsmPrinter &Asm, StringRef Str)
Get a reference to an entry in the string pool.
void EmitDwarfOffset(const MCSymbol *Label, uint64_t Offset) const
Emit something like ".long Label + Offset".
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:56
bool useRangesSection() const
Returns whether ranges section should be emitted.
Definition: DwarfDebug.h:542
bool isBlockByrefVariable() const
Definition: DwarfDebug.cpp:190
TargetOptions Options
Definition: TargetMachine.h:98
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:760
bool shareAcrossDWOCUs() const
Definition: DwarfDebug.cpp:475
MCSection * getDwarfGnuPubNamesSection() const
Definition: MD5.h:41
Optional< StringRef > getSource() const
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
void emitStrings(MCSection *StrSection, MCSection *OffsetSection=nullptr, bool UseRelativeOffsets=false)
Emit all of the strings to the section given.
Definition: DwarfFile.cpp:100
static cl::opt< bool > NoDwarfPubSections("no-dwarf-pub-sections", cl::Hidden, cl::desc("Disable emission of DWARF pub sections."), cl::init(false))
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.
uint16_t getDwarfVersion() const
Definition: DwarfUnit.h:115
void addDIETypeSignature(DIE &Die, uint64_t Signature)
Add a type&#39;s DW_AT_signature and set the declaration flag.
Definition: DwarfUnit.cpp:330
DIEValue findAttribute(dwarf::Attribute Attribute) const
Find a value in the DIE with the attribute given.
Definition: DIE.cpp:222
ArrayRef< LexicalScope * > getAbstractScopesList() const
getAbstractScopesList - Return a reference to list of abstract scopes.
unsigned getCol() const
Definition: DebugLoc.cpp:31
void addSubprogramNames(const DISubprogram *SP, DIE &Die)
Definition: DwarfDebug.cpp:422
const MCSymbol * End
unsigned getCodePointerSize() const
Get the code pointer size in bytes.
Definition: MCAsmInfo.h:392
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.
void emitStringOffsetsTableHeader(MCSection *Section)
Emit the string table offsets header.
Definition: DwarfFile.cpp:31
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
MCSection * getDwarfAccelNamespaceSection() const
static const char *const DWARFGroupName
Definition: DwarfDebug.cpp:165
void emitInt8(int Value) const
Emit a byte directive and value.
void finishVariableDefinition(const DbgVariable &Var)
LLVM Value Representation.
Definition: Value.h:73
constexpr char Size[]
Key for Kernel::Arg::Metadata::mSize.
void EmitULEB128(uint64_t Value, const char *Desc=nullptr) const
Emit the specified unsigned leb128 value.
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:727
DbgVariable * getExistingAbstractVariable(InlinedVariable IV, const DILocalVariable *&Cleansed)
uint16_t getDwarfVersion() const
Returns the Dwarf Version.
void emitAbbrevs(MCSection *)
Emit a set of abbreviations to the specific section.
Definition: DwarfFile.cpp:97
GDBIndexEntryLinkage
Definition: Dwarf.h:405
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:209
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:106
bool isNVPTX() const
Tests whether the target is NVPTX (32- or 64-bit).
Definition: Triple.h:644
iterator_range< global_iterator > globals()
Definition: Module.h:566
IRTranslator LLVM IR MI
void addAccelObjC(StringRef Name, const DIE &Die)
MachineLocation getLoc() const
Definition: DebugLocEntry.h:75
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:53
MCSection * getDwarfRangesSection() const
bool tuneForSCE() const
Definition: DwarfDebug.h:633
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:25
uint64_t high() const
Definition: MD5.h:72
static bool isObjCClass(StringRef Name)
Definition: DwarfDebug.cpp:394
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
void createAbstractVariable(const DILocalVariable *Var, LexicalScope *Scope)
Builder for DebugLocStream entries.
#define LLVM_DEBUG(X)
Definition: Debug.h:119
for(unsigned i=Desc.getNumOperands(), e=OldMI.getNumOperands();i !=e;++i)
const MachineOperand & getOperand(unsigned i) const
Definition: MachineInstr.h:316
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.
bool getFlag(MIFlag Flag) const
Return whether an MI flag is set.
Definition: MachineInstr.h:197
const ConstantFP * getConstantFP() const
Definition: DebugLocEntry.h:73
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.
void emitInt16(int Value) const
Emit a short directive and value.
StringRef getName() const
Basic type, like &#39;int&#39; or &#39;float&#39;.
const MCSymbol * Sym
Definition: DwarfDebug.h:191
unsigned getIndex(const MCSymbol *Sym, bool TLS=false)
Returns the index into the address pool with the given label/symbol.
Definition: AddressPool.cpp:20