/* Convert types from GDB to GCC
- Copyright (C) 2014-2020 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.
{
scope_component comp
= {
- decl_name (type->name ()).get (),
+ decl_name (type->name ()).get (),
lookup_symbol (type->name (), block (), VAR_DOMAIN, nullptr)
};
scope.push_back (comp);
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 (TYPE_LOW_BOUND_KIND (range) != PROP_CONST)
+ if (range->bounds ()->low.kind () != PROP_CONST)
{
const char *s = _("array type with non-constant"
" lower bound is not supported");
return instance->plugin ().error (s);
}
- if (TYPE_HIGH_BOUND_KIND (range) == PROP_LOCEXPR
- || TYPE_HIGH_BOUND_KIND (range) == PROP_LOCLIST)
+ if (range->bounds ()->high.kind () == PROP_LOCEXPR
+ || range->bounds ()->high.kind () == PROP_LOCLIST)
{
- if (TYPE_VECTOR (type))
+ if (type->is_vector ())
{
const char *s = _("variably-sized vector type is not supported");
{
LONGEST low_bound, high_bound, count;
- if (get_array_bounds (type, &low_bound, &high_bound) == 0)
+ if (!get_array_bounds (type, &low_bound, &high_bound))
count = -1;
else
{
count = high_bound + 1;
}
- if (TYPE_VECTOR (type))
+ if (type->is_vector ())
return instance->plugin ().build_vector_type (element_type, count);
return instance->plugin ().build_array_type (element_type, count);
{
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 ());
}
}
}
type and corresponding qualifier flags. */
gcc_type func_type = compile_cplus_convert_func (instance, method_type, true);
gcc_type class_type = instance->convert_type (parent_type);
- gcc_cp_qualifiers_flags quals = (enum gcc_cp_qualifiers) 0;
+ gcc_cp_qualifiers_flags quals = 0;
if (TYPE_CONST (method_type))
quals |= GCC_CP_QUALIFIER_CONST;
gcc_cp_ref_qualifiers_flags rquals = GCC_CP_REF_QUAL_NONE;
return instance->plugin ().build_method_type
- (class_type, func_type, quals, rquals);
+ (class_type, func_type, quals.raw (), rquals.raw ());
}
/* Convert a member or method pointer represented by TYPE. */
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);
(sym_kind
| get_method_access_flag (type, i, j)
| GCC_CP_FLAG_VIRTUAL_FUNCTION
- | GCC_CP_FLAG_PURE_VIRTUAL_FUNCTION),
+ | GCC_CP_FLAG_PURE_VIRTUAL_FUNCTION).raw (),
method_type, nullptr, 0, nullptr, 0);
continue;
}
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))
instance->plugin ().build_decl
(kind, overloaded_name.get (),
- sym_kind | get_method_access_flag (type, i, j),
+ (sym_kind | get_method_access_flag (type, i, j)).raw (),
method_type, nullptr, address, filename, line);
}
}
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);
gcc_type result;
if (type->code () == TYPE_CODE_STRUCT)
{
- struct gcc_vbase_array bases;
int num_baseclasses = TYPE_N_BASECLASSES (type);
+ std::vector<gcc_type> elements (num_baseclasses);
+ std::vector<enum gcc_cp_symbol_kind> flags (num_baseclasses);
- memset (&bases, 0, sizeof (bases));
+ struct gcc_vbase_array bases {};
+ bases.elements = elements.data ();
+ bases.flags = flags.data ();
+ bases.n_elements = num_baseclasses;
- if (num_baseclasses > 0)
+ for (int i = 0; i < num_baseclasses; ++i)
{
- bases.elements = XNEWVEC (gcc_type, num_baseclasses);
- bases.flags = XNEWVEC (enum gcc_cp_symbol_kind, num_baseclasses);
- bases.n_elements = num_baseclasses;
- for (int i = 0; i < num_baseclasses; ++i)
- {
- struct type *base_type = TYPE_BASECLASS (type, i);
-
- bases.flags[i] = GCC_CP_SYMBOL_BASECLASS
- | get_field_access_flag (type, i)
- | (BASETYPE_VIA_VIRTUAL (type, i)
- ? GCC_CP_FLAG_BASECLASS_VIRTUAL
- : GCC_CP_FLAG_BASECLASS_NOFLAG);
- bases.elements[i] = instance->convert_type (base_type);
- }
+ struct type *base_type = TYPE_BASECLASS (type, i);
+
+ bases.flags[i] = (GCC_CP_SYMBOL_BASECLASS
+ | get_field_access_flag (type, i)
+ | (BASETYPE_VIA_VIRTUAL (type, i)
+ ? GCC_CP_FLAG_BASECLASS_VIRTUAL
+ : GCC_CP_FLAG_BASECLASS_NOFLAG));
+ bases.elements[i] = instance->convert_type (base_type);
}
result = instance->plugin ().start_class_type
(name.get (), resuld, &bases, filename, line);
- xfree (bases.flags);
- xfree (bases.elements);
}
else
{
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 ();
instance->enter_scope (std::move (scope));
gcc_type int_type
- = instance->plugin ().get_int_type (TYPE_UNSIGNED (type),
- TYPE_LENGTH (type), nullptr);
+ = instance->plugin ().get_int_type (type->is_unsigned (),
+ 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. */
compile_cplus_convert_func (compile_cplus_instance *instance,
struct type *type, bool strip_artificial)
{
- int is_varargs = TYPE_VARARGS (type);
- struct type *target_type = TYPE_TARGET_TYPE (type);
+ int is_varargs = type->has_varargs ();
+ 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"));
}
types. Those are impossible in C, though. */
gcc_type return_type = instance->convert_type (target_type);
- struct gcc_type_array array =
- { type->num_fields (), XNEWVEC (gcc_type, type->num_fields ()) };
+ std::vector<gcc_type> elements (type->num_fields ());
+ struct gcc_type_array array = { type->num_fields (), elements.data () };
int artificials = 0;
for (int i = 0; i < type->num_fields (); ++i)
{
with some minsyms like printf (compile-cplus.exp has examples). */
gcc_type result = instance->plugin ().build_function_type
(return_type, &array, is_varargs);
- xfree (array.elements);
return result;
}
static gcc_type
compile_cplus_convert_int (compile_cplus_instance *instance, struct type *type)
{
- if (TYPE_NOSIGN (type))
+ 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_UNSIGNED (type), 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. */
gcc_type result = base;
if (quals != 0)
- result = plugin ().build_qualified_type (base, quals);
+ result = plugin ().build_qualified_type (base, quals.raw ());
return result;
}
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);
}
{
/* If we are converting a qualified type, first convert the
unqualified type and then apply the qualifiers. */
- if ((TYPE_INSTANCE_FLAGS (type) & (TYPE_INSTANCE_FLAG_CONST
- | TYPE_INSTANCE_FLAG_VOLATILE
- | TYPE_INSTANCE_FLAG_RESTRICT)) != 0)
+ if ((type->instance_flags () & (TYPE_INSTANCE_FLAG_CONST
+ | TYPE_INSTANCE_FLAG_VOLATILE
+ | TYPE_INSTANCE_FLAG_RESTRICT)) != 0)
return compile_cplus_convert_qualified (instance, type);
switch (type->code ())
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