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