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
9#include "llvm/DWARFLinker/Classic/DWARFLinker.h"
10#include "llvm/ADT/ArrayRef.h"
11#include "llvm/ADT/BitVector.h"
12#include "llvm/ADT/STLExtras.h"
13#include "llvm/ADT/StringExtras.h"
14#include "llvm/CodeGen/NonRelocatableStringpool.h"
15#include "llvm/DWARFLinker/Classic/DWARFLinkerDeclContext.h"
16#include "llvm/DWARFLinker/Classic/DWARFStreamer.h"
17#include "llvm/DWARFLinker/Utils.h"
18#include "llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h"
19#include "llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h"
20#include "llvm/DebugInfo/DWARF/DWARFContext.h"
21#include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
22#include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
23#include "llvm/DebugInfo/DWARF/DWARFDebugMacro.h"
24#include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
25#include "llvm/DebugInfo/DWARF/DWARFDie.h"
26#include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
27#include "llvm/DebugInfo/DWARF/DWARFSection.h"
28#include "llvm/DebugInfo/DWARF/DWARFUnit.h"
29#include "llvm/DebugInfo/DWARF/LowLevel/DWARFExpression.h"
30#include "llvm/MC/MCDwarf.h"
31#include "llvm/Support/DataExtractor.h"
32#include "llvm/Support/Error.h"
33#include "llvm/Support/ErrorHandling.h"
34#include "llvm/Support/ErrorOr.h"
35#include "llvm/Support/FormatVariadic.h"
36#include "llvm/Support/LEB128.h"
37#include "llvm/Support/Path.h"
38#include "llvm/Support/ThreadPool.h"
39#include <vector>
40
41namespace llvm {
42
43using namespace dwarf_linker;
44using namespace dwarf_linker::classic;
45
46/// Hold the input and output of the debug info size in bytes.
47struct DebugInfoSize {
48 uint64_t Input;
49 uint64_t Output;
50};
51
52/// Compute the total size of the debug info.
53static uint64_t getDebugInfoSize(DWARFContext &Dwarf) {
54 uint64_t Size = 0;
55 for (auto &Unit : Dwarf.compile_units()) {
56 Size += Unit->getLength();
57 }
58 return Size;
59}
60
61/// Similar to DWARFUnitSection::getUnitForOffset(), but returning our
62/// CompileUnit object instead.
63static CompileUnit *getUnitForOffset(const UnitListTy &Units, uint64_t Offset) {
64 auto CU = llvm::upper_bound(
65 Range: Units, Value&: Offset, C: [](uint64_t LHS, const std::unique_ptr<CompileUnit> &RHS) {
66 return LHS < RHS->getOrigUnit().getNextUnitOffset();
67 });
68 return CU != Units.end() ? CU->get() : nullptr;
69}
70
71/// Resolve the DIE attribute reference that has been extracted in \p RefValue.
72/// The resulting DIE might be in another CompileUnit which is stored into \p
73/// ReferencedCU. \returns null if resolving fails for any reason.
74DWARFDie DWARFLinker::resolveDIEReference(const DWARFFile &File,
75 const UnitListTy &Units,
76 const DWARFFormValue &RefValue,
77 const DWARFDie &DIE,
78 CompileUnit *&RefCU) {
79 assert(RefValue.isFormClass(DWARFFormValue::FC_Reference));
80 uint64_t RefOffset;
81 if (std::optional<uint64_t> Off = RefValue.getAsRelativeReference()) {
82 RefOffset = RefValue.getUnit()->getOffset() + *Off;
83 } else if (Off = RefValue.getAsDebugInfoReference(); Off) {
84 RefOffset = *Off;
85 } else {
86 reportWarning(Warning: "Unsupported reference type", File, DIE: &DIE);
87 return DWARFDie();
88 }
89 if ((RefCU = getUnitForOffset(Units, Offset: RefOffset)))
90 if (const auto RefDie = RefCU->getOrigUnit().getDIEForOffset(Offset: RefOffset)) {
91 // In a file with broken references, an attribute might point to a NULL
92 // DIE.
93 if (!RefDie.isNULL())
94 return RefDie;
95 }
96
97 reportWarning(Warning: "could not find referenced DIE", File, DIE: &DIE);
98 return DWARFDie();
99}
100
101/// \returns whether the passed \a Attr type might contain a DIE reference
102/// suitable for ODR uniquing.
103static bool isODRAttribute(uint16_t Attr) {
104 switch (Attr) {
105 default:
106 return false;
107 case dwarf::DW_AT_type:
108 case dwarf::DW_AT_containing_type:
109 case dwarf::DW_AT_specification:
110 case dwarf::DW_AT_abstract_origin:
111 case dwarf::DW_AT_import:
112 return true;
113 }
114 llvm_unreachable("Improper attribute.");
115}
116
117static bool isTypeTag(uint16_t Tag) {
118 switch (Tag) {
119 case dwarf::DW_TAG_array_type:
120 case dwarf::DW_TAG_class_type:
121 case dwarf::DW_TAG_enumeration_type:
122 case dwarf::DW_TAG_pointer_type:
123 case dwarf::DW_TAG_reference_type:
124 case dwarf::DW_TAG_string_type:
125 case dwarf::DW_TAG_structure_type:
126 case dwarf::DW_TAG_subroutine_type:
127 case dwarf::DW_TAG_template_alias:
128 case dwarf::DW_TAG_typedef:
129 case dwarf::DW_TAG_union_type:
130 case dwarf::DW_TAG_ptr_to_member_type:
131 case dwarf::DW_TAG_set_type:
132 case dwarf::DW_TAG_subrange_type:
133 case dwarf::DW_TAG_base_type:
134 case dwarf::DW_TAG_const_type:
135 case dwarf::DW_TAG_constant:
136 case dwarf::DW_TAG_file_type:
137 case dwarf::DW_TAG_namelist:
138 case dwarf::DW_TAG_packed_type:
139 case dwarf::DW_TAG_volatile_type:
140 case dwarf::DW_TAG_restrict_type:
141 case dwarf::DW_TAG_atomic_type:
142 case dwarf::DW_TAG_interface_type:
143 case dwarf::DW_TAG_unspecified_type:
144 case dwarf::DW_TAG_shared_type:
145 case dwarf::DW_TAG_immutable_type:
146 return true;
147 default:
148 break;
149 }
150 return false;
151}
152
153bool DWARFLinker::DIECloner::getDIENames(const DWARFDie &Die,
154 AttributesInfo &Info,
155 OffsetsStringPool &StringPool,
156 bool StripTemplate) {
157 // This function will be called on DIEs having low_pcs and
158 // ranges. As getting the name might be more expansive, filter out
159 // blocks directly.
160 if (Die.getTag() == dwarf::DW_TAG_lexical_block)
161 return false;
162
163 if (!Info.MangledName)
164 if (const char *MangledName = Die.getLinkageName())
165 Info.MangledName = StringPool.getEntry(S: MangledName);
166
167 if (!Info.Name)
168 if (const char *Name = Die.getShortName())
169 Info.Name = StringPool.getEntry(S: Name);
170
171 if (!Info.MangledName)
172 Info.MangledName = Info.Name;
173
174 if (StripTemplate && Info.Name && Info.MangledName != Info.Name) {
175 StringRef Name = Info.Name.getString();
176 if (std::optional<StringRef> StrippedName = StripTemplateParameters(Name))
177 Info.NameWithoutTemplate = StringPool.getEntry(S: *StrippedName);
178 }
179
180 return Info.Name || Info.MangledName;
181}
182
183/// Resolve the relative path to a build artifact referenced by DWARF by
184/// applying DW_AT_comp_dir.
185static void resolveRelativeObjectPath(SmallVectorImpl<char> &Buf, DWARFDie CU) {
186 sys::path::append(path&: Buf, a: dwarf::toString(V: CU.find(Attr: dwarf::DW_AT_comp_dir), Default: ""));
187}
188
189/// Collect references to parseable Swift interfaces in imported
190/// DW_TAG_module blocks.
191static void analyzeImportedModule(
192 const DWARFDie &DIE, CompileUnit &CU,
193 DWARFLinkerBase::SwiftInterfacesMapTy *ParseableSwiftInterfaces,
194 std::function<void(const Twine &, const DWARFDie &)> ReportWarning) {
195 if (CU.getLanguage() != dwarf::DW_LANG_Swift)
196 return;
197
198 if (!ParseableSwiftInterfaces)
199 return;
200
201 StringRef Path = dwarf::toStringRef(V: DIE.find(Attr: dwarf::DW_AT_LLVM_include_path));
202 if (!Path.ends_with(Suffix: ".swiftinterface"))
203 return;
204 // Don't track interfaces that are part of the SDK.
205 StringRef SysRoot = dwarf::toStringRef(V: DIE.find(Attr: dwarf::DW_AT_LLVM_sysroot));
206 if (SysRoot.empty())
207 SysRoot = CU.getSysRoot();
208 if (!SysRoot.empty() && Path.starts_with(Prefix: SysRoot))
209 return;
210 // Don't track interfaces that are part of the toolchain.
211 // For example: Swift, _Concurrency, ...
212 StringRef DeveloperDir = guessDeveloperDir(SysRoot);
213 if (!DeveloperDir.empty() && Path.starts_with(Prefix: DeveloperDir))
214 return;
215 if (isInToolchainDir(Path))
216 return;
217 std::optional<const char *> Name =
218 dwarf::toString(V: DIE.find(Attr: dwarf::DW_AT_name));
219 if (!Name)
220 return;
221 auto &Entry = (*ParseableSwiftInterfaces)[*Name];
222 // The prepend path is applied later when copying.
223 DWARFDie CUDie = CU.getOrigUnit().getUnitDIE();
224 SmallString<128> ResolvedPath;
225 if (sys::path::is_relative(path: Path))
226 resolveRelativeObjectPath(Buf&: ResolvedPath, CU: CUDie);
227 sys::path::append(path&: ResolvedPath, a: Path);
228 if (!Entry.empty() && Entry != ResolvedPath)
229 ReportWarning(Twine("Conflicting parseable interfaces for Swift Module ") +
230 *Name + ": " + Entry + " and " + Path,
231 DIE);
232 Entry = std::string(ResolvedPath);
233}
234
235/// The distinct types of work performed by the work loop in
236/// analyzeContextInfo.
237enum class ContextWorklistItemType : uint8_t {
238 AnalyzeContextInfo,
239 UpdateChildPruning,
240 UpdatePruning,
241};
242
243/// This class represents an item in the work list. The type defines what kind
244/// of work needs to be performed when processing the current item. Everything
245/// but the Type and Die fields are optional based on the type.
246struct ContextWorklistItem {
247 DWARFDie Die;
248 unsigned ParentIdx;
249 union {
250 CompileUnit::DIEInfo *OtherInfo;
251 DeclContext *Context;
252 };
253 ContextWorklistItemType Type;
254 bool InImportedModule;
255
256 ContextWorklistItem(DWARFDie Die, ContextWorklistItemType T,
257 CompileUnit::DIEInfo *OtherInfo = nullptr)
258 : Die(Die), ParentIdx(0), OtherInfo(OtherInfo), Type(T),
259 InImportedModule(false) {}
260
261 ContextWorklistItem(DWARFDie Die, DeclContext *Context, unsigned ParentIdx,
262 bool InImportedModule)
263 : Die(Die), ParentIdx(ParentIdx), Context(Context),
264 Type(ContextWorklistItemType::AnalyzeContextInfo),
265 InImportedModule(InImportedModule) {}
266};
267
268static bool updatePruning(const DWARFDie &Die, CompileUnit &CU,
269 uint64_t ModulesEndOffset) {
270 CompileUnit::DIEInfo &Info = CU.getInfo(Die);
271
272 // Prune this DIE if it is either a forward declaration inside a
273 // DW_TAG_module or a DW_TAG_module that contains nothing but
274 // forward declarations.
275 Info.Prune &= (Die.getTag() == dwarf::DW_TAG_module) ||
276 (isTypeTag(Tag: Die.getTag()) &&
277 dwarf::toUnsigned(V: Die.find(Attr: dwarf::DW_AT_declaration), Default: 0));
278
279 // Only prune forward declarations inside a DW_TAG_module for which a
280 // definition exists elsewhere.
281 if (ModulesEndOffset == 0)
282 Info.Prune &= Info.Ctxt && Info.Ctxt->getCanonicalDIEOffset();
283 else
284 Info.Prune &= Info.Ctxt && Info.Ctxt->getCanonicalDIEOffset() > 0 &&
285 Info.Ctxt->getCanonicalDIEOffset() <= ModulesEndOffset;
286
287 return Info.Prune;
288}
289
290static void updateChildPruning(const DWARFDie &Die, CompileUnit &CU,
291 CompileUnit::DIEInfo &ChildInfo) {
292 CompileUnit::DIEInfo &Info = CU.getInfo(Die);
293 Info.Prune &= ChildInfo.Prune;
294}
295
296/// Recursive helper to build the global DeclContext information and
297/// gather the child->parent relationships in the original compile unit.
298///
299/// This function uses the same work list approach as lookForDIEsToKeep.
300///
301/// \return true when this DIE and all of its children are only
302/// forward declarations to types defined in external clang modules
303/// (i.e., forward declarations that are children of a DW_TAG_module).
304static void analyzeContextInfo(
305 const DWARFDie &DIE, unsigned ParentIdx, CompileUnit &CU,
306 DeclContext *CurrentDeclContext, DeclContextTree &Contexts,
307 uint64_t ModulesEndOffset,
308 DWARFLinkerBase::SwiftInterfacesMapTy *ParseableSwiftInterfaces,
309 std::function<void(const Twine &, const DWARFDie &)> ReportWarning) {
310 // LIFO work list.
311 std::vector<ContextWorklistItem> Worklist;
312 Worklist.emplace_back(args: DIE, args&: CurrentDeclContext, args&: ParentIdx, args: false);
313
314 while (!Worklist.empty()) {
315 ContextWorklistItem Current = Worklist.back();
316 Worklist.pop_back();
317
318 switch (Current.Type) {
319 case ContextWorklistItemType::UpdatePruning:
320 updatePruning(Die: Current.Die, CU, ModulesEndOffset);
321 continue;
322 case ContextWorklistItemType::UpdateChildPruning:
323 updateChildPruning(Die: Current.Die, CU, ChildInfo&: *Current.OtherInfo);
324 continue;
325 case ContextWorklistItemType::AnalyzeContextInfo:
326 break;
327 }
328
329 unsigned Idx = CU.getOrigUnit().getDIEIndex(D: Current.Die);
330 CompileUnit::DIEInfo &Info = CU.getInfo(Idx);
331
332 // Clang imposes an ODR on modules(!) regardless of the language:
333 // "The module-id should consist of only a single identifier,
334 // which provides the name of the module being defined. Each
335 // module shall have a single definition."
336 //
337 // This does not extend to the types inside the modules:
338 // "[I]n C, this implies that if two structs are defined in
339 // different submodules with the same name, those two types are
340 // distinct types (but may be compatible types if their
341 // definitions match)."
342 //
343 // We treat non-C++ modules like namespaces for this reason.
344 if (Current.Die.getTag() == dwarf::DW_TAG_module &&
345 Current.ParentIdx == 0 &&
346 dwarf::toString(V: Current.Die.find(Attr: dwarf::DW_AT_name), Default: "") !=
347 CU.getClangModuleName()) {
348 Current.InImportedModule = true;
349 analyzeImportedModule(DIE: Current.Die, CU, ParseableSwiftInterfaces,
350 ReportWarning);
351 }
352
353 Info.ParentIdx = Current.ParentIdx;
354 Info.InModuleScope = CU.isClangModule() || Current.InImportedModule;
355 if (CU.hasODR() || Info.InModuleScope) {
356 if (Current.Context) {
357 auto PtrInvalidPair = Contexts.getChildDeclContext(
358 Context&: *Current.Context, DIE: Current.Die, Unit&: CU, InClangModule: Info.InModuleScope);
359 Current.Context = PtrInvalidPair.getPointer();
360 Info.Ctxt =
361 PtrInvalidPair.getInt() ? nullptr : PtrInvalidPair.getPointer();
362 if (Info.Ctxt)
363 Info.Ctxt->setDefinedInClangModule(Info.InModuleScope);
364 } else
365 Info.Ctxt = Current.Context = nullptr;
366 }
367
368 Info.Prune = Current.InImportedModule;
369 // Add children in reverse order to the worklist to effectively process
370 // them in order.
371 Worklist.emplace_back(args&: Current.Die, args: ContextWorklistItemType::UpdatePruning);
372 for (auto Child : reverse(C: Current.Die.children())) {
373 CompileUnit::DIEInfo &ChildInfo = CU.getInfo(Die: Child);
374 Worklist.emplace_back(
375 args&: Current.Die, args: ContextWorklistItemType::UpdateChildPruning, args: &ChildInfo);
376 Worklist.emplace_back(args&: Child, args&: Current.Context, args&: Idx,
377 args&: Current.InImportedModule);
378 }
379 }
380}
381
382static bool dieNeedsChildrenToBeMeaningful(uint32_t Tag) {
383 switch (Tag) {
384 default:
385 return false;
386 case dwarf::DW_TAG_class_type:
387 case dwarf::DW_TAG_common_block:
388 case dwarf::DW_TAG_lexical_block:
389 case dwarf::DW_TAG_structure_type:
390 case dwarf::DW_TAG_subprogram:
391 case dwarf::DW_TAG_subroutine_type:
392 case dwarf::DW_TAG_union_type:
393 return true;
394 }
395 llvm_unreachable("Invalid Tag");
396}
397
398void DWARFLinker::cleanupAuxiliarryData(LinkContext &Context) {
399 Context.clear();
400
401 for (DIEBlock *I : DIEBlocks)
402 I->~DIEBlock();
403 for (DIELoc *I : DIELocs)
404 I->~DIELoc();
405
406 DIEBlocks.clear();
407 DIELocs.clear();
408 DIEAlloc.Reset();
409}
410
411static bool isTlsAddressCode(uint8_t DW_OP_Code) {
412 return DW_OP_Code == dwarf::DW_OP_form_tls_address ||
413 DW_OP_Code == dwarf::DW_OP_GNU_push_tls_address;
414}
415
416std::pair<bool, std::optional<int64_t>>
417DWARFLinker::getVariableRelocAdjustment(AddressesMap &RelocMgr,
418 const DWARFDie &DIE) {
419 assert((DIE.getTag() == dwarf::DW_TAG_variable ||
420 DIE.getTag() == dwarf::DW_TAG_constant) &&
421 "Wrong type of input die");
422
423 const auto *Abbrev = DIE.getAbbreviationDeclarationPtr();
424
425 // Check if DIE has DW_AT_location attribute.
426 DWARFUnit *U = DIE.getDwarfUnit();
427 std::optional<uint32_t> LocationIdx =
428 Abbrev->findAttributeIndex(attr: dwarf::DW_AT_location);
429 if (!LocationIdx)
430 return std::make_pair(x: false, y: std::nullopt);
431
432 // Get offset to the DW_AT_location attribute.
433 uint64_t AttrOffset =
434 Abbrev->getAttributeOffsetFromIndex(AttrIndex: *LocationIdx, DIEOffset: DIE.getOffset(), U: *U);
435
436 // Get value of the DW_AT_location attribute.
437 std::optional<DWARFFormValue> LocationValue =
438 Abbrev->getAttributeValueFromOffset(AttrIndex: *LocationIdx, Offset: AttrOffset, U: *U);
439 if (!LocationValue)
440 return std::make_pair(x: false, y: std::nullopt);
441
442 // Check that DW_AT_location attribute is of 'exprloc' class.
443 // Handling value of location expressions for attributes of 'loclist'
444 // class is not implemented yet.
445 std::optional<ArrayRef<uint8_t>> Expr = LocationValue->getAsBlock();
446 if (!Expr)
447 return std::make_pair(x: false, y: std::nullopt);
448
449 // Parse 'exprloc' expression.
450 DataExtractor Data(toStringRef(Input: *Expr), U->getContext().isLittleEndian(),
451 U->getAddressByteSize());
452 DWARFExpression Expression(Data, U->getAddressByteSize(),
453 U->getFormParams().Format);
454
455 bool HasLocationAddress = false;
456 uint64_t CurExprOffset = 0;
457 for (DWARFExpression::iterator It = Expression.begin();
458 It != Expression.end(); ++It) {
459 DWARFExpression::iterator NextIt = It;
460 ++NextIt;
461
462 const DWARFExpression::Operation &Op = *It;
463 switch (Op.getCode()) {
464 case dwarf::DW_OP_const2u:
465 case dwarf::DW_OP_const4u:
466 case dwarf::DW_OP_const8u:
467 case dwarf::DW_OP_const2s:
468 case dwarf::DW_OP_const4s:
469 case dwarf::DW_OP_const8s:
470 if (NextIt == Expression.end() || !isTlsAddressCode(DW_OP_Code: NextIt->getCode()))
471 break;
472 [[fallthrough]];
473 case dwarf::DW_OP_addr: {
474 HasLocationAddress = true;
475 // Check relocation for the address.
476 if (std::optional<int64_t> RelocAdjustment =
477 RelocMgr.getExprOpAddressRelocAdjustment(
478 U&: *U, Op, StartOffset: AttrOffset + CurExprOffset,
479 EndOffset: AttrOffset + Op.getEndOffset(), Verbose: Options.Verbose))
480 return std::make_pair(x&: HasLocationAddress, y&: *RelocAdjustment);
481 } break;
482 case dwarf::DW_OP_constx:
483 case dwarf::DW_OP_addrx: {
484 HasLocationAddress = true;
485 if (std::optional<uint64_t> AddressOffset =
486 DIE.getDwarfUnit()->getIndexedAddressOffset(
487 Index: Op.getRawOperand(Idx: 0))) {
488 // Check relocation for the address.
489 if (std::optional<int64_t> RelocAdjustment =
490 RelocMgr.getExprOpAddressRelocAdjustment(
491 U&: *U, Op, StartOffset: *AddressOffset,
492 EndOffset: *AddressOffset + DIE.getDwarfUnit()->getAddressByteSize(),
493 Verbose: Options.Verbose))
494 return std::make_pair(x&: HasLocationAddress, y&: *RelocAdjustment);
495 }
496 } break;
497 default: {
498 // Nothing to do.
499 } break;
500 }
501 CurExprOffset = Op.getEndOffset();
502 }
503
504 return std::make_pair(x&: HasLocationAddress, y: std::nullopt);
505}
506
507/// Check if a variable describing DIE should be kept.
508/// \returns updated TraversalFlags.
509unsigned DWARFLinker::shouldKeepVariableDIE(AddressesMap &RelocMgr,
510 const DWARFDie &DIE,
511 CompileUnit::DIEInfo &MyInfo,
512 unsigned Flags) {
513 const auto *Abbrev = DIE.getAbbreviationDeclarationPtr();
514
515 // Global variables with constant value can always be kept.
516 if (!(Flags & TF_InFunctionScope) &&
517 Abbrev->findAttributeIndex(attr: dwarf::DW_AT_const_value)) {
518 MyInfo.InDebugMap = true;
519 return Flags | TF_Keep;
520 }
521
522 // See if there is a relocation to a valid debug map entry inside this
523 // variable's location. The order is important here. We want to always check
524 // if the variable has a valid relocation, so that the DIEInfo is filled.
525 // However, we don't want a static variable in a function to force us to keep
526 // the enclosing function, unless requested explicitly.
527 std::pair<bool, std::optional<int64_t>> LocExprAddrAndRelocAdjustment =
528 getVariableRelocAdjustment(RelocMgr, DIE);
529
530 if (LocExprAddrAndRelocAdjustment.first)
531 MyInfo.HasLocationExpressionAddr = true;
532
533 if (!LocExprAddrAndRelocAdjustment.second)
534 return Flags;
535
536 MyInfo.AddrAdjust = *LocExprAddrAndRelocAdjustment.second;
537 MyInfo.InDebugMap = true;
538
539 if (((Flags & TF_InFunctionScope) &&
540 !LLVM_UNLIKELY(Options.KeepFunctionForStatic)))
541 return Flags;
542
543 if (Options.Verbose) {
544 outs() << "Keeping variable DIE:";
545 DIDumpOptions DumpOpts;
546 DumpOpts.ChildRecurseDepth = 0;
547 DumpOpts.Verbose = Options.Verbose;
548 DIE.dump(OS&: outs(), indent: 8 /* Indent */, DumpOpts);
549 }
550
551 return Flags | TF_Keep;
552}
553
554/// Check if a function describing DIE should be kept.
555/// \returns updated TraversalFlags.
556unsigned DWARFLinker::shouldKeepSubprogramDIE(
557 AddressesMap &RelocMgr, const DWARFDie &DIE, const DWARFFile &File,
558 CompileUnit &Unit, CompileUnit::DIEInfo &MyInfo, unsigned Flags) {
559 Flags |= TF_InFunctionScope;
560
561 auto LowPc = dwarf::toAddress(V: DIE.find(Attr: dwarf::DW_AT_low_pc));
562 if (!LowPc)
563 return Flags;
564
565 assert(LowPc && "low_pc attribute is not an address.");
566 std::optional<int64_t> RelocAdjustment =
567 RelocMgr.getSubprogramRelocAdjustment(DIE, Verbose: Options.Verbose);
568 if (!RelocAdjustment)
569 return Flags;
570
571 MyInfo.AddrAdjust = *RelocAdjustment;
572 MyInfo.InDebugMap = true;
573
574 if (Options.Verbose) {
575 outs() << "Keeping subprogram DIE:";
576 DIDumpOptions DumpOpts;
577 DumpOpts.ChildRecurseDepth = 0;
578 DumpOpts.Verbose = Options.Verbose;
579 DIE.dump(OS&: outs(), indent: 8 /* Indent */, DumpOpts);
580 }
581
582 if (DIE.getTag() == dwarf::DW_TAG_label) {
583 if (Unit.hasLabelAt(Addr: *LowPc))
584 return Flags;
585
586 DWARFUnit &OrigUnit = Unit.getOrigUnit();
587 // FIXME: dsymutil-classic compat. dsymutil-classic doesn't consider labels
588 // that don't fall into the CU's aranges. This is wrong IMO. Debug info
589 // generation bugs aside, this is really wrong in the case of labels, where
590 // a label marking the end of a function will have a PC == CU's high_pc.
591 if (dwarf::toAddress(V: OrigUnit.getUnitDIE().find(Attr: dwarf::DW_AT_high_pc))
592 .value_or(UINT64_MAX) <= LowPc)
593 return Flags;
594 Unit.addLabelLowPc(LabelLowPc: *LowPc, PcOffset: MyInfo.AddrAdjust);
595 return Flags | TF_Keep;
596 }
597
598 Flags |= TF_Keep;
599
600 std::optional<uint64_t> HighPc = DIE.getHighPC(LowPC: *LowPc);
601 if (!HighPc) {
602 reportWarning(Warning: "Function without high_pc. Range will be discarded.\n", File,
603 DIE: &DIE);
604 return Flags;
605 }
606 if (*LowPc > *HighPc) {
607 reportWarning(Warning: "low_pc greater than high_pc. Range will be discarded.\n",
608 File, DIE: &DIE);
609 return Flags;
610 }
611
612 // Replace the debug map range with a more accurate one.
613 Unit.addFunctionRange(LowPC: *LowPc, HighPC: *HighPc, PCOffset: MyInfo.AddrAdjust);
614 return Flags;
615}
616
617/// Check if a DIE should be kept.
618/// \returns updated TraversalFlags.
619unsigned DWARFLinker::shouldKeepDIE(AddressesMap &RelocMgr, const DWARFDie &DIE,
620 const DWARFFile &File, CompileUnit &Unit,
621 CompileUnit::DIEInfo &MyInfo,
622 unsigned Flags) {
623 switch (DIE.getTag()) {
624 case dwarf::DW_TAG_constant:
625 case dwarf::DW_TAG_variable:
626 return shouldKeepVariableDIE(RelocMgr, DIE, MyInfo, Flags);
627 case dwarf::DW_TAG_subprogram:
628 case dwarf::DW_TAG_label:
629 return shouldKeepSubprogramDIE(RelocMgr, DIE, File, Unit, MyInfo, Flags);
630 case dwarf::DW_TAG_base_type:
631 // DWARF Expressions may reference basic types, but scanning them
632 // is expensive. Basic types are tiny, so just keep all of them.
633 case dwarf::DW_TAG_imported_module:
634 case dwarf::DW_TAG_imported_declaration:
635 case dwarf::DW_TAG_imported_unit:
636 // We always want to keep these.
637 return Flags | TF_Keep;
638 default:
639 break;
640 }
641
642 return Flags;
643}
644
645/// Helper that updates the completeness of the current DIE based on the
646/// completeness of one of its children. It depends on the incompleteness of
647/// the children already being computed.
648static void updateChildIncompleteness(const DWARFDie &Die, CompileUnit &CU,
649 CompileUnit::DIEInfo &ChildInfo) {
650 switch (Die.getTag()) {
651 case dwarf::DW_TAG_structure_type:
652 case dwarf::DW_TAG_class_type:
653 case dwarf::DW_TAG_union_type:
654 break;
655 default:
656 return;
657 }
658
659 CompileUnit::DIEInfo &MyInfo = CU.getInfo(Die);
660
661 if (ChildInfo.Incomplete || ChildInfo.Prune)
662 MyInfo.Incomplete = true;
663}
664
665/// Helper that updates the completeness of the current DIE based on the
666/// completeness of the DIEs it references. It depends on the incompleteness of
667/// the referenced DIE already being computed.
668static void updateRefIncompleteness(const DWARFDie &Die, CompileUnit &CU,
669 CompileUnit::DIEInfo &RefInfo) {
670 switch (Die.getTag()) {
671 case dwarf::DW_TAG_typedef:
672 case dwarf::DW_TAG_member:
673 case dwarf::DW_TAG_reference_type:
674 case dwarf::DW_TAG_ptr_to_member_type:
675 case dwarf::DW_TAG_pointer_type:
676 break;
677 default:
678 return;
679 }
680
681 CompileUnit::DIEInfo &MyInfo = CU.getInfo(Die);
682
683 if (MyInfo.Incomplete)
684 return;
685
686 if (RefInfo.Incomplete)
687 MyInfo.Incomplete = true;
688}
689
690/// Look at the children of the given DIE and decide whether they should be
691/// kept.
692void DWARFLinker::lookForChildDIEsToKeep(
693 const DWARFDie &Die, CompileUnit &CU, unsigned Flags,
694 SmallVectorImpl<WorklistItem> &Worklist) {
695 // The TF_ParentWalk flag tells us that we are currently walking up the
696 // parent chain of a required DIE, and we don't want to mark all the children
697 // of the parents as kept (consider for example a DW_TAG_namespace node in
698 // the parent chain). There are however a set of DIE types for which we want
699 // to ignore that directive and still walk their children.
700 if (dieNeedsChildrenToBeMeaningful(Tag: Die.getTag()))
701 Flags &= ~DWARFLinker::TF_ParentWalk;
702
703 // We're finished if this DIE has no children or we're walking the parent
704 // chain.
705 if (!Die.hasChildren() || (Flags & DWARFLinker::TF_ParentWalk))
706 return;
707
708 // Add children in reverse order to the worklist to effectively process them
709 // in order.
710 for (auto Child : reverse(C: Die.children())) {
711 // Add a worklist item before every child to calculate incompleteness right
712 // after the current child is processed.
713 CompileUnit::DIEInfo &ChildInfo = CU.getInfo(Die: Child);
714 Worklist.emplace_back(Args: Die, Args&: CU, Args: WorklistItemType::UpdateChildIncompleteness,
715 Args: &ChildInfo);
716 Worklist.emplace_back(Args&: Child, Args&: CU, Args&: Flags);
717 }
718}
719
720static bool isODRCanonicalCandidate(const DWARFDie &Die, CompileUnit &CU) {
721 CompileUnit::DIEInfo &Info = CU.getInfo(Die);
722
723 if (!Info.Ctxt || (Die.getTag() == dwarf::DW_TAG_namespace))
724 return false;
725
726 if (!CU.hasODR() && !Info.InModuleScope)
727 return false;
728
729 return !Info.Incomplete && Info.Ctxt != CU.getInfo(Idx: Info.ParentIdx).Ctxt;
730}
731
732void DWARFLinker::markODRCanonicalDie(const DWARFDie &Die, CompileUnit &CU) {
733 CompileUnit::DIEInfo &Info = CU.getInfo(Die);
734
735 Info.ODRMarkingDone = true;
736 if (Info.Keep && isODRCanonicalCandidate(Die, CU) &&
737 !Info.Ctxt->hasCanonicalDIE())
738 Info.Ctxt->setHasCanonicalDIE();
739}
740
741/// Look at DIEs referenced by the given DIE and decide whether they should be
742/// kept. All DIEs referenced though attributes should be kept.
743void DWARFLinker::lookForRefDIEsToKeep(
744 const DWARFDie &Die, CompileUnit &CU, unsigned Flags,
745 const UnitListTy &Units, const DWARFFile &File,
746 SmallVectorImpl<WorklistItem> &Worklist) {
747 bool UseOdr = (Flags & DWARFLinker::TF_DependencyWalk)
748 ? (Flags & DWARFLinker::TF_ODR)
749 : CU.hasODR();
750 DWARFUnit &Unit = CU.getOrigUnit();
751 DWARFDataExtractor Data = Unit.getDebugInfoExtractor();
752 const auto *Abbrev = Die.getAbbreviationDeclarationPtr();
753 uint64_t Offset = Die.getOffset() + getULEB128Size(Value: Abbrev->getCode());
754
755 SmallVector<std::pair<DWARFDie, CompileUnit &>, 4> ReferencedDIEs;
756 for (const auto &AttrSpec : Abbrev->attributes()) {
757 DWARFFormValue Val(AttrSpec.Form);
758 if (!Val.isFormClass(FC: DWARFFormValue::FC_Reference) ||
759 AttrSpec.Attr == dwarf::DW_AT_sibling) {
760 DWARFFormValue::skipValue(Form: AttrSpec.Form, DebugInfoData: Data, OffsetPtr: &Offset,
761 FormParams: Unit.getFormParams());
762 continue;
763 }
764
765 Val.extractValue(Data, OffsetPtr: &Offset, FormParams: Unit.getFormParams(), U: &Unit);
766 CompileUnit *ReferencedCU;
767 if (auto RefDie =
768 resolveDIEReference(File, Units, RefValue: Val, DIE: Die, RefCU&: ReferencedCU)) {
769 CompileUnit::DIEInfo &Info = ReferencedCU->getInfo(Die: RefDie);
770 // If the referenced DIE has a DeclContext that has already been
771 // emitted, then do not keep the one in this CU. We'll link to
772 // the canonical DIE in cloneDieReferenceAttribute.
773 //
774 // FIXME: compatibility with dsymutil-classic. UseODR shouldn't
775 // be necessary and could be advantageously replaced by
776 // ReferencedCU->hasODR() && CU.hasODR().
777 //
778 // FIXME: compatibility with dsymutil-classic. There is no
779 // reason not to unique ref_addr references.
780 if (AttrSpec.Form != dwarf::DW_FORM_ref_addr &&
781 isODRAttribute(Attr: AttrSpec.Attr) && Info.Ctxt &&
782 Info.Ctxt->hasCanonicalDIE())
783 continue;
784
785 // Keep a module forward declaration if there is no definition.
786 if (!(isODRAttribute(Attr: AttrSpec.Attr) && Info.Ctxt &&
787 Info.Ctxt->hasCanonicalDIE()))
788 Info.Prune = false;
789 ReferencedDIEs.emplace_back(Args&: RefDie, Args&: *ReferencedCU);
790 }
791 }
792
793 unsigned ODRFlag = UseOdr ? DWARFLinker::TF_ODR : 0;
794
795 // Add referenced DIEs in reverse order to the worklist to effectively
796 // process them in order.
797 for (auto &P : reverse(C&: ReferencedDIEs)) {
798 // Add a worklist item before every child to calculate incompleteness right
799 // after the current child is processed.
800 CompileUnit::DIEInfo &Info = P.second.getInfo(Die: P.first);
801 Worklist.emplace_back(Args: Die, Args&: CU, Args: WorklistItemType::UpdateRefIncompleteness,
802 Args: &Info);
803 Worklist.emplace_back(Args&: P.first, Args&: P.second,
804 Args: DWARFLinker::TF_Keep |
805 DWARFLinker::TF_DependencyWalk | ODRFlag);
806 }
807}
808
809/// Look at the parent of the given DIE and decide whether they should be kept.
810void DWARFLinker::lookForParentDIEsToKeep(
811 unsigned AncestorIdx, CompileUnit &CU, unsigned Flags,
812 SmallVectorImpl<WorklistItem> &Worklist) {
813 // Stop if we encounter an ancestor that's already marked as kept.
814 if (CU.getInfo(Idx: AncestorIdx).Keep)
815 return;
816
817 DWARFUnit &Unit = CU.getOrigUnit();
818 DWARFDie ParentDIE = Unit.getDIEAtIndex(Index: AncestorIdx);
819 Worklist.emplace_back(Args&: CU.getInfo(Idx: AncestorIdx).ParentIdx, Args&: CU, Args&: Flags);
820 Worklist.emplace_back(Args&: ParentDIE, Args&: CU, Args&: Flags);
821}
822
823/// Recursively walk the \p DIE tree and look for DIEs to keep. Store that
824/// information in \p CU's DIEInfo.
825///
826/// This function is the entry point of the DIE selection algorithm. It is
827/// expected to walk the DIE tree in file order and (though the mediation of
828/// its helper) call hasValidRelocation() on each DIE that might be a 'root
829/// DIE' (See DwarfLinker class comment).
830///
831/// While walking the dependencies of root DIEs, this function is also called,
832/// but during these dependency walks the file order is not respected. The
833/// TF_DependencyWalk flag tells us which kind of traversal we are currently
834/// doing.
835///
836/// The recursive algorithm is implemented iteratively as a work list because
837/// very deep recursion could exhaust the stack for large projects. The work
838/// list acts as a scheduler for different types of work that need to be
839/// performed.
840///
841/// The recursive nature of the algorithm is simulated by running the "main"
842/// algorithm (LookForDIEsToKeep) followed by either looking at more DIEs
843/// (LookForChildDIEsToKeep, LookForRefDIEsToKeep, LookForParentDIEsToKeep) or
844/// fixing up a computed property (UpdateChildIncompleteness,
845/// UpdateRefIncompleteness).
846///
847/// The return value indicates whether the DIE is incomplete.
848void DWARFLinker::lookForDIEsToKeep(AddressesMap &AddressesMap,
849 const UnitListTy &Units,
850 const DWARFDie &Die, const DWARFFile &File,
851 CompileUnit &Cu, unsigned Flags) {
852 // LIFO work list.
853 SmallVector<WorklistItem, 4> Worklist;
854 Worklist.emplace_back(Args: Die, Args&: Cu, Args&: Flags);
855
856 while (!Worklist.empty()) {
857 WorklistItem Current = Worklist.pop_back_val();
858
859 // Look at the worklist type to decide what kind of work to perform.
860 switch (Current.Type) {
861 case WorklistItemType::UpdateChildIncompleteness:
862 updateChildIncompleteness(Die: Current.Die, CU&: Current.CU, ChildInfo&: *Current.OtherInfo);
863 continue;
864 case WorklistItemType::UpdateRefIncompleteness:
865 updateRefIncompleteness(Die: Current.Die, CU&: Current.CU, RefInfo&: *Current.OtherInfo);
866 continue;
867 case WorklistItemType::LookForChildDIEsToKeep:
868 lookForChildDIEsToKeep(Die: Current.Die, CU&: Current.CU, Flags: Current.Flags, Worklist);
869 continue;
870 case WorklistItemType::LookForRefDIEsToKeep:
871 lookForRefDIEsToKeep(Die: Current.Die, CU&: Current.CU, Flags: Current.Flags, Units, File,
872 Worklist);
873 continue;
874 case WorklistItemType::LookForParentDIEsToKeep:
875 lookForParentDIEsToKeep(AncestorIdx: Current.AncestorIdx, CU&: Current.CU, Flags: Current.Flags,
876 Worklist);
877 continue;
878 case WorklistItemType::MarkODRCanonicalDie:
879 markODRCanonicalDie(Die: Current.Die, CU&: Current.CU);
880 continue;
881 case WorklistItemType::LookForDIEsToKeep:
882 break;
883 }
884
885 unsigned Idx = Current.CU.getOrigUnit().getDIEIndex(D: Current.Die);
886 CompileUnit::DIEInfo &MyInfo = Current.CU.getInfo(Idx);
887
888 if (MyInfo.Prune) {
889 // We're walking the dependencies of a module forward declaration that was
890 // kept because there is no definition.
891 if (Current.Flags & TF_DependencyWalk)
892 MyInfo.Prune = false;
893 else
894 continue;
895 }
896
897 // If the Keep flag is set, we are marking a required DIE's dependencies.
898 // If our target is already marked as kept, we're all set.
899 bool AlreadyKept = MyInfo.Keep;
900 if ((Current.Flags & TF_DependencyWalk) && AlreadyKept)
901 continue;
902
903 if (!(Current.Flags & TF_DependencyWalk))
904 Current.Flags = shouldKeepDIE(RelocMgr&: AddressesMap, DIE: Current.Die, File, Unit&: Current.CU,
905 MyInfo, Flags: Current.Flags);
906
907 // We need to mark context for the canonical die in the end of normal
908 // traversing(not TF_DependencyWalk) or after normal traversing if die
909 // was not marked as kept.
910 if (!(Current.Flags & TF_DependencyWalk) ||
911 (MyInfo.ODRMarkingDone && !MyInfo.Keep)) {
912 if (Current.CU.hasODR() || MyInfo.InModuleScope)
913 Worklist.emplace_back(Args&: Current.Die, Args&: Current.CU,
914 Args: WorklistItemType::MarkODRCanonicalDie);
915 }
916
917 // Finish by looking for child DIEs. Because of the LIFO worklist we need
918 // to schedule that work before any subsequent items are added to the
919 // worklist.
920 Worklist.emplace_back(Args&: Current.Die, Args&: Current.CU, Args&: Current.Flags,
921 Args: WorklistItemType::LookForChildDIEsToKeep);
922
923 if (AlreadyKept || !(Current.Flags & TF_Keep))
924 continue;
925
926 // If it is a newly kept DIE mark it as well as all its dependencies as
927 // kept.
928 MyInfo.Keep = true;
929
930 // We're looking for incomplete types.
931 MyInfo.Incomplete =
932 Current.Die.getTag() != dwarf::DW_TAG_subprogram &&
933 Current.Die.getTag() != dwarf::DW_TAG_member &&
934 dwarf::toUnsigned(V: Current.Die.find(Attr: dwarf::DW_AT_declaration), Default: 0);
935
936 // After looking at the parent chain, look for referenced DIEs. Because of
937 // the LIFO worklist we need to schedule that work before any subsequent
938 // items are added to the worklist.
939 Worklist.emplace_back(Args&: Current.Die, Args&: Current.CU, Args&: Current.Flags,
940 Args: WorklistItemType::LookForRefDIEsToKeep);
941
942 bool UseOdr = (Current.Flags & TF_DependencyWalk) ? (Current.Flags & TF_ODR)
943 : Current.CU.hasODR();
944 unsigned ODRFlag = UseOdr ? TF_ODR : 0;
945 unsigned ParFlags = TF_ParentWalk | TF_Keep | TF_DependencyWalk | ODRFlag;
946
947 // Now schedule the parent walk.
948 Worklist.emplace_back(Args&: MyInfo.ParentIdx, Args&: Current.CU, Args&: ParFlags);
949 }
950}
951
952#ifndef NDEBUG
953/// A broken link in the keep chain. By recording both the parent and the child
954/// we can show only broken links for DIEs with multiple children.
955struct BrokenLink {
956 BrokenLink(DWARFDie Parent, DWARFDie Child) : Parent(Parent), Child(Child) {}
957 DWARFDie Parent;
958 DWARFDie Child;
959};
960
961/// Verify the keep chain by looking for DIEs that are kept but who's parent
962/// isn't.
963static void verifyKeepChain(CompileUnit &CU) {
964 std::vector<DWARFDie> Worklist;
965 Worklist.push_back(CU.getOrigUnit().getUnitDIE());
966
967 // List of broken links.
968 std::vector<BrokenLink> BrokenLinks;
969
970 while (!Worklist.empty()) {
971 const DWARFDie Current = Worklist.back();
972 Worklist.pop_back();
973
974 const bool CurrentDieIsKept = CU.getInfo(Current).Keep;
975
976 for (DWARFDie Child : reverse(Current.children())) {
977 Worklist.push_back(Child);
978
979 const bool ChildDieIsKept = CU.getInfo(Child).Keep;
980 if (!CurrentDieIsKept && ChildDieIsKept)
981 BrokenLinks.emplace_back(Current, Child);
982 }
983 }
984
985 if (!BrokenLinks.empty()) {
986 for (BrokenLink Link : BrokenLinks) {
987 WithColor::error() << formatv(
988 "Found invalid link in keep chain between {0:x} and {1:x}\n",
989 Link.Parent.getOffset(), Link.Child.getOffset());
990
991 errs() << "Parent:";
992 Link.Parent.dump(errs(), 0, {});
993 CU.getInfo(Link.Parent).dump();
994
995 errs() << "Child:";
996 Link.Child.dump(errs(), 2, {});
997 CU.getInfo(Link.Child).dump();
998 }
999 report_fatal_error("invalid keep chain");
1000 }
1001}
1002#endif
1003
1004/// Assign an abbreviation number to \p Abbrev.
1005///
1006/// Our DIEs get freed after every DebugMapObject has been processed,
1007/// thus the FoldingSet we use to unique DIEAbbrevs cannot refer to
1008/// the instances hold by the DIEs. When we encounter an abbreviation
1009/// that we don't know, we create a permanent copy of it.
1010void DWARFLinker::assignAbbrev(DIEAbbrev &Abbrev) {
1011 // Check the set for priors.
1012 FoldingSetNodeID ID;
1013 Abbrev.Profile(ID);
1014 void *InsertToken;
1015 DIEAbbrev *InSet = AbbreviationsSet.FindNodeOrInsertPos(ID, InsertPos&: InsertToken);
1016
1017 // If it's newly added.
1018 if (InSet) {
1019 // Assign existing abbreviation number.
1020 Abbrev.setNumber(InSet->getNumber());
1021 } else {
1022 // Add to abbreviation list.
1023 Abbreviations.push_back(
1024 x: std::make_unique<DIEAbbrev>(args: Abbrev.getTag(), args: Abbrev.hasChildren()));
1025 for (const auto &Attr : Abbrev.getData())
1026 Abbreviations.back()->AddAttribute(AbbrevData: Attr);
1027 AbbreviationsSet.InsertNode(N: Abbreviations.back().get(), InsertPos: InsertToken);
1028 // Assign the unique abbreviation number.
1029 Abbrev.setNumber(Abbreviations.size());
1030 Abbreviations.back()->setNumber(Abbreviations.size());
1031 }
1032}
1033
1034unsigned DWARFLinker::DIECloner::cloneStringAttribute(DIE &Die,
1035 AttributeSpec AttrSpec,
1036 const DWARFFormValue &Val,
1037 const DWARFUnit &U,
1038 AttributesInfo &Info) {
1039 std::optional<const char *> String = dwarf::toString(V: Val);
1040 if (!String)
1041 return 0;
1042 DwarfStringPoolEntryRef StringEntry;
1043 if (AttrSpec.Form == dwarf::DW_FORM_line_strp) {
1044 StringEntry = DebugLineStrPool.getEntry(S: *String);
1045 } else {
1046 StringEntry = DebugStrPool.getEntry(S: *String);
1047
1048 if (AttrSpec.Attr == dwarf::DW_AT_APPLE_origin) {
1049 Info.HasAppleOrigin = true;
1050 if (std::optional<StringRef> FileName =
1051 ObjFile.Addresses->getLibraryInstallName()) {
1052 StringEntry = DebugStrPool.getEntry(S: *FileName);
1053 }
1054 }
1055
1056 // Update attributes info.
1057 if (AttrSpec.Attr == dwarf::DW_AT_name)
1058 Info.Name = StringEntry;
1059 else if (AttrSpec.Attr == dwarf::DW_AT_MIPS_linkage_name ||
1060 AttrSpec.Attr == dwarf::DW_AT_linkage_name)
1061 Info.MangledName = StringEntry;
1062 if (U.getVersion() >= 5) {
1063 // Switch everything to DW_FORM_strx strings.
1064 auto StringOffsetIndex =
1065 StringOffsetPool.getValueIndex(Value: StringEntry.getOffset());
1066 return Die
1067 .addValue(Alloc&: DIEAlloc, Attribute: dwarf::Attribute(AttrSpec.Attr),
1068 Form: dwarf::DW_FORM_strx, Value: DIEInteger(StringOffsetIndex))
1069 ->sizeOf(FormParams: U.getFormParams());
1070 }
1071 // Switch everything to out of line strings.
1072 AttrSpec.Form = dwarf::DW_FORM_strp;
1073 }
1074 Die.addValue(Alloc&: DIEAlloc, Attribute: dwarf::Attribute(AttrSpec.Attr), Form: AttrSpec.Form,
1075 Value: DIEInteger(StringEntry.getOffset()));
1076 return 4;
1077}
1078
1079unsigned DWARFLinker::DIECloner::cloneDieReferenceAttribute(
1080 DIE &Die, const DWARFDie &InputDIE, AttributeSpec AttrSpec,
1081 unsigned AttrSize, const DWARFFormValue &Val, const DWARFFile &File,
1082 CompileUnit &Unit) {
1083 const DWARFUnit &U = Unit.getOrigUnit();
1084 uint64_t Ref;
1085 if (std::optional<uint64_t> Off = Val.getAsRelativeReference())
1086 Ref = Val.getUnit()->getOffset() + *Off;
1087 else if (Off = Val.getAsDebugInfoReference(); Off)
1088 Ref = *Off;
1089 else
1090 return 0;
1091
1092 DIE *NewRefDie = nullptr;
1093 CompileUnit *RefUnit = nullptr;
1094
1095 DWARFDie RefDie =
1096 Linker.resolveDIEReference(File, Units: CompileUnits, RefValue: Val, DIE: InputDIE, RefCU&: RefUnit);
1097
1098 // If the referenced DIE is not found, drop the attribute.
1099 if (!RefDie || AttrSpec.Attr == dwarf::DW_AT_sibling)
1100 return 0;
1101
1102 CompileUnit::DIEInfo &RefInfo = RefUnit->getInfo(Die: RefDie);
1103
1104 // If we already have emitted an equivalent DeclContext, just point
1105 // at it.
1106 if (isODRAttribute(Attr: AttrSpec.Attr) && RefInfo.Ctxt &&
1107 RefInfo.Ctxt->getCanonicalDIEOffset()) {
1108 assert(RefInfo.Ctxt->hasCanonicalDIE() &&
1109 "Offset to canonical die is set, but context is not marked");
1110 DIEInteger Attr(RefInfo.Ctxt->getCanonicalDIEOffset());
1111 Die.addValue(Alloc&: DIEAlloc, Attribute: dwarf::Attribute(AttrSpec.Attr),
1112 Form: dwarf::DW_FORM_ref_addr, Value&: Attr);
1113 return U.getRefAddrByteSize();
1114 }
1115
1116 if (!RefInfo.Clone) {
1117 // We haven't cloned this DIE yet. Just create an empty one and
1118 // store it. It'll get really cloned when we process it.
1119 RefInfo.UnclonedReference = true;
1120 RefInfo.Clone = DIE::get(Alloc&: DIEAlloc, Tag: dwarf::Tag(RefDie.getTag()));
1121 }
1122 NewRefDie = RefInfo.Clone;
1123
1124 if (AttrSpec.Form == dwarf::DW_FORM_ref_addr ||
1125 (Unit.hasODR() && isODRAttribute(Attr: AttrSpec.Attr))) {
1126 // We cannot currently rely on a DIEEntry to emit ref_addr
1127 // references, because the implementation calls back to DwarfDebug
1128 // to find the unit offset. (We don't have a DwarfDebug)
1129 // FIXME: we should be able to design DIEEntry reliance on
1130 // DwarfDebug away.
1131 uint64_t Attr;
1132 if (Ref < InputDIE.getOffset() && !RefInfo.UnclonedReference) {
1133 // We have already cloned that DIE.
1134 uint32_t NewRefOffset =
1135 RefUnit->getStartOffset() + NewRefDie->getOffset();
1136 Attr = NewRefOffset;
1137 Die.addValue(Alloc&: DIEAlloc, Attribute: dwarf::Attribute(AttrSpec.Attr),
1138 Form: dwarf::DW_FORM_ref_addr, Value: DIEInteger(Attr));
1139 } else {
1140 // A forward reference. Note and fixup later.
1141 Attr = 0xBADDEF;
1142 Unit.noteForwardReference(
1143 Die: NewRefDie, RefUnit, Ctxt: RefInfo.Ctxt,
1144 Attr: Die.addValue(Alloc&: DIEAlloc, Attribute: dwarf::Attribute(AttrSpec.Attr),
1145 Form: dwarf::DW_FORM_ref_addr, Value: DIEInteger(Attr)));
1146 }
1147 return U.getRefAddrByteSize();
1148 }
1149
1150 Die.addValue(Alloc&: DIEAlloc, Attribute: dwarf::Attribute(AttrSpec.Attr),
1151 Form: dwarf::Form(AttrSpec.Form), Value: DIEEntry(*NewRefDie));
1152
1153 return AttrSize;
1154}
1155
1156void DWARFLinker::DIECloner::cloneExpression(
1157 DataExtractor &Data, DWARFExpression Expression, const DWARFFile &File,
1158 CompileUnit &Unit, SmallVectorImpl<uint8_t> &OutputBuffer,
1159 int64_t AddrRelocAdjustment, bool IsLittleEndian) {
1160 using Encoding = DWARFExpression::Operation::Encoding;
1161
1162 uint8_t OrigAddressByteSize = Unit.getOrigUnit().getAddressByteSize();
1163
1164 uint64_t OpOffset = 0;
1165 for (auto &Op : Expression) {
1166 auto Desc = Op.getDescription();
1167 // DW_OP_const_type is variable-length and has 3
1168 // operands. Thus far we only support 2.
1169 if ((Desc.Op.size() == 2 && Desc.Op[0] == Encoding::BaseTypeRef) ||
1170 (Desc.Op.size() == 2 && Desc.Op[1] == Encoding::BaseTypeRef &&
1171 Desc.Op[0] != Encoding::Size1))
1172 Linker.reportWarning(Warning: "Unsupported DW_OP encoding.", File);
1173
1174 if ((Desc.Op.size() == 1 && Desc.Op[0] == Encoding::BaseTypeRef) ||
1175 (Desc.Op.size() == 2 && Desc.Op[1] == Encoding::BaseTypeRef &&
1176 Desc.Op[0] == Encoding::Size1)) {
1177 // This code assumes that the other non-typeref operand fits into 1 byte.
1178 assert(OpOffset < Op.getEndOffset());
1179 uint32_t ULEBsize = Op.getEndOffset() - OpOffset - 1;
1180 assert(ULEBsize <= 16);
1181
1182 // Copy over the operation.
1183 assert(!Op.getSubCode() && "SubOps not yet supported");
1184 OutputBuffer.push_back(Elt: Op.getCode());
1185 uint64_t RefOffset;
1186 if (Desc.Op.size() == 1) {
1187 RefOffset = Op.getRawOperand(Idx: 0);
1188 } else {
1189 OutputBuffer.push_back(Elt: Op.getRawOperand(Idx: 0));
1190 RefOffset = Op.getRawOperand(Idx: 1);
1191 }
1192 uint32_t Offset = 0;
1193 // Look up the base type. For DW_OP_convert, the operand may be 0 to
1194 // instead indicate the generic type. The same holds for
1195 // DW_OP_reinterpret, which is currently not supported.
1196 if (RefOffset > 0 || Op.getCode() != dwarf::DW_OP_convert) {
1197 RefOffset += Unit.getOrigUnit().getOffset();
1198 auto RefDie = Unit.getOrigUnit().getDIEForOffset(Offset: RefOffset);
1199 CompileUnit::DIEInfo &Info = Unit.getInfo(Die: RefDie);
1200 if (DIE *Clone = Info.Clone)
1201 Offset = Clone->getOffset();
1202 else
1203 Linker.reportWarning(
1204 Warning: "base type ref doesn't point to DW_TAG_base_type.", File);
1205 }
1206 uint8_t ULEB[16];
1207 unsigned RealSize = encodeULEB128(Value: Offset, p: ULEB, PadTo: ULEBsize);
1208 if (RealSize > ULEBsize) {
1209 // Emit the generic type as a fallback.
1210 RealSize = encodeULEB128(Value: 0, p: ULEB, PadTo: ULEBsize);
1211 Linker.reportWarning(Warning: "base type ref doesn't fit.", File);
1212 }
1213 assert(RealSize == ULEBsize && "padding failed");
1214 ArrayRef<uint8_t> ULEBbytes(ULEB, ULEBsize);
1215 OutputBuffer.append(in_start: ULEBbytes.begin(), in_end: ULEBbytes.end());
1216 } else if (!Linker.Options.Update && Op.getCode() == dwarf::DW_OP_addrx) {
1217 if (std::optional<object::SectionedAddress> SA =
1218 Unit.getOrigUnit().getAddrOffsetSectionItem(
1219 Index: Op.getRawOperand(Idx: 0))) {
1220 // DWARFLinker does not use addrx forms since it generates relocated
1221 // addresses. Replace DW_OP_addrx with DW_OP_addr here.
1222 // Argument of DW_OP_addrx should be relocated here as it is not
1223 // processed by applyValidRelocs.
1224 OutputBuffer.push_back(Elt: dwarf::DW_OP_addr);
1225 uint64_t LinkedAddress = SA->Address + AddrRelocAdjustment;
1226 if (IsLittleEndian != sys::IsLittleEndianHost)
1227 sys::swapByteOrder(Value&: LinkedAddress);
1228 ArrayRef<uint8_t> AddressBytes(
1229 reinterpret_cast<const uint8_t *>(&LinkedAddress),
1230 OrigAddressByteSize);
1231 OutputBuffer.append(in_start: AddressBytes.begin(), in_end: AddressBytes.end());
1232 } else
1233 Linker.reportWarning(Warning: "cannot read DW_OP_addrx operand.", File);
1234 } else if (!Linker.Options.Update && Op.getCode() == dwarf::DW_OP_constx) {
1235 if (std::optional<object::SectionedAddress> SA =
1236 Unit.getOrigUnit().getAddrOffsetSectionItem(
1237 Index: Op.getRawOperand(Idx: 0))) {
1238 // DWARFLinker does not use constx forms since it generates relocated
1239 // addresses. Replace DW_OP_constx with DW_OP_const[*]u here.
1240 // Argument of DW_OP_constx should be relocated here as it is not
1241 // processed by applyValidRelocs.
1242 std::optional<uint8_t> OutOperandKind;
1243 switch (OrigAddressByteSize) {
1244 case 4:
1245 OutOperandKind = dwarf::DW_OP_const4u;
1246 break;
1247 case 8:
1248 OutOperandKind = dwarf::DW_OP_const8u;
1249 break;
1250 default:
1251 Linker.reportWarning(
1252 Warning: formatv(Fmt: ("unsupported address size: {0}."), Vals&: OrigAddressByteSize),
1253 File);
1254 break;
1255 }
1256
1257 if (OutOperandKind) {
1258 OutputBuffer.push_back(Elt: *OutOperandKind);
1259 uint64_t LinkedAddress = SA->Address + AddrRelocAdjustment;
1260 if (IsLittleEndian != sys::IsLittleEndianHost)
1261 sys::swapByteOrder(Value&: LinkedAddress);
1262 ArrayRef<uint8_t> AddressBytes(
1263 reinterpret_cast<const uint8_t *>(&LinkedAddress),
1264 OrigAddressByteSize);
1265 OutputBuffer.append(in_start: AddressBytes.begin(), in_end: AddressBytes.end());
1266 }
1267 } else
1268 Linker.reportWarning(Warning: "cannot read DW_OP_constx operand.", File);
1269 } else {
1270 // Copy over everything else unmodified.
1271 StringRef Bytes = Data.getData().slice(Start: OpOffset, End: Op.getEndOffset());
1272 OutputBuffer.append(in_start: Bytes.begin(), in_end: Bytes.end());
1273 }
1274 OpOffset = Op.getEndOffset();
1275 }
1276}
1277
1278unsigned DWARFLinker::DIECloner::cloneBlockAttribute(
1279 DIE &Die, const DWARFDie &InputDIE, const DWARFFile &File,
1280 CompileUnit &Unit, AttributeSpec AttrSpec, const DWARFFormValue &Val,
1281 bool IsLittleEndian) {
1282 DIEValueList *Attr;
1283 DIEValue Value;
1284 DIELoc *Loc = nullptr;
1285 DIEBlock *Block = nullptr;
1286 if (AttrSpec.Form == dwarf::DW_FORM_exprloc) {
1287 Loc = new (DIEAlloc) DIELoc;
1288 Linker.DIELocs.push_back(x: Loc);
1289 } else {
1290 Block = new (DIEAlloc) DIEBlock;
1291 Linker.DIEBlocks.push_back(x: Block);
1292 }
1293 Attr = Loc ? static_cast<DIEValueList *>(Loc)
1294 : static_cast<DIEValueList *>(Block);
1295
1296 DWARFUnit &OrigUnit = Unit.getOrigUnit();
1297 // If the block is a DWARF Expression, clone it into the temporary
1298 // buffer using cloneExpression(), otherwise copy the data directly.
1299 SmallVector<uint8_t, 32> Buffer;
1300 ArrayRef<uint8_t> Bytes = *Val.getAsBlock();
1301 if (DWARFAttribute::mayHaveLocationExpr(Attr: AttrSpec.Attr) &&
1302 (Val.isFormClass(FC: DWARFFormValue::FC_Block) ||
1303 Val.isFormClass(FC: DWARFFormValue::FC_Exprloc))) {
1304 DataExtractor Data(StringRef((const char *)Bytes.data(), Bytes.size()),
1305 IsLittleEndian, OrigUnit.getAddressByteSize());
1306 DWARFExpression Expr(Data, OrigUnit.getAddressByteSize(),
1307 OrigUnit.getFormParams().Format);
1308 cloneExpression(Data, Expression: Expr, File, Unit, OutputBuffer&: Buffer,
1309 AddrRelocAdjustment: Unit.getInfo(Die: InputDIE).AddrAdjust, IsLittleEndian);
1310 Bytes = Buffer;
1311 }
1312 for (auto Byte : Bytes)
1313 Attr->addValue(Alloc&: DIEAlloc, Attribute: static_cast<dwarf::Attribute>(0),
1314 Form: dwarf::DW_FORM_data1, Value: DIEInteger(Byte));
1315
1316 // FIXME: If DIEBlock and DIELoc just reuses the Size field of
1317 // the DIE class, this "if" could be replaced by
1318 // Attr->setSize(Bytes.size()).
1319 if (Loc)
1320 Loc->setSize(Bytes.size());
1321 else
1322 Block->setSize(Bytes.size());
1323
1324 if (Loc)
1325 Value = DIEValue(dwarf::Attribute(AttrSpec.Attr),
1326 dwarf::Form(AttrSpec.Form), Loc);
1327 else {
1328 // The expression location data might be updated and exceed the original
1329 // size. Check whether the new data fits into the original form.
1330 if ((AttrSpec.Form == dwarf::DW_FORM_block1 &&
1331 (Bytes.size() > UINT8_MAX)) ||
1332 (AttrSpec.Form == dwarf::DW_FORM_block2 &&
1333 (Bytes.size() > UINT16_MAX)) ||
1334 (AttrSpec.Form == dwarf::DW_FORM_block4 && (Bytes.size() > UINT32_MAX)))
1335 AttrSpec.Form = dwarf::DW_FORM_block;
1336
1337 Value = DIEValue(dwarf::Attribute(AttrSpec.Attr),
1338 dwarf::Form(AttrSpec.Form), Block);
1339 }
1340
1341 return Die.addValue(Alloc&: DIEAlloc, V: Value)->sizeOf(FormParams: OrigUnit.getFormParams());
1342}
1343
1344unsigned DWARFLinker::DIECloner::cloneAddressAttribute(
1345 DIE &Die, const DWARFDie &InputDIE, AttributeSpec AttrSpec,
1346 unsigned AttrSize, const DWARFFormValue &Val, const CompileUnit &Unit,
1347 AttributesInfo &Info) {
1348 if (AttrSpec.Attr == dwarf::DW_AT_low_pc)
1349 Info.HasLowPc = true;
1350
1351 if (LLVM_UNLIKELY(Linker.Options.Update)) {
1352 Die.addValue(Alloc&: DIEAlloc, Attribute: dwarf::Attribute(AttrSpec.Attr),
1353 Form: dwarf::Form(AttrSpec.Form), Value: DIEInteger(Val.getRawUValue()));
1354 return AttrSize;
1355 }
1356
1357 // Cloned Die may have address attributes relocated to a
1358 // totally unrelated value. This can happen:
1359 // - If high_pc is an address (Dwarf version == 2), then it might have been
1360 // relocated to a totally unrelated value (because the end address in the
1361 // object file might be start address of another function which got moved
1362 // independently by the linker).
1363 // - If address relocated in an inline_subprogram that happens at the
1364 // beginning of its inlining function.
1365 // To avoid above cases and to not apply relocation twice (in
1366 // applyValidRelocs and here), read address attribute from InputDIE and apply
1367 // Info.PCOffset here.
1368
1369 std::optional<DWARFFormValue> AddrAttribute = InputDIE.find(Attr: AttrSpec.Attr);
1370 if (!AddrAttribute)
1371 llvm_unreachable("Cann't find attribute.");
1372
1373 std::optional<uint64_t> Addr = AddrAttribute->getAsAddress();
1374 if (!Addr) {
1375 Linker.reportWarning(Warning: "Cann't read address attribute value.", File: ObjFile);
1376 return 0;
1377 }
1378
1379 if (InputDIE.getTag() == dwarf::DW_TAG_compile_unit &&
1380 AttrSpec.Attr == dwarf::DW_AT_low_pc) {
1381 if (std::optional<uint64_t> LowPC = Unit.getLowPc())
1382 Addr = *LowPC;
1383 else
1384 return 0;
1385 } else if (InputDIE.getTag() == dwarf::DW_TAG_compile_unit &&
1386 AttrSpec.Attr == dwarf::DW_AT_high_pc) {
1387 if (uint64_t HighPc = Unit.getHighPc())
1388 Addr = HighPc;
1389 else
1390 return 0;
1391 } else {
1392 *Addr += Info.PCOffset;
1393 }
1394
1395 if (AttrSpec.Form == dwarf::DW_FORM_addr) {
1396 Die.addValue(Alloc&: DIEAlloc, Attribute: static_cast<dwarf::Attribute>(AttrSpec.Attr),
1397 Form: AttrSpec.Form, Value: DIEInteger(*Addr));
1398 return Unit.getOrigUnit().getAddressByteSize();
1399 }
1400
1401 auto AddrIndex = AddrPool.getValueIndex(Value: *Addr);
1402
1403 return Die
1404 .addValue(Alloc&: DIEAlloc, Attribute: static_cast<dwarf::Attribute>(AttrSpec.Attr),
1405 Form: dwarf::Form::DW_FORM_addrx, Value: DIEInteger(AddrIndex))
1406 ->sizeOf(FormParams: Unit.getOrigUnit().getFormParams());
1407}
1408
1409unsigned DWARFLinker::DIECloner::cloneScalarAttribute(
1410 DIE &Die, const DWARFDie &InputDIE, const DWARFFile &File,
1411 CompileUnit &Unit, AttributeSpec AttrSpec, const DWARFFormValue &Val,
1412 unsigned AttrSize, AttributesInfo &Info) {
1413 uint64_t Value;
1414
1415 // We don't emit any skeleton CUs with dsymutil. So avoid emitting
1416 // a redundant DW_AT_GNU_dwo_id on the non-skeleton CU.
1417 if (AttrSpec.Attr == dwarf::DW_AT_GNU_dwo_id ||
1418 AttrSpec.Attr == dwarf::DW_AT_dwo_id)
1419 return 0;
1420
1421 // Check for the offset to the macro table. If offset is incorrect then we
1422 // need to remove the attribute.
1423 if (AttrSpec.Attr == dwarf::DW_AT_macro_info) {
1424 if (std::optional<uint64_t> Offset = Val.getAsSectionOffset()) {
1425 const llvm::DWARFDebugMacro *Macro = File.Dwarf->getDebugMacinfo();
1426 if (Macro == nullptr || !Macro->hasEntryForOffset(Offset: *Offset))
1427 return 0;
1428 }
1429 }
1430
1431 if (AttrSpec.Attr == dwarf::DW_AT_macros) {
1432 if (std::optional<uint64_t> Offset = Val.getAsSectionOffset()) {
1433 const llvm::DWARFDebugMacro *Macro = File.Dwarf->getDebugMacro();
1434 if (Macro == nullptr || !Macro->hasEntryForOffset(Offset: *Offset))
1435 return 0;
1436 }
1437 }
1438
1439 if (AttrSpec.Attr == dwarf::DW_AT_str_offsets_base) {
1440 // DWARFLinker generates common .debug_str_offsets table used for all
1441 // compile units. The offset to the common .debug_str_offsets table is 8 on
1442 // DWARF32.
1443 Info.AttrStrOffsetBaseSeen = true;
1444 return Die
1445 .addValue(Alloc&: DIEAlloc, Attribute: dwarf::DW_AT_str_offsets_base,
1446 Form: dwarf::DW_FORM_sec_offset, Value: DIEInteger(8))
1447 ->sizeOf(FormParams: Unit.getOrigUnit().getFormParams());
1448 }
1449
1450 if (AttrSpec.Attr == dwarf::DW_AT_LLVM_stmt_sequence) {
1451 // If needed, we'll patch this sec_offset later with the correct offset.
1452 auto Patch = Die.addValue(Alloc&: DIEAlloc, Attribute: dwarf::Attribute(AttrSpec.Attr),
1453 Form: dwarf::DW_FORM_sec_offset,
1454 Value: DIEInteger(*Val.getAsSectionOffset()));
1455
1456 // Record this patch location so that it can be fixed up later.
1457 Unit.noteStmtSeqListAttribute(Attr: Patch);
1458
1459 return Unit.getOrigUnit().getFormParams().getDwarfOffsetByteSize();
1460 }
1461
1462 if (LLVM_UNLIKELY(Linker.Options.Update)) {
1463 if (auto OptionalValue = Val.getAsUnsignedConstant())
1464 Value = *OptionalValue;
1465 else if (auto OptionalValue = Val.getAsSignedConstant())
1466 Value = *OptionalValue;
1467 else if (auto OptionalValue = Val.getAsSectionOffset())
1468 Value = *OptionalValue;
1469 else {
1470 Linker.reportWarning(
1471 Warning: "Unsupported scalar attribute form. Dropping attribute.", File,
1472 DIE: &InputDIE);
1473 return 0;
1474 }
1475 if (AttrSpec.Attr == dwarf::DW_AT_declaration && Value)
1476 Info.IsDeclaration = true;
1477
1478 if (AttrSpec.Form == dwarf::DW_FORM_loclistx)
1479 Die.addValue(Alloc&: DIEAlloc, Attribute: dwarf::Attribute(AttrSpec.Attr),
1480 Form: dwarf::Form(AttrSpec.Form), Value: DIELocList(Value));
1481 else
1482 Die.addValue(Alloc&: DIEAlloc, Attribute: dwarf::Attribute(AttrSpec.Attr),
1483 Form: dwarf::Form(AttrSpec.Form), Value: DIEInteger(Value));
1484 return AttrSize;
1485 }
1486
1487 [[maybe_unused]] dwarf::Form OriginalForm = AttrSpec.Form;
1488 if (AttrSpec.Form == dwarf::DW_FORM_rnglistx) {
1489 // DWARFLinker does not generate .debug_addr table. Thus we need to change
1490 // all "addrx" related forms to "addr" version. Change DW_FORM_rnglistx
1491 // to DW_FORM_sec_offset here.
1492 std::optional<uint64_t> Index = Val.getAsSectionOffset();
1493 if (!Index) {
1494 Linker.reportWarning(Warning: "Cannot read the attribute. Dropping.", File,
1495 DIE: &InputDIE);
1496 return 0;
1497 }
1498 std::optional<uint64_t> Offset =
1499 Unit.getOrigUnit().getRnglistOffset(Index: *Index);
1500 if (!Offset) {
1501 Linker.reportWarning(Warning: "Cannot read the attribute. Dropping.", File,
1502 DIE: &InputDIE);
1503 return 0;
1504 }
1505
1506 Value = *Offset;
1507 AttrSpec.Form = dwarf::DW_FORM_sec_offset;
1508 AttrSize = Unit.getOrigUnit().getFormParams().getDwarfOffsetByteSize();
1509 } else if (AttrSpec.Form == dwarf::DW_FORM_loclistx) {
1510 // DWARFLinker does not generate .debug_addr table. Thus we need to change
1511 // all "addrx" related forms to "addr" version. Change DW_FORM_loclistx
1512 // to DW_FORM_sec_offset here.
1513 std::optional<uint64_t> Index = Val.getAsSectionOffset();
1514 if (!Index) {
1515 Linker.reportWarning(Warning: "Cannot read the attribute. Dropping.", File,
1516 DIE: &InputDIE);
1517 return 0;
1518 }
1519 std::optional<uint64_t> Offset =
1520 Unit.getOrigUnit().getLoclistOffset(Index: *Index);
1521 if (!Offset) {
1522 Linker.reportWarning(Warning: "Cannot read the attribute. Dropping.", File,
1523 DIE: &InputDIE);
1524 return 0;
1525 }
1526
1527 Value = *Offset;
1528 AttrSpec.Form = dwarf::DW_FORM_sec_offset;
1529 AttrSize = Unit.getOrigUnit().getFormParams().getDwarfOffsetByteSize();
1530 } else if (AttrSpec.Attr == dwarf::DW_AT_high_pc &&
1531 Die.getTag() == dwarf::DW_TAG_compile_unit) {
1532 std::optional<uint64_t> LowPC = Unit.getLowPc();
1533 if (!LowPC)
1534 return 0;
1535 // Dwarf >= 4 high_pc is an size, not an address.
1536 Value = Unit.getHighPc() - *LowPC;
1537 } else if (AttrSpec.Form == dwarf::DW_FORM_sec_offset)
1538 Value = *Val.getAsSectionOffset();
1539 else if (AttrSpec.Form == dwarf::DW_FORM_sdata)
1540 Value = *Val.getAsSignedConstant();
1541 else if (auto OptionalValue = Val.getAsUnsignedConstant())
1542 Value = *OptionalValue;
1543 else {
1544 Linker.reportWarning(
1545 Warning: "Unsupported scalar attribute form. Dropping attribute.", File,
1546 DIE: &InputDIE);
1547 return 0;
1548 }
1549
1550 DIE::value_iterator Patch =
1551 Die.addValue(Alloc&: DIEAlloc, Attribute: dwarf::Attribute(AttrSpec.Attr),
1552 Form: dwarf::Form(AttrSpec.Form), Value: DIEInteger(Value));
1553 if (AttrSpec.Attr == dwarf::DW_AT_ranges ||
1554 AttrSpec.Attr == dwarf::DW_AT_start_scope) {
1555 Unit.noteRangeAttribute(Die, Attr: Patch);
1556 Info.HasRanges = true;
1557 } else if (DWARFAttribute::mayHaveLocationList(Attr: AttrSpec.Attr) &&
1558 dwarf::doesFormBelongToClass(Form: AttrSpec.Form,
1559 FC: DWARFFormValue::FC_SectionOffset,
1560 DwarfVersion: Unit.getOrigUnit().getVersion())) {
1561
1562 CompileUnit::DIEInfo &LocationDieInfo = Unit.getInfo(Die: InputDIE);
1563 Unit.noteLocationAttribute(Attr: {Patch, LocationDieInfo.InDebugMap
1564 ? LocationDieInfo.AddrAdjust
1565 : Info.PCOffset});
1566 } else if (AttrSpec.Attr == dwarf::DW_AT_declaration && Value)
1567 Info.IsDeclaration = true;
1568
1569 // check that all dwarf::DW_FORM_rnglistx are handled previously.
1570 assert((Info.HasRanges || (OriginalForm != dwarf::DW_FORM_rnglistx)) &&
1571 "Unhandled DW_FORM_rnglistx attribute");
1572
1573 return AttrSize;
1574}
1575
1576/// Clone \p InputDIE's attribute described by \p AttrSpec with
1577/// value \p Val, and add it to \p Die.
1578/// \returns the size of the cloned attribute.
1579unsigned DWARFLinker::DIECloner::cloneAttribute(
1580 DIE &Die, const DWARFDie &InputDIE, const DWARFFile &File,
1581 CompileUnit &Unit, const DWARFFormValue &Val, const AttributeSpec AttrSpec,
1582 unsigned AttrSize, AttributesInfo &Info, bool IsLittleEndian) {
1583 const DWARFUnit &U = Unit.getOrigUnit();
1584
1585 switch (AttrSpec.Form) {
1586 case dwarf::DW_FORM_strp:
1587 case dwarf::DW_FORM_line_strp:
1588 case dwarf::DW_FORM_string:
1589 case dwarf::DW_FORM_strx:
1590 case dwarf::DW_FORM_strx1:
1591 case dwarf::DW_FORM_strx2:
1592 case dwarf::DW_FORM_strx3:
1593 case dwarf::DW_FORM_strx4:
1594 return cloneStringAttribute(Die, AttrSpec, Val, U, Info);
1595 case dwarf::DW_FORM_ref_addr:
1596 case dwarf::DW_FORM_ref1:
1597 case dwarf::DW_FORM_ref2:
1598 case dwarf::DW_FORM_ref4:
1599 case dwarf::DW_FORM_ref8:
1600 return cloneDieReferenceAttribute(Die, InputDIE, AttrSpec, AttrSize, Val,
1601 File, Unit);
1602 case dwarf::DW_FORM_block:
1603 case dwarf::DW_FORM_block1:
1604 case dwarf::DW_FORM_block2:
1605 case dwarf::DW_FORM_block4:
1606 case dwarf::DW_FORM_exprloc:
1607 return cloneBlockAttribute(Die, InputDIE, File, Unit, AttrSpec, Val,
1608 IsLittleEndian);
1609 case dwarf::DW_FORM_addr:
1610 case dwarf::DW_FORM_addrx:
1611 case dwarf::DW_FORM_addrx1:
1612 case dwarf::DW_FORM_addrx2:
1613 case dwarf::DW_FORM_addrx3:
1614 case dwarf::DW_FORM_addrx4:
1615 return cloneAddressAttribute(Die, InputDIE, AttrSpec, AttrSize, Val, Unit,
1616 Info);
1617 case dwarf::DW_FORM_data1:
1618 case dwarf::DW_FORM_data2:
1619 case dwarf::DW_FORM_data4:
1620 case dwarf::DW_FORM_data8:
1621 case dwarf::DW_FORM_udata:
1622 case dwarf::DW_FORM_sdata:
1623 case dwarf::DW_FORM_sec_offset:
1624 case dwarf::DW_FORM_flag:
1625 case dwarf::DW_FORM_flag_present:
1626 case dwarf::DW_FORM_rnglistx:
1627 case dwarf::DW_FORM_loclistx:
1628 case dwarf::DW_FORM_implicit_const:
1629 return cloneScalarAttribute(Die, InputDIE, File, Unit, AttrSpec, Val,
1630 AttrSize, Info);
1631 default:
1632 Linker.reportWarning(Warning: "Unsupported attribute form " +
1633 dwarf::FormEncodingString(Encoding: AttrSpec.Form) +
1634 " in cloneAttribute. Dropping.",
1635 File, DIE: &InputDIE);
1636 }
1637
1638 return 0;
1639}
1640
1641void DWARFLinker::DIECloner::addObjCAccelerator(CompileUnit &Unit,
1642 const DIE *Die,
1643 DwarfStringPoolEntryRef Name,
1644 OffsetsStringPool &StringPool,
1645 bool SkipPubSection) {
1646 std::optional<ObjCSelectorNames> Names =
1647 getObjCNamesIfSelector(Name: Name.getString());
1648 if (!Names)
1649 return;
1650 Unit.addNameAccelerator(Die, Name: StringPool.getEntry(S: Names->Selector),
1651 SkipPubnamesSection: SkipPubSection);
1652 Unit.addObjCAccelerator(Die, Name: StringPool.getEntry(S: Names->ClassName),
1653 SkipPubnamesSection: SkipPubSection);
1654 if (Names->ClassNameNoCategory)
1655 Unit.addObjCAccelerator(
1656 Die, Name: StringPool.getEntry(S: *Names->ClassNameNoCategory), SkipPubnamesSection: SkipPubSection);
1657 if (Names->MethodNameNoCategory)
1658 Unit.addNameAccelerator(
1659 Die, Name: StringPool.getEntry(S: *Names->MethodNameNoCategory), SkipPubnamesSection: SkipPubSection);
1660}
1661
1662static bool
1663shouldSkipAttribute(bool Update,
1664 DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
1665 bool SkipPC) {
1666 switch (AttrSpec.Attr) {
1667 default:
1668 return false;
1669 case dwarf::DW_AT_low_pc:
1670 case dwarf::DW_AT_high_pc:
1671 case dwarf::DW_AT_ranges:
1672 return !Update && SkipPC;
1673 case dwarf::DW_AT_rnglists_base:
1674 // In case !Update the .debug_addr table is not generated/preserved.
1675 // Thus instead of DW_FORM_rnglistx the DW_FORM_sec_offset is used.
1676 // Since DW_AT_rnglists_base is used for only DW_FORM_rnglistx the
1677 // DW_AT_rnglists_base is removed.
1678 return !Update;
1679 case dwarf::DW_AT_loclists_base:
1680 // In case !Update the .debug_addr table is not generated/preserved.
1681 // Thus instead of DW_FORM_loclistx the DW_FORM_sec_offset is used.
1682 // Since DW_AT_loclists_base is used for only DW_FORM_loclistx the
1683 // DW_AT_loclists_base is removed.
1684 return !Update;
1685 case dwarf::DW_AT_location:
1686 case dwarf::DW_AT_frame_base:
1687 return !Update && SkipPC;
1688 }
1689}
1690
1691struct AttributeLinkedOffsetFixup {
1692 int64_t LinkedOffsetFixupVal;
1693 uint64_t InputAttrStartOffset;
1694 uint64_t InputAttrEndOffset;
1695};
1696
1697DIE *DWARFLinker::DIECloner::cloneDIE(const DWARFDie &InputDIE,
1698 const DWARFFile &File, CompileUnit &Unit,
1699 int64_t PCOffset, uint32_t OutOffset,
1700 unsigned Flags, bool IsLittleEndian,
1701 DIE *Die) {
1702 DWARFUnit &U = Unit.getOrigUnit();
1703 unsigned Idx = U.getDIEIndex(D: InputDIE);
1704 CompileUnit::DIEInfo &Info = Unit.getInfo(Idx);
1705
1706 // Should the DIE appear in the output?
1707 if (!Unit.getInfo(Idx).Keep)
1708 return nullptr;
1709
1710 uint64_t Offset = InputDIE.getOffset();
1711 assert(!(Die && Info.Clone) && "Can't supply a DIE and a cloned DIE");
1712 if (!Die) {
1713 // The DIE might have been already created by a forward reference
1714 // (see cloneDieReferenceAttribute()).
1715 if (!Info.Clone)
1716 Info.Clone = DIE::get(Alloc&: DIEAlloc, Tag: dwarf::Tag(InputDIE.getTag()));
1717 Die = Info.Clone;
1718 }
1719
1720 assert(Die->getTag() == InputDIE.getTag());
1721 Die->setOffset(OutOffset);
1722 if (isODRCanonicalCandidate(Die: InputDIE, CU&: Unit) && Info.Ctxt &&
1723 (Info.Ctxt->getCanonicalDIEOffset() == 0)) {
1724 if (!Info.Ctxt->hasCanonicalDIE())
1725 Info.Ctxt->setHasCanonicalDIE();
1726 // We are about to emit a DIE that is the root of its own valid
1727 // DeclContext tree. Make the current offset the canonical offset
1728 // for this context.
1729 Info.Ctxt->setCanonicalDIEOffset(OutOffset + Unit.getStartOffset());
1730 }
1731
1732 // Extract and clone every attribute.
1733 DWARFDataExtractor Data = U.getDebugInfoExtractor();
1734 // Point to the next DIE (generally there is always at least a NULL
1735 // entry after the current one). If this is a lone
1736 // DW_TAG_compile_unit without any children, point to the next unit.
1737 uint64_t NextOffset = (Idx + 1 < U.getNumDIEs())
1738 ? U.getDIEAtIndex(Index: Idx + 1).getOffset()
1739 : U.getNextUnitOffset();
1740 AttributesInfo AttrInfo;
1741
1742 // We could copy the data only if we need to apply a relocation to it. After
1743 // testing, it seems there is no performance downside to doing the copy
1744 // unconditionally, and it makes the code simpler.
1745 SmallString<40> DIECopy(Data.getData().substr(Start: Offset, N: NextOffset - Offset));
1746 Data =
1747 DWARFDataExtractor(DIECopy, Data.isLittleEndian(), Data.getAddressSize());
1748
1749 // Modify the copy with relocated addresses.
1750 ObjFile.Addresses->applyValidRelocs(Data: DIECopy, BaseOffset: Offset, IsLittleEndian: Data.isLittleEndian());
1751
1752 // Reset the Offset to 0 as we will be working on the local copy of
1753 // the data.
1754 Offset = 0;
1755
1756 const auto *Abbrev = InputDIE.getAbbreviationDeclarationPtr();
1757 Offset += getULEB128Size(Value: Abbrev->getCode());
1758
1759 // We are entering a subprogram. Get and propagate the PCOffset.
1760 if (Die->getTag() == dwarf::DW_TAG_subprogram)
1761 PCOffset = Info.AddrAdjust;
1762 AttrInfo.PCOffset = PCOffset;
1763
1764 if (Abbrev->getTag() == dwarf::DW_TAG_subprogram) {
1765 Flags |= TF_InFunctionScope;
1766 if (!Info.InDebugMap && LLVM_LIKELY(!Update))
1767 Flags |= TF_SkipPC;
1768 } else if (Abbrev->getTag() == dwarf::DW_TAG_variable) {
1769 // Function-local globals could be in the debug map even when the function
1770 // is not, e.g., inlined functions.
1771 if ((Flags & TF_InFunctionScope) && Info.InDebugMap)
1772 Flags &= ~TF_SkipPC;
1773 // Location expressions referencing an address which is not in debug map
1774 // should be deleted.
1775 else if (!Info.InDebugMap && Info.HasLocationExpressionAddr &&
1776 LLVM_LIKELY(!Update))
1777 Flags |= TF_SkipPC;
1778 }
1779
1780 std::optional<StringRef> LibraryInstallName =
1781 ObjFile.Addresses->getLibraryInstallName();
1782 SmallVector<AttributeLinkedOffsetFixup> AttributesFixups;
1783 for (const auto &AttrSpec : Abbrev->attributes()) {
1784 if (shouldSkipAttribute(Update, AttrSpec, SkipPC: Flags & TF_SkipPC)) {
1785 DWARFFormValue::skipValue(Form: AttrSpec.Form, DebugInfoData: Data, OffsetPtr: &Offset,
1786 FormParams: U.getFormParams());
1787 continue;
1788 }
1789
1790 AttributeLinkedOffsetFixup CurAttrFixup;
1791 CurAttrFixup.InputAttrStartOffset = InputDIE.getOffset() + Offset;
1792 CurAttrFixup.LinkedOffsetFixupVal =
1793 Unit.getStartOffset() + OutOffset - CurAttrFixup.InputAttrStartOffset;
1794
1795 DWARFFormValue Val = AttrSpec.getFormValue();
1796 uint64_t AttrSize = Offset;
1797 Val.extractValue(Data, OffsetPtr: &Offset, FormParams: U.getFormParams(), U: &U);
1798 CurAttrFixup.InputAttrEndOffset = InputDIE.getOffset() + Offset;
1799 AttrSize = Offset - AttrSize;
1800
1801 uint64_t FinalAttrSize =
1802 cloneAttribute(Die&: *Die, InputDIE, File, Unit, Val, AttrSpec, AttrSize,
1803 Info&: AttrInfo, IsLittleEndian);
1804 if (FinalAttrSize != 0 && ObjFile.Addresses->needToSaveValidRelocs())
1805 AttributesFixups.push_back(Elt: CurAttrFixup);
1806
1807 OutOffset += FinalAttrSize;
1808 }
1809
1810 uint16_t Tag = InputDIE.getTag();
1811 // Add the DW_AT_APPLE_origin attribute to Compile Unit die if we have
1812 // an install name and the DWARF doesn't have the attribute yet.
1813 const bool NeedsAppleOrigin = (Tag == dwarf::DW_TAG_compile_unit) &&
1814 LibraryInstallName.has_value() &&
1815 !AttrInfo.HasAppleOrigin;
1816 if (NeedsAppleOrigin) {
1817 auto StringEntry = DebugStrPool.getEntry(S: LibraryInstallName.value());
1818 Die->addValue(Alloc&: DIEAlloc, Attribute: dwarf::Attribute(dwarf::DW_AT_APPLE_origin),
1819 Form: dwarf::DW_FORM_strp, Value: DIEInteger(StringEntry.getOffset()));
1820 AttrInfo.Name = StringEntry;
1821 OutOffset += 4;
1822 }
1823
1824 // Look for accelerator entries.
1825 // FIXME: This is slightly wrong. An inline_subroutine without a
1826 // low_pc, but with AT_ranges might be interesting to get into the
1827 // accelerator tables too. For now stick with dsymutil's behavior.
1828 if ((Info.InDebugMap || AttrInfo.HasLowPc || AttrInfo.HasRanges) &&
1829 Tag != dwarf::DW_TAG_compile_unit &&
1830 getDIENames(Die: InputDIE, Info&: AttrInfo, StringPool&: DebugStrPool,
1831 StripTemplate: Tag != dwarf::DW_TAG_inlined_subroutine)) {
1832 if (AttrInfo.MangledName && AttrInfo.MangledName != AttrInfo.Name)
1833 Unit.addNameAccelerator(Die, Name: AttrInfo.MangledName,
1834 SkipPubnamesSection: Tag == dwarf::DW_TAG_inlined_subroutine);
1835 if (AttrInfo.Name) {
1836 if (AttrInfo.NameWithoutTemplate)
1837 Unit.addNameAccelerator(Die, Name: AttrInfo.NameWithoutTemplate,
1838 /* SkipPubSection */ SkipPubnamesSection: true);
1839 Unit.addNameAccelerator(Die, Name: AttrInfo.Name,
1840 SkipPubnamesSection: Tag == dwarf::DW_TAG_inlined_subroutine);
1841 }
1842 if (AttrInfo.Name)
1843 addObjCAccelerator(Unit, Die, Name: AttrInfo.Name, StringPool&: DebugStrPool,
1844 /* SkipPubSection =*/true);
1845
1846 } else if (Tag == dwarf::DW_TAG_namespace) {
1847 if (!AttrInfo.Name)
1848 AttrInfo.Name = DebugStrPool.getEntry(S: "(anonymous namespace)");
1849 Unit.addNamespaceAccelerator(Die, Name: AttrInfo.Name);
1850 } else if (Tag == dwarf::DW_TAG_imported_declaration && AttrInfo.Name) {
1851 Unit.addNamespaceAccelerator(Die, Name: AttrInfo.Name);
1852 } else if (isTypeTag(Tag) && !AttrInfo.IsDeclaration) {
1853 bool Success = getDIENames(Die: InputDIE, Info&: AttrInfo, StringPool&: DebugStrPool);
1854 uint64_t RuntimeLang =
1855 dwarf::toUnsigned(V: InputDIE.find(Attr: dwarf::DW_AT_APPLE_runtime_class))
1856 .value_or(u: 0);
1857 bool ObjCClassIsImplementation =
1858 (RuntimeLang == dwarf::DW_LANG_ObjC ||
1859 RuntimeLang == dwarf::DW_LANG_ObjC_plus_plus) &&
1860 dwarf::toUnsigned(V: InputDIE.find(Attr: dwarf::DW_AT_APPLE_objc_complete_type))
1861 .value_or(u: 0);
1862 if (Success && AttrInfo.Name && !AttrInfo.Name.getString().empty()) {
1863 uint32_t Hash = hashFullyQualifiedName(DIE: InputDIE, U&: Unit, File);
1864 Unit.addTypeAccelerator(Die, Name: AttrInfo.Name, ObjcClassImplementation: ObjCClassIsImplementation,
1865 QualifiedNameHash: Hash);
1866 }
1867
1868 // For Swift, mangled names are put into DW_AT_linkage_name.
1869 if (Success && AttrInfo.MangledName &&
1870 RuntimeLang == dwarf::DW_LANG_Swift &&
1871 !AttrInfo.MangledName.getString().empty() &&
1872 AttrInfo.MangledName != AttrInfo.Name) {
1873 auto Hash = djbHash(Buffer: AttrInfo.MangledName.getString().data());
1874 Unit.addTypeAccelerator(Die, Name: AttrInfo.MangledName,
1875 ObjcClassImplementation: ObjCClassIsImplementation, QualifiedNameHash: Hash);
1876 }
1877 }
1878
1879 // Determine whether there are any children that we want to keep.
1880 bool HasChildren = false;
1881 for (auto Child : InputDIE.children()) {
1882 unsigned Idx = U.getDIEIndex(D: Child);
1883 if (Unit.getInfo(Idx).Keep) {
1884 HasChildren = true;
1885 break;
1886 }
1887 }
1888
1889 if (Unit.getOrigUnit().getVersion() >= 5 && !AttrInfo.AttrStrOffsetBaseSeen &&
1890 Die->getTag() == dwarf::DW_TAG_compile_unit) {
1891 // No DW_AT_str_offsets_base seen, add it to the DIE.
1892 Die->addValue(Alloc&: DIEAlloc, Attribute: dwarf::DW_AT_str_offsets_base,
1893 Form: dwarf::DW_FORM_sec_offset, Value: DIEInteger(8));
1894 OutOffset += 4;
1895 }
1896
1897 DIEAbbrev NewAbbrev = Die->generateAbbrev();
1898 if (HasChildren)
1899 NewAbbrev.setChildrenFlag(dwarf::DW_CHILDREN_yes);
1900 // Assign a permanent abbrev number
1901 Linker.assignAbbrev(Abbrev&: NewAbbrev);
1902 Die->setAbbrevNumber(NewAbbrev.getNumber());
1903
1904 uint64_t AbbrevNumberSize = getULEB128Size(Value: Die->getAbbrevNumber());
1905
1906 // Add the size of the abbreviation number to the output offset.
1907 OutOffset += AbbrevNumberSize;
1908
1909 // Update fixups with the size of the abbreviation number
1910 for (AttributeLinkedOffsetFixup &F : AttributesFixups)
1911 F.LinkedOffsetFixupVal += AbbrevNumberSize;
1912
1913 for (AttributeLinkedOffsetFixup &F : AttributesFixups)
1914 ObjFile.Addresses->updateAndSaveValidRelocs(
1915 IsDWARF5: Unit.getOrigUnit().getVersion() >= 5, OriginalUnitOffset: Unit.getOrigUnit().getOffset(),
1916 LinkedOffset: F.LinkedOffsetFixupVal, StartOffset: F.InputAttrStartOffset, EndOffset: F.InputAttrEndOffset);
1917
1918 if (!HasChildren) {
1919 // Update our size.
1920 Die->setSize(OutOffset - Die->getOffset());
1921 return Die;
1922 }
1923
1924 // Recursively clone children.
1925 for (auto Child : InputDIE.children()) {
1926 if (DIE *Clone = cloneDIE(InputDIE: Child, File, Unit, PCOffset, OutOffset, Flags,
1927 IsLittleEndian)) {
1928 Die->addChild(Child: Clone);
1929 OutOffset = Clone->getOffset() + Clone->getSize();
1930 }
1931 }
1932
1933 // Account for the end of children marker.
1934 OutOffset += sizeof(int8_t);
1935 // Update our size.
1936 Die->setSize(OutOffset - Die->getOffset());
1937 return Die;
1938}
1939
1940/// Patch the input object file relevant debug_ranges or debug_rnglists
1941/// entries and emit them in the output file. Update the relevant attributes
1942/// to point at the new entries.
1943void DWARFLinker::generateUnitRanges(CompileUnit &Unit, const DWARFFile &File,
1944 DebugDieValuePool &AddrPool) const {
1945 if (LLVM_UNLIKELY(Options.Update))
1946 return;
1947
1948 const auto &FunctionRanges = Unit.getFunctionRanges();
1949
1950 // Build set of linked address ranges for unit function ranges.
1951 AddressRanges LinkedFunctionRanges;
1952 for (const AddressRangeValuePair &Range : FunctionRanges)
1953 LinkedFunctionRanges.insert(
1954 Range: {Range.Range.start() + Range.Value, Range.Range.end() + Range.Value});
1955
1956 // Emit LinkedFunctionRanges into .debug_aranges
1957 if (!LinkedFunctionRanges.empty())
1958 TheDwarfEmitter->emitDwarfDebugArangesTable(Unit, LinkedRanges: LinkedFunctionRanges);
1959
1960 RngListAttributesTy AllRngListAttributes = Unit.getRangesAttributes();
1961 std::optional<PatchLocation> UnitRngListAttribute =
1962 Unit.getUnitRangesAttribute();
1963
1964 if (!AllRngListAttributes.empty() || UnitRngListAttribute) {
1965 std::optional<AddressRangeValuePair> CachedRange;
1966 MCSymbol *EndLabel = TheDwarfEmitter->emitDwarfDebugRangeListHeader(Unit);
1967
1968 // Read original address ranges, apply relocation value, emit linked address
1969 // ranges.
1970 for (PatchLocation &AttributePatch : AllRngListAttributes) {
1971 // Get ranges from the source DWARF corresponding to the current
1972 // attribute.
1973 AddressRanges LinkedRanges;
1974 if (Expected<DWARFAddressRangesVector> OriginalRanges =
1975 Unit.getOrigUnit().findRnglistFromOffset(Offset: AttributePatch.get())) {
1976 // Apply relocation adjustment.
1977 for (const auto &Range : *OriginalRanges) {
1978 if (!CachedRange || !CachedRange->Range.contains(Addr: Range.LowPC))
1979 CachedRange = FunctionRanges.getRangeThatContains(Addr: Range.LowPC);
1980
1981 // All range entries should lie in the function range.
1982 if (!CachedRange) {
1983 reportWarning(Warning: "inconsistent range data.", File);
1984 continue;
1985 }
1986
1987 // Store range for emiting.
1988 LinkedRanges.insert(Range: {Range.LowPC + CachedRange->Value,
1989 Range.HighPC + CachedRange->Value});
1990 }
1991 } else {
1992 llvm::consumeError(Err: OriginalRanges.takeError());
1993 reportWarning(Warning: "invalid range list ignored.", File);
1994 }
1995
1996 // Emit linked ranges.
1997 TheDwarfEmitter->emitDwarfDebugRangeListFragment(
1998 Unit, LinkedRanges, Patch: AttributePatch, AddrPool);
1999 }
2000
2001 // Emit ranges for Unit AT_ranges attribute.
2002 if (UnitRngListAttribute.has_value())
2003 TheDwarfEmitter->emitDwarfDebugRangeListFragment(
2004 Unit, LinkedRanges: LinkedFunctionRanges, Patch: *UnitRngListAttribute, AddrPool);
2005
2006 // Emit ranges footer.
2007 TheDwarfEmitter->emitDwarfDebugRangeListFooter(Unit, EndLabel);
2008 }
2009}
2010
2011void DWARFLinker::DIECloner::generateUnitLocations(
2012 CompileUnit &Unit, const DWARFFile &File,
2013 ExpressionHandlerRef ExprHandler) {
2014 if (LLVM_UNLIKELY(Linker.Options.Update))
2015 return;
2016
2017 const LocListAttributesTy &AllLocListAttributes =
2018 Unit.getLocationAttributes();
2019
2020 if (AllLocListAttributes.empty())
2021 return;
2022
2023 // Emit locations list table header.
2024 MCSymbol *EndLabel = Emitter->emitDwarfDebugLocListHeader(Unit);
2025
2026 for (auto &CurLocAttr : AllLocListAttributes) {
2027 // Get location expressions vector corresponding to the current attribute
2028 // from the source DWARF.
2029 Expected<DWARFLocationExpressionsVector> OriginalLocations =
2030 Unit.getOrigUnit().findLoclistFromOffset(Offset: CurLocAttr.get());
2031
2032 if (!OriginalLocations) {
2033 llvm::consumeError(Err: OriginalLocations.takeError());
2034 Linker.reportWarning(Warning: "Invalid location attribute ignored.", File);
2035 continue;
2036 }
2037
2038 DWARFLocationExpressionsVector LinkedLocationExpressions;
2039 for (DWARFLocationExpression &CurExpression : *OriginalLocations) {
2040 DWARFLocationExpression LinkedExpression;
2041
2042 if (CurExpression.Range) {
2043 // Relocate address range.
2044 LinkedExpression.Range = {
2045 CurExpression.Range->LowPC + CurLocAttr.RelocAdjustment,
2046 CurExpression.Range->HighPC + CurLocAttr.RelocAdjustment};
2047 }
2048
2049 // Clone expression.
2050 LinkedExpression.Expr.reserve(N: CurExpression.Expr.size());
2051 ExprHandler(CurExpression.Expr, LinkedExpression.Expr,
2052 CurLocAttr.RelocAdjustment);
2053
2054 LinkedLocationExpressions.push_back(x: LinkedExpression);
2055 }
2056
2057 // Emit locations list table fragment corresponding to the CurLocAttr.
2058 Emitter->emitDwarfDebugLocListFragment(Unit, LinkedLocationExpression: LinkedLocationExpressions,
2059 Patch: CurLocAttr, AddrPool);
2060 }
2061
2062 // Emit locations list table footer.
2063 Emitter->emitDwarfDebugLocListFooter(Unit, EndLabel);
2064}
2065
2066static void patchAddrBase(DIE &Die, DIEInteger Offset) {
2067 for (auto &V : Die.values())
2068 if (V.getAttribute() == dwarf::DW_AT_addr_base) {
2069 V = DIEValue(V.getAttribute(), V.getForm(), Offset);
2070 return;
2071 }
2072
2073 llvm_unreachable("Didn't find a DW_AT_addr_base in cloned DIE!");
2074}
2075
2076void DWARFLinker::DIECloner::emitDebugAddrSection(
2077 CompileUnit &Unit, const uint16_t DwarfVersion) const {
2078
2079 if (LLVM_UNLIKELY(Linker.Options.Update))
2080 return;
2081
2082 if (DwarfVersion < 5)
2083 return;
2084
2085 if (AddrPool.getValues().empty())
2086 return;
2087
2088 MCSymbol *EndLabel = Emitter->emitDwarfDebugAddrsHeader(Unit);
2089 patchAddrBase(Die&: *Unit.getOutputUnitDIE(),
2090 Offset: DIEInteger(Emitter->getDebugAddrSectionSize()));
2091 Emitter->emitDwarfDebugAddrs(Addrs: AddrPool.getValues(),
2092 AddrSize: Unit.getOrigUnit().getAddressByteSize());
2093 Emitter->emitDwarfDebugAddrsFooter(Unit, EndLabel);
2094}
2095
2096/// A helper struct to help keep track of the association between the input and
2097/// output rows during line table rewriting. This is used to patch
2098/// DW_AT_LLVM_stmt_sequence attributes, which reference a particular line table
2099/// row.
2100struct TrackedRow {
2101 DWARFDebugLine::Row Row;
2102 size_t OriginalRowIndex;
2103 bool isStartSeqInOutput;
2104};
2105
2106/// Insert the new line info sequence \p Seq into the current
2107/// set of already linked line info \p Rows.
2108static void insertLineSequence(std::vector<TrackedRow> &Seq,
2109 std::vector<TrackedRow> &Rows) {
2110 if (Seq.empty())
2111 return;
2112
2113 // Mark the first row in Seq to indicate it is the start of a sequence
2114 // in the output line table.
2115 Seq.front().isStartSeqInOutput = true;
2116
2117 if (!Rows.empty() && Rows.back().Row.Address < Seq.front().Row.Address) {
2118 llvm::append_range(C&: Rows, R&: Seq);
2119 Seq.clear();
2120 return;
2121 }
2122
2123 object::SectionedAddress Front = Seq.front().Row.Address;
2124 auto InsertPoint = partition_point(
2125 Range&: Rows, P: [=](const TrackedRow &O) { return O.Row.Address < Front; });
2126
2127 // FIXME: this only removes the unneeded end_sequence if the
2128 // sequences have been inserted in order. Using a global sort like
2129 // described in generateLineTableForUnit() and delaying the end_sequence
2130 // elimination to emitLineTableForUnit() we can get rid of all of them.
2131 if (InsertPoint != Rows.end() && InsertPoint->Row.Address == Front &&
2132 InsertPoint->Row.EndSequence) {
2133 *InsertPoint = Seq.front();
2134 Rows.insert(position: InsertPoint + 1, first: Seq.begin() + 1, last: Seq.end());
2135 } else {
2136 Rows.insert(position: InsertPoint, first: Seq.begin(), last: Seq.end());
2137 }
2138
2139 Seq.clear();
2140}
2141
2142static void patchStmtList(DIE &Die, DIEInteger Offset) {
2143 for (auto &V : Die.values())
2144 if (V.getAttribute() == dwarf::DW_AT_stmt_list) {
2145 V = DIEValue(V.getAttribute(), V.getForm(), Offset);
2146 return;
2147 }
2148
2149 llvm_unreachable("Didn't find DW_AT_stmt_list in cloned DIE!");
2150}
2151
2152void DWARFLinker::DIECloner::rememberUnitForMacroOffset(CompileUnit &Unit) {
2153 DWARFUnit &OrigUnit = Unit.getOrigUnit();
2154 DWARFDie OrigUnitDie = OrigUnit.getUnitDIE();
2155
2156 if (std::optional<uint64_t> MacroAttr =
2157 dwarf::toSectionOffset(V: OrigUnitDie.find(Attr: dwarf::DW_AT_macros))) {
2158 UnitMacroMap.insert(KV: std::make_pair(x&: *MacroAttr, y: &Unit));
2159 return;
2160 }
2161
2162 if (std::optional<uint64_t> MacroAttr =
2163 dwarf::toSectionOffset(V: OrigUnitDie.find(Attr: dwarf::DW_AT_macro_info))) {
2164 UnitMacroMap.insert(KV: std::make_pair(x&: *MacroAttr, y: &Unit));
2165 return;
2166 }
2167}
2168
2169void DWARFLinker::DIECloner::generateLineTableForUnit(CompileUnit &Unit) {
2170 if (LLVM_UNLIKELY(Emitter == nullptr))
2171 return;
2172
2173 // Check whether DW_AT_stmt_list attribute is presented.
2174 DWARFDie CUDie = Unit.getOrigUnit().getUnitDIE();
2175 auto StmtList = dwarf::toSectionOffset(V: CUDie.find(Attr: dwarf::DW_AT_stmt_list));
2176 if (!StmtList)
2177 return;
2178
2179 // Update the cloned DW_AT_stmt_list with the correct debug_line offset.
2180 if (auto *OutputDIE = Unit.getOutputUnitDIE())
2181 patchStmtList(Die&: *OutputDIE, Offset: DIEInteger(Emitter->getLineSectionSize()));
2182
2183 if (const DWARFDebugLine::LineTable *LT =
2184 ObjFile.Dwarf->getLineTableForUnit(U: &Unit.getOrigUnit())) {
2185
2186 DWARFDebugLine::LineTable LineTable;
2187
2188 // Set Line Table header.
2189 LineTable.Prologue = LT->Prologue;
2190
2191 // Set Line Table Rows.
2192 if (Linker.Options.Update) {
2193 LineTable.Rows = LT->Rows;
2194 // If all the line table contains is a DW_LNE_end_sequence, clear the line
2195 // table rows, it will be inserted again in the DWARFStreamer.
2196 if (LineTable.Rows.size() == 1 && LineTable.Rows[0].EndSequence)
2197 LineTable.Rows.clear();
2198
2199 LineTable.Sequences = LT->Sequences;
2200
2201 Emitter->emitLineTableForUnit(LineTable, Unit, DebugStrPool,
2202 DebugLineStrPool);
2203 } else {
2204 // Create TrackedRow objects for all input rows.
2205 std::vector<TrackedRow> InputRows;
2206 InputRows.reserve(n: LT->Rows.size());
2207 for (size_t i = 0; i < LT->Rows.size(); i++)
2208 InputRows.emplace_back(args: TrackedRow{.Row: LT->Rows[i], .OriginalRowIndex: i, .isStartSeqInOutput: false});
2209
2210 // This vector is the output line table (still in TrackedRow form).
2211 std::vector<TrackedRow> OutputRows;
2212 OutputRows.reserve(n: InputRows.size());
2213
2214 // Current sequence of rows being extracted, before being inserted
2215 // in OutputRows.
2216 std::vector<TrackedRow> Seq;
2217 Seq.reserve(n: InputRows.size());
2218
2219 const auto &FunctionRanges = Unit.getFunctionRanges();
2220 std::optional<AddressRangeValuePair> CurrRange;
2221
2222 // FIXME: This logic is meant to generate exactly the same output as
2223 // Darwin's classic dsymutil. There is a nicer way to implement this
2224 // by simply putting all the relocated line info in OutputRows and simply
2225 // sorting OutputRows before passing it to emitLineTableForUnit. This
2226 // should be correct as sequences for a function should stay
2227 // together in the sorted output. There are a few corner cases that
2228 // look suspicious though, and that required to implement the logic
2229 // this way. Revisit that once initial validation is finished.
2230
2231 // Iterate over the object file line info and extract the sequences
2232 // that correspond to linked functions.
2233 for (size_t i = 0; i < InputRows.size(); i++) {
2234 TrackedRow TR = InputRows[i];
2235
2236 // Check whether we stepped out of the range. The range is
2237 // half-open, but consider accepting the end address of the range if
2238 // it is marked as end_sequence in the input (because in that
2239 // case, the relocation offset is accurate and that entry won't
2240 // serve as the start of another function).
2241 if (!CurrRange || !CurrRange->Range.contains(Addr: TR.Row.Address.Address)) {
2242 // We just stepped out of a known range. Insert an end_sequence
2243 // corresponding to the end of the range.
2244 uint64_t StopAddress =
2245 CurrRange ? CurrRange->Range.end() + CurrRange->Value : -1ULL;
2246 CurrRange =
2247 FunctionRanges.getRangeThatContains(Addr: TR.Row.Address.Address);
2248 if (StopAddress != -1ULL && !Seq.empty()) {
2249 // Insert end sequence row with the computed end address, but
2250 // the same line as the previous one.
2251 auto NextLine = Seq.back();
2252 NextLine.Row.Address.Address = StopAddress;
2253 NextLine.Row.EndSequence = 1;
2254 NextLine.Row.PrologueEnd = 0;
2255 NextLine.Row.BasicBlock = 0;
2256 NextLine.Row.EpilogueBegin = 0;
2257 Seq.push_back(x: NextLine);
2258 insertLineSequence(Seq, Rows&: OutputRows);
2259 }
2260
2261 if (!CurrRange)
2262 continue;
2263 }
2264
2265 // Ignore empty sequences.
2266 if (TR.Row.EndSequence && Seq.empty())
2267 continue;
2268
2269 // Relocate row address and add it to the current sequence.
2270 TR.Row.Address.Address += CurrRange->Value;
2271 Seq.push_back(x: TR);
2272
2273 if (TR.Row.EndSequence)
2274 insertLineSequence(Seq, Rows&: OutputRows);
2275 }
2276
2277 // Materialize the tracked rows into final DWARFDebugLine::Row objects.
2278 LineTable.Rows.clear();
2279 LineTable.Rows.reserve(n: OutputRows.size());
2280 for (auto &TR : OutputRows)
2281 LineTable.Rows.push_back(x: TR.Row);
2282
2283 // Use OutputRowOffsets to store the offsets of each line table row in the
2284 // output .debug_line section.
2285 std::vector<uint64_t> OutputRowOffsets;
2286
2287 // The unit might not have any DW_AT_LLVM_stmt_sequence attributes, so use
2288 // hasStmtSeq to skip the patching logic.
2289 bool hasStmtSeq = Unit.getStmtSeqListAttributes().size() > 0;
2290 Emitter->emitLineTableForUnit(LineTable, Unit, DebugStrPool,
2291 DebugLineStrPool,
2292 RowOffsets: hasStmtSeq ? &OutputRowOffsets : nullptr);
2293
2294 if (hasStmtSeq) {
2295 assert(OutputRowOffsets.size() == OutputRows.size() &&
2296 "must have an offset for each row");
2297
2298 // Create a map of stmt sequence offsets to original row indices.
2299 DenseMap<uint64_t, unsigned> SeqOffToOrigRow;
2300 for (const DWARFDebugLine::Sequence &Seq : LT->Sequences)
2301 SeqOffToOrigRow[Seq.StmtSeqOffset] = Seq.FirstRowIndex;
2302
2303 // Create a map of original row indices to new row indices.
2304 DenseMap<size_t, size_t> OrigRowToNewRow;
2305 for (size_t i = 0; i < OutputRows.size(); ++i)
2306 OrigRowToNewRow[OutputRows[i].OriginalRowIndex] = i;
2307
2308 // Patch DW_AT_LLVM_stmt_sequence attributes in the compile unit DIE
2309 // with the correct offset into the .debug_line section.
2310 for (const auto &StmtSeq : Unit.getStmtSeqListAttributes()) {
2311 uint64_t OrigStmtSeq = StmtSeq.get();
2312 // 1. Get the original row index from the stmt list offset.
2313 auto OrigRowIter = SeqOffToOrigRow.find(Val: OrigStmtSeq);
2314 // Check whether we have an output sequence for the StmtSeq offset.
2315 // Some sequences are discarded by the DWARFLinker if they are invalid
2316 // (empty).
2317 if (OrigRowIter == SeqOffToOrigRow.end()) {
2318 StmtSeq.set(UINT64_MAX);
2319 continue;
2320 }
2321 size_t OrigRowIndex = OrigRowIter->second;
2322
2323 // 2. Get the new row index from the original row index.
2324 auto NewRowIter = OrigRowToNewRow.find(Val: OrigRowIndex);
2325 if (NewRowIter == OrigRowToNewRow.end()) {
2326 // If the original row index is not found in the map, update the
2327 // stmt_sequence attribute to the 'invalid offset' magic value.
2328 StmtSeq.set(UINT64_MAX);
2329 continue;
2330 }
2331
2332 // 3. Get the offset of the new row in the output .debug_line section.
2333 assert(NewRowIter->second < OutputRowOffsets.size() &&
2334 "New row index out of bounds");
2335 uint64_t NewStmtSeqOffset = OutputRowOffsets[NewRowIter->second];
2336
2337 // 4. Patch the stmt_list attribute with the new offset.
2338 StmtSeq.set(NewStmtSeqOffset);
2339 }
2340 }
2341 }
2342
2343 } else
2344 Linker.reportWarning(Warning: "Cann't load line table.", File: ObjFile);
2345}
2346
2347void DWARFLinker::emitAcceleratorEntriesForUnit(CompileUnit &Unit) {
2348 for (AccelTableKind AccelTableKind : Options.AccelTables) {
2349 switch (AccelTableKind) {
2350 case AccelTableKind::Apple: {
2351 // Add namespaces.
2352 for (const auto &Namespace : Unit.getNamespaces())
2353 AppleNamespaces.addName(Name: Namespace.Name, Args: Namespace.Die->getOffset() +
2354 Unit.getStartOffset());
2355 // Add names.
2356 for (const auto &Pubname : Unit.getPubnames())
2357 AppleNames.addName(Name: Pubname.Name,
2358 Args: Pubname.Die->getOffset() + Unit.getStartOffset());
2359 // Add types.
2360 for (const auto &Pubtype : Unit.getPubtypes())
2361 AppleTypes.addName(
2362 Name: Pubtype.Name, Args: Pubtype.Die->getOffset() + Unit.getStartOffset(),
2363 Args: Pubtype.Die->getTag(),
2364 Args: Pubtype.ObjcClassImplementation ? dwarf::DW_FLAG_type_implementation
2365 : 0,
2366 Args: Pubtype.QualifiedNameHash);
2367 // Add ObjC names.
2368 for (const auto &ObjC : Unit.getObjC())
2369 AppleObjc.addName(Name: ObjC.Name,
2370 Args: ObjC.Die->getOffset() + Unit.getStartOffset());
2371 } break;
2372 case AccelTableKind::Pub: {
2373 TheDwarfEmitter->emitPubNamesForUnit(Unit);
2374 TheDwarfEmitter->emitPubTypesForUnit(Unit);
2375 } break;
2376 case AccelTableKind::DebugNames: {
2377 for (const auto &Namespace : Unit.getNamespaces())
2378 DebugNames.addName(
2379 Name: Namespace.Name, Args: Namespace.Die->getOffset(),
2380 Args: DWARF5AccelTableData::getDefiningParentDieOffset(Die: *Namespace.Die),
2381 Args: Namespace.Die->getTag(), Args: Unit.getUniqueID(),
2382 Args: Unit.getTag() == dwarf::DW_TAG_type_unit);
2383 for (const auto &Pubname : Unit.getPubnames())
2384 DebugNames.addName(
2385 Name: Pubname.Name, Args: Pubname.Die->getOffset(),
2386 Args: DWARF5AccelTableData::getDefiningParentDieOffset(Die: *Pubname.Die),
2387 Args: Pubname.Die->getTag(), Args: Unit.getUniqueID(),
2388 Args: Unit.getTag() == dwarf::DW_TAG_type_unit);
2389 for (const auto &Pubtype : Unit.getPubtypes())
2390 DebugNames.addName(
2391 Name: Pubtype.Name, Args: Pubtype.Die->getOffset(),
2392 Args: DWARF5AccelTableData::getDefiningParentDieOffset(Die: *Pubtype.Die),
2393 Args: Pubtype.Die->getTag(), Args: Unit.getUniqueID(),
2394 Args: Unit.getTag() == dwarf::DW_TAG_type_unit);
2395 } break;
2396 }
2397 }
2398}
2399
2400/// Read the frame info stored in the object, and emit the
2401/// patched frame descriptions for the resulting file.
2402///
2403/// This is actually pretty easy as the data of the CIEs and FDEs can
2404/// be considered as black boxes and moved as is. The only thing to do
2405/// is to patch the addresses in the headers.
2406void DWARFLinker::patchFrameInfoForObject(LinkContext &Context) {
2407 DWARFContext &OrigDwarf = *Context.File.Dwarf;
2408 unsigned SrcAddrSize = OrigDwarf.getDWARFObj().getAddressSize();
2409
2410 StringRef FrameData = OrigDwarf.getDWARFObj().getFrameSection().Data;
2411 if (FrameData.empty())
2412 return;
2413
2414 RangesTy AllUnitsRanges;
2415 for (std::unique_ptr<CompileUnit> &Unit : Context.CompileUnits) {
2416 for (auto CurRange : Unit->getFunctionRanges())
2417 AllUnitsRanges.insert(Range: CurRange.Range, Value: CurRange.Value);
2418 }
2419
2420 DataExtractor Data(FrameData, OrigDwarf.isLittleEndian(), 0);
2421 uint64_t InputOffset = 0;
2422
2423 // Store the data of the CIEs defined in this object, keyed by their
2424 // offsets.
2425 DenseMap<uint64_t, StringRef> LocalCIES;
2426
2427 while (Data.isValidOffset(offset: InputOffset)) {
2428 uint64_t EntryOffset = InputOffset;
2429 uint32_t InitialLength = Data.getU32(offset_ptr: &InputOffset);
2430 if (InitialLength == 0xFFFFFFFF)
2431 return reportWarning(Warning: "Dwarf64 bits no supported", File: Context.File);
2432
2433 uint32_t CIEId = Data.getU32(offset_ptr: &InputOffset);
2434 if (CIEId == 0xFFFFFFFF) {
2435 // This is a CIE, store it.
2436 StringRef CIEData = FrameData.substr(Start: EntryOffset, N: InitialLength + 4);
2437 LocalCIES[EntryOffset] = CIEData;
2438 // The -4 is to account for the CIEId we just read.
2439 InputOffset += InitialLength - 4;
2440 continue;
2441 }
2442
2443 uint64_t Loc = Data.getUnsigned(offset_ptr: &InputOffset, byte_size: SrcAddrSize);
2444
2445 // Some compilers seem to emit frame info that doesn't start at
2446 // the function entry point, thus we can't just lookup the address
2447 // in the debug map. Use the AddressInfo's range map to see if the FDE
2448 // describes something that we can relocate.
2449 std::optional<AddressRangeValuePair> Range =
2450 AllUnitsRanges.getRangeThatContains(Addr: Loc);
2451 if (!Range) {
2452 // The +4 is to account for the size of the InitialLength field itself.
2453 InputOffset = EntryOffset + InitialLength + 4;
2454 continue;
2455 }
2456
2457 // This is an FDE, and we have a mapping.
2458 // Have we already emitted a corresponding CIE?
2459 StringRef CIEData = LocalCIES[CIEId];
2460 if (CIEData.empty())
2461 return reportWarning(Warning: "Inconsistent debug_frame content. Dropping.",
2462 File: Context.File);
2463
2464 // Look if we already emitted a CIE that corresponds to the
2465 // referenced one (the CIE data is the key of that lookup).
2466 auto IteratorInserted = EmittedCIEs.insert(
2467 KV: std::make_pair(x&: CIEData, y: TheDwarfEmitter->getFrameSectionSize()));
2468 // If there is no CIE yet for this ID, emit it.
2469 if (IteratorInserted.second) {
2470 LastCIEOffset = TheDwarfEmitter->getFrameSectionSize();
2471 IteratorInserted.first->getValue() = LastCIEOffset;
2472 TheDwarfEmitter->emitCIE(CIEBytes: CIEData);
2473 }
2474
2475 // Emit the FDE with updated address and CIE pointer.
2476 // (4 + AddrSize) is the size of the CIEId + initial_location
2477 // fields that will get reconstructed by emitFDE().
2478 unsigned FDERemainingBytes = InitialLength - (4 + SrcAddrSize);
2479 TheDwarfEmitter->emitFDE(CIEOffset: IteratorInserted.first->getValue(), AddreSize: SrcAddrSize,
2480 Address: Loc + Range->Value,
2481 Bytes: FrameData.substr(Start: InputOffset, N: FDERemainingBytes));
2482 InputOffset += FDERemainingBytes;
2483 }
2484}
2485
2486uint32_t DWARFLinker::DIECloner::hashFullyQualifiedName(DWARFDie DIE,
2487 CompileUnit &U,
2488 const DWARFFile &File,
2489 int ChildRecurseDepth) {
2490 const char *Name = nullptr;
2491 DWARFUnit *OrigUnit = &U.getOrigUnit();
2492 CompileUnit *CU = &U;
2493 std::optional<DWARFFormValue> Ref;
2494
2495 while (true) {
2496 if (const char *CurrentName = DIE.getName(Kind: DINameKind::ShortName))
2497 Name = CurrentName;
2498
2499 if (!(Ref = DIE.find(Attr: dwarf::DW_AT_specification)) &&
2500 !(Ref = DIE.find(Attr: dwarf::DW_AT_abstract_origin)))
2501 break;
2502
2503 if (!Ref->isFormClass(FC: DWARFFormValue::FC_Reference))
2504 break;
2505
2506 CompileUnit *RefCU;
2507 if (auto RefDIE =
2508 Linker.resolveDIEReference(File, Units: CompileUnits, RefValue: *Ref, DIE, RefCU)) {
2509 CU = RefCU;
2510 OrigUnit = &RefCU->getOrigUnit();
2511 DIE = RefDIE;
2512 }
2513 }
2514
2515 unsigned Idx = OrigUnit->getDIEIndex(D: DIE);
2516 if (!Name && DIE.getTag() == dwarf::DW_TAG_namespace)
2517 Name = "(anonymous namespace)";
2518
2519 if (CU->getInfo(Idx).ParentIdx == 0 ||
2520 // FIXME: dsymutil-classic compatibility. Ignore modules.
2521 CU->getOrigUnit().getDIEAtIndex(Index: CU->getInfo(Idx).ParentIdx).getTag() ==
2522 dwarf::DW_TAG_module)
2523 return djbHash(Buffer: Name ? Name : "", H: djbHash(Buffer: ChildRecurseDepth ? "" : "::"));
2524
2525 DWARFDie Die = OrigUnit->getDIEAtIndex(Index: CU->getInfo(Idx).ParentIdx);
2526 return djbHash(
2527 Buffer: (Name ? Name : ""),
2528 H: djbHash(Buffer: (Name ? "::" : ""),
2529 H: hashFullyQualifiedName(DIE: Die, U&: *CU, File, ChildRecurseDepth: ++ChildRecurseDepth)));
2530}
2531
2532static uint64_t getDwoId(const DWARFDie &CUDie) {
2533 auto DwoId = dwarf::toUnsigned(
2534 V: CUDie.find(Attrs: {dwarf::DW_AT_dwo_id, dwarf::DW_AT_GNU_dwo_id}));
2535 if (DwoId)
2536 return *DwoId;
2537 return 0;
2538}
2539
2540static std::string
2541remapPath(StringRef Path,
2542 const DWARFLinkerBase::ObjectPrefixMapTy &ObjectPrefixMap) {
2543 if (ObjectPrefixMap.empty())
2544 return Path.str();
2545
2546 SmallString<256> p = Path;
2547 for (const auto &Entry : ObjectPrefixMap)
2548 if (llvm::sys::path::replace_path_prefix(Path&: p, OldPrefix: Entry.first, NewPrefix: Entry.second))
2549 break;
2550 return p.str().str();
2551}
2552
2553static std::string
2554getPCMFile(const DWARFDie &CUDie,
2555 const DWARFLinkerBase::ObjectPrefixMapTy *ObjectPrefixMap) {
2556 std::string PCMFile = dwarf::toString(
2557 V: CUDie.find(Attrs: {dwarf::DW_AT_dwo_name, dwarf::DW_AT_GNU_dwo_name}), Default: "");
2558
2559 if (PCMFile.empty())
2560 return PCMFile;
2561
2562 if (ObjectPrefixMap)
2563 PCMFile = remapPath(Path: PCMFile, ObjectPrefixMap: *ObjectPrefixMap);
2564
2565 return PCMFile;
2566}
2567
2568std::pair<bool, bool> DWARFLinker::isClangModuleRef(const DWARFDie &CUDie,
2569 std::string &PCMFile,
2570 LinkContext &Context,
2571 unsigned Indent,
2572 bool Quiet) {
2573 if (PCMFile.empty())
2574 return std::make_pair(x: false, y: false);
2575
2576 // Clang module DWARF skeleton CUs abuse this for the path to the module.
2577 uint64_t DwoId = getDwoId(CUDie);
2578
2579 std::string Name = dwarf::toString(V: CUDie.find(Attr: dwarf::DW_AT_name), Default: "");
2580 if (Name.empty()) {
2581 if (!Quiet)
2582 reportWarning(Warning: "Anonymous module skeleton CU for " + PCMFile,
2583 File: Context.File);
2584 return std::make_pair(x: true, y: true);
2585 }
2586
2587 if (!Quiet && Options.Verbose) {
2588 outs().indent(NumSpaces: Indent);
2589 outs() << "Found clang module reference " << PCMFile;
2590 }
2591
2592 auto Cached = ClangModules.find(Key: PCMFile);
2593 if (Cached != ClangModules.end()) {
2594 // FIXME: Until PR27449 (https://llvm.org/bugs/show_bug.cgi?id=27449) is
2595 // fixed in clang, only warn about DWO_id mismatches in verbose mode.
2596 // ASTFileSignatures will change randomly when a module is rebuilt.
2597 if (!Quiet && Options.Verbose && (Cached->second != DwoId))
2598 reportWarning(Warning: Twine("hash mismatch: this object file was built against a "
2599 "different version of the module ") +
2600 PCMFile,
2601 File: Context.File);
2602 if (!Quiet && Options.Verbose)
2603 outs() << " [cached].\n";
2604 return std::make_pair(x: true, y: true);
2605 }
2606
2607 return std::make_pair(x: true, y: false);
2608}
2609
2610bool DWARFLinker::registerModuleReference(const DWARFDie &CUDie,
2611 LinkContext &Context,
2612 ObjFileLoaderTy Loader,
2613 CompileUnitHandlerTy OnCUDieLoaded,
2614 unsigned Indent) {
2615 std::string PCMFile = getPCMFile(CUDie, ObjectPrefixMap: Options.ObjectPrefixMap);
2616 std::pair<bool, bool> IsClangModuleRef =
2617 isClangModuleRef(CUDie, PCMFile, Context, Indent, Quiet: false);
2618
2619 if (!IsClangModuleRef.first)
2620 return false;
2621
2622 if (IsClangModuleRef.second)
2623 return true;
2624
2625 if (Options.Verbose)
2626 outs() << " ...\n";
2627
2628 // Cyclic dependencies are disallowed by Clang, but we still
2629 // shouldn't run into an infinite loop, so mark it as processed now.
2630 ClangModules.insert(KV: {PCMFile, getDwoId(CUDie)});
2631
2632 if (Error E = loadClangModule(Loader, CUDie, PCMFile, Context, OnCUDieLoaded,
2633 Indent: Indent + 2)) {
2634 consumeError(Err: std::move(E));
2635 return false;
2636 }
2637 return true;
2638}
2639
2640Error DWARFLinker::loadClangModule(
2641 ObjFileLoaderTy Loader, const DWARFDie &CUDie, const std::string &PCMFile,
2642 LinkContext &Context, CompileUnitHandlerTy OnCUDieLoaded, unsigned Indent) {
2643
2644 uint64_t DwoId = getDwoId(CUDie);
2645 std::string ModuleName = dwarf::toString(V: CUDie.find(Attr: dwarf::DW_AT_name), Default: "");
2646
2647 /// Using a SmallString<0> because loadClangModule() is recursive.
2648 SmallString<0> Path(Options.PrependPath);
2649 if (sys::path::is_relative(path: PCMFile))
2650 resolveRelativeObjectPath(Buf&: Path, CU: CUDie);
2651 sys::path::append(path&: Path, a: PCMFile);
2652 // Don't use the cached binary holder because we have no thread-safety
2653 // guarantee and the lifetime is limited.
2654
2655 if (Loader == nullptr) {
2656 reportError(Warning: "Could not load clang module: loader is not specified.\n",
2657 File: Context.File);
2658 return Error::success();
2659 }
2660
2661 auto ErrOrObj = Loader(Context.File.FileName, Path);
2662 if (!ErrOrObj)
2663 return Error::success();
2664
2665 std::unique_ptr<CompileUnit> Unit;
2666 for (const auto &CU : ErrOrObj->Dwarf->compile_units()) {
2667 OnCUDieLoaded(*CU);
2668 // Recursively get all modules imported by this one.
2669 auto ChildCUDie = CU->getUnitDIE();
2670 if (!ChildCUDie)
2671 continue;
2672 if (!registerModuleReference(CUDie: ChildCUDie, Context, Loader, OnCUDieLoaded,
2673 Indent)) {
2674 if (Unit) {
2675 std::string Err =
2676 (PCMFile +
2677 ": Clang modules are expected to have exactly 1 compile unit.\n");
2678 reportError(Warning: Err, File: Context.File);
2679 return make_error<StringError>(Args&: Err, Args: inconvertibleErrorCode());
2680 }
2681 // FIXME: Until PR27449 (https://llvm.org/bugs/show_bug.cgi?id=27449) is
2682 // fixed in clang, only warn about DWO_id mismatches in verbose mode.
2683 // ASTFileSignatures will change randomly when a module is rebuilt.
2684 uint64_t PCMDwoId = getDwoId(CUDie: ChildCUDie);
2685 if (PCMDwoId != DwoId) {
2686 if (Options.Verbose)
2687 reportWarning(
2688 Warning: Twine("hash mismatch: this object file was built against a "
2689 "different version of the module ") +
2690 PCMFile,
2691 File: Context.File);
2692 // Update the cache entry with the DwoId of the module loaded from disk.
2693 ClangModules[PCMFile] = PCMDwoId;
2694 }
2695
2696 // Add this module.
2697 Unit = std::make_unique<CompileUnit>(args&: *CU, args: UniqueUnitID++, args: !Options.NoODR,
2698 args&: ModuleName);
2699 }
2700 }
2701
2702 if (Unit)
2703 Context.ModuleUnits.emplace_back(args: RefModuleUnit{*ErrOrObj, std::move(Unit)});
2704
2705 return Error::success();
2706}
2707
2708uint64_t DWARFLinker::DIECloner::cloneAllCompileUnits(
2709 DWARFContext &DwarfContext, const DWARFFile &File, bool IsLittleEndian) {
2710 uint64_t OutputDebugInfoSize =
2711 (Emitter == nullptr) ? 0 : Emitter->getDebugInfoSectionSize();
2712 const uint64_t StartOutputDebugInfoSize = OutputDebugInfoSize;
2713
2714 for (auto &CurrentUnit : CompileUnits) {
2715 const uint16_t DwarfVersion = CurrentUnit->getOrigUnit().getVersion();
2716 const uint32_t UnitHeaderSize = DwarfVersion >= 5 ? 12 : 11;
2717 auto InputDIE = CurrentUnit->getOrigUnit().getUnitDIE();
2718 CurrentUnit->setStartOffset(OutputDebugInfoSize);
2719 if (!InputDIE) {
2720 OutputDebugInfoSize = CurrentUnit->computeNextUnitOffset(DwarfVersion);
2721 continue;
2722 }
2723 if (CurrentUnit->getInfo(Idx: 0).Keep) {
2724 // Clone the InputDIE into your Unit DIE in our compile unit since it
2725 // already has a DIE inside of it.
2726 CurrentUnit->createOutputDIE();
2727 rememberUnitForMacroOffset(Unit&: *CurrentUnit);
2728 cloneDIE(InputDIE, File, Unit&: *CurrentUnit, PCOffset: 0 /* PC offset */, OutOffset: UnitHeaderSize,
2729 Flags: 0, IsLittleEndian, Die: CurrentUnit->getOutputUnitDIE());
2730 }
2731
2732 OutputDebugInfoSize = CurrentUnit->computeNextUnitOffset(DwarfVersion);
2733
2734 if (Emitter != nullptr) {
2735
2736 generateLineTableForUnit(Unit&: *CurrentUnit);
2737
2738 Linker.emitAcceleratorEntriesForUnit(Unit&: *CurrentUnit);
2739
2740 if (LLVM_UNLIKELY(Linker.Options.Update))
2741 continue;
2742
2743 Linker.generateUnitRanges(Unit&: *CurrentUnit, File, AddrPool);
2744
2745 auto ProcessExpr = [&](SmallVectorImpl<uint8_t> &SrcBytes,
2746 SmallVectorImpl<uint8_t> &OutBytes,
2747 int64_t RelocAdjustment) {
2748 DWARFUnit &OrigUnit = CurrentUnit->getOrigUnit();
2749 DataExtractor Data(SrcBytes, IsLittleEndian,
2750 OrigUnit.getAddressByteSize());
2751 cloneExpression(Data,
2752 Expression: DWARFExpression(Data, OrigUnit.getAddressByteSize(),
2753 OrigUnit.getFormParams().Format),
2754 File, Unit&: *CurrentUnit, OutputBuffer&: OutBytes, AddrRelocAdjustment: RelocAdjustment,
2755 IsLittleEndian);
2756 };
2757 generateUnitLocations(Unit&: *CurrentUnit, File, ExprHandler: ProcessExpr);
2758 emitDebugAddrSection(Unit&: *CurrentUnit, DwarfVersion);
2759 }
2760 AddrPool.clear();
2761 }
2762
2763 if (Emitter != nullptr) {
2764 assert(Emitter);
2765 // Emit macro tables.
2766 Emitter->emitMacroTables(Context: File.Dwarf.get(), UnitMacroMap, StringPool&: DebugStrPool);
2767
2768 // Emit all the compile unit's debug information.
2769 for (auto &CurrentUnit : CompileUnits) {
2770 CurrentUnit->fixupForwardReferences();
2771
2772 if (!CurrentUnit->getOutputUnitDIE())
2773 continue;
2774
2775 unsigned DwarfVersion = CurrentUnit->getOrigUnit().getVersion();
2776
2777 assert(Emitter->getDebugInfoSectionSize() ==
2778 CurrentUnit->getStartOffset());
2779 Emitter->emitCompileUnitHeader(Unit&: *CurrentUnit, DwarfVersion);
2780 Emitter->emitDIE(Die&: *CurrentUnit->getOutputUnitDIE());
2781 assert(Emitter->getDebugInfoSectionSize() ==
2782 CurrentUnit->computeNextUnitOffset(DwarfVersion));
2783 }
2784 }
2785
2786 return OutputDebugInfoSize - StartOutputDebugInfoSize;
2787}
2788
2789void DWARFLinker::copyInvariantDebugSection(DWARFContext &Dwarf) {
2790 TheDwarfEmitter->emitSectionContents(SecData: Dwarf.getDWARFObj().getLocSection().Data,
2791 SecKind: DebugSectionKind::DebugLoc);
2792 TheDwarfEmitter->emitSectionContents(
2793 SecData: Dwarf.getDWARFObj().getRangesSection().Data,
2794 SecKind: DebugSectionKind::DebugRange);
2795 TheDwarfEmitter->emitSectionContents(
2796 SecData: Dwarf.getDWARFObj().getFrameSection().Data, SecKind: DebugSectionKind::DebugFrame);
2797 TheDwarfEmitter->emitSectionContents(SecData: Dwarf.getDWARFObj().getArangesSection(),
2798 SecKind: DebugSectionKind::DebugARanges);
2799 TheDwarfEmitter->emitSectionContents(
2800 SecData: Dwarf.getDWARFObj().getAddrSection().Data, SecKind: DebugSectionKind::DebugAddr);
2801 TheDwarfEmitter->emitSectionContents(
2802 SecData: Dwarf.getDWARFObj().getRnglistsSection().Data,
2803 SecKind: DebugSectionKind::DebugRngLists);
2804 TheDwarfEmitter->emitSectionContents(
2805 SecData: Dwarf.getDWARFObj().getLoclistsSection().Data,
2806 SecKind: DebugSectionKind::DebugLocLists);
2807}
2808
2809void DWARFLinker::addObjectFile(DWARFFile &File, ObjFileLoaderTy Loader,
2810 CompileUnitHandlerTy OnCUDieLoaded) {
2811 ObjectContexts.emplace_back(args: LinkContext(File));
2812
2813 if (ObjectContexts.back().File.Dwarf) {
2814 for (const std::unique_ptr<DWARFUnit> &CU :
2815 ObjectContexts.back().File.Dwarf->compile_units()) {
2816 DWARFDie CUDie = CU->getUnitDIE();
2817
2818 if (!CUDie)
2819 continue;
2820
2821 OnCUDieLoaded(*CU);
2822
2823 if (!LLVM_UNLIKELY(Options.Update))
2824 registerModuleReference(CUDie, Context&: ObjectContexts.back(), Loader,
2825 OnCUDieLoaded);
2826 }
2827 }
2828}
2829
2830Error DWARFLinker::link() {
2831 assert((Options.TargetDWARFVersion != 0) &&
2832 "TargetDWARFVersion should be set");
2833
2834 // First populate the data structure we need for each iteration of the
2835 // parallel loop.
2836 unsigned NumObjects = ObjectContexts.size();
2837
2838 // This Dwarf string pool which is used for emission. It must be used
2839 // serially as the order of calling getStringOffset matters for
2840 // reproducibility.
2841 OffsetsStringPool DebugStrPool(true);
2842 OffsetsStringPool DebugLineStrPool(false);
2843 DebugDieValuePool StringOffsetPool;
2844
2845 // ODR Contexts for the optimize.
2846 DeclContextTree ODRContexts;
2847
2848 for (LinkContext &OptContext : ObjectContexts) {
2849 if (Options.Verbose)
2850 outs() << "DEBUG MAP OBJECT: " << OptContext.File.FileName << "\n";
2851
2852 if (!OptContext.File.Dwarf)
2853 continue;
2854
2855 if (Options.VerifyInputDWARF)
2856 verifyInput(File: OptContext.File);
2857
2858 // Look for relocations that correspond to address map entries.
2859
2860 // there was findvalidrelocations previously ... probably we need to gather
2861 // info here
2862 if (LLVM_LIKELY(!Options.Update) &&
2863 !OptContext.File.Addresses->hasValidRelocs()) {
2864 if (Options.Verbose)
2865 outs() << "No valid relocations found. Skipping.\n";
2866
2867 // Set "Skip" flag as a signal to other loops that we should not
2868 // process this iteration.
2869 OptContext.Skip = true;
2870 continue;
2871 }
2872
2873 // Setup access to the debug info.
2874 if (!OptContext.File.Dwarf)
2875 continue;
2876
2877 // Check whether type units are presented.
2878 if (!OptContext.File.Dwarf->types_section_units().empty()) {
2879 reportWarning(Warning: "type units are not currently supported: file will "
2880 "be skipped",
2881 File: OptContext.File);
2882 OptContext.Skip = true;
2883 continue;
2884 }
2885
2886 // Clone all the clang modules with requires extracting the DIE units. We
2887 // don't need the full debug info until the Analyze phase.
2888 OptContext.CompileUnits.reserve(
2889 n: OptContext.File.Dwarf->getNumCompileUnits());
2890 for (const auto &CU : OptContext.File.Dwarf->compile_units()) {
2891 auto CUDie = CU->getUnitDIE(/*ExtractUnitDIEOnly=*/true);
2892 if (Options.Verbose) {
2893 outs() << "Input compilation unit:";
2894 DIDumpOptions DumpOpts;
2895 DumpOpts.ChildRecurseDepth = 0;
2896 DumpOpts.Verbose = Options.Verbose;
2897 CUDie.dump(OS&: outs(), indent: 0, DumpOpts);
2898 }
2899 }
2900
2901 for (auto &CU : OptContext.ModuleUnits) {
2902 if (Error Err = cloneModuleUnit(Context&: OptContext, Unit&: CU, ODRContexts, DebugStrPool,
2903 DebugLineStrPool, StringOffsetPool))
2904 reportWarning(Warning: toString(E: std::move(Err)), File: CU.File);
2905 }
2906 }
2907
2908 // At this point we know how much data we have emitted. We use this value to
2909 // compare canonical DIE offsets in analyzeContextInfo to see if a definition
2910 // is already emitted, without being affected by canonical die offsets set
2911 // later. This prevents undeterminism when analyze and clone execute
2912 // concurrently, as clone set the canonical DIE offset and analyze reads it.
2913 const uint64_t ModulesEndOffset =
2914 (TheDwarfEmitter == nullptr) ? 0
2915 : TheDwarfEmitter->getDebugInfoSectionSize();
2916
2917 // These variables manage the list of processed object files.
2918 // The mutex and condition variable are to ensure that this is thread safe.
2919 std::mutex ProcessedFilesMutex;
2920 std::condition_variable ProcessedFilesConditionVariable;
2921 BitVector ProcessedFiles(NumObjects, false);
2922
2923 // Analyzing the context info is particularly expensive so it is executed in
2924 // parallel with emitting the previous compile unit.
2925 auto AnalyzeLambda = [&](size_t I) {
2926 auto &Context = ObjectContexts[I];
2927
2928 if (Context.Skip || !Context.File.Dwarf)
2929 return;
2930
2931 for (const auto &CU : Context.File.Dwarf->compile_units()) {
2932 // Previously we only extracted the unit DIEs. We need the full debug info
2933 // now.
2934 auto CUDie = CU->getUnitDIE(/*ExtractUnitDIEOnly=*/false);
2935 std::string PCMFile = getPCMFile(CUDie, ObjectPrefixMap: Options.ObjectPrefixMap);
2936
2937 if (!CUDie || LLVM_UNLIKELY(Options.Update) ||
2938 !isClangModuleRef(CUDie, PCMFile, Context, Indent: 0, Quiet: true).first) {
2939 Context.CompileUnits.push_back(x: std::make_unique<CompileUnit>(
2940 args&: *CU, args: UniqueUnitID++, args: !Options.NoODR && !Options.Update, args: ""));
2941 }
2942 }
2943
2944 // Now build the DIE parent links that we will use during the next phase.
2945 for (auto &CurrentUnit : Context.CompileUnits) {
2946 auto CUDie = CurrentUnit->getOrigUnit().getUnitDIE();
2947 if (!CUDie)
2948 continue;
2949 analyzeContextInfo(DIE: CurrentUnit->getOrigUnit().getUnitDIE(), ParentIdx: 0,
2950 CU&: *CurrentUnit, CurrentDeclContext: &ODRContexts.getRoot(), Contexts&: ODRContexts,
2951 ModulesEndOffset, ParseableSwiftInterfaces: Options.ParseableSwiftInterfaces,
2952 ReportWarning: [&](const Twine &Warning, const DWARFDie &DIE) {
2953 reportWarning(Warning, File: Context.File, DIE: &DIE);
2954 });
2955 }
2956 };
2957
2958 // For each object file map how many bytes were emitted.
2959 StringMap<DebugInfoSize> SizeByObject;
2960
2961 // And then the remaining work in serial again.
2962 // Note, although this loop runs in serial, it can run in parallel with
2963 // the analyzeContextInfo loop so long as we process files with indices >=
2964 // than those processed by analyzeContextInfo.
2965 auto CloneLambda = [&](size_t I) {
2966 auto &OptContext = ObjectContexts[I];
2967 if (OptContext.Skip || !OptContext.File.Dwarf)
2968 return;
2969
2970 // Then mark all the DIEs that need to be present in the generated output
2971 // and collect some information about them.
2972 // Note that this loop can not be merged with the previous one because
2973 // cross-cu references require the ParentIdx to be setup for every CU in
2974 // the object file before calling this.
2975 if (LLVM_UNLIKELY(Options.Update)) {
2976 for (auto &CurrentUnit : OptContext.CompileUnits)
2977 CurrentUnit->markEverythingAsKept();
2978 copyInvariantDebugSection(Dwarf&: *OptContext.File.Dwarf);
2979 } else {
2980 for (auto &CurrentUnit : OptContext.CompileUnits) {
2981 lookForDIEsToKeep(AddressesMap&: *OptContext.File.Addresses, Units: OptContext.CompileUnits,
2982 Die: CurrentUnit->getOrigUnit().getUnitDIE(),
2983 File: OptContext.File, Cu&: *CurrentUnit, Flags: 0);
2984#ifndef NDEBUG
2985 verifyKeepChain(*CurrentUnit);
2986#endif
2987 }
2988 }
2989
2990 // The calls to applyValidRelocs inside cloneDIE will walk the reloc
2991 // array again (in the same way findValidRelocsInDebugInfo() did). We
2992 // need to reset the NextValidReloc index to the beginning.
2993 if (OptContext.File.Addresses->hasValidRelocs() ||
2994 LLVM_UNLIKELY(Options.Update)) {
2995 SizeByObject[OptContext.File.FileName].Input =
2996 getDebugInfoSize(Dwarf&: *OptContext.File.Dwarf);
2997 SizeByObject[OptContext.File.FileName].Output =
2998 DIECloner(*this, TheDwarfEmitter, OptContext.File, DIEAlloc,
2999 OptContext.CompileUnits, Options.Update, DebugStrPool,
3000 DebugLineStrPool, StringOffsetPool)
3001 .cloneAllCompileUnits(DwarfContext&: *OptContext.File.Dwarf, File: OptContext.File,
3002 IsLittleEndian: OptContext.File.Dwarf->isLittleEndian());
3003 }
3004 if ((TheDwarfEmitter != nullptr) && !OptContext.CompileUnits.empty() &&
3005 LLVM_LIKELY(!Options.Update))
3006 patchFrameInfoForObject(Context&: OptContext);
3007
3008 // Clean-up before starting working on the next object.
3009 cleanupAuxiliarryData(Context&: OptContext);
3010 };
3011
3012 auto EmitLambda = [&]() {
3013 // Emit everything that's global.
3014 if (TheDwarfEmitter != nullptr) {
3015 TheDwarfEmitter->emitAbbrevs(Abbrevs: Abbreviations, DwarfVersion: Options.TargetDWARFVersion);
3016 TheDwarfEmitter->emitStrings(Pool: DebugStrPool);
3017 TheDwarfEmitter->emitStringOffsets(StringOffsets: StringOffsetPool.getValues(),
3018 TargetDWARFVersion: Options.TargetDWARFVersion);
3019 TheDwarfEmitter->emitLineStrings(Pool: DebugLineStrPool);
3020 for (AccelTableKind TableKind : Options.AccelTables) {
3021 switch (TableKind) {
3022 case AccelTableKind::Apple:
3023 TheDwarfEmitter->emitAppleNamespaces(Table&: AppleNamespaces);
3024 TheDwarfEmitter->emitAppleNames(Table&: AppleNames);
3025 TheDwarfEmitter->emitAppleTypes(Table&: AppleTypes);
3026 TheDwarfEmitter->emitAppleObjc(Table&: AppleObjc);
3027 break;
3028 case AccelTableKind::Pub:
3029 // Already emitted by emitAcceleratorEntriesForUnit.
3030 // Already emitted by emitAcceleratorEntriesForUnit.
3031 break;
3032 case AccelTableKind::DebugNames:
3033 TheDwarfEmitter->emitDebugNames(Table&: DebugNames);
3034 break;
3035 }
3036 }
3037 }
3038 };
3039
3040 auto AnalyzeAll = [&]() {
3041 for (unsigned I = 0, E = NumObjects; I != E; ++I) {
3042 AnalyzeLambda(I);
3043
3044 std::unique_lock<std::mutex> LockGuard(ProcessedFilesMutex);
3045 ProcessedFiles.set(I);
3046 ProcessedFilesConditionVariable.notify_one();
3047 }
3048 };
3049
3050 auto CloneAll = [&]() {
3051 for (unsigned I = 0, E = NumObjects; I != E; ++I) {
3052 {
3053 std::unique_lock<std::mutex> LockGuard(ProcessedFilesMutex);
3054 if (!ProcessedFiles[I]) {
3055 ProcessedFilesConditionVariable.wait(
3056 lock&: LockGuard, p: [&]() { return ProcessedFiles[I]; });
3057 }
3058 }
3059
3060 CloneLambda(I);
3061 }
3062 EmitLambda();
3063 };
3064
3065 // To limit memory usage in the single threaded case, analyze and clone are
3066 // run sequentially so the OptContext is freed after processing each object
3067 // in endDebugObject.
3068 if (Options.Threads == 1) {
3069 for (unsigned I = 0, E = NumObjects; I != E; ++I) {
3070 AnalyzeLambda(I);
3071 CloneLambda(I);
3072 }
3073 EmitLambda();
3074 } else {
3075 DefaultThreadPool Pool(hardware_concurrency(ThreadCount: 2));
3076 Pool.async(F&: AnalyzeAll);
3077 Pool.async(F&: CloneAll);
3078 Pool.wait();
3079 }
3080
3081 if (Options.Statistics) {
3082 // Create a vector sorted in descending order by output size.
3083 std::vector<std::pair<StringRef, DebugInfoSize>> Sorted;
3084 for (auto &E : SizeByObject)
3085 Sorted.emplace_back(args: E.first(), args&: E.second);
3086 llvm::sort(C&: Sorted, Comp: [](auto &LHS, auto &RHS) {
3087 return LHS.second.Output > RHS.second.Output;
3088 });
3089
3090 auto ComputePercentange = [](int64_t Input, int64_t Output) -> float {
3091 const float Difference = Output - Input;
3092 const float Sum = Input + Output;
3093 if (Sum == 0)
3094 return 0;
3095 return (Difference / (Sum / 2));
3096 };
3097
3098 int64_t InputTotal = 0;
3099 int64_t OutputTotal = 0;
3100 const char *FormatStr = "{0,-45} {1,10}b {2,10}b {3,8:P}\n";
3101
3102 // Print header.
3103 outs() << ".debug_info section size (in bytes)\n";
3104 outs() << "----------------------------------------------------------------"
3105 "---------------\n";
3106 outs() << "Filename Object "
3107 " dSYM Change\n";
3108 outs() << "----------------------------------------------------------------"
3109 "---------------\n";
3110
3111 // Print body.
3112 for (auto &E : Sorted) {
3113 InputTotal += E.second.Input;
3114 OutputTotal += E.second.Output;
3115 llvm::outs() << formatv(
3116 Fmt: FormatStr, Vals: sys::path::filename(path: E.first).take_back(N: 45), Vals&: E.second.Input,
3117 Vals&: E.second.Output, Vals: ComputePercentange(E.second.Input, E.second.Output));
3118 }
3119 // Print total and footer.
3120 outs() << "----------------------------------------------------------------"
3121 "---------------\n";
3122 llvm::outs() << formatv(Fmt: FormatStr, Vals: "Total", Vals&: InputTotal, Vals&: OutputTotal,
3123 Vals: ComputePercentange(InputTotal, OutputTotal));
3124 outs() << "----------------------------------------------------------------"
3125 "---------------\n\n";
3126 }
3127
3128 return Error::success();
3129}
3130
3131Error DWARFLinker::cloneModuleUnit(LinkContext &Context, RefModuleUnit &Unit,
3132 DeclContextTree &ODRContexts,
3133 OffsetsStringPool &DebugStrPool,
3134 OffsetsStringPool &DebugLineStrPool,
3135 DebugDieValuePool &StringOffsetPool,
3136 unsigned Indent) {
3137 assert(Unit.Unit.get() != nullptr);
3138
3139 if (!Unit.Unit->getOrigUnit().getUnitDIE().hasChildren())
3140 return Error::success();
3141
3142 if (Options.Verbose) {
3143 outs().indent(NumSpaces: Indent);
3144 outs() << "cloning .debug_info from " << Unit.File.FileName << "\n";
3145 }
3146
3147 // Analyze context for the module.
3148 analyzeContextInfo(DIE: Unit.Unit->getOrigUnit().getUnitDIE(), ParentIdx: 0, CU&: *(Unit.Unit),
3149 CurrentDeclContext: &ODRContexts.getRoot(), Contexts&: ODRContexts, ModulesEndOffset: 0,
3150 ParseableSwiftInterfaces: Options.ParseableSwiftInterfaces,
3151 ReportWarning: [&](const Twine &Warning, const DWARFDie &DIE) {
3152 reportWarning(Warning, File: Context.File, DIE: &DIE);
3153 });
3154 // Keep everything.
3155 Unit.Unit->markEverythingAsKept();
3156
3157 // Clone unit.
3158 UnitListTy CompileUnits;
3159 CompileUnits.emplace_back(args: std::move(Unit.Unit));
3160 assert(TheDwarfEmitter);
3161 DIECloner(*this, TheDwarfEmitter, Unit.File, DIEAlloc, CompileUnits,
3162 Options.Update, DebugStrPool, DebugLineStrPool, StringOffsetPool)
3163 .cloneAllCompileUnits(DwarfContext&: *Unit.File.Dwarf, File: Unit.File,
3164 IsLittleEndian: Unit.File.Dwarf->isLittleEndian());
3165 return Error::success();
3166}
3167
3168void DWARFLinker::verifyInput(const DWARFFile &File) {
3169 assert(File.Dwarf);
3170
3171 std::string Buffer;
3172 raw_string_ostream OS(Buffer);
3173 DIDumpOptions DumpOpts;
3174 if (!File.Dwarf->verify(OS, DumpOpts: DumpOpts.noImplicitRecursion())) {
3175 if (Options.InputVerificationHandler)
3176 Options.InputVerificationHandler(File, OS.str());
3177 }
3178}
3179
3180} // namespace llvm
3181