Type *
Types::Find (const char *name, bool ignore_case)
{
Type *t;
for (int i = 1; i < types.GetCount (); i++) { // 0 = INVALID, shouldn't compare against that
if (i == Type::LASTTYPE)
continue;
t = (Type *) types [i];
if ((ignore_case && !g_ascii_strcasecmp (t->GetName (), name)) || !strcmp (t->GetName (), name))
return t;
}
return NULL;
}
Type *Namespace::GetOrCreateType(Class *c)
{
auto iter = m_Types.find(c->GetName());
if (iter != m_Types.end())
{
return iter->second->GetPrimitive() == TypePrimitive::Class
? iter->second.get()
: nullptr;
}
Type *t = new Type(c);
m_Types[t->GetName()] = std::unique_ptr<Type>(t);
return t;
}
void ConfigType::RegisterObject(const ConfigObject::Ptr& object)
{
String name = object->GetName();
{
boost::mutex::scoped_lock lock(m_Mutex);
auto it = m_ObjectMap.find(name);
if (it != m_ObjectMap.end()) {
if (it->second == object)
return;
Type *type = dynamic_cast<Type *>(this);
BOOST_THROW_EXCEPTION(ScriptError("An object with type '" + type->GetName() + "' and name '" + name + "' already exists (" +
Convert::ToString(it->second->GetDebugInfo()) + "), new declaration: " + Convert::ToString(object->GetDebugInfo()),
object->GetDebugInfo()));
}
m_ObjectMap[name] = object;
m_ObjectVector.push_back(object);
}
}
bool Address::Dump(Stream *s, ExecutionContextScope *exe_scope, DumpStyle style,
DumpStyle fallback_style, uint32_t addr_size) const {
// If the section was nullptr, only load address is going to work unless we
// are
// trying to deref a pointer
SectionSP section_sp(GetSection());
if (!section_sp && style != DumpStyleResolvedPointerDescription)
style = DumpStyleLoadAddress;
ExecutionContext exe_ctx(exe_scope);
Target *target = exe_ctx.GetTargetPtr();
// If addr_byte_size is UINT32_MAX, then determine the correct address
// byte size for the process or default to the size of addr_t
if (addr_size == UINT32_MAX) {
if (target)
addr_size = target->GetArchitecture().GetAddressByteSize();
else
addr_size = sizeof(addr_t);
}
Address so_addr;
switch (style) {
case DumpStyleInvalid:
return false;
case DumpStyleSectionNameOffset:
if (section_sp) {
section_sp->DumpName(s);
s->Printf(" + %" PRIu64, m_offset);
} else {
s->Address(m_offset, addr_size);
}
break;
case DumpStyleSectionPointerOffset:
s->Printf("(Section *)%p + ", static_cast<void *>(section_sp.get()));
s->Address(m_offset, addr_size);
break;
case DumpStyleModuleWithFileAddress:
if (section_sp) {
ModuleSP module_sp = section_sp->GetModule();
if (module_sp)
s->Printf("%s[", module_sp->GetFileSpec().GetFilename().AsCString(
"<Unknown>"));
else
s->Printf("%s[", "<Unknown>");
}
LLVM_FALLTHROUGH;
case DumpStyleFileAddress: {
addr_t file_addr = GetFileAddress();
if (file_addr == LLDB_INVALID_ADDRESS) {
if (fallback_style != DumpStyleInvalid)
return Dump(s, exe_scope, fallback_style, DumpStyleInvalid, addr_size);
return false;
}
s->Address(file_addr, addr_size);
if (style == DumpStyleModuleWithFileAddress && section_sp)
s->PutChar(']');
} break;
case DumpStyleLoadAddress: {
addr_t load_addr = GetLoadAddress(target);
/*
* MIPS:
* Display address in compressed form for MIPS16 or microMIPS
* if the address belongs to eAddressClassCodeAlternateISA.
*/
if (target) {
const llvm::Triple::ArchType llvm_arch =
target->GetArchitecture().GetMachine();
if (llvm_arch == llvm::Triple::mips ||
llvm_arch == llvm::Triple::mipsel ||
llvm_arch == llvm::Triple::mips64 ||
llvm_arch == llvm::Triple::mips64el)
load_addr = GetCallableLoadAddress(target);
}
if (load_addr == LLDB_INVALID_ADDRESS) {
if (fallback_style != DumpStyleInvalid)
return Dump(s, exe_scope, fallback_style, DumpStyleInvalid, addr_size);
return false;
}
s->Address(load_addr, addr_size);
} break;
case DumpStyleResolvedDescription:
case DumpStyleResolvedDescriptionNoModule:
case DumpStyleResolvedDescriptionNoFunctionArguments:
case DumpStyleNoFunctionName:
if (IsSectionOffset()) {
uint32_t pointer_size = 4;
ModuleSP module_sp(GetModule());
if (target)
pointer_size = target->GetArchitecture().GetAddressByteSize();
else if (module_sp)
pointer_size = module_sp->GetArchitecture().GetAddressByteSize();
bool showed_info = false;
if (section_sp) {
SectionType sect_type = section_sp->GetType();
switch (sect_type) {
case eSectionTypeData:
if (module_sp) {
SymbolVendor *sym_vendor = module_sp->GetSymbolVendor();
if (sym_vendor) {
Symtab *symtab = sym_vendor->GetSymtab();
if (symtab) {
const addr_t file_Addr = GetFileAddress();
Symbol *symbol =
symtab->FindSymbolContainingFileAddress(file_Addr);
if (symbol) {
const char *symbol_name = symbol->GetName().AsCString();
if (symbol_name) {
s->PutCString(symbol_name);
addr_t delta =
file_Addr - symbol->GetAddressRef().GetFileAddress();
if (delta)
s->Printf(" + %" PRIu64, delta);
showed_info = true;
}
}
}
}
}
break;
case eSectionTypeDataCString:
// Read the C string from memory and display it
showed_info = true;
ReadCStringFromMemory(exe_scope, *this, s);
break;
case eSectionTypeDataCStringPointers:
if (ReadAddress(exe_scope, *this, pointer_size, so_addr)) {
#if VERBOSE_OUTPUT
s->PutCString("(char *)");
so_addr.Dump(s, exe_scope, DumpStyleLoadAddress,
DumpStyleFileAddress);
s->PutCString(": ");
#endif
showed_info = true;
ReadCStringFromMemory(exe_scope, so_addr, s);
}
break;
case eSectionTypeDataObjCMessageRefs:
if (ReadAddress(exe_scope, *this, pointer_size, so_addr)) {
if (target && so_addr.IsSectionOffset()) {
SymbolContext func_sc;
target->GetImages().ResolveSymbolContextForAddress(
so_addr, eSymbolContextEverything, func_sc);
if (func_sc.function != nullptr || func_sc.symbol != nullptr) {
showed_info = true;
#if VERBOSE_OUTPUT
s->PutCString("(objc_msgref *) -> { (func*)");
so_addr.Dump(s, exe_scope, DumpStyleLoadAddress,
DumpStyleFileAddress);
#else
s->PutCString("{ ");
#endif
Address cstr_addr(*this);
cstr_addr.SetOffset(cstr_addr.GetOffset() + pointer_size);
func_sc.DumpStopContext(s, exe_scope, so_addr, true, true,
false, true, true);
if (ReadAddress(exe_scope, cstr_addr, pointer_size, so_addr)) {
#if VERBOSE_OUTPUT
s->PutCString("), (char *)");
so_addr.Dump(s, exe_scope, DumpStyleLoadAddress,
DumpStyleFileAddress);
s->PutCString(" (");
#else
s->PutCString(", ");
#endif
ReadCStringFromMemory(exe_scope, so_addr, s);
}
#if VERBOSE_OUTPUT
s->PutCString(") }");
#else
s->PutCString(" }");
#endif
}
}
}
break;
case eSectionTypeDataObjCCFStrings: {
Address cfstring_data_addr(*this);
cfstring_data_addr.SetOffset(cfstring_data_addr.GetOffset() +
(2 * pointer_size));
if (ReadAddress(exe_scope, cfstring_data_addr, pointer_size,
so_addr)) {
#if VERBOSE_OUTPUT
s->PutCString("(CFString *) ");
cfstring_data_addr.Dump(s, exe_scope, DumpStyleLoadAddress,
DumpStyleFileAddress);
s->PutCString(" -> @");
#else
s->PutChar('@');
#endif
if (so_addr.Dump(s, exe_scope, DumpStyleResolvedDescription))
showed_info = true;
}
} break;
case eSectionTypeData4:
// Read the 4 byte data and display it
showed_info = true;
s->PutCString("(uint32_t) ");
DumpUInt(exe_scope, *this, 4, s);
break;
case eSectionTypeData8:
// Read the 8 byte data and display it
showed_info = true;
s->PutCString("(uint64_t) ");
DumpUInt(exe_scope, *this, 8, s);
break;
case eSectionTypeData16:
// Read the 16 byte data and display it
showed_info = true;
s->PutCString("(uint128_t) ");
DumpUInt(exe_scope, *this, 16, s);
break;
case eSectionTypeDataPointers:
// Read the pointer data and display it
if (ReadAddress(exe_scope, *this, pointer_size, so_addr)) {
s->PutCString("(void *)");
so_addr.Dump(s, exe_scope, DumpStyleLoadAddress,
DumpStyleFileAddress);
showed_info = true;
if (so_addr.IsSectionOffset()) {
SymbolContext pointer_sc;
if (target) {
target->GetImages().ResolveSymbolContextForAddress(
so_addr, eSymbolContextEverything, pointer_sc);
if (pointer_sc.function != nullptr ||
pointer_sc.symbol != nullptr) {
s->PutCString(": ");
pointer_sc.DumpStopContext(s, exe_scope, so_addr, true, false,
false, true, true);
}
}
}
}
break;
default:
break;
}
}
if (!showed_info) {
if (module_sp) {
SymbolContext sc;
module_sp->ResolveSymbolContextForAddress(
*this, eSymbolContextEverything, sc);
if (sc.function || sc.symbol) {
bool show_stop_context = true;
const bool show_module = (style == DumpStyleResolvedDescription);
const bool show_fullpaths = false;
const bool show_inlined_frames = true;
const bool show_function_arguments =
(style != DumpStyleResolvedDescriptionNoFunctionArguments);
const bool show_function_name = (style != DumpStyleNoFunctionName);
if (sc.function == nullptr && sc.symbol != nullptr) {
// If we have just a symbol make sure it is in the right section
if (sc.symbol->ValueIsAddress()) {
if (sc.symbol->GetAddressRef().GetSection() != GetSection()) {
// don't show the module if the symbol is a trampoline symbol
show_stop_context = false;
}
}
}
if (show_stop_context) {
// We have a function or a symbol from the same
// sections as this address.
sc.DumpStopContext(s, exe_scope, *this, show_fullpaths,
show_module, show_inlined_frames,
show_function_arguments, show_function_name);
} else {
// We found a symbol but it was in a different
// section so it isn't the symbol we should be
// showing, just show the section name + offset
Dump(s, exe_scope, DumpStyleSectionNameOffset);
}
}
}
}
} else {
if (fallback_style != DumpStyleInvalid)
return Dump(s, exe_scope, fallback_style, DumpStyleInvalid, addr_size);
return false;
}
break;
case DumpStyleDetailedSymbolContext:
if (IsSectionOffset()) {
ModuleSP module_sp(GetModule());
if (module_sp) {
SymbolContext sc;
module_sp->ResolveSymbolContextForAddress(
*this, eSymbolContextEverything | eSymbolContextVariable, sc);
if (sc.symbol) {
// If we have just a symbol make sure it is in the same section
// as our address. If it isn't, then we might have just found
// the last symbol that came before the address that we are
// looking up that has nothing to do with our address lookup.
if (sc.symbol->ValueIsAddress() &&
sc.symbol->GetAddressRef().GetSection() != GetSection())
sc.symbol = nullptr;
}
sc.GetDescription(s, eDescriptionLevelBrief, target);
if (sc.block) {
bool can_create = true;
bool get_parent_variables = true;
bool stop_if_block_is_inlined_function = false;
VariableList variable_list;
sc.block->AppendVariables(can_create, get_parent_variables,
stop_if_block_is_inlined_function,
[](Variable *) { return true; },
&variable_list);
const size_t num_variables = variable_list.GetSize();
for (size_t var_idx = 0; var_idx < num_variables; ++var_idx) {
Variable *var = variable_list.GetVariableAtIndex(var_idx).get();
if (var && var->LocationIsValidForAddress(*this)) {
s->Indent();
s->Printf(" Variable: id = {0x%8.8" PRIx64 "}, name = \"%s\"",
var->GetID(), var->GetName().GetCString());
Type *type = var->GetType();
if (type)
s->Printf(", type = \"%s\"", type->GetName().GetCString());
else
s->PutCString(", type = <unknown>");
s->PutCString(", location = ");
var->DumpLocationForAddress(s, *this);
s->PutCString(", decl = ");
var->GetDeclaration().DumpStopContext(s, false);
s->EOL();
}
}
}
}
} else {
if (fallback_style != DumpStyleInvalid)
return Dump(s, exe_scope, fallback_style, DumpStyleInvalid, addr_size);
return false;
}
break;
case DumpStyleResolvedPointerDescription: {
Process *process = exe_ctx.GetProcessPtr();
if (process) {
addr_t load_addr = GetLoadAddress(target);
if (load_addr != LLDB_INVALID_ADDRESS) {
Error memory_error;
addr_t dereferenced_load_addr =
process->ReadPointerFromMemory(load_addr, memory_error);
if (dereferenced_load_addr != LLDB_INVALID_ADDRESS) {
Address dereferenced_addr;
if (dereferenced_addr.SetLoadAddress(dereferenced_load_addr,
target)) {
StreamString strm;
if (dereferenced_addr.Dump(&strm, exe_scope,
DumpStyleResolvedDescription,
DumpStyleInvalid, addr_size)) {
s->Address(dereferenced_load_addr, addr_size, " -> ", " ");
s->Write(strm.GetData(), strm.GetSize());
return true;
}
}
}
}
}
if (fallback_style != DumpStyleInvalid)
return Dump(s, exe_scope, fallback_style, DumpStyleInvalid, addr_size);
return false;
} break;
}
return true;
}
const RichBool::detail::String& GetName(size_t idx) const
{ return (idx==size) ? Level<L>::GetName(size_t(0)) : type.GetName(idx); }
const RichBool::detail::String& GetName(size_t idx) const
{ return type.GetName(idx); }
TypeSP
DWARFASTParserGo::ParseTypeFromDWARF(const lldb_private::SymbolContext &sc, const DWARFDIE &die, lldb_private::Log *log,
bool *type_is_new_ptr)
{
TypeSP type_sp;
if (type_is_new_ptr)
*type_is_new_ptr = false;
if (die)
{
SymbolFileDWARF *dwarf = die.GetDWARF();
if (log)
{
dwarf->GetObjectFile()->GetModule()->LogMessage(
log, "DWARFASTParserGo::ParseTypeFromDWARF (die = 0x%8.8x) %s name = '%s')", die.GetOffset(),
DW_TAG_value_to_name(die.Tag()), die.GetName());
}
Type *type_ptr = dwarf->m_die_to_type.lookup(die.GetDIE());
TypeList *type_list = dwarf->GetTypeList();
if (type_ptr == NULL)
{
if (type_is_new_ptr)
*type_is_new_ptr = true;
const dw_tag_t tag = die.Tag();
bool is_forward_declaration = false;
DWARFAttributes attributes;
const char *type_name_cstr = NULL;
ConstString type_name_const_str;
Type::ResolveState resolve_state = Type::eResolveStateUnresolved;
uint64_t byte_size = 0;
uint64_t go_kind = 0;
Declaration decl;
Type::EncodingDataType encoding_data_type = Type::eEncodingIsUID;
CompilerType compiler_type;
DWARFFormValue form_value;
dw_attr_t attr;
switch (tag)
{
case DW_TAG_base_type:
case DW_TAG_pointer_type:
case DW_TAG_typedef:
case DW_TAG_unspecified_type:
{
// Set a bit that lets us know that we are currently parsing this
dwarf->m_die_to_type[die.GetDIE()] = DIE_IS_BEING_PARSED;
const size_t num_attributes = die.GetAttributes(attributes);
lldb::user_id_t encoding_uid = LLDB_INVALID_UID;
if (num_attributes > 0)
{
uint32_t i;
for (i = 0; i < num_attributes; ++i)
{
attr = attributes.AttributeAtIndex(i);
if (attributes.ExtractFormValueAtIndex(i, form_value))
{
switch (attr)
{
case DW_AT_name:
type_name_cstr = form_value.AsCString();
if (type_name_cstr)
type_name_const_str.SetCString(type_name_cstr);
break;
case DW_AT_byte_size:
byte_size = form_value.Unsigned();
break;
case DW_AT_encoding:
// = form_value.Unsigned();
break;
case DW_AT_type:
encoding_uid = form_value.Reference();
break;
case DW_AT_go_kind:
go_kind = form_value.Unsigned();
break;
default:
// Do we care about DW_AT_go_key or DW_AT_go_elem?
break;
}
}
}
}
DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\") type => 0x%8.8lx\n", dwarf->MakeUserID(die.GetOffset()),
DW_TAG_value_to_name(tag), type_name_cstr, encoding_uid);
switch (tag)
{
default:
break;
case DW_TAG_unspecified_type:
resolve_state = Type::eResolveStateFull;
compiler_type = m_ast.CreateVoidType(type_name_const_str);
break;
case DW_TAG_base_type:
resolve_state = Type::eResolveStateFull;
compiler_type = m_ast.CreateBaseType(go_kind, type_name_const_str, byte_size);
break;
case DW_TAG_pointer_type:
encoding_data_type = Type::eEncodingIsPointerUID;
break;
case DW_TAG_typedef:
encoding_data_type = Type::eEncodingIsTypedefUID;
CompilerType impl;
Type *type = dwarf->ResolveTypeUID(encoding_uid);
if (type)
{
if (go_kind == 0 && type->GetName() == type_name_const_str)
{
// Go emits extra typedefs as a forward declaration. Ignore these.
dwarf->m_die_to_type[die.GetDIE()] = type;
return type->shared_from_this();
}
impl = type->GetForwardCompilerType();
compiler_type = m_ast.CreateTypedefType (go_kind, type_name_const_str, impl);
}
break;
}
type_sp.reset(new Type(dwarf->MakeUserID(die.GetOffset()), dwarf, type_name_const_str, byte_size,
NULL, encoding_uid, encoding_data_type, &decl, compiler_type, resolve_state));
dwarf->m_die_to_type[die.GetDIE()] = type_sp.get();
}
break;
case DW_TAG_structure_type:
{
// Set a bit that lets us know that we are currently parsing this
dwarf->m_die_to_type[die.GetDIE()] = DIE_IS_BEING_PARSED;
bool byte_size_valid = false;
const size_t num_attributes = die.GetAttributes(attributes);
if (num_attributes > 0)
{
uint32_t i;
for (i = 0; i < num_attributes; ++i)
{
attr = attributes.AttributeAtIndex(i);
if (attributes.ExtractFormValueAtIndex(i, form_value))
{
switch (attr)
{
case DW_AT_name:
type_name_cstr = form_value.AsCString();
type_name_const_str.SetCString(type_name_cstr);
break;
case DW_AT_byte_size:
byte_size = form_value.Unsigned();
byte_size_valid = true;
break;
case DW_AT_go_kind:
go_kind = form_value.Unsigned();
break;
// TODO: Should we use SLICETYPE's DW_AT_go_elem?
default:
break;
}
}
}
}
// TODO(ribrdb): Do we need this?
// UniqueDWARFASTType is large, so don't create a local variables on the
// stack, put it on the heap. This function is often called recursively
// and clang isn't good and sharing the stack space for variables in different blocks.
std::unique_ptr<UniqueDWARFASTType> unique_ast_entry_ap(new UniqueDWARFASTType());
// Only try and unique the type if it has a name.
if (type_name_const_str &&
dwarf->GetUniqueDWARFASTTypeMap().Find(type_name_const_str, die, decl,
byte_size_valid ? byte_size : -1, *unique_ast_entry_ap))
{
// We have already parsed this type or from another
// compile unit. GCC loves to use the "one definition
// rule" which can result in multiple definitions
// of the same class over and over in each compile
// unit.
type_sp = unique_ast_entry_ap->m_type_sp;
if (type_sp)
{
dwarf->m_die_to_type[die.GetDIE()] = type_sp.get();
return type_sp;
}
}
DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\")\n", dwarf->MakeUserID(die.GetOffset()),
DW_TAG_value_to_name(tag), type_name_cstr);
bool compiler_type_was_created = false;
compiler_type.SetCompilerType(&m_ast, dwarf->m_forward_decl_die_to_clang_type.lookup(die.GetDIE()));
if (!compiler_type)
{
compiler_type_was_created = true;
compiler_type = m_ast.CreateStructType(go_kind, type_name_const_str, byte_size);
}
type_sp.reset(new Type(dwarf->MakeUserID(die.GetOffset()), dwarf, type_name_const_str, byte_size,
NULL, LLDB_INVALID_UID, Type::eEncodingIsUID, &decl, compiler_type,
Type::eResolveStateForward));
// Add our type to the unique type map so we don't
// end up creating many copies of the same type over
// and over in the ASTContext for our module
unique_ast_entry_ap->m_type_sp = type_sp;
unique_ast_entry_ap->m_die = die;
unique_ast_entry_ap->m_declaration = decl;
unique_ast_entry_ap->m_byte_size = byte_size;
dwarf->GetUniqueDWARFASTTypeMap().Insert(type_name_const_str, *unique_ast_entry_ap);
if (!is_forward_declaration)
{
// Always start the definition for a class type so that
// if the class has child classes or types that require
// the class to be created for use as their decl contexts
// the class will be ready to accept these child definitions.
if (die.HasChildren() == false)
{
// No children for this struct/union/class, lets finish it
m_ast.CompleteStructType(compiler_type);
}
else if (compiler_type_was_created)
{
// Leave this as a forward declaration until we need
// to know the details of the type. lldb_private::Type
// will automatically call the SymbolFile virtual function
// "SymbolFileDWARF::CompleteType(Type *)"
// When the definition needs to be defined.
dwarf->m_forward_decl_die_to_clang_type[die.GetDIE()] = compiler_type.GetOpaqueQualType();
dwarf->m_forward_decl_clang_type_to_die[compiler_type.GetOpaqueQualType()] = die.GetDIERef();
// SetHasExternalStorage (compiler_type.GetOpaqueQualType(), true);
}
}
}
break;
case DW_TAG_subprogram:
case DW_TAG_subroutine_type:
{
// Set a bit that lets us know that we are currently parsing this
dwarf->m_die_to_type[die.GetDIE()] = DIE_IS_BEING_PARSED;
bool is_variadic = false;
clang::StorageClass storage = clang::SC_None; //, Extern, Static, PrivateExtern
const size_t num_attributes = die.GetAttributes(attributes);
if (num_attributes > 0)
{
uint32_t i;
for (i = 0; i < num_attributes; ++i)
{
attr = attributes.AttributeAtIndex(i);
if (attributes.ExtractFormValueAtIndex(i, form_value))
{
switch (attr)
{
case DW_AT_name:
type_name_cstr = form_value.AsCString();
type_name_const_str.SetCString(type_name_cstr);
break;
case DW_AT_external:
if (form_value.Unsigned())
{
if (storage == clang::SC_None)
storage = clang::SC_Extern;
else
storage = clang::SC_PrivateExtern;
}
break;
case DW_AT_high_pc:
case DW_AT_low_pc:
break;
}
}
}
}
DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\")\n", dwarf->MakeUserID(die.GetOffset()),
DW_TAG_value_to_name(tag), type_name_cstr);
std::vector<CompilerType> function_param_types;
// Parse the function children for the parameters
if (die.HasChildren())
{
ParseChildParameters(sc, die, is_variadic, function_param_types);
}
// compiler_type will get the function prototype clang type after this call
compiler_type = m_ast.CreateFunctionType(type_name_const_str, function_param_types.data(),
function_param_types.size(), is_variadic);
type_sp.reset(new Type(dwarf->MakeUserID(die.GetOffset()), dwarf, type_name_const_str, 0, NULL,
LLDB_INVALID_UID, Type::eEncodingIsUID, &decl, compiler_type,
Type::eResolveStateFull));
assert(type_sp.get());
}
break;
case DW_TAG_array_type:
{
// Set a bit that lets us know that we are currently parsing this
dwarf->m_die_to_type[die.GetDIE()] = DIE_IS_BEING_PARSED;
lldb::user_id_t type_die_offset = DW_INVALID_OFFSET;
int64_t first_index = 0;
uint32_t byte_stride = 0;
uint32_t bit_stride = 0;
const size_t num_attributes = die.GetAttributes(attributes);
if (num_attributes > 0)
{
uint32_t i;
for (i = 0; i < num_attributes; ++i)
{
attr = attributes.AttributeAtIndex(i);
if (attributes.ExtractFormValueAtIndex(i, form_value))
{
switch (attr)
{
case DW_AT_name:
type_name_cstr = form_value.AsCString();
type_name_const_str.SetCString(type_name_cstr);
break;
case DW_AT_type:
type_die_offset = form_value.Reference();
break;
case DW_AT_byte_size:
break; // byte_size = form_value.Unsigned(); break;
case DW_AT_go_kind:
go_kind = form_value.Unsigned();
break;
default:
break;
}
}
}
DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\")\n", dwarf->MakeUserID(die.GetOffset()),
DW_TAG_value_to_name(tag), type_name_cstr);
Type *element_type = dwarf->ResolveTypeUID(type_die_offset);
if (element_type)
{
std::vector<uint64_t> element_orders;
ParseChildArrayInfo(sc, die, first_index, element_orders, byte_stride, bit_stride);
if (byte_stride == 0)
byte_stride = element_type->GetByteSize();
CompilerType array_element_type = element_type->GetForwardCompilerType();
if (element_orders.size() > 0)
{
if (element_orders.size() > 1)
printf("golang: unsupported multi-dimensional array %s\n", type_name_cstr);
compiler_type =
m_ast.CreateArrayType(type_name_const_str, array_element_type, element_orders[0]);
}
else
{
compiler_type = m_ast.CreateArrayType(type_name_const_str, array_element_type, 0);
}
type_sp.reset(new Type(dwarf->MakeUserID(die.GetOffset()), dwarf, type_name_const_str,
byte_stride, NULL, type_die_offset, Type::eEncodingIsUID, &decl,
compiler_type, Type::eResolveStateFull));
type_sp->SetEncodingType(element_type);
}
}
}
break;
default:
dwarf->GetObjectFile()->GetModule()->ReportError("{0x%8.8x}: unhandled type tag 0x%4.4x (%s), "
"please file a bug and attach the file at the "
"start of this error message",
die.GetOffset(), tag, DW_TAG_value_to_name(tag));
break;
}
if (type_sp.get())
{
DWARFDIE sc_parent_die = SymbolFileDWARF::GetParentSymbolContextDIE(die);
dw_tag_t sc_parent_tag = sc_parent_die.Tag();
SymbolContextScope *symbol_context_scope = NULL;
if (sc_parent_tag == DW_TAG_compile_unit)
{
symbol_context_scope = sc.comp_unit;
}
else if (sc.function != NULL && sc_parent_die)
{
symbol_context_scope =
sc.function->GetBlock(true).FindBlockByID(dwarf->MakeUserID(sc_parent_die.GetOffset()));
if (symbol_context_scope == NULL)
symbol_context_scope = sc.function;
}
if (symbol_context_scope != NULL)
{
type_sp->SetSymbolContextScope(symbol_context_scope);
}
// We are ready to put this type into the uniqued list up at the module level
type_list->Insert(type_sp);
dwarf->m_die_to_type[die.GetDIE()] = type_sp.get();
}
}
else if (type_ptr != DIE_IS_BEING_PARSED)
{
type_sp = type_ptr->shared_from_this();
}
}
return type_sp;
}
