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
9 #include "lldb/Symbol/TypeSystem.h"
10 #include "lldb/Core/PluginManager.h"
11 #include "lldb/Expression/UtilityFunction.h"
12 #include "lldb/Symbol/CompilerType.h"
13 #include "lldb/Target/Language.h"
14
15 #include <set>
16
17 using namespace lldb_private;
18 using namespace lldb;
19
20 /// A 64-bit SmallBitVector is only small up to 64-7 bits, and the
21 /// setBitsInMask interface wants to write full bytes.
22 static const size_t g_num_small_bitvector_bits = 64 - 8;
23 static_assert(eNumLanguageTypes < g_num_small_bitvector_bits,
24 "Languages bit vector is no longer small on 64 bit systems");
LanguageSet()25 LanguageSet::LanguageSet() : bitvector(eNumLanguageTypes, 0) {}
26
GetSingularLanguage()27 llvm::Optional<LanguageType> LanguageSet::GetSingularLanguage() {
28 if (bitvector.count() == 1)
29 return (LanguageType)bitvector.find_first();
30 return {};
31 }
32
Insert(LanguageType language)33 void LanguageSet::Insert(LanguageType language) { bitvector.set(language); }
Size() const34 size_t LanguageSet::Size() const { return bitvector.count(); }
Empty() const35 bool LanguageSet::Empty() const { return bitvector.none(); }
operator [](unsigned i) const36 bool LanguageSet::operator[](unsigned i) const { return bitvector[i]; }
37
38 TypeSystem::~TypeSystem() = default;
39
CreateInstanceHelper(lldb::LanguageType language,Module * module,Target * target)40 static lldb::TypeSystemSP CreateInstanceHelper(lldb::LanguageType language,
41 Module *module, Target *target) {
42 uint32_t i = 0;
43 TypeSystemCreateInstance create_callback;
44 while ((create_callback = PluginManager::GetTypeSystemCreateCallbackAtIndex(
45 i++)) != nullptr) {
46 lldb::TypeSystemSP type_system_sp =
47 create_callback(language, module, target);
48 if (type_system_sp)
49 return type_system_sp;
50 }
51
52 return lldb::TypeSystemSP();
53 }
54
CreateInstance(lldb::LanguageType language,Module * module)55 lldb::TypeSystemSP TypeSystem::CreateInstance(lldb::LanguageType language,
56 Module *module) {
57 return CreateInstanceHelper(language, module, nullptr);
58 }
59
CreateInstance(lldb::LanguageType language,Target * target)60 lldb::TypeSystemSP TypeSystem::CreateInstance(lldb::LanguageType language,
61 Target *target) {
62 return CreateInstanceHelper(language, nullptr, target);
63 }
64
65 #ifndef NDEBUG
Verify(lldb::opaque_compiler_type_t type)66 bool TypeSystem::Verify(lldb::opaque_compiler_type_t type) { return true; }
67 #endif
68
IsAnonymousType(lldb::opaque_compiler_type_t type)69 bool TypeSystem::IsAnonymousType(lldb::opaque_compiler_type_t type) {
70 return false;
71 }
72
GetArrayType(lldb::opaque_compiler_type_t type,uint64_t size)73 CompilerType TypeSystem::GetArrayType(lldb::opaque_compiler_type_t type,
74 uint64_t size) {
75 return CompilerType();
76 }
77
78 CompilerType
GetLValueReferenceType(lldb::opaque_compiler_type_t type)79 TypeSystem::GetLValueReferenceType(lldb::opaque_compiler_type_t type) {
80 return CompilerType();
81 }
82
83 CompilerType
GetRValueReferenceType(lldb::opaque_compiler_type_t type)84 TypeSystem::GetRValueReferenceType(lldb::opaque_compiler_type_t type) {
85 return CompilerType();
86 }
87
GetAtomicType(lldb::opaque_compiler_type_t type)88 CompilerType TypeSystem::GetAtomicType(lldb::opaque_compiler_type_t type) {
89 return CompilerType();
90 }
91
AddConstModifier(lldb::opaque_compiler_type_t type)92 CompilerType TypeSystem::AddConstModifier(lldb::opaque_compiler_type_t type) {
93 return CompilerType();
94 }
95
96 CompilerType
AddVolatileModifier(lldb::opaque_compiler_type_t type)97 TypeSystem::AddVolatileModifier(lldb::opaque_compiler_type_t type) {
98 return CompilerType();
99 }
100
101 CompilerType
AddRestrictModifier(lldb::opaque_compiler_type_t type)102 TypeSystem::AddRestrictModifier(lldb::opaque_compiler_type_t type) {
103 return CompilerType();
104 }
105
CreateTypedef(lldb::opaque_compiler_type_t type,const char * name,const CompilerDeclContext & decl_ctx,uint32_t opaque_payload)106 CompilerType TypeSystem::CreateTypedef(lldb::opaque_compiler_type_t type,
107 const char *name,
108 const CompilerDeclContext &decl_ctx,
109 uint32_t opaque_payload) {
110 return CompilerType();
111 }
112
GetBuiltinTypeByName(ConstString name)113 CompilerType TypeSystem::GetBuiltinTypeByName(ConstString name) {
114 return CompilerType();
115 }
116
GetTypeForFormatters(void * type)117 CompilerType TypeSystem::GetTypeForFormatters(void *type) {
118 return CompilerType(this, type);
119 }
120
GetNumTemplateArguments(lldb::opaque_compiler_type_t type)121 size_t TypeSystem::GetNumTemplateArguments(lldb::opaque_compiler_type_t type) {
122 return 0;
123 }
124
125 TemplateArgumentKind
GetTemplateArgumentKind(opaque_compiler_type_t type,size_t idx)126 TypeSystem::GetTemplateArgumentKind(opaque_compiler_type_t type, size_t idx) {
127 return eTemplateArgumentKindNull;
128 }
129
GetTypeTemplateArgument(opaque_compiler_type_t type,size_t idx)130 CompilerType TypeSystem::GetTypeTemplateArgument(opaque_compiler_type_t type,
131 size_t idx) {
132 return CompilerType();
133 }
134
135 llvm::Optional<CompilerType::IntegralTemplateArgument>
GetIntegralTemplateArgument(opaque_compiler_type_t type,size_t idx)136 TypeSystem::GetIntegralTemplateArgument(opaque_compiler_type_t type,
137 size_t idx) {
138 return llvm::None;
139 }
140
ShouldPrintAsOneLiner(void * type,ValueObject * valobj)141 LazyBool TypeSystem::ShouldPrintAsOneLiner(void *type, ValueObject *valobj) {
142 return eLazyBoolCalculate;
143 }
144
IsMeaninglessWithoutDynamicResolution(void * type)145 bool TypeSystem::IsMeaninglessWithoutDynamicResolution(void *type) {
146 return false;
147 }
148
DeclGetMangledName(void * opaque_decl)149 ConstString TypeSystem::DeclGetMangledName(void *opaque_decl) {
150 return ConstString();
151 }
152
DeclGetDeclContext(void * opaque_decl)153 CompilerDeclContext TypeSystem::DeclGetDeclContext(void *opaque_decl) {
154 return CompilerDeclContext();
155 }
156
DeclGetFunctionReturnType(void * opaque_decl)157 CompilerType TypeSystem::DeclGetFunctionReturnType(void *opaque_decl) {
158 return CompilerType();
159 }
160
DeclGetFunctionNumArguments(void * opaque_decl)161 size_t TypeSystem::DeclGetFunctionNumArguments(void *opaque_decl) { return 0; }
162
DeclGetFunctionArgumentType(void * opaque_decl,size_t arg_idx)163 CompilerType TypeSystem::DeclGetFunctionArgumentType(void *opaque_decl,
164 size_t arg_idx) {
165 return CompilerType();
166 }
167
168 std::vector<CompilerDecl>
DeclContextFindDeclByName(void * opaque_decl_ctx,ConstString name,bool ignore_imported_decls)169 TypeSystem::DeclContextFindDeclByName(void *opaque_decl_ctx, ConstString name,
170 bool ignore_imported_decls) {
171 return std::vector<CompilerDecl>();
172 }
173
174 std::unique_ptr<UtilityFunction>
CreateUtilityFunction(std::string text,std::string name)175 TypeSystem::CreateUtilityFunction(std::string text, std::string name) {
176 return {};
177 }
178
179 #pragma mark TypeSystemMap
180
TypeSystemMap()181 TypeSystemMap::TypeSystemMap() : m_mutex(), m_map() {}
182
183 TypeSystemMap::~TypeSystemMap() = default;
184
Clear()185 void TypeSystemMap::Clear() {
186 collection map;
187 {
188 std::lock_guard<std::mutex> guard(m_mutex);
189 map = m_map;
190 m_clear_in_progress = true;
191 }
192 std::set<TypeSystem *> visited;
193 for (auto pair : map) {
194 TypeSystem *type_system = pair.second.get();
195 if (type_system && !visited.count(type_system)) {
196 visited.insert(type_system);
197 type_system->Finalize();
198 }
199 }
200 map.clear();
201 {
202 std::lock_guard<std::mutex> guard(m_mutex);
203 m_map.clear();
204 m_clear_in_progress = false;
205 }
206 }
207
ForEach(std::function<bool (TypeSystem *)> const & callback)208 void TypeSystemMap::ForEach(std::function<bool(TypeSystem *)> const &callback) {
209 std::lock_guard<std::mutex> guard(m_mutex);
210 // Use a std::set so we only call the callback once for each unique
211 // TypeSystem instance
212 std::set<TypeSystem *> visited;
213 for (auto pair : m_map) {
214 TypeSystem *type_system = pair.second.get();
215 if (type_system && !visited.count(type_system)) {
216 visited.insert(type_system);
217 if (!callback(type_system))
218 break;
219 }
220 }
221 }
222
GetTypeSystemForLanguage(lldb::LanguageType language,llvm::Optional<CreateCallback> create_callback)223 llvm::Expected<TypeSystem &> TypeSystemMap::GetTypeSystemForLanguage(
224 lldb::LanguageType language,
225 llvm::Optional<CreateCallback> create_callback) {
226 std::lock_guard<std::mutex> guard(m_mutex);
227 if (m_clear_in_progress)
228 return llvm::make_error<llvm::StringError>(
229 "Unable to get TypeSystem because TypeSystemMap is being cleared",
230 llvm::inconvertibleErrorCode());
231
232 collection::iterator pos = m_map.find(language);
233 if (pos != m_map.end()) {
234 auto *type_system = pos->second.get();
235 if (type_system)
236 return *type_system;
237 return llvm::make_error<llvm::StringError>(
238 "TypeSystem for language " +
239 llvm::StringRef(Language::GetNameForLanguageType(language)) +
240 " doesn't exist",
241 llvm::inconvertibleErrorCode());
242 }
243
244 for (const auto &pair : m_map) {
245 if (pair.second && pair.second->SupportsLanguage(language)) {
246 // Add a new mapping for "language" to point to an already existing
247 // TypeSystem that supports this language
248 m_map[language] = pair.second;
249 if (pair.second.get())
250 return *pair.second.get();
251 return llvm::make_error<llvm::StringError>(
252 "TypeSystem for language " +
253 llvm::StringRef(Language::GetNameForLanguageType(language)) +
254 " doesn't exist",
255 llvm::inconvertibleErrorCode());
256 }
257 }
258
259 if (!create_callback)
260 return llvm::make_error<llvm::StringError>(
261 "Unable to find type system for language " +
262 llvm::StringRef(Language::GetNameForLanguageType(language)),
263 llvm::inconvertibleErrorCode());
264
265 // Cache even if we get a shared pointer that contains a null type system
266 // back
267 TypeSystemSP type_system_sp = (*create_callback)();
268 m_map[language] = type_system_sp;
269 if (type_system_sp.get())
270 return *type_system_sp.get();
271 return llvm::make_error<llvm::StringError>(
272 "TypeSystem for language " +
273 llvm::StringRef(Language::GetNameForLanguageType(language)) +
274 " doesn't exist",
275 llvm::inconvertibleErrorCode());
276 }
277
278 llvm::Expected<TypeSystem &>
GetTypeSystemForLanguage(lldb::LanguageType language,Module * module,bool can_create)279 TypeSystemMap::GetTypeSystemForLanguage(lldb::LanguageType language,
280 Module *module, bool can_create) {
281 if (can_create) {
282 return GetTypeSystemForLanguage(
283 language, llvm::Optional<CreateCallback>([language, module]() {
284 return TypeSystem::CreateInstance(language, module);
285 }));
286 }
287 return GetTypeSystemForLanguage(language);
288 }
289
290 llvm::Expected<TypeSystem &>
GetTypeSystemForLanguage(lldb::LanguageType language,Target * target,bool can_create)291 TypeSystemMap::GetTypeSystemForLanguage(lldb::LanguageType language,
292 Target *target, bool can_create) {
293 if (can_create) {
294 return GetTypeSystemForLanguage(
295 language, llvm::Optional<CreateCallback>([language, target]() {
296 return TypeSystem::CreateInstance(language, target);
297 }));
298 }
299 return GetTypeSystemForLanguage(language);
300 }
301