contrib/llvm/tools/lldb/source/Symbol/TypeSystem.cpp

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