30#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
37 while (!Worklist.
empty()) {
53 CU.getDIEInfo(Child.getDebugInfoEntry());
57 if (!ParentPlainDieIsKept && ChildPlainDieIsKept)
59 "Found invalid link in keep chain");
61 if (Child.getTag() == dwarf::DW_TAG_subprogram) {
63 &
CU, Child.getDebugInfoEntry()))) {
65 "Live subprogram is not marked as kept");
69 if (!ChildInfo.getODRAvailable()) {
70 assert(!ChildTypeDieIsKept);
74 if (!ParentTypeDieIsKept && ChildTypeDieIsKept)
76 "Found invalid link in keep chain");
78 if (CurrentInfo.getIsInAnonNamespaceScope() &&
81 "Found invalid placement marking for member "
82 "of anonymous namespace");
87 if (!BrokenLinks.
empty()) {
89 errs() <<
"\n=================================\n";
91 Link.Parent.getOffset(),
92 Link.Child.getOffset());
94 errs() <<
"\nParent:";
95 Link.Parent.dump(
errs(), 0, {});
97 CU.getDIEInfo(Link.Parent).dump();
100 Link.Child.dump(
errs(), 2, {});
102 CU.getDIEInfo(Link.Child).dump();
110 switch (Entry->getTag()) {
111 case dwarf::DW_TAG_compile_unit:
112 case dwarf::DW_TAG_module:
113 case dwarf::DW_TAG_namespace:
128 std::nullopt,
false);
132 bool InterCUProcessingStarted, std::atomic<bool> &HasNewInterconnectedCUs) {
139 "recorded subtrees would be walked in a different resolution mode");
144 HasNewInterconnectedCUs);
149 std::optional<UnitEntryPairTy> ReferencedBy,
153 ReferencedTypeDieEntry);
161 const UnitEntryPairTy &Entry, std::optional<UnitEntryPairTy> ReferencedBy,
164 Entry.CU->getFirstChildEntry(Entry.DieEntry);
166 CurChild = Entry.CU->getSiblingEntry(CurChild)) {
170 bool IsLiveChild =
false;
172 switch (CurChild->getTag()) {
173 case dwarf::DW_TAG_label: {
178 if (IsLiveChild || (IsLiveParent && ChildInfo.getHasAnAddress())) {
184 case dwarf::DW_TAG_subprogram: {
192 (ChildInfo.getIsInMouduleScope() && ChildInfo.getODRAvailable())
199 case dwarf::DW_TAG_constant:
200 case dwarf::DW_TAG_variable: {
209 (ChildInfo.getIsInMouduleScope() && ChildInfo.getODRAvailable())
216 case dwarf::DW_TAG_base_type: {
222 case dwarf::DW_TAG_imported_module:
223 case dwarf::DW_TAG_imported_declaration:
224 case dwarf::DW_TAG_imported_unit: {
226 if (Entry.DieEntry->getTag() == dwarf::DW_TAG_compile_unit) {
237 case dwarf::DW_TAG_type_unit:
238 case dwarf::DW_TAG_partial_unit:
239 case dwarf::DW_TAG_compile_unit: {
263 if (!Entry.CU->isClangModule() &&
264 Entry.DieEntry->getTag() == dwarf::DW_TAG_module &&
280 bool InterCUProcessingStarted, std::atomic<bool> &HasNewInterconnectedCUs) {
289 HasNewInterconnectedCUs)) {
328 std::atomic<bool> HasNewInterconnectedCUs =
false;
330 Ref.Action,
Ref.ReferencedBy,
Ref.Subtree,
333 assert(Res && !HasNewInterconnectedCUs &&
"record-deps-only walk failed");
353 ReferencedTypeDieEntry ? ReferencedTypeDieEntry : Root.
DieEntry;
370 bool HasNewDependency =
false;
373 Ref.ReferencedBy.CU->getDIEInfo(
Ref.ReferencedBy.DieEntry);
387 HasNewDependency =
true;
393 return HasNewDependency;
399 bool HasNewDependency =
false;
401 assert(Root.hasReferencedByOtherEntry() &&
402 "Root entry without dependency inside the dependencies list");
405 Root.getReferencedTypeDieEntry(),
406 Root.getReferencedByEntry()))
407 HasNewDependency =
true;
411 HasNewDependency =
true;
413 return HasNewDependency;
420 !Info.getKeepTypeChildren())
424 Info.unsetKeepTypeChildren();
428 Entry.CU->getFirstChildEntry(Entry.DieEntry);
430 CurChild = Entry.CU->getSiblingEntry(CurChild))
439 switch (NewPlacement) {
441 return Info.needToPlaceInTypeTable();
444 return Info.needToKeepInPlainDwarf();
447 return Info.needToPlaceInTypeTable() && Info.needToKeepInPlainDwarf();
458 return isAlreadyMarked(Entry.CU->getDIEInfo(Entry.DieEntry), NewPlacement);
477 if (Entry.DieEntry->getAbbreviationDeclarationPtr() ==
nullptr)
482 bool NeedKeepPlainChildren = Info.needToKeepInPlainDwarf();
484 bool AreTypeParentsDone = !NeedKeepTypeChildren;
485 bool ArePlainParentsDone = !NeedKeepPlainChildren;
488 std::optional<uint32_t> ParentIdx = Entry.DieEntry->getParentIdx();
491 Entry.CU->getDebugInfoEntry(*ParentIdx);
494 if (!AreTypeParentsDone && NeedKeepTypeChildren) {
495 if (ParentInfo.getKeepTypeChildren())
496 AreTypeParentsDone =
true;
500 ParentInfo.setKeepTypeChildren();
509 if (!ArePlainParentsDone && NeedKeepPlainChildren) {
510 if (ParentInfo.getKeepPlainChildren())
511 ArePlainParentsDone =
true;
515 ParentInfo.setKeepPlainChildren();
524 if (AreTypeParentsDone && ArePlainParentsDone)
532struct FinalPlacement {
567 if (!EntryInfo.getODRAvailable())
570 if (Entry.DieEntry->getTag() == dwarf::DW_TAG_variable) {
580 Entry.CU->find(Entry.DieEntry, dwarf::DW_AT_declaration), 0);
581 bool ParentIsType =
false;
583 if (std::optional<uint32_t> ParentIdx = Entry.DieEntry->getParentIdx()) {
585 Entry.CU->getDebugInfoEntry(*ParentIdx)->getTag();
586 ParentIsType = ParentTag == dwarf::DW_TAG_class_type ||
587 ParentTag == dwarf::DW_TAG_structure_type ||
588 ParentTag == dwarf::DW_TAG_union_type;
591 if (IsDeclaration && ParentIsType) {
603 return {
Placement, FinalPlacement::JoinVariable};
606 return {
Placement, FinalPlacement::Join};
612 std::atomic<bool> &HasNewInterconnectedCUs,
TreeWalkKindTy Kind) {
613 if (Entry.DieEntry->getAbbreviationDeclarationPtr() ==
nullptr)
625 "Wrong kind of placement for ODR unavailable entry");
646 switch (Final.Mode) {
647 case FinalPlacement::Overwrite:
650 case FinalPlacement::Join:
653 case FinalPlacement::JoinVariable:
662 bool IsSubprogram = Entry.DieEntry->getTag() == dwarf::DW_TAG_subprogram;
676 InterCUProcessingStarted,
677 HasNewInterconnectedCUs, FinalKind))
681 if (isSingleAction(Action))
686 if (Entry.DieEntry->getTag() == dwarf::DW_TAG_subprogram &&
687 Info.getODRAvailable()) {
698 Entry.CU->getFirstChildEntry(Entry.DieEntry);
700 CurChild = Entry.CU->getSiblingEntry(CurChild)) {
703 switch (CurChild->getTag()) {
704 case dwarf::DW_TAG_variable:
705 case dwarf::DW_TAG_constant:
706 case dwarf::DW_TAG_subprogram:
707 case dwarf::DW_TAG_label: {
708 if (ChildInfo.getHasAnAddress()) {
716 case dwarf::DW_TAG_lexical_block:
717 case dwarf::DW_TAG_friend:
718 case dwarf::DW_TAG_inheritance:
719 case dwarf::DW_TAG_formal_parameter:
720 case dwarf::DW_TAG_unspecified_parameters:
721 case dwarf::DW_TAG_template_type_parameter:
722 case dwarf::DW_TAG_template_value_parameter:
723 case dwarf::DW_TAG_GNU_template_parameter_pack:
724 case dwarf::DW_TAG_GNU_formal_parameter_pack:
725 case dwarf::DW_TAG_GNU_template_template_param:
726 case dwarf::DW_TAG_thrown_type: {
747 InterCUProcessingStarted, HasNewInterconnectedCUs, FinalKind))
756 Entry.CU->getFirstChildEntry(Entry.DieEntry);
758 CurChild = Entry.CU->getSiblingEntry(CurChild)) {
760 switch (CurChild->getTag()) {
761 case dwarf::DW_TAG_variable:
762 case dwarf::DW_TAG_constant:
763 case dwarf::DW_TAG_subprogram:
764 case dwarf::DW_TAG_label: {
765 if (ChildInfo.getHasAnAddress()) {
777 InterCUProcessingStarted, HasNewInterconnectedCUs, FinalKind))
790 case dwarf::DW_TAG_imported_module:
791 case dwarf::DW_TAG_imported_declaration:
792 case dwarf::DW_TAG_imported_unit:
793 case dwarf::DW_TAG_array_type:
794 case dwarf::DW_TAG_class_type:
795 case dwarf::DW_TAG_enumeration_type:
796 case dwarf::DW_TAG_pointer_type:
797 case dwarf::DW_TAG_reference_type:
798 case dwarf::DW_TAG_string_type:
799 case dwarf::DW_TAG_structure_type:
800 case dwarf::DW_TAG_subroutine_type:
801 case dwarf::DW_TAG_typedef:
802 case dwarf::DW_TAG_union_type:
803 case dwarf::DW_TAG_variant:
804 case dwarf::DW_TAG_module:
805 case dwarf::DW_TAG_ptr_to_member_type:
806 case dwarf::DW_TAG_set_type:
807 case dwarf::DW_TAG_subrange_type:
808 case dwarf::DW_TAG_base_type:
809 case dwarf::DW_TAG_const_type:
810 case dwarf::DW_TAG_enumerator:
811 case dwarf::DW_TAG_file_type:
812 case dwarf::DW_TAG_packed_type:
813 case dwarf::DW_TAG_thrown_type:
814 case dwarf::DW_TAG_volatile_type:
815 case dwarf::DW_TAG_dwarf_procedure:
816 case dwarf::DW_TAG_restrict_type:
817 case dwarf::DW_TAG_interface_type:
818 case dwarf::DW_TAG_namespace:
819 case dwarf::DW_TAG_unspecified_type:
820 case dwarf::DW_TAG_shared_type:
821 case dwarf::DW_TAG_rvalue_reference_type:
822 case dwarf::DW_TAG_coarray_type:
823 case dwarf::DW_TAG_dynamic_type:
824 case dwarf::DW_TAG_atomic_type:
825 case dwarf::DW_TAG_immutable_type:
826 case dwarf::DW_TAG_function_template:
827 case dwarf::DW_TAG_class_template:
835 std::atomic<bool> &HasNewInterconnectedCUs,
TreeWalkKindTy Kind) {
836 const auto *Abbrev = Entry.DieEntry->getAbbreviationDeclarationPtr();
837 if (Abbrev ==
nullptr)
850 ReferencedTypeDieEntry);
858 {RootAction, Root, ReferencedTypeDieEntry});
865 ReferencedTypeDieEntry);
871 DWARFUnit &Unit = Entry.CU->getOrigUnit();
877 for (
const auto &AttrSpec : Abbrev->attributes()) {
880 AttrSpec.Attr == dwarf::DW_AT_sibling) {
882 Unit.getFormParams());
888 std::optional<UnitEntryPairTy> RefDie = Entry.CU->resolveDIEReference(
889 Val, InterCUProcessingStarted
893 Entry.CU->warn(
"could not find referenced DIE", Entry.DieEntry);
897 if (!RefDie->DieEntry) {
905 RefDie->CU->setInterconnectedCU();
906 Entry.CU->setInterconnectedCU();
907 HasNewInterconnectedCUs =
true;
911 assert((Entry.CU->getUniqueID() == RefDie->CU->getUniqueID() ||
912 InterCUProcessingStarted) &&
913 "Inter-CU reference while inter-CU processing is not started");
915 "Referenced unit has not found its live roots");
918 if (!RefInfo.getODRAvailable())
920 else if (RefInfo.getODRAvailable() &&
931 if (AttrSpec.Attr == dwarf::DW_AT_import) {
940 AddRoot(Action, *RefDie,
nullptr);
949 AddRoot(Action, RootForReferencedDie, RefDie->DieEntry);
960 switch (Entry.DieEntry->getTag()) {
961 case dwarf::DW_TAG_subprogram:
962 case dwarf::DW_TAG_label:
963 case dwarf::DW_TAG_variable:
964 case dwarf::DW_TAG_constant: {
973 std::optional<uint32_t> ParentIdx = Result.DieEntry->getParentIdx();
978 Result.CU->getDebugInfoEntry(*ParentIdx);
981 Result.DieEntry = ParentEntry;
990 outs() <<
"Keeping " << Kind <<
" DIE:";
1002 if (Info.getTrackLiveness()) {
1003 const auto *Abbrev =
DIE.getAbbreviationDeclarationPtr();
1005 if (!Info.getIsInFunctionScope() &&
1006 Abbrev->findAttributeIndex(dwarf::DW_AT_const_value)) {
1014 std::pair<bool, std::optional<int64_t>> LocExprAddrAndRelocAdjustment =
1015 Entry.CU->getContainingFile().Addresses->getVariableRelocAdjustment(
1016 DIE, Entry.CU->getGlobalData().getOptions().Verbose);
1018 if (LocExprAddrAndRelocAdjustment.first)
1019 Info.setHasAnAddress();
1021 if (!LocExprAddrAndRelocAdjustment.second)
1024 if (!IsLiveParent && Info.getIsInFunctionScope() &&
1025 !Entry.CU->getGlobalData().getOptions().KeepFunctionForStatic) {
1026 Info.setKeepWithParent();
1031 Info.setHasAnAddress();
1033 dumpKeptDIE(
DIE,
"variable", Entry.CU->getGlobalData().getOptions().Verbose);
1041 std::optional<DWARFFormValue> LowPCVal =
DIE.find(dwarf::DW_AT_low_pc);
1043 const bool Verbose = Entry.CU->getGlobalData().getOptions().Verbose;
1044 std::optional<uint64_t> LowPc;
1045 std::optional<uint64_t> HighPc;
1046 std::optional<int64_t> RelocAdjustment;
1047 if (Info.getTrackLiveness()) {
1052 Info.setHasAnAddress();
1055 Entry.CU->getContainingFile().Addresses->getSubprogramRelocAdjustment(
1057 if (!RelocAdjustment)
1060 if (
DIE.
getTag() == dwarf::DW_TAG_subprogram) {
1063 HighPc =
DIE.getHighPC(*LowPc);
1065 Entry.CU->warn(
"function without high_pc. Range will be discarded.",
1070 if (*LowPc > *HighPc) {
1071 Entry.CU->warn(
"low_pc greater than high_pc. Range will be discarded.",
1075 }
else if (
DIE.
getTag() == dwarf::DW_TAG_label) {
1076 if (Entry.CU->hasLabelAt(*LowPc))
1093 Entry.CU->getOrigUnit().getUnitDIE().find(dwarf::DW_AT_language), 0);
1094 if (Language == dwarf::DW_LANG_Mips_Assembler ||
1095 Language == dwarf::DW_LANG_Assembly) {
1096 if (
auto Range = Entry.CU->getContainingFile()
1097 .Addresses->getSymbolRangeForAddress(*LowPc))
1098 Entry.CU->addFunctionRange(
Range->LowPC,
Range->HighPC,
1102 Entry.CU->addLabelLowPc(*LowPc, *RelocAdjustment);
1105 Info.setHasAnAddress();
1109 if (!Info.getTrackLiveness() ||
DIE.
getTag() == dwarf::DW_TAG_label)
1112 Entry.CU->addFunctionRange(
1114 Entry.CU->getContainingFile().Addresses->constrainCodeRangeHighPC(
1115 *LowPc, *HighPc, *RelocAdjustment),
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
bool isAlreadyMarked(const CompileUnit::DIEInfo &Info, CompileUnit::DieOutputPlacement NewPlacement)
static void dumpKeptDIE(const DWARFDie &DIE, StringRef Kind, bool Verbose)
static FinalPlacement getFinalPlacementForEntry(const UnitEntryPairTy &Entry, CompileUnit::DieOutputPlacement Placement)
static bool isNamespaceLikeEntry(const DWARFDebugInfoEntry *Entry)
Branch Probability Basic Block Placement
ConstantRange Range(APInt(BitWidth, Low), APInt(BitWidth, High))
This file provides utility classes that use RAII to save and restore values.
A pointer to another debug information entry.
A structured debug information entry.
dwarf::Tag getTag() const
LLVM_ABI void dump() const
DWARFDebugInfoEntry - A DIE with only the minimum required data.
std::optional< uint32_t > getParentIdx() const
Returns index of the parent die.
const DWARFAbbreviationDeclaration * getAbbreviationDeclarationPtr() const
Utility class that carries the DWARF compile/type unit and the debug info entry in an object.
iterator_range< iterator > children() const
const DWARFDebugInfoEntry * getDebugInfoEntry() const
reference emplace_back(ArgTypes &&... Args)
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Represent a constant reference to a string, i.e.
static LLVM_ABI raw_ostream & error()
Convenience method for printing "error: " to stderr.
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.
@ LiveRootsCollected
DIEs with a live address are found.
Class keeping live worklist item data.
UnitEntryPairTy getRootEntry() const
LiveRootWorklistActionTy getAction() const
bool hasReferencedByOtherEntry() const
bool markDIEEntryAsKeptRec(LiveRootWorklistActionTy Action, const UnitEntryPairTy &RootEntry, const UnitEntryPairTy &Entry, bool InterCUProcessingStarted, std::atomic< bool > &HasNewInterconnectedCUs, TreeWalkKindTy Kind=TreeWalkKindTy::MarkTree)
Mark whole DIE tree as kept recursively.
void verifyKeepChain()
Recursively walk the DIE tree and check "keepness" and "placement" information.
RootEntriesListTy Dependencies
List of entries dependencies.
void markParentsAsKeepingChildren(const UnitEntryPairTy &Entry)
Mark parents as keeping children.
UnitEntryPairTy getRootForSpecifiedEntry(UnitEntryPairTy Entry)
static bool recordsDepsOnly(TreeWalkKindTy Kind)
bool demoteIfIncomplete(const UnitEntryPairTy &Root, const DWARFDebugInfoEntry *ReferencedTypeDieEntry, const UnitEntryPairTy &ReferencedBy)
Demote ReferencedBy to plain DWARF if it may not stay in the type table while the DIE it references t...
bool markCollectedLiveRootsAsKept(bool InterCUProcessingStarted, std::atomic< bool > &HasNewInterconnectedCUs)
Examine worklist and mark all 'root DIE's as kept and set "Placement" property.
bool InterCUProcessingWasStarted
Whether inter-unit references could be resolved during marking.
bool applySubtreeSummaries()
Apply each summarized subtree's dependencies to every root recorded as referencing it.
bool isLiveAction(LiveRootWorklistActionTy Action)
bool isChildrenAction(LiveRootWorklistActionTy Action)
void keepWithParent(const UnitEntryPairTy &RootEntry, const UnitEntryPairTy &Child, TreeWalkKindTy Kind)
Keep Child if it is a variable that is kept with its parent, which the walk in progress keeps for Roo...
TreeWalkKindTy
What a tree walk does, and for a walk that only records dependencies, which root the dependencies it ...
@ MarkTree
Mark the tree as kept and schedule the roots it references.
@ RecordSubtreeDeps
Do not mark.
@ RecordNestedSubprogramDeps
Do not mark.
bool isTypeAction(LiveRootWorklistActionTy Action)
void addActionToRootEntriesWorkList(LiveRootWorklistActionTy Action, const UnitEntryPairTy &Entry, std::optional< UnitEntryPairTy > ReferencedBy, const DWARFDebugInfoEntry *ReferencedTypeDieEntry=nullptr)
Add action item to the work list.
DenseMap< SubtreeDependenciesKeyTy, SubtreeDependenciesTy > SubtreeSummaries
Dependency summaries of already-marked subtrees, keyed by subtree and action.
SubtreeDependenciesTy * CollectedSubtreeDeps
Where the walk in progress collects the dependencies that belong to the root referencing the walked s...
bool isTypeTableCandidate(const DWARFDebugInfoEntry *DIEEntry)
size_t MaterializedRefs
Number of leading SubtreeDependencyRefs whose subtree is summarized.
void setPlainDwarfPlacementRec(const UnitEntryPairTy &Entry)
Mark whole DIE tree as placed in "PlainDwarf".
RootEntriesListTy RootEntriesWorkList
List of entries which are 'root DIE's.
SmallVector< SubtreeDependencyTy > SubtreeDependenciesTy
static bool isLiveSubprogramEntry(const UnitEntryPairTy &Entry)
Returns true if specified subprogram references live code section.
std::tuple< CompileUnit *, const DWARFDebugInfoEntry *, LiveRootWorklistActionTy > SubtreeDependenciesKeyTy
A subtree paired with the action it is walked with, which selects both the visited children and the a...
void recordSubtreeDependencies(LiveRootWorklistActionTy Action, const UnitEntryPairTy &RootEntry, const UnitEntryPairTy &Entry)
Record that RootEntry references the already-marked subtree Entry, and therefore carries the complete...
bool resolveDependenciesAndMarkLiveness(bool InterCUProcessingStarted, std::atomic< bool > &HasNewInterconnectedCUs)
Recursively walk the DIE tree and look for DIEs to keep.
static bool isLiveVariableEntry(const UnitEntryPairTy &Entry, bool IsLiveParent)
Returns true if specified variable references live code section.
@ MarkSingleTypeEntry
Mark current item as type entry.
@ MarkSingleLiveEntry
Mark current item as live entry.
@ MarkTypeEntryRec
Mark current item and all its children as type entry.
@ MarkLiveChildrenRec
Mark all children of current item as live entry.
@ MarkLiveEntryRec
Mark current item and all its children as live entry.
@ MarkTypeChildrenRec
Mark all children of current item as type entry.
SmallVector< SubtreeDependencyRefTy > SubtreeDependencyRefs
Roots referencing an already-marked subtree.
void collectLiveRoots()
This function is the entry point of the DIE selection algorithm.
void collectRootsToKeep(const UnitEntryPairTy &Entry, std::optional< UnitEntryPairTy > ReferencedBy, bool IsLiveParent)
This function navigates DIEs tree starting from specified Entry.
bool maybeAddReferencedRoots(LiveRootWorklistActionTy Action, const UnitEntryPairTy &RootEntry, const UnitEntryPairTy &Entry, bool InterCUProcessingStarted, std::atomic< bool > &HasNewInterconnectedCUs, TreeWalkKindTy Kind=TreeWalkKindTy::MarkTree)
Check referenced DIEs and add them into the worklist.
bool updateDependenciesCompleteness()
Check if dependencies have incompatible placement.
void materializeSubtreeSummaries()
Walk every subtree that a recorded reference stands for, once per subtree and action,...
DIEInfo & getDIEInfo(unsigned Idx)
Idx index of the DIE.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
ArrayRef< dwarf::Attribute > getODRAttributes()
std::optional< uint64_t > toAddress(const std::optional< DWARFFormValue > &V)
Take an optional DWARFFormValue and try to extract an address.
std::optional< uint64_t > toUnsigned(const std::optional< DWARFFormValue > &V)
Take an optional DWARFFormValue and try to extract an unsigned constant.
This is an optimization pass for GlobalISel generic memory operations.
LLVM_ABI raw_fd_ostream & outs()
This returns a reference to a raw_fd_ostream for standard output.
auto formatv(bool Validate, const char *Fmt, Ts &&...Vals)
auto reverse(ContainerTy &&C)
LLVM_ABI void report_fatal_error(Error Err, bool gen_crash_diag=true)
LLVM_ATTRIBUTE_VISIBILITY_DEFAULT AnalysisKey InnerAnalysisManagerProxy< AnalysisManagerT, IRUnitT, ExtraArgTs... >::Key
LLVM_ABI raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
@ Ref
The access may reference the value stored in memory.
LLVM_ABI unsigned getULEB128Size(uint64_t Value)
Utility function to get the size of the ULEB128-encoded value.
bool is_contained(R &&Range, const E &Element)
Returns true if Element is found in Range.
BrokenLink(DWARFDie Parent, DWARFDie Child, const char *Message)
A broken link in the keep chain.
Container for dump options that control which debug information will be dumped.
unsigned ChildRecurseDepth
A utility class that uses RAII to save and restore the value of a variable.
Information gathered about a DIE in the object file.
Information gathered about source DIEs.
void setPlacement(DieOutputPlacement Placement)
Sets Placement kind for the corresponding die.
bool needToKeepInPlainDwarf() const
bool needToPlaceInTypeTable() const
A root referencing an already-marked subtree, standing in for all of that subtree's dependencies.
A completeness dependency of a subtree that belongs to whichever root references the subtree,...
const DWARFDebugInfoEntry * ReferencedTypeDieEntry
This is a helper structure which keeps a debug info entry with it's containing compilation unit.
const DWARFDebugInfoEntry * DieEntry