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 <array>
10#include <atomic>
11#include <functional>
12#include <map>
13#include <mutex>
14
16
21#include "lldb/Target/Target.h"
22#include "lldb/Utility/Stream.h"
24
25#include "llvm/ADT/StringSet.h"
26#include "llvm/BinaryFormat/Dwarf.h"
27#include "llvm/Support/Threading.h"
28#include "llvm/Support/raw_ostream.h"
29
30using namespace lldb;
31using namespace lldb_private;
32using namespace lldb_private::formatters;
33
34typedef std::unique_ptr<Language> LanguageUP;
35typedef std::map<lldb::LanguageType, LanguageUP> LanguagesMap;
36
37#define LLDB_PROPERTIES_language
38#include "TargetProperties.inc"
39
40enum {
41#define LLDB_PROPERTIES_language
42#include "TargetPropertiesEnum.inc"
43};
44
46 static LanguageProperties g_settings;
47 return g_settings;
48}
49
51 static constexpr llvm::StringLiteral g_setting_name("language");
52 return g_setting_name;
53}
54
56 m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
57 m_collection_sp->Initialize(g_language_properties_def);
58}
59
61 const uint32_t idx = ePropertyEnableFilterForLineBreakpoints;
63 idx, g_language_properties[idx].default_uint_value != 0);
64}
65
67 static LanguagesMap *g_map = nullptr;
68 static llvm::once_flag g_initialize;
69
70 llvm::call_once(g_initialize, [] {
71 g_map = new LanguagesMap(); // NOTE: INTENTIONAL LEAK due to global
72 // destructor chain
73 });
74
75 return *g_map;
76}
77static std::mutex &GetLanguagesMutex() {
78 static std::mutex *g_mutex = nullptr;
79 static llvm::once_flag g_initialize;
80
81 llvm::call_once(g_initialize, [] {
82 g_mutex = new std::mutex(); // NOTE: INTENTIONAL LEAK due to global
83 // destructor chain
84 });
85
86 return *g_mutex;
87}
88
90 std::lock_guard<std::mutex> guard(GetLanguagesMutex());
92 auto iter = map.find(language), end = map.end();
93 if (iter != end)
94 return iter->second.get();
95
96 Language *language_ptr = nullptr;
97
98 for (auto create_callback : PluginManager::GetLanguageCreateCallbacks()) {
99 language_ptr = create_callback(language);
100
101 if (language_ptr) {
102 map[language] = std::unique_ptr<Language>(language_ptr);
103 return language_ptr;
104 }
105 }
106
107 return nullptr;
108}
109
110Language *Language::FindPlugin(llvm::StringRef file_path) {
111 Language *result = nullptr;
112 ForEach([&result, file_path](Language *language) {
113 if (language->IsSourceFile(file_path)) {
114 result = language;
116 }
118 });
119 return result;
120}
121
123 llvm::StringRef file_path) {
124 Language *result = FindPlugin(language);
125 // Finding a language by file path is slower, we so we use this as the
126 // fallback.
127 if (!result)
128 result = FindPlugin(file_path);
129 return result;
130}
131
132Language *
134 // Mangled calls this for every name it demangles, so avoid the lock in
135 // FindPlugin(). Language instances are never destroyed, and the language of
136 // a scheme never changes, so the plugin can be cached once it's found.
137 static std::array<std::atomic<Language *>, Mangled::g_num_mangling_schemes>
138 g_plugins;
139 if (scheme >= g_plugins.size())
140 return nullptr;
141 if (Language *language = g_plugins[scheme].load(std::memory_order_acquire))
142 return language;
143
144 lldb::LanguageType language_type =
146 if (language_type == eLanguageTypeUnknown)
147 return nullptr;
148 Language *language = FindPlugin(language_type);
149 if (language)
150 g_plugins[scheme].store(language, std::memory_order_release);
151 return language;
152}
153
155 llvm::function_ref<IterationAction(Language *)> callback) {
156 // If we want to iterate over all languages, we first have to complete the
157 // LanguagesMap.
158 static llvm::once_flag g_initialize;
159 llvm::call_once(g_initialize, [] {
160 for (unsigned lang = eLanguageTypeUnknown; lang < eNumLanguageTypes;
161 ++lang) {
162 FindPlugin(static_cast<lldb::LanguageType>(lang));
163 }
164 });
165
166 // callback may call a method in Language that attempts to acquire the same
167 // lock (such as Language::ForEach or Language::FindPlugin). To avoid a
168 // deadlock, we do not use callback while holding the lock.
169 std::vector<Language *> loaded_plugins;
170 {
171 std::lock_guard<std::mutex> guard(GetLanguagesMutex());
173 for (const auto &entry : map) {
174 if (entry.second)
175 loaded_plugins.push_back(entry.second.get());
176 }
177 }
178
179 for (auto *lang : loaded_plugins) {
180 if (callback(lang) == IterationAction::Stop)
181 break;
182 }
183}
184
186 std::string version;
187 llvm::raw_string_ostream os(version);
189 llvm::StringSet<> plugin_names;
190 ForEach([&](Language *language) {
191 if (!plugin_names.insert(language->GetPluginName()).second)
193 std::string info = language->GetVersionInfo();
194 if (!info.empty())
195 os << '\n' << info;
197 });
198 return version;
199}
200
201llvm::Expected<LanguageType>
204 LanguageType exception_language = eLanguageTypeUnknown;
205
206 llvm::StringRef error_context;
207 switch (language) {
208 case eLanguageTypeC89:
209 case eLanguageTypeC:
210 case eLanguageTypeC99:
211 case eLanguageTypeC11:
212 exception_language = eLanguageTypeC;
213 break;
218 exception_language = eLanguageTypeC_plus_plus;
219 break;
221 error_context =
222 "Set exception breakpoints separately for c++ and objective-c";
223 break;
225 error_context = "Unknown language type for exception breakpoint";
226 break;
227 default:
228 if (Language *languagePlugin = Language::FindPlugin(language)) {
229 if (languagePlugin->SupportsExceptionBreakpointsOnThrow() ||
230 languagePlugin->SupportsExceptionBreakpointsOnCatch()) {
231 exception_language = language;
232 break;
233 }
234 }
235 error_context = "Unsupported language type for exception breakpoint";
236 }
237 if (!error_context.empty())
238 return llvm::createStringError(llvm::inconvertibleErrorCode(),
239 error_context);
240 return exception_language;
241}
242
243bool Language::IsTopLevelFunction(Function &function) { return false; }
244
246
250
254
257 return {};
258}
259
260std::vector<FormattersMatchCandidate>
262 lldb::DynamicValueType use_dynamic) {
263 return {};
264}
265
270
272 // To allow GetNameForLanguageType to be a simple array lookup, the first
273 // part of this array must follow enum LanguageType exactly.
274 {"unknown", eLanguageTypeUnknown},
275 {"c89", eLanguageTypeC89},
276 {"c", eLanguageTypeC},
277 {"ada83", eLanguageTypeAda83},
279 {"cobol74", eLanguageTypeCobol74},
280 {"cobol85", eLanguageTypeCobol85},
281 {"fortran77", eLanguageTypeFortran77},
282 {"fortran90", eLanguageTypeFortran90},
283 {"pascal83", eLanguageTypePascal83},
284 {"modula2", eLanguageTypeModula2},
285 {"java", eLanguageTypeJava},
286 {"c99", eLanguageTypeC99},
287 {"ada95", eLanguageTypeAda95},
288 {"fortran95", eLanguageTypeFortran95},
289 {"pli", eLanguageTypePLI},
290 {"objective-c", eLanguageTypeObjC},
291 {"objective-c++", eLanguageTypeObjC_plus_plus},
292 {"upc", eLanguageTypeUPC},
293 {"d", eLanguageTypeD},
294 {"python", eLanguageTypePython},
295 {"opencl", eLanguageTypeOpenCL},
296 {"go", eLanguageTypeGo},
297 {"modula3", eLanguageTypeModula3},
298 {"haskell", eLanguageTypeHaskell},
301 {"ocaml", eLanguageTypeOCaml},
302 {"rust", eLanguageTypeRust},
303 {"c11", eLanguageTypeC11},
304 {"swift", eLanguageTypeSwift},
305 {"julia", eLanguageTypeJulia},
306 {"dylan", eLanguageTypeDylan},
308 {"fortran03", eLanguageTypeFortran03},
309 {"fortran08", eLanguageTypeFortran08},
310 {"renderscript", eLanguageTypeRenderScript},
311 {"bliss", eLanguageTypeBLISS},
312 {"kotlin", eLanguageTypeKotlin},
313 {"zig", eLanguageTypeZig},
314 {"crystal", eLanguageTypeCrystal},
315 {"<invalid language>",
316 static_cast<LanguageType>(
317 0x0029)}, // Not yet taken by any language in the DWARF spec
318 // and thus has no entry in LanguageType
321 {"c17", eLanguageTypeC17},
322 {"fortran18", eLanguageTypeFortran18},
323 {"ada2005", eLanguageTypeAda2005},
324 {"ada2012", eLanguageTypeAda2012},
325 {"HIP", eLanguageTypeHIP},
326 {"assembly", eLanguageTypeAssembly},
327 {"c-sharp", eLanguageTypeC_sharp},
328 {"mojo", eLanguageTypeMojo},
329 // Vendor Extensions
330 {"assembler", eLanguageTypeMipsAssembler},
331 // Now synonyms, in arbitrary order
332 {"objc", eLanguageTypeObjC},
333 {"objc++", eLanguageTypeObjC_plus_plus},
334 {"pascal", eLanguageTypePascal83}};
335
336static uint32_t num_languages =
337 sizeof(language_names) / sizeof(struct language_name_pair);
338
340 for (const auto &L : language_names) {
341 if (string.equals_insensitive(L.name))
342 return L.type;
343 }
344
346}
347
349 if (language < num_languages)
350 return language_names[language].name;
351 else
353}
354
356 return SourceLanguage(language).GetDescription();
357}
358
360 llvm::StringRef prefix,
361 llvm::StringRef suffix) {
363 for (size_t idx = 0; idx < num_languages; ++idx) {
364 auto const &lang = language_names[idx];
365 if (supported[lang.type])
366 s << prefix << lang.name << suffix;
367 }
368}
369
370void Language::PrintAllLanguages(Stream &s, const char *prefix,
371 const char *suffix) {
372 for (uint32_t i = 1; i < num_languages; i++) {
373 s.Printf("%s%s%s", prefix, language_names[i].name, suffix);
374 }
375}
376
378 llvm::function_ref<IterationAction(lldb::LanguageType)> callback) {
379 for (uint32_t i = 1; i < num_languages; i++) {
380 if (callback(language_names[i].type) == IterationAction::Stop)
381 break;
382 }
383}
384
386 switch (language) {
394 return true;
395 default:
396 return false;
397 }
398}
399
401 switch (language) {
404 return true;
405 default:
406 return false;
407 }
408}
409
411 switch (language) {
412 case eLanguageTypeC:
413 case eLanguageTypeC89:
414 case eLanguageTypeC99:
415 case eLanguageTypeC11:
416 return true;
417 default:
418 return false;
419 }
420}
421
423 switch (language) {
424 case eLanguageTypeC:
425 case eLanguageTypeC89:
426 case eLanguageTypeC99:
427 case eLanguageTypeC11:
436 return true;
437 default:
438 return false;
439 }
440}
441
443 switch (language) {
450 return true;
451 default:
452 return false;
453 }
454}
455
457 switch (language) {
459 return true;
460 default:
461 return false;
462 }
463}
464
514
515std::set<lldb::LanguageType> Language::GetSupportedLanguages() {
516 std::set<lldb::LanguageType> supported_languages;
517 ForEach([&](Language *lang) {
518 supported_languages.emplace(lang->GetLanguageType());
520 });
521 return supported_languages;
522}
523
527
531
535
536std::unique_ptr<Language::TypeScavenger> Language::GetTypeScavenger() {
537 return nullptr;
538}
539
540const char *Language::GetLanguageSpecificTypeLookupHelp() { return nullptr; }
541
543 const char *key, ResultSet &results,
544 bool append) {
545 if (!exe_scope || !exe_scope->CalculateTarget().get())
546 return false;
547
548 if (!key || !key[0])
549 return false;
550
551 if (!append)
552 results.clear();
553
554 size_t old_size = results.size();
555
556 if (this->Find_Impl(exe_scope, key, results))
557 return results.size() - old_size;
558 return 0;
559}
560
562 ExecutionContextScope *exe_scope, const char *key, ResultSet &results) {
563 bool result = false;
564
565 Target *target = exe_scope->CalculateTarget().get();
566 if (target) {
567 const auto &images(target->GetImages());
568 TypeQuery query(key);
569 TypeResults type_results;
570 images.FindTypes(nullptr, query, type_results);
571 for (const auto &match : type_results.GetTypeMap().Types()) {
572 if (match) {
573 CompilerType compiler_type(match->GetFullCompilerType());
574 compiler_type = AdjustForInclusion(compiler_type);
575 if (!compiler_type)
576 continue;
577 std::unique_ptr<Language::TypeScavenger::Result> scavengeresult(
578 new Result(compiler_type));
579 results.insert(std::move(scavengeresult));
580 result = true;
581 }
582 }
583 }
584
585 return result;
586}
587
588std::pair<llvm::StringRef, llvm::StringRef>
589Language::GetFormatterPrefixSuffix(llvm::StringRef type_hint) {
590 return std::pair<llvm::StringRef, llvm::StringRef>();
591}
592
593bool Language::DemangledNameContainsPath(llvm::StringRef path,
594 ConstString demangled) const {
595 // The base implementation does a simple contains comparision:
596 if (path.empty())
597 return false;
598 return demangled.GetStringRef().contains(path);
599}
600
604
608
609bool Language::IsNilReference(ValueObject &valobj) { return false; }
610
611bool Language::IsUninitializedReference(ValueObject &valobj) { return false; }
612
614 const ExecutionContext *exe_ctx,
615 FunctionNameRepresentation representation,
616 Stream &s) {
617 return false;
618}
619
620void Language::GetExceptionResolverDescription(bool catch_on, bool throw_on,
621 Stream &s) {
622 GetDefaultExceptionResolverDescription(catch_on, throw_on, s);
623}
624
626 bool throw_on,
627 Stream &s) {
628 s.Printf("Exception breakpoint (catch: %s throw: %s)",
629 catch_on ? "on" : "off", throw_on ? "on" : "off");
630}
631
632std::optional<bool> Language::GetBooleanFromString(llvm::StringRef str) const {
633 return llvm::StringSwitch<std::optional<bool>>(str)
634 .Case("true", {true})
635 .Case("false", {false})
636 .Default({});
637}
638
639// Constructor
640Language::Language() = default;
641
642// Destructor
643Language::~Language() = default;
644
645static std::optional<llvm::dwarf::SourceLanguage>
647 if (language_type <= lldb::eLanguageTypeLastStandardLanguage)
648 return static_cast<llvm::dwarf::SourceLanguage>(language_type);
649
650 switch (language_type) {
652 return llvm::dwarf::DW_LANG_Mips_Assembler;
653 default:
654 return std::nullopt;
655 }
656}
657
659 std::optional<llvm::dwarf::SourceLanguage> dwarf_lang =
660 ToDwarfSourceLanguage(language_type);
661 if (!dwarf_lang)
662 return;
663
664 auto lname = llvm::dwarf::toDW_LNAME(*dwarf_lang);
665 if (!lname)
666 return;
667 name = lname->first;
668 version = lname->second;
669}
670
672 if (auto lang = llvm::dwarf::toDW_LANG((llvm::dwarf::SourceLanguageName)name,
673 version))
674 return (lldb::LanguageType)*lang;
676}
677
678llvm::StringRef SourceLanguage::GetDescription() const {
679 return llvm::dwarf::LanguageDescription(
680 static_cast<llvm::dwarf::SourceLanguageName>(name), version);
681}
682bool SourceLanguage::IsC() const { return name == llvm::dwarf::DW_LNAME_C; }
683
685 return name == llvm::dwarf::DW_LNAME_ObjC;
686}
687
689 return name == llvm::dwarf::DW_LNAME_C_plus_plus;
690}
691
693 const lldb::LanguageType &language, llvm::raw_ostream &OS,
694 llvm::StringRef Options) {
696}
static llvm::raw_ostream & error(Stream &strm)
static std::optional< llvm::dwarf::SourceLanguage > ToDwarfSourceLanguage(lldb::LanguageType language_type)
Definition Language.cpp:646
struct language_name_pair language_names[]
Definition Language.cpp:271
std::map< lldb::LanguageType, LanguageUP > LanguagesMap
Definition Language.cpp:35
static LanguagesMap & GetLanguagesMap()
Definition Language.cpp:66
static uint32_t num_languages
Definition Language.cpp:336
static std::mutex & GetLanguagesMutex()
Definition Language.cpp:77
std::unique_ptr< Language > LanguageUP
Definition Language.cpp:34
Generic representation of a type in a programming language.
A uniqued constant string class.
Definition ConstString.h:40
llvm::StringRef GetStringRef() const
Get the string value as a llvm::StringRef.
std::function< bool(llvm::StringRef, llvm::StringRef, 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:386
HardcodedFormatterFinders< SyntheticChildren > HardcodedSyntheticFinder
HardcodedFormatterFinders< TypeSummaryImpl > HardcodedSummaryFinder
HardcodedFormatterFinders< TypeFormatImpl > HardcodedFormatFinder
static llvm::StringRef GetSettingName()
Definition Language.cpp:50
bool GetEnableFilterForLineBreakpoints() const
Definition Language.cpp:60
virtual CompilerType AdjustForInclusion(CompilerType &candidate)=0
bool Find_Impl(ExecutionContextScope *exe_scope, const char *key, ResultSet &results) override
Definition Language.cpp:561
std::set< std::unique_ptr< Result > > ResultSet
Definition Language.h:57
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:542
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:359
static LanguageSet GetLanguagesSupportingREPLs()
Definition Language.cpp:532
static LanguageSet GetLanguagesSupportingTypeSystems()
Definition Language.cpp:524
virtual std::optional< bool > GetBooleanFromString(llvm::StringRef str) const
Definition Language.cpp:632
static std::string GetVersionWithLanguageInfo()
Returns lldb_private::GetVersion(), followed by the GetVersionInfo() of each registered language plug...
Definition Language.cpp:185
virtual std::vector< FormattersMatchCandidate > GetPossibleFormattersMatches(ValueObject &valobj, lldb::DynamicValueType use_dynamic)
Definition Language.cpp:261
virtual lldb::TypeCategoryImplSP GetFormatters()
Definition Language.cpp:245
static void ForEach(llvm::function_ref< IterationAction(Language *)> callback)
Definition Language.cpp:154
static void ForAllLanguages(llvm::function_ref< IterationAction(lldb::LanguageType)> callback)
Definition Language.cpp:377
static Language * FindPlugin(lldb::LanguageType language)
Definition Language.cpp:89
static const char * GetNameForLanguageType(lldb::LanguageType language)
Returns the internal LLDB name for the specified language.
Definition Language.cpp:348
virtual DumpValueObjectOptions::DeclPrintingHelper GetDeclPrintingHelper()
Definition Language.cpp:601
static LanguageProperties & GetGlobalLanguageProperties()
Definition Language.cpp:45
virtual LazyBool IsLogicalTrue(ValueObject &valobj, Status &error)
Definition Language.cpp:605
virtual const char * GetLanguageSpecificTypeLookupHelp()
Definition Language.cpp:540
virtual bool GetFunctionDisplayName(const SymbolContext &sc, const ExecutionContext *exe_ctx, FunctionNameRepresentation representation, Stream &s)
Definition Language.cpp:613
virtual std::pair< llvm::StringRef, llvm::StringRef > GetFormatterPrefixSuffix(llvm::StringRef type_hint)
An individual data formatter may apply to several types and cross language boundaries.
Definition Language.cpp:589
virtual std::string GetVersionInfo() const
Returns text to append to LLDB's version string, such as the revisions of compilers embedded in this ...
Definition Language.h:567
static bool LanguageIsC(lldb::LanguageType language)
Definition Language.cpp:410
virtual lldb::LanguageType GetLanguageType() const =0
virtual HardcodedFormatters::HardcodedSummaryFinder GetHardcodedSummaries()
Definition Language.cpp:251
static void GetDefaultExceptionResolverDescription(bool catch_on, bool throw_on, Stream &s)
Definition Language.cpp:625
virtual bool DemangledNameContainsPath(llvm::StringRef path, ConstString demangled) const
Definition Language.cpp:593
static bool LanguageIsCPlusPlus(lldb::LanguageType language)
Definition Language.cpp:385
static llvm::StringRef GetDisplayNameForLanguageType(lldb::LanguageType language)
Returns a user-friendly name for the specified language.
Definition Language.cpp:355
static Language * FindPluginForManglingScheme(Mangled::ManglingScheme scheme)
Returns the Language that registered scheme with Mangled::RegisterManglingScheme(),...
Definition Language.cpp:133
static lldb::LanguageType GetPrimaryLanguage(lldb::LanguageType language)
Definition Language.cpp:465
static bool LanguageIsPascal(lldb::LanguageType language)
Definition Language.cpp:456
virtual bool IsNilReference(ValueObject &valobj)
Definition Language.cpp:609
virtual bool IsUninitializedReference(ValueObject &valobj)
Definition Language.cpp:611
static void PrintAllLanguages(Stream &s, const char *prefix, const char *suffix)
Definition Language.cpp:370
static llvm::Expected< lldb::LanguageType > GetExceptionLanguageForLanguage(llvm::StringRef lang_name)
Definition Language.cpp:202
virtual HardcodedFormatters::HardcodedSyntheticFinder GetHardcodedSynthetics()
Definition Language.cpp:256
virtual std::unique_ptr< TypeScavenger > GetTypeScavenger()
Definition Language.cpp:536
static bool LanguageIsFortran(lldb::LanguageType language)
Definition Language.cpp:442
static LanguageSet GetLanguagesSupportingTypeSystemsForExpressions()
Definition Language.cpp:528
virtual bool IsTopLevelFunction(Function &function)
Definition Language.cpp:243
virtual void GetExceptionResolverDescription(bool catch_on, bool throw_on, Stream &s)
Definition Language.cpp:620
static lldb::LanguageType GetLanguageTypeFromString(const char *string)=delete
static bool LanguageIsCFamily(lldb::LanguageType language)
Equivalent to LanguageIsC||LanguageIsObjC||LanguageIsCPlusPlus.
Definition Language.cpp:422
static std::set< lldb::LanguageType > GetSupportedLanguages()
Definition Language.cpp:515
virtual HardcodedFormatters::HardcodedFormatFinder GetHardcodedFormats()
Definition Language.cpp:247
static bool LanguageIsObjC(lldb::LanguageType language)
Definition Language.cpp:400
static constexpr size_t g_num_mangling_schemes
The number of possible mangling schemes, which sizes the tables that are indexed by ManglingScheme.
Definition Mangled.h:51
static lldb::LanguageType GetLanguageForManglingScheme(ManglingScheme scheme)
Returns the language that registered scheme, or eLanguageTypeUnknown if no language did.
Definition Mangled.cpp:174
A command line option parsing protocol class.
Definition Options.h:58
virtual llvm::StringRef GetPluginName()=0
static LanguageSet GetAllTypeSystemSupportedLanguagesForExpressions()
static LanguageSet GetREPLAllTypeSystemSupportedLanguages()
static LanguageSet GetAllTypeSystemSupportedLanguagesForTypes()
static llvm::SmallVector< LanguageCreateInstance > GetLanguageCreateCallbacks()
lldb::OptionValuePropertiesSP m_collection_sp
T GetPropertyAtIndexAs(uint32_t idx, T default_value, const ExecutionContext *exe_ctx=nullptr) const
An error handling class.
Definition Status.h:118
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:134
Defines a symbol context baton that can be handed other debug core functions.
const ModuleList & GetImages() const
Get accessor for the images for this process.
Definition Target.h:1283
TypeIterable Types() const
Definition TypeMap.h:47
A class that contains all state required for type lookups.
This class tracks the state and results of a TypeQuery.
A class that represents a running process on the host machine.
const char * GetVersion()
Retrieves a string representing the LLDB version, which includes the lldb version number,...
Definition Version.cpp:37
IterationAction
Useful for callbacks whose return type indicates whether to continue iteration or short-circuit.
LanguageType
Programming language type.
@ eLanguageTypeC_plus_plus_20
ISO C++:2020.
@ eLanguageTypeC_plus_plus_14
ISO C++:2014.
@ eLanguageTypeHaskell
Haskell.
@ eLanguageTypeRenderScript
@ eLanguageTypePLI
ANSI PL/I:1976.
@ eLanguageTypeC11
ISO C:2011.
@ eLanguageTypeJava
Java.
@ eLanguageTypeFortran08
ISO Fortran 2008.
@ eLanguageTypeFortran18
@ 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.
@ eLanguageTypeC_sharp
@ eLanguageTypeAda2012
@ eLanguageTypeC_plus_plus_17
ISO C++:2017.
@ eLanguageTypeCrystal
@ eLanguageTypeObjC_plus_plus
Objective-C++.
@ eLanguageTypeC_plus_plus_11
ISO C++:2011.
@ eLanguageTypeSwift
Swift.
@ eLanguageTypeC89
ISO C:1989.
@ eLanguageTypeAda83
ISO Ada:1983.
@ eLanguageTypeJulia
Julia.
@ eLanguageTypeGo
Go.
@ eLanguageTypeFortran77
ISO Fortran 77.
@ eLanguageTypeKotlin
@ 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.
@ eLanguageTypeAda2005
@ eLanguageTypeOpenCL
OpenCL.
@ eLanguageTypeAssembly
@ eLanguageTypeD
D.
@ eLanguageTypeFortran90
ISO Fortran 90.
@ eLanguageTypeObjC
Objective-C.
@ eLanguageTypeC_plus_plus
ISO C++:1998.
@ eLanguageTypeLastStandardLanguage
@ eLanguageTypeDylan
Dylan.
@ eLanguageTypeFortran03
ISO Fortran 2003.
std::shared_ptr< lldb_private::TypeCategoryImpl > TypeCategoryImplSP
LanguageType type
Definition Language.cpp:268
const char * name
Definition Language.cpp:267
A SmallBitVector that represents a set of source languages (lldb::LanguageType).
A type-erased pair of llvm::dwarf::SourceLanguageName and version.
lldb::LanguageType AsLanguageType() const
Definition Language.cpp:671
llvm::StringRef GetDescription() const
Definition Language.cpp:678
static void format(const lldb::LanguageType &language, llvm::raw_ostream &OS, llvm::StringRef Options)
Definition Language.cpp:692