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