39 if (!File.Dwarf->compile_units().empty())
40 CompileUnits.reserve(File.Dwarf->getNumCompileUnits());
43 Format.Version = File.Dwarf->getMaxVersion();
44 Format.AddrSize = File.Dwarf->getCUAddrSize();
45 Endianness = File.Dwarf->isLittleEndian() ? llvm::endianness::little
46 : llvm::endianness::big;
57 for (
const std::unique_ptr<DWARFUnit> &
CU :
67 if (!
GlobalData.getOptions().UpdateIndexTablesOnly)
91 if (std::optional<std::reference_wrapper<const Triple>> CurTriple =
93 GlobalEndianness = (*CurTriple).get().isLittleEndian()
97 std::optional<uint16_t> Language;
100 if (Context->InputDWARFFile.Dwarf ==
nullptr) {
101 Context->setOutputFormat(Context->getFormParams(), GlobalEndianness);
106 outs() <<
"DEBUG MAP OBJECT: " << Context->InputDWARFFile.FileName
109 for (
const std::unique_ptr<DWARFUnit> &OrigCU :
110 Context->InputDWARFFile.Dwarf->compile_units()) {
111 outs() <<
"Input compilation unit:";
115 OrigCU->getUnitDIE().dump(
outs(), 0, DumpOpts);
124 GlobalEndianness = Context->getEndianness();
126 std::max(GlobalFormat.
AddrSize, Context->getFormParams().AddrSize);
128 Context->setOutputFormat(Context->getFormParams(), GlobalEndianness);
133 for (
const std::unique_ptr<DWARFUnit> &OrigCU :
134 Context->InputDWARFFile.Dwarf->compile_units()) {
135 DWARFDie UnitDie = OrigCU->getUnitDIE();
138 if (std::optional<uint64_t> LangVal = UnitDie.
getLanguage())
140 Language =
static_cast<uint16_t
>(*LangVal);
148 for (
const std::unique_ptr<CompileUnit> &
Module :
149 Context->ModulesCompileUnits) {
151 if (std::optional<uint16_t> LangVal =
Module->getLanguage())
159 if (std::optional<std::reference_wrapper<const Triple>> TargetTriple =
161 GlobalFormat.
AddrSize = (*TargetTriple).get().isArch32Bit() ? 4 : 8;
168 if (!
GlobalData.Options.NoODR && Language.has_value()) {
192 GlobalData.error(std::move(Err), Context->InputDWARFFile.FileName);
193 if (
Error Err = Context->unloadInput())
194 GlobalData.error(std::move(Err), Context->InputDWARFFile.FileName);
203 GlobalData.error(std::move(Err), Context->InputDWARFFile.FileName);
204 if (
Error Err = Context->unloadInput())
205 GlobalData.error(std::move(Err), Context->InputDWARFFile.FileName);
213 GlobalData.Options.ParseableSwiftInterfaces) {
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);
225 if (!
GlobalData.getOptions().UpdateIndexTablesOnly) {
228 if (Context->FrameScan)
229 Context->registerCIEs(CIEs);
233 if (!Context->FrameScan)
236 if (
Error Err = Context->emitDebugFrame(CIEs))
237 GlobalData.error(std::move(Err), Context->InputDWARFFile.FileName);
246 ->Children.empty()) {
268 if (
GlobalData.getOptions().InputVerificationHandler)
269 GlobalData.getOptions().InputVerificationHandler(File, OS.
str());
274 if (
GlobalData.getOptions().TargetDWARFVersion == 0)
276 "target DWARF version is not set");
281 "set number of threads to 1 to make --verbose to work properly.",
"");
285 if (
GlobalData.getOptions().UpdateIndexTablesOnly &&
300 CUDie.
find({dwarf::DW_AT_dwo_id, dwarf::DW_AT_GNU_dwo_id}));
309 if (ObjectPrefixMap.empty())
313 for (
const auto &Entry : ObjectPrefixMap)
316 return p.str().str();
322 CUDie.
find({dwarf::DW_AT_dwo_name, dwarf::DW_AT_GNU_dwo_name}),
"");
328 PCMFile =
remapPath(PCMFile, *ObjectPrefixMap);
334 const DWARFDie &CUDie, std::string &PCMFile,
unsigned Indent,
bool Quiet) {
336 return std::make_pair(
false,
false);
344 GlobalData.warn(
"anonymous module skeleton CU for " + PCMFile +
".",
346 return std::make_pair(
true,
true);
351 outs() <<
"Found clang module reference " << PCMFile;
359 if (!
Quiet &&
GlobalData.getOptions().Verbose && (Cached->second != DwoId))
361 Twine(
"hash mismatch: this object file was built against a "
362 "different version of the module ") +
366 outs() <<
" [cached].\n";
367 return std::make_pair(
true,
true);
370 return std::make_pair(
true,
false);
382 std::string PCMFile =
384 std::pair<bool, bool> IsClangModuleRef =
387 if (!IsClangModuleRef.first)
390 if (IsClangModuleRef.second)
423 if (Loader ==
nullptr) {
424 GlobalData.error(
"cann't load clang module: loader is not specified.",
433 std::unique_ptr<CompileUnit> Unit;
434 for (
const auto &
CU : ErrOrObj->Dwarf->compile_units()) {
437 auto ChildCUDie =
CU->getUnitDIE();
444 ": Clang modules are expected to have exactly 1 compile unit.\n");
451 uint64_t PCMDwoId =
getDwoId(ChildCUDie);
452 if (PCMDwoId != DwoId) {
455 Twine(
"hash mismatch: this object file was built against a "
456 "different version of the module ") +
464 if (!ChildCUDie.hasChildren())
468 Unit = std::make_unique<CompileUnit>(
503 assert(!
Mod->isInterconnectedCU() &&
"module unit is inter-connected");
509 if (!
GlobalData.getOptions().UpdateIndexTablesOnly &&
512 outs() <<
"No valid relocations found. Skipping.\n";
520 uint64_t LocalCUIdx = 0;
521 for (
const auto &OrigCU :
InputDWARFFile.Dwarf->compile_units()) {
523 auto CUDie = OrigCU->getUnitDIE();
524 std::string PCMFile =
529 if (!CUDie ||
GlobalData.getOptions().UpdateIndexTablesOnly ||
531 CompileUnits.emplace_back(std::make_unique<CompileUnit>(
560 if (
CU->isInterconnectedCU()) {
561 CU->maybeResetToLoadedStage();
589 if (
CU->isInterconnectedCU() &&
619 if (
GlobalData.getOptions().UpdateIndexTablesOnly) {
636 if (
CU.getStage() >= DoUntilStage)
639 switch (
CU.getStage()) {
643 if (!
CU.loadInputDIEs()) {
648 CU.analyzeDWARFStructure();
659 if (!
GlobalData.getOptions().UpdateIndexTablesOnly &&
661 CU.getOrigUnit().getUnitDIE(),
nullptr,
670 CU.collectLiveRoots();
680 "Flag indicating new inter-connections is not set");
689 if (
CU.updateDependenciesCompleteness())
694 return CU.updateDependenciesCompleteness();
696 return std::move(Err);
704 CU.verifyDependencies();
710 return std::move(Err);
717 if (
CU.isClangModule() ||
718 GlobalData.getOptions().UpdateIndexTablesOnly ||
719 CU.getContainingFile().Addresses->hasValidRelocs()) {
722 return std::move(Err);
730 CU.updateDieRefPatchesWithClonedOffsets();
735 if (
CU.isClangModule())
736 CU.noteModuleAnchors();
743 CU.cleanupDataAfterClonning();
758 CU.error(std::move(Err));
759 CU.cleanupDataAfterClonning();
765 if (!
GlobalData.getTargetTriple().has_value())
787 if (
GlobalData.getOptions().UpdateIndexTablesOnly)
789 if (!
GlobalData.getTargetTriple().has_value())
800 if (OrigFrameData.
empty())
803 auto Scan = std::make_unique<FrameScanResult>();
804 Scan->FrameData = OrigFrameData;
808 for (std::unique_ptr<CompileUnit> &Unit :
CompileUnits) {
809 for (
auto CurRange : Unit->getFunctionRanges())
810 AllUnitsRanges.
insert(CurRange.Range, CurRange.Value);
815 uint64_t InputOffset = 0;
816 const unsigned SrcAddrSize = Scan->AddressSize;
819 constexpr unsigned CIEPointerSize = 4;
825 while (
Data.isValidOffset(InputOffset)) {
826 uint64_t EntryOffset = InputOffset;
828 if (InitialLength == 0xFFFFFFFF)
831 "Dwarf64 bits not supported"));
836 if (InitialLength > FrameBytes.
size() - InputOffset)
840 "Truncated .debug_frame entry."));
843 if (CIEId == 0xFFFFFFFF) {
846 LocalCIEs[EntryOffset] = CIEData;
848 InputOffset += InitialLength - 4;
852 uint64_t
Loc =
Data.getUnsigned(&InputOffset, SrcAddrSize);
858 std::optional<AddressRangeValuePair>
Range =
862 InputOffset = EntryOffset + InitialLength + 4;
872 "Inconsistent debug_frame content. Dropping."));
877 if (InitialLength < CIEPointerSize + SrcAddrSize)
880 "Truncated .debug_frame FDE."));
884 if (AddedCIEs.
insert(CIEId).second)
885 Scan->CIEs.push_back(CIEData);
887 unsigned FDERemainingBytes = InitialLength - (CIEPointerSize + SrcAddrSize);
888 Scan->FDEs.push_back({CIEData,
Loc +
Range->Value,
889 FrameBytes.
substr(InputOffset, FDERemainingBytes)});
890 InputOffset += FDERemainingBytes;
904 auto [It, Inserted] =
907 FrameScan->OwnedCIEs.push_back(CIEBytes);
908 NextLocalOffset +=
static_cast<uint32_t>(CIEBytes.
size());
920 OutSection.
OS << CIEBytes;
923 const unsigned SrcAddrSize =
FrameScan->AddressSize;
927 assert(It != CIEs.
end() &&
"CIE missing from registry");
929 const uint32_t CIELocalOffset = It->second.LocalOffset;
931 const uint64_t FDEPos = OutSection.
OS.
tell();
938 if (FDEPos >
FP.getDwarfMaxOffset())
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());
980 if (!
GlobalData.getTargetTriple().has_value())
1013 for (
const std::unique_ptr<LinkContext> &Context :
ObjectContexts) {
1014 uint64_t AllDebugInfoSectionsSize = 0;
1016 for (std::unique_ptr<CompileUnit> &
CU : Context->CompileUnits)
1017 if (std::optional<SectionDescriptor *>
DebugInfo =
1019 AllDebugInfoSectionsSize += (*DebugInfo)->getContents().size();
1021 auto &
Size = SizeByObject[Context->InputDWARFFile.FileName];
1022 Size.Input = Context->OriginalDebugInfoSize;
1023 Size.Output = AllDebugInfoSectionsSize;
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;
1034 auto ComputePercentange = [](int64_t
Input, int64_t Output) ->
float {
1035 const float Difference = Output -
Input;
1036 const float Sum =
Input + Output;
1039 return (Difference / (Sum / 2));
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";
1047 outs() <<
".debug_info section size (in bytes)\n";
1048 outs() <<
"----------------------------------------------------------------"
1049 "---------------\n";
1050 outs() <<
"Filename Object "
1052 outs() <<
"----------------------------------------------------------------"
1053 "---------------\n";
1056 for (
auto &E : Sorted) {
1057 InputTotal += E.second.Input;
1058 OutputTotal += E.second.Output;
1061 E.second.Output, ComputePercentange(E.second.Input, E.second.Output));
1064 outs() <<
"----------------------------------------------------------------"
1065 "---------------\n";
1067 ComputePercentange(InputTotal, OutputTotal));
1068 outs() <<
"----------------------------------------------------------------"
1069 "---------------\n\n";
1079 size_t CurDebugStrIndex = 1;
1080 uint64_t CurDebugStrOffset =
1082 size_t CurDebugLineStrIndex = 0;
1083 uint64_t CurDebugLineStrOffset = 0;
1092 assert(Entry !=
nullptr);
1094 if (!Entry->isIndexed()) {
1095 Entry->Offset = CurDebugStrOffset;
1096 CurDebugStrOffset += Entry->String.size() + 1;
1097 Entry->Index = CurDebugStrIndex++;
1103 assert(Entry !=
nullptr);
1105 if (!Entry->isIndexed()) {
1106 Entry->Offset = CurDebugLineStrOffset;
1107 CurDebugLineStrOffset += Entry->String.size() + 1;
1108 Entry->Index = CurDebugLineStrIndex++;
1116 std::array<uint64_t, SectionKindsNum> SectionSizesAccumulator = {0};
1133 OutSection.ListDebugStrPatch.forEach([&](
DebugStrPatch &Patch) {
1143 StringHandler(
DebugStr, Info.String);
1149 OutSection.ListDebugStrPatch.forEach([&](
DebugStrPatch &Patch) {
1158 if (Patch.Die ==
nullptr)
1162 if (&
TypeEntry->getFinalDie() != Patch.Die)
1168 OutSection.ListDebugTypeLineStrPatch.forEach(
1170 if (Patch.Die ==
nullptr)
1174 if (&
TypeEntry->getFinalDie() != Patch.Die)
1190 for (
const std::unique_ptr<LinkContext> &Context :
ObjectContexts)
1191 for (std::unique_ptr<CompileUnit> &ModuleUnit :
1192 Context->ModulesCompileUnits)
1194 SectionsSetHandler(*ModuleUnit);
1197 for (
const std::unique_ptr<LinkContext> &Context :
ObjectContexts) {
1199 SectionsSetHandler(*Context);
1202 for (std::unique_ptr<CompileUnit> &
CU : Context->CompileUnits)
1204 SectionsSetHandler(*
CU);
1214 for (
const std::unique_ptr<LinkContext> &Context :
ObjectContexts)
1215 for (std::unique_ptr<CompileUnit> &ModuleUnit :
1216 Context->ModulesCompileUnits)
1218 UnitHandler(ModuleUnit.get());
1221 for (
const std::unique_ptr<LinkContext> &Context :
ObjectContexts)
1222 for (std::unique_ptr<CompileUnit> &
CU : Context->CompileUnits)
1224 UnitHandler(
CU.get());
1230 for (
const std::unique_ptr<LinkContext> &Context :
ObjectContexts)
1231 for (std::unique_ptr<CompileUnit> &ModuleUnit :
1232 Context->ModulesCompileUnits)
1234 UnitHandler(ModuleUnit.get());
1237 for (
const std::unique_ptr<LinkContext> &Context :
ObjectContexts)
1238 for (std::unique_ptr<CompileUnit> &
CU : Context->CompileUnits)
1240 UnitHandler(
CU.get());
1299 uint64_t DebugStrNextOffset = 0;
1300 uint64_t DebugLineStrNextOffset = 0;
1305 .emitInplaceString(
"");
1306 DebugStrNextOffset++;
1319 if (StringToEmit->
Offset >= DebugStrNextOffset) {
1320 DebugStrNextOffset =
1324 .emitInplaceString(StringToEmit->
String);
1335 if (StringToEmit->
Offset >= DebugLineStrNextOffset) {
1336 DebugLineStrNextOffset =
1340 .emitInplaceString(StringToEmit->
String);
1355 uint64_t OutOffset = Info.OutOffset;
1356 switch (Info.Type) {
1386 Info.QualifiedNameHash);
1400 if (
Error Err =
Emitter.init(TargetTriple,
"__DWARF")) {
1421 if (
Error Err =
Emitter.init(TargetTriple,
"__DWARF")) {
1442 if (
Error Err =
Emitter.init(TargetTriple,
"__DWARF")) {
1463 if (
Error Err =
Emitter.init(TargetTriple,
"__DWARF")) {
1478 std::unique_ptr<DWARF5AccelTable>
DebugNames;
1486 bool HasRecords =
false;
1489 DebugNames = std::make_unique<DWARF5AccelTable>();
1492 switch (Info.Type) {
1497 Info.OutOffset, Info.ParentOffset, Info.Tag,
1499 CU->getTag() == dwarf::DW_TAG_type_unit);
1508 CompUnits.push_back(
1511 CUidToIdx[
CU->getUniqueID()] = Id++;
1523 if (
Error Err =
Emitter.init(TargetTriple,
"__DWARF")) {
1546 Sections.
forEach([&](std::shared_ptr<SectionDescriptor> OutSection) {
1554 CommonSections.forEach([&](std::shared_ptr<SectionDescriptor> OutSection) {
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
dxil container DXContainer Global Emitter
static fatal_error_handler_t ErrorHandler
ConstantRange Range(APInt(BitWidth, Low), APInt(BitWidth, High))
This class holds an abstract representation of an Accelerator Table, consisting of a sequence of buck...
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.
LLVM_ABI std::optional< DWARFFormValue > find(dwarf::Attribute Attr) const
Extract the specified attribute from this DIE.
LLVM_ABI std::optional< uint64_t > getLanguage() const
Returns the DW_LANG_ code for this DIE's DWARF unit, if it exists.
virtual bool isLittleEndian() const =0
virtual const DWARFSection & getFrameSection() const
virtual uint8_t getAddressSize() const
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.
Implements a dense probed hash-table based set.
Lightweight error class with error context and mandatory checking.
static ErrorSuccess success()
Create a success value.
Tagged union holding either a T or a Error.
A Module instance is used to store all the information related to an LLVM module.
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
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",...
iterator find(StringRef Key)
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.
Represent a constant reference to a string, i.e.
constexpr StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
constexpr bool empty() const
Check if the string is empty.
constexpr size_t size() const
Get the string size.
constexpr const char * data() const
Get a pointer to the start of the string (which may not be null terminated).
A group of tasks to be run on a thread pool.
auto async(Function &&F, Args &&...ArgList)
Calls ThreadPool::async() for this group.
Triple - Helper class for working with autoconf configuration names.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
static Twine utohexstr(uint64_t Val)
std::pair< iterator, bool > insert(const ValueT &V)
This class represents DWARF information for source file and it's address map.
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
@ DebugNames
.debug_names.
@ 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.
@ Cloned
Output DWARF is generated.
@ TypeNamesAssigned
Type names assigned to DIEs.
@ 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.
@ Loaded
Input DWARF is loaded.
@ 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.
@ Skipped
Compile Unit should be skipped.
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.
void emitStringSections()
Emit string sections.
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)
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.
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)
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.
LinkingGlobalData GlobalData
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)
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
StringMapEntry< EmptyStringSetTag > StringEntry
StringEntry keeps data of the string: the length, external offset and a string body which is placed r...
Error finiteLoop(function_ref< Expected< bool >()> Iteration, size_t MaxCounter=100000)
This function calls Iteration() until it returns false.
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.
@ DW_FLAG_type_implementation
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
LLVM_ABI bool is_relative(const Twine &path, Style style=Style::native)
Is path relative?
LLVM_ABI StringRef filename(StringRef path LLVM_LIFETIME_BOUND, Style style=Style::native)
Get filename.
LLVM_ABI bool replace_path_prefix(SmallVectorImpl< char > &Path, StringRef OldPrefix, StringRef NewPrefix, Style style=Style::native)
Replace matching path prefix with another path.
LLVM_ABI void append(SmallVectorImpl< char > &path, const Twine &a, const Twine &b="", const Twine &c="", const Twine &d="")
Append to path.
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,...
Error createFileError(const Twine &F, Error E)
Concatenate a source file path and/or name with an Error.
LLVM_ABI std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
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.
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)
static uint64_t getDwoId(const DWARFDie &CUDie)
Error make_error(ArgTs &&... Args)
Make a Error instance representing failure using the given error info type.
@ Mod
The access may modify the value stored in memory.
void call_once(once_flag &flag, Function &&F, Args &&... ArgList)
Execute the function specified as a parameter once.
bool is_contained(R &&Range, const E &Element)
Returns true if Element is found in Range.
void parallelForEach(IterTy Begin, IterTy End, FuncTy Fn)
void consumeError(Error Err)
Consume a Error without doing anything.
Container for dump options that control which debug information will be dumped.
DIDumpOptions noImplicitRecursion() const
Return the options with RecurseDepth set to 0 unless explicitly required.
unsigned ChildRecurseDepth
DwarfStringPoolEntry with string keeping externally.
Section + local offset of a .debug_frame CIE that has been (or will be) emitted by some LinkContext.
FDEs retained for emission.
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)
DWARFFile & InputDWARFFile
Object file descriptor.
std::unique_ptr< FrameScanResult > FrameScan
Error scanFrameData()
Parse this context's input .debug_frame into FrameScan.
uint64_t OriginalDebugInfoSize
Size of Debug info before optimizing.
Error emitInvariantSections()
Emit invariant sections.
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.
StringMap< uint64_t > & ClangModules
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::atomic< bool > HasNewGlobalDependency
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.
const StringEntry * String
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.