1 //
2 //  TypeSystem.cpp
3 //  lldb
4 //
5 //  Created by Ryan Brown on 3/29/15.
6 //
7 //
8 
9 #include "lldb/Symbol/TypeSystem.h"
10 
11 #include <set>
12 
13 #include "lldb/Core/PluginManager.h"
14 #include "lldb/Symbol/CompilerType.h"
15 
16 using namespace lldb_private;
17 
18 TypeSystem::TypeSystem(LLVMCastKind kind) :
19     m_kind (kind),
20     m_sym_file (nullptr)
21 {
22 }
23 
24 TypeSystem::~TypeSystem()
25 {
26 }
27 
28 lldb::TypeSystemSP
29 TypeSystem::CreateInstance (lldb::LanguageType language, Module *module)
30 {
31     uint32_t i = 0;
32     TypeSystemCreateInstance create_callback;
33     while ((create_callback = PluginManager::GetTypeSystemCreateCallbackAtIndex (i++)) != nullptr)
34     {
35         lldb::TypeSystemSP type_system_sp = create_callback(language, module, nullptr);
36         if (type_system_sp)
37             return type_system_sp;
38     }
39 
40     return lldb::TypeSystemSP();
41 }
42 
43 lldb::TypeSystemSP
44 TypeSystem::CreateInstance (lldb::LanguageType language, Target *target)
45 {
46     uint32_t i = 0;
47     TypeSystemCreateInstance create_callback;
48     while ((create_callback = PluginManager::GetTypeSystemCreateCallbackAtIndex (i++)) != nullptr)
49     {
50         lldb::TypeSystemSP type_system_sp = create_callback(language, nullptr, target);
51         if (type_system_sp)
52             return type_system_sp;
53     }
54 
55     return lldb::TypeSystemSP();
56 }
57 
58 bool
59 TypeSystem::IsAnonymousType (lldb::opaque_compiler_type_t type)
60 {
61     return false;
62 }
63 
64 CompilerType
65 TypeSystem::GetLValueReferenceType (lldb::opaque_compiler_type_t type)
66 {
67     return CompilerType();
68 }
69 
70 CompilerType
71 TypeSystem::GetRValueReferenceType (lldb::opaque_compiler_type_t type)
72 {
73     return CompilerType();
74 }
75 
76 CompilerType
77 TypeSystem::AddConstModifier (lldb::opaque_compiler_type_t type)
78 {
79     return CompilerType();
80 }
81 
82 CompilerType
83 TypeSystem::AddVolatileModifier (lldb::opaque_compiler_type_t type)
84 {
85     return CompilerType();
86 }
87 
88 CompilerType
89 TypeSystem::AddRestrictModifier (lldb::opaque_compiler_type_t type)
90 {
91     return CompilerType();
92 }
93 
94 CompilerType
95 TypeSystem::CreateTypedef (lldb::opaque_compiler_type_t type, const char *name, const CompilerDeclContext &decl_ctx)
96 {
97     return CompilerType();
98 }
99 
100 CompilerType
101 TypeSystem::GetBuiltinTypeByName (const ConstString &name)
102 {
103     return CompilerType();
104 }
105 
106 CompilerType
107 TypeSystem::GetTypeForFormatters (void* type)
108 {
109     return CompilerType(this, type);
110 }
111 
112 LazyBool
113 TypeSystem::ShouldPrintAsOneLiner (void* type, ValueObject* valobj)
114 {
115     return eLazyBoolCalculate;
116 }
117 
118 bool
119 TypeSystem::IsMeaninglessWithoutDynamicResolution (void* type)
120 {
121     return false;
122 }
123 
124 ConstString
125 TypeSystem::DeclGetMangledName (void *opaque_decl)
126 {
127     return ConstString();
128 }
129 
130 CompilerDeclContext
131 TypeSystem::DeclGetDeclContext (void *opaque_decl)
132 {
133     return CompilerDeclContext();
134 }
135 
136 CompilerType
137 TypeSystem::DeclGetFunctionReturnType(void *opaque_decl)
138 {
139     return CompilerType();
140 }
141 
142 size_t
143 TypeSystem::DeclGetFunctionNumArguments(void *opaque_decl)
144 {
145     return 0;
146 }
147 
148 CompilerType
149 TypeSystem::DeclGetFunctionArgumentType (void *opaque_decl, size_t arg_idx)
150 {
151     return CompilerType();
152 }
153 
154 
155 std::vector<CompilerDecl>
156 TypeSystem::DeclContextFindDeclByName (void *opaque_decl_ctx,
157                                        ConstString name,
158                                        bool ignore_imported_decls)
159 {
160     return std::vector<CompilerDecl>();
161 }
162 
163 
164 #pragma mark TypeSystemMap
165 
166 TypeSystemMap::TypeSystemMap() :
167     m_mutex (),
168     m_map (),
169     m_clear_in_progress(false)
170 {
171 }
172 
173 TypeSystemMap::~TypeSystemMap()
174 {
175 }
176 
177 void
178 TypeSystemMap::Clear ()
179 {
180     collection map;
181     {
182         Mutex::Locker locker (m_mutex);
183         map = m_map;
184         m_clear_in_progress = true;
185     }
186     std::set<TypeSystem *> visited;
187     for (auto pair : map)
188     {
189         TypeSystem *type_system = pair.second.get();
190         if (type_system && !visited.count(type_system))
191         {
192             visited.insert(type_system);
193             type_system->Finalize();
194         }
195     }
196     map.clear();
197     {
198         Mutex::Locker locker (m_mutex);
199         m_map.clear();
200         m_clear_in_progress = false;
201     }
202 }
203 
204 
205 void
206 TypeSystemMap::ForEach (std::function <bool(TypeSystem *)> const &callback)
207 {
208     Mutex::Locker locker (m_mutex);
209     // Use a std::set so we only call the callback once for each unique
210     // TypeSystem instance
211     std::set<TypeSystem *> visited;
212     for (auto pair : m_map)
213     {
214         TypeSystem *type_system = pair.second.get();
215         if (type_system && !visited.count(type_system))
216         {
217             visited.insert(type_system);
218             if (callback (type_system) == false)
219                 break;
220         }
221     }
222 }
223 
224 TypeSystem *
225 TypeSystemMap::GetTypeSystemForLanguage (lldb::LanguageType language, Module *module, bool can_create)
226 {
227     Mutex::Locker locker (m_mutex);
228     collection::iterator pos = m_map.find(language);
229     if (pos != m_map.end())
230         return pos->second.get();
231 
232     for (const auto &pair : m_map)
233     {
234         if (pair.second && pair.second->SupportsLanguage(language))
235         {
236             // Add a new mapping for "language" to point to an already existing
237             // TypeSystem that supports this language
238             AddToMap(language, pair.second);
239             return pair.second.get();
240         }
241     }
242 
243     if (!can_create)
244         return nullptr;
245 
246     // Cache even if we get a shared pointer that contains null type system back
247     lldb::TypeSystemSP type_system_sp = TypeSystem::CreateInstance (language, module);
248     AddToMap (language, type_system_sp);
249     return type_system_sp.get();
250 }
251 
252 TypeSystem *
253 TypeSystemMap::GetTypeSystemForLanguage (lldb::LanguageType language, Target *target, bool can_create)
254 {
255     Mutex::Locker locker (m_mutex);
256     collection::iterator pos = m_map.find(language);
257     if (pos != m_map.end())
258         return pos->second.get();
259 
260     for (const auto &pair : m_map)
261     {
262         if (pair.second && pair.second->SupportsLanguage(language))
263         {
264             // Add a new mapping for "language" to point to an already existing
265             // TypeSystem that supports this language
266 
267             AddToMap(language, pair.second);
268             return pair.second.get();
269         }
270     }
271 
272     if (!can_create)
273         return nullptr;
274 
275     // Cache even if we get a shared pointer that contains null type system back
276     lldb::TypeSystemSP type_system_sp;
277     if (!m_clear_in_progress)
278         type_system_sp = TypeSystem::CreateInstance (language, target);
279 
280     AddToMap(language, type_system_sp);
281     return type_system_sp.get();
282 }
283 
284 void
285 TypeSystemMap::AddToMap (lldb::LanguageType language, lldb::TypeSystemSP const &type_system_sp)
286 {
287     if (!m_clear_in_progress)
288         m_map[language] = type_system_sp;
289 }
290