#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"
/* 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_ibm_long_double
};
+/* 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,
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. */
return TYPE_OWNER (type).gdbarch;
}
-
/* Alloc a new type instance structure, fill it with some defaults,
and point it at OLDTYPE. Allocate the new type instance from the
same place as OLDTYPE. */
/* 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)
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,
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)
{
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. */
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)
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);
name);
}
-
/* Lookup an enum type named "enum NAME",
visible in lexical block BLOCK. */
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))
{
{
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
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. */
/* 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
}
return type;
}
+\f
+/* Queries on types. */
int
can_dereference (struct type *t)
case TYPE_CODE_UNION:
case TYPE_CODE_SET:
case TYPE_CODE_STRING:
- case TYPE_CODE_BITSTRING:
return 0;
default:
return 1;
}
\f
+/* Overload resolution. */
/* Return the sum of the rank of A with the rank of B. */
case TYPE_CODE_FUNC:
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
- && value_as_long (value) == 0)
+ if (value != NULL && TYPE_CODE (value_type (value)) == TYPE_CODE_INT)
{
- /* Null pointer conversion: allow it to be cast to a pointer.
- [4.10.1 of C++ standard draft n3290] */
- return NULL_POINTER_CONVERSION_BADNESS;
+ 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_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:
} /* switch (TYPE_CODE (arg)) */
}
-
/* 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 ("\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
if (spaces == 0)
obstack_free (&dont_print_type_obstack, NULL);
}
-
+\f
/* Trivial helpers for the libiberty hash table, for mapping one
type to another. */
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));
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)
{
if (left)
{
- FIELD_BITPOS (f[0]) += (alignment - left);
+ 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 *
return builtin_type;
}
-
/* This set of objfile-based types is intended to be used by symbol
readers as basic types. */
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,
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);
}
projects / deliverable / binutils-gdb.git / blobdiff