13#include "lldb/Host/Config.h"
31#include "llvm/Support/MemoryBuffer.h"
64 return "Compact C Type Format Symbol Reader";
78 const SectionList *section_list = module_sp->GetSectionList();
95 LLDB_LOG(log,
"Parsing Compact C Type format for {0}", module_desc.
GetData());
100 constexpr size_t ctf_header_size =
sizeof(
ctf_header_t);
102 LLDB_LOG(log,
"CTF parsing failed: insufficient data for CTF header");
123 LLDB_LOG(log,
"CTF parsing failed: invalid magic: {0:x}",
129 LLDB_LOG(log,
"CTF parsing failed: unsupported version: {0}",
134 LLDB_LOG(log,
"Parsed valid CTF preamble: version {0}, flags {1:x}",
143 const std::size_t decompressed_size = ctf_header.
stroff + ctf_header.
strlen;
145 std::make_shared<DataBufferHeap>(decompressed_size, 0x0);
148 memset(&zstr, 0,
sizeof(zstr));
153 (Bytef *)
const_cast<uint8_t *
>(decompressed_data->GetBytes());
154 zstr.avail_out = decompressed_size;
156 int rc = inflateInit(&zstr);
158 LLDB_LOG(log,
"CTF parsing failed: inflate initialization error: {0}",
163 rc = inflate(&zstr, Z_FINISH);
164 if (rc != Z_STREAM_END) {
165 LLDB_LOG(log,
"CTF parsing failed: inflate error: {0}", zError(rc));
169 rc = inflateEnd(&zstr);
171 LLDB_LOG(log,
"CTF parsing failed: inflate end error: {0}", zError(rc));
175 if (zstr.total_out != decompressed_size) {
177 "CTF parsing failed: decompressed size ({0}) doesn't match "
178 "expected size ([1})",
179 zstr.total_out, decompressed_size);
189 "CTF parsing failed: data is compressed but no zlib inflate support");
197 "CTF parsing failed: invalid label section offset in header: {0}",
204 "CTF parsing failed: invalid object section offset in header: {0}",
212 "CTF parsing failed: invalid function section offset in header: {0}",
219 "CTF parsing failed: invalid type section offset in header: {0}",
226 "CTF parsing failed: invalid string section offset in header: {0}",
235 "CTF parsing failed: invalid string section length in header: {0}",
243 "CTF parsing failed: invalid parent label offset: {0} exceeds end "
244 "of string section ({1})",
245 ctf_header.
parlabel, str_end_offset);
251 "CTF parsing failed: invalid parent name offset: {0} exceeds end "
252 "of string section ({1})",
253 ctf_header.
parname, str_end_offset);
258 "Parsed valid CTF header: lbloff = {0}, objtoff = {1}, funcoff = "
259 "{2}, typeoff = {3}, stroff = {4}, strlen = {5}",
270 if (
auto err = type_system_or_err.takeError()) {
271 LLDB_LOG_ERROR(log, std::move(err),
"Unable to get type system: {0}");
275 auto ts = *type_system_or_err;
276 m_ast = llvm::dyn_cast_or_null<TypeSystemClang>(ts.get());
291 return llvm::StringRef(str);
297 return ((data)&0xff000000) >> 24;
303 return (data)&0x0000ffff;
309 return ((data)&0xf800) >> 11;
323 return clang::TagTypeKind::Struct;
325 return clang::TagTypeKind::Union;
328 return clang::TagTypeKind::Struct;
332llvm::Expected<TypeSP>
337 return llvm::make_error<llvm::StringError>(
338 llvm::formatv(
"unsupported integer type: no corresponding basic clang "
341 llvm::inconvertibleErrorCode());
347 bool compiler_type_is_signed =
false;
349 return llvm::make_error<llvm::StringError>(
351 "Found compiler type for '{0}' but it's not an integer type: {1}",
354 llvm::inconvertibleErrorCode());
358 if (compiler_type_is_signed != type_is_signed)
359 return llvm::make_error<llvm::StringError>(
360 llvm::formatv(
"Found integer compiler type for {0} but compiler type "
361 "is {1} and {0} is {2}",
363 compiler_type_is_signed ?
"signed" :
"unsigned",
364 type_is_signed ?
"signed" :
"unsigned"),
365 llvm::inconvertibleErrorCode());
375llvm::Expected<lldb::TypeSP>
379 return llvm::make_error<llvm::StringError>(
380 llvm::formatv(
"Could not find modified type: {0}", ctf_modifier.
type),
381 llvm::inconvertibleErrorCode());
385 switch (ctf_modifier.
kind) {
399 return llvm::make_error<llvm::StringError>(
400 llvm::formatv(
"ParseModifier called with unsupported kind: {0}",
402 llvm::inconvertibleErrorCode());
411llvm::Expected<lldb::TypeSP>
414 if (!underlying_type)
415 return llvm::make_error<llvm::StringError>(
416 llvm::formatv(
"Could not find typedef underlying type: {0}",
418 llvm::inconvertibleErrorCode());
431llvm::Expected<lldb::TypeSP>
435 return llvm::make_error<llvm::StringError>(
436 llvm::formatv(
"Could not find array element type: {0}", ctf_array.
type),
437 llvm::inconvertibleErrorCode());
439 std::optional<uint64_t> element_size = element_type->
GetByteSize(
nullptr);
441 return llvm::make_error<llvm::StringError>(
442 llvm::formatv(
"could not get element size of type: {0}",
444 llvm::inconvertibleErrorCode());
446 uint64_t size = ctf_array.
nelems * *element_size;
458llvm::Expected<lldb::TypeSP>
469 enum_type, value_decl, value.
name.data(), value.
value, ctf_enum.
size);
478llvm::Expected<lldb::TypeSP>
480 std::vector<CompilerType> arg_types;
481 for (uint32_t arg : ctf_function.
args) {
483 arg_types.push_back(arg_type->GetFullCompilerType());
488 return llvm::make_error<llvm::StringError>(
489 llvm::formatv(
"Could not find function return type: {0}",
491 llvm::inconvertibleErrorCode());
495 ctf_function.
variadic, 0, clang::CallingConv::CC_C);
503llvm::Expected<lldb::TypeSP>
522 const CTFType *ctf_type = it->second;
523 assert(ctf_type &&
"m_compiler_types should only contain valid CTF types");
526 assert(llvm::isa<CTFRecord>(ctf_type));
535 "Cannot complete type {0} because field {1} is incomplete",
545 assert(field_type &&
"field must be complete");
546 const uint32_t field_size = field_type->
GetByteSize(
nullptr).value_or(0);
561llvm::Expected<lldb::TypeSP>
574 return llvm::make_error<llvm::StringError>(
575 "cannot create type for unparsed type", llvm::inconvertibleErrorCode());
577 switch (ctf_type->
kind) {
601 return llvm::make_error<llvm::StringError>(
602 llvm::formatv(
"unsupported type (uid = {0}, name = {1}, kind = {2})",
604 llvm::inconvertibleErrorCode());
608llvm::Expected<std::unique_ptr<CTFType>>
617 const uint32_t variable_length =
GetVLen(ctf_stype.
info);
618 const uint32_t type = ctf_stype.
GetType();
619 const uint32_t size = ctf_stype.
GetSize();
626 return std::make_unique<CTFInteger>(uid, name,
bits, encoding);
629 return std::make_unique<CTFConst>(uid, type);
631 return std::make_unique<CTFPointer>(uid, type);
633 return std::make_unique<CTFRestrict>(uid, type);
635 return std::make_unique<CTFVolatile>(uid, type);
637 return std::make_unique<CTFTypedef>(uid, name, type);
642 return std::make_unique<CTFArray>(uid, name, type, index, nelems);
645 std::vector<CTFEnum::Value> values;
646 for (uint32_t i = 0; i < variable_length; ++i) {
649 values.emplace_back(
ReadString(value_name), value);
651 return std::make_unique<CTFEnum>(uid, name, variable_length, size, values);
654 std::vector<uint32_t> args;
655 bool variadic =
false;
656 for (uint32_t i = 0; i < variable_length; ++i) {
663 args.push_back(arg_uid);
667 if (variable_length % 2 == 1)
669 return std::make_unique<CTFFunction>(uid, name, variable_length, type, args,
674 std::vector<CTFRecord::Field> fields;
675 for (uint32_t i = 0; i < variable_length; ++i) {
678 uint64_t field_offset = 0;
685 field_offset = (((uint64_t)offset_hi) << 32) | ((uint64_t)offset_lo);
687 fields.emplace_back(
ReadString(field_name), type, field_offset);
689 return std::make_unique<CTFRecord>(
static_cast<CTFType::Kind>(kind), uid,
690 name, variable_length, size, fields);
693 return std::make_unique<CTFForward>(uid, name);
695 return std::make_unique<CTFType>(
static_cast<CTFType::Kind>(kind), uid,
699 offset += (variable_length *
sizeof(uint32_t));
703 return llvm::make_error<llvm::StringError>(
704 llvm::formatv(
"unsupported type (name = {0}, kind = {1}, vlength = {2})",
705 name, kind, variable_length),
706 llvm::inconvertibleErrorCode());
726 while (type_offset < type_offset_end) {
727 llvm::Expected<std::unique_ptr<CTFType>> type_or_error =
730 m_ctf_types[(*type_or_error)->uid] = std::move(*type_or_error);
733 "Failed to parse type {1} at offset {2}: {0}", type_uid,
764 LLDB_LOG(log,
"Parsing CTF functions");
769 uint32_t symbol_idx = 0;
771 while (function_offset < function_offset_end) {
773 const uint16_t kind =
GetKind(info);
774 const uint16_t variable_length =
GetVLen(info);
787 const uint32_t ret_uid =
m_data.
GetU32(&function_offset);
788 const uint32_t num_args = variable_length;
790 std::vector<CompilerType> arg_types;
791 arg_types.reserve(num_args);
793 bool is_variadic =
false;
794 for (uint32_t i = 0; i < variable_length; i++) {
795 const uint32_t arg_uid =
m_data.
GetU32(&function_offset);
816 is_variadic, 0, clang::CallingConv::CC_C);
822 m_types[function_type_uid] = type_sp;
826 FunctionSP function_sp = std::make_shared<Function>(
827 &cu, func_uid, function_type_uid, symbol->
GetMangled(), type_sp.get(),
844 const ArchSpec &architecture = module_sp->GetArchitecture();
850 stream.
PutHex8(lldb_private::dwarf::DW_OP_addr);
854 std::make_shared<DataBufferHeap>(stream.
GetData(), stream.
GetSize());
874 Symtab *symtab = module_sp->GetSymtab();
879 LLDB_LOG(log,
"Parsing CTF objects");
884 uint32_t symbol_idx = 0;
886 while (object_offset < object_offset_end) {
887 const uint32_t type_uid =
m_data.
GetU32(&object_offset);
893 ranges.
Append(symbol->GetFileAddress(), symbol->GetByteSize());
895 auto type_sp = std::make_shared<SymbolFileType>(*
this, type_uid);
901 m_variables.emplace_back(std::make_shared<Variable>(
902 variable_type_uid, symbol->GetName().AsCString(),
904 m_comp_unit_sp.get(), ranges, &decl, location, symbol->IsExternal(),
926 SymbolContextItem resolve_scope,
932 uint32_t resolved_flags = 0;
935 if (resolve_scope & eSymbolContextSymbol) {
939 resolved_flags |= eSymbolContextSymbol;
943 if (resolve_scope & eSymbolContextFunction) {
945 if (function_sp->GetAddressRange().ContainsFileAddress(
948 resolved_flags |= eSymbolContextFunction;
955 if (resolve_scope & eSymbolContextVariable) {
957 if (variable_sp->LocationIsValidForAddress(so_addr.
GetFileAddress())) {
964 return resolved_flags;
984 auto type_it =
m_types.find(type_uid);
986 return type_it->second.get();
992 CTFType *ctf_type = ctf_type_it->second.get();
993 assert(ctf_type &&
"m_ctf_types should only contain valid CTF types");
997 llvm::Expected<TypeSP> type_or_error =
CreateType(ctf_type);
998 if (!type_or_error) {
1000 "Failed to create type for {1}: {0}", ctf_type->
uid);
1004 TypeSP type_sp = *type_or_error;
1008 type_sp->Dump(&ss,
true);
1009 LLDB_LOGV(log,
"Adding type {0}: {1}", type_sp->GetID(),
1010 llvm::StringRef(ss.
GetString()).rtrim());
1017 if (!isa<CTFRecord>(ctf_type))
1020 return type_sp.get();
1026 uint32_t max_matches,
1027 llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
1030 searched_symbol_files.clear();
1031 searched_symbol_files.insert(
this);
1035 if (matches == max_matches)
1037 if (type_sp && type_sp->GetName() == name) {
1051 if (matches == max_matches)
1053 if (type_sp && regex.
Execute(type_sp->GetName()))
1067 if (function_sp && function_sp->GetName() == name) {
1077 bool include_inlines,
1080 if (function_sp && regex.
Execute(function_sp->GetName())) {
1097 if (matches == max_matches)
1099 if (variable_sp && variable_sp->GetName() == name) {
1113 if (matches == max_matches)
1115 if (variable_sp && regex.
Execute(variable_sp->GetName())) {
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
#define LLDB_LOG_ERROR(log, error,...)
#define LLDB_LOGV(log,...)
#define LLDB_PLUGIN_DEFINE(PluginName)
uint32_t GetKind(uint32_t data)
Return the type kind encoded in the given data.
static DWARFExpression CreateDWARFExpression(ModuleSP module_sp, const Symbol &symbol)
uint32_t GetVLen(uint32_t data)
Return the variable length encoded in the given data.
static clang::TagTypeKind TranslateRecordKind(CTFType::Kind type)
static uint32_t GetEncoding(uint32_t data)
Return the integer display representation encoded in the given data.
static uint32_t GetBits(uint32_t data)
Return the integral width in bits encoded in the given data.
static uint32_t GetBytes(uint32_t bits)
A section + offset based address range class.
A section + offset based address class.
lldb::addr_t GetFileAddress() const
Get the file address.
An architecture specification class.
uint32_t GetAddressByteSize() const
Returns the size in bytes of an address of the current architecture.
uint32_t GetDataByteSize() const
Architecture data byte width accessor.
lldb::ByteOrder GetByteOrder() const
Returns the byte order for the architecture specification.
A class that describes a compilation unit.
void AddFunction(lldb::FunctionSP &function_sp)
Add a function to this compile unit.
Represents a generic declaration context in a program.
Generic representation of a type in a programming language.
CompilerType AddConstModifier() const
Return a new CompilerType adds a const modifier to this type if this type is valid and the type syste...
ConstString GetDisplayTypeName() const
CompilerType GetPointerType() const
Return a new CompilerType that is a pointer to this type.
lldb::opaque_compiler_type_t GetOpaqueQualType() const
CompilerType AddVolatileModifier() const
Return a new CompilerType adds a volatile modifier to this type if this type is valid and the type sy...
CompilerType AddRestrictModifier() const
Return a new CompilerType adds a restrict modifier to this type if this type is valid and the type sy...
bool IsIntegerType(bool &is_signed) const
CompilerType CreateTypedef(const char *name, const CompilerDeclContext &decl_ctx, uint32_t payload) const
Create a typedef to this type using "name" as the name of the typedef this type is valid and the type...
A uniqued constant string class.
llvm::StringRef GetStringRef() const
Get the string value as a llvm::StringRef.
"lldb/Expression/DWARFExpressionList.h" Encapsulates a range map from file address range to a single ...
"lldb/Expression/DWARFExpression.h" Encapsulates a DWARF location expression and interprets it.
void SetRegisterKind(lldb::RegisterKind reg_kind)
Set the call-frame-info style register kind.
A class that describes the declaration location of a lldb object.
lldb::ModuleSP GetModule() const
Get const accessor for the module pointer.
A class that encapsulates name lookup information.
ConstString GetLookupName() const
static bool RegisterPlugin(llvm::StringRef name, llvm::StringRef description, ABICreateInstance create_callback)
static bool UnregisterPlugin(ABICreateInstance create_callback)
void Append(const Entry &entry)
bool Execute(llvm::StringRef string, llvm::SmallVectorImpl< llvm::StringRef > *matches=nullptr) const
Execute a regular expression match using the compiled regular expression that is already in this obje...
lldb::SectionSP FindSectionByType(lldb::SectionType sect_type, bool check_children, size_t start_idx=0) const
const char * GetData() const
const char * GetData() const
llvm::StringRef GetString() const
@ eBinary
Get and put data as binary instead of as the default string mode.
llvm::raw_ostream & AsRawOstream()
Returns a raw_ostream that forwards the data to this Stream object.
size_t size_t PutHex8(uint8_t uvalue)
Append an uint8_t value in the hexadecimal format to the stream.
size_t PutMaxHex64(uint64_t uvalue, size_t byte_size, lldb::ByteOrder byte_order=lldb::eByteOrderInvalid)
Defines a list of symbol context objects.
void Append(const SymbolContext &sc)
Append a new symbol context to the list.
Defines a symbol context baton that can be handed other debug core functions.
Function * function
The Function for a given query.
CompileUnit * comp_unit
The CompileUnit for a given query.
Variable * variable
The global variable matching the given query.
Symbol * symbol
The Symbol for a given query.
void FindTypesByRegex(const lldb_private::RegularExpression ®ex, uint32_t max_matches, lldb_private::TypeMap &types)
Type * ResolveTypeUID(lldb::user_id_t type_uid) override
static constexpr uint16_t g_ctf_magic
llvm::Expected< lldb::TypeSP > CreateFunction(const CTFFunction &ctf_function)
void AddSymbols(Symtab &symtab) override
bool CompleteType(CompilerType &compiler_type) override
lldb::CompUnitSP m_comp_unit_sp
std::vector< lldb::FunctionSP > m_functions
static char ID
LLVM RTTI support.
llvm::Expected< lldb::TypeSP > CreateTypedef(const CTFTypedef &ctf_typedef)
size_t ParseFunctions(CompileUnit &comp_unit) override
static llvm::StringRef GetPluginDescriptionStatic()
llvm::DenseMap< lldb::opaque_compiler_type_t, const CTFType * > m_compiler_types
To complete types, we need a way to map (imcomplete) compiler types back to parsed CTF types.
void FindFunctions(const lldb_private::Module::LookupInfo &lookup_info, const lldb_private::CompilerDeclContext &parent_decl_ctx, bool include_inlines, lldb_private::SymbolContextList &sc_list) override
llvm::Expected< lldb::TypeSP > CreateArray(const CTFArray &ctf_array)
uint32_t CalculateAbilities() override
size_t ParseVariablesForContext(const SymbolContext &sc) override
static lldb_private::SymbolFile * CreateInstance(lldb::ObjectFileSP objfile_sp)
lldb::offset_t m_body_offset
The start offset of the CTF body into m_data.
static constexpr uint16_t g_ctf_field_threshold
lldb::CompUnitSP ParseCompileUnitAtIndex(uint32_t index) override
static llvm::StringRef GetPluginNameStatic()
size_t ParseObjects(CompileUnit &comp_unit)
llvm::Expected< lldb::TypeSP > CreateForward(const CTFForward &ctf_forward)
llvm::Expected< lldb::TypeSP > CreateEnum(const CTFEnum &ctf_enum)
void InitializeObject() override
Initialize the SymbolFile object.
llvm::StringRef ReadString(lldb::offset_t offset) const
void FindTypes(lldb_private::ConstString name, const lldb_private::CompilerDeclContext &parent_decl_ctx, uint32_t max_matches, llvm::DenseSet< lldb_private::SymbolFile * > &searched_symbol_files, lldb_private::TypeMap &types) override
llvm::Expected< lldb::TypeSP > CreateRecord(const CTFRecord &ctf_record)
void FindGlobalVariables(lldb_private::ConstString name, const lldb_private::CompilerDeclContext &parent_decl_ctx, uint32_t max_matches, lldb_private::VariableList &variables) override
llvm::Expected< lldb::TypeSP > CreateInteger(const CTFInteger &ctf_integer)
static constexpr uint8_t g_ctf_version
llvm::DenseMap< lldb::user_id_t, lldb::TypeSP > m_types
Parsed LLDB types.
std::vector< lldb::VariableSP > m_variables
llvm::DenseMap< lldb::user_id_t, std::unique_ptr< CTFType > > m_ctf_types
Parsed CTF types.
llvm::Expected< lldb::TypeSP > CreateModifier(const CTFModifier &ctf_modifier)
llvm::Expected< lldb::TypeSP > CreateType(CTFType *ctf_type)
SymbolFileCTF(lldb::ObjectFileSP objfile_sp)
uint32_t ResolveSymbolContext(const lldb_private::Address &so_addr, lldb::SymbolContextItem resolve_scope, lldb_private::SymbolContext &sc) override
llvm::Expected< std::unique_ptr< CTFType > > ParseType(lldb::offset_t &offset, lldb::user_id_t uid)
std::optional< ctf_header_t > m_header
size_t ParseTypes(CompileUnit &cu) override
Containing protected virtual methods for child classes to override.
ObjectFile * GetObjectFile() override
virtual TypeList & GetTypeList()
lldb::ObjectFileSP m_objfile_sp
llvm::Expected< lldb::TypeSystemSP > GetTypeSystemForLanguage(lldb::LanguageType language) override
lldb::TypeSP MakeType(lldb::user_id_t uid, ConstString name, std::optional< uint64_t > byte_size, SymbolContextScope *context, lldb::user_id_t encoding_uid, Type::EncodingDataType encoding_uid_type, const Declaration &decl, const CompilerType &compiler_qual_type, Type::ResolveState compiler_type_resolve_state, uint32_t opaque_payload=0) override
This function is used to create types that belong to a SymbolFile.
Provides public interface for all SymbolFiles.
virtual std::recursive_mutex & GetModuleMutex() const
Symbols file subclasses should override this to return the Module that owns the TypeSystem that this ...
lldb::addr_t GetFileAddress() const
lldb::addr_t GetByteSize() const
ConstString GetName() const
Symbol * FindSymbolWithType(lldb::SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, uint32_t &start_idx)
void Insert(const lldb::TypeSP &type)
clang::TranslationUnitDecl * GetTranslationUnitDecl()
CompilerType GetBasicType(lldb::BasicType type)
static clang::FieldDecl * AddFieldToRecordType(const CompilerType &type, llvm::StringRef name, const CompilerType &field_type, lldb::AccessType access, uint32_t bitfield_bit_size)
static lldb::BasicType GetBasicTypeEnumeration(llvm::StringRef name)
CompilerDeclContext CreateDeclContext(clang::DeclContext *ctx)
Creates a CompilerDeclContext from the given DeclContext with the current TypeSystemClang instance as...
clang::EnumConstantDecl * AddEnumerationValueToEnumerationType(const CompilerType &enum_type, const Declaration &decl, const char *name, int64_t enum_value, uint32_t enum_value_bit_size)
static bool CompleteTagDeclarationDefinition(const CompilerType &type)
CompilerType CreateEnumerationType(llvm::StringRef name, clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module, const Declaration &decl, const CompilerType &integer_qual_type, bool is_scoped)
CompilerType CreateArrayType(const CompilerType &element_type, size_t element_count, bool is_vector)
static bool StartTagDeclarationDefinition(const CompilerType &type)
CompilerType CreateFunctionType(const CompilerType &result_type, const CompilerType *args, unsigned num_args, bool is_variadic, unsigned type_quals, clang::CallingConv cc=clang::CC_C, clang::RefQualifierKind ref_qual=clang::RQ_None)
CompilerType CreateRecordType(clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module, lldb::AccessType access_type, llvm::StringRef name, int kind, lldb::LanguageType language, ClangASTMetadata *metadata=nullptr, bool exports_symbols=false)
@ eEncodingIsUID
This type is the type whose UID is m_encoding_uid.
std::optional< uint64_t > GetByteSize(ExecutionContextScope *exe_scope)
CompilerType GetFullCompilerType()
void AddVariable(const lldb::VariableSP &var_sp)
A class that represents a running process on the host machine.
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
static uint32_t bits(const uint32_t val, const uint32_t msbit, const uint32_t lsbit)
std::shared_ptr< lldb_private::Function > FunctionSP
BasicType
Basic types enumeration for the public API SBType::GetBasicType().
std::shared_ptr< lldb_private::ObjectFile > ObjectFileSP
@ eLanguageTypeC
Non-standardized C, such as K&R.
std::shared_ptr< lldb_private::Type > TypeSP
ByteOrder
Byte ordering definitions.
std::shared_ptr< lldb_private::Variable > VariableSP
std::shared_ptr< lldb_private::DataBuffer > DataBufferSP
std::shared_ptr< lldb_private::Section > SectionSP
std::shared_ptr< lldb_private::Module > ModuleSP
std::shared_ptr< lldb_private::CompileUnit > CompUnitSP
@ eValueTypeVariableGlobal
globals variable
@ eRegisterKindDWARF
the register numbers seen DWARF
std::vector< Value > values
std::vector< uint32_t > args
std::vector< Field > fields