lldb/source/Symbol/TypeSystem.cpp

   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, false) {}
  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() = default;
  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() : m_mutex(), m_map() {}
 182
 183 TypeSystemMap::~TypeSystemMap() = default;
 184
 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
 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
 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 &>
 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 &>
 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 }