LLVM 20.0.0git
DWARFLinkerDeclContext.cpp
Go to the documentation of this file.
1//===- DWARFLinkerDeclContext.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
14
15namespace llvm {
16
17using namespace dwarf_linker;
18using namespace dwarf_linker::classic;
19
20/// Set the last DIE/CU a context was seen in and, possibly invalidate the
21/// context if it is ambiguous.
22///
23/// In the current implementation, we don't handle overloaded functions well,
24/// because the argument types are not taken into account when computing the
25/// DeclContext tree.
26///
27/// Some of this is mitigated byt using mangled names that do contain the
28/// arguments types, but sometimes (e.g. with function templates) we don't have
29/// that. In that case, just do not unique anything that refers to the contexts
30/// we are not able to distinguish.
31///
32/// If a context that is not a namespace appears twice in the same CU, we know
33/// it is ambiguous. Make it invalid.
35 if (LastSeenCompileUnitID == U.getUniqueID()) {
36 DWARFUnit &OrigUnit = U.getOrigUnit();
37 uint32_t FirstIdx = OrigUnit.getDIEIndex(LastSeenDIE);
38 U.getInfo(FirstIdx).Ctxt = nullptr;
39 return false;
40 }
41
42 LastSeenCompileUnitID = U.getUniqueID();
43 LastSeenDIE = Die;
44 return true;
45}
46
49 CompileUnit &U, bool InClangModule) {
50 unsigned Tag = DIE.getTag();
51
52 // FIXME: dsymutil-classic compat: We should bail out here if we
53 // have a specification or an abstract_origin. We will get the
54 // parent context wrong here.
55
56 switch (Tag) {
57 default:
58 // By default stop gathering child contexts.
60 case dwarf::DW_TAG_module:
61 break;
62 case dwarf::DW_TAG_compile_unit:
63 return PointerIntPair<DeclContext *, 1>(&Context);
64 case dwarf::DW_TAG_subprogram:
65 // Do not unique anything inside CU local functions.
66 if ((Context.getTag() == dwarf::DW_TAG_namespace ||
67 Context.getTag() == dwarf::DW_TAG_compile_unit) &&
68 !dwarf::toUnsigned(DIE.find(dwarf::DW_AT_external), 0))
70 [[fallthrough]];
71 case dwarf::DW_TAG_member:
72 case dwarf::DW_TAG_namespace:
73 case dwarf::DW_TAG_structure_type:
74 case dwarf::DW_TAG_class_type:
75 case dwarf::DW_TAG_union_type:
76 case dwarf::DW_TAG_enumeration_type:
77 case dwarf::DW_TAG_typedef:
78 // Artificial things might be ambiguous, because they might be created on
79 // demand. For example implicitly defined constructors are ambiguous
80 // because of the way we identify contexts, and they won't be generated
81 // every time everywhere.
82 if (dwarf::toUnsigned(DIE.find(dwarf::DW_AT_artificial), 0))
84 break;
85 }
86
87 StringRef NameRef;
88 StringRef FileRef;
89
90 if (const char *LinkageName = DIE.getLinkageName())
91 NameRef = StringPool.internString(LinkageName);
92 else if (const char *ShortName = DIE.getShortName())
93 NameRef = StringPool.internString(ShortName);
94
95 bool IsAnonymousNamespace = NameRef.empty() && Tag == dwarf::DW_TAG_namespace;
96 if (IsAnonymousNamespace) {
97 // FIXME: For dsymutil-classic compatibility. I think uniquing within
98 // anonymous namespaces is wrong. There is no ODR guarantee there.
99 NameRef = "(anonymous namespace)";
100 }
101
102 if (Tag != dwarf::DW_TAG_class_type && Tag != dwarf::DW_TAG_structure_type &&
103 Tag != dwarf::DW_TAG_union_type &&
104 Tag != dwarf::DW_TAG_enumeration_type && NameRef.empty())
105 return PointerIntPair<DeclContext *, 1>(nullptr);
106
107 unsigned Line = 0;
108 unsigned ByteSize = std::numeric_limits<uint32_t>::max();
109
110 if (!InClangModule) {
111 // Gather some discriminating data about the DeclContext we will be
112 // creating: File, line number and byte size. This shouldn't be necessary,
113 // because the ODR is just about names, but given that we do some
114 // approximations with overloaded functions and anonymous namespaces, use
115 // these additional data points to make the process safer.
116 //
117 // This is disabled for clang modules, because forward declarations of
118 // module-defined types do not have a file and line.
119 ByteSize = dwarf::toUnsigned(DIE.find(dwarf::DW_AT_byte_size),
120 std::numeric_limits<uint64_t>::max());
121 if (Tag != dwarf::DW_TAG_namespace || IsAnonymousNamespace) {
122 if (unsigned FileNum =
123 dwarf::toUnsigned(DIE.find(dwarf::DW_AT_decl_file), 0)) {
124 if (const auto *LT = U.getOrigUnit().getContext().getLineTableForUnit(
125 &U.getOrigUnit())) {
126 // FIXME: dsymutil-classic compatibility. I'd rather not
127 // unique anything in anonymous namespaces, but if we do, then
128 // verify that the file and line correspond.
129 if (IsAnonymousNamespace)
130 FileNum = 1;
131
132 if (LT->hasFileAtIndex(FileNum)) {
133 Line = dwarf::toUnsigned(DIE.find(dwarf::DW_AT_decl_line), 0);
134 // Cache the resolved paths based on the index in the line table,
135 // because calling realpath is expensive.
136 FileRef = getResolvedPath(U, FileNum, *LT);
137 }
138 }
139 }
140 }
141 }
142
143 if (!Line && NameRef.empty())
144 return PointerIntPair<DeclContext *, 1>(nullptr);
145
146 // We hash NameRef, which is the mangled name, in order to get most
147 // overloaded functions resolve correctly.
148 //
149 // Strictly speaking, hashing the Tag is only necessary for a
150 // DW_TAG_module, to prevent uniquing of a module and a namespace
151 // with the same name.
152 //
153 // FIXME: dsymutil-classic won't unique the same type presented
154 // once as a struct and once as a class. Using the Tag in the fully
155 // qualified name hash to get the same effect.
156 unsigned Hash = hash_combine(Context.getQualifiedNameHash(), Tag, NameRef);
157
158 // FIXME: dsymutil-classic compatibility: when we don't have a name,
159 // use the filename.
160 if (IsAnonymousNamespace)
161 Hash = hash_combine(Hash, FileRef);
162
163 // Now look if this context already exists.
164 DeclContext Key(Hash, Line, ByteSize, Tag, NameRef, FileRef, Context);
165 auto ContextIter = Contexts.find(&Key);
166
167 if (ContextIter == Contexts.end()) {
168 // The context wasn't found.
169 bool Inserted;
170 DeclContext *NewContext =
171 new (Allocator) DeclContext(Hash, Line, ByteSize, Tag, NameRef, FileRef,
172 Context, DIE, U.getUniqueID());
173 std::tie(ContextIter, Inserted) = Contexts.insert(NewContext);
174 assert(Inserted && "Failed to insert DeclContext");
175 (void)Inserted;
176 } else if (Tag != dwarf::DW_TAG_namespace &&
177 !(*ContextIter)->setLastSeenDIE(U, DIE)) {
178 // The context was found, but it is ambiguous with another context
179 // in the same file. Mark it invalid.
180 return PointerIntPair<DeclContext *, 1>(*ContextIter, /* IntVal= */ 1);
181 }
182
183 assert(ContextIter != Contexts.end());
184 // FIXME: dsymutil-classic compatibility. Union types aren't
185 // uniques, but their children might be.
186 if ((Tag == dwarf::DW_TAG_subprogram &&
187 Context.getTag() != dwarf::DW_TAG_structure_type &&
188 Context.getTag() != dwarf::DW_TAG_class_type) ||
189 (Tag == dwarf::DW_TAG_union_type))
190 return PointerIntPair<DeclContext *, 1>(*ContextIter, /* IntVal= */ 1);
191
192 return PointerIntPair<DeclContext *, 1>(*ContextIter);
193}
194
196DeclContextTree::getResolvedPath(CompileUnit &CU, unsigned FileNum,
197 const DWARFDebugLine::LineTable &LineTable) {
198 std::pair<unsigned, unsigned> Key = {CU.getUniqueID(), FileNum};
199
200 ResolvedPathsMap::const_iterator It = ResolvedPaths.find(Key);
201 if (It == ResolvedPaths.end()) {
202 std::string FileName;
203 bool FoundFileName = LineTable.getFileNameByIndex(
204 FileNum, CU.getOrigUnit().getCompilationDir(),
205 DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath, FileName);
206 (void)FoundFileName;
207 assert(FoundFileName && "Must get file name from line table");
208
209 // Second level of caching, this time based on the file's parent
210 // path.
211 StringRef ResolvedPath = PathResolver.resolve(FileName, StringPool);
212
213 It = ResolvedPaths.insert(std::make_pair(Key, ResolvedPath)).first;
214 }
215
216 return It->second;
217}
218
219} // namespace llvm
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
A structured debug information entry.
Definition: DIE.h:819
dwarf::Tag getTag() const
Definition: DIE.h:855
Utility class that carries the DWARF compile/type unit and the debug info entry in an object.
Definition: DWARFDie.h:42
uint32_t getDIEIndex(const DWARFDebugInfoEntry *Die) const
Return the index of a Die entry inside the unit's DIE vector.
Definition: DWARFUnit.h:269
iterator find(const_arg_type_t< KeyT > Val)
Definition: DenseMap.h:155
iterator end()
Definition: DenseMap.h:84
DenseMapIterator< KeyT, ValueT, KeyInfoT, BucketT, true > const_iterator
Definition: DenseMap.h:73
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Definition: DenseMap.h:211
PointerIntPair - This class implements a pair of a pointer and small integer.
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
constexpr bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:134
std::pair< iterator, bool > insert(const ValueT &V)
Definition: DenseSet.h:206
iterator find(const_arg_type_t< ValueT > V)
Definition: DenseSet.h:179
StringRef resolve(const std::string &Path, NonRelocatableStringpool &StringPool)
Resolve a path by calling realpath and cache its result.
Stores all information relating to a compile unit, be it in its original instance in the object file ...
PointerIntPair< DeclContext *, 1 > getChildDeclContext(DeclContext &Context, const DWARFDie &DIE, CompileUnit &Unit, bool InClangModule)
Get the child of Context described by DIE in Unit.
A DeclContext is a named program scope that is used for ODR uniquing of types.
bool setLastSeenDIE(CompileUnit &U, const DWARFDie &Die)
Set the last DIE/CU a context was seen in and, possibly invalidate the context if it is ambiguous.
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.
Definition: AddressRanges.h:18
hash_code hash_combine(const Ts &...args)
Combine values into a single hash_code.
Definition: Hashing.h:593
bool getFileNameByIndex(uint64_t FileIndex, StringRef CompDir, DILineInfoSpecifier::FileLineInfoKind Kind, std::string &Result) const
Extracts filename by its index in filename table in prologue.