LLVM 24.0.0git
DWARFLinkerImpl.cpp
Go to the documentation of this file.
1//=== DWARFLinkerImpl.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 "DWARFLinkerImpl.h"
10#include "DependencyTracker.h"
16
17using namespace llvm;
18using namespace dwarf_linker;
19using namespace dwarf_linker::parallel;
20
28
30 DWARFFile &File, uint64_t ObjFileIdx,
32 uint64_t &ModuleUnitIdx,
33 std::atomic<size_t> &UniqueUnitID)
37
38 if (File.Dwarf) {
39 if (!File.Dwarf->compile_units().empty())
40 CompileUnits.reserve(File.Dwarf->getNumCompileUnits());
41
42 // Set context format&endianness based on the input file.
43 Format.Version = File.Dwarf->getMaxVersion();
44 Format.AddrSize = File.Dwarf->getCUAddrSize();
45 Endianness = File.Dwarf->isLittleEndian() ? llvm::endianness::little
46 : llvm::endianness::big;
47 }
48}
49
51 CompileUnitHandlerTy OnCUDieLoaded) {
52 ObjectContexts.emplace_back(std::make_unique<LinkContext>(
55
56 if (ObjectContexts.back()->InputDWARFFile.Dwarf) {
57 for (const std::unique_ptr<DWARFUnit> &CU :
58 ObjectContexts.back()->InputDWARFFile.Dwarf->compile_units()) {
59 DWARFDie CUDie = CU->getUnitDIE();
60
61 if (!CUDie)
62 continue;
63
64 OnCUDieLoaded(*CU);
65
66 // Register mofule reference.
67 if (!GlobalData.getOptions().UpdateIndexTablesOnly)
68 ObjectContexts.back()->registerModuleReference(CUDie, Loader,
69 OnCUDieLoaded);
70 }
71 }
72}
73
75 ObjectContexts.reserve(ObjFilesNum);
76}
77
79 // UniqueUnitID is initialized by the constructor and must not be reset
80 // here. addObjectFile() may have already handed out IDs to clang module
81 // CUs loaded from .pcm files, and the IDs handed out below must stay
82 // disjoint from those.
83
85 return Err;
86
87 dwarf::FormParams GlobalFormat = {GlobalData.getOptions().TargetDWARFVersion,
90
91 if (std::optional<std::reference_wrapper<const Triple>> CurTriple =
92 GlobalData.getTargetTriple()) {
93 GlobalEndianness = (*CurTriple).get().isLittleEndian()
96 }
97 std::optional<uint16_t> Language;
98
99 for (std::unique_ptr<LinkContext> &Context : ObjectContexts) {
100 if (Context->InputDWARFFile.Dwarf == nullptr) {
101 Context->setOutputFormat(Context->getFormParams(), GlobalEndianness);
102 continue;
103 }
104
105 if (GlobalData.getOptions().Verbose) {
106 outs() << "DEBUG MAP OBJECT: " << Context->InputDWARFFile.FileName
107 << "\n";
108
109 for (const std::unique_ptr<DWARFUnit> &OrigCU :
110 Context->InputDWARFFile.Dwarf->compile_units()) {
111 outs() << "Input compilation unit:";
112 DIDumpOptions DumpOpts;
113 DumpOpts.ChildRecurseDepth = 0;
114 DumpOpts.Verbose = GlobalData.getOptions().Verbose;
115 OrigCU->getUnitDIE().dump(outs(), 0, DumpOpts);
116 }
117 }
118
119 // Verify input DWARF if requested.
120 if (GlobalData.getOptions().VerifyInputDWARF)
121 verifyInput(Context->InputDWARFFile);
122
123 if (!GlobalData.getTargetTriple())
124 GlobalEndianness = Context->getEndianness();
125 GlobalFormat.AddrSize =
126 std::max(GlobalFormat.AddrSize, Context->getFormParams().AddrSize);
127
128 Context->setOutputFormat(Context->getFormParams(), GlobalEndianness);
129
130 // FIXME: move creation of CompileUnits into the addObjectFile.
131 // This would allow to not scan for context Language and Modules state
132 // twice. And then following handling might be removed.
133 for (const std::unique_ptr<DWARFUnit> &OrigCU :
134 Context->InputDWARFFile.Dwarf->compile_units()) {
135 DWARFDie UnitDie = OrigCU->getUnitDIE();
136
137 if (!Language) {
138 if (std::optional<uint64_t> LangVal = UnitDie.getLanguage())
139 if (isODRLanguage(*LangVal))
140 Language = static_cast<uint16_t>(*LangVal);
141 }
142 }
143
144 // Clang module units decide their ODR availability from their own
145 // language, so they have to be part of this scan as well. A module unit
146 // can be the only ODR unit of a link, and any unit which deduplicates
147 // types requires the artificial type unit to exist.
148 for (const std::unique_ptr<CompileUnit> &Module :
149 Context->ModulesCompileUnits) {
150 if (!Language) {
151 if (std::optional<uint16_t> LangVal = Module->getLanguage())
152 if (isODRLanguage(*LangVal))
153 Language = *LangVal;
154 }
155 }
156 }
157
158 if (GlobalFormat.AddrSize == 0) {
159 if (std::optional<std::reference_wrapper<const Triple>> TargetTriple =
160 GlobalData.getTargetTriple())
161 GlobalFormat.AddrSize = (*TargetTriple).get().isArch32Bit() ? 4 : 8;
162 else
163 GlobalFormat.AddrSize = 8;
164 }
165
166 CommonSections.setOutputFormat(GlobalFormat, GlobalEndianness);
167
168 if (!GlobalData.Options.NoODR && Language.has_value()) {
170 TGroup.spawn([&]() {
171 ArtificialTypeUnit = std::make_unique<TypeUnit>(
172 GlobalData, UniqueUnitID++, Language, GlobalFormat, GlobalEndianness);
173 });
174 }
175
176 // Set this process-global once. link() runs per architecture and dsymutil
177 // may run those links concurrently, so assigning it from each would be a
178 // data race; the thread count is the same for every architecture, so the
179 // first assignment suffices. Size the executor from that thread count rather
180 // than the per-architecture CU count, which is moot once it is shared.
181 static llvm::once_flag ParallelStrategyFlag;
182 llvm::call_once(ParallelStrategyFlag, [&] {
184 hardware_concurrency(GlobalData.getOptions().Threads);
185 });
186
187 // Link object files.
188 if (GlobalData.getOptions().Threads == 1) {
189 for (std::unique_ptr<LinkContext> &Context : ObjectContexts) {
190 // Link object file.
191 if (Error Err = Context->link(ArtificialTypeUnit.get()))
192 GlobalData.error(std::move(Err), Context->InputDWARFFile.FileName);
193 if (Error Err = Context->unloadInput())
194 GlobalData.error(std::move(Err), Context->InputDWARFFile.FileName);
195 }
196 } else {
197 assert(ThreadPool && "setThreadPool() must be called before link()");
199 for (std::unique_ptr<LinkContext> &Context : ObjectContexts)
200 Group.async([&]() {
201 // Link object file.
202 if (Error Err = Context->link(ArtificialTypeUnit.get()))
203 GlobalData.error(std::move(Err), Context->InputDWARFFile.FileName);
204 if (Error Err = Context->unloadInput())
205 GlobalData.error(std::move(Err), Context->InputDWARFFile.FileName);
206 });
207 }
208
209 // Merge staged parseable Swift interface entries into the shared map. Done
210 // serially so that the final map contents and any conflict warnings are
211 // deterministic.
212 if (DWARFLinkerBase::SwiftInterfacesMapTy *SwiftInterfaces =
213 GlobalData.Options.ParseableSwiftInterfaces) {
214 for (std::unique_ptr<LinkContext> &Context : ObjectContexts) {
215 for (std::unique_ptr<CompileUnit> &ModuleUnit :
216 Context->ModulesCompileUnits)
217 ModuleUnit->mergeSwiftInterfaces(*SwiftInterfaces);
218 for (std::unique_ptr<CompileUnit> &CU : Context->CompileUnits)
219 CU->mergeSwiftInterfaces(*SwiftInterfaces);
220 }
221 }
222
223 // Build the linker-wide CIE registry, then emit each context's
224 // .debug_frame in parallel. See CIERegistry for the ownership rules.
225 if (!GlobalData.getOptions().UpdateIndexTablesOnly) {
227 for (std::unique_ptr<LinkContext> &Context : ObjectContexts)
228 if (Context->FrameScan)
229 Context->registerCIEs(CIEs);
230
232 for (std::unique_ptr<LinkContext> &Context : ObjectContexts) {
233 if (!Context->FrameScan)
234 continue;
235 TGroup.spawn([&]() {
236 if (Error Err = Context->emitDebugFrame(CIEs))
237 GlobalData.error(std::move(Err), Context->InputDWARFFile.FileName);
238 });
239 }
240 }
241
242 if (ArtificialTypeUnit != nullptr && !ArtificialTypeUnit->getTypePool()
243 .getRoot()
244 ->getValue()
245 .load()
246 ->Children.empty()) {
247 if (GlobalData.getTargetTriple().has_value())
248 if (Error Err = ArtificialTypeUnit->finishCloningAndEmit(
249 (*GlobalData.getTargetTriple()).get()))
250 return Err;
251 }
252
253 // At this stage each compile units are cloned to their own set of debug
254 // sections. Now, update patches, assign offsets and assemble final file
255 // glueing debug tables from each compile unit.
257
258 return Error::success();
259}
260
262 assert(File.Dwarf);
263
264 std::string Buffer;
265 raw_string_ostream OS(Buffer);
266 DIDumpOptions DumpOpts;
267 if (!File.Dwarf->verify(OS, DumpOpts.noImplicitRecursion())) {
268 if (GlobalData.getOptions().InputVerificationHandler)
269 GlobalData.getOptions().InputVerificationHandler(File, OS.str());
270 }
271}
272
274 if (GlobalData.getOptions().TargetDWARFVersion == 0)
275 return createStringError(std::errc::invalid_argument,
276 "target DWARF version is not set");
277
278 if (GlobalData.getOptions().Verbose && GlobalData.getOptions().Threads != 1) {
279 GlobalData.Options.Threads = 1;
280 GlobalData.warn(
281 "set number of threads to 1 to make --verbose to work properly.", "");
282 }
283
284 // Do not do types deduplication in case --update.
285 if (GlobalData.getOptions().UpdateIndexTablesOnly &&
286 !GlobalData.Options.NoODR)
287 GlobalData.Options.NoODR = true;
288
289 return Error::success();
290}
291
292/// Resolve the relative path to a build artifact referenced by DWARF by
293/// applying DW_AT_comp_dir.
295 sys::path::append(Buf, dwarf::toString(CU.find(dwarf::DW_AT_comp_dir), ""));
296}
297
298static uint64_t getDwoId(const DWARFDie &CUDie) {
299 auto DwoId = dwarf::toUnsigned(
300 CUDie.find({dwarf::DW_AT_dwo_id, dwarf::DW_AT_GNU_dwo_id}));
301 if (DwoId)
302 return *DwoId;
303 return 0;
304}
305
306static std::string
308 const DWARFLinker::ObjectPrefixMapTy &ObjectPrefixMap) {
309 if (ObjectPrefixMap.empty())
310 return Path.str();
311
312 SmallString<256> p = Path;
313 for (const auto &Entry : ObjectPrefixMap)
314 if (llvm::sys::path::replace_path_prefix(p, Entry.first, Entry.second))
315 break;
316 return p.str().str();
317}
318
319static std::string getPCMFile(const DWARFDie &CUDie,
320 DWARFLinker::ObjectPrefixMapTy *ObjectPrefixMap) {
321 std::string PCMFile = dwarf::toString(
322 CUDie.find({dwarf::DW_AT_dwo_name, dwarf::DW_AT_GNU_dwo_name}), "");
323
324 if (PCMFile.empty())
325 return PCMFile;
326
327 if (ObjectPrefixMap)
328 PCMFile = remapPath(PCMFile, *ObjectPrefixMap);
329
330 return PCMFile;
331}
332
334 const DWARFDie &CUDie, std::string &PCMFile, unsigned Indent, bool Quiet) {
335 if (PCMFile.empty())
336 return std::make_pair(false, false);
337
338 // Clang module DWARF skeleton CUs abuse this for the path to the module.
339 uint64_t DwoId = getDwoId(CUDie);
340
341 std::string Name = dwarf::toString(CUDie.find(dwarf::DW_AT_name), "");
342 if (Name.empty()) {
343 if (!Quiet)
344 GlobalData.warn("anonymous module skeleton CU for " + PCMFile + ".",
345 InputDWARFFile.FileName);
346 return std::make_pair(true, true);
347 }
348
349 if (!Quiet && GlobalData.getOptions().Verbose) {
350 outs().indent(Indent);
351 outs() << "Found clang module reference " << PCMFile;
352 }
353
354 auto Cached = ClangModules.find(PCMFile);
355 if (Cached != ClangModules.end()) {
356 // FIXME: Until PR27449 (https://llvm.org/bugs/show_bug.cgi?id=27449) is
357 // fixed in clang, only warn about DWO_id mismatches in verbose mode.
358 // ASTFileSignatures will change randomly when a module is rebuilt.
359 if (!Quiet && GlobalData.getOptions().Verbose && (Cached->second != DwoId))
360 GlobalData.warn(
361 Twine("hash mismatch: this object file was built against a "
362 "different version of the module ") +
363 PCMFile + ".",
364 InputDWARFFile.FileName);
365 if (!Quiet && GlobalData.getOptions().Verbose)
366 outs() << " [cached].\n";
367 return std::make_pair(true, true);
368 }
369
370 return std::make_pair(true, false);
371}
372
373/// If this compile unit is really a skeleton CU that points to a
374/// clang module, register it in ClangModules and return true.
375///
376/// A skeleton CU is a CU without children, a DW_AT_gnu_dwo_name
377/// pointing to the module, and a DW_AT_gnu_dwo_id with the module
378/// hash.
380 const DWARFDie &CUDie, ObjFileLoaderTy Loader,
381 CompileUnitHandlerTy OnCUDieLoaded, unsigned Indent) {
382 std::string PCMFile =
383 getPCMFile(CUDie, GlobalData.getOptions().ObjectPrefixMap);
384 std::pair<bool, bool> IsClangModuleRef =
385 isClangModuleRef(CUDie, PCMFile, Indent, false);
386
387 if (!IsClangModuleRef.first)
388 return false;
389
390 if (IsClangModuleRef.second)
391 return true;
392
393 if (GlobalData.getOptions().Verbose)
394 outs() << " ...\n";
395
396 // Cyclic dependencies are disallowed by Clang, but we still
397 // shouldn't run into an infinite loop, so mark it as processed now.
398 ClangModules.insert({PCMFile, getDwoId(CUDie)});
399
400 if (Error E =
401 loadClangModule(Loader, CUDie, PCMFile, OnCUDieLoaded, Indent + 2)) {
402 consumeError(std::move(E));
403 return false;
404 }
405 return true;
406}
407
409 ObjFileLoaderTy Loader, const DWARFDie &CUDie, const std::string &PCMFile,
410 CompileUnitHandlerTy OnCUDieLoaded, unsigned Indent) {
411
412 uint64_t DwoId = getDwoId(CUDie);
413 std::string ModuleName = dwarf::toString(CUDie.find(dwarf::DW_AT_name), "");
414
415 /// Using a SmallString<0> because loadClangModule() is recursive.
416 SmallString<0> Path(GlobalData.getOptions().PrependPath);
417 if (sys::path::is_relative(PCMFile))
418 resolveRelativeObjectPath(Path, CUDie);
419 sys::path::append(Path, PCMFile);
420 // Don't use the cached binary holder because we have no thread-safety
421 // guarantee and the lifetime is limited.
422
423 if (Loader == nullptr) {
424 GlobalData.error("cann't load clang module: loader is not specified.",
425 InputDWARFFile.FileName);
426 return Error::success();
427 }
428
429 auto ErrOrObj = Loader(InputDWARFFile.FileName, Path);
430 if (!ErrOrObj)
431 return Error::success();
432
433 std::unique_ptr<CompileUnit> Unit;
434 for (const auto &CU : ErrOrObj->Dwarf->compile_units()) {
435 OnCUDieLoaded(*CU);
436 // Recursively get all modules imported by this one.
437 auto ChildCUDie = CU->getUnitDIE();
438 if (!ChildCUDie)
439 continue;
440 if (!registerModuleReference(ChildCUDie, Loader, OnCUDieLoaded, Indent)) {
441 if (Unit) {
442 std::string Err =
443 (PCMFile +
444 ": Clang modules are expected to have exactly 1 compile unit.\n");
445 GlobalData.error(Err, InputDWARFFile.FileName);
447 }
448 // FIXME: Until PR27449 (https://llvm.org/bugs/show_bug.cgi?id=27449) is
449 // fixed in clang, only warn about DWO_id mismatches in verbose mode.
450 // ASTFileSignatures will change randomly when a module is rebuilt.
451 uint64_t PCMDwoId = getDwoId(ChildCUDie);
452 if (PCMDwoId != DwoId) {
453 if (GlobalData.getOptions().Verbose)
454 GlobalData.warn(
455 Twine("hash mismatch: this object file was built against a "
456 "different version of the module ") +
457 PCMFile + ".",
458 InputDWARFFile.FileName);
459 // Update the cache entry with the DwoId of the module loaded from disk.
460 ClangModules[PCMFile] = PCMDwoId;
461 }
462
463 // Empty modules units should not be cloned.
464 if (!ChildCUDie.hasChildren())
465 continue;
466
467 // Add this module.
468 Unit = std::make_unique<CompileUnit>(
469 GlobalData, *CU, UniqueUnitID.fetch_add(1), ModuleName, *ErrOrObj,
470 getUnitForOffset, CU->getFormParams(), getEndianness());
471 }
472 }
473
474 if (Unit) {
475 // Incrementing the shared counter needs no synchronization: reaching this
476 // point requires a loader, and only the serial pass over the object files
477 // supplies one.
478 if (Error E = Unit->setPriority(ModuleUnitObjFileIdx, ModuleUnitIdx++))
479 return E;
480
481 ModulesCompileUnits.emplace_back(std::move(Unit));
482 // Preload line table, as it can't be loaded asynchronously.
483 ModulesCompileUnits.back()->loadLineTable();
484 }
485
486 return Error::success();
487}
488
491 if (!InputDWARFFile.Dwarf)
492 return Error::success();
493
494 // Preload macro tables, as they can't be loaded asynchronously.
495 InputDWARFFile.Dwarf->getDebugMacinfo();
496 InputDWARFFile.Dwarf->getDebugMacro();
497
498 // Link modules compile units first.
499 parallelForEach(ModulesCompileUnits, [&](std::unique_ptr<CompileUnit> &Mod) {
500 // A module unit describes DIEs which no address reaches, so nothing marks
501 // it inter-connected and the inter-connected loops below, which iterate
502 // CompileUnits alone, would never advance it.
503 assert(!Mod->isInterconnectedCU() && "module unit is inter-connected");
505 });
506
507 // Check for live relocations. If there is no any live relocation then we
508 // can skip entire object file.
509 if (!GlobalData.getOptions().UpdateIndexTablesOnly &&
510 !InputDWARFFile.Addresses->hasValidRelocs()) {
511 if (GlobalData.getOptions().Verbose)
512 outs() << "No valid relocations found. Skipping.\n";
513 return Error::success();
514 }
515
517
518 // Create CompileUnit structures to keep information about source
519 // DWARFUnit`s, load line tables.
520 uint64_t LocalCUIdx = 0;
521 for (const auto &OrigCU : InputDWARFFile.Dwarf->compile_units()) {
522 // Load only unit DIE at this stage.
523 auto CUDie = OrigCU->getUnitDIE();
524 std::string PCMFile =
525 getPCMFile(CUDie, GlobalData.getOptions().ObjectPrefixMap);
526
527 // The !isClangModuleRef condition effectively skips over fully resolved
528 // skeleton units.
529 if (!CUDie || GlobalData.getOptions().UpdateIndexTablesOnly ||
530 !isClangModuleRef(CUDie, PCMFile, 0, true).first) {
531 CompileUnits.emplace_back(std::make_unique<CompileUnit>(
532 GlobalData, *OrigCU, UniqueUnitID.fetch_add(1), "", InputDWARFFile,
533 getUnitForOffset, OrigCU->getFormParams(), getEndianness()));
534 if (llvm::Error E =
535 CompileUnits.back()->setPriority(ObjectFileIdx, LocalCUIdx++))
536 return E;
537
538 // Preload line table, as it can't be loaded asynchronously.
539 CompileUnits.back()->loadLineTable();
540 }
541 };
542
544
545 // Link self-sufficient compile units and discover inter-connected compile
546 // units.
547 parallelForEach(CompileUnits, [&](std::unique_ptr<CompileUnit> &CU) {
549 });
550
551 // Link all inter-connected units.
554
555 if (Error Err = finiteLoop([&]() -> Expected<bool> {
557
558 // Load inter-connected units and find their live roots.
559 parallelForEach(CompileUnits, [&](std::unique_ptr<CompileUnit> &CU) {
560 if (CU->isInterconnectedCU()) {
561 CU->maybeResetToLoadedStage();
564 }
565 });
566
567 // Do liveness analysis for inter-connected units.
568 parallelForEach(CompileUnits, [&](std::unique_ptr<CompileUnit> &CU) {
571 });
572
573 return HasNewInterconnectedCUs.load();
574 }))
575 return Err;
576
577 // Update dependencies.
578 if (Error Err = finiteLoop([&]() -> Expected<bool> {
580 parallelForEach(CompileUnits, [&](std::unique_ptr<CompileUnit> &CU) {
584 });
585 return HasNewGlobalDependency.load();
586 }))
587 return Err;
588 parallelForEach(CompileUnits, [&](std::unique_ptr<CompileUnit> &CU) {
589 if (CU->isInterconnectedCU() &&
592 });
593
594 // Assign type names.
595 parallelForEach(CompileUnits, [&](std::unique_ptr<CompileUnit> &CU) {
598 });
599
600 // Clone inter-connected units.
601 parallelForEach(CompileUnits, [&](std::unique_ptr<CompileUnit> &CU) {
604 });
605
606 // Update patches for inter-connected units.
607 parallelForEach(CompileUnits, [&](std::unique_ptr<CompileUnit> &CU) {
610 });
611
612 // Release data.
613 parallelForEach(CompileUnits, [&](std::unique_ptr<CompileUnit> &CU) {
616 });
617 }
618
619 if (GlobalData.getOptions().UpdateIndexTablesOnly) {
620 // Emit Invariant sections.
621
622 if (Error Err = emitInvariantSections())
623 return Err;
624 }
625
626 return Error::success();
627}
628
631 enum CompileUnit::Stage DoUntilStage) {
632 if (InterCUProcessingStarted != CU.isInterconnectedCU())
633 return;
634
635 if (Error Err = finiteLoop([&]() -> Expected<bool> {
636 if (CU.getStage() >= DoUntilStage)
637 return false;
638
639 switch (CU.getStage()) {
641 // Load input compilation unit DIEs.
642 // Analyze properties of DIEs.
643 if (!CU.loadInputDIEs()) {
644 // We do not need to do liveness analysis for invalid compilation
645 // unit.
647 } else {
648 CU.analyzeDWARFStructure();
649
650 // The registerModuleReference() condition effectively skips
651 // over fully resolved skeleton units. This second pass of
652 // registerModuleReferences doesn't do any new work, but it
653 // will collect top-level errors, which are suppressed. Module
654 // warnings were already displayed in the first iteration.
655 //
656 // Runs concurrently, so it must stay a no-op: it may only be
657 // entered when the serial pass in addObjectFile() has already
658 // populated the module map.
659 if (!GlobalData.getOptions().UpdateIndexTablesOnly &&
661 CU.getOrigUnit().getUnitDIE(), nullptr,
662 [](const DWARFUnit &) {}, 0))
664 else
666 }
667 } break;
668
670 CU.collectLiveRoots();
672 break;
673
675 // Mark all the DIEs that need to be present in the generated output.
676 // If ODR requested, build type names.
677 if (!CU.resolveDependenciesAndMarkLiveness(InterCUProcessingStarted,
680 "Flag indicating new inter-connections is not set");
681 return false;
682 }
683
685 } break;
686
689 if (CU.updateDependenciesCompleteness())
691 return false;
692 } else {
693 if (Error Err = finiteLoop([&]() -> Expected<bool> {
694 return CU.updateDependenciesCompleteness();
695 }))
696 return std::move(Err);
697
699 }
700 } break;
701
703#ifndef NDEBUG
704 CU.verifyDependencies();
705#endif
706
707 if (ArtificialTypeUnit) {
708 if (Error Err =
709 CU.assignTypeNames(ArtificialTypeUnit->getTypePool()))
710 return std::move(Err);
711 }
713 break;
714
716 // Clone input compile unit.
717 if (CU.isClangModule() ||
718 GlobalData.getOptions().UpdateIndexTablesOnly ||
719 CU.getContainingFile().Addresses->hasValidRelocs()) {
720 if (Error Err = CU.cloneAndEmit(GlobalData.getTargetTriple(),
722 return std::move(Err);
723 }
724
726 break;
727
729 // Update DIEs referencies.
730 CU.updateDieRefPatchesWithClonedOffsets();
731
732 // Later than cloning, so that the offsets are final, and no later,
733 // because a unit which got this far can no longer be skipped and have
734 // its section dropped from the output.
735 if (CU.isClangModule())
736 CU.noteModuleAnchors();
737
739 break;
740
742 // Cleanup resources.
743 CU.cleanupDataAfterClonning();
745 break;
746
748 assert(false);
749 break;
750
752 // Nothing to do.
753 break;
754 }
755
756 return true;
757 })) {
758 CU.error(std::move(Err));
759 CU.cleanupDataAfterClonning();
761 }
762}
763
765 if (!GlobalData.getTargetTriple().has_value())
766 return Error::success();
767
769 << InputDWARFFile.Dwarf->getDWARFObj().getLocSection().Data;
771 << InputDWARFFile.Dwarf->getDWARFObj().getLoclistsSection().Data;
773 << InputDWARFFile.Dwarf->getDWARFObj().getRangesSection().Data;
775 << InputDWARFFile.Dwarf->getDWARFObj().getRnglistsSection().Data;
777 << InputDWARFFile.Dwarf->getDWARFObj().getArangesSection();
779 << InputDWARFFile.Dwarf->getDWARFObj().getFrameSection().Data;
781 << InputDWARFFile.Dwarf->getDWARFObj().getAddrSection().Data;
782
783 return Error::success();
784}
785
787 if (GlobalData.getOptions().UpdateIndexTablesOnly)
788 return Error::success();
789 if (!GlobalData.getTargetTriple().has_value())
790 return Error::success();
791
792 if (InputDWARFFile.Dwarf == nullptr)
793 return Error::success();
794 if (CompileUnits.empty())
795 return Error::success();
796
797 const DWARFObject &InputDWARFObj = InputDWARFFile.Dwarf->getDWARFObj();
798
799 StringRef OrigFrameData = InputDWARFObj.getFrameSection().Data;
800 if (OrigFrameData.empty())
801 return Error::success();
802
803 auto Scan = std::make_unique<FrameScanResult>();
804 Scan->FrameData = OrigFrameData;
805 Scan->AddressSize = InputDWARFObj.getAddressSize();
806
807 RangesTy AllUnitsRanges;
808 for (std::unique_ptr<CompileUnit> &Unit : CompileUnits) {
809 for (auto CurRange : Unit->getFunctionRanges())
810 AllUnitsRanges.insert(CurRange.Range, CurRange.Value);
811 }
812
813 StringRef FrameBytes = Scan->FrameData;
814 DataExtractor Data(FrameBytes, InputDWARFObj.isLittleEndian());
815 uint64_t InputOffset = 0;
816 const unsigned SrcAddrSize = Scan->AddressSize;
817 // Width of the CIE_pointer field at the start of every FDE (and of the
818 // CIE_id sentinel at the start of every CIE) in DWARF32 .debug_frame.
819 constexpr unsigned CIEPointerSize = 4;
820
821 // CIEs defined in this input, keyed by their input offsets.
823 DenseSet<uint64_t> AddedCIEs;
824
825 while (Data.isValidOffset(InputOffset)) {
826 uint64_t EntryOffset = InputOffset;
827 uint32_t InitialLength = Data.getU32(&InputOffset);
828 if (InitialLength == 0xFFFFFFFF)
829 return createFileError(InputDWARFFile.FileName,
830 createStringError(std::errc::invalid_argument,
831 "Dwarf64 bits not supported"));
832
833 // Reject lengths that don't fit in the input section. substr() saturates
834 // silently, which would otherwise let a malformed length poison the
835 // CIE bytes used as the registry key.
836 if (InitialLength > FrameBytes.size() - InputOffset)
837 return createFileError(
838 InputDWARFFile.FileName,
839 createStringError(std::errc::invalid_argument,
840 "Truncated .debug_frame entry."));
841
842 uint32_t CIEId = Data.getU32(&InputOffset);
843 if (CIEId == 0xFFFFFFFF) {
844 // This is a CIE, store it.
845 StringRef CIEData = FrameBytes.substr(EntryOffset, InitialLength + 4);
846 LocalCIEs[EntryOffset] = CIEData;
847 // The -4 is to account for the CIEId we just read.
848 InputOffset += InitialLength - 4;
849 continue;
850 }
851
852 uint64_t Loc = Data.getUnsigned(&InputOffset, SrcAddrSize);
853
854 // Some compilers seem to emit frame info that doesn't start at
855 // the function entry point, thus we can't just lookup the address
856 // in the debug map. Use the AddressInfo's range map to see if the FDE
857 // describes something that we can relocate.
858 std::optional<AddressRangeValuePair> Range =
859 AllUnitsRanges.getRangeThatContains(Loc);
860 if (!Range) {
861 // The +4 is to account for the size of the InitialLength field itself.
862 InputOffset = EntryOffset + InitialLength + 4;
863 continue;
864 }
865
866 // This is an FDE, and we have a mapping.
867 StringRef CIEData = LocalCIEs.lookup(CIEId);
868 if (CIEData.empty())
869 return createFileError(
870 InputDWARFFile.FileName,
871 createStringError(std::errc::invalid_argument,
872 "Inconsistent debug_frame content. Dropping."));
873
874 // Reject FDEs whose length doesn't even cover the CIE_pointer and
875 // initial_location fields; otherwise the unsigned subtraction below
876 // would wrap and substr() would saturate to a giant garbage blob.
877 if (InitialLength < CIEPointerSize + SrcAddrSize)
878 return createFileError(InputDWARFFile.FileName,
879 createStringError(std::errc::invalid_argument,
880 "Truncated .debug_frame FDE."));
881
882 // Promote each CIE on first reference; CIEs no FDE references are
883 // dropped from the output.
884 if (AddedCIEs.insert(CIEId).second)
885 Scan->CIEs.push_back(CIEData);
886
887 unsigned FDERemainingBytes = InitialLength - (CIEPointerSize + SrcAddrSize);
888 Scan->FDEs.push_back({CIEData, Loc + Range->Value,
889 FrameBytes.substr(InputOffset, FDERemainingBytes)});
890 InputOffset += FDERemainingBytes;
891 }
892
893 FrameScan = std::move(Scan);
894 return Error::success();
895}
896
898 assert(FrameScan && "registerCIEs called without FrameScan");
899 SectionDescriptor &OutSection =
901
902 uint32_t NextLocalOffset = 0;
903 for (StringRef CIEBytes : FrameScan->CIEs) {
904 auto [It, Inserted] =
905 CIEs.try_emplace(CIEBytes, CIELocation{&OutSection, NextLocalOffset});
906 if (Inserted) {
907 FrameScan->OwnedCIEs.push_back(CIEBytes);
908 NextLocalOffset += static_cast<uint32_t>(CIEBytes.size());
909 }
910 }
911}
912
914 assert(FrameScan && "emitDebugFrame called without FrameScan");
915 SectionDescriptor &OutSection =
917
918 // Emit owned CIEs at the offsets registerCIEs reserved for them.
919 for (StringRef CIEBytes : FrameScan->OwnedCIEs)
920 OutSection.OS << CIEBytes;
921
922 const dwarf::FormParams FP = OutSection.getFormParams();
923 const unsigned SrcAddrSize = FrameScan->AddressSize;
924
925 for (const FrameScanResult::FDE &FDE : FrameScan->FDEs) {
926 auto It = CIEs.find(FDE.CIEBytes);
927 assert(It != CIEs.end() && "CIE missing from registry");
928 SectionDescriptor *CIEOwnerSection = It->second.OwnerSection;
929 const uint32_t CIELocalOffset = It->second.LocalOffset;
930
931 const uint64_t FDEPos = OutSection.OS.tell();
932 // Note: this guards against a single context's section exceeding the
933 // DWARF32 limit. It does NOT catch the post-glue overflow that would
934 // happen if the concatenated .debug_frame across all contexts pushes
935 // past 4 GB; that case slips through silently because StartOffset is
936 // not yet assigned. A post-glue check would belong in the patch
937 // resolver in OutputSections.cpp.
938 if (FDEPos > FP.getDwarfMaxOffset())
939 return createFileError(
940 InputDWARFFile.FileName,
941 createStringError(".debug_frame section offset "
942 "0x" +
943 Twine::utohexstr(FDEPos) + " exceeds the " +
944 dwarf::FormatString(FP.Format) + " limit"));
945
946 // CIE_pointer field follows the 4-byte initial_length.
947 OutSection.notePatch(DebugOffsetPatch{FDEPos + 4, CIEOwnerSection, true});
948
949 emitFDE(CIELocalOffset, SrcAddrSize, FDE.Address, FDE.Instructions,
950 OutSection);
951 }
952
953 FrameScan.reset();
954 return Error::success();
955}
956
958 // Scan the input's .debug_frame now, while the DWARFContext is still
959 // loaded, so the later (post-pool) emission pass can run against the
960 // scan result alone.
961 Error ScanErr = scanFrameData();
962 InputDWARFFile.unload();
963 return ScanErr;
964}
965
966/// Emit a FDE into the debug_frame section. \p FDEBytes
967/// contains the FDE data without the length, CIE offset and address
968/// which will be replaced with the parameter values.
970 uint32_t AddrSize, uint64_t Address,
971 StringRef FDEBytes,
972 SectionDescriptor &Section) {
973 Section.emitIntVal(FDEBytes.size() + 4 + AddrSize, 4);
974 Section.emitIntVal(CIEOffset, 4);
975 Section.emitIntVal(Address, AddrSize);
976 Section.OS.write(FDEBytes.data(), FDEBytes.size());
977}
978
980 if (!GlobalData.getTargetTriple().has_value())
981 return;
983
984 // Go through all object files, all compile units and assign
985 // offsets to them.
987
988 // Patch size/offsets fields according to the assigned CU offsets.
990
991 // Emit common sections and write debug tables from all object files/compile
992 // units into the resulting file.
994
995 if (ArtificialTypeUnit != nullptr)
996 ArtificialTypeUnit.reset();
997
998 // Write common debug sections into the resulting file.
1000
1001 // Cleanup data.
1003
1004 if (GlobalData.getOptions().Statistics)
1006}
1007
1009
1010 // For each object file map how many bytes were emitted.
1011 StringMap<DebugInfoSize> SizeByObject;
1012
1013 for (const std::unique_ptr<LinkContext> &Context : ObjectContexts) {
1014 uint64_t AllDebugInfoSectionsSize = 0;
1015
1016 for (std::unique_ptr<CompileUnit> &CU : Context->CompileUnits)
1017 if (std::optional<SectionDescriptor *> DebugInfo =
1018 CU->tryGetSectionDescriptor(DebugSectionKind::DebugInfo))
1019 AllDebugInfoSectionsSize += (*DebugInfo)->getContents().size();
1020
1021 auto &Size = SizeByObject[Context->InputDWARFFile.FileName];
1022 Size.Input = Context->OriginalDebugInfoSize;
1023 Size.Output = AllDebugInfoSectionsSize;
1024 }
1025
1026 // Create a vector sorted in descending order by output size.
1027 std::vector<std::pair<StringRef, DebugInfoSize>> Sorted;
1028 for (auto &E : SizeByObject)
1029 Sorted.emplace_back(E.first(), E.second);
1030 llvm::sort(Sorted, [](auto &LHS, auto &RHS) {
1031 return LHS.second.Output > RHS.second.Output;
1032 });
1033
1034 auto ComputePercentange = [](int64_t Input, int64_t Output) -> float {
1035 const float Difference = Output - Input;
1036 const float Sum = Input + Output;
1037 if (Sum == 0)
1038 return 0;
1039 return (Difference / (Sum / 2));
1040 };
1041
1042 int64_t InputTotal = 0;
1043 int64_t OutputTotal = 0;
1044 const char *FormatStr = "{0,-45} {1,10}b {2,10}b {3,8:P}\n";
1045
1046 // Print header.
1047 outs() << ".debug_info section size (in bytes)\n";
1048 outs() << "----------------------------------------------------------------"
1049 "---------------\n";
1050 outs() << "Filename Object "
1051 " dSYM Change\n";
1052 outs() << "----------------------------------------------------------------"
1053 "---------------\n";
1054
1055 // Print body.
1056 for (auto &E : Sorted) {
1057 InputTotal += E.second.Input;
1058 OutputTotal += E.second.Output;
1059 llvm::outs() << formatv(
1060 FormatStr, sys::path::filename(E.first).take_back(45), E.second.Input,
1061 E.second.Output, ComputePercentange(E.second.Input, E.second.Output));
1062 }
1063 // Print total and footer.
1064 outs() << "----------------------------------------------------------------"
1065 "---------------\n";
1066 llvm::outs() << formatv(FormatStr, "Total", InputTotal, OutputTotal,
1067 ComputePercentange(InputTotal, OutputTotal));
1068 outs() << "----------------------------------------------------------------"
1069 "---------------\n\n";
1070}
1071
1074 TGroup.spawn([&]() { assignOffsetsToStrings(); });
1075 TGroup.spawn([&]() { assignOffsetsToSections(); });
1076}
1077
1079 size_t CurDebugStrIndex = 1; // start from 1 to take into account zero entry.
1080 uint64_t CurDebugStrOffset =
1081 1; // start from 1 to take into account zero entry.
1082 size_t CurDebugLineStrIndex = 0;
1083 uint64_t CurDebugLineStrOffset = 0;
1084
1085 // Enumerates all strings, add them into the DwarfStringPoolEntry map,
1086 // assign offset and index to the string if it is not indexed yet.
1088 const StringEntry *String) {
1089 switch (Kind) {
1092 assert(Entry != nullptr);
1093
1094 if (!Entry->isIndexed()) {
1095 Entry->Offset = CurDebugStrOffset;
1096 CurDebugStrOffset += Entry->String.size() + 1;
1097 Entry->Index = CurDebugStrIndex++;
1098 }
1099 } break;
1103 assert(Entry != nullptr);
1104
1105 if (!Entry->isIndexed()) {
1106 Entry->Offset = CurDebugLineStrOffset;
1107 CurDebugLineStrOffset += Entry->String.size() + 1;
1108 Entry->Index = CurDebugLineStrIndex++;
1109 }
1110 } break;
1111 }
1112 });
1113}
1114
1116 std::array<uint64_t, SectionKindsNum> SectionSizesAccumulator = {0};
1117
1118 forEachObjectSectionsSet([&](OutputSections &UnitSections) {
1119 UnitSections.assignSectionsOffsetAndAccumulateSize(SectionSizesAccumulator);
1120 });
1121}
1122
1125 StringHandler) {
1126 // To save space we do not create any separate string table.
1127 // We use already allocated string patches and accelerator entries:
1128 // enumerate them in natural order and assign offsets.
1129 // ASSUMPTION: strings should be stored into .debug_str/.debug_line_str
1130 // sections in the same order as they were assigned offsets.
1132 CU->forEach([&](SectionDescriptor &OutSection) {
1133 OutSection.ListDebugStrPatch.forEach([&](DebugStrPatch &Patch) {
1134 StringHandler(StringDestinationKind::DebugStr, Patch.String);
1135 });
1136
1137 OutSection.ListDebugLineStrPatch.forEach([&](DebugLineStrPatch &Patch) {
1138 StringHandler(StringDestinationKind::DebugLineStr, Patch.String);
1139 });
1140 });
1141
1142 CU->forEachAcceleratorRecord([&](DwarfUnit::AccelInfo &Info) {
1143 StringHandler(DebugStr, Info.String);
1144 });
1145 });
1146
1147 if (ArtificialTypeUnit != nullptr) {
1148 ArtificialTypeUnit->forEach([&](SectionDescriptor &OutSection) {
1149 OutSection.ListDebugStrPatch.forEach([&](DebugStrPatch &Patch) {
1150 StringHandler(StringDestinationKind::DebugStr, Patch.String);
1151 });
1152
1153 OutSection.ListDebugLineStrPatch.forEach([&](DebugLineStrPatch &Patch) {
1154 StringHandler(StringDestinationKind::DebugLineStr, Patch.String);
1155 });
1156
1157 OutSection.ListDebugTypeStrPatch.forEach([&](DebugTypeStrPatch &Patch) {
1158 if (Patch.Die == nullptr)
1159 return;
1160
1161 TypeEntryBody *TypeEntry = Patch.TypeName->getValue().load();
1162 if (&TypeEntry->getFinalDie() != Patch.Die)
1163 return;
1164
1165 StringHandler(StringDestinationKind::DebugStr, Patch.String);
1166 });
1167
1168 OutSection.ListDebugTypeLineStrPatch.forEach(
1169 [&](DebugTypeLineStrPatch &Patch) {
1170 if (Patch.Die == nullptr)
1171 return;
1172
1173 TypeEntryBody *TypeEntry = Patch.TypeName->getValue().load();
1174 if (&TypeEntry->getFinalDie() != Patch.Die)
1175 return;
1176
1177 StringHandler(StringDestinationKind::DebugStr, Patch.String);
1178 });
1179 });
1180 }
1181}
1182
1184 function_ref<void(OutputSections &)> SectionsSetHandler) {
1185 // Handle artificial type unit first.
1186 if (ArtificialTypeUnit != nullptr)
1187 SectionsSetHandler(*ArtificialTypeUnit);
1188
1189 // Then all modules(before regular compilation units).
1190 for (const std::unique_ptr<LinkContext> &Context : ObjectContexts)
1191 for (std::unique_ptr<CompileUnit> &ModuleUnit :
1192 Context->ModulesCompileUnits)
1193 if (ModuleUnit->getStage() != CompileUnit::Stage::Skipped)
1194 SectionsSetHandler(*ModuleUnit);
1195
1196 // Finally all compilation units.
1197 for (const std::unique_ptr<LinkContext> &Context : ObjectContexts) {
1198 // Handle object file common sections.
1199 SectionsSetHandler(*Context);
1200
1201 // Handle compilation units.
1202 for (std::unique_ptr<CompileUnit> &CU : Context->CompileUnits)
1203 if (CU->getStage() != CompileUnit::Stage::Skipped)
1204 SectionsSetHandler(*CU);
1205 }
1206}
1207
1209 function_ref<void(DwarfUnit *CU)> UnitHandler) {
1210 if (ArtificialTypeUnit != nullptr)
1211 UnitHandler(ArtificialTypeUnit.get());
1212
1213 // Enumerate module units.
1214 for (const std::unique_ptr<LinkContext> &Context : ObjectContexts)
1215 for (std::unique_ptr<CompileUnit> &ModuleUnit :
1216 Context->ModulesCompileUnits)
1217 if (ModuleUnit->getStage() != CompileUnit::Stage::Skipped)
1218 UnitHandler(ModuleUnit.get());
1219
1220 // Enumerate compile units.
1221 for (const std::unique_ptr<LinkContext> &Context : ObjectContexts)
1222 for (std::unique_ptr<CompileUnit> &CU : Context->CompileUnits)
1223 if (CU->getStage() != CompileUnit::Stage::Skipped)
1224 UnitHandler(CU.get());
1225}
1226
1228 function_ref<void(CompileUnit *CU)> UnitHandler) {
1229 // Enumerate module units.
1230 for (const std::unique_ptr<LinkContext> &Context : ObjectContexts)
1231 for (std::unique_ptr<CompileUnit> &ModuleUnit :
1232 Context->ModulesCompileUnits)
1233 if (ModuleUnit->getStage() != CompileUnit::Stage::Skipped)
1234 UnitHandler(ModuleUnit.get());
1235
1236 // Enumerate compile units.
1237 for (const std::unique_ptr<LinkContext> &Context : ObjectContexts)
1238 for (std::unique_ptr<CompileUnit> &CU : Context->CompileUnits)
1239 if (CU->getStage() != CompileUnit::Stage::Skipped)
1240 UnitHandler(CU.get());
1241}
1242
1244 forEachObjectSectionsSet([&](OutputSections &SectionsSet) {
1245 SectionsSet.forEach([&](SectionDescriptor &OutSection) {
1246 SectionsSet.applyPatches(OutSection, DebugStrStrings, DebugLineStrStrings,
1247 ArtificialTypeUnit.get());
1248 });
1249 });
1250}
1251
1254
1255 // Create section descriptors ahead if they are not exist at the moment.
1256 // SectionDescriptors container is not thread safe. Thus we should be sure
1257 // that descriptors would not be created in following parallel tasks.
1258
1259 CommonSections.getOrCreateSectionDescriptor(DebugSectionKind::DebugStr);
1260 CommonSections.getOrCreateSectionDescriptor(DebugSectionKind::DebugLineStr);
1261
1262 if (llvm::is_contained(GlobalData.Options.AccelTables,
1264 CommonSections.getOrCreateSectionDescriptor(DebugSectionKind::AppleNames);
1265 CommonSections.getOrCreateSectionDescriptor(
1267 CommonSections.getOrCreateSectionDescriptor(DebugSectionKind::AppleObjC);
1268 CommonSections.getOrCreateSectionDescriptor(DebugSectionKind::AppleTypes);
1269 }
1270
1271 if (llvm::is_contained(GlobalData.Options.AccelTables,
1273 CommonSections.getOrCreateSectionDescriptor(DebugSectionKind::DebugNames);
1274
1275 // Emit .debug_str and .debug_line_str sections.
1276 TG.spawn([&]() { emitStringSections(); });
1277
1278 if (llvm::is_contained(GlobalData.Options.AccelTables,
1280 // Emit apple accelerator sections.
1281 TG.spawn([&]() {
1282 emitAppleAcceleratorSections((*GlobalData.getTargetTriple()).get());
1283 });
1284 }
1285
1286 if (llvm::is_contained(GlobalData.Options.AccelTables,
1288 // Emit .debug_names section.
1289 TG.spawn([&]() {
1290 emitDWARFv5DebugNamesSection((*GlobalData.getTargetTriple()).get());
1291 });
1292 }
1293
1294 // Write compile units to the output file.
1295 TG.spawn([&]() { writeCompileUnitsToTheOutput(); });
1296}
1297
1299 uint64_t DebugStrNextOffset = 0;
1300 uint64_t DebugLineStrNextOffset = 0;
1301
1302 // Emit zero length string. Accelerator tables does not work correctly
1303 // if the first string is not zero length string.
1304 CommonSections.getSectionDescriptor(DebugSectionKind::DebugStr)
1305 .emitInplaceString("");
1306 DebugStrNextOffset++;
1307
1309 [&](StringDestinationKind Kind, const StringEntry *String) {
1310 switch (Kind) {
1312 DwarfStringPoolEntryWithExtString *StringToEmit =
1313 DebugStrStrings.getExistingEntry(String);
1314 assert(StringToEmit->isIndexed());
1315
1316 // Strings may be repeated. Use accumulated DebugStrNextOffset
1317 // to understand whether corresponding string is already emitted.
1318 // Skip string if its offset less than accumulated offset.
1319 if (StringToEmit->Offset >= DebugStrNextOffset) {
1320 DebugStrNextOffset =
1321 StringToEmit->Offset + StringToEmit->String.size() + 1;
1322 // Emit the string itself.
1323 CommonSections.getSectionDescriptor(DebugSectionKind::DebugStr)
1324 .emitInplaceString(StringToEmit->String);
1325 }
1326 } break;
1328 DwarfStringPoolEntryWithExtString *StringToEmit =
1329 DebugLineStrStrings.getExistingEntry(String);
1330 assert(StringToEmit->isIndexed());
1331
1332 // Strings may be repeated. Use accumulated DebugLineStrStrings
1333 // to understand whether corresponding string is already emitted.
1334 // Skip string if its offset less than accumulated offset.
1335 if (StringToEmit->Offset >= DebugLineStrNextOffset) {
1336 DebugLineStrNextOffset =
1337 StringToEmit->Offset + StringToEmit->String.size() + 1;
1338 // Emit the string itself.
1340 .emitInplaceString(StringToEmit->String);
1341 }
1342 } break;
1343 }
1344 });
1345}
1346
1352
1354 CU->forEachAcceleratorRecord([&](const DwarfUnit::AccelInfo &Info) {
1355 uint64_t OutOffset = Info.OutOffset;
1356 switch (Info.Type) {
1358 llvm_unreachable("Unknown accelerator record");
1359 } break;
1361 AppleNamespaces.addName(
1362 *DebugStrStrings.getExistingEntry(Info.String),
1363 CU->getSectionDescriptor(DebugSectionKind::DebugInfo).StartOffset +
1364 OutOffset);
1365 } break;
1367 AppleNames.addName(
1368 *DebugStrStrings.getExistingEntry(Info.String),
1369 CU->getSectionDescriptor(DebugSectionKind::DebugInfo).StartOffset +
1370 OutOffset);
1371 } break;
1373 AppleObjC.addName(
1374 *DebugStrStrings.getExistingEntry(Info.String),
1375 CU->getSectionDescriptor(DebugSectionKind::DebugInfo).StartOffset +
1376 OutOffset);
1377 } break;
1379 AppleTypes.addName(
1380 *DebugStrStrings.getExistingEntry(Info.String),
1381 CU->getSectionDescriptor(DebugSectionKind::DebugInfo).StartOffset +
1382 OutOffset,
1383 Info.Tag,
1384 Info.ObjcClassImplementation ? dwarf::DW_FLAG_type_implementation
1385 : 0,
1386 Info.QualifiedNameHash);
1387 } break;
1388 }
1389 });
1390 });
1391
1392 {
1393 // FIXME: we use AsmPrinter to emit accelerator sections.
1394 // It might be beneficial to directly emit accelerator data
1395 // to the raw_svector_ostream.
1396 SectionDescriptor &OutSection =
1399 OutSection.OS);
1400 if (Error Err = Emitter.init(TargetTriple, "__DWARF")) {
1401 consumeError(std::move(Err));
1402 return;
1403 }
1404
1405 // Emit table.
1406 Emitter.emitAppleNamespaces(AppleNamespaces);
1407 Emitter.finish();
1408
1409 // Set start offset and size for output section.
1411 }
1412
1413 {
1414 // FIXME: we use AsmPrinter to emit accelerator sections.
1415 // It might be beneficial to directly emit accelerator data
1416 // to the raw_svector_ostream.
1417 SectionDescriptor &OutSection =
1418 CommonSections.getSectionDescriptor(DebugSectionKind::AppleNames);
1420 OutSection.OS);
1421 if (Error Err = Emitter.init(TargetTriple, "__DWARF")) {
1422 consumeError(std::move(Err));
1423 return;
1424 }
1425
1426 // Emit table.
1427 Emitter.emitAppleNames(AppleNames);
1428 Emitter.finish();
1429
1430 // Set start offset ans size for output section.
1432 }
1433
1434 {
1435 // FIXME: we use AsmPrinter to emit accelerator sections.
1436 // It might be beneficial to directly emit accelerator data
1437 // to the raw_svector_ostream.
1438 SectionDescriptor &OutSection =
1439 CommonSections.getSectionDescriptor(DebugSectionKind::AppleObjC);
1441 OutSection.OS);
1442 if (Error Err = Emitter.init(TargetTriple, "__DWARF")) {
1443 consumeError(std::move(Err));
1444 return;
1445 }
1446
1447 // Emit table.
1448 Emitter.emitAppleObjc(AppleObjC);
1449 Emitter.finish();
1450
1451 // Set start offset ans size for output section.
1453 }
1454
1455 {
1456 // FIXME: we use AsmPrinter to emit accelerator sections.
1457 // It might be beneficial to directly emit accelerator data
1458 // to the raw_svector_ostream.
1459 SectionDescriptor &OutSection =
1460 CommonSections.getSectionDescriptor(DebugSectionKind::AppleTypes);
1462 OutSection.OS);
1463 if (Error Err = Emitter.init(TargetTriple, "__DWARF")) {
1464 consumeError(std::move(Err));
1465 return;
1466 }
1467
1468 // Emit table.
1469 Emitter.emitAppleTypes(AppleTypes);
1470 Emitter.finish();
1471
1472 // Set start offset ans size for output section.
1474 }
1475}
1476
1478 std::unique_ptr<DWARF5AccelTable> DebugNames;
1479
1480 DebugNamesUnitsOffsets CompUnits;
1481 CompUnitIDToIdx CUidToIdx;
1482
1483 unsigned Id = 0;
1484
1486 bool HasRecords = false;
1487 CU->forEachAcceleratorRecord([&](const DwarfUnit::AccelInfo &Info) {
1488 if (DebugNames == nullptr)
1489 DebugNames = std::make_unique<DWARF5AccelTable>();
1490
1491 HasRecords = true;
1492 switch (Info.Type) {
1496 DebugNames->addName(*DebugStrStrings.getExistingEntry(Info.String),
1497 Info.OutOffset, Info.ParentOffset, Info.Tag,
1498 CU->getUniqueID(),
1499 CU->getTag() == dwarf::DW_TAG_type_unit);
1500 } break;
1501
1502 default:
1503 break; // Nothing to do.
1504 };
1505 });
1506
1507 if (HasRecords) {
1508 CompUnits.push_back(
1509 CU->getOrCreateSectionDescriptor(DebugSectionKind::DebugInfo)
1510 .StartOffset);
1511 CUidToIdx[CU->getUniqueID()] = Id++;
1512 }
1513 });
1514
1515 if (DebugNames != nullptr) {
1516 // FIXME: we use AsmPrinter to emit accelerator sections.
1517 // It might be beneficial to directly emit accelerator data
1518 // to the raw_svector_ostream.
1519 SectionDescriptor &OutSection =
1520 CommonSections.getSectionDescriptor(DebugSectionKind::DebugNames);
1522 OutSection.OS);
1523 if (Error Err = Emitter.init(TargetTriple, "__DWARF")) {
1524 consumeError(std::move(Err));
1525 return;
1526 }
1527
1528 // Emit table.
1529 Emitter.emitDebugNames(*DebugNames, CompUnits, CUidToIdx);
1530 Emitter.finish();
1531
1532 // Set start offset ans size for output section.
1534 }
1535}
1536
1538 GlobalData.getStringPool().clear();
1539 DebugStrStrings.clear();
1540 DebugLineStrStrings.clear();
1541}
1542
1544 // Enumerate all sections and store them into the final emitter.
1546 Sections.forEach([&](std::shared_ptr<SectionDescriptor> OutSection) {
1547 // Emit section content.
1548 SectionHandler(OutSection);
1549 });
1550 });
1551}
1552
1554 CommonSections.forEach([&](std::shared_ptr<SectionDescriptor> OutSection) {
1555 SectionHandler(OutSection);
1556 });
1557}
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
uint64_t uint64_t
dxil container DXContainer Global Emitter
static fatal_error_handler_t ErrorHandler
ConstantRange Range(APInt(BitWidth, Low), APInt(BitWidth, High))
The Input class is used to parse a yaml document into in-memory structs and vectors.
This class holds an abstract representation of an Accelerator Table, consisting of a sequence of buck...
Definition AccelTable.h:203
std::optional< T > getRangeThatContains(uint64_t Addr) const
void insert(AddressRange Range, int64_t Value)
Utility class that carries the DWARF compile/type unit and the debug info entry in an object.
Definition DWARFDie.h:43
LLVM_ABI std::optional< DWARFFormValue > find(dwarf::Attribute Attr) const
Extract the specified attribute from this DIE.
Definition DWARFDie.cpp:335
LLVM_ABI std::optional< uint64_t > getLanguage() const
Returns the DW_LANG_ code for this DIE's DWARF unit, if it exists.
Definition DWARFDie.cpp:506
virtual bool isLittleEndian() const =0
virtual const DWARFSection & getFrameSection() const
Definition DWARFObject.h:44
virtual uint8_t getAddressSize() const
Definition DWARFObject.h:35
ValueT lookup(const_arg_type_t< KeyT > Val) const
Return the entry for the specified key, or a default constructed value if no such entry exists.
Definition DenseMap.h:793
Implements a dense probed hash-table based set.
Definition DenseSet.h:283
Lightweight error class with error context and mandatory checking.
Definition Error.h:159
static ErrorSuccess success()
Create a success value.
Definition Error.h:336
Tagged union holding either a T or a Error.
Definition Error.h:485
A Module instance is used to store all the information related to an LLVM module.
Definition Module.h:68
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition SmallString.h:28
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Definition StringMap.h:129
iterator end()
Definition StringMap.h:214
iterator find(StringRef Key)
Definition StringMap.h:227
std::pair< iterator, bool > try_emplace(StringRef Key, ArgsTy &&...Args)
Emplace a new element for the specified key into the map if the key isn't already in the map.
Definition StringMap.h:370
Represent a constant reference to a string, i.e.
Definition StringRef.h:56
constexpr StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition StringRef.h:597
constexpr bool empty() const
Check if the string is empty.
Definition StringRef.h:141
constexpr size_t size() const
Get the string size.
Definition StringRef.h:144
constexpr const char * data() const
Get a pointer to the start of the string (which may not be null terminated).
Definition StringRef.h:138
A group of tasks to be run on a thread pool.
Definition ThreadPool.h:269
auto async(Function &&F, Args &&...ArgList)
Calls ThreadPool::async() for this group.
Definition ThreadPool.h:280
Triple - Helper class for working with autoconf configuration names.
Definition Triple.h:48
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition Twine.h:82
static Twine utohexstr(uint64_t Val)
Definition Twine.h:385
std::pair< iterator, bool > insert(const ValueT &V)
Definition DenseSet.h:210
This class represents DWARF information for source file and it's address map.
Definition DWARFFile.h:25
std::map< std::string, std::string > ObjectPrefixMapTy
function_ref< void(const DWARFUnit &Unit)> CompileUnitHandlerTy
std::function< void( const Twine &Warning, StringRef Context, const DWARFDie *DIE)> MessageHandlerTy
@ Apple
.apple_names, .apple_namespaces, .apple_types, .apple_objc.
std::map< std::string, std::string > SwiftInterfacesMapTy
std::function< ErrorOr< DWARFFile & >( StringRef ContainerName, StringRef Path)> ObjFileLoaderTy
Stores all information related to a compile unit, be it in its original instance of the object file o...
Stage
The stages of new compile unit processing.
@ LiveRootsCollected
DIEs with a live address are found.
@ CreatedNotLoaded
Created, linked with input DWARF file.
@ PatchesUpdated
Offsets inside patch records are updated.
@ Cleaned
Resources(Input DWARF, Output DWARF tree) are released.
@ LivenessAnalysisDone
Input DWARF is analysed(DIEs pointing to the real code section and theDIEs they depend on are marked)...
@ UpdateDependenciesCompleteness
Check if dependencies have incompatible placement.
void forEachObjectSectionsSet(function_ref< void(OutputSections &SectionsSet)> SectionsSetHandler)
Enumerates sections for modules, invariant for object files, compile units.
void emitDWARFv5DebugNamesSection(const Triple &TargetTriple)
Emit .debug_names section.
static constexpr uint64_t ModuleUnitObjFileIdx
The object file index given to every clang module unit.
void writeCompileUnitsToTheOutput()
Enumerate all compile units and put their data into the output stream.
void forEachCompileUnit(function_ref< void(CompileUnit *CU)> UnitHandler)
Enumerates all comple units.
void assignOffsetsToStrings()
Enumerate all compile units and assign offsets to their strings.
void assignOffsets()
Enumerate all compile units and assign offsets to their sections and strings.
Error link() override
Link debug info for added files.
Error validateAndUpdateOptions()
Validate specified options.
void writeCommonSectionsToTheOutput()
Enumerate common sections and put their data into the output stream.
void assignOffsetsToSections()
Enumerate all compile units and assign offsets to their sections.
void printStatistic()
Print statistic for processed Debug Info.
void glueCompileUnitsAndWriteToTheOutput()
Take already linked compile units and glue them into single file.
void emitAppleAcceleratorSections(const Triple &TargetTriple)
Emit apple accelerator sections.
void verifyInput(const DWARFFile &File)
Verify input DWARF file.
void forEachCompileAndTypeUnit(function_ref< void(DwarfUnit *CU)> UnitHandler)
Enumerates all compile and type units.
DWARFLinkerImpl(MessageHandlerTy ErrorHandler, MessageHandlerTy WarningHandler)
void addObjectFile(DWARFFile &File, ObjFileLoaderTy Loader=nullptr, CompileUnitHandlerTy OnCUDieLoaded=[](const DWARFUnit &) {}) override
Add object file to be linked.
void cleanupDataAfterDWARFOutputIsWritten()
Cleanup data(string pools) after output sections are generated.
void forEachOutputString(function_ref< void(StringDestinationKind, const StringEntry *)> StringHandler)
Enumerates all strings.
static constexpr uint64_t FirstObjFileIdx
Object file indices follow the module units'.
void emitCommonSectionsAndWriteCompileUnitsToTheOutput()
Emit debug sections common for all input files.
void patchOffsetsAndSizes()
Enumerates all patches and update them with the correct values.
This class emits DWARF data to the output stream.
Base class for all Dwarf units(Compile unit/Type table unit).
This class keeps data and services common for the whole linking process.
This class keeps contents and offsets to the debug sections.
void applyPatches(SectionDescriptor &Section, StringEntryToDwarfStringPoolEntryMap &DebugStrStrings, StringEntryToDwarfStringPoolEntryMap &DebugLineStrStrings, TypeUnit *TypeUnitPtr)
Enumerate all sections, for each section apply all section patches.
OutputSections(LinkingGlobalData &GlobalData)
void forEach(function_ref< void(SectionDescriptor &)> Handler)
Enumerate all sections and call Handler for each.
llvm::endianness getEndianness() const
Endiannes for the sections.
SectionDescriptor & getOrCreateSectionDescriptor(DebugSectionKind SectionKind)
Returns descriptor for the specified section of SectionKind.
void assignSectionsOffsetAndAccumulateSize(std::array< uint64_t, SectionKindsNum > &SectionSizesAccumulator)
Enumerate all sections, for each section set current offset (kept by SectionSizesAccumulator),...
const SectionDescriptor & getSectionDescriptor(DebugSectionKind SectionKind) const
Returns descriptor for the specified section of SectionKind.
Keeps cloned data for the type DIE.
Definition TypePool.h:76
Type Unit is used to represent an artificial compilation unit which keeps all type information.
An efficient, type-erasing, non-owning reference to a callable.
LLVM_ABI void spawn(std::function< void()> f)
Definition Parallel.cpp:244
uint64_t tell() const
tell - Return the current offset with the file.
raw_ostream & indent(unsigned NumSpaces)
indent - Insert 'NumSpaces' spaces.
A raw_ostream that writes to an std::string.
std::string & str()
Returns the string's reference.
ThreadPoolInterface * ThreadPool
Thread pool that links the object files, or null to use a private pool.
std::atomic< size_t > UniqueUnitID
Unique ID for compile unit.
SmallVector< std::unique_ptr< LinkContext > > ObjectContexts
Keeps all linking contexts.
StringEntryToDwarfStringPoolEntryMap DebugLineStrStrings
DwarfStringPoolEntries for .debug_line_str section.
SectionHandlerTy SectionHandler
Hanler for output sections.
std::unique_ptr< TypeUnit > ArtificialTypeUnit
Type unit.
StringEntryToDwarfStringPoolEntryMap DebugStrStrings
DwarfStringPoolEntries for .debug_str section.
uint64_t ModuleUnitIdx
Numbers the clang module units of the whole link, so that they form one priority sequence regardless ...
OutputSections CommonSections
Common sections.
StringMap< uint64_t > ClangModules
Mapping the PCM filename to the DwoId.
LLVM_ABI StringRef FormatString(DwarfFormat Format)
Definition Dwarf.cpp:1065
void setEstimatedObjfilesAmount(unsigned ObjFilesNum) override
Set estimated objects files amount, for preliminary data allocation.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
bool isODRLanguage(uint16_t Language)
std::vector< std::variant< MCSymbol *, uint64_t > > DebugNamesUnitsOffsets
DenseMap< unsigned, unsigned > CompUnitIDToIdx
StringMapEntry< std::atomic< TypeEntryBody * > > TypeEntry
Definition TypePool.h:31
StringMapEntry< EmptyStringSetTag > StringEntry
StringEntry keeps data of the string: the length, external offset and a string body which is placed r...
Definition StringPool.h:23
Error finiteLoop(function_ref< Expected< bool >()> Iteration, size_t MaxCounter=100000)
This function calls Iteration() until it returns false.
Definition Utils.h:76
AddressRangesMap RangesTy
Mapped value in the address map is the offset to apply to the linked address.
std::optional< const char * > toString(const std::optional< DWARFFormValue > &V)
Take an optional DWARFFormValue and try to extract a string value from it.
@ DWARF32
Definition Dwarf.h:93
@ DW_FLAG_type_implementation
Definition Dwarf.h:1056
std::optional< uint64_t > toUnsigned(const std::optional< DWARFFormValue > &V)
Take an optional DWARFFormValue and try to extract an unsigned constant.
LLVM_ABI ThreadPoolStrategy strategy
Definition Parallel.cpp:27
LLVM_ABI bool is_relative(const Twine &path, Style style=Style::native)
Is path relative?
Definition Path.cpp:716
LLVM_ABI StringRef filename(StringRef path LLVM_LIFETIME_BOUND, Style style=Style::native)
Get filename.
Definition Path.cpp:594
LLVM_ABI bool replace_path_prefix(SmallVectorImpl< char > &Path, StringRef OldPrefix, StringRef NewPrefix, Style style=Style::native)
Replace matching path prefix with another path.
Definition Path.cpp:529
LLVM_ABI void append(SmallVectorImpl< char > &path, const Twine &a, const Twine &b="", const Twine &c="", const Twine &d="")
Append to path.
Definition Path.cpp:467
This is an optimization pass for GlobalISel generic memory operations.
ThreadPoolStrategy hardware_concurrency(unsigned ThreadCount=0)
Returns a default thread strategy where all available hardware resources are to be used,...
Definition Threading.h:190
Error createFileError(const Twine &F, Error E)
Concatenate a source file path and/or name with an Error.
Definition Error.h:1415
LLVM_ABI std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
Definition Error.cpp:94
LLVM_ABI raw_fd_ostream & outs()
This returns a reference to a raw_fd_ostream for standard output.
static std::string remapPath(StringRef Path, const DWARFLinkerBase::ObjectPrefixMapTy &ObjectPrefixMap)
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
Definition Error.h:1321
static void resolveRelativeObjectPath(SmallVectorImpl< char > &Buf, DWARFDie CU)
Resolve the relative path to a build artifact referenced by DWARF by applying DW_AT_comp_dir.
static std::string getPCMFile(const DWARFDie &CUDie, const DWARFLinkerBase::ObjectPrefixMapTy *ObjectPrefixMap)
auto formatv(bool Validate, const char *Fmt, Ts &&...Vals)
void sort(IteratorTy Start, IteratorTy End)
Definition STLExtras.h:1652
static uint64_t getDwoId(const DWARFDie &CUDie)
Error make_error(ArgTs &&... Args)
Make a Error instance representing failure using the given error info type.
Definition Error.h:340
@ Mod
The access may modify the value stored in memory.
Definition ModRef.h:34
void call_once(once_flag &flag, Function &&F, Args &&... ArgList)
Execute the function specified as a parameter once.
Definition Threading.h:86
bool is_contained(R &&Range, const E &Element)
Returns true if Element is found in Range.
Definition STLExtras.h:1963
void parallelForEach(IterTy Begin, IterTy End, FuncTy Fn)
Definition Parallel.h:209
endianness
Definition bit.h:71
void consumeError(Error Err)
Consume a Error without doing anything.
Definition Error.h:1106
Container for dump options that control which debug information will be dumped.
Definition DIContext.h:197
DIDumpOptions noImplicitRecursion() const
Return the options with RecurseDepth set to 0 unless explicitly required.
Definition DIContext.h:238
unsigned ChildRecurseDepth
Definition DIContext.h:199
DwarfStringPoolEntry with string keeping externally.
A helper struct providing information about the byte size of DW_FORM values that vary in size dependi...
Definition Dwarf.h:1221
Section + local offset of a .debug_frame CIE that has been (or will be) emitted by some LinkContext.
uint64_t getInputDebugInfoSize() const
Computes the total size of the debug info.
bool InterCUProcessingStarted
Flag indicating that all inter-connected units are loaded and the dwarf linking process for these uni...
bool registerModuleReference(const DWARFDie &CUDie, ObjFileLoaderTy Loader, CompileUnitHandlerTy OnCUDieLoaded, unsigned Indent=0)
If this compile unit is really a skeleton CU that points to a clang module, register it in ClangModul...
Error loadClangModule(ObjFileLoaderTy Loader, const DWARFDie &CUDie, const std::string &PCMFile, CompileUnitHandlerTy OnCUDieLoaded, unsigned Indent=0)
Recursively add the debug info in this clang module .pcm file (and all the modules imported by it in ...
LinkContext(LinkingGlobalData &GlobalData, DWARFFile &File, uint64_t ObjFileIdx, StringMap< uint64_t > &ClangModules, uint64_t &ModuleUnitIdx, std::atomic< size_t > &UniqueUnitID)
Error scanFrameData()
Parse this context's input .debug_frame into FrameScan.
uint64_t OriginalDebugInfoSize
Size of Debug info before optimizing.
std::pair< bool, bool > isClangModuleRef(const DWARFDie &CUDie, std::string &PCMFile, unsigned Indent, bool Quiet)
Check whether specified CUDie is a Clang module reference.
void emitFDE(uint32_t CIEOffset, uint32_t AddrSize, uint64_t Address, StringRef FDEBytes, SectionDescriptor &Section)
Emit FDE record.
UnitListTy CompileUnits
Set of Compilation Units(may be accessed asynchroniously for reading).
void linkSingleCompileUnit(CompileUnit &CU, TypeUnit *ArtificialTypeUnit, enum CompileUnit::Stage DoUntilStage=CompileUnit::Stage::Cleaned)
Link specified compile unit until specified stage.
UnitListTy ModulesCompileUnits
Set of Compile Units for modules.
void registerCIEs(CIERegistry &CIEs)
Register this context's CIEs with the linker-wide registry.
std::atomic< bool > HasNewInterconnectedCUs
Flag indicating that new inter-connected compilation units were discovered.
Error emitDebugFrame(const CIERegistry &CIEs)
Emit this context's .debug_frame section.
std::atomic< size_t > & UniqueUnitID
Counter for compile units ID.
Error link(TypeUnit *ArtificialTypeUnit)
Link compile units for this context.
StringMap< CIELocation > CIERegistry
Linker-wide registry for .debug_frame CIEs.
Error unloadInput()
Unload the input DWARFContext after scanning the input .debug_frame into FrameScan.
uint64_t ObjectFileIdx
Index of this object file in the link order (used for deterministic type DIE allocation).
std::function< CompileUnit *(uint64_t)> getUnitForOffset
This structure is used to update strings offsets into .debug_line_str.
This structure is used to update strings offsets into .debug_str.
This structure keeps fields which would be used for creating accelerator table.
dwarf::FormParams getFormParams() const
Returns FormParams used by section.
This structure is used to keep data of the concrete section.
raw_svector_ostream OS
Stream which stores data to the Contents.
void setSizesForSectionCreatedByAsmPrinter()
Some sections are emitted using AsmPrinter.
The llvm::once_flag structure.
Definition Threading.h:67