/* Support routines for manipulating internal types for GDB.
- Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002,
- 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
- Free Software Foundation, Inc.
+ Copyright (C) 1992-2014 Free Software Foundation, Inc.
Contributed by Cygnus Support, using pieces from other GDB modules.
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
-#include "gdb_string.h"
+#include <string.h>
#include "bfd.h"
#include "symtab.h"
#include "symfile.h"
#include "demangle.h"
#include "complaints.h"
#include "gdbcmd.h"
-#include "wrapper.h"
#include "cp-abi.h"
#include "gdb_assert.h"
#include "hashtab.h"
-
+#include "exceptions.h"
+#include "cp-support.h"
+#include "bcache.h"
+#include "dwarf2loc.h"
/* Initialize BADNESS constants. */
const struct rank FLOAT_CONVERSION_BADNESS = {2,0};
const struct rank INT_FLOAT_CONVERSION_BADNESS = {2,0};
const struct rank VOID_PTR_CONVERSION_BADNESS = {2,0};
-const struct rank BOOL_PTR_CONVERSION_BADNESS = {3,0};
+const struct rank BOOL_CONVERSION_BADNESS = {3,0};
const struct rank BASE_CONVERSION_BADNESS = {2,0};
const struct rank REFERENCE_CONVERSION_BADNESS = {2,0};
-
+const struct rank NULL_POINTER_CONVERSION_BADNESS = {2,0};
const struct rank NS_POINTER_CONVERSION_BADNESS = {10,0};
+const struct rank NS_INTEGER_POINTER_CONVERSION_BADNESS = {3,0};
/* Floatformat pairs. */
const struct floatformat *floatformats_ieee_half[BFD_ENDIAN_UNKNOWN] = {
&floatformat_vax_d
};
const struct floatformat *floatformats_ibm_long_double[BFD_ENDIAN_UNKNOWN] = {
- &floatformat_ibm_long_double,
- &floatformat_ibm_long_double
+ &floatformat_ibm_long_double_big,
+ &floatformat_ibm_long_double_little
};
+/* Should opaque types be resolved? */
+
+static int opaque_type_resolution = 1;
+
+/* A flag to enable printing of debugging information of C++
+ overloading. */
+
+unsigned int overload_debug = 0;
+
+/* A flag to enable strict type checking. */
+
+static int strict_type_checking = 1;
+
+/* A function to show whether opaque types are resolved. */
-int opaque_type_resolution = 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"),
+ fprintf_filtered (file, _("Resolution of opaque struct/class/union types "
+ "(if set before loading symbols) is %s.\n"),
value);
}
-int overload_debug = 0;
+/* A function to show whether C++ overload debugging is enabled. */
+
static void
show_overload_debug (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
value);
}
-struct extra
- {
- char str[128];
- int len;
- }; /* Maximum extension is 128! FIXME */
-
-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);
+/* A function to show the status of strict type checking. */
+static void
+show_strict_type_checking (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("Strict type checking is %s.\n"), value);
+}
+\f
/* Allocate a new OBJFILE-associated type structure and fill it
with some defaults. Space for the type structure is allocated
on the objfile's objfile_obstack. */
/* Alloc the structure and start off with all fields zeroed. */
- type = XZALLOC (struct type);
- TYPE_MAIN_TYPE (type) = XZALLOC (struct main_type);
+ type = XCNEW (struct type);
+ TYPE_MAIN_TYPE (type) = XCNEW (struct main_type);
TYPE_OBJFILE_OWNED (type) = 0;
TYPE_OWNER (type).gdbarch = gdbarch;
return TYPE_OWNER (type).gdbarch;
}
+/* See gdbtypes.h. */
+
+struct type *
+get_target_type (struct type *type)
+{
+ if (type != NULL)
+ {
+ type = TYPE_TARGET_TYPE (type);
+ if (type != NULL)
+ type = check_typedef (type);
+ }
+
+ return type;
+}
/* Alloc a new type instance structure, fill it with some defaults,
and point it at OLDTYPE. Allocate the new type instance from the
/* Allocate the structure. */
if (! TYPE_OBJFILE_OWNED (oldtype))
- type = XZALLOC (struct type);
+ type = XCNEW (struct type);
else
type = OBSTACK_ZALLOC (&TYPE_OBJFILE (oldtype)->objfile_obstack,
struct type);
/* Clear all remnants of the previous type at TYPE, in preparation for
replacing it with something else. Preserve owner information. */
+
static void
smash_type (struct type *type)
{
TYPE_TARGET_TYPE (ntype) = type;
TYPE_POINTER_TYPE (type) = ntype;
- /* FIXME! Assume the machine has only one representation for
- pointers! */
+ /* FIXME! Assumes the machine has only one representation for pointers! */
TYPE_LENGTH (ntype)
= gdbarch_ptr_bit (get_type_arch (type)) / TARGET_CHAR_BIT;
gdbarch_address_to_pointer. */
TYPE_UNSIGNED (ntype) = 1;
- if (!TYPE_POINTER_TYPE (type)) /* Remember it, if don't have one. */
- TYPE_POINTER_TYPE (type) = ntype;
-
/* Update the length of all the other variants of this type. */
chain = TYPE_CHAIN (ntype);
while (chain != ntype)
TYPE_LENGTH (ntype) = 1;
TYPE_CODE (ntype) = TYPE_CODE_FUNC;
+ INIT_FUNC_SPECIFIC (ntype);
+
return ntype;
}
-
/* Given a type TYPE, return a type of functions that return that type.
May need to construct such a type if this is the first use. */
return make_function_type (type, (struct type **) 0);
}
+/* Given a type TYPE and argument types, return the appropriate
+ function type. If the final type in PARAM_TYPES is NULL, make a
+ varargs function. */
+
+struct type *
+lookup_function_type_with_arguments (struct type *type,
+ int nparams,
+ struct type **param_types)
+{
+ struct type *fn = make_function_type (type, (struct type **) 0);
+ int i;
+
+ if (nparams > 0)
+ {
+ if (param_types[nparams - 1] == NULL)
+ {
+ --nparams;
+ TYPE_VARARGS (fn) = 1;
+ }
+ else if (TYPE_CODE (check_typedef (param_types[nparams - 1]))
+ == TYPE_CODE_VOID)
+ {
+ --nparams;
+ /* Caller should have ensured this. */
+ gdb_assert (nparams == 0);
+ TYPE_PROTOTYPED (fn) = 1;
+ }
+ }
+
+ TYPE_NFIELDS (fn) = nparams;
+ TYPE_FIELDS (fn) = TYPE_ZALLOC (fn, nparams * sizeof (struct field));
+ for (i = 0; i < nparams; ++i)
+ TYPE_FIELD_TYPE (fn, i) = param_types[i];
+
+ return fn;
+}
+
/* Identify address space identifier by name --
return the integer flag defined in gdbtypes.h. */
-extern int
+
+int
address_space_name_to_int (struct gdbarch *gdbarch, char *space_identifier)
{
int type_flags;
in the same objfile. Otherwise, allocate fresh memory for the new
type whereever TYPE lives. If TYPEPTR is non-zero, set it to the
new type we construct. */
+
struct type *
make_cv_type (int cnst, int voltl,
struct type *type,
return ntype;
}
+/* Make a 'restrict'-qualified version of TYPE. */
+
+struct type *
+make_restrict_type (struct type *type)
+{
+ return make_qualified_type (type,
+ (TYPE_INSTANCE_FLAGS (type)
+ | TYPE_INSTANCE_FLAG_RESTRICT),
+ NULL);
+}
+
/* Replace the contents of ntype with the type *type. This changes the
contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
the changes are propogated to all types in the TYPE_CHAIN.
smashing is ugly, and needs to be replaced with something more
controlled. TYPE_MAIN_TYPE is a step in this direction; it's not
clear if more steps are needed. */
+
void
replace_type (struct type *ntype, struct type *type)
{
if (TYPE_NFIELDS (type) > 0)
{
/* The enums may not be sorted by value, so search all
- entries */
+ entries. */
int i;
- *lowp = *highp = TYPE_FIELD_BITPOS (type, 0);
+ *lowp = *highp = TYPE_FIELD_ENUMVAL (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 (TYPE_FIELD_ENUMVAL (type, i) < *lowp)
+ *lowp = TYPE_FIELD_ENUMVAL (type, i);
+ if (TYPE_FIELD_ENUMVAL (type, i) > *highp)
+ *highp = TYPE_FIELD_ENUMVAL (type, i);
}
/* Set unsigned indicator if warranted. */
and lower bound. Save the low bound into LOW_BOUND if not NULL.
Save the high bound into HIGH_BOUND if not NULL.
- Return 1 if the operation was successful. Return zero otherwise,
+ Return 1 if the operation was successful. Return zero otherwise,
in which case the values of LOW_BOUND and HIGH_BOUNDS are unmodified.
We now simply use get_discrete_bounds call to get the values
Elements will be of type ELEMENT_TYPE, the indices will be of type
RANGE_TYPE.
+ If BIT_STRIDE is not zero, build a packed array type whose element
+ size is BIT_STRIDE. Otherwise, ignore this parameter.
+
FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
sure it is TYPE_CODE_UNDEF before we bash it into an array
type? */
struct type *
-create_array_type (struct type *result_type,
- struct type *element_type,
- struct type *range_type)
+create_array_type_with_stride (struct type *result_type,
+ struct type *element_type,
+ struct type *range_type,
+ unsigned int bit_stride)
{
LONGEST low_bound, high_bound;
In such cases, the array length should be zero. */
if (high_bound < low_bound)
TYPE_LENGTH (result_type) = 0;
+ else if (bit_stride > 0)
+ TYPE_LENGTH (result_type) =
+ (bit_stride * (high_bound - low_bound + 1) + 7) / 8;
else
TYPE_LENGTH (result_type) =
TYPE_LENGTH (element_type) * (high_bound - low_bound + 1);
(struct field *) TYPE_ZALLOC (result_type, sizeof (struct field));
TYPE_INDEX_TYPE (result_type) = range_type;
TYPE_VPTR_FIELDNO (result_type) = -1;
+ if (bit_stride > 0)
+ TYPE_FIELD_BITSIZE (result_type, 0) = bit_stride;
- /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays */
+ /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays. */
if (TYPE_LENGTH (result_type) == 0)
TYPE_TARGET_STUB (result_type) = 1;
return result_type;
}
+/* Same as create_array_type_with_stride but with no bit_stride
+ (BIT_STRIDE = 0), thus building an unpacked array. */
+
+struct type *
+create_array_type (struct type *result_type,
+ struct type *element_type,
+ struct type *range_type)
+{
+ return create_array_type_with_stride (result_type, element_type,
+ range_type, 0);
+}
+
struct type *
lookup_array_range_type (struct type *element_type,
- int low_bound, int high_bound)
+ LONGEST low_bound, LONGEST high_bound)
{
struct gdbarch *gdbarch = get_type_arch (element_type);
struct type *index_type = builtin_type (gdbarch)->builtin_int;
struct type *
lookup_string_range_type (struct type *string_char_type,
- int low_bound, int high_bound)
+ LONGEST low_bound, LONGEST high_bound)
{
struct type *result_type;
/* Return a typename for a struct/union/enum type without "struct ",
"union ", or "enum ". If the type has a NULL name, return NULL. */
-char *
+const char *
type_name_no_tag (const struct type *type)
{
if (TYPE_TAG_NAME (type) != NULL)
return TYPE_NAME (type);
}
+/* A wrapper of type_name_no_tag which calls error if the type is anonymous.
+ Since GCC PR debug/47510 DWARF provides associated information to detect the
+ anonymous class linkage name from its typedef.
+
+ Parameter TYPE should not yet have CHECK_TYPEDEF applied, this function will
+ apply it itself. */
+
+const char *
+type_name_no_tag_or_error (struct type *type)
+{
+ struct type *saved_type = type;
+ const char *name;
+ struct objfile *objfile;
+
+ CHECK_TYPEDEF (type);
+
+ name = type_name_no_tag (type);
+ if (name != NULL)
+ return name;
+
+ name = type_name_no_tag (saved_type);
+ objfile = TYPE_OBJFILE (saved_type);
+ error (_("Invalid anonymous type %s [in module %s], GCC PR debug/47510 bug?"),
+ name ? name : "<anonymous>",
+ objfile ? objfile_name (objfile) : "<arch>");
+}
+
/* Lookup a typedef or primitive type named NAME, visible in lexical
block BLOCK. If NOERR is nonzero, return zero if NAME is not
suitably defined. */
struct type *
lookup_typename (const struct language_defn *language,
- struct gdbarch *gdbarch, char *name,
+ struct gdbarch *gdbarch, const char *name,
const struct block *block, int noerr)
{
struct symbol *sym;
- struct type *tmp;
+ struct type *type;
sym = lookup_symbol (name, block, VAR_DOMAIN, 0);
- if (sym == NULL || SYMBOL_CLASS (sym) != LOC_TYPEDEF)
- {
- tmp = language_lookup_primitive_type_by_name (language, gdbarch, name);
- if (tmp)
- {
- return tmp;
- }
- else if (!tmp && noerr)
- {
- return NULL;
- }
- else
- {
- error (_("No type named %s."), name);
- }
- }
- return (SYMBOL_TYPE (sym));
+ if (sym != NULL && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
+ return SYMBOL_TYPE (sym);
+
+ type = language_lookup_primitive_type_by_name (language, gdbarch, name);
+ if (type)
+ return type;
+
+ if (noerr)
+ return NULL;
+ error (_("No type named %s."), name);
}
struct type *
lookup_unsigned_typename (const struct language_defn *language,
- struct gdbarch *gdbarch, char *name)
+ struct gdbarch *gdbarch, const char *name)
{
char *uns = alloca (strlen (name) + 10);
struct type *
lookup_signed_typename (const struct language_defn *language,
- struct gdbarch *gdbarch, char *name)
+ struct gdbarch *gdbarch, const char *name)
{
struct type *t;
char *uns = alloca (strlen (name) + 8);
visible in lexical block BLOCK. */
struct type *
-lookup_struct (char *name, struct block *block)
+lookup_struct (const char *name, const struct block *block)
{
struct symbol *sym;
visible in lexical block BLOCK. */
struct type *
-lookup_union (char *name, struct block *block)
+lookup_union (const char *name, const struct block *block)
{
struct symbol *sym;
struct type *t;
name);
}
-
/* Lookup an enum type named "enum NAME",
visible in lexical block BLOCK. */
struct type *
-lookup_enum (char *name, struct block *block)
+lookup_enum (const char *name, const struct block *block)
{
struct symbol *sym;
struct type *
lookup_template_type (char *name, struct type *type,
- struct block *block)
+ const struct block *block)
{
struct symbol *sym;
char *nam = (char *)
strcpy (nam, name);
strcat (nam, "<");
strcat (nam, TYPE_NAME (type));
- strcat (nam, " >"); /* FIXME, extra space still introduced in gcc? */
+ strcat (nam, " >"); /* FIXME, extra space still introduced in gcc? */
sym = lookup_symbol (nam, block, VAR_DOMAIN, 0);
If NAME is the name of a baseclass type, return that type. */
struct type *
-lookup_struct_elt_type (struct type *type, char *name, int noerr)
+lookup_struct_elt_type (struct type *type, const char *name, int noerr)
{
int i;
char *typename;
#if 0
/* FIXME: This change put in by Michael seems incorrect for the case
where the structure tag name is the same as the member name.
- I.E. when doing "ptype bell->bar" for "struct foo { int bar; int
+ I.e. when doing "ptype bell->bar" for "struct foo { int bar; int
foo; } bell;" Disabled by fnf. */
{
char *typename;
for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
{
- char *t_field_name = TYPE_FIELD_NAME (type, i);
+ const char *t_field_name = TYPE_FIELD_NAME (type, i);
if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
{
error (_("Type %s has no component named %s."), typename, name);
}
+/* Store in *MAX the largest number representable by unsigned integer type
+ TYPE. */
+
+void
+get_unsigned_type_max (struct type *type, ULONGEST *max)
+{
+ unsigned int n;
+
+ CHECK_TYPEDEF (type);
+ gdb_assert (TYPE_CODE (type) == TYPE_CODE_INT && TYPE_UNSIGNED (type));
+ gdb_assert (TYPE_LENGTH (type) <= sizeof (ULONGEST));
+
+ /* Written this way to avoid overflow. */
+ n = TYPE_LENGTH (type) * TARGET_CHAR_BIT;
+ *max = ((((ULONGEST) 1 << (n - 1)) - 1) << 1) | 1;
+}
+
+/* Store in *MIN, *MAX the smallest and largest numbers representable by
+ signed integer type TYPE. */
+
+void
+get_signed_type_minmax (struct type *type, LONGEST *min, LONGEST *max)
+{
+ unsigned int n;
+
+ CHECK_TYPEDEF (type);
+ gdb_assert (TYPE_CODE (type) == TYPE_CODE_INT && !TYPE_UNSIGNED (type));
+ gdb_assert (TYPE_LENGTH (type) <= sizeof (LONGEST));
+
+ n = TYPE_LENGTH (type) * TARGET_CHAR_BIT;
+ *min = -((ULONGEST) 1 << (n - 1));
+ *max = ((ULONGEST) 1 << (n - 1)) - 1;
+}
+
/* Lookup the vptr basetype/fieldno values for TYPE.
If found store vptr_basetype in *BASETYPEP if non-NULL, and return
vptr_fieldno. Also, if found and basetype is from the same objfile,
if (fieldno >= 0)
{
/* If the type comes from a different objfile we can't cache
- it, it may have a different lifetime. PR 2384 */
+ it, it may have a different lifetime. PR 2384 */
if (TYPE_OBJFILE (type) == TYPE_OBJFILE (basetype))
{
TYPE_VPTR_FIELDNO (type) = fieldno;
not been computed and we're either in the middle of reading symbols, or
there was no name for the typedef in the debug info.
+ NOTE: Lookup of opaque types can throw errors for invalid symbol files.
+ QUITs in the symbol reading code can also throw.
+ Thus this function can throw an exception.
+
If TYPE is a TYPE_CODE_TYPEDEF, its length is updated to the length of
the target type.
If this is a stubbed struct (i.e. declared as struct foo *), see if
- we can find a full definition in some other file. If so, copy this
+ we can find a full definition in some other file. If so, copy this
definition, so we can use it in future. There used to be a comment
(but not any code) that if we don't find a full definition, we'd
set a flag so we don't spend time in the future checking the same
{
if (!TYPE_TARGET_TYPE (type))
{
- char *name;
+ const char *name;
struct symbol *sym;
/* It is dangerous to call lookup_symbol if we are currently
&& opaque_type_resolution
&& !currently_reading_symtab)
{
- char *name = type_name_no_tag (type);
+ const char *name = type_name_no_tag (type);
struct type *newtype;
if (name == NULL)
types. */
else if (TYPE_STUB (type) && !currently_reading_symtab)
{
- char *name = type_name_no_tag (type);
+ const char *name = type_name_no_tag (type);
/* FIXME: shouldn't we separately check the TYPE_NAME and the
TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
as appropriate? (this code was written before TYPE_NAME and
/* Now recompute the length of the array type, based on its
number of elements and the target type's length.
Watch out for Ada null Ada arrays where the high bound
- is smaller than the low bound. */
+ is smaller than the low bound. */
const LONGEST low_bound = TYPE_LOW_BOUND (range_type);
const LONGEST high_bound = TYPE_HIGH_BOUND (range_type);
ULONGEST len;
that for x < 0, (ULONGEST) x == -x + ULONGEST_MAX + 1,
which is technically not guaranteed by C, but is usually true
(because it would be true if x were unsigned with its
- high-order bit on). It uses the fact that
+ high-order bit on). It uses the fact that
high_bound-low_bound is always representable in
ULONGEST and that if high_bound-low_bound+1 overflows,
it overflows to 0. We must change these tests if we
decide to increase the representation of TYPE_LENGTH
- from unsigned int to ULONGEST. */
+ from unsigned int to ULONGEST. */
ULONGEST ulow = low_bound, uhigh = high_bound;
ULONGEST tlen = TYPE_LENGTH (target_type);
safe_parse_type (struct gdbarch *gdbarch, char *p, int length)
{
struct ui_file *saved_gdb_stderr;
- struct type *type;
+ struct type *type = NULL; /* Initialize to keep gcc happy. */
+ volatile struct gdb_exception except;
/* Suppress error messages. */
saved_gdb_stderr = gdb_stderr;
gdb_stderr = ui_file_new ();
/* Call parse_and_eval_type() without fear of longjmp()s. */
- if (!gdb_parse_and_eval_type (p, length, &type))
+ TRY_CATCH (except, RETURN_MASK_ERROR)
+ {
+ type = parse_and_eval_type (p, length);
+ }
+
+ if (except.reason < 0)
type = builtin_type (gdbarch)->builtin_void;
/* Stop suppressing error messages. */
struct gdbarch *gdbarch = get_type_arch (type);
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 *demangled_name = gdb_demangle (mangled_name,
+ DMGL_PARAMS | DMGL_ANSI);
char *argtypetext, *p;
int depth = 0, argcount = 1;
struct field *argtypes;
argcount = 1;
}
- if (*p != ')') /* () means no args, skip while */
+ if (*p != ')') /* () means no args, skip while. */
{
depth = 0;
while (*p)
/* Set the TYPE's type-specific kind to TYPE_SPECIFIC_GNAT_STUFF,
and allocate the associated gnat-specific data. The gnat-specific
data is also initialized to gnat_aux_default. */
+
void
allocate_gnat_aux_type (struct type *type)
{
*(TYPE_GNAT_SPECIFIC (type)) = gnat_aux_default;
}
-
/* Helper function to initialize the standard scalar types.
- If NAME is non-NULL, then we make a copy of the string pointed
- to by name in the objfile_obstack for that objfile, and initialize
- the type name to that copy. There are places (mipsread.c in particular),
- where init_type is called with a NULL value for NAME). */
+ If NAME is non-NULL, then it is used to initialize the type name.
+ Note that NAME is not copied; it is required to have a lifetime at
+ least as long as OBJFILE. */
struct type *
init_type (enum type_code code, int length, int flags,
- char *name, struct objfile *objfile)
+ const char *name, struct objfile *objfile)
{
struct type *type;
TYPE_STUB_SUPPORTED (type) = 1;
if (flags & TYPE_FLAG_FIXED_INSTANCE)
TYPE_FIXED_INSTANCE (type) = 1;
+ if (flags & TYPE_FLAG_GNU_IFUNC)
+ TYPE_GNU_IFUNC (type) = 1;
- if (name)
- TYPE_NAME (type) = obsavestring (name, strlen (name),
- &objfile->objfile_obstack);
+ TYPE_NAME (type) = name;
/* C++ fancies. */
TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_FLOATFORMAT;
break;
case TYPE_CODE_FUNC:
- TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_CALLING_CONVENTION;
+ INIT_FUNC_SPECIFIC (type);
break;
}
return type;
}
+\f
+/* Queries on types. */
int
can_dereference (struct type *t)
|| (TYPE_CODE (t) == TYPE_CODE_BOOL)));
}
+/* Return true if TYPE is scalar. */
+
+static int
+is_scalar_type (struct type *type)
+{
+ CHECK_TYPEDEF (type);
+
+ switch (TYPE_CODE (type))
+ {
+ case TYPE_CODE_ARRAY:
+ case TYPE_CODE_STRUCT:
+ case TYPE_CODE_UNION:
+ case TYPE_CODE_SET:
+ case TYPE_CODE_STRING:
+ return 0;
+ default:
+ return 1;
+ }
+}
+
+/* Return true if T is scalar, or a composite type which in practice has
+ the memory layout of a scalar type. E.g., an array or struct with only
+ one scalar element inside it, or a union with only scalar elements. */
+
+int
+is_scalar_type_recursive (struct type *t)
+{
+ CHECK_TYPEDEF (t);
+
+ if (is_scalar_type (t))
+ return 1;
+ /* Are we dealing with an array or string of known dimensions? */
+ else if ((TYPE_CODE (t) == TYPE_CODE_ARRAY
+ || TYPE_CODE (t) == TYPE_CODE_STRING) && TYPE_NFIELDS (t) == 1
+ && TYPE_CODE (TYPE_INDEX_TYPE (t)) == TYPE_CODE_RANGE)
+ {
+ LONGEST low_bound, high_bound;
+ struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (t));
+
+ get_discrete_bounds (TYPE_INDEX_TYPE (t), &low_bound, &high_bound);
+
+ return high_bound == low_bound && is_scalar_type_recursive (elt_type);
+ }
+ /* Are we dealing with a struct with one element? */
+ else if (TYPE_CODE (t) == TYPE_CODE_STRUCT && TYPE_NFIELDS (t) == 1)
+ return is_scalar_type_recursive (TYPE_FIELD_TYPE (t, 0));
+ else if (TYPE_CODE (t) == TYPE_CODE_UNION)
+ {
+ int i, n = TYPE_NFIELDS (t);
+
+ /* If all elements of the union are scalar, then the union is scalar. */
+ for (i = 0; i < n; i++)
+ if (!is_scalar_type_recursive (TYPE_FIELD_TYPE (t, i)))
+ return 0;
+
+ return 1;
+ }
+
+ return 0;
+}
+
/* A helper function which returns true if types A and B represent the
"same" class type. This is true if the types have the same main
type, or the same name. */
of DCLASS.
Eg:
- distance_to_ancestor (A, D, 1) = -1 */
+ distance_to_ancestor (A, D, 1) = -1. */
static int
distance_to_ancestor (struct type *base, struct type *dclass, int public)
static int
is_unique_ancestor_worker (struct type *base, struct type *dclass,
int *offset,
- const bfd_byte *contents, CORE_ADDR address)
+ const gdb_byte *valaddr, int embedded_offset,
+ CORE_ADDR address, struct value *val)
{
int i, count = 0;
for (i = 0; i < TYPE_N_BASECLASSES (dclass) && count < 2; ++i)
{
- struct type *iter = check_typedef (TYPE_BASECLASS (dclass, i));
- int this_offset = baseclass_offset (dclass, i, contents, address);
+ struct type *iter;
+ int this_offset;
+
+ iter = check_typedef (TYPE_BASECLASS (dclass, i));
- if (this_offset == -1)
- error (_("virtual baseclass botch"));
+ this_offset = baseclass_offset (dclass, i, valaddr, embedded_offset,
+ address, val);
if (class_types_same_p (base, iter))
{
}
else
count += is_unique_ancestor_worker (base, iter, offset,
- contents + this_offset,
- address + this_offset);
+ valaddr,
+ embedded_offset + this_offset,
+ address, val);
}
return count;
int offset = -1;
return is_unique_ancestor_worker (base, value_type (val), &offset,
- value_contents (val),
- value_address (val)) == 1;
+ value_contents_for_printing (val),
+ value_embedded_offset (val),
+ value_address (val), val) == 1;
}
\f
+/* Overload resolution. */
/* Return the sum of the rank of A with the rank of B. */
if (a.rank < b.rank)
return 1;
- /* a.rank > b.rank */
+ /* a.rank > b.rank */
return -1;
}
-/* Functions for overload resolution begin here */
+/* Functions for overload resolution begin here. */
/* Compare two badness vectors A and B and return the result.
0 => A and B are identical
struct badness_vector *
rank_function (struct type **parms, int nparms,
- struct type **args, int nargs)
+ struct value **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; /* add 1 for the length-match rank */
+ bv->length = nargs + 1; /* add 1 for the length-match rank. */
bv->rank = xmalloc ((nargs + 1) * sizeof (int));
/* First compare the lengths of the supplied lists.
? LENGTH_MISMATCH_BADNESS
: EXACT_MATCH_BADNESS;
- /* Now rank all the parameters of the candidate function */
+ /* Now rank all the parameters of the candidate function. */
for (i = 1; i <= min_len; i++)
- bv->rank[i] = rank_one_type (parms[i-1], args[i-1]);
+ bv->rank[i] = rank_one_type (parms[i - 1], value_type (args[i - 1]),
+ args[i - 1]);
- /* If more arguments than parameters, add dummy entries */
+ /* If more arguments than parameters, add dummy entries. */
for (i = min_len + 1; i <= nargs; i++)
bv->rank[i] = TOO_FEW_PARAMS_BADNESS;
/* Compares type A to type B returns 1 if the represent the same type
0 otherwise. */
-static int
+int
types_equal (struct type *a, struct type *b)
{
/* Identical type pointers. */
return types_equal (TYPE_TARGET_TYPE (a),
TYPE_TARGET_TYPE (b));
- /*
- Well, damnit, if the names are exactly the same, I'll say they
+ /* Well, damnit, if the names are exactly the same, I'll say they
are exactly the same. This happens when we generate method
stubs. The types won't point to the same address, but they
- really are the same.
- */
+ really are the same. */
if (TYPE_NAME (a) && TYPE_NAME (b)
&& strcmp (TYPE_NAME (a), TYPE_NAME (b)) == 0)
if (a == b)
return 1;
+ /* Two function types are equal if their argument and return types
+ are equal. */
+ if (TYPE_CODE (a) == TYPE_CODE_FUNC)
+ {
+ int i;
+
+ if (TYPE_NFIELDS (a) != TYPE_NFIELDS (b))
+ return 0;
+
+ if (!types_equal (TYPE_TARGET_TYPE (a), TYPE_TARGET_TYPE (b)))
+ return 0;
+
+ for (i = 0; i < TYPE_NFIELDS (a); ++i)
+ if (!types_equal (TYPE_FIELD_TYPE (a, i), TYPE_FIELD_TYPE (b, i)))
+ return 0;
+
+ return 1;
+ }
+
return 0;
}
+\f
+/* Deep comparison of types. */
+
+/* An entry in the type-equality bcache. */
+
+typedef struct type_equality_entry
+{
+ struct type *type1, *type2;
+} type_equality_entry_d;
+
+DEF_VEC_O (type_equality_entry_d);
+
+/* A helper function to compare two strings. Returns 1 if they are
+ the same, 0 otherwise. Handles NULLs properly. */
+
+static int
+compare_maybe_null_strings (const char *s, const char *t)
+{
+ if (s == NULL && t != NULL)
+ return 0;
+ else if (s != NULL && t == NULL)
+ return 0;
+ else if (s == NULL && t== NULL)
+ return 1;
+ return strcmp (s, t) == 0;
+}
+
+/* A helper function for check_types_worklist that checks two types for
+ "deep" equality. Returns non-zero if the types are considered the
+ same, zero otherwise. */
+
+static int
+check_types_equal (struct type *type1, struct type *type2,
+ VEC (type_equality_entry_d) **worklist)
+{
+ CHECK_TYPEDEF (type1);
+ CHECK_TYPEDEF (type2);
+
+ if (type1 == type2)
+ return 1;
+
+ if (TYPE_CODE (type1) != TYPE_CODE (type2)
+ || TYPE_LENGTH (type1) != TYPE_LENGTH (type2)
+ || TYPE_UNSIGNED (type1) != TYPE_UNSIGNED (type2)
+ || TYPE_NOSIGN (type1) != TYPE_NOSIGN (type2)
+ || TYPE_VARARGS (type1) != TYPE_VARARGS (type2)
+ || TYPE_VECTOR (type1) != TYPE_VECTOR (type2)
+ || TYPE_NOTTEXT (type1) != TYPE_NOTTEXT (type2)
+ || TYPE_INSTANCE_FLAGS (type1) != TYPE_INSTANCE_FLAGS (type2)
+ || TYPE_NFIELDS (type1) != TYPE_NFIELDS (type2))
+ return 0;
+
+ if (!compare_maybe_null_strings (TYPE_TAG_NAME (type1),
+ TYPE_TAG_NAME (type2)))
+ return 0;
+ if (!compare_maybe_null_strings (TYPE_NAME (type1), TYPE_NAME (type2)))
+ return 0;
+
+ if (TYPE_CODE (type1) == TYPE_CODE_RANGE)
+ {
+ if (memcmp (TYPE_RANGE_DATA (type1), TYPE_RANGE_DATA (type2),
+ sizeof (*TYPE_RANGE_DATA (type1))) != 0)
+ return 0;
+ }
+ else
+ {
+ int i;
+
+ for (i = 0; i < TYPE_NFIELDS (type1); ++i)
+ {
+ const struct field *field1 = &TYPE_FIELD (type1, i);
+ const struct field *field2 = &TYPE_FIELD (type2, i);
+ struct type_equality_entry entry;
+
+ if (FIELD_ARTIFICIAL (*field1) != FIELD_ARTIFICIAL (*field2)
+ || FIELD_BITSIZE (*field1) != FIELD_BITSIZE (*field2)
+ || FIELD_LOC_KIND (*field1) != FIELD_LOC_KIND (*field2))
+ return 0;
+ if (!compare_maybe_null_strings (FIELD_NAME (*field1),
+ FIELD_NAME (*field2)))
+ return 0;
+ switch (FIELD_LOC_KIND (*field1))
+ {
+ case FIELD_LOC_KIND_BITPOS:
+ if (FIELD_BITPOS (*field1) != FIELD_BITPOS (*field2))
+ return 0;
+ break;
+ case FIELD_LOC_KIND_ENUMVAL:
+ if (FIELD_ENUMVAL (*field1) != FIELD_ENUMVAL (*field2))
+ return 0;
+ break;
+ case FIELD_LOC_KIND_PHYSADDR:
+ if (FIELD_STATIC_PHYSADDR (*field1)
+ != FIELD_STATIC_PHYSADDR (*field2))
+ return 0;
+ break;
+ case FIELD_LOC_KIND_PHYSNAME:
+ if (!compare_maybe_null_strings (FIELD_STATIC_PHYSNAME (*field1),
+ FIELD_STATIC_PHYSNAME (*field2)))
+ return 0;
+ break;
+ case FIELD_LOC_KIND_DWARF_BLOCK:
+ {
+ struct dwarf2_locexpr_baton *block1, *block2;
+
+ block1 = FIELD_DWARF_BLOCK (*field1);
+ block2 = FIELD_DWARF_BLOCK (*field2);
+ if (block1->per_cu != block2->per_cu
+ || block1->size != block2->size
+ || memcmp (block1->data, block2->data, block1->size) != 0)
+ return 0;
+ }
+ break;
+ default:
+ internal_error (__FILE__, __LINE__, _("Unsupported field kind "
+ "%d by check_types_equal"),
+ FIELD_LOC_KIND (*field1));
+ }
+
+ entry.type1 = FIELD_TYPE (*field1);
+ entry.type2 = FIELD_TYPE (*field2);
+ VEC_safe_push (type_equality_entry_d, *worklist, &entry);
+ }
+ }
+
+ if (TYPE_TARGET_TYPE (type1) != NULL)
+ {
+ struct type_equality_entry entry;
+
+ if (TYPE_TARGET_TYPE (type2) == NULL)
+ return 0;
+ entry.type1 = TYPE_TARGET_TYPE (type1);
+ entry.type2 = TYPE_TARGET_TYPE (type2);
+ VEC_safe_push (type_equality_entry_d, *worklist, &entry);
+ }
+ else if (TYPE_TARGET_TYPE (type2) != NULL)
+ return 0;
+
+ return 1;
+}
+
+/* Check types on a worklist for equality. Returns zero if any pair
+ is not equal, non-zero if they are all considered equal. */
+
+static int
+check_types_worklist (VEC (type_equality_entry_d) **worklist,
+ struct bcache *cache)
+{
+ while (!VEC_empty (type_equality_entry_d, *worklist))
+ {
+ struct type_equality_entry entry;
+ int added;
+
+ entry = *VEC_last (type_equality_entry_d, *worklist);
+ VEC_pop (type_equality_entry_d, *worklist);
+
+ /* If the type pair has already been visited, we know it is
+ ok. */
+ bcache_full (&entry, sizeof (entry), cache, &added);
+ if (!added)
+ continue;
+
+ if (check_types_equal (entry.type1, entry.type2, worklist) == 0)
+ return 0;
+ }
+
+ return 1;
+}
+
+/* Return non-zero if types TYPE1 and TYPE2 are equal, as determined by a
+ "deep comparison". Otherwise return zero. */
+
+int
+types_deeply_equal (struct type *type1, struct type *type2)
+{
+ volatile struct gdb_exception except;
+ int result = 0;
+ struct bcache *cache;
+ VEC (type_equality_entry_d) *worklist = NULL;
+ struct type_equality_entry entry;
+
+ gdb_assert (type1 != NULL && type2 != NULL);
+
+ /* Early exit for the simple case. */
+ if (type1 == type2)
+ return 1;
+
+ cache = bcache_xmalloc (NULL, NULL);
+
+ entry.type1 = type1;
+ entry.type2 = type2;
+ VEC_safe_push (type_equality_entry_d, worklist, &entry);
+
+ TRY_CATCH (except, RETURN_MASK_ALL)
+ {
+ result = check_types_worklist (&worklist, cache);
+ }
+ /* check_types_worklist calls several nested helper functions,
+ some of which can raise a GDB Exception, so we just check
+ and rethrow here. If there is a GDB exception, a comparison
+ is not capable (or trusted), so exit. */
+ bcache_xfree (cache);
+ VEC_free (type_equality_entry_d, worklist);
+ /* Rethrow if there was a problem. */
+ if (except.reason < 0)
+ throw_exception (except);
+
+ return result;
+}
+\f
/* Compare one type (PARM) for compatibility with another (ARG).
* PARM is intended to be the parameter type of a function; and
* ARG is the supplied argument's type. This function tests if
* the latter can be converted to the former.
+ * VALUE is the argument's value or NULL if none (or called recursively)
*
* Return 0 if they are identical types;
* Otherwise, return an integer which corresponds to how compatible
* Generally the "bad" conversions are all uniformly assigned a 100. */
struct rank
-rank_one_type (struct type *parm, struct type *arg)
+rank_one_type (struct type *parm, struct type *arg, struct value *value)
{
struct rank rank = {0,0};
/* See through references, since we can almost make non-references
references. */
if (TYPE_CODE (arg) == TYPE_CODE_REF)
- return (sum_ranks (rank_one_type (parm, TYPE_TARGET_TYPE (arg)),
+ return (sum_ranks (rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL),
REFERENCE_CONVERSION_BADNESS));
if (TYPE_CODE (parm) == TYPE_CODE_REF)
- return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm), arg),
+ return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL),
REFERENCE_CONVERSION_BADNESS));
if (overload_debug)
/* Debugging only. */
TYPE_NAME (arg), TYPE_CODE (arg),
TYPE_NAME (parm), TYPE_CODE (parm));
- /* x -> y means arg of type x being supplied for parameter of type y */
+ /* x -> y means arg of type x being supplied for parameter of type y. */
switch (TYPE_CODE (parm))
{
return EXACT_MATCH_BADNESS;
return INCOMPATIBLE_TYPE_BADNESS;
case TYPE_CODE_FUNC:
- return rank_one_type (TYPE_TARGET_TYPE (parm), arg);
+ return rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL);
case TYPE_CODE_INT:
+ if (value != NULL && TYPE_CODE (value_type (value)) == TYPE_CODE_INT)
+ {
+ if (value_as_long (value) == 0)
+ {
+ /* Null pointer conversion: allow it to be cast to a pointer.
+ [4.10.1 of C++ standard draft n3290] */
+ return NULL_POINTER_CONVERSION_BADNESS;
+ }
+ else
+ {
+ /* If type checking is disabled, allow the conversion. */
+ if (!strict_type_checking)
+ return NS_INTEGER_POINTER_CONVERSION_BADNESS;
+ }
+ }
+ /* fall through */
case TYPE_CODE_ENUM:
case TYPE_CODE_FLAGS:
case TYPE_CODE_CHAR:
case TYPE_CODE_PTR:
case TYPE_CODE_ARRAY:
return rank_one_type (TYPE_TARGET_TYPE (parm),
- TYPE_TARGET_TYPE (arg));
+ TYPE_TARGET_TYPE (arg), NULL);
default:
return INCOMPATIBLE_TYPE_BADNESS;
}
switch (TYPE_CODE (arg))
{
case TYPE_CODE_PTR: /* funcptr -> func */
- return rank_one_type (parm, TYPE_TARGET_TYPE (arg));
+ return rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL);
default:
return INCOMPATIBLE_TYPE_BADNESS;
}
signed and unsigned ints. */
if (TYPE_NOSIGN (parm))
{
- /* This case only for character types */
+ /* This case only for character types. */
if (TYPE_NOSIGN (arg))
return EXACT_MATCH_BADNESS; /* plain char -> plain char */
else /* signed/unsigned char -> plain char */
"int")
&& integer_types_same_name_p (TYPE_NAME (parm),
"long"))
- return INTEGER_PROMOTION_BADNESS; /* unsigned int -> unsigned long */
+ /* unsigned int -> unsigned long */
+ return INTEGER_PROMOTION_BADNESS;
else
- return INTEGER_CONVERSION_BADNESS; /* unsigned long -> unsigned int */
+ /* unsigned long -> unsigned int */
+ return INTEGER_CONVERSION_BADNESS;
}
else
{
"long")
&& integer_types_same_name_p (TYPE_NAME (parm),
"int"))
- return INTEGER_CONVERSION_BADNESS; /* signed long -> unsigned int */
+ /* signed long -> unsigned int */
+ return INTEGER_CONVERSION_BADNESS;
else
- return INTEGER_CONVERSION_BADNESS; /* signed int/long -> unsigned int/long */
+ /* signed int/long -> unsigned int/long */
+ return INTEGER_CONVERSION_BADNESS;
}
}
else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
case TYPE_CODE_BOOL:
switch (TYPE_CODE (arg))
{
+ /* n3290 draft, section 4.12.1 (conv.bool):
+
+ "A prvalue of arithmetic, unscoped enumeration, pointer, or
+ pointer to member type can be converted to a prvalue of type
+ bool. A zero value, null pointer value, or null member pointer
+ value is converted to false; any other value is converted to
+ true. A prvalue of type std::nullptr_t can be converted to a
+ prvalue of type bool; the resulting value is false." */
case TYPE_CODE_INT:
case TYPE_CODE_CHAR:
- case TYPE_CODE_RANGE:
case TYPE_CODE_ENUM:
case TYPE_CODE_FLT:
- return INCOMPATIBLE_TYPE_BADNESS;
+ case TYPE_CODE_MEMBERPTR:
case TYPE_CODE_PTR:
- return BOOL_PTR_CONVERSION_BADNESS;
+ return BOOL_CONVERSION_BADNESS;
+ case TYPE_CODE_RANGE:
+ return INCOMPATIBLE_TYPE_BADNESS;
case TYPE_CODE_BOOL:
return EXACT_MATCH_BADNESS;
default:
}
break;
case TYPE_CODE_STRUCT:
- /* currently same as TYPE_CODE_CLASS */
+ /* currently same as TYPE_CODE_CLASS. */
switch (TYPE_CODE (arg))
{
case TYPE_CODE_STRUCT:
/* Not in C++ */
case TYPE_CODE_SET:
return rank_one_type (TYPE_FIELD_TYPE (parm, 0),
- TYPE_FIELD_TYPE (arg, 0));
+ TYPE_FIELD_TYPE (arg, 0), NULL);
default:
return INCOMPATIBLE_TYPE_BADNESS;
}
} /* switch (TYPE_CODE (arg)) */
}
-
-/* End of functions for overload resolution */
+/* End of functions for overload resolution. */
+\f
+/* Routines to pretty-print types. */
static void
print_bit_vector (B_TYPE *bits, int nbits)
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 *",
case TYPE_CODE_STRING:
printf_filtered ("(TYPE_CODE_STRING)");
break;
- case TYPE_CODE_BITSTRING:
- printf_filtered ("(TYPE_CODE_BITSTRING)");
- break;
case TYPE_CODE_ERROR:
printf_filtered ("(TYPE_CODE_ERROR)");
break;
{
puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
}
+ if (TYPE_RESTRICT (type))
+ {
+ puts_filtered (" TYPE_FLAG_RESTRICT");
+ }
puts_filtered ("\n");
printfi_filtered (spaces, "flags");
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));
+ if (TYPE_CODE (type) == TYPE_CODE_ENUM)
+ printfi_filtered (spaces + 2,
+ "[%d] enumval %s type ",
+ idx, plongest (TYPE_FIELD_ENUMVAL (type, idx)));
+ else
+ 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
plongest (TYPE_LOW_BOUND (type)),
TYPE_LOW_BOUND_UNDEFINED (type) ? " (undefined)" : "",
plongest (TYPE_HIGH_BOUND (type)),
- TYPE_HIGH_BOUND_UNDEFINED (type) ? " (undefined)" : "");
+ TYPE_HIGH_BOUND_UNDEFINED (type)
+ ? " (undefined)" : "");
}
printfi_filtered (spaces, "vptr_basetype ");
gdb_print_host_address (TYPE_VPTR_BASETYPE (type), gdb_stdout);
puts_filtered ("\n");
break;
- case TYPE_SPECIFIC_CALLING_CONVENTION:
+ case TYPE_SPECIFIC_FUNC:
printfi_filtered (spaces, "calling_convention %d\n",
TYPE_CALLING_CONVENTION (type));
+ /* tail_call_list is not printed. */
break;
}
if (spaces == 0)
obstack_free (&dont_print_type_obstack, NULL);
}
-
+\f
/* Trivial helpers for the libiberty hash table, for mapping one
type to another. */
/* We must add the new type to the hash table immediately, in case
we encounter this type again during a recursive call below. */
- stored = obstack_alloc (&objfile->objfile_obstack, sizeof (struct type_pair));
+ stored
+ = obstack_alloc (&objfile->objfile_obstack, sizeof (struct type_pair));
stored->old = type;
stored->new = new_type;
*slot = stored;
int i, nfields;
nfields = TYPE_NFIELDS (type);
- TYPE_FIELDS (new_type) = XCALLOC (nfields, struct field);
+ TYPE_FIELDS (new_type) = XCNEWVEC (struct field, nfields);
for (i = 0; i < nfields; i++)
{
TYPE_FIELD_ARTIFICIAL (new_type, i) =
SET_FIELD_BITPOS (TYPE_FIELD (new_type, i),
TYPE_FIELD_BITPOS (type, i));
break;
+ case FIELD_LOC_KIND_ENUMVAL:
+ SET_FIELD_ENUMVAL (TYPE_FIELD (new_type, i),
+ TYPE_FIELD_ENUMVAL (type, i));
+ break;
case FIELD_LOC_KIND_PHYSADDR:
SET_FIELD_PHYSADDR (TYPE_FIELD (new_type, i),
TYPE_FIELD_STATIC_PHYSADDR (type, i));
}
}
- /* For range types, copy the bounds information. */
+ /* For range types, copy the bounds information. */
if (TYPE_CODE (type) == TYPE_CODE_RANGE)
{
TYPE_RANGE_DATA (new_type) = xmalloc (sizeof (struct range_bounds));
return new_type;
}
-
-
+\f
/* Helper functions to initialize architecture-specific types. */
/* Allocate a type structure associated with GDBARCH and set its
CODE, LENGTH, and NAME fields. */
+
struct type *
arch_type (struct gdbarch *gdbarch,
enum type_code code, int length, char *name)
/* Allocate a TYPE_CODE_INT type structure associated with GDBARCH.
BIT is the type size in bits. If UNSIGNED_P is non-zero, set
the type's TYPE_UNSIGNED flag. NAME is the type name. */
+
struct type *
arch_integer_type (struct gdbarch *gdbarch,
int bit, int unsigned_p, char *name)
/* Allocate a TYPE_CODE_CHAR type structure associated with GDBARCH.
BIT is the type size in bits. If UNSIGNED_P is non-zero, set
the type's TYPE_UNSIGNED flag. NAME is the type name. */
+
struct type *
arch_character_type (struct gdbarch *gdbarch,
int bit, int unsigned_p, char *name)
/* Allocate a TYPE_CODE_BOOL type structure associated with GDBARCH.
BIT is the type size in bits. If UNSIGNED_P is non-zero, set
the type's TYPE_UNSIGNED flag. NAME is the type name. */
+
struct type *
arch_boolean_type (struct gdbarch *gdbarch,
int bit, int unsigned_p, char *name)
BIT is the type size in bits; if BIT equals -1, the size is
determined by the floatformat. NAME is the type name. Set the
TYPE_FLOATFORMAT from FLOATFORMATS. */
+
struct type *
arch_float_type (struct gdbarch *gdbarch,
int bit, char *name, const struct floatformat **floatformats)
/* Allocate a TYPE_CODE_COMPLEX type structure associated with GDBARCH.
NAME is the type name. TARGET_TYPE is the component float type. */
+
struct type *
arch_complex_type (struct gdbarch *gdbarch,
char *name, struct type *target_type)
/* Allocate a TYPE_CODE_FLAGS type structure associated with GDBARCH.
NAME is the type name. LENGTH is the size of the flag word in bytes. */
+
struct type *
arch_flags_type (struct gdbarch *gdbarch, char *name, int length)
{
/* Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
position BITPOS is called NAME. */
+
void
append_flags_type_flag (struct type *type, int bitpos, char *name)
{
if (name)
{
TYPE_FIELD_NAME (type, bitpos) = xstrdup (name);
- TYPE_FIELD_BITPOS (type, bitpos) = bitpos;
+ SET_FIELD_BITPOS (TYPE_FIELD (type, bitpos), bitpos);
}
else
{
/* Don't show this field to the user. */
- TYPE_FIELD_BITPOS (type, bitpos) = -1;
+ SET_FIELD_BITPOS (TYPE_FIELD (type, bitpos), -1);
}
}
/* Allocate a TYPE_CODE_STRUCT or TYPE_CODE_UNION type structure (as
specified by CODE) associated with GDBARCH. NAME is the type name. */
+
struct type *
arch_composite_type (struct gdbarch *gdbarch, char *name, enum type_code code)
{
/* Add new field with name NAME and type FIELD to composite type T.
Do not set the field's position or adjust the type's length;
the caller should do so. Return the new field. */
+
struct field *
append_composite_type_field_raw (struct type *t, char *name,
struct type *field)
/* Add new field with name NAME and type FIELD to composite type T.
ALIGNMENT (if non-zero) specifies the minimum field alignment. */
+
void
append_composite_type_field_aligned (struct type *t, char *name,
struct type *field, int alignment)
TYPE_LENGTH (t) = TYPE_LENGTH (t) + TYPE_LENGTH (field);
if (TYPE_NFIELDS (t) > 1)
{
- FIELD_BITPOS (f[0]) = (FIELD_BITPOS (f[-1])
- + (TYPE_LENGTH (FIELD_TYPE (f[-1]))
- * TARGET_CHAR_BIT));
+ SET_FIELD_BITPOS (f[0],
+ (FIELD_BITPOS (f[-1])
+ + (TYPE_LENGTH (FIELD_TYPE (f[-1]))
+ * TARGET_CHAR_BIT)));
if (alignment)
{
- int left = FIELD_BITPOS (f[0]) % (alignment * TARGET_CHAR_BIT);
+ int left;
+
+ alignment *= TARGET_CHAR_BIT;
+ left = FIELD_BITPOS (f[0]) % alignment;
if (left)
{
- FIELD_BITPOS (f[0]) += left;
- TYPE_LENGTH (t) += left / TARGET_CHAR_BIT;
+ SET_FIELD_BITPOS (f[0], FIELD_BITPOS (f[0]) + (alignment - left));
+ TYPE_LENGTH (t) += (alignment - left) / TARGET_CHAR_BIT;
}
}
}
}
/* Add new field with name NAME and type FIELD to composite type T. */
+
void
append_composite_type_field (struct type *t, char *name,
struct type *field)
append_composite_type_field_aligned (t, name, field, 0);
}
-
static struct gdbarch_data *gdbtypes_data;
const struct builtin_type *
= lookup_pointer_type (builtin_type->builtin_void);
builtin_type->builtin_func_ptr
= lookup_pointer_type (lookup_function_type (builtin_type->builtin_void));
+ builtin_type->builtin_func_func
+ = lookup_function_type (builtin_type->builtin_func_ptr);
/* This type represents a GDB internal function. */
builtin_type->internal_fn
return builtin_type;
}
-
/* This set of objfile-based types is intended to be used by symbol
readers as basic types. */
"<text variable, no debug info>", objfile);
TYPE_TARGET_TYPE (objfile_type->nodebug_text_symbol)
= objfile_type->builtin_int;
+ objfile_type->nodebug_text_gnu_ifunc_symbol
+ = init_type (TYPE_CODE_FUNC, 1, TYPE_FLAG_GNU_IFUNC,
+ "<text gnu-indirect-function variable, no debug info>",
+ objfile);
+ TYPE_TARGET_TYPE (objfile_type->nodebug_text_gnu_ifunc_symbol)
+ = objfile_type->nodebug_text_symbol;
+ objfile_type->nodebug_got_plt_symbol
+ = init_type (TYPE_CODE_PTR, gdbarch_addr_bit (gdbarch) / 8, 0,
+ "<text from jump slot in .got.plt, no debug info>",
+ objfile);
+ TYPE_TARGET_TYPE (objfile_type->nodebug_got_plt_symbol)
+ = objfile_type->nodebug_text_symbol;
objfile_type->nodebug_data_symbol
= init_type (TYPE_CODE_INT,
gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0,
"<thread local variable, no debug info>", objfile);
/* NOTE: on some targets, addresses and pointers are not necessarily
- the same --- for example, on the D10V, pointers are 16 bits long,
- but addresses are 32 bits long. See doc/gdbint.texinfo,
- ``Pointers Are Not Always Addresses''.
+ the same.
The upshot is:
- gdb's `struct type' always describes the target's
can access any memory on the target, even if the processor has
separate code and data address spaces.
- So, for example:
- - If v is a value holding a D10V code pointer, its contents are
- in target form: a big-endian address left-shifted two bits.
- - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
- sizeof (void *) == 2 on the target.
-
In this context, objfile_type->builtin_core_addr is a bit odd:
it's a target type for a value the target will never see. It's
only used to hold the values of (typeless) linker symbols, which
return objfile_type;
}
+extern initialize_file_ftype _initialize_gdbtypes;
-extern void _initialize_gdbtypes (void);
void
_initialize_gdbtypes (void)
{
gdbtypes_data = gdbarch_data_register_post_init (gdbtypes_post_init);
objfile_type_data = register_objfile_data ();
- 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_zuinteger_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 user knob for controlling resolution of opaque types. */
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,
+ &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);
+
+ /* Add an option to permit non-strict type checking. */
+ add_setshow_boolean_cmd ("type", class_support,
+ &strict_type_checking,
+ _("Set strict type checking."),
+ _("Show strict type checking."),
+ NULL, NULL,
+ show_strict_type_checking,
+ &setchecklist, &showchecklist);
}