/* Support routines for manipulating internal types for GDB.
- Copyright (C) 1992-1996, 1998-2012 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 "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? */
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. */
static void
value);
}
+/* 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
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
same place as OLDTYPE. */
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.
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;
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 : "<arch>");
+ name ? name : "<anonymous>",
+ objfile ? objfile_name (objfile) : "<arch>");
}
/* Lookup a typedef or primitive type named NAME, visible in lexical
visible in lexical block BLOCK. */
struct type *
-lookup_struct (const 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 (const char *name, struct block *block)
+lookup_union (const char *name, const struct block *block)
{
struct symbol *sym;
struct type *t;
visible in lexical block BLOCK. */
struct type *
-lookup_enum (const 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 *)
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;
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;
/* 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;
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. */
/* 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. */
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
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:
{
puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
}
+ if (TYPE_RESTRICT (type))
+ {
+ puts_filtered (" TYPE_FLAG_RESTRICT");
+ }
puts_filtered ("\n");
printfi_filtered (spaces, "flags");
"<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
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);
}