/* Convert types from GDB to GCC
- Copyright (C) 2014-2021 Free Software Foundation, Inc.
+ Copyright (C) 2014-2022 Free Software Foundation, Inc.
This file is part of GDB.
gdb_assert (type->code () == TYPE_CODE_STRUCT);
/* If this type was not declared a class, everything is public. */
- if (!TYPE_DECLARED_CLASS (type))
+ if (!type->is_declared_class ())
return GCC_CP_ACCESS_PUBLIC;
/* Otherwise, read accessibility from the fn_field. */
scope.push_back (comp);
- if (SYMBOL_TYPE (bsymbol.symbol)->code () != TYPE_CODE_NAMESPACE)
+ if (bsymbol.symbol->type ()->code () != TYPE_CODE_NAMESPACE)
{
/* We're done. */
break;
/* This shouldn't happen since we are not attempting to
loop over user input. This name is generated by GDB
from debug info. */
- internal_error (__FILE__, __LINE__,
- _("malformed TYPE_NAME during parsing"));
+ internal_error (_("malformed TYPE_NAME during parsing"));
}
}
}
{
if (debug_compile_cplus_scopes)
{
- fprintf_unfiltered (gdb_stdlog, "entering new scope %s\n",
- host_address_to_string (&m_scopes.back ()));
+ gdb_printf (gdb_stdlog, "entering new scope %s\n",
+ host_address_to_string (&m_scopes.back ()));
}
/* Push the global namespace. */
(m_scopes.back ().begin (), m_scopes.back ().end () - 1,
[this] (const scope_component &comp)
{
- gdb_assert (SYMBOL_TYPE (comp.bsymbol.symbol)->code ()
+ gdb_assert (comp.bsymbol.symbol->type ()->code ()
== TYPE_CODE_NAMESPACE);
const char *ns = (comp.name == CP_ANONYMOUS_NAMESPACE_STR ? nullptr
{
if (debug_compile_cplus_scopes)
{
- fprintf_unfiltered (gdb_stdlog, "staying in current scope -- "
- "scopes are identical\n");
+ gdb_printf (gdb_stdlog, "staying in current scope -- "
+ "scopes are identical\n");
}
}
}
{
if (debug_compile_cplus_scopes)
{
- fprintf_unfiltered (gdb_stdlog, "leaving scope %s\n",
- host_address_to_string (¤t));
+ gdb_printf (gdb_stdlog, "leaving scope %s\n",
+ host_address_to_string (¤t));
}
/* Pop namespaces. */
std::for_each
(current.begin (),current.end () - 1,
[this] (const scope_component &comp) {
- gdb_assert (SYMBOL_TYPE (comp.bsymbol.symbol)->code ()
+ gdb_assert (comp.bsymbol.symbol->type ()->code ()
== TYPE_CODE_NAMESPACE);
this->plugin ().pop_binding_level (comp.name.c_str ());
});
else
{
if (debug_compile_cplus_scopes)
- fprintf_unfiltered (gdb_stdlog,
- "identical scopes -- not leaving scope\n");
+ gdb_printf (gdb_stdlog,
+ "identical scopes -- not leaving scope\n");
}
}
unqualified name of the type to process. */
scope_component &comp = scope.back ();
- if (!types_equal (type, SYMBOL_TYPE (comp.bsymbol.symbol))
+ if (!types_equal (type, comp.bsymbol.symbol->type ())
&& (m_scopes.empty ()
|| (m_scopes.back ().back ().bsymbol.symbol
!= comp.bsymbol.symbol)))
{
/* The type is defined inside another class(es). Convert that
type instead of defining this type. */
- convert_type (SYMBOL_TYPE (comp.bsymbol.symbol));
+ convert_type (comp.bsymbol.symbol->type ());
/* If the original type (passed in to us) is defined in a nested
class, the previous call will give us that type's gcc_type.
compile_cplus_convert_reference (compile_cplus_instance *instance,
struct type *type)
{
- gcc_type target = instance->convert_type (TYPE_TARGET_TYPE (type));
+ gcc_type target = instance->convert_type (type->target_type ());
enum gcc_cp_ref_qualifiers quals = GCC_CP_REF_QUAL_NONE;
switch (type->code ())
compile_cplus_convert_pointer (compile_cplus_instance *instance,
struct type *type)
{
- gcc_type target = instance->convert_type (TYPE_TARGET_TYPE (type));
+ gcc_type target = instance->convert_type (type->target_type ());
return instance->convert_pointer_base (target);
}
struct type *type)
{
struct type *range = type->index_type ();
- gcc_type element_type = instance->convert_type (TYPE_TARGET_TYPE (type));
+ gcc_type element_type = instance->convert_type (type->target_type ());
if (range->bounds ()->low.kind () != PROP_CONST)
{
{
for (int i = TYPE_N_BASECLASSES (type); i < type->num_fields (); ++i)
{
- const char *field_name = TYPE_FIELD_NAME (type, i);
+ const char *field_name = type->field (i).name ();
if (TYPE_FIELD_IGNORE (type, i)
|| TYPE_FIELD_ARTIFICIAL (type, i))
{
CORE_ADDR physaddr;
- switch (TYPE_FIELD_LOC_KIND (type, i))
+ switch (type->field (i).loc_kind ())
{
case FIELD_LOC_KIND_PHYSADDR:
{
- physaddr = TYPE_FIELD_STATIC_PHYSADDR (type, i);
+ physaddr = type->field (i).loc_physaddr ();
instance->plugin ().build_decl
("field physaddr", field_name,
case FIELD_LOC_KIND_PHYSNAME:
{
- const char *physname = TYPE_FIELD_STATIC_PHYSNAME (type, i);
+ const char *physname = type->field (i).loc_physname ();
struct block_symbol sym
= lookup_symbol (physname, instance->block (),
VAR_DOMAIN, nullptr);
we can do but ignore this member. */
continue;
}
- const char *filename = symbol_symtab (sym.symbol)->filename;
- unsigned int line = SYMBOL_LINE (sym.symbol);
+ const char *filename = sym.symbol->symtab ()->filename;
+ unsigned int line = sym.symbol->line ();
- physaddr = SYMBOL_VALUE_ADDRESS (sym.symbol);
+ physaddr = sym.symbol->value_address ();
instance->plugin ().build_decl
("field physname", field_name,
(GCC_CP_SYMBOL_VARIABLE| get_field_access_flag (type, i)),
| get_field_access_flag (type, i);
if (bitsize == 0)
- bitsize = 8 * TYPE_LENGTH (type->field (i).type ());
+ bitsize = 8 * type->field (i).type ()->length ();
instance->plugin ().build_field
(field_name, field_type, field_flags, bitsize,
- TYPE_FIELD_BITPOS (type, i));
+ type->field (i).loc_bitpos ());
}
}
}
gcc_type class_type = instance->convert_type (containing_class);
gcc_type member_type
- = instance->convert_type (TYPE_TARGET_TYPE (type));
+ = instance->convert_type (type->target_type ());
return instance->plugin ().build_pointer_to_member_type
(class_type, member_type);
continue;
}
- const char *filename = symbol_symtab (sym.symbol)->filename;
- unsigned int line = SYMBOL_LINE (sym.symbol);
- CORE_ADDR address = BLOCK_START (SYMBOL_BLOCK_VALUE (sym.symbol));
+ const char *filename = sym.symbol->symtab ()->filename;
+ unsigned int line = sym.symbol->line ();
+ CORE_ADDR address = sym.symbol->value_block()->start ();
const char *kind;
if (TYPE_FN_FIELD_STATIC_P (methods, j))
gcc_decl resuld;
if (type->code () == TYPE_CODE_STRUCT)
{
- const char *what = TYPE_DECLARED_CLASS (type) ? "struct" : "class";
+ const char *what = type->is_declared_class () ? "class" : "struct";
resuld = instance->plugin ().build_decl
(what, name.get (), (GCC_CP_SYMBOL_CLASS | nested_access
- | (TYPE_DECLARED_CLASS (type)
+ | (type->is_declared_class ()
? GCC_CP_FLAG_CLASS_NOFLAG
: GCC_CP_FLAG_CLASS_IS_STRUCT)),
0, nullptr, 0, filename, line);
compile_cplus_convert_struct_or_union_members (instance, type, result);
/* All finished. */
- instance->plugin ().finish_class_type (name.get (), TYPE_LENGTH (type));
+ instance->plugin ().finish_class_type (name.get (), type->length ());
/* Pop all scopes. */
instance->leave_scope ();
gcc_type int_type
= instance->plugin ().get_int_type (type->is_unsigned (),
- TYPE_LENGTH (type), nullptr);
+ type->length (), nullptr);
gcc_type result
= instance->plugin ().start_enum_type (name.get (), int_type,
GCC_CP_SYMBOL_ENUM | nested_access
for (int i = 0; i < type->num_fields (); ++i)
{
gdb::unique_xmalloc_ptr<char> fname
- = compile_cplus_instance::decl_name (TYPE_FIELD_NAME (type, i));
+ = compile_cplus_instance::decl_name (type->field (i).name ());
- if (TYPE_FIELD_LOC_KIND (type, i) != FIELD_LOC_KIND_ENUMVAL
+ if (type->field (i).loc_kind () != FIELD_LOC_KIND_ENUMVAL
|| fname == nullptr)
continue;
instance->plugin ().build_enum_constant (result, fname.get (),
- TYPE_FIELD_ENUMVAL (type, i));
+ type->field (i).loc_enumval ());
}
/* Finish enum definition and pop scopes. */
struct type *type, bool strip_artificial)
{
int is_varargs = type->has_varargs ();
- struct type *target_type = TYPE_TARGET_TYPE (type);
+ struct type *target_type = type->target_type ();
/* Functions with no debug info have no return type. Ideally we'd
want to fallback to the type of the cast just before the
GDB's parser used to do. */
if (target_type == nullptr)
{
- if (TYPE_OBJFILE_OWNED (type))
- target_type = objfile_type (TYPE_OWNER (type).objfile)->builtin_int;
+ if (type->is_objfile_owned ())
+ target_type = objfile_type (type->objfile_owner ())->builtin_int;
else
- target_type = builtin_type (TYPE_OWNER (type).gdbarch)->builtin_int;
+ target_type = builtin_type (type->arch_owner ())->builtin_int;
warning (_("function has unknown return type; assuming int"));
}
{
if (type->has_no_signedness ())
{
- gdb_assert (TYPE_LENGTH (type) == 1);
+ gdb_assert (type->length () == 1);
return instance->plugin ().get_char_type ();
}
return instance->plugin ().get_int_type
- (type->is_unsigned (), TYPE_LENGTH (type), type->name ());
+ (type->is_unsigned (), type->length (), type->name ());
}
/* Convert a floating-point type to its gcc representation. */
struct type *type)
{
return instance->plugin ().get_float_type
- (TYPE_LENGTH (type), type->name ());
+ (type->length (), type->name ());
}
/* Convert the 'void' type to its gcc representation. */
compile_cplus_convert_complex (compile_cplus_instance *instance,
struct type *type)
{
- gcc_type base = instance->convert_type (TYPE_TARGET_TYPE (type));
+ gcc_type base = instance->convert_type (type->target_type ());
return instance->plugin ().build_complex_type (base);
}
static void
compile_cplus_debug_output_1 (ULONGEST arg)
{
- fprintf_unfiltered (gdb_stdlog, "%s", pulongest (arg));
+ gdb_printf (gdb_stdlog, "%s", pulongest (arg));
}
static void
compile_cplus_debug_output_1 (const char *arg)
{
if (arg == nullptr)
- fputs_unfiltered ("NULL", gdb_stdlog);
+ gdb_puts ("NULL", gdb_stdlog);
else
- fputs_unfiltered (arg, gdb_stdlog);
+ gdb_puts (arg, gdb_stdlog);
}
static void
compile_cplus_debug_output (T arg, Targs... Args)
{
compile_cplus_debug_output_1 (arg);
- fputc_unfiltered (' ', gdb_stdlog);
+ gdb_putc (' ', gdb_stdlog);
compile_cplus_debug_output (Args...);
}
#define OUTPUT_DEBUG_RESULT(R) \
if (debug_compile_cplus_types) \
{ \
- fputs_unfiltered (": ", gdb_stdlog); \
+ gdb_puts (": ", gdb_stdlog); \
compile_cplus_debug_output (R); \
- fputc_unfiltered ('\n', gdb_stdlog); \
+ gdb_putc ('\n', gdb_stdlog); \
} \
#define GCC_METHOD0(R, N) \
const char *filename, unsigned int line_number)
{
if (debug_compile_cplus_types)
- fprintf_unfiltered (gdb_stdlog, "<%s> ", debug_decltype);
+ gdb_printf (gdb_stdlog, "<%s> ", debug_decltype);
return build_decl (name, sym_kind, sym_type, substitution_name,
address, filename, line_number);
const char *filename, unsigned int line_number)
{
if (debug_compile_cplus_types)
- fprintf_unfiltered (gdb_stdlog, "<%s> ", debug_name);
+ gdb_printf (gdb_stdlog, "<%s> ", debug_name);
return start_class_type (typedecl, base_classes, filename, line_number);
}
unsigned long size_in_bytes)
{
if (debug_compile_cplus_types)
- fprintf_unfiltered (gdb_stdlog, "<%s> ", debug_name);
+ gdb_printf (gdb_stdlog, "<%s> ", debug_name);
return finish_class_type (size_in_bytes);
}
gcc_cp_plugin::pop_binding_level (const char *debug_name)
{
if (debug_compile_cplus_types)
- fprintf_unfiltered (gdb_stdlog, "<%s> ", debug_name);
+ gdb_printf (gdb_stdlog, "<%s> ", debug_name);
return pop_binding_level ();
}
projects / binutils.git / blobdiff