1 //===-- Language.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 <functional> 10 #include <map> 11 #include <mutex> 12 13 #include "lldb/Target/Language.h" 14 15 #include "lldb/Core/PluginManager.h" 16 #include "lldb/Symbol/SymbolFile.h" 17 #include "lldb/Symbol/TypeList.h" 18 #include "lldb/Target/Target.h" 19 #include "lldb/Utility/Stream.h" 20 21 #include "llvm/Support/Threading.h" 22 23 using namespace lldb; 24 using namespace lldb_private; 25 using namespace lldb_private::formatters; 26 27 typedef std::unique_ptr<Language> LanguageUP; 28 typedef std::map<lldb::LanguageType, LanguageUP> LanguagesMap; 29 30 static LanguagesMap &GetLanguagesMap() { 31 static LanguagesMap *g_map = nullptr; 32 static llvm::once_flag g_initialize; 33 34 llvm::call_once(g_initialize, [] { 35 g_map = new LanguagesMap(); // NOTE: INTENTIONAL LEAK due to global 36 // destructor chain 37 }); 38 39 return *g_map; 40 } 41 static std::mutex &GetLanguagesMutex() { 42 static std::mutex *g_mutex = nullptr; 43 static llvm::once_flag g_initialize; 44 45 llvm::call_once(g_initialize, [] { 46 g_mutex = new std::mutex(); // NOTE: INTENTIONAL LEAK due to global 47 // destructor chain 48 }); 49 50 return *g_mutex; 51 } 52 53 Language *Language::FindPlugin(lldb::LanguageType language) { 54 std::lock_guard<std::mutex> guard(GetLanguagesMutex()); 55 LanguagesMap &map(GetLanguagesMap()); 56 auto iter = map.find(language), end = map.end(); 57 if (iter != end) 58 return iter->second.get(); 59 60 Language *language_ptr = nullptr; 61 LanguageCreateInstance create_callback; 62 63 for (uint32_t idx = 0; 64 (create_callback = 65 PluginManager::GetLanguageCreateCallbackAtIndex(idx)) != nullptr; 66 ++idx) { 67 language_ptr = create_callback(language); 68 69 if (language_ptr) { 70 map[language] = std::unique_ptr<Language>(language_ptr); 71 return language_ptr; 72 } 73 } 74 75 return nullptr; 76 } 77 78 Language *Language::FindPlugin(llvm::StringRef file_path) { 79 Language *result = nullptr; 80 ForEach([&result, file_path](Language *language) { 81 if (language->IsSourceFile(file_path)) { 82 result = language; 83 return false; 84 } 85 return true; 86 }); 87 return result; 88 } 89 90 Language *Language::FindPlugin(LanguageType language, 91 llvm::StringRef file_path) { 92 Language *result = FindPlugin(language); 93 // Finding a language by file path is slower, we so we use this as the 94 // fallback. 95 if (!result) 96 result = FindPlugin(file_path); 97 return result; 98 } 99 100 void Language::ForEach(std::function<bool(Language *)> callback) { 101 // If we want to iterate over all languages, we first have to complete the 102 // LanguagesMap. 103 static llvm::once_flag g_initialize; 104 llvm::call_once(g_initialize, [] { 105 for (unsigned lang = eLanguageTypeUnknown; lang < eNumLanguageTypes; 106 ++lang) { 107 FindPlugin(static_cast<lldb::LanguageType>(lang)); 108 } 109 }); 110 111 // callback may call a method in Language that attempts to acquire the same 112 // lock (such as Language::ForEach or Language::FindPlugin). To avoid a 113 // deadlock, we do not use callback while holding the lock. 114 std::vector<Language *> loaded_plugins; 115 { 116 std::lock_guard<std::mutex> guard(GetLanguagesMutex()); 117 LanguagesMap &map(GetLanguagesMap()); 118 for (const auto &entry : map) { 119 if (entry.second) 120 loaded_plugins.push_back(entry.second.get()); 121 } 122 } 123 124 for (auto *lang : loaded_plugins) { 125 if (!callback(lang)) 126 break; 127 } 128 } 129 130 bool Language::IsTopLevelFunction(Function &function) { return false; } 131 132 lldb::TypeCategoryImplSP Language::GetFormatters() { return nullptr; } 133 134 HardcodedFormatters::HardcodedFormatFinder Language::GetHardcodedFormats() { 135 return {}; 136 } 137 138 HardcodedFormatters::HardcodedSummaryFinder Language::GetHardcodedSummaries() { 139 return {}; 140 } 141 142 HardcodedFormatters::HardcodedSyntheticFinder 143 Language::GetHardcodedSynthetics() { 144 return {}; 145 } 146 147 std::vector<FormattersMatchCandidate> 148 Language::GetPossibleFormattersMatches(ValueObject &valobj, 149 lldb::DynamicValueType use_dynamic) { 150 return {}; 151 } 152 153 struct language_name_pair { 154 const char *name; 155 LanguageType type; 156 }; 157 158 struct language_name_pair language_names[] = { 159 // To allow GetNameForLanguageType to be a simple array lookup, the first 160 // part of this array must follow enum LanguageType exactly. 161 {"unknown", eLanguageTypeUnknown}, 162 {"c89", eLanguageTypeC89}, 163 {"c", eLanguageTypeC}, 164 {"ada83", eLanguageTypeAda83}, 165 {"c++", eLanguageTypeC_plus_plus}, 166 {"cobol74", eLanguageTypeCobol74}, 167 {"cobol85", eLanguageTypeCobol85}, 168 {"fortran77", eLanguageTypeFortran77}, 169 {"fortran90", eLanguageTypeFortran90}, 170 {"pascal83", eLanguageTypePascal83}, 171 {"modula2", eLanguageTypeModula2}, 172 {"java", eLanguageTypeJava}, 173 {"c99", eLanguageTypeC99}, 174 {"ada95", eLanguageTypeAda95}, 175 {"fortran95", eLanguageTypeFortran95}, 176 {"pli", eLanguageTypePLI}, 177 {"objective-c", eLanguageTypeObjC}, 178 {"objective-c++", eLanguageTypeObjC_plus_plus}, 179 {"upc", eLanguageTypeUPC}, 180 {"d", eLanguageTypeD}, 181 {"python", eLanguageTypePython}, 182 {"opencl", eLanguageTypeOpenCL}, 183 {"go", eLanguageTypeGo}, 184 {"modula3", eLanguageTypeModula3}, 185 {"haskell", eLanguageTypeHaskell}, 186 {"c++03", eLanguageTypeC_plus_plus_03}, 187 {"c++11", eLanguageTypeC_plus_plus_11}, 188 {"ocaml", eLanguageTypeOCaml}, 189 {"rust", eLanguageTypeRust}, 190 {"c11", eLanguageTypeC11}, 191 {"swift", eLanguageTypeSwift}, 192 {"julia", eLanguageTypeJulia}, 193 {"dylan", eLanguageTypeDylan}, 194 {"c++14", eLanguageTypeC_plus_plus_14}, 195 {"fortran03", eLanguageTypeFortran03}, 196 {"fortran08", eLanguageTypeFortran08}, 197 {"renderscript", eLanguageTypeRenderScript}, 198 {"bliss", eLanguageTypeBLISS}, 199 {"kotlin", eLanguageTypeKotlin}, 200 {"zig", eLanguageTypeZig}, 201 {"crystal", eLanguageTypeCrystal}, 202 {"<invalid language>", 203 static_cast<LanguageType>( 204 0x0029)}, // Not yet taken by any language in the DWARF spec 205 // and thus has no entry in LanguageType 206 {"c++17", eLanguageTypeC_plus_plus_17}, 207 {"c++20", eLanguageTypeC_plus_plus_20}, 208 {"c17", eLanguageTypeC17}, 209 {"fortran18", eLanguageTypeFortran18}, 210 {"ada2005", eLanguageTypeAda2005}, 211 {"ada2012", eLanguageTypeAda2012}, 212 {"HIP", eLanguageTypeHIP}, 213 {"assembly", eLanguageTypeAssembly}, 214 {"c-sharp", eLanguageTypeC_sharp}, 215 {"mojo", eLanguageTypeMojo}, 216 // Vendor Extensions 217 {"assembler", eLanguageTypeMipsAssembler}, 218 // Now synonyms, in arbitrary order 219 {"objc", eLanguageTypeObjC}, 220 {"objc++", eLanguageTypeObjC_plus_plus}, 221 {"pascal", eLanguageTypePascal83}}; 222 223 static uint32_t num_languages = 224 sizeof(language_names) / sizeof(struct language_name_pair); 225 226 LanguageType Language::GetLanguageTypeFromString(llvm::StringRef string) { 227 for (const auto &L : language_names) { 228 if (string.equals_insensitive(L.name)) 229 return static_cast<LanguageType>(L.type); 230 } 231 232 return eLanguageTypeUnknown; 233 } 234 235 const char *Language::GetNameForLanguageType(LanguageType language) { 236 if (language < num_languages) 237 return language_names[language].name; 238 else 239 return language_names[eLanguageTypeUnknown].name; 240 } 241 242 void Language::PrintSupportedLanguagesForExpressions(Stream &s, 243 llvm::StringRef prefix, 244 llvm::StringRef suffix) { 245 auto supported = Language::GetLanguagesSupportingTypeSystemsForExpressions(); 246 for (size_t idx = 0; idx < num_languages; ++idx) { 247 auto const &lang = language_names[idx]; 248 if (supported[lang.type]) 249 s << prefix << lang.name << suffix; 250 } 251 } 252 253 void Language::PrintAllLanguages(Stream &s, const char *prefix, 254 const char *suffix) { 255 for (uint32_t i = 1; i < num_languages; i++) { 256 s.Printf("%s%s%s", prefix, language_names[i].name, suffix); 257 } 258 } 259 260 void Language::ForAllLanguages( 261 std::function<bool(lldb::LanguageType)> callback) { 262 for (uint32_t i = 1; i < num_languages; i++) { 263 if (!callback(language_names[i].type)) 264 break; 265 } 266 } 267 268 bool Language::LanguageIsCPlusPlus(LanguageType language) { 269 switch (language) { 270 case eLanguageTypeC_plus_plus: 271 case eLanguageTypeC_plus_plus_03: 272 case eLanguageTypeC_plus_plus_11: 273 case eLanguageTypeC_plus_plus_14: 274 case eLanguageTypeC_plus_plus_17: 275 case eLanguageTypeC_plus_plus_20: 276 case eLanguageTypeObjC_plus_plus: 277 return true; 278 default: 279 return false; 280 } 281 } 282 283 bool Language::LanguageIsObjC(LanguageType language) { 284 switch (language) { 285 case eLanguageTypeObjC: 286 case eLanguageTypeObjC_plus_plus: 287 return true; 288 default: 289 return false; 290 } 291 } 292 293 bool Language::LanguageIsC(LanguageType language) { 294 switch (language) { 295 case eLanguageTypeC: 296 case eLanguageTypeC89: 297 case eLanguageTypeC99: 298 case eLanguageTypeC11: 299 return true; 300 default: 301 return false; 302 } 303 } 304 305 bool Language::LanguageIsCFamily(LanguageType language) { 306 switch (language) { 307 case eLanguageTypeC: 308 case eLanguageTypeC89: 309 case eLanguageTypeC99: 310 case eLanguageTypeC11: 311 case eLanguageTypeC_plus_plus: 312 case eLanguageTypeC_plus_plus_03: 313 case eLanguageTypeC_plus_plus_11: 314 case eLanguageTypeC_plus_plus_14: 315 case eLanguageTypeC_plus_plus_17: 316 case eLanguageTypeC_plus_plus_20: 317 case eLanguageTypeObjC_plus_plus: 318 case eLanguageTypeObjC: 319 return true; 320 default: 321 return false; 322 } 323 } 324 325 bool Language::LanguageIsPascal(LanguageType language) { 326 switch (language) { 327 case eLanguageTypePascal83: 328 return true; 329 default: 330 return false; 331 } 332 } 333 334 LanguageType Language::GetPrimaryLanguage(LanguageType language) { 335 switch (language) { 336 case eLanguageTypeC_plus_plus: 337 case eLanguageTypeC_plus_plus_03: 338 case eLanguageTypeC_plus_plus_11: 339 case eLanguageTypeC_plus_plus_14: 340 case eLanguageTypeC_plus_plus_17: 341 case eLanguageTypeC_plus_plus_20: 342 return eLanguageTypeC_plus_plus; 343 case eLanguageTypeC: 344 case eLanguageTypeC89: 345 case eLanguageTypeC99: 346 case eLanguageTypeC11: 347 return eLanguageTypeC; 348 case eLanguageTypeObjC: 349 case eLanguageTypeObjC_plus_plus: 350 return eLanguageTypeObjC; 351 case eLanguageTypePascal83: 352 case eLanguageTypeCobol74: 353 case eLanguageTypeCobol85: 354 case eLanguageTypeFortran77: 355 case eLanguageTypeFortran90: 356 case eLanguageTypeFortran95: 357 case eLanguageTypeFortran03: 358 case eLanguageTypeFortran08: 359 case eLanguageTypeAda83: 360 case eLanguageTypeAda95: 361 case eLanguageTypeModula2: 362 case eLanguageTypeJava: 363 case eLanguageTypePLI: 364 case eLanguageTypeUPC: 365 case eLanguageTypeD: 366 case eLanguageTypePython: 367 case eLanguageTypeOpenCL: 368 case eLanguageTypeGo: 369 case eLanguageTypeModula3: 370 case eLanguageTypeHaskell: 371 case eLanguageTypeOCaml: 372 case eLanguageTypeRust: 373 case eLanguageTypeSwift: 374 case eLanguageTypeJulia: 375 case eLanguageTypeDylan: 376 case eLanguageTypeMipsAssembler: 377 case eLanguageTypeUnknown: 378 default: 379 return language; 380 } 381 } 382 383 std::set<lldb::LanguageType> Language::GetSupportedLanguages() { 384 std::set<lldb::LanguageType> supported_languages; 385 ForEach([&](Language *lang) { 386 supported_languages.emplace(lang->GetLanguageType()); 387 return true; 388 }); 389 return supported_languages; 390 } 391 392 LanguageSet Language::GetLanguagesSupportingTypeSystems() { 393 return PluginManager::GetAllTypeSystemSupportedLanguagesForTypes(); 394 } 395 396 LanguageSet Language::GetLanguagesSupportingTypeSystemsForExpressions() { 397 return PluginManager::GetAllTypeSystemSupportedLanguagesForExpressions(); 398 } 399 400 LanguageSet Language::GetLanguagesSupportingREPLs() { 401 return PluginManager::GetREPLAllTypeSystemSupportedLanguages(); 402 } 403 404 std::unique_ptr<Language::TypeScavenger> Language::GetTypeScavenger() { 405 return nullptr; 406 } 407 408 const char *Language::GetLanguageSpecificTypeLookupHelp() { return nullptr; } 409 410 size_t Language::TypeScavenger::Find(ExecutionContextScope *exe_scope, 411 const char *key, ResultSet &results, 412 bool append) { 413 if (!exe_scope || !exe_scope->CalculateTarget().get()) 414 return false; 415 416 if (!key || !key[0]) 417 return false; 418 419 if (!append) 420 results.clear(); 421 422 size_t old_size = results.size(); 423 424 if (this->Find_Impl(exe_scope, key, results)) 425 return results.size() - old_size; 426 return 0; 427 } 428 429 bool Language::ImageListTypeScavenger::Find_Impl( 430 ExecutionContextScope *exe_scope, const char *key, ResultSet &results) { 431 bool result = false; 432 433 Target *target = exe_scope->CalculateTarget().get(); 434 if (target) { 435 const auto &images(target->GetImages()); 436 ConstString cs_key(key); 437 llvm::DenseSet<SymbolFile *> searched_sym_files; 438 TypeList matches; 439 images.FindTypes(nullptr, cs_key, false, UINT32_MAX, searched_sym_files, 440 matches); 441 for (const auto &match : matches.Types()) { 442 if (match) { 443 CompilerType compiler_type(match->GetFullCompilerType()); 444 compiler_type = AdjustForInclusion(compiler_type); 445 if (!compiler_type) 446 continue; 447 std::unique_ptr<Language::TypeScavenger::Result> scavengeresult( 448 new Result(compiler_type)); 449 results.insert(std::move(scavengeresult)); 450 result = true; 451 } 452 } 453 } 454 455 return result; 456 } 457 458 std::pair<llvm::StringRef, llvm::StringRef> 459 Language::GetFormatterPrefixSuffix(llvm::StringRef type_hint) { 460 return std::pair<llvm::StringRef, llvm::StringRef>(); 461 } 462 463 bool Language::DemangledNameContainsPath(llvm::StringRef path, 464 ConstString demangled) const { 465 // The base implementation does a simple contains comparision: 466 if (path.empty()) 467 return false; 468 return demangled.GetStringRef().contains(path); 469 } 470 471 DumpValueObjectOptions::DeclPrintingHelper Language::GetDeclPrintingHelper() { 472 return nullptr; 473 } 474 475 LazyBool Language::IsLogicalTrue(ValueObject &valobj, Status &error) { 476 return eLazyBoolCalculate; 477 } 478 479 bool Language::IsNilReference(ValueObject &valobj) { return false; } 480 481 bool Language::IsUninitializedReference(ValueObject &valobj) { return false; } 482 483 bool Language::GetFunctionDisplayName(const SymbolContext *sc, 484 const ExecutionContext *exe_ctx, 485 FunctionNameRepresentation representation, 486 Stream &s) { 487 return false; 488 } 489 490 void Language::GetExceptionResolverDescription(bool catch_on, bool throw_on, 491 Stream &s) { 492 GetDefaultExceptionResolverDescription(catch_on, throw_on, s); 493 } 494 495 void Language::GetDefaultExceptionResolverDescription(bool catch_on, 496 bool throw_on, 497 Stream &s) { 498 s.Printf("Exception breakpoint (catch: %s throw: %s)", 499 catch_on ? "on" : "off", throw_on ? "on" : "off"); 500 } 501 // Constructor 502 Language::Language() = default; 503 504 // Destructor 505 Language::~Language() = default; 506