1//===- DWARFLinkerCompileUnit.h ---------------------------------*- C++ -*-===// 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 7//===----------------------------------------------------------------------===// 9#ifndef LLVM_LIB_DWARFLINKER_PARALLEL_DWARFLINKERCOMPILEUNIT_H 10#define LLVM_LIB_DWARFLINKER_PARALLEL_DWARFLINKERCOMPILEUNIT_H 17namespacedwarf_linker {
30/// This is a helper structure which keeps a debug info entry 31/// with it's containing compilation unit. 41 std::optional<UnitEntryPairTy>
getParent();
49/// Stores all information related to a compile unit, be it in its original 50/// instance of the object file or its brand new cloned and generated DIE tree. 51/// NOTE: we need alignment of at least 8 bytes as we use 52/// PointerIntPair<CompileUnit *, 3> in the DependencyTracker.h 55 /// The stages of new compile unit processing. 57 /// Created, linked with input DWARF file. 60 /// Input DWARF is loaded. 63 /// Input DWARF is analysed(DIEs pointing to the real code section are 64 /// discovered, type names are assigned if ODR is requested). 67 /// Check if dependencies have incompatible placement. 68 /// If that is the case modify placement to be compatible. 71 /// Type names assigned to DIEs. 74 /// Output DWARF is generated. 77 /// Offsets inside patch records are updated. 80 /// Resources(Input DWARF, Output DWARF tree) are released. 83 /// Compile Unit should be skipped 97 /// Returns stage of overall processing. 100 /// Set stage of overall processing. 103 /// Loads unit line table. 106 /// Returns name of the file for the \p FileIdx 107 /// from the unit`s line table. 110 /// Returns DWARFFile containing this compile unit. 113 /// Load DIEs of input compilation unit. \returns true if input DIEs 114 /// successfully loaded. 117 /// Reset compile units data(results of liveness analysis, clonning) 118 /// if current stage greater than Stage::Loaded. We need to reset data 119 /// as we are going to repeat stages. 122 /// Collect references to parseable Swift interfaces in imported 123 /// DW_TAG_module blocks. 126 /// Navigate DWARF tree and set die properties. 131 /// Cleanup unneeded resources after compile unit is cloned. 134 /// After cloning stage the output DIEs offsets are deallocated. 135 /// This method copies output offsets for referenced DIEs into DIEs patches. 138 /// Search for subprograms and variables referencing live code and discover 139 /// dependend DIEs. Mark live DIEs, set placement for DIEs. 141bool InterCUProcessingStarted,
142 std::atomic<bool> &HasNewInterconnectedCUs);
144 /// Check dependend DIEs for incompatible placement. 145 /// Make placement to be consistent. 148 /// Check DIEs to have a consistent marking(keep marking, placement marking). 151 /// Search for type entries and assign names. 154 /// Kinds of placement for the output die. 158 /// Corresponding DIE goes to the type table only. 161 /// Corresponding DIE goes to the plain dwarf only. 164 /// Corresponding DIE goes to type table and to plain dwarf. 168 /// Information gathered about source DIEs. 177 /// Data member keeping various flags. 180 /// \returns Placement kind for the corresponding die. 185 /// Sets Placement kind for the corresponding die. 187auto InputData =
Flags.load();
188while (!
Flags.compare_exchange_weak(InputData,
193 /// Unsets Placement kind for the corresponding die. 195auto InputData =
Flags.load();
196while (!
Flags.compare_exchange_weak(InputData, (InputData & ~0x7))) {
200 /// Sets Placement kind for the corresponding die. 202auto InputData =
Flags.load();
203if ((InputData & 0x7) ==
NotSet)
204if (
Flags.compare_exchange_weak(InputData, (InputData |
Placement)))
210#define SINGLE_FLAG_METHODS_SET(Name, Value) \ 211 bool get##Name() const { return Flags & Value; } \ 213 auto InputData = Flags.load(); \ 214 while (!Flags.compare_exchange_weak(InputData, InputData | Value)) { \ 217 void unset##Name() { \ 218 auto InputData = Flags.load(); \ 219 while (!Flags.compare_exchange_weak(InputData, InputData & ~Value)) { \ 223 /// DIE is a part of the linked output. 226/// DIE has children which are part of the linked output. 229 /// DIE has children which are part of the type table. 232 /// DIE is in module scope. 235 /// DIE is in function scope. 238 /// DIE is in anonymous namespace scope. 241 /// DIE is available for ODR type deduplication. 244 /// Track liveness for the DIE. 247 /// Track liveness for the DIE. 251auto InputData =
Flags.load();
252while (!
Flags.compare_exchange_weak(
253 InputData, InputData & ~(0x7 | 0x8 | 0x10 | 0x20))) {
260#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) 267 getKeepTypeChildren();
273 getKeepPlainChildren();
277 /// \defgroup Group of functions returning DIE info. 281 /// \p Idx index of the DIE. 282 /// \returns DieInfo descriptor. 285 /// \p Idx index of the DIE. 286 /// \returns DieInfo descriptor. 289 /// \p Idx index of the DIE. 290 /// \returns DieInfo descriptor. 295 /// \p Idx index of the DIE. 296 /// \returns DieInfo descriptor. 302 /// \returns PlainDieInfo descriptor. 308 /// \returns PlainDieInfo descriptor. 313 /// \p Idx index of the DIE. 314 /// \returns DieInfo descriptor. 316returnreinterpret_cast<std::atomic<uint64_t> *
>(&OutDieOffsetArray[
Idx])
320 /// \p Idx index of the DIE. 321 /// \returns type entry. 323returnreinterpret_cast<std::atomic<TypeEntry *> *
>(&TypeEntries[
Idx])
327 /// \p InputDieEntry debug info entry. 328 /// \returns DieInfo descriptor. 330returnreinterpret_cast<std::atomic<uint64_t> *
>(
335 /// \p InputDieEntry debug info entry. 336 /// \returns type entry. 338returnreinterpret_cast<std::atomic<TypeEntry *> *
>(
343 /// \p Idx index of the DIE. 344 /// \returns DieInfo descriptor. 346reinterpret_cast<std::atomic<uint64_t> *
>(&OutDieOffsetArray[
Idx])
350 /// \p Idx index of the DIE. 353reinterpret_cast<std::atomic<TypeEntry *> *
>(&TypeEntries[
Idx])
357 /// \p InputDieEntry debug info entry. 361reinterpret_cast<std::atomic<TypeEntry *> *
>(
368 /// Returns value of DW_AT_low_pc attribute. 369 std::optional<uint64_t>
getLowPc()
const{
return LowPc; }
371 /// Returns value of DW_AT_high_pc attribute. 374 /// Returns true if there is a label corresponding to the specified \p Addr. 377 /// Add the low_pc of a label that is relocated by applying 378 /// offset \p PCOffset. 381 /// Resolve the DIE attribute reference that has been extracted in \p 382 /// RefValue. The resulting DIE might be in another CompileUnit. 383 /// \returns referenced die and corresponding compilation unit. 384 /// compilation unit is null if reference could not be resolved. 385 std::optional<UnitEntryPairTy>
389 std::optional<UnitEntryPairTy>
396 /// Add a function range [\p LowPC, \p HighPC) that is relocated by applying 397 /// offset \p PCOffset. 400 /// Returns function ranges of this unit. 403 /// Clone and emit this compilation unit. 405cloneAndEmit(std::optional<std::reference_wrapper<const Triple>> TargetTriple,
408 /// Clone and emit debug locations(.debug_loc/.debug_loclists). 411 /// Clone and emit ranges. 414 /// Clone and emit debug macros(.debug_macinfo/.debug_macro). 417// Clone input DIE entry. 418 std::pair<DIE *, TypeEntry *>
421 std::optional<int64_t> FuncAddressAdjustment,
422 std::optional<int64_t> VarAddressAdjustment,
425// Clone and emit line table. 428 /// Clone attribute location axpression. 432 std::optional<int64_t> VarAddressAdjustment,
435 /// Returns index(inside .debug_addr) of an address. 440 /// Returns directory and file from the line table by index. 441 std::optional<std::pair<StringRef, StringRef>>
444 /// Returns directory and file from the line table by index. 445 std::optional<std::pair<StringRef, StringRef>>
448 /// \defgroup Helper methods to access OrigUnit. 452 /// Returns paired compile unit from input DWARF. 454assert(OrigUnit !=
nullptr);
460assert(OrigUnit !=
nullptr);
466assert(OrigUnit !=
nullptr);
471assert(OrigUnit !=
nullptr);
476assert(OrigUnit !=
nullptr);
481assert(OrigUnit !=
nullptr);
486assert(OrigUnit !=
nullptr);
487return OrigUnit->
getUnitDIE(ExtractUnitDIEOnly);
491assert(OrigUnit !=
nullptr);
496assert(OrigUnit !=
nullptr);
501assert(OrigUnit !=
nullptr);
507assert(OrigUnit !=
nullptr);
517for (
auto Attr : Attrs) {
518if (
autoValue = AbbrevDecl->getAttributeValue(Die->
getOffset(), Attr,
532 /// \defgroup Methods used for reporting warnings and errors: 547if (DieEntry !=
nullptr) {
568 /// Save specified accelerator info \p Info. 573 /// Enumerates all units accelerator records. 576 AcceleratorRecords.
forEach(Handler);
579 /// Output unit selector. 585 /// Accessor for common functionality. 592 /// Returns CompileUnit if applicable. 595 /// Returns TypeUnit if applicable. 603 /// Navigate DWARF tree recursively and set die properties. 605bool IsODRUnavailableFunctionScope);
607structLinkedLocationExpressionsWithOffsetPatches {
611usingLinkedLocationExpressionsVector =
614 /// Emit debug locations. 617 /// Emit location list header. 620 /// Emit location list fragment. 622const LinkedLocationExpressionsVector &LinkedLocationExpression,
625 /// Emit the .debug_addr section fragment for current unit. 626Error emitDebugAddrSection();
628 /// Emit .debug_aranges. 631 /// Clone and emit .debug_ranges/.debug_rnglists. 635 /// Emit range list header. 638 /// Emit range list fragment. 642 /// Insert the new line info sequence \p Seq into the current 643 /// set of already linked line info \p Rows. 644void insertLineSequence(std::vector<DWARFDebugLine::Row> &Seq,
645 std::vector<DWARFDebugLine::Row> &Rows);
647 /// Emits body for both macro sections. 649uint64_t OffsetToMacroTable,
bool hasDWARFv5Header);
651 /// Creates DIE which would be placed into the "Plain" compile unit. 652DIE *createPlainDIEandCloneAttributes(
654uint64_t &OutOffset, std::optional<int64_t> &FuncAddressAdjustment,
655 std::optional<int64_t> &VarAddressAdjustment);
657 /// Creates DIE which would be placed into the "Type" compile unit. 658TypeEntry *createTypeDIEandCloneAttributes(
662 /// Create output DIE inside specified \p TypeDescriptor. 665bool IsDeclaration,
bool IsParentDeclaration);
667 /// Enumerate \p DieEntry children and assign names for them. 671 /// DWARFFile containing this compile unit. 674 /// Pointer to the paired compile unit from the input DWARF. 677 /// The DW_AT_language of this unit. 678 std::optional<uint16_t> Language;
680 /// Line table for this unit. 683 /// Cached resolved paths from the line table. 684 /// The key is <UniqueUnitID, FileIdx>. 686 ResolvedPathsMap ResolvedFullPaths;
689 /// Maps an address into the index inside .debug_addr section. 692 std::unique_ptr<DependencyTracker> Dependencies;
694 /// \defgroup Data Members accessed asinchronously. 699 std::optional<uint64_t> LowPc;
702 /// Flag indicating whether type de-duplication is forbidden. 705 /// The ranges in that map are the PC ranges for functions in this unit, 706 /// associated with the PC offset to apply to the addresses to get 707 /// the linked address. 709 std::mutex RangesMutex;
711 /// The DW_AT_low_pc of each DW_TAG_label. 714 std::mutex LabelsMutex;
716 /// This field keeps current stage of overall compile unit processing. 717 std::atomic<Stage>
Stage;
719 /// DIE info indexed by DIE index. 724 /// The list of accelerator records for this unit. 729/// \returns list of attributes referencing type DIEs which might be 731/// Note: it does not include DW_AT_containing_type attribute to avoid 732/// infinite recursion. 735}
// end of namespace parallel 736}
// end of namespace dwarf_linker 737}
// end of namespace llvm 739#endif// LLVM_LIB_DWARFLINKER_PARALLEL_DWARFLINKERCOMPILEUNIT_H AMDGPU Mark last scratch load
Analysis containing CSE Info
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds.
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
Branch Probability Basic Block Placement
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
AddressRangesMap class maps values to the address ranges.
The AddressRanges class helps normalize address range collections.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Allocate memory in an ever growing pool, as if by bump-pointer.
A structured debug information entry.
DWARFDebugInfoEntry - A DIE with only the minimum required data.
uint64_t getOffset() const
const DWARFAbbreviationDeclaration * getAbbreviationDeclarationPtr() const
Utility class that carries the DWARF compile/type unit and the debug info entry in an object.
const DWARFDebugInfoEntry * getDebugInfoEntry(unsigned Index) const
Return DWARFDebugInfoEntry for the specified index Index.
const DWARFDebugInfoEntry * getSiblingEntry(const DWARFDebugInfoEntry *Die) const
DWARFDie getUnitDIE(bool ExtractUnitDIEOnly=true)
DWARFDie getParent(const DWARFDebugInfoEntry *Die)
std::optional< uint32_t > getDIEIndexForOffset(uint64_t Offset)
Return the DIE index for a given offset Offset inside the unit's DIE vector.
uint32_t getDIEIndex(const DWARFDebugInfoEntry *Die) const
Return the index of a Die entry inside the unit's DIE vector.
const DWARFDebugInfoEntry * getFirstChildEntry(const DWARFDebugInfoEntry *Die) const
DWARFDie getDIEAtIndex(unsigned Index)
Return the DIE object at the given index Index.
size_type count(const_arg_type_t< KeyT > Val) const
Return 1 if the specified key is in the map, 0 otherwise.
Base class for error info classes.
Lightweight error class with error context and mandatory checking.
Class representing an expression and its matching format.
A discriminated union of two or more pointer types, with the discriminator in the low bit of the poin...
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
StringMapEntry - This is used to represent one value that is inserted into a StringMap.
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
StringRef - Represent a constant reference to a string, i.e.
Triple - Helper class for working with autoconf configuration names.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
LLVM Value Representation.
This class represents DWARF information for source file and it's address map.
This class stores values sequentually and assigns index to the each value.
uint64_t getValueIndex(T Value)
This class is a simple list of T structures.
T & add(const T &Item)
Add specified Item to the list.
void forEach(ItemHandlerTy Handler)
Enumerate all items and apply specified Handler to each.
TypeUnit * getAsTypeUnit()
Returns TypeUnit if applicable.
DwarfUnit * operator->()
Accessor for common functionality.
PointerUnion< CompileUnit *, TypeUnit * > Ptr
CompileUnit * getAsCompileUnit()
Returns CompileUnit if applicable.
Stores all information related to a compile unit, be it in its original instance of the object file o...
void addLabelLowPc(uint64_t LabelLowPc, int64_t PcOffset)
Add the low_pc of a label that is relocated by applying offset PCOffset.
Error cloneAndEmitDebugLocations()
Clone and emit debug locations(.debug_loc/.debug_loclists).
void cloneDieAttrExpression(const DWARFExpression &InputExpression, SmallVectorImpl< uint8_t > &OutputExpression, SectionDescriptor &Section, std::optional< int64_t > VarAddressAdjustment, OffsetsPtrVector &PatchesOffsets)
Clone attribute location axpression.
void maybeResetToLoadedStage()
Reset compile units data(results of liveness analysis, clonning) if current stage greater than Stage:...
void addFunctionRange(uint64_t LowPC, uint64_t HighPC, int64_t PCOffset)
Add a function range [LowPC, HighPC) that is relocated by applying offset PCOffset.
void analyzeImportedModule(const DWARFDebugInfoEntry *DieEntry)
Collect references to parseable Swift interfaces in imported DW_TAG_module blocks.
std::pair< DIE *, TypeEntry * > cloneDIE(const DWARFDebugInfoEntry *InputDieEntry, TypeEntry *ClonedParentTypeDIE, uint64_t OutOffset, std::optional< int64_t > FuncAddressAdjustment, std::optional< int64_t > VarAddressAdjustment, BumpPtrAllocator &Allocator, TypeUnit *ArtificialTypeUnit)
void cleanupDataAfterClonning()
Cleanup unneeded resources after compile unit is cloned.
Error assignTypeNames(TypePool &TypePoolRef)
Search for type entries and assign names.
uint64_t getHighPc() const
Returns value of DW_AT_high_pc attribute.
DieOutputPlacement
Kinds of placement for the output die.
@ Both
Corresponding DIE goes to type table and to plain dwarf.
@ TypeTable
Corresponding DIE goes to the type table only.
@ PlainDwarf
Corresponding DIE goes to the plain dwarf only.
Error cloneAndEmitLineTable(const Triple &TargetTriple)
void analyzeDWARFStructure()
Navigate DWARF tree and set die properties.
Error cloneAndEmitRanges()
Clone and emit ranges.
void updateDieRefPatchesWithClonedOffsets()
After cloning stage the output DIEs offsets are deallocated.
uint64_t getDebugAddrIndex(uint64_t Addr)
Returns index(inside .debug_addr) of an address.
const DWARFFile & getContaingFile() const
Returns DWARFFile containing this compile unit.
bool resolveDependenciesAndMarkLiveness(bool InterCUProcessingStarted, std::atomic< bool > &HasNewInterconnectedCUs)
Search for subprograms and variables referencing live code and discover dependend DIEs.
bool hasLabelAt(uint64_t Addr) const
Returns true if there is a label corresponding to the specified Addr.
bool updateDependenciesCompleteness()
Check dependend DIEs for incompatible placement.
bool loadInputDIEs()
Load DIEs of input compilation unit.
const RangesTy & getFunctionRanges() const
Returns function ranges of this unit.
void saveAcceleratorInfo(const DwarfUnit::AccelInfo &Info)
Save specified accelerator info Info.
Error cloneAndEmitDebugMacro()
Clone and emit debug macros(.debug_macinfo/.debug_macro).
Error cloneAndEmit(std::optional< std::reference_wrapper< const Triple > > TargetTriple, TypeUnit *ArtificialTypeUnit)
Clone and emit this compilation unit.
void setStage(Stage Stage)
Set stage of overall processing.
Stage getStage() const
Returns stage of overall processing.
void verifyDependencies()
Check DIEs to have a consistent marking(keep marking, placement marking).
Stage
The stages of new compile unit processing.
@ Cloned
Output DWARF is generated.
@ TypeNamesAssigned
Type names assigned to DIEs.
@ 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 are discovered,...
@ UpdateDependenciesCompleteness
Check if dependencies have incompatible placement.
@ Skipped
Compile Unit should be skipped.
void forEachAcceleratorRecord(function_ref< void(AccelInfo &)> Handler) override
Enumerates all units accelerator records.
std::optional< uint64_t > getLowPc() const
Returns value of DW_AT_low_pc attribute.
std::optional< std::pair< StringRef, StringRef > > getDirAndFilenameFromLineTable(const DWARFFormValue &FileIdxValue)
Returns directory and file from the line table by index.
std::optional< UnitEntryPairTy > resolveDIEReference(const DWARFFormValue &RefValue, ResolveInterCUReferencesMode CanResolveInterCUReferences)
Resolve the DIE attribute reference that has been extracted in RefValue.
void loadLineTable()
Loads unit line table.
StringEntry * getFileName(unsigned FileIdx, StringPool &GlobalStrings)
Returns name of the file for the FileIdx from the unit`s line table.
This class is a helper to create output DIE tree.
This class discovers DIEs dependencies: marks "live" DIEs, marks DIE locations (whether DIE should be...
Base class for all Dwarf units(Compile unit/Type table unit).
StringRef getUnitName() const
Returns this unit name.
std::string ClangModuleName
If this is a Clang module, this holds the module's name.
This class keeps data and services common for the whole linking process.
void warn(const Twine &Warning, StringRef Context, const DWARFDie *DIE=nullptr)
Report warning.
void error(const Twine &Err, StringRef Context, const DWARFDie *DIE=nullptr)
Report error.
LinkingGlobalData & GlobalData
dwarf::FormParams Format
Format for sections.
The helper class to build type name based on DIE properties.
Keeps cloned data for the type DIE.
TypePool keeps type descriptors which contain partially cloned DIE correspinding to each type.
Type Unit is used to represent an artificial compilation unit which keeps all type information.
uint64_t getDieOutOffset(const DWARFDebugInfoEntry *InputDieEntry)
InputDieEntry debug info entry.
void rememberDieOutOffset(uint32_t Idx, uint64_t Offset)
Idx index of the DIE.
TypeEntry * getDieTypeEntry(uint32_t Idx)
Idx index of the DIE.
DIEInfo & getDIEInfo(unsigned Idx)
Idx index of the DIE.
const DIEInfo & getDIEInfo(const DWARFDebugInfoEntry *Entry) const
Idx index of the DIE.
uint64_t getDieOutOffset(uint32_t Idx)
Idx index of the DIE.
const DIEInfo & getDIEInfo(const DWARFDie &Die) const
Die
const DIEInfo & getDIEInfo(unsigned Idx) const
Idx index of the DIE.
DIEInfo & getDIEInfo(const DWARFDebugInfoEntry *Entry)
Idx index of the DIE.
TypeEntry * getDieTypeEntry(const DWARFDebugInfoEntry *InputDieEntry)
InputDieEntry debug info entry.
void setDieTypeEntry(const DWARFDebugInfoEntry *InputDieEntry, TypeEntry *Entry)
InputDieEntry debug info entry.
void setDieTypeEntry(uint32_t Idx, TypeEntry *Entry)
Idx index of the DIE.
DIEInfo & getDIEInfo(const DWARFDie &Die)
Die
const DWARFDebugInfoEntry * getSiblingEntry(const DWARFDebugInfoEntry *Die) const
const DWARFDebugInfoEntry * getFirstChildEntry(const DWARFDebugInfoEntry *Die) const
std::optional< uint32_t > getDIEIndexForOffset(uint64_t Offset)
DWARFDie getDIEAtIndex(unsigned Index)
DWARFDie getDIE(const DWARFDebugInfoEntry *Die)
std::optional< DWARFFormValue > find(const DWARFDebugInfoEntry *Die, ArrayRef< dwarf::Attribute > Attrs) const
const DWARFDebugInfoEntry * getDebugInfoEntry(unsigned Index) const
DWARFUnit & getOrigUnit() const
Returns paired compile unit from input DWARF.
DWARFDie getUnitDIE(bool ExtractUnitDIEOnly=true)
DWARFDie getParent(const DWARFDebugInfoEntry *Die)
uint32_t getDIEIndex(const DWARFDebugInfoEntry *Die) const
uint32_t getDIEIndex(const DWARFDie &Die) const
std::optional< DWARFFormValue > find(uint32_t DieIdx, ArrayRef< dwarf::Attribute > Attrs) const
void error(Error Err, const DWARFDie *DIE=nullptr)
void warn(Error Warning, const DWARFDie *DIE=nullptr)
void warn(const Twine &Warning, const DWARFDie *DIE=nullptr)
void error(const Twine &Err, const DWARFDie *DIE=nullptr)
void warn(const Twine &Warning, const DWARFDebugInfoEntry *DieEntry)
#define SINGLE_FLAG_METHODS_SET(Name, Value)
ArrayRef< dwarf::Attribute > getODRAttributes()
ResolveInterCUReferencesMode
DebugSectionKind
List of tracked debug tables.
This is an optimization pass for GlobalISel generic memory operations.
void handleAllErrors(Error E, HandlerTs &&... Handlers)
Behaves the same as handleErrors, except that by contract all errors must be handled by the given han...
@ Keep
No function return thunk.
Represents a single DWARF expression, whose value is location-dependent.
A helper struct providing information about the byte size of DW_FORM values that vary in size dependi...
Information gathered and exchanged between the various clone*Attr helpers about the attributes of a p...
Information gathered about source DIEs.
LLVM_DUMP_METHOD void dump()
void setPlacement(DieOutputPlacement Placement)
Sets Placement kind for the corresponding die.
bool needToKeepInPlainDwarf() const
std::atomic< uint16_t > Flags
Data member keeping various flags.
bool needToPlaceInTypeTable() const
DieOutputPlacement getPlacement() const
void unsetPlacement()
Unsets Placement kind for the corresponding die.
bool setPlacementIfUnset(DieOutputPlacement Placement)
Sets Placement kind for the corresponding die.
DIEInfo & operator=(const DIEInfo &Other)
void unsetFlagsWhichSetDuringLiveAnalysis()
DIE is a part of the linked output.
DIEInfo(const DIEInfo &Other)
void eraseData()
Erase all flags.
This structure keeps fields which would be used for creating accelerator table.
This structure is used to keep data of the concrete section.
This is a helper structure which keeps a debug info entry with it's containing compilation unit.
UnitEntryPairTy()=default
UnitEntryPairTy(CompileUnit *CU, const DWARFDebugInfoEntry *DieEntry)
std::optional< UnitEntryPairTy > getParent()
UnitEntryPairTy getNamespaceOrigin()
const DWARFDebugInfoEntry * DieEntry
