contrib/llvm/tools/lldb/source/Target/Language.cpp

   1 //===-- Language.cpp -------------------------------------------------*- C++
   2 //-*-===//
   3 //
   4 //                     The LLVM Compiler Infrastructure
   5 //
   6 // This file is distributed under the University of Illinois Open Source
   7 // License. See LICENSE.TXT for details.
   8 //
   9 //===----------------------------------------------------------------------===//
  10
  11 #include <functional>
  12 #include <map>
  13 #include <mutex>
  14
  15 #include "lldb/Target/Language.h"
  16
  17 #include "lldb/Core/PluginManager.h"
  18 #include "lldb/Symbol/SymbolFile.h"
  19 #include "lldb/Symbol/TypeList.h"
  20 #include "lldb/Target/Target.h"
  21 #include "lldb/Utility/Stream.h"
  22
  23 #include "llvm/Support/Threading.h"
  24
  25 using namespace lldb;
  26 using namespace lldb_private;
  27 using namespace lldb_private::formatters;
  28
  29 typedef std::unique_ptr<Language> LanguageUP;
  30 typedef std::map<lldb::LanguageType, LanguageUP> LanguagesMap;
  31
  32 static LanguagesMap &GetLanguagesMap() {
  33   static LanguagesMap *g_map = nullptr;
  34   static llvm::once_flag g_initialize;
  35
  36   llvm::call_once(g_initialize, [] {
  37     g_map = new LanguagesMap(); // NOTE: INTENTIONAL LEAK due to global
  38                                 // destructor chain
  39   });
  40
  41   return *g_map;
  42 }
  43 static std::mutex &GetLanguagesMutex() {
  44   static std::mutex *g_mutex = nullptr;
  45   static llvm::once_flag g_initialize;
  46
  47   llvm::call_once(g_initialize, [] {
  48     g_mutex = new std::mutex(); // NOTE: INTENTIONAL LEAK due to global
  49                                 // destructor chain
  50   });
  51
  52   return *g_mutex;
  53 }
  54
  55 Language *Language::FindPlugin(lldb::LanguageType language) {
  56   std::lock_guard<std::mutex> guard(GetLanguagesMutex());
  57   LanguagesMap &map(GetLanguagesMap());
  58   auto iter = map.find(language), end = map.end();
  59   if (iter != end)
  60     return iter->second.get();
  61
  62   Language *language_ptr = nullptr;
  63   LanguageCreateInstance create_callback;
  64
  65   for (uint32_t idx = 0;
  66        (create_callback =
  67             PluginManager::GetLanguageCreateCallbackAtIndex(idx)) != nullptr;
  68        ++idx) {
  69     language_ptr = create_callback(language);
  70
  71     if (language_ptr) {
  72       map[language] = std::unique_ptr<Language>(language_ptr);
  73       return language_ptr;
  74     }
  75   }
  76
  77   return nullptr;
  78 }
  79
  80 void Language::ForEach(std::function<bool(Language *)> callback) {
  81   std::lock_guard<std::mutex> guard(GetLanguagesMutex());
  82   LanguagesMap &map(GetLanguagesMap());
  83   for (const auto &entry : map) {
  84     if (!callback(entry.second.get()))
  85       break;
  86   }
  87 }
  88
  89 bool Language::IsTopLevelFunction(Function &function) { return false; }
  90
  91 lldb::TypeCategoryImplSP Language::GetFormatters() { return nullptr; }
  92
  93 HardcodedFormatters::HardcodedFormatFinder Language::GetHardcodedFormats() {
  94   return {};
  95 }
  96
  97 HardcodedFormatters::HardcodedSummaryFinder Language::GetHardcodedSummaries() {
  98   return {};
  99 }
 100
 101 HardcodedFormatters::HardcodedSyntheticFinder
 102 Language::GetHardcodedSynthetics() {
 103   return {};
 104 }
 105
 106 HardcodedFormatters::HardcodedValidatorFinder
 107 Language::GetHardcodedValidators() {
 108   return {};
 109 }
 110
 111 std::vector<ConstString>
 112 Language::GetPossibleFormattersMatches(ValueObject &valobj,
 113                                        lldb::DynamicValueType use_dynamic) {
 114   return {};
 115 }
 116
 117 lldb_private::formatters::StringPrinter::EscapingHelper
 118 Language::GetStringPrinterEscapingHelper(
 119     lldb_private::formatters::StringPrinter::GetPrintableElementType
 120         elem_type) {
 121   return StringPrinter::GetDefaultEscapingHelper(elem_type);
 122 }
 123
 124 struct language_name_pair {
 125   const char *name;
 126   LanguageType type;
 127 };
 128
 129 struct language_name_pair language_names[] = {
 130     // To allow GetNameForLanguageType to be a simple array lookup, the first
 131     // part of this array must follow enum LanguageType exactly.
 132     {"unknown", eLanguageTypeUnknown},
 133     {"c89", eLanguageTypeC89},
 134     {"c", eLanguageTypeC},
 135     {"ada83", eLanguageTypeAda83},
 136     {"c++", eLanguageTypeC_plus_plus},
 137     {"cobol74", eLanguageTypeCobol74},
 138     {"cobol85", eLanguageTypeCobol85},
 139     {"fortran77", eLanguageTypeFortran77},
 140     {"fortran90", eLanguageTypeFortran90},
 141     {"pascal83", eLanguageTypePascal83},
 142     {"modula2", eLanguageTypeModula2},
 143     {"java", eLanguageTypeJava},
 144     {"c99", eLanguageTypeC99},
 145     {"ada95", eLanguageTypeAda95},
 146     {"fortran95", eLanguageTypeFortran95},
 147     {"pli", eLanguageTypePLI},
 148     {"objective-c", eLanguageTypeObjC},
 149     {"objective-c++", eLanguageTypeObjC_plus_plus},
 150     {"upc", eLanguageTypeUPC},
 151     {"d", eLanguageTypeD},
 152     {"python", eLanguageTypePython},
 153     {"opencl", eLanguageTypeOpenCL},
 154     {"go", eLanguageTypeGo},
 155     {"modula3", eLanguageTypeModula3},
 156     {"haskell", eLanguageTypeHaskell},
 157     {"c++03", eLanguageTypeC_plus_plus_03},
 158     {"c++11", eLanguageTypeC_plus_plus_11},
 159     {"ocaml", eLanguageTypeOCaml},
 160     {"rust", eLanguageTypeRust},
 161     {"c11", eLanguageTypeC11},
 162     {"swift", eLanguageTypeSwift},
 163     {"julia", eLanguageTypeJulia},
 164     {"dylan", eLanguageTypeDylan},
 165     {"c++14", eLanguageTypeC_plus_plus_14},
 166     {"fortran03", eLanguageTypeFortran03},
 167     {"fortran08", eLanguageTypeFortran08},
 168     // Vendor Extensions
 169     {"mipsassem", eLanguageTypeMipsAssembler},
 170     {"renderscript", eLanguageTypeExtRenderScript},
 171     // Now synonyms, in arbitrary order
 172     {"objc", eLanguageTypeObjC},
 173     {"objc++", eLanguageTypeObjC_plus_plus},
 174     {"pascal", eLanguageTypePascal83}};
 175
 176 static uint32_t num_languages =
 177     sizeof(language_names) / sizeof(struct language_name_pair);
 178
 179 LanguageType Language::GetLanguageTypeFromString(llvm::StringRef string) {
 180   for (const auto &L : language_names) {
 181     if (string.equals_lower(L.name))
 182       return static_cast<LanguageType>(L.type);
 183   }
 184
 185   return eLanguageTypeUnknown;
 186 }
 187
 188 const char *Language::GetNameForLanguageType(LanguageType language) {
 189   if (language < num_languages)
 190     return language_names[language].name;
 191   else
 192     return language_names[eLanguageTypeUnknown].name;
 193 }
 194
 195 void Language::PrintAllLanguages(Stream &s, const char *prefix,
 196                                  const char *suffix) {
 197   for (uint32_t i = 1; i < num_languages; i++) {
 198     s.Printf("%s%s%s", prefix, language_names[i].name, suffix);
 199   }
 200 }
 201
 202 void Language::ForAllLanguages(
 203     std::function<bool(lldb::LanguageType)> callback) {
 204   for (uint32_t i = 1; i < num_languages; i++) {
 205     if (!callback(language_names[i].type))
 206       break;
 207   }
 208 }
 209
 210 bool Language::LanguageIsCPlusPlus(LanguageType language) {
 211   switch (language) {
 212   case eLanguageTypeC_plus_plus:
 213   case eLanguageTypeC_plus_plus_03:
 214   case eLanguageTypeC_plus_plus_11:
 215   case eLanguageTypeC_plus_plus_14:
 216   case eLanguageTypeObjC_plus_plus:
 217     return true;
 218   default:
 219     return false;
 220   }
 221 }
 222
 223 bool Language::LanguageIsObjC(LanguageType language) {
 224   switch (language) {
 225   case eLanguageTypeObjC:
 226   case eLanguageTypeObjC_plus_plus:
 227     return true;
 228   default:
 229     return false;
 230   }
 231 }
 232
 233 bool Language::LanguageIsC(LanguageType language) {
 234   switch (language) {
 235   case eLanguageTypeC:
 236   case eLanguageTypeC89:
 237   case eLanguageTypeC99:
 238   case eLanguageTypeC11:
 239     return true;
 240   default:
 241     return false;
 242   }
 243 }
 244
 245 bool Language::LanguageIsPascal(LanguageType language) {
 246   switch (language) {
 247   case eLanguageTypePascal83:
 248     return true;
 249   default:
 250     return false;
 251   }
 252 }
 253
 254 LanguageType Language::GetPrimaryLanguage(LanguageType language) {
 255   switch (language) {
 256   case eLanguageTypeC_plus_plus:
 257   case eLanguageTypeC_plus_plus_03:
 258   case eLanguageTypeC_plus_plus_11:
 259   case eLanguageTypeC_plus_plus_14:
 260     return eLanguageTypeC_plus_plus;
 261   case eLanguageTypeC:
 262   case eLanguageTypeC89:
 263   case eLanguageTypeC99:
 264   case eLanguageTypeC11:
 265     return eLanguageTypeC;
 266   case eLanguageTypeObjC:
 267   case eLanguageTypeObjC_plus_plus:
 268     return eLanguageTypeObjC;
 269   case eLanguageTypePascal83:
 270   case eLanguageTypeCobol74:
 271   case eLanguageTypeCobol85:
 272   case eLanguageTypeFortran77:
 273   case eLanguageTypeFortran90:
 274   case eLanguageTypeFortran95:
 275   case eLanguageTypeFortran03:
 276   case eLanguageTypeFortran08:
 277   case eLanguageTypeAda83:
 278   case eLanguageTypeAda95:
 279   case eLanguageTypeModula2:
 280   case eLanguageTypeJava:
 281   case eLanguageTypePLI:
 282   case eLanguageTypeUPC:
 283   case eLanguageTypeD:
 284   case eLanguageTypePython:
 285   case eLanguageTypeOpenCL:
 286   case eLanguageTypeGo:
 287   case eLanguageTypeModula3:
 288   case eLanguageTypeHaskell:
 289   case eLanguageTypeOCaml:
 290   case eLanguageTypeRust:
 291   case eLanguageTypeSwift:
 292   case eLanguageTypeJulia:
 293   case eLanguageTypeDylan:
 294   case eLanguageTypeMipsAssembler:
 295   case eLanguageTypeExtRenderScript:
 296   case eLanguageTypeUnknown:
 297   default:
 298     return language;
 299   }
 300 }
 301
 302 void Language::GetLanguagesSupportingTypeSystems(
 303     std::set<lldb::LanguageType> &languages,
 304     std::set<lldb::LanguageType> &languages_for_expressions) {
 305   uint32_t idx = 0;
 306
 307   while (TypeSystemEnumerateSupportedLanguages enumerate = PluginManager::
 308              GetTypeSystemEnumerateSupportedLanguagesCallbackAtIndex(idx++)) {
 309     (*enumerate)(languages, languages_for_expressions);
 310   }
 311 }
 312
 313 void Language::GetLanguagesSupportingREPLs(
 314     std::set<lldb::LanguageType> &languages) {
 315   uint32_t idx = 0;
 316
 317   while (REPLEnumerateSupportedLanguages enumerate =
 318              PluginManager::GetREPLEnumerateSupportedLanguagesCallbackAtIndex(
 319                  idx++)) {
 320     (*enumerate)(languages);
 321   }
 322 }
 323
 324 std::unique_ptr<Language::TypeScavenger> Language::GetTypeScavenger() {
 325   return nullptr;
 326 }
 327
 328 const char *Language::GetLanguageSpecificTypeLookupHelp() { return nullptr; }
 329
 330 size_t Language::TypeScavenger::Find(ExecutionContextScope *exe_scope,
 331                                      const char *key, ResultSet &results,
 332                                      bool append) {
 333   if (!exe_scope || !exe_scope->CalculateTarget().get())
 334     return false;
 335
 336   if (!key || !key[0])
 337     return false;
 338
 339   if (!append)
 340     results.clear();
 341
 342   size_t old_size = results.size();
 343
 344   if (this->Find_Impl(exe_scope, key, results))
 345     return results.size() - old_size;
 346   return 0;
 347 }
 348
 349 bool Language::ImageListTypeScavenger::Find_Impl(
 350     ExecutionContextScope *exe_scope, const char *key, ResultSet &results) {
 351   bool result = false;
 352
 353   Target *target = exe_scope->CalculateTarget().get();
 354   if (target) {
 355     const auto &images(target->GetImages());
 356     SymbolContext null_sc;
 357     ConstString cs_key(key);
 358     llvm::DenseSet<SymbolFile *> searched_sym_files;
 359     TypeList matches;
 360     images.FindTypes(null_sc, cs_key, false, UINT32_MAX, searched_sym_files,
 361                      matches);
 362     for (const auto &match : matches.Types()) {
 363       if (match.get()) {
 364         CompilerType compiler_type(match->GetFullCompilerType());
 365         compiler_type = AdjustForInclusion(compiler_type);
 366         if (!compiler_type)
 367           continue;
 368         std::unique_ptr<Language::TypeScavenger::Result> scavengeresult(
 369             new Result(compiler_type));
 370         results.insert(std::move(scavengeresult));
 371         result = true;
 372       }
 373     }
 374   }
 375
 376   return result;
 377 }
 378
 379 bool Language::GetFormatterPrefixSuffix(ValueObject &valobj,
 380                                         ConstString type_hint,
 381                                         std::string &prefix,
 382                                         std::string &suffix) {
 383   return false;
 384 }
 385
 386 DumpValueObjectOptions::DeclPrintingHelper Language::GetDeclPrintingHelper() {
 387   return nullptr;
 388 }
 389
 390 LazyBool Language::IsLogicalTrue(ValueObject &valobj, Error &error) {
 391   return eLazyBoolCalculate;
 392 }
 393
 394 bool Language::IsNilReference(ValueObject &valobj) { return false; }
 395
 396 bool Language::IsUninitializedReference(ValueObject &valobj) { return false; }
 397
 398 bool Language::GetFunctionDisplayName(const SymbolContext *sc,
 399                                       const ExecutionContext *exe_ctx,
 400                                       FunctionNameRepresentation representation,
 401                                       Stream &s) {
 402   return false;
 403 }
 404
 405 void Language::GetExceptionResolverDescription(bool catch_on, bool throw_on,
 406                                                Stream &s) {
 407   GetDefaultExceptionResolverDescription(catch_on, throw_on, s);
 408 }
 409
 410 void Language::GetDefaultExceptionResolverDescription(bool catch_on,
 411                                                       bool throw_on,
 412                                                       Stream &s) {
 413   s.Printf("Exception breakpoint (catch: %s throw: %s)",
 414            catch_on ? "on" : "off", throw_on ? "on" : "off");
 415 }
 416 //----------------------------------------------------------------------
 417 // Constructor
 418 //----------------------------------------------------------------------
 419 Language::Language() {}
 420
 421 //----------------------------------------------------------------------
 422 // Destructor
 423 //----------------------------------------------------------------------
 424 Language::~Language() {}