1//===- tools/dsymutil/DwarfLinkerForBinary.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 "DwarfLinkerForBinary.h"
10#include "BinaryHolder.h"
11#include "DebugMap.h"
12#include "MachOUtils.h"
13#include "SwiftModule.h"
14#include "dsymutil.h"
15#include "llvm/ADT/ArrayRef.h"
16#include "llvm/ADT/DenseMap.h"
17#include "llvm/ADT/FoldingSet.h"
18#include "llvm/ADT/Hashing.h"
19#include "llvm/ADT/STLExtras.h"
20#include "llvm/ADT/SmallString.h"
21#include "llvm/ADT/StringRef.h"
22#include "llvm/ADT/StringSet.h"
23#include "llvm/ADT/Twine.h"
24#include "llvm/BinaryFormat/Dwarf.h"
25#include "llvm/BinaryFormat/MachO.h"
26#include "llvm/BinaryFormat/Swift.h"
27#include "llvm/CodeGen/AccelTable.h"
28#include "llvm/CodeGen/AsmPrinter.h"
29#include "llvm/CodeGen/DIE.h"
30#include "llvm/CodeGen/NonRelocatableStringpool.h"
31#include "llvm/Config/config.h"
32#include "llvm/DWARFLinker/Classic/DWARFLinker.h"
33#include "llvm/DWARFLinker/Classic/DWARFStreamer.h"
34#include "llvm/DWARFLinker/Parallel/DWARFLinker.h"
35#include "llvm/DebugInfo/DIContext.h"
36#include "llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h"
37#include "llvm/DebugInfo/DWARF/DWARFContext.h"
38#include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
39#include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
40#include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
41#include "llvm/DebugInfo/DWARF/DWARFDie.h"
42#include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
43#include "llvm/DebugInfo/DWARF/DWARFSection.h"
44#include "llvm/DebugInfo/DWARF/DWARFUnit.h"
45#include "llvm/DebugInfo/DWARF/LowLevel/DWARFExpression.h"
46#include "llvm/MC/MCAsmBackend.h"
47#include "llvm/MC/MCAsmInfo.h"
48#include "llvm/MC/MCCodeEmitter.h"
49#include "llvm/MC/MCContext.h"
50#include "llvm/MC/MCDwarf.h"
51#include "llvm/MC/MCInstrInfo.h"
52#include "llvm/MC/MCObjectFileInfo.h"
53#include "llvm/MC/MCObjectWriter.h"
54#include "llvm/MC/MCRegisterInfo.h"
55#include "llvm/MC/MCSection.h"
56#include "llvm/MC/MCStreamer.h"
57#include "llvm/MC/MCSubtargetInfo.h"
58#include "llvm/MC/MCTargetOptions.h"
59#include "llvm/MC/MCTargetOptionsCommandFlags.h"
60#include "llvm/MC/TargetRegistry.h"
61#include "llvm/Object/MachO.h"
62#include "llvm/Object/ObjectFile.h"
63#include "llvm/Object/SymbolicFile.h"
64#include "llvm/Support/Allocator.h"
65#include "llvm/Support/Casting.h"
66#include "llvm/Support/Compiler.h"
67#include "llvm/Support/DJB.h"
68#include "llvm/Support/DataExtractor.h"
69#include "llvm/Support/Error.h"
70#include "llvm/Support/ErrorHandling.h"
71#include "llvm/Support/ErrorOr.h"
72#include "llvm/Support/FileSystem.h"
73#include "llvm/Support/Format.h"
74#include "llvm/Support/LEB128.h"
75#include "llvm/Support/MathExtras.h"
76#include "llvm/Support/MemoryBuffer.h"
77#include "llvm/Support/Path.h"
78#include "llvm/Support/ThreadPool.h"
79#include "llvm/Support/ToolOutputFile.h"
80#include "llvm/Support/WithColor.h"
81#include "llvm/Support/raw_ostream.h"
82#include "llvm/Target/TargetMachine.h"
83#include "llvm/Target/TargetOptions.h"
84#include "llvm/TargetParser/Triple.h"
85#include <algorithm>
86#include <cassert>
87#include <cinttypes>
88#include <climits>
89#include <cstdint>
90#include <cstdlib>
91#include <cstring>
92#include <limits>
93#include <map>
94#include <memory>
95#include <optional>
96#include <string>
97#include <system_error>
98#include <tuple>
99#include <utility>
100#include <vector>
101
102namespace llvm {
103
104static mc::RegisterMCTargetOptionsFlags MOF;
105
106using namespace dwarf_linker;
107
108namespace dsymutil {
109
110static void dumpDIE(const DWARFDie *DIE, bool Verbose) {
111 if (!DIE || !Verbose)
112 return;
113
114 DIDumpOptions DumpOpts;
115 DumpOpts.ChildRecurseDepth = 0;
116 DumpOpts.Verbose = Verbose;
117
118 WithColor::note() << " in DIE:\n";
119 DIE->dump(OS&: errs(), indent: 6 /* Indent */, DumpOpts);
120}
121
122/// Report a warning to the user, optionally including information about a
123/// specific \p DIE related to the warning.
124void DwarfLinkerForBinary::reportWarning(Twine Warning, Twine Context,
125 const DWARFDie *DIE) const {
126 // FIXME: implement warning logging which does not block other threads.
127 if (ErrorHandlerMutex.try_lock()) {
128 warn(Warning, Context);
129 dumpDIE(DIE, Verbose: Options.Verbose);
130 ErrorHandlerMutex.unlock();
131 }
132}
133
134void DwarfLinkerForBinary::reportError(Twine Error, Twine Context,
135 const DWARFDie *DIE) const {
136 // FIXME: implement error logging which does not block other threads.
137 if (ErrorHandlerMutex.try_lock()) {
138 error(Error, Context);
139 dumpDIE(DIE, Verbose: Options.Verbose);
140 ErrorHandlerMutex.unlock();
141 }
142}
143
144ErrorOr<const object::ObjectFile &>
145DwarfLinkerForBinary::loadObject(const DebugMapObject &Obj,
146 const Triple &Triple) {
147 auto ObjectEntry =
148 BinHolder.getObjectEntry(Filename: Obj.getObjectFilename(), Timestamp: Obj.getTimestamp());
149 if (!ObjectEntry) {
150 auto Err = ObjectEntry.takeError();
151 reportWarning(Warning: Twine(Obj.getObjectFilename()) + ": " +
152 toStringWithoutConsuming(E: Err),
153 Context: Obj.getObjectFilename());
154 return errorToErrorCode(Err: std::move(Err));
155 }
156
157 auto Object = ObjectEntry->getObject(T: Triple);
158 if (!Object) {
159 auto Err = Object.takeError();
160 reportWarning(Warning: Twine(Obj.getObjectFilename()) + ": " +
161 toStringWithoutConsuming(E: Err),
162 Context: Obj.getObjectFilename());
163 return errorToErrorCode(Err: std::move(Err));
164 }
165
166 return *Object;
167}
168
169static Error remarksErrorHandler(const DebugMapObject &DMO,
170 DwarfLinkerForBinary &Linker,
171 std::unique_ptr<FileError> FE) {
172 bool IsArchive = DMO.getObjectFilename().ends_with(Suffix: ")");
173 // Don't report errors for missing remark files from static
174 // archives.
175 if (!IsArchive)
176 return Error(std::move(FE));
177
178 std::string Message = FE->message();
179 Error E = FE->takeError();
180 Error NewE = handleErrors(E: std::move(E), Hs: [&](std::unique_ptr<ECError> EC) {
181 if (EC->convertToErrorCode() != std::errc::no_such_file_or_directory)
182 return Error(std::move(EC));
183
184 Linker.reportWarning(Warning: Message, Context: DMO.getObjectFilename());
185 return Error(Error::success());
186 });
187
188 if (!NewE)
189 return Error::success();
190
191 return createFileError(F: FE->getFileName(), E: std::move(NewE));
192}
193Error DwarfLinkerForBinary::emitRelocations(
194 const DebugMap &DM, std::vector<ObjectWithRelocMap> &ObjectsForLinking) {
195 // Return early if the "Resources" directory is not being written to.
196 if (!Options.ResourceDir)
197 return Error::success();
198
199 RelocationMap RM(DM.getTriple(), DM.getBinaryPath());
200 for (auto &Obj : ObjectsForLinking) {
201 if (!Obj.OutRelocs->isInitialized())
202 continue;
203 Obj.OutRelocs->addValidRelocs(RM);
204 }
205
206 SmallString<128> Path;
207 // Create the "Relocations" directory in the "Resources" directory, and
208 // create an architecture-specific directory in the "Relocations" directory.
209 StringRef ArchName = Triple::getArchName(Kind: RM.getTriple().getArch(),
210 SubArch: RM.getTriple().getSubArch());
211 sys::path::append(path&: Path, a: *Options.ResourceDir, b: "Relocations", c: ArchName);
212 if (std::error_code EC = sys::fs::create_directories(path: Path.str(), IgnoreExisting: true,
213 Perms: sys::fs::perms::all_all))
214 return errorCodeToError(EC);
215
216 // Append the file name.
217 sys::path::append(path&: Path, a: sys::path::filename(path: DM.getBinaryPath()));
218 Path.append(RHS: ".yml");
219
220 std::error_code EC;
221 raw_fd_ostream OS(Path.str(), EC, sys::fs::OF_Text);
222 if (EC)
223 return errorCodeToError(EC);
224
225 RM.print(OS);
226 return Error::success();
227}
228
229static Error emitRemarks(const LinkOptions &Options, StringRef BinaryPath,
230 StringRef ArchName, const remarks::RemarkLinker &RL) {
231 // Make sure we don't create the directories and the file if there is nothing
232 // to serialize.
233 if (RL.empty())
234 return Error::success();
235
236 SmallString<128> Path;
237 // Create the "Remarks" directory in the "Resources" directory.
238 sys::path::append(path&: Path, a: *Options.ResourceDir, b: "Remarks");
239 if (std::error_code EC = sys::fs::create_directories(path: Path.str(), IgnoreExisting: true,
240 Perms: sys::fs::perms::all_all))
241 return errorCodeToError(EC);
242
243 // Append the file name.
244 // For fat binaries, also append a dash and the architecture name.
245 sys::path::append(path&: Path, a: sys::path::filename(path: BinaryPath));
246 if (Options.NumDebugMaps > 1) {
247 // More than one debug map means we have a fat binary.
248 Path += '-';
249 Path += ArchName;
250 }
251
252 std::error_code EC;
253 raw_fd_ostream OS(Options.NoOutput ? "-" : Path.str(), EC,
254 Options.RemarksFormat == remarks::Format::Bitstream
255 ? sys::fs::OF_None
256 : sys::fs::OF_Text);
257 if (EC)
258 return errorCodeToError(EC);
259
260 if (Error E = RL.serialize(OS, RemarksFormat: Options.RemarksFormat))
261 return E;
262
263 return Error::success();
264}
265
266ErrorOr<std::unique_ptr<DWARFFile>> DwarfLinkerForBinary::loadObject(
267 const DebugMapObject &Obj, const DebugMap &DebugMap,
268 remarks::RemarkLinker &RL,
269 std::shared_ptr<DwarfLinkerForBinaryRelocationMap> DLBRM) {
270 auto ErrorOrObj = loadObject(Obj, Triple: DebugMap.getTriple());
271 std::unique_ptr<DWARFFile> Res;
272
273 if (ErrorOrObj) {
274 auto Context = DWARFContext::create(
275 Obj: *ErrorOrObj, RelocAction: DWARFContext::ProcessDebugRelocations::Process, L: nullptr,
276 DWPName: "",
277 RecoverableErrorHandler: [&](Error Err) {
278 handleAllErrors(E: std::move(Err), Handlers: [&](ErrorInfoBase &Info) {
279 reportError(Error: Info.message());
280 });
281 },
282 WarningHandler: [&](Error Warning) {
283 handleAllErrors(E: std::move(Warning), Handlers: [&](ErrorInfoBase &Info) {
284 reportWarning(Warning: Info.message());
285 });
286 });
287 DLBRM->init(Context&: *Context);
288 Res = std::make_unique<DWARFFile>(
289 args: Obj.getObjectFilename(), args: std::move(Context),
290 args: std::make_unique<AddressManager>(args&: *this, args: *ErrorOrObj, args: Obj, args&: DLBRM),
291 args: [&](StringRef FileName) { BinHolder.eraseObjectEntry(Filename: FileName); });
292
293 Error E = RL.link(Obj: *ErrorOrObj);
294 if (Error NewE = handleErrors(
295 E: std::move(E), Hs: [&](std::unique_ptr<FileError> EC) -> Error {
296 return remarksErrorHandler(DMO: Obj, Linker&: *this, FE: std::move(EC));
297 }))
298 return errorToErrorCode(Err: std::move(NewE));
299
300 return std::move(Res);
301 }
302
303 return ErrorOrObj.getError();
304}
305
306static bool binaryHasStrippableSwiftReflectionSections(
307 const DebugMap &Map, const LinkOptions &Options, BinaryHolder &BinHolder) {
308 // If the input binary has strippable swift5 reflection sections, there is no
309 // need to copy them to the .dSYM. Only copy them for binaries where the
310 // linker omitted the reflection metadata.
311 if (!Map.getBinaryPath().empty() &&
312 Options.FileType == DWARFLinkerBase::OutputFileType::Object) {
313
314 auto ObjectEntry = BinHolder.getObjectEntry(Filename: Map.getBinaryPath());
315 // If ObjectEntry or Object has an error, no binary exists, therefore no
316 // reflection sections exist.
317 if (!ObjectEntry) {
318 // Any errors will be diagnosed later in the main loop, ignore them here.
319 llvm::consumeError(Err: ObjectEntry.takeError());
320 return false;
321 }
322
323 auto Object =
324 ObjectEntry->getObjectAs<object::MachOObjectFile>(T: Map.getTriple());
325 if (!Object) {
326 // Any errors will be diagnosed later in the main loop, ignore them here.
327 llvm::consumeError(Err: Object.takeError());
328 return false;
329 }
330
331 for (auto &Section : Object->sections()) {
332 llvm::Expected<llvm::StringRef> NameOrErr =
333 Object->getSectionName(Sec: Section.getRawDataRefImpl());
334 if (!NameOrErr) {
335 llvm::consumeError(Err: NameOrErr.takeError());
336 continue;
337 }
338 NameOrErr->consume_back(Suffix: "__TEXT");
339 auto ReflectionSectionKind =
340 Object->mapReflectionSectionNameToEnumValue(SectionName: *NameOrErr);
341 if (Object->isReflectionSectionStrippable(ReflectionSectionKind)) {
342 return true;
343 }
344 }
345 }
346 return false;
347}
348
349/// Calculate the start of the strippable swift reflection sections in Dwarf.
350/// Note that there's an assumption that the reflection sections will appear
351/// in alphabetic order.
352static std::vector<uint64_t>
353calculateStartOfStrippableReflectionSections(const DebugMap &Map) {
354 using llvm::binaryformat::Swift5ReflectionSectionKind;
355 uint64_t AssocTySize = 0;
356 uint64_t FieldMdSize = 0;
357 for (const auto &Obj : Map.objects()) {
358 auto OF =
359 llvm::object::ObjectFile::createObjectFile(ObjectPath: Obj->getObjectFilename());
360 if (!OF) {
361 llvm::consumeError(Err: OF.takeError());
362 continue;
363 }
364 if (auto *MO = dyn_cast<llvm::object::MachOObjectFile>(Val: OF->getBinary())) {
365 for (auto &Section : MO->sections()) {
366 llvm::Expected<llvm::StringRef> NameOrErr =
367 MO->getSectionName(Sec: Section.getRawDataRefImpl());
368 if (!NameOrErr) {
369 llvm::consumeError(Err: NameOrErr.takeError());
370 continue;
371 }
372 NameOrErr->consume_back(Suffix: "__TEXT");
373 auto ReflSectionKind =
374 MO->mapReflectionSectionNameToEnumValue(SectionName: *NameOrErr);
375 switch (ReflSectionKind) {
376 case Swift5ReflectionSectionKind::assocty:
377 AssocTySize += Section.getSize();
378 break;
379 case Swift5ReflectionSectionKind::fieldmd:
380 FieldMdSize += Section.getSize();
381 break;
382 default:
383 break;
384 }
385 }
386 }
387 }
388 // Initialize the vector with enough space to fit every reflection section
389 // kind.
390 std::vector<uint64_t> SectionToOffset(Swift5ReflectionSectionKind::last, 0);
391 SectionToOffset[Swift5ReflectionSectionKind::assocty] = 0;
392 SectionToOffset[Swift5ReflectionSectionKind::fieldmd] =
393 llvm::alignTo(Value: AssocTySize, Align: 4);
394 SectionToOffset[Swift5ReflectionSectionKind::reflstr] = llvm::alignTo(
395 Value: SectionToOffset[Swift5ReflectionSectionKind::fieldmd] + FieldMdSize, Align: 4);
396
397 return SectionToOffset;
398}
399
400void DwarfLinkerForBinary::collectRelocationsToApplyToSwiftReflectionSections(
401 const object::SectionRef &Section, StringRef &Contents,
402 const llvm::object::MachOObjectFile *MO,
403 const std::vector<uint64_t> &SectionToOffsetInDwarf,
404 const llvm::dsymutil::DebugMapObject *Obj,
405 std::vector<MachOUtils::DwarfRelocationApplicationInfo> &RelocationsToApply)
406 const {
407 for (auto It = Section.relocation_begin(); It != Section.relocation_end();
408 ++It) {
409 object::DataRefImpl RelocDataRef = It->getRawDataRefImpl();
410 MachO::any_relocation_info MachOReloc = MO->getRelocation(Rel: RelocDataRef);
411
412 if (!object::MachOObjectFile::isMachOPairedReloc(
413 RelocType: MO->getAnyRelocationType(RE: MachOReloc), Arch: MO->getArch())) {
414 reportWarning(
415 Warning: "Unimplemented relocation type in strippable reflection section ",
416 Context: Obj->getObjectFilename());
417 continue;
418 }
419
420 auto CalculateAddressOfSymbolInDwarfSegment =
421 [&]() -> std::optional<int64_t> {
422 auto Symbol = It->getSymbol();
423 auto SymbolAbsoluteAddress = Symbol->getAddress();
424 if (!SymbolAbsoluteAddress)
425 return {};
426 auto Section = Symbol->getSection();
427 if (!Section) {
428 llvm::consumeError(Err: Section.takeError());
429 return {};
430 }
431
432 if ((*Section)->getObject()->section_end() == *Section)
433 return {};
434
435 auto SectionStart = (*Section)->getAddress();
436 auto SymbolAddressInSection = *SymbolAbsoluteAddress - SectionStart;
437 auto SectionName = (*Section)->getName();
438 if (!SectionName)
439 return {};
440 auto ReflSectionKind =
441 MO->mapReflectionSectionNameToEnumValue(SectionName: *SectionName);
442
443 int64_t SectionStartInLinkedBinary =
444 SectionToOffsetInDwarf[ReflSectionKind];
445
446 auto Addr = SectionStartInLinkedBinary + SymbolAddressInSection;
447 return Addr;
448 };
449
450 // The first symbol should always be in the section we're currently
451 // iterating over.
452 auto FirstSymbolAddress = CalculateAddressOfSymbolInDwarfSegment();
453 ++It;
454
455 bool ShouldSubtractDwarfVM = false;
456 // For the second symbol there are two possibilities.
457 std::optional<int64_t> SecondSymbolAddress;
458 auto Sym = It->getSymbol();
459 if (Sym != MO->symbol_end()) {
460 Expected<StringRef> SymbolName = Sym->getName();
461 if (SymbolName) {
462 if (const auto *Mapping = Obj->lookupSymbol(SymbolName: *SymbolName)) {
463 // First possibility: the symbol exists in the binary, and exists in a
464 // non-strippable section (for example, typeref, or __TEXT,__const),
465 // in which case we look up its address in the binary, which dsymutil
466 // will copy verbatim.
467 SecondSymbolAddress = Mapping->getValue().BinaryAddress;
468 // Since the symbols live in different segments, we have to substract
469 // the start of the Dwarf's vmaddr so the value calculated points to
470 // the correct place.
471 ShouldSubtractDwarfVM = true;
472 }
473 }
474 }
475
476 if (!SecondSymbolAddress) {
477 // Second possibility, this symbol is not present in the main binary, and
478 // must be in one of the strippable sections (for example, reflstr).
479 // Calculate its address in the same way as we did the first one.
480 SecondSymbolAddress = CalculateAddressOfSymbolInDwarfSegment();
481 }
482
483 if (!FirstSymbolAddress || !SecondSymbolAddress)
484 continue;
485
486 auto SectionName = Section.getName();
487 if (!SectionName)
488 continue;
489
490 int32_t Addend;
491 memcpy(dest: &Addend, src: Contents.data() + It->getOffset(), n: sizeof(int32_t));
492 int32_t Value = (*SecondSymbolAddress + Addend) - *FirstSymbolAddress;
493 auto ReflSectionKind =
494 MO->mapReflectionSectionNameToEnumValue(SectionName: *SectionName);
495 uint64_t AddressFromDwarfVM =
496 SectionToOffsetInDwarf[ReflSectionKind] + It->getOffset();
497 RelocationsToApply.emplace_back(args&: AddressFromDwarfVM, args&: Value,
498 args&: ShouldSubtractDwarfVM);
499 }
500}
501
502Error DwarfLinkerForBinary::copySwiftInterfaces(StringRef Architecture) const {
503 std::error_code EC;
504 SmallString<128> InputPath;
505 SmallString<128> Path;
506 sys::path::append(path&: Path, a: *Options.ResourceDir, b: "Swift", c: Architecture);
507 if ((EC = sys::fs::create_directories(path: Path.str(), IgnoreExisting: true,
508 Perms: sys::fs::perms::all_all)))
509 return make_error<StringError>(
510 Args: "cannot create directory: " + toString(E: errorCodeToError(EC)), Args&: EC);
511 unsigned BaseLength = Path.size();
512
513 for (auto &I : ParseableSwiftInterfaces) {
514 StringRef ModuleName = I.first;
515 StringRef InterfaceFile = I.second;
516 if (!Options.PrependPath.empty()) {
517 InputPath.clear();
518 sys::path::append(path&: InputPath, a: Options.PrependPath, b: InterfaceFile);
519 InterfaceFile = InputPath;
520 }
521 sys::path::append(path&: Path, a: ModuleName);
522 Path.append(RHS: ".swiftinterface");
523 if (Options.Verbose)
524 outs() << "copy parseable Swift interface " << InterfaceFile << " -> "
525 << Path.str() << '\n';
526
527 // copy_file attempts an APFS clone first, so this should be cheap.
528 if ((EC = sys::fs::copy_file(From: InterfaceFile, To: Path.str())))
529 reportWarning(Warning: Twine("cannot copy parseable Swift interface ") +
530 InterfaceFile + ": " + toString(E: errorCodeToError(EC)));
531 Path.resize(N: BaseLength);
532 }
533 return Error::success();
534}
535
536void DwarfLinkerForBinary::copySwiftReflectionMetadata(
537 const llvm::dsymutil::DebugMapObject *Obj, classic::DwarfStreamer *Streamer,
538 std::vector<uint64_t> &SectionToOffsetInDwarf,
539 std::vector<MachOUtils::DwarfRelocationApplicationInfo>
540 &RelocationsToApply) {
541 using binaryformat::Swift5ReflectionSectionKind;
542 auto OF =
543 llvm::object::ObjectFile::createObjectFile(ObjectPath: Obj->getObjectFilename());
544 if (!OF) {
545 llvm::consumeError(Err: OF.takeError());
546 return;
547 }
548 if (auto *MO = dyn_cast<llvm::object::MachOObjectFile>(Val: OF->getBinary())) {
549 // Collect the swift reflection sections before emitting them. This is
550 // done so we control the order they're emitted.
551 std::array<std::optional<object::SectionRef>,
552 Swift5ReflectionSectionKind::last + 1>
553 SwiftSections;
554 for (auto &Section : MO->sections()) {
555 llvm::Expected<llvm::StringRef> NameOrErr =
556 MO->getSectionName(Sec: Section.getRawDataRefImpl());
557 if (!NameOrErr) {
558 llvm::consumeError(Err: NameOrErr.takeError());
559 continue;
560 }
561 NameOrErr->consume_back(Suffix: "__TEXT");
562 auto ReflSectionKind =
563 MO->mapReflectionSectionNameToEnumValue(SectionName: *NameOrErr);
564 if (MO->isReflectionSectionStrippable(ReflectionSectionKind: ReflSectionKind))
565 SwiftSections[ReflSectionKind] = Section;
566 }
567 // Make sure we copy the sections in alphabetic order.
568 auto SectionKindsToEmit = {Swift5ReflectionSectionKind::assocty,
569 Swift5ReflectionSectionKind::fieldmd,
570 Swift5ReflectionSectionKind::reflstr};
571 for (auto SectionKind : SectionKindsToEmit) {
572 if (!SwiftSections[SectionKind])
573 continue;
574 auto &Section = *SwiftSections[SectionKind];
575 llvm::Expected<llvm::StringRef> SectionContents = Section.getContents();
576 if (!SectionContents)
577 continue;
578 const auto *MO =
579 llvm::cast<llvm::object::MachOObjectFile>(Val: Section.getObject());
580 collectRelocationsToApplyToSwiftReflectionSections(
581 Section, Contents&: *SectionContents, MO, SectionToOffsetInDwarf, Obj,
582 RelocationsToApply);
583 // Update the section start with the current section's contribution, so
584 // the next section we copy from a different .o file points to the correct
585 // place.
586 SectionToOffsetInDwarf[SectionKind] += Section.getSize();
587 Streamer->emitSwiftReflectionSection(ReflSectionKind: SectionKind, Buffer: *SectionContents,
588 Alignment: Section.getAlignment().value(),
589 Size: Section.getSize());
590 }
591 }
592}
593
594bool DwarfLinkerForBinary::link(const DebugMap &Map) {
595 if (Options.DWARFLinkerType == DsymutilDWARFLinkerType::Parallel)
596 return linkImpl<parallel::DWARFLinker>(Map, ObjectType: Options.FileType);
597
598 return linkImpl<classic::DWARFLinker>(Map, ObjectType: Options.FileType);
599}
600
601template <typename Linker>
602void setAcceleratorTables(Linker &GeneralLinker,
603 DsymutilAccelTableKind TableKind,
604 uint16_t MaxDWARFVersion) {
605 switch (TableKind) {
606 case DsymutilAccelTableKind::Apple:
607 GeneralLinker.addAccelTableKind(Linker::AccelTableKind::Apple);
608 return;
609 case DsymutilAccelTableKind::Dwarf:
610 GeneralLinker.addAccelTableKind(Linker::AccelTableKind::DebugNames);
611 return;
612 case DsymutilAccelTableKind::Pub:
613 GeneralLinker.addAccelTableKind(Linker::AccelTableKind::Pub);
614 return;
615 case DsymutilAccelTableKind::Default:
616 if (MaxDWARFVersion >= 5)
617 GeneralLinker.addAccelTableKind(Linker::AccelTableKind::DebugNames);
618 else
619 GeneralLinker.addAccelTableKind(Linker::AccelTableKind::Apple);
620 return;
621 case DsymutilAccelTableKind::None:
622 // Nothing to do.
623 return;
624 }
625
626 llvm_unreachable("All cases handled above!");
627}
628
629template <typename Linker>
630bool DwarfLinkerForBinary::linkImpl(
631 const DebugMap &Map, typename Linker::OutputFileType ObjectType) {
632
633 std::vector<ObjectWithRelocMap> ObjectsForLinking;
634
635 DebugMap DebugMap(Map.getTriple(), Map.getBinaryPath());
636
637 std::unique_ptr<Linker> GeneralLinker = Linker::createLinker(
638 [&](const Twine &Error, StringRef Context, const DWARFDie *DIE) {
639 reportError(Error, Context, DIE);
640 },
641 [&](const Twine &Warning, StringRef Context, const DWARFDie *DIE) {
642 reportWarning(Warning, Context, DIE);
643 });
644
645 std::unique_ptr<classic::DwarfStreamer> Streamer;
646 if (!Options.NoOutput) {
647 if (Expected<std::unique_ptr<classic::DwarfStreamer>> StreamerOrErr =
648 classic::DwarfStreamer::createStreamer(
649 TheTriple: Map.getTriple(), FileType: ObjectType, OutFile,
650 Warning: [&](const Twine &Warning, StringRef Context,
651 const DWARFDie *DIE) {
652 reportWarning(Warning, Context, DIE);
653 }))
654 Streamer = std::move(*StreamerOrErr);
655 else {
656 handleAllErrors(StreamerOrErr.takeError(), [&](const ErrorInfoBase &EI) {
657 reportError(Error: EI.message(), Context: "dwarf streamer init");
658 });
659 return false;
660 }
661
662 if constexpr (std::is_same<Linker, parallel::DWARFLinker>::value) {
663 GeneralLinker->setOutputDWARFHandler(
664 Map.getTriple(),
665 [&](std::shared_ptr<parallel::SectionDescriptorBase> Section) {
666 Streamer->emitSectionContents(SecData: Section->getContents(),
667 SecKind: Section->getKind());
668 });
669 } else
670 GeneralLinker->setOutputDWARFEmitter(Streamer.get());
671 }
672
673 remarks::RemarkLinker RL;
674 if (!Options.RemarksPrependPath.empty())
675 RL.setExternalFilePrependPath(Options.RemarksPrependPath);
676 RL.setKeepAllRemarks(Options.RemarksKeepAll);
677 GeneralLinker->setObjectPrefixMap(&Options.ObjectPrefixMap);
678
679 GeneralLinker->setVerbosity(Options.Verbose);
680 GeneralLinker->setStatistics(Options.Statistics);
681 GeneralLinker->setVerifyInputDWARF(Options.VerifyInputDWARF);
682 GeneralLinker->setNoODR(Options.NoODR);
683 GeneralLinker->setUpdateIndexTablesOnly(Options.Update);
684 GeneralLinker->setNumThreads(Options.Threads);
685 GeneralLinker->setPrependPath(Options.PrependPath);
686 GeneralLinker->setKeepFunctionForStatic(Options.KeepFunctionForStatic);
687 GeneralLinker->setInputVerificationHandler(
688 [&](const DWARFFile &File, llvm::StringRef Output) {
689 std::lock_guard<std::mutex> Guard(ErrorHandlerMutex);
690 if (Options.Verbose)
691 errs() << Output;
692 warn(Warning: "input verification failed", Context: File.FileName);
693 HasVerificationErrors = true;
694 });
695 auto Loader = [&](StringRef ContainerName,
696 StringRef Path) -> ErrorOr<DWARFFile &> {
697 auto &Obj = DebugMap.addDebugMapObject(
698 ObjectFilePath: Path, Timestamp: sys::TimePoint<std::chrono::seconds>(), Type: MachO::N_OSO);
699
700 auto DLBRelocMap = std::make_shared<DwarfLinkerForBinaryRelocationMap>();
701 if (ErrorOr<std::unique_ptr<DWARFFile>> ErrorOrObj =
702 loadObject(Obj, DebugMap, RL, DLBRM: DLBRelocMap)) {
703 ObjectsForLinking.emplace_back(args: std::move(*ErrorOrObj), args&: DLBRelocMap);
704 return *ObjectsForLinking.back().Object;
705 } else {
706 // Try and emit more helpful warnings by applying some heuristics.
707 StringRef ObjFile = ContainerName;
708 bool IsClangModule = sys::path::extension(path: Path) == ".pcm";
709 bool IsArchive = ObjFile.ends_with(Suffix: ")");
710
711 if (IsClangModule) {
712 StringRef ModuleCacheDir = sys::path::parent_path(path: Path);
713 if (sys::fs::exists(Path: ModuleCacheDir)) {
714 // If the module's parent directory exists, we assume that the
715 // module cache has expired and was pruned by clang. A more
716 // adventurous dsymutil would invoke clang to rebuild the module
717 // now.
718 if (!ModuleCacheHintDisplayed) {
719 WithColor::note()
720 << "The clang module cache may have expired since "
721 "this object file was built. Rebuilding the "
722 "object file will rebuild the module cache.\n";
723 ModuleCacheHintDisplayed = true;
724 }
725 } else if (IsArchive) {
726 // If the module cache directory doesn't exist at all and the
727 // object file is inside a static library, we assume that the
728 // static library was built on a different machine. We don't want
729 // to discourage module debugging for convenience libraries within
730 // a project though.
731 if (!ArchiveHintDisplayed) {
732 WithColor::note()
733 << "Linking a static library that was built with "
734 "-gmodules, but the module cache was not found. "
735 "Redistributable static libraries should never be "
736 "built with module debugging enabled. The debug "
737 "experience will be degraded due to incomplete "
738 "debug information.\n";
739 ArchiveHintDisplayed = true;
740 }
741 }
742 }
743
744 return ErrorOrObj.getError();
745 }
746
747 llvm_unreachable("Unhandled DebugMap object");
748 };
749 GeneralLinker->setSwiftInterfacesMap(&ParseableSwiftInterfaces);
750 bool ReflectionSectionsPresentInBinary = false;
751 // If there is no output specified, no point in checking the binary for swift5
752 // reflection sections.
753 if (!Options.NoOutput) {
754 ReflectionSectionsPresentInBinary =
755 binaryHasStrippableSwiftReflectionSections(Map, Options, BinHolder);
756 }
757
758 std::vector<MachOUtils::DwarfRelocationApplicationInfo> RelocationsToApply;
759 if (!Options.NoOutput && !ReflectionSectionsPresentInBinary) {
760 auto SectionToOffsetInDwarf =
761 calculateStartOfStrippableReflectionSections(Map);
762 for (const auto &Obj : Map.objects())
763 copySwiftReflectionMetadata(Obj: Obj.get(), Streamer: Streamer.get(),
764 SectionToOffsetInDwarf, RelocationsToApply);
765 }
766
767 uint16_t MaxDWARFVersion = 0;
768 std::function<void(const DWARFUnit &Unit)> OnCUDieLoaded =
769 [&MaxDWARFVersion](const DWARFUnit &Unit) {
770 MaxDWARFVersion = std::max(a: Unit.getVersion(), b: MaxDWARFVersion);
771 };
772
773 llvm::StringSet<> SwiftModules;
774 for (const auto &Obj : Map.objects()) {
775 // N_AST objects (swiftmodule files) should get dumped directly into the
776 // appropriate DWARF section.
777 if (Obj->getType() == MachO::N_AST) {
778 if (Options.Verbose)
779 outs() << "DEBUG MAP OBJECT: " << Obj->getObjectFilename() << "\n";
780
781 StringRef File = Obj->getObjectFilename();
782 if (!SwiftModules.insert(key: File).second)
783 continue;
784
785 auto ErrorOrMem = MemoryBuffer::getFile(Filename: File);
786 if (!ErrorOrMem) {
787 reportWarning(Warning: "Could not open '" + File + "'");
788 continue;
789 }
790 auto FromInterfaceOrErr =
791 IsBuiltFromSwiftInterface(data: (*ErrorOrMem)->getBuffer());
792 if (!FromInterfaceOrErr) {
793 reportWarning(Warning: "Could not parse binary Swift module: " +
794 toString(E: FromInterfaceOrErr.takeError()),
795 Context: Obj->getObjectFilename());
796 // Only skip swiftmodules that could be parsed and are
797 // positively identified as textual.
798 } else if (*FromInterfaceOrErr) {
799 if (Options.Verbose)
800 outs() << "Skipping compiled textual Swift interface: "
801 << Obj->getObjectFilename() << "\n";
802 continue;
803 }
804
805 sys::fs::file_status Stat;
806 if (auto Err = sys::fs::status(path: File, result&: Stat)) {
807 reportWarning(Warning: Err.message());
808 continue;
809 }
810 if (!Options.NoTimestamp) {
811 // The modification can have sub-second precision so we need to cast
812 // away the extra precision that's not present in the debug map.
813 auto ModificationTime =
814 std::chrono::time_point_cast<std::chrono::seconds>(
815 t: Stat.getLastModificationTime());
816 if (Obj->getTimestamp() != sys::TimePoint<>() &&
817 ModificationTime != Obj->getTimestamp()) {
818 // Not using the helper here as we can easily stream TimePoint<>.
819 WithColor::warning()
820 << File << ": timestamp mismatch between swift interface file ("
821 << sys::TimePoint<>(ModificationTime) << ") and debug map ("
822 << sys::TimePoint<>(Obj->getTimestamp()) << ")\n";
823 continue;
824 }
825 }
826
827 // Copy the module into the .swift_ast section.
828 if (!Options.NoOutput)
829 Streamer->emitSwiftAST(Buffer: (*ErrorOrMem)->getBuffer());
830
831 continue;
832 }
833
834 auto DLBRelocMap = std::make_shared<DwarfLinkerForBinaryRelocationMap>();
835 if (ErrorOr<std::unique_ptr<DWARFFile>> ErrorOrObj =
836 loadObject(Obj: *Obj, DebugMap: Map, RL, DLBRM: DLBRelocMap)) {
837 ObjectsForLinking.emplace_back(args: std::move(*ErrorOrObj), args&: DLBRelocMap);
838 GeneralLinker->addObjectFile(*ObjectsForLinking.back().Object, Loader,
839 OnCUDieLoaded);
840 } else {
841 ObjectsForLinking.push_back(
842 x: {std::make_unique<DWARFFile>(args: Obj->getObjectFilename(), args: nullptr,
843 args: nullptr),
844 DLBRelocMap});
845 GeneralLinker->addObjectFile(*ObjectsForLinking.back().Object);
846 }
847 }
848
849 // If we haven't seen any CUs, pick an arbitrary valid Dwarf version anyway.
850 if (MaxDWARFVersion == 0)
851 MaxDWARFVersion = 3;
852
853 if (Error E = GeneralLinker->setTargetDWARFVersion(MaxDWARFVersion))
854 return error(Error: toString(E: std::move(E)));
855
856 setAcceleratorTables<Linker>(*GeneralLinker, Options.TheAccelTableKind,
857 MaxDWARFVersion);
858
859 // link debug info for loaded object files.
860 if (Error E = GeneralLinker->link())
861 return error(Error: toString(E: std::move(E)));
862
863 StringRef ArchName = Map.getTriple().getArchName();
864 if (Error E = emitRemarks(Options, BinaryPath: Map.getBinaryPath(), ArchName, RL))
865 return error(Error: toString(E: std::move(E)));
866
867 if (Options.NoOutput)
868 return true;
869
870 if (Error E = emitRelocations(DM: Map, ObjectsForLinking))
871 return error(Error: toString(E: std::move(E)));
872
873 if (Options.ResourceDir && !ParseableSwiftInterfaces.empty()) {
874 StringRef ArchName = Triple::getArchTypeName(Kind: Map.getTriple().getArch());
875 if (auto E = copySwiftInterfaces(Architecture: ArchName))
876 return error(Error: toString(E: std::move(E)));
877 }
878
879 auto MapTriple = Map.getTriple();
880 if ((MapTriple.isOSDarwin() || MapTriple.isOSBinFormatMachO()) &&
881 !Map.getBinaryPath().empty() &&
882 ObjectType == Linker::OutputFileType::Object)
883 return MachOUtils::generateDsymCompanion(
884 VFS: Options.VFS, DM: Map, MS&: *Streamer->getAsmPrinter().OutStreamer, OutFile,
885 RelocationsToApply);
886
887 Streamer->finish();
888 return true;
889}
890
891/// Iterate over the relocations of the given \p Section and
892/// store the ones that correspond to debug map entries into the
893/// ValidRelocs array.
894void DwarfLinkerForBinary::AddressManager::findValidRelocsMachO(
895 const object::SectionRef &Section, const object::MachOObjectFile &Obj,
896 const DebugMapObject &DMO, std::vector<ValidReloc> &ValidRelocs) {
897 Expected<StringRef> ContentsOrErr = Section.getContents();
898 if (!ContentsOrErr) {
899 consumeError(Err: ContentsOrErr.takeError());
900 Linker.reportWarning(Warning: "error reading section", Context: DMO.getObjectFilename());
901 return;
902 }
903 DataExtractor Data(*ContentsOrErr, Obj.isLittleEndian(), 0);
904 bool SkipNext = false;
905
906 for (const object::RelocationRef &Reloc : Section.relocations()) {
907 if (SkipNext) {
908 SkipNext = false;
909 continue;
910 }
911
912 object::DataRefImpl RelocDataRef = Reloc.getRawDataRefImpl();
913 MachO::any_relocation_info MachOReloc = Obj.getRelocation(Rel: RelocDataRef);
914
915 if (object::MachOObjectFile::isMachOPairedReloc(RelocType: Obj.getAnyRelocationType(RE: MachOReloc),
916 Arch: Obj.getArch())) {
917 SkipNext = true;
918 Linker.reportWarning(Warning: "unsupported relocation in " + *Section.getName() +
919 " section.",
920 Context: DMO.getObjectFilename());
921 continue;
922 }
923
924 unsigned RelocSize = 1 << Obj.getAnyRelocationLength(RE: MachOReloc);
925 uint64_t Offset64 = Reloc.getOffset();
926 if ((RelocSize != 4 && RelocSize != 8)) {
927 Linker.reportWarning(Warning: "unsupported relocation in " + *Section.getName() +
928 " section.",
929 Context: DMO.getObjectFilename());
930 continue;
931 }
932 uint64_t OffsetCopy = Offset64;
933 // Mach-o uses REL relocations, the addend is at the relocation offset.
934 uint64_t Addend = Data.getUnsigned(offset_ptr: &OffsetCopy, byte_size: RelocSize);
935 uint64_t SymAddress;
936 int64_t SymOffset;
937
938 if (Obj.isRelocationScattered(RE: MachOReloc)) {
939 // The address of the base symbol for scattered relocations is
940 // stored in the reloc itself. The actual addend will store the
941 // base address plus the offset.
942 SymAddress = Obj.getScatteredRelocationValue(RE: MachOReloc);
943 SymOffset = int64_t(Addend) - SymAddress;
944 } else {
945 SymAddress = Addend;
946 SymOffset = 0;
947 }
948
949 auto Sym = Reloc.getSymbol();
950 if (Sym != Obj.symbol_end()) {
951 Expected<StringRef> SymbolName = Sym->getName();
952 if (!SymbolName) {
953 consumeError(Err: SymbolName.takeError());
954 Linker.reportWarning(Warning: "error getting relocation symbol name.",
955 Context: DMO.getObjectFilename());
956 continue;
957 }
958 if (const auto *Mapping = DMO.lookupSymbol(SymbolName: *SymbolName))
959 ValidRelocs.emplace_back(args&: Offset64, args&: RelocSize, args&: Addend, args: Mapping->getKey(),
960 args: Mapping->getValue());
961 } else if (const auto *Mapping = DMO.lookupObjectAddress(Address: SymAddress)) {
962 // Do not store the addend. The addend was the address of the symbol in
963 // the object file, the address in the binary that is stored in the debug
964 // map doesn't need to be offset.
965 ValidRelocs.emplace_back(args&: Offset64, args&: RelocSize, args&: SymOffset,
966 args: Mapping->getKey(), args: Mapping->getValue());
967 }
968 }
969}
970
971/// Dispatch the valid relocation finding logic to the
972/// appropriate handler depending on the object file format.
973bool DwarfLinkerForBinary::AddressManager::findValidRelocs(
974 const object::SectionRef &Section, const object::ObjectFile &Obj,
975 const DebugMapObject &DMO, std::vector<ValidReloc> &Relocs) {
976 // Dispatch to the right handler depending on the file type.
977 if (auto *MachOObj = dyn_cast<object::MachOObjectFile>(Val: &Obj))
978 findValidRelocsMachO(Section, Obj: *MachOObj, DMO, ValidRelocs&: Relocs);
979 else
980 Linker.reportWarning(Warning: Twine("unsupported object file type: ") +
981 Obj.getFileName(),
982 Context: DMO.getObjectFilename());
983 if (Relocs.empty())
984 return false;
985
986 // Sort the relocations by offset. We will walk the DIEs linearly in
987 // the file, this allows us to just keep an index in the relocation
988 // array that we advance during our walk, rather than resorting to
989 // some associative container. See DwarfLinkerForBinary::NextValidReloc.
990 llvm::sort(C&: Relocs);
991 return true;
992}
993
994/// Look for relocations in the debug_info and debug_addr section that match
995/// entries in the debug map. These relocations will drive the Dwarf link by
996/// indicating which DIEs refer to symbols present in the linked binary.
997/// \returns whether there are any valid relocations in the debug info.
998bool DwarfLinkerForBinary::AddressManager::findValidRelocsInDebugSections(
999 const object::ObjectFile &Obj, const DebugMapObject &DMO) {
1000 // Find the debug_info section.
1001 bool FoundValidRelocs = false;
1002 for (const object::SectionRef &Section : Obj.sections()) {
1003 StringRef SectionName;
1004 if (Expected<StringRef> NameOrErr = Section.getName())
1005 SectionName = *NameOrErr;
1006 else
1007 consumeError(Err: NameOrErr.takeError());
1008
1009 SectionName = SectionName.substr(Start: SectionName.find_first_not_of(Chars: "._"));
1010 if (SectionName == "debug_info")
1011 FoundValidRelocs |=
1012 findValidRelocs(Section, Obj, DMO, Relocs&: ValidDebugInfoRelocs);
1013 if (SectionName == "debug_addr")
1014 FoundValidRelocs |=
1015 findValidRelocs(Section, Obj, DMO, Relocs&: ValidDebugAddrRelocs);
1016 }
1017 return FoundValidRelocs;
1018}
1019
1020std::vector<ValidReloc> DwarfLinkerForBinary::AddressManager::getRelocations(
1021 const std::vector<ValidReloc> &Relocs, uint64_t StartPos, uint64_t EndPos) {
1022 std::vector<ValidReloc> Res;
1023
1024 auto CurReloc = partition_point(Range: Relocs, P: [StartPos](const ValidReloc &Reloc) {
1025 return (uint64_t)Reloc.Offset < StartPos;
1026 });
1027
1028 while (CurReloc != Relocs.end() && CurReloc->Offset >= StartPos &&
1029 (uint64_t)CurReloc->Offset < EndPos) {
1030 Res.push_back(x: *CurReloc);
1031 CurReloc++;
1032 }
1033
1034 return Res;
1035}
1036
1037void DwarfLinkerForBinary::AddressManager::printReloc(const ValidReloc &Reloc) {
1038 const auto &Mapping = Reloc.SymbolMapping;
1039 const uint64_t ObjectAddress = Mapping.ObjectAddress
1040 ? uint64_t(*Mapping.ObjectAddress)
1041 : std::numeric_limits<uint64_t>::max();
1042
1043 outs() << "Found valid debug map entry: " << Reloc.SymbolName << "\t"
1044 << format(Fmt: "0x%016" PRIx64 " => 0x%016" PRIx64 "\n", Vals: ObjectAddress,
1045 Vals: uint64_t(Mapping.BinaryAddress));
1046}
1047
1048int64_t
1049DwarfLinkerForBinary::AddressManager::getRelocValue(const ValidReloc &Reloc) {
1050 int64_t AddrAdjust = relocate(Reloc);
1051 if (Reloc.SymbolMapping.ObjectAddress)
1052 AddrAdjust -= uint64_t(*Reloc.SymbolMapping.ObjectAddress);
1053 return AddrAdjust;
1054}
1055
1056std::optional<int64_t>
1057DwarfLinkerForBinary::AddressManager::hasValidRelocationAt(
1058 const std::vector<ValidReloc> &AllRelocs, uint64_t StartOffset,
1059 uint64_t EndOffset, bool Verbose) {
1060 std::vector<ValidReloc> Relocs =
1061 getRelocations(Relocs: AllRelocs, StartPos: StartOffset, EndPos: EndOffset);
1062 if (Relocs.size() == 0)
1063 return std::nullopt;
1064
1065 if (Verbose)
1066 printReloc(Reloc: Relocs[0]);
1067
1068 return getRelocValue(Reloc: Relocs[0]);
1069}
1070
1071/// Get the starting and ending (exclusive) offset for the
1072/// attribute with index \p Idx descibed by \p Abbrev. \p Offset is
1073/// supposed to point to the position of the first attribute described
1074/// by \p Abbrev.
1075/// \return [StartOffset, EndOffset) as a pair.
1076static std::pair<uint64_t, uint64_t>
1077getAttributeOffsets(const DWARFAbbreviationDeclaration *Abbrev, unsigned Idx,
1078 uint64_t Offset, const DWARFUnit &Unit) {
1079 DataExtractor Data = Unit.getDebugInfoExtractor();
1080
1081 for (unsigned I = 0; I < Idx; ++I)
1082 DWARFFormValue::skipValue(Form: Abbrev->getFormByIndex(idx: I), DebugInfoData: Data, OffsetPtr: &Offset,
1083 FormParams: Unit.getFormParams());
1084
1085 uint64_t End = Offset;
1086 DWARFFormValue::skipValue(Form: Abbrev->getFormByIndex(idx: Idx), DebugInfoData: Data, OffsetPtr: &End,
1087 FormParams: Unit.getFormParams());
1088
1089 return std::make_pair(x&: Offset, y&: End);
1090}
1091
1092std::optional<int64_t>
1093DwarfLinkerForBinary::AddressManager::getExprOpAddressRelocAdjustment(
1094 DWARFUnit &U, const DWARFExpression::Operation &Op, uint64_t StartOffset,
1095 uint64_t EndOffset, bool Verbose) {
1096 switch (Op.getCode()) {
1097 default: {
1098 assert(false && "Specified operation does not have address operand");
1099 } break;
1100 case dwarf::DW_OP_const2u:
1101 case dwarf::DW_OP_const4u:
1102 case dwarf::DW_OP_const8u:
1103 case dwarf::DW_OP_const2s:
1104 case dwarf::DW_OP_const4s:
1105 case dwarf::DW_OP_const8s:
1106 case dwarf::DW_OP_addr: {
1107 return hasValidRelocationAt(AllRelocs: ValidDebugInfoRelocs, StartOffset, EndOffset,
1108 Verbose);
1109 } break;
1110 case dwarf::DW_OP_constx:
1111 case dwarf::DW_OP_addrx: {
1112 return hasValidRelocationAt(AllRelocs: ValidDebugAddrRelocs, StartOffset, EndOffset,
1113 Verbose);
1114 } break;
1115 }
1116
1117 return std::nullopt;
1118}
1119
1120std::optional<int64_t>
1121DwarfLinkerForBinary::AddressManager::getSubprogramRelocAdjustment(
1122 const DWARFDie &DIE, bool Verbose) {
1123 const auto *Abbrev = DIE.getAbbreviationDeclarationPtr();
1124
1125 std::optional<uint32_t> LowPcIdx =
1126 Abbrev->findAttributeIndex(attr: dwarf::DW_AT_low_pc);
1127 if (!LowPcIdx)
1128 return std::nullopt;
1129
1130 dwarf::Form Form = Abbrev->getFormByIndex(idx: *LowPcIdx);
1131
1132 switch (Form) {
1133 case dwarf::DW_FORM_addr: {
1134 uint64_t Offset = DIE.getOffset() + getULEB128Size(Value: Abbrev->getCode());
1135 uint64_t LowPcOffset, LowPcEndOffset;
1136 std::tie(args&: LowPcOffset, args&: LowPcEndOffset) =
1137 getAttributeOffsets(Abbrev, Idx: *LowPcIdx, Offset, Unit: *DIE.getDwarfUnit());
1138 return hasValidRelocationAt(AllRelocs: ValidDebugInfoRelocs, StartOffset: LowPcOffset,
1139 EndOffset: LowPcEndOffset, Verbose);
1140 }
1141 case dwarf::DW_FORM_addrx:
1142 case dwarf::DW_FORM_addrx1:
1143 case dwarf::DW_FORM_addrx2:
1144 case dwarf::DW_FORM_addrx3:
1145 case dwarf::DW_FORM_addrx4: {
1146 std::optional<DWARFFormValue> AddrValue = DIE.find(Attr: dwarf::DW_AT_low_pc);
1147 if (std::optional<uint64_t> AddressOffset =
1148 DIE.getDwarfUnit()->getIndexedAddressOffset(
1149 Index: AddrValue->getRawUValue()))
1150 return hasValidRelocationAt(
1151 AllRelocs: ValidDebugAddrRelocs, StartOffset: *AddressOffset,
1152 EndOffset: *AddressOffset + DIE.getDwarfUnit()->getAddressByteSize(), Verbose);
1153
1154 Linker.reportWarning(Warning: "no base offset for address table", Context: SrcFileName);
1155 return std::nullopt;
1156 }
1157 default:
1158 return std::nullopt;
1159 }
1160}
1161
1162std::optional<StringRef>
1163DwarfLinkerForBinary::AddressManager::getLibraryInstallName() {
1164 return LibInstallName;
1165}
1166
1167uint64_t
1168DwarfLinkerForBinary::AddressManager::relocate(const ValidReloc &Reloc) const {
1169 return Reloc.SymbolMapping.BinaryAddress + Reloc.Addend;
1170}
1171
1172void DwarfLinkerForBinary::AddressManager::updateAndSaveValidRelocs(
1173 bool IsDWARF5, uint64_t OriginalUnitOffset, int64_t LinkedOffset,
1174 uint64_t StartOffset, uint64_t EndOffset) {
1175 std::vector<ValidReloc> InRelocs =
1176 getRelocations(Relocs: ValidDebugInfoRelocs, StartPos: StartOffset, EndPos: EndOffset);
1177 if (IsDWARF5)
1178 InRelocs = getRelocations(Relocs: ValidDebugAddrRelocs, StartPos: StartOffset, EndPos: EndOffset);
1179 DwarfLinkerRelocMap->updateAndSaveValidRelocs(
1180 IsDWARF5, InRelocs, UnitOffset: OriginalUnitOffset, LinkedOffset);
1181}
1182
1183void DwarfLinkerForBinary::AddressManager::updateRelocationsWithUnitOffset(
1184 uint64_t OriginalUnitOffset, uint64_t OutputUnitOffset) {
1185 DwarfLinkerRelocMap->updateRelocationsWithUnitOffset(OriginalUnitOffset,
1186 OutputUnitOffset);
1187}
1188/// Apply the valid relocations found by findValidRelocs() to
1189/// the buffer \p Data, taking into account that Data is at \p BaseOffset
1190/// in the debug_info section.
1191///
1192/// Like for findValidRelocs(), this function must be called with
1193/// monotonic \p BaseOffset values.
1194///
1195/// \returns whether any reloc has been applied.
1196bool DwarfLinkerForBinary::AddressManager::applyValidRelocs(
1197 MutableArrayRef<char> Data, uint64_t BaseOffset, bool IsLittleEndian) {
1198
1199 std::vector<ValidReloc> Relocs = getRelocations(
1200 Relocs: ValidDebugInfoRelocs, StartPos: BaseOffset, EndPos: BaseOffset + Data.size());
1201
1202 for (const ValidReloc &CurReloc : Relocs) {
1203 assert(CurReloc.Offset - BaseOffset < Data.size());
1204 assert(CurReloc.Offset - BaseOffset + CurReloc.Size <= Data.size());
1205 char Buf[8];
1206 uint64_t Value = relocate(Reloc: CurReloc);
1207 for (unsigned I = 0; I != CurReloc.Size; ++I) {
1208 unsigned Index = IsLittleEndian ? I : (CurReloc.Size - I - 1);
1209 Buf[I] = uint8_t(Value >> (Index * 8));
1210 }
1211 assert(CurReloc.Size <= sizeof(Buf));
1212 memcpy(dest: &Data[CurReloc.Offset - BaseOffset], src: Buf, n: CurReloc.Size);
1213 }
1214 return Relocs.size() > 0;
1215}
1216
1217void DwarfLinkerForBinaryRelocationMap::init(DWARFContext &Context) {
1218 for (const std::unique_ptr<DWARFUnit> &CU : Context.compile_units())
1219 StoredValidDebugInfoRelocsMap.insert(
1220 KV: std::make_pair(x: CU->getOffset(), y: std::vector<ValidReloc>()));
1221 // FIXME: Support relocations debug_addr (DWARF5).
1222}
1223
1224void DwarfLinkerForBinaryRelocationMap::addValidRelocs(RelocationMap &RM) {
1225 for (const auto &DebugInfoRelocs : StoredValidDebugInfoRelocsMap) {
1226 for (const auto &InfoReloc : DebugInfoRelocs.second)
1227 RM.addRelocationMapEntry(Relocation: InfoReloc);
1228 }
1229 // FIXME: Support relocations debug_addr (DWARF5).
1230}
1231
1232void DwarfLinkerForBinaryRelocationMap::updateRelocationsWithUnitOffset(
1233 uint64_t OriginalUnitOffset, uint64_t OutputUnitOffset) {
1234 std::vector<ValidReloc> &StoredValidDebugInfoRelocs =
1235 StoredValidDebugInfoRelocsMap[OriginalUnitOffset];
1236 for (ValidReloc &R : StoredValidDebugInfoRelocs) {
1237 R.Offset = (uint64_t)R.Offset + OutputUnitOffset;
1238 }
1239 // FIXME: Support relocations debug_addr (DWARF5).
1240}
1241
1242void DwarfLinkerForBinaryRelocationMap::updateAndSaveValidRelocs(
1243 bool IsDWARF5, std::vector<ValidReloc> &InRelocs, uint64_t UnitOffset,
1244 int64_t LinkedOffset) {
1245 std::vector<ValidReloc> &OutRelocs =
1246 StoredValidDebugInfoRelocsMap[UnitOffset];
1247 if (IsDWARF5)
1248 OutRelocs = StoredValidDebugAddrRelocsMap[UnitOffset];
1249
1250 for (ValidReloc &R : InRelocs) {
1251 OutRelocs.emplace_back(args: R.Offset + LinkedOffset, args&: R.Size, args&: R.Addend,
1252 args&: R.SymbolName, args&: R.SymbolMapping);
1253 }
1254}
1255
1256} // namespace dsymutil
1257} // namespace llvm
1258