LLDB mainline
Language.cpp
Go to the documentation of this file.
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
14
18#include "lldb/Target/Target.h"
19#include "lldb/Utility/Stream.h"
20
21#include "llvm/Support/Threading.h"
22
23using namespace lldb;
24using namespace lldb_private;
25using namespace lldb_private::formatters;
26
27typedef std::unique_ptr<Language> LanguageUP;
28typedef std::map<lldb::LanguageType, LanguageUP> LanguagesMap;
29
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}
41static 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
54 std::lock_guard<std::mutex> guard(GetLanguagesMutex());
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 =
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
78Language *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
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
100void 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());
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
130bool Language::IsTopLevelFunction(Function &function) { return false; }
131
132lldb::TypeCategoryImplSP Language::GetFormatters() { return nullptr; }
133
135 return {};
136}
137
139 return {};
140}
141
144 return {};
145}
146
147std::vector<FormattersMatchCandidate>
149 lldb::DynamicValueType use_dynamic) {
150 return {};
151}
152
154 const char *name;
156};
157
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},
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},
188 {"ocaml", eLanguageTypeOCaml},
189 {"rust", eLanguageTypeRust},
190 {"c11", eLanguageTypeC11},
191 {"swift", eLanguageTypeSwift},
192 {"julia", eLanguageTypeJulia},
193 {"dylan", eLanguageTypeDylan},
195 {"fortran03", eLanguageTypeFortran03},
196 {"fortran08", eLanguageTypeFortran08},
197 // Vendor Extensions
198 {"assembler", eLanguageTypeMipsAssembler},
199 // Now synonyms, in arbitrary order
200 {"objc", eLanguageTypeObjC},
201 {"objc++", eLanguageTypeObjC_plus_plus},
202 {"pascal", eLanguageTypePascal83}};
203
205 sizeof(language_names) / sizeof(struct language_name_pair);
206
208 for (const auto &L : language_names) {
209 if (string.equals_insensitive(L.name))
210 return static_cast<LanguageType>(L.type);
211 }
212
214}
215
217 if (language < num_languages)
218 return language_names[language].name;
219 else
221}
222
224 llvm::StringRef prefix,
225 llvm::StringRef suffix) {
227 for (size_t idx = 0; idx < num_languages; ++idx) {
228 auto const &lang = language_names[idx];
229 if (supported[lang.type])
230 s << prefix << lang.name << suffix;
231 }
232}
233
234void Language::PrintAllLanguages(Stream &s, const char *prefix,
235 const char *suffix) {
236 for (uint32_t i = 1; i < num_languages; i++) {
237 s.Printf("%s%s%s", prefix, language_names[i].name, suffix);
238 }
239}
240
242 std::function<bool(lldb::LanguageType)> callback) {
243 for (uint32_t i = 1; i < num_languages; i++) {
244 if (!callback(language_names[i].type))
245 break;
246 }
247}
248
250 switch (language) {
256 return true;
257 default:
258 return false;
259 }
260}
261
263 switch (language) {
266 return true;
267 default:
268 return false;
269 }
270}
271
273 switch (language) {
274 case eLanguageTypeC:
275 case eLanguageTypeC89:
276 case eLanguageTypeC99:
277 case eLanguageTypeC11:
278 return true;
279 default:
280 return false;
281 }
282}
283
285 switch (language) {
286 case eLanguageTypeC:
287 case eLanguageTypeC89:
288 case eLanguageTypeC99:
289 case eLanguageTypeC11:
296 return true;
297 default:
298 return false;
299 }
300}
301
303 switch (language) {
305 return true;
306 default:
307 return false;
308 }
309}
310
312 switch (language) {
318 case eLanguageTypeC:
319 case eLanguageTypeC89:
320 case eLanguageTypeC99:
321 case eLanguageTypeC11:
322 return eLanguageTypeC;
325 return eLanguageTypeObjC;
338 case eLanguageTypePLI:
339 case eLanguageTypeUPC:
340 case eLanguageTypeD:
343 case eLanguageTypeGo:
353 default:
354 return language;
355 }
356}
357
358std::set<lldb::LanguageType> Language::GetSupportedLanguages() {
359 std::set<lldb::LanguageType> supported_languages;
360 ForEach([&](Language *lang) {
361 supported_languages.emplace(lang->GetLanguageType());
362 return true;
363 });
364 return supported_languages;
365}
366
369}
370
373}
374
377}
378
379std::unique_ptr<Language::TypeScavenger> Language::GetTypeScavenger() {
380 return nullptr;
381}
382
383const char *Language::GetLanguageSpecificTypeLookupHelp() { return nullptr; }
384
386 const char *key, ResultSet &results,
387 bool append) {
388 if (!exe_scope || !exe_scope->CalculateTarget().get())
389 return false;
390
391 if (!key || !key[0])
392 return false;
393
394 if (!append)
395 results.clear();
396
397 size_t old_size = results.size();
398
399 if (this->Find_Impl(exe_scope, key, results))
400 return results.size() - old_size;
401 return 0;
402}
403
405 ExecutionContextScope *exe_scope, const char *key, ResultSet &results) {
406 bool result = false;
407
408 Target *target = exe_scope->CalculateTarget().get();
409 if (target) {
410 const auto &images(target->GetImages());
411 ConstString cs_key(key);
412 llvm::DenseSet<SymbolFile *> searched_sym_files;
413 TypeList matches;
414 images.FindTypes(nullptr, cs_key, false, UINT32_MAX, searched_sym_files,
415 matches);
416 for (const auto &match : matches.Types()) {
417 if (match) {
418 CompilerType compiler_type(match->GetFullCompilerType());
419 compiler_type = AdjustForInclusion(compiler_type);
420 if (!compiler_type)
421 continue;
422 std::unique_ptr<Language::TypeScavenger::Result> scavengeresult(
423 new Result(compiler_type));
424 results.insert(std::move(scavengeresult));
425 result = true;
426 }
427 }
428 }
429
430 return result;
431}
432
434 ConstString type_hint,
435 std::string &prefix,
436 std::string &suffix) {
437 return false;
438}
439
440bool Language::DemangledNameContainsPath(llvm::StringRef path,
441 ConstString demangled) const {
442 // The base implementation does a simple contains comparision:
443 if (path.empty())
444 return false;
445 return demangled.GetStringRef().contains(path);
446}
447
449 return nullptr;
450}
451
453 return eLazyBoolCalculate;
454}
455
456bool Language::IsNilReference(ValueObject &valobj) { return false; }
457
458bool Language::IsUninitializedReference(ValueObject &valobj) { return false; }
459
461 const ExecutionContext *exe_ctx,
462 FunctionNameRepresentation representation,
463 Stream &s) {
464 return false;
465}
466
467void Language::GetExceptionResolverDescription(bool catch_on, bool throw_on,
468 Stream &s) {
469 GetDefaultExceptionResolverDescription(catch_on, throw_on, s);
470}
471
473 bool throw_on,
474 Stream &s) {
475 s.Printf("Exception breakpoint (catch: %s throw: %s)",
476 catch_on ? "on" : "off", throw_on ? "on" : "off");
477}
478// Constructor
479Language::Language() = default;
480
481// Destructor
482Language::~Language() = default;
static llvm::raw_ostream & error(Stream &strm)
struct language_name_pair language_names[]
Definition: Language.cpp:158
std::map< lldb::LanguageType, LanguageUP > LanguagesMap
Definition: Language.cpp:28
static LanguagesMap & GetLanguagesMap()
Definition: Language.cpp:30
static uint32_t num_languages
Definition: Language.cpp:204
static std::mutex & GetLanguagesMutex()
Definition: Language.cpp:41
std::unique_ptr< Language > LanguageUP
Definition: Language.cpp:27
Generic representation of a type in a programming language.
Definition: CompilerType.h:36
A uniqued constant string class.
Definition: ConstString.h:39
llvm::StringRef GetStringRef() const
Get the string value as a llvm::StringRef.
Definition: ConstString.h:201
std::function< bool(ConstString, ConstString, const DumpValueObjectOptions &, Stream &)> DeclPrintingHelper
"lldb/Target/ExecutionContextScope.h" Inherit from this if your object can reconstruct its execution ...
virtual lldb::TargetSP CalculateTarget()=0
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
A class that describes a function.
Definition: Function.h:409
HardcodedFormatterFinders< SyntheticChildren > HardcodedSyntheticFinder
Definition: FormatClasses.h:42
HardcodedFormatterFinders< TypeSummaryImpl > HardcodedSummaryFinder
Definition: FormatClasses.h:41
HardcodedFormatterFinders< TypeFormatImpl > HardcodedFormatFinder
Definition: FormatClasses.h:40
bool Find_Impl(ExecutionContextScope *exe_scope, const char *key, ResultSet &results) override
Definition: Language.cpp:404
std::set< std::unique_ptr< Result > > ResultSet
Definition: Language.h:43
virtual bool Find_Impl(ExecutionContextScope *exe_scope, const char *key, ResultSet &results)=0
size_t Find(ExecutionContextScope *exe_scope, const char *key, ResultSet &results, bool append=true)
Definition: Language.cpp:385
virtual bool IsSourceFile(llvm::StringRef file_path) const =0
static void PrintSupportedLanguagesForExpressions(Stream &s, llvm::StringRef prefix, llvm::StringRef suffix)
Prints to the specified stream 's' each language type that the current target supports for expression...
Definition: Language.cpp:223
static LanguageSet GetLanguagesSupportingREPLs()
Definition: Language.cpp:375
static LanguageSet GetLanguagesSupportingTypeSystems()
Definition: Language.cpp:367
virtual std::vector< FormattersMatchCandidate > GetPossibleFormattersMatches(ValueObject &valobj, lldb::DynamicValueType use_dynamic)
Definition: Language.cpp:148
virtual lldb::TypeCategoryImplSP GetFormatters()
Definition: Language.cpp:132
static Language * FindPlugin(lldb::LanguageType language)
Definition: Language.cpp:53
static const char * GetNameForLanguageType(lldb::LanguageType language)
Definition: Language.cpp:216
virtual DumpValueObjectOptions::DeclPrintingHelper GetDeclPrintingHelper()
Definition: Language.cpp:448
virtual LazyBool IsLogicalTrue(ValueObject &valobj, Status &error)
Definition: Language.cpp:452
virtual const char * GetLanguageSpecificTypeLookupHelp()
Definition: Language.cpp:383
static bool LanguageIsC(lldb::LanguageType language)
Definition: Language.cpp:272
virtual lldb::LanguageType GetLanguageType() const =0
virtual HardcodedFormatters::HardcodedSummaryFinder GetHardcodedSummaries()
Definition: Language.cpp:138
static void GetDefaultExceptionResolverDescription(bool catch_on, bool throw_on, Stream &s)
Definition: Language.cpp:472
virtual bool DemangledNameContainsPath(llvm::StringRef path, ConstString demangled) const
Definition: Language.cpp:440
static bool LanguageIsCPlusPlus(lldb::LanguageType language)
Definition: Language.cpp:249
static lldb::LanguageType GetPrimaryLanguage(lldb::LanguageType language)
Definition: Language.cpp:311
static bool LanguageIsPascal(lldb::LanguageType language)
Definition: Language.cpp:302
virtual bool IsNilReference(ValueObject &valobj)
Definition: Language.cpp:456
static void ForAllLanguages(std::function< bool(lldb::LanguageType)> callback)
Definition: Language.cpp:241
virtual bool IsUninitializedReference(ValueObject &valobj)
Definition: Language.cpp:458
virtual bool GetFunctionDisplayName(const SymbolContext *sc, const ExecutionContext *exe_ctx, FunctionNameRepresentation representation, Stream &s)
Definition: Language.cpp:460
static void PrintAllLanguages(Stream &s, const char *prefix, const char *suffix)
Definition: Language.cpp:234
virtual HardcodedFormatters::HardcodedSyntheticFinder GetHardcodedSynthetics()
Definition: Language.cpp:143
virtual std::unique_ptr< TypeScavenger > GetTypeScavenger()
Definition: Language.cpp:379
static LanguageSet GetLanguagesSupportingTypeSystemsForExpressions()
Definition: Language.cpp:371
virtual bool IsTopLevelFunction(Function &function)
Definition: Language.cpp:130
virtual void GetExceptionResolverDescription(bool catch_on, bool throw_on, Stream &s)
Definition: Language.cpp:467
static lldb::LanguageType GetLanguageTypeFromString(const char *string)=delete
static void ForEach(std::function< bool(Language *)> callback)
Definition: Language.cpp:100
static bool LanguageIsCFamily(lldb::LanguageType language)
Equivalent to LanguageIsC||LanguageIsObjC||LanguageIsCPlusPlus.
Definition: Language.cpp:284
static std::set< lldb::LanguageType > GetSupportedLanguages()
Definition: Language.cpp:358
virtual HardcodedFormatters::HardcodedFormatFinder GetHardcodedFormats()
Definition: Language.cpp:134
virtual bool GetFormatterPrefixSuffix(ValueObject &valobj, ConstString type_hint, std::string &prefix, std::string &suffix)
Definition: Language.cpp:433
static bool LanguageIsObjC(lldb::LanguageType language)
Definition: Language.cpp:262
static LanguageSet GetAllTypeSystemSupportedLanguagesForExpressions()
static LanguageSet GetREPLAllTypeSystemSupportedLanguages()
static LanguageCreateInstance GetLanguageCreateCallbackAtIndex(uint32_t idx)
static LanguageSet GetAllTypeSystemSupportedLanguagesForTypes()
An error handling class.
Definition: Status.h:44
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:107
Defines a symbol context baton that can be handed other debug core functions.
Definition: SymbolContext.h:33
const ModuleList & GetImages() const
Get accessor for the images for this process.
Definition: Target.h:948
TypeList FindTypes(ConstString name)
TypeIterable Types()
Definition: TypeList.h:45
#define UINT32_MAX
Definition: lldb-defines.h:19
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
Definition: SBAddress.h:15
LanguageType
Programming language type.
@ eLanguageTypeC_plus_plus_14
ISO C++:2014.
@ eLanguageTypeHaskell
Haskell.
@ eLanguageTypePLI
ANSI PL/I:1976.
@ eLanguageTypeC11
ISO C:2011.
@ eLanguageTypeJava
Java.
@ eLanguageTypeFortran08
ISO Fortran 2008.
@ eLanguageTypeC99
ISO C:1999.
@ eLanguageTypePascal83
ISO Pascal:1983.
@ eLanguageTypeModula3
Modula 3.
@ eLanguageTypeModula2
ISO Modula-2:1996.
@ eLanguageTypeOCaml
OCaml.
@ eLanguageTypeMipsAssembler
Mips_Assembler.
@ eLanguageTypeC_plus_plus_03
ISO C++:2003.
@ eLanguageTypeUnknown
Unknown or invalid language value.
@ eLanguageTypeRust
Rust.
@ eLanguageTypeFortran95
ISO Fortran 95.
@ eLanguageTypeObjC_plus_plus
Objective-C++.
@ eLanguageTypeC_plus_plus_11
ISO C++:2011.
@ eNumLanguageTypes
@ eLanguageTypeSwift
Swift.
@ eLanguageTypeC89
ISO C:1989.
@ eLanguageTypeAda83
ISO Ada:1983.
@ eLanguageTypeJulia
Julia.
@ eLanguageTypeGo
Go.
@ eLanguageTypeFortran77
ISO Fortran 77.
@ eLanguageTypeCobol85
ISO Cobol:1985.
@ eLanguageTypeUPC
Unified Parallel C.
@ eLanguageTypeC
Non-standardized C, such as K&R.
@ eLanguageTypeAda95
ISO Ada:1995.
@ eLanguageTypeCobol74
ISO Cobol:1974.
@ eLanguageTypePython
Python.
@ eLanguageTypeOpenCL
OpenCL.
@ eLanguageTypeD
D.
@ eLanguageTypeFortran90
ISO Fortran 90.
@ eLanguageTypeObjC
Objective-C.
@ eLanguageTypeC_plus_plus
ISO C++:1998.
@ eLanguageTypeDylan
Dylan.
@ eLanguageTypeFortran03
ISO Fortran 2003.
LanguageType type
Definition: Language.cpp:155
const char * name
Definition: Language.cpp:154
A SmallBitVector that represents a set of source languages (lldb::LanguageType).
Definition: TypeSystem.h:45