#include "defs.h"
#include "gdb_string.h"
#include "bfd.h"
#include "symtab.h"
#include "symfile.h"
#include "objfiles.h"
#include "gdbtypes.h"
#include "expression.h"
#include "language.h"
#include "target.h"
#include "value.h"
#include "demangle.h"
#include "complaints.h"
#include "gdbcmd.h"
#include "varobj.h"
#include "wrapper.h"
#include "cp-abi.h"
#include "gdb_assert.h"
#include "exceptions.h"
struct type *builtin_type_void;
struct type *builtin_type_char;
struct type *builtin_type_true_char;
struct type *builtin_type_short;
struct type *builtin_type_int;
struct type *builtin_type_long;
struct type *builtin_type_long_long;
struct type *builtin_type_signed_char;
struct type *builtin_type_unsigned_char;
struct type *builtin_type_unsigned_short;
struct type *builtin_type_unsigned_int;
struct type *builtin_type_unsigned_long;
struct type *builtin_type_unsigned_long_long;
struct type *builtin_type_float;
struct type *builtin_type_double;
struct type *builtin_type_long_double;
struct type *builtin_type_complex;
struct type *builtin_type_double_complex;
struct type *builtin_type_string;
struct type *builtin_type_int0;
struct type *builtin_type_int8;
struct type *builtin_type_uint8;
struct type *builtin_type_int16;
struct type *builtin_type_uint16;
struct type *builtin_type_int32;
struct type *builtin_type_uint32;
struct type *builtin_type_int64;
struct type *builtin_type_uint64;
struct type *builtin_type_int128;
struct type *builtin_type_uint128;
struct type *builtin_type_bool;
struct type *builtin_type_v2_double;
struct type *builtin_type_v4_float;
struct type *builtin_type_v2_int64;
struct type *builtin_type_v4_int32;
struct type *builtin_type_v8_int16;
struct type *builtin_type_v16_int8;
struct type *builtin_type_v2_float;
struct type *builtin_type_v2_int32;
struct type *builtin_type_v4_int16;
struct type *builtin_type_v8_int8;
struct type *builtin_type_v4sf;
struct type *builtin_type_v4si;
struct type *builtin_type_v16qi;
struct type *builtin_type_v8qi;
struct type *builtin_type_v8hi;
struct type *builtin_type_v4hi;
struct type *builtin_type_v2si;
struct type *builtin_type_vec64;
struct type *builtin_type_vec128;
struct type *builtin_type_ieee_single[BFD_ENDIAN_UNKNOWN];
struct type *builtin_type_ieee_single_big;
struct type *builtin_type_ieee_single_little;
struct type *builtin_type_ieee_double[BFD_ENDIAN_UNKNOWN];
struct type *builtin_type_ieee_double_big;
struct type *builtin_type_ieee_double_little;
struct type *builtin_type_ieee_double_littlebyte_bigword;
struct type *builtin_type_i387_ext;
struct type *builtin_type_m68881_ext;
struct type *builtin_type_i960_ext;
struct type *builtin_type_m88110_ext;
struct type *builtin_type_m88110_harris_ext;
struct type *builtin_type_arm_ext[BFD_ENDIAN_UNKNOWN];
struct type *builtin_type_arm_ext_big;
struct type *builtin_type_arm_ext_littlebyte_bigword;
struct type *builtin_type_ia64_spill[BFD_ENDIAN_UNKNOWN];
struct type *builtin_type_ia64_spill_big;
struct type *builtin_type_ia64_spill_little;
struct type *builtin_type_ia64_quad[BFD_ENDIAN_UNKNOWN];
struct type *builtin_type_ia64_quad_big;
struct type *builtin_type_ia64_quad_little;
struct type *builtin_type_void_data_ptr;
struct type *builtin_type_void_func_ptr;
struct type *builtin_type_CORE_ADDR;
struct type *builtin_type_bfd_vma;
struct type *builtin_type_voidptrfuncptr;
int opaque_type_resolution = 1;
int use_stride = 1;
static void
show_opaque_type_resolution (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
fprintf_filtered (file, _("\
Resolution of opaque struct/class/union types (if set before loading symbols) is %s.\n"),
value);
}
int overload_debug = 0;
static void
show_overload_debug (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
fprintf_filtered (file, _("Debugging of C++ overloading is %s.\n"), value);
}
struct extra
{
char str[128];
int len;
};
static void print_bit_vector (B_TYPE *, int);
static void print_arg_types (struct field *, int, int);
static void dump_fn_fieldlists (struct type *, int);
static void print_cplus_stuff (struct type *, int);
static void virtual_base_list_aux (struct type *dclass);
struct type *
alloc_type (struct objfile *objfile)
{
struct type *type;
if (objfile == NULL)
{
type = xmalloc (sizeof (struct type));
memset (type, 0, sizeof (struct type));
TYPE_MAIN_TYPE (type) = xmalloc (sizeof (struct main_type));
}
else
{
type = obstack_alloc (&objfile->objfile_obstack,
sizeof (struct type));
memset (type, 0, sizeof (struct type));
TYPE_MAIN_TYPE (type) = obstack_alloc (&objfile->objfile_obstack,
sizeof (struct main_type));
OBJSTAT (objfile, n_types++);
}
memset (TYPE_MAIN_TYPE (type), 0, sizeof (struct main_type));
TYPE_CODE (type) = TYPE_CODE_UNDEF;
TYPE_BYTE_ORDER (type) = BFD_ENDIAN_UNKNOWN;
TYPE_OBJFILE (type) = objfile;
TYPE_VPTR_FIELDNO (type) = -1;
TYPE_CHAIN (type) = type;
return (type);
}
static struct type *
alloc_type_instance (struct type *oldtype)
{
struct type *type;
if (TYPE_OBJFILE (oldtype) == NULL)
{
type = xmalloc (sizeof (struct type));
memset (type, 0, sizeof (struct type));
}
else
{
type = obstack_alloc (&TYPE_OBJFILE (oldtype)->objfile_obstack,
sizeof (struct type));
memset (type, 0, sizeof (struct type));
}
TYPE_MAIN_TYPE (type) = TYPE_MAIN_TYPE (oldtype);
TYPE_CHAIN (type) = type;
return (type);
}
static void
smash_type (struct type *type)
{
memset (TYPE_MAIN_TYPE (type), 0, sizeof (struct main_type));
#if 0
TYPE_CHAIN (type) = type;
#endif
}
struct type *
make_pointer_type (struct type *type, struct type **typeptr)
{
struct type *ntype;
struct objfile *objfile;
ntype = TYPE_POINTER_TYPE (type);
if (ntype)
{
if (typeptr == 0)
return ntype;
else if (*typeptr == 0)
{
*typeptr = ntype;
return ntype;
}
}
if (typeptr == 0 || *typeptr == 0)
{
ntype = alloc_type (TYPE_OBJFILE (type));
if (typeptr)
*typeptr = ntype;
}
else
{
ntype = *typeptr;
objfile = TYPE_OBJFILE (ntype);
smash_type (ntype);
TYPE_OBJFILE (ntype) = objfile;
}
TYPE_TARGET_TYPE (ntype) = type;
TYPE_POINTER_TYPE (type) = ntype;
TYPE_LENGTH_ASSIGN (ntype) = TARGET_PTR_BIT / TARGET_CHAR_BIT;
TYPE_CODE (ntype) = TYPE_CODE_PTR;
TYPE_FLAGS (ntype) |= TYPE_FLAG_UNSIGNED;
if (!TYPE_POINTER_TYPE (type))
TYPE_POINTER_TYPE (type) = ntype;
return ntype;
}
struct type *
lookup_pointer_type (struct type *type)
{
return make_pointer_type (type, (struct type **) 0);
}
struct type *
make_reference_type (struct type *type, struct type **typeptr)
{
struct type *ntype;
struct objfile *objfile;
ntype = TYPE_REFERENCE_TYPE (type);
if (ntype)
{
if (typeptr == 0)
return ntype;
else if (*typeptr == 0)
{
*typeptr = ntype;
return ntype;
}
}
if (typeptr == 0 || *typeptr == 0)
{
ntype = alloc_type (TYPE_OBJFILE (type));
if (typeptr)
*typeptr = ntype;
}
else
{
ntype = *typeptr;
objfile = TYPE_OBJFILE (ntype);
smash_type (ntype);
TYPE_OBJFILE (ntype) = objfile;
}
TYPE_TARGET_TYPE (ntype) = type;
TYPE_REFERENCE_TYPE (type) = ntype;
TYPE_LENGTH_ASSIGN (ntype) = TARGET_PTR_BIT / TARGET_CHAR_BIT;
TYPE_CODE (ntype) = TYPE_CODE_REF;
if (!TYPE_REFERENCE_TYPE (type))
TYPE_REFERENCE_TYPE (type) = ntype;
return ntype;
}
struct type *
lookup_reference_type (struct type *type)
{
return make_reference_type (type, (struct type **) 0);
}
struct type *
make_function_type (struct type *type, struct type **typeptr, int optimized)
{
struct type *ntype;
struct objfile *objfile;
if (typeptr == 0 || *typeptr == 0)
{
ntype = alloc_type (TYPE_OBJFILE (type));
if (typeptr)
*typeptr = ntype;
}
else
{
ntype = *typeptr;
objfile = TYPE_OBJFILE (ntype);
smash_type (ntype);
TYPE_OBJFILE (ntype) = objfile;
}
TYPE_TARGET_TYPE (ntype) = type;
TYPE_LENGTH_ASSIGN (ntype) = 1;
TYPE_CODE (ntype) = TYPE_CODE_FUNC;
if (optimized)
TYPE_FLAGS (ntype) |= TYPE_FLAG_OPTIMIZED;
return ntype;
}
struct type *
lookup_function_type (struct type *type)
{
return make_function_type (type, (struct type **) 0, 0);
}
extern int
address_space_name_to_int (char *space_identifier)
{
struct gdbarch *gdbarch = current_gdbarch;
int type_flags;
if (!strcmp (space_identifier, "code"))
return TYPE_FLAG_CODE_SPACE;
else if (!strcmp (space_identifier, "data"))
return TYPE_FLAG_DATA_SPACE;
else if (gdbarch_address_class_name_to_type_flags_p (gdbarch)
&& gdbarch_address_class_name_to_type_flags (gdbarch,
space_identifier,
&type_flags))
return type_flags;
else
error (_("Unknown address space specifier: \"%s\""), space_identifier);
}
const char *
address_space_int_to_name (int space_flag)
{
struct gdbarch *gdbarch = current_gdbarch;
if (space_flag & TYPE_FLAG_CODE_SPACE)
return "code";
else if (space_flag & TYPE_FLAG_DATA_SPACE)
return "data";
else if ((space_flag & TYPE_FLAG_ADDRESS_CLASS_ALL)
&& gdbarch_address_class_type_flags_to_name_p (gdbarch))
return gdbarch_address_class_type_flags_to_name (gdbarch, space_flag);
else
return NULL;
}
static struct type *
make_qualified_type (struct type *type, int new_flags,
struct type *storage)
{
struct type *ntype;
struct type *elem;
ntype = type;
do {
if (TYPE_INSTANCE_FLAGS (ntype) == new_flags)
return ntype;
ntype = TYPE_CHAIN (ntype);
} while (ntype != type);
if (storage == NULL)
ntype = alloc_type_instance (type);
else
{
gdb_assert (TYPE_OBJFILE (type) == TYPE_OBJFILE (storage));
ntype = storage;
#if 0
TYPE_MAIN_TYPE (ntype) = TYPE_MAIN_TYPE (type);
#endif
#if 0
TYPE_CHAIN (ntype) = ntype;
#endif
}
#if 0
TYPE_POINTER_TYPE (ntype) = (struct type *) 0;
TYPE_REFERENCE_TYPE (ntype) = (struct type *) 0;
#endif
elem = ntype;
while (1)
{
TYPE_INSTANCE_FLAGS (elem) |= new_flags;
TYPE_LENGTH_ASSIGN (elem) = TYPE_LENGTH (type);
TYPE_MAIN_TYPE (elem) = TYPE_MAIN_TYPE (type);
if (TYPE_CHAIN (elem) == ntype)
break;
else
elem = TYPE_CHAIN (elem);
}
TYPE_CHAIN (elem) = TYPE_CHAIN (type);
TYPE_CHAIN (type) = ntype;
return ntype;
}
struct type *
make_type_with_address_space (struct type *type, int space_flag)
{
int new_flags = ((TYPE_INSTANCE_FLAGS (type)
& ~(TYPE_FLAG_CODE_SPACE | TYPE_FLAG_DATA_SPACE
| TYPE_FLAG_ADDRESS_CLASS_ALL))
| space_flag);
return make_qualified_type (type, new_flags, NULL);
}
struct type *
make_cvr_type (int cnst, int voltl, int restrct, struct type *type,
struct type **typeptr)
{
struct type *ntype;
int new_flags = (TYPE_INSTANCE_FLAGS (type)
& ~(TYPE_FLAG_CONST | TYPE_FLAG_VOLATILE | TYPE_FLAG_RESTRICT));
if (TYPE_CODE (type) == TYPE_CODE_ERROR)
{
if (typeptr != NULL)
*typeptr = builtin_type_error;
return builtin_type_error;
}
if (cnst)
new_flags |= TYPE_FLAG_CONST;
if (voltl)
new_flags |= TYPE_FLAG_VOLATILE;
if (restrct)
new_flags |= TYPE_FLAG_RESTRICT;
if (typeptr && *typeptr != NULL)
{
if (TYPE_CODE (*typeptr) == TYPE_CODE_ERROR)
{
return builtin_type_error;
}
#if 0
gdb_assert (TYPE_OBJFILE (*typeptr) == TYPE_OBJFILE (type)
|| (TYPE_STUB (*typeptr) || TYPE_IS_OPAQUE (*typeptr)));
#else
if (TYPE_OBJFILE (*typeptr) != TYPE_OBJFILE (type)
&& !TYPE_STUB (*typeptr) && !TYPE_IS_OPAQUE (*typeptr))
return builtin_type_error;
#endif
}
ntype = make_qualified_type (type, new_flags, typeptr ? *typeptr : NULL);
if (typeptr != NULL)
*typeptr = ntype;
return ntype;
}
void
replace_type (struct type *ntype, struct type *type)
{
struct type *chain;
gdb_assert (TYPE_OBJFILE (ntype) == TYPE_OBJFILE (ntype));
*TYPE_MAIN_TYPE (ntype) = *TYPE_MAIN_TYPE (type);
chain = ntype;
do {
gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain) == 0);
TYPE_LENGTH_ASSIGN (ntype) = TYPE_LENGTH (type);
chain = TYPE_CHAIN (chain);
} while (ntype != chain);
gdb_assert (TYPE_INSTANCE_FLAGS (ntype) == TYPE_INSTANCE_FLAGS (type));
}
struct type *
lookup_member_type (struct type *type, struct type *domain)
{
struct type *mtype;
mtype = alloc_type (TYPE_OBJFILE (type));
smash_to_member_type (mtype, domain, type);
return (mtype);
}
struct type *
allocate_stub_method (struct type *type)
{
struct type *mtype;
mtype = init_type (TYPE_CODE_METHOD, 1, TYPE_FLAG_STUB, NULL,
TYPE_OBJFILE (type));
TYPE_TARGET_TYPE (mtype) = type;
return (mtype);
}
struct type *
create_range_type (struct type *result_type, struct type *index_type,
int low_bound, int high_bound)
{
if (result_type == NULL)
{
result_type = alloc_type (TYPE_OBJFILE (index_type));
}
TYPE_CODE (result_type) = TYPE_CODE_RANGE;
TYPE_TARGET_TYPE (result_type) = index_type;
if (TYPE_STUB (index_type))
TYPE_FLAGS (result_type) |= TYPE_FLAG_TARGET_STUB;
else
TYPE_LENGTH_ASSIGN (result_type) = TYPE_LENGTH (check_typedef (index_type));
TYPE_NFIELDS (result_type) = 3;
TYPE_FIELDS (result_type) = (struct field *)
TYPE_ALLOC (result_type, 3 * sizeof (struct field));
memset (TYPE_FIELDS (result_type), 0, 3 * sizeof (struct field));
TYPE_FIELD_BITPOS_ASSIGN (result_type, 0) = low_bound;
TYPE_FIELD_BITPOS_ASSIGN (result_type, 1) = high_bound;
TYPE_FIELD_BITPOS_ASSIGN (result_type, 2) = 1;
TYPE_FIELD_TYPE (result_type, 0) = builtin_type_int;
TYPE_FIELD_TYPE (result_type, 1) = builtin_type_int;
TYPE_FIELD_TYPE (result_type, 2) = builtin_type_int;
if (low_bound >= 0)
TYPE_FLAGS (result_type) |= TYPE_FLAG_UNSIGNED;
return (result_type);
}
int
get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp)
{
CHECK_TYPEDEF (type);
switch (TYPE_CODE (type))
{
case TYPE_CODE_RANGE:
*lowp = TYPE_LOW_BOUND (type);
*highp = TYPE_HIGH_BOUND (type);
return 1;
case TYPE_CODE_ENUM:
if (TYPE_NFIELDS (type) > 0)
{
int i;
*lowp = *highp = TYPE_FIELD_BITPOS (type, 0);
for (i = 0; i < TYPE_NFIELDS (type); i++)
{
if (TYPE_FIELD_BITPOS (type, i) < *lowp)
*lowp = TYPE_FIELD_BITPOS (type, i);
if (TYPE_FIELD_BITPOS (type, i) > *highp)
*highp = TYPE_FIELD_BITPOS (type, i);
}
if (*lowp >= 0)
{
TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;
}
}
else
{
*lowp = 0;
*highp = -1;
}
return 0;
case TYPE_CODE_BOOL:
*lowp = 0;
*highp = 1;
return 0;
case TYPE_CODE_INT:
if (TYPE_LENGTH (type) > sizeof (LONGEST))
return -1;
if (!TYPE_UNSIGNED (type))
{
*lowp = -(1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1));
*highp = -*lowp - 1;
return 0;
}
case TYPE_CODE_CHAR:
*lowp = 0;
*highp = 1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1);
*highp = (*highp - 1) | *highp;
return 0;
default:
return -1;
}
}
int
get_array_bounds (struct type *array, LONGEST *lowp, LONGEST *highp, LONGEST *stride)
{
struct type *range = TYPE_INDEX_TYPE (array);
CHECK_TYPEDEF (range);
if (TYPE_CODE (range) != TYPE_CODE_RANGE)
internal_error (__FILE__, __LINE__, "invalid type code");
if (TYPE_STRIDE (range) == 0)
internal_error (__FILE__, __LINE__, "range type did not set stride");
*lowp = TYPE_LOW_BOUND (range);
*highp = TYPE_HIGH_BOUND (range);
if (use_stride)
*stride = TYPE_STRIDE (range);
else
*stride = 1;
return 1;
}
static struct type **undef_arrays;
static int undef_arrays_allocated;
static int undef_arrays_length;
static void
add_undefined_array (struct type *type)
{
if (undef_arrays_length == undef_arrays_allocated)
{
undef_arrays_allocated *= 2;
undef_arrays = (struct type **)
xrealloc ((char *) undef_arrays,
undef_arrays_allocated * sizeof (struct type *));
}
undef_arrays[undef_arrays_length++] = type;
}
void
cleanup_undefined_arrays (void)
{
struct type **type;
for (type = undef_arrays; type < undef_arrays + undef_arrays_length; type++)
{
struct type *range_type, *element_type;
LONGEST low_bound, high_bound;
if (TYPE_CODE (*type) != TYPE_CODE_ARRAY)
{
warning ("Got a non-array type in cleanup_undefined_arrays");
continue;
}
element_type = check_typedef(TYPE_TARGET_TYPE (*type));
range_type = TYPE_FIELD_TYPE (*type, 0);
if (element_type == NULL)
{
warning ("Got null element type for cleanup_undefined_arrays.");
continue;
}
else if (range_type == NULL)
{
warning ("Got null range type for cleanup_undefined_arrays.");
continue;
}
if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
low_bound = high_bound = 0;
CHECK_TYPEDEF (element_type);
TYPE_LENGTH_ASSIGN (*type) =
TYPE_LENGTH (element_type) * (high_bound - low_bound + 1);
TYPE_FLAGS (*type) &= ~TYPE_FLAG_TARGET_STUB;
}
undef_arrays_length = 0;
}
struct type *
create_array_type (struct type *result_type, struct type *element_type,
struct type *range_type)
{
LONGEST low_bound, high_bound;
if (result_type == NULL)
{
result_type = alloc_type (TYPE_OBJFILE (range_type));
}
TYPE_CODE (result_type) = TYPE_CODE_ARRAY;
TYPE_TARGET_TYPE (result_type) = element_type;
if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
low_bound = high_bound = 0;
CHECK_TYPEDEF (element_type);
if (TYPE_CODE (element_type) == TYPE_CODE_UNDEF
|| (TYPE_CODE (element_type) == TYPE_CODE_ARRAY
&& TYPE_LENGTH (element_type) == 0))
add_undefined_array (result_type);
TYPE_LENGTH_ASSIGN (result_type) =
TYPE_LENGTH (element_type) * (high_bound - low_bound + 1);
TYPE_NFIELDS (result_type) = 1;
TYPE_FIELDS (result_type) =
(struct field *) TYPE_ALLOC (result_type, sizeof (struct field));
memset (TYPE_FIELDS (result_type), 0, sizeof (struct field));
TYPE_FIELD_TYPE (result_type, 0) = range_type;
TYPE_VPTR_FIELDNO (result_type) = -1;
if (TYPE_LENGTH (result_type) == 0)
TYPE_FLAGS (result_type) |= TYPE_FLAG_TARGET_STUB;
return (result_type);
}
struct type *
create_string_type (struct type *result_type, struct type *range_type)
{
struct type *string_char_type;
string_char_type = language_string_char_type (current_language,
current_gdbarch);
result_type = create_array_type (result_type,
string_char_type,
range_type);
TYPE_CODE (result_type) = TYPE_CODE_STRING;
return (result_type);
}
struct type *
create_set_type (struct type *result_type, struct type *domain_type)
{
LONGEST low_bound, high_bound, bit_length;
low_bound = 0;
if (result_type == NULL)
{
result_type = alloc_type (TYPE_OBJFILE (domain_type));
}
TYPE_CODE (result_type) = TYPE_CODE_SET;
TYPE_NFIELDS (result_type) = 1;
TYPE_FIELDS (result_type) = (struct field *)
TYPE_ALLOC (result_type, 1 * sizeof (struct field));
memset (TYPE_FIELDS (result_type), 0, sizeof (struct field));
if (!TYPE_STUB (domain_type))
{
if (get_discrete_bounds (domain_type, &low_bound, &high_bound) < 0)
low_bound = high_bound = 0;
bit_length = high_bound - low_bound + 1;
TYPE_LENGTH_ASSIGN (result_type)
= (bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
}
TYPE_FIELD_TYPE (result_type, 0) = domain_type;
if (low_bound >= 0)
TYPE_FLAGS (result_type) |= TYPE_FLAG_UNSIGNED;
return (result_type);
}
static struct type *
init_simd_type (char *name,
struct type *elt_type,
char *elt_name,
int n)
{
struct type *simd_type;
struct type *array_type;
simd_type = init_composite_type (name, TYPE_CODE_STRUCT);
array_type = create_array_type (0, elt_type,
create_range_type (0, builtin_type_int,
0, n-1));
append_composite_type_field (simd_type, elt_name, array_type);
return simd_type;
}
static struct type *
init_vector_type (struct type *elt_type, int n)
{
struct type *array_type;
array_type = create_array_type (0, elt_type,
create_range_type (0, builtin_type_int,
0, n-1));
TYPE_FLAGS (array_type) |= TYPE_FLAG_VECTOR;
return array_type;
}
static struct type *
build_builtin_type_vec64 (void)
{
#if 0
union __gdb_builtin_type_vec64
{
int64_t uint64;
float v2_float[2];
int32_t v2_int32[2];
int16_t v4_int16[4];
int8_t v8_int8[8];
};
#endif
struct type *t;
t = init_composite_type ("__gdb_builtin_type_vec64", TYPE_CODE_UNION);
append_composite_type_field (t, "uint64", builtin_type_int64);
append_composite_type_field (t, "v2_float", builtin_type_v2_float);
append_composite_type_field (t, "v2_int32", builtin_type_v2_int32);
append_composite_type_field (t, "v4_int16", builtin_type_v4_int16);
append_composite_type_field (t, "v8_int8", builtin_type_v8_int8);
TYPE_FLAGS (t) |= TYPE_FLAG_VECTOR;
TYPE_NAME (t) = "builtin_type_vec64";
return t;
}
static struct type *
build_builtin_type_vec128 (void)
{
#if 0
union __gdb_builtin_type_vec128
{
int128_t uint128;
float v4_float[4];
int32_t v4_int32[4];
int16_t v8_int16[8];
int8_t v16_int8[16];
};
#endif
struct type *t;
t = init_composite_type ("__gdb_builtin_type_vec128", TYPE_CODE_UNION);
append_composite_type_field (t, "uint128", builtin_type_uint128);
append_composite_type_field (t, "v4_float", builtin_type_v4_float);
append_composite_type_field (t, "v4_int32", builtin_type_v4_int32);
append_composite_type_field (t, "v8_int16", builtin_type_v8_int16);
append_composite_type_field (t, "v16_int8", builtin_type_v16_int8);
TYPE_FLAGS (t) |= TYPE_FLAG_VECTOR;
TYPE_NAME (t) = "builtin_type_vec128";
return t;
}
void
smash_to_member_type (struct type *type, struct type *domain,
struct type *to_type)
{
struct objfile *objfile;
objfile = TYPE_OBJFILE (type);
smash_type (type);
TYPE_OBJFILE (type) = objfile;
TYPE_TARGET_TYPE (type) = to_type;
TYPE_DOMAIN_TYPE (type) = domain;
TYPE_LENGTH_ASSIGN (type) = 1;
TYPE_CODE (type) = TYPE_CODE_MEMBER;
}
void
smash_to_method_type (struct type *type, struct type *domain,
struct type *to_type, struct field *args,
int nargs, int varargs)
{
struct objfile *objfile;
objfile = TYPE_OBJFILE (type);
smash_type (type);
TYPE_OBJFILE (type) = objfile;
TYPE_TARGET_TYPE (type) = to_type;
TYPE_DOMAIN_TYPE (type) = domain;
TYPE_FIELDS (type) = args;
TYPE_NFIELDS (type) = nargs;
if (varargs)
TYPE_FLAGS (type) |= TYPE_FLAG_VARARGS;
TYPE_LENGTH_ASSIGN (type) = 1;
TYPE_CODE (type) = TYPE_CODE_METHOD;
}
char *
type_name_no_tag (const struct type *type)
{
if (TYPE_TAG_NAME (type) != NULL)
return TYPE_TAG_NAME (type);
return TYPE_NAME (type);
}
struct type *
lookup_typename (char *name, struct block *block, int noerr)
{
struct symbol *sym;
struct type *tmp;
sym = lookup_symbol (name, block, VAR_DOMAIN, 0, (struct symtab **) NULL);
if (sym == NULL || SYMBOL_CLASS (sym) != LOC_TYPEDEF)
{
tmp = language_lookup_primitive_type_by_name (current_language,
current_gdbarch,
name);
if (tmp)
{
return (tmp);
}
else if (!tmp && noerr)
{
return (NULL);
}
else
{
error (_("No type named %s."), name);
}
}
return (SYMBOL_TYPE (sym));
}
struct type *
lookup_unsigned_typename (char *name)
{
char *uns = alloca (strlen (name) + 10);
strcpy (uns, "unsigned ");
strcpy (uns + 9, name);
return (lookup_typename (uns, (struct block *) NULL, 0));
}
struct type *
lookup_signed_typename (char *name)
{
struct type *t;
char *uns = alloca (strlen (name) + 8);
strcpy (uns, "signed ");
strcpy (uns + 7, name);
t = lookup_typename (uns, (struct block *) NULL, 1);
if (t != NULL)
return t;
return lookup_typename (name, (struct block *) NULL, 0);
}
struct type *
lookup_struct (char *name, struct block *block)
{
struct symbol *sym;
sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0,
(struct symtab **) NULL);
if (sym == NULL)
{
error (_("No struct type named %s."), name);
}
if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
{
error (_("This context has class, union or enum %s, not a struct."), name);
}
return (SYMBOL_TYPE (sym));
}
struct type *
lookup_struct_no_error (name, block)
char *name;
struct block *block;
{
register struct symbol *sym;
sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0,
(struct symtab **) NULL);
if (sym == NULL)
{
return (NULL);
}
if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
{
return (NULL);
}
return (SYMBOL_TYPE (sym));
}
struct type *
lookup_union (char *name, struct block *block)
{
struct symbol *sym;
struct type *t;
sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0,
(struct symtab **) NULL);
if (sym == NULL)
error (_("No union type named %s."), name);
t = SYMBOL_TYPE (sym);
if (TYPE_CODE (t) == TYPE_CODE_UNION)
return (t);
if (HAVE_CPLUS_STRUCT (t))
if (TYPE_DECLARED_TYPE (t) == DECLARED_TYPE_UNION)
return (t);
error (_("This context has class, struct or enum %s, not a union."), name);
}
struct type *
lookup_enum (char *name, struct block *block)
{
struct symbol *sym;
sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0,
(struct symtab **) NULL);
if (sym == NULL)
{
error (_("No enum type named %s."), name);
}
if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_ENUM)
{
error (_("This context has class, struct or union %s, not an enum."), name);
}
return (SYMBOL_TYPE (sym));
}
struct type *
lookup_template_type (char *name, struct type *type, struct block *block)
{
struct symbol *sym;
char *nam = (char *) alloca (strlen (name) + strlen (TYPE_NAME (type)) + 4);
strcpy (nam, name);
strcat (nam, "<");
strcat (nam, TYPE_NAME (type));
strcat (nam, " >");
sym = lookup_symbol (nam, block, VAR_DOMAIN, 0, (struct symtab **) NULL);
if (sym == NULL)
{
error (_("No template type named %s."), name);
}
if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
{
error (_("This context has class, union or enum %s, not a struct."), name);
}
return (SYMBOL_TYPE (sym));
}
struct type *
lookup_struct_elt_type (struct type *type, char *name, int noerr)
{
int i;
char *type_for_printing;
for (;;)
{
CHECK_TYPEDEF (type);
if (TYPE_CODE (type) != TYPE_CODE_PTR
&& TYPE_CODE (type) != TYPE_CODE_REF)
break;
type = TYPE_TARGET_TYPE (type);
}
if (TYPE_CODE (type) != TYPE_CODE_STRUCT &&
TYPE_CODE (type) != TYPE_CODE_UNION)
{
target_terminal_ours ();
gdb_flush (gdb_stdout);
type_for_printing = type_sprint (type, "", -1);
make_cleanup (xfree, type_for_printing);
error ("Type %s is not a structure or union type.", type_for_printing);
}
#if 0
{
char *typename;
typename = type_name_no_tag (type);
if (typename != NULL && strcmp (typename, name) == 0)
return type;
}
#endif
for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
{
char *t_field_name = TYPE_FIELD_NAME (type, i);
if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
{
return TYPE_FIELD_TYPE (type, i);
}
}
for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
{
struct type *t;
t = lookup_struct_elt_type (TYPE_BASECLASS (type, i), name, noerr);
if (t != NULL)
{
return t;
}
}
if (noerr)
{
return NULL;
}
target_terminal_ours ();
gdb_flush (gdb_stdout);
type_for_printing = type_sprint (type, "", -1);
make_cleanup (xfree, type_for_printing);
error ("Type %s has no component named %s.", type_for_printing, name);
return (struct type *) -1;
}
void
fill_in_vptr_fieldno (struct type *type)
{
CHECK_TYPEDEF (type);
if (TYPE_VPTR_FIELDNO (type) < 0)
{
int i;
for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
{
struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
fill_in_vptr_fieldno (baseclass);
if (TYPE_VPTR_FIELDNO (baseclass) >= 0)
{
TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (baseclass);
TYPE_VPTR_BASETYPE (type) = TYPE_VPTR_BASETYPE (baseclass);
break;
}
}
}
}
int
get_destructor_fn_field (struct type *t, int *method_indexp, int *field_indexp)
{
int i;
for (i = 0; i < TYPE_NFN_FIELDS (t); i++)
{
int j;
struct fn_field *f = TYPE_FN_FIELDLIST1 (t, i);
for (j = 0; j < TYPE_FN_FIELDLIST_LENGTH (t, i); j++)
{
if (is_destructor_name (TYPE_FN_FIELD_PHYSNAME (f, j)) != 0)
{
*method_indexp = i;
*field_indexp = j;
return 1;
}
}
}
return 0;
}
static void
stub_noname_complaint (void)
{
complaint (&symfile_complaints, _("stub type has NULL name"));
}
struct type *
remove_all_typedefs (struct type *type)
{
while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF
|| TYPE_CODE (type) == TYPE_CODE_PTR
|| TYPE_CODE (type) == TYPE_CODE_REF)
{
switch (TYPE_CODE (type))
{
case TYPE_CODE_TYPEDEF:
CHECK_TYPEDEF (type);
break;
case TYPE_CODE_PTR:
type = remove_all_typedefs (TYPE_TARGET_TYPE (type));
return make_pointer_type (type, NULL);
case TYPE_CODE_REF:
type = remove_all_typedefs (TYPE_TARGET_TYPE (type));
return make_reference_type (type, NULL);
break;
default:
error ("Should never get here, keeps the compiler quiet");
}
}
return type;
}
struct type *
check_typedef (struct type *type)
{
struct type *orig_type = type;
int is_const, is_volatile, is_restrict;
while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
{
if (TYPE_TARGET_TYPE (type) == type)
{
break;
}
if (!TYPE_TARGET_TYPE (type))
{
char *name;
struct symbol *sym;
if (currently_reading_symtab)
return type;
name = type_name_no_tag (type);
if (name == NULL)
{
stub_noname_complaint ();
return type;
}
sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0,
(struct symtab **) NULL);
if (sym)
TYPE_TARGET_TYPE (type) = SYMBOL_TYPE (sym);
else
TYPE_TARGET_TYPE (type) = alloc_type (NULL);
}
type = TYPE_TARGET_TYPE (type);
}
is_const = TYPE_CONST (type);
is_volatile = TYPE_VOLATILE (type);
is_restrict= TYPE_RESTRICT (type);
if (TYPE_IS_OPAQUE (type) && opaque_type_resolution && !currently_reading_symtab)
{
char *name = type_name_no_tag (type);
struct type *newtype;
if (name == NULL)
{
stub_noname_complaint ();
return type;
}
newtype = lookup_transparent_type (name);
if (newtype)
{
if (TYPE_OBJFILE (newtype) == TYPE_OBJFILE (type))
make_cvr_type (is_const, is_volatile, is_restrict, newtype, &type);
else
type = newtype;
}
}
else if (TYPE_STUB (type) && !currently_reading_symtab)
{
char *name = type_name_no_tag (type);
struct symbol *sym;
if (name == NULL)
{
stub_noname_complaint ();
return type;
}
sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0, (struct symtab **) NULL);
if (sym)
make_cvr_type (is_const, is_volatile, is_restrict, SYMBOL_TYPE (sym), &type);
}
if (TYPE_TARGET_STUB (type))
{
struct type *range_type;
struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
if (TYPE_STUB (target_type) || TYPE_TARGET_STUB (target_type))
{
}
else if (TYPE_CODE (type) == TYPE_CODE_ARRAY
&& TYPE_NFIELDS (type) == 1
&& (TYPE_CODE (range_type = TYPE_FIELD_TYPE (type, 0))
== TYPE_CODE_RANGE))
{
TYPE_LENGTH_ASSIGN (type) =
((TYPE_FIELD_BITPOS (range_type, 1)
- TYPE_FIELD_BITPOS (range_type, 0)
+ 1)
* TYPE_LENGTH (target_type));
TYPE_FLAGS (type) &= ~TYPE_FLAG_TARGET_STUB;
}
else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
{
TYPE_LENGTH_ASSIGN (type) = TYPE_LENGTH (target_type);
TYPE_FLAGS (type) &= ~TYPE_FLAG_TARGET_STUB;
}
}
if (TYPE_TARGET_TYPE (type) == type)
{
TYPE_TARGET_TYPE (type) = alloc_type (NULL);
}
if (TYPE_LENGTH (orig_type) != TYPE_LENGTH (type))
TYPE_LENGTH_ASSIGN (orig_type) = TYPE_LENGTH (type);
return type;
}
static struct type *
safe_parse_type (char *p, int length)
{
struct ui_file *saved_gdb_stderr;
struct type *type;
saved_gdb_stderr = gdb_stderr;
gdb_stderr = ui_file_new ();
if (!gdb_parse_and_eval_type (p, length, &type))
type = builtin_type_void;
ui_file_delete (gdb_stderr);
gdb_stderr = saved_gdb_stderr;
return type;
}
static void
check_stub_method (struct type *type, int method_id, int signature_id)
{
struct fn_field *f;
char *mangled_name = gdb_mangle_name (type, method_id, signature_id);
char *demangled_name = cplus_demangle (mangled_name,
DMGL_PARAMS | DMGL_ANSI);
char *argtypetext, *p;
int depth = 0, argcount = 1;
struct field *argtypes;
struct type *mtype;
if (demangled_name)
p = strchr (demangled_name, '(');
else
p = NULL;
if (demangled_name == NULL || p == NULL)
error (_("Internal: Cannot demangle mangled name `%s'."), mangled_name);
p += 1;
argtypetext = p;
while (*p)
{
if (*p == '(' || *p == '<')
{
depth += 1;
}
else if (*p == ')' || *p == '>')
{
depth -= 1;
}
else if (*p == ',' && depth == 0)
{
argcount += 1;
}
p += 1;
}
if (strncmp (argtypetext, "(void)", 6) == 0)
argcount -= 1;
argtypes = (struct field *)
TYPE_ALLOC (type, (argcount + 1) * sizeof (struct field));
p = argtypetext;
f = TYPE_FN_FIELDLIST1 (type, method_id);
if (TYPE_FN_FIELD_STATIC_P (f, signature_id))
argcount = 0;
else
{
argtypes[0].type = lookup_pointer_type (type);
argcount = 1;
}
if (*p != ')')
{
depth = 0;
while (*p)
{
if (depth <= 0 && (*p == ',' || *p == ')'))
{
if (strncmp (argtypetext, "...", p - argtypetext) != 0
&& strncmp (argtypetext, "void", p - argtypetext) != 0)
{
argtypes[argcount].type =
safe_parse_type (argtypetext, p - argtypetext);
argcount += 1;
}
argtypetext = p + 1;
}
if (*p == '(' || *p == '<')
{
depth += 1;
}
else if (*p == ')' || *p == '>')
{
depth -= 1;
}
p += 1;
}
}
TYPE_FN_FIELD_PHYSNAME (f, signature_id) = mangled_name;
mtype = TYPE_FN_FIELD_TYPE (f, signature_id);
TYPE_DOMAIN_TYPE (mtype) = type;
TYPE_FIELDS (mtype) = argtypes;
TYPE_NFIELDS (mtype) = argcount;
TYPE_FLAGS (mtype) &= ~TYPE_FLAG_STUB;
TYPE_FN_FIELD_STUB (f, signature_id) = 0;
if (p[-2] == '.')
TYPE_FLAGS (mtype) |= TYPE_FLAG_VARARGS;
xfree (demangled_name);
}
void
check_stub_method_group (struct type *type, int method_id)
{
int len = TYPE_FN_FIELDLIST_LENGTH (type, method_id);
struct fn_field *f = TYPE_FN_FIELDLIST1 (type, method_id);
int j, found_stub = 0;
for (j = 0; j < len; j++)
if (TYPE_FN_FIELD_STUB (f, j))
{
found_stub = 1;
check_stub_method (type, method_id, j);
}
if (found_stub && strncmp (TYPE_FN_FIELD_PHYSNAME (f, 0), "_Z", 2) != 0)
{
int ret;
char dem_opname[256];
ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type, method_id),
dem_opname, DMGL_ANSI);
if (!ret)
ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type, method_id),
dem_opname, 0);
if (ret)
{
TYPE_FN_FIELDLIST_NAME (type, method_id) =
TYPE_ALLOC (type, strlen (dem_opname) + 1);
strcpy (TYPE_FN_FIELDLIST_NAME (type, method_id), dem_opname);
}
}
}
struct cplus_struct_type cplus_struct_default;
void
allocate_cplus_struct_type (struct type *type)
{
if (!HAVE_CPLUS_STRUCT (type))
{
TYPE_CPLUS_SPECIFIC (type) = (struct cplus_struct_type *)
TYPE_ALLOC (type, sizeof (struct cplus_struct_type));
*(TYPE_CPLUS_SPECIFIC (type)) = cplus_struct_default;
}
}
struct type *
init_type (enum type_code code, int length, int flags, char *name,
struct objfile *objfile)
{
struct type *type;
type = alloc_type (objfile);
TYPE_CODE (type) = code;
TYPE_LENGTH_ASSIGN (type) = length;
TYPE_FLAGS (type) |= flags;
if ((name != NULL) && (objfile != NULL))
{
TYPE_NAME (type) =
obsavestring (name, strlen (name), &objfile->objfile_obstack);
}
else
{
TYPE_NAME (type) = name;
}
if (name && strcmp (name, "char") == 0)
TYPE_FLAGS (type) |= TYPE_FLAG_NOSIGN;
if (code == TYPE_CODE_FLT && name && strcmp (name, "long double") == 0)
{
if (length * TARGET_CHAR_BIT != TARGET_LONG_DOUBLE_BIT)
{
TYPE_FLOATFORMAT(type) = gdbarch_long_double_format (current_gdbarch);
}
}
if (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION
|| code == TYPE_CODE_NAMESPACE)
{
INIT_CPLUS_SPECIFIC (type);
}
return (type);
}
struct type *
init_composite_type (char *name, enum type_code code)
{
struct type *t;
gdb_assert (code == TYPE_CODE_STRUCT
|| code == TYPE_CODE_UNION);
t = init_type (code, 0, 0, NULL, NULL);
TYPE_TAG_NAME (t) = name;
return t;
}
void
append_composite_type_field (struct type *t, char *name, struct type *field)
{
struct field *f;
TYPE_NFIELDS (t) = TYPE_NFIELDS (t) + 1;
TYPE_FIELDS (t) = xrealloc (TYPE_FIELDS (t),
sizeof (struct field) * TYPE_NFIELDS (t));
f = &(TYPE_FIELDS (t)[TYPE_NFIELDS (t) - 1]);
memset (f, 0, sizeof f[0]);
FIELD_TYPE (f[0]) = field;
FIELD_NAME (f[0]) = name;
if (TYPE_CODE (t) == TYPE_CODE_UNION)
{
if (TYPE_LENGTH (t) < TYPE_LENGTH (field))
TYPE_LENGTH_ASSIGN (t) = TYPE_LENGTH (field);
}
else if (TYPE_CODE (t) == TYPE_CODE_STRUCT)
{
TYPE_LENGTH_ASSIGN (t) = TYPE_LENGTH (t) + TYPE_LENGTH (field);
if (TYPE_NFIELDS (t) > 1)
{
FIELD_BITPOS (f[0]) = (FIELD_BITPOS (f[-1])
+ TYPE_LENGTH (field) * TARGET_CHAR_BIT);
}
}
}
struct type *
lookup_fundamental_type (struct objfile *objfile, int typeid)
{
struct type **typep;
int nbytes;
if (typeid < 0 || typeid >= FT_NUM_MEMBERS)
{
error (_("internal error - invalid fundamental type id %d"), typeid);
}
if (objfile->fundamental_types == NULL)
{
nbytes = FT_NUM_MEMBERS * sizeof (struct type *);
objfile->fundamental_types = (struct type **)
obstack_alloc (&objfile->objfile_obstack, nbytes);
memset ((char *) objfile->fundamental_types, 0, nbytes);
OBJSTAT (objfile, n_types += FT_NUM_MEMBERS);
}
typep = objfile->fundamental_types + typeid;
if (*typep == NULL)
{
*typep = create_fundamental_type (objfile, typeid);
}
return (*typep);
}
int
can_dereference (struct type *t)
{
CHECK_TYPEDEF (t);
return
(t != NULL
&& TYPE_CODE (t) == TYPE_CODE_PTR
&& TYPE_CODE (TYPE_TARGET_TYPE (t)) != TYPE_CODE_VOID);
}
int
is_integral_type (struct type *t)
{
CHECK_TYPEDEF (t);
return
((t != NULL)
&& ((TYPE_CODE (t) == TYPE_CODE_INT)
|| (TYPE_CODE (t) == TYPE_CODE_ENUM)
|| (TYPE_CODE (t) == TYPE_CODE_CHAR)
|| (TYPE_CODE (t) == TYPE_CODE_RANGE)
|| (TYPE_CODE (t) == TYPE_CODE_BOOL)));
}
int
is_ancestor (struct type *base, struct type *dclass)
{
int i;
CHECK_TYPEDEF (base);
CHECK_TYPEDEF (dclass);
if (base == dclass)
return 1;
if (TYPE_NAME (base) && TYPE_NAME (dclass) &&
!strcmp (TYPE_NAME (base), TYPE_NAME (dclass)))
return 1;
for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
if (is_ancestor (base, TYPE_BASECLASS (dclass, i)))
return 1;
return 0;
}
int
is_ancestor_by_name (const char *base, struct type *dclass)
{
int i;
CHECK_TYPEDEF (dclass);
if (TYPE_NAME (dclass) &&
!strcmp (base, TYPE_NAME (dclass)))
return 1;
for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
if (is_ancestor_by_name (base, TYPE_BASECLASS (dclass, i)))
return 1;
return 0;
}
int
has_vtable (struct type *dclass)
{
int i;
if (TYPE_CODE (dclass) != TYPE_CODE_CLASS)
return 0;
if (TYPE_FIELD_VIRTUAL_BITS (dclass))
for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
if (B_TST (TYPE_FIELD_VIRTUAL_BITS (dclass), i))
return 1;
if (TYPE_FN_FIELDLISTS (dclass))
for (i = 0; i < TYPE_NFN_FIELDS (dclass); i++)
if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (dclass, i), 0))
return 1;
if (TYPE_FIELD_VIRTUAL_BITS (dclass))
for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
if ((!B_TST (TYPE_FIELD_VIRTUAL_BITS (dclass), i)) &&
(has_vtable (TYPE_FIELD_TYPE (dclass, i))))
return 1;
return 0;
}
struct type *
primary_base_class (struct type *dclass)
{
int i;
if (TYPE_CODE (dclass) != TYPE_CODE_CLASS)
return NULL;
for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
if (!TYPE_FIELD_VIRTUAL (dclass, i) &&
has_vtable (TYPE_FIELD_TYPE (dclass, i)))
return TYPE_FIELD_TYPE (dclass, i);
return NULL;
}
static struct vbase *current_vbase_list = NULL;
static void
virtual_base_list_aux (struct type *dclass)
{
struct vbase *tmp_vbase;
int i;
if (TYPE_CODE (dclass) != TYPE_CODE_CLASS)
return;
for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
{
virtual_base_list_aux (TYPE_FIELD_TYPE (dclass, i));
if (BASETYPE_VIA_VIRTUAL (dclass, i))
{
struct type *basetype = TYPE_FIELD_TYPE (dclass, i);
tmp_vbase = current_vbase_list;
while (tmp_vbase)
{
if (tmp_vbase->vbasetype == basetype)
break;
tmp_vbase = tmp_vbase->next;
}
if (!tmp_vbase)
{
tmp_vbase = (struct vbase *) xmalloc (sizeof (struct vbase));
tmp_vbase->vbasetype = basetype;
tmp_vbase->next = current_vbase_list;
current_vbase_list = tmp_vbase;
}
}
}
}
struct type **
virtual_base_list (struct type *dclass)
{
struct vbase *tmp_vbase;
struct vbase *tmp_vbase_2;
int i;
int count;
struct type **vbase_array;
current_vbase_list = NULL;
virtual_base_list_aux (dclass);
for (i = 0, tmp_vbase = current_vbase_list; tmp_vbase != NULL; i++, tmp_vbase = tmp_vbase->next)
;
count = i;
vbase_array = (struct type **) xmalloc ((count + 1) * sizeof (struct type *));
for (i = count - 1, tmp_vbase = current_vbase_list; i >= 0; i--, tmp_vbase = tmp_vbase->next)
vbase_array[i] = tmp_vbase->vbasetype;
tmp_vbase_2 = tmp_vbase = current_vbase_list;
while (tmp_vbase)
{
tmp_vbase = tmp_vbase->next;
xfree (tmp_vbase_2);
tmp_vbase_2 = tmp_vbase;
}
vbase_array[count] = NULL;
return vbase_array;
}
int
virtual_base_list_length (struct type *dclass)
{
int i;
struct vbase *tmp_vbase;
current_vbase_list = NULL;
virtual_base_list_aux (dclass);
for (i = 0, tmp_vbase = current_vbase_list; tmp_vbase != NULL; i++, tmp_vbase = tmp_vbase->next)
;
return i;
}
int
virtual_base_list_length_skip_primaries (struct type *dclass)
{
int i;
struct vbase *tmp_vbase;
struct type *primary;
primary = TYPE_RUNTIME_PTR (dclass) ? TYPE_PRIMARY_BASE (dclass) : NULL;
if (!primary)
return virtual_base_list_length (dclass);
current_vbase_list = NULL;
virtual_base_list_aux (dclass);
for (i = 0, tmp_vbase = current_vbase_list; tmp_vbase != NULL; tmp_vbase = tmp_vbase->next)
{
if (virtual_base_index (tmp_vbase->vbasetype, primary) >= 0)
continue;
i++;
}
return i;
}
int
virtual_base_index (struct type *base, struct type *dclass)
{
struct type *vbase;
int i;
if ((TYPE_CODE (dclass) != TYPE_CODE_CLASS) ||
(TYPE_CODE (base) != TYPE_CODE_CLASS))
return -1;
i = 0;
vbase = virtual_base_list (dclass)[0];
while (vbase)
{
if (vbase == base)
break;
vbase = virtual_base_list (dclass)[++i];
}
return vbase ? i : -1;
}
int
virtual_base_index_skip_primaries (struct type *base, struct type *dclass)
{
struct type *vbase;
int i, j;
struct type *primary;
if ((TYPE_CODE (dclass) != TYPE_CODE_CLASS) ||
(TYPE_CODE (base) != TYPE_CODE_CLASS))
return -1;
primary = TYPE_RUNTIME_PTR (dclass) ? TYPE_PRIMARY_BASE (dclass) : NULL;
j = -1;
i = 0;
vbase = virtual_base_list (dclass)[0];
while (vbase)
{
if (!primary || (virtual_base_index_skip_primaries (vbase, primary) < 0))
j++;
if (vbase == base)
break;
vbase = virtual_base_list (dclass)[++i];
}
return vbase ? j : -1;
}
int
class_index_in_primary_list (struct type *dclass)
{
struct type *pbc;
pbc = TYPE_PRIMARY_BASE (dclass);
if (pbc)
return 1 + class_index_in_primary_list (pbc);
else
return 0;
}
int
count_virtual_fns (struct type *dclass)
{
int fn, oi;
int vfuncs;
struct type *pbc = primary_base_class (dclass);
if (pbc)
vfuncs = count_virtual_fns (pbc);
else
vfuncs = 0;
for (fn = 0; fn < TYPE_NFN_FIELDS (dclass); fn++)
for (oi = 0; oi < TYPE_FN_FIELDLIST_LENGTH (dclass, fn); oi++)
if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (dclass, fn), oi))
vfuncs++;
return vfuncs;
}
int
compare_badness (struct badness_vector *a, struct badness_vector *b)
{
int i;
int tmp;
short found_pos = 0;
short found_neg = 0;
if (a->length != b->length)
return 1;
for (i = 0; i < a->length; i++)
{
tmp = a->rank[i] - b->rank[i];
if (tmp > 0)
found_pos = 1;
else if (tmp < 0)
found_neg = 1;
}
if (found_pos)
{
if (found_neg)
return 1;
else
return 3;
}
else
{
if (found_neg)
return 2;
else
return 0;
}
}
struct badness_vector *
rank_function (struct type **parms, int nparms, struct type **args, int nargs)
{
int i;
struct badness_vector *bv;
int min_len = nparms < nargs ? nparms : nargs;
bv = xmalloc (sizeof (struct badness_vector));
bv->length = nargs + 1;
bv->rank = xmalloc ((nargs + 1) * sizeof (int));
LENGTH_MATCH (bv) = (nargs != nparms) ? LENGTH_MISMATCH_BADNESS : 0;
for (i = 1; i <= min_len; i++)
bv->rank[i] = rank_one_type (parms[i-1], args[i-1]);
for (i = min_len + 1; i <= nargs; i++)
bv->rank[i] = TOO_FEW_PARAMS_BADNESS;
return bv;
}
static int
integer_types_same_name_p (const char *first, const char *second)
{
int first_p, second_p;
first_p = (strstr (first, "short") != NULL);
second_p = (strstr (second, "short") != NULL);
if (first_p && second_p)
return 1;
if (first_p || second_p)
return 0;
first_p = (strstr (first, "long") != NULL);
second_p = (strstr (second, "long") != NULL);
if (first_p && second_p)
return 1;
if (first_p || second_p)
return 0;
first_p = (strstr (first, "char") != NULL);
second_p = (strstr (second, "char") != NULL);
if (first_p && second_p)
return 1;
if (first_p || second_p)
return 0;
return 1;
}
int
rank_one_type (struct type *parm, struct type *arg)
{
if (parm == arg)
return 0;
if (TYPE_CODE (parm) == TYPE_CODE_TYPEDEF)
parm = check_typedef (parm);
if (TYPE_CODE (arg) == TYPE_CODE_TYPEDEF)
arg = check_typedef (arg);
if (TYPE_NAME (parm) && TYPE_NAME (arg) &&
!strcmp (TYPE_NAME (parm), TYPE_NAME (arg)))
return 0;
if (parm == arg)
return 0;
if (TYPE_CODE (arg) == TYPE_CODE_REF)
return (rank_one_type (parm, TYPE_TARGET_TYPE (arg))
+ REFERENCE_CONVERSION_BADNESS);
if (TYPE_CODE (parm) == TYPE_CODE_REF)
return (rank_one_type (TYPE_TARGET_TYPE (parm), arg)
+ REFERENCE_CONVERSION_BADNESS);
if (overload_debug)
fprintf_filtered (gdb_stderr,"------ Arg is %s [%d], parm is %s [%d]\n",
TYPE_NAME (arg), TYPE_CODE (arg), TYPE_NAME (parm), TYPE_CODE (parm));
switch (TYPE_CODE (parm))
{
case TYPE_CODE_PTR:
switch (TYPE_CODE (arg))
{
case TYPE_CODE_PTR:
if (TYPE_CODE (TYPE_TARGET_TYPE (parm)) == TYPE_CODE_VOID)
return VOID_PTR_CONVERSION_BADNESS;
else
return rank_one_type (TYPE_TARGET_TYPE (parm), TYPE_TARGET_TYPE (arg));
case TYPE_CODE_ARRAY:
return rank_one_type (TYPE_TARGET_TYPE (parm), TYPE_TARGET_TYPE (arg));
case TYPE_CODE_FUNC:
return rank_one_type (TYPE_TARGET_TYPE (parm), arg);
case TYPE_CODE_INT:
case TYPE_CODE_ENUM:
case TYPE_CODE_CHAR:
case TYPE_CODE_RANGE:
case TYPE_CODE_BOOL:
return POINTER_CONVERSION_BADNESS;
default:
return INCOMPATIBLE_TYPE_BADNESS;
}
case TYPE_CODE_ARRAY:
switch (TYPE_CODE (arg))
{
case TYPE_CODE_PTR:
case TYPE_CODE_ARRAY:
return rank_one_type (TYPE_TARGET_TYPE (parm), TYPE_TARGET_TYPE (arg));
default:
return INCOMPATIBLE_TYPE_BADNESS;
}
case TYPE_CODE_FUNC:
switch (TYPE_CODE (arg))
{
case TYPE_CODE_PTR:
return rank_one_type (parm, TYPE_TARGET_TYPE (arg));
default:
return INCOMPATIBLE_TYPE_BADNESS;
}
case TYPE_CODE_INT:
switch (TYPE_CODE (arg))
{
case TYPE_CODE_INT:
if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
{
if (TYPE_NOSIGN (parm))
{
if (TYPE_NOSIGN (arg))
return 0;
else
return INTEGER_CONVERSION_BADNESS;
}
else if (TYPE_UNSIGNED (parm))
{
if (TYPE_UNSIGNED (arg))
{
if (integer_types_same_name_p (TYPE_NAME (parm), TYPE_NAME (arg)))
return 0;
else if (integer_types_same_name_p (TYPE_NAME (arg), "int")
&& integer_types_same_name_p (TYPE_NAME (parm), "long"))
return INTEGER_PROMOTION_BADNESS;
else
return INTEGER_CONVERSION_BADNESS;
}
else
{
if (integer_types_same_name_p (TYPE_NAME (arg), "long")
&& integer_types_same_name_p (TYPE_NAME (parm), "int"))
return INTEGER_CONVERSION_BADNESS;
else
return INTEGER_CONVERSION_BADNESS;
}
}
else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
{
if (integer_types_same_name_p (TYPE_NAME (parm), TYPE_NAME (arg)))
return 0;
else if (integer_types_same_name_p (TYPE_NAME (arg), "int")
&& integer_types_same_name_p (TYPE_NAME (parm), "long"))
return INTEGER_PROMOTION_BADNESS;
else
return INTEGER_CONVERSION_BADNESS;
}
else
return INTEGER_CONVERSION_BADNESS;
}
else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
return INTEGER_PROMOTION_BADNESS;
else
return INTEGER_CONVERSION_BADNESS;
case TYPE_CODE_ENUM:
case TYPE_CODE_CHAR:
case TYPE_CODE_RANGE:
case TYPE_CODE_BOOL:
return INTEGER_PROMOTION_BADNESS;
case TYPE_CODE_FLT:
return INT_FLOAT_CONVERSION_BADNESS;
case TYPE_CODE_PTR:
return NS_POINTER_CONVERSION_BADNESS;
default:
return INCOMPATIBLE_TYPE_BADNESS;
}
break;
case TYPE_CODE_ENUM:
switch (TYPE_CODE (arg))
{
case TYPE_CODE_INT:
case TYPE_CODE_CHAR:
case TYPE_CODE_RANGE:
case TYPE_CODE_BOOL:
case TYPE_CODE_ENUM:
return INTEGER_CONVERSION_BADNESS;
case TYPE_CODE_FLT:
return INT_FLOAT_CONVERSION_BADNESS;
default:
return INCOMPATIBLE_TYPE_BADNESS;
}
break;
case TYPE_CODE_CHAR:
switch (TYPE_CODE (arg))
{
case TYPE_CODE_RANGE:
case TYPE_CODE_BOOL:
case TYPE_CODE_ENUM:
return INTEGER_CONVERSION_BADNESS;
case TYPE_CODE_FLT:
return INT_FLOAT_CONVERSION_BADNESS;
case TYPE_CODE_INT:
if (TYPE_LENGTH (arg) > TYPE_LENGTH (parm))
return INTEGER_CONVERSION_BADNESS;
else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
return INTEGER_PROMOTION_BADNESS;
case TYPE_CODE_CHAR:
if (TYPE_NOSIGN (parm))
{
if (TYPE_NOSIGN (arg))
return 0;
else
return INTEGER_CONVERSION_BADNESS;
}
else if (TYPE_UNSIGNED (parm))
{
if (TYPE_UNSIGNED (arg))
return 0;
else
return INTEGER_PROMOTION_BADNESS;
}
else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
return 0;
else
return INTEGER_CONVERSION_BADNESS;
default:
return INCOMPATIBLE_TYPE_BADNESS;
}
break;
case TYPE_CODE_RANGE:
switch (TYPE_CODE (arg))
{
case TYPE_CODE_INT:
case TYPE_CODE_CHAR:
case TYPE_CODE_RANGE:
case TYPE_CODE_BOOL:
case TYPE_CODE_ENUM:
return INTEGER_CONVERSION_BADNESS;
case TYPE_CODE_FLT:
return INT_FLOAT_CONVERSION_BADNESS;
default:
return INCOMPATIBLE_TYPE_BADNESS;
}
break;
case TYPE_CODE_BOOL:
switch (TYPE_CODE (arg))
{
case TYPE_CODE_INT:
case TYPE_CODE_CHAR:
case TYPE_CODE_RANGE:
case TYPE_CODE_ENUM:
case TYPE_CODE_FLT:
case TYPE_CODE_PTR:
return BOOLEAN_CONVERSION_BADNESS;
case TYPE_CODE_BOOL:
return 0;
default:
return INCOMPATIBLE_TYPE_BADNESS;
}
break;
case TYPE_CODE_FLT:
switch (TYPE_CODE (arg))
{
case TYPE_CODE_FLT:
if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
return FLOAT_PROMOTION_BADNESS;
else if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
return 0;
else
return FLOAT_CONVERSION_BADNESS;
case TYPE_CODE_INT:
case TYPE_CODE_BOOL:
case TYPE_CODE_ENUM:
case TYPE_CODE_RANGE:
case TYPE_CODE_CHAR:
return INT_FLOAT_CONVERSION_BADNESS;
default:
return INCOMPATIBLE_TYPE_BADNESS;
}
break;
case TYPE_CODE_COMPLEX:
switch (TYPE_CODE (arg))
{
case TYPE_CODE_FLT:
return FLOAT_PROMOTION_BADNESS;
case TYPE_CODE_COMPLEX:
return 0;
default:
return INCOMPATIBLE_TYPE_BADNESS;
}
break;
case TYPE_CODE_STRUCT:
switch (TYPE_CODE (arg))
{
case TYPE_CODE_STRUCT:
if (is_ancestor (parm, arg))
return BASE_CONVERSION_BADNESS;
default:
return INCOMPATIBLE_TYPE_BADNESS;
}
break;
case TYPE_CODE_UNION:
switch (TYPE_CODE (arg))
{
case TYPE_CODE_UNION:
default:
return INCOMPATIBLE_TYPE_BADNESS;
}
break;
case TYPE_CODE_MEMBER:
switch (TYPE_CODE (arg))
{
default:
return INCOMPATIBLE_TYPE_BADNESS;
}
break;
case TYPE_CODE_METHOD:
switch (TYPE_CODE (arg))
{
default:
return INCOMPATIBLE_TYPE_BADNESS;
}
break;
case TYPE_CODE_REF:
switch (TYPE_CODE (arg))
{
default:
return INCOMPATIBLE_TYPE_BADNESS;
}
break;
case TYPE_CODE_SET:
switch (TYPE_CODE (arg))
{
case TYPE_CODE_SET:
return rank_one_type (TYPE_FIELD_TYPE (parm, 0), TYPE_FIELD_TYPE (arg, 0));
default:
return INCOMPATIBLE_TYPE_BADNESS;
}
break;
case TYPE_CODE_VOID:
default:
return INCOMPATIBLE_TYPE_BADNESS;
}
}
static void
print_bit_vector (B_TYPE *bits, int nbits)
{
int bitno;
for (bitno = 0; bitno < nbits; bitno++)
{
if ((bitno % 8) == 0)
{
puts_filtered (" ");
}
if (B_TST (bits, bitno))
printf_filtered (("1"));
else
printf_filtered (("0"));
}
}
static void
print_arg_types (struct field *args, int nargs, int spaces)
{
if (args != NULL)
{
int i;
for (i = 0; i < nargs; i++)
recursive_dump_type (args[i].type, spaces + 2);
}
}
static void
dump_fn_fieldlists (struct type *type, int spaces)
{
int method_idx;
int overload_idx;
struct fn_field *f;
printfi_filtered (spaces, "fn_fieldlists ");
gdb_print_host_address (TYPE_FN_FIELDLISTS (type), gdb_stdout);
printf_filtered ("\n");
for (method_idx = 0; method_idx < TYPE_NFN_FIELDS (type); method_idx++)
{
f = TYPE_FN_FIELDLIST1 (type, method_idx);
printfi_filtered (spaces + 2, "[%d] name '%s' (",
method_idx,
TYPE_FN_FIELDLIST_NAME (type, method_idx));
gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type, method_idx),
gdb_stdout);
printf_filtered (_(") length %d\n"),
TYPE_FN_FIELDLIST_LENGTH (type, method_idx));
for (overload_idx = 0;
overload_idx < TYPE_FN_FIELDLIST_LENGTH (type, method_idx);
overload_idx++)
{
printfi_filtered (spaces + 4, "[%d] physname '%s' (",
overload_idx,
TYPE_FN_FIELD_PHYSNAME (f, overload_idx));
gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f, overload_idx),
gdb_stdout);
printf_filtered (")\n");
printfi_filtered (spaces + 8, "type ");
gdb_print_host_address (TYPE_FN_FIELD_TYPE (f, overload_idx), gdb_stdout);
printf_filtered ("\n");
recursive_dump_type (TYPE_FN_FIELD_TYPE (f, overload_idx),
spaces + 8 + 2);
printfi_filtered (spaces + 8, "args ");
gdb_print_host_address (TYPE_FN_FIELD_ARGS (f, overload_idx), gdb_stdout);
printf_filtered ("\n");
print_arg_types (TYPE_FN_FIELD_ARGS (f, overload_idx),
TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f, overload_idx)),
spaces);
printfi_filtered (spaces + 8, "fcontext ");
gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f, overload_idx),
gdb_stdout);
printf_filtered ("\n");
printfi_filtered (spaces + 8, "is_const %d\n",
TYPE_FN_FIELD_CONST (f, overload_idx));
printfi_filtered (spaces + 8, "is_volatile %d\n",
TYPE_FN_FIELD_VOLATILE (f, overload_idx));
printfi_filtered (spaces + 8, "is_private %d\n",
TYPE_FN_FIELD_PRIVATE (f, overload_idx));
printfi_filtered (spaces + 8, "is_protected %d\n",
TYPE_FN_FIELD_PROTECTED (f, overload_idx));
printfi_filtered (spaces + 8, "is_stub %d\n",
TYPE_FN_FIELD_STUB (f, overload_idx));
printfi_filtered (spaces + 8, "voffset %u\n",
TYPE_FN_FIELD_VOFFSET (f, overload_idx));
}
}
}
static void
print_cplus_stuff (struct type *type, int spaces)
{
printfi_filtered (spaces, "n_baseclasses %d\n",
TYPE_N_BASECLASSES (type));
printfi_filtered (spaces, "nfn_fields %d\n",
TYPE_NFN_FIELDS (type));
printfi_filtered (spaces, "nfn_fields_total %d\n",
TYPE_NFN_FIELDS_TOTAL (type));
if (TYPE_N_BASECLASSES (type) > 0)
{
printfi_filtered (spaces, "virtual_field_bits (%d bits at *",
TYPE_N_BASECLASSES (type));
gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type), gdb_stdout);
printf_filtered (")");
print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type),
TYPE_N_BASECLASSES (type));
puts_filtered ("\n");
}
if (TYPE_NFIELDS (type) > 0)
{
if (TYPE_FIELD_PRIVATE_BITS (type) != NULL)
{
printfi_filtered (spaces, "private_field_bits (%d bits at *",
TYPE_NFIELDS (type));
gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type), gdb_stdout);
printf_filtered (")");
print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type),
TYPE_NFIELDS (type));
puts_filtered ("\n");
}
if (TYPE_FIELD_PROTECTED_BITS (type) != NULL)
{
printfi_filtered (spaces, "protected_field_bits (%d bits at *",
TYPE_NFIELDS (type));
gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type), gdb_stdout);
printf_filtered (")");
print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type),
TYPE_NFIELDS (type));
puts_filtered ("\n");
}
}
if (TYPE_NFN_FIELDS (type) > 0)
{
dump_fn_fieldlists (type, spaces);
}
}
static void
print_bound_type (int bt)
{
switch (bt)
{
case BOUND_CANNOT_BE_DETERMINED:
printf_filtered ("(BOUND_CANNOT_BE_DETERMINED)");
break;
case BOUND_BY_REF_ON_STACK:
printf_filtered ("(BOUND_BY_REF_ON_STACK)");
break;
case BOUND_BY_VALUE_ON_STACK:
printf_filtered ("(BOUND_BY_VALUE_ON_STACK)");
break;
case BOUND_BY_REF_IN_REG:
printf_filtered ("(BOUND_BY_REF_IN_REG)");
break;
case BOUND_BY_VALUE_IN_REG:
printf_filtered ("(BOUND_BY_VALUE_IN_REG)");
break;
case BOUND_SIMPLE:
printf_filtered ("(BOUND_SIMPLE)");
break;
default:
printf_filtered (_("(unknown bound type)"));
break;
}
}
static struct obstack dont_print_type_obstack;
const char *type_code_name (int code)
{
switch (code)
{
case TYPE_CODE_UNDEF:
return "TYPE_CODE_UNDEF";
case TYPE_CODE_PTR:
return "TYPE_CODE_PTR";
case TYPE_CODE_ARRAY:
return "TYPE_CODE_ARRAY";
case TYPE_CODE_STRUCT:
return "TYPE_CODE_STRUCT";
case TYPE_CODE_UNION:
return "TYPE_CODE_UNION";
case TYPE_CODE_ENUM:
return "TYPE_CODE_ENUM";
case TYPE_CODE_FUNC:
return "TYPE_CODE_FUNC";
case TYPE_CODE_INT:
return "TYPE_CODE_INT";
case TYPE_CODE_FLT:
return "TYPE_CODE_FLT";
case TYPE_CODE_VOID:
return "TYPE_CODE_VOID";
case TYPE_CODE_SET:
return "TYPE_CODE_SET";
case TYPE_CODE_RANGE:
return "TYPE_CODE_RANGE";
case TYPE_CODE_STRING:
return "TYPE_CODE_STRING";
case TYPE_CODE_BITSTRING:
return "TYPE_CODE_BITSTRING";
case TYPE_CODE_ERROR:
return "TYPE_CODE_ERROR";
case TYPE_CODE_MEMBER:
return "TYPE_CODE_MEMBER";
case TYPE_CODE_METHOD:
return "TYPE_CODE_METHOD";
case TYPE_CODE_REF:
return "TYPE_CODE_REF";
case TYPE_CODE_CHAR:
return "TYPE_CODE_CHAR";
case TYPE_CODE_BOOL:
return "TYPE_CODE_BOOL";
case TYPE_CODE_COMPLEX:
return "TYPE_CODE_COMPLEX";
case TYPE_CODE_TYPEDEF:
return "TYPE_CODE_TYPEDEF";
case TYPE_CODE_TEMPLATE:
return "TYPE_CODE_TEMPLATE";
case TYPE_CODE_TEMPLATE_ARG:
return "TYPE_CODE_TEMPLATE_ARG";
case TYPE_CODE_NAMESPACE:
return "TYPE_CODE_NAMESPACE";
default:
return "UNKNOWN TYPE CODE";
}
}
void
recursive_dump_type (struct type *type, int spaces)
{
int idx;
if (spaces == 0)
obstack_begin (&dont_print_type_obstack, 0);
if (TYPE_NFIELDS (type) > 0
|| (TYPE_CPLUS_SPECIFIC (type) && TYPE_NFN_FIELDS (type) > 0))
{
struct type **first_dont_print
= (struct type **) obstack_base (&dont_print_type_obstack);
int i = (struct type **) obstack_next_free (&dont_print_type_obstack)
- first_dont_print;
while (--i >= 0)
{
if (type == first_dont_print[i])
{
printfi_filtered (spaces, "type node ");
gdb_print_host_address (type, gdb_stdout);
printf_filtered (_(" <same as already seen type>\n"));
return;
}
}
obstack_ptr_grow (&dont_print_type_obstack, type);
}
printfi_filtered (spaces, "type node ");
gdb_print_host_address (type, gdb_stdout);
printf_filtered ("\n");
printfi_filtered (spaces, "name '%s' (",
TYPE_NAME (type) ? TYPE_NAME (type) : "<NULL>");
gdb_print_host_address (TYPE_NAME (type), gdb_stdout);
printf_filtered (")\n");
printfi_filtered (spaces, "tagname '%s' (",
TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) : "<NULL>");
gdb_print_host_address (TYPE_TAG_NAME (type), gdb_stdout);
printf_filtered (")\n");
printfi_filtered (spaces, "code 0x%x (%s)", TYPE_CODE (type),
type_code_name (TYPE_CODE (type)));
puts_filtered ("\n");
printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type));
printfi_filtered (spaces, "upper_bound_type 0x%x ",
TYPE_ARRAY_UPPER_BOUND_TYPE (type));
print_bound_type (TYPE_ARRAY_UPPER_BOUND_TYPE (type));
puts_filtered ("\n");
printfi_filtered (spaces, "lower_bound_type 0x%x ",
TYPE_ARRAY_LOWER_BOUND_TYPE (type));
print_bound_type (TYPE_ARRAY_LOWER_BOUND_TYPE (type));
puts_filtered ("\n");
printfi_filtered (spaces, "objfile ");
gdb_print_host_address (TYPE_OBJFILE (type), gdb_stdout);
printf_filtered ("\n");
printfi_filtered (spaces, "target_type ");
gdb_print_host_address (TYPE_TARGET_TYPE (type), gdb_stdout);
printf_filtered ("\n");
if (TYPE_TARGET_TYPE (type) != NULL)
{
recursive_dump_type (TYPE_TARGET_TYPE (type), spaces + 2);
}
printfi_filtered (spaces, "pointer_type ");
gdb_print_host_address (TYPE_POINTER_TYPE (type), gdb_stdout);
printf_filtered ("\n");
printfi_filtered (spaces, "reference_type ");
gdb_print_host_address (TYPE_REFERENCE_TYPE (type), gdb_stdout);
printf_filtered ("\n");
printfi_filtered (spaces, "type_chain ");
gdb_print_host_address (TYPE_CHAIN (type), gdb_stdout);
printf_filtered ("\n");
printfi_filtered (spaces, "instance_flags 0x%x", TYPE_INSTANCE_FLAGS (type));
if (TYPE_CONST (type))
{
puts_filtered (" TYPE_FLAG_CONST");
}
if (TYPE_VOLATILE (type))
{
puts_filtered (" TYPE_FLAG_VOLATILE");
}
if (TYPE_CODE_SPACE (type))
{
puts_filtered (" TYPE_FLAG_CODE_SPACE");
}
if (TYPE_DATA_SPACE (type))
{
puts_filtered (" TYPE_FLAG_DATA_SPACE");
}
if (TYPE_ADDRESS_CLASS_1 (type))
{
puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_1");
}
if (TYPE_ADDRESS_CLASS_2 (type))
{
puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
}
puts_filtered ("\n");
printfi_filtered (spaces, "flags 0x%x", TYPE_FLAGS (type));
if (TYPE_UNSIGNED (type))
{
puts_filtered (" TYPE_FLAG_UNSIGNED");
}
if (TYPE_NOSIGN (type))
{
puts_filtered (" TYPE_FLAG_NOSIGN");
}
if (TYPE_STUB (type))
{
puts_filtered (" TYPE_FLAG_STUB");
}
if (TYPE_TARGET_STUB (type))
{
puts_filtered (" TYPE_FLAG_TARGET_STUB");
}
if (TYPE_STATIC (type))
{
puts_filtered (" TYPE_FLAG_STATIC");
}
if (TYPE_PROTOTYPED (type))
{
puts_filtered (" TYPE_FLAG_PROTOTYPED");
}
if (TYPE_INCOMPLETE (type))
{
puts_filtered (" TYPE_FLAG_INCOMPLETE");
}
if (TYPE_VARARGS (type))
{
puts_filtered (" TYPE_FLAG_VARARGS");
}
if (TYPE_VECTOR (type))
{
puts_filtered (" TYPE_FLAG_VECTOR");
}
puts_filtered ("\n");
printfi_filtered (spaces, "nfields %d ", TYPE_NFIELDS (type));
gdb_print_host_address (TYPE_FIELDS (type), gdb_stdout);
puts_filtered ("\n");
for (idx = 0; idx < TYPE_NFIELDS (type); idx++)
{
printfi_filtered (spaces + 2,
"[%d] bitpos %d bitsize %d type ",
idx, TYPE_FIELD_BITPOS (type, idx),
TYPE_FIELD_BITSIZE (type, idx));
gdb_print_host_address (TYPE_FIELD_TYPE (type, idx), gdb_stdout);
printf_filtered (" name '%s' (",
TYPE_FIELD_NAME (type, idx) != NULL
? TYPE_FIELD_NAME (type, idx)
: "<NULL>");
gdb_print_host_address (TYPE_FIELD_NAME (type, idx), gdb_stdout);
printf_filtered (")\n");
if (TYPE_FIELD_TYPE (type, idx) != NULL)
{
recursive_dump_type (TYPE_FIELD_TYPE (type, idx), spaces + 4);
}
}
printfi_filtered (spaces, "vptr_basetype ");
gdb_print_host_address (TYPE_VPTR_BASETYPE (type), gdb_stdout);
puts_filtered ("\n");
if (TYPE_VPTR_BASETYPE (type) != NULL)
{
recursive_dump_type (TYPE_VPTR_BASETYPE (type), spaces + 2);
}
printfi_filtered (spaces, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type));
switch (TYPE_CODE (type))
{
case TYPE_CODE_STRUCT:
printfi_filtered (spaces, "cplus_stuff ");
gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type), gdb_stdout);
puts_filtered ("\n");
print_cplus_stuff (type, spaces);
break;
case TYPE_CODE_FLT:
printfi_filtered (spaces, "floatformat ");
if (TYPE_FLOATFORMAT (type) == NULL
|| TYPE_FLOATFORMAT (type)->name == NULL)
puts_filtered ("(null)");
else
puts_filtered (TYPE_FLOATFORMAT (type)->name);
puts_filtered ("\n");
break;
default:
printfi_filtered (spaces, "type_specific ");
gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type), gdb_stdout);
if (TYPE_CPLUS_SPECIFIC (type) != NULL)
{
printf_filtered (_(" (unknown data form)"));
}
printf_filtered ("\n");
break;
}
if (spaces == 0)
obstack_free (&dont_print_type_obstack, NULL);
}
static void build_gdbtypes (void);
static void
build_gdbtypes (void)
{
builtin_type_void =
init_type (TYPE_CODE_VOID, 1,
0,
"void", (struct objfile *) NULL);
builtin_type_char =
init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
(TYPE_FLAG_NOSIGN
| (TARGET_CHAR_SIGNED ? 0 : TYPE_FLAG_UNSIGNED)),
"char", (struct objfile *) NULL);
builtin_type_true_char =
init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
0,
"true character", (struct objfile *) NULL);
builtin_type_signed_char =
init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
0,
"signed char", (struct objfile *) NULL);
builtin_type_unsigned_char =
init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_UNSIGNED,
"unsigned char", (struct objfile *) NULL);
builtin_type_short =
init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT,
0,
"short", (struct objfile *) NULL);
builtin_type_unsigned_short =
init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_UNSIGNED,
"unsigned short", (struct objfile *) NULL);
builtin_type_int =
init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
0,
"int", (struct objfile *) NULL);
builtin_type_unsigned_int =
init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_UNSIGNED,
"unsigned int", (struct objfile *) NULL);
builtin_type_long =
init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
0,
"long", (struct objfile *) NULL);
builtin_type_unsigned_long =
init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_UNSIGNED,
"unsigned long", (struct objfile *) NULL);
builtin_type_long_long =
init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
0,
"long long", (struct objfile *) NULL);
builtin_type_unsigned_long_long =
init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_UNSIGNED,
"unsigned long long", (struct objfile *) NULL);
builtin_type_float =
init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
0,
"float", (struct objfile *) NULL);
#if 0
TYPE_FLOATFORMAT (builtin_type_float) = TARGET_FLOAT_FORMAT;
#endif
builtin_type_double =
init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
0,
"double", (struct objfile *) NULL);
#if 0
TYPE_FLOATFORMAT (builtin_type_double) = TARGET_DOUBLE_FORMAT;
#endif
builtin_type_long_double =
init_type (TYPE_CODE_FLT, TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
0,
"long double", (struct objfile *) NULL);
#if 0
TYPE_FLOATFORMAT (builtin_type_long_double) = TARGET_LONG_DOUBLE_FORMAT;
#endif
builtin_type_complex =
init_type (TYPE_CODE_COMPLEX, 2 * TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
0,
"complex", (struct objfile *) NULL);
TYPE_TARGET_TYPE (builtin_type_complex) = builtin_type_float;
builtin_type_double_complex =
init_type (TYPE_CODE_COMPLEX, 2 * TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
0,
"double complex", (struct objfile *) NULL);
TYPE_TARGET_TYPE (builtin_type_double_complex) = builtin_type_double;
builtin_type_string =
init_type (TYPE_CODE_STRING, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
0,
"string", (struct objfile *) NULL);
builtin_type_bool =
init_type (TYPE_CODE_BOOL, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
0,
"bool", (struct objfile *) NULL);
add_setshow_boolean_cmd ("opaque-type-resolution", class_support,
&opaque_type_resolution, _("\
Set resolution of opaque struct/class/union types (if set before loading symbols)."), _("\
Show resolution of opaque struct/class/union types (if set before loading symbols)."), NULL,
NULL,
show_opaque_type_resolution,
&setlist, &showlist);
opaque_type_resolution = 1;
builtin_type_v4sf
= init_simd_type ("__builtin_v4sf", builtin_type_float, "f", 4);
builtin_type_v4si
= init_simd_type ("__builtin_v4si", builtin_type_int32, "f", 4);
builtin_type_v16qi
= init_simd_type ("__builtin_v16qi", builtin_type_int8, "f", 16);
builtin_type_v8qi
= init_simd_type ("__builtin_v8qi", builtin_type_int8, "f", 8);
builtin_type_v8hi
= init_simd_type ("__builtin_v8hi", builtin_type_int16, "f", 8);
builtin_type_v4hi
= init_simd_type ("__builtin_v4hi", builtin_type_int16, "f", 4);
builtin_type_v2si
= init_simd_type ("__builtin_v2si", builtin_type_int32, "f", 2);
builtin_type_v2_double = init_vector_type (builtin_type_double, 2);
builtin_type_v4_float = init_vector_type (builtin_type_float, 4);
builtin_type_v2_int64 = init_vector_type (builtin_type_int64, 2);
builtin_type_v4_int32 = init_vector_type (builtin_type_int32, 4);
builtin_type_v8_int16 = init_vector_type (builtin_type_int16, 8);
builtin_type_v16_int8 = init_vector_type (builtin_type_int8, 16);
builtin_type_v2_float = init_vector_type (builtin_type_float, 2);
builtin_type_v2_int32 = init_vector_type (builtin_type_int32, 2);
builtin_type_v4_int16 = init_vector_type (builtin_type_int16, 4);
builtin_type_v8_int8 = init_vector_type (builtin_type_int8, 8);
builtin_type_vec64 = build_builtin_type_vec64 ();
builtin_type_vec128 = build_builtin_type_vec128 ();
builtin_type_void_data_ptr = make_pointer_type (builtin_type_void, NULL);
builtin_type_void_func_ptr
= lookup_pointer_type (lookup_function_type (builtin_type_void));
builtin_type_CORE_ADDR =
init_type (TYPE_CODE_INT, TARGET_ADDR_BIT / 8,
TYPE_FLAG_UNSIGNED,
"__CORE_ADDR", (struct objfile *) NULL);
builtin_type_bfd_vma =
init_type (TYPE_CODE_INT, TARGET_BFD_VMA_BIT / 8,
TYPE_FLAG_UNSIGNED,
"__bfd_vma", (struct objfile *) NULL);
builtin_type_voidptrfuncptr =
lookup_pointer_type (lookup_function_type (lookup_pointer_type (builtin_type_void)));
}
static struct gdbarch_data *gdbtypes_data;
const struct builtin_type *
builtin_type (struct gdbarch *gdbarch)
{
return gdbarch_data (gdbarch, gdbtypes_data);
}
static struct type *
build_flt (int bit, char *name, const struct floatformat *floatformat)
{
struct type *t;
if (bit <= 0 || floatformat == NULL)
{
gdb_assert (builtin_type_error != NULL);
return builtin_type_error;
}
t = init_type (TYPE_CODE_FLT, bit / TARGET_CHAR_BIT,
0, name, (struct objfile *) NULL);
TYPE_FLOATFORMAT (t) = floatformat;
return t;
}
static struct type *
build_complex (int bit, char *name, struct type *target_type)
{
struct type *t;
if (bit <= 0 || target_type == builtin_type_error)
{
gdb_assert (builtin_type_error != NULL);
return builtin_type_error;
}
t = init_type (TYPE_CODE_COMPLEX, 2 * bit / TARGET_CHAR_BIT,
0, name, (struct objfile *) NULL);
TYPE_TARGET_TYPE (t) = target_type;
return t;
}
static void *
gdbtypes_post_init (struct gdbarch *gdbarch)
{
struct builtin_type *builtin_type
= GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_type);
builtin_type->builtin_void =
init_type (TYPE_CODE_VOID, 1,
0,
"void", (struct objfile *) NULL);
builtin_type->builtin_char =
init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
(TYPE_FLAG_NOSIGN
| (TARGET_CHAR_SIGNED ? 0 : TYPE_FLAG_UNSIGNED)),
"char", (struct objfile *) NULL);
builtin_type->builtin_true_char =
init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
0,
"true character", (struct objfile *) NULL);
builtin_type->builtin_signed_char =
init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
0,
"signed char", (struct objfile *) NULL);
builtin_type->builtin_unsigned_char =
init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_UNSIGNED,
"unsigned char", (struct objfile *) NULL);
builtin_type->builtin_short =
init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT,
0,
"short", (struct objfile *) NULL);
builtin_type->builtin_unsigned_short =
init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_UNSIGNED,
"unsigned short", (struct objfile *) NULL);
builtin_type->builtin_int =
init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
0,
"int", (struct objfile *) NULL);
builtin_type->builtin_unsigned_int =
init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_UNSIGNED,
"unsigned int", (struct objfile *) NULL);
builtin_type->builtin_long =
init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
0,
"long", (struct objfile *) NULL);
builtin_type->builtin_unsigned_long =
init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_UNSIGNED,
"unsigned long", (struct objfile *) NULL);
builtin_type->builtin_long_long =
init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
0,
"long long", (struct objfile *) NULL);
builtin_type->builtin_unsigned_long_long =
init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_UNSIGNED,
"unsigned long long", (struct objfile *) NULL);
builtin_type->builtin_float
= build_flt (gdbarch_float_bit (gdbarch), "float",
gdbarch_float_format (gdbarch));
builtin_type->builtin_double
= build_flt (gdbarch_double_bit (gdbarch), "double",
gdbarch_double_format (gdbarch));
builtin_type->builtin_long_double
= build_flt (gdbarch_long_double_bit (gdbarch), "long double",
gdbarch_long_double_format (gdbarch));
builtin_type->builtin_complex
= build_complex (gdbarch_float_bit (gdbarch), "complex",
builtin_type->builtin_float);
builtin_type->builtin_double_complex
= build_complex (gdbarch_double_bit (gdbarch), "double complex",
builtin_type->builtin_double);
builtin_type->builtin_string =
init_type (TYPE_CODE_STRING, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
0,
"string", (struct objfile *) NULL);
builtin_type->builtin_bool =
init_type (TYPE_CODE_BOOL, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
0,
"bool", (struct objfile *) NULL);
builtin_type->builtin_data_ptr
= make_pointer_type (builtin_type->builtin_void, NULL);
builtin_type->builtin_func_ptr
= lookup_pointer_type (lookup_function_type (builtin_type->builtin_void));
builtin_type->builtin_core_addr =
init_type (TYPE_CODE_INT, TARGET_ADDR_BIT / 8,
TYPE_FLAG_UNSIGNED,
"__CORE_ADDR", (struct objfile *) NULL);
return builtin_type;
}
struct type *
build_builtin_enum (const char *name, uint32_t size, int flags,
struct gdbtypes_enum_info *enums, uint32_t num_enums)
{
int i;
struct type *t = init_type (TYPE_CODE_ENUM, size, flags, xstrdup (name),
(struct objfile *) NULL);
TYPE_NFIELDS (t) = num_enums;
const int fields_size = sizeof (struct field) * TYPE_NFIELDS (t);
TYPE_FIELDS (t) = xmalloc (fields_size);
memset (TYPE_FIELDS (t), 0, fields_size);
for (i = 0; i < num_enums; i++)
{
TYPE_FIELD_NAME (t, i) = xstrdup (enums[i].name);
TYPE_FIELD_BITPOS_ASSIGN (t, i) = enums[i].value;
}
gdb_assert (i == TYPE_NFIELDS (t));
TYPE_LENGTH_ASSIGN (t) = size;
return t;
}
struct type *
build_builtin_bitfield (const char *name, uint32_t size,
struct gdbtypes_bitfield_info *bitfields,
uint32_t num_bitfields)
{
struct type *t;
t = init_composite_type (xstrdup (name), TYPE_CODE_STRUCT);
TYPE_NFIELDS (t) = num_bitfields;
const int fields_size = sizeof (struct field) * TYPE_NFIELDS (t);
TYPE_FIELDS (t) = xmalloc (fields_size);
memset (TYPE_FIELDS (t), 0, fields_size);
int i = 0;
for (i = 0; i < num_bitfields; i++)
{
TYPE_FIELD_NAME (t, i) = xstrdup (bitfields[i].name);
TYPE_FIELD_TYPE (t, i) = bitfields[i].type;
TYPE_FIELD_BITSIZE (t, i) = bitfields[i].msbit - bitfields[i].lsbit + 1;
TYPE_FIELD_BITPOS_ASSIGN (t, i) = bitfields[i].lsbit;
}
gdb_assert (i == TYPE_NFIELDS (t));
TYPE_LENGTH_ASSIGN (t) = size;
return t;
}
struct value *
get_closure_implementation_fn (struct value *in_value)
{
struct value *funcPtr_val = NULL;
struct gdb_exception e;
CORE_ADDR func_addr;
struct symbol *func_sym;
TRY_CATCH (e, RETURN_MASK_ALL)
{
funcPtr_val = value_struct_elt (&in_value, NULL, "__FuncPtr", NULL, "");
}
if (!funcPtr_val && e.reason == RETURN_ERROR)
{
TRY_CATCH (e, RETURN_MASK_ALL)
{
funcPtr_val = value_struct_elt (&in_value, NULL, "FuncPtr", NULL,
"");
}
}
if (e.reason != NO_ERROR || funcPtr_val == NULL)
return NULL;
func_addr = value_as_address (funcPtr_val);
func_sym = find_pc_function (func_addr);
if (func_sym != NULL)
{
struct type *func_type;
func_type = SYMBOL_TYPE (func_sym);
if (TYPE_CODE (value_type (funcPtr_val)) == TYPE_CODE_PTR)
{
func_type = make_pointer_type (func_type, NULL);
funcPtr_val = value_cast (func_type, funcPtr_val);
funcPtr_val = value_ind (funcPtr_val);
}
else
funcPtr_val = value_cast (func_type, funcPtr_val);
}
return funcPtr_val;
}
struct type *
get_closure_dynamic_type (struct value *in_value)
{
struct type *deref;
struct type *dynamic_type = NULL;
struct type *base_type = check_typedef (value_type (in_value));
if (TYPE_CODE (base_type) == TYPE_CODE_PTR
|| TYPE_CODE (base_type) == TYPE_CODE_REF)
deref = TYPE_TARGET_TYPE (base_type);
else if (TYPE_CODE (base_type) == TYPE_CODE_STRUCT)
deref = base_type;
else
return NULL;
if (deref
&& ((TYPE_FLAGS (deref) & TYPE_FLAG_APPLE_CLOSURE) != 0))
{
struct value *funcPtr_val;
struct gdb_exception e;
TRY_CATCH (e, RETURN_MASK_ALL)
{
funcPtr_val = get_closure_implementation_fn (in_value);
if (funcPtr_val != NULL)
{
struct type *func_type;
func_type = value_type (funcPtr_val);
if (TYPE_NFIELDS (func_type) > 0)
{
dynamic_type = TYPE_FIELD_TYPE (func_type, 0);
if (TYPE_CODE (dynamic_type) != TYPE_CODE_PTR)
dynamic_type = NULL;
else
{
if (TYPE_CODE (base_type) == TYPE_CODE_STRUCT)
dynamic_type = TYPE_TARGET_TYPE (dynamic_type);
else if (TYPE_CODE (base_type) == TYPE_CODE_REF)
{
dynamic_type = make_reference_type (dynamic_type, NULL);
}
}
}
}
}
}
return dynamic_type;
}
extern void _initialize_gdbtypes (void);
void
_initialize_gdbtypes (void)
{
builtin_type_int0 =
init_type (TYPE_CODE_INT, 0 / 8,
0,
"int0_t", (struct objfile *) NULL);
builtin_type_int8 =
init_type (TYPE_CODE_INT, 8 / 8,
0,
"int8_t", (struct objfile *) NULL);
builtin_type_uint8 =
init_type (TYPE_CODE_INT, 8 / 8,
TYPE_FLAG_UNSIGNED,
"uint8_t", (struct objfile *) NULL);
builtin_type_int16 =
init_type (TYPE_CODE_INT, 16 / 8,
0,
"int16_t", (struct objfile *) NULL);
builtin_type_uint16 =
init_type (TYPE_CODE_INT, 16 / 8,
TYPE_FLAG_UNSIGNED,
"uint16_t", (struct objfile *) NULL);
builtin_type_int32 =
init_type (TYPE_CODE_INT, 32 / 8,
0,
"int32_t", (struct objfile *) NULL);
builtin_type_uint32 =
init_type (TYPE_CODE_INT, 32 / 8,
TYPE_FLAG_UNSIGNED,
"uint32_t", (struct objfile *) NULL);
builtin_type_int64 =
init_type (TYPE_CODE_INT, 64 / 8,
0,
"int64_t", (struct objfile *) NULL);
builtin_type_uint64 =
init_type (TYPE_CODE_INT, 64 / 8,
TYPE_FLAG_UNSIGNED,
"uint64_t", (struct objfile *) NULL);
builtin_type_int128 =
init_type (TYPE_CODE_INT, 128 / 8,
0,
"int128_t", (struct objfile *) NULL);
builtin_type_uint128 =
init_type (TYPE_CODE_INT, 128 / 8,
TYPE_FLAG_UNSIGNED,
"uint128_t", (struct objfile *) NULL);
build_gdbtypes ();
gdbtypes_data = gdbarch_data_register_post_init (gdbtypes_post_init);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_void);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_char);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_short);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_int);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_long);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_long_long);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_signed_char);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_char);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_short);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_int);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_long);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_long_long);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_float);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_double);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_long_double);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_complex);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_double_complex);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_string);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4sf);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4si);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v16qi);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v8qi);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v8hi);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4hi);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2si);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2_double);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4_float);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2_int64);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4_int32);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v8_int16);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v16_int8);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2_float);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2_int32);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v8_int8);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4_int16);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_vec128);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_void_data_ptr);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_void_func_ptr);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_CORE_ADDR);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_bfd_vma);
deprecated_register_gdbarch_swap (NULL, 0, build_gdbtypes);
builtin_type_ieee_single_big =
init_type (TYPE_CODE_FLT, floatformat_ieee_single_big.totalsize / 8,
0, "builtin_type_ieee_single_big", NULL);
TYPE_FLOATFORMAT (builtin_type_ieee_single_big) = &floatformat_ieee_single_big;
builtin_type_ieee_single_little =
init_type (TYPE_CODE_FLT, floatformat_ieee_single_little.totalsize / 8,
0, "builtin_type_ieee_single_little", NULL);
TYPE_FLOATFORMAT (builtin_type_ieee_single_little) = &floatformat_ieee_single_little;
builtin_type_ieee_single[BFD_ENDIAN_BIG]
= build_flt (floatformat_ieee_single_big.totalsize,
"builtin_type_ieee_single_big",
&floatformat_ieee_single_big);
builtin_type_ieee_single[BFD_ENDIAN_LITTLE]
= build_flt (floatformat_ieee_single_little.totalsize,
"builtin_type_ieee_single_little",
&floatformat_ieee_single_little);
builtin_type_ieee_double_big =
init_type (TYPE_CODE_FLT, floatformat_ieee_double_big.totalsize / 8,
0, "builtin_type_ieee_double_big", NULL);
TYPE_FLOATFORMAT (builtin_type_ieee_double_big) = &floatformat_ieee_double_big;
builtin_type_ieee_double_little =
init_type (TYPE_CODE_FLT, floatformat_ieee_double_little.totalsize / 8,
0, "builtin_type_ieee_double_little", NULL);
TYPE_FLOATFORMAT (builtin_type_ieee_double_little) = &floatformat_ieee_double_little;
builtin_type_ieee_double[BFD_ENDIAN_BIG]
= build_flt (floatformat_ieee_double_big.totalsize,
"builtin_type_ieee_double_big",
&floatformat_ieee_double_big);
builtin_type_ieee_double[BFD_ENDIAN_LITTLE]
= build_flt (floatformat_ieee_double_little.totalsize,
"builtin_type_ieee_double_little",
&floatformat_ieee_double_little);
builtin_type_ieee_double_littlebyte_bigword =
init_type (TYPE_CODE_FLT, floatformat_ieee_double_littlebyte_bigword.totalsize / 8,
0, "builtin_type_ieee_double_littlebyte_bigword", NULL);
TYPE_FLOATFORMAT (builtin_type_ieee_double_littlebyte_bigword) = &floatformat_ieee_double_littlebyte_bigword;
builtin_type_i387_ext =
init_type (TYPE_CODE_FLT, floatformat_i387_ext.totalsize / 8,
0, "builtin_type_i387_ext", NULL);
TYPE_FLOATFORMAT (builtin_type_i387_ext) = &floatformat_i387_ext;
builtin_type_m68881_ext =
init_type (TYPE_CODE_FLT, floatformat_m68881_ext.totalsize / 8,
0, "builtin_type_m68881_ext", NULL);
TYPE_FLOATFORMAT (builtin_type_m68881_ext) = &floatformat_m68881_ext;
builtin_type_i960_ext =
init_type (TYPE_CODE_FLT, floatformat_i960_ext.totalsize / 8,
0, "builtin_type_i960_ext", NULL);
TYPE_FLOATFORMAT (builtin_type_i960_ext) = &floatformat_i960_ext;
builtin_type_m88110_ext =
init_type (TYPE_CODE_FLT, floatformat_m88110_ext.totalsize / 8,
0, "builtin_type_m88110_ext", NULL);
TYPE_FLOATFORMAT (builtin_type_m88110_ext) = &floatformat_m88110_ext;
builtin_type_m88110_harris_ext =
init_type (TYPE_CODE_FLT, floatformat_m88110_harris_ext.totalsize / 8,
0, "builtin_type_m88110_harris_ext", NULL);
TYPE_FLOATFORMAT (builtin_type_m88110_harris_ext) = &floatformat_m88110_harris_ext;
builtin_type_arm_ext_big =
init_type (TYPE_CODE_FLT, floatformat_arm_ext_big.totalsize / 8,
0, "builtin_type_arm_ext_big", NULL);
TYPE_FLOATFORMAT (builtin_type_arm_ext_big) = &floatformat_arm_ext_big;
builtin_type_arm_ext_littlebyte_bigword =
init_type (TYPE_CODE_FLT, floatformat_arm_ext_littlebyte_bigword.totalsize / 8,
0, "builtin_type_arm_ext_littlebyte_bigword", NULL);
TYPE_FLOATFORMAT (builtin_type_arm_ext_littlebyte_bigword) = &floatformat_arm_ext_littlebyte_bigword;
builtin_type_arm_ext[BFD_ENDIAN_BIG]
= build_flt (floatformat_arm_ext_big.totalsize,
"builtin_type_arm_ext_big",
&floatformat_arm_ext_big);
builtin_type_arm_ext[BFD_ENDIAN_LITTLE]
= build_flt (floatformat_arm_ext_littlebyte_bigword.totalsize,
"builtin_type_arm_ext_littlebyte_bigword",
&floatformat_arm_ext_littlebyte_bigword);
builtin_type_ia64_spill_big =
init_type (TYPE_CODE_FLT, floatformat_ia64_spill_big.totalsize / 8,
0, "builtin_type_ia64_spill_big", NULL);
TYPE_FLOATFORMAT (builtin_type_ia64_spill_big) = &floatformat_ia64_spill_big;
builtin_type_ia64_spill_little =
init_type (TYPE_CODE_FLT, floatformat_ia64_spill_little.totalsize / 8,
0, "builtin_type_ia64_spill_little", NULL);
TYPE_FLOATFORMAT (builtin_type_ia64_spill_little) = &floatformat_ia64_spill_little;
builtin_type_ia64_spill[BFD_ENDIAN_BIG]
= build_flt (floatformat_ia64_spill_big.totalsize,
"builtin_type_ia64_spill_big",
&floatformat_ia64_spill_big);
builtin_type_ia64_spill[BFD_ENDIAN_LITTLE]
= build_flt (floatformat_ia64_spill_little.totalsize,
"builtin_type_ia64_spill_little",
&floatformat_ia64_spill_little);
builtin_type_ia64_quad_big =
init_type (TYPE_CODE_FLT, floatformat_ia64_quad_big.totalsize / 8,
0, "builtin_type_ia64_quad_big", NULL);
TYPE_FLOATFORMAT (builtin_type_ia64_quad_big) = &floatformat_ia64_quad_big;
builtin_type_ia64_quad_little =
init_type (TYPE_CODE_FLT, floatformat_ia64_quad_little.totalsize / 8,
0, "builtin_type_ia64_quad_little", NULL);
TYPE_FLOATFORMAT (builtin_type_ia64_quad_little) = &floatformat_ia64_quad_little;
builtin_type_ia64_quad[BFD_ENDIAN_BIG]
= build_flt (floatformat_ia64_quad_big.totalsize,
"builtin_type_ia64_quad_big",
&floatformat_ia64_quad_big);
builtin_type_ia64_quad[BFD_ENDIAN_LITTLE]
= build_flt (floatformat_ia64_quad_little.totalsize,
"builtin_type_ia64_quad_little",
&floatformat_ia64_quad_little);
add_setshow_zinteger_cmd ("overload", no_class, &overload_debug, _("\
Set debugging of C++ overloading."), _("\
Show debugging of C++ overloading."), _("\
When enabled, ranking of the functions is displayed."),
NULL,
show_overload_debug,
&setdebuglist, &showdebuglist);
add_setshow_zinteger_cmd ("use-array-stride", no_class,
&use_stride, _("\
Set if GDB should honor the 'stride' parameter of array types."), _("\
Show if GDB should honor the 'stride' parameter of array types."), NULL,
NULL, NULL,
&setlist, &showlist);
undef_arrays_allocated = 20;
undef_arrays_length = 0;
undef_arrays = (struct type **)
xmalloc (undef_arrays_allocated * sizeof (struct type *));
}