1 //===-- TypeSystem.cpp ------------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
14 // Created by Ryan Brown on 3/29/15.
18 #include "lldb/Symbol/TypeSystem.h"
22 #include "lldb/Core/PluginManager.h"
23 #include "lldb/Symbol/CompilerType.h"
25 using namespace lldb_private;
27 TypeSystem::TypeSystem(LLVMCastKind kind) : m_kind(kind), m_sym_file(nullptr) {}
29 TypeSystem::~TypeSystem() {}
31 lldb::TypeSystemSP TypeSystem::CreateInstance(lldb::LanguageType language,
34 TypeSystemCreateInstance create_callback;
35 while ((create_callback = PluginManager::GetTypeSystemCreateCallbackAtIndex(
37 lldb::TypeSystemSP type_system_sp =
38 create_callback(language, module, nullptr);
40 return type_system_sp;
43 return lldb::TypeSystemSP();
46 lldb::TypeSystemSP TypeSystem::CreateInstance(lldb::LanguageType language,
49 TypeSystemCreateInstance create_callback;
50 while ((create_callback = PluginManager::GetTypeSystemCreateCallbackAtIndex(
52 lldb::TypeSystemSP type_system_sp =
53 create_callback(language, nullptr, target);
55 return type_system_sp;
58 return lldb::TypeSystemSP();
61 bool TypeSystem::IsAnonymousType(lldb::opaque_compiler_type_t type) {
65 CompilerType TypeSystem::GetArrayType(lldb::opaque_compiler_type_t type,
67 return CompilerType();
71 TypeSystem::GetLValueReferenceType(lldb::opaque_compiler_type_t type) {
72 return CompilerType();
76 TypeSystem::GetRValueReferenceType(lldb::opaque_compiler_type_t type) {
77 return CompilerType();
80 CompilerType TypeSystem::AddConstModifier(lldb::opaque_compiler_type_t type) {
81 return CompilerType();
85 TypeSystem::AddVolatileModifier(lldb::opaque_compiler_type_t type) {
86 return CompilerType();
90 TypeSystem::AddRestrictModifier(lldb::opaque_compiler_type_t type) {
91 return CompilerType();
94 CompilerType TypeSystem::CreateTypedef(lldb::opaque_compiler_type_t type,
96 const CompilerDeclContext &decl_ctx) {
97 return CompilerType();
100 CompilerType TypeSystem::GetBuiltinTypeByName(const ConstString &name) {
101 return CompilerType();
104 CompilerType TypeSystem::GetTypeForFormatters(void *type) {
105 return CompilerType(this, type);
108 LazyBool TypeSystem::ShouldPrintAsOneLiner(void *type, ValueObject *valobj) {
109 return eLazyBoolCalculate;
112 bool TypeSystem::IsMeaninglessWithoutDynamicResolution(void *type) {
116 ConstString TypeSystem::DeclGetMangledName(void *opaque_decl) {
117 return ConstString();
120 CompilerDeclContext TypeSystem::DeclGetDeclContext(void *opaque_decl) {
121 return CompilerDeclContext();
124 CompilerType TypeSystem::DeclGetFunctionReturnType(void *opaque_decl) {
125 return CompilerType();
128 size_t TypeSystem::DeclGetFunctionNumArguments(void *opaque_decl) { return 0; }
130 CompilerType TypeSystem::DeclGetFunctionArgumentType(void *opaque_decl,
132 return CompilerType();
135 std::vector<CompilerDecl>
136 TypeSystem::DeclContextFindDeclByName(void *opaque_decl_ctx, ConstString name,
137 bool ignore_imported_decls) {
138 return std::vector<CompilerDecl>();
141 #pragma mark TypeSystemMap
143 TypeSystemMap::TypeSystemMap()
144 : m_mutex(), m_map(), m_clear_in_progress(false) {}
146 TypeSystemMap::~TypeSystemMap() {}
148 void TypeSystemMap::Clear() {
151 std::lock_guard<std::mutex> guard(m_mutex);
153 m_clear_in_progress = true;
155 std::set<TypeSystem *> visited;
156 for (auto pair : map) {
157 TypeSystem *type_system = pair.second.get();
158 if (type_system && !visited.count(type_system)) {
159 visited.insert(type_system);
160 type_system->Finalize();
165 std::lock_guard<std::mutex> guard(m_mutex);
167 m_clear_in_progress = false;
171 void TypeSystemMap::ForEach(std::function<bool(TypeSystem *)> const &callback) {
172 std::lock_guard<std::mutex> guard(m_mutex);
173 // Use a std::set so we only call the callback once for each unique
174 // TypeSystem instance
175 std::set<TypeSystem *> visited;
176 for (auto pair : m_map) {
177 TypeSystem *type_system = pair.second.get();
178 if (type_system && !visited.count(type_system)) {
179 visited.insert(type_system);
180 if (callback(type_system) == false)
186 TypeSystem *TypeSystemMap::GetTypeSystemForLanguage(lldb::LanguageType language,
189 std::lock_guard<std::mutex> guard(m_mutex);
190 collection::iterator pos = m_map.find(language);
191 if (pos != m_map.end())
192 return pos->second.get();
194 for (const auto &pair : m_map) {
195 if (pair.second && pair.second->SupportsLanguage(language)) {
196 // Add a new mapping for "language" to point to an already existing
197 // TypeSystem that supports this language
198 AddToMap(language, pair.second);
199 return pair.second.get();
206 // Cache even if we get a shared pointer that contains null type system back
207 lldb::TypeSystemSP type_system_sp =
208 TypeSystem::CreateInstance(language, module);
209 AddToMap(language, type_system_sp);
210 return type_system_sp.get();
213 TypeSystem *TypeSystemMap::GetTypeSystemForLanguage(lldb::LanguageType language,
216 std::lock_guard<std::mutex> guard(m_mutex);
217 collection::iterator pos = m_map.find(language);
218 if (pos != m_map.end())
219 return pos->second.get();
221 for (const auto &pair : m_map) {
222 if (pair.second && pair.second->SupportsLanguage(language)) {
223 // Add a new mapping for "language" to point to an already existing
224 // TypeSystem that supports this language
226 AddToMap(language, pair.second);
227 return pair.second.get();
234 // Cache even if we get a shared pointer that contains null type system back
235 lldb::TypeSystemSP type_system_sp;
236 if (!m_clear_in_progress)
237 type_system_sp = TypeSystem::CreateInstance(language, target);
239 AddToMap(language, type_system_sp);
240 return type_system_sp.get();
243 void TypeSystemMap::AddToMap(lldb::LanguageType language,
244 lldb::TypeSystemSP const &type_system_sp) {
245 if (!m_clear_in_progress)
246 m_map[language] = type_system_sp;