LLVM  14.0.0git
DwarfDebug.cpp
Go to the documentation of this file.
1 //===- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ----------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file contains support for writing dwarf debug info into asm files.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "DwarfDebug.h"
14 #include "ByteStreamer.h"
15 #include "DIEHash.h"
16 #include "DwarfCompileUnit.h"
17 #include "DwarfExpression.h"
18 #include "DwarfUnit.h"
19 #include "llvm/ADT/APInt.h"
20 #include "llvm/ADT/Statistic.h"
21 #include "llvm/ADT/Triple.h"
22 #include "llvm/ADT/Twine.h"
24 #include "llvm/CodeGen/DIE.h"
36 #include "llvm/IR/Constants.h"
37 #include "llvm/IR/Function.h"
38 #include "llvm/IR/GlobalVariable.h"
39 #include "llvm/IR/Module.h"
40 #include "llvm/MC/MCAsmInfo.h"
41 #include "llvm/MC/MCContext.h"
42 #include "llvm/MC/MCSection.h"
43 #include "llvm/MC/MCStreamer.h"
44 #include "llvm/MC/MCSymbol.h"
47 #include "llvm/MC/SectionKind.h"
48 #include "llvm/Pass.h"
49 #include "llvm/Support/Casting.h"
51 #include "llvm/Support/Debug.h"
53 #include "llvm/Support/MD5.h"
55 #include "llvm/Support/Timer.h"
59 #include <algorithm>
60 #include <cstddef>
61 #include <iterator>
62 #include <string>
63 
64 using namespace llvm;
65 
66 #define DEBUG_TYPE "dwarfdebug"
67 
68 STATISTIC(NumCSParams, "Number of dbg call site params created");
69 
71  "use-dwarf-ranges-base-address-specifier", cl::Hidden,
72  cl::desc("Use base address specifiers in debug_ranges"), cl::init(false));
73 
74 static cl::opt<bool> GenerateARangeSection("generate-arange-section",
75  cl::Hidden,
76  cl::desc("Generate dwarf aranges"),
77  cl::init(false));
78 
79 static cl::opt<bool>
80  GenerateDwarfTypeUnits("generate-type-units", cl::Hidden,
81  cl::desc("Generate DWARF4 type units."),
82  cl::init(false));
83 
85  "split-dwarf-cross-cu-references", cl::Hidden,
86  cl::desc("Enable cross-cu references in DWO files"), cl::init(false));
87 
88 enum DefaultOnOff { Default, Enable, Disable };
89 
91  "use-unknown-locations", cl::Hidden,
92  cl::desc("Make an absence of debug location information explicit."),
93  cl::values(clEnumVal(Default, "At top of block or after label"),
94  clEnumVal(Enable, "In all cases"), clEnumVal(Disable, "Never")),
95  cl::init(Default));
96 
98  "accel-tables", cl::Hidden, cl::desc("Output dwarf accelerator tables."),
100  "Default for platform"),
101  clEnumValN(AccelTableKind::None, "Disable", "Disabled."),
102  clEnumValN(AccelTableKind::Apple, "Apple", "Apple"),
103  clEnumValN(AccelTableKind::Dwarf, "Dwarf", "DWARF")),
105 
107 DwarfInlinedStrings("dwarf-inlined-strings", cl::Hidden,
108  cl::desc("Use inlined strings rather than string section."),
109  cl::values(clEnumVal(Default, "Default for platform"),
110  clEnumVal(Enable, "Enabled"),
111  clEnumVal(Disable, "Disabled")),
112  cl::init(Default));
113 
114 static cl::opt<bool>
115  NoDwarfRangesSection("no-dwarf-ranges-section", cl::Hidden,
116  cl::desc("Disable emission .debug_ranges section."),
117  cl::init(false));
118 
120  "dwarf-sections-as-references", cl::Hidden,
121  cl::desc("Use sections+offset as references rather than labels."),
122  cl::values(clEnumVal(Default, "Default for platform"),
123  clEnumVal(Enable, "Enabled"), clEnumVal(Disable, "Disabled")),
124  cl::init(Default));
125 
126 static cl::opt<bool>
127  UseGNUDebugMacro("use-gnu-debug-macro", cl::Hidden,
128  cl::desc("Emit the GNU .debug_macro format with DWARF <5"),
129  cl::init(false));
130 
132  "dwarf-op-convert", cl::Hidden,
133  cl::desc("Enable use of the DWARFv5 DW_OP_convert operator"),
134  cl::values(clEnumVal(Default, "Default for platform"),
135  clEnumVal(Enable, "Enabled"), clEnumVal(Disable, "Disabled")),
136  cl::init(Default));
137 
142 };
143 
145  DwarfLinkageNames("dwarf-linkage-names", cl::Hidden,
146  cl::desc("Which DWARF linkage-name attributes to emit."),
148  "Default for platform"),
149  clEnumValN(AllLinkageNames, "All", "All"),
150  clEnumValN(AbstractLinkageNames, "Abstract",
151  "Abstract subprograms")),
153 
155  "minimize-addr-in-v5", cl::Hidden,
156  cl::desc("Always use DW_AT_ranges in DWARFv5 whenever it could allow more "
157  "address pool entry sharing to reduce relocations/object size"),
159  "Default address minimization strategy"),
161  "Use rnglists for contiguous ranges if that allows "
162  "using a pre-existing base address"),
164  "Expressions",
165  "Use exprloc addrx+offset expressions for any "
166  "address with a prior base address"),
168  "Use addrx+offset extension form for any address "
169  "with a prior base address"),
171  "Stuff")),
173 
174 static constexpr unsigned ULEB128PadSize = 4;
175 
176 void DebugLocDwarfExpression::emitOp(uint8_t Op, const char *Comment) {
177  getActiveStreamer().emitInt8(
178  Op, Comment ? Twine(Comment) + " " + dwarf::OperationEncodingString(Op)
180 }
181 
182 void DebugLocDwarfExpression::emitSigned(int64_t Value) {
183  getActiveStreamer().emitSLEB128(Value, Twine(Value));
184 }
185 
186 void DebugLocDwarfExpression::emitUnsigned(uint64_t Value) {
187  getActiveStreamer().emitULEB128(Value, Twine(Value));
188 }
189 
190 void DebugLocDwarfExpression::emitData1(uint8_t Value) {
191  getActiveStreamer().emitInt8(Value, Twine(Value));
192 }
193 
194 void DebugLocDwarfExpression::emitBaseTypeRef(uint64_t Idx) {
195  assert(Idx < (1ULL << (ULEB128PadSize * 7)) && "Idx wont fit");
196  getActiveStreamer().emitULEB128(Idx, Twine(Idx), ULEB128PadSize);
197 }
198 
199 bool DebugLocDwarfExpression::isFrameRegister(const TargetRegisterInfo &TRI,
200  llvm::Register MachineReg) {
201  // This information is not available while emitting .debug_loc entries.
202  return false;
203 }
204 
205 void DebugLocDwarfExpression::enableTemporaryBuffer() {
206  assert(!IsBuffering && "Already buffering?");
207  if (!TmpBuf)
208  TmpBuf = std::make_unique<TempBuffer>(OutBS.GenerateComments);
209  IsBuffering = true;
210 }
211 
212 void DebugLocDwarfExpression::disableTemporaryBuffer() { IsBuffering = false; }
213 
214 unsigned DebugLocDwarfExpression::getTemporaryBufferSize() {
215  return TmpBuf ? TmpBuf->Bytes.size() : 0;
216 }
217 
218 void DebugLocDwarfExpression::commitTemporaryBuffer() {
219  if (!TmpBuf)
220  return;
221  for (auto Byte : enumerate(TmpBuf->Bytes)) {
222  const char *Comment = (Byte.index() < TmpBuf->Comments.size())
223  ? TmpBuf->Comments[Byte.index()].c_str()
224  : "";
225  OutBS.emitInt8(Byte.value(), Comment);
226  }
227  TmpBuf->Bytes.clear();
228  TmpBuf->Comments.clear();
229 }
230 
231 const DIType *DbgVariable::getType() const {
232  return getVariable()->getType();
233 }
234 
235 /// Get .debug_loc entry for the instruction range starting at MI.
237  const DIExpression *Expr = MI->getDebugExpression();
238  const bool IsVariadic = MI->isDebugValueList();
239  assert(MI->getNumOperands() >= 3);
240  SmallVector<DbgValueLocEntry, 4> DbgValueLocEntries;
241  for (const MachineOperand &Op : MI->debug_operands()) {
242  if (Op.isReg()) {
243  MachineLocation MLoc(Op.getReg(),
244  MI->isNonListDebugValue() && MI->isDebugOffsetImm());
245  DbgValueLocEntries.push_back(DbgValueLocEntry(MLoc));
246  } else if (Op.isTargetIndex()) {
247  DbgValueLocEntries.push_back(
248  DbgValueLocEntry(TargetIndexLocation(Op.getIndex(), Op.getOffset())));
249  } else if (Op.isImm())
250  DbgValueLocEntries.push_back(DbgValueLocEntry(Op.getImm()));
251  else if (Op.isFPImm())
252  DbgValueLocEntries.push_back(DbgValueLocEntry(Op.getFPImm()));
253  else if (Op.isCImm())
254  DbgValueLocEntries.push_back(DbgValueLocEntry(Op.getCImm()));
255  else
256  llvm_unreachable("Unexpected debug operand in DBG_VALUE* instruction!");
257  }
258  return DbgValueLoc(Expr, DbgValueLocEntries, IsVariadic);
259 }
260 
262  assert(FrameIndexExprs.empty() && "Already initialized?");
263  assert(!ValueLoc.get() && "Already initialized?");
264 
265  assert(getVariable() == DbgValue->getDebugVariable() && "Wrong variable");
266  assert(getInlinedAt() == DbgValue->getDebugLoc()->getInlinedAt() &&
267  "Wrong inlined-at");
268 
269  ValueLoc = std::make_unique<DbgValueLoc>(getDebugLocValue(DbgValue));
270  if (auto *E = DbgValue->getDebugExpression())
271  if (E->getNumElements())
272  FrameIndexExprs.push_back({0, E});
273 }
274 
276  if (FrameIndexExprs.size() == 1)
277  return FrameIndexExprs;
278 
279  assert(llvm::all_of(FrameIndexExprs,
280  [](const FrameIndexExpr &A) {
281  return A.Expr->isFragment();
282  }) &&
283  "multiple FI expressions without DW_OP_LLVM_fragment");
284  llvm::sort(FrameIndexExprs,
285  [](const FrameIndexExpr &A, const FrameIndexExpr &B) -> bool {
286  return A.Expr->getFragmentInfo()->OffsetInBits <
287  B.Expr->getFragmentInfo()->OffsetInBits;
288  });
289 
290  return FrameIndexExprs;
291 }
292 
294  assert(DebugLocListIndex == ~0U && !ValueLoc.get() && "not an MMI entry");
295  assert(V.DebugLocListIndex == ~0U && !V.ValueLoc.get() && "not an MMI entry");
296  assert(V.getVariable() == getVariable() && "conflicting variable");
297  assert(V.getInlinedAt() == getInlinedAt() && "conflicting inlined-at location");
298 
299  assert(!FrameIndexExprs.empty() && "Expected an MMI entry");
300  assert(!V.FrameIndexExprs.empty() && "Expected an MMI entry");
301 
302  // FIXME: This logic should not be necessary anymore, as we now have proper
303  // deduplication. However, without it, we currently run into the assertion
304  // below, which means that we are likely dealing with broken input, i.e. two
305  // non-fragment entries for the same variable at different frame indices.
306  if (FrameIndexExprs.size()) {
307  auto *Expr = FrameIndexExprs.back().Expr;
308  if (!Expr || !Expr->isFragment())
309  return;
310  }
311 
312  for (const auto &FIE : V.FrameIndexExprs)
313  // Ignore duplicate entries.
314  if (llvm::none_of(FrameIndexExprs, [&](const FrameIndexExpr &Other) {
315  return FIE.FI == Other.FI && FIE.Expr == Other.Expr;
316  }))
317  FrameIndexExprs.push_back(FIE);
318 
319  assert((FrameIndexExprs.size() == 1 ||
320  llvm::all_of(FrameIndexExprs,
321  [](FrameIndexExpr &FIE) {
322  return FIE.Expr && FIE.Expr->isFragment();
323  })) &&
324  "conflicting locations for variable");
325 }
326 
327 static AccelTableKind computeAccelTableKind(unsigned DwarfVersion,
328  bool GenerateTypeUnits,
329  DebuggerKind Tuning,
330  const Triple &TT) {
331  // Honor an explicit request.
333  return AccelTables;
334 
335  // Accelerator tables with type units are currently not supported.
336  if (GenerateTypeUnits)
337  return AccelTableKind::None;
338 
339  // Accelerator tables get emitted if targetting DWARF v5 or LLDB. DWARF v5
340  // always implies debug_names. For lower standard versions we use apple
341  // accelerator tables on apple platforms and debug_names elsewhere.
342  if (DwarfVersion >= 5)
343  return AccelTableKind::Dwarf;
344  if (Tuning == DebuggerKind::LLDB)
345  return TT.isOSBinFormatMachO() ? AccelTableKind::Apple
347  return AccelTableKind::None;
348 }
349 
351  : DebugHandlerBase(A), DebugLocs(A->OutStreamer->isVerboseAsm()),
352  InfoHolder(A, "info_string", DIEValueAllocator),
353  SkeletonHolder(A, "skel_string", DIEValueAllocator),
354  IsDarwin(A->TM.getTargetTriple().isOSDarwin()) {
355  const Triple &TT = Asm->TM.getTargetTriple();
356 
357  // Make sure we know our "debugger tuning". The target option takes
358  // precedence; fall back to triple-based defaults.
360  DebuggerTuning = Asm->TM.Options.DebuggerTuning;
361  else if (IsDarwin)
362  DebuggerTuning = DebuggerKind::LLDB;
363  else if (TT.isPS4CPU())
364  DebuggerTuning = DebuggerKind::SCE;
365  else if (TT.isOSAIX())
366  DebuggerTuning = DebuggerKind::DBX;
367  else
368  DebuggerTuning = DebuggerKind::GDB;
369 
370  if (DwarfInlinedStrings == Default)
371  UseInlineStrings = TT.isNVPTX() || tuneForDBX();
372  else
373  UseInlineStrings = DwarfInlinedStrings == Enable;
374 
375  UseLocSection = !TT.isNVPTX();
376 
377  HasAppleExtensionAttributes = tuneForLLDB();
378 
379  // Handle split DWARF.
380  HasSplitDwarf = !Asm->TM.Options.MCOptions.SplitDwarfFile.empty();
381 
382  // SCE defaults to linkage names only for abstract subprograms.
384  UseAllLinkageNames = !tuneForSCE();
385  else
386  UseAllLinkageNames = DwarfLinkageNames == AllLinkageNames;
387 
388  unsigned DwarfVersionNumber = Asm->TM.Options.MCOptions.DwarfVersion;
389  unsigned DwarfVersion = DwarfVersionNumber ? DwarfVersionNumber
390  : MMI->getModule()->getDwarfVersion();
391  // Use dwarf 4 by default if nothing is requested. For NVPTX, use dwarf 2.
392  DwarfVersion =
393  TT.isNVPTX() ? 2 : (DwarfVersion ? DwarfVersion : dwarf::DWARF_VERSION);
394 
395  bool Dwarf64 = DwarfVersion >= 3 && // DWARF64 was introduced in DWARFv3.
396  TT.isArch64Bit(); // DWARF64 requires 64-bit relocations.
397 
398  // Support DWARF64
399  // 1: For ELF when requested.
400  // 2: For XCOFF64: the AIX assembler will fill in debug section lengths
401  // according to the DWARF64 format for 64-bit assembly, so we must use
402  // DWARF64 in the compiler too for 64-bit mode.
403  Dwarf64 &=
405  TT.isOSBinFormatELF()) ||
406  TT.isOSBinFormatXCOFF();
407 
408  if (!Dwarf64 && TT.isArch64Bit() && TT.isOSBinFormatXCOFF())
409  report_fatal_error("XCOFF requires DWARF64 for 64-bit mode!");
410 
411  UseRangesSection = !NoDwarfRangesSection && !TT.isNVPTX();
412 
413  // Use sections as references. Force for NVPTX.
414  if (DwarfSectionsAsReferences == Default)
415  UseSectionsAsReferences = TT.isNVPTX();
416  else
417  UseSectionsAsReferences = DwarfSectionsAsReferences == Enable;
418 
419  // Don't generate type units for unsupported object file formats.
420  GenerateTypeUnits = (A->TM.getTargetTriple().isOSBinFormatELF() ||
421  A->TM.getTargetTriple().isOSBinFormatWasm()) &&
423 
424  TheAccelTableKind = computeAccelTableKind(
425  DwarfVersion, GenerateTypeUnits, DebuggerTuning, A->TM.getTargetTriple());
426 
427  // Work around a GDB bug. GDB doesn't support the standard opcode;
428  // SCE doesn't support GNU's; LLDB prefers the standard opcode, which
429  // is defined as of DWARF 3.
430  // See GDB bug 11616 - DW_OP_form_tls_address is unimplemented
431  // https://sourceware.org/bugzilla/show_bug.cgi?id=11616
432  UseGNUTLSOpcode = tuneForGDB() || DwarfVersion < 3;
433 
434  // GDB does not fully support the DWARF 4 representation for bitfields.
435  UseDWARF2Bitfields = (DwarfVersion < 4) || tuneForGDB();
436 
437  // The DWARF v5 string offsets table has - possibly shared - contributions
438  // from each compile and type unit each preceded by a header. The string
439  // offsets table used by the pre-DWARF v5 split-DWARF implementation uses
440  // a monolithic string offsets table without any header.
441  UseSegmentedStringOffsetsTable = DwarfVersion >= 5;
442 
443  // Emit call-site-param debug info for GDB and LLDB, if the target supports
444  // the debug entry values feature. It can also be enabled explicitly.
445  EmitDebugEntryValues = Asm->TM.Options.ShouldEmitDebugEntryValues();
446 
447  // It is unclear if the GCC .debug_macro extension is well-specified
448  // for split DWARF. For now, do not allow LLVM to emit it.
449  UseDebugMacroSection =
450  DwarfVersion >= 5 || (UseGNUDebugMacro && !useSplitDwarf());
451  if (DwarfOpConvert == Default)
452  EnableOpConvert = !((tuneForGDB() && useSplitDwarf()) || (tuneForLLDB() && !TT.isOSBinFormatMachO()));
453  else
454  EnableOpConvert = (DwarfOpConvert == Enable);
455 
456  // Split DWARF would benefit object size significantly by trading reductions
457  // in address pool usage for slightly increased range list encodings.
458  if (DwarfVersion >= 5) {
459  MinimizeAddr = MinimizeAddrInV5Option;
460  // FIXME: In the future, enable this by default for Split DWARF where the
461  // tradeoff is more pronounced due to being able to offload the range
462  // lists to the dwo file and shrink object files/reduce relocations there.
463  if (MinimizeAddr == MinimizeAddrInV5::Default)
464  MinimizeAddr = MinimizeAddrInV5::Disabled;
465  }
466 
467  Asm->OutStreamer->getContext().setDwarfVersion(DwarfVersion);
468  Asm->OutStreamer->getContext().setDwarfFormat(Dwarf64 ? dwarf::DWARF64
469  : dwarf::DWARF32);
470 }
471 
472 // Define out of line so we don't have to include DwarfUnit.h in DwarfDebug.h.
473 DwarfDebug::~DwarfDebug() = default;
474 
475 static bool isObjCClass(StringRef Name) {
476  return Name.startswith("+") || Name.startswith("-");
477 }
478 
480  if (!isObjCClass(Name))
481  return false;
482 
483  return Name.find(") ") != StringRef::npos;
484 }
485 
487  StringRef &Category) {
488  if (!hasObjCCategory(In)) {
489  Class = In.slice(In.find('[') + 1, In.find(' '));
490  Category = "";
491  return;
492  }
493 
494  Class = In.slice(In.find('[') + 1, In.find('('));
495  Category = In.slice(In.find('[') + 1, In.find(' '));
496 }
497 
499  return In.slice(In.find(' ') + 1, In.find(']'));
500 }
501 
502 // Add the various names to the Dwarf accelerator table names.
504  const DISubprogram *SP, DIE &Die) {
506  CU.getNameTableKind() == DICompileUnit::DebugNameTableKind::None)
507  return;
508 
509  if (!SP->isDefinition())
510  return;
511 
512  if (SP->getName() != "")
513  addAccelName(CU, SP->getName(), Die);
514 
515  // If the linkage name is different than the name, go ahead and output that as
516  // well into the name table. Only do that if we are going to actually emit
517  // that name.
518  if (SP->getLinkageName() != "" && SP->getName() != SP->getLinkageName() &&
519  (useAllLinkageNames() || InfoHolder.getAbstractSPDies().lookup(SP)))
520  addAccelName(CU, SP->getLinkageName(), Die);
521 
522  // If this is an Objective-C selector name add it to the ObjC accelerator
523  // too.
524  if (isObjCClass(SP->getName())) {
525  StringRef Class, Category;
526  getObjCClassCategory(SP->getName(), Class, Category);
527  addAccelObjC(CU, Class, Die);
528  if (Category != "")
529  addAccelObjC(CU, Category, Die);
530  // Also add the base method name to the name table.
532  }
533 }
534 
535 /// Check whether we should create a DIE for the given Scope, return true
536 /// if we don't create a DIE (the corresponding DIE is null).
538  if (Scope->isAbstractScope())
539  return false;
540 
541  // We don't create a DIE if there is no Range.
542  const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
543  if (Ranges.empty())
544  return true;
545 
546  if (Ranges.size() > 1)
547  return false;
548 
549  // We don't create a DIE if we have a single Range and the end label
550  // is null.
551  return !getLabelAfterInsn(Ranges.front().second);
552 }
553 
554 template <typename Func> static void forBothCUs(DwarfCompileUnit &CU, Func F) {
555  F(CU);
556  if (auto *SkelCU = CU.getSkeleton())
557  if (CU.getCUNode()->getSplitDebugInlining())
558  F(*SkelCU);
559 }
560 
563 }
564 
565 void DwarfDebug::constructAbstractSubprogramScopeDIE(DwarfCompileUnit &SrcCU,
566  LexicalScope *Scope) {
567  assert(Scope && Scope->getScopeNode());
568  assert(Scope->isAbstractScope());
569  assert(!Scope->getInlinedAt());
570 
571  auto *SP = cast<DISubprogram>(Scope->getScopeNode());
572 
573  // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
574  // was inlined from another compile unit.
575  if (useSplitDwarf() && !shareAcrossDWOCUs() && !SP->getUnit()->getSplitDebugInlining())
576  // Avoid building the original CU if it won't be used
578  else {
579  auto &CU = getOrCreateDwarfCompileUnit(SP->getUnit());
580  if (auto *SkelCU = CU.getSkeleton()) {
581  (shareAcrossDWOCUs() ? CU : SrcCU)
582  .constructAbstractSubprogramScopeDIE(Scope);
583  if (CU.getCUNode()->getSplitDebugInlining())
584  SkelCU->constructAbstractSubprogramScopeDIE(Scope);
585  } else
586  CU.constructAbstractSubprogramScopeDIE(Scope);
587  }
588 }
589 
590 /// Represents a parameter whose call site value can be described by applying a
591 /// debug expression to a register in the forwarded register worklist.
593  /// The described parameter register.
594  unsigned ParamReg;
595 
596  /// Debug expression that has been built up when walking through the
597  /// instruction chain that produces the parameter's value.
599 };
600 
601 /// Register worklist for finding call site values.
603 
604 /// Append the expression \p Addition to \p Original and return the result.
605 static const DIExpression *combineDIExpressions(const DIExpression *Original,
606  const DIExpression *Addition) {
607  std::vector<uint64_t> Elts = Addition->getElements().vec();
608  // Avoid multiple DW_OP_stack_values.
609  if (Original->isImplicit() && Addition->isImplicit())
610  erase_value(Elts, dwarf::DW_OP_stack_value);
611  const DIExpression *CombinedExpr =
612  (Elts.size() > 0) ? DIExpression::append(Original, Elts) : Original;
613  return CombinedExpr;
614 }
615 
616 /// Emit call site parameter entries that are described by the given value and
617 /// debug expression.
618 template <typename ValT>
619 static void finishCallSiteParams(ValT Val, const DIExpression *Expr,
620  ArrayRef<FwdRegParamInfo> DescribedParams,
621  ParamSet &Params) {
622  for (auto Param : DescribedParams) {
623  bool ShouldCombineExpressions = Expr && Param.Expr->getNumElements() > 0;
624 
625  // TODO: Entry value operations can currently not be combined with any
626  // other expressions, so we can't emit call site entries in those cases.
627  if (ShouldCombineExpressions && Expr->isEntryValue())
628  continue;
629 
630  // If a parameter's call site value is produced by a chain of
631  // instructions we may have already created an expression for the
632  // parameter when walking through the instructions. Append that to the
633  // base expression.
634  const DIExpression *CombinedExpr =
635  ShouldCombineExpressions ? combineDIExpressions(Expr, Param.Expr)
636  : Expr;
637  assert((!CombinedExpr || CombinedExpr->isValid()) &&
638  "Combined debug expression is invalid");
639 
640  DbgValueLoc DbgLocVal(CombinedExpr, DbgValueLocEntry(Val));
641  DbgCallSiteParam CSParm(Param.ParamReg, DbgLocVal);
642  Params.push_back(CSParm);
643  ++NumCSParams;
644  }
645 }
646 
647 /// Add \p Reg to the worklist, if it's not already present, and mark that the
648 /// given parameter registers' values can (potentially) be described using
649 /// that register and an debug expression.
650 static void addToFwdRegWorklist(FwdRegWorklist &Worklist, unsigned Reg,
651  const DIExpression *Expr,
652  ArrayRef<FwdRegParamInfo> ParamsToAdd) {
653  auto I = Worklist.insert({Reg, {}});
654  auto &ParamsForFwdReg = I.first->second;
655  for (auto Param : ParamsToAdd) {
656  assert(none_of(ParamsForFwdReg,
657  [Param](const FwdRegParamInfo &D) {
658  return D.ParamReg == Param.ParamReg;
659  }) &&
660  "Same parameter described twice by forwarding reg");
661 
662  // If a parameter's call site value is produced by a chain of
663  // instructions we may have already created an expression for the
664  // parameter when walking through the instructions. Append that to the
665  // new expression.
666  const DIExpression *CombinedExpr = combineDIExpressions(Expr, Param.Expr);
667  ParamsForFwdReg.push_back({Param.ParamReg, CombinedExpr});
668  }
669 }
670 
671 /// Interpret values loaded into registers by \p CurMI.
672 static void interpretValues(const MachineInstr *CurMI,
673  FwdRegWorklist &ForwardedRegWorklist,
674  ParamSet &Params) {
675 
676  const MachineFunction *MF = CurMI->getMF();
677  const DIExpression *EmptyExpr =
679  const auto &TRI = *MF->getSubtarget().getRegisterInfo();
680  const auto &TII = *MF->getSubtarget().getInstrInfo();
681  const auto &TLI = *MF->getSubtarget().getTargetLowering();
682 
683  // If an instruction defines more than one item in the worklist, we may run
684  // into situations where a worklist register's value is (potentially)
685  // described by the previous value of another register that is also defined
686  // by that instruction.
687  //
688  // This can for example occur in cases like this:
689  //
690  // $r1 = mov 123
691  // $r0, $r1 = mvrr $r1, 456
692  // call @foo, $r0, $r1
693  //
694  // When describing $r1's value for the mvrr instruction, we need to make sure
695  // that we don't finalize an entry value for $r0, as that is dependent on the
696  // previous value of $r1 (123 rather than 456).
697  //
698  // In order to not have to distinguish between those cases when finalizing
699  // entry values, we simply postpone adding new parameter registers to the
700  // worklist, by first keeping them in this temporary container until the
701  // instruction has been handled.
702  FwdRegWorklist TmpWorklistItems;
703 
704  // If the MI is an instruction defining one or more parameters' forwarding
705  // registers, add those defines.
706  auto getForwardingRegsDefinedByMI = [&](const MachineInstr &MI,
708  if (MI.isDebugInstr())
709  return;
710 
711  for (const MachineOperand &MO : MI.operands()) {
712  if (MO.isReg() && MO.isDef() &&
713  Register::isPhysicalRegister(MO.getReg())) {
714  for (auto &FwdReg : ForwardedRegWorklist)
715  if (TRI.regsOverlap(FwdReg.first, MO.getReg()))
716  Defs.insert(FwdReg.first);
717  }
718  }
719  };
720 
721  // Set of worklist registers that are defined by this instruction.
722  SmallSetVector<unsigned, 4> FwdRegDefs;
723 
724  getForwardingRegsDefinedByMI(*CurMI, FwdRegDefs);
725  if (FwdRegDefs.empty())
726  return;
727 
728  for (auto ParamFwdReg : FwdRegDefs) {
729  if (auto ParamValue = TII.describeLoadedValue(*CurMI, ParamFwdReg)) {
730  if (ParamValue->first.isImm()) {
731  int64_t Val = ParamValue->first.getImm();
732  finishCallSiteParams(Val, ParamValue->second,
733  ForwardedRegWorklist[ParamFwdReg], Params);
734  } else if (ParamValue->first.isReg()) {
735  Register RegLoc = ParamValue->first.getReg();
736  Register SP = TLI.getStackPointerRegisterToSaveRestore();
738  bool IsSPorFP = (RegLoc == SP) || (RegLoc == FP);
739  if (TRI.isCalleeSavedPhysReg(RegLoc, *MF) || IsSPorFP) {
740  MachineLocation MLoc(RegLoc, /*Indirect=*/IsSPorFP);
741  finishCallSiteParams(MLoc, ParamValue->second,
742  ForwardedRegWorklist[ParamFwdReg], Params);
743  } else {
744  // ParamFwdReg was described by the non-callee saved register
745  // RegLoc. Mark that the call site values for the parameters are
746  // dependent on that register instead of ParamFwdReg. Since RegLoc
747  // may be a register that will be handled in this iteration, we
748  // postpone adding the items to the worklist, and instead keep them
749  // in a temporary container.
750  addToFwdRegWorklist(TmpWorklistItems, RegLoc, ParamValue->second,
751  ForwardedRegWorklist[ParamFwdReg]);
752  }
753  }
754  }
755  }
756 
757  // Remove all registers that this instruction defines from the worklist.
758  for (auto ParamFwdReg : FwdRegDefs)
759  ForwardedRegWorklist.erase(ParamFwdReg);
760 
761  // Now that we are done handling this instruction, add items from the
762  // temporary worklist to the real one.
763  for (auto &New : TmpWorklistItems)
764  addToFwdRegWorklist(ForwardedRegWorklist, New.first, EmptyExpr, New.second);
765  TmpWorklistItems.clear();
766 }
767 
768 static bool interpretNextInstr(const MachineInstr *CurMI,
769  FwdRegWorklist &ForwardedRegWorklist,
770  ParamSet &Params) {
771  // Skip bundle headers.
772  if (CurMI->isBundle())
773  return true;
774 
775  // If the next instruction is a call we can not interpret parameter's
776  // forwarding registers or we finished the interpretation of all
777  // parameters.
778  if (CurMI->isCall())
779  return false;
780 
781  if (ForwardedRegWorklist.empty())
782  return false;
783 
784  // Avoid NOP description.
785  if (CurMI->getNumOperands() == 0)
786  return true;
787 
788  interpretValues(CurMI, ForwardedRegWorklist, Params);
789 
790  return true;
791 }
792 
793 /// Try to interpret values loaded into registers that forward parameters
794 /// for \p CallMI. Store parameters with interpreted value into \p Params.
795 static void collectCallSiteParameters(const MachineInstr *CallMI,
796  ParamSet &Params) {
797  const MachineFunction *MF = CallMI->getMF();
798  const auto &CalleesMap = MF->getCallSitesInfo();
799  auto CallFwdRegsInfo = CalleesMap.find(CallMI);
800 
801  // There is no information for the call instruction.
802  if (CallFwdRegsInfo == CalleesMap.end())
803  return;
804 
805  const MachineBasicBlock *MBB = CallMI->getParent();
806 
807  // Skip the call instruction.
808  auto I = std::next(CallMI->getReverseIterator());
809 
810  FwdRegWorklist ForwardedRegWorklist;
811 
812  const DIExpression *EmptyExpr =
814 
815  // Add all the forwarding registers into the ForwardedRegWorklist.
816  for (const auto &ArgReg : CallFwdRegsInfo->second) {
817  bool InsertedReg =
818  ForwardedRegWorklist.insert({ArgReg.Reg, {{ArgReg.Reg, EmptyExpr}}})
819  .second;
820  assert(InsertedReg && "Single register used to forward two arguments?");
821  (void)InsertedReg;
822  }
823 
824  // Do not emit CSInfo for undef forwarding registers.
825  for (auto &MO : CallMI->uses())
826  if (MO.isReg() && MO.isUndef())
827  ForwardedRegWorklist.erase(MO.getReg());
828 
829  // We erase, from the ForwardedRegWorklist, those forwarding registers for
830  // which we successfully describe a loaded value (by using
831  // the describeLoadedValue()). For those remaining arguments in the working
832  // list, for which we do not describe a loaded value by
833  // the describeLoadedValue(), we try to generate an entry value expression
834  // for their call site value description, if the call is within the entry MBB.
835  // TODO: Handle situations when call site parameter value can be described
836  // as the entry value within basic blocks other than the first one.
837  bool ShouldTryEmitEntryVals = MBB->getIterator() == MF->begin();
838 
839  // Search for a loading value in forwarding registers inside call delay slot.
840  if (CallMI->hasDelaySlot()) {
841  auto Suc = std::next(CallMI->getIterator());
842  // Only one-instruction delay slot is supported.
843  auto BundleEnd = llvm::getBundleEnd(CallMI->getIterator());
844  (void)BundleEnd;
845  assert(std::next(Suc) == BundleEnd &&
846  "More than one instruction in call delay slot");
847  // Try to interpret value loaded by instruction.
848  if (!interpretNextInstr(&*Suc, ForwardedRegWorklist, Params))
849  return;
850  }
851 
852  // Search for a loading value in forwarding registers.
853  for (; I != MBB->rend(); ++I) {
854  // Try to interpret values loaded by instruction.
855  if (!interpretNextInstr(&*I, ForwardedRegWorklist, Params))
856  return;
857  }
858 
859  // Emit the call site parameter's value as an entry value.
860  if (ShouldTryEmitEntryVals) {
861  // Create an expression where the register's entry value is used.
862  DIExpression *EntryExpr = DIExpression::get(
863  MF->getFunction().getContext(), {dwarf::DW_OP_LLVM_entry_value, 1});
864  for (auto &RegEntry : ForwardedRegWorklist) {
865  MachineLocation MLoc(RegEntry.first);
866  finishCallSiteParams(MLoc, EntryExpr, RegEntry.second, Params);
867  }
868  }
869 }
870 
871 void DwarfDebug::constructCallSiteEntryDIEs(const DISubprogram &SP,
872  DwarfCompileUnit &CU, DIE &ScopeDIE,
873  const MachineFunction &MF) {
874  // Add a call site-related attribute (DWARF5, Sec. 3.3.1.3). Do this only if
875  // the subprogram is required to have one.
876  if (!SP.areAllCallsDescribed() || !SP.isDefinition())
877  return;
878 
879  // Use DW_AT_call_all_calls to express that call site entries are present
880  // for both tail and non-tail calls. Don't use DW_AT_call_all_source_calls
881  // because one of its requirements is not met: call site entries for
882  // optimized-out calls are elided.
883  CU.addFlag(ScopeDIE, CU.getDwarf5OrGNUAttr(dwarf::DW_AT_call_all_calls));
884 
886  assert(TII && "TargetInstrInfo not found: cannot label tail calls");
887 
888  // Delay slot support check.
889  auto delaySlotSupported = [&](const MachineInstr &MI) {
890  if (!MI.isBundledWithSucc())
891  return false;
892  auto Suc = std::next(MI.getIterator());
893  auto CallInstrBundle = getBundleStart(MI.getIterator());
894  (void)CallInstrBundle;
895  auto DelaySlotBundle = getBundleStart(Suc);
896  (void)DelaySlotBundle;
897  // Ensure that label after call is following delay slot instruction.
898  // Ex. CALL_INSTRUCTION {
899  // DELAY_SLOT_INSTRUCTION }
900  // LABEL_AFTER_CALL
901  assert(getLabelAfterInsn(&*CallInstrBundle) ==
902  getLabelAfterInsn(&*DelaySlotBundle) &&
903  "Call and its successor instruction don't have same label after.");
904  return true;
905  };
906 
907  // Emit call site entries for each call or tail call in the function.
908  for (const MachineBasicBlock &MBB : MF) {
909  for (const MachineInstr &MI : MBB.instrs()) {
910  // Bundles with call in them will pass the isCall() test below but do not
911  // have callee operand information so skip them here. Iterator will
912  // eventually reach the call MI.
913  if (MI.isBundle())
914  continue;
915 
916  // Skip instructions which aren't calls. Both calls and tail-calling jump
917  // instructions (e.g TAILJMPd64) are classified correctly here.
918  if (!MI.isCandidateForCallSiteEntry())
919  continue;
920 
921  // Skip instructions marked as frame setup, as they are not interesting to
922  // the user.
923  if (MI.getFlag(MachineInstr::FrameSetup))
924  continue;
925 
926  // Check if delay slot support is enabled.
927  if (MI.hasDelaySlot() && !delaySlotSupported(*&MI))
928  return;
929 
930  // If this is a direct call, find the callee's subprogram.
931  // In the case of an indirect call find the register that holds
932  // the callee.
933  const MachineOperand &CalleeOp = TII->getCalleeOperand(MI);
934  if (!CalleeOp.isGlobal() &&
935  (!CalleeOp.isReg() ||
936  !Register::isPhysicalRegister(CalleeOp.getReg())))
937  continue;
938 
939  unsigned CallReg = 0;
940  const DISubprogram *CalleeSP = nullptr;
941  const Function *CalleeDecl = nullptr;
942  if (CalleeOp.isReg()) {
943  CallReg = CalleeOp.getReg();
944  if (!CallReg)
945  continue;
946  } else {
947  CalleeDecl = dyn_cast<Function>(CalleeOp.getGlobal());
948  if (!CalleeDecl || !CalleeDecl->getSubprogram())
949  continue;
950  CalleeSP = CalleeDecl->getSubprogram();
951  }
952 
953  // TODO: Omit call site entries for runtime calls (objc_msgSend, etc).
954 
955  bool IsTail = TII->isTailCall(MI);
956 
957  // If MI is in a bundle, the label was created after the bundle since
958  // EmitFunctionBody iterates over top-level MIs. Get that top-level MI
959  // to search for that label below.
960  const MachineInstr *TopLevelCallMI =
961  MI.isInsideBundle() ? &*getBundleStart(MI.getIterator()) : &MI;
962 
963  // For non-tail calls, the return PC is needed to disambiguate paths in
964  // the call graph which could lead to some target function. For tail
965  // calls, no return PC information is needed, unless tuning for GDB in
966  // DWARF4 mode in which case we fake a return PC for compatibility.
967  const MCSymbol *PCAddr =
968  (!IsTail || CU.useGNUAnalogForDwarf5Feature())
969  ? const_cast<MCSymbol *>(getLabelAfterInsn(TopLevelCallMI))
970  : nullptr;
971 
972  // For tail calls, it's necessary to record the address of the branch
973  // instruction so that the debugger can show where the tail call occurred.
974  const MCSymbol *CallAddr =
975  IsTail ? getLabelBeforeInsn(TopLevelCallMI) : nullptr;
976 
977  assert((IsTail || PCAddr) && "Non-tail call without return PC");
978 
979  LLVM_DEBUG(dbgs() << "CallSiteEntry: " << MF.getName() << " -> "
980  << (CalleeDecl ? CalleeDecl->getName()
981  : StringRef(MF.getSubtarget()
982  .getRegisterInfo()
983  ->getName(CallReg)))
984  << (IsTail ? " [IsTail]" : "") << "\n");
985 
986  DIE &CallSiteDIE = CU.constructCallSiteEntryDIE(
987  ScopeDIE, CalleeSP, IsTail, PCAddr, CallAddr, CallReg);
988 
989  // Optionally emit call-site-param debug info.
990  if (emitDebugEntryValues()) {
991  ParamSet Params;
992  // Try to interpret values of call site parameters.
993  collectCallSiteParameters(&MI, Params);
994  CU.constructCallSiteParmEntryDIEs(CallSiteDIE, Params);
995  }
996  }
997  }
998 }
999 
1000 void DwarfDebug::addGnuPubAttributes(DwarfCompileUnit &U, DIE &D) const {
1001  if (!U.hasDwarfPubSections())
1002  return;
1003 
1004  U.addFlag(D, dwarf::DW_AT_GNU_pubnames);
1005 }
1006 
1007 void DwarfDebug::finishUnitAttributes(const DICompileUnit *DIUnit,
1008  DwarfCompileUnit &NewCU) {
1009  DIE &Die = NewCU.getUnitDie();
1010  StringRef FN = DIUnit->getFilename();
1011 
1012  StringRef Producer = DIUnit->getProducer();
1013  StringRef Flags = DIUnit->getFlags();
1014  if (!Flags.empty() && !useAppleExtensionAttributes()) {
1015  std::string ProducerWithFlags = Producer.str() + " " + Flags.str();
1016  NewCU.addString(Die, dwarf::DW_AT_producer, ProducerWithFlags);
1017  } else
1018  NewCU.addString(Die, dwarf::DW_AT_producer, Producer);
1019 
1020  NewCU.addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
1021  DIUnit->getSourceLanguage());
1022  NewCU.addString(Die, dwarf::DW_AT_name, FN);
1023  StringRef SysRoot = DIUnit->getSysRoot();
1024  if (!SysRoot.empty())
1025  NewCU.addString(Die, dwarf::DW_AT_LLVM_sysroot, SysRoot);
1026  StringRef SDK = DIUnit->getSDK();
1027  if (!SDK.empty())
1028  NewCU.addString(Die, dwarf::DW_AT_APPLE_sdk, SDK);
1029 
1030  // Add DW_str_offsets_base to the unit DIE, except for split units.
1032  NewCU.addStringOffsetsStart();
1033 
1034  if (!useSplitDwarf()) {
1035  NewCU.initStmtList();
1036 
1037  // If we're using split dwarf the compilation dir is going to be in the
1038  // skeleton CU and so we don't need to duplicate it here.
1039  if (!CompilationDir.empty())
1040  NewCU.addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
1041  addGnuPubAttributes(NewCU, Die);
1042  }
1043 
1045  if (DIUnit->isOptimized())
1046  NewCU.addFlag(Die, dwarf::DW_AT_APPLE_optimized);
1047 
1048  StringRef Flags = DIUnit->getFlags();
1049  if (!Flags.empty())
1050  NewCU.addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
1051 
1052  if (unsigned RVer = DIUnit->getRuntimeVersion())
1053  NewCU.addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1054  dwarf::DW_FORM_data1, RVer);
1055  }
1056 
1057  if (DIUnit->getDWOId()) {
1058  // This CU is either a clang module DWO or a skeleton CU.
1059  NewCU.addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8,
1060  DIUnit->getDWOId());
1061  if (!DIUnit->getSplitDebugFilename().empty()) {
1062  // This is a prefabricated skeleton CU.
1063  dwarf::Attribute attrDWOName = getDwarfVersion() >= 5
1064  ? dwarf::DW_AT_dwo_name
1065  : dwarf::DW_AT_GNU_dwo_name;
1066  NewCU.addString(Die, attrDWOName, DIUnit->getSplitDebugFilename());
1067  }
1068  }
1069 }
1070 // Create new DwarfCompileUnit for the given metadata node with tag
1071 // DW_TAG_compile_unit.
1073 DwarfDebug::getOrCreateDwarfCompileUnit(const DICompileUnit *DIUnit) {
1074  if (auto *CU = CUMap.lookup(DIUnit))
1075  return *CU;
1076 
1077  CompilationDir = DIUnit->getDirectory();
1078 
1079  auto OwnedUnit = std::make_unique<DwarfCompileUnit>(
1080  InfoHolder.getUnits().size(), DIUnit, Asm, this, &InfoHolder);
1081  DwarfCompileUnit &NewCU = *OwnedUnit;
1082  InfoHolder.addUnit(std::move(OwnedUnit));
1083 
1084  for (auto *IE : DIUnit->getImportedEntities())
1085  NewCU.addImportedEntity(IE);
1086 
1087  // LTO with assembly output shares a single line table amongst multiple CUs.
1088  // To avoid the compilation directory being ambiguous, let the line table
1089  // explicitly describe the directory of all files, never relying on the
1090  // compilation directory.
1091  if (!Asm->OutStreamer->hasRawTextSupport() || SingleCU)
1092  Asm->OutStreamer->emitDwarfFile0Directive(
1093  CompilationDir, DIUnit->getFilename(), getMD5AsBytes(DIUnit->getFile()),
1094  DIUnit->getSource(), NewCU.getUniqueID());
1095 
1096  if (useSplitDwarf()) {
1097  NewCU.setSkeleton(constructSkeletonCU(NewCU));
1099  } else {
1100  finishUnitAttributes(DIUnit, NewCU);
1102  }
1103 
1104  CUMap.insert({DIUnit, &NewCU});
1105  CUDieMap.insert({&NewCU.getUnitDie(), &NewCU});
1106  return NewCU;
1107 }
1108 
1109 void DwarfDebug::constructAndAddImportedEntityDIE(DwarfCompileUnit &TheCU,
1110  const DIImportedEntity *N) {
1111  if (isa<DILocalScope>(N->getScope()))
1112  return;
1113  if (DIE *D = TheCU.getOrCreateContextDIE(N->getScope()))
1114  D->addChild(TheCU.constructImportedEntityDIE(N));
1115 }
1116 
1117 /// Sort and unique GVEs by comparing their fragment offset.
1120  llvm::sort(
1122  // Sort order: first null exprs, then exprs without fragment
1123  // info, then sort by fragment offset in bits.
1124  // FIXME: Come up with a more comprehensive comparator so
1125  // the sorting isn't non-deterministic, and so the following
1126  // std::unique call works correctly.
1127  if (!A.Expr || !B.Expr)
1128  return !!B.Expr;
1129  auto FragmentA = A.Expr->getFragmentInfo();
1130  auto FragmentB = B.Expr->getFragmentInfo();
1131  if (!FragmentA || !FragmentB)
1132  return !!FragmentB;
1133  return FragmentA->OffsetInBits < FragmentB->OffsetInBits;
1134  });
1135  GVEs.erase(std::unique(GVEs.begin(), GVEs.end(),
1138  return A.Expr == B.Expr;
1139  }),
1140  GVEs.end());
1141  return GVEs;
1142 }
1143 
1144 // Emit all Dwarf sections that should come prior to the content. Create
1145 // global DIEs and emit initial debug info sections. This is invoked by
1146 // the target AsmPrinter.
1149 
1150  if (!Asm || !MMI->hasDebugInfo())
1151  return;
1152 
1153  unsigned NumDebugCUs = std::distance(M->debug_compile_units_begin(),
1154  M->debug_compile_units_end());
1155  assert(NumDebugCUs > 0 && "Asm unexpectedly initialized");
1156  assert(MMI->hasDebugInfo() &&
1157  "DebugInfoAvailabilty unexpectedly not initialized");
1158  SingleCU = NumDebugCUs == 1;
1160  GVMap;
1161  for (const GlobalVariable &Global : M->globals()) {
1163  Global.getDebugInfo(GVs);
1164  for (auto *GVE : GVs)
1165  GVMap[GVE->getVariable()].push_back({&Global, GVE->getExpression()});
1166  }
1167 
1168  // Create the symbol that designates the start of the unit's contribution
1169  // to the string offsets table. In a split DWARF scenario, only the skeleton
1170  // unit has the DW_AT_str_offsets_base attribute (and hence needs the symbol).
1172  (useSplitDwarf() ? SkeletonHolder : InfoHolder)
1173  .setStringOffsetsStartSym(Asm->createTempSymbol("str_offsets_base"));
1174 
1175 
1176  // Create the symbols that designates the start of the DWARF v5 range list
1177  // and locations list tables. They are located past the table headers.
1178  if (getDwarfVersion() >= 5) {
1179  DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1180  Holder.setRnglistsTableBaseSym(
1181  Asm->createTempSymbol("rnglists_table_base"));
1182 
1183  if (useSplitDwarf())
1184  InfoHolder.setRnglistsTableBaseSym(
1185  Asm->createTempSymbol("rnglists_dwo_table_base"));
1186  }
1187 
1188  // Create the symbol that points to the first entry following the debug
1189  // address table (.debug_addr) header.
1190  AddrPool.setLabel(Asm->createTempSymbol("addr_table_base"));
1191  DebugLocs.setSym(Asm->createTempSymbol("loclists_table_base"));
1192 
1193  for (DICompileUnit *CUNode : M->debug_compile_units()) {
1194  // FIXME: Move local imported entities into a list attached to the
1195  // subprogram, then this search won't be needed and a
1196  // getImportedEntities().empty() test should go below with the rest.
1197  bool HasNonLocalImportedEntities = llvm::any_of(
1198  CUNode->getImportedEntities(), [](const DIImportedEntity *IE) {
1199  return !isa<DILocalScope>(IE->getScope());
1200  });
1201 
1202  if (!HasNonLocalImportedEntities && CUNode->getEnumTypes().empty() &&
1203  CUNode->getRetainedTypes().empty() &&
1204  CUNode->getGlobalVariables().empty() && CUNode->getMacros().empty())
1205  continue;
1206 
1207  DwarfCompileUnit &CU = getOrCreateDwarfCompileUnit(CUNode);
1208 
1209  // Global Variables.
1210  for (auto *GVE : CUNode->getGlobalVariables()) {
1211  // Don't bother adding DIGlobalVariableExpressions listed in the CU if we
1212  // already know about the variable and it isn't adding a constant
1213  // expression.
1214  auto &GVMapEntry = GVMap[GVE->getVariable()];
1215  auto *Expr = GVE->getExpression();
1216  if (!GVMapEntry.size() || (Expr && Expr->isConstant()))
1217  GVMapEntry.push_back({nullptr, Expr});
1218  }
1219 
1220  DenseSet<DIGlobalVariable *> Processed;
1221  for (auto *GVE : CUNode->getGlobalVariables()) {
1222  DIGlobalVariable *GV = GVE->getVariable();
1223  if (Processed.insert(GV).second)
1224  CU.getOrCreateGlobalVariableDIE(GV, sortGlobalExprs(GVMap[GV]));
1225  }
1226 
1227  for (auto *Ty : CUNode->getEnumTypes()) {
1228  // The enum types array by design contains pointers to
1229  // MDNodes rather than DIRefs. Unique them here.
1230  CU.getOrCreateTypeDIE(cast<DIType>(Ty));
1231  }
1232  for (auto *Ty : CUNode->getRetainedTypes()) {
1233  // The retained types array by design contains pointers to
1234  // MDNodes rather than DIRefs. Unique them here.
1235  if (DIType *RT = dyn_cast<DIType>(Ty))
1236  // There is no point in force-emitting a forward declaration.
1237  CU.getOrCreateTypeDIE(RT);
1238  }
1239  // Emit imported_modules last so that the relevant context is already
1240  // available.
1241  for (auto *IE : CUNode->getImportedEntities())
1242  constructAndAddImportedEntityDIE(CU, IE);
1243  }
1244 }
1245 
1246 void DwarfDebug::finishEntityDefinitions() {
1247  for (const auto &Entity : ConcreteEntities) {
1248  DIE *Die = Entity->getDIE();
1249  assert(Die);
1250  // FIXME: Consider the time-space tradeoff of just storing the unit pointer
1251  // in the ConcreteEntities list, rather than looking it up again here.
1252  // DIE::getUnit isn't simple - it walks parent pointers, etc.
1253  DwarfCompileUnit *Unit = CUDieMap.lookup(Die->getUnitDie());
1254  assert(Unit);
1255  Unit->finishEntityDefinition(Entity.get());
1256  }
1257 }
1258 
1259 void DwarfDebug::finishSubprogramDefinitions() {
1260  for (const DISubprogram *SP : ProcessedSPNodes) {
1261  assert(SP->getUnit()->getEmissionKind() != DICompileUnit::NoDebug);
1262  forBothCUs(
1263  getOrCreateDwarfCompileUnit(SP->getUnit()),
1264  [&](DwarfCompileUnit &CU) { CU.finishSubprogramDefinition(SP); });
1265  }
1266 }
1267 
1268 void DwarfDebug::finalizeModuleInfo() {
1270 
1271  finishSubprogramDefinitions();
1272 
1273  finishEntityDefinitions();
1274 
1275  // Include the DWO file name in the hash if there's more than one CU.
1276  // This handles ThinLTO's situation where imported CUs may very easily be
1277  // duplicate with the same CU partially imported into another ThinLTO unit.
1278  StringRef DWOName;
1279  if (CUMap.size() > 1)
1280  DWOName = Asm->TM.Options.MCOptions.SplitDwarfFile;
1281 
1282  // Handle anything that needs to be done on a per-unit basis after
1283  // all other generation.
1284  for (const auto &P : CUMap) {
1285  auto &TheCU = *P.second;
1286  if (TheCU.getCUNode()->isDebugDirectivesOnly())
1287  continue;
1288  // Emit DW_AT_containing_type attribute to connect types with their
1289  // vtable holding type.
1291 
1292  // Add CU specific attributes if we need to add any.
1293  // If we're splitting the dwarf out now that we've got the entire
1294  // CU then add the dwo id to it.
1295  auto *SkCU = TheCU.getSkeleton();
1296 
1297  bool HasSplitUnit = SkCU && !TheCU.getUnitDie().children().empty();
1298 
1299  if (HasSplitUnit) {
1300  dwarf::Attribute attrDWOName = getDwarfVersion() >= 5
1301  ? dwarf::DW_AT_dwo_name
1302  : dwarf::DW_AT_GNU_dwo_name;
1303  finishUnitAttributes(TheCU.getCUNode(), TheCU);
1304  TheCU.addString(TheCU.getUnitDie(), attrDWOName,
1306  SkCU->addString(SkCU->getUnitDie(), attrDWOName,
1308  // Emit a unique identifier for this CU.
1309  uint64_t ID =
1310  DIEHash(Asm, &TheCU).computeCUSignature(DWOName, TheCU.getUnitDie());
1311  if (getDwarfVersion() >= 5) {
1312  TheCU.setDWOId(ID);
1313  SkCU->setDWOId(ID);
1314  } else {
1315  TheCU.addUInt(TheCU.getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1316  dwarf::DW_FORM_data8, ID);
1317  SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1318  dwarf::DW_FORM_data8, ID);
1319  }
1320 
1321  if (getDwarfVersion() < 5 && !SkeletonHolder.getRangeLists().empty()) {
1322  const MCSymbol *Sym = TLOF.getDwarfRangesSection()->getBeginSymbol();
1323  SkCU->addSectionLabel(SkCU->getUnitDie(), dwarf::DW_AT_GNU_ranges_base,
1324  Sym, Sym);
1325  }
1326  } else if (SkCU) {
1327  finishUnitAttributes(SkCU->getCUNode(), *SkCU);
1328  }
1329 
1330  // If we have code split among multiple sections or non-contiguous
1331  // ranges of code then emit a DW_AT_ranges attribute on the unit that will
1332  // remain in the .o file, otherwise add a DW_AT_low_pc.
1333  // FIXME: We should use ranges allow reordering of code ala
1334  // .subsections_via_symbols in mach-o. This would mean turning on
1335  // ranges for all subprogram DIEs for mach-o.
1336  DwarfCompileUnit &U = SkCU ? *SkCU : TheCU;
1337 
1338  if (unsigned NumRanges = TheCU.getRanges().size()) {
1339  if (NumRanges > 1 && useRangesSection())
1340  // A DW_AT_low_pc attribute may also be specified in combination with
1341  // DW_AT_ranges to specify the default base address for use in
1342  // location lists (see Section 2.6.2) and range lists (see Section
1343  // 2.17.3).
1344  U.addUInt(U.getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
1345  else
1346  U.setBaseAddress(TheCU.getRanges().front().Begin);
1348  }
1349 
1350  // We don't keep track of which addresses are used in which CU so this
1351  // is a bit pessimistic under LTO.
1352  if ((HasSplitUnit || getDwarfVersion() >= 5) && !AddrPool.isEmpty())
1353  U.addAddrTableBase();
1354 
1355  if (getDwarfVersion() >= 5) {
1356  if (U.hasRangeLists())
1357  U.addRnglistsBase();
1358 
1359  if (!DebugLocs.getLists().empty()) {
1360  if (!useSplitDwarf())
1361  U.addSectionLabel(U.getUnitDie(), dwarf::DW_AT_loclists_base,
1362  DebugLocs.getSym(),
1364  }
1365  }
1366 
1367  auto *CUNode = cast<DICompileUnit>(P.first);
1368  // If compile Unit has macros, emit "DW_AT_macro_info/DW_AT_macros"
1369  // attribute.
1370  if (CUNode->getMacros()) {
1371  if (UseDebugMacroSection) {
1372  if (useSplitDwarf())
1373  TheCU.addSectionDelta(
1374  TheCU.getUnitDie(), dwarf::DW_AT_macros, U.getMacroLabelBegin(),
1376  else {
1377  dwarf::Attribute MacrosAttr = getDwarfVersion() >= 5
1378  ? dwarf::DW_AT_macros
1379  : dwarf::DW_AT_GNU_macros;
1380  U.addSectionLabel(U.getUnitDie(), MacrosAttr, U.getMacroLabelBegin(),
1382  }
1383  } else {
1384  if (useSplitDwarf())
1385  TheCU.addSectionDelta(
1386  TheCU.getUnitDie(), dwarf::DW_AT_macro_info,
1387  U.getMacroLabelBegin(),
1389  else
1390  U.addSectionLabel(U.getUnitDie(), dwarf::DW_AT_macro_info,
1391  U.getMacroLabelBegin(),
1393  }
1394  }
1395  }
1396 
1397  // Emit all frontend-produced Skeleton CUs, i.e., Clang modules.
1398  for (auto *CUNode : MMI->getModule()->debug_compile_units())
1399  if (CUNode->getDWOId())
1400  getOrCreateDwarfCompileUnit(CUNode);
1401 
1402  // Compute DIE offsets and sizes.
1403  InfoHolder.computeSizeAndOffsets();
1404  if (useSplitDwarf())
1405  SkeletonHolder.computeSizeAndOffsets();
1406 }
1407 
1408 // Emit all Dwarf sections that should come after the content.
1410  assert(CurFn == nullptr);
1411  assert(CurMI == nullptr);
1412 
1413  for (const auto &P : CUMap) {
1414  auto &CU = *P.second;
1415  CU.createBaseTypeDIEs();
1416  }
1417 
1418  // If we aren't actually generating debug info (check beginModule -
1419  // conditionalized on the presence of the llvm.dbg.cu metadata node)
1420  if (!Asm || !MMI->hasDebugInfo())
1421  return;
1422 
1423  // Finalize the debug info for the module.
1424  finalizeModuleInfo();
1425 
1426  if (useSplitDwarf())
1427  // Emit debug_loc.dwo/debug_loclists.dwo section.
1428  emitDebugLocDWO();
1429  else
1430  // Emit debug_loc/debug_loclists section.
1431  emitDebugLoc();
1432 
1433  // Corresponding abbreviations into a abbrev section.
1434  emitAbbreviations();
1435 
1436  // Emit all the DIEs into a debug info section.
1437  emitDebugInfo();
1438 
1439  // Emit info into a debug aranges section.
1441  emitDebugARanges();
1442 
1443  // Emit info into a debug ranges section.
1444  emitDebugRanges();
1445 
1446  if (useSplitDwarf())
1447  // Emit info into a debug macinfo.dwo section.
1448  emitDebugMacinfoDWO();
1449  else
1450  // Emit info into a debug macinfo/macro section.
1451  emitDebugMacinfo();
1452 
1453  emitDebugStr();
1454 
1455  if (useSplitDwarf()) {
1456  emitDebugStrDWO();
1457  emitDebugInfoDWO();
1458  emitDebugAbbrevDWO();
1459  emitDebugLineDWO();
1460  emitDebugRangesDWO();
1461  }
1462 
1463  emitDebugAddr();
1464 
1465  // Emit info into the dwarf accelerator table sections.
1466  switch (getAccelTableKind()) {
1467  case AccelTableKind::Apple:
1468  emitAccelNames();
1469  emitAccelObjC();
1470  emitAccelNamespaces();
1471  emitAccelTypes();
1472  break;
1473  case AccelTableKind::Dwarf:
1474  emitAccelDebugNames();
1475  break;
1476  case AccelTableKind::None:
1477  break;
1479  llvm_unreachable("Default should have already been resolved.");
1480  }
1481 
1482  // Emit the pubnames and pubtypes sections if requested.
1483  emitDebugPubSections();
1484 
1485  // clean up.
1486  // FIXME: AbstractVariables.clear();
1487 }
1488 
1489 void DwarfDebug::ensureAbstractEntityIsCreated(DwarfCompileUnit &CU,
1490  const DINode *Node,
1491  const MDNode *ScopeNode) {
1492  if (CU.getExistingAbstractEntity(Node))
1493  return;
1494 
1495  CU.createAbstractEntity(Node, LScopes.getOrCreateAbstractScope(
1496  cast<DILocalScope>(ScopeNode)));
1497 }
1498 
1499 void DwarfDebug::ensureAbstractEntityIsCreatedIfScoped(DwarfCompileUnit &CU,
1500  const DINode *Node, const MDNode *ScopeNode) {
1501  if (CU.getExistingAbstractEntity(Node))
1502  return;
1503 
1504  if (LexicalScope *Scope =
1505  LScopes.findAbstractScope(cast_or_null<DILocalScope>(ScopeNode)))
1506  CU.createAbstractEntity(Node, Scope);
1507 }
1508 
1509 // Collect variable information from side table maintained by MF.
1510 void DwarfDebug::collectVariableInfoFromMFTable(
1511  DwarfCompileUnit &TheCU, DenseSet<InlinedEntity> &Processed) {
1513  LLVM_DEBUG(dbgs() << "DwarfDebug: collecting variables from MF side table\n");
1514  for (const auto &VI : Asm->MF->getVariableDbgInfo()) {
1515  if (!VI.Var)
1516  continue;
1517  assert(VI.Var->isValidLocationForIntrinsic(VI.Loc) &&
1518  "Expected inlined-at fields to agree");
1519 
1520  InlinedEntity Var(VI.Var, VI.Loc->getInlinedAt());
1521  Processed.insert(Var);
1523 
1524  // If variable scope is not found then skip this variable.
1525  if (!Scope) {
1526  LLVM_DEBUG(dbgs() << "Dropping debug info for " << VI.Var->getName()
1527  << ", no variable scope found\n");
1528  continue;
1529  }
1530 
1531  ensureAbstractEntityIsCreatedIfScoped(TheCU, Var.first, Scope->getScopeNode());
1532  auto RegVar = std::make_unique<DbgVariable>(
1533  cast<DILocalVariable>(Var.first), Var.second);
1534  RegVar->initializeMMI(VI.Expr, VI.Slot);
1535  LLVM_DEBUG(dbgs() << "Created DbgVariable for " << VI.Var->getName()
1536  << "\n");
1537 
1538  if (DbgVariable *DbgVar = MFVars.lookup(Var))
1539  DbgVar->addMMIEntry(*RegVar);
1540  else if (InfoHolder.addScopeVariable(Scope, RegVar.get())) {
1541  MFVars.insert({Var, RegVar.get()});
1542  ConcreteEntities.push_back(std::move(RegVar));
1543  }
1544  }
1545 }
1546 
1547 /// Determine whether a *singular* DBG_VALUE is valid for the entirety of its
1548 /// enclosing lexical scope. The check ensures there are no other instructions
1549 /// in the same lexical scope preceding the DBG_VALUE and that its range is
1550 /// either open or otherwise rolls off the end of the scope.
1551 static bool validThroughout(LexicalScopes &LScopes,
1552  const MachineInstr *DbgValue,
1553  const MachineInstr *RangeEnd,
1554  const InstructionOrdering &Ordering) {
1555  assert(DbgValue->getDebugLoc() && "DBG_VALUE without a debug location");
1556  auto MBB = DbgValue->getParent();
1557  auto DL = DbgValue->getDebugLoc();
1558  auto *LScope = LScopes.findLexicalScope(DL);
1559  // Scope doesn't exist; this is a dead DBG_VALUE.
1560  if (!LScope)
1561  return false;
1562  auto &LSRange = LScope->getRanges();
1563  if (LSRange.size() == 0)
1564  return false;
1565 
1566  const MachineInstr *LScopeBegin = LSRange.front().first;
1567  // If the scope starts before the DBG_VALUE then we may have a negative
1568  // result. Otherwise the location is live coming into the scope and we
1569  // can skip the following checks.
1570  if (!Ordering.isBefore(DbgValue, LScopeBegin)) {
1571  // Exit if the lexical scope begins outside of the current block.
1572  if (LScopeBegin->getParent() != MBB)
1573  return false;
1574 
1576  for (++Pred; Pred != MBB->rend(); ++Pred) {
1577  if (Pred->getFlag(MachineInstr::FrameSetup))
1578  break;
1579  auto PredDL = Pred->getDebugLoc();
1580  if (!PredDL || Pred->isMetaInstruction())
1581  continue;
1582  // Check whether the instruction preceding the DBG_VALUE is in the same
1583  // (sub)scope as the DBG_VALUE.
1584  if (DL->getScope() == PredDL->getScope())
1585  return false;
1586  auto *PredScope = LScopes.findLexicalScope(PredDL);
1587  if (!PredScope || LScope->dominates(PredScope))
1588  return false;
1589  }
1590  }
1591 
1592  // If the range of the DBG_VALUE is open-ended, report success.
1593  if (!RangeEnd)
1594  return true;
1595 
1596  // Single, constant DBG_VALUEs in the prologue are promoted to be live
1597  // throughout the function. This is a hack, presumably for DWARF v2 and not
1598  // necessarily correct. It would be much better to use a dbg.declare instead
1599  // if we know the constant is live throughout the scope.
1600  if (MBB->pred_empty() &&
1601  all_of(DbgValue->debug_operands(),
1602  [](const MachineOperand &Op) { return Op.isImm(); }))
1603  return true;
1604 
1605  // Test if the location terminates before the end of the scope.
1606  const MachineInstr *LScopeEnd = LSRange.back().second;
1607  if (Ordering.isBefore(RangeEnd, LScopeEnd))
1608  return false;
1609 
1610  // There's a single location which starts at the scope start, and ends at or
1611  // after the scope end.
1612  return true;
1613 }
1614 
1615 /// Build the location list for all DBG_VALUEs in the function that
1616 /// describe the same variable. The resulting DebugLocEntries will have
1617 /// strict monotonically increasing begin addresses and will never
1618 /// overlap. If the resulting list has only one entry that is valid
1619 /// throughout variable's scope return true.
1620 //
1621 // See the definition of DbgValueHistoryMap::Entry for an explanation of the
1622 // different kinds of history map entries. One thing to be aware of is that if
1623 // a debug value is ended by another entry (rather than being valid until the
1624 // end of the function), that entry's instruction may or may not be included in
1625 // the range, depending on if the entry is a clobbering entry (it has an
1626 // instruction that clobbers one or more preceding locations), or if it is an
1627 // (overlapping) debug value entry. This distinction can be seen in the example
1628 // below. The first debug value is ended by the clobbering entry 2, and the
1629 // second and third debug values are ended by the overlapping debug value entry
1630 // 4.
1631 //
1632 // Input:
1633 //
1634 // History map entries [type, end index, mi]
1635 //
1636 // 0 | [DbgValue, 2, DBG_VALUE $reg0, [...] (fragment 0, 32)]
1637 // 1 | | [DbgValue, 4, DBG_VALUE $reg1, [...] (fragment 32, 32)]
1638 // 2 | | [Clobber, $reg0 = [...], -, -]
1639 // 3 | | [DbgValue, 4, DBG_VALUE 123, [...] (fragment 64, 32)]
1640 // 4 [DbgValue, ~0, DBG_VALUE @g, [...] (fragment 0, 96)]
1641 //
1642 // Output [start, end) [Value...]:
1643 //
1644 // [0-1) [(reg0, fragment 0, 32)]
1645 // [1-3) [(reg0, fragment 0, 32), (reg1, fragment 32, 32)]
1646 // [3-4) [(reg1, fragment 32, 32), (123, fragment 64, 32)]
1647 // [4-) [(@g, fragment 0, 96)]
1648 bool DwarfDebug::buildLocationList(SmallVectorImpl<DebugLocEntry> &DebugLoc,
1649  const DbgValueHistoryMap::Entries &Entries) {
1650  using OpenRange =
1651  std::pair<DbgValueHistoryMap::EntryIndex, DbgValueLoc>;
1652  SmallVector<OpenRange, 4> OpenRanges;
1653  bool isSafeForSingleLocation = true;
1654  const MachineInstr *StartDebugMI = nullptr;
1655  const MachineInstr *EndMI = nullptr;
1656 
1657  for (auto EB = Entries.begin(), EI = EB, EE = Entries.end(); EI != EE; ++EI) {
1658  const MachineInstr *Instr = EI->getInstr();
1659 
1660  // Remove all values that are no longer live.
1661  size_t Index = std::distance(EB, EI);
1662  erase_if(OpenRanges, [&](OpenRange &R) { return R.first <= Index; });
1663 
1664  // If we are dealing with a clobbering entry, this iteration will result in
1665  // a location list entry starting after the clobbering instruction.
1666  const MCSymbol *StartLabel =
1667  EI->isClobber() ? getLabelAfterInsn(Instr) : getLabelBeforeInsn(Instr);
1668  assert(StartLabel &&
1669  "Forgot label before/after instruction starting a range!");
1670 
1671  const MCSymbol *EndLabel;
1672  if (std::next(EI) == Entries.end()) {
1673  const MachineBasicBlock &EndMBB = Asm->MF->back();
1674  EndLabel = Asm->MBBSectionRanges[EndMBB.getSectionIDNum()].EndLabel;
1675  if (EI->isClobber())
1676  EndMI = EI->getInstr();
1677  }
1678  else if (std::next(EI)->isClobber())
1679  EndLabel = getLabelAfterInsn(std::next(EI)->getInstr());
1680  else
1681  EndLabel = getLabelBeforeInsn(std::next(EI)->getInstr());
1682  assert(EndLabel && "Forgot label after instruction ending a range!");
1683 
1684  if (EI->isDbgValue())
1685  LLVM_DEBUG(dbgs() << "DotDebugLoc: " << *Instr << "\n");
1686 
1687  // If this history map entry has a debug value, add that to the list of
1688  // open ranges and check if its location is valid for a single value
1689  // location.
1690  if (EI->isDbgValue()) {
1691  // Do not add undef debug values, as they are redundant information in
1692  // the location list entries. An undef debug results in an empty location
1693  // description. If there are any non-undef fragments then padding pieces
1694  // with empty location descriptions will automatically be inserted, and if
1695  // all fragments are undef then the whole location list entry is
1696  // redundant.
1697  if (!Instr->isUndefDebugValue()) {
1698  auto Value = getDebugLocValue(Instr);
1699  OpenRanges.emplace_back(EI->getEndIndex(), Value);
1700 
1701  // TODO: Add support for single value fragment locations.
1702  if (Instr->getDebugExpression()->isFragment())
1703  isSafeForSingleLocation = false;
1704 
1705  if (!StartDebugMI)
1706  StartDebugMI = Instr;
1707  } else {
1708  isSafeForSingleLocation = false;
1709  }
1710  }
1711 
1712  // Location list entries with empty location descriptions are redundant
1713  // information in DWARF, so do not emit those.
1714  if (OpenRanges.empty())
1715  continue;
1716 
1717  // Omit entries with empty ranges as they do not have any effect in DWARF.
1718  if (StartLabel == EndLabel) {
1719  LLVM_DEBUG(dbgs() << "Omitting location list entry with empty range.\n");
1720  continue;
1721  }
1722 
1724  for (auto &R : OpenRanges)
1725  Values.push_back(R.second);
1726 
1727  // With Basic block sections, it is posssible that the StartLabel and the
1728  // Instr are not in the same section. This happens when the StartLabel is
1729  // the function begin label and the dbg value appears in a basic block
1730  // that is not the entry. In this case, the range needs to be split to
1731  // span each individual section in the range from StartLabel to EndLabel.
1732  if (Asm->MF->hasBBSections() && StartLabel == Asm->getFunctionBegin() &&
1733  !Instr->getParent()->sameSection(&Asm->MF->front())) {
1734  const MCSymbol *BeginSectionLabel = StartLabel;
1735 
1736  for (const MachineBasicBlock &MBB : *Asm->MF) {
1737  if (MBB.isBeginSection() && &MBB != &Asm->MF->front())
1738  BeginSectionLabel = MBB.getSymbol();
1739 
1740  if (MBB.sameSection(Instr->getParent())) {
1741  DebugLoc.emplace_back(BeginSectionLabel, EndLabel, Values);
1742  break;
1743  }
1744  if (MBB.isEndSection())
1745  DebugLoc.emplace_back(BeginSectionLabel, MBB.getEndSymbol(), Values);
1746  }
1747  } else {
1748  DebugLoc.emplace_back(StartLabel, EndLabel, Values);
1749  }
1750 
1751  // Attempt to coalesce the ranges of two otherwise identical
1752  // DebugLocEntries.
1753  auto CurEntry = DebugLoc.rbegin();
1754  LLVM_DEBUG({
1755  dbgs() << CurEntry->getValues().size() << " Values:\n";
1756  for (auto &Value : CurEntry->getValues())
1757  Value.dump();
1758  dbgs() << "-----\n";
1759  });
1760 
1761  auto PrevEntry = std::next(CurEntry);
1762  if (PrevEntry != DebugLoc.rend() && PrevEntry->MergeRanges(*CurEntry))
1763  DebugLoc.pop_back();
1764  }
1765 
1766  if (!isSafeForSingleLocation ||
1767  !validThroughout(LScopes, StartDebugMI, EndMI, getInstOrdering()))
1768  return false;
1769 
1770  if (DebugLoc.size() == 1)
1771  return true;
1772 
1773  if (!Asm->MF->hasBBSections())
1774  return false;
1775 
1776  // Check here to see if loclist can be merged into a single range. If not,
1777  // we must keep the split loclists per section. This does exactly what
1778  // MergeRanges does without sections. We don't actually merge the ranges
1779  // as the split ranges must be kept intact if this cannot be collapsed
1780  // into a single range.
1781  const MachineBasicBlock *RangeMBB = nullptr;
1782  if (DebugLoc[0].getBeginSym() == Asm->getFunctionBegin())
1783  RangeMBB = &Asm->MF->front();
1784  else
1785  RangeMBB = Entries.begin()->getInstr()->getParent();
1786  auto *CurEntry = DebugLoc.begin();
1787  auto *NextEntry = std::next(CurEntry);
1788  while (NextEntry != DebugLoc.end()) {
1789  // Get the last machine basic block of this section.
1790  while (!RangeMBB->isEndSection())
1791  RangeMBB = RangeMBB->getNextNode();
1792  if (!RangeMBB->getNextNode())
1793  return false;
1794  // CurEntry should end the current section and NextEntry should start
1795  // the next section and the Values must match for these two ranges to be
1796  // merged.
1797  if (CurEntry->getEndSym() != RangeMBB->getEndSymbol() ||
1798  NextEntry->getBeginSym() != RangeMBB->getNextNode()->getSymbol() ||
1799  CurEntry->getValues() != NextEntry->getValues())
1800  return false;
1801  RangeMBB = RangeMBB->getNextNode();
1802  CurEntry = NextEntry;
1803  NextEntry = std::next(CurEntry);
1804  }
1805  return true;
1806 }
1807 
1808 DbgEntity *DwarfDebug::createConcreteEntity(DwarfCompileUnit &TheCU,
1810  const DINode *Node,
1811  const DILocation *Location,
1812  const MCSymbol *Sym) {
1813  ensureAbstractEntityIsCreatedIfScoped(TheCU, Node, Scope.getScopeNode());
1814  if (isa<const DILocalVariable>(Node)) {
1815  ConcreteEntities.push_back(
1816  std::make_unique<DbgVariable>(cast<const DILocalVariable>(Node),
1817  Location));
1818  InfoHolder.addScopeVariable(&Scope,
1819  cast<DbgVariable>(ConcreteEntities.back().get()));
1820  } else if (isa<const DILabel>(Node)) {
1821  ConcreteEntities.push_back(
1822  std::make_unique<DbgLabel>(cast<const DILabel>(Node),
1823  Location, Sym));
1824  InfoHolder.addScopeLabel(&Scope,
1825  cast<DbgLabel>(ConcreteEntities.back().get()));
1826  }
1827  return ConcreteEntities.back().get();
1828 }
1829 
1830 // Find variables for each lexical scope.
1831 void DwarfDebug::collectEntityInfo(DwarfCompileUnit &TheCU,
1832  const DISubprogram *SP,
1833  DenseSet<InlinedEntity> &Processed) {
1834  // Grab the variable info that was squirreled away in the MMI side-table.
1835  collectVariableInfoFromMFTable(TheCU, Processed);
1836 
1837  for (const auto &I : DbgValues) {
1838  InlinedEntity IV = I.first;
1839  if (Processed.count(IV))
1840  continue;
1841 
1842  // Instruction ranges, specifying where IV is accessible.
1843  const auto &HistoryMapEntries = I.second;
1844 
1845  // Try to find any non-empty variable location. Do not create a concrete
1846  // entity if there are no locations.
1847  if (!DbgValues.hasNonEmptyLocation(HistoryMapEntries))
1848  continue;
1849 
1850  LexicalScope *Scope = nullptr;
1851  const DILocalVariable *LocalVar = cast<DILocalVariable>(IV.first);
1852  if (const DILocation *IA = IV.second)
1853  Scope = LScopes.findInlinedScope(LocalVar->getScope(), IA);
1854  else
1855  Scope = LScopes.findLexicalScope(LocalVar->getScope());
1856  // If variable scope is not found then skip this variable.
1857  if (!Scope)
1858  continue;
1859 
1860  Processed.insert(IV);
1861  DbgVariable *RegVar = cast<DbgVariable>(createConcreteEntity(TheCU,
1862  *Scope, LocalVar, IV.second));
1863 
1864  const MachineInstr *MInsn = HistoryMapEntries.front().getInstr();
1865  assert(MInsn->isDebugValue() && "History must begin with debug value");
1866 
1867  // Check if there is a single DBG_VALUE, valid throughout the var's scope.
1868  // If the history map contains a single debug value, there may be an
1869  // additional entry which clobbers the debug value.
1870  size_t HistSize = HistoryMapEntries.size();
1871  bool SingleValueWithClobber =
1872  HistSize == 2 && HistoryMapEntries[1].isClobber();
1873  if (HistSize == 1 || SingleValueWithClobber) {
1874  const auto *End =
1875  SingleValueWithClobber ? HistoryMapEntries[1].getInstr() : nullptr;
1876  if (validThroughout(LScopes, MInsn, End, getInstOrdering())) {
1877  RegVar->initializeDbgValue(MInsn);
1878  continue;
1879  }
1880  }
1881 
1882  // Do not emit location lists if .debug_loc secton is disabled.
1883  if (!useLocSection())
1884  continue;
1885 
1886  // Handle multiple DBG_VALUE instructions describing one variable.
1887  DebugLocStream::ListBuilder List(DebugLocs, TheCU, *Asm, *RegVar, *MInsn);
1888 
1889  // Build the location list for this variable.
1891  bool isValidSingleLocation = buildLocationList(Entries, HistoryMapEntries);
1892 
1893  // Check whether buildLocationList managed to merge all locations to one
1894  // that is valid throughout the variable's scope. If so, produce single
1895  // value location.
1896  if (isValidSingleLocation) {
1897  RegVar->initializeDbgValue(Entries[0].getValues()[0]);
1898  continue;
1899  }
1900 
1901  // If the variable has a DIBasicType, extract it. Basic types cannot have
1902  // unique identifiers, so don't bother resolving the type with the
1903  // identifier map.
1904  const DIBasicType *BT = dyn_cast<DIBasicType>(
1905  static_cast<const Metadata *>(LocalVar->getType()));
1906 
1907  // Finalize the entry by lowering it into a DWARF bytestream.
1908  for (auto &Entry : Entries)
1909  Entry.finalize(*Asm, List, BT, TheCU);
1910  }
1911 
1912  // For each InlinedEntity collected from DBG_LABEL instructions, convert to
1913  // DWARF-related DbgLabel.
1914  for (const auto &I : DbgLabels) {
1915  InlinedEntity IL = I.first;
1916  const MachineInstr *MI = I.second;
1917  if (MI == nullptr)
1918  continue;
1919 
1920  LexicalScope *Scope = nullptr;
1921  const DILabel *Label = cast<DILabel>(IL.first);
1922  // The scope could have an extra lexical block file.
1923  const DILocalScope *LocalScope =
1924  Label->getScope()->getNonLexicalBlockFileScope();
1925  // Get inlined DILocation if it is inlined label.
1926  if (const DILocation *IA = IL.second)
1927  Scope = LScopes.findInlinedScope(LocalScope, IA);
1928  else
1929  Scope = LScopes.findLexicalScope(LocalScope);
1930  // If label scope is not found then skip this label.
1931  if (!Scope)
1932  continue;
1933 
1934  Processed.insert(IL);
1935  /// At this point, the temporary label is created.
1936  /// Save the temporary label to DbgLabel entity to get the
1937  /// actually address when generating Dwarf DIE.
1938  MCSymbol *Sym = getLabelBeforeInsn(MI);
1939  createConcreteEntity(TheCU, *Scope, Label, IL.second, Sym);
1940  }
1941 
1942  // Collect info for variables/labels that were optimized out.
1943  for (const DINode *DN : SP->getRetainedNodes()) {
1944  if (!Processed.insert(InlinedEntity(DN, nullptr)).second)
1945  continue;
1946  LexicalScope *Scope = nullptr;
1947  if (auto *DV = dyn_cast<DILocalVariable>(DN)) {
1948  Scope = LScopes.findLexicalScope(DV->getScope());
1949  } else if (auto *DL = dyn_cast<DILabel>(DN)) {
1950  Scope = LScopes.findLexicalScope(DL->getScope());
1951  }
1952 
1953  if (Scope)
1954  createConcreteEntity(TheCU, *Scope, DN, nullptr);
1955  }
1956 }
1957 
1958 // Process beginning of an instruction.
1960  const MachineFunction &MF = *MI->getMF();
1961  const auto *SP = MF.getFunction().getSubprogram();
1962  bool NoDebug =
1963  !SP || SP->getUnit()->getEmissionKind() == DICompileUnit::NoDebug;
1964 
1965  // Delay slot support check.
1966  auto delaySlotSupported = [](const MachineInstr &MI) {
1967  if (!MI.isBundledWithSucc())
1968  return false;
1969  auto Suc = std::next(MI.getIterator());
1970  (void)Suc;
1971  // Ensure that delay slot instruction is successor of the call instruction.
1972  // Ex. CALL_INSTRUCTION {
1973  // DELAY_SLOT_INSTRUCTION }
1974  assert(Suc->isBundledWithPred() &&
1975  "Call bundle instructions are out of order");
1976  return true;
1977  };
1978 
1979  // When describing calls, we need a label for the call instruction.
1980  if (!NoDebug && SP->areAllCallsDescribed() &&
1981  MI->isCandidateForCallSiteEntry(MachineInstr::AnyInBundle) &&
1982  (!MI->hasDelaySlot() || delaySlotSupported(*MI))) {
1983  const TargetInstrInfo *TII = MF.getSubtarget().getInstrInfo();
1984  bool IsTail = TII->isTailCall(*MI);
1985  // For tail calls, we need the address of the branch instruction for
1986  // DW_AT_call_pc.
1987  if (IsTail)
1989  // For non-tail calls, we need the return address for the call for
1990  // DW_AT_call_return_pc. Under GDB tuning, this information is needed for
1991  // tail calls as well.
1993  }
1994 
1996  if (!CurMI)
1997  return;
1998 
1999  if (NoDebug)
2000  return;
2001 
2002  // Check if source location changes, but ignore DBG_VALUE and CFI locations.
2003  // If the instruction is part of the function frame setup code, do not emit
2004  // any line record, as there is no correspondence with any user code.
2005  if (MI->isMetaInstruction() || MI->getFlag(MachineInstr::FrameSetup))
2006  return;
2007  const DebugLoc &DL = MI->getDebugLoc();
2008  // When we emit a line-0 record, we don't update PrevInstLoc; so look at
2009  // the last line number actually emitted, to see if it was line 0.
2010  unsigned LastAsmLine =
2011  Asm->OutStreamer->getContext().getCurrentDwarfLoc().getLine();
2012 
2013  if (DL == PrevInstLoc) {
2014  // If we have an ongoing unspecified location, nothing to do here.
2015  if (!DL)
2016  return;
2017  // We have an explicit location, same as the previous location.
2018  // But we might be coming back to it after a line 0 record.
2019  if (LastAsmLine == 0 && DL.getLine() != 0) {
2020  // Reinstate the source location but not marked as a statement.
2021  const MDNode *Scope = DL.getScope();
2022  recordSourceLine(DL.getLine(), DL.getCol(), Scope, /*Flags=*/0);
2023  }
2024  return;
2025  }
2026 
2027  if (!DL) {
2028  // We have an unspecified location, which might want to be line 0.
2029  // If we have already emitted a line-0 record, don't repeat it.
2030  if (LastAsmLine == 0)
2031  return;
2032  // If user said Don't Do That, don't do that.
2033  if (UnknownLocations == Disable)
2034  return;
2035  // See if we have a reason to emit a line-0 record now.
2036  // Reasons to emit a line-0 record include:
2037  // - User asked for it (UnknownLocations).
2038  // - Instruction has a label, so it's referenced from somewhere else,
2039  // possibly debug information; we want it to have a source location.
2040  // - Instruction is at the top of a block; we don't want to inherit the
2041  // location from the physically previous (maybe unrelated) block.
2042  if (UnknownLocations == Enable || PrevLabel ||
2043  (PrevInstBB && PrevInstBB != MI->getParent())) {
2044  // Preserve the file and column numbers, if we can, to save space in
2045  // the encoded line table.
2046  // Do not update PrevInstLoc, it remembers the last non-0 line.
2047  const MDNode *Scope = nullptr;
2048  unsigned Column = 0;
2049  if (PrevInstLoc) {
2051  Column = PrevInstLoc.getCol();
2052  }
2053  recordSourceLine(/*Line=*/0, Column, Scope, /*Flags=*/0);
2054  }
2055  return;
2056  }
2057 
2058  // We have an explicit location, different from the previous location.
2059  // Don't repeat a line-0 record, but otherwise emit the new location.
2060  // (The new location might be an explicit line 0, which we do emit.)
2061  if (DL.getLine() == 0 && LastAsmLine == 0)
2062  return;
2063  unsigned Flags = 0;
2064  if (DL == PrologEndLoc) {
2066  PrologEndLoc = DebugLoc();
2067  }
2068  // If the line changed, we call that a new statement; unless we went to
2069  // line 0 and came back, in which case it is not a new statement.
2070  unsigned OldLine = PrevInstLoc ? PrevInstLoc.getLine() : LastAsmLine;
2071  if (DL.getLine() && DL.getLine() != OldLine)
2072  Flags |= DWARF2_FLAG_IS_STMT;
2073 
2074  const MDNode *Scope = DL.getScope();
2075  recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
2076 
2077  // If we're not at line 0, remember this location.
2078  if (DL.getLine())
2079  PrevInstLoc = DL;
2080 }
2081 
2083  // First known non-DBG_VALUE and non-frame setup location marks
2084  // the beginning of the function body.
2085  DebugLoc LineZeroLoc;
2086  for (const auto &MBB : *MF) {
2087  for (const auto &MI : MBB) {
2088  if (!MI.isMetaInstruction() && !MI.getFlag(MachineInstr::FrameSetup) &&
2089  MI.getDebugLoc()) {
2090  // Scan forward to try to find a non-zero line number. The prologue_end
2091  // marks the first breakpoint in the function after the frame setup, and
2092  // a compiler-generated line 0 location is not a meaningful breakpoint.
2093  // If none is found, return the first location after the frame setup.
2094  if (MI.getDebugLoc().getLine())
2095  return MI.getDebugLoc();
2096  LineZeroLoc = MI.getDebugLoc();
2097  }
2098  }
2099  }
2100  return LineZeroLoc;
2101 }
2102 
2103 /// Register a source line with debug info. Returns the unique label that was
2104 /// emitted and which provides correspondence to the source line list.
2105 static void recordSourceLine(AsmPrinter &Asm, unsigned Line, unsigned Col,
2106  const MDNode *S, unsigned Flags, unsigned CUID,
2107  uint16_t DwarfVersion,
2108  ArrayRef<std::unique_ptr<DwarfCompileUnit>> DCUs) {
2109  StringRef Fn;
2110  unsigned FileNo = 1;
2111  unsigned Discriminator = 0;
2112  if (auto *Scope = cast_or_null<DIScope>(S)) {
2113  Fn = Scope->getFilename();
2114  if (Line != 0 && DwarfVersion >= 4)
2115  if (auto *LBF = dyn_cast<DILexicalBlockFile>(Scope))
2116  Discriminator = LBF->getDiscriminator();
2117 
2118  FileNo = static_cast<DwarfCompileUnit &>(*DCUs[CUID])
2119  .getOrCreateSourceID(Scope->getFile());
2120  }
2121  Asm.OutStreamer->emitDwarfLocDirective(FileNo, Line, Col, Flags, 0,
2122  Discriminator, Fn);
2123 }
2124 
2126  unsigned CUID) {
2127  // Get beginning of function.
2129  // Ensure the compile unit is created if the function is called before
2130  // beginFunction().
2131  (void)getOrCreateDwarfCompileUnit(
2132  MF.getFunction().getSubprogram()->getUnit());
2133  // We'd like to list the prologue as "not statements" but GDB behaves
2134  // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
2135  const DISubprogram *SP = PrologEndLoc->getInlinedAtScope()->getSubprogram();
2136  ::recordSourceLine(*Asm, SP->getScopeLine(), 0, SP, DWARF2_FLAG_IS_STMT,
2137  CUID, getDwarfVersion(), getUnits());
2138  return PrologEndLoc;
2139  }
2140  return DebugLoc();
2141 }
2142 
2143 // Gather pre-function debug information. Assumes being called immediately
2144 // after the function entry point has been emitted.
2146  CurFn = MF;
2147 
2148  auto *SP = MF->getFunction().getSubprogram();
2150  if (SP->getUnit()->getEmissionKind() == DICompileUnit::NoDebug)
2151  return;
2152 
2153  DwarfCompileUnit &CU = getOrCreateDwarfCompileUnit(SP->getUnit());
2154 
2155  Asm->OutStreamer->getContext().setDwarfCompileUnitID(
2157 
2158  // Record beginning of function.
2160  *MF, Asm->OutStreamer->getContext().getDwarfCompileUnitID());
2161 }
2162 
2163 unsigned
2165  // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
2166  // belongs to so that we add to the correct per-cu line table in the
2167  // non-asm case.
2168  if (Asm->OutStreamer->hasRawTextSupport())
2169  // Use a single line table if we are generating assembly.
2170  return 0;
2171  else
2172  return CU.getUniqueID();
2173 }
2174 
2176  // If we don't have a subprogram for this function then there will be a hole
2177  // in the range information. Keep note of this by setting the previously used
2178  // section to nullptr.
2179  PrevCU = nullptr;
2180  CurFn = nullptr;
2181 }
2182 
2183 // Gather and emit post-function debug information.
2185  const DISubprogram *SP = MF->getFunction().getSubprogram();
2186 
2187  assert(CurFn == MF &&
2188  "endFunction should be called with the same function as beginFunction");
2189 
2190  // Set DwarfDwarfCompileUnitID in MCContext to default value.
2191  Asm->OutStreamer->getContext().setDwarfCompileUnitID(0);
2192 
2194  assert(!FnScope || SP == FnScope->getScopeNode());
2195  DwarfCompileUnit &TheCU = *CUMap.lookup(SP->getUnit());
2196  if (TheCU.getCUNode()->isDebugDirectivesOnly()) {
2197  PrevLabel = nullptr;
2198  CurFn = nullptr;
2199  return;
2200  }
2201 
2202  DenseSet<InlinedEntity> Processed;
2203  collectEntityInfo(TheCU, SP, Processed);
2204 
2205  // Add the range of this function to the list of ranges for the CU.
2206  // With basic block sections, add ranges for all basic block sections.
2207  for (const auto &R : Asm->MBBSectionRanges)
2208  TheCU.addRange({R.second.BeginLabel, R.second.EndLabel});
2209 
2210  // Under -gmlt, skip building the subprogram if there are no inlined
2211  // subroutines inside it. But with -fdebug-info-for-profiling, the subprogram
2212  // is still needed as we need its source location.
2213  if (!TheCU.getCUNode()->getDebugInfoForProfiling() &&
2215  LScopes.getAbstractScopesList().empty() && !IsDarwin) {
2216  assert(InfoHolder.getScopeVariables().empty());
2217  PrevLabel = nullptr;
2218  CurFn = nullptr;
2219  return;
2220  }
2221 
2222 #ifndef NDEBUG
2223  size_t NumAbstractScopes = LScopes.getAbstractScopesList().size();
2224 #endif
2225  // Construct abstract scopes.
2226  for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
2227  auto *SP = cast<DISubprogram>(AScope->getScopeNode());
2228  for (const DINode *DN : SP->getRetainedNodes()) {
2229  if (!Processed.insert(InlinedEntity(DN, nullptr)).second)
2230  continue;
2231 
2232  const MDNode *Scope = nullptr;
2233  if (auto *DV = dyn_cast<DILocalVariable>(DN))
2234  Scope = DV->getScope();
2235  else if (auto *DL = dyn_cast<DILabel>(DN))
2236  Scope = DL->getScope();
2237  else
2238  llvm_unreachable("Unexpected DI type!");
2239 
2240  // Collect info for variables/labels that were optimized out.
2241  ensureAbstractEntityIsCreated(TheCU, DN, Scope);
2242  assert(LScopes.getAbstractScopesList().size() == NumAbstractScopes
2243  && "ensureAbstractEntityIsCreated inserted abstract scopes");
2244  }
2245  constructAbstractSubprogramScopeDIE(TheCU, AScope);
2246  }
2247 
2248  ProcessedSPNodes.insert(SP);
2249  DIE &ScopeDIE = TheCU.constructSubprogramScopeDIE(SP, FnScope);
2250  if (auto *SkelCU = TheCU.getSkeleton())
2251  if (!LScopes.getAbstractScopesList().empty() &&
2252  TheCU.getCUNode()->getSplitDebugInlining())
2253  SkelCU->constructSubprogramScopeDIE(SP, FnScope);
2254 
2255  // Construct call site entries.
2256  constructCallSiteEntryDIEs(*SP, TheCU, ScopeDIE, *MF);
2257 
2258  // Clear debug info
2259  // Ownership of DbgVariables is a bit subtle - ScopeVariables owns all the
2260  // DbgVariables except those that are also in AbstractVariables (since they
2261  // can be used cross-function)
2262  InfoHolder.getScopeVariables().clear();
2263  InfoHolder.getScopeLabels().clear();
2264  PrevLabel = nullptr;
2265  CurFn = nullptr;
2266 }
2267 
2268 // Register a source line with debug info. Returns the unique label that was
2269 // emitted and which provides correspondence to the source line list.
2270 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
2271  unsigned Flags) {
2272  ::recordSourceLine(*Asm, Line, Col, S, Flags,
2273  Asm->OutStreamer->getContext().getDwarfCompileUnitID(),
2274  getDwarfVersion(), getUnits());
2275 }
2276 
2277 //===----------------------------------------------------------------------===//
2278 // Emit Methods
2279 //===----------------------------------------------------------------------===//
2280 
2281 // Emit the debug info section.
2282 void DwarfDebug::emitDebugInfo() {
2283  DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2284  Holder.emitUnits(/* UseOffsets */ false);
2285 }
2286 
2287 // Emit the abbreviation section.
2288 void DwarfDebug::emitAbbreviations() {
2289  DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2290 
2292 }
2293 
2294 void DwarfDebug::emitStringOffsetsTableHeader() {
2295  DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2298  Holder.getStringOffsetsStartSym());
2299 }
2300 
2301 template <typename AccelTableT>
2302 void DwarfDebug::emitAccel(AccelTableT &Accel, MCSection *Section,
2303  StringRef TableName) {
2304  Asm->OutStreamer->SwitchSection(Section);
2305 
2306  // Emit the full data.
2307  emitAppleAccelTable(Asm, Accel, TableName, Section->getBeginSymbol());
2308 }
2309 
2310 void DwarfDebug::emitAccelDebugNames() {
2311  // Don't emit anything if we have no compilation units to index.
2312  if (getUnits().empty())
2313  return;
2314 
2315  emitDWARF5AccelTable(Asm, AccelDebugNames, *this, getUnits());
2316 }
2317 
2318 // Emit visible names into a hashed accelerator table section.
2319 void DwarfDebug::emitAccelNames() {
2320  emitAccel(AccelNames, Asm->getObjFileLowering().getDwarfAccelNamesSection(),
2321  "Names");
2322 }
2323 
2324 // Emit objective C classes and categories into a hashed accelerator table
2325 // section.
2326 void DwarfDebug::emitAccelObjC() {
2327  emitAccel(AccelObjC, Asm->getObjFileLowering().getDwarfAccelObjCSection(),
2328  "ObjC");
2329 }
2330 
2331 // Emit namespace dies into a hashed accelerator table.
2332 void DwarfDebug::emitAccelNamespaces() {
2333  emitAccel(AccelNamespace,
2335  "namespac");
2336 }
2337 
2338 // Emit type dies into a hashed accelerator table.
2339 void DwarfDebug::emitAccelTypes() {
2340  emitAccel(AccelTypes, Asm->getObjFileLowering().getDwarfAccelTypesSection(),
2341  "types");
2342 }
2343 
2344 // Public name handling.
2345 // The format for the various pubnames:
2346 //
2347 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2348 // for the DIE that is named.
2349 //
2350 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2351 // into the CU and the index value is computed according to the type of value
2352 // for the DIE that is named.
2353 //
2354 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2355 // it's the offset within the debug_info/debug_types dwo section, however, the
2356 // reference in the pubname header doesn't change.
2357 
2358 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2360  const DIE *Die) {
2361  // Entities that ended up only in a Type Unit reference the CU instead (since
2362  // the pub entry has offsets within the CU there's no real offset that can be
2363  // provided anyway). As it happens all such entities (namespaces and types,
2364  // types only in C++ at that) are rendered as TYPE+EXTERNAL. If this turns out
2365  // not to be true it would be necessary to persist this information from the
2366  // point at which the entry is added to the index data structure - since by
2367  // the time the index is built from that, the original type/namespace DIE in a
2368  // type unit has already been destroyed so it can't be queried for properties
2369  // like tag, etc.
2370  if (Die->getTag() == dwarf::DW_TAG_compile_unit)
2374 
2375  // We could have a specification DIE that has our most of our knowledge,
2376  // look for that now.
2377  if (DIEValue SpecVal = Die->findAttribute(dwarf::DW_AT_specification)) {
2378  DIE &SpecDIE = SpecVal.getDIEEntry().getEntry();
2379  if (SpecDIE.findAttribute(dwarf::DW_AT_external))
2381  } else if (Die->findAttribute(dwarf::DW_AT_external))
2383 
2384  switch (Die->getTag()) {
2385  case dwarf::DW_TAG_class_type:
2386  case dwarf::DW_TAG_structure_type:
2387  case dwarf::DW_TAG_union_type:
2388  case dwarf::DW_TAG_enumeration_type:
2393  : dwarf::GIEL_STATIC);
2394  case dwarf::DW_TAG_typedef:
2395  case dwarf::DW_TAG_base_type:
2396  case dwarf::DW_TAG_subrange_type:
2398  case dwarf::DW_TAG_namespace:
2399  return dwarf::GIEK_TYPE;
2400  case dwarf::DW_TAG_subprogram:
2402  case dwarf::DW_TAG_variable:
2404  case dwarf::DW_TAG_enumerator:
2407  default:
2408  return dwarf::GIEK_NONE;
2409  }
2410 }
2411 
2412 /// emitDebugPubSections - Emit visible names and types into debug pubnames and
2413 /// pubtypes sections.
2414 void DwarfDebug::emitDebugPubSections() {
2415  for (const auto &NU : CUMap) {
2416  DwarfCompileUnit *TheU = NU.second;
2417  if (!TheU->hasDwarfPubSections())
2418  continue;
2419 
2420  bool GnuStyle = TheU->getCUNode()->getNameTableKind() ==
2422 
2423  Asm->OutStreamer->SwitchSection(
2426  emitDebugPubSection(GnuStyle, "Names", TheU, TheU->getGlobalNames());
2427 
2428  Asm->OutStreamer->SwitchSection(
2431  emitDebugPubSection(GnuStyle, "Types", TheU, TheU->getGlobalTypes());
2432  }
2433 }
2434 
2435 void DwarfDebug::emitSectionReference(const DwarfCompileUnit &CU) {
2437  Asm->emitDwarfOffset(CU.getSection()->getBeginSymbol(),
2438  CU.getDebugSectionOffset());
2439  else
2440  Asm->emitDwarfSymbolReference(CU.getLabelBegin());
2441 }
2442 
2443 void DwarfDebug::emitDebugPubSection(bool GnuStyle, StringRef Name,
2444  DwarfCompileUnit *TheU,
2445  const StringMap<const DIE *> &Globals) {
2446  if (auto *Skeleton = TheU->getSkeleton())
2447  TheU = Skeleton;
2448 
2449  // Emit the header.
2450  MCSymbol *EndLabel = Asm->emitDwarfUnitLength(
2451  "pub" + Name, "Length of Public " + Name + " Info");
2452 
2453  Asm->OutStreamer->AddComment("DWARF Version");
2455 
2456  Asm->OutStreamer->AddComment("Offset of Compilation Unit Info");
2457  emitSectionReference(*TheU);
2458 
2459  Asm->OutStreamer->AddComment("Compilation Unit Length");
2461 
2462  // Emit the pubnames for this compilation unit.
2463  for (const auto &GI : Globals) {
2464  const char *Name = GI.getKeyData();
2465  const DIE *Entity = GI.second;
2466 
2467  Asm->OutStreamer->AddComment("DIE offset");
2469 
2470  if (GnuStyle) {
2472  Asm->OutStreamer->AddComment(
2473  Twine("Attributes: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) +
2475  Asm->emitInt8(Desc.toBits());
2476  }
2477 
2478  Asm->OutStreamer->AddComment("External Name");
2479  Asm->OutStreamer->emitBytes(StringRef(Name, GI.getKeyLength() + 1));
2480  }
2481 
2482  Asm->OutStreamer->AddComment("End Mark");
2484  Asm->OutStreamer->emitLabel(EndLabel);
2485 }
2486 
2487 /// Emit null-terminated strings into a debug str section.
2488 void DwarfDebug::emitDebugStr() {
2489  MCSection *StringOffsetsSection = nullptr;
2491  emitStringOffsetsTableHeader();
2492  StringOffsetsSection = Asm->getObjFileLowering().getDwarfStrOffSection();
2493  }
2494  DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2496  StringOffsetsSection, /* UseRelativeOffsets = */ true);
2497 }
2498 
2500  const DebugLocStream::Entry &Entry,
2501  const DwarfCompileUnit *CU) {
2502  auto &&Comments = DebugLocs.getComments(Entry);
2503  auto Comment = Comments.begin();
2504  auto End = Comments.end();
2505 
2506  // The expressions are inserted into a byte stream rather early (see
2507  // DwarfExpression::addExpression) so for those ops (e.g. DW_OP_convert) that
2508  // need to reference a base_type DIE the offset of that DIE is not yet known.
2509  // To deal with this we instead insert a placeholder early and then extract
2510  // it here and replace it with the real reference.
2511  unsigned PtrSize = Asm->MAI->getCodePointerSize();
2512  DWARFDataExtractor Data(StringRef(DebugLocs.getBytes(Entry).data(),
2513  DebugLocs.getBytes(Entry).size()),
2514  Asm->getDataLayout().isLittleEndian(), PtrSize);
2515  DWARFExpression Expr(Data, PtrSize, Asm->OutContext.getDwarfFormat());
2516 
2517  using Encoding = DWARFExpression::Operation::Encoding;
2518  uint64_t Offset = 0;
2519  for (auto &Op : Expr) {
2520  assert(Op.getCode() != dwarf::DW_OP_const_type &&
2521  "3 operand ops not yet supported");
2522  Streamer.emitInt8(Op.getCode(), Comment != End ? *(Comment++) : "");
2523  Offset++;
2524  for (unsigned I = 0; I < 2; ++I) {
2525  if (Op.getDescription().Op[I] == Encoding::SizeNA)
2526  continue;
2527  if (Op.getDescription().Op[I] == Encoding::BaseTypeRef) {
2528  uint64_t Offset =
2529  CU->ExprRefedBaseTypes[Op.getRawOperand(I)].Die->getOffset();
2530  assert(Offset < (1ULL << (ULEB128PadSize * 7)) && "Offset wont fit");
2531  Streamer.emitULEB128(Offset, "", ULEB128PadSize);
2532  // Make sure comments stay aligned.
2533  for (unsigned J = 0; J < ULEB128PadSize; ++J)
2534  if (Comment != End)
2535  Comment++;
2536  } else {
2537  for (uint64_t J = Offset; J < Op.getOperandEndOffset(I); ++J)
2538  Streamer.emitInt8(Data.getData()[J], Comment != End ? *(Comment++) : "");
2539  }
2540  Offset = Op.getOperandEndOffset(I);
2541  }
2542  assert(Offset == Op.getEndOffset());
2543  }
2544 }
2545 
2547  const DbgValueLoc &Value,
2548  DwarfExpression &DwarfExpr) {
2549  auto *DIExpr = Value.getExpression();
2550  DIExpressionCursor ExprCursor(DIExpr);
2551  DwarfExpr.addFragmentOffset(DIExpr);
2552 
2553  // If the DIExpr is is an Entry Value, we want to follow the same code path
2554  // regardless of whether the DBG_VALUE is variadic or not.
2555  if (DIExpr && DIExpr->isEntryValue()) {
2556  // Entry values can only be a single register with no additional DIExpr,
2557  // so just add it directly.
2558  assert(Value.getLocEntries().size() == 1);
2559  assert(Value.getLocEntries()[0].isLocation());
2560  MachineLocation Location = Value.getLocEntries()[0].getLoc();
2561  DwarfExpr.setLocation(Location, DIExpr);
2562 
2563  DwarfExpr.beginEntryValueExpression(ExprCursor);
2564 
2566  if (!DwarfExpr.addMachineRegExpression(TRI, ExprCursor, Location.getReg()))
2567  return;
2568  return DwarfExpr.addExpression(std::move(ExprCursor));
2569  }
2570 
2571  // Regular entry.
2572  auto EmitValueLocEntry = [&DwarfExpr, &BT,
2573  &AP](const DbgValueLocEntry &Entry,
2574  DIExpressionCursor &Cursor) -> bool {
2575  if (Entry.isInt()) {
2576  if (BT && (BT->getEncoding() == dwarf::DW_ATE_signed ||
2577  BT->getEncoding() == dwarf::DW_ATE_signed_char))
2578  DwarfExpr.addSignedConstant(Entry.getInt());
2579  else
2580  DwarfExpr.addUnsignedConstant(Entry.getInt());
2581  } else if (Entry.isLocation()) {
2582  MachineLocation Location = Entry.getLoc();
2583  if (Location.isIndirect())
2584  DwarfExpr.setMemoryLocationKind();
2585 
2587  if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg()))
2588  return false;
2589  } else if (Entry.isTargetIndexLocation()) {
2590  TargetIndexLocation Loc = Entry.getTargetIndexLocation();
2591  // TODO TargetIndexLocation is a target-independent. Currently only the
2592  // WebAssembly-specific encoding is supported.
2593  assert(AP.TM.getTargetTriple().isWasm());
2594  DwarfExpr.addWasmLocation(Loc.Index, static_cast<uint64_t>(Loc.Offset));
2595  } else if (Entry.isConstantFP()) {
2596  if (AP.getDwarfVersion() >= 4 && !AP.getDwarfDebug()->tuneForSCE() &&
2597  !Cursor) {
2598  DwarfExpr.addConstantFP(Entry.getConstantFP()->getValueAPF(), AP);
2599  } else if (Entry.getConstantFP()
2600  ->getValueAPF()
2601  .bitcastToAPInt()
2602  .getBitWidth() <= 64 /*bits*/) {
2603  DwarfExpr.addUnsignedConstant(
2604  Entry.getConstantFP()->getValueAPF().bitcastToAPInt());
2605  } else {
2606  LLVM_DEBUG(
2607  dbgs() << "Skipped DwarfExpression creation for ConstantFP of size"
2608  << Entry.getConstantFP()
2609  ->getValueAPF()
2610  .bitcastToAPInt()
2611  .getBitWidth()
2612  << " bits\n");
2613  return false;
2614  }
2615  }
2616  return true;
2617  };
2618 
2619  if (!Value.isVariadic()) {
2620  if (!EmitValueLocEntry(Value.getLocEntries()[0], ExprCursor))
2621  return;
2622  DwarfExpr.addExpression(std::move(ExprCursor));
2623  return;
2624  }
2625 
2626  // If any of the location entries are registers with the value 0, then the
2627  // location is undefined.
2628  if (any_of(Value.getLocEntries(), [](const DbgValueLocEntry &Entry) {
2629  return Entry.isLocation() && !Entry.getLoc().getReg();
2630  }))
2631  return;
2632 
2633  DwarfExpr.addExpression(
2634  std::move(ExprCursor),
2635  [EmitValueLocEntry, &Value](unsigned Idx,
2636  DIExpressionCursor &Cursor) -> bool {
2637  return EmitValueLocEntry(Value.getLocEntries()[Idx], Cursor);
2638  });
2639 }
2640 
2643  const DIBasicType *BT,
2644  DwarfCompileUnit &TheCU) {
2645  assert(!Values.empty() &&
2646  "location list entries without values are redundant");
2647  assert(Begin != End && "unexpected location list entry with empty range");
2648  DebugLocStream::EntryBuilder Entry(List, Begin, End);
2649  BufferByteStreamer Streamer = Entry.getStreamer();
2650  DebugLocDwarfExpression DwarfExpr(AP.getDwarfVersion(), Streamer, TheCU);
2651  const DbgValueLoc &Value = Values[0];
2652  if (Value.isFragment()) {
2653  // Emit all fragments that belong to the same variable and range.
2654  assert(llvm::all_of(Values, [](DbgValueLoc P) {
2655  return P.isFragment();
2656  }) && "all values are expected to be fragments");
2657  assert(llvm::is_sorted(Values) && "fragments are expected to be sorted");
2658 
2659  for (const auto &Fragment : Values)
2660  DwarfDebug::emitDebugLocValue(AP, BT, Fragment, DwarfExpr);
2661 
2662  } else {
2663  assert(Values.size() == 1 && "only fragments may have >1 value");
2664  DwarfDebug::emitDebugLocValue(AP, BT, Value, DwarfExpr);
2665  }
2666  DwarfExpr.finalize();
2667  if (DwarfExpr.TagOffset)
2668  List.setTagOffset(*DwarfExpr.TagOffset);
2669 }
2670 
2672  const DwarfCompileUnit *CU) {
2673  // Emit the size.
2674  Asm->OutStreamer->AddComment("Loc expr size");
2675  if (getDwarfVersion() >= 5)
2676  Asm->emitULEB128(DebugLocs.getBytes(Entry).size());
2677  else if (DebugLocs.getBytes(Entry).size() <= std::numeric_limits<uint16_t>::max())
2678  Asm->emitInt16(DebugLocs.getBytes(Entry).size());
2679  else {
2680  // The entry is too big to fit into 16 bit, drop it as there is nothing we
2681  // can do.
2682  Asm->emitInt16(0);
2683  return;
2684  }
2685  // Emit the entry.
2686  APByteStreamer Streamer(*Asm);
2687  emitDebugLocEntry(Streamer, Entry, CU);
2688 }
2689 
2690 // Emit the header of a DWARF 5 range list table list table. Returns the symbol
2691 // that designates the end of the table for the caller to emit when the table is
2692 // complete.
2694  const DwarfFile &Holder) {
2695  MCSymbol *TableEnd = mcdwarf::emitListsTableHeaderStart(*Asm->OutStreamer);
2696 
2697  Asm->OutStreamer->AddComment("Offset entry count");
2698  Asm->emitInt32(Holder.getRangeLists().size());
2699  Asm->OutStreamer->emitLabel(Holder.getRnglistsTableBaseSym());
2700 
2701  for (const RangeSpanList &List : Holder.getRangeLists())
2702  Asm->emitLabelDifference(List.Label, Holder.getRnglistsTableBaseSym(),
2703  Asm->getDwarfOffsetByteSize());
2704 
2705  return TableEnd;
2706 }
2707 
2708 // Emit the header of a DWARF 5 locations list table. Returns the symbol that
2709 // designates the end of the table for the caller to emit when the table is
2710 // complete.
2712  const DwarfDebug &DD) {
2713  MCSymbol *TableEnd = mcdwarf::emitListsTableHeaderStart(*Asm->OutStreamer);
2714 
2715  const auto &DebugLocs = DD.getDebugLocs();
2716 
2717  Asm->OutStreamer->AddComment("Offset entry count");
2718  Asm->emitInt32(DebugLocs.getLists().size());
2719  Asm->OutStreamer->emitLabel(DebugLocs.getSym());
2720 
2721  for (const auto &List : DebugLocs.getLists())
2722  Asm->emitLabelDifference(List.Label, DebugLocs.getSym(),
2723  Asm->getDwarfOffsetByteSize());
2724 
2725  return TableEnd;
2726 }
2727 
2728 template <typename Ranges, typename PayloadEmitter>
2729 static void emitRangeList(
2730  DwarfDebug &DD, AsmPrinter *Asm, MCSymbol *Sym, const Ranges &R,
2731  const DwarfCompileUnit &CU, unsigned BaseAddressx, unsigned OffsetPair,
2732  unsigned StartxLength, unsigned EndOfList,
2733  StringRef (*StringifyEnum)(unsigned),
2734  bool ShouldUseBaseAddress,
2735  PayloadEmitter EmitPayload) {
2736 
2737  auto Size = Asm->MAI->getCodePointerSize();
2738  bool UseDwarf5 = DD.getDwarfVersion() >= 5;
2739 
2740  // Emit our symbol so we can find the beginning of the range.
2741  Asm->OutStreamer->emitLabel(Sym);
2742 
2743  // Gather all the ranges that apply to the same section so they can share
2744  // a base address entry.
2745  MapVector<const MCSection *, std::vector<decltype(&*R.begin())>> SectionRanges;
2746 
2747  for (const auto &Range : R)
2748  SectionRanges[&Range.Begin->getSection()].push_back(&Range);
2749 
2750  const MCSymbol *CUBase = CU.getBaseAddress();
2751  bool BaseIsSet = false;
2752  for (const auto &P : SectionRanges) {
2753  auto *Base = CUBase;
2754  if (!Base && ShouldUseBaseAddress) {
2755  const MCSymbol *Begin = P.second.front()->Begin;
2756  const MCSymbol *NewBase = DD.getSectionLabel(&Begin->getSection());
2757  if (!UseDwarf5) {
2758  Base = NewBase;
2759  BaseIsSet = true;
2760  Asm->OutStreamer->emitIntValue(-1, Size);
2761  Asm->OutStreamer->AddComment(" base address");
2762  Asm->OutStreamer->emitSymbolValue(Base, Size);
2763  } else if (NewBase != Begin || P.second.size() > 1) {
2764  // Only use a base address if
2765  // * the existing pool address doesn't match (NewBase != Begin)
2766  // * or, there's more than one entry to share the base address
2767  Base = NewBase;
2768  BaseIsSet = true;
2769  Asm->OutStreamer->AddComment(StringifyEnum(BaseAddressx));
2770  Asm->emitInt8(BaseAddressx);
2771  Asm->OutStreamer->AddComment(" base address index");
2772  Asm->emitULEB128(DD.getAddressPool().getIndex(Base));
2773  }
2774  } else if (BaseIsSet && !UseDwarf5) {
2775  BaseIsSet = false;
2776  assert(!Base);
2777  Asm->OutStreamer->emitIntValue(-1, Size);
2778  Asm->OutStreamer->emitIntValue(0, Size);
2779  }
2780 
2781  for (const auto *RS : P.second) {
2782  const MCSymbol *Begin = RS->Begin;
2783  const MCSymbol *End = RS->End;
2784  assert(Begin && "Range without a begin symbol?");
2785  assert(End && "Range without an end symbol?");
2786  if (Base) {
2787  if (UseDwarf5) {
2788  // Emit offset_pair when we have a base.
2789  Asm->OutStreamer->AddComment(StringifyEnum(OffsetPair));
2790  Asm->emitInt8(OffsetPair);
2791  Asm->OutStreamer->AddComment(" starting offset");
2792  Asm->emitLabelDifferenceAsULEB128(Begin, Base);
2793  Asm->OutStreamer->AddComment(" ending offset");
2794  Asm->emitLabelDifferenceAsULEB128(End, Base);
2795  } else {
2796  Asm->emitLabelDifference(Begin, Base, Size);
2797  Asm->emitLabelDifference(End, Base, Size);
2798  }
2799  } else if (UseDwarf5) {
2800  Asm->OutStreamer->AddComment(StringifyEnum(StartxLength));
2801  Asm->emitInt8(StartxLength);
2802  Asm->OutStreamer->AddComment(" start index");
2803  Asm->emitULEB128(DD.getAddressPool().getIndex(Begin));
2804  Asm->OutStreamer->AddComment(" length");
2805  Asm->emitLabelDifferenceAsULEB128(End, Begin);
2806  } else {
2807  Asm->OutStreamer->emitSymbolValue(Begin, Size);
2808  Asm->OutStreamer->emitSymbolValue(End, Size);
2809  }
2810  EmitPayload(*RS);
2811  }
2812  }
2813 
2814  if (UseDwarf5) {
2815  Asm->OutStreamer->AddComment(StringifyEnum(EndOfList));
2816  Asm->emitInt8(EndOfList);
2817  } else {
2818  // Terminate the list with two 0 values.
2819  Asm->OutStreamer->emitIntValue(0, Size);
2820  Asm->OutStreamer->emitIntValue(0, Size);
2821  }
2822 }
2823 
2824 // Handles emission of both debug_loclist / debug_loclist.dwo
2825 static void emitLocList(DwarfDebug &DD, AsmPrinter *Asm, const DebugLocStream::List &List) {
2826  emitRangeList(DD, Asm, List.Label, DD.getDebugLocs().getEntries(List),
2827  *List.CU, dwarf::DW_LLE_base_addressx,
2828  dwarf::DW_LLE_offset_pair, dwarf::DW_LLE_startx_length,
2829  dwarf::DW_LLE_end_of_list, llvm::dwarf::LocListEncodingString,
2830  /* ShouldUseBaseAddress */ true,
2831  [&](const DebugLocStream::Entry &E) {
2832  DD.emitDebugLocEntryLocation(E, List.CU);
2833  });
2834 }
2835 
2836 void DwarfDebug::emitDebugLocImpl(MCSection *Sec) {
2837  if (DebugLocs.getLists().empty())
2838  return;
2839 
2840  Asm->OutStreamer->SwitchSection(Sec);
2841 
2842  MCSymbol *TableEnd = nullptr;
2843  if (getDwarfVersion() >= 5)
2844  TableEnd = emitLoclistsTableHeader(Asm, *this);
2845 
2846  for (const auto &List : DebugLocs.getLists())
2847  emitLocList(*this, Asm, List);
2848 
2849  if (TableEnd)
2850  Asm->OutStreamer->emitLabel(TableEnd);
2851 }
2852 
2853 // Emit locations into the .debug_loc/.debug_loclists section.
2854 void DwarfDebug::emitDebugLoc() {
2855  emitDebugLocImpl(
2856  getDwarfVersion() >= 5
2859 }
2860 
2861 // Emit locations into the .debug_loc.dwo/.debug_loclists.dwo section.
2862 void DwarfDebug::emitDebugLocDWO() {
2863  if (getDwarfVersion() >= 5) {
2864  emitDebugLocImpl(
2866 
2867  return;
2868  }
2869 
2870  for (const auto &List : DebugLocs.getLists()) {
2871  Asm->OutStreamer->SwitchSection(
2873  Asm->OutStreamer->emitLabel(List.Label);
2874 
2875  for (const auto &Entry : DebugLocs.getEntries(List)) {
2876  // GDB only supports startx_length in pre-standard split-DWARF.
2877  // (in v5 standard loclists, it currently* /only/ supports base_address +
2878  // offset_pair, so the implementations can't really share much since they
2879  // need to use different representations)
2880  // * as of October 2018, at least
2881  //
2882  // In v5 (see emitLocList), this uses SectionLabels to reuse existing
2883  // addresses in the address pool to minimize object size/relocations.
2884  Asm->emitInt8(dwarf::DW_LLE_startx_length);
2885  unsigned idx = AddrPool.getIndex(Entry.Begin);
2886  Asm->emitULEB128(idx);
2887  // Also the pre-standard encoding is slightly different, emitting this as
2888  // an address-length entry here, but its a ULEB128 in DWARFv5 loclists.
2889  Asm->emitLabelDifference(Entry.End, Entry.Begin, 4);
2890  emitDebugLocEntryLocation(Entry, List.CU);
2891  }
2892  Asm->emitInt8(dwarf::DW_LLE_end_of_list);
2893  }
2894 }
2895 
2896 struct ArangeSpan {
2897  const MCSymbol *Start, *End;
2898 };
2899 
2900 // Emit a debug aranges section, containing a CU lookup for any
2901 // address we can tie back to a CU.
2902 void DwarfDebug::emitDebugARanges() {
2903  // Provides a unique id per text section.
2905 
2906  // Filter labels by section.
2907  for (const SymbolCU &SCU : ArangeLabels) {
2908  if (SCU.Sym->isInSection()) {
2909  // Make a note of this symbol and it's section.
2910  MCSection *Section = &SCU.Sym->getSection();
2911  if (!Section->getKind().isMetadata())
2912  SectionMap[Section].push_back(SCU);
2913  } else {
2914  // Some symbols (e.g. common/bss on mach-o) can have no section but still
2915  // appear in the output. This sucks as we rely on sections to build
2916  // arange spans. We can do it without, but it's icky.
2917  SectionMap[nullptr].push_back(SCU);
2918  }
2919  }
2920 
2922 
2923  for (auto &I : SectionMap) {
2924  MCSection *Section = I.first;
2925  SmallVector<SymbolCU, 8> &List = I.second;
2926  if (List.size() < 1)
2927  continue;
2928 
2929  // If we have no section (e.g. common), just write out
2930  // individual spans for each symbol.
2931  if (!Section) {
2932  for (const SymbolCU &Cur : List) {
2933  ArangeSpan Span;
2934  Span.Start = Cur.Sym;
2935  Span.End = nullptr;
2936  assert(Cur.CU);
2937  Spans[Cur.CU].push_back(Span);
2938  }
2939  continue;
2940  }
2941 
2942  // Sort the symbols by offset within the section.
2943  llvm::stable_sort(List, [&](const SymbolCU &A, const SymbolCU &B) {
2944  unsigned IA = A.Sym ? Asm->OutStreamer->GetSymbolOrder(A.Sym) : 0;
2945  unsigned IB = B.Sym ? Asm->OutStreamer->GetSymbolOrder(B.Sym) : 0;
2946 
2947  // Symbols with no order assigned should be placed at the end.
2948  // (e.g. section end labels)
2949  if (IA == 0)
2950  return false;
2951  if (IB == 0)
2952  return true;
2953  return IA < IB;
2954  });
2955 
2956  // Insert a final terminator.
2957  List.push_back(SymbolCU(nullptr, Asm->OutStreamer->endSection(Section)));
2958 
2959  // Build spans between each label.
2960  const MCSymbol *StartSym = List[0].Sym;
2961  for (size_t n = 1, e = List.size(); n < e; n++) {
2962  const SymbolCU &Prev = List[n - 1];
2963  const SymbolCU &Cur = List[n];
2964 
2965  // Try and build the longest span we can within the same CU.
2966  if (Cur.CU != Prev.CU) {
2967  ArangeSpan Span;
2968  Span.Start = StartSym;
2969  Span.End = Cur.Sym;
2970  assert(Prev.CU);
2971  Spans[Prev.CU].push_back(Span);
2972  StartSym = Cur.Sym;
2973  }
2974  }
2975  }
2976 
2977  // Start the dwarf aranges section.
2978  Asm->OutStreamer->SwitchSection(
2980 
2981  unsigned PtrSize = Asm->MAI->getCodePointerSize();
2982 
2983  // Build a list of CUs used.
2984  std::vector<DwarfCompileUnit *> CUs;
2985  for (const auto &it : Spans) {
2986  DwarfCompileUnit *CU = it.first;
2987  CUs.push_back(CU);
2988  }
2989 
2990  // Sort the CU list (again, to ensure consistent output order).
2991  llvm::sort(CUs, [](const DwarfCompileUnit *A, const DwarfCompileUnit *B) {
2992  return A->getUniqueID() < B->getUniqueID();
2993  });
2994 
2995  // Emit an arange table for each CU we used.
2996  for (DwarfCompileUnit *CU : CUs) {
2997  std::vector<ArangeSpan> &List = Spans[CU];
2998 
2999  // Describe the skeleton CU's offset and length, not the dwo file's.
3000  if (auto *Skel = CU->getSkeleton())
3001  CU = Skel;
3002 
3003  // Emit size of content not including length itself.
3004  unsigned ContentSize =
3005  sizeof(int16_t) + // DWARF ARange version number
3006  Asm->getDwarfOffsetByteSize() + // Offset of CU in the .debug_info
3007  // section
3008  sizeof(int8_t) + // Pointer Size (in bytes)
3009  sizeof(int8_t); // Segment Size (in bytes)
3010 
3011  unsigned TupleSize = PtrSize * 2;
3012 
3013  // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
3014  unsigned Padding = offsetToAlignment(
3015  Asm->getUnitLengthFieldByteSize() + ContentSize, Align(TupleSize));
3016 
3017  ContentSize += Padding;
3018  ContentSize += (List.size() + 1) * TupleSize;
3019 
3020  // For each compile unit, write the list of spans it covers.
3021  Asm->emitDwarfUnitLength(ContentSize, "Length of ARange Set");
3022  Asm->OutStreamer->AddComment("DWARF Arange version number");
3024  Asm->OutStreamer->AddComment("Offset Into Debug Info Section");
3025  emitSectionReference(*CU);
3026  Asm->OutStreamer->AddComment("Address Size (in bytes)");
3027  Asm->emitInt8(PtrSize);
3028  Asm->OutStreamer->AddComment("Segment Size (in bytes)");
3029  Asm->emitInt8(0);
3030 
3031  Asm->OutStreamer->emitFill(Padding, 0xff);
3032 
3033  for (const ArangeSpan &Span : List) {
3034  Asm->emitLabelReference(Span.Start, PtrSize);
3035 
3036  // Calculate the size as being from the span start to it's end.
3037  if (Span.End) {
3038  Asm->emitLabelDifference(Span.End, Span.Start, PtrSize);
3039  } else {
3040  // For symbols without an end marker (e.g. common), we
3041  // write a single arange entry containing just that one symbol.
3042  uint64_t Size = SymSize[Span.Start];
3043  if (Size == 0)
3044  Size = 1;
3045 
3046  Asm->OutStreamer->emitIntValue(Size, PtrSize);
3047  }
3048  }
3049 
3050  Asm->OutStreamer->AddComment("ARange terminator");
3051  Asm->OutStreamer->emitIntValue(0, PtrSize);
3052  Asm->OutStreamer->emitIntValue(0, PtrSize);
3053  }
3054 }
3055 
3056 /// Emit a single range list. We handle both DWARF v5 and earlier.
3058  const RangeSpanList &List) {
3059  emitRangeList(DD, Asm, List.Label, List.Ranges, *List.CU,
3060  dwarf::DW_RLE_base_addressx, dwarf::DW_RLE_offset_pair,
3061  dwarf::DW_RLE_startx_length, dwarf::DW_RLE_end_of_list,
3063  List.CU->getCUNode()->getRangesBaseAddress() ||
3064  DD.getDwarfVersion() >= 5,
3065  [](auto) {});
3066 }
3067 
3068 void DwarfDebug::emitDebugRangesImpl(const DwarfFile &Holder, MCSection *Section) {
3069  if (Holder.getRangeLists().empty())
3070  return;
3071 
3073  assert(!CUMap.empty());
3074  assert(llvm::any_of(CUMap, [](const decltype(CUMap)::value_type &Pair) {
3075  return !Pair.second->getCUNode()->isDebugDirectivesOnly();
3076  }));
3077 
3078  Asm->OutStreamer->SwitchSection(Section);
3079 
3080  MCSymbol *TableEnd = nullptr;
3081  if (getDwarfVersion() >= 5)
3082  TableEnd = emitRnglistsTableHeader(Asm, Holder);
3083 
3084  for (const RangeSpanList &List : Holder.getRangeLists())
3085  emitRangeList(*this, Asm, List);
3086 
3087  if (TableEnd)
3088  Asm->OutStreamer->emitLabel(TableEnd);
3089 }
3090 
3091 /// Emit address ranges into the .debug_ranges section or into the DWARF v5
3092 /// .debug_rnglists section.
3093 void DwarfDebug::emitDebugRanges() {
3094  const auto &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
3095 
3096  emitDebugRangesImpl(Holder,
3097  getDwarfVersion() >= 5
3100 }
3101 
3102 void DwarfDebug::emitDebugRangesDWO() {
3103  emitDebugRangesImpl(InfoHolder,
3105 }
3106 
3107 /// Emit the header of a DWARF 5 macro section, or the GNU extension for
3108 /// DWARF 4.
3109 static void emitMacroHeader(AsmPrinter *Asm, const DwarfDebug &DD,
3110  const DwarfCompileUnit &CU, uint16_t DwarfVersion) {
3111  enum HeaderFlagMask {
3112 #define HANDLE_MACRO_FLAG(ID, NAME) MACRO_FLAG_##NAME = ID,
3113 #include "llvm/BinaryFormat/Dwarf.def"
3114  };
3115  Asm->OutStreamer->AddComment("Macro information version");
3116  Asm->emitInt16(DwarfVersion >= 5 ? DwarfVersion : 4);
3117  // We emit the line offset flag unconditionally here, since line offset should
3118  // be mostly present.
3119  if (Asm->isDwarf64()) {
3120  Asm->OutStreamer->AddComment("Flags: 64 bit, debug_line_offset present");
3121  Asm->emitInt8(MACRO_FLAG_OFFSET_SIZE | MACRO_FLAG_DEBUG_LINE_OFFSET);
3122  } else {
3123  Asm->OutStreamer->AddComment("Flags: 32 bit, debug_line_offset present");
3124  Asm->emitInt8(MACRO_FLAG_DEBUG_LINE_OFFSET);
3125  }
3126  Asm->OutStreamer->AddComment("debug_line_offset");
3127  if (DD.useSplitDwarf())
3128  Asm->emitDwarfLengthOrOffset(0);
3129  else
3130  Asm->emitDwarfSymbolReference(CU.getLineTableStartSym());
3131 }
3132 
3133 void DwarfDebug::handleMacroNodes(DIMacroNodeArray Nodes, DwarfCompileUnit &U) {
3134  for (auto *MN : Nodes) {
3135  if (auto *M = dyn_cast<DIMacro>(MN))
3136  emitMacro(*M);
3137  else if (auto *F = dyn_cast<DIMacroFile>(MN))
3138  emitMacroFile(*F, U);
3139  else
3140  llvm_unreachable("Unexpected DI type!");
3141  }
3142 }
3143 
3144 void DwarfDebug::emitMacro(DIMacro &M) {
3145  StringRef Name = M.getName();
3146  StringRef Value = M.getValue();
3147 
3148  // There should be one space between the macro name and the macro value in
3149  // define entries. In undef entries, only the macro name is emitted.
3150  std::string Str = Value.empty() ? Name.str() : (Name + " " + Value).str();
3151 
3152  if (UseDebugMacroSection) {
3153  if (getDwarfVersion() >= 5) {
3154  unsigned Type = M.getMacinfoType() == dwarf::DW_MACINFO_define
3155  ? dwarf::DW_MACRO_define_strx
3156  : dwarf::DW_MACRO_undef_strx;
3157  Asm->OutStreamer->AddComment(dwarf::MacroString(Type));
3158  Asm->emitULEB128(Type);
3159  Asm->OutStreamer->AddComment("Line Number");
3160  Asm->emitULEB128(M.getLine());
3161  Asm->OutStreamer->AddComment("Macro String");
3162  Asm->emitULEB128(
3163  InfoHolder.getStringPool().getIndexedEntry(*Asm, Str).getIndex());
3164  } else {
3165  unsigned Type = M.getMacinfoType() == dwarf::DW_MACINFO_define
3166  ? dwarf::DW_MACRO_GNU_define_indirect
3167  : dwarf::DW_MACRO_GNU_undef_indirect;
3168  Asm->OutStreamer->AddComment(dwarf::GnuMacroString(Type));
3169  Asm->emitULEB128(Type);
3170  Asm->OutStreamer->AddComment("Line Number");
3171  Asm->emitULEB128(M.getLine());
3172  Asm->OutStreamer->AddComment("Macro String");
3174  InfoHolder.getStringPool().getEntry(*Asm, Str).getSymbol());
3175  }
3176  } else {
3177  Asm->OutStreamer->AddComment(dwarf::MacinfoString(M.getMacinfoType()));
3178  Asm->emitULEB128(M.getMacinfoType());
3179  Asm->OutStreamer->AddComment("Line Number");
3180  Asm->emitULEB128(M.getLine());
3181  Asm->OutStreamer->AddComment("Macro String");
3182  Asm->OutStreamer->emitBytes(Str);
3183  Asm->emitInt8('\0');
3184  }
3185 }
3186 
3187 void DwarfDebug::emitMacroFileImpl(
3188  DIMacroFile &MF, DwarfCompileUnit &U, unsigned StartFile, unsigned EndFile,
3189  StringRef (*MacroFormToString)(unsigned Form)) {
3190 
3191  Asm->OutStreamer->AddComment(MacroFormToString(StartFile));
3192  Asm->emitULEB128(StartFile);
3193  Asm->OutStreamer->AddComment("Line Number");
3194  Asm->emitULEB128(MF.getLine());
3195  Asm->OutStreamer->AddComment("File Number");
3196  DIFile &F = *MF.getFile();
3197  if (useSplitDwarf())
3198  Asm->emitULEB128(getDwoLineTable(U)->getFile(
3199  F.getDirectory(), F.getFilename(), getMD5AsBytes(&F),
3200  Asm->OutContext.getDwarfVersion(), F.getSource()));
3201  else
3203  handleMacroNodes(MF.getElements(), U);
3204  Asm->OutStreamer->AddComment(MacroFormToString(EndFile));
3205  Asm->emitULEB128(EndFile);
3206 }
3207 
3208 void DwarfDebug::emitMacroFile(DIMacroFile &F, DwarfCompileUnit &U) {
3209  // DWARFv5 macro and DWARFv4 macinfo share some common encodings,
3210  // so for readibility/uniformity, We are explicitly emitting those.
3211  assert(F.getMacinfoType() == dwarf::DW_MACINFO_start_file);
3212  if (UseDebugMacroSection)
3213  emitMacroFileImpl(
3214  F, U, dwarf::DW_MACRO_start_file, dwarf::DW_MACRO_end_file,
3216  else
3217  emitMacroFileImpl(F, U, dwarf::DW_MACINFO_start_file,
3219 }
3220 
3221 void DwarfDebug::emitDebugMacinfoImpl(MCSection *Section) {
3222  for (const auto &P : CUMap) {
3223  auto &TheCU = *P.second;
3224  auto *SkCU = TheCU.getSkeleton();
3225  DwarfCompileUnit &U = SkCU ? *SkCU : TheCU;
3226  auto *CUNode = cast<DICompileUnit>(P.first);
3227  DIMacroNodeArray Macros = CUNode->getMacros();
3228  if (Macros.empty())
3229  continue;
3230  Asm->OutStreamer->SwitchSection(Section);
3231  Asm->OutStreamer->emitLabel(U.getMacroLabelBegin());
3232  if (UseDebugMacroSection)
3233  emitMacroHeader(Asm, *this, U, getDwarfVersion());
3234  handleMacroNodes(Macros, U);
3235  Asm->OutStreamer->AddComment("End Of Macro List Mark");
3236  Asm->emitInt8(0);
3237  }
3238 }
3239 
3240 /// Emit macros into a debug macinfo/macro section.
3241 void DwarfDebug::emitDebugMacinfo() {
3242  auto &ObjLower = Asm->getObjFileLowering();
3243  emitDebugMacinfoImpl(UseDebugMacroSection
3244  ? ObjLower.getDwarfMacroSection()
3245  : ObjLower.getDwarfMacinfoSection());
3246 }
3247 
3248 void DwarfDebug::emitDebugMacinfoDWO() {
3249  auto &ObjLower = Asm->getObjFileLowering();
3250  emitDebugMacinfoImpl(UseDebugMacroSection
3251  ? ObjLower.getDwarfMacroDWOSection()
3252  : ObjLower.getDwarfMacinfoDWOSection());
3253 }
3254 
3255 // DWARF5 Experimental Separate Dwarf emitters.
3256 
3257 void DwarfDebug::initSkeletonUnit(const DwarfUnit &U, DIE &Die,
3258  std::unique_ptr<DwarfCompileUnit> NewU) {
3259 
3260  if (!CompilationDir.empty())
3261  NewU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
3262  addGnuPubAttributes(*NewU, Die);
3263 
3264  SkeletonHolder.addUnit(std::move(NewU));
3265 }
3266 
3267 DwarfCompileUnit &DwarfDebug::constructSkeletonCU(const DwarfCompileUnit &CU) {
3268 
3269  auto OwnedUnit = std::make_unique<DwarfCompileUnit>(
3270  CU.getUniqueID(), CU.getCUNode(), Asm, this, &SkeletonHolder,
3272  DwarfCompileUnit &NewCU = *OwnedUnit;
3274 
3275  NewCU.initStmtList();
3276 
3278  NewCU.addStringOffsetsStart();
3279 
3280  initSkeletonUnit(CU, NewCU.getUnitDie(), std::move(OwnedUnit));
3281 
3282  return NewCU;
3283 }
3284 
3285 // Emit the .debug_info.dwo section for separated dwarf. This contains the
3286 // compile units that would normally be in debug_info.
3287 void DwarfDebug::emitDebugInfoDWO() {
3288  assert(useSplitDwarf() && "No split dwarf debug info?");
3289  // Don't emit relocations into the dwo file.
3290  InfoHolder.emitUnits(/* UseOffsets */ true);
3291 }
3292 
3293 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
3294 // abbreviations for the .debug_info.dwo section.
3295 void DwarfDebug::emitDebugAbbrevDWO() {
3296  assert(useSplitDwarf() && "No split dwarf?");
3298 }
3299 
3300 void DwarfDebug::emitDebugLineDWO() {
3301  assert(useSplitDwarf() && "No split dwarf?");
3302  SplitTypeUnitFileTable.Emit(
3305 }
3306 
3307 void DwarfDebug::emitStringOffsetsTableHeaderDWO() {
3308  assert(useSplitDwarf() && "No split dwarf?");
3311  InfoHolder.getStringOffsetsStartSym());
3312 }
3313 
3314 // Emit the .debug_str.dwo section for separated dwarf. This contains the
3315 // string section and is identical in format to traditional .debug_str
3316 // sections.
3317 void DwarfDebug::emitDebugStrDWO() {
3319  emitStringOffsetsTableHeaderDWO();
3320  assert(useSplitDwarf() && "No split dwarf?");
3323  OffSec, /* UseRelativeOffsets = */ false);
3324 }
3325 
3326 // Emit address pool.
3327 void DwarfDebug::emitDebugAddr() {
3329 }
3330 
3331 MCDwarfDwoLineTable *DwarfDebug::getDwoLineTable(const DwarfCompileUnit &CU) {
3332  if (!useSplitDwarf())
3333  return nullptr;
3334  const DICompileUnit *DIUnit = CU.getCUNode();
3335  SplitTypeUnitFileTable.maybeSetRootFile(
3336  DIUnit->getDirectory(), DIUnit->getFilename(),
3337  getMD5AsBytes(DIUnit->getFile()), DIUnit->getSource());
3338  return &SplitTypeUnitFileTable;
3339 }
3340 
3342  MD5 Hash;
3343  Hash.update(Identifier);
3344  // ... take the least significant 8 bytes and return those. Our MD5
3345  // implementation always returns its results in little endian, so we actually
3346  // need the "high" word.
3347  MD5::MD5Result Result;
3348  Hash.final(Result);
3349  return Result.high();
3350 }
3351 
3353  StringRef Identifier, DIE &RefDie,
3354  const DICompositeType *CTy) {
3355  // Fast path if we're building some type units and one has already used the
3356  // address pool we know we're going to throw away all this work anyway, so
3357  // don't bother building dependent types.
3358  if (!TypeUnitsUnderConstruction.empty() && AddrPool.hasBeenUsed())
3359  return;
3360 
3361  auto Ins = TypeSignatures.insert(std::make_pair(CTy, 0));
3362  if (!Ins.second) {
3363  CU.addDIETypeSignature(RefDie, Ins.first->second);
3364  return;
3365  }
3366 
3367  bool TopLevelType = TypeUnitsUnderConstruction.empty();
3368  AddrPool.resetUsedFlag();
3369 
3370  auto OwnedUnit = std::make_unique<DwarfTypeUnit>(CU, Asm, this, &InfoHolder,
3371  getDwoLineTable(CU));
3372  DwarfTypeUnit &NewTU = *OwnedUnit;
3373  DIE &UnitDie = NewTU.getUnitDie();
3374  TypeUnitsUnderConstruction.emplace_back(std::move(OwnedUnit), CTy);
3375 
3376  NewTU.addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
3377  CU.getLanguage());
3378 
3379  uint64_t Signature = makeTypeSignature(Identifier);
3380  NewTU.setTypeSignature(Signature);
3381  Ins.first->second = Signature;
3382 
3383  if (useSplitDwarf()) {
3384  MCSection *Section =
3385  getDwarfVersion() <= 4
3388  NewTU.setSection(Section);
3389  } else {
3390  MCSection *Section =
3391  getDwarfVersion() <= 4
3393  : Asm->getObjFileLowering().getDwarfInfoSection(Signature);
3394  NewTU.setSection(Section);
3395  // Non-split type units reuse the compile unit's line table.
3396  CU.applyStmtList(UnitDie);
3397  }
3398 
3399  // Add DW_AT_str_offsets_base to the type unit DIE, but not for split type
3400  // units.
3402  NewTU.addStringOffsetsStart();
3403 
3404  NewTU.setType(NewTU.createTypeDIE(CTy));
3405 
3406  if (TopLevelType) {
3407  auto TypeUnitsToAdd = std::move(TypeUnitsUnderConstruction);
3408  TypeUnitsUnderConstruction.clear();
3409 
3410  // Types referencing entries in the address table cannot be placed in type
3411  // units.
3412  if (AddrPool.hasBeenUsed()) {
3413 
3414  // Remove all the types built while building this type.
3415  // This is pessimistic as some of these types might not be dependent on
3416  // the type that used an address.
3417  for (const auto &TU : TypeUnitsToAdd)
3418  TypeSignatures.erase(TU.second);
3419 
3420  // Construct this type in the CU directly.
3421  // This is inefficient because all the dependent types will be rebuilt
3422  // from scratch, including building them in type units, discovering that
3423  // they depend on addresses, throwing them out and rebuilding them.
3424  CU.constructTypeDIE(RefDie, cast<DICompositeType>(CTy));
3425  return;
3426  }
3427 
3428  // If the type wasn't dependent on fission addresses, finish adding the type
3429  // and all its dependent types.
3430  for (auto &TU : TypeUnitsToAdd) {
3431  InfoHolder.computeSizeAndOffsetsForUnit(TU.first.get());
3432  InfoHolder.emitUnit(TU.first.get(), useSplitDwarf());
3433  }
3434  }
3435  CU.addDIETypeSignature(RefDie, Signature);
3436 }
3437 
3438 DwarfDebug::NonTypeUnitContext::NonTypeUnitContext(DwarfDebug *DD)
3439  : DD(DD),
3440  TypeUnitsUnderConstruction(std::move(DD->TypeUnitsUnderConstruction)), AddrPoolUsed(DD->AddrPool.hasBeenUsed()) {
3441  DD->TypeUnitsUnderConstruction.clear();
3442  DD->AddrPool.resetUsedFlag();
3443 }
3444 
3446  DD->TypeUnitsUnderConstruction = std::move(TypeUnitsUnderConstruction);
3447  DD->AddrPool.resetUsedFlag(AddrPoolUsed);
3448 }
3449 
3451  return NonTypeUnitContext(this);
3452 }
3453 
3454 // Add the Name along with its companion DIE to the appropriate accelerator
3455 // table (for AccelTableKind::Dwarf it's always AccelDebugNames, for
3456 // AccelTableKind::Apple, we use the table we got as an argument). If
3457 // accelerator tables are disabled, this function does nothing.
3458 template <typename DataT>
3459 void DwarfDebug::addAccelNameImpl(const DICompileUnit &CU,
3460  AccelTable<DataT> &AppleAccel, StringRef Name,
3461  const DIE &Die) {
3463  return;
3464 
3466  CU.getNameTableKind() != DICompileUnit::DebugNameTableKind::Default)
3467  return;
3468 
3469  DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
3471 
3472  switch (getAccelTableKind()) {
3473  case AccelTableKind::Apple:
3474  AppleAccel.addName(Ref, Die);
3475  break;
3476  case AccelTableKind::Dwarf:
3477  AccelDebugNames.addName(Ref, Die);
3478  break;
3480  llvm_unreachable("Default should have already been resolved.");
3481  case AccelTableKind::None:
3482  llvm_unreachable("None handled above");
3483  }
3484 }
3485 
3487  const DIE &Die) {
3488  addAccelNameImpl(CU, AccelNames, Name, Die);
3489 }
3490 
3492  const DIE &Die) {
3493  // ObjC names go only into the Apple accelerator tables.
3495  addAccelNameImpl(CU, AccelObjC, Name, Die);
3496 }
3497 
3499  const DIE &Die) {
3500  addAccelNameImpl(CU, AccelNamespace, Name, Die);
3501 }
3502 
3504  const DIE &Die, char Flags) {
3505  addAccelNameImpl(CU, AccelTypes, Name, Die);
3506 }
3507 
3509  return Asm->OutStreamer->getContext().getDwarfVersion();
3510 }
3511 
3513  if (Asm->getDwarfVersion() >= 4)
3514  return dwarf::Form::DW_FORM_sec_offset;
3515  assert((!Asm->isDwarf64() || (Asm->getDwarfVersion() == 3)) &&
3516  "DWARF64 is not defined prior DWARFv3");
3517  return Asm->isDwarf64() ? dwarf::Form::DW_FORM_data8
3518  : dwarf::Form::DW_FORM_data4;
3519 }
3520 
3522  auto I = SectionLabels.find(S);
3523  if (I == SectionLabels.end())
3524  return nullptr;
3525  return I->second;
3526 }
3528  if (SectionLabels.insert(std::make_pair(&S->getSection(), S)).second)
3529  if (useSplitDwarf() || getDwarfVersion() >= 5)
3530  AddrPool.getIndex(S);
3531 }
3532 
3534  assert(File);
3535  if (getDwarfVersion() < 5)
3536  return None;
3537  Optional<DIFile::ChecksumInfo<StringRef>> Checksum = File->getChecksum();
3538  if (!Checksum || Checksum->Kind != DIFile::CSK_MD5)
3539  return None;
3540 
3541  // Convert the string checksum to an MD5Result for the streamer.
3542  // The verifier validates the checksum so we assume it's okay.
3543  // An MD5 checksum is 16 bytes.
3544  std::string ChecksumString = fromHex(Checksum->Value);
3545  MD5::MD5Result CKMem;
3546  std::copy(ChecksumString.begin(), ChecksumString.end(), CKMem.Bytes.data());
3547  return CKMem;
3548 }
llvm::DIScope::getFilename
StringRef getFilename() const
Definition: DebugInfoMetadata.h:639
llvm::Check::Size
@ Size
Definition: FileCheck.h:73
llvm::codeview::SimpleTypeKind::Byte
@ Byte
llvm::DwarfDebug::NonTypeUnitContext::~NonTypeUnitContext
~NonTypeUnitContext()
Definition: DwarfDebug.cpp:3445
llvm::MachineInstr::isDebugValue
bool isDebugValue() const
Definition: MachineInstr.h:1216
llvm::DwarfDebug::MinimizeAddrInV5::Disabled
@ Disabled
llvm::HexagonInstrInfo::isTailCall
bool isTailCall(const MachineInstr &MI) const override
Definition: HexagonInstrInfo.cpp:2611
llvm::MCObjectFileInfo::getDwarfRangesSection
MCSection * getDwarfRangesSection() const
Definition: MCObjectFileInfo.h:286
llvm::MCTargetOptions::DwarfVersion
int DwarfVersion
Definition: MCTargetOptions.h:60
llvm::DwarfStringPool::getEntry
EntryRef getEntry(AsmPrinter &Asm, StringRef Str)
Get a reference to an entry in the string pool.
Definition: DwarfStringPool.cpp:39
AsmPrinter.h
llvm::MCObjectFileInfo::getDwarfAddrSection
MCSection * getDwarfAddrSection() const
Definition: MCObjectFileInfo.h:316
CmpMode::FP
@ FP
llvm::AsmPrinter::emitLabelDifference
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...
Definition: AsmPrinter.cpp:2417
llvm::DICompileUnit::DebugNameTableKind::GNU
@ GNU
llvm::DwarfCompileUnit::constructSubprogramScopeDIE
DIE & constructSubprogramScopeDIE(const DISubprogram *Sub, LexicalScope *Scope)
Construct a DIE for this subprogram scope.
Definition: DwarfCompileUnit.cpp:1035
llvm::DebugHandlerBase::LScopes
LexicalScopes LScopes
Definition: DebugHandlerBase.h:78
llvm::MachineInstr::isUndefDebugValue
bool isUndefDebugValue() const
Return true if the instruction is a debug value which describes a part of a variable as unavailable.
Definition: MachineInstr.h:1245
llvm::DbgEntity::getInlinedAt
const DILocation * getInlinedAt() const
Definition: DwarfDebug.h:86
llvm::MCObjectFileInfo::getDwarfAccelObjCSection
MCSection * getDwarfAccelObjCSection() const
Definition: MCObjectFileInfo.h:298
llvm::MachineInstr::uses
iterator_range< mop_iterator > uses()
Returns a range that includes all operands that are register uses.
Definition: MachineInstr.h:666
llvm::DwarfUnit::addRnglistsBase
void addRnglistsBase()
Add the DW_AT_rnglists_base attribute to the unit DIE.
Definition: DwarfUnit.cpp:1834
llvm::DebugHandlerBase::beginInstruction
void beginInstruction(const MachineInstr *MI) override
Process beginning of an instruction.
Definition: DebugHandlerBase.cpp:347
MI
IRTranslator LLVM IR MI
Definition: IRTranslator.cpp:105
MathExtras.h
llvm::MachineLocation
Definition: MachineLocation.h:22
llvm
This file implements support for optimizing divisions by a constant.
Definition: AllocatorList.h:23
llvm::SmallVectorImpl::erase
iterator erase(const_iterator CI)
Definition: SmallVector.h:705
llvm::DIType
Base class for types.
Definition: DebugInfoMetadata.h:662
llvm::dwarf::GIEK_TYPE
@ GIEK_TYPE
Definition: Dwarf.h:528
Reg
unsigned Reg
Definition: MachineSink.cpp:1566
GenerateDwarfTypeUnits
static cl::opt< bool > GenerateDwarfTypeUnits("generate-type-units", cl::Hidden, cl::desc("Generate DWARF4 type units."), cl::init(false))
llvm::DwarfExpression::addUnsignedConstant
void addUnsignedConstant(uint64_t Value)
Emit an unsigned constant.
Definition: DwarfExpression.cpp:197
llvm::DebugHandlerBase::getLabelAfterInsn
MCSymbol * getLabelAfterInsn(const MachineInstr *MI)
Return Label immediately following the instruction.
Definition: DebugHandlerBase.cpp:143
llvm::DwarfTypeUnit::setType
void setType(const DIE *Ty)
Definition: DwarfUnit.h:370
llvm::MCSymbol
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::dwarf::MacroString
StringRef MacroString(unsigned Encoding)
Definition: Dwarf.cpp:486
llvm::MCObjectFileInfo::getDwarfMacroSection
MCSection * getDwarfMacroSection() const
Definition: MCObjectFileInfo.h:290
llvm::StringRef::empty
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:153
it
into xmm2 addss xmm2 xmm1 xmm3 addss xmm3 movaps xmm0 unpcklps xmm0 ret seems silly when it could just be one addps Expand libm rounding functions main should enable SSE DAZ mode and other fast SSE modes Think about doing i64 math in SSE regs on x86 This testcase should have no SSE instructions in it
Definition: README-SSE.txt:81
llvm::none_of
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:1565
llvm::DwarfCompileUnit::getGlobalNames
const StringMap< const DIE * > & getGlobalNames() const
Definition: DwarfCompileUnit.h:322
MinimizeAddrInV5Option
static cl::opt< DwarfDebug::MinimizeAddrInV5 > MinimizeAddrInV5Option("minimize-addr-in-v5", cl::Hidden, cl::desc("Always use DW_AT_ranges in DWARFv5 whenever it could allow more " "address pool entry sharing to reduce relocations/object size"), cl::values(clEnumValN(DwarfDebug::MinimizeAddrInV5::Default, "Default", "Default address minimization strategy"), clEnumValN(DwarfDebug::MinimizeAddrInV5::Ranges, "Ranges", "Use rnglists for contiguous ranges if that allows " "using a pre-existing base address"), clEnumValN(DwarfDebug::MinimizeAddrInV5::Expressions, "Expressions", "Use exprloc addrx+offset expressions for any " "address with a prior base address"), clEnumValN(DwarfDebug::MinimizeAddrInV5::Form, "Form", "Use addrx+offset extension form for any address " "with a prior base address"), clEnumValN(DwarfDebug::MinimizeAddrInV5::Disabled, "Disabled", "Stuff")), cl::init(DwarfDebug::MinimizeAddrInV5::Default))
llvm::MD5::update
void update(ArrayRef< uint8_t > Data)
Updates the hash for the byte stream provided.
Definition: MD5.cpp:190
llvm::DwarfDebug::getAddressPool
AddressPool & getAddressPool()
Definition: DwarfDebug.h:800
llvm::DwarfDebug::emitDebugLocEntry
void emitDebugLocEntry(ByteStreamer &Streamer, const DebugLocStream::Entry &Entry, const DwarfCompileUnit *CU)
Emit an entry for the debug loc section.
Definition: DwarfDebug.cpp:2499
DwarfSectionsAsReferences
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))
llvm::DwarfUnit::addFlag
void addFlag(DIE &Die, dwarf::Attribute Attribute)
Add a flag that is true to the DIE.
Definition: DwarfUnit.cpp:221
MCTargetOptions.h
llvm::SymbolCU::Sym
const MCSymbol * Sym
Definition: DwarfDebug.h:282
llvm::MachineFunction::getVariableDbgInfo
VariableDbgInfoMapTy & getVariableDbgInfo()
Definition: MachineFunction.h:1174
llvm::MCContext::getDwarfFormat
dwarf::DwarfFormat getDwarfFormat() const
Definition: MCContext.h:790
llvm::MCObjectFileInfo::getDwarfPubTypesSection
MCSection * getDwarfPubTypesSection() const
Definition: MCObjectFileInfo.h:273
llvm::AsmPrinter::emitULEB128
void emitULEB128(uint64_t Value, const char *Desc=nullptr, unsigned PadTo=0) const
Emit the specified unsigned leb128 value.
Definition: AsmPrinterDwarf.cpp:47
llvm::DbgEntity
This class is defined as the common parent of DbgVariable and DbgLabel such that it could levarage po...
Definition: DwarfDebug.h:67
llvm::Module::isDwarf64
bool isDwarf64() const
Returns the DWARF format by checking module flags.
Definition: Module.cpp:566
llvm::DebuggerKind
DebuggerKind
Identify a debugger for "tuning" the debug info.
Definition: TargetOptions.h:97
llvm::AccelTableKind::Dwarf
@ Dwarf
DWARF v5 .debug_names.
UnknownLocations
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))
llvm::MachineOperand::getGlobal
const GlobalValue * getGlobal() const
Definition: MachineOperand.h:563
addToFwdRegWorklist
static void addToFwdRegWorklist(FwdRegWorklist &Worklist, unsigned Reg, const DIExpression *Expr, ArrayRef< FwdRegParamInfo > ParamsToAdd)
Add Reg to the worklist, if it's not already present, and mark that the given parameter registers' va...
Definition: DwarfDebug.cpp:650
llvm::AsmPrinter::createTempSymbol
MCSymbol * createTempSymbol(const Twine &Name) const
Definition: AsmPrinter.cpp:3112
llvm::AsmPrinter::getDwarfDebug
DwarfDebug * getDwarfDebug()
Definition: AsmPrinter.h:221
llvm::MachineInstr::debug_operands
iterator_range< mop_iterator > debug_operands()
Returns a range over all operands that are used to determine the variable location for this DBG_VALUE...
Definition: MachineInstr.h:640
emitMacroHeader
static void emitMacroHeader(AsmPrinter *Asm, const DwarfDebug &DD, const DwarfCompileUnit &CU, uint16_t DwarfVersion)
Emit the header of a DWARF 5 macro section, or the GNU extension for DWARF 4.
Definition: DwarfDebug.cpp:3109
llvm::Function
Definition: Function.h:62
llvm::DebugLocStream::List
Definition: DebugLocStream.h:33
llvm::DenseMapBase< SmallDenseMap< KeyT, ValueT, 4, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >, KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >::lookup
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:197
llvm::Value::dump
void dump() const
Support for debugging, callable in GDB: V->dump()
Definition: AsmWriter.cpp:4807
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
llvm::DwarfUnit::getOrCreateContextDIE
DIE * getOrCreateContextDIE(const DIScope *Context)
Get context owner's DIE.
Definition: DwarfUnit.cpp:539
Pass.h
llvm::TargetSubtargetInfo::getInstrInfo
virtual const TargetInstrInfo * getInstrInfo() const
Definition: TargetSubtargetInfo.h:92
llvm::DwarfCompileUnit
Definition: DwarfCompileUnit.h:47
llvm::DwarfFile::getAbstractSPDies
DenseMap< const MDNode *, DIE * > & getAbstractSPDies()
Definition: DwarfFile.h:165
llvm::MachineBasicBlock::instrs
instr_range instrs()
Definition: MachineBasicBlock.h:263
DwarfLinkageNames
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))
llvm::MCObjectFileInfo::getDwarfLoclistsSection
MCSection * getDwarfLoclistsSection() const
Definition: MCObjectFileInfo.h:288
llvm::AsmPrinter::MAI
const MCAsmInfo * MAI
Target Asm Printer information.
Definition: AsmPrinter.h:88
llvm::DIEValue
Definition: DIE.h:369
llvm::DwarfDebug::emitDebugEntryValues
bool emitDebugEntryValues() const
Definition: DwarfDebug.h:761
llvm::lltok::LocalVar
@ LocalVar
Definition: LLToken.h:476
llvm::TargetIndexLocation
This struct describes target specific location.
Definition: DebugLocEntry.h:24
llvm::StringRef::npos
static constexpr size_t npos
Definition: StringRef.h:60
ULEB128PadSize
static constexpr unsigned ULEB128PadSize
Definition: DwarfDebug.cpp:174
llvm::dwarf::GIEL_EXTERNAL
@ GIEL_EXTERNAL
Definition: Dwarf.h:537
llvm::MCSection::getBeginSymbol
MCSymbol * getBeginSymbol()
Definition: MCSection.h:127
llvm::ilist_node_with_parent::getNextNode
NodeTy * getNextNode()
Get the next node, or nullptr for the list tail.
Definition: ilist_node.h:288
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1168
Statistic.h
llvm::dwarf::GDBIndexEntryLinkageString
StringRef GDBIndexEntryLinkageString(GDBIndexEntryLinkage Linkage)
Definition: Dwarf.cpp:629
llvm::DbgVariable::initializeDbgValue
void initializeDbgValue(DbgValueLoc Value)
Definition: DwarfDebug.h:152
llvm::DebugLocStream::Entry
Definition: DebugLocStream.h:40
llvm::LexicalScope
LexicalScope - This class is used to track scope information.
Definition: LexicalScopes.h:44
llvm::enumerate
detail::enumerator< R > enumerate(R &&TheRange)
Given an input range, returns a new range whose values are are pair (A,B) such that A is the 0-based ...
Definition: STLExtras.h:1981
llvm::dwarf::Form
Form
Definition: Dwarf.h:131
llvm::Function::getSubprogram
DISubprogram * getSubprogram() const
Get the attached subprogram.
Definition: Metadata.cpp:1541
ErrorHandling.h
llvm::DwarfDebug::addAccelName
void addAccelName(const DICompileUnit &CU, StringRef Name, const DIE &Die)
Definition: DwarfDebug.cpp:3486
llvm::AccelTable::addName
void addName(DwarfStringPoolEntryRef Name, Types &&... Args)
Definition: AccelTable.h:207
llvm::GlobalVariable
Definition: GlobalVariable.h:40
llvm::erase_if
void erase_if(Container &C, UnaryPredicate P)
Provide a container algorithm similar to C++ Library Fundamentals v2's erase_if which is equivalent t...
Definition: STLExtras.h:1732
llvm::SmallDenseMap
Definition: DenseMap.h:880
llvm::MachineFunction::back
const MachineBasicBlock & back() const
Definition: MachineFunction.h:822
llvm::DwarfDebug::skippedNonDebugFunction
void skippedNonDebugFunction() override
Definition: DwarfDebug.cpp:2175
llvm::Triple
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:45
MachineBasicBlock.h
llvm::DIScope::getName
StringRef getName() const
Definition: DebugInfoMetadata.cpp:261
llvm::AddressPool::resetUsedFlag
void resetUsedFlag(bool HasBeenUsed=false)
Definition: AddressPool.h:51
llvm::TargetSubtargetInfo::getRegisterInfo
virtual const TargetRegisterInfo * getRegisterInfo() const
getRegisterInfo - If register information is available, return it.
Definition: TargetSubtargetInfo.h:124
llvm::cl::Hidden
@ Hidden
Definition: CommandLine.h:143
llvm::DebugHandlerBase::PrevInstLoc
DebugLoc PrevInstLoc
Previous instruction's location information.
Definition: DebugHandlerBase.h:67
llvm::MachineModuleInfo::hasDebugInfo
bool hasDebugInfo() const
Returns true if valid debug info is present.
Definition: MachineModuleInfo.h:203
APInt.h
llvm::TargetRegisterInfo
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
Definition: TargetRegisterInfo.h:233
llvm::DwarfFile::addScopeVariable
bool addScopeVariable(LexicalScope *LS, DbgVariable *Var)
Definition: DwarfFile.cpp:106
llvm::DILocation
Debug location.
Definition: DebugInfoMetadata.h:1580
llvm::Module::debug_compile_units
iterator_range< debug_compile_units_iterator > debug_compile_units() const
Return an iterator for all DICompileUnits listed in this Module's llvm.dbg.cu named metadata node and...
Definition: Module.h:779
llvm::Function::getContext
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function.
Definition: Function.cpp:321
llvm::DIE::getUnitDie
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:203
llvm::DebugHandlerBase::beginModule
void beginModule(Module *M) override
Definition: DebugHandlerBase.cpp:104
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::DwarfCompileUnit::attachRangesOrLowHighPC
void attachRangesOrLowHighPC(DIE &D, SmallVector< RangeSpan, 2 > Ranges)
Definition: DwarfCompileUnit.cpp:594
llvm::DwarfExpression::TagOffset
Optional< uint8_t > TagOffset
Definition: DwarfExpression.h:173
Module.h
llvm::DwarfUnit::addString
void addString(DIE &Die, dwarf::Attribute Attribute, StringRef Str)
Add a string attribute data and value.
Definition: DwarfUnit.cpp:254
llvm::ilist_node_impl::getReverseIterator
reverse_self_iterator getReverseIterator()
Definition: ilist_node.h:84
TargetInstrInfo.h
llvm::AsmPrinter::getDwarfOffsetByteSize
unsigned int getDwarfOffsetByteSize() const
Returns 4 for DWARF32 and 8 for DWARF64.
Definition: AsmPrinter.cpp:3613
hasObjCCategory
static bool hasObjCCategory(StringRef Name)
Definition: DwarfDebug.cpp:479
llvm::dwarf::DWARF_VERSION
@ DWARF_VERSION
Other constants.
Definition: Dwarf.h:62
llvm::DwarfTypeUnit
Definition: DwarfUnit.h:354
llvm::DwarfFile::getUnits
const SmallVectorImpl< std::unique_ptr< DwarfCompileUnit > > & getUnits()
Definition: DwarfFile.h:101
llvm::DebugLocStream::getComments
ArrayRef< std::string > getComments(const Entry &E) const
Definition: DebugLocStream.h:121
llvm::dwarf::RangeListEncodingString
StringRef RangeListEncodingString(unsigned Encoding)
Definition: Dwarf.cpp:514
llvm::DebugLocStream::getBytes
ArrayRef< char > getBytes(const Entry &E) const
Definition: DebugLocStream.h:116
llvm::DwarfDebug::addAccelObjC
void addAccelObjC(const DICompileUnit &CU, StringRef Name, const DIE &Die)
Definition: DwarfDebug.cpp:3491
llvm::DebugHandlerBase::requestLabelAfterInsn
void requestLabelAfterInsn(const MachineInstr *MI)
Ensure that a label will be emitted after MI.
Definition: DebugHandlerBase.h:105
llvm::MCObjectFileInfo::getDwarfLocSection
MCSection * getDwarfLocSection() const
Definition: MCObjectFileInfo.h:284
computeAccelTableKind
static AccelTableKind computeAccelTableKind(unsigned DwarfVersion, bool GenerateTypeUnits, DebuggerKind Tuning, const Triple &TT)
Definition: DwarfDebug.cpp:327
llvm::MachineInstr::getMF
const MachineFunction * getMF() const
Return the function that contains the basic block that this instruction belongs to.
Definition: MachineInstr.cpp:666
llvm::AsmPrinter::emitDwarfOffset
void emitDwarfOffset(const MCSymbol *Label, uint64_t Offset) const
Emit something like ".long Label + Offset" or ".quad Label + Offset" depending on the DWARF format.
Definition: AsmPrinterDwarf.cpp:192
llvm::MCAsmInfo::getCodePointerSize
unsigned getCodePointerSize() const
Get the code pointer size in bytes.
Definition: MCAsmInfo.h:536
llvm::Optional
Definition: APInt.h:33
llvm::DwarfDebug::endModule
void endModule() override
Emit all Dwarf sections that should come after the content.
Definition: DwarfDebug.cpp:1409
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:81
llvm::MapVector
This class implements a map that also provides access to all stored values in a deterministic order.
Definition: MapVector.h:37
llvm::DwarfCompileUnit::getGlobalTypes
const StringMap< const DIE * > & getGlobalTypes() const
Definition: DwarfCompileUnit.h:323
llvm::DWARFExpression::Operation::Encoding
Encoding
Size and signedness of expression operations' operands.
Definition: DWARFExpression.h:38
llvm::APByteStreamer
Definition: ByteStreamer.h:38
llvm::dwarf::GIEK_VARIABLE
@ GIEK_VARIABLE
Definition: Dwarf.h:529
llvm::DwarfDebug::NonTypeUnitContext
Definition: DwarfDebug.h:669
llvm::DIE
A structured debug information entry.
Definition: DIE.h:739
llvm::AddressPool::isEmpty
bool isEmpty()
Definition: AddressPool.h:47
llvm::MCObjectFileInfo::getDwarfStrOffSection
MCSection * getDwarfStrOffSection() const
Definition: MCObjectFileInfo.h:315
llvm::AsmPrinter::emitLabelReference
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:596
llvm::TargetRegisterInfo::isCalleeSavedPhysReg
virtual bool isCalleeSavedPhysReg(MCRegister PhysReg, const MachineFunction &MF) const
This is a wrapper around getCallPreservedMask().
Definition: TargetRegisterInfo.cpp:464
llvm::AccelTable
This class holds an abstract representation of an Accelerator Table, consisting of a sequence of buck...
Definition: AccelTable.h:197
llvm::DIExpression
DWARF expression.
Definition: DebugInfoMetadata.h:2586
llvm::DIE::getTag
dwarf::Tag getTag() const
Definition: DIE.h:775
llvm::DWARFDataExtractor
A DataExtractor (typically for an in-memory copy of an object-file section) plus a relocation map for...
Definition: DWARFDataExtractor.h:21
llvm::DebuggerKind::GDB
@ GDB
Tune debug info for gdb.
AbstractLinkageNames
@ AbstractLinkageNames
Definition: DwarfDebug.cpp:141
llvm::DwarfStringPool::getIndexedEntry
EntryRef getIndexedEntry(AsmPrinter &Asm, StringRef Str)
Same as getEntry, except that you can use EntryRef::getIndex to obtain a unique ID of this entry (e....
Definition: DwarfStringPool.cpp:45
llvm::DebugLocStream::setSym
void setSym(MCSymbol *Sym)
Definition: DebugLocStream.h:66
llvm::MCObjectFileInfo::getDwarfGnuPubTypesSection
MCSection * getDwarfGnuPubTypesSection() const
Definition: MCObjectFileInfo.h:277
llvm::DwarfDebug::useSectionsAsReferences
bool useSectionsAsReferences() const
Returns whether to use sections as labels rather than temp symbols.
Definition: DwarfDebug.h:728
llvm::detail::DenseSetImpl< ValueT, DenseMap< ValueT, detail::DenseSetEmpty, DenseMapInfo< ValueT >, detail::DenseSetPair< ValueT > >, DenseMapInfo< ValueT > >::insert
std::pair< iterator, bool > insert(const ValueT &V)
Definition: DenseSet.h:206
llvm::LexicalScope::getRanges
SmallVectorImpl< InsnRange > & getRanges()
Definition: LexicalScopes.h:66
llvm::detail::DenseSetImpl< ValueT, DenseMap< ValueT, detail::DenseSetEmpty, DenseMapInfo< ValueT >, detail::DenseSetPair< ValueT > >, DenseMapInfo< ValueT > >::count
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:97
llvm::dwarf::GIEL_STATIC
@ GIEL_STATIC
Definition: Dwarf.h:537
TRI
unsigned const TargetRegisterInfo * TRI
Definition: MachineSink.cpp:1567
llvm::DwarfExpression::setLocation
void setLocation(const MachineLocation &Loc, const DIExpression *DIExpr)
Set the location (Loc) and DIExpression (DIExpr) to describe.
Definition: DwarfExpression.cpp:380
clEnumVal
#define clEnumVal(ENUMVAL, DESC)
Definition: CommandLine.h:670
llvm::Data
@ Data
Definition: SIMachineScheduler.h:55
llvm::DwarfDebug::emitDebugLocEntryLocation
void emitDebugLocEntryLocation(const DebugLocStream::Entry &Entry, const DwarfCompileUnit *CU)
Emit the location for a debug loc entry, including the size header.
Definition: DwarfDebug.cpp:2671
llvm::ByteStreamer::emitSLEB128
virtual void emitSLEB128(uint64_t DWord, const Twine &Comment="")=0
llvm::DwarfDebug::addDwarfTypeUnitType
void addDwarfTypeUnitType(DwarfCompileUnit &CU, StringRef Identifier, DIE &Die, const DICompositeType *CTy)
Add a DIE to the set of types that we're going to pull into type units.
Definition: DwarfDebug.cpp:3352
llvm::MCObjectFileInfo::getDwarfInfoSection
MCSection * getDwarfInfoSection() const
Definition: MCObjectFileInfo.h:265
llvm::DwarfStringPoolEntryRef
String pool entry reference.
Definition: DwarfStringPoolEntry.h:31
LLVM_DEBUG
#define LLVM_DEBUG(X)
Definition: Debug.h:101
llvm::dwarf::Attribute
Attribute
Attributes.
Definition: Dwarf.h:124
llvm::ArrayRef::data
const T * data() const
Definition: ArrayRef.h:162
llvm::MDNode::get
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition: Metadata.h:1233
llvm::MCObjectFileInfo::getDwarfLoclistsDWOSection
MCSection * getDwarfLoclistsDWOSection() const
Definition: MCObjectFileInfo.h:320
F
#define F(x, y, z)
Definition: MD5.cpp:56
llvm::dwarf::GnuMacroString
StringRef GnuMacroString(unsigned Encoding)
Definition: Dwarf.cpp:497
llvm::RISCVFenceField::R
@ R
Definition: RISCVBaseInfo.h:198
findPrologueEndLoc
static DebugLoc findPrologueEndLoc(const MachineFunction *MF)
Definition: DwarfDebug.cpp:2082
llvm::dwarf::DW_MACINFO_end_file
@ DW_MACINFO_end_file
Definition: Dwarf.h:384
llvm::MachineBasicBlock::isBeginSection
bool isBeginSection() const
Returns true if this block begins any section.
Definition: MachineBasicBlock.h:564
llvm::MCObjectFileInfo::getDwarfPubNamesSection
MCSection * getDwarfPubNamesSection() const
Definition: MCObjectFileInfo.h:272
llvm::DwarfFile::setRnglistsTableBaseSym
void setRnglistsTableBaseSym(MCSymbol *Sym)
Definition: DwarfFile.h:150
llvm::getBundleEnd
MachineBasicBlock::instr_iterator getBundleEnd(MachineBasicBlock::instr_iterator I)
Returns an iterator pointing beyond the bundle containing I.
Definition: MachineInstrBundle.h:60
llvm::TargetLoweringObjectFile
Definition: TargetLoweringObjectFile.h:43
llvm::dbgs
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
llvm::DwarfExpression
Base class containing the logic for constructing DWARF expressions independently of whether they are ...
Definition: DwarfExpression.h:106
llvm::AddressPool::setLabel
void setLabel(MCSymbol *Sym)
Definition: AddressPool.h:54
llvm::ARMBuildAttrs::Section
@ Section
Legacy Tags.
Definition: ARMBuildAttributes.h:78
llvm::DwarfDebug::insertSectionLabel
void insertSectionLabel(const MCSymbol *S)
Definition: DwarfDebug.cpp:3527
llvm::DIEHash
An object containing the capability of hashing and adding hash attributes onto a DIE.
Definition: DIEHash.h:26
llvm::DwarfDebug::addAccelNamespace
void addAccelNamespace(const DICompileUnit &CU, StringRef Name, const DIE &Die)
Definition: DwarfDebug.cpp:3498
ArangeSpan::Start
const MCSymbol * Start
Definition: DwarfDebug.cpp:2897
llvm::emitAppleAccelTable
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:303
llvm::MachineBasicBlock::getSymbol
MCSymbol * getSymbol() const
Return the MCSymbol for this basic block.
Definition: MachineBasicBlock.cpp:60
CommandLine.h
llvm::DwarfDebug::isLexicalScopeDIENull
bool isLexicalScopeDIENull(LexicalScope *Scope)
A helper function to check whether the DIE for a given Scope is going to be null.
Definition: DwarfDebug.cpp:537
DwarfExpression.h
TargetLowering.h
getDebugLocValue
static DbgValueLoc getDebugLocValue(const MachineInstr *MI)
Get .debug_loc entry for the instruction range starting at MI.
Definition: DwarfDebug.cpp:236
llvm::AccelTableKind::None
@ None
None.
llvm::all_of
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:1551
llvm::DwarfCompileUnit::takeRanges
SmallVector< RangeSpan, 2 > takeRanges()
Definition: DwarfCompileUnit.h:355
llvm::MachineFunction::front
const MachineBasicBlock & front() const
Definition: MachineFunction.h:820
DWARF2_FLAG_IS_STMT
#define DWARF2_FLAG_IS_STMT
Definition: MCDwarf.h:106
llvm::DwarfDebug::useAllLinkageNames
bool useAllLinkageNames() const
Returns whether we should emit all DW_AT_[MIPS_]linkage_name.
Definition: DwarfDebug.h:693
llvm::BufferByteStreamer::GenerateComments
const bool GenerateComments
Only verbose textual output needs comments.
Definition: ByteStreamer.h:85
llvm::MachineInstr::isCall
bool isCall(QueryType Type=AnyInBundle) const
Definition: MachineInstr.h:823
llvm::TargetInstrInfo
TargetInstrInfo - Interface to description of machine instruction set.
Definition: TargetInstrInfo.h:97
llvm::MD5::final
void final(MD5Result &Result)
Finishes off the hash and puts the result in result.
Definition: MD5.cpp:235
llvm::DebugHandlerBase::PrologEndLoc
DebugLoc PrologEndLoc
This location indicates end of function prologue and beginning of function body.
Definition: DebugHandlerBase.h:73
TargetMachine.h
llvm::MCSymbol::getSection
MCSection & getSection() const
Get the section associated with a defined, non-absolute symbol.
Definition: MCSymbol.h:262
llvm::ModRefInfo::Ref
@ Ref
The access may reference the value stored in memory.
NoDwarfRangesSection
static cl::opt< bool > NoDwarfRangesSection("no-dwarf-ranges-section", cl::Hidden, cl::desc("Disable emission .debug_ranges section."), cl::init(false))
Constants.h
llvm::DwarfFile::emitUnit
void emitUnit(DwarfUnit *TheU, bool UseOffsets)
Emit the given unit to its section.
Definition: DwarfFile.cpp:36
interpretValues
static void interpretValues(const MachineInstr *CurMI, FwdRegWorklist &ForwardedRegWorklist, ParamSet &Params)
Interpret values loaded into registers by CurMI.
Definition: DwarfDebug.cpp:672
getObjCMethodName
static StringRef getObjCMethodName(StringRef In)
Definition: DwarfDebug.cpp:498
MD5.h
llvm::DwarfDebug::getMD5AsBytes
Optional< MD5::MD5Result > getMD5AsBytes(const DIFile *File) const
If the File has an MD5 checksum, return it as an MD5Result allocated in the MCContext.
Definition: DwarfDebug.cpp:3533
llvm::DILocalVariable
Local variable.
Definition: DebugInfoMetadata.h:3097
llvm::DwarfUnit::constructContainingTypeDIEs
void constructContainingTypeDIEs()
Construct DIEs for types that contain vtables.
Definition: DwarfUnit.cpp:1560
llvm::MCObjectFileInfo::getDwarfARangesSection
MCSection * getDwarfARangesSection() const
Definition: MCObjectFileInfo.h:285
llvm::DIMacro
Definition: DebugInfoMetadata.h:3491
llvm::DebugHandlerBase::Asm
AsmPrinter * Asm
Target of debug info emission.
Definition: DebugHandlerBase.h:58
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::DebugLoc::getCol
unsigned getCol() const
Definition: DebugLoc.cpp:30
llvm::DIScope::getSource
Optional< StringRef > getSource() const
Definition: DebugInfoMetadata.h:651
llvm::DwarfCompileUnit::setDWOId
void setDWOId(uint64_t DwoId)
Definition: DwarfCompileUnit.h:361
llvm::MCDwarfLineTableParams
Definition: MCDwarf.h:224
llvm::dwarf::PubIndexEntryDescriptor::toBits
uint8_t toBits() const
Definition: Dwarf.h:727
llvm::AsmPrinter::OutStreamer
std::unique_ptr< MCStreamer > OutStreamer
This is the MCStreamer object for the file we are generating.
Definition: AsmPrinter.h:97
llvm::ARM_PROC::A
@ A
Definition: ARMBaseInfo.h:34
llvm::DwarfDebug::addSubprogramNames
void addSubprogramNames(const DICompileUnit &CU, const DISubprogram *SP, DIE &Die)
Definition: DwarfDebug.cpp:503
Twine.h
llvm::DwarfExpression::addConstantFP
void addConstantFP(const APFloat &Value, const AsmPrinter &AP)
Emit an floating point constant.
Definition: DwarfExpression.cpp:223
llvm::DwarfUnit::addSectionLabel
void addSectionLabel(DIE &Die, dwarf::Attribute Attribute, const MCSymbol *Label, const MCSymbol *Sec)
Add a Dwarf section label attribute data and value.
Definition: DwarfUnit.cpp:1795
MCContext.h
llvm::AccelTableKind::Apple
@ Apple
.apple_names, .apple_namespaces, .apple_types, .apple_objc.
llvm::DICompileUnit::LineTablesOnly
@ LineTablesOnly
Definition: DebugInfoMetadata.h:1343
llvm::Register::isPhysicalRegister
static bool isPhysicalRegister(unsigned Reg)
Return true if the specified register number is in the physical register namespace.
Definition: Register.h:65
llvm::DwarfExpression::finalize
void finalize()
This needs to be called last to commit any pending changes.
Definition: DwarfExpression.cpp:644
DefaultLinkageNames
@ DefaultLinkageNames
Definition: DwarfDebug.cpp:139
MCSymbol.h
llvm::MCObjectFileInfo::getDwarfMacinfoSection
MCSection * getDwarfMacinfoSection() const
Definition: MCObjectFileInfo.h:289
Param
Value * Param
Definition: NVPTXLowerArgs.cpp:163
llvm::MCTargetOptions::SplitDwarfFile
std::string SplitDwarfFile
Definition: MCTargetOptions.h:64
llvm::MCObjectFileInfo::getDwarfInfoDWOSection
MCSection * getDwarfInfoDWOSection() const
Definition: MCObjectFileInfo.h:305
llvm::BitTracker
Definition: BitTracker.h:35
llvm::TargetOptions::MCOptions
MCTargetOptions MCOptions
Machine level options.
Definition: TargetOptions.h:420
emitRangeList
static void emitRangeList(DwarfDebug &DD, AsmPrinter *Asm, MCSymbol *Sym, const Ranges &R, const DwarfCompileUnit &CU, unsigned BaseAddressx, unsigned OffsetPair, unsigned StartxLength, unsigned EndOfList, StringRef(*StringifyEnum)(unsigned), bool ShouldUseBaseAddress, PayloadEmitter EmitPayload)
Definition: DwarfDebug.cpp:2729
llvm::MD5::MD5Result::Bytes
std::array< uint8_t, 16 > Bytes
Definition: MD5.h:44
llvm::InstructionOrdering::isBefore
bool isBefore(const MachineInstr *A, const MachineInstr *B) const
Check if instruction A comes before B, where A and B both belong to the MachineFunction passed to ini...
Definition: DbgEntityHistoryCalculator.cpp:63
llvm::DwarfUnit::addSectionDelta
void addSectionDelta(DIE &Die, dwarf::Attribute Attribute, const MCSymbol *Hi, const MCSymbol *Lo)
addSectionDelta - Add a label delta attribute data and value.
Definition: DwarfUnit.cpp:1789
TII
const HexagonInstrInfo * TII
Definition: HexagonCopyToCombine.cpp:129
FwdRegParamInfo::ParamReg
unsigned ParamReg
The described parameter register.
Definition: DwarfDebug.cpp:594
B
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
llvm::MachineOperand
MachineOperand class - Representation of each machine instruction operand.
Definition: MachineOperand.h:49
llvm::DwarfExpression::setMemoryLocationKind
void setMemoryLocationKind()
Lock this down to become a memory location description.
Definition: DwarfExpression.h:307
llvm::MCContext::getDwarfVersion
uint16_t getDwarfVersion() const
Definition: MCContext.h:793
llvm::MCObjectFileInfo::getDwarfLocDWOSection
MCSection * getDwarfLocDWOSection() const
Definition: MCObjectFileInfo.h:313
llvm::DwarfExpression::addMachineRegExpression
bool addMachineRegExpression(const TargetRegisterInfo &TRI, DIExpressionCursor &Expr, llvm::Register MachineReg, unsigned FragmentOffsetInBits=0)
Emit a machine register location.
Definition: DwarfExpression.cpp:250
llvm::DwarfUnit::getCUNode
const DICompileUnit * getCUNode() const
Definition: DwarfUnit.h:101
llvm::MachineInstr::FrameSetup
@ FrameSetup
Definition: MachineInstr.h:82
llvm::DebugHandlerBase::requestLabelBeforeInsn
void requestLabelBeforeInsn(const MachineInstr *MI)
Ensure that a label will be emitted before MI.
Definition: DebugHandlerBase.h:100
llvm::DICompileUnit::getSplitDebugInlining
bool getSplitDebugInlining() const
Definition: DebugInfoMetadata.h:1499
llvm::MachineBasicBlock::rend
reverse_iterator rend()
Definition: MachineBasicBlock.h:278
LexicalScopes.h
llvm::report_fatal_error
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:140
llvm::DwarfExpression::addWasmLocation
void addWasmLocation(unsigned Index, uint64_t Offset)
Emit location information expressed via WebAssembly location + offset The Index is an identifier for ...
Definition: DwarfExpression.cpp:689
llvm::STATISTIC
STATISTIC(NumFunctions, "Total number of functions")
llvm::DICompileUnit::getEmissionKind
static Optional< DebugEmissionKind > getEmissionKind(StringRef Str)
Definition: DebugInfoMetadata.cpp:774
llvm::TargetRegisterInfo::regsOverlap
bool regsOverlap(Register regA, Register regB) const
Returns true if the two registers are equal or alias each other.
Definition: TargetRegisterInfo.h:418
llvm::MachineFunction::begin
iterator begin()
Definition: MachineFunction.h:808
llvm::DbgValueHistoryMap::hasNonEmptyLocation
bool hasNonEmptyLocation(const Entries &Entries) const
Test whether a vector of entries features any non-empty locations.
Definition: DbgEntityHistoryCalculator.cpp:260
llvm::DwarfFile::emitStrings
void emitStrings(MCSection *StrSection, MCSection *OffsetSection=nullptr, bool UseRelativeOffsets=false)
Emit all of the strings to the section given.
Definition: DwarfFile.cpp:101
llvm::DwarfCompileUnit::initStmtList
void initStmtList()
Definition: DwarfCompileUnit.cpp:372
emitLocList
static void emitLocList(DwarfDebug &DD, AsmPrinter *Asm, const DebugLocStream::List &List)
Definition: DwarfDebug.cpp:2825
llvm::iterator_range::empty
bool empty() const
Definition: iterator_range.h:46
DwarfDebug.h
llvm::MCObjectFileInfo::getDwarfStrDWOSection
MCSection * getDwarfStrDWOSection() const
Definition: MCObjectFileInfo.h:311
llvm::AsmPrinter::emitDwarfSymbolReference
void emitDwarfSymbolReference(const MCSymbol *Label, bool ForceOffset=false) const
Emit a reference to a symbol for use in dwarf.
Definition: AsmPrinterDwarf.cpp:158
llvm::DwarfFile::getScopeLabels
DenseMap< LexicalScope *, LabelList > & getScopeLabels()
Definition: DwarfFile.h:161
llvm::DebugLocStream::getLists
ArrayRef< List > getLists() const
Definition: DebugLocStream.h:62
llvm::DbgVariable
This class is used to track local variable information.
Definition: DwarfDebug.h:116
AllLinkageNames
@ AllLinkageNames
Definition: DwarfDebug.cpp:140
llvm::AsmPrinter::emitInt8
void emitInt8(int Value) const
Emit a byte directive and value.
Definition: AsmPrinter.cpp:2401
llvm::Align
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
llvm::Metadata
Root of the metadata hierarchy.
Definition: Metadata.h:62
llvm::dwarf::GDBIndexEntryKindString
StringRef GDBIndexEntryKindString(GDBIndexEntryKind Kind)
Definition: Dwarf.cpp:606
finishCallSiteParams
static void finishCallSiteParams(ValT Val, const DIExpression *Expr, ArrayRef< FwdRegParamInfo > DescribedParams, ParamSet &Params)
Emit call site parameter entries that are described by the given value and debug expression.
Definition: DwarfDebug.cpp:619
llvm::DebugHandlerBase::getLabelBeforeInsn
MCSymbol * getLabelBeforeInsn(const MachineInstr *MI)
Return Label preceding the instruction.
Definition: DebugHandlerBase.cpp:136
llvm::StringRef::str
LLVM_NODISCARD std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:245
llvm::MCObjectFileInfo::getDwarfAccelNamespaceSection
MCSection * getDwarfAccelNamespaceSection() const
Definition: MCObjectFileInfo.h:299
llvm::SetVector< T, SmallVector< T, N >, SmallDenseSet< T, N > >::empty
bool empty() const
Determine if the SetVector is empty or not.
Definition: SetVector.h:72
llvm::None
const NoneType None
Definition: None.h:23
llvm::AsmPrinter::getFunctionBegin
MCSymbol * getFunctionBegin() const
Definition: AsmPrinter.h:247
llvm::MCObjectFileInfo::getDwarfRnglistsSection
MCSection * getDwarfRnglistsSection() const
Definition: MCObjectFileInfo.h:287
llvm::erase_value
void erase_value(Container &C, ValueType V)
Wrapper function to remove a value from a container:
Definition: STLExtras.h:1740
llvm::DIMacroFile::getLine
unsigned getLine() const
Definition: DebugInfoMetadata.h:3587
llvm::InstructionOrdering
Record instruction ordering so we can query their relative positions within a function.
Definition: DbgEntityHistoryCalculator.h:31
llvm::MachineBasicBlock
Definition: MachineBasicBlock.h:95
llvm::StringMap
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Definition: StringMap.h:108
DIE.h
llvm::DwarfCompileUnit::constructAbstractSubprogramScopeDIE
void constructAbstractSubprogramScopeDIE(LexicalScope *Scope)
Definition: DwarfCompileUnit.cpp:1076
llvm::DbgCallSiteParam
Used for tracking debug info about call site parameters.
Definition: DwarfDebug.h:260
llvm::MachineInstr::AnyInBundle
@ AnyInBundle
Definition: MachineInstr.h:767
ArangeSpan
Definition: DwarfDebug.cpp:2896
validThroughout
static bool validThroughout(LexicalScopes &LScopes, const MachineInstr *DbgValue, const MachineInstr *RangeEnd, const InstructionOrdering &Ordering)
Determine whether a singular DBG_VALUE is valid for the entirety of its enclosing lexical scope.
Definition: DwarfDebug.cpp:1551
llvm::MachineBasicBlock::getSectionIDNum
unsigned getSectionIDNum() const
Returns the unique section ID number of this basic block.
Definition: MachineBasicBlock.h:577
llvm::DebugLocStream::ListBuilder
Builder for DebugLocStream lists.
Definition: DebugLocStream.h:156
llvm::ARM_PROC::IE
@ IE
Definition: ARMBaseInfo.h:27
llvm::DebuggerKind::DBX
@ DBX
Tune debug info for dbx.
llvm::DIExpression::append
static DIExpression * append(const DIExpression *Expr, ArrayRef< uint64_t > Ops)
Append the opcodes Ops to DIExpr.
Definition: DebugInfoMetadata.cpp:1392
llvm::LexicalScopes::getOrCreateAbstractScope
LexicalScope * getOrCreateAbstractScope(const DILocalScope *Scope)
getOrCreateAbstractScope - Find or create an abstract lexical scope.
Definition: LexicalScopes.cpp:212
llvm::DIEHash::computeCUSignature
uint64_t computeCUSignature(StringRef DWOName, const DIE &Die)
Computes the CU signature.
Definition: DIEHash.cpp:392
llvm::DwarfCompileUnit::setSkeleton
void setSkeleton(DwarfCompileUnit &Skel)
Set the skeleton unit associated with this unit.
Definition: DwarfCompileUnit.h:280
llvm::DIExpression::isImplicit
bool isImplicit() const
Return whether this is an implicit location description.
Definition: DebugInfoMetadata.cpp:1177
llvm::DenseSet
Implements a dense probed hash-table based set.
Definition: DenseSet.h:268
llvm::MachineFunction::getSubtarget
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
Definition: MachineFunction.h:626
llvm::tgtok::In
@ In
Definition: TGLexer.h:51
Timer.h
llvm::cl::opt< bool >
llvm::dwarf::PubIndexEntryDescriptor::Linkage
GDBIndexEntryLinkage Linkage
Definition: Dwarf.h:717
SplitDwarfCrossCuReferences
static cl::opt< bool > SplitDwarfCrossCuReferences("split-dwarf-cross-cu-references", cl::Hidden, cl::desc("Enable cross-cu references in DWO files"), cl::init(false))
llvm::DwarfStringPool::emitStringOffsetsTableHeader
void emitStringOffsetsTableHeader(AsmPrinter &Asm, MCSection *OffsetSection, MCSymbol *StartSym)
Definition: DwarfStringPool.cpp:53
llvm::DwarfDebug::getDwarfSectionOffsetForm
dwarf::Form getDwarfSectionOffsetForm() const
Returns a suitable DWARF form to represent a section offset, i.e.
Definition: DwarfDebug.cpp:3512
llvm::DICompileUnit::getDWOId
uint64_t getDWOId() const
Definition: DebugInfoMetadata.h:1497
llvm::DebugHandlerBase::PrevInstBB
const MachineBasicBlock * PrevInstBB
Definition: DebugHandlerBase.h:69
llvm::MachineInstr::getDebugLoc
const DebugLoc & getDebugLoc() const
Returns the debug location id of this MachineInstr.
Definition: MachineInstr.h:418
llvm::DICompileUnit::getSourceLanguage
unsigned getSourceLanguage() const
Definition: DebugInfoMetadata.h:1465
llvm::LexicalScopes::findAbstractScope
LexicalScope * findAbstractScope(const DILocalScope *N)
findAbstractScope - Find an abstract scope or return null.
Definition: LexicalScopes.h:180
VI
@ VI
Definition: SIInstrInfo.cpp:7685
llvm::DwarfDebug::tuneForLLDB
bool tuneForLLDB() const
Definition: DwarfDebug.h:839
llvm::DwarfCompileUnit::GlobalExpr
A pair of GlobalVariable and DIExpression.
Definition: DwarfCompileUnit.h:132
llvm::cl::values
ValuesClass values(OptsTy... Options)
Helper to build a ValuesClass by forwarding a variable number of arguments as an initializer list to ...
Definition: CommandLine.h:697
llvm::DwarfCompileUnit::getMacroLabelBegin
MCSymbol * getMacroLabelBegin() const
Definition: DwarfCompileUnit.h:304
sortGlobalExprs
static SmallVectorImpl< DwarfCompileUnit::GlobalExpr > & sortGlobalExprs(SmallVectorImpl< DwarfCompileUnit::GlobalExpr > &GVEs)
Sort and unique GVEs by comparing their fragment offset.
Definition: DwarfDebug.cpp:1119
llvm::DwarfDebug::beginModule
void beginModule(Module *M) override
Emit all Dwarf sections that should come prior to the content.
Definition: DwarfDebug.cpp:1147
llvm::MachineLocation::getReg
unsigned getReg() const
Definition: MachineLocation.h:47
emitLoclistsTableHeader
static MCSymbol * emitLoclistsTableHeader(AsmPrinter *Asm, const DwarfDebug &DD)
Definition: DwarfDebug.cpp:2711
llvm::DwarfCompileUnit::hasDwarfPubSections
bool hasDwarfPubSections() const
Definition: DwarfCompileUnit.cpp:1361
llvm::MachineInstr::getDebugExpression
const DIExpression * getDebugExpression() const
Return the complex address expression referenced by this DBG_VALUE instruction.
Definition: MachineInstr.cpp:874
Index
uint32_t Index
Definition: ELFObjHandler.cpp:84
llvm::MachineOperand::isReg
bool isReg() const
isReg - Tests if this is a MO_Register operand.
Definition: MachineOperand.h:321
llvm::MachineInstr
Representation of each machine instruction.
Definition: MachineInstr.h:64
llvm::DwarfDebug
Collects and handles dwarf debug information.
Definition: DwarfDebug.h:295
uint64_t
D
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
llvm::DwarfDebug::getAccelTableKind
AccelTableKind getAccelTableKind() const
Returns what kind (if any) of accelerator tables to emit.
Definition: DwarfDebug.h:741
llvm::DwarfDebug::DwarfDebug
DwarfDebug(AsmPrinter *A)
Definition: DwarfDebug.cpp:350
llvm::DataLayout::isLittleEndian
bool isLittleEndian() const
Layout endianness...
Definition: DataLayout.h:243
llvm::DIGlobalVariable
Global variables.
Definition: DebugInfoMetadata.h:2946
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::MD5
Definition: MD5.h:41
llvm::TargetRegisterInfo::getFrameRegister
virtual Register getFrameRegister(const MachineFunction &MF) const =0
Debug information queries.
llvm::numbers::e
constexpr double e
Definition: MathExtras.h:57
llvm::MCObjectFileInfo::getDwarfAccelNamesSection
MCSection * getDwarfAccelNamesSection() const
Definition: MCObjectFileInfo.h:295
llvm::DenseMap
Definition: DenseMap.h:714
llvm::TargetIndexLocation::Index
int Index
Definition: DebugLocEntry.h:25
llvm::DwarfDebug::useSplitDwarf
bool useSplitDwarf() const
Returns whether or not to change the current debug info for the split dwarf proposal support.
Definition: DwarfDebug.h:749
I
#define I(x, y, z)
Definition: MD5.cpp:59
llvm::MachineFunction::getCallSitesInfo
const CallSiteInfoMap & getCallSitesInfo() const
Definition: MachineFunction.h:1189
llvm::DwarfCompileUnit::getOrCreateSourceID
unsigned getOrCreateSourceID(const DIFile *File) override
Look up the source ID for the given file.
Definition: DwarfCompileUnit.cpp:120
llvm::DwarfUnit::addStringOffsetsStart
void addStringOffsetsStart()
Add the DW_AT_str_offsets_base attribute to the unit DIE.
Definition: DwarfUnit.cpp:1827
llvm::cl::init
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:441
llvm::DwarfExpression::beginEntryValueExpression
void beginEntryValueExpression(DIExpressionCursor &ExprCursor)
Begin emission of an entry value dwarf operation.
Definition: DwarfExpression.cpp:389
llvm::DICompileUnit
Compile unit.
Definition: DebugInfoMetadata.h:1335
llvm::DIImportedEntity
An imported module (C++ using directive or similar).
Definition: DebugInfoMetadata.h:3336
llvm::DWARFExpression
Definition: DWARFExpression.h:25
llvm::DwarfDebug::emitInitialLocDirective
DebugLoc emitInitialLocDirective(const MachineFunction &MF, unsigned CUID)
Emits inital debug location directive.
Definition: DwarfDebug.cpp:2125
llvm::DwarfDebug::tuneForGDB
bool tuneForGDB() const
Definition: DwarfDebug.h:838
llvm::DenseMapBase::find
iterator find(const_arg_type_t< KeyT > Val)
Definition: DenseMap.h:150
llvm::DIMacroFile
Definition: DebugInfoMetadata.h:3540
Enable
@ Enable
Definition: DwarfDebug.cpp:88
llvm::TargetMachine::Options
TargetOptions Options
Definition: TargetMachine.h:120
llvm::TargetOptions::ShouldEmitDebugEntryValues
bool ShouldEmitDebugEntryValues() const
NOTE: There are targets that still do not support the debug entry values production.
Definition: TargetOptionsImpl.cpp:54
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::AsmPrinter::emitDwarfUnitLength
void emitDwarfUnitLength(uint64_t Length, const Twine &Comment) const
Emit a unit length field.
Definition: AsmPrinterDwarf.cpp:201
llvm::DICompileUnit::isDebugDirectivesOnly
bool isDebugDirectivesOnly() const
Definition: DebugInfoMetadata.h:1471
llvm::move
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1609
DIEHash.h
llvm::DwarfDebug::endFunctionImpl
void endFunctionImpl(const MachineFunction *MF) override
Gather and emit post-function debug information.
Definition: DwarfDebug.cpp:2184
llvm::DIExpression::isEntryValue
bool isEntryValue() const
Check if the expression consists of exactly one entry value operand.
Definition: DebugInfoMetadata.h:2904
llvm::SymbolCU::CU
DwarfCompileUnit * CU
Definition: DwarfDebug.h:283
llvm::AddressPool::hasBeenUsed
bool hasBeenUsed() const
Definition: AddressPool.h:49
llvm::dwarf::DW_ARANGES_VERSION
@ DW_ARANGES_VERSION
Section version number for .debug_aranges.
Definition: Dwarf.h:65
llvm::AsmPrinter::MF
MachineFunction * MF
The current machine function.
Definition: AsmPrinter.h:100
llvm::AsmPrinter::OutContext
MCContext & OutContext
This is the context for the output file that we are streaming.
Definition: AsmPrinter.h:92
llvm::DwarfDebug::tuneForDBX
bool tuneForDBX() const
Definition: DwarfDebug.h:841
llvm::DwarfDebug::beginInstruction
void beginInstruction(const MachineInstr *MI) override
Process beginning of an instruction.
Definition: DwarfDebug.cpp:1959
llvm::MachineInstr::hasDelaySlot
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:939
MachineModuleInfo.h
llvm::MachineOperand::getReg
Register getReg() const
getReg - Returns the register number.
Definition: MachineOperand.h:360
emitRnglistsTableHeader
static MCSymbol * emitRnglistsTableHeader(AsmPrinter *Asm, const DwarfFile &Holder)
Definition: DwarfDebug.cpp:2693
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:67
llvm::MDNode
Metadata node.
Definition: Metadata.h:906
llvm::DebugHandlerBase::DbgLabels
DbgLabelInstrMap DbgLabels
Mapping of inlined labels and DBG_LABEL machine instruction.
Definition: DebugHandlerBase.h:85
llvm::DwarfDebug::beginFunctionImpl
void beginFunctionImpl(const MachineFunction *MF) override
Gather pre-function debug information.
Definition: DwarfDebug.cpp:2145
llvm::DwarfCompileUnit::constructImportedEntityDIE
DIE * constructImportedEntityDIE(const DIImportedEntity *Module)
Construct import_module DIE.
Definition: DwarfCompileUnit.cpp:1247
llvm::MachineBasicBlock::pred_empty
bool pred_empty() const
Definition: MachineBasicBlock.h:331
llvm::DebugHandlerBase::CurMI
const MachineInstr * CurMI
If nonnull, stores the current machine instruction we're processing.
Definition: DebugHandlerBase.h:76
llvm::AsmPrinter::emitDwarfLengthOrOffset
void emitDwarfLengthOrOffset(uint64_t Value) const
Emit 32- or 64-bit value depending on the DWARF format.
Definition: AsmPrinterDwarf.cpp:196
llvm::MCTargetOptions::Dwarf64
bool Dwarf64
Definition: MCTargetOptions.h:59
llvm::ByteStreamer::emitInt8
virtual void emitInt8(uint8_t Byte, const Twine &Comment="")=0
MCSection.h
llvm::DIBasicType
Basic type, like 'int' or 'float'.
Definition: DebugInfoMetadata.h:769
llvm::DwarfExpression::addSignedConstant
void addSignedConstant(int64_t Value)
Emit a signed constant.
Definition: DwarfExpression.cpp:190
llvm::MachineFunction
Definition: MachineFunction.h:230
llvm::mcdwarf::emitListsTableHeaderStart
MCSymbol * emitListsTableHeaderStart(MCStreamer &S)
Definition: MCDwarf.cpp:47
LinkageNameOption
LinkageNameOption
Definition: DwarfDebug.cpp:138
ByteStreamer.h
llvm::DwarfFile::computeSizeAndOffsetsForUnit
unsigned computeSizeAndOffsetsForUnit(DwarfUnit *TheU)
Compute the size and offset of all the DIEs in the given unit.
Definition: DwarfFile.cpp:82
llvm::MachineInstr::getDebugVariable
const DILocalVariable * getDebugVariable() const
Return the debug variable referenced by this DBG_VALUE instruction.
Definition: MachineInstr.cpp:858
Triple.h
llvm::dwarf::SourceLanguage
SourceLanguage
Definition: Dwarf.h:200
llvm::DICompositeType
Composite types.
Definition: DebugInfoMetadata.h:1060
llvm::AddressPool::emit
void emit(AsmPrinter &Asm, MCSection *AddrSection)
Definition: AddressPool.cpp:42
llvm::DICompileUnit::NoDebug
@ NoDebug
Definition: DebugInfoMetadata.h:1341
llvm::DwarfFile::addScopeLabel
void addScopeLabel(LexicalScope *LS, DbgLabel *Label)
Definition: DwarfFile.cpp:123
llvm::LexicalScopes::empty
bool empty()
empty - Return true if there is any lexical scope information available.
Definition: LexicalScopes.h:153
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
llvm::DwarfDebug::getDebugLocs
const DebugLocStream & getDebugLocs() const
Returns the entries for the .debug_loc section.
Definition: DwarfDebug.h:785
llvm::LexicalScopes::getAbstractScopesList
ArrayRef< LexicalScope * > getAbstractScopesList() const
getAbstractScopesList - Return a reference to list of abstract scopes.
Definition: LexicalScopes.h:175
llvm::MapVector::insert
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Definition: MapVector.h:117
MCAsmInfo.h
llvm::any_of
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:1558
llvm::MCDwarfDwoLineTable
Definition: MCDwarf.h:301
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm::DebuggerKind::Default
@ Default
No specific tuning requested.
llvm::DINode
Tagged DWARF-like metadata node.
Definition: DebugInfoMetadata.h:127
DwarfOpConvert
static cl::opt< DefaultOnOff > DwarfOpConvert("dwarf-op-convert", cl::Hidden, cl::desc("Enable use of the DWARFv5 DW_OP_convert operator"), cl::values(clEnumVal(Default, "Default for platform"), clEnumVal(Enable, "Enabled"), clEnumVal(Disable, "Disabled")), cl::init(Default))
MachineLocation.h
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:134
llvm::DwarfCompileUnit::addRange
void addRange(RangeSpan Range)
addRange - Add an address range to the list of ranges for this unit.
Definition: DwarfCompileUnit.cpp:353
interpretNextInstr
static bool interpretNextInstr(const MachineInstr *CurMI, FwdRegWorklist &ForwardedRegWorklist, ParamSet &Params)
Definition: DwarfDebug.cpp:768
if
if(llvm_vc STREQUAL "") set(fake_version_inc "$
Definition: CMakeLists.txt:14
TargetLoweringObjectFile.h
isObjCClass
static bool isObjCClass(StringRef Name)
Definition: DwarfDebug.cpp:475
llvm::DIE::children
child_range children()
Definition: DIE.h:787
llvm::getBundleStart
MachineBasicBlock::instr_iterator getBundleStart(MachineBasicBlock::instr_iterator I)
Returns an iterator to the first instruction in the bundle containing I.
Definition: MachineInstrBundle.h:44
forBothCUs
static void forBothCUs(DwarfCompileUnit &CU, Func F)
Definition: DwarfDebug.cpp:554
llvm::ilist_node_impl::getIterator
self_iterator getIterator()
Definition: ilist_node.h:81
llvm::DwarfCompileUnit::addAddrTableBase
void addAddrTableBase()
Add the DW_AT_addr_base attribute to the unit DIE.
Definition: DwarfCompileUnit.cpp:1545
TargetSubtargetInfo.h
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
llvm::MCSection
Instances of this class represent a uniqued identifier for a section in the current translation unit.
Definition: MCSection.h:39
clEnumValN
#define clEnumValN(ENUMVAL, FLAGNAME, DESC)
Definition: CommandLine.h:672
llvm::DICompileUnit::getSplitDebugFilename
StringRef getSplitDebugFilename() const
Definition: DebugInfoMetadata.h:1481
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::MachineFunction::hasBBSections
bool hasBBSections() const
Returns true if this function has basic block sections enabled.
Definition: MachineFunction.h:604
llvm::dwarf::PubIndexEntryDescriptor::Kind
GDBIndexEntryKind Kind
Definition: Dwarf.h:716
llvm::dwarf::DW_MACINFO_define
@ DW_MACINFO_define
Definition: Dwarf.h:381
DwarfCompileUnit.h
llvm::DIScope::getDirectory
StringRef getDirectory() const
Definition: DebugInfoMetadata.h:645
llvm::DebugLocStream::EntryBuilder
Builder for DebugLocStream entries.
Definition: DebugLocStream.h:184
llvm::AsmPrinter::getUnitLengthFieldByteSize
unsigned int getUnitLengthFieldByteSize() const
Returns 4 for DWARF32 and 12 for DWARF64.
Definition: AsmPrinter.cpp:3618
llvm::MachineInstr::getParent
const MachineBasicBlock * getParent() const
Definition: MachineInstr.h:286
llvm::Value::getName
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:309
llvm::MachineLocation::isIndirect
bool isIndirect() const
Definition: MachineLocation.h:45
llvm::DenseMapBase< SmallDenseMap< KeyT, ValueT, 4, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >, KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >::insert
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Definition: DenseMap.h:207
llvm::DwarfFile::addUnit
void addUnit(std::unique_ptr< DwarfCompileUnit > U)
Add a unit to the list of CUs.
Definition: DwarfFile.cpp:25
llvm::DwarfDebug::shareAcrossDWOCUs
bool shareAcrossDWOCUs() const
Definition: DwarfDebug.cpp:561
llvm::MCDwarfDwoLineTable::maybeSetRootFile
void maybeSetRootFile(StringRef Directory, StringRef FileName, Optional< MD5::MD5Result > Checksum, Optional< StringRef > Source)
Definition: MCDwarf.h:306
llvm::Register
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
llvm::ByteStreamer::emitULEB128
virtual void emitULEB128(uint64_t DWord, const Twine &Comment="", unsigned PadTo=0)=0
Disable
@ Disable
Definition: DwarfDebug.cpp:88
llvm::MCDwarfDwoLineTable::Emit
void Emit(MCStreamer &MCOS, MCDwarfLineTableParams Params, MCSection *Section) const
Definition: MCDwarf.cpp:246
llvm::DwarfDebug::MinimizeAddrInV5::Default
@ Default
llvm::DICompileUnit::getSDK
StringRef getSDK() const
Definition: DebugInfoMetadata.h:1504
llvm::DwarfDebug::enterNonTypeUnitContext
NonTypeUnitContext enterNonTypeUnitContext()
Definition: DwarfDebug.cpp:3450
llvm::DwarfDebug::getSectionLabel
const MCSymbol * getSectionLabel(const MCSection *S)
Definition: DwarfDebug.cpp:3521
llvm::DICompileUnit::getNameTableKind
static Optional< DebugNameTableKind > getNameTableKind(StringRef Str)
Definition: DebugInfoMetadata.cpp:784
llvm::DwarfFile::getStringPool
DwarfStringPool & getStringPool()
Returns the string pool.
Definition: DwarfFile.h:144
llvm::MachineBasicBlock::getEndSymbol
MCSymbol * getEndSymbol() const
Returns the MCSymbol marking the end of this basic block.
Definition: MachineBasicBlock.cpp:102
MBB
MachineBasicBlock & MBB
Definition: AArch64SLSHardening.cpp:74
llvm::MD5::MD5Result
Definition: MD5.h:43
llvm::MapVector::empty
bool empty() const
Definition: MapVector.h:79
collectCallSiteParameters
static void collectCallSiteParameters(const MachineInstr *CallMI, ParamSet &Params)
Try to interpret values loaded into registers that forward parameters for CallMI.
Definition: DwarfDebug.cpp:795
llvm::dwarf::GIEK_FUNCTION
@ GIEK_FUNCTION
Definition: Dwarf.h:530
llvm::DbgVariable::getFrameIndexExprs
ArrayRef< FrameIndexExpr > getFrameIndexExprs() const
Get the FI entries, sorted by fragment offset.
Definition: DwarfDebug.cpp:275
llvm::DwarfFile::getStringOffsetsStartSym
MCSymbol * getStringOffsetsStartSym() const
Definition: DwarfFile.h:146
getObjCClassCategory
static void getObjCClassCategory(StringRef In, StringRef &Class, StringRef &Category)
Definition: DwarfDebug.cpp:486
llvm::DwarfDebug::emitDebugLocValue
static void emitDebugLocValue(const AsmPrinter &AP, const DIBasicType *BT, const DbgValueLoc &Value, DwarfExpression &DwarfExpr)
Definition: DwarfDebug.cpp:2546
llvm::DwarfCompileUnit::setBaseAddress
void setBaseAddress(const MCSymbol *Base)
Definition: DwarfCompileUnit.h:357
llvm::DwarfDebug::useLocSection
bool useLocSection() const
Returns whether .debug_loc section should be emitted.
Definition: DwarfDebug.h:733
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
llvm::DwarfDebug::useAppleExtensionAttributes
bool useAppleExtensionAttributes() const
Definition: DwarfDebug.h:743
llvm::LexicalScope::getScopeNode
const DILocalScope * getScopeNode() const
Definition: LexicalScopes.h:63
llvm::DebugHandlerBase::getInstOrdering
const InstructionOrdering & getInstOrdering() const
Definition: DebugHandlerBase.h:141
llvm::stable_sort
void stable_sort(R &&Range)
Definition: STLExtras.h:1686
llvm::DwarfFile::computeSizeAndOffsets
void computeSizeAndOffsets()
Compute the size and offset of all the DIEs.
Definition: DwarfFile.cpp:59
llvm::TargetOptions::DebuggerTuning
DebuggerKind DebuggerTuning
Which debugger to tune for.
Definition: TargetOptions.h:387
llvm::empty
constexpr bool empty(const T &RangeOrContainer)
Test whether RangeOrContainer is empty. Similar to C++17 std::empty.
Definition: STLExtras.h:254
llvm::DwarfDebug::getDwarfCompileUnitIDForLineTable
unsigned getDwarfCompileUnitIDForLineTable(const DwarfCompileUnit &CU)
Get Dwarf compile unit ID for line table.
Definition: DwarfDebug.cpp:2164
llvm::pdb::PDB_SymType::Label
@ Label
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
std
Definition: BitVector.h:838
llvm::MachineFunction::getFunction
Function & getFunction()
Return the LLVM function that this machine code represents.
Definition: MachineFunction.h:592
llvm::DICompileUnit::getProducer
StringRef getProducer() const
Definition: DebugInfoMetadata.h:1479
llvm::DIExpression::isFragment
bool isFragment() const
Return whether this is a piece of an aggregate variable.
Definition: DebugInfoMetadata.h:2765
llvm::DwarfExpression::addFragmentOffset
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...
Definition: DwarfExpression.cpp:655
FwdRegParamInfo::Expr
const DIExpression * Expr
Debug expression that has been built up when walking through the instruction chain that produces the ...
Definition: DwarfDebug.cpp:598
uint16_t
UseDwarfRangesBaseAddressSpecifier
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))
llvm::MachineBasicBlock::isEndSection
bool isEndSection() const
Returns true if this block ends any section.
Definition: MachineBasicBlock.h:567
llvm::DwarfStringPoolEntryRef::getSymbol
MCSymbol * getSymbol() const
Definition: DwarfStringPoolEntry.h:46
llvm::AMDGPU::SendMsg::Op
Op
Definition: SIDefines.h:324
AccelTables
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))
llvm::DwarfUnit::addUInt
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:228
DefaultOnOff
DefaultOnOff
Definition: DwarfDebug.cpp:88
llvm::ArrayRef::begin
iterator begin() const
Definition: ArrayRef.h:153
llvm::LexicalScopes::findInlinedScope
LexicalScope * findInlinedScope(const DILocalScope *N, const DILocation *IA)
findInlinedScope - Find an inlined scope for the given scope/inlined-at.
Definition: LexicalScopes.h:186
llvm::DebugLocEntry::finalize
void finalize(const AsmPrinter &AP, DebugLocStream::ListBuilder &List, const DIBasicType *BT, DwarfCompileUnit &TheCU)
Lower this entry into a DWARF expression.
Definition: DwarfDebug.cpp:2641
llvm::AsmPrinter::isDwarf64
bool isDwarf64() const
Definition: AsmPrinter.cpp:3609
llvm::MCObjectFileInfo::getDwarfMacroDWOSection
MCSection * getDwarfMacroDWOSection() const
Definition: MCObjectFileInfo.h:323
llvm::dwarf::DW_PUBNAMES_VERSION
@ DW_PUBNAMES_VERSION
Section version number for .debug_pubnames.
Definition: Dwarf.h:64
GlobalVariable.h
llvm::DwarfStringPoolEntryRef::getIndex
unsigned getIndex() const
Definition: DwarfStringPoolEntry.h:52
llvm::DbgValueLocEntry
A single location or constant within a variable location description, with either a single entry (wit...
Definition: DebugLocEntry.h:40
llvm::dwarf::GIEK_NONE
@ GIEK_NONE
Definition: Dwarf.h:527
llvm::DwarfCompileUnit::getLength
unsigned getLength()
Definition: DwarfCompileUnit.h:289
llvm::LexicalScopes::findLexicalScope
LexicalScope * findLexicalScope(const DILocation *DL)
findLexicalScope - Find lexical scope, either regular or inlined, for the given DebugLoc.
Definition: LexicalScopes.cpp:124
Casting.h
Function.h
llvm::AsmPrinter::getDwarfVersion
uint16_t getDwarfVersion() const
Definition: AsmPrinter.cpp:3601
llvm::MCObjectFileInfo::getDwarfTypesDWOSection
MCSection * getDwarfTypesDWOSection() const
Definition: MCObjectFileInfo.h:309
llvm::dwarf::DW_MACINFO_start_file
@ DW_MACINFO_start_file
Definition: Dwarf.h:383
llvm::DICompileUnit::getDebugInfoForProfiling
bool getDebugInfoForProfiling() const
Definition: DebugInfoMetadata.h:1474
llvm::DwarfDebug::useSegmentedStringOffsetsTable
bool useSegmentedStringOffsetsTable() const
Returns whether to generate a string offsets table with (possibly shared) contributions from each CU ...
Definition: DwarfDebug.h:757
llvm::AccelTableKind::Default
@ Default
Dwarf for DWARF5 or later, Apple otherwise.
DwarfUnit.h
llvm::sort
void sort(IteratorTy Start, IteratorTy End)
Definition: STLExtras.h:1492
llvm::TargetStackID::Value
Value
Definition: TargetFrameLowering.h:27
EndOfList
@ EndOfList
Definition: FunctionInfo.cpp:22
DWARFExpression.h
llvm::is_sorted
bool is_sorted(R &&Range, Compare C)
Wrapper function around std::is_sorted to check if elements in a range R are sorted with respect to a...
Definition: STLExtras.h:1622
llvm::DIExpression::getElements
ArrayRef< uint64_t > getElements() const
Definition: DebugInfoMetadata.h:2610
combineDIExpressions
static const DIExpression * combineDIExpressions(const DIExpression *Original, const DIExpression *Addition)
Append the expression Addition to Original and return the result.
Definition: DwarfDebug.cpp:605
ArangeSpan::End
const MCSymbol * End
Definition: DwarfDebug.cpp:2897
llvm::MCObjectFileInfo::getDwarfTypesSection
MCSection * getDwarfTypesSection(uint64_t Hash) const
Definition: MCObjectFileInfo.h:306
llvm::Module::getDwarfVersion
unsigned getDwarfVersion() const
Returns the Dwarf Version by checking module flags.
Definition: Module.cpp:559
llvm::AsmPrinter
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:82
llvm::unique
auto unique(Range &&R, Predicate P)
Definition: STLExtras.h:1704
llvm::DwarfTypeUnit::setTypeSignature
void setTypeSignature(uint64_t Signature)
Definition: DwarfUnit.h:369
llvm::AddressPool::getIndex
unsigned getIndex(const MCSymbol *Sym, bool TLS=false)
Returns the index into the address pool with the given label/symbol.
Definition: AddressPool.cpp:19
llvm::DwarfFile
Definition: DwarfFile.h:49
llvm::DIEUnit::setSection
void setSection(MCSection *Section)
Set the section that this DIEUnit will be emitted into.
Definition: DIE.h:896
llvm::dwarf::isCPlusPlus
bool isCPlusPlus(SourceLanguage S)
Definition: Dwarf.h:208
llvm::DICompileUnit::DebugNameTableKind::Default
@ Default
llvm::DwarfUnit::createTypeDIE
DIE * createTypeDIE(const DIScope *Context, DIE &ContextDIE, const DIType *Ty)
Creates type DIE with specific context.
Definition: DwarfUnit.cpp:569
llvm::MCObjectFileInfo::getDwarfLineDWOSection
MCSection * getDwarfLineDWOSection() const
Definition: MCObjectFileInfo.h:312
llvm::MCObjectFileInfo::getDwarfAbbrevSection
MCSection * getDwarfAbbrevSection() const
Definition: MCObjectFileInfo.h:264
SectionKind.h
llvm::dwarf::PubIndexEntryDescriptor
Describes an entry of the various gnu_pub* debug sections.
Definition: Dwarf.h:715
llvm::MachineInstr::isBundle
bool isBundle() const
Definition: MachineInstr.h:1287
llvm::DwarfFile::emitUnits
void emitUnits(bool UseOffsets)
Emit all of the units to the section listed with the given abbreviation section.
Definition: DwarfFile.cpp:31
llvm::BufferByteStreamer
Definition: ByteStreamer.h:76
llvm::DwarfFile::getScopeVariables
DenseMap< LexicalScope *, ScopeVars > & getScopeVariables()
Definition: DwarfFile.h:157
llvm::DwarfCompileUnit::getSkeleton
DwarfCompileUnit * getSkeleton() const
Definition: DwarfCompileUnit.h:117
llvm::DIE::findAttribute
DIEValue findAttribute(dwarf::Attribute Attribute) const
Find a value in the DIE with the attribute given.
Definition: DIE.cpp:221
llvm::DbgValueLoc
The location of a single variable, composed of an expression and 0 or more DbgValueLocEntries.
Definition: DebugLocEntry.h:108
llvm::DebugLoc::getLine
unsigned getLine() const
Definition: DebugLoc.cpp:25
llvm::DwarfCompileUnit::addImportedEntity
void addImportedEntity(const DIImportedEntity *IE)
Definition: DwarfCompileUnit.h:172
llvm::AsmPrinter::MBBSectionRanges
MapVector< unsigned, MBBSectionRange > MBBSectionRanges
Definition: AsmPrinter.h:136
llvm::DIMacroFile::getElements
DIMacroNodeArray getElements() const
Definition: DebugInfoMetadata.h:3590
llvm::DwarfDebug::makeTypeSignature
static uint64_t makeTypeSignature(StringRef Identifier)
Perform an MD5 checksum of Identifier and return the lower 64 bits.
Definition: DwarfDebug.cpp:3341
llvm::DebugHandlerBase::PrevLabel
MCSymbol * PrevLabel
Definition: DebugHandlerBase.h:68
UseGNUDebugMacro
static cl::opt< bool > UseGNUDebugMacro("use-gnu-debug-macro", cl::Hidden, cl::desc("Emit the GNU .debug_macro format with DWARF <5"), cl::init(false))
llvm::DwarfFile::getRnglistsTableBaseSym
MCSymbol * getRnglistsTableBaseSym() const
Definition: DwarfFile.h:149
llvm::AsmPrinter::TM
TargetMachine & TM
Target machine description.
Definition: AsmPrinter.h:85
llvm::DICompileUnit::getRuntimeVersion
unsigned getRuntimeVersion() const
Definition: DebugInfoMetadata.h:1467
llvm::TargetSubtargetInfo::getTargetLowering
virtual const TargetLowering * getTargetLowering() const
Definition: TargetSubtargetInfo.h:96
llvm::dwarf::MacinfoString
StringRef MacinfoString(unsigned Encoding)
Definition: Dwarf.cpp:457
llvm::BufferByteStreamer::emitInt8
void emitInt8(uint8_t Byte, const Twine &Comment) override
Definition: ByteStreamer.h:91
llvm::MCObjectFileInfo::getDwarfAbbrevDWOSection
MCSection * getDwarfAbbrevDWOSection() const
Definition: MCObjectFileInfo.h:310
llvm::DIMacroFile::getFile
DIFile * getFile() const
Definition: DebugInfoMetadata.h:3588
llvm::DebugLocDwarfExpression
DwarfExpression implementation for .debug_loc entries.
Definition: DwarfExpression.h:367
llvm::DIExpressionCursor
Holds a DIExpression and keeps track of how many operands have been consumed so far.
Definition: DwarfExpression.h:37
List
const NodeList & List
Definition: RDFGraph.cpp:201
BT
BitTracker BT
Definition: BitTracker.cpp:73
llvm::DICompileUnit::isOptimized
bool isOptimized() const
Definition: DebugInfoMetadata.h:1466
GenerateARangeSection
static cl::opt< bool > GenerateARangeSection("generate-arange-section", cl::Hidden, cl::desc("Generate dwarf aranges"), cl::init(false))
llvm::DwarfExpression::addExpression
void addExpression(DIExpressionCursor &&Expr, unsigned FragmentOffsetInBits=0)
Emit all remaining operations in the DIExpressionCursor.
Definition: DwarfExpression.cpp:466
llvm::AsmPrinter::getObjFileLowering
const TargetLoweringObjectFile & getObjFileLowering() const
Return information about object file lowering.
Definition: AsmPrinter.cpp:224
N
#define N
llvm::DIFile::CSK_MD5
@ CSK_MD5
Definition: DebugInfoMetadata.h:544
MCStreamer.h
llvm::DICompileUnit::DebugNameTableKind::None
@ None
llvm::MachineInstr::getNumOperands
unsigned getNumOperands() const
Retuns the total number of operands.
Definition: MachineInstr.h:492
llvm::DbgVariable::getVariable
const DILocalVariable * getVariable() const
Definition: DwarfDebug.h:167
llvm::UnitKind::Skeleton
@ Skeleton
llvm::TargetMachine::getTargetTriple
const Triple & getTargetTriple() const
Definition: TargetMachine.h:128
computeIndexValue
static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU, const DIE *Die)
computeIndexValue - Compute the gdb index value for the DIE and CU.
Definition: DwarfDebug.cpp:2359
llvm::DwarfDebug::tuneForSCE
bool tuneForSCE() const
Definition: DwarfDebug.h:840
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:165
llvm::max
Align max(MaybeAlign Lhs, Align Rhs)
Definition: Alignment.h:340
llvm::MCObjectFileInfo::getDwarfStrSection
MCSection * getDwarfStrSection() const
Definition: MCObjectFileInfo.h:283
llvm::DwarfDebug::addAccelType
void addAccelType(const DICompileUnit &CU, StringRef Name, const DIE &Die, char Flags)
Definition: DwarfDebug.cpp:3503
llvm::LexicalScopes::getCurrentFunctionScope
LexicalScope * getCurrentFunctionScope() const
getCurrentFunctionScope - Return lexical scope for the current function.
Definition: LexicalScopes.h:156
llvm::MCObjectFileInfo::getDwarfMacinfoDWOSection
MCSection * getDwarfMacinfoDWOSection() const
Definition: MCObjectFileInfo.h:324
llvm::DebugHandlerBase::MMI
MachineModuleInfo * MMI
Collected machine module information.
Definition: DebugHandlerBase.h:61
llvm::AsmPrinter::getDataLayout
const DataLayout & getDataLayout() const
Return information about data layout.
Definition: AsmPrinter.cpp:228
llvm::DebugHandlerBase
Base class for debug information backends.
Definition: DebugHandlerBase.h:53
llvm::DwarfDebug::MinimizeAddrInV5::Ranges
@ Ranges
llvm::MipsISD::Ins
@ Ins
Definition: MipsISelLowering.h:157
llvm::DISubprogram
Subprogram description.
Definition: DebugInfoMetadata.h:1820
llvm::SmallVectorImpl< InsnRange >
llvm::MCObjectFileInfo::getDwarfAccelTypesSection
MCSection * getDwarfAccelTypesSection() const
Definition: MCObjectFileInfo.h:302
MachineOperand.h
DWARF2_FLAG_PROLOGUE_END
#define DWARF2_FLAG_PROLOGUE_END
Definition: MCDwarf.h:108
llvm::SmallSetVector
A SetVector that performs no allocations if smaller than a certain size.
Definition: SetVector.h:307
llvm::HexStyle::Asm
@ Asm
0ffh
Definition: MCInstPrinter.h:34
TM
const char LLVMTargetMachineRef TM
Definition: PassBuilderBindings.cpp:47
llvm::MCObjectFileInfo::getDwarfRnglistsDWOSection
MCSection * getDwarfRnglistsDWOSection() const
Definition: MCObjectFileInfo.h:317
llvm::DwarfDebug::getDwarfVersion
uint16_t getDwarfVersion() const
Returns the Dwarf Version.
Definition: DwarfDebug.cpp:3508
llvm::dwarf::DWARF64
@ DWARF64
Definition: Dwarf.h:92
llvm::DILabel
Label.
Definition: DebugInfoMetadata.h:3185
llvm::DwarfUnit
This dwarf writer support class manages information associated with a source file.
Definition: DwarfUnit.h:37
FwdRegParamInfo
Represents a parameter whose call site value can be described by applying a debug expression to a reg...
Definition: DwarfDebug.cpp:592
llvm::DILocalScope
A scope for locals.
Definition: DebugInfoMetadata.h:1550
llvm::TargetIndexLocation::Offset
int Offset
Definition: DebugLocEntry.h:26
llvm::DebugLoc
A debug info location.
Definition: DebugLoc.h:33
llvm::DebugLoc::getScope
MDNode * getScope() const
Definition: DebugLoc.cpp:35
llvm::DwarfDebug::useRangesSection
bool useRangesSection() const
Returns whether ranges section should be emitted.
Definition: DwarfDebug.h:707
llvm::DebugHandlerBase::DbgValues
DbgValueHistoryMap DbgValues
History of DBG_VALUE and clobber instructions for each user variable.
Definition: DebugHandlerBase.h:82
llvm::cl::desc
Definition: CommandLine.h:412
llvm::DICompileUnit::getImportedEntities
DIImportedEntityArray getImportedEntities() const
Definition: DebugInfoMetadata.h:1491
llvm::DwarfDebug::MinimizeAddrInV5::Form
@ Form
llvm::DwarfFile::emitAbbrevs
void emitAbbrevs(MCSection *)
Emit a set of abbreviations to the specific section.
Definition: DwarfFile.cpp:98
raw_ostream.h
llvm::DbgVariable::addMMIEntry
void addMMIEntry(const DbgVariable &V)
Definition: DwarfDebug.cpp:293
llvm::DIE::getOffset
unsigned getOffset() const
Get the compile/type unit relative offset of this DIE.
Definition: DIE.h:777
llvm::DwarfCompileUnit::hasRangeLists
bool hasRangeLists() const
Definition: DwarfCompileUnit.h:114
DwarfInlinedStrings
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))
llvm::LexicalScopes
LexicalScopes - This class provides interface to collect and use lexical scoping information from mac...
Definition: LexicalScopes.h:141
n
The same transformation can work with an even modulo with the addition of a and shrink the compare RHS by the same amount Unless the target supports that transformation probably isn t worthwhile The transformation can also easily be made to work with non zero equality for n
Definition: README.txt:685
llvm::DebuggerKind::SCE
@ SCE
Tune debug info for SCE targets (e.g. PS4).
MachineFunction.h
llvm::ByteStreamer
Definition: ByteStreamer.h:24
llvm::DwarfFile::getRangeLists
const SmallVectorImpl< RangeSpanList > & getRangeLists() const
getRangeLists - Get the vector of range lists.
Definition: DwarfFile.h:109
llvm::ArrayRef::vec
std::vector< T > vec() const
Definition: ArrayRef.h:280
llvm::Triple::isWasm
bool isWasm() const
Tests whether the target is wasm (32- and 64-bit).
Definition: Triple.h:796
llvm::MachineInstrBundleIterator
MachineBasicBlock iterator that automatically skips over MIs that are inside bundles (i....
Definition: MachineInstrBundleIterator.h:108
llvm::DebuggerKind::LLDB
@ LLDB
Tune debug info for lldb.
copy
we should consider alternate ways to model stack dependencies Lots of things could be done in WebAssemblyTargetTransformInfo cpp there are numerous optimization related hooks that can be overridden in WebAssemblyTargetLowering Instead of the OptimizeReturned which should consider preserving the returned attribute through to MachineInstrs and extending the MemIntrinsicResults pass to do this optimization on calls too That would also let the WebAssemblyPeephole pass clean up dead defs for such as it does for stores Consider implementing and or getMachineCombinerPatterns Find a clean way to fix the problem which leads to the Shrink Wrapping pass being run after the WebAssembly PEI pass When setting multiple variables to the same we currently get code like const It could be done with a smaller encoding like local tee $pop5 local copy
Definition: README.txt:101
recordSourceLine
static void recordSourceLine(AsmPrinter &Asm, unsigned Line, unsigned Col, const MDNode *S, unsigned Flags, unsigned CUID, uint16_t DwarfVersion, ArrayRef< std::unique_ptr< DwarfCompileUnit >> DCUs)
Register a source line with debug info.
Definition: DwarfDebug.cpp:2105
llvm::SymbolCU
Helper used to pair up a symbol and its DWARF compile unit.
Definition: DwarfDebug.h:279
CU
Definition: AArch64AsmBackend.cpp:501
llvm::DwarfCompileUnit::getUniqueID
unsigned getUniqueID() const
Definition: DwarfCompileUnit.h:115
llvm::DebugLocStream::getSym
MCSymbol * getSym() const
Definition: DebugLocStream.h:63
llvm::MachineModuleInfo::getModule
const Module * getModule() const
Definition: MachineModuleInfo.h:174
llvm::offsetToAlignment
uint64_t offsetToAlignment(uint64_t Value, Align Alignment)
Returns the offset to the next integer (mod 2**64) that is greater than or equal to Value and is a mu...
Definition: Alignment.h:196
llvm::RangeSpanList
Definition: DwarfFile.h:41
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
llvm::AsmPrinter::emitInt16
void emitInt16(int Value) const
Emit a short directive and value.
Definition: AsmPrinter.cpp:2404
llvm::DwarfDebug::~DwarfDebug
~DwarfDebug() override
TargetRegisterInfo.h
llvm::DwarfCompileUnit::getRanges
const SmallVectorImpl< RangeSpan > & getRanges() const
getRanges - Get the list of ranges for this unit.
Definition: DwarfCompileUnit.h:354
Debug.h
File
Instrumentation for Order File
Definition: InstrOrderFile.cpp:205
llvm::MCObjectFileInfo::getDwarfStrOffDWOSection
MCSection * getDwarfStrOffDWOSection() const
Definition: MCObjectFileInfo.h:314
llvm::dwarf::GDBIndexEntryLinkage
GDBIndexEntryLinkage
Definition: Dwarf.h:537
llvm::DIVariable::getType
DIType * getType() const
Definition: DebugInfoMetadata.h:2534
llvm::MapVector::erase
VectorType::iterator erase(typename VectorType::iterator Iterator)
Remove the element given by Iterator.
Definition: MapVector.h:173
llvm::DIEUnit::getUnitDie
DIE & getUnitDie()
Definition: DIE.h:911
llvm::DICompileUnit::getFlags
StringRef getFlags() const
Definition: DebugInfoMetadata.h:1480
llvm::dwarf::OperationEncodingString
StringRef OperationEncodingString(unsigned Encoding)
Definition: Dwarf.cpp:138
llvm::dwarf::LocListEncodingString
StringRef LocListEncodingString(unsigned Encoding)
Definition: Dwarf.cpp:525
llvm::AccelTableKind
AccelTableKind
The kind of accelerator tables we should emit.
Definition: DWARFLinker.h:25
llvm::MCObjectFileInfo::getDwarfGnuPubNamesSection
MCSection * getDwarfGnuPubNamesSection() const
Definition: MCObjectFileInfo.h:274
llvm::dwarf::DWARF32
@ DWARF32
Definition: Dwarf.h:92
llvm::DICompileUnit::getSysRoot
StringRef getSysRoot() const
Definition: DebugInfoMetadata.h:1503
llvm::DwarfDebug::MinimizeAddrInV5::Expressions
@ Expressions
llvm::sampleprof::Base
@ Base
Definition: Discriminator.h:58
llvm::DebugLocStream::getEntries
ArrayRef< Entry > getEntries(const List &L) const
Definition: DebugLocStream.h:110
llvm::DIScope::getFile
DIFile * getFile() const
Definition: DebugInfoMetadata.h:484
Other
Optional< std::vector< StOtherPiece > > Other
Definition: ELFYAML.cpp:1184
llvm::DIFile
File.
Definition: DebugInfoMetadata.h:530
llvm::DbgVariable::getType
const DIType * getType() const
Definition: DwarfDebug.cpp:231
llvm::SmallVectorImpl::emplace_back
reference emplace_back(ArgTypes &&... Args)
Definition: SmallVector.h:908
llvm::DIExpression::isValid
bool isValid() const
Definition: DebugInfoMetadata.cpp:1096
llvm::MachineOperand::isGlobal
bool isGlobal() const
isGlobal - Tests if this is a MO_GlobalAddress operand.
Definition: MachineOperand.h:339
DWARFDataExtractor.h
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:37
llvm::MachineBasicBlock::sameSection
bool sameSection(const MachineBasicBlock *MBB) const
Returns true if this and MBB belong to the same section.
Definition: MachineBasicBlock.h:615
llvm::emitDWARF5AccelTable
void emitDWARF5AccelTable(AsmPrinter *Asm, AccelTable< DWARF5AccelTableData > &Contents, const DwarfDebug &DD, ArrayRef< std::unique_ptr< DwarfCompileUnit >> CUs)
Definition: AccelTable.cpp:546