wangtao
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
llvm-project/lldb/source/Symbol/GoASTContext.cpp

1448 lines
46 KiB
C++
Raw Blame History

//===-- GoASTContext.cpp ----------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include <mutex>
#include <utility>
#include <vector>
#include "lldb/Core/DumpDataExtractor.h"
#include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h"
#include "lldb/Core/StreamFile.h"
#include "lldb/Core/UniqueCStringMap.h"
#include "lldb/Core/ValueObject.h"
#include "lldb/Symbol/CompilerType.h"
#include "lldb/Symbol/GoASTContext.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/SymbolFile.h"
#include "lldb/Symbol/Type.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Target.h"
#include "llvm/Support/Threading.h"
#include "Plugins/ExpressionParser/Go/GoUserExpression.h"
#include "Plugins/SymbolFile/DWARF/DWARFASTParserGo.h"
using namespace lldb;
namespace lldb_private {
class GoArray;
class GoFunction;
class GoStruct;
class GoType {
public:
enum {
KIND_BOOL = 1,
KIND_INT = 2,
KIND_INT8 = 3,
KIND_INT16 = 4,
KIND_INT32 = 5,
KIND_INT64 = 6,
KIND_UINT = 7,
KIND_UINT8 = 8,
KIND_UINT16 = 9,
KIND_UINT32 = 10,
KIND_UINT64 = 11,
KIND_UINTPTR = 12,
KIND_FLOAT32 = 13,
KIND_FLOAT64 = 14,
KIND_COMPLEX64 = 15,
KIND_COMPLEX128 = 16,
KIND_ARRAY = 17,
KIND_CHAN = 18,
KIND_FUNC = 19,
KIND_INTERFACE = 20,
KIND_MAP = 21,
KIND_PTR = 22,
KIND_SLICE = 23,
KIND_STRING = 24,
KIND_STRUCT = 25,
KIND_UNSAFEPOINTER = 26,
KIND_LLDB_VOID, // Extension for LLDB, not used by go runtime.
KIND_MASK = (1 << 5) - 1,
KIND_DIRECT_IFACE = 1 << 5
};
GoType(int kind, const ConstString &name)
: m_kind(kind & KIND_MASK), m_name(name) {
if (m_kind == KIND_FUNC)
m_kind = KIND_FUNC;
}
virtual ~GoType() {}
int GetGoKind() const { return m_kind; }
const ConstString &GetName() const { return m_name; }
virtual CompilerType GetElementType() const { return CompilerType(); }
bool IsTypedef() const {
switch (m_kind) {
case KIND_CHAN:
case KIND_MAP:
case KIND_INTERFACE:
return true;
default:
return false;
}
}
GoArray *GetArray();
GoFunction *GetFunction();
GoStruct *GetStruct();
private:
int m_kind;
ConstString m_name;
GoType(const GoType &) = delete;
const GoType &operator=(const GoType &) = delete;
};
class GoElem : public GoType {
public:
GoElem(int kind, const ConstString &name, const CompilerType &elem)
: GoType(kind, name), m_elem(elem) {}
virtual CompilerType GetElementType() const { return m_elem; }
private:
// TODO: should we store this differently?
CompilerType m_elem;
GoElem(const GoElem &) = delete;
const GoElem &operator=(const GoElem &) = delete;
};
class GoArray : public GoElem {
public:
GoArray(const ConstString &name, uint64_t length, const CompilerType &elem)
: GoElem(KIND_ARRAY, name, elem), m_length(length) {}
uint64_t GetLength() const { return m_length; }
private:
uint64_t m_length;
GoArray(const GoArray &) = delete;
const GoArray &operator=(const GoArray &) = delete;
};
class GoFunction : public GoType {
public:
GoFunction(const ConstString &name, bool is_variadic)
: GoType(KIND_FUNC, name), m_is_variadic(is_variadic) {}
bool IsVariadic() const { return m_is_variadic; }
private:
bool m_is_variadic;
GoFunction(const GoFunction &) = delete;
const GoFunction &operator=(const GoFunction &) = delete;
};
class GoStruct : public GoType {
public:
struct Field {
Field(const ConstString &name, const CompilerType &type, uint64_t offset)
: m_name(name), m_type(type), m_byte_offset(offset) {}
ConstString m_name;
CompilerType m_type;
uint64_t m_byte_offset;
};
GoStruct(int kind, const ConstString &name, int64_t byte_size)
: GoType(kind == 0 ? KIND_STRUCT : kind, name), m_is_complete(false),
m_byte_size(byte_size) {}
uint32_t GetNumFields() const { return m_fields.size(); }
const Field *GetField(uint32_t i) const {
if (i < m_fields.size())
return &m_fields[i];
return nullptr;
}
void AddField(const ConstString &name, const CompilerType &type,
uint64_t offset) {
m_fields.push_back(Field(name, type, offset));
}
bool IsComplete() const { return m_is_complete; }
void SetComplete() { m_is_complete = true; }
int64_t GetByteSize() const { return m_byte_size; }
private:
bool m_is_complete;
int64_t m_byte_size;
std::vector<Field> m_fields;
GoStruct(const GoStruct &) = delete;
const GoStruct &operator=(const GoStruct &) = delete;
};
GoArray *GoType::GetArray() {
if (m_kind == KIND_ARRAY) {
return static_cast<GoArray *>(this);
}
return nullptr;
}
GoFunction *GoType::GetFunction() {
if (m_kind == KIND_FUNC) {
return static_cast<GoFunction *>(this);
}
return nullptr;
}
GoStruct *GoType::GetStruct() {
switch (m_kind) {
case KIND_STRING:
case KIND_STRUCT:
case KIND_SLICE:
return static_cast<GoStruct *>(this);
}
return nullptr;
}
} // namespace lldb_private
using namespace lldb_private;
GoASTContext::GoASTContext()
: TypeSystem(eKindGo), m_pointer_byte_size(0), m_int_byte_size(0),
m_types(new TypeMap) {}
GoASTContext::~GoASTContext() {}
//------------------------------------------------------------------
// PluginInterface functions
//------------------------------------------------------------------
ConstString GoASTContext::GetPluginNameStatic() { return ConstString("go"); }
ConstString GoASTContext::GetPluginName() {
return GoASTContext::GetPluginNameStatic();
}
uint32_t GoASTContext::GetPluginVersion() { return 1; }
lldb::TypeSystemSP GoASTContext::CreateInstance(lldb::LanguageType language,
Module *module,
Target *target) {
if (language == eLanguageTypeGo) {
ArchSpec arch;
std::shared_ptr<GoASTContext> go_ast_sp;
if (module) {
arch = module->GetArchitecture();
go_ast_sp = std::shared_ptr<GoASTContext>(new GoASTContext);
} else if (target) {
arch = target->GetArchitecture();
go_ast_sp = std::shared_ptr<GoASTContextForExpr>(
new GoASTContextForExpr(target->shared_from_this()));
}
if (arch.IsValid()) {
go_ast_sp->SetAddressByteSize(arch.GetAddressByteSize());
return go_ast_sp;
}
}
return lldb::TypeSystemSP();
}
void GoASTContext::EnumerateSupportedLanguages(
std::set<lldb::LanguageType> &languages_for_types,
std::set<lldb::LanguageType> &languages_for_expressions) {
static std::vector<lldb::LanguageType> s_supported_languages_for_types(
{lldb::eLanguageTypeGo});
static std::vector<lldb::LanguageType> s_supported_languages_for_expressions(
{});
languages_for_types.insert(s_supported_languages_for_types.begin(),
s_supported_languages_for_types.end());
languages_for_expressions.insert(
s_supported_languages_for_expressions.begin(),
s_supported_languages_for_expressions.end());
}
void GoASTContext::Initialize() {
PluginManager::RegisterPlugin(GetPluginNameStatic(), "AST context plug-in",
CreateInstance, EnumerateSupportedLanguages);
}
void GoASTContext::Terminate() {
PluginManager::UnregisterPlugin(CreateInstance);
}
//----------------------------------------------------------------------
// Tests
//----------------------------------------------------------------------
bool GoASTContext::IsArrayType(lldb::opaque_compiler_type_t type,
CompilerType *element_type, uint64_t *size,
bool *is_incomplete) {
if (element_type)
element_type->Clear();
if (size)
*size = 0;
if (is_incomplete)
*is_incomplete = false;
GoArray *array = static_cast<GoType *>(type)->GetArray();
if (array) {
if (size)
*size = array->GetLength();
if (element_type)
*element_type = array->GetElementType();
return true;
}
return false;
}
bool GoASTContext::IsVectorType(lldb::opaque_compiler_type_t type,
CompilerType *element_type, uint64_t *size) {
if (element_type)
element_type->Clear();
if (size)
*size = 0;
return false;
}
bool GoASTContext::IsAggregateType(lldb::opaque_compiler_type_t type) {
int kind = static_cast<GoType *>(type)->GetGoKind();
if (kind < GoType::KIND_ARRAY)
return false;
if (kind == GoType::KIND_PTR)
return false;
if (kind == GoType::KIND_CHAN)
return false;
if (kind == GoType::KIND_MAP)
return false;
if (kind == GoType::KIND_STRING)
return false;
if (kind == GoType::KIND_UNSAFEPOINTER)
return false;
return true;
}
bool GoASTContext::IsBeingDefined(lldb::opaque_compiler_type_t type) {
return false;
}
bool GoASTContext::IsCharType(lldb::opaque_compiler_type_t type) {
// Go's DWARF doesn't distinguish between rune and int32.
return false;
}
bool GoASTContext::IsCompleteType(lldb::opaque_compiler_type_t type) {
if (!type)
return false;
GoType *t = static_cast<GoType *>(type);
if (GoStruct *s = t->GetStruct())
return s->IsComplete();
if (t->IsTypedef() || t->GetGoKind() == GoType::KIND_PTR)
return t->GetElementType().IsCompleteType();
return true;
}
bool GoASTContext::IsConst(lldb::opaque_compiler_type_t type) { return false; }
bool GoASTContext::IsCStringType(lldb::opaque_compiler_type_t type,
uint32_t &length) {
return false;
}
bool GoASTContext::IsDefined(lldb::opaque_compiler_type_t type) {
return type != nullptr;
}
bool GoASTContext::IsFloatingPointType(lldb::opaque_compiler_type_t type,
uint32_t &count, bool &is_complex) {
int kind = static_cast<GoType *>(type)->GetGoKind();
if (kind >= GoType::KIND_FLOAT32 && kind <= GoType::KIND_COMPLEX128) {
if (kind >= GoType::KIND_COMPLEX64) {
is_complex = true;
count = 2;
} else {
is_complex = false;
count = 1;
}
return true;
}
count = 0;
is_complex = false;
return false;
}
bool GoASTContext::IsFunctionType(lldb::opaque_compiler_type_t type,
bool *is_variadic_ptr) {
GoFunction *func = static_cast<GoType *>(type)->GetFunction();
if (func) {
if (is_variadic_ptr)
*is_variadic_ptr = func->IsVariadic();
return true;
}
if (is_variadic_ptr)
*is_variadic_ptr = false;
return false;
}
uint32_t GoASTContext::IsHomogeneousAggregate(lldb::opaque_compiler_type_t type,
CompilerType *base_type_ptr) {
return false;
}
size_t
GoASTContext::GetNumberOfFunctionArguments(lldb::opaque_compiler_type_t type) {
return 0;
}
CompilerType
GoASTContext::GetFunctionArgumentAtIndex(lldb::opaque_compiler_type_t type,
const size_t index) {
return CompilerType();
}
bool GoASTContext::IsFunctionPointerType(lldb::opaque_compiler_type_t type) {
return IsFunctionType(type);
}
bool GoASTContext::IsBlockPointerType(lldb::opaque_compiler_type_t type,
CompilerType *function_pointer_type_ptr) {
return false;
}
bool GoASTContext::IsIntegerType(lldb::opaque_compiler_type_t type,
bool &is_signed) {
is_signed = false;
// TODO: Is bool an integer?
if (type) {
int kind = static_cast<GoType *>(type)->GetGoKind();
if (kind <= GoType::KIND_UINTPTR) {
is_signed = (kind != GoType::KIND_BOOL) & (kind <= GoType::KIND_INT64);
return true;
}
}
return false;
}
bool GoASTContext::IsPolymorphicClass(lldb::opaque_compiler_type_t type) {
return false;
}
bool GoASTContext::IsPossibleDynamicType(
lldb::opaque_compiler_type_t type,
CompilerType *target_type, // Can pass NULL
bool check_cplusplus, bool check_objc) {
if (target_type)
target_type->Clear();
if (type)
return static_cast<GoType *>(type)->GetGoKind() == GoType::KIND_INTERFACE;
return false;
}
bool GoASTContext::IsRuntimeGeneratedType(lldb::opaque_compiler_type_t type) {
return false;
}
bool GoASTContext::IsPointerType(lldb::opaque_compiler_type_t type,
CompilerType *pointee_type) {
if (!type)
return false;
GoType *t = static_cast<GoType *>(type);
if (pointee_type) {
*pointee_type = t->GetElementType();
}
switch (t->GetGoKind()) {
case GoType::KIND_PTR:
case GoType::KIND_UNSAFEPOINTER:
case GoType::KIND_CHAN:
case GoType::KIND_MAP:
// TODO: is function a pointer?
return true;
default:
return false;
}
}
bool GoASTContext::IsPointerOrReferenceType(lldb::opaque_compiler_type_t type,
CompilerType *pointee_type) {
return IsPointerType(type, pointee_type);
}
bool GoASTContext::IsReferenceType(lldb::opaque_compiler_type_t type,
CompilerType *pointee_type,
bool *is_rvalue) {
return false;
}
bool GoASTContext::IsScalarType(lldb::opaque_compiler_type_t type) {
return !IsAggregateType(type);
}
bool GoASTContext::IsTypedefType(lldb::opaque_compiler_type_t type) {
if (type)
return static_cast<GoType *>(type)->IsTypedef();
return false;
}
bool GoASTContext::IsVoidType(lldb::opaque_compiler_type_t type) {
if (!type)
return false;
return static_cast<GoType *>(type)->GetGoKind() == GoType::KIND_LLDB_VOID;
}
bool GoASTContext::SupportsLanguage(lldb::LanguageType language) {
return language == eLanguageTypeGo;
}
//----------------------------------------------------------------------
// Type Completion
//----------------------------------------------------------------------
bool GoASTContext::GetCompleteType(lldb::opaque_compiler_type_t type) {
if (!type)
return false;
GoType *t = static_cast<GoType *>(type);
if (t->IsTypedef() || t->GetGoKind() == GoType::KIND_PTR || t->GetArray())
return t->GetElementType().GetCompleteType();
if (GoStruct *s = t->GetStruct()) {
if (s->IsComplete())
return true;
CompilerType compiler_type(this, s);
SymbolFile *symbols = GetSymbolFile();
return symbols && symbols->CompleteType(compiler_type);
}
return true;
}
//----------------------------------------------------------------------
// AST related queries
//----------------------------------------------------------------------
uint32_t GoASTContext::GetPointerByteSize() { return m_pointer_byte_size; }
//----------------------------------------------------------------------
// Accessors
//----------------------------------------------------------------------
ConstString GoASTContext::GetTypeName(lldb::opaque_compiler_type_t type) {
if (type)
return static_cast<GoType *>(type)->GetName();
return ConstString();
}
uint32_t
GoASTContext::GetTypeInfo(lldb::opaque_compiler_type_t type,
CompilerType *pointee_or_element_compiler_type) {
if (pointee_or_element_compiler_type)
pointee_or_element_compiler_type->Clear();
if (!type)
return 0;
GoType *t = static_cast<GoType *>(type);
if (pointee_or_element_compiler_type)
*pointee_or_element_compiler_type = t->GetElementType();
int kind = t->GetGoKind();
if (kind == GoType::KIND_ARRAY)
return eTypeHasChildren | eTypeIsArray;
if (kind < GoType::KIND_ARRAY) {
uint32_t builtin_type_flags = eTypeIsBuiltIn | eTypeHasValue;
if (kind < GoType::KIND_FLOAT32) {
builtin_type_flags |= eTypeIsInteger | eTypeIsScalar;
if (kind >= GoType::KIND_INT && kind <= GoType::KIND_INT64)
builtin_type_flags |= eTypeIsSigned;
} else {
builtin_type_flags |= eTypeIsFloat;
if (kind < GoType::KIND_COMPLEX64)
builtin_type_flags |= eTypeIsComplex;
else
builtin_type_flags |= eTypeIsScalar;
}
return builtin_type_flags;
}
if (kind == GoType::KIND_STRING)
return eTypeHasValue | eTypeIsBuiltIn;
if (kind == GoType::KIND_FUNC)
return eTypeIsFuncPrototype | eTypeHasValue;
if (IsPointerType(type))
return eTypeIsPointer | eTypeHasValue | eTypeHasChildren;
if (kind == GoType::KIND_LLDB_VOID)
return 0;
return eTypeHasChildren | eTypeIsStructUnion;
}
lldb::TypeClass GoASTContext::GetTypeClass(lldb::opaque_compiler_type_t type) {
if (!type)
return eTypeClassInvalid;
int kind = static_cast<GoType *>(type)->GetGoKind();
if (kind == GoType::KIND_FUNC)
return eTypeClassFunction;
if (IsPointerType(type))
return eTypeClassPointer;
if (kind < GoType::KIND_COMPLEX64)
return eTypeClassBuiltin;
if (kind <= GoType::KIND_COMPLEX128)
return eTypeClassComplexFloat;
if (kind == GoType::KIND_LLDB_VOID)
return eTypeClassInvalid;
return eTypeClassStruct;
}
lldb::BasicType
GoASTContext::GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) {
ConstString name = GetTypeName(type);
if (name) {
typedef UniqueCStringMap<lldb::BasicType> TypeNameToBasicTypeMap;
static TypeNameToBasicTypeMap g_type_map;
static llvm::once_flag g_once_flag;
llvm::call_once(g_once_flag, []() {
// "void"
g_type_map.Append(ConstString("void"), eBasicTypeVoid);
// "int"
g_type_map.Append(ConstString("int"), eBasicTypeInt);
g_type_map.Append(ConstString("uint"), eBasicTypeUnsignedInt);
// Miscellaneous
g_type_map.Append(ConstString("bool"), eBasicTypeBool);
// Others. Should these map to C types?
g_type_map.Append(ConstString("byte"), eBasicTypeOther);
g_type_map.Append(ConstString("uint8"), eBasicTypeOther);
g_type_map.Append(ConstString("uint16"), eBasicTypeOther);
g_type_map.Append(ConstString("uint32"), eBasicTypeOther);
g_type_map.Append(ConstString("uint64"), eBasicTypeOther);
g_type_map.Append(ConstString("int8"), eBasicTypeOther);
g_type_map.Append(ConstString("int16"), eBasicTypeOther);
g_type_map.Append(ConstString("int32"), eBasicTypeOther);
g_type_map.Append(ConstString("int64"), eBasicTypeOther);
g_type_map.Append(ConstString("float32"), eBasicTypeOther);
g_type_map.Append(ConstString("float64"), eBasicTypeOther);
g_type_map.Append(ConstString("uintptr"), eBasicTypeOther);
g_type_map.Sort();
});
return g_type_map.Find(name, eBasicTypeInvalid);
}
return eBasicTypeInvalid;
}
lldb::LanguageType
GoASTContext::GetMinimumLanguage(lldb::opaque_compiler_type_t type) {
return lldb::eLanguageTypeGo;
}
unsigned GoASTContext::GetTypeQualifiers(lldb::opaque_compiler_type_t type) {
return 0;
}
//----------------------------------------------------------------------
// Creating related types
//----------------------------------------------------------------------
CompilerType
GoASTContext::GetArrayElementType(lldb::opaque_compiler_type_t type,
uint64_t *stride) {
GoArray *array = static_cast<GoType *>(type)->GetArray();
if (array) {
if (stride) {
*stride = array->GetElementType().GetByteSize(nullptr);
}
return array->GetElementType();
}
return CompilerType();
}
CompilerType GoASTContext::GetCanonicalType(lldb::opaque_compiler_type_t type) {
GoType *t = static_cast<GoType *>(type);
if (t->IsTypedef())
return t->GetElementType();
return CompilerType(this, type);
}
CompilerType
GoASTContext::GetFullyUnqualifiedType(lldb::opaque_compiler_type_t type) {
return CompilerType(this, type);
}
// Returns -1 if this isn't a function of if the function doesn't have a
// prototype
// Returns a value >= 0 if there is a prototype.
int GoASTContext::GetFunctionArgumentCount(lldb::opaque_compiler_type_t type) {
return GetNumberOfFunctionArguments(type);
}
CompilerType
GoASTContext::GetFunctionArgumentTypeAtIndex(lldb::opaque_compiler_type_t type,
size_t idx) {
return GetFunctionArgumentAtIndex(type, idx);
}
CompilerType
GoASTContext::GetFunctionReturnType(lldb::opaque_compiler_type_t type) {
CompilerType result;
if (type) {
GoType *t = static_cast<GoType *>(type);
if (t->GetGoKind() == GoType::KIND_FUNC)
result = t->GetElementType();
}
return result;
}
size_t GoASTContext::GetNumMemberFunctions(lldb::opaque_compiler_type_t type) {
return 0;
}
TypeMemberFunctionImpl
GoASTContext::GetMemberFunctionAtIndex(lldb::opaque_compiler_type_t type,
size_t idx) {
return TypeMemberFunctionImpl();
}
CompilerType
GoASTContext::GetNonReferenceType(lldb::opaque_compiler_type_t type) {
return CompilerType(this, type);
}
CompilerType GoASTContext::GetPointeeType(lldb::opaque_compiler_type_t type) {
if (!type)
return CompilerType();
return static_cast<GoType *>(type)->GetElementType();
}
CompilerType GoASTContext::GetPointerType(lldb::opaque_compiler_type_t type) {
if (!type)
return CompilerType();
ConstString type_name = GetTypeName(type);
ConstString pointer_name(std::string("*") + type_name.GetCString());
GoType *pointer = (*m_types)[pointer_name].get();
if (pointer == nullptr) {
pointer =
new GoElem(GoType::KIND_PTR, pointer_name, CompilerType(this, type));
(*m_types)[pointer_name].reset(pointer);
}
return CompilerType(this, pointer);
}
// If the current object represents a typedef type, get the underlying type
CompilerType GoASTContext::GetTypedefedType(lldb::opaque_compiler_type_t type) {
if (IsTypedefType(type))
return static_cast<GoType *>(type)->GetElementType();
return CompilerType();
}
//----------------------------------------------------------------------
// Create related types using the current type's AST
//----------------------------------------------------------------------
CompilerType GoASTContext::GetBasicTypeFromAST(lldb::BasicType basic_type) {
return CompilerType();
}
CompilerType
GoASTContext::GetBuiltinTypeForEncodingAndBitSize(lldb::Encoding encoding,
size_t bit_size) {
return CompilerType();
}
//----------------------------------------------------------------------
// Exploring the type
//----------------------------------------------------------------------
uint64_t GoASTContext::GetBitSize(lldb::opaque_compiler_type_t type,
ExecutionContextScope *exe_scope) {
if (!type)
return 0;
if (!GetCompleteType(type))
return 0;
GoType *t = static_cast<GoType *>(type);
GoArray *array = nullptr;
switch (t->GetGoKind()) {
case GoType::KIND_BOOL:
case GoType::KIND_INT8:
case GoType::KIND_UINT8:
return 8;
case GoType::KIND_INT16:
case GoType::KIND_UINT16:
return 16;
case GoType::KIND_INT32:
case GoType::KIND_UINT32:
case GoType::KIND_FLOAT32:
return 32;
case GoType::KIND_INT64:
case GoType::KIND_UINT64:
case GoType::KIND_FLOAT64:
case GoType::KIND_COMPLEX64:
return 64;
case GoType::KIND_COMPLEX128:
return 128;
case GoType::KIND_INT:
case GoType::KIND_UINT:
return m_int_byte_size * 8;
case GoType::KIND_UINTPTR:
case GoType::KIND_FUNC: // I assume this is a pointer?
case GoType::KIND_CHAN:
case GoType::KIND_PTR:
case GoType::KIND_UNSAFEPOINTER:
case GoType::KIND_MAP:
return m_pointer_byte_size * 8;
case GoType::KIND_ARRAY:
array = t->GetArray();
return array->GetLength() * array->GetElementType().GetBitSize(exe_scope);
case GoType::KIND_INTERFACE:
return t->GetElementType().GetBitSize(exe_scope);
case GoType::KIND_SLICE:
case GoType::KIND_STRING:
case GoType::KIND_STRUCT:
return t->GetStruct()->GetByteSize() * 8;
default:
assert(false);
}
return 0;
}
lldb::Encoding GoASTContext::GetEncoding(lldb::opaque_compiler_type_t type,
uint64_t &count) {
count = 1;
bool is_signed;
if (IsIntegerType(type, is_signed))
return is_signed ? lldb::eEncodingSint : eEncodingUint;
bool is_complex;
uint32_t complex_count;
if (IsFloatingPointType(type, complex_count, is_complex)) {
count = complex_count;
return eEncodingIEEE754;
}
if (IsPointerType(type))
return eEncodingUint;
return eEncodingInvalid;
}
lldb::Format GoASTContext::GetFormat(lldb::opaque_compiler_type_t type) {
if (!type)
return eFormatDefault;
switch (static_cast<GoType *>(type)->GetGoKind()) {
case GoType::KIND_BOOL:
return eFormatBoolean;
case GoType::KIND_INT:
case GoType::KIND_INT8:
case GoType::KIND_INT16:
case GoType::KIND_INT32:
case GoType::KIND_INT64:
return eFormatDecimal;
case GoType::KIND_UINT:
case GoType::KIND_UINT8:
case GoType::KIND_UINT16:
case GoType::KIND_UINT32:
case GoType::KIND_UINT64:
return eFormatUnsigned;
case GoType::KIND_FLOAT32:
case GoType::KIND_FLOAT64:
return eFormatFloat;
case GoType::KIND_COMPLEX64:
case GoType::KIND_COMPLEX128:
return eFormatComplexFloat;
case GoType::KIND_UINTPTR:
case GoType::KIND_CHAN:
case GoType::KIND_PTR:
case GoType::KIND_MAP:
case GoType::KIND_UNSAFEPOINTER:
return eFormatHex;
case GoType::KIND_STRING:
return eFormatCString;
case GoType::KIND_ARRAY:
case GoType::KIND_INTERFACE:
case GoType::KIND_SLICE:
case GoType::KIND_STRUCT:
default:
// Don't know how to display this.
return eFormatBytes;
}
}
size_t GoASTContext::GetTypeBitAlign(lldb::opaque_compiler_type_t type) {
return 0;
}
uint32_t GoASTContext::GetNumChildren(lldb::opaque_compiler_type_t type,
bool omit_empty_base_classes) {
if (!type || !GetCompleteType(type))
return 0;
GoType *t = static_cast<GoType *>(type);
if (t->GetGoKind() == GoType::KIND_PTR) {
CompilerType elem = t->GetElementType();
if (elem.IsAggregateType())
return elem.GetNumChildren(omit_empty_base_classes);
return 1;
} else if (GoArray *array = t->GetArray()) {
return array->GetLength();
} else if (t->IsTypedef()) {
return t->GetElementType().GetNumChildren(omit_empty_base_classes);
}
return GetNumFields(type);
}
uint32_t GoASTContext::GetNumFields(lldb::opaque_compiler_type_t type) {
if (!type || !GetCompleteType(type))
return 0;
GoType *t = static_cast<GoType *>(type);
if (t->IsTypedef())
return t->GetElementType().GetNumFields();
GoStruct *s = t->GetStruct();
if (s)
return s->GetNumFields();
return 0;
}
CompilerType GoASTContext::GetFieldAtIndex(lldb::opaque_compiler_type_t type,
size_t idx, std::string &name,
uint64_t *bit_offset_ptr,
uint32_t *bitfield_bit_size_ptr,
bool *is_bitfield_ptr) {
if (bit_offset_ptr)
*bit_offset_ptr = 0;
if (bitfield_bit_size_ptr)
*bitfield_bit_size_ptr = 0;
if (is_bitfield_ptr)
*is_bitfield_ptr = false;
if (!type || !GetCompleteType(type))
return CompilerType();
GoType *t = static_cast<GoType *>(type);
if (t->IsTypedef())
return t->GetElementType().GetFieldAtIndex(
idx, name, bit_offset_ptr, bitfield_bit_size_ptr, is_bitfield_ptr);
GoStruct *s = t->GetStruct();
if (s) {
const auto *field = s->GetField(idx);
if (field) {
name = field->m_name.GetStringRef();
if (bit_offset_ptr)
*bit_offset_ptr = field->m_byte_offset * 8;
return field->m_type;
}
}
return CompilerType();
}
CompilerType GoASTContext::GetChildCompilerTypeAtIndex(
lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, size_t idx,
bool transparent_pointers, bool omit_empty_base_classes,
bool ignore_array_bounds, std::string &child_name,
uint32_t &child_byte_size, int32_t &child_byte_offset,
uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset,
bool &child_is_base_class, bool &child_is_deref_of_parent,
ValueObject *valobj, uint64_t &language_flags) {
child_name.clear();
child_byte_size = 0;
child_byte_offset = 0;
child_bitfield_bit_size = 0;
child_bitfield_bit_offset = 0;
child_is_base_class = false;
child_is_deref_of_parent = false;
language_flags = 0;
if (!type || !GetCompleteType(type))
return CompilerType();
GoType *t = static_cast<GoType *>(type);
if (t->GetStruct()) {
uint64_t bit_offset;
CompilerType ret =
GetFieldAtIndex(type, idx, child_name, &bit_offset, nullptr, nullptr);
child_byte_size = ret.GetByteSize(
exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr);
child_byte_offset = bit_offset / 8;
return ret;
} else if (t->GetGoKind() == GoType::KIND_PTR) {
CompilerType pointee = t->GetElementType();
if (!pointee.IsValid() || pointee.IsVoidType())
return CompilerType();
if (transparent_pointers && pointee.IsAggregateType()) {
bool tmp_child_is_deref_of_parent = false;
return pointee.GetChildCompilerTypeAtIndex(
exe_ctx, idx, transparent_pointers, omit_empty_base_classes,
ignore_array_bounds, child_name, child_byte_size, child_byte_offset,
child_bitfield_bit_size, child_bitfield_bit_offset,
child_is_base_class, tmp_child_is_deref_of_parent, valobj,
language_flags);
} else {
child_is_deref_of_parent = true;
const char *parent_name = valobj ? valobj->GetName().GetCString() : NULL;
if (parent_name) {
child_name.assign(1, '*');
child_name += parent_name;
}
// We have a pointer to an simple type
if (idx == 0 && pointee.GetCompleteType()) {
child_byte_size = pointee.GetByteSize(
exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL);
child_byte_offset = 0;
return pointee;
}
}
} else if (GoArray *a = t->GetArray()) {
if (ignore_array_bounds || idx < a->GetLength()) {
CompilerType element_type = a->GetElementType();
if (element_type.GetCompleteType()) {
char element_name[64];
::snprintf(element_name, sizeof(element_name), "[%zu]", idx);
child_name.assign(element_name);
child_byte_size = element_type.GetByteSize(
exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL);
child_byte_offset = (int32_t)idx * (int32_t)child_byte_size;
return element_type;
}
}
} else if (t->IsTypedef()) {
return t->GetElementType().GetChildCompilerTypeAtIndex(
exe_ctx, idx, transparent_pointers, omit_empty_base_classes,
ignore_array_bounds, child_name, child_byte_size, child_byte_offset,
child_bitfield_bit_size, child_bitfield_bit_offset, child_is_base_class,
child_is_deref_of_parent, valobj, language_flags);
}
return CompilerType();
}
// Lookup a child given a name. This function will match base class names
// and member member names in "clang_type" only, not descendants.
uint32_t
GoASTContext::GetIndexOfChildWithName(lldb::opaque_compiler_type_t type,
const char *name,
bool omit_empty_base_classes) {
if (!type || !GetCompleteType(type))
return UINT_MAX;
GoType *t = static_cast<GoType *>(type);
GoStruct *s = t->GetStruct();
if (s) {
for (uint32_t i = 0; i < s->GetNumFields(); ++i) {
const GoStruct::Field *f = s->GetField(i);
if (f->m_name.GetStringRef() == name)
return i;
}
} else if (t->GetGoKind() == GoType::KIND_PTR || t->IsTypedef()) {
return t->GetElementType().GetIndexOfChildWithName(name,
omit_empty_base_classes);
}
return UINT_MAX;
}
// Lookup a child member given a name. This function will match member names
// only and will descend into "clang_type" children in search for the first
// member in this class, or any base class that matches "name".
// TODO: Return all matches for a given name by returning a
// vector<vector<uint32_t>>
// so we catch all names that match a given child name, not just the first.
size_t GoASTContext::GetIndexOfChildMemberWithName(
lldb::opaque_compiler_type_t type, const char *name,
bool omit_empty_base_classes, std::vector<uint32_t> &child_indexes) {
uint32_t index = GetIndexOfChildWithName(type, name, omit_empty_base_classes);
if (index == UINT_MAX)
return 0;
child_indexes.push_back(index);
return 1;
}
// Converts "s" to a floating point value and place resulting floating
// point bytes in the "dst" buffer.
size_t
GoASTContext::ConvertStringToFloatValue(lldb::opaque_compiler_type_t type,
const char *s, uint8_t *dst,
size_t dst_size) {
assert(false);
return 0;
}
//----------------------------------------------------------------------
// Dumping types
//----------------------------------------------------------------------
#define DEPTH_INCREMENT 2
void GoASTContext::DumpValue(lldb::opaque_compiler_type_t type,
ExecutionContext *exe_ctx, Stream *s,
lldb::Format format, const DataExtractor &data,
lldb::offset_t data_byte_offset,
size_t data_byte_size, uint32_t bitfield_bit_size,
uint32_t bitfield_bit_offset, bool show_types,
bool show_summary, bool verbose, uint32_t depth) {
if (IsTypedefType(type))
type = GetTypedefedType(type).GetOpaqueQualType();
if (!type)
return;
GoType *t = static_cast<GoType *>(type);
if (GoStruct *st = t->GetStruct()) {
if (GetCompleteType(type)) {
uint32_t field_idx = 0;
for (auto *field = st->GetField(field_idx); field != nullptr;
field_idx++) {
// Print the starting squiggly bracket (if this is the
// first member) or comma (for member 2 and beyond) for
// the struct/union/class member.
if (field_idx == 0)
s->PutChar('{');
else
s->PutChar(',');
// Indent
s->Printf("\n%*s", depth + DEPTH_INCREMENT, "");
// Print the member type if requested
if (show_types) {
ConstString field_type_name = field->m_type.GetTypeName();
s->Printf("(%s) ", field_type_name.AsCString());
}
// Print the member name and equal sign
s->Printf("%s = ", field->m_name.AsCString());
// Dump the value of the member
CompilerType field_type = field->m_type;
field_type.DumpValue(
exe_ctx,
s, // Stream to dump to
field_type
.GetFormat(), // The format with which to display the member
data, // Data buffer containing all bytes for this type
data_byte_offset + field->m_byte_offset, // Offset into "data" where
// to grab value from
field->m_type.GetByteSize(
exe_ctx->GetBestExecutionContextScope()), // Size of this type
// in bytes
0, // Bitfield bit size
0, // Bitfield bit offset
show_types, // Boolean indicating if we should show the variable
// types
show_summary, // Boolean indicating if we should show a summary for
// the current type
verbose, // Verbose output?
depth + DEPTH_INCREMENT); // Scope depth for any types that have
// children
}
// Indent the trailing squiggly bracket
if (field_idx > 0)
s->Printf("\n%*s}", depth, "");
}
}
if (GoArray *a = t->GetArray()) {
CompilerType element_clang_type = a->GetElementType();
lldb::Format element_format = element_clang_type.GetFormat();
uint32_t element_byte_size =
element_clang_type.GetByteSize(exe_ctx->GetBestExecutionContextScope());
uint64_t element_idx;
for (element_idx = 0; element_idx < a->GetLength(); ++element_idx) {
// Print the starting squiggly bracket (if this is the
// first member) or comman (for member 2 and beyong) for
// the struct/union/class member.
if (element_idx == 0)
s->PutChar('{');
else
s->PutChar(',');
// Indent and print the index
s->Printf("\n%*s[%" PRIu64 "] ", depth + DEPTH_INCREMENT, "",
element_idx);
// Figure out the field offset within the current struct/union/class type
uint64_t element_offset = element_idx * element_byte_size;
// Dump the value of the member
element_clang_type.DumpValue(
exe_ctx,
s, // Stream to dump to
element_format, // The format with which to display the element
data, // Data buffer containing all bytes for this type
data_byte_offset +
element_offset, // Offset into "data" where to grab value from
element_byte_size, // Size of this type in bytes
0, // Bitfield bit size
0, // Bitfield bit offset
show_types, // Boolean indicating if we should show the variable types
show_summary, // Boolean indicating if we should show a summary for
// the current type
verbose, // Verbose output?
depth +
DEPTH_INCREMENT); // Scope depth for any types that have children
}
// Indent the trailing squiggly bracket
if (element_idx > 0)
s->Printf("\n%*s}", depth, "");
}
if (show_summary)
DumpSummary(type, exe_ctx, s, data, data_byte_offset, data_byte_size);
}
bool GoASTContext::DumpTypeValue(lldb::opaque_compiler_type_t type, Stream *s,
lldb::Format format, const DataExtractor &data,
lldb::offset_t byte_offset, size_t byte_size,
uint32_t bitfield_bit_size,
uint32_t bitfield_bit_offset,
ExecutionContextScope *exe_scope) {
if (!type)
return false;
if (IsAggregateType(type)) {
return false;
} else {
GoType *t = static_cast<GoType *>(type);
if (t->IsTypedef()) {
CompilerType typedef_compiler_type = t->GetElementType();
if (format == eFormatDefault)
format = typedef_compiler_type.GetFormat();
uint64_t typedef_byte_size = typedef_compiler_type.GetByteSize(exe_scope);
return typedef_compiler_type.DumpTypeValue(
s,
format, // The format with which to display the element
data, // Data buffer containing all bytes for this type
byte_offset, // Offset into "data" where to grab value from
typedef_byte_size, // Size of this type in bytes
bitfield_bit_size, // Size in bits of a bitfield value, if zero don't
// treat as a bitfield
bitfield_bit_offset, // Offset in bits of a bitfield value if
// bitfield_bit_size != 0
exe_scope);
}
uint32_t item_count = 1;
// A few formats, we might need to modify our size and count for depending
// on how we are trying to display the value...
switch (format) {
default:
case eFormatBoolean:
case eFormatBinary:
case eFormatComplex:
case eFormatCString: // NULL terminated C strings
case eFormatDecimal:
case eFormatEnum:
case eFormatHex:
case eFormatHexUppercase:
case eFormatFloat:
case eFormatOctal:
case eFormatOSType:
case eFormatUnsigned:
case eFormatPointer:
case eFormatVectorOfChar:
case eFormatVectorOfSInt8:
case eFormatVectorOfUInt8:
case eFormatVectorOfSInt16:
case eFormatVectorOfUInt16:
case eFormatVectorOfSInt32:
case eFormatVectorOfUInt32:
case eFormatVectorOfSInt64:
case eFormatVectorOfUInt64:
case eFormatVectorOfFloat32:
case eFormatVectorOfFloat64:
case eFormatVectorOfUInt128:
break;
case eFormatChar:
case eFormatCharPrintable:
case eFormatCharArray:
case eFormatBytes:
case eFormatBytesWithASCII:
item_count = byte_size;
byte_size = 1;
break;
case eFormatUnicode16:
item_count = byte_size / 2;
byte_size = 2;
break;
case eFormatUnicode32:
item_count = byte_size / 4;
byte_size = 4;
break;
}
return DumpDataExtractor(data, s, byte_offset, format, byte_size,
item_count, UINT32_MAX, LLDB_INVALID_ADDRESS,
bitfield_bit_size, bitfield_bit_offset, exe_scope);
}
return 0;
}
void GoASTContext::DumpSummary(lldb::opaque_compiler_type_t type,
ExecutionContext *exe_ctx, Stream *s,
const DataExtractor &data,
lldb::offset_t data_offset,
size_t data_byte_size) {
if (type && GoType::KIND_STRING == static_cast<GoType *>(type)->GetGoKind()) {
// TODO(ribrdb): read length and data
}
}
void GoASTContext::DumpTypeDescription(lldb::opaque_compiler_type_t type) {
// Dump to stdout
StreamFile s(stdout, false);
DumpTypeDescription(type, &s);
}
void GoASTContext::DumpTypeDescription(lldb::opaque_compiler_type_t type,
Stream *s) {
if (!type)
return;
ConstString name = GetTypeName(type);
GoType *t = static_cast<GoType *>(type);
if (GoStruct *st = t->GetStruct()) {
if (GetCompleteType(type)) {
if (NULL == strchr(name.AsCString(), '{'))
s->Printf("type %s ", name.AsCString());
s->PutCString("struct {");
if (st->GetNumFields() == 0) {
s->PutChar('}');
return;
}
s->IndentMore();
uint32_t field_idx = 0;
for (auto *field = st->GetField(field_idx); field != nullptr;
field_idx++) {
s->PutChar('\n');
s->Indent();
s->Printf("%s %s", field->m_name.AsCString(),
field->m_type.GetTypeName().AsCString());
}
s->IndentLess();
s->PutChar('\n');
s->Indent("}");
return;
}
}
s->PutCString(name.AsCString());
}
CompilerType GoASTContext::CreateArrayType(const ConstString &name,
const CompilerType &element_type,
uint64_t length) {
GoType *type = new GoArray(name, length, element_type);
(*m_types)[name].reset(type);
return CompilerType(this, type);
}
CompilerType GoASTContext::CreateBaseType(int go_kind,
const lldb_private::ConstString &name,
uint64_t byte_size) {
if (go_kind == GoType::KIND_UINT || go_kind == GoType::KIND_INT)
m_int_byte_size = byte_size;
GoType *type = new GoType(go_kind, name);
(*m_types)[name].reset(type);
return CompilerType(this, type);
}
CompilerType GoASTContext::CreateTypedefType(int kind, const ConstString &name,
CompilerType impl) {
GoType *type = new GoElem(kind, name, impl);
(*m_types)[name].reset(type);
return CompilerType(this, type);
}
CompilerType
GoASTContext::CreateVoidType(const lldb_private::ConstString &name) {
GoType *type = new GoType(GoType::KIND_LLDB_VOID, name);
(*m_types)[name].reset(type);
return CompilerType(this, type);
}
CompilerType
GoASTContext::CreateStructType(int kind, const lldb_private::ConstString &name,
uint32_t byte_size) {
GoType *type = new GoStruct(kind, name, byte_size);
(*m_types)[name].reset(type);
return CompilerType(this, type);
}
void GoASTContext::AddFieldToStruct(
const lldb_private::CompilerType &struct_type,
const lldb_private::ConstString &name,
const lldb_private::CompilerType &field_type, uint32_t byte_offset) {
if (!struct_type)
return;
GoASTContext *ast =
llvm::dyn_cast_or_null<GoASTContext>(struct_type.GetTypeSystem());
if (!ast)
return;
GoType *type = static_cast<GoType *>(struct_type.GetOpaqueQualType());
if (GoStruct *s = type->GetStruct())
s->AddField(name, field_type, byte_offset);
}
void GoASTContext::CompleteStructType(
const lldb_private::CompilerType &struct_type) {
if (!struct_type)
return;
GoASTContext *ast =
llvm::dyn_cast_or_null<GoASTContext>(struct_type.GetTypeSystem());
if (!ast)
return;
GoType *type = static_cast<GoType *>(struct_type.GetOpaqueQualType());
if (GoStruct *s = type->GetStruct())
s->SetComplete();
}
CompilerType
GoASTContext::CreateFunctionType(const lldb_private::ConstString &name,
CompilerType *params, size_t params_count,
bool is_variadic) {
GoType *type = new GoFunction(name, is_variadic);
(*m_types)[name].reset(type);
return CompilerType(this, type);
}
bool GoASTContext::IsGoString(const lldb_private::CompilerType &type) {
if (!type.IsValid() ||
!llvm::dyn_cast_or_null<GoASTContext>(type.GetTypeSystem()))
return false;
return GoType::KIND_STRING ==
static_cast<GoType *>(type.GetOpaqueQualType())->GetGoKind();
}
bool GoASTContext::IsGoSlice(const lldb_private::CompilerType &type) {
if (!type.IsValid() ||
!llvm::dyn_cast_or_null<GoASTContext>(type.GetTypeSystem()))
return false;
return GoType::KIND_SLICE ==
static_cast<GoType *>(type.GetOpaqueQualType())->GetGoKind();
}
bool GoASTContext::IsGoInterface(const lldb_private::CompilerType &type) {
if (!type.IsValid() ||
!llvm::dyn_cast_or_null<GoASTContext>(type.GetTypeSystem()))
return false;
return GoType::KIND_INTERFACE ==
static_cast<GoType *>(type.GetOpaqueQualType())->GetGoKind();
}
bool GoASTContext::IsPointerKind(uint8_t kind) {
return (kind & GoType::KIND_MASK) == GoType::KIND_PTR;
}
bool GoASTContext::IsDirectIface(uint8_t kind) {
return (kind & GoType::KIND_DIRECT_IFACE) == GoType::KIND_DIRECT_IFACE;
}
DWARFASTParser *GoASTContext::GetDWARFParser() {
if (!m_dwarf_ast_parser_ap)
m_dwarf_ast_parser_ap.reset(new DWARFASTParserGo(*this));
return m_dwarf_ast_parser_ap.get();
}
UserExpression *GoASTContextForExpr::GetUserExpression(
llvm::StringRef expr, llvm::StringRef prefix, lldb::LanguageType language,
Expression::ResultType desired_type,
const EvaluateExpressionOptions &options) {
TargetSP target = m_target_wp.lock();
if (target)
return new GoUserExpression(*target, expr, prefix, language, desired_type,
options);
return nullptr;
}
Reference in New Issue View Git Blame Copy Permalink