LLVM  15.0.0git
DWARFLinker.cpp
Go to the documentation of this file.
1 //=== DWARFLinker.cpp -----------------------------------------------------===//
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 
10 #include "llvm/ADT/ArrayRef.h"
11 #include "llvm/ADT/BitVector.h"
12 #include "llvm/ADT/STLExtras.h"
25 #include "llvm/MC/MCDwarf.h"
27 #include "llvm/Support/Error.h"
29 #include "llvm/Support/ErrorOr.h"
31 #include "llvm/Support/LEB128.h"
32 #include "llvm/Support/Path.h"
34 #include <vector>
35 
36 namespace llvm {
37 
38 /// Hold the input and output of the debug info size in bytes.
39 struct DebugInfoSize {
42 };
43 
44 /// Compute the total size of the debug info.
46  uint64_t Size = 0;
47  for (auto &Unit : Dwarf.compile_units()) {
48  Size += Unit->getLength();
49  }
50  return Size;
51 }
52 
53 /// Similar to DWARFUnitSection::getUnitForOffset(), but returning our
54 /// CompileUnit object instead.
55 static CompileUnit *getUnitForOffset(const UnitListTy &Units, uint64_t Offset) {
56  auto CU = llvm::upper_bound(
57  Units, Offset, [](uint64_t LHS, const std::unique_ptr<CompileUnit> &RHS) {
58  return LHS < RHS->getOrigUnit().getNextUnitOffset();
59  });
60  return CU != Units.end() ? CU->get() : nullptr;
61 }
62 
63 /// Resolve the DIE attribute reference that has been extracted in \p RefValue.
64 /// The resulting DIE might be in another CompileUnit which is stored into \p
65 /// ReferencedCU. \returns null if resolving fails for any reason.
66 DWARFDie DWARFLinker::resolveDIEReference(const DWARFFile &File,
67  const UnitListTy &Units,
68  const DWARFFormValue &RefValue,
69  const DWARFDie &DIE,
70  CompileUnit *&RefCU) {
71  assert(RefValue.isFormClass(DWARFFormValue::FC_Reference));
72  uint64_t RefOffset = *RefValue.getAsReference();
73  if ((RefCU = getUnitForOffset(Units, RefOffset)))
74  if (const auto RefDie = RefCU->getOrigUnit().getDIEForOffset(RefOffset)) {
75  // In a file with broken references, an attribute might point to a NULL
76  // DIE.
77  if (!RefDie.isNULL())
78  return RefDie;
79  }
80 
81  reportWarning("could not find referenced DIE", File, &DIE);
82  return DWARFDie();
83 }
84 
85 /// \returns whether the passed \a Attr type might contain a DIE reference
86 /// suitable for ODR uniquing.
87 static bool isODRAttribute(uint16_t Attr) {
88  switch (Attr) {
89  default:
90  return false;
91  case dwarf::DW_AT_type:
92  case dwarf::DW_AT_containing_type:
93  case dwarf::DW_AT_specification:
94  case dwarf::DW_AT_abstract_origin:
95  case dwarf::DW_AT_import:
96  return true;
97  }
98  llvm_unreachable("Improper attribute.");
99 }
100 
101 static bool isTypeTag(uint16_t Tag) {
102  switch (Tag) {
103  case dwarf::DW_TAG_array_type:
104  case dwarf::DW_TAG_class_type:
105  case dwarf::DW_TAG_enumeration_type:
106  case dwarf::DW_TAG_pointer_type:
107  case dwarf::DW_TAG_reference_type:
108  case dwarf::DW_TAG_string_type:
109  case dwarf::DW_TAG_structure_type:
110  case dwarf::DW_TAG_subroutine_type:
111  case dwarf::DW_TAG_typedef:
112  case dwarf::DW_TAG_union_type:
113  case dwarf::DW_TAG_ptr_to_member_type:
114  case dwarf::DW_TAG_set_type:
115  case dwarf::DW_TAG_subrange_type:
116  case dwarf::DW_TAG_base_type:
117  case dwarf::DW_TAG_const_type:
118  case dwarf::DW_TAG_constant:
119  case dwarf::DW_TAG_file_type:
120  case dwarf::DW_TAG_namelist:
121  case dwarf::DW_TAG_packed_type:
122  case dwarf::DW_TAG_volatile_type:
123  case dwarf::DW_TAG_restrict_type:
124  case dwarf::DW_TAG_atomic_type:
125  case dwarf::DW_TAG_interface_type:
126  case dwarf::DW_TAG_unspecified_type:
127  case dwarf::DW_TAG_shared_type:
128  case dwarf::DW_TAG_immutable_type:
129  return true;
130  default:
131  break;
132  }
133  return false;
134 }
135 
136 AddressesMap::~AddressesMap() = default;
137 
138 DwarfEmitter::~DwarfEmitter() = default;
139 
141  // We are looking for template parameters to strip from Name. e.g.
142  //
143  // operator<<B>
144  //
145  // We look for > at the end but if it does not contain any < then we
146  // have something like operator>>. We check for the operator<=> case.
147  if (!Name.endswith(">") || Name.count("<") == 0 || Name.endswith("<=>"))
148  return {};
149 
150  // How many < until we have the start of the template parameters.
151  size_t NumLeftAnglesToSkip = 1;
152 
153  // If we have operator<=> then we need to skip its < as well.
154  NumLeftAnglesToSkip += Name.count("<=>");
155 
156  size_t RightAngleCount = Name.count('>');
157  size_t LeftAngleCount = Name.count('<');
158 
159  // If we have more < than > we have operator< or operator<<
160  // we to account for their < as well.
161  if (LeftAngleCount > RightAngleCount)
162  NumLeftAnglesToSkip += LeftAngleCount - RightAngleCount;
163 
164  size_t StartOfTemplate = 0;
165  while (NumLeftAnglesToSkip--)
166  StartOfTemplate = Name.find('<', StartOfTemplate) + 1;
167 
168  return Name.substr(0, StartOfTemplate - 1);
169 }
170 
171 bool DWARFLinker::DIECloner::getDIENames(const DWARFDie &Die,
172  AttributesInfo &Info,
173  OffsetsStringPool &StringPool,
174  bool StripTemplate) {
175  // This function will be called on DIEs having low_pcs and
176  // ranges. As getting the name might be more expansive, filter out
177  // blocks directly.
178  if (Die.getTag() == dwarf::DW_TAG_lexical_block)
179  return false;
180 
181  if (!Info.MangledName)
182  if (const char *MangledName = Die.getLinkageName())
183  Info.MangledName = StringPool.getEntry(MangledName);
184 
185  if (!Info.Name)
186  if (const char *Name = Die.getShortName())
187  Info.Name = StringPool.getEntry(Name);
188 
189  if (!Info.MangledName)
190  Info.MangledName = Info.Name;
191 
192  if (StripTemplate && Info.Name && Info.MangledName != Info.Name) {
193  StringRef Name = Info.Name.getString();
194  if (Optional<StringRef> StrippedName = StripTemplateParameters(Name))
195  Info.NameWithoutTemplate = StringPool.getEntry(*StrippedName);
196  }
197 
198  return Info.Name || Info.MangledName;
199 }
200 
201 /// Resolve the relative path to a build artifact referenced by DWARF by
202 /// applying DW_AT_comp_dir.
204  sys::path::append(Buf, dwarf::toString(CU.find(dwarf::DW_AT_comp_dir), ""));
205 }
206 
207 /// Collect references to parseable Swift interfaces in imported
208 /// DW_TAG_module blocks.
210  const DWARFDie &DIE, CompileUnit &CU,
211  swiftInterfacesMap *ParseableSwiftInterfaces,
212  std::function<void(const Twine &, const DWARFDie &)> ReportWarning) {
213  if (CU.getLanguage() != dwarf::DW_LANG_Swift)
214  return;
215 
216  if (!ParseableSwiftInterfaces)
217  return;
218 
219  StringRef Path = dwarf::toStringRef(DIE.find(dwarf::DW_AT_LLVM_include_path));
220  if (!Path.endswith(".swiftinterface"))
221  return;
222  // Don't track interfaces that are part of the SDK.
223  StringRef SysRoot = dwarf::toStringRef(DIE.find(dwarf::DW_AT_LLVM_sysroot));
224  if (SysRoot.empty())
225  SysRoot = CU.getSysRoot();
226  if (!SysRoot.empty() && Path.startswith(SysRoot))
227  return;
228  Optional<const char*> Name = dwarf::toString(DIE.find(dwarf::DW_AT_name));
229  if (!Name)
230  return;
231  auto &Entry = (*ParseableSwiftInterfaces)[*Name];
232  // The prepend path is applied later when copying.
233  DWARFDie CUDie = CU.getOrigUnit().getUnitDIE();
234  SmallString<128> ResolvedPath;
235  if (sys::path::is_relative(Path))
236  resolveRelativeObjectPath(ResolvedPath, CUDie);
237  sys::path::append(ResolvedPath, Path);
238  if (!Entry.empty() && Entry != ResolvedPath)
239  ReportWarning(Twine("Conflicting parseable interfaces for Swift Module ") +
240  *Name + ": " + Entry + " and " + Path,
241  DIE);
242  Entry = std::string(ResolvedPath.str());
243 }
244 
245 /// The distinct types of work performed by the work loop in
246 /// analyzeContextInfo.
247 enum class ContextWorklistItemType : uint8_t {
251 };
252 
253 /// This class represents an item in the work list. The type defines what kind
254 /// of work needs to be performed when processing the current item. Everything
255 /// but the Type and Die fields are optional based on the type.
258  unsigned ParentIdx;
259  union {
262  };
265 
267  CompileUnit::DIEInfo *OtherInfo = nullptr)
270 
272  bool InImportedModule)
276 };
277 
278 static bool updatePruning(const DWARFDie &Die, CompileUnit &CU,
279  uint64_t ModulesEndOffset) {
280  CompileUnit::DIEInfo &Info = CU.getInfo(Die);
281 
282  // Prune this DIE if it is either a forward declaration inside a
283  // DW_TAG_module or a DW_TAG_module that contains nothing but
284  // forward declarations.
285  Info.Prune &= (Die.getTag() == dwarf::DW_TAG_module) ||
286  (isTypeTag(Die.getTag()) &&
287  dwarf::toUnsigned(Die.find(dwarf::DW_AT_declaration), 0));
288 
289  // Only prune forward declarations inside a DW_TAG_module for which a
290  // definition exists elsewhere.
291  if (ModulesEndOffset == 0)
292  Info.Prune &= Info.Ctxt && Info.Ctxt->getCanonicalDIEOffset();
293  else
294  Info.Prune &= Info.Ctxt && Info.Ctxt->getCanonicalDIEOffset() > 0 &&
295  Info.Ctxt->getCanonicalDIEOffset() <= ModulesEndOffset;
296 
297  return Info.Prune;
298 }
299 
300 static void updateChildPruning(const DWARFDie &Die, CompileUnit &CU,
301  CompileUnit::DIEInfo &ChildInfo) {
302  CompileUnit::DIEInfo &Info = CU.getInfo(Die);
303  Info.Prune &= ChildInfo.Prune;
304 }
305 
306 /// Recursive helper to build the global DeclContext information and
307 /// gather the child->parent relationships in the original compile unit.
308 ///
309 /// This function uses the same work list approach as lookForDIEsToKeep.
310 ///
311 /// \return true when this DIE and all of its children are only
312 /// forward declarations to types defined in external clang modules
313 /// (i.e., forward declarations that are children of a DW_TAG_module).
314 static bool analyzeContextInfo(
315  const DWARFDie &DIE, unsigned ParentIdx, CompileUnit &CU,
316  DeclContext *CurrentDeclContext, DeclContextTree &Contexts,
317  uint64_t ModulesEndOffset, swiftInterfacesMap *ParseableSwiftInterfaces,
318  std::function<void(const Twine &, const DWARFDie &)> ReportWarning,
319  bool InImportedModule = false) {
320  // LIFO work list.
321  std::vector<ContextWorklistItem> Worklist;
322  Worklist.emplace_back(DIE, CurrentDeclContext, ParentIdx, InImportedModule);
323 
324  while (!Worklist.empty()) {
325  ContextWorklistItem Current = Worklist.back();
326  Worklist.pop_back();
327 
328  switch (Current.Type) {
330  updatePruning(Current.Die, CU, ModulesEndOffset);
331  continue;
333  updateChildPruning(Current.Die, CU, *Current.OtherInfo);
334  continue;
336  break;
337  }
338 
339  unsigned Idx = CU.getOrigUnit().getDIEIndex(Current.Die);
340  CompileUnit::DIEInfo &Info = CU.getInfo(Idx);
341 
342  // Clang imposes an ODR on modules(!) regardless of the language:
343  // "The module-id should consist of only a single identifier,
344  // which provides the name of the module being defined. Each
345  // module shall have a single definition."
346  //
347  // This does not extend to the types inside the modules:
348  // "[I]n C, this implies that if two structs are defined in
349  // different submodules with the same name, those two types are
350  // distinct types (but may be compatible types if their
351  // definitions match)."
352  //
353  // We treat non-C++ modules like namespaces for this reason.
354  if (Current.Die.getTag() == dwarf::DW_TAG_module &&
355  Current.ParentIdx == 0 &&
356  dwarf::toString(Current.Die.find(dwarf::DW_AT_name), "") !=
357  CU.getClangModuleName()) {
358  Current.InImportedModule = true;
359  analyzeImportedModule(Current.Die, CU, ParseableSwiftInterfaces,
360  ReportWarning);
361  }
362 
363  Info.ParentIdx = Current.ParentIdx;
364  bool InClangModule = CU.isClangModule() || Current.InImportedModule;
365  if (CU.hasODR() || InClangModule) {
366  if (Current.Context) {
367  auto PtrInvalidPair = Contexts.getChildDeclContext(
368  *Current.Context, Current.Die, CU, InClangModule);
369  Current.Context = PtrInvalidPair.getPointer();
370  Info.Ctxt =
371  PtrInvalidPair.getInt() ? nullptr : PtrInvalidPair.getPointer();
372  if (Info.Ctxt)
373  Info.Ctxt->setDefinedInClangModule(InClangModule);
374  } else
375  Info.Ctxt = Current.Context = nullptr;
376  }
377 
378  Info.Prune = Current.InImportedModule;
379  // Add children in reverse order to the worklist to effectively process
380  // them in order.
381  Worklist.emplace_back(Current.Die, ContextWorklistItemType::UpdatePruning);
382  for (auto Child : reverse(Current.Die.children())) {
383  CompileUnit::DIEInfo &ChildInfo = CU.getInfo(Child);
384  Worklist.emplace_back(
385  Current.Die, ContextWorklistItemType::UpdateChildPruning, &ChildInfo);
386  Worklist.emplace_back(Child, Current.Context, Idx,
387  Current.InImportedModule);
388  }
389  }
390 
391  return CU.getInfo(DIE).Prune;
392 }
393 
395  switch (Tag) {
396  default:
397  return false;
398  case dwarf::DW_TAG_class_type:
399  case dwarf::DW_TAG_common_block:
400  case dwarf::DW_TAG_lexical_block:
401  case dwarf::DW_TAG_structure_type:
402  case dwarf::DW_TAG_subprogram:
403  case dwarf::DW_TAG_subroutine_type:
404  case dwarf::DW_TAG_union_type:
405  return true;
406  }
407  llvm_unreachable("Invalid Tag");
408 }
409 
410 void DWARFLinker::cleanupAuxiliarryData(LinkContext &Context) {
411  Context.clear();
412 
413  for (DIEBlock *I : DIEBlocks)
414  I->~DIEBlock();
415  for (DIELoc *I : DIELocs)
416  I->~DIELoc();
417 
418  DIEBlocks.clear();
419  DIELocs.clear();
420  DIEAlloc.Reset();
421 }
422 
423 /// Check if a variable describing DIE should be kept.
424 /// \returns updated TraversalFlags.
425 unsigned DWARFLinker::shouldKeepVariableDIE(AddressesMap &RelocMgr,
426  const DWARFDie &DIE,
427  CompileUnit::DIEInfo &MyInfo,
428  unsigned Flags) {
429  const auto *Abbrev = DIE.getAbbreviationDeclarationPtr();
430 
431  // Global variables with constant value can always be kept.
432  if (!(Flags & TF_InFunctionScope) &&
433  Abbrev->findAttributeIndex(dwarf::DW_AT_const_value)) {
434  MyInfo.InDebugMap = true;
435  return Flags | TF_Keep;
436  }
437 
438  // See if there is a relocation to a valid debug map entry inside this
439  // variable's location. The order is important here. We want to always check
440  // if the variable has a valid relocation, so that the DIEInfo is filled.
441  // However, we don't want a static variable in a function to force us to keep
442  // the enclosing function, unless requested explicitly.
443  const bool HasLiveMemoryLocation = RelocMgr.isLiveVariable(DIE, MyInfo);
444  if (!HasLiveMemoryLocation || ((Flags & TF_InFunctionScope) &&
445  !LLVM_UNLIKELY(Options.KeepFunctionForStatic)))
446  return Flags;
447 
448  if (Options.Verbose) {
449  outs() << "Keeping variable DIE:";
450  DIDumpOptions DumpOpts;
451  DumpOpts.ChildRecurseDepth = 0;
452  DumpOpts.Verbose = Options.Verbose;
453  DIE.dump(outs(), 8 /* Indent */, DumpOpts);
454  }
455 
456  return Flags | TF_Keep;
457 }
458 
459 /// Check if a function describing DIE should be kept.
460 /// \returns updated TraversalFlags.
461 unsigned DWARFLinker::shouldKeepSubprogramDIE(
462  AddressesMap &RelocMgr, RangesTy &Ranges, const DWARFDie &DIE,
463  const DWARFFile &File, CompileUnit &Unit, CompileUnit::DIEInfo &MyInfo,
464  unsigned Flags) {
465  Flags |= TF_InFunctionScope;
466 
467  auto LowPc = dwarf::toAddress(DIE.find(dwarf::DW_AT_low_pc));
468  if (!LowPc)
469  return Flags;
470 
471  assert(LowPc && "low_pc attribute is not an address.");
472  if (!RelocMgr.isLiveSubprogram(DIE, MyInfo))
473  return Flags;
474 
475  if (Options.Verbose) {
476  outs() << "Keeping subprogram DIE:";
477  DIDumpOptions DumpOpts;
478  DumpOpts.ChildRecurseDepth = 0;
479  DumpOpts.Verbose = Options.Verbose;
480  DIE.dump(outs(), 8 /* Indent */, DumpOpts);
481  }
482 
483  if (DIE.getTag() == dwarf::DW_TAG_label) {
484  if (Unit.hasLabelAt(*LowPc))
485  return Flags;
486 
487  DWARFUnit &OrigUnit = Unit.getOrigUnit();
488  // FIXME: dsymutil-classic compat. dsymutil-classic doesn't consider labels
489  // that don't fall into the CU's aranges. This is wrong IMO. Debug info
490  // generation bugs aside, this is really wrong in the case of labels, where
491  // a label marking the end of a function will have a PC == CU's high_pc.
492  if (dwarf::toAddress(OrigUnit.getUnitDIE().find(dwarf::DW_AT_high_pc))
493  .value_or(UINT64_MAX) <= LowPc)
494  return Flags;
495  Unit.addLabelLowPc(*LowPc, MyInfo.AddrAdjust);
496  return Flags | TF_Keep;
497  }
498 
499  Flags |= TF_Keep;
500 
501  Optional<uint64_t> HighPc = DIE.getHighPC(*LowPc);
502  if (!HighPc) {
503  reportWarning("Function without high_pc. Range will be discarded.\n", File,
504  &DIE);
505  return Flags;
506  }
507 
508  // Replace the debug map range with a more accurate one.
509  Ranges[*LowPc] = ObjFileAddressRange(*HighPc, MyInfo.AddrAdjust);
510  Unit.addFunctionRange(*LowPc, *HighPc, MyInfo.AddrAdjust);
511  return Flags;
512 }
513 
514 /// Check if a DIE should be kept.
515 /// \returns updated TraversalFlags.
516 unsigned DWARFLinker::shouldKeepDIE(AddressesMap &RelocMgr, RangesTy &Ranges,
517  const DWARFDie &DIE, const DWARFFile &File,
518  CompileUnit &Unit,
519  CompileUnit::DIEInfo &MyInfo,
520  unsigned Flags) {
521  switch (DIE.getTag()) {
522  case dwarf::DW_TAG_constant:
523  case dwarf::DW_TAG_variable:
524  return shouldKeepVariableDIE(RelocMgr, DIE, MyInfo, Flags);
525  case dwarf::DW_TAG_subprogram:
526  case dwarf::DW_TAG_label:
527  return shouldKeepSubprogramDIE(RelocMgr, Ranges, DIE, File, Unit, MyInfo,
528  Flags);
529  case dwarf::DW_TAG_base_type:
530  // DWARF Expressions may reference basic types, but scanning them
531  // is expensive. Basic types are tiny, so just keep all of them.
532  case dwarf::DW_TAG_imported_module:
533  case dwarf::DW_TAG_imported_declaration:
534  case dwarf::DW_TAG_imported_unit:
535  // We always want to keep these.
536  return Flags | TF_Keep;
537  default:
538  break;
539  }
540 
541  return Flags;
542 }
543 
544 /// Helper that updates the completeness of the current DIE based on the
545 /// completeness of one of its children. It depends on the incompleteness of
546 /// the children already being computed.
548  CompileUnit::DIEInfo &ChildInfo) {
549  switch (Die.getTag()) {
550  case dwarf::DW_TAG_structure_type:
551  case dwarf::DW_TAG_class_type:
552  case dwarf::DW_TAG_union_type:
553  break;
554  default:
555  return;
556  }
557 
558  CompileUnit::DIEInfo &MyInfo = CU.getInfo(Die);
559 
560  if (ChildInfo.Incomplete || ChildInfo.Prune)
561  MyInfo.Incomplete = true;
562 }
563 
564 /// Helper that updates the completeness of the current DIE based on the
565 /// completeness of the DIEs it references. It depends on the incompleteness of
566 /// the referenced DIE already being computed.
568  CompileUnit::DIEInfo &RefInfo) {
569  switch (Die.getTag()) {
570  case dwarf::DW_TAG_typedef:
571  case dwarf::DW_TAG_member:
572  case dwarf::DW_TAG_reference_type:
573  case dwarf::DW_TAG_ptr_to_member_type:
574  case dwarf::DW_TAG_pointer_type:
575  break;
576  default:
577  return;
578  }
579 
580  CompileUnit::DIEInfo &MyInfo = CU.getInfo(Die);
581 
582  if (MyInfo.Incomplete)
583  return;
584 
585  if (RefInfo.Incomplete)
586  MyInfo.Incomplete = true;
587 }
588 
589 /// Look at the children of the given DIE and decide whether they should be
590 /// kept.
591 void DWARFLinker::lookForChildDIEsToKeep(
592  const DWARFDie &Die, CompileUnit &CU, unsigned Flags,
593  SmallVectorImpl<WorklistItem> &Worklist) {
594  // The TF_ParentWalk flag tells us that we are currently walking up the
595  // parent chain of a required DIE, and we don't want to mark all the children
596  // of the parents as kept (consider for example a DW_TAG_namespace node in
597  // the parent chain). There are however a set of DIE types for which we want
598  // to ignore that directive and still walk their children.
599  if (dieNeedsChildrenToBeMeaningful(Die.getTag()))
600  Flags &= ~DWARFLinker::TF_ParentWalk;
601 
602  // We're finished if this DIE has no children or we're walking the parent
603  // chain.
604  if (!Die.hasChildren() || (Flags & DWARFLinker::TF_ParentWalk))
605  return;
606 
607  // Add children in reverse order to the worklist to effectively process them
608  // in order.
609  for (auto Child : reverse(Die.children())) {
610  // Add a worklist item before every child to calculate incompleteness right
611  // after the current child is processed.
612  CompileUnit::DIEInfo &ChildInfo = CU.getInfo(Child);
613  Worklist.emplace_back(Die, CU, WorklistItemType::UpdateChildIncompleteness,
614  &ChildInfo);
615  Worklist.emplace_back(Child, CU, Flags);
616  }
617 }
618 
619 /// Look at DIEs referenced by the given DIE and decide whether they should be
620 /// kept. All DIEs referenced though attributes should be kept.
621 void DWARFLinker::lookForRefDIEsToKeep(
622  const DWARFDie &Die, CompileUnit &CU, unsigned Flags,
623  const UnitListTy &Units, const DWARFFile &File,
624  SmallVectorImpl<WorklistItem> &Worklist) {
625  bool UseOdr = (Flags & DWARFLinker::TF_DependencyWalk)
626  ? (Flags & DWARFLinker::TF_ODR)
627  : CU.hasODR();
628  DWARFUnit &Unit = CU.getOrigUnit();
629  DWARFDataExtractor Data = Unit.getDebugInfoExtractor();
630  const auto *Abbrev = Die.getAbbreviationDeclarationPtr();
631  uint64_t Offset = Die.getOffset() + getULEB128Size(Abbrev->getCode());
632 
633  SmallVector<std::pair<DWARFDie, CompileUnit &>, 4> ReferencedDIEs;
634  for (const auto &AttrSpec : Abbrev->attributes()) {
635  DWARFFormValue Val(AttrSpec.Form);
636  if (!Val.isFormClass(DWARFFormValue::FC_Reference) ||
637  AttrSpec.Attr == dwarf::DW_AT_sibling) {
638  DWARFFormValue::skipValue(AttrSpec.Form, Data, &Offset,
639  Unit.getFormParams());
640  continue;
641  }
642 
643  Val.extractValue(Data, &Offset, Unit.getFormParams(), &Unit);
644  CompileUnit *ReferencedCU;
645  if (auto RefDie =
646  resolveDIEReference(File, Units, Val, Die, ReferencedCU)) {
647  CompileUnit::DIEInfo &Info = ReferencedCU->getInfo(RefDie);
648  bool IsModuleRef = Info.Ctxt && Info.Ctxt->getCanonicalDIEOffset() &&
649  Info.Ctxt->isDefinedInClangModule();
650  // If the referenced DIE has a DeclContext that has already been
651  // emitted, then do not keep the one in this CU. We'll link to
652  // the canonical DIE in cloneDieReferenceAttribute.
653  //
654  // FIXME: compatibility with dsymutil-classic. UseODR shouldn't
655  // be necessary and could be advantageously replaced by
656  // ReferencedCU->hasODR() && CU.hasODR().
657  //
658  // FIXME: compatibility with dsymutil-classic. There is no
659  // reason not to unique ref_addr references.
660  if (AttrSpec.Form != dwarf::DW_FORM_ref_addr && (UseOdr || IsModuleRef) &&
661  Info.Ctxt &&
662  Info.Ctxt != ReferencedCU->getInfo(Info.ParentIdx).Ctxt &&
663  Info.Ctxt->getCanonicalDIEOffset() && isODRAttribute(AttrSpec.Attr))
664  continue;
665 
666  // Keep a module forward declaration if there is no definition.
667  if (!(isODRAttribute(AttrSpec.Attr) && Info.Ctxt &&
668  Info.Ctxt->getCanonicalDIEOffset()))
669  Info.Prune = false;
670  ReferencedDIEs.emplace_back(RefDie, *ReferencedCU);
671  }
672  }
673 
674  unsigned ODRFlag = UseOdr ? DWARFLinker::TF_ODR : 0;
675 
676  // Add referenced DIEs in reverse order to the worklist to effectively
677  // process them in order.
678  for (auto &P : reverse(ReferencedDIEs)) {
679  // Add a worklist item before every child to calculate incompleteness right
680  // after the current child is processed.
681  CompileUnit::DIEInfo &Info = P.second.getInfo(P.first);
682  Worklist.emplace_back(Die, CU, WorklistItemType::UpdateRefIncompleteness,
683  &Info);
684  Worklist.emplace_back(P.first, P.second,
685  DWARFLinker::TF_Keep |
686  DWARFLinker::TF_DependencyWalk | ODRFlag);
687  }
688 }
689 
690 /// Look at the parent of the given DIE and decide whether they should be kept.
691 void DWARFLinker::lookForParentDIEsToKeep(
692  unsigned AncestorIdx, CompileUnit &CU, unsigned Flags,
693  SmallVectorImpl<WorklistItem> &Worklist) {
694  // Stop if we encounter an ancestor that's already marked as kept.
695  if (CU.getInfo(AncestorIdx).Keep)
696  return;
697 
698  DWARFUnit &Unit = CU.getOrigUnit();
699  DWARFDie ParentDIE = Unit.getDIEAtIndex(AncestorIdx);
700  Worklist.emplace_back(CU.getInfo(AncestorIdx).ParentIdx, CU, Flags);
701  Worklist.emplace_back(ParentDIE, CU, Flags);
702 }
703 
704 /// Recursively walk the \p DIE tree and look for DIEs to keep. Store that
705 /// information in \p CU's DIEInfo.
706 ///
707 /// This function is the entry point of the DIE selection algorithm. It is
708 /// expected to walk the DIE tree in file order and (though the mediation of
709 /// its helper) call hasValidRelocation() on each DIE that might be a 'root
710 /// DIE' (See DwarfLinker class comment).
711 ///
712 /// While walking the dependencies of root DIEs, this function is also called,
713 /// but during these dependency walks the file order is not respected. The
714 /// TF_DependencyWalk flag tells us which kind of traversal we are currently
715 /// doing.
716 ///
717 /// The recursive algorithm is implemented iteratively as a work list because
718 /// very deep recursion could exhaust the stack for large projects. The work
719 /// list acts as a scheduler for different types of work that need to be
720 /// performed.
721 ///
722 /// The recursive nature of the algorithm is simulated by running the "main"
723 /// algorithm (LookForDIEsToKeep) followed by either looking at more DIEs
724 /// (LookForChildDIEsToKeep, LookForRefDIEsToKeep, LookForParentDIEsToKeep) or
725 /// fixing up a computed property (UpdateChildIncompleteness,
726 /// UpdateRefIncompleteness).
727 ///
728 /// The return value indicates whether the DIE is incomplete.
729 void DWARFLinker::lookForDIEsToKeep(AddressesMap &AddressesMap,
730  RangesTy &Ranges, const UnitListTy &Units,
731  const DWARFDie &Die, const DWARFFile &File,
732  CompileUnit &Cu, unsigned Flags) {
733  // LIFO work list.
734  SmallVector<WorklistItem, 4> Worklist;
735  Worklist.emplace_back(Die, Cu, Flags);
736 
737  while (!Worklist.empty()) {
738  WorklistItem Current = Worklist.pop_back_val();
739 
740  // Look at the worklist type to decide what kind of work to perform.
741  switch (Current.Type) {
742  case WorklistItemType::UpdateChildIncompleteness:
743  updateChildIncompleteness(Current.Die, Current.CU, *Current.OtherInfo);
744  continue;
745  case WorklistItemType::UpdateRefIncompleteness:
746  updateRefIncompleteness(Current.Die, Current.CU, *Current.OtherInfo);
747  continue;
748  case WorklistItemType::LookForChildDIEsToKeep:
749  lookForChildDIEsToKeep(Current.Die, Current.CU, Current.Flags, Worklist);
750  continue;
751  case WorklistItemType::LookForRefDIEsToKeep:
752  lookForRefDIEsToKeep(Current.Die, Current.CU, Current.Flags, Units, File,
753  Worklist);
754  continue;
755  case WorklistItemType::LookForParentDIEsToKeep:
756  lookForParentDIEsToKeep(Current.AncestorIdx, Current.CU, Current.Flags,
757  Worklist);
758  continue;
759  case WorklistItemType::LookForDIEsToKeep:
760  break;
761  }
762 
763  unsigned Idx = Current.CU.getOrigUnit().getDIEIndex(Current.Die);
764  CompileUnit::DIEInfo &MyInfo = Current.CU.getInfo(Idx);
765 
766  if (MyInfo.Prune)
767  continue;
768 
769  // If the Keep flag is set, we are marking a required DIE's dependencies.
770  // If our target is already marked as kept, we're all set.
771  bool AlreadyKept = MyInfo.Keep;
772  if ((Current.Flags & TF_DependencyWalk) && AlreadyKept)
773  continue;
774 
775  // We must not call shouldKeepDIE while called from keepDIEAndDependencies,
776  // because it would screw up the relocation finding logic.
777  if (!(Current.Flags & TF_DependencyWalk))
778  Current.Flags = shouldKeepDIE(AddressesMap, Ranges, Current.Die, File,
779  Current.CU, MyInfo, Current.Flags);
780 
781  // Finish by looking for child DIEs. Because of the LIFO worklist we need
782  // to schedule that work before any subsequent items are added to the
783  // worklist.
784  Worklist.emplace_back(Current.Die, Current.CU, Current.Flags,
785  WorklistItemType::LookForChildDIEsToKeep);
786 
787  if (AlreadyKept || !(Current.Flags & TF_Keep))
788  continue;
789 
790  // If it is a newly kept DIE mark it as well as all its dependencies as
791  // kept.
792  MyInfo.Keep = true;
793 
794  // We're looking for incomplete types.
795  MyInfo.Incomplete =
796  Current.Die.getTag() != dwarf::DW_TAG_subprogram &&
797  Current.Die.getTag() != dwarf::DW_TAG_member &&
798  dwarf::toUnsigned(Current.Die.find(dwarf::DW_AT_declaration), 0);
799 
800  // After looking at the parent chain, look for referenced DIEs. Because of
801  // the LIFO worklist we need to schedule that work before any subsequent
802  // items are added to the worklist.
803  Worklist.emplace_back(Current.Die, Current.CU, Current.Flags,
804  WorklistItemType::LookForRefDIEsToKeep);
805 
806  bool UseOdr = (Current.Flags & TF_DependencyWalk) ? (Current.Flags & TF_ODR)
807  : Current.CU.hasODR();
808  unsigned ODRFlag = UseOdr ? TF_ODR : 0;
809  unsigned ParFlags = TF_ParentWalk | TF_Keep | TF_DependencyWalk | ODRFlag;
810 
811  // Now schedule the parent walk.
812  Worklist.emplace_back(MyInfo.ParentIdx, Current.CU, ParFlags);
813  }
814 }
815 
816 /// Assign an abbreviation number to \p Abbrev.
817 ///
818 /// Our DIEs get freed after every DebugMapObject has been processed,
819 /// thus the FoldingSet we use to unique DIEAbbrevs cannot refer to
820 /// the instances hold by the DIEs. When we encounter an abbreviation
821 /// that we don't know, we create a permanent copy of it.
822 void DWARFLinker::assignAbbrev(DIEAbbrev &Abbrev) {
823  // Check the set for priors.
824  FoldingSetNodeID ID;
825  Abbrev.Profile(ID);
826  void *InsertToken;
827  DIEAbbrev *InSet = AbbreviationsSet.FindNodeOrInsertPos(ID, InsertToken);
828 
829  // If it's newly added.
830  if (InSet) {
831  // Assign existing abbreviation number.
832  Abbrev.setNumber(InSet->getNumber());
833  } else {
834  // Add to abbreviation list.
835  Abbreviations.push_back(
836  std::make_unique<DIEAbbrev>(Abbrev.getTag(), Abbrev.hasChildren()));
837  for (const auto &Attr : Abbrev.getData())
838  Abbreviations.back()->AddAttribute(Attr.getAttribute(), Attr.getForm());
839  AbbreviationsSet.InsertNode(Abbreviations.back().get(), InsertToken);
840  // Assign the unique abbreviation number.
841  Abbrev.setNumber(Abbreviations.size());
842  Abbreviations.back()->setNumber(Abbreviations.size());
843  }
844 }
845 
846 unsigned DWARFLinker::DIECloner::cloneStringAttribute(
847  DIE &Die, AttributeSpec AttrSpec, const DWARFFormValue &Val,
848  const DWARFUnit &U, OffsetsStringPool &StringPool, AttributesInfo &Info) {
849  Optional<const char *> String = dwarf::toString(Val);
850  if (!String)
851  return 0;
852 
853  // Switch everything to out of line strings.
854  auto StringEntry = StringPool.getEntry(*String);
855 
856  // Update attributes info.
857  if (AttrSpec.Attr == dwarf::DW_AT_name)
858  Info.Name = StringEntry;
859  else if (AttrSpec.Attr == dwarf::DW_AT_MIPS_linkage_name ||
860  AttrSpec.Attr == dwarf::DW_AT_linkage_name)
861  Info.MangledName = StringEntry;
862 
863  Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr), dwarf::DW_FORM_strp,
864  DIEInteger(StringEntry.getOffset()));
865 
866  return 4;
867 }
868 
869 unsigned DWARFLinker::DIECloner::cloneDieReferenceAttribute(
870  DIE &Die, const DWARFDie &InputDIE, AttributeSpec AttrSpec,
871  unsigned AttrSize, const DWARFFormValue &Val, const DWARFFile &File,
872  CompileUnit &Unit) {
873  const DWARFUnit &U = Unit.getOrigUnit();
874  uint64_t Ref = *Val.getAsReference();
875 
876  DIE *NewRefDie = nullptr;
877  CompileUnit *RefUnit = nullptr;
878  DeclContext *Ctxt = nullptr;
879 
880  DWARFDie RefDie =
881  Linker.resolveDIEReference(File, CompileUnits, Val, InputDIE, RefUnit);
882 
883  // If the referenced DIE is not found, drop the attribute.
884  if (!RefDie || AttrSpec.Attr == dwarf::DW_AT_sibling)
885  return 0;
886 
887  CompileUnit::DIEInfo &RefInfo = RefUnit->getInfo(RefDie);
888 
889  // If we already have emitted an equivalent DeclContext, just point
890  // at it.
891  if (isODRAttribute(AttrSpec.Attr)) {
892  Ctxt = RefInfo.Ctxt;
893  if (Ctxt && Ctxt->getCanonicalDIEOffset()) {
894  DIEInteger Attr(Ctxt->getCanonicalDIEOffset());
895  Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr),
896  dwarf::DW_FORM_ref_addr, Attr);
897  return U.getRefAddrByteSize();
898  }
899  }
900 
901  if (!RefInfo.Clone) {
902  assert(Ref > InputDIE.getOffset());
903  // We haven't cloned this DIE yet. Just create an empty one and
904  // store it. It'll get really cloned when we process it.
905  RefInfo.Clone = DIE::get(DIEAlloc, dwarf::Tag(RefDie.getTag()));
906  }
907  NewRefDie = RefInfo.Clone;
908 
909  if (AttrSpec.Form == dwarf::DW_FORM_ref_addr ||
910  (Unit.hasODR() && isODRAttribute(AttrSpec.Attr))) {
911  // We cannot currently rely on a DIEEntry to emit ref_addr
912  // references, because the implementation calls back to DwarfDebug
913  // to find the unit offset. (We don't have a DwarfDebug)
914  // FIXME: we should be able to design DIEEntry reliance on
915  // DwarfDebug away.
916  uint64_t Attr;
917  if (Ref < InputDIE.getOffset()) {
918  // We must have already cloned that DIE.
919  uint32_t NewRefOffset =
920  RefUnit->getStartOffset() + NewRefDie->getOffset();
921  Attr = NewRefOffset;
922  Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr),
923  dwarf::DW_FORM_ref_addr, DIEInteger(Attr));
924  } else {
925  // A forward reference. Note and fixup later.
926  Attr = 0xBADDEF;
927  Unit.noteForwardReference(
928  NewRefDie, RefUnit, Ctxt,
929  Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr),
930  dwarf::DW_FORM_ref_addr, DIEInteger(Attr)));
931  }
932  return U.getRefAddrByteSize();
933  }
934 
935  Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr),
936  dwarf::Form(AttrSpec.Form), DIEEntry(*NewRefDie));
937 
938  return AttrSize;
939 }
940 
941 void DWARFLinker::DIECloner::cloneExpression(
942  DataExtractor &Data, DWARFExpression Expression, const DWARFFile &File,
943  CompileUnit &Unit, SmallVectorImpl<uint8_t> &OutputBuffer) {
944  using Encoding = DWARFExpression::Operation::Encoding;
945 
946  uint64_t OpOffset = 0;
947  for (auto &Op : Expression) {
948  auto Description = Op.getDescription();
949  // DW_OP_const_type is variable-length and has 3
950  // operands. DWARFExpression thus far only supports 2.
951  auto Op0 = Description.Op[0];
952  auto Op1 = Description.Op[1];
953  if ((Op0 == Encoding::BaseTypeRef && Op1 != Encoding::SizeNA) ||
954  (Op1 == Encoding::BaseTypeRef && Op0 != Encoding::Size1))
955  Linker.reportWarning("Unsupported DW_OP encoding.", File);
956 
957  if ((Op0 == Encoding::BaseTypeRef && Op1 == Encoding::SizeNA) ||
958  (Op1 == Encoding::BaseTypeRef && Op0 == Encoding::Size1)) {
959  // This code assumes that the other non-typeref operand fits into 1 byte.
960  assert(OpOffset < Op.getEndOffset());
961  uint32_t ULEBsize = Op.getEndOffset() - OpOffset - 1;
962  assert(ULEBsize <= 16);
963 
964  // Copy over the operation.
965  OutputBuffer.push_back(Op.getCode());
966  uint64_t RefOffset;
967  if (Op1 == Encoding::SizeNA) {
968  RefOffset = Op.getRawOperand(0);
969  } else {
970  OutputBuffer.push_back(Op.getRawOperand(0));
971  RefOffset = Op.getRawOperand(1);
972  }
973  uint32_t Offset = 0;
974  // Look up the base type. For DW_OP_convert, the operand may be 0 to
975  // instead indicate the generic type. The same holds for
976  // DW_OP_reinterpret, which is currently not supported.
977  if (RefOffset > 0 || Op.getCode() != dwarf::DW_OP_convert) {
978  auto RefDie = Unit.getOrigUnit().getDIEForOffset(RefOffset);
979  CompileUnit::DIEInfo &Info = Unit.getInfo(RefDie);
980  if (DIE *Clone = Info.Clone)
981  Offset = Clone->getOffset();
982  else
983  Linker.reportWarning(
984  "base type ref doesn't point to DW_TAG_base_type.", File);
985  }
986  uint8_t ULEB[16];
987  unsigned RealSize = encodeULEB128(Offset, ULEB, ULEBsize);
988  if (RealSize > ULEBsize) {
989  // Emit the generic type as a fallback.
990  RealSize = encodeULEB128(0, ULEB, ULEBsize);
991  Linker.reportWarning("base type ref doesn't fit.", File);
992  }
993  assert(RealSize == ULEBsize && "padding failed");
994  ArrayRef<uint8_t> ULEBbytes(ULEB, ULEBsize);
995  OutputBuffer.append(ULEBbytes.begin(), ULEBbytes.end());
996  } else {
997  // Copy over everything else unmodified.
998  StringRef Bytes = Data.getData().slice(OpOffset, Op.getEndOffset());
999  OutputBuffer.append(Bytes.begin(), Bytes.end());
1000  }
1001  OpOffset = Op.getEndOffset();
1002  }
1003 }
1004 
1005 unsigned DWARFLinker::DIECloner::cloneBlockAttribute(
1006  DIE &Die, const DWARFFile &File, CompileUnit &Unit, AttributeSpec AttrSpec,
1007  const DWARFFormValue &Val, unsigned AttrSize, bool IsLittleEndian) {
1008  DIEValueList *Attr;
1009  DIEValue Value;
1010  DIELoc *Loc = nullptr;
1011  DIEBlock *Block = nullptr;
1012  if (AttrSpec.Form == dwarf::DW_FORM_exprloc) {
1013  Loc = new (DIEAlloc) DIELoc;
1014  Linker.DIELocs.push_back(Loc);
1015  } else {
1016  Block = new (DIEAlloc) DIEBlock;
1017  Linker.DIEBlocks.push_back(Block);
1018  }
1019  Attr = Loc ? static_cast<DIEValueList *>(Loc)
1020  : static_cast<DIEValueList *>(Block);
1021 
1022  if (Loc)
1023  Value = DIEValue(dwarf::Attribute(AttrSpec.Attr),
1024  dwarf::Form(AttrSpec.Form), Loc);
1025  else
1026  Value = DIEValue(dwarf::Attribute(AttrSpec.Attr),
1027  dwarf::Form(AttrSpec.Form), Block);
1028 
1029  // If the block is a DWARF Expression, clone it into the temporary
1030  // buffer using cloneExpression(), otherwise copy the data directly.
1031  SmallVector<uint8_t, 32> Buffer;
1032  ArrayRef<uint8_t> Bytes = *Val.getAsBlock();
1033  if (DWARFAttribute::mayHaveLocationExpr(AttrSpec.Attr) &&
1034  (Val.isFormClass(DWARFFormValue::FC_Block) ||
1035  Val.isFormClass(DWARFFormValue::FC_Exprloc))) {
1036  DWARFUnit &OrigUnit = Unit.getOrigUnit();
1037  DataExtractor Data(StringRef((const char *)Bytes.data(), Bytes.size()),
1038  IsLittleEndian, OrigUnit.getAddressByteSize());
1039  DWARFExpression Expr(Data, OrigUnit.getAddressByteSize(),
1040  OrigUnit.getFormParams().Format);
1041  cloneExpression(Data, Expr, File, Unit, Buffer);
1042  Bytes = Buffer;
1043  }
1044  for (auto Byte : Bytes)
1045  Attr->addValue(DIEAlloc, static_cast<dwarf::Attribute>(0),
1046  dwarf::DW_FORM_data1, DIEInteger(Byte));
1047 
1048  // FIXME: If DIEBlock and DIELoc just reuses the Size field of
1049  // the DIE class, this "if" could be replaced by
1050  // Attr->setSize(Bytes.size()).
1051  if (Loc)
1052  Loc->setSize(Bytes.size());
1053  else
1054  Block->setSize(Bytes.size());
1055 
1056  Die.addValue(DIEAlloc, Value);
1057  return AttrSize;
1058 }
1059 
1060 unsigned DWARFLinker::DIECloner::cloneAddressAttribute(
1061  DIE &Die, AttributeSpec AttrSpec, const DWARFFormValue &Val,
1062  const CompileUnit &Unit, AttributesInfo &Info) {
1063  if (LLVM_UNLIKELY(Linker.Options.Update)) {
1064  if (AttrSpec.Attr == dwarf::DW_AT_low_pc)
1065  Info.HasLowPc = true;
1066  Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr),
1067  dwarf::Form(AttrSpec.Form), DIEInteger(Val.getRawUValue()));
1068  return Unit.getOrigUnit().getAddressByteSize();
1069  }
1070 
1071  dwarf::Form Form = AttrSpec.Form;
1072  uint64_t Addr = 0;
1073  if (Form == dwarf::DW_FORM_addrx) {
1074  if (Optional<uint64_t> AddrOffsetSectionBase =
1075  Unit.getOrigUnit().getAddrOffsetSectionBase()) {
1076  uint64_t StartOffset = *AddrOffsetSectionBase + Val.getRawUValue();
1077  uint64_t EndOffset =
1078  StartOffset + Unit.getOrigUnit().getAddressByteSize();
1079  if (llvm::Expected<uint64_t> RelocAddr =
1080  ObjFile.Addresses->relocateIndexedAddr(StartOffset, EndOffset))
1081  Addr = *RelocAddr;
1082  else
1083  Linker.reportWarning(toString(RelocAddr.takeError()), ObjFile);
1084  } else
1085  Linker.reportWarning("no base offset for address table", ObjFile);
1086 
1087  // If this is an indexed address emit the debug_info address.
1088  Form = dwarf::DW_FORM_addr;
1089  } else
1090  Addr = *Val.getAsAddress();
1091 
1092  if (AttrSpec.Attr == dwarf::DW_AT_low_pc) {
1093  if (Die.getTag() == dwarf::DW_TAG_inlined_subroutine ||
1094  Die.getTag() == dwarf::DW_TAG_lexical_block ||
1095  Die.getTag() == dwarf::DW_TAG_label) {
1096  // The low_pc of a block or inline subroutine might get
1097  // relocated because it happens to match the low_pc of the
1098  // enclosing subprogram. To prevent issues with that, always use
1099  // the low_pc from the input DIE if relocations have been applied.
1100  Addr = (Info.OrigLowPc != std::numeric_limits<uint64_t>::max()
1101  ? Info.OrigLowPc
1102  : Addr) +
1103  Info.PCOffset;
1104  } else if (Die.getTag() == dwarf::DW_TAG_compile_unit) {
1105  Addr = Unit.getLowPc();
1107  return 0;
1108  }
1109  Info.HasLowPc = true;
1110  } else if (AttrSpec.Attr == dwarf::DW_AT_high_pc) {
1111  if (Die.getTag() == dwarf::DW_TAG_compile_unit) {
1112  if (uint64_t HighPc = Unit.getHighPc())
1113  Addr = HighPc;
1114  else
1115  return 0;
1116  } else
1117  // If we have a high_pc recorded for the input DIE, use
1118  // it. Otherwise (when no relocations where applied) just use the
1119  // one we just decoded.
1120  Addr = (Info.OrigHighPc ? Info.OrigHighPc : Addr) + Info.PCOffset;
1121  } else if (AttrSpec.Attr == dwarf::DW_AT_call_return_pc) {
1122  // Relocate a return PC address within a call site entry.
1123  if (Die.getTag() == dwarf::DW_TAG_call_site)
1124  Addr = (Info.OrigCallReturnPc ? Info.OrigCallReturnPc : Addr) +
1125  Info.PCOffset;
1126  } else if (AttrSpec.Attr == dwarf::DW_AT_call_pc) {
1127  // Relocate the address of a branch instruction within a call site entry.
1128  if (Die.getTag() == dwarf::DW_TAG_call_site)
1129  Addr = (Info.OrigCallPc ? Info.OrigCallPc : Addr) + Info.PCOffset;
1130  }
1131 
1132  Die.addValue(DIEAlloc, static_cast<dwarf::Attribute>(AttrSpec.Attr),
1133  static_cast<dwarf::Form>(Form), DIEInteger(Addr));
1134  return Unit.getOrigUnit().getAddressByteSize();
1135 }
1136 
1137 unsigned DWARFLinker::DIECloner::cloneScalarAttribute(
1138  DIE &Die, const DWARFDie &InputDIE, const DWARFFile &File,
1139  CompileUnit &Unit, AttributeSpec AttrSpec, const DWARFFormValue &Val,
1140  unsigned AttrSize, AttributesInfo &Info) {
1141  uint64_t Value;
1142 
1143  if (LLVM_UNLIKELY(Linker.Options.Update)) {
1144  if (auto OptionalValue = Val.getAsUnsignedConstant())
1145  Value = *OptionalValue;
1146  else if (auto OptionalValue = Val.getAsSignedConstant())
1147  Value = *OptionalValue;
1148  else if (auto OptionalValue = Val.getAsSectionOffset())
1149  Value = *OptionalValue;
1150  else {
1151  Linker.reportWarning(
1152  "Unsupported scalar attribute form. Dropping attribute.", File,
1153  &InputDIE);
1154  return 0;
1155  }
1156  if (AttrSpec.Attr == dwarf::DW_AT_declaration && Value)
1157  Info.IsDeclaration = true;
1158  Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr),
1159  dwarf::Form(AttrSpec.Form), DIEInteger(Value));
1160  return AttrSize;
1161  }
1162 
1163  if (AttrSpec.Attr == dwarf::DW_AT_high_pc &&
1164  Die.getTag() == dwarf::DW_TAG_compile_unit) {
1165  if (Unit.getLowPc() == -1ULL)
1166  return 0;
1167  // Dwarf >= 4 high_pc is an size, not an address.
1168  Value = Unit.getHighPc() - Unit.getLowPc();
1169  } else if (AttrSpec.Form == dwarf::DW_FORM_sec_offset)
1170  Value = *Val.getAsSectionOffset();
1171  else if (AttrSpec.Form == dwarf::DW_FORM_sdata)
1172  Value = *Val.getAsSignedConstant();
1173  else if (auto OptionalValue = Val.getAsUnsignedConstant())
1174  Value = *OptionalValue;
1175  else {
1176  Linker.reportWarning(
1177  "Unsupported scalar attribute form. Dropping attribute.", File,
1178  &InputDIE);
1179  return 0;
1180  }
1181  PatchLocation Patch =
1182  Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr),
1183  dwarf::Form(AttrSpec.Form), DIEInteger(Value));
1184  if (AttrSpec.Attr == dwarf::DW_AT_ranges) {
1185  Unit.noteRangeAttribute(Die, Patch);
1186  Info.HasRanges = true;
1187  }
1188 
1189  // A more generic way to check for location attributes would be
1190  // nice, but it's very unlikely that any other attribute needs a
1191  // location list.
1192  // FIXME: use DWARFAttribute::mayHaveLocationDescription().
1193  else if (AttrSpec.Attr == dwarf::DW_AT_location ||
1194  AttrSpec.Attr == dwarf::DW_AT_frame_base) {
1195  Unit.noteLocationAttribute(Patch, Info.PCOffset);
1196  } else if (AttrSpec.Attr == dwarf::DW_AT_declaration && Value)
1197  Info.IsDeclaration = true;
1198 
1199  return AttrSize;
1200 }
1201 
1202 /// Clone \p InputDIE's attribute described by \p AttrSpec with
1203 /// value \p Val, and add it to \p Die.
1204 /// \returns the size of the cloned attribute.
1205 unsigned DWARFLinker::DIECloner::cloneAttribute(
1206  DIE &Die, const DWARFDie &InputDIE, const DWARFFile &File,
1207  CompileUnit &Unit, OffsetsStringPool &StringPool, const DWARFFormValue &Val,
1208  const AttributeSpec AttrSpec, unsigned AttrSize, AttributesInfo &Info,
1209  bool IsLittleEndian) {
1210  const DWARFUnit &U = Unit.getOrigUnit();
1211 
1212  switch (AttrSpec.Form) {
1213  case dwarf::DW_FORM_strp:
1214  case dwarf::DW_FORM_string:
1215  case dwarf::DW_FORM_strx:
1216  case dwarf::DW_FORM_strx1:
1217  case dwarf::DW_FORM_strx2:
1218  case dwarf::DW_FORM_strx3:
1219  case dwarf::DW_FORM_strx4:
1220  return cloneStringAttribute(Die, AttrSpec, Val, U, StringPool, Info);
1221  case dwarf::DW_FORM_ref_addr:
1222  case dwarf::DW_FORM_ref1:
1223  case dwarf::DW_FORM_ref2:
1224  case dwarf::DW_FORM_ref4:
1225  case dwarf::DW_FORM_ref8:
1226  return cloneDieReferenceAttribute(Die, InputDIE, AttrSpec, AttrSize, Val,
1227  File, Unit);
1228  case dwarf::DW_FORM_block:
1229  case dwarf::DW_FORM_block1:
1230  case dwarf::DW_FORM_block2:
1231  case dwarf::DW_FORM_block4:
1232  case dwarf::DW_FORM_exprloc:
1233  return cloneBlockAttribute(Die, File, Unit, AttrSpec, Val, AttrSize,
1234  IsLittleEndian);
1235  case dwarf::DW_FORM_addr:
1236  case dwarf::DW_FORM_addrx:
1237  return cloneAddressAttribute(Die, AttrSpec, Val, Unit, Info);
1238  case dwarf::DW_FORM_data1:
1239  case dwarf::DW_FORM_data2:
1240  case dwarf::DW_FORM_data4:
1241  case dwarf::DW_FORM_data8:
1242  case dwarf::DW_FORM_udata:
1243  case dwarf::DW_FORM_sdata:
1244  case dwarf::DW_FORM_sec_offset:
1245  case dwarf::DW_FORM_flag:
1246  case dwarf::DW_FORM_flag_present:
1247  return cloneScalarAttribute(Die, InputDIE, File, Unit, AttrSpec, Val,
1248  AttrSize, Info);
1249  default:
1250  Linker.reportWarning("Unsupported attribute form " +
1251  dwarf::FormEncodingString(AttrSpec.Form) +
1252  " in cloneAttribute. Dropping.",
1253  File, &InputDIE);
1254  }
1255 
1256  return 0;
1257 }
1258 
1260  return Name.size() > 2 && (Name[0] == '-' || Name[0] == '+') &&
1261  (Name[1] == '[');
1262 }
1263 
1264 void DWARFLinker::DIECloner::addObjCAccelerator(CompileUnit &Unit,
1265  const DIE *Die,
1266  DwarfStringPoolEntryRef Name,
1267  OffsetsStringPool &StringPool,
1268  bool SkipPubSection) {
1269  assert(isObjCSelector(Name.getString()) && "not an objc selector");
1270  // Objective C method or class function.
1271  // "- [Class(Category) selector :withArg ...]"
1272  StringRef ClassNameStart(Name.getString().drop_front(2));
1273  size_t FirstSpace = ClassNameStart.find(' ');
1274  if (FirstSpace == StringRef::npos)
1275  return;
1276 
1277  StringRef SelectorStart(ClassNameStart.data() + FirstSpace + 1);
1278  if (!SelectorStart.size())
1279  return;
1280 
1281  StringRef Selector(SelectorStart.data(), SelectorStart.size() - 1);
1282  Unit.addNameAccelerator(Die, StringPool.getEntry(Selector), SkipPubSection);
1283 
1284  // Add an entry for the class name that points to this
1285  // method/class function.
1286  StringRef ClassName(ClassNameStart.data(), FirstSpace);
1287  Unit.addObjCAccelerator(Die, StringPool.getEntry(ClassName), SkipPubSection);
1288 
1289  if (ClassName[ClassName.size() - 1] == ')') {
1290  size_t OpenParens = ClassName.find('(');
1291  if (OpenParens != StringRef::npos) {
1292  StringRef ClassNameNoCategory(ClassName.data(), OpenParens);
1293  Unit.addObjCAccelerator(Die, StringPool.getEntry(ClassNameNoCategory),
1294  SkipPubSection);
1295 
1296  std::string MethodNameNoCategory(Name.getString().data(), OpenParens + 2);
1297  // FIXME: The missing space here may be a bug, but
1298  // dsymutil-classic also does it this way.
1299  MethodNameNoCategory.append(std::string(SelectorStart));
1300  Unit.addNameAccelerator(Die, StringPool.getEntry(MethodNameNoCategory),
1301  SkipPubSection);
1302  }
1303  }
1304 }
1305 
1306 static bool
1308  uint16_t Tag, bool InDebugMap, bool SkipPC,
1309  bool InFunctionScope) {
1310  switch (AttrSpec.Attr) {
1311  default:
1312  return false;
1313  case dwarf::DW_AT_low_pc:
1314  case dwarf::DW_AT_high_pc:
1315  case dwarf::DW_AT_ranges:
1316  return SkipPC;
1317  case dwarf::DW_AT_str_offsets_base:
1318  // FIXME: Use the string offset table with Dwarf 5.
1319  return true;
1320  case dwarf::DW_AT_location:
1321  case dwarf::DW_AT_frame_base:
1322  // FIXME: for some reason dsymutil-classic keeps the location attributes
1323  // when they are of block type (i.e. not location lists). This is totally
1324  // wrong for globals where we will keep a wrong address. It is mostly
1325  // harmless for locals, but there is no point in keeping these anyway when
1326  // the function wasn't linked.
1327  return (SkipPC || (!InFunctionScope && Tag == dwarf::DW_TAG_variable &&
1328  !InDebugMap)) &&
1330  }
1331 }
1332 
1333 DIE *DWARFLinker::DIECloner::cloneDIE(const DWARFDie &InputDIE,
1334  const DWARFFile &File, CompileUnit &Unit,
1335  OffsetsStringPool &StringPool,
1336  int64_t PCOffset, uint32_t OutOffset,
1337  unsigned Flags, bool IsLittleEndian,
1338  DIE *Die) {
1339  DWARFUnit &U = Unit.getOrigUnit();
1340  unsigned Idx = U.getDIEIndex(InputDIE);
1341  CompileUnit::DIEInfo &Info = Unit.getInfo(Idx);
1342 
1343  // Should the DIE appear in the output?
1344  if (!Unit.getInfo(Idx).Keep)
1345  return nullptr;
1346 
1347  uint64_t Offset = InputDIE.getOffset();
1348  assert(!(Die && Info.Clone) && "Can't supply a DIE and a cloned DIE");
1349  if (!Die) {
1350  // The DIE might have been already created by a forward reference
1351  // (see cloneDieReferenceAttribute()).
1352  if (!Info.Clone)
1353  Info.Clone = DIE::get(DIEAlloc, dwarf::Tag(InputDIE.getTag()));
1354  Die = Info.Clone;
1355  }
1356 
1357  assert(Die->getTag() == InputDIE.getTag());
1358  Die->setOffset(OutOffset);
1359  if ((Unit.hasODR() || Unit.isClangModule()) && !Info.Incomplete &&
1360  Die->getTag() != dwarf::DW_TAG_namespace && Info.Ctxt &&
1361  Info.Ctxt != Unit.getInfo(Info.ParentIdx).Ctxt &&
1362  !Info.Ctxt->getCanonicalDIEOffset()) {
1363  // We are about to emit a DIE that is the root of its own valid
1364  // DeclContext tree. Make the current offset the canonical offset
1365  // for this context.
1366  Info.Ctxt->setCanonicalDIEOffset(OutOffset + Unit.getStartOffset());
1367  }
1368 
1369  // Extract and clone every attribute.
1370  DWARFDataExtractor Data = U.getDebugInfoExtractor();
1371  // Point to the next DIE (generally there is always at least a NULL
1372  // entry after the current one). If this is a lone
1373  // DW_TAG_compile_unit without any children, point to the next unit.
1374  uint64_t NextOffset = (Idx + 1 < U.getNumDIEs())
1375  ? U.getDIEAtIndex(Idx + 1).getOffset()
1376  : U.getNextUnitOffset();
1377  AttributesInfo AttrInfo;
1378 
1379  // We could copy the data only if we need to apply a relocation to it. After
1380  // testing, it seems there is no performance downside to doing the copy
1381  // unconditionally, and it makes the code simpler.
1382  SmallString<40> DIECopy(Data.getData().substr(Offset, NextOffset - Offset));
1383  Data =
1384  DWARFDataExtractor(DIECopy, Data.isLittleEndian(), Data.getAddressSize());
1385 
1386  // Modify the copy with relocated addresses.
1387  if (ObjFile.Addresses->applyValidRelocs(DIECopy, Offset,
1388  Data.isLittleEndian())) {
1389  // If we applied relocations, we store the value of high_pc that was
1390  // potentially stored in the input DIE. If high_pc is an address
1391  // (Dwarf version == 2), then it might have been relocated to a
1392  // totally unrelated value (because the end address in the object
1393  // file might be start address of another function which got moved
1394  // independently by the linker). The computation of the actual
1395  // high_pc value is done in cloneAddressAttribute().
1396  AttrInfo.OrigHighPc =
1397  dwarf::toAddress(InputDIE.find(dwarf::DW_AT_high_pc), 0);
1398  // Also store the low_pc. It might get relocated in an
1399  // inline_subprogram that happens at the beginning of its
1400  // inlining function.
1401  AttrInfo.OrigLowPc = dwarf::toAddress(InputDIE.find(dwarf::DW_AT_low_pc),
1403  AttrInfo.OrigCallReturnPc =
1404  dwarf::toAddress(InputDIE.find(dwarf::DW_AT_call_return_pc), 0);
1405  AttrInfo.OrigCallPc =
1406  dwarf::toAddress(InputDIE.find(dwarf::DW_AT_call_pc), 0);
1407  }
1408 
1409  // Reset the Offset to 0 as we will be working on the local copy of
1410  // the data.
1411  Offset = 0;
1412 
1413  const auto *Abbrev = InputDIE.getAbbreviationDeclarationPtr();
1414  Offset += getULEB128Size(Abbrev->getCode());
1415 
1416  // We are entering a subprogram. Get and propagate the PCOffset.
1417  if (Die->getTag() == dwarf::DW_TAG_subprogram)
1418  PCOffset = Info.AddrAdjust;
1419  AttrInfo.PCOffset = PCOffset;
1420 
1421  if (Abbrev->getTag() == dwarf::DW_TAG_subprogram) {
1422  Flags |= TF_InFunctionScope;
1423  if (!Info.InDebugMap && LLVM_LIKELY(!Update))
1424  Flags |= TF_SkipPC;
1425  } else if (Abbrev->getTag() == dwarf::DW_TAG_variable) {
1426  // Function-local globals could be in the debug map even when the function
1427  // is not, e.g., inlined functions.
1428  if ((Flags & TF_InFunctionScope) && Info.InDebugMap)
1429  Flags &= ~TF_SkipPC;
1430  }
1431 
1432  for (const auto &AttrSpec : Abbrev->attributes()) {
1433  if (LLVM_LIKELY(!Update) &&
1434  shouldSkipAttribute(AttrSpec, Die->getTag(), Info.InDebugMap,
1435  Flags & TF_SkipPC, Flags & TF_InFunctionScope)) {
1436  DWARFFormValue::skipValue(AttrSpec.Form, Data, &Offset,
1437  U.getFormParams());
1438  continue;
1439  }
1440 
1441  DWARFFormValue Val(AttrSpec.Form);
1442  uint64_t AttrSize = Offset;
1443  Val.extractValue(Data, &Offset, U.getFormParams(), &U);
1444  AttrSize = Offset - AttrSize;
1445 
1446  OutOffset += cloneAttribute(*Die, InputDIE, File, Unit, StringPool, Val,
1447  AttrSpec, AttrSize, AttrInfo, IsLittleEndian);
1448  }
1449 
1450  // Look for accelerator entries.
1451  uint16_t Tag = InputDIE.getTag();
1452  // FIXME: This is slightly wrong. An inline_subroutine without a
1453  // low_pc, but with AT_ranges might be interesting to get into the
1454  // accelerator tables too. For now stick with dsymutil's behavior.
1455  if ((Info.InDebugMap || AttrInfo.HasLowPc || AttrInfo.HasRanges) &&
1456  Tag != dwarf::DW_TAG_compile_unit &&
1457  getDIENames(InputDIE, AttrInfo, StringPool,
1458  Tag != dwarf::DW_TAG_inlined_subroutine)) {
1459  if (AttrInfo.MangledName && AttrInfo.MangledName != AttrInfo.Name)
1460  Unit.addNameAccelerator(Die, AttrInfo.MangledName,
1461  Tag == dwarf::DW_TAG_inlined_subroutine);
1462  if (AttrInfo.Name) {
1463  if (AttrInfo.NameWithoutTemplate)
1464  Unit.addNameAccelerator(Die, AttrInfo.NameWithoutTemplate,
1465  /* SkipPubSection */ true);
1466  Unit.addNameAccelerator(Die, AttrInfo.Name,
1467  Tag == dwarf::DW_TAG_inlined_subroutine);
1468  }
1469  if (AttrInfo.Name && isObjCSelector(AttrInfo.Name.getString()))
1470  addObjCAccelerator(Unit, Die, AttrInfo.Name, StringPool,
1471  /* SkipPubSection =*/true);
1472 
1473  } else if (Tag == dwarf::DW_TAG_namespace) {
1474  if (!AttrInfo.Name)
1475  AttrInfo.Name = StringPool.getEntry("(anonymous namespace)");
1476  Unit.addNamespaceAccelerator(Die, AttrInfo.Name);
1477  } else if (isTypeTag(Tag) && !AttrInfo.IsDeclaration &&
1478  getDIENames(InputDIE, AttrInfo, StringPool) && AttrInfo.Name &&
1479  AttrInfo.Name.getString()[0]) {
1480  uint32_t Hash = hashFullyQualifiedName(InputDIE, Unit, File);
1481  uint64_t RuntimeLang =
1482  dwarf::toUnsigned(InputDIE.find(dwarf::DW_AT_APPLE_runtime_class))
1483  .value_or(0);
1484  bool ObjCClassIsImplementation =
1485  (RuntimeLang == dwarf::DW_LANG_ObjC ||
1486  RuntimeLang == dwarf::DW_LANG_ObjC_plus_plus) &&
1487  dwarf::toUnsigned(InputDIE.find(dwarf::DW_AT_APPLE_objc_complete_type))
1488  .value_or(0);
1489  Unit.addTypeAccelerator(Die, AttrInfo.Name, ObjCClassIsImplementation,
1490  Hash);
1491  }
1492 
1493  // Determine whether there are any children that we want to keep.
1494  bool HasChildren = false;
1495  for (auto Child : InputDIE.children()) {
1496  unsigned Idx = U.getDIEIndex(Child);
1497  if (Unit.getInfo(Idx).Keep) {
1498  HasChildren = true;
1499  break;
1500  }
1501  }
1502 
1503  DIEAbbrev NewAbbrev = Die->generateAbbrev();
1504  if (HasChildren)
1505  NewAbbrev.setChildrenFlag(dwarf::DW_CHILDREN_yes);
1506  // Assign a permanent abbrev number
1507  Linker.assignAbbrev(NewAbbrev);
1508  Die->setAbbrevNumber(NewAbbrev.getNumber());
1509 
1510  // Add the size of the abbreviation number to the output offset.
1511  OutOffset += getULEB128Size(Die->getAbbrevNumber());
1512 
1513  if (!HasChildren) {
1514  // Update our size.
1515  Die->setSize(OutOffset - Die->getOffset());
1516  return Die;
1517  }
1518 
1519  // Recursively clone children.
1520  for (auto Child : InputDIE.children()) {
1521  if (DIE *Clone = cloneDIE(Child, File, Unit, StringPool, PCOffset,
1522  OutOffset, Flags, IsLittleEndian)) {
1523  Die->addChild(Clone);
1524  OutOffset = Clone->getOffset() + Clone->getSize();
1525  }
1526  }
1527 
1528  // Account for the end of children marker.
1529  OutOffset += sizeof(int8_t);
1530  // Update our size.
1531  Die->setSize(OutOffset - Die->getOffset());
1532  return Die;
1533 }
1534 
1535 /// Patch the input object file relevant debug_ranges entries
1536 /// and emit them in the output file. Update the relevant attributes
1537 /// to point at the new entries.
1538 void DWARFLinker::patchRangesForUnit(const CompileUnit &Unit,
1539  DWARFContext &OrigDwarf,
1540  const DWARFFile &File) const {
1541  DWARFDebugRangeList RangeList;
1542  const auto &FunctionRanges = Unit.getFunctionRanges();
1543  unsigned AddressSize = Unit.getOrigUnit().getAddressByteSize();
1544  DWARFDataExtractor RangeExtractor(OrigDwarf.getDWARFObj(),
1545  OrigDwarf.getDWARFObj().getRangesSection(),
1546  OrigDwarf.isLittleEndian(), AddressSize);
1547  auto InvalidRange = FunctionRanges.end(), CurrRange = InvalidRange;
1548  DWARFUnit &OrigUnit = Unit.getOrigUnit();
1549  auto OrigUnitDie = OrigUnit.getUnitDIE(false);
1550  uint64_t OrigLowPc =
1551  dwarf::toAddress(OrigUnitDie.find(dwarf::DW_AT_low_pc), -1ULL);
1552  // Ranges addresses are based on the unit's low_pc. Compute the
1553  // offset we need to apply to adapt to the new unit's low_pc.
1554  int64_t UnitPcOffset = 0;
1555  if (OrigLowPc != -1ULL)
1556  UnitPcOffset = int64_t(OrigLowPc) - Unit.getLowPc();
1557 
1558  for (const auto &RangeAttribute : Unit.getRangesAttributes()) {
1559  uint64_t Offset = RangeAttribute.get();
1560  RangeAttribute.set(TheDwarfEmitter->getRangesSectionSize());
1561  if (Error E = RangeList.extract(RangeExtractor, &Offset)) {
1563  reportWarning("invalid range list ignored.", File);
1564  RangeList.clear();
1565  }
1566  const auto &Entries = RangeList.getEntries();
1567  if (!Entries.empty()) {
1568  const DWARFDebugRangeList::RangeListEntry &First = Entries.front();
1569 
1570  if (CurrRange == InvalidRange ||
1571  First.StartAddress + OrigLowPc < CurrRange.start() ||
1572  First.StartAddress + OrigLowPc >= CurrRange.stop()) {
1573  CurrRange = FunctionRanges.find(First.StartAddress + OrigLowPc);
1574  if (CurrRange == InvalidRange ||
1575  CurrRange.start() > First.StartAddress + OrigLowPc) {
1576  reportWarning("no mapping for range.", File);
1577  continue;
1578  }
1579  }
1580  }
1581 
1582  TheDwarfEmitter->emitRangesEntries(UnitPcOffset, OrigLowPc, CurrRange,
1583  Entries, AddressSize);
1584  }
1585 }
1586 
1587 /// Generate the debug_aranges entries for \p Unit and if the
1588 /// unit has a DW_AT_ranges attribute, also emit the debug_ranges
1589 /// contribution for this attribute.
1590 /// FIXME: this could actually be done right in patchRangesForUnit,
1591 /// but for the sake of initial bit-for-bit compatibility with legacy
1592 /// dsymutil, we have to do it in a delayed pass.
1593 void DWARFLinker::generateUnitRanges(CompileUnit &Unit) const {
1594  auto Attr = Unit.getUnitRangesAttribute();
1595  if (Attr)
1596  Attr->set(TheDwarfEmitter->getRangesSectionSize());
1597  TheDwarfEmitter->emitUnitRangesEntries(Unit, static_cast<bool>(Attr));
1598 }
1599 
1600 /// Insert the new line info sequence \p Seq into the current
1601 /// set of already linked line info \p Rows.
1602 static void insertLineSequence(std::vector<DWARFDebugLine::Row> &Seq,
1603  std::vector<DWARFDebugLine::Row> &Rows) {
1604  if (Seq.empty())
1605  return;
1606 
1607  if (!Rows.empty() && Rows.back().Address < Seq.front().Address) {
1608  llvm::append_range(Rows, Seq);
1609  Seq.clear();
1610  return;
1611  }
1612 
1613  object::SectionedAddress Front = Seq.front().Address;
1614  auto InsertPoint = partition_point(
1615  Rows, [=](const DWARFDebugLine::Row &O) { return O.Address < Front; });
1616 
1617  // FIXME: this only removes the unneeded end_sequence if the
1618  // sequences have been inserted in order. Using a global sort like
1619  // described in patchLineTableForUnit() and delaying the end_sequene
1620  // elimination to emitLineTableForUnit() we can get rid of all of them.
1621  if (InsertPoint != Rows.end() && InsertPoint->Address == Front &&
1622  InsertPoint->EndSequence) {
1623  *InsertPoint = Seq.front();
1624  Rows.insert(InsertPoint + 1, Seq.begin() + 1, Seq.end());
1625  } else {
1626  Rows.insert(InsertPoint, Seq.begin(), Seq.end());
1627  }
1628 
1629  Seq.clear();
1630 }
1631 
1632 static void patchStmtList(DIE &Die, DIEInteger Offset) {
1633  for (auto &V : Die.values())
1634  if (V.getAttribute() == dwarf::DW_AT_stmt_list) {
1635  V = DIEValue(V.getAttribute(), V.getForm(), Offset);
1636  return;
1637  }
1638 
1639  llvm_unreachable("Didn't find DW_AT_stmt_list in cloned DIE!");
1640 }
1641 
1642 /// Extract the line table for \p Unit from \p OrigDwarf, and
1643 /// recreate a relocated version of these for the address ranges that
1644 /// are present in the binary.
1645 void DWARFLinker::patchLineTableForUnit(CompileUnit &Unit,
1646  DWARFContext &OrigDwarf,
1647  const DWARFFile &File) {
1648  DWARFDie CUDie = Unit.getOrigUnit().getUnitDIE();
1649  auto StmtList = dwarf::toSectionOffset(CUDie.find(dwarf::DW_AT_stmt_list));
1650  if (!StmtList)
1651  return;
1652 
1653  // Update the cloned DW_AT_stmt_list with the correct debug_line offset.
1654  if (auto *OutputDIE = Unit.getOutputUnitDIE())
1655  patchStmtList(*OutputDIE,
1656  DIEInteger(TheDwarfEmitter->getLineSectionSize()));
1657 
1658  RangesTy &Ranges = File.Addresses->getValidAddressRanges();
1659 
1660  // Parse the original line info for the unit.
1661  DWARFDebugLine::LineTable LineTable;
1662  uint64_t StmtOffset = *StmtList;
1663  DWARFDataExtractor LineExtractor(
1664  OrigDwarf.getDWARFObj(), OrigDwarf.getDWARFObj().getLineSection(),
1665  OrigDwarf.isLittleEndian(), Unit.getOrigUnit().getAddressByteSize());
1666  if (needToTranslateStrings())
1667  return TheDwarfEmitter->translateLineTable(LineExtractor, StmtOffset);
1668 
1669  if (Error Err =
1670  LineTable.parse(LineExtractor, &StmtOffset, OrigDwarf,
1671  &Unit.getOrigUnit(), OrigDwarf.getWarningHandler()))
1672  OrigDwarf.getWarningHandler()(std::move(Err));
1673 
1674  // This vector is the output line table.
1675  std::vector<DWARFDebugLine::Row> NewRows;
1676  NewRows.reserve(LineTable.Rows.size());
1677 
1678  // Current sequence of rows being extracted, before being inserted
1679  // in NewRows.
1680  std::vector<DWARFDebugLine::Row> Seq;
1681  const auto &FunctionRanges = Unit.getFunctionRanges();
1682  auto InvalidRange = FunctionRanges.end(), CurrRange = InvalidRange;
1683 
1684  // FIXME: This logic is meant to generate exactly the same output as
1685  // Darwin's classic dsymutil. There is a nicer way to implement this
1686  // by simply putting all the relocated line info in NewRows and simply
1687  // sorting NewRows before passing it to emitLineTableForUnit. This
1688  // should be correct as sequences for a function should stay
1689  // together in the sorted output. There are a few corner cases that
1690  // look suspicious though, and that required to implement the logic
1691  // this way. Revisit that once initial validation is finished.
1692 
1693  // Iterate over the object file line info and extract the sequences
1694  // that correspond to linked functions.
1695  for (auto &Row : LineTable.Rows) {
1696  // Check whether we stepped out of the range. The range is
1697  // half-open, but consider accept the end address of the range if
1698  // it is marked as end_sequence in the input (because in that
1699  // case, the relocation offset is accurate and that entry won't
1700  // serve as the start of another function).
1701  if (CurrRange == InvalidRange || Row.Address.Address < CurrRange.start() ||
1702  Row.Address.Address > CurrRange.stop() ||
1703  (Row.Address.Address == CurrRange.stop() && !Row.EndSequence)) {
1704  // We just stepped out of a known range. Insert a end_sequence
1705  // corresponding to the end of the range.
1706  uint64_t StopAddress = CurrRange != InvalidRange
1707  ? CurrRange.stop() + CurrRange.value()
1708  : -1ULL;
1709  CurrRange = FunctionRanges.find(Row.Address.Address);
1710  bool CurrRangeValid =
1711  CurrRange != InvalidRange && CurrRange.start() <= Row.Address.Address;
1712  if (!CurrRangeValid) {
1713  CurrRange = InvalidRange;
1714  if (StopAddress != -1ULL) {
1715  // Try harder by looking in the Address ranges map.
1716  // There are corner cases where this finds a
1717  // valid entry. It's unclear if this is right or wrong, but
1718  // for now do as dsymutil.
1719  // FIXME: Understand exactly what cases this addresses and
1720  // potentially remove it along with the Ranges map.
1721  auto Range = Ranges.lower_bound(Row.Address.Address);
1722  if (Range != Ranges.begin() && Range != Ranges.end())
1723  --Range;
1724 
1725  if (Range != Ranges.end() && Range->first <= Row.Address.Address &&
1726  Range->second.HighPC >= Row.Address.Address) {
1727  StopAddress = Row.Address.Address + Range->second.Offset;
1728  }
1729  }
1730  }
1731  if (StopAddress != -1ULL && !Seq.empty()) {
1732  // Insert end sequence row with the computed end address, but
1733  // the same line as the previous one.
1734  auto NextLine = Seq.back();
1735  NextLine.Address.Address = StopAddress;
1736  NextLine.EndSequence = 1;
1737  NextLine.PrologueEnd = 0;
1738  NextLine.BasicBlock = 0;
1739  NextLine.EpilogueBegin = 0;
1740  Seq.push_back(NextLine);
1741  insertLineSequence(Seq, NewRows);
1742  }
1743 
1744  if (!CurrRangeValid)
1745  continue;
1746  }
1747 
1748  // Ignore empty sequences.
1749  if (Row.EndSequence && Seq.empty())
1750  continue;
1751 
1752  // Relocate row address and add it to the current sequence.
1753  Row.Address.Address += CurrRange.value();
1754  Seq.emplace_back(Row);
1755 
1756  if (Row.EndSequence)
1757  insertLineSequence(Seq, NewRows);
1758  }
1759 
1760  // Finished extracting, now emit the line tables.
1761  // FIXME: LLVM hard-codes its prologue values. We just copy the
1762  // prologue over and that works because we act as both producer and
1763  // consumer. It would be nicer to have a real configurable line
1764  // table emitter.
1765  if (LineTable.Prologue.getVersion() < 2 ||
1766  LineTable.Prologue.getVersion() > 5 ||
1767  LineTable.Prologue.DefaultIsStmt != DWARF2_LINE_DEFAULT_IS_STMT ||
1768  LineTable.Prologue.OpcodeBase > 13)
1769  reportWarning("line table parameters mismatch. Cannot emit.", File);
1770  else {
1771  uint32_t PrologueEnd = *StmtList + 10 + LineTable.Prologue.PrologueLength;
1772  // DWARF v5 has an extra 2 bytes of information before the header_length
1773  // field.
1774  if (LineTable.Prologue.getVersion() == 5)
1775  PrologueEnd += 2;
1776  StringRef LineData = OrigDwarf.getDWARFObj().getLineSection().Data;
1777  MCDwarfLineTableParams Params;
1778  Params.DWARF2LineOpcodeBase = LineTable.Prologue.OpcodeBase;
1779  Params.DWARF2LineBase = LineTable.Prologue.LineBase;
1780  Params.DWARF2LineRange = LineTable.Prologue.LineRange;
1781  TheDwarfEmitter->emitLineTableForUnit(
1782  Params, LineData.slice(*StmtList + 4, PrologueEnd),
1783  LineTable.Prologue.MinInstLength, NewRows,
1784  Unit.getOrigUnit().getAddressByteSize());
1785  }
1786 }
1787 
1788 void DWARFLinker::emitAcceleratorEntriesForUnit(CompileUnit &Unit) {
1789  switch (Options.TheAccelTableKind) {
1791  // Nothing to do.
1792  break;
1794  emitAppleAcceleratorEntriesForUnit(Unit);
1795  break;
1797  emitDwarfAcceleratorEntriesForUnit(Unit);
1798  break;
1800  emitPubAcceleratorEntriesForUnit(Unit);
1801  break;
1803  llvm_unreachable("The default must be updated to a concrete value.");
1804  break;
1805  }
1806 }
1807 
1808 void DWARFLinker::emitAppleAcceleratorEntriesForUnit(CompileUnit &Unit) {
1809  // Add namespaces.
1810  for (const auto &Namespace : Unit.getNamespaces())
1811  AppleNamespaces.addName(Namespace.Name,
1812  Namespace.Die->getOffset() + Unit.getStartOffset());
1813 
1814  /// Add names.
1815  for (const auto &Pubname : Unit.getPubnames())
1816  AppleNames.addName(Pubname.Name,
1817  Pubname.Die->getOffset() + Unit.getStartOffset());
1818 
1819  /// Add types.
1820  for (const auto &Pubtype : Unit.getPubtypes())
1821  AppleTypes.addName(
1822  Pubtype.Name, Pubtype.Die->getOffset() + Unit.getStartOffset(),
1823  Pubtype.Die->getTag(),
1824  Pubtype.ObjcClassImplementation ? dwarf::DW_FLAG_type_implementation
1825  : 0,
1826  Pubtype.QualifiedNameHash);
1827 
1828  /// Add ObjC names.
1829  for (const auto &ObjC : Unit.getObjC())
1830  AppleObjc.addName(ObjC.Name, ObjC.Die->getOffset() + Unit.getStartOffset());
1831 }
1832 
1833 void DWARFLinker::emitDwarfAcceleratorEntriesForUnit(CompileUnit &Unit) {
1834  for (const auto &Namespace : Unit.getNamespaces())
1835  DebugNames.addName(Namespace.Name, Namespace.Die->getOffset(),
1836  Namespace.Die->getTag(), Unit.getUniqueID());
1837  for (const auto &Pubname : Unit.getPubnames())
1838  DebugNames.addName(Pubname.Name, Pubname.Die->getOffset(),
1839  Pubname.Die->getTag(), Unit.getUniqueID());
1840  for (const auto &Pubtype : Unit.getPubtypes())
1841  DebugNames.addName(Pubtype.Name, Pubtype.Die->getOffset(),
1842  Pubtype.Die->getTag(), Unit.getUniqueID());
1843 }
1844 
1845 void DWARFLinker::emitPubAcceleratorEntriesForUnit(CompileUnit &Unit) {
1846  TheDwarfEmitter->emitPubNamesForUnit(Unit);
1847  TheDwarfEmitter->emitPubTypesForUnit(Unit);
1848 }
1849 
1850 /// Read the frame info stored in the object, and emit the
1851 /// patched frame descriptions for the resulting file.
1852 ///
1853 /// This is actually pretty easy as the data of the CIEs and FDEs can
1854 /// be considered as black boxes and moved as is. The only thing to do
1855 /// is to patch the addresses in the headers.
1856 void DWARFLinker::patchFrameInfoForObject(const DWARFFile &File,
1857  RangesTy &Ranges,
1858  DWARFContext &OrigDwarf,
1859  unsigned AddrSize) {
1860  StringRef FrameData = OrigDwarf.getDWARFObj().getFrameSection().Data;
1861  if (FrameData.empty())
1862  return;
1863 
1864  DataExtractor Data(FrameData, OrigDwarf.isLittleEndian(), 0);
1865  uint64_t InputOffset = 0;
1866 
1867  // Store the data of the CIEs defined in this object, keyed by their
1868  // offsets.
1869  DenseMap<uint64_t, StringRef> LocalCIES;
1870 
1871  while (Data.isValidOffset(InputOffset)) {
1872  uint64_t EntryOffset = InputOffset;
1873  uint32_t InitialLength = Data.getU32(&InputOffset);
1874  if (InitialLength == 0xFFFFFFFF)
1875  return reportWarning("Dwarf64 bits no supported", File);
1876 
1877  uint32_t CIEId = Data.getU32(&InputOffset);
1878  if (CIEId == 0xFFFFFFFF) {
1879  // This is a CIE, store it.
1880  StringRef CIEData = FrameData.substr(EntryOffset, InitialLength + 4);
1881  LocalCIES[EntryOffset] = CIEData;
1882  // The -4 is to account for the CIEId we just read.
1883  InputOffset += InitialLength - 4;
1884  continue;
1885  }
1886 
1887  uint32_t Loc = Data.getUnsigned(&InputOffset, AddrSize);
1888 
1889  // Some compilers seem to emit frame info that doesn't start at
1890  // the function entry point, thus we can't just lookup the address
1891  // in the debug map. Use the AddressInfo's range map to see if the FDE
1892  // describes something that we can relocate.
1893  auto Range = Ranges.upper_bound(Loc);
1894  if (Range != Ranges.begin())
1895  --Range;
1896  if (Range == Ranges.end() || Range->first > Loc ||
1897  Range->second.HighPC <= Loc) {
1898  // The +4 is to account for the size of the InitialLength field itself.
1899  InputOffset = EntryOffset + InitialLength + 4;
1900  continue;
1901  }
1902 
1903  // This is an FDE, and we have a mapping.
1904  // Have we already emitted a corresponding CIE?
1905  StringRef CIEData = LocalCIES[CIEId];
1906  if (CIEData.empty())
1907  return reportWarning("Inconsistent debug_frame content. Dropping.", File);
1908 
1909  // Look if we already emitted a CIE that corresponds to the
1910  // referenced one (the CIE data is the key of that lookup).
1911  auto IteratorInserted = EmittedCIEs.insert(
1912  std::make_pair(CIEData, TheDwarfEmitter->getFrameSectionSize()));
1913  // If there is no CIE yet for this ID, emit it.
1914  if (IteratorInserted.second) {
1915  LastCIEOffset = TheDwarfEmitter->getFrameSectionSize();
1916  IteratorInserted.first->getValue() = LastCIEOffset;
1917  TheDwarfEmitter->emitCIE(CIEData);
1918  }
1919 
1920  // Emit the FDE with updated address and CIE pointer.
1921  // (4 + AddrSize) is the size of the CIEId + initial_location
1922  // fields that will get reconstructed by emitFDE().
1923  unsigned FDERemainingBytes = InitialLength - (4 + AddrSize);
1924  TheDwarfEmitter->emitFDE(IteratorInserted.first->getValue(), AddrSize,
1925  Loc + Range->second.Offset,
1926  FrameData.substr(InputOffset, FDERemainingBytes));
1927  InputOffset += FDERemainingBytes;
1928  }
1929 }
1930 
1931 uint32_t DWARFLinker::DIECloner::hashFullyQualifiedName(DWARFDie DIE,
1932  CompileUnit &U,
1933  const DWARFFile &File,
1934  int ChildRecurseDepth) {
1935  const char *Name = nullptr;
1936  DWARFUnit *OrigUnit = &U.getOrigUnit();
1937  CompileUnit *CU = &U;
1938  Optional<DWARFFormValue> Ref;
1939 
1940  while (true) {
1941  if (const char *CurrentName = DIE.getName(DINameKind::ShortName))
1942  Name = CurrentName;
1943 
1944  if (!(Ref = DIE.find(dwarf::DW_AT_specification)) &&
1945  !(Ref = DIE.find(dwarf::DW_AT_abstract_origin)))
1946  break;
1947 
1948  if (!Ref->isFormClass(DWARFFormValue::FC_Reference))
1949  break;
1950 
1951  CompileUnit *RefCU;
1952  if (auto RefDIE =
1953  Linker.resolveDIEReference(File, CompileUnits, *Ref, DIE, RefCU)) {
1954  CU = RefCU;
1955  OrigUnit = &RefCU->getOrigUnit();
1956  DIE = RefDIE;
1957  }
1958  }
1959 
1960  unsigned Idx = OrigUnit->getDIEIndex(DIE);
1961  if (!Name && DIE.getTag() == dwarf::DW_TAG_namespace)
1962  Name = "(anonymous namespace)";
1963 
1964  if (CU->getInfo(Idx).ParentIdx == 0 ||
1965  // FIXME: dsymutil-classic compatibility. Ignore modules.
1966  CU->getOrigUnit().getDIEAtIndex(CU->getInfo(Idx).ParentIdx).getTag() ==
1967  dwarf::DW_TAG_module)
1968  return djbHash(Name ? Name : "", djbHash(ChildRecurseDepth ? "" : "::"));
1969 
1970  DWARFDie Die = OrigUnit->getDIEAtIndex(CU->getInfo(Idx).ParentIdx);
1971  return djbHash(
1972  (Name ? Name : ""),
1973  djbHash((Name ? "::" : ""),
1974  hashFullyQualifiedName(Die, *CU, File, ++ChildRecurseDepth)));
1975 }
1976 
1977 static uint64_t getDwoId(const DWARFDie &CUDie, const DWARFUnit &Unit) {
1978  auto DwoId = dwarf::toUnsigned(
1979  CUDie.find({dwarf::DW_AT_dwo_id, dwarf::DW_AT_GNU_dwo_id}));
1980  if (DwoId)
1981  return *DwoId;
1982  return 0;
1983 }
1984 
1985 static std::string remapPath(StringRef Path,
1986  const objectPrefixMap &ObjectPrefixMap) {
1987  if (ObjectPrefixMap.empty())
1988  return Path.str();
1989 
1990  SmallString<256> p = Path;
1991  for (const auto &Entry : ObjectPrefixMap)
1992  if (llvm::sys::path::replace_path_prefix(p, Entry.first, Entry.second))
1993  break;
1994  return p.str().str();
1995 }
1996 
1997 bool DWARFLinker::registerModuleReference(DWARFDie CUDie, const DWARFUnit &Unit,
1998  const DWARFFile &File,
1999  OffsetsStringPool &StringPool,
2000  DeclContextTree &ODRContexts,
2001  uint64_t ModulesEndOffset,
2002  unsigned &UnitID, bool IsLittleEndian,
2003  unsigned Indent, bool Quiet) {
2004  std::string PCMfile = dwarf::toString(
2005  CUDie.find({dwarf::DW_AT_dwo_name, dwarf::DW_AT_GNU_dwo_name}), "");
2006  if (PCMfile.empty())
2007  return false;
2008  if (Options.ObjectPrefixMap)
2009  PCMfile = remapPath(PCMfile, *Options.ObjectPrefixMap);
2010 
2011  // Clang module DWARF skeleton CUs abuse this for the path to the module.
2012  uint64_t DwoId = getDwoId(CUDie, Unit);
2013 
2014  std::string Name = dwarf::toString(CUDie.find(dwarf::DW_AT_name), "");
2015  if (Name.empty()) {
2016  if (!Quiet)
2017  reportWarning("Anonymous module skeleton CU for " + PCMfile, File);
2018  return true;
2019  }
2020 
2021  if (!Quiet && Options.Verbose) {
2022  outs().indent(Indent);
2023  outs() << "Found clang module reference " << PCMfile;
2024  }
2025 
2026  auto Cached = ClangModules.find(PCMfile);
2027  if (Cached != ClangModules.end()) {
2028  // FIXME: Until PR27449 (https://llvm.org/bugs/show_bug.cgi?id=27449) is
2029  // fixed in clang, only warn about DWO_id mismatches in verbose mode.
2030  // ASTFileSignatures will change randomly when a module is rebuilt.
2031  if (!Quiet && Options.Verbose && (Cached->second != DwoId))
2032  reportWarning(Twine("hash mismatch: this object file was built against a "
2033  "different version of the module ") +
2034  PCMfile,
2035  File);
2036  if (!Quiet && Options.Verbose)
2037  outs() << " [cached].\n";
2038  return true;
2039  }
2040  if (!Quiet && Options.Verbose)
2041  outs() << " ...\n";
2042 
2043  // Cyclic dependencies are disallowed by Clang, but we still
2044  // shouldn't run into an infinite loop, so mark it as processed now.
2045  ClangModules.insert({PCMfile, DwoId});
2046 
2047  if (Error E = loadClangModule(CUDie, PCMfile, Name, DwoId, File, StringPool,
2048  ODRContexts, ModulesEndOffset, UnitID,
2049  IsLittleEndian, Indent + 2, Quiet)) {
2051  return false;
2052  }
2053  return true;
2054 }
2055 
2056 Error DWARFLinker::loadClangModule(
2057  DWARFDie CUDie, StringRef Filename, StringRef ModuleName, uint64_t DwoId,
2058  const DWARFFile &File, OffsetsStringPool &StringPool,
2059  DeclContextTree &ODRContexts, uint64_t ModulesEndOffset, unsigned &UnitID,
2060  bool IsLittleEndian, unsigned Indent, bool Quiet) {
2061  /// Using a SmallString<0> because loadClangModule() is recursive.
2062  SmallString<0> Path(Options.PrependPath);
2063  if (sys::path::is_relative(Filename))
2064  resolveRelativeObjectPath(Path, CUDie);
2065  sys::path::append(Path, Filename);
2066  // Don't use the cached binary holder because we have no thread-safety
2067  // guarantee and the lifetime is limited.
2068 
2069  if (Options.ObjFileLoader == nullptr)
2070  return Error::success();
2071 
2072  auto ErrOrObj = Options.ObjFileLoader(File.FileName, Path);
2073  if (!ErrOrObj)
2074  return Error::success();
2075 
2076  std::unique_ptr<CompileUnit> Unit;
2077 
2078  for (const auto &CU : ErrOrObj->Dwarf->compile_units()) {
2079  updateDwarfVersion(CU->getVersion());
2080  // Recursively get all modules imported by this one.
2081  auto CUDie = CU->getUnitDIE(false);
2082  if (!CUDie)
2083  continue;
2084  if (!registerModuleReference(CUDie, *CU, File, StringPool, ODRContexts,
2085  ModulesEndOffset, UnitID, IsLittleEndian,
2086  Indent, Quiet)) {
2087  if (Unit) {
2088  std::string Err =
2089  (Filename +
2090  ": Clang modules are expected to have exactly 1 compile unit.\n")
2091  .str();
2092  reportError(Err, File);
2093  return make_error<StringError>(Err, inconvertibleErrorCode());
2094  }
2095  // FIXME: Until PR27449 (https://llvm.org/bugs/show_bug.cgi?id=27449) is
2096  // fixed in clang, only warn about DWO_id mismatches in verbose mode.
2097  // ASTFileSignatures will change randomly when a module is rebuilt.
2098  uint64_t PCMDwoId = getDwoId(CUDie, *CU);
2099  if (PCMDwoId != DwoId) {
2100  if (!Quiet && Options.Verbose)
2101  reportWarning(
2102  Twine("hash mismatch: this object file was built against a "
2103  "different version of the module ") +
2104  Filename,
2105  File);
2106  // Update the cache entry with the DwoId of the module loaded from disk.
2107  ClangModules[Filename] = PCMDwoId;
2108  }
2109 
2110  // Add this module.
2111  Unit = std::make_unique<CompileUnit>(*CU, UnitID++, !Options.NoODR,
2112  ModuleName);
2113  analyzeContextInfo(CUDie, 0, *Unit, &ODRContexts.getRoot(), ODRContexts,
2114  ModulesEndOffset, Options.ParseableSwiftInterfaces,
2115  [&](const Twine &Warning, const DWARFDie &DIE) {
2116  reportWarning(Warning, File, &DIE);
2117  });
2118  // Keep everything.
2119  Unit->markEverythingAsKept();
2120  }
2121  }
2122  assert(Unit && "CompileUnit is not set!");
2123  if (!Unit->getOrigUnit().getUnitDIE().hasChildren())
2124  return Error::success();
2125  if (!Quiet && Options.Verbose) {
2126  outs().indent(Indent);
2127  outs() << "cloning .debug_info from " << Filename << "\n";
2128  }
2129 
2130  UnitListTy CompileUnits;
2131  CompileUnits.push_back(std::move(Unit));
2132  assert(TheDwarfEmitter);
2133  DIECloner(*this, TheDwarfEmitter, *ErrOrObj, DIEAlloc, CompileUnits,
2134  Options.Update)
2135  .cloneAllCompileUnits(*(ErrOrObj->Dwarf), File, StringPool,
2136  IsLittleEndian);
2137  return Error::success();
2138 }
2139 
2140 uint64_t DWARFLinker::DIECloner::cloneAllCompileUnits(
2141  DWARFContext &DwarfContext, const DWARFFile &File,
2142  OffsetsStringPool &StringPool, bool IsLittleEndian) {
2143  uint64_t OutputDebugInfoSize =
2144  Linker.Options.NoOutput ? 0 : Emitter->getDebugInfoSectionSize();
2145  const uint64_t StartOutputDebugInfoSize = OutputDebugInfoSize;
2146 
2147  for (auto &CurrentUnit : CompileUnits) {
2148  const uint16_t DwarfVersion = CurrentUnit->getOrigUnit().getVersion();
2149  const uint32_t UnitHeaderSize = DwarfVersion >= 5 ? 12 : 11;
2150  auto InputDIE = CurrentUnit->getOrigUnit().getUnitDIE();
2151  CurrentUnit->setStartOffset(OutputDebugInfoSize);
2152  if (!InputDIE) {
2153  OutputDebugInfoSize = CurrentUnit->computeNextUnitOffset(DwarfVersion);
2154  continue;
2155  }
2156  if (CurrentUnit->getInfo(0).Keep) {
2157  // Clone the InputDIE into your Unit DIE in our compile unit since it
2158  // already has a DIE inside of it.
2159  CurrentUnit->createOutputDIE();
2160  cloneDIE(InputDIE, File, *CurrentUnit, StringPool, 0 /* PC offset */,
2161  UnitHeaderSize, 0, IsLittleEndian,
2162  CurrentUnit->getOutputUnitDIE());
2163  }
2164 
2165  OutputDebugInfoSize = CurrentUnit->computeNextUnitOffset(DwarfVersion);
2166 
2167  if (!Linker.Options.NoOutput) {
2168  assert(Emitter);
2169 
2170  if (LLVM_LIKELY(!Linker.Options.Update) ||
2171  Linker.needToTranslateStrings())
2172  Linker.patchLineTableForUnit(*CurrentUnit, DwarfContext, File);
2173 
2174  Linker.emitAcceleratorEntriesForUnit(*CurrentUnit);
2175 
2176  if (LLVM_UNLIKELY(Linker.Options.Update))
2177  continue;
2178 
2179  Linker.patchRangesForUnit(*CurrentUnit, DwarfContext, File);
2180  auto ProcessExpr = [&](StringRef Bytes,
2181  SmallVectorImpl<uint8_t> &Buffer) {
2182  DWARFUnit &OrigUnit = CurrentUnit->getOrigUnit();
2183  DataExtractor Data(Bytes, IsLittleEndian,
2184  OrigUnit.getAddressByteSize());
2185  cloneExpression(Data,
2186  DWARFExpression(Data, OrigUnit.getAddressByteSize(),
2187  OrigUnit.getFormParams().Format),
2188  File, *CurrentUnit, Buffer);
2189  };
2190  Emitter->emitLocationsForUnit(*CurrentUnit, DwarfContext, ProcessExpr);
2191  }
2192  }
2193 
2194  if (!Linker.Options.NoOutput) {
2195  assert(Emitter);
2196  // Emit all the compile unit's debug information.
2197  for (auto &CurrentUnit : CompileUnits) {
2198  if (LLVM_LIKELY(!Linker.Options.Update))
2199  Linker.generateUnitRanges(*CurrentUnit);
2200 
2201  CurrentUnit->fixupForwardReferences();
2202 
2203  if (!CurrentUnit->getOutputUnitDIE())
2204  continue;
2205 
2206  unsigned DwarfVersion = CurrentUnit->getOrigUnit().getVersion();
2207 
2208  assert(Emitter->getDebugInfoSectionSize() ==
2209  CurrentUnit->getStartOffset());
2210  Emitter->emitCompileUnitHeader(*CurrentUnit, DwarfVersion);
2211  Emitter->emitDIE(*CurrentUnit->getOutputUnitDIE());
2212  assert(Emitter->getDebugInfoSectionSize() ==
2213  CurrentUnit->computeNextUnitOffset(DwarfVersion));
2214  }
2215  }
2216 
2217  return OutputDebugInfoSize - StartOutputDebugInfoSize;
2218 }
2219 
2220 void DWARFLinker::updateAccelKind(DWARFContext &Dwarf) {
2221  if (Options.TheAccelTableKind != DwarfLinkerAccelTableKind::Default)
2222  return;
2223 
2224  auto &DwarfObj = Dwarf.getDWARFObj();
2225 
2226  if (!AtLeastOneDwarfAccelTable &&
2227  (!DwarfObj.getAppleNamesSection().Data.empty() ||
2228  !DwarfObj.getAppleTypesSection().Data.empty() ||
2229  !DwarfObj.getAppleNamespacesSection().Data.empty() ||
2230  !DwarfObj.getAppleObjCSection().Data.empty())) {
2231  AtLeastOneAppleAccelTable = true;
2232  }
2233 
2234  if (!AtLeastOneDwarfAccelTable && !DwarfObj.getNamesSection().Data.empty()) {
2235  AtLeastOneDwarfAccelTable = true;
2236  }
2237 }
2238 
2239 bool DWARFLinker::emitPaperTrailWarnings(const DWARFFile &File,
2240  OffsetsStringPool &StringPool) {
2241 
2242  if (File.Warnings.empty())
2243  return false;
2244 
2245  DIE *CUDie = DIE::get(DIEAlloc, dwarf::DW_TAG_compile_unit);
2246  CUDie->setOffset(11);
2247  StringRef Producer;
2248  StringRef WarningHeader;
2249 
2250  switch (DwarfLinkerClientID) {
2252  Producer = StringPool.internString("dsymutil");
2253  WarningHeader = "dsymutil_warning";
2254  break;
2255 
2256  default:
2257  Producer = StringPool.internString("dwarfopt");
2258  WarningHeader = "dwarfopt_warning";
2259  break;
2260  }
2261 
2262  StringRef FileName = StringPool.internString(File.FileName);
2263  CUDie->addValue(DIEAlloc, dwarf::DW_AT_producer, dwarf::DW_FORM_strp,
2264  DIEInteger(StringPool.getStringOffset(Producer)));
2265  DIEBlock *String = new (DIEAlloc) DIEBlock();
2266  DIEBlocks.push_back(String);
2267  for (auto &C : FileName)
2268  String->addValue(DIEAlloc, dwarf::Attribute(0), dwarf::DW_FORM_data1,
2269  DIEInteger(C));
2270  String->addValue(DIEAlloc, dwarf::Attribute(0), dwarf::DW_FORM_data1,
2271  DIEInteger(0));
2272 
2273  CUDie->addValue(DIEAlloc, dwarf::DW_AT_name, dwarf::DW_FORM_string, String);
2274  for (const auto &Warning : File.Warnings) {
2275  DIE &ConstDie = CUDie->addChild(DIE::get(DIEAlloc, dwarf::DW_TAG_constant));
2276  ConstDie.addValue(DIEAlloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp,
2277  DIEInteger(StringPool.getStringOffset(WarningHeader)));
2278  ConstDie.addValue(DIEAlloc, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag,
2279  DIEInteger(1));
2280  ConstDie.addValue(DIEAlloc, dwarf::DW_AT_const_value, dwarf::DW_FORM_strp,
2281  DIEInteger(StringPool.getStringOffset(Warning)));
2282  }
2283  unsigned Size = 4 /* FORM_strp */ + FileName.size() + 1 +
2284  File.Warnings.size() * (4 + 1 + 4) + 1 /* End of children */;
2285  DIEAbbrev Abbrev = CUDie->generateAbbrev();
2286  assignAbbrev(Abbrev);
2287  CUDie->setAbbrevNumber(Abbrev.getNumber());
2288  Size += getULEB128Size(Abbrev.getNumber());
2289  // Abbreviation ordering needed for classic compatibility.
2290  for (auto &Child : CUDie->children()) {
2291  Abbrev = Child.generateAbbrev();
2292  assignAbbrev(Abbrev);
2293  Child.setAbbrevNumber(Abbrev.getNumber());
2294  Size += getULEB128Size(Abbrev.getNumber());
2295  }
2296  CUDie->setSize(Size);
2297  TheDwarfEmitter->emitPaperTrailWarningsDie(*CUDie);
2298 
2299  return true;
2300 }
2301 
2302 void DWARFLinker::copyInvariantDebugSection(DWARFContext &Dwarf) {
2303  if (!needToTranslateStrings())
2304  TheDwarfEmitter->emitSectionContents(
2305  Dwarf.getDWARFObj().getLineSection().Data, "debug_line");
2306  TheDwarfEmitter->emitSectionContents(Dwarf.getDWARFObj().getLocSection().Data,
2307  "debug_loc");
2308  TheDwarfEmitter->emitSectionContents(
2309  Dwarf.getDWARFObj().getRangesSection().Data, "debug_ranges");
2310  TheDwarfEmitter->emitSectionContents(
2311  Dwarf.getDWARFObj().getFrameSection().Data, "debug_frame");
2312  TheDwarfEmitter->emitSectionContents(Dwarf.getDWARFObj().getArangesSection(),
2313  "debug_aranges");
2314 }
2315 
2317  ObjectContexts.emplace_back(LinkContext(File));
2318 
2319  if (ObjectContexts.back().File.Dwarf)
2320  updateAccelKind(*ObjectContexts.back().File.Dwarf);
2321 }
2322 
2324  assert(Options.NoOutput || TheDwarfEmitter);
2325 
2326  // A unique ID that identifies each compile unit.
2327  unsigned UnitID = 0;
2328 
2329  // First populate the data structure we need for each iteration of the
2330  // parallel loop.
2331  unsigned NumObjects = ObjectContexts.size();
2332 
2333  // This Dwarf string pool which is used for emission. It must be used
2334  // serially as the order of calling getStringOffset matters for
2335  // reproducibility.
2336  OffsetsStringPool OffsetsStringPool(StringsTranslator, true);
2337 
2338  // ODR Contexts for the optimize.
2339  DeclContextTree ODRContexts;
2340 
2341  // If we haven't decided on an accelerator table kind yet, we base ourselves
2342  // on the DWARF we have seen so far. At this point we haven't pulled in debug
2343  // information from modules yet, so it is technically possible that they
2344  // would affect the decision. However, as they're built with the same
2345  // compiler and flags, it is safe to assume that they will follow the
2346  // decision made here.
2347  if (Options.TheAccelTableKind == DwarfLinkerAccelTableKind::Default) {
2348  if (AtLeastOneDwarfAccelTable && !AtLeastOneAppleAccelTable)
2349  Options.TheAccelTableKind = DwarfLinkerAccelTableKind::Dwarf;
2350  else
2351  Options.TheAccelTableKind = DwarfLinkerAccelTableKind::Apple;
2352  }
2353 
2354  for (LinkContext &OptContext : ObjectContexts) {
2355  if (Options.Verbose) {
2356  if (DwarfLinkerClientID == DwarfLinkerClient::Dsymutil)
2357  outs() << "DEBUG MAP OBJECT: " << OptContext.File.FileName << "\n";
2358  else
2359  outs() << "OBJECT FILE: " << OptContext.File.FileName << "\n";
2360  }
2361 
2362  if (emitPaperTrailWarnings(OptContext.File, OffsetsStringPool))
2363  continue;
2364 
2365  if (!OptContext.File.Dwarf)
2366  continue;
2367 
2368  if (Options.VerifyInputDWARF)
2369  verify(OptContext.File);
2370 
2371  // Look for relocations that correspond to address map entries.
2372 
2373  // there was findvalidrelocations previously ... probably we need to gather
2374  // info here
2375  if (LLVM_LIKELY(!Options.Update) &&
2376  !OptContext.File.Addresses->hasValidRelocs()) {
2377  if (Options.Verbose)
2378  outs() << "No valid relocations found. Skipping.\n";
2379 
2380  // Set "Skip" flag as a signal to other loops that we should not
2381  // process this iteration.
2382  OptContext.Skip = true;
2383  continue;
2384  }
2385 
2386  // Setup access to the debug info.
2387  if (!OptContext.File.Dwarf)
2388  continue;
2389 
2390  // In a first phase, just read in the debug info and load all clang modules.
2391  OptContext.CompileUnits.reserve(
2392  OptContext.File.Dwarf->getNumCompileUnits());
2393 
2394  for (const auto &CU : OptContext.File.Dwarf->compile_units()) {
2395  updateDwarfVersion(CU->getVersion());
2396  auto CUDie = CU->getUnitDIE(false);
2397  if (Options.Verbose) {
2398  outs() << "Input compilation unit:";
2399  DIDumpOptions DumpOpts;
2400  DumpOpts.ChildRecurseDepth = 0;
2401  DumpOpts.Verbose = Options.Verbose;
2402  CUDie.dump(outs(), 0, DumpOpts);
2403  }
2404  if (CUDie && !LLVM_UNLIKELY(Options.Update))
2405  registerModuleReference(CUDie, *CU, OptContext.File, OffsetsStringPool,
2406  ODRContexts, 0, UnitID,
2407  OptContext.File.Dwarf->isLittleEndian());
2408  }
2409  }
2410 
2411  // If we haven't seen any CUs, pick an arbitrary valid Dwarf version anyway.
2412  if (MaxDwarfVersion == 0)
2413  MaxDwarfVersion = 3;
2414 
2415  // At this point we know how much data we have emitted. We use this value to
2416  // compare canonical DIE offsets in analyzeContextInfo to see if a definition
2417  // is already emitted, without being affected by canonical die offsets set
2418  // later. This prevents undeterminism when analyze and clone execute
2419  // concurrently, as clone set the canonical DIE offset and analyze reads it.
2420  const uint64_t ModulesEndOffset =
2421  Options.NoOutput ? 0 : TheDwarfEmitter->getDebugInfoSectionSize();
2422 
2423  // These variables manage the list of processed object files.
2424  // The mutex and condition variable are to ensure that this is thread safe.
2425  std::mutex ProcessedFilesMutex;
2426  std::condition_variable ProcessedFilesConditionVariable;
2427  BitVector ProcessedFiles(NumObjects, false);
2428 
2429  // Analyzing the context info is particularly expensive so it is executed in
2430  // parallel with emitting the previous compile unit.
2431  auto AnalyzeLambda = [&](size_t I) {
2432  auto &Context = ObjectContexts[I];
2433 
2434  if (Context.Skip || !Context.File.Dwarf)
2435  return;
2436 
2437  for (const auto &CU : Context.File.Dwarf->compile_units()) {
2438  updateDwarfVersion(CU->getVersion());
2439  // The !registerModuleReference() condition effectively skips
2440  // over fully resolved skeleton units. This second pass of
2441  // registerModuleReferences doesn't do any new work, but it
2442  // will collect top-level errors, which are suppressed. Module
2443  // warnings were already displayed in the first iteration.
2444  bool Quiet = true;
2445  auto CUDie = CU->getUnitDIE(false);
2446  if (!CUDie || LLVM_UNLIKELY(Options.Update) ||
2447  !registerModuleReference(CUDie, *CU, Context.File, OffsetsStringPool,
2448  ODRContexts, ModulesEndOffset, UnitID,
2449  Quiet)) {
2450  Context.CompileUnits.push_back(std::make_unique<CompileUnit>(
2451  *CU, UnitID++, !Options.NoODR && !Options.Update, ""));
2452  }
2453  }
2454 
2455  // Now build the DIE parent links that we will use during the next phase.
2456  for (auto &CurrentUnit : Context.CompileUnits) {
2457  auto CUDie = CurrentUnit->getOrigUnit().getUnitDIE();
2458  if (!CUDie)
2459  continue;
2460  analyzeContextInfo(CurrentUnit->getOrigUnit().getUnitDIE(), 0,
2461  *CurrentUnit, &ODRContexts.getRoot(), ODRContexts,
2462  ModulesEndOffset, Options.ParseableSwiftInterfaces,
2463  [&](const Twine &Warning, const DWARFDie &DIE) {
2464  reportWarning(Warning, Context.File, &DIE);
2465  });
2466  }
2467  };
2468 
2469  // For each object file map how many bytes were emitted.
2470  StringMap<DebugInfoSize> SizeByObject;
2471 
2472  // And then the remaining work in serial again.
2473  // Note, although this loop runs in serial, it can run in parallel with
2474  // the analyzeContextInfo loop so long as we process files with indices >=
2475  // than those processed by analyzeContextInfo.
2476  auto CloneLambda = [&](size_t I) {
2477  auto &OptContext = ObjectContexts[I];
2478  if (OptContext.Skip || !OptContext.File.Dwarf)
2479  return;
2480 
2481  // Then mark all the DIEs that need to be present in the generated output
2482  // and collect some information about them.
2483  // Note that this loop can not be merged with the previous one because
2484  // cross-cu references require the ParentIdx to be setup for every CU in
2485  // the object file before calling this.
2486  if (LLVM_UNLIKELY(Options.Update)) {
2487  for (auto &CurrentUnit : OptContext.CompileUnits)
2488  CurrentUnit->markEverythingAsKept();
2489  copyInvariantDebugSection(*OptContext.File.Dwarf);
2490  } else {
2491  for (auto &CurrentUnit : OptContext.CompileUnits)
2492  lookForDIEsToKeep(*OptContext.File.Addresses,
2493  OptContext.File.Addresses->getValidAddressRanges(),
2494  OptContext.CompileUnits,
2495  CurrentUnit->getOrigUnit().getUnitDIE(),
2496  OptContext.File, *CurrentUnit, 0);
2497  }
2498 
2499  // The calls to applyValidRelocs inside cloneDIE will walk the reloc
2500  // array again (in the same way findValidRelocsInDebugInfo() did). We
2501  // need to reset the NextValidReloc index to the beginning.
2502  if (OptContext.File.Addresses->hasValidRelocs() ||
2503  LLVM_UNLIKELY(Options.Update)) {
2504  SizeByObject[OptContext.File.FileName].Input =
2505  getDebugInfoSize(*OptContext.File.Dwarf);
2506  SizeByObject[OptContext.File.FileName].Output =
2507  DIECloner(*this, TheDwarfEmitter, OptContext.File, DIEAlloc,
2508  OptContext.CompileUnits, Options.Update)
2509  .cloneAllCompileUnits(*OptContext.File.Dwarf, OptContext.File,
2511  OptContext.File.Dwarf->isLittleEndian());
2512  }
2513  if (!Options.NoOutput && !OptContext.CompileUnits.empty() &&
2514  LLVM_LIKELY(!Options.Update))
2515  patchFrameInfoForObject(
2516  OptContext.File, OptContext.File.Addresses->getValidAddressRanges(),
2517  *OptContext.File.Dwarf,
2518  OptContext.CompileUnits[0]->getOrigUnit().getAddressByteSize());
2519 
2520  // Clean-up before starting working on the next object.
2521  cleanupAuxiliarryData(OptContext);
2522  };
2523 
2524  auto EmitLambda = [&]() {
2525  // Emit everything that's global.
2526  if (!Options.NoOutput) {
2527  TheDwarfEmitter->emitAbbrevs(Abbreviations, MaxDwarfVersion);
2528  TheDwarfEmitter->emitStrings(OffsetsStringPool);
2529  switch (Options.TheAccelTableKind) {
2531  // Nothing to do.
2532  break;
2534  TheDwarfEmitter->emitAppleNames(AppleNames);
2535  TheDwarfEmitter->emitAppleNamespaces(AppleNamespaces);
2536  TheDwarfEmitter->emitAppleTypes(AppleTypes);
2537  TheDwarfEmitter->emitAppleObjc(AppleObjc);
2538  break;
2540  TheDwarfEmitter->emitDebugNames(DebugNames);
2541  break;
2543  // Already emitted by emitPubAcceleratorEntriesForUnit.
2544  break;
2546  llvm_unreachable("Default should have already been resolved.");
2547  break;
2548  }
2549  }
2550  };
2551 
2552  auto AnalyzeAll = [&]() {
2553  for (unsigned I = 0, E = NumObjects; I != E; ++I) {
2554  AnalyzeLambda(I);
2555 
2556  std::unique_lock<std::mutex> LockGuard(ProcessedFilesMutex);
2557  ProcessedFiles.set(I);
2558  ProcessedFilesConditionVariable.notify_one();
2559  }
2560  };
2561 
2562  auto CloneAll = [&]() {
2563  for (unsigned I = 0, E = NumObjects; I != E; ++I) {
2564  {
2565  std::unique_lock<std::mutex> LockGuard(ProcessedFilesMutex);
2566  if (!ProcessedFiles[I]) {
2567  ProcessedFilesConditionVariable.wait(
2568  LockGuard, [&]() { return ProcessedFiles[I]; });
2569  }
2570  }
2571 
2572  CloneLambda(I);
2573  }
2574  EmitLambda();
2575  };
2576 
2577  // To limit memory usage in the single threaded case, analyze and clone are
2578  // run sequentially so the OptContext is freed after processing each object
2579  // in endDebugObject.
2580  if (Options.Threads == 1) {
2581  for (unsigned I = 0, E = NumObjects; I != E; ++I) {
2582  AnalyzeLambda(I);
2583  CloneLambda(I);
2584  }
2585  EmitLambda();
2586  } else {
2588  Pool.async(AnalyzeAll);
2589  Pool.async(CloneAll);
2590  Pool.wait();
2591  }
2592 
2593  if (Options.Statistics) {
2594  // Create a vector sorted in descending order by output size.
2595  std::vector<std::pair<StringRef, DebugInfoSize>> Sorted;
2596  for (auto &E : SizeByObject)
2597  Sorted.emplace_back(E.first(), E.second);
2598  llvm::sort(Sorted, [](auto &LHS, auto &RHS) {
2599  return LHS.second.Output > RHS.second.Output;
2600  });
2601 
2602  auto ComputePercentange = [](int64_t Input, int64_t Output) -> float {
2603  const float Difference = Output - Input;
2604  const float Sum = Input + Output;
2605  if (Sum == 0)
2606  return 0;
2607  return (Difference / (Sum / 2));
2608  };
2609 
2610  int64_t InputTotal = 0;
2611  int64_t OutputTotal = 0;
2612  const char *FormatStr = "{0,-45} {1,10}b {2,10}b {3,8:P}\n";
2613 
2614  // Print header.
2615  outs() << ".debug_info section size (in bytes)\n";
2616  outs() << "----------------------------------------------------------------"
2617  "---------------\n";
2618  outs() << "Filename Object "
2619  " dSYM Change\n";
2620  outs() << "----------------------------------------------------------------"
2621  "---------------\n";
2622 
2623  // Print body.
2624  for (auto &E : Sorted) {
2625  InputTotal += E.second.Input;
2626  OutputTotal += E.second.Output;
2627  llvm::outs() << formatv(
2628  FormatStr, sys::path::filename(E.first).take_back(45), E.second.Input,
2629  E.second.Output, ComputePercentange(E.second.Input, E.second.Output));
2630  }
2631  // Print total and footer.
2632  outs() << "----------------------------------------------------------------"
2633  "---------------\n";
2634  llvm::outs() << formatv(FormatStr, "Total", InputTotal, OutputTotal,
2635  ComputePercentange(InputTotal, OutputTotal));
2636  outs() << "----------------------------------------------------------------"
2637  "---------------\n\n";
2638  }
2639 
2640  return true;
2641 }
2642 
2643 bool DWARFLinker::verify(const DWARFFile &File) {
2644  assert(File.Dwarf);
2645 
2646  DIDumpOptions DumpOpts;
2647  if (!File.Dwarf->verify(llvm::outs(), DumpOpts.noImplicitRecursion())) {
2648  reportWarning("input verification failed", File);
2649  return false;
2650  }
2651  return true;
2652 }
2653 
2654 } // namespace llvm
llvm::Check::Size
@ Size
Definition: FileCheck.h:77
llvm::UnitListTy
std::vector< std::unique_ptr< CompileUnit > > UnitListTy
Definition: DWARFLinker.h:211
DWARFFormValue.h
llvm::DwarfEmitter::emitDebugNames
virtual void emitDebugNames(AccelTable< DWARF5AccelTableStaticData > &Table)=0
Emit DWARF debug names.
llvm::DwarfEmitter::emitStrings
virtual void emitStrings(const NonRelocatableStringpool &Pool)=0
Emit the string table described by Pool.
llvm::swiftInterfacesMap
std::map< std::string, std::string > swiftInterfacesMap
Definition: DWARFLinker.h:238
MCDwarf.h
llvm::hardware_concurrency
ThreadPoolStrategy hardware_concurrency(unsigned ThreadCount=0)
Returns a default thread strategy where all available hardware resources are to be used,...
Definition: Threading.h:185
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
llvm::SPIRV::Decoration::Patch
@ Patch
llvm::ContextWorklistItem::ParentIdx
unsigned ParentIdx
Definition: DWARFLinker.cpp:258
llvm::upper_bound
auto upper_bound(R &&Range, T &&Value)
Provide wrappers to std::upper_bound which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:1749
llvm::sys::path::replace_path_prefix
bool replace_path_prefix(SmallVectorImpl< char > &Path, StringRef OldPrefix, StringRef NewPrefix, Style style=Style::native)
Replace matching path prefix with another path.
Definition: Path.cpp:518
llvm::DWARFLinker::DWARFLinker
DWARFLinker(DwarfEmitter *Emitter, DwarfLinkerClient ClientID=DwarfLinkerClient::General)
Definition: DWARFLinker.h:257
llvm::lltok::Error
@ Error
Definition: LLToken.h:21
llvm::DwarfEmitter::emitAppleNames
virtual void emitAppleNames(AccelTable< AppleAccelTableStaticOffsetData > &Table)=0
Emit Apple names accelerator table.
llvm::BumpPtrAllocatorImpl::Reset
void Reset()
Deallocate all but the current slab and reset the current pointer to the beginning of it,...
Definition: Allocator.h:121
llvm::ContextWorklistItem::Context
DeclContext * Context
Definition: DWARFLinker.cpp:261
llvm::DwarfEmitter::getFrameSectionSize
virtual uint64_t getFrameSectionSize() const =0
Returns size of generated .debug_frame section.
llvm::DeclContext
A DeclContext is a named program scope that is used for ODR uniquing of types.
Definition: DWARFLinkerDeclContext.h:77
llvm::ThreadPool
A ThreadPool for asynchronous parallel execution on a defined number of threads.
Definition: ThreadPool.h:52
llvm::DwarfEmitter::emitFDE
virtual void emitFDE(uint32_t CIEOffset, uint32_t AddreSize, uint32_t Address, StringRef Bytes)=0
Emit an FDE with data Bytes.
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::BitVector::set
BitVector & set()
Definition: BitVector.h:344
llvm::DWARFAbbreviationDeclaration::AttributeSpec
Definition: DWARFAbbreviationDeclaration.h:29
llvm::DIEValue
Definition: DIE.h:369
llvm::updateRefIncompleteness
static void updateRefIncompleteness(const DWARFDie &Die, CompileUnit &CU, CompileUnit::DIEInfo &RefInfo)
Helper that updates the completeness of the current DIE based on the completeness of the DIEs it refe...
Definition: DWARFLinker.cpp:567
llvm::analyzeContextInfo
static bool analyzeContextInfo(const DWARFDie &DIE, unsigned ParentIdx, CompileUnit &CU, DeclContext *CurrentDeclContext, DeclContextTree &Contexts, uint64_t ModulesEndOffset, swiftInterfacesMap *ParseableSwiftInterfaces, std::function< void(const Twine &, const DWARFDie &)> ReportWarning, bool InImportedModule=false)
Recursive helper to build the global DeclContext information and gather the child->parent relationshi...
Definition: DWARFLinker.cpp:314
llvm::StringRef::npos
static constexpr size_t npos
Definition: StringRef.h:60
Path.h
llvm::getUnitForOffset
static CompileUnit * getUnitForOffset(const UnitListTy &Units, uint64_t Offset)
Similar to DWARFUnitSection::getUnitForOffset(), but returning our CompileUnit object instead.
Definition: DWARFLinker.cpp:55
llvm::dwarf::Form
Form
Definition: Dwarf.h:132
llvm::object::SectionedAddress::Address
uint64_t Address
Definition: ObjectFile.h:147
llvm::AddressesMap::~AddressesMap
virtual ~AddressesMap()
ErrorHandling.h
llvm::DwarfEmitter::emitLineTableForUnit
virtual void emitLineTableForUnit(MCDwarfLineTableParams Params, StringRef PrologueBytes, unsigned MinInstLength, std::vector< DWARFDebugLine::Row > &Rows, unsigned AdddressSize)=0
Emit the line table described in Rows into the .debug_line section.
llvm::Error::success
static ErrorSuccess success()
Create a success value.
Definition: Error.h:329
llvm::ContextWorklistItemType::AnalyzeContextInfo
@ AnalyzeContextInfo
llvm::DwarfEmitter::getLineSectionSize
virtual uint64_t getLineSectionSize() const =0
Returns size of generated .debug_line section.
DWARFDebugLine.h
DWARFContext.h
Error.h
llvm::CompileUnit::DIEInfo::Prune
bool Prune
Is this a pure forward declaration we can strip?
Definition: DWARFLinkerCompileUnit.h:73
llvm::StringMap::end
iterator end()
Definition: StringMap.h:205
llvm::getULEB128Size
unsigned getULEB128Size(uint64_t Value)
Utility function to get the size of the ULEB128-encoded value.
Definition: LEB128.cpp:19
llvm::DWARFContext
DWARFContext This data structure is the top level entity that deals with dwarf debug information pars...
Definition: DWARFContext.h:47
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::patchStmtList
static void patchStmtList(DIE &Die, DIEInteger Offset)
Definition: DWARFLinker.cpp:1632
llvm::DwarfLinkerClient::Dsymutil
@ Dsymutil
llvm::reverse
auto reverse(ContainerTy &&C, std::enable_if_t< has_rbegin< ContainerTy >::value > *=nullptr)
Definition: STLExtras.h:380
llvm::DWARFFormValue::FC_Exprloc
@ FC_Exprloc
Definition: DWARFFormValue.h:40
llvm::dwarf::DW_CHILDREN_yes
@ DW_CHILDREN_yes
Definition: Dwarf.h:435
llvm::Optional
Definition: APInt.h:33
T
#define T
Definition: Mips16ISelLowering.cpp:341
llvm::DwarfEmitter::getDebugInfoSectionSize
virtual uint64_t getDebugInfoSectionSize() const =0
Returns size of generated .debug_info section.
llvm::DWARFExpression::Operation::Encoding
Encoding
Size and signedness of expression operations' operands.
Definition: DWARFExpression.h:37
llvm::DwarfEmitter::emitAbbrevs
virtual void emitAbbrevs(const std::vector< std::unique_ptr< DIEAbbrev >> &Abbrevs, unsigned DwarfVersion)=0
Emit the abbreviation table Abbrevs to the .debug_abbrev section.
llvm::DIE
A structured debug information entry.
Definition: DIE.h:739
llvm::max
Expected< ExpressionValue > max(const ExpressionValue &Lhs, const ExpressionValue &Rhs)
Definition: FileCheck.cpp:337
llvm::DwarfEmitter::emitPubTypesForUnit
virtual void emitPubTypesForUnit(const CompileUnit &Unit)=0
Emit the .debug_pubtypes contribution for Unit.
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:41
STLExtras.h
llvm::getDebugInfoSize
static uint64_t getDebugInfoSize(DWARFContext &Dwarf)
Compute the total size of the debug info.
Definition: DWARFLinker.cpp:45
llvm::DWARFFormValue::FC_Reference
@ FC_Reference
Definition: DWARFFormValue.h:37
RHS
Value * RHS
Definition: X86PartialReduction.cpp:76
llvm::StringMap::find
iterator find(StringRef Key)
Definition: StringMap.h:218
llvm::ContextWorklistItem::InImportedModule
bool InImportedModule
Definition: DWARFLinker.cpp:264
llvm::dwarf::Tag
Tag
Definition: Dwarf.h:105
llvm::DWARFDie::children
iterator_range< iterator > children() const
Definition: DWARFDie.h:396
llvm::consumeError
void consumeError(Error Err)
Consume a Error without doing anything.
Definition: Error.h:1043
llvm::Data
@ Data
Definition: SIMachineScheduler.h:55
p
the resulting code requires compare and branches when and if * p
Definition: README.txt:396
llvm::DwarfEmitter::getRangesSectionSize
virtual uint64_t getRangesSectionSize() const =0
Returns size of generated .debug_ranges section.
llvm::DeclContextTree::getRoot
DeclContext & getRoot()
Definition: DWARFLinkerDeclContext.h:139
llvm::dwarf::toAddress
Optional< uint64_t > toAddress(const Optional< DWARFFormValue > &V)
Take an optional DWARFFormValue and try to extract an address.
Definition: DWARFFormValue.h:290
llvm::dwarf::Attribute
Attribute
Attributes.
Definition: Dwarf.h:125
llvm::shouldSkipAttribute
static bool shouldSkipAttribute(DWARFAbbreviationDeclaration::AttributeSpec AttrSpec, uint16_t Tag, bool InDebugMap, bool SkipPC, bool InFunctionScope)
Definition: DWARFLinker.cpp:1307
llvm::DIEValueList::values
value_range values()
Definition: DIE.h:727
llvm::sys::path::append
void append(SmallVectorImpl< char > &path, const Twine &a, const Twine &b="", const Twine &c="", const Twine &d="")
Append to path.
Definition: Path.cpp:456
llvm::DwarfEmitter::emitPaperTrailWarningsDie
virtual void emitPaperTrailWarningsDie(DIE &Die)=0
Emit DIE containing warnings.
Context
LLVMContext & Context
Definition: NVVMIntrRange.cpp:66
LHS
Value * LHS
Definition: X86PartialReduction.cpp:75
llvm::formatv
auto formatv(const char *Fmt, Ts &&... Vals) -> formatv_object< decltype(std::make_tuple(detail::build_format_adapter(std::forward< Ts >(Vals))...))>
Definition: FormatVariadic.h:251
llvm::ContextWorklistItem
This class represents an item in the work list.
Definition: DWARFLinker.cpp:256
llvm::DwarfLinkerAccelTableKind::Pub
@ Pub
.debug_pubnames, .debug_pubtypes
llvm::CompileUnit::DIEInfo
Information gathered about a DIE in the object file.
Definition: DWARFLinkerCompileUnit.h:53
DWARFDebugRangeList.h
llvm::DWARFDebugLine::Row
Standard .debug_line state machine structure.
Definition: DWARFDebugLine.h:133
llvm::RangesTy
std::map< uint64_t, ObjFileAddressRange > RangesTy
Map LowPC to ObjFileAddressRange.
Definition: DWARFLinker.h:57
llvm::DIDumpOptions::Verbose
bool Verbose
Definition: DIContext.h:199
llvm::ModRefInfo::Ref
@ Ref
The access may reference the value stored in memory.
llvm::outs
raw_fd_ostream & outs()
This returns a reference to a raw_fd_ostream for standard output.
Definition: raw_ostream.cpp:885
llvm::ContextWorklistItem::OtherInfo
CompileUnit::DIEInfo * OtherInfo
Definition: DWARFLinker.cpp:260
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
NonRelocatableStringpool.h
llvm::DwarfLinkerAccelTableKind::Apple
@ Apple
.apple_names, .apple_namespaces, .apple_types, .apple_objc.
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::StringMap::insert
bool insert(MapEntryTy *KeyValue)
insert - Insert the specified key/value pair into the map.
Definition: StringMap.h:276
llvm::dwarf::DW_FLAG_type_implementation
@ DW_FLAG_type_implementation
Definition: Dwarf.h:522
DWARFSection.h
llvm::DebugInfoSize
Hold the input and output of the debug info size in bytes.
Definition: DWARFLinker.cpp:39
llvm::DWARFAbbreviationDeclaration::AttributeSpec::Attr
dwarf::Attribute Attr
Definition: DWARFAbbreviationDeclaration.h:42
UINT64_MAX
#define UINT64_MAX
Definition: DataTypes.h:77
DWARFDie.h
false
Definition: StackSlotColoring.cpp:141
llvm::dwarf::toStringRef
StringRef toStringRef(const Optional< DWARFFormValue > &V, StringRef Default={})
Take an optional DWARFFormValue and try to extract a string value from it.
Definition: DWARFFormValue.h:193
First
into llvm powi allowing the code generator to produce balanced multiplication trees First
Definition: README.txt:54
llvm::DIDumpOptions::ChildRecurseDepth
unsigned ChildRecurseDepth
Definition: DIContext.h:190
llvm::StripTemplateParameters
static Optional< StringRef > StripTemplateParameters(StringRef Name)
Definition: DWARFLinker.cpp:140
llvm::dwarf::toSectionOffset
Optional< uint64_t > toSectionOffset(const Optional< DWARFFormValue > &V)
Take an optional DWARFFormValue and try to extract an section offset.
Definition: DWARFFormValue.h:318
llvm::resolveRelativeObjectPath
static void resolveRelativeObjectPath(SmallVectorImpl< char > &Buf, DWARFDie CU)
Resolve the relative path to a build artifact referenced by DWARF by applying DW_AT_comp_dir.
Definition: DWARFLinker.cpp:203
llvm::DWARFFormValue
Definition: DWARFFormValue.h:28
BitVector.h
llvm::DIEInteger
An integer value DIE.
Definition: DIE.h:163
Info
Analysis containing CSE Info
Definition: CSEInfo.cpp:27
llvm::BitVector
Definition: BitVector.h:75
llvm::DeclContextTree::getChildDeclContext
PointerIntPair< DeclContext *, 1 > getChildDeclContext(DeclContext &Context, const DWARFDie &DIE, CompileUnit &Unit, bool InClangModule)
Get the child of Context described by DIE in Unit.
Definition: DWARFLinkerDeclContext.cpp:45
llvm::pdb::PDB_ColorItem::Path
@ Path
FormatVariadic.h
llvm::dwarf::FormEncodingString
StringRef FormEncodingString(unsigned Encoding)
Definition: Dwarf.cpp:105
llvm::StringMap
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Definition: StringMap.h:110
llvm::SmallString< 128 >
llvm::DWARFFormValue::skipValue
bool skipValue(DataExtractor DebugInfoData, uint64_t *OffsetPtr, const dwarf::FormParams Params) const
Skip a form's value in DebugInfoData at the offset specified by OffsetPtr.
Definition: DWARFFormValue.h:147
DWARFLinker.h
ThreadPool.h
llvm::RISCVFenceField::O
@ O
Definition: RISCVBaseInfo.h:239
llvm::DINameKind::ShortName
@ ShortName
llvm::DwarfLinkerAccelTableKind::None
@ None
llvm::AMDGPU::Hwreg::Offset
Offset
Definition: SIDefines.h:413
llvm::StringRef::empty
constexpr LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:153
llvm::DwarfEmitter::translateLineTable
virtual void translateLineTable(DataExtractor LineData, uint64_t Offset)=0
Copy the .debug_line over to the updated binary while unobfuscating the file names and directories.
uint64_t
Addr
uint64_t Addr
Definition: ELFObjHandler.cpp:78
llvm::ContextWorklistItemType::UpdateChildPruning
@ UpdateChildPruning
llvm::ContextWorklistItem::Die
DWARFDie Die
Definition: DWARFLinker.cpp:257
llvm::CompileUnit
Stores all information relating to a compile unit, be it in its original instance in the object file ...
Definition: DWARFLinkerCompileUnit.h:50
LEB128.h
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
ErrorOr.h
llvm::isODRAttribute
static bool isODRAttribute(uint16_t Attr)
Definition: DWARFLinker.cpp:87
I
#define I(x, y, z)
Definition: MD5.cpp:58
DWARFUnit.h
llvm::DeclContextTree
This class gives a tree-like API to the DenseMap that stores the DeclContext objects.
Definition: DWARFLinkerDeclContext.h:121
llvm::DWARFDie::find
Optional< DWARFFormValue > find(dwarf::Attribute Attr) const
Extract the specified attribute from this DIE.
Definition: DWARFDie.cpp:245
llvm::DwarfEmitter::emitRangesEntries
virtual void emitRangesEntries(int64_t UnitPcOffset, uint64_t OrigLowPc, const FunctionIntervals::const_iterator &FuncRange, const std::vector< DWARFDebugRangeList::RangeListEntry > &Entries, unsigned AddressSize)=0
Emit .debug_ranges for FuncRange by translating the original Entries.
ArrayRef.h
llvm::DWARFAbbreviationDeclaration::AttributeSpec::Form
dwarf::Form Form
Definition: DWARFAbbreviationDeclaration.h:43
DWARFAbbreviationDeclaration.h
llvm::DwarfEmitter::emitPubNamesForUnit
virtual void emitPubNamesForUnit(const CompileUnit &Unit)=0
Emit the .debug_pubnames contribution for Unit.
llvm::DWARFFormValue::FC_Block
@ FC_Block
Definition: DWARFFormValue.h:33
llvm::DebugInfoSize::Output
uint64_t Output
Definition: DWARFLinker.cpp:41
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
ModuleName
Definition: ItaniumDemangle.h:989
function
print Print MemDeps of function
Definition: MemDepPrinter.cpp:82
llvm::getDwoId
static uint64_t getDwoId(const DWARFDie &CUDie, const DWARFUnit &Unit)
Definition: DWARFLinker.cpp:1977
llvm::dieNeedsChildrenToBeMeaningful
static bool dieNeedsChildrenToBeMeaningful(uint32_t Tag)
Definition: DWARFLinker.cpp:394
llvm::insertLineSequence
static void insertLineSequence(std::vector< DWARFDebugLine::Row > &Seq, std::vector< DWARFDebugLine::Row > &Rows)
Insert the new line info sequence Seq into the current set of already linked line info Rows.
Definition: DWARFLinker.cpp:1602
llvm::dwarf::toString
Optional< const char * > toString(const Optional< DWARFFormValue > &V)
Take an optional DWARFFormValue and try to extract a string value from it.
Definition: DWARFFormValue.h:177
llvm::DwarfEmitter::emitCIE
virtual void emitCIE(StringRef CIEBytes)=0
Emit a CIE.
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm::DWARFLinker::addObjectFile
void addObjectFile(DWARFFile &File)
Add object file to be linked.
Definition: DWARFLinker.cpp:2316
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:143
llvm::OffsetsStringPool
StrongType< NonRelocatableStringpool, OffsetsTag > OffsetsStringPool
Definition: NonRelocatableStringpool.h:79
llvm::ThreadPool::async
auto async(Function &&F, Args &&...ArgList)
Asynchronous submission of a task to the pool.
Definition: ThreadPool.h:66
uint32_t
llvm::append_range
void append_range(Container &C, Range &&R)
Wrapper function to append a range to a container.
Definition: STLExtras.h:1823
DWARF2_LINE_DEFAULT_IS_STMT
#define DWARF2_LINE_DEFAULT_IS_STMT
Definition: MCDwarf.h:106
llvm::DIE::get
static DIE * get(BumpPtrAllocator &Alloc, dwarf::Tag Tag)
Definition: DIE.h:769
llvm::analyzeImportedModule
static void analyzeImportedModule(const DWARFDie &DIE, CompileUnit &CU, swiftInterfacesMap *ParseableSwiftInterfaces, std::function< void(const Twine &, const DWARFDie &)> ReportWarning)
Collect references to parseable Swift interfaces in imported DW_TAG_module blocks.
Definition: DWARFLinker.cpp:209
llvm::DwarfEmitter::~DwarfEmitter
virtual ~DwarfEmitter()
llvm::DWARFLinker::link
bool link()
Link debug info for added objFiles.
Definition: DWARFLinker.cpp:2323
llvm::DWARFFile
this class represents DWARF information for source file and it`s address map.
Definition: DWARFLinker.h:215
llvm::DWARFAttribute::mayHaveLocationExpr
static bool mayHaveLocationExpr(dwarf::Attribute Attr)
Identifies DWARF attributes that may contain a reference to a DWARF expression.
Definition: DWARFDie.cpp:719
llvm::DwarfEmitter::emitUnitRangesEntries
virtual void emitUnitRangesEntries(CompileUnit &Unit, bool DoRangesSection)=0
Emit .debug_aranges entries for Unit and if DoRangesSection is true, also emit the ....
llvm::updateChildPruning
static void updateChildPruning(const DWARFDie &Die, CompileUnit &CU, CompileUnit::DIEInfo &ChildInfo)
Definition: DWARFLinker.cpp:300
llvm::partition_point
auto partition_point(R &&Range, Predicate P)
Binary search for the first iterator in a range where a predicate is false.
Definition: STLExtras.h:1774
llvm::isObjCSelector
static bool isObjCSelector(StringRef Name)
Definition: DWARFLinker.cpp:1259
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:50
llvm::updateChildIncompleteness
static void updateChildIncompleteness(const DWARFDie &Die, CompileUnit &CU, CompileUnit::DIEInfo &ChildInfo)
Helper that updates the completeness of the current DIE based on the completeness of one of its child...
Definition: DWARFLinker.cpp:547
llvm::inconvertibleErrorCode
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
Definition: Error.cpp:77
uint16_t
llvm::toString
const char * toString(DWARFSectionKind Kind)
Definition: DWARFUnitIndex.h:67
llvm::AMDGPU::SendMsg::Op
Op
Definition: SIDefines.h:345
llvm::DwarfEmitter::emitSectionContents
virtual void emitSectionContents(StringRef SecData, StringRef SecName)=0
Emit section named SecName with data SecData.
llvm::DWARFUnit
Definition: DWARFUnit.h:207
DataExtractor.h
llvm::sort
void sort(IteratorTy Start, IteratorTy End)
Definition: STLExtras.h:1562
llvm::TargetStackID::Value
Value
Definition: TargetFrameLowering.h:27
DWARFExpression.h
llvm::isTypeTag
static bool isTypeTag(uint16_t Tag)
Definition: DWARFLinker.cpp:101
llvm::SmallString::str
StringRef str() const
Explicit conversion to StringRef.
Definition: SmallString.h:260
llvm::dwarf::toUnsigned
Optional< uint64_t > toUnsigned(const Optional< DWARFFormValue > &V)
Take an optional DWARFFormValue and try to extract an unsigned constant.
Definition: DWARFFormValue.h:225
llvm::remapPath
static std::string remapPath(StringRef Path, const objectPrefixMap &ObjectPrefixMap)
Definition: DWARFLinker.cpp:1985
llvm::ContextWorklistItemType
ContextWorklistItemType
The distinct types of work performed by the work loop in analyzeContextInfo.
Definition: DWARFLinker.cpp:247
OutputBuffer
Definition: Utility.h:31
llvm::ThreadPool::wait
void wait()
Blocking wait for all the threads to complete and the queue to be empty.
Definition: ThreadPool.cpp:143
llvm::DwarfLinkerAccelTableKind::Default
@ Default
Dwarf for DWARF5 or later, Apple otherwise.
llvm::StrongType
Helper for making strong types.
Definition: NonRelocatableStringpool.h:67
llvm::sys::path::filename
StringRef filename(StringRef path, Style style=Style::native)
Get filename.
Definition: Path.cpp:577
llvm::DWARFDie::getTag
dwarf::Tag getTag() const
Definition: DWARFDie.h:72
llvm::raw_ostream::indent
raw_ostream & indent(unsigned NumSpaces)
indent - Insert 'NumSpaces' spaces.
Definition: raw_ostream.cpp:496
llvm::DWARFFormValue::isFormClass
bool isFormClass(FormClass FC) const
Definition: DWARFFormValue.cpp:215
DWARFLinkerDeclContext.h
llvm::object::SectionedAddress
Definition: ObjectFile.h:144
llvm::ContextWorklistItem::Type
ContextWorklistItemType Type
Definition: DWARFLinker.cpp:263
llvm::DwarfEmitter::emitAppleTypes
virtual void emitAppleTypes(AccelTable< AppleAccelTableStaticTypeData > &Table)=0
Emit Apple type accelerator table.
LLVM_LIKELY
#define LLVM_LIKELY(EXPR)
Definition: Compiler.h:219
llvm::encodeULEB128
unsigned encodeULEB128(uint64_t Value, raw_ostream &OS, unsigned PadTo=0)
Utility function to encode a ULEB128 value to an output stream.
Definition: LEB128.h:80
llvm::SmallVectorImpl< char >
llvm::ContextWorklistItem::ContextWorklistItem
ContextWorklistItem(DWARFDie Die, DeclContext *Context, unsigned ParentIdx, bool InImportedModule)
Definition: DWARFLinker.cpp:271
llvm::ContextWorklistItemType::UpdatePruning
@ UpdatePruning
llvm::DIDumpOptions::noImplicitRecursion
DIDumpOptions noImplicitRecursion() const
Return the options with RecurseDepth set to 0 unless explicitly required.
Definition: DIContext.h:211
llvm::DWARFDie
Utility class that carries the DWARF compile/type unit and the debug info entry in an object.
Definition: DWARFDie.h:43
llvm::ContextWorklistItem::ContextWorklistItem
ContextWorklistItem(DWARFDie Die, ContextWorklistItemType T, CompileUnit::DIEInfo *OtherInfo=nullptr)
Definition: DWARFLinker.cpp:266
llvm::djbHash
uint32_t djbHash(StringRef Buffer, uint32_t H=5381)
The Bernstein hash function used by the DWARF accelerator tables.
Definition: DJB.h:21
llvm::pdb::String
@ String
Definition: PDBTypes.h:408
llvm::ARMBuildAttrs::File
@ File
Definition: ARMBuildAttributes.h:36
llvm::CompileUnit::DIEInfo::Incomplete
bool Incomplete
Does DIE transitively refer an incomplete decl?
Definition: DWARFLinkerCompileUnit.h:76
LLVM_UNLIKELY
#define LLVM_UNLIKELY(EXPR)
Definition: Compiler.h:220
llvm::pdb::PDB_SymType::Block
@ Block
llvm::sys::path::is_relative
bool is_relative(const Twine &path, Style style=Style::native)
Is path relative?
Definition: Path.cpp:699
CU
Definition: AArch64AsmBackend.cpp:504
llvm::Optional::value_or
constexpr T value_or(U &&alt) const &
Definition: Optional.h:318
llvm::DwarfEmitter::emitAppleNamespaces
virtual void emitAppleNamespaces(AccelTable< AppleAccelTableStaticOffsetData > &Table)=0
Emit Apple namespaces accelerator table.
llvm::updatePruning
static bool updatePruning(const DWARFDie &Die, CompileUnit &CU, uint64_t ModulesEndOffset)
Definition: DWARFLinker.cpp:278
llvm::DebugInfoSize::Input
uint64_t Input
Definition: DWARFLinker.cpp:40
llvm::codeview::DebugSubsectionKind::FrameData
@ FrameData
llvm::DwarfLinkerAccelTableKind::Dwarf
@ Dwarf
DWARF v5 .debug_names.
DWARFDataExtractor.h
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:38
llvm::StringRef::take_back
LLVM_NODISCARD StringRef take_back(size_t N=1) const
Return a StringRef equal to 'this' but with only the last N elements remaining.
Definition: StringRef.h:634
llvm::DIDumpOptions
Container for dump options that control which debug information will be dumped.
Definition: DIContext.h:188
llvm::objectPrefixMap
std::map< std::string, std::string > objectPrefixMap
Definition: DWARFLinker.h:239
llvm::DwarfEmitter::emitAppleObjc
virtual void emitAppleObjc(AccelTable< AppleAccelTableStaticOffsetData > &Table)=0
Emit Apple Objective-C accelerator table.