LLDB mainline
TypeSystem.cpp
Go to the documentation of this file.
1//===-- TypeSystem.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
15#include "llvm/ADT/DenseSet.h"
16#include <optional>
17
18using namespace lldb_private;
19using namespace lldb;
20
21/// A 64-bit SmallBitVector is only small up to 64-7 bits, and the
22/// setBitsInMask interface wants to write full bytes.
23static const size_t g_num_small_bitvector_bits = 64 - 8;
25 "Languages bit vector is no longer small on 64 bit systems");
27
28std::optional<LanguageType> LanguageSet::GetSingularLanguage() {
29 if (bitvector.count() == 1)
30 return (LanguageType)bitvector.find_first();
31 return {};
32}
33
34void LanguageSet::Insert(LanguageType language) { bitvector.set(language); }
35size_t LanguageSet::Size() const { return bitvector.count(); }
36bool LanguageSet::Empty() const { return bitvector.none(); }
37bool LanguageSet::operator[](unsigned i) const { return bitvector[i]; }
38
39TypeSystem::TypeSystem() = default;
40TypeSystem::~TypeSystem() = default;
41
43 Module *module, Target *target) {
44 uint32_t i = 0;
45 TypeSystemCreateInstance create_callback;
47 i++)) != nullptr) {
48 if (auto type_system_sp = create_callback(language, module, target))
49 return type_system_sp;
50 }
51
52 return {};
53}
54
56 Module *module) {
57 return CreateInstanceHelper(language, module, nullptr);
58}
59
61 Target *target) {
62 return CreateInstanceHelper(language, nullptr, target);
63}
64
65#ifndef NDEBUG
67#endif
68
70 return false;
71}
72
74 uint64_t size) {
75 return CompilerType();
76}
77
80 return CompilerType();
81}
82
85 return CompilerType();
86}
87
89 return CompilerType();
90}
91
93 return CompilerType();
94}
95
97 uint32_t payload) {
98 return CompilerType();
99}
100
103 return CompilerType();
104}
105
108 return CompilerType();
109}
110
112 const char *name,
113 const CompilerDeclContext &decl_ctx,
114 uint32_t opaque_payload) {
115 return CompilerType();
116}
117
119 return CompilerType();
120}
121
123 return CompilerType(weak_from_this(), type);
124}
125
127 return false;
128}
129
131 bool expand_pack) {
132 return 0;
133}
134
137 bool expand_pack) {
139}
140
142 size_t idx, bool expand_pack) {
143 return CompilerType();
144}
145
146std::optional<CompilerType::IntegralTemplateArgument>
148 bool expand_pack) {
149 return std::nullopt;
150}
151
153 return eLazyBoolCalculate;
154}
155
157 return false;
158}
159
161 return ConstString();
162}
163
165 return CompilerDeclContext();
166}
167
169 return CompilerType();
170}
171
172size_t TypeSystem::DeclGetFunctionNumArguments(void *opaque_decl) { return 0; }
173
175 size_t arg_idx) {
176 return CompilerType();
177}
178
179std::vector<lldb_private::CompilerContext>
181 return {};
182}
183
184std::vector<lldb_private::CompilerContext>
186 return {};
187}
188
189std::vector<CompilerDecl>
191 bool ignore_imported_decls) {
192 return std::vector<CompilerDecl>();
193}
194
195std::unique_ptr<UtilityFunction>
196TypeSystem::CreateUtilityFunction(std::string text, std::string name) {
197 return {};
198}
199
200std::optional<llvm::json::Value> TypeSystem::ReportStatistics() {
201 return std::nullopt;
202}
203
206 return CompilerDeclContext();
207}
208
209#pragma mark TypeSystemMap
210
211TypeSystemMap::TypeSystemMap() : m_mutex(), m_map() {}
212
214
216 collection map;
217 {
218 std::lock_guard<std::mutex> guard(m_mutex);
219 map = m_map;
220 m_clear_in_progress = true;
221 }
222 llvm::DenseSet<TypeSystem *> visited;
223 for (auto &pair : map) {
224 if (visited.count(pair.second.get()))
225 continue;
226 visited.insert(pair.second.get());
227 if (lldb::TypeSystemSP type_system = pair.second)
228 type_system->Finalize();
229 }
230 map.clear();
231 {
232 std::lock_guard<std::mutex> guard(m_mutex);
233 m_map.clear();
234 m_clear_in_progress = false;
235 }
236}
237
239 std::function<bool(lldb::TypeSystemSP)> const &callback) {
240
241 // The callback may call into this function again causing
242 // us to lock m_mutex twice if we held it across the callback.
243 // Since we just care about guarding access to 'm_map', make
244 // a local copy and iterate over that instead.
245 collection map_snapshot;
246 {
247 std::lock_guard<std::mutex> guard(m_mutex);
248 map_snapshot = m_map;
249 }
250
251 // Use a std::set so we only call the callback once for each unique
252 // TypeSystem instance.
253 llvm::DenseSet<TypeSystem *> visited;
254 for (auto &pair : map_snapshot) {
255 TypeSystem *type_system = pair.second.get();
256 if (!type_system || visited.count(type_system))
257 continue;
258 visited.insert(type_system);
259 assert(type_system);
260 if (!callback(pair.second))
261 break;
262 }
263}
264
265llvm::Expected<lldb::TypeSystemSP> TypeSystemMap::GetTypeSystemForLanguage(
266 lldb::LanguageType language,
267 std::optional<CreateCallback> create_callback) {
268 std::lock_guard<std::mutex> guard(m_mutex);
270 return llvm::createStringError(
271 "Unable to get TypeSystem because TypeSystemMap is being cleared");
272
273 collection::iterator pos = m_map.find(language);
274 if (pos != m_map.end()) {
275 if (pos->second) {
276 assert(!pos->second->weak_from_this().expired());
277 return pos->second;
278 }
279 return llvm::createStringError(
280 "TypeSystem for language " +
281 llvm::StringRef(Language::GetNameForLanguageType(language)) +
282 " doesn't exist");
283 }
284
285 for (const auto &pair : m_map) {
286 if (pair.second && pair.second->SupportsLanguage(language)) {
287 // Add a new mapping for "language" to point to an already existing
288 // TypeSystem that supports this language
289 m_map[language] = pair.second;
290 if (pair.second)
291 return pair.second;
292 return llvm::createStringError(
293 "TypeSystem for language " +
294 llvm::StringRef(Language::GetNameForLanguageType(language)) +
295 " doesn't exist");
296 }
297 }
298
299 if (!create_callback)
300 return llvm::createStringError(
301 "Unable to find type system for language " +
302 llvm::StringRef(Language::GetNameForLanguageType(language)));
303 // Cache even if we get a shared pointer that contains a null type system
304 // back.
305 TypeSystemSP type_system_sp = (*create_callback)();
306 m_map[language] = type_system_sp;
307 if (type_system_sp)
308 return type_system_sp;
309 return llvm::createStringError(
310 "TypeSystem for language " +
311 llvm::StringRef(Language::GetNameForLanguageType(language)) +
312 " doesn't exist");
313}
314
315llvm::Expected<lldb::TypeSystemSP>
317 Module *module, bool can_create) {
318 if (can_create) {
320 language, std::optional<CreateCallback>([language, module]() {
321 return TypeSystem::CreateInstance(language, module);
322 }));
323 }
324 return GetTypeSystemForLanguage(language);
325}
326
327llvm::Expected<lldb::TypeSystemSP>
329 Target *target, bool can_create) {
330 if (can_create) {
332 language, std::optional<CreateCallback>([language, target]() {
333 return TypeSystem::CreateInstance(language, target);
334 }));
335 }
336 return GetTypeSystemForLanguage(language);
337}
static const size_t g_num_small_bitvector_bits
A 64-bit SmallBitVector is only small up to 64-7 bits, and the setBitsInMask interface wants to write...
Definition: TypeSystem.cpp:23
static TypeSystemSP CreateInstanceHelper(lldb::LanguageType language, Module *module, Target *target)
Definition: TypeSystem.cpp:42
Represents a generic declaration context in a program.
Generic representation of a type in a programming language.
Definition: CompilerType.h:36
A uniqued constant string class.
Definition: ConstString.h:40
static const char * GetNameForLanguageType(lldb::LanguageType language)
Definition: Language.cpp:266
A class that describes an executable image and its associated object and symbol files.
Definition: Module.h:88
static TypeSystemCreateInstance GetTypeSystemCreateCallbackAtIndex(uint32_t idx)
llvm::DenseMap< uint16_t, lldb::TypeSystemSP > collection
Definition: TypeSystem.h:572
std::mutex m_mutex
A mutex to keep this object happy in multi-threaded environments.
Definition: TypeSystem.h:573
llvm::Expected< lldb::TypeSystemSP > GetTypeSystemForLanguage(lldb::LanguageType language, Module *module, bool can_create)
Definition: TypeSystem.cpp:316
void ForEach(std::function< bool(lldb::TypeSystemSP)> const &callback)
Definition: TypeSystem.cpp:238
Interface for representing a type system.
Definition: TypeSystem.h:70
virtual std::unique_ptr< UtilityFunction > CreateUtilityFunction(std::string text, std::string name)
Definition: TypeSystem.cpp:196
virtual bool IsMeaninglessWithoutDynamicResolution(void *type)
Definition: TypeSystem.cpp:156
virtual size_t GetNumTemplateArguments(lldb::opaque_compiler_type_t type, bool expand_pack)
Definition: TypeSystem.cpp:130
virtual CompilerType GetBuiltinTypeByName(ConstString name)
Definition: TypeSystem.cpp:118
virtual CompilerType GetTypeTemplateArgument(lldb::opaque_compiler_type_t type, size_t idx, bool expand_pack)
Definition: TypeSystem.cpp:141
virtual CompilerType GetTypeForFormatters(void *type)
Definition: TypeSystem.cpp:122
virtual CompilerType AddRestrictModifier(lldb::opaque_compiler_type_t type)
Definition: TypeSystem.cpp:107
virtual CompilerType GetAtomicType(lldb::opaque_compiler_type_t type)
Definition: TypeSystem.cpp:88
virtual CompilerType GetLValueReferenceType(lldb::opaque_compiler_type_t type)
Definition: TypeSystem.cpp:79
virtual std::vector< CompilerDecl > DeclContextFindDeclByName(void *opaque_decl_ctx, ConstString name, const bool ignore_imported_decls)
Definition: TypeSystem.cpp:190
virtual std::optional< llvm::json::Value > ReportStatistics()
Definition: TypeSystem.cpp:200
virtual CompilerType CreateTypedef(lldb::opaque_compiler_type_t type, const char *name, const CompilerDeclContext &decl_ctx, uint32_t opaque_payload)
Definition: TypeSystem.cpp:111
virtual LazyBool ShouldPrintAsOneLiner(void *type, ValueObject *valobj)
Definition: TypeSystem.cpp:152
virtual CompilerType AddConstModifier(lldb::opaque_compiler_type_t type)
Definition: TypeSystem.cpp:92
virtual CompilerType AddPtrAuthModifier(lldb::opaque_compiler_type_t type, uint32_t payload)
Definition: TypeSystem.cpp:96
virtual CompilerType DeclGetFunctionReturnType(void *opaque_decl)
Definition: TypeSystem.cpp:168
virtual CompilerType DeclGetFunctionArgumentType(void *opaque_decl, size_t arg_idx)
Definition: TypeSystem.cpp:174
virtual CompilerType GetRValueReferenceType(lldb::opaque_compiler_type_t type)
Definition: TypeSystem.cpp:84
virtual std::vector< lldb_private::CompilerContext > DeclGetCompilerContext(void *opaque_decl)
Definition: TypeSystem.cpp:180
virtual std::vector< lldb_private::CompilerContext > DeclContextGetCompilerContext(void *opaque_decl_ctx)
Definition: TypeSystem.cpp:185
virtual bool IsAnonymousType(lldb::opaque_compiler_type_t type)
Definition: TypeSystem.cpp:69
virtual ConstString DeclGetMangledName(void *opaque_decl)
Definition: TypeSystem.cpp:160
virtual CompilerType GetArrayType(lldb::opaque_compiler_type_t type, uint64_t size)
Definition: TypeSystem.cpp:73
virtual CompilerDeclContext GetCompilerDeclContextForType(const CompilerType &type)
Returns the direct parent context of specified type.
Definition: TypeSystem.cpp:205
virtual std::optional< CompilerType::IntegralTemplateArgument > GetIntegralTemplateArgument(lldb::opaque_compiler_type_t type, size_t idx, bool expand_pack)
Definition: TypeSystem.cpp:147
virtual bool Verify(lldb::opaque_compiler_type_t type)=0
Verify the integrity of the type to catch CompilerTypes that mix and match invalid TypeSystem/Opaque ...
Definition: TypeSystem.cpp:66
virtual lldb::TemplateArgumentKind GetTemplateArgumentKind(lldb::opaque_compiler_type_t type, size_t idx, bool expand_pack)
Definition: TypeSystem.cpp:136
static lldb::TypeSystemSP CreateInstance(lldb::LanguageType language, Module *module)
Definition: TypeSystem.cpp:55
virtual bool IsTemplateType(lldb::opaque_compiler_type_t type)
Definition: TypeSystem.cpp:126
virtual size_t DeclGetFunctionNumArguments(void *opaque_decl)
Definition: TypeSystem.cpp:172
virtual CompilerDeclContext DeclGetDeclContext(void *opaque_decl)
Definition: TypeSystem.cpp:164
virtual CompilerType AddVolatileModifier(lldb::opaque_compiler_type_t type)
Definition: TypeSystem.cpp:102
A class that represents a running process on the host machine.
Definition: SBAddress.h:15
std::shared_ptr< lldb_private::TypeSystem > TypeSystemSP
Definition: lldb-forward.h:460
void * opaque_compiler_type_t
Definition: lldb-types.h:89
LanguageType
Programming language type.
@ eNumLanguageTypes
@ eTemplateArgumentKindNull
llvm::SmallBitVector bitvector
Definition: Type.h:39
std::optional< lldb::LanguageType > GetSingularLanguage()
If the set contains a single language only, return it.
Definition: TypeSystem.cpp:28
bool operator[](unsigned i) const
Definition: TypeSystem.cpp:37
void Insert(lldb::LanguageType language)
Definition: TypeSystem.cpp:34