LLVM  14.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"
13 #include "llvm/ADT/Triple.h"
26 #include "llvm/Support/Error.h"
28 #include "llvm/Support/ErrorOr.h"
30 #include "llvm/Support/LEB128.h"
31 #include "llvm/Support/Path.h"
33 #include <vector>
34 
35 namespace llvm {
36 
37 /// Hold the input and output of the debug info size in bytes.
38 struct DebugInfoSize {
41 };
42 
43 /// Compute the total size of the debug info.
45  uint64_t Size = 0;
46  for (auto &Unit : Dwarf.compile_units()) {
47  Size += Unit->getLength();
48  }
49  return Size;
50 }
51 
52 /// Similar to DWARFUnitSection::getUnitForOffset(), but returning our
53 /// CompileUnit object instead.
55  auto CU = llvm::upper_bound(
56  Units, Offset, [](uint64_t LHS, const std::unique_ptr<CompileUnit> &RHS) {
57  return LHS < RHS->getOrigUnit().getNextUnitOffset();
58  });
59  return CU != Units.end() ? CU->get() : nullptr;
60 }
61 
62 /// Resolve the DIE attribute reference that has been extracted in \p RefValue.
63 /// The resulting DIE might be in another CompileUnit which is stored into \p
64 /// ReferencedCU. \returns null if resolving fails for any reason.
65 DWARFDie DWARFLinker::resolveDIEReference(const DWARFFile &File,
66  const UnitListTy &Units,
67  const DWARFFormValue &RefValue,
68  const DWARFDie &DIE,
69  CompileUnit *&RefCU) {
70  assert(RefValue.isFormClass(DWARFFormValue::FC_Reference));
71  uint64_t RefOffset = *RefValue.getAsReference();
72  if ((RefCU = getUnitForOffset(Units, RefOffset)))
73  if (const auto RefDie = RefCU->getOrigUnit().getDIEForOffset(RefOffset)) {
74  // In a file with broken references, an attribute might point to a NULL
75  // DIE.
76  if (!RefDie.isNULL())
77  return RefDie;
78  }
79 
80  reportWarning("could not find referenced DIE", File, &DIE);
81  return DWARFDie();
82 }
83 
84 /// \returns whether the passed \a Attr type might contain a DIE reference
85 /// suitable for ODR uniquing.
86 static bool isODRAttribute(uint16_t Attr) {
87  switch (Attr) {
88  default:
89  return false;
90  case dwarf::DW_AT_type:
91  case dwarf::DW_AT_containing_type:
92  case dwarf::DW_AT_specification:
93  case dwarf::DW_AT_abstract_origin:
94  case dwarf::DW_AT_import:
95  return true;
96  }
97  llvm_unreachable("Improper attribute.");
98 }
99 
100 static bool isTypeTag(uint16_t Tag) {
101  switch (Tag) {
102  case dwarf::DW_TAG_array_type:
103  case dwarf::DW_TAG_class_type:
104  case dwarf::DW_TAG_enumeration_type:
105  case dwarf::DW_TAG_pointer_type:
106  case dwarf::DW_TAG_reference_type:
107  case dwarf::DW_TAG_string_type:
108  case dwarf::DW_TAG_structure_type:
109  case dwarf::DW_TAG_subroutine_type:
110  case dwarf::DW_TAG_typedef:
111  case dwarf::DW_TAG_union_type:
112  case dwarf::DW_TAG_ptr_to_member_type:
113  case dwarf::DW_TAG_set_type:
114  case dwarf::DW_TAG_subrange_type:
115  case dwarf::DW_TAG_base_type:
116  case dwarf::DW_TAG_const_type:
117  case dwarf::DW_TAG_constant:
118  case dwarf::DW_TAG_file_type:
119  case dwarf::DW_TAG_namelist:
120  case dwarf::DW_TAG_packed_type:
121  case dwarf::DW_TAG_volatile_type:
122  case dwarf::DW_TAG_restrict_type:
123  case dwarf::DW_TAG_atomic_type:
124  case dwarf::DW_TAG_interface_type:
125  case dwarf::DW_TAG_unspecified_type:
126  case dwarf::DW_TAG_shared_type:
127  case dwarf::DW_TAG_immutable_type:
128  return true;
129  default:
130  break;
131  }
132  return false;
133 }
134 
136 
138 
140  // We are looking for template parameters to strip from Name. e.g.
141  //
142  // operator<<B>
143  //
144  // We look for > at the end but if it does not contain any < then we
145  // have something like operator>>. We check for the operator<=> case.
146  if (!Name.endswith(">") || Name.count("<") == 0 || Name.endswith("<=>"))
147  return {};
148 
149  // How many < until we have the start of the template parameters.
150  size_t NumLeftAnglesToSkip = 1;
151 
152  // If we have operator<=> then we need to skip its < as well.
153  NumLeftAnglesToSkip += Name.count("<=>");
154 
155  size_t RightAngleCount = Name.count('>');
156  size_t LeftAngleCount = Name.count('<');
157 
158  // If we have more < than > we have operator< or operator<<
159  // we to account for their < as well.
160  if (LeftAngleCount > RightAngleCount)
161  NumLeftAnglesToSkip += LeftAngleCount - RightAngleCount;
162 
163  size_t StartOfTemplate = 0;
164  while (NumLeftAnglesToSkip--)
165  StartOfTemplate = Name.find('<', StartOfTemplate) + 1;
166 
167  return Name.substr(0, StartOfTemplate - 1);
168 }
169 
170 bool DWARFLinker::DIECloner::getDIENames(const DWARFDie &Die,
171  AttributesInfo &Info,
172  OffsetsStringPool &StringPool,
173  bool StripTemplate) {
174  // This function will be called on DIEs having low_pcs and
175  // ranges. As getting the name might be more expansive, filter out
176  // blocks directly.
177  if (Die.getTag() == dwarf::DW_TAG_lexical_block)
178  return false;
179 
180  if (!Info.MangledName)
181  if (const char *MangledName = Die.getLinkageName())
182  Info.MangledName = StringPool.getEntry(MangledName);
183 
184  if (!Info.Name)
185  if (const char *Name = Die.getShortName())
186  Info.Name = StringPool.getEntry(Name);
187 
188  if (!Info.MangledName)
189  Info.MangledName = Info.Name;
190 
191  if (StripTemplate && Info.Name && Info.MangledName != Info.Name) {
192  StringRef Name = Info.Name.getString();
193  if (Optional<StringRef> StrippedName = StripTemplateParameters(Name))
194  Info.NameWithoutTemplate = StringPool.getEntry(*StrippedName);
195  }
196 
197  return Info.Name || Info.MangledName;
198 }
199 
200 /// Resolve the relative path to a build artifact referenced by DWARF by
201 /// applying DW_AT_comp_dir.
203  sys::path::append(Buf, dwarf::toString(CU.find(dwarf::DW_AT_comp_dir), ""));
204 }
205 
206 /// Collect references to parseable Swift interfaces in imported
207 /// DW_TAG_module blocks.
209  const DWARFDie &DIE, CompileUnit &CU,
210  swiftInterfacesMap *ParseableSwiftInterfaces,
211  std::function<void(const Twine &, const DWARFDie &)> ReportWarning) {
212  if (CU.getLanguage() != dwarf::DW_LANG_Swift)
213  return;
214 
215  if (!ParseableSwiftInterfaces)
216  return;
217 
218  StringRef Path = dwarf::toStringRef(DIE.find(dwarf::DW_AT_LLVM_include_path));
219  if (!Path.endswith(".swiftinterface"))
220  return;
221  // Don't track interfaces that are part of the SDK.
222  StringRef SysRoot = dwarf::toStringRef(DIE.find(dwarf::DW_AT_LLVM_sysroot));
223  if (SysRoot.empty())
224  SysRoot = CU.getSysRoot();
225  if (!SysRoot.empty() && Path.startswith(SysRoot))
226  return;
227  Optional<const char*> Name = dwarf::toString(DIE.find(dwarf::DW_AT_name));
228  if (!Name)
229  return;
230  auto &Entry = (*ParseableSwiftInterfaces)[*Name];
231  // The prepend path is applied later when copying.
232  DWARFDie CUDie = CU.getOrigUnit().getUnitDIE();
233  SmallString<128> ResolvedPath;
234  if (sys::path::is_relative(Path))
235  resolveRelativeObjectPath(ResolvedPath, CUDie);
236  sys::path::append(ResolvedPath, Path);
237  if (!Entry.empty() && Entry != ResolvedPath)
238  ReportWarning(Twine("Conflicting parseable interfaces for Swift Module ") +
239  *Name + ": " + Entry + " and " + Path,
240  DIE);
241  Entry = std::string(ResolvedPath.str());
242 }
243 
244 /// The distinct types of work performed by the work loop in
245 /// analyzeContextInfo.
246 enum class ContextWorklistItemType : uint8_t {
250 };
251 
252 /// This class represents an item in the work list. The type defines what kind
253 /// of work needs to be performed when processing the current item. Everything
254 /// but the Type and Die fields are optional based on the type.
257  unsigned ParentIdx;
258  union {
261  };
264 
266  CompileUnit::DIEInfo *OtherInfo = nullptr)
269 
271  bool InImportedModule)
275 };
276 
277 static bool updatePruning(const DWARFDie &Die, CompileUnit &CU,
278  uint64_t ModulesEndOffset) {
279  CompileUnit::DIEInfo &Info = CU.getInfo(Die);
280 
281  // Prune this DIE if it is either a forward declaration inside a
282  // DW_TAG_module or a DW_TAG_module that contains nothing but
283  // forward declarations.
284  Info.Prune &= (Die.getTag() == dwarf::DW_TAG_module) ||
285  (isTypeTag(Die.getTag()) &&
286  dwarf::toUnsigned(Die.find(dwarf::DW_AT_declaration), 0));
287 
288  // Only prune forward declarations inside a DW_TAG_module for which a
289  // definition exists elsewhere.
290  if (ModulesEndOffset == 0)
291  Info.Prune &= Info.Ctxt && Info.Ctxt->getCanonicalDIEOffset();
292  else
293  Info.Prune &= Info.Ctxt && Info.Ctxt->getCanonicalDIEOffset() > 0 &&
294  Info.Ctxt->getCanonicalDIEOffset() <= ModulesEndOffset;
295 
296  return Info.Prune;
297 }
298 
299 static void updateChildPruning(const DWARFDie &Die, CompileUnit &CU,
300  CompileUnit::DIEInfo &ChildInfo) {
301  CompileUnit::DIEInfo &Info = CU.getInfo(Die);
302  Info.Prune &= ChildInfo.Prune;
303 }
304 
305 /// Recursive helper to build the global DeclContext information and
306 /// gather the child->parent relationships in the original compile unit.
307 ///
308 /// This function uses the same work list approach as lookForDIEsToKeep.
309 ///
310 /// \return true when this DIE and all of its children are only
311 /// forward declarations to types defined in external clang modules
312 /// (i.e., forward declarations that are children of a DW_TAG_module).
313 static bool analyzeContextInfo(
314  const DWARFDie &DIE, unsigned ParentIdx, CompileUnit &CU,
315  DeclContext *CurrentDeclContext, DeclContextTree &Contexts,
316  uint64_t ModulesEndOffset, swiftInterfacesMap *ParseableSwiftInterfaces,
317  std::function<void(const Twine &, const DWARFDie &)> ReportWarning,
318  bool InImportedModule = false) {
319  // LIFO work list.
320  std::vector<ContextWorklistItem> Worklist;
321  Worklist.emplace_back(DIE, CurrentDeclContext, ParentIdx, InImportedModule);
322 
323  while (!Worklist.empty()) {
324  ContextWorklistItem Current = Worklist.back();
325  Worklist.pop_back();
326 
327  switch (Current.Type) {
329  updatePruning(Current.Die, CU, ModulesEndOffset);
330  continue;
332  updateChildPruning(Current.Die, CU, *Current.OtherInfo);
333  continue;
335  break;
336  }
337 
338  unsigned Idx = CU.getOrigUnit().getDIEIndex(Current.Die);
339  CompileUnit::DIEInfo &Info = CU.getInfo(Idx);
340 
341  // Clang imposes an ODR on modules(!) regardless of the language:
342  // "The module-id should consist of only a single identifier,
343  // which provides the name of the module being defined. Each
344  // module shall have a single definition."
345  //
346  // This does not extend to the types inside the modules:
347  // "[I]n C, this implies that if two structs are defined in
348  // different submodules with the same name, those two types are
349  // distinct types (but may be compatible types if their
350  // definitions match)."
351  //
352  // We treat non-C++ modules like namespaces for this reason.
353  if (Current.Die.getTag() == dwarf::DW_TAG_module &&
354  Current.ParentIdx == 0 &&
355  dwarf::toString(Current.Die.find(dwarf::DW_AT_name), "") !=
356  CU.getClangModuleName()) {
357  Current.InImportedModule = true;
358  analyzeImportedModule(Current.Die, CU, ParseableSwiftInterfaces,
359  ReportWarning);
360  }
361 
362  Info.ParentIdx = Current.ParentIdx;
363  bool InClangModule = CU.isClangModule() || Current.InImportedModule;
364  if (CU.hasODR() || InClangModule) {
365  if (Current.Context) {
366  auto PtrInvalidPair = Contexts.getChildDeclContext(
367  *Current.Context, Current.Die, CU, InClangModule);
368  Current.Context = PtrInvalidPair.getPointer();
369  Info.Ctxt =
370  PtrInvalidPair.getInt() ? nullptr : PtrInvalidPair.getPointer();
371  if (Info.Ctxt)
372  Info.Ctxt->setDefinedInClangModule(InClangModule);
373  } else
374  Info.Ctxt = Current.Context = nullptr;
375  }
376 
377  Info.Prune = Current.InImportedModule;
378  // Add children in reverse order to the worklist to effectively process
379  // them in order.
380  Worklist.emplace_back(Current.Die, ContextWorklistItemType::UpdatePruning);
381  for (auto Child : reverse(Current.Die.children())) {
382  CompileUnit::DIEInfo &ChildInfo = CU.getInfo(Child);
383  Worklist.emplace_back(
384  Current.Die, ContextWorklistItemType::UpdateChildPruning, &ChildInfo);
385  Worklist.emplace_back(Child, Current.Context, Idx,
386  Current.InImportedModule);
387  }
388  }
389 
390  return CU.getInfo(DIE).Prune;
391 }
392 
394  switch (Tag) {
395  default:
396  return false;
397  case dwarf::DW_TAG_class_type:
398  case dwarf::DW_TAG_common_block:
399  case dwarf::DW_TAG_lexical_block:
400  case dwarf::DW_TAG_structure_type:
401  case dwarf::DW_TAG_subprogram:
402  case dwarf::DW_TAG_subroutine_type:
403  case dwarf::DW_TAG_union_type:
404  return true;
405  }
406  llvm_unreachable("Invalid Tag");
407 }
408 
409 void DWARFLinker::cleanupAuxiliarryData(LinkContext &Context) {
410  Context.clear();
411 
412  for (DIEBlock *I : DIEBlocks)
413  I->~DIEBlock();
414  for (DIELoc *I : DIELocs)
415  I->~DIELoc();
416 
417  DIEBlocks.clear();
418  DIELocs.clear();
419  DIEAlloc.Reset();
420 }
421 
422 /// Check if a variable describing DIE should be kept.
423 /// \returns updated TraversalFlags.
424 unsigned DWARFLinker::shouldKeepVariableDIE(AddressesMap &RelocMgr,
425  const DWARFDie &DIE,
426  CompileUnit::DIEInfo &MyInfo,
427  unsigned Flags) {
428  const auto *Abbrev = DIE.getAbbreviationDeclarationPtr();
429 
430  // Global variables with constant value can always be kept.
431  if (!(Flags & TF_InFunctionScope) &&
432  Abbrev->findAttributeIndex(dwarf::DW_AT_const_value)) {
433  MyInfo.InDebugMap = true;
434  return Flags | TF_Keep;
435  }
436 
437  // See if there is a relocation to a valid debug map entry inside this
438  // variable's location. The order is important here. We want to always check
439  // if the variable has a valid relocation, so that the DIEInfo is filled.
440  // However, we don't want a static variable in a function to force us to keep
441  // the enclosing function, unless requested explicitly.
442  const bool HasLiveMemoryLocation =
443  RelocMgr.hasLiveMemoryLocation(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.hasValue() && "low_pc attribute is not an address.");
472  if (!RelocMgr.hasLiveAddressRange(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  .getValueOr(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->areRelocationsResolved() &&
1388  ObjFile.Addresses->applyValidRelocs(DIECopy, Offset,
1389  Data.isLittleEndian())) {
1390  // If we applied relocations, we store the value of high_pc that was
1391  // potentially stored in the input DIE. If high_pc is an address
1392  // (Dwarf version == 2), then it might have been relocated to a
1393  // totally unrelated value (because the end address in the object
1394  // file might be start address of another function which got moved
1395  // independently by the linker). The computation of the actual
1396  // high_pc value is done in cloneAddressAttribute().
1397  AttrInfo.OrigHighPc =
1398  dwarf::toAddress(InputDIE.find(dwarf::DW_AT_high_pc), 0);
1399  // Also store the low_pc. It might get relocated in an
1400  // inline_subprogram that happens at the beginning of its
1401  // inlining function.
1402  AttrInfo.OrigLowPc = dwarf::toAddress(InputDIE.find(dwarf::DW_AT_low_pc),
1404  AttrInfo.OrigCallReturnPc =
1405  dwarf::toAddress(InputDIE.find(dwarf::DW_AT_call_return_pc), 0);
1406  AttrInfo.OrigCallPc =
1407  dwarf::toAddress(InputDIE.find(dwarf::DW_AT_call_pc), 0);
1408  }
1409 
1410  // Reset the Offset to 0 as we will be working on the local copy of
1411  // the data.
1412  Offset = 0;
1413 
1414  const auto *Abbrev = InputDIE.getAbbreviationDeclarationPtr();
1415  Offset += getULEB128Size(Abbrev->getCode());
1416 
1417  // We are entering a subprogram. Get and propagate the PCOffset.
1418  if (Die->getTag() == dwarf::DW_TAG_subprogram)
1419  PCOffset = Info.AddrAdjust;
1420  AttrInfo.PCOffset = PCOffset;
1421 
1422  if (Abbrev->getTag() == dwarf::DW_TAG_subprogram) {
1423  Flags |= TF_InFunctionScope;
1424  if (!Info.InDebugMap && LLVM_LIKELY(!Update))
1425  Flags |= TF_SkipPC;
1426  } else if (Abbrev->getTag() == dwarf::DW_TAG_variable) {
1427  // Function-local globals could be in the debug map even when the function
1428  // is not, e.g., inlined functions.
1429  if ((Flags & TF_InFunctionScope) && Info.InDebugMap)
1430  Flags &= ~TF_SkipPC;
1431  }
1432 
1433  for (const auto &AttrSpec : Abbrev->attributes()) {
1434  if (LLVM_LIKELY(!Update) &&
1435  shouldSkipAttribute(AttrSpec, Die->getTag(), Info.InDebugMap,
1436  Flags & TF_SkipPC, Flags & TF_InFunctionScope)) {
1437  DWARFFormValue::skipValue(AttrSpec.Form, Data, &Offset,
1438  U.getFormParams());
1439  continue;
1440  }
1441 
1442  DWARFFormValue Val(AttrSpec.Form);
1443  uint64_t AttrSize = Offset;
1444  Val.extractValue(Data, &Offset, U.getFormParams(), &U);
1445  AttrSize = Offset - AttrSize;
1446 
1447  OutOffset += cloneAttribute(*Die, InputDIE, File, Unit, StringPool, Val,
1448  AttrSpec, AttrSize, AttrInfo, IsLittleEndian);
1449  }
1450 
1451  // Look for accelerator entries.
1452  uint16_t Tag = InputDIE.getTag();
1453  // FIXME: This is slightly wrong. An inline_subroutine without a
1454  // low_pc, but with AT_ranges might be interesting to get into the
1455  // accelerator tables too. For now stick with dsymutil's behavior.
1456  if ((Info.InDebugMap || AttrInfo.HasLowPc || AttrInfo.HasRanges) &&
1457  Tag != dwarf::DW_TAG_compile_unit &&
1458  getDIENames(InputDIE, AttrInfo, StringPool,
1459  Tag != dwarf::DW_TAG_inlined_subroutine)) {
1460  if (AttrInfo.MangledName && AttrInfo.MangledName != AttrInfo.Name)
1461  Unit.addNameAccelerator(Die, AttrInfo.MangledName,
1462  Tag == dwarf::DW_TAG_inlined_subroutine);
1463  if (AttrInfo.Name) {
1464  if (AttrInfo.NameWithoutTemplate)
1465  Unit.addNameAccelerator(Die, AttrInfo.NameWithoutTemplate,
1466  /* SkipPubSection */ true);
1467  Unit.addNameAccelerator(Die, AttrInfo.Name,
1468  Tag == dwarf::DW_TAG_inlined_subroutine);
1469  }
1470  if (AttrInfo.Name && isObjCSelector(AttrInfo.Name.getString()))
1471  addObjCAccelerator(Unit, Die, AttrInfo.Name, StringPool,
1472  /* SkipPubSection =*/true);
1473 
1474  } else if (Tag == dwarf::DW_TAG_namespace) {
1475  if (!AttrInfo.Name)
1476  AttrInfo.Name = StringPool.getEntry("(anonymous namespace)");
1477  Unit.addNamespaceAccelerator(Die, AttrInfo.Name);
1478  } else if (isTypeTag(Tag) && !AttrInfo.IsDeclaration &&
1479  getDIENames(InputDIE, AttrInfo, StringPool) && AttrInfo.Name &&
1480  AttrInfo.Name.getString()[0]) {
1481  uint32_t Hash = hashFullyQualifiedName(InputDIE, Unit, File);
1482  uint64_t RuntimeLang =
1483  dwarf::toUnsigned(InputDIE.find(dwarf::DW_AT_APPLE_runtime_class))
1484  .getValueOr(0);
1485  bool ObjCClassIsImplementation =
1486  (RuntimeLang == dwarf::DW_LANG_ObjC ||
1487  RuntimeLang == dwarf::DW_LANG_ObjC_plus_plus) &&
1488  dwarf::toUnsigned(InputDIE.find(dwarf::DW_AT_APPLE_objc_complete_type))
1489  .getValueOr(0);
1490  Unit.addTypeAccelerator(Die, AttrInfo.Name, ObjCClassIsImplementation,
1491  Hash);
1492  }
1493 
1494  // Determine whether there are any children that we want to keep.
1495  bool HasChildren = false;
1496  for (auto Child : InputDIE.children()) {
1497  unsigned Idx = U.getDIEIndex(Child);
1498  if (Unit.getInfo(Idx).Keep) {
1499  HasChildren = true;
1500  break;
1501  }
1502  }
1503 
1504  DIEAbbrev NewAbbrev = Die->generateAbbrev();
1505  if (HasChildren)
1506  NewAbbrev.setChildrenFlag(dwarf::DW_CHILDREN_yes);
1507  // Assign a permanent abbrev number
1508  Linker.assignAbbrev(NewAbbrev);
1509  Die->setAbbrevNumber(NewAbbrev.getNumber());
1510 
1511  // Add the size of the abbreviation number to the output offset.
1512  OutOffset += getULEB128Size(Die->getAbbrevNumber());
1513 
1514  if (!HasChildren) {
1515  // Update our size.
1516  Die->setSize(OutOffset - Die->getOffset());
1517  return Die;
1518  }
1519 
1520  // Recursively clone children.
1521  for (auto Child : InputDIE.children()) {
1522  if (DIE *Clone = cloneDIE(Child, File, Unit, StringPool, PCOffset,
1523  OutOffset, Flags, IsLittleEndian)) {
1524  Die->addChild(Clone);
1525  OutOffset = Clone->getOffset() + Clone->getSize();
1526  }
1527  }
1528 
1529  // Account for the end of children marker.
1530  OutOffset += sizeof(int8_t);
1531  // Update our size.
1532  Die->setSize(OutOffset - Die->getOffset());
1533  return Die;
1534 }
1535 
1536 /// Patch the input object file relevant debug_ranges entries
1537 /// and emit them in the output file. Update the relevant attributes
1538 /// to point at the new entries.
1539 void DWARFLinker::patchRangesForUnit(const CompileUnit &Unit,
1540  DWARFContext &OrigDwarf,
1541  const DWARFFile &File) const {
1542  DWARFDebugRangeList RangeList;
1543  const auto &FunctionRanges = Unit.getFunctionRanges();
1544  unsigned AddressSize = Unit.getOrigUnit().getAddressByteSize();
1545  DWARFDataExtractor RangeExtractor(OrigDwarf.getDWARFObj(),
1546  OrigDwarf.getDWARFObj().getRangesSection(),
1547  OrigDwarf.isLittleEndian(), AddressSize);
1548  auto InvalidRange = FunctionRanges.end(), CurrRange = InvalidRange;
1549  DWARFUnit &OrigUnit = Unit.getOrigUnit();
1550  auto OrigUnitDie = OrigUnit.getUnitDIE(false);
1551  uint64_t OrigLowPc =
1552  dwarf::toAddress(OrigUnitDie.find(dwarf::DW_AT_low_pc), -1ULL);
1553  // Ranges addresses are based on the unit's low_pc. Compute the
1554  // offset we need to apply to adapt to the new unit's low_pc.
1555  int64_t UnitPcOffset = 0;
1556  if (OrigLowPc != -1ULL)
1557  UnitPcOffset = int64_t(OrigLowPc) - Unit.getLowPc();
1558 
1559  for (const auto &RangeAttribute : Unit.getRangesAttributes()) {
1560  uint64_t Offset = RangeAttribute.get();
1561  RangeAttribute.set(TheDwarfEmitter->getRangesSectionSize());
1562  if (Error E = RangeList.extract(RangeExtractor, &Offset)) {
1564  reportWarning("invalid range list ignored.", File);
1565  RangeList.clear();
1566  }
1567  const auto &Entries = RangeList.getEntries();
1568  if (!Entries.empty()) {
1569  const DWARFDebugRangeList::RangeListEntry &First = Entries.front();
1570 
1571  if (CurrRange == InvalidRange ||
1572  First.StartAddress + OrigLowPc < CurrRange.start() ||
1573  First.StartAddress + OrigLowPc >= CurrRange.stop()) {
1574  CurrRange = FunctionRanges.find(First.StartAddress + OrigLowPc);
1575  if (CurrRange == InvalidRange ||
1576  CurrRange.start() > First.StartAddress + OrigLowPc) {
1577  reportWarning("no mapping for range.", File);
1578  continue;
1579  }
1580  }
1581  }
1582 
1583  TheDwarfEmitter->emitRangesEntries(UnitPcOffset, OrigLowPc, CurrRange,
1584  Entries, AddressSize);
1585  }
1586 }
1587 
1588 /// Generate the debug_aranges entries for \p Unit and if the
1589 /// unit has a DW_AT_ranges attribute, also emit the debug_ranges
1590 /// contribution for this attribute.
1591 /// FIXME: this could actually be done right in patchRangesForUnit,
1592 /// but for the sake of initial bit-for-bit compatibility with legacy
1593 /// dsymutil, we have to do it in a delayed pass.
1594 void DWARFLinker::generateUnitRanges(CompileUnit &Unit) const {
1595  auto Attr = Unit.getUnitRangesAttribute();
1596  if (Attr)
1597  Attr->set(TheDwarfEmitter->getRangesSectionSize());
1598  TheDwarfEmitter->emitUnitRangesEntries(Unit, static_cast<bool>(Attr));
1599 }
1600 
1601 /// Insert the new line info sequence \p Seq into the current
1602 /// set of already linked line info \p Rows.
1603 static void insertLineSequence(std::vector<DWARFDebugLine::Row> &Seq,
1604  std::vector<DWARFDebugLine::Row> &Rows) {
1605  if (Seq.empty())
1606  return;
1607 
1608  if (!Rows.empty() && Rows.back().Address < Seq.front().Address) {
1609  llvm::append_range(Rows, Seq);
1610  Seq.clear();
1611  return;
1612  }
1613 
1614  object::SectionedAddress Front = Seq.front().Address;
1615  auto InsertPoint = partition_point(
1616  Rows, [=](const DWARFDebugLine::Row &O) { return O.Address < Front; });
1617 
1618  // FIXME: this only removes the unneeded end_sequence if the
1619  // sequences have been inserted in order. Using a global sort like
1620  // described in patchLineTableForUnit() and delaying the end_sequene
1621  // elimination to emitLineTableForUnit() we can get rid of all of them.
1622  if (InsertPoint != Rows.end() && InsertPoint->Address == Front &&
1623  InsertPoint->EndSequence) {
1624  *InsertPoint = Seq.front();
1625  Rows.insert(InsertPoint + 1, Seq.begin() + 1, Seq.end());
1626  } else {
1627  Rows.insert(InsertPoint, Seq.begin(), Seq.end());
1628  }
1629 
1630  Seq.clear();
1631 }
1632 
1633 static void patchStmtList(DIE &Die, DIEInteger Offset) {
1634  for (auto &V : Die.values())
1635  if (V.getAttribute() == dwarf::DW_AT_stmt_list) {
1636  V = DIEValue(V.getAttribute(), V.getForm(), Offset);
1637  return;
1638  }
1639 
1640  llvm_unreachable("Didn't find DW_AT_stmt_list in cloned DIE!");
1641 }
1642 
1643 /// Extract the line table for \p Unit from \p OrigDwarf, and
1644 /// recreate a relocated version of these for the address ranges that
1645 /// are present in the binary.
1646 void DWARFLinker::patchLineTableForUnit(CompileUnit &Unit,
1647  DWARFContext &OrigDwarf,
1648  const DWARFFile &File) {
1649  DWARFDie CUDie = Unit.getOrigUnit().getUnitDIE();
1650  auto StmtList = dwarf::toSectionOffset(CUDie.find(dwarf::DW_AT_stmt_list));
1651  if (!StmtList)
1652  return;
1653 
1654  // Update the cloned DW_AT_stmt_list with the correct debug_line offset.
1655  if (auto *OutputDIE = Unit.getOutputUnitDIE())
1656  patchStmtList(*OutputDIE,
1657  DIEInteger(TheDwarfEmitter->getLineSectionSize()));
1658 
1659  RangesTy &Ranges = File.Addresses->getValidAddressRanges();
1660 
1661  // Parse the original line info for the unit.
1662  DWARFDebugLine::LineTable LineTable;
1663  uint64_t StmtOffset = *StmtList;
1664  DWARFDataExtractor LineExtractor(
1665  OrigDwarf.getDWARFObj(), OrigDwarf.getDWARFObj().getLineSection(),
1666  OrigDwarf.isLittleEndian(), Unit.getOrigUnit().getAddressByteSize());
1667  if (needToTranslateStrings())
1668  return TheDwarfEmitter->translateLineTable(LineExtractor, StmtOffset);
1669 
1670  if (Error Err =
1671  LineTable.parse(LineExtractor, &StmtOffset, OrigDwarf,
1672  &Unit.getOrigUnit(), OrigDwarf.getWarningHandler()))
1673  OrigDwarf.getWarningHandler()(std::move(Err));
1674 
1675  // This vector is the output line table.
1676  std::vector<DWARFDebugLine::Row> NewRows;
1677  NewRows.reserve(LineTable.Rows.size());
1678 
1679  // Current sequence of rows being extracted, before being inserted
1680  // in NewRows.
1681  std::vector<DWARFDebugLine::Row> Seq;
1682  const auto &FunctionRanges = Unit.getFunctionRanges();
1683  auto InvalidRange = FunctionRanges.end(), CurrRange = InvalidRange;
1684 
1685  // FIXME: This logic is meant to generate exactly the same output as
1686  // Darwin's classic dsymutil. There is a nicer way to implement this
1687  // by simply putting all the relocated line info in NewRows and simply
1688  // sorting NewRows before passing it to emitLineTableForUnit. This
1689  // should be correct as sequences for a function should stay
1690  // together in the sorted output. There are a few corner cases that
1691  // look suspicious though, and that required to implement the logic
1692  // this way. Revisit that once initial validation is finished.
1693 
1694  // Iterate over the object file line info and extract the sequences
1695  // that correspond to linked functions.
1696  for (auto &Row : LineTable.Rows) {
1697  // Check whether we stepped out of the range. The range is
1698  // half-open, but consider accept the end address of the range if
1699  // it is marked as end_sequence in the input (because in that
1700  // case, the relocation offset is accurate and that entry won't
1701  // serve as the start of another function).
1702  if (CurrRange == InvalidRange || Row.Address.Address < CurrRange.start() ||
1703  Row.Address.Address > CurrRange.stop() ||
1704  (Row.Address.Address == CurrRange.stop() && !Row.EndSequence)) {
1705  // We just stepped out of a known range. Insert a end_sequence
1706  // corresponding to the end of the range.
1707  uint64_t StopAddress = CurrRange != InvalidRange
1708  ? CurrRange.stop() + CurrRange.value()
1709  : -1ULL;
1710  CurrRange = FunctionRanges.find(Row.Address.Address);
1711  bool CurrRangeValid =
1712  CurrRange != InvalidRange && CurrRange.start() <= Row.Address.Address;
1713  if (!CurrRangeValid) {
1714  CurrRange = InvalidRange;
1715  if (StopAddress != -1ULL) {
1716  // Try harder by looking in the Address ranges map.
1717  // There are corner cases where this finds a
1718  // valid entry. It's unclear if this is right or wrong, but
1719  // for now do as dsymutil.
1720  // FIXME: Understand exactly what cases this addresses and
1721  // potentially remove it along with the Ranges map.
1722  auto Range = Ranges.lower_bound(Row.Address.Address);
1723  if (Range != Ranges.begin() && Range != Ranges.end())
1724  --Range;
1725 
1726  if (Range != Ranges.end() && Range->first <= Row.Address.Address &&
1727  Range->second.HighPC >= Row.Address.Address) {
1728  StopAddress = Row.Address.Address + Range->second.Offset;
1729  }
1730  }
1731  }
1732  if (StopAddress != -1ULL && !Seq.empty()) {
1733  // Insert end sequence row with the computed end address, but
1734  // the same line as the previous one.
1735  auto NextLine = Seq.back();
1736  NextLine.Address.Address = StopAddress;
1737  NextLine.EndSequence = 1;
1738  NextLine.PrologueEnd = 0;
1739  NextLine.BasicBlock = 0;
1740  NextLine.EpilogueBegin = 0;
1741  Seq.push_back(NextLine);
1742  insertLineSequence(Seq, NewRows);
1743  }
1744 
1745  if (!CurrRangeValid)
1746  continue;
1747  }
1748 
1749  // Ignore empty sequences.
1750  if (Row.EndSequence && Seq.empty())
1751  continue;
1752 
1753  // Relocate row address and add it to the current sequence.
1754  Row.Address.Address += CurrRange.value();
1755  Seq.emplace_back(Row);
1756 
1757  if (Row.EndSequence)
1758  insertLineSequence(Seq, NewRows);
1759  }
1760 
1761  // Finished extracting, now emit the line tables.
1762  // FIXME: LLVM hard-codes its prologue values. We just copy the
1763  // prologue over and that works because we act as both producer and
1764  // consumer. It would be nicer to have a real configurable line
1765  // table emitter.
1766  if (LineTable.Prologue.getVersion() < 2 ||
1767  LineTable.Prologue.getVersion() > 5 ||
1768  LineTable.Prologue.DefaultIsStmt != DWARF2_LINE_DEFAULT_IS_STMT ||
1769  LineTable.Prologue.OpcodeBase > 13)
1770  reportWarning("line table parameters mismatch. Cannot emit.", File);
1771  else {
1772  uint32_t PrologueEnd = *StmtList + 10 + LineTable.Prologue.PrologueLength;
1773  // DWARF v5 has an extra 2 bytes of information before the header_length
1774  // field.
1775  if (LineTable.Prologue.getVersion() == 5)
1776  PrologueEnd += 2;
1777  StringRef LineData = OrigDwarf.getDWARFObj().getLineSection().Data;
1778  MCDwarfLineTableParams Params;
1779  Params.DWARF2LineOpcodeBase = LineTable.Prologue.OpcodeBase;
1780  Params.DWARF2LineBase = LineTable.Prologue.LineBase;
1781  Params.DWARF2LineRange = LineTable.Prologue.LineRange;
1782  TheDwarfEmitter->emitLineTableForUnit(
1783  Params, LineData.slice(*StmtList + 4, PrologueEnd),
1784  LineTable.Prologue.MinInstLength, NewRows,
1785  Unit.getOrigUnit().getAddressByteSize());
1786  }
1787 }
1788 
1789 void DWARFLinker::emitAcceleratorEntriesForUnit(CompileUnit &Unit) {
1790  switch (Options.TheAccelTableKind) {
1791  case AccelTableKind::Apple:
1792  emitAppleAcceleratorEntriesForUnit(Unit);
1793  break;
1794  case AccelTableKind::Dwarf:
1795  emitDwarfAcceleratorEntriesForUnit(Unit);
1796  break;
1797  case AccelTableKind::Pub:
1798  emitPubAcceleratorEntriesForUnit(Unit);
1799  break;
1801  llvm_unreachable("The default must be updated to a concrete value.");
1802  break;
1803  }
1804 }
1805 
1806 void DWARFLinker::emitAppleAcceleratorEntriesForUnit(CompileUnit &Unit) {
1807  // Add namespaces.
1808  for (const auto &Namespace : Unit.getNamespaces())
1809  AppleNamespaces.addName(Namespace.Name,
1810  Namespace.Die->getOffset() + Unit.getStartOffset());
1811 
1812  /// Add names.
1813  for (const auto &Pubname : Unit.getPubnames())
1814  AppleNames.addName(Pubname.Name,
1815  Pubname.Die->getOffset() + Unit.getStartOffset());
1816 
1817  /// Add types.
1818  for (const auto &Pubtype : Unit.getPubtypes())
1819  AppleTypes.addName(
1820  Pubtype.Name, Pubtype.Die->getOffset() + Unit.getStartOffset(),
1821  Pubtype.Die->getTag(),
1822  Pubtype.ObjcClassImplementation ? dwarf::DW_FLAG_type_implementation
1823  : 0,
1824  Pubtype.QualifiedNameHash);
1825 
1826  /// Add ObjC names.
1827  for (const auto &ObjC : Unit.getObjC())
1828  AppleObjc.addName(ObjC.Name, ObjC.Die->getOffset() + Unit.getStartOffset());
1829 }
1830 
1831 void DWARFLinker::emitDwarfAcceleratorEntriesForUnit(CompileUnit &Unit) {
1832  for (const auto &Namespace : Unit.getNamespaces())
1833  DebugNames.addName(Namespace.Name, Namespace.Die->getOffset(),
1834  Namespace.Die->getTag(), Unit.getUniqueID());
1835  for (const auto &Pubname : Unit.getPubnames())
1836  DebugNames.addName(Pubname.Name, Pubname.Die->getOffset(),
1837  Pubname.Die->getTag(), Unit.getUniqueID());
1838  for (const auto &Pubtype : Unit.getPubtypes())
1839  DebugNames.addName(Pubtype.Name, Pubtype.Die->getOffset(),
1840  Pubtype.Die->getTag(), Unit.getUniqueID());
1841 }
1842 
1843 void DWARFLinker::emitPubAcceleratorEntriesForUnit(CompileUnit &Unit) {
1844  TheDwarfEmitter->emitPubNamesForUnit(Unit);
1845  TheDwarfEmitter->emitPubTypesForUnit(Unit);
1846 }
1847 
1848 /// Read the frame info stored in the object, and emit the
1849 /// patched frame descriptions for the resulting file.
1850 ///
1851 /// This is actually pretty easy as the data of the CIEs and FDEs can
1852 /// be considered as black boxes and moved as is. The only thing to do
1853 /// is to patch the addresses in the headers.
1854 void DWARFLinker::patchFrameInfoForObject(const DWARFFile &File,
1855  RangesTy &Ranges,
1856  DWARFContext &OrigDwarf,
1857  unsigned AddrSize) {
1858  StringRef FrameData = OrigDwarf.getDWARFObj().getFrameSection().Data;
1859  if (FrameData.empty())
1860  return;
1861 
1862  DataExtractor Data(FrameData, OrigDwarf.isLittleEndian(), 0);
1863  uint64_t InputOffset = 0;
1864 
1865  // Store the data of the CIEs defined in this object, keyed by their
1866  // offsets.
1867  DenseMap<uint64_t, StringRef> LocalCIES;
1868 
1869  while (Data.isValidOffset(InputOffset)) {
1870  uint64_t EntryOffset = InputOffset;
1871  uint32_t InitialLength = Data.getU32(&InputOffset);
1872  if (InitialLength == 0xFFFFFFFF)
1873  return reportWarning("Dwarf64 bits no supported", File);
1874 
1875  uint32_t CIEId = Data.getU32(&InputOffset);
1876  if (CIEId == 0xFFFFFFFF) {
1877  // This is a CIE, store it.
1878  StringRef CIEData = FrameData.substr(EntryOffset, InitialLength + 4);
1879  LocalCIES[EntryOffset] = CIEData;
1880  // The -4 is to account for the CIEId we just read.
1881  InputOffset += InitialLength - 4;
1882  continue;
1883  }
1884 
1885  uint32_t Loc = Data.getUnsigned(&InputOffset, AddrSize);
1886 
1887  // Some compilers seem to emit frame info that doesn't start at
1888  // the function entry point, thus we can't just lookup the address
1889  // in the debug map. Use the AddressInfo's range map to see if the FDE
1890  // describes something that we can relocate.
1891  auto Range = Ranges.upper_bound(Loc);
1892  if (Range != Ranges.begin())
1893  --Range;
1894  if (Range == Ranges.end() || Range->first > Loc ||
1895  Range->second.HighPC <= Loc) {
1896  // The +4 is to account for the size of the InitialLength field itself.
1897  InputOffset = EntryOffset + InitialLength + 4;
1898  continue;
1899  }
1900 
1901  // This is an FDE, and we have a mapping.
1902  // Have we already emitted a corresponding CIE?
1903  StringRef CIEData = LocalCIES[CIEId];
1904  if (CIEData.empty())
1905  return reportWarning("Inconsistent debug_frame content. Dropping.", File);
1906 
1907  // Look if we already emitted a CIE that corresponds to the
1908  // referenced one (the CIE data is the key of that lookup).
1909  auto IteratorInserted = EmittedCIEs.insert(
1910  std::make_pair(CIEData, TheDwarfEmitter->getFrameSectionSize()));
1911  // If there is no CIE yet for this ID, emit it.
1912  if (IteratorInserted.second) {
1913  LastCIEOffset = TheDwarfEmitter->getFrameSectionSize();
1914  IteratorInserted.first->getValue() = LastCIEOffset;
1915  TheDwarfEmitter->emitCIE(CIEData);
1916  }
1917 
1918  // Emit the FDE with updated address and CIE pointer.
1919  // (4 + AddrSize) is the size of the CIEId + initial_location
1920  // fields that will get reconstructed by emitFDE().
1921  unsigned FDERemainingBytes = InitialLength - (4 + AddrSize);
1922  TheDwarfEmitter->emitFDE(IteratorInserted.first->getValue(), AddrSize,
1923  Loc + Range->second.Offset,
1924  FrameData.substr(InputOffset, FDERemainingBytes));
1925  InputOffset += FDERemainingBytes;
1926  }
1927 }
1928 
1929 uint32_t DWARFLinker::DIECloner::hashFullyQualifiedName(DWARFDie DIE,
1930  CompileUnit &U,
1931  const DWARFFile &File,
1932  int ChildRecurseDepth) {
1933  const char *Name = nullptr;
1934  DWARFUnit *OrigUnit = &U.getOrigUnit();
1935  CompileUnit *CU = &U;
1936  Optional<DWARFFormValue> Ref;
1937 
1938  while (true) {
1939  if (const char *CurrentName = DIE.getName(DINameKind::ShortName))
1940  Name = CurrentName;
1941 
1942  if (!(Ref = DIE.find(dwarf::DW_AT_specification)) &&
1943  !(Ref = DIE.find(dwarf::DW_AT_abstract_origin)))
1944  break;
1945 
1946  if (!Ref->isFormClass(DWARFFormValue::FC_Reference))
1947  break;
1948 
1949  CompileUnit *RefCU;
1950  if (auto RefDIE =
1951  Linker.resolveDIEReference(File, CompileUnits, *Ref, DIE, RefCU)) {
1952  CU = RefCU;
1953  OrigUnit = &RefCU->getOrigUnit();
1954  DIE = RefDIE;
1955  }
1956  }
1957 
1958  unsigned Idx = OrigUnit->getDIEIndex(DIE);
1959  if (!Name && DIE.getTag() == dwarf::DW_TAG_namespace)
1960  Name = "(anonymous namespace)";
1961 
1962  if (CU->getInfo(Idx).ParentIdx == 0 ||
1963  // FIXME: dsymutil-classic compatibility. Ignore modules.
1964  CU->getOrigUnit().getDIEAtIndex(CU->getInfo(Idx).ParentIdx).getTag() ==
1965  dwarf::DW_TAG_module)
1966  return djbHash(Name ? Name : "", djbHash(ChildRecurseDepth ? "" : "::"));
1967 
1968  DWARFDie Die = OrigUnit->getDIEAtIndex(CU->getInfo(Idx).ParentIdx);
1969  return djbHash(
1970  (Name ? Name : ""),
1971  djbHash((Name ? "::" : ""),
1972  hashFullyQualifiedName(Die, *CU, File, ++ChildRecurseDepth)));
1973 }
1974 
1975 static uint64_t getDwoId(const DWARFDie &CUDie, const DWARFUnit &Unit) {
1976  auto DwoId = dwarf::toUnsigned(
1977  CUDie.find({dwarf::DW_AT_dwo_id, dwarf::DW_AT_GNU_dwo_id}));
1978  if (DwoId)
1979  return *DwoId;
1980  return 0;
1981 }
1982 
1983 static std::string remapPath(StringRef Path,
1984  const objectPrefixMap &ObjectPrefixMap) {
1985  if (ObjectPrefixMap.empty())
1986  return Path.str();
1987 
1988  SmallString<256> p = Path;
1989  for (const auto &Entry : ObjectPrefixMap)
1990  if (llvm::sys::path::replace_path_prefix(p, Entry.first, Entry.second))
1991  break;
1992  return p.str().str();
1993 }
1994 
1995 bool DWARFLinker::registerModuleReference(DWARFDie CUDie, const DWARFUnit &Unit,
1996  const DWARFFile &File,
1997  OffsetsStringPool &StringPool,
1998  DeclContextTree &ODRContexts,
1999  uint64_t ModulesEndOffset,
2000  unsigned &UnitID, bool IsLittleEndian,
2001  unsigned Indent, bool Quiet) {
2002  std::string PCMfile = dwarf::toString(
2003  CUDie.find({dwarf::DW_AT_dwo_name, dwarf::DW_AT_GNU_dwo_name}), "");
2004  if (PCMfile.empty())
2005  return false;
2006  if (Options.ObjectPrefixMap)
2007  PCMfile = remapPath(PCMfile, *Options.ObjectPrefixMap);
2008 
2009  // Clang module DWARF skeleton CUs abuse this for the path to the module.
2010  uint64_t DwoId = getDwoId(CUDie, Unit);
2011 
2012  std::string Name = dwarf::toString(CUDie.find(dwarf::DW_AT_name), "");
2013  if (Name.empty()) {
2014  if (!Quiet)
2015  reportWarning("Anonymous module skeleton CU for " + PCMfile, File);
2016  return true;
2017  }
2018 
2019  if (!Quiet && Options.Verbose) {
2020  outs().indent(Indent);
2021  outs() << "Found clang module reference " << PCMfile;
2022  }
2023 
2024  auto Cached = ClangModules.find(PCMfile);
2025  if (Cached != ClangModules.end()) {
2026  // FIXME: Until PR27449 (https://llvm.org/bugs/show_bug.cgi?id=27449) is
2027  // fixed in clang, only warn about DWO_id mismatches in verbose mode.
2028  // ASTFileSignatures will change randomly when a module is rebuilt.
2029  if (!Quiet && Options.Verbose && (Cached->second != DwoId))
2030  reportWarning(Twine("hash mismatch: this object file was built against a "
2031  "different version of the module ") +
2032  PCMfile,
2033  File);
2034  if (!Quiet && Options.Verbose)
2035  outs() << " [cached].\n";
2036  return true;
2037  }
2038  if (!Quiet && Options.Verbose)
2039  outs() << " ...\n";
2040 
2041  // Cyclic dependencies are disallowed by Clang, but we still
2042  // shouldn't run into an infinite loop, so mark it as processed now.
2043  ClangModules.insert({PCMfile, DwoId});
2044 
2045  if (Error E = loadClangModule(CUDie, PCMfile, Name, DwoId, File, StringPool,
2046  ODRContexts, ModulesEndOffset, UnitID,
2047  IsLittleEndian, Indent + 2, Quiet)) {
2049  return false;
2050  }
2051  return true;
2052 }
2053 
2054 Error DWARFLinker::loadClangModule(
2055  DWARFDie CUDie, StringRef Filename, StringRef ModuleName, uint64_t DwoId,
2056  const DWARFFile &File, OffsetsStringPool &StringPool,
2057  DeclContextTree &ODRContexts, uint64_t ModulesEndOffset, unsigned &UnitID,
2058  bool IsLittleEndian, unsigned Indent, bool Quiet) {
2059  /// Using a SmallString<0> because loadClangModule() is recursive.
2060  SmallString<0> Path(Options.PrependPath);
2061  if (sys::path::is_relative(Filename))
2062  resolveRelativeObjectPath(Path, CUDie);
2063  sys::path::append(Path, Filename);
2064  // Don't use the cached binary holder because we have no thread-safety
2065  // guarantee and the lifetime is limited.
2066 
2067  if (Options.ObjFileLoader == nullptr)
2068  return Error::success();
2069 
2070  auto ErrOrObj = Options.ObjFileLoader(File.FileName, Path);
2071  if (!ErrOrObj)
2072  return Error::success();
2073 
2074  std::unique_ptr<CompileUnit> Unit;
2075 
2076  for (const auto &CU : ErrOrObj->Dwarf->compile_units()) {
2077  updateDwarfVersion(CU->getVersion());
2078  // Recursively get all modules imported by this one.
2079  auto CUDie = CU->getUnitDIE(false);
2080  if (!CUDie)
2081  continue;
2082  if (!registerModuleReference(CUDie, *CU, File, StringPool, ODRContexts,
2083  ModulesEndOffset, UnitID, IsLittleEndian,
2084  Indent, Quiet)) {
2085  if (Unit) {
2086  std::string Err =
2087  (Filename +
2088  ": Clang modules are expected to have exactly 1 compile unit.\n")
2089  .str();
2090  reportError(Err, File);
2091  return make_error<StringError>(Err, inconvertibleErrorCode());
2092  }
2093  // FIXME: Until PR27449 (https://llvm.org/bugs/show_bug.cgi?id=27449) is
2094  // fixed in clang, only warn about DWO_id mismatches in verbose mode.
2095  // ASTFileSignatures will change randomly when a module is rebuilt.
2096  uint64_t PCMDwoId = getDwoId(CUDie, *CU);
2097  if (PCMDwoId != DwoId) {
2098  if (!Quiet && Options.Verbose)
2099  reportWarning(
2100  Twine("hash mismatch: this object file was built against a "
2101  "different version of the module ") +
2102  Filename,
2103  File);
2104  // Update the cache entry with the DwoId of the module loaded from disk.
2105  ClangModules[Filename] = PCMDwoId;
2106  }
2107 
2108  // Add this module.
2109  Unit = std::make_unique<CompileUnit>(*CU, UnitID++, !Options.NoODR,
2110  ModuleName);
2111  analyzeContextInfo(CUDie, 0, *Unit, &ODRContexts.getRoot(), ODRContexts,
2112  ModulesEndOffset, Options.ParseableSwiftInterfaces,
2113  [&](const Twine &Warning, const DWARFDie &DIE) {
2114  reportWarning(Warning, File, &DIE);
2115  });
2116  // Keep everything.
2117  Unit->markEverythingAsKept();
2118  }
2119  }
2120  assert(Unit && "CompileUnit is not set!");
2121  if (!Unit->getOrigUnit().getUnitDIE().hasChildren())
2122  return Error::success();
2123  if (!Quiet && Options.Verbose) {
2124  outs().indent(Indent);
2125  outs() << "cloning .debug_info from " << Filename << "\n";
2126  }
2127 
2128  UnitListTy CompileUnits;
2129  CompileUnits.push_back(std::move(Unit));
2130  assert(TheDwarfEmitter);
2131  DIECloner(*this, TheDwarfEmitter, *ErrOrObj, DIEAlloc, CompileUnits,
2132  Options.Update)
2133  .cloneAllCompileUnits(*(ErrOrObj->Dwarf), File, StringPool,
2134  IsLittleEndian);
2135  return Error::success();
2136 }
2137 
2138 uint64_t DWARFLinker::DIECloner::cloneAllCompileUnits(
2139  DWARFContext &DwarfContext, const DWARFFile &File,
2140  OffsetsStringPool &StringPool, bool IsLittleEndian) {
2141  uint64_t OutputDebugInfoSize =
2142  Linker.Options.NoOutput ? 0 : Emitter->getDebugInfoSectionSize();
2143  const uint64_t StartOutputDebugInfoSize = OutputDebugInfoSize;
2144 
2145  for (auto &CurrentUnit : CompileUnits) {
2146  const uint16_t DwarfVersion = CurrentUnit->getOrigUnit().getVersion();
2147  const uint32_t UnitHeaderSize = DwarfVersion >= 5 ? 12 : 11;
2148  auto InputDIE = CurrentUnit->getOrigUnit().getUnitDIE();
2149  CurrentUnit->setStartOffset(OutputDebugInfoSize);
2150  if (!InputDIE) {
2151  OutputDebugInfoSize = CurrentUnit->computeNextUnitOffset(DwarfVersion);
2152  continue;
2153  }
2154  if (CurrentUnit->getInfo(0).Keep) {
2155  // Clone the InputDIE into your Unit DIE in our compile unit since it
2156  // already has a DIE inside of it.
2157  CurrentUnit->createOutputDIE();
2158  cloneDIE(InputDIE, File, *CurrentUnit, StringPool, 0 /* PC offset */,
2159  UnitHeaderSize, 0, IsLittleEndian,
2160  CurrentUnit->getOutputUnitDIE());
2161  }
2162 
2163  OutputDebugInfoSize = CurrentUnit->computeNextUnitOffset(DwarfVersion);
2164 
2165  if (!Linker.Options.NoOutput) {
2166  assert(Emitter);
2167 
2168  if (LLVM_LIKELY(!Linker.Options.Update) ||
2169  Linker.needToTranslateStrings())
2170  Linker.patchLineTableForUnit(*CurrentUnit, DwarfContext, File);
2171 
2172  Linker.emitAcceleratorEntriesForUnit(*CurrentUnit);
2173 
2174  if (LLVM_UNLIKELY(Linker.Options.Update))
2175  continue;
2176 
2177  Linker.patchRangesForUnit(*CurrentUnit, DwarfContext, File);
2178  auto ProcessExpr = [&](StringRef Bytes,
2179  SmallVectorImpl<uint8_t> &Buffer) {
2180  DWARFUnit &OrigUnit = CurrentUnit->getOrigUnit();
2181  DataExtractor Data(Bytes, IsLittleEndian,
2182  OrigUnit.getAddressByteSize());
2183  cloneExpression(Data,
2184  DWARFExpression(Data, OrigUnit.getAddressByteSize(),
2185  OrigUnit.getFormParams().Format),
2186  File, *CurrentUnit, Buffer);
2187  };
2188  Emitter->emitLocationsForUnit(*CurrentUnit, DwarfContext, ProcessExpr);
2189  }
2190  }
2191 
2192  if (!Linker.Options.NoOutput) {
2193  assert(Emitter);
2194  // Emit all the compile unit's debug information.
2195  for (auto &CurrentUnit : CompileUnits) {
2196  if (LLVM_LIKELY(!Linker.Options.Update))
2197  Linker.generateUnitRanges(*CurrentUnit);
2198 
2199  CurrentUnit->fixupForwardReferences();
2200 
2201  if (!CurrentUnit->getOutputUnitDIE())
2202  continue;
2203 
2204  unsigned DwarfVersion = CurrentUnit->getOrigUnit().getVersion();
2205 
2206  assert(Emitter->getDebugInfoSectionSize() ==
2207  CurrentUnit->getStartOffset());
2208  Emitter->emitCompileUnitHeader(*CurrentUnit, DwarfVersion);
2209  Emitter->emitDIE(*CurrentUnit->getOutputUnitDIE());
2210  assert(Emitter->getDebugInfoSectionSize() ==
2211  CurrentUnit->computeNextUnitOffset(DwarfVersion));
2212  }
2213  }
2214 
2215  return OutputDebugInfoSize - StartOutputDebugInfoSize;
2216 }
2217 
2218 void DWARFLinker::updateAccelKind(DWARFContext &Dwarf) {
2219  if (Options.TheAccelTableKind != AccelTableKind::Default)
2220  return;
2221 
2222  auto &DwarfObj = Dwarf.getDWARFObj();
2223 
2224  if (!AtLeastOneDwarfAccelTable &&
2225  (!DwarfObj.getAppleNamesSection().Data.empty() ||
2226  !DwarfObj.getAppleTypesSection().Data.empty() ||
2227  !DwarfObj.getAppleNamespacesSection().Data.empty() ||
2228  !DwarfObj.getAppleObjCSection().Data.empty())) {
2229  AtLeastOneAppleAccelTable = true;
2230  }
2231 
2232  if (!AtLeastOneDwarfAccelTable && !DwarfObj.getNamesSection().Data.empty()) {
2233  AtLeastOneDwarfAccelTable = true;
2234  }
2235 }
2236 
2237 bool DWARFLinker::emitPaperTrailWarnings(const DWARFFile &File,
2238  OffsetsStringPool &StringPool) {
2239 
2240  if (File.Warnings.empty())
2241  return false;
2242 
2243  DIE *CUDie = DIE::get(DIEAlloc, dwarf::DW_TAG_compile_unit);
2244  CUDie->setOffset(11);
2245  StringRef Producer;
2246  StringRef WarningHeader;
2247 
2248  switch (DwarfLinkerClientID) {
2250  Producer = StringPool.internString("dsymutil");
2251  WarningHeader = "dsymutil_warning";
2252  break;
2253 
2254  default:
2255  Producer = StringPool.internString("dwarfopt");
2256  WarningHeader = "dwarfopt_warning";
2257  break;
2258  }
2259 
2260  StringRef FileName = StringPool.internString(File.FileName);
2261  CUDie->addValue(DIEAlloc, dwarf::DW_AT_producer, dwarf::DW_FORM_strp,
2262  DIEInteger(StringPool.getStringOffset(Producer)));
2263  DIEBlock *String = new (DIEAlloc) DIEBlock();
2264  DIEBlocks.push_back(String);
2265  for (auto &C : FileName)
2266  String->addValue(DIEAlloc, dwarf::Attribute(0), dwarf::DW_FORM_data1,
2267  DIEInteger(C));
2268  String->addValue(DIEAlloc, dwarf::Attribute(0), dwarf::DW_FORM_data1,
2269  DIEInteger(0));
2270 
2271  CUDie->addValue(DIEAlloc, dwarf::DW_AT_name, dwarf::DW_FORM_string, String);
2272  for (const auto &Warning : File.Warnings) {
2273  DIE &ConstDie = CUDie->addChild(DIE::get(DIEAlloc, dwarf::DW_TAG_constant));
2274  ConstDie.addValue(DIEAlloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp,
2275  DIEInteger(StringPool.getStringOffset(WarningHeader)));
2276  ConstDie.addValue(DIEAlloc, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag,
2277  DIEInteger(1));
2278  ConstDie.addValue(DIEAlloc, dwarf::DW_AT_const_value, dwarf::DW_FORM_strp,
2279  DIEInteger(StringPool.getStringOffset(Warning)));
2280  }
2281  unsigned Size = 4 /* FORM_strp */ + FileName.size() + 1 +
2282  File.Warnings.size() * (4 + 1 + 4) + 1 /* End of children */;
2283  DIEAbbrev Abbrev = CUDie->generateAbbrev();
2284  assignAbbrev(Abbrev);
2285  CUDie->setAbbrevNumber(Abbrev.getNumber());
2286  Size += getULEB128Size(Abbrev.getNumber());
2287  // Abbreviation ordering needed for classic compatibility.
2288  for (auto &Child : CUDie->children()) {
2289  Abbrev = Child.generateAbbrev();
2290  assignAbbrev(Abbrev);
2291  Child.setAbbrevNumber(Abbrev.getNumber());
2292  Size += getULEB128Size(Abbrev.getNumber());
2293  }
2294  CUDie->setSize(Size);
2295  TheDwarfEmitter->emitPaperTrailWarningsDie(*CUDie);
2296 
2297  return true;
2298 }
2299 
2300 void DWARFLinker::copyInvariantDebugSection(DWARFContext &Dwarf) {
2301  if (!needToTranslateStrings())
2302  TheDwarfEmitter->emitSectionContents(
2303  Dwarf.getDWARFObj().getLineSection().Data, "debug_line");
2304  TheDwarfEmitter->emitSectionContents(Dwarf.getDWARFObj().getLocSection().Data,
2305  "debug_loc");
2306  TheDwarfEmitter->emitSectionContents(
2307  Dwarf.getDWARFObj().getRangesSection().Data, "debug_ranges");
2308  TheDwarfEmitter->emitSectionContents(
2309  Dwarf.getDWARFObj().getFrameSection().Data, "debug_frame");
2310  TheDwarfEmitter->emitSectionContents(Dwarf.getDWARFObj().getArangesSection(),
2311  "debug_aranges");
2312 }
2313 
2315  ObjectContexts.emplace_back(LinkContext(File));
2316 
2317  if (ObjectContexts.back().File.Dwarf)
2318  updateAccelKind(*ObjectContexts.back().File.Dwarf);
2319 }
2320 
2322  assert(Options.NoOutput || TheDwarfEmitter);
2323 
2324  // A unique ID that identifies each compile unit.
2325  unsigned UnitID = 0;
2326 
2327  // First populate the data structure we need for each iteration of the
2328  // parallel loop.
2329  unsigned NumObjects = ObjectContexts.size();
2330 
2331  // This Dwarf string pool which is used for emission. It must be used
2332  // serially as the order of calling getStringOffset matters for
2333  // reproducibility.
2334  OffsetsStringPool OffsetsStringPool(StringsTranslator, true);
2335 
2336  // ODR Contexts for the optimize.
2337  DeclContextTree ODRContexts;
2338 
2339  // If we haven't decided on an accelerator table kind yet, we base ourselves
2340  // on the DWARF we have seen so far. At this point we haven't pulled in debug
2341  // information from modules yet, so it is technically possible that they
2342  // would affect the decision. However, as they're built with the same
2343  // compiler and flags, it is safe to assume that they will follow the
2344  // decision made here.
2345  if (Options.TheAccelTableKind == AccelTableKind::Default) {
2346  if (AtLeastOneDwarfAccelTable && !AtLeastOneAppleAccelTable)
2347  Options.TheAccelTableKind = AccelTableKind::Dwarf;
2348  else
2349  Options.TheAccelTableKind = AccelTableKind::Apple;
2350  }
2351 
2352  for (LinkContext &OptContext : ObjectContexts) {
2353  if (Options.Verbose) {
2354  if (DwarfLinkerClientID == DwarfLinkerClient::Dsymutil)
2355  outs() << "DEBUG MAP OBJECT: " << OptContext.File.FileName << "\n";
2356  else
2357  outs() << "OBJECT FILE: " << OptContext.File.FileName << "\n";
2358  }
2359 
2360  if (emitPaperTrailWarnings(OptContext.File, OffsetsStringPool))
2361  continue;
2362 
2363  if (!OptContext.File.Dwarf)
2364  continue;
2365  // Look for relocations that correspond to address map entries.
2366 
2367  // there was findvalidrelocations previously ... probably we need to gather
2368  // info here
2369  if (LLVM_LIKELY(!Options.Update) &&
2370  !OptContext.File.Addresses->hasValidRelocs()) {
2371  if (Options.Verbose)
2372  outs() << "No valid relocations found. Skipping.\n";
2373 
2374  // Set "Skip" flag as a signal to other loops that we should not
2375  // process this iteration.
2376  OptContext.Skip = true;
2377  continue;
2378  }
2379 
2380  // Setup access to the debug info.
2381  if (!OptContext.File.Dwarf)
2382  continue;
2383 
2384  // In a first phase, just read in the debug info and load all clang modules.
2385  OptContext.CompileUnits.reserve(
2386  OptContext.File.Dwarf->getNumCompileUnits());
2387 
2388  for (const auto &CU : OptContext.File.Dwarf->compile_units()) {
2389  updateDwarfVersion(CU->getVersion());
2390  auto CUDie = CU->getUnitDIE(false);
2391  if (Options.Verbose) {
2392  outs() << "Input compilation unit:";
2393  DIDumpOptions DumpOpts;
2394  DumpOpts.ChildRecurseDepth = 0;
2395  DumpOpts.Verbose = Options.Verbose;
2396  CUDie.dump(outs(), 0, DumpOpts);
2397  }
2398  if (CUDie && !LLVM_UNLIKELY(Options.Update))
2399  registerModuleReference(CUDie, *CU, OptContext.File, OffsetsStringPool,
2400  ODRContexts, 0, UnitID,
2401  OptContext.File.Dwarf->isLittleEndian());
2402  }
2403  }
2404 
2405  // If we haven't seen any CUs, pick an arbitrary valid Dwarf version anyway.
2406  if (MaxDwarfVersion == 0)
2407  MaxDwarfVersion = 3;
2408 
2409  // At this point we know how much data we have emitted. We use this value to
2410  // compare canonical DIE offsets in analyzeContextInfo to see if a definition
2411  // is already emitted, without being affected by canonical die offsets set
2412  // later. This prevents undeterminism when analyze and clone execute
2413  // concurrently, as clone set the canonical DIE offset and analyze reads it.
2414  const uint64_t ModulesEndOffset =
2415  Options.NoOutput ? 0 : TheDwarfEmitter->getDebugInfoSectionSize();
2416 
2417  // These variables manage the list of processed object files.
2418  // The mutex and condition variable are to ensure that this is thread safe.
2419  std::mutex ProcessedFilesMutex;
2420  std::condition_variable ProcessedFilesConditionVariable;
2421  BitVector ProcessedFiles(NumObjects, false);
2422 
2423  // Analyzing the context info is particularly expensive so it is executed in
2424  // parallel with emitting the previous compile unit.
2425  auto AnalyzeLambda = [&](size_t I) {
2426  auto &Context = ObjectContexts[I];
2427 
2428  if (Context.Skip || !Context.File.Dwarf)
2429  return;
2430 
2431  for (const auto &CU : Context.File.Dwarf->compile_units()) {
2432  updateDwarfVersion(CU->getVersion());
2433  // The !registerModuleReference() condition effectively skips
2434  // over fully resolved skeleton units. This second pass of
2435  // registerModuleReferences doesn't do any new work, but it
2436  // will collect top-level errors, which are suppressed. Module
2437  // warnings were already displayed in the first iteration.
2438  bool Quiet = true;
2439  auto CUDie = CU->getUnitDIE(false);
2440  if (!CUDie || LLVM_UNLIKELY(Options.Update) ||
2441  !registerModuleReference(CUDie, *CU, Context.File, OffsetsStringPool,
2442  ODRContexts, ModulesEndOffset, UnitID,
2443  Quiet)) {
2444  Context.CompileUnits.push_back(std::make_unique<CompileUnit>(
2445  *CU, UnitID++, !Options.NoODR && !Options.Update, ""));
2446  }
2447  }
2448 
2449  // Now build the DIE parent links that we will use during the next phase.
2450  for (auto &CurrentUnit : Context.CompileUnits) {
2451  auto CUDie = CurrentUnit->getOrigUnit().getUnitDIE();
2452  if (!CUDie)
2453  continue;
2454  analyzeContextInfo(CurrentUnit->getOrigUnit().getUnitDIE(), 0,
2455  *CurrentUnit, &ODRContexts.getRoot(), ODRContexts,
2456  ModulesEndOffset, Options.ParseableSwiftInterfaces,
2457  [&](const Twine &Warning, const DWARFDie &DIE) {
2458  reportWarning(Warning, Context.File, &DIE);
2459  });
2460  }
2461  };
2462 
2463  // For each object file map how many bytes were emitted.
2464  StringMap<DebugInfoSize> SizeByObject;
2465 
2466  // And then the remaining work in serial again.
2467  // Note, although this loop runs in serial, it can run in parallel with
2468  // the analyzeContextInfo loop so long as we process files with indices >=
2469  // than those processed by analyzeContextInfo.
2470  auto CloneLambda = [&](size_t I) {
2471  auto &OptContext = ObjectContexts[I];
2472  if (OptContext.Skip || !OptContext.File.Dwarf)
2473  return;
2474 
2475  // Then mark all the DIEs that need to be present in the generated output
2476  // and collect some information about them.
2477  // Note that this loop can not be merged with the previous one because
2478  // cross-cu references require the ParentIdx to be setup for every CU in
2479  // the object file before calling this.
2480  if (LLVM_UNLIKELY(Options.Update)) {
2481  for (auto &CurrentUnit : OptContext.CompileUnits)
2482  CurrentUnit->markEverythingAsKept();
2483  copyInvariantDebugSection(*OptContext.File.Dwarf);
2484  } else {
2485  for (auto &CurrentUnit : OptContext.CompileUnits)
2486  lookForDIEsToKeep(*OptContext.File.Addresses,
2487  OptContext.File.Addresses->getValidAddressRanges(),
2488  OptContext.CompileUnits,
2489  CurrentUnit->getOrigUnit().getUnitDIE(),
2490  OptContext.File, *CurrentUnit, 0);
2491  }
2492 
2493  // The calls to applyValidRelocs inside cloneDIE will walk the reloc
2494  // array again (in the same way findValidRelocsInDebugInfo() did). We
2495  // need to reset the NextValidReloc index to the beginning.
2496  if (OptContext.File.Addresses->hasValidRelocs() ||
2497  LLVM_UNLIKELY(Options.Update)) {
2498  SizeByObject[OptContext.File.FileName].Input =
2499  getDebugInfoSize(*OptContext.File.Dwarf);
2500  SizeByObject[OptContext.File.FileName].Output =
2501  DIECloner(*this, TheDwarfEmitter, OptContext.File, DIEAlloc,
2502  OptContext.CompileUnits, Options.Update)
2503  .cloneAllCompileUnits(*OptContext.File.Dwarf, OptContext.File,
2505  OptContext.File.Dwarf->isLittleEndian());
2506  }
2507  if (!Options.NoOutput && !OptContext.CompileUnits.empty() &&
2508  LLVM_LIKELY(!Options.Update))
2509  patchFrameInfoForObject(
2510  OptContext.File, OptContext.File.Addresses->getValidAddressRanges(),
2511  *OptContext.File.Dwarf,
2512  OptContext.CompileUnits[0]->getOrigUnit().getAddressByteSize());
2513 
2514  // Clean-up before starting working on the next object.
2515  cleanupAuxiliarryData(OptContext);
2516  };
2517 
2518  auto EmitLambda = [&]() {
2519  // Emit everything that's global.
2520  if (!Options.NoOutput) {
2521  TheDwarfEmitter->emitAbbrevs(Abbreviations, MaxDwarfVersion);
2522  TheDwarfEmitter->emitStrings(OffsetsStringPool);
2523  switch (Options.TheAccelTableKind) {
2524  case AccelTableKind::Apple:
2525  TheDwarfEmitter->emitAppleNames(AppleNames);
2526  TheDwarfEmitter->emitAppleNamespaces(AppleNamespaces);
2527  TheDwarfEmitter->emitAppleTypes(AppleTypes);
2528  TheDwarfEmitter->emitAppleObjc(AppleObjc);
2529  break;
2530  case AccelTableKind::Dwarf:
2531  TheDwarfEmitter->emitDebugNames(DebugNames);
2532  break;
2533  case AccelTableKind::Pub:
2534  // Already emitted by emitPubAcceleratorEntriesForUnit.
2535  break;
2537  llvm_unreachable("Default should have already been resolved.");
2538  break;
2539  }
2540  }
2541  };
2542 
2543  auto AnalyzeAll = [&]() {
2544  for (unsigned I = 0, E = NumObjects; I != E; ++I) {
2545  AnalyzeLambda(I);
2546 
2547  std::unique_lock<std::mutex> LockGuard(ProcessedFilesMutex);
2548  ProcessedFiles.set(I);
2549  ProcessedFilesConditionVariable.notify_one();
2550  }
2551  };
2552 
2553  auto CloneAll = [&]() {
2554  for (unsigned I = 0, E = NumObjects; I != E; ++I) {
2555  {
2556  std::unique_lock<std::mutex> LockGuard(ProcessedFilesMutex);
2557  if (!ProcessedFiles[I]) {
2558  ProcessedFilesConditionVariable.wait(
2559  LockGuard, [&]() { return ProcessedFiles[I]; });
2560  }
2561  }
2562 
2563  CloneLambda(I);
2564  }
2565  EmitLambda();
2566  };
2567 
2568  // To limit memory usage in the single threaded case, analyze and clone are
2569  // run sequentially so the OptContext is freed after processing each object
2570  // in endDebugObject.
2571  if (Options.Threads == 1) {
2572  for (unsigned I = 0, E = NumObjects; I != E; ++I) {
2573  AnalyzeLambda(I);
2574  CloneLambda(I);
2575  }
2576  EmitLambda();
2577  } else {
2579  Pool.async(AnalyzeAll);
2580  Pool.async(CloneAll);
2581  Pool.wait();
2582  }
2583 
2584  if (Options.Statistics) {
2585  // Create a vector sorted in descending order by output size.
2586  std::vector<std::pair<StringRef, DebugInfoSize>> Sorted;
2587  for (auto &E : SizeByObject)
2588  Sorted.emplace_back(E.first(), E.second);
2589  llvm::sort(Sorted, [](auto &LHS, auto &RHS) {
2590  return LHS.second.Output > RHS.second.Output;
2591  });
2592 
2593  auto ComputePercentange = [](int64_t Input, int64_t Output) -> float {
2594  const float Difference = Output - Input;
2595  const float Sum = Input + Output;
2596  if (Sum == 0)
2597  return 0;
2598  return (Difference / (Sum / 2));
2599  };
2600 
2601  int64_t InputTotal = 0;
2602  int64_t OutputTotal = 0;
2603  const char *FormatStr = "{0,-45} {1,10}b {2,10}b {3,8:P}\n";
2604 
2605  // Print header.
2606  outs() << ".debug_info section size (in bytes)\n";
2607  outs() << "----------------------------------------------------------------"
2608  "---------------\n";
2609  outs() << "Filename Object "
2610  " dSYM Change\n";
2611  outs() << "----------------------------------------------------------------"
2612  "---------------\n";
2613 
2614  // Print body.
2615  for (auto &E : Sorted) {
2616  InputTotal += E.second.Input;
2617  OutputTotal += E.second.Output;
2618  llvm::outs() << formatv(
2619  FormatStr, sys::path::filename(E.first).take_back(45), E.second.Input,
2620  E.second.Output, ComputePercentange(E.second.Input, E.second.Output));
2621  }
2622  // Print total and footer.
2623  outs() << "----------------------------------------------------------------"
2624  "---------------\n";
2625  llvm::outs() << formatv(FormatStr, "Total", InputTotal, OutputTotal,
2626  ComputePercentange(InputTotal, OutputTotal));
2627  outs() << "----------------------------------------------------------------"
2628  "---------------\n\n";
2629  }
2630 
2631  return true;
2632 }
2633 
2634 } // namespace llvm
llvm::Check::Size
@ Size
Definition: FileCheck.h:73
llvm::UnitListTy
std::vector< std::unique_ptr< CompileUnit > > UnitListTy
Definition: DWARFLinker.h:210
DWARFFormValue.h
llvm::StringRef::startswith
LLVM_NODISCARD bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:285
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:237
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:188
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AllocatorList.h:23
llvm::ContextWorklistItem::ParentIdx
unsigned ParentIdx
Definition: DWARFLinker.cpp:257
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:1772
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:519
llvm::DWARFLinker::DWARFLinker
DWARFLinker(DwarfEmitter *Emitter, DwarfLinkerClient ClientID=DwarfLinkerClient::General)
Definition: DWARFLinker.h:256
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:125
llvm::ContextWorklistItem::Context
DeclContext * Context
Definition: DWARFLinker.cpp:260
llvm::AccelTableKind::Dwarf
@ Dwarf
DWARF v5 .debug_names.
llvm::DwarfEmitter::getFrameSectionSize
virtual uint64_t getFrameSectionSize() const =0
Returns size of generated .debug_frame section.
llvm::StringRef::endswith
LLVM_NODISCARD bool endswith(StringRef Suffix) const
Check if this string ends with the given Suffix.
Definition: StringRef.h:296
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:37
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:343
llvm::DWARFAbbreviationDeclaration::AttributeSpec
Definition: DWARFAbbreviationDeclaration.h:29
llvm::DIEValue
Definition: DIE.h:369
llvm::toString
std::string toString(Error E)
Write all error messages (if any) in E to a string.
Definition: Error.h:1030
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:313
llvm::StringRef::npos
static constexpr size_t npos
Definition: StringRef.h:59
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:54
llvm::dwarf::Form
Form
Definition: Dwarf.h:131
llvm::object::SectionedAddress::Address
uint64_t Address
Definition: ObjectFile.h:146
llvm::AddressesMap::~AddressesMap
virtual ~AddressesMap()
Definition: DWARFLinker.cpp:135
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:331
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::AccelTableKind::Pub
@ Pub
.debug_pubnames, .debug_pubtypes
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:203
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:53
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:1633
llvm::DwarfLinkerClient::Dsymutil
@ Dsymutil
llvm::reverse
auto reverse(ContainerTy &&C, std::enable_if_t< has_rbegin< ContainerTy >::value > *=nullptr)
Definition: STLExtras.h:414
llvm::DWARFFormValue::FC_Exprloc
@ FC_Exprloc
Definition: DWARFFormValue.h:38
llvm::dwarf::DW_CHILDREN_yes
@ DW_CHILDREN_yes
Definition: Dwarf.h:430
llvm::Optional
Definition: APInt.h:33
T
#define T
Definition: Mips16ISelLowering.cpp:341
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:80
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:38
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::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:42
STLExtras.h
llvm::getDebugInfoSize
static uint64_t getDebugInfoSize(DWARFContext &Dwarf)
Compute the total size of the debug info.
Definition: DWARFLinker.cpp:44
llvm::DWARFFormValue::FC_Reference
@ FC_Reference
Definition: DWARFFormValue.h:35
RHS
Value * RHS
Definition: X86PartialReduction.cpp:74
llvm::StringMap::find
iterator find(StringRef Key)
Definition: StringMap.h:216
llvm::ContextWorklistItem::InImportedModule
bool InImportedModule
Definition: DWARFLinker.cpp:263
llvm::dwarf::Tag
Tag
Definition: Dwarf.h:104
llvm::DWARFDie::children
iterator_range< iterator > children() const
Definition: DWARFDie.h:389
llvm::consumeError
void consumeError(Error Err)
Consume a Error without doing anything.
Definition: Error.h:1045
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:288
llvm::dwarf::Attribute
Attribute
Attributes.
Definition: Dwarf.h:124
llvm::shouldSkipAttribute
static bool shouldSkipAttribute(DWARFAbbreviationDeclaration::AttributeSpec AttrSpec, uint16_t Tag, bool InDebugMap, bool SkipPC, bool InFunctionScope)
Definition: DWARFLinker.cpp:1307
llvm::HighlightColor::Warning
@ Warning
Context
ManagedStatic< detail::RecordContext > Context
Definition: Record.cpp:96
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:457
llvm::DwarfEmitter::emitPaperTrailWarningsDie
virtual void emitPaperTrailWarningsDie(DIE &Die)=0
Emit DIE containing warnings.
LHS
Value * LHS
Definition: X86PartialReduction.cpp:73
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:250
llvm::ContextWorklistItem
This class represents an item in the work list.
Definition: DWARFLinker.cpp:255
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:136
llvm::RangesTy
std::map< uint64_t, ObjFileAddressRange > RangesTy
Map LowPC to ObjFileAddressRange.
Definition: DWARFLinker.h:49
llvm::DIDumpOptions::Verbose
bool Verbose
Definition: DIContext.h:191
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:886
llvm::ContextWorklistItem::OtherInfo
CompileUnit::DIEInfo * OtherInfo
Definition: DWARFLinker.cpp:259
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
NonRelocatableStringpool.h
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:274
llvm::dwarf::DW_FLAG_type_implementation
@ DW_FLAG_type_implementation
Definition: Dwarf.h:517
llvm::AccelTableKind::Apple
@ Apple
.apple_names, .apple_namespaces, .apple_types, .apple_objc.
DWARFSection.h
llvm::DebugInfoSize
Hold the input and output of the debug info size in bytes.
Definition: DWARFLinker.cpp:38
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:142
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:191
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:182
llvm::StripTemplateParameters
static Optional< StringRef > StripTemplateParameters(StringRef Name)
Definition: DWARFLinker.cpp:139
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:316
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:202
llvm::DWARFFormValue
Definition: DWARFFormValue.h:26
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:74
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:44
FormatVariadic.h
llvm::StringRef::str
LLVM_NODISCARD std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:244
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:108
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:145
DWARFLinker.h
ThreadPool.h
llvm::Optional::getValueOr
constexpr T getValueOr(U &&value) const LLVM_LVALUE_FUNCTION
Definition: Optional.h:298
llvm::RISCVFenceField::O
@ O
Definition: RISCVBaseInfo.h:206
llvm::DINameKind::ShortName
@ ShortName
llvm::StringRef::empty
constexpr LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:152
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:79
llvm::ContextWorklistItemType::UpdateChildPruning
@ UpdateChildPruning
llvm::ContextWorklistItem::Die
DWARFDie Die
Definition: DWARFLinker.cpp:256
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:86
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:821
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:31
llvm::DebugInfoSize::Output
uint64_t Output
Definition: DWARFLinker.cpp:40
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
function
print Print MemDeps of function
Definition: MemDepPrinter.cpp:83
llvm::getDwoId
static uint64_t getDwoId(const DWARFDie &CUDie, const DWARFUnit &Unit)
Definition: DWARFLinker.cpp:1975
llvm::dieNeedsChildrenToBeMeaningful
static bool dieNeedsChildrenToBeMeaningful(uint32_t Tag)
Definition: DWARFLinker.cpp:393
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:1603
Triple.h
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:175
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:57
llvm::DWARFLinker::addObjectFile
void addObjectFile(DWARFFile &File)
Add object file to be linked.
Definition: DWARFLinker.cpp:2314
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:134
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:51
uint32_t
llvm::append_range
void append_range(Container &C, Range &&R)
Wrapper function to append a range to a container.
Definition: STLExtras.h:1846
DWARF2_LINE_DEFAULT_IS_STMT
#define DWARF2_LINE_DEFAULT_IS_STMT
Definition: MCDwarf.h:104
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:208
llvm::DwarfEmitter::~DwarfEmitter
virtual ~DwarfEmitter()
Definition: DWARFLinker.cpp:137
llvm::DWARFLinker::link
bool link()
Link debug info for added objFiles.
Definition: DWARFLinker.cpp:2321
llvm::DWARFFile
this class represents DWARF information for source file and it`s address map.
Definition: DWARFLinker.h:214
llvm::DWARFAttribute::mayHaveLocationExpr
static bool mayHaveLocationExpr(dwarf::Attribute Attr)
Identifies DWARF attributes that may contain a reference to a DWARF expression.
Definition: DWARFDie.cpp:1235
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:299
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:1797
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:52
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::AMDGPU::SendMsg::Op
Op
Definition: SIDefines.h:325
llvm::DwarfEmitter::emitSectionContents
virtual void emitSectionContents(StringRef SecData, StringRef SecName)=0
Emit section named SecName with data SecData.
llvm::DWARFUnit
Definition: DWARFUnit.h:203
DataExtractor.h
llvm::AccelTableKind::Default
@ Default
Dwarf for DWARF5 or later, Apple otherwise.
llvm::sort
void sort(IteratorTy Start, IteratorTy End)
Definition: STLExtras.h:1590
llvm::TargetStackID::Value
Value
Definition: TargetFrameLowering.h:27
llvm::isTypeTag
static bool isTypeTag(uint16_t Tag)
Definition: DWARFLinker.cpp:100
llvm::SmallString::str
StringRef str() const
Explicit conversion to StringRef.
Definition: SmallString.h:259
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:223
llvm::remapPath
static std::string remapPath(StringRef Path, const objectPrefixMap &ObjectPrefixMap)
Definition: DWARFLinker.cpp:1983
llvm::ContextWorklistItemType
ContextWorklistItemType
The distinct types of work performed by the work loop in analyzeContextInfo.
Definition: DWARFLinker.cpp:246
OutputBuffer
Definition: Utility.h:27
llvm::ThreadPool::wait
void wait()
Blocking wait for all the threads to complete and the queue to be empty.
Definition: ThreadPool.cpp:73
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:578
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:497
llvm::DWARFFormValue::isFormClass
bool isFormClass(FormClass FC) const
Definition: DWARFFormValue.cpp:212
DWARFLinkerDeclContext.h
llvm::object::SectionedAddress
Definition: ObjectFile.h:143
llvm::ContextWorklistItem::Type
ContextWorklistItemType Type
Definition: DWARFLinker.cpp:262
llvm::DwarfEmitter::emitAppleTypes
virtual void emitAppleTypes(AccelTable< AppleAccelTableStaticTypeData > &Table)=0
Emit Apple type accelerator table.
llvm::max
Align max(MaybeAlign Lhs, Align Rhs)
Definition: Alignment.h:340
LLVM_LIKELY
#define LLVM_LIKELY(EXPR)
Definition: Compiler.h:229
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:270
llvm::ContextWorklistItemType::UpdatePruning
@ UpdatePruning
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:265
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:407
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:230
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:700
CU
Definition: AArch64AsmBackend.cpp:504
llvm::DwarfEmitter::emitAppleNamespaces
virtual void emitAppleNamespaces(AccelTable< AppleAccelTableStaticOffsetData > &Table)=0
Emit Apple namespaces accelerator table.
File
Instrumentation for Order File
Definition: InstrOrderFile.cpp:205
llvm::updatePruning
static bool updatePruning(const DWARFDie &Die, CompileUnit &CU, uint64_t ModulesEndOffset)
Definition: DWARFLinker.cpp:277
llvm::DebugInfoSize::Input
uint64_t Input
Definition: DWARFLinker.cpp:39
llvm::codeview::DebugSubsectionKind::FrameData
@ FrameData
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:629
llvm::DIDumpOptions
Container for dump options that control which debug information will be dumped.
Definition: DIContext.h:180
llvm::objectPrefixMap
std::map< std::string, std::string > objectPrefixMap
Definition: DWARFLinker.h:238
llvm::DwarfEmitter::emitAppleObjc
virtual void emitAppleObjc(AccelTable< AppleAccelTableStaticOffsetData > &Table)=0
Emit Apple Objective-C accelerator table.