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
GetLanguagesMap()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 }
GetLanguagesMutex()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
FindPlugin(lldb::LanguageType language)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
FindPlugin(llvm::StringRef file_path)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
FindPlugin(LanguageType language,llvm::StringRef file_path)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
ForEach(std::function<bool (Language *)> callback)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
IsTopLevelFunction(Function & function)130 bool Language::IsTopLevelFunction(Function &function) { return false; }
131
GetFormatters()132 lldb::TypeCategoryImplSP Language::GetFormatters() { return nullptr; }
133
GetHardcodedFormats()134 HardcodedFormatters::HardcodedFormatFinder Language::GetHardcodedFormats() {
135 return {};
136 }
137
GetHardcodedSummaries()138 HardcodedFormatters::HardcodedSummaryFinder Language::GetHardcodedSummaries() {
139 return {};
140 }
141
142 HardcodedFormatters::HardcodedSyntheticFinder
GetHardcodedSynthetics()143 Language::GetHardcodedSynthetics() {
144 return {};
145 }
146
147 std::vector<FormattersMatchCandidate>
GetPossibleFormattersMatches(ValueObject & valobj,lldb::DynamicValueType use_dynamic)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 // Vendor Extensions
198 {"assembler", eLanguageTypeMipsAssembler},
199 {"renderscript", eLanguageTypeExtRenderScript},
200 // Now synonyms, in arbitrary order
201 {"objc", eLanguageTypeObjC},
202 {"objc++", eLanguageTypeObjC_plus_plus},
203 {"pascal", eLanguageTypePascal83}};
204
205 static uint32_t num_languages =
206 sizeof(language_names) / sizeof(struct language_name_pair);
207
GetLanguageTypeFromString(llvm::StringRef string)208 LanguageType Language::GetLanguageTypeFromString(llvm::StringRef string) {
209 for (const auto &L : language_names) {
210 if (string.equals_insensitive(L.name))
211 return static_cast<LanguageType>(L.type);
212 }
213
214 return eLanguageTypeUnknown;
215 }
216
GetNameForLanguageType(LanguageType language)217 const char *Language::GetNameForLanguageType(LanguageType language) {
218 if (language < num_languages)
219 return language_names[language].name;
220 else
221 return language_names[eLanguageTypeUnknown].name;
222 }
223
PrintSupportedLanguagesForExpressions(Stream & s,llvm::StringRef prefix,llvm::StringRef suffix)224 void Language::PrintSupportedLanguagesForExpressions(Stream &s,
225 llvm::StringRef prefix,
226 llvm::StringRef suffix) {
227 auto supported = Language::GetLanguagesSupportingTypeSystemsForExpressions();
228 for (size_t idx = 0; idx < num_languages; ++idx) {
229 auto const &lang = language_names[idx];
230 if (supported[lang.type])
231 s << prefix << lang.name << suffix;
232 }
233 }
234
PrintAllLanguages(Stream & s,const char * prefix,const char * suffix)235 void Language::PrintAllLanguages(Stream &s, const char *prefix,
236 const char *suffix) {
237 for (uint32_t i = 1; i < num_languages; i++) {
238 s.Printf("%s%s%s", prefix, language_names[i].name, suffix);
239 }
240 }
241
ForAllLanguages(std::function<bool (lldb::LanguageType)> callback)242 void Language::ForAllLanguages(
243 std::function<bool(lldb::LanguageType)> callback) {
244 for (uint32_t i = 1; i < num_languages; i++) {
245 if (!callback(language_names[i].type))
246 break;
247 }
248 }
249
LanguageIsCPlusPlus(LanguageType language)250 bool Language::LanguageIsCPlusPlus(LanguageType language) {
251 switch (language) {
252 case eLanguageTypeC_plus_plus:
253 case eLanguageTypeC_plus_plus_03:
254 case eLanguageTypeC_plus_plus_11:
255 case eLanguageTypeC_plus_plus_14:
256 case eLanguageTypeObjC_plus_plus:
257 return true;
258 default:
259 return false;
260 }
261 }
262
LanguageIsObjC(LanguageType language)263 bool Language::LanguageIsObjC(LanguageType language) {
264 switch (language) {
265 case eLanguageTypeObjC:
266 case eLanguageTypeObjC_plus_plus:
267 return true;
268 default:
269 return false;
270 }
271 }
272
LanguageIsC(LanguageType language)273 bool Language::LanguageIsC(LanguageType language) {
274 switch (language) {
275 case eLanguageTypeC:
276 case eLanguageTypeC89:
277 case eLanguageTypeC99:
278 case eLanguageTypeC11:
279 return true;
280 default:
281 return false;
282 }
283 }
284
LanguageIsCFamily(LanguageType language)285 bool Language::LanguageIsCFamily(LanguageType language) {
286 switch (language) {
287 case eLanguageTypeC:
288 case eLanguageTypeC89:
289 case eLanguageTypeC99:
290 case eLanguageTypeC11:
291 case eLanguageTypeC_plus_plus:
292 case eLanguageTypeC_plus_plus_03:
293 case eLanguageTypeC_plus_plus_11:
294 case eLanguageTypeC_plus_plus_14:
295 case eLanguageTypeObjC_plus_plus:
296 case eLanguageTypeObjC:
297 return true;
298 default:
299 return false;
300 }
301 }
302
LanguageIsPascal(LanguageType language)303 bool Language::LanguageIsPascal(LanguageType language) {
304 switch (language) {
305 case eLanguageTypePascal83:
306 return true;
307 default:
308 return false;
309 }
310 }
311
GetPrimaryLanguage(LanguageType language)312 LanguageType Language::GetPrimaryLanguage(LanguageType language) {
313 switch (language) {
314 case eLanguageTypeC_plus_plus:
315 case eLanguageTypeC_plus_plus_03:
316 case eLanguageTypeC_plus_plus_11:
317 case eLanguageTypeC_plus_plus_14:
318 return eLanguageTypeC_plus_plus;
319 case eLanguageTypeC:
320 case eLanguageTypeC89:
321 case eLanguageTypeC99:
322 case eLanguageTypeC11:
323 return eLanguageTypeC;
324 case eLanguageTypeObjC:
325 case eLanguageTypeObjC_plus_plus:
326 return eLanguageTypeObjC;
327 case eLanguageTypePascal83:
328 case eLanguageTypeCobol74:
329 case eLanguageTypeCobol85:
330 case eLanguageTypeFortran77:
331 case eLanguageTypeFortran90:
332 case eLanguageTypeFortran95:
333 case eLanguageTypeFortran03:
334 case eLanguageTypeFortran08:
335 case eLanguageTypeAda83:
336 case eLanguageTypeAda95:
337 case eLanguageTypeModula2:
338 case eLanguageTypeJava:
339 case eLanguageTypePLI:
340 case eLanguageTypeUPC:
341 case eLanguageTypeD:
342 case eLanguageTypePython:
343 case eLanguageTypeOpenCL:
344 case eLanguageTypeGo:
345 case eLanguageTypeModula3:
346 case eLanguageTypeHaskell:
347 case eLanguageTypeOCaml:
348 case eLanguageTypeRust:
349 case eLanguageTypeSwift:
350 case eLanguageTypeJulia:
351 case eLanguageTypeDylan:
352 case eLanguageTypeMipsAssembler:
353 case eLanguageTypeExtRenderScript:
354 case eLanguageTypeUnknown:
355 default:
356 return language;
357 }
358 }
359
GetSupportedLanguages()360 std::set<lldb::LanguageType> Language::GetSupportedLanguages() {
361 std::set<lldb::LanguageType> supported_languages;
362 ForEach([&](Language *lang) {
363 supported_languages.emplace(lang->GetLanguageType());
364 return true;
365 });
366 return supported_languages;
367 }
368
GetLanguagesSupportingTypeSystems()369 LanguageSet Language::GetLanguagesSupportingTypeSystems() {
370 return PluginManager::GetAllTypeSystemSupportedLanguagesForTypes();
371 }
372
GetLanguagesSupportingTypeSystemsForExpressions()373 LanguageSet Language::GetLanguagesSupportingTypeSystemsForExpressions() {
374 return PluginManager::GetAllTypeSystemSupportedLanguagesForExpressions();
375 }
376
GetLanguagesSupportingREPLs()377 LanguageSet Language::GetLanguagesSupportingREPLs() {
378 return PluginManager::GetREPLAllTypeSystemSupportedLanguages();
379 }
380
GetTypeScavenger()381 std::unique_ptr<Language::TypeScavenger> Language::GetTypeScavenger() {
382 return nullptr;
383 }
384
GetLanguageSpecificTypeLookupHelp()385 const char *Language::GetLanguageSpecificTypeLookupHelp() { return nullptr; }
386
Find(ExecutionContextScope * exe_scope,const char * key,ResultSet & results,bool append)387 size_t Language::TypeScavenger::Find(ExecutionContextScope *exe_scope,
388 const char *key, ResultSet &results,
389 bool append) {
390 if (!exe_scope || !exe_scope->CalculateTarget().get())
391 return false;
392
393 if (!key || !key[0])
394 return false;
395
396 if (!append)
397 results.clear();
398
399 size_t old_size = results.size();
400
401 if (this->Find_Impl(exe_scope, key, results))
402 return results.size() - old_size;
403 return 0;
404 }
405
Find_Impl(ExecutionContextScope * exe_scope,const char * key,ResultSet & results)406 bool Language::ImageListTypeScavenger::Find_Impl(
407 ExecutionContextScope *exe_scope, const char *key, ResultSet &results) {
408 bool result = false;
409
410 Target *target = exe_scope->CalculateTarget().get();
411 if (target) {
412 const auto &images(target->GetImages());
413 ConstString cs_key(key);
414 llvm::DenseSet<SymbolFile *> searched_sym_files;
415 TypeList matches;
416 images.FindTypes(nullptr, cs_key, false, UINT32_MAX, searched_sym_files,
417 matches);
418 for (const auto &match : matches.Types()) {
419 if (match) {
420 CompilerType compiler_type(match->GetFullCompilerType());
421 compiler_type = AdjustForInclusion(compiler_type);
422 if (!compiler_type)
423 continue;
424 std::unique_ptr<Language::TypeScavenger::Result> scavengeresult(
425 new Result(compiler_type));
426 results.insert(std::move(scavengeresult));
427 result = true;
428 }
429 }
430 }
431
432 return result;
433 }
434
GetFormatterPrefixSuffix(ValueObject & valobj,ConstString type_hint,std::string & prefix,std::string & suffix)435 bool Language::GetFormatterPrefixSuffix(ValueObject &valobj,
436 ConstString type_hint,
437 std::string &prefix,
438 std::string &suffix) {
439 return false;
440 }
441
DemangledNameContainsPath(llvm::StringRef path,ConstString demangled) const442 bool Language::DemangledNameContainsPath(llvm::StringRef path,
443 ConstString demangled) const {
444 // The base implementation does a simple contains comparision:
445 if (path.empty())
446 return false;
447 return demangled.GetStringRef().contains(path);
448 }
449
GetDeclPrintingHelper()450 DumpValueObjectOptions::DeclPrintingHelper Language::GetDeclPrintingHelper() {
451 return nullptr;
452 }
453
IsLogicalTrue(ValueObject & valobj,Status & error)454 LazyBool Language::IsLogicalTrue(ValueObject &valobj, Status &error) {
455 return eLazyBoolCalculate;
456 }
457
IsNilReference(ValueObject & valobj)458 bool Language::IsNilReference(ValueObject &valobj) { return false; }
459
IsUninitializedReference(ValueObject & valobj)460 bool Language::IsUninitializedReference(ValueObject &valobj) { return false; }
461
GetFunctionDisplayName(const SymbolContext * sc,const ExecutionContext * exe_ctx,FunctionNameRepresentation representation,Stream & s)462 bool Language::GetFunctionDisplayName(const SymbolContext *sc,
463 const ExecutionContext *exe_ctx,
464 FunctionNameRepresentation representation,
465 Stream &s) {
466 return false;
467 }
468
GetExceptionResolverDescription(bool catch_on,bool throw_on,Stream & s)469 void Language::GetExceptionResolverDescription(bool catch_on, bool throw_on,
470 Stream &s) {
471 GetDefaultExceptionResolverDescription(catch_on, throw_on, s);
472 }
473
GetDefaultExceptionResolverDescription(bool catch_on,bool throw_on,Stream & s)474 void Language::GetDefaultExceptionResolverDescription(bool catch_on,
475 bool throw_on,
476 Stream &s) {
477 s.Printf("Exception breakpoint (catch: %s throw: %s)",
478 catch_on ? "on" : "off", throw_on ? "on" : "off");
479 }
480 // Constructor
481 Language::Language() = default;
482
483 // Destructor
484 Language::~Language() = default;
485