/* Support routines for manipulating internal types for GDB.
- Copyright (C) 1992-2015 Free Software Foundation, Inc.
+ Copyright (C) 1992-2017 Free Software Foundation, Inc.
Contributed by Cygnus Support, using pieces from other GDB modules.
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 LVALUE_REFERENCE_TO_RVALUE_BINDING_BADNESS = {5,0};
+const struct rank DIFFERENT_REFERENCE_TYPE_BADNESS = {6,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};
/* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero,
points to a pointer to memory where the reference type should be
stored. If *TYPEPTR is zero, update it to point to the reference
- type we return. We allocate new memory if needed. */
+ type we return. We allocate new memory if needed. REFCODE denotes
+ the kind of reference type to lookup (lvalue or rvalue reference). */
struct type *
-make_reference_type (struct type *type, struct type **typeptr)
+make_reference_type (struct type *type, struct type **typeptr,
+ enum type_code refcode)
{
struct type *ntype; /* New type */
+ struct type **reftype;
struct type *chain;
- ntype = TYPE_REFERENCE_TYPE (type);
+ gdb_assert (refcode == TYPE_CODE_REF || refcode == TYPE_CODE_RVALUE_REF);
+
+ ntype = (refcode == TYPE_CODE_REF ? TYPE_REFERENCE_TYPE (type)
+ : TYPE_RVALUE_REFERENCE_TYPE (type));
if (ntype)
{
}
TYPE_TARGET_TYPE (ntype) = type;
- TYPE_REFERENCE_TYPE (type) = ntype;
+ reftype = (refcode == TYPE_CODE_REF ? &TYPE_REFERENCE_TYPE (type)
+ : &TYPE_RVALUE_REFERENCE_TYPE (type));
+
+ *reftype = ntype;
/* FIXME! Assume the machine has only one representation for
references, and that it matches the (only) representation for
TYPE_LENGTH (ntype) =
gdbarch_ptr_bit (get_type_arch (type)) / TARGET_CHAR_BIT;
- TYPE_CODE (ntype) = TYPE_CODE_REF;
+ TYPE_CODE (ntype) = refcode;
- if (!TYPE_REFERENCE_TYPE (type)) /* Remember it, if don't have one. */
- TYPE_REFERENCE_TYPE (type) = ntype;
+ *reftype = ntype;
/* Update the length of all the other variants of this type. */
chain = TYPE_CHAIN (ntype);
details. */
struct type *
-lookup_reference_type (struct type *type)
+lookup_reference_type (struct type *type, enum type_code refcode)
+{
+ return make_reference_type (type, (struct type **) 0, refcode);
+}
+
+/* Lookup the lvalue reference type for the type TYPE. */
+
+struct type *
+lookup_lvalue_reference_type (struct type *type)
{
- return make_reference_type (type, (struct type **) 0);
+ return lookup_reference_type (type, TYPE_CODE_REF);
+}
+
+/* Lookup the rvalue reference type for the type TYPE. */
+
+struct type *
+lookup_rvalue_reference_type (struct type *type)
+{
+ return lookup_reference_type (type, TYPE_CODE_RVALUE_REF);
}
/* Lookup a function type that returns type TYPE. TYPEPTR, if
the assignment of one type's main type structure to the other
will produce a type with references to objects (names; field
lists; etc.) allocated on an objfile other than its own. */
- gdb_assert (TYPE_OBJFILE (ntype) == TYPE_OBJFILE (ntype));
+ gdb_assert (TYPE_OBJFILE (ntype) == TYPE_OBJFILE (type));
*TYPE_MAIN_TYPE (ntype) = *TYPE_MAIN_TYPE (type);
TYPE_CODE (result_type) = TYPE_CODE_ARRAY;
TYPE_TARGET_TYPE (result_type) = element_type;
if (has_static_range (TYPE_RANGE_DATA (range_type))
- && (!type_not_associated (result_type)
- && !type_not_allocated (result_type)))
+ && (!type_not_associated (result_type)
+ && !type_not_allocated (result_type)))
{
LONGEST low_bound, high_bound;
if (bit_stride > 0)
TYPE_FIELD_BITSIZE (result_type, 0) = bit_stride;
- /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays. */
+ /* TYPE_TARGET_STUB will take care of zero length arrays. */
if (TYPE_LENGTH (result_type) == 0)
TYPE_TARGET_STUB (result_type) = 1;
const struct block *block, int noerr)
{
struct symbol *sym;
- struct type *type;
sym = lookup_symbol_in_language (name, block, VAR_DOMAIN,
language->la_language, NULL).symbol;
lookup_struct_elt_type (struct type *type, const char *name, int noerr)
{
int i;
- char *type_name;
for (;;)
{
if (TYPE_CODE (type) != TYPE_CODE_STRUCT
&& TYPE_CODE (type) != TYPE_CODE_UNION)
{
- type_name = type_to_string (type);
- make_cleanup (xfree, type_name);
- error (_("Type %s is not a structure or union type."), type_name);
+ std::string type_name = type_to_string (type);
+ error (_("Type %s is not a structure or union type."),
+ type_name.c_str ());
}
#if 0
return NULL;
}
- type_name = type_to_string (type);
- make_cleanup (xfree, type_name);
- error (_("Type %s has no component named %s."), type_name, name);
+ std::string type_name = type_to_string (type);
+ error (_("Type %s has no component named %s."), type_name.c_str (), name);
}
/* Store in *MAX the largest number representable by unsigned integer type
CORE_ADDR value;
struct type *static_range_type, *static_target_type;
const struct dynamic_prop *prop;
- const struct dwarf2_locexpr_baton *baton;
struct dynamic_prop low_bound, high_bound;
gdb_assert (TYPE_CODE (dyn_range_type) == TYPE_CODE_RANGE);
pinfo.type = check_typedef (TYPE_FIELD_TYPE (type, i));
pinfo.valaddr = addr_stack->valaddr;
- pinfo.addr = addr_stack->addr;
+ pinfo.addr
+ = (addr_stack->addr
+ + (TYPE_FIELD_BITPOS (resolved_type, i) / TARGET_CHAR_BIT));
pinfo.next = addr_stack;
TYPE_FIELD_TYPE (resolved_type, i)
resolved_type_bit_length = new_bit_length;
}
- TYPE_LENGTH (resolved_type)
- = (resolved_type_bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
+ /* The length of a type won't change for fortran, but it does for C and Ada.
+ For fortran the size of dynamic fields might change over time but not the
+ type length of the structure. If we adapt it, we run into problems
+ when calculating the element offset for arrays of structs. */
+ if (current_language->la_language != language_fortran)
+ TYPE_LENGTH (resolved_type)
+ = (resolved_type_bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
/* The Ada language uses this field as a cache for static fixed types: reset
it as RESOLVED_TYPE must have its own static fixed type. */
TYPE_DYN_PROP_LIST (type) = temp;
}
+/* Remove dynamic property from TYPE in case it exists. */
+
+void
+remove_dyn_prop (enum dynamic_prop_node_kind prop_kind,
+ struct type *type)
+{
+ struct dynamic_prop_list *prev_node, *curr_node;
+
+ curr_node = TYPE_DYN_PROP_LIST (type);
+ prev_node = NULL;
+
+ while (NULL != curr_node)
+ {
+ if (curr_node->prop_kind == prop_kind)
+ {
+ /* Update the linked list but don't free anything.
+ The property was allocated on objstack and it is not known
+ if we are on top of it. Nevertheless, everything is released
+ when the complete objstack is freed. */
+ if (NULL == prev_node)
+ TYPE_DYN_PROP_LIST (type) = curr_node->next;
+ else
+ prev_node->next = curr_node->next;
+
+ return;
+ }
+
+ prev_node = curr_node;
+ curr_node = curr_node->next;
+ }
+}
/* Find the real type of TYPE. This function returns the real type,
after removing all layers of typedefs, and completing opaque or stub
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))
/* Suppress error messages. */
saved_gdb_stderr = gdb_stderr;
- gdb_stderr = ui_file_new ();
+ gdb_stderr = &null_stream;
/* Call parse_and_eval_type() without fear of longjmp()s. */
TRY
END_CATCH
/* Stop suppressing error messages. */
- ui_file_delete (gdb_stderr);
gdb_stderr = saved_gdb_stderr;
return type;
*(TYPE_GNAT_SPECIFIC (type)) = gnat_aux_default;
}
-/* Helper function to initialize the standard scalar types.
-
- 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. */
+/* Helper function to initialize a newly allocated type. Set type code
+ to CODE and initialize the type-specific fields accordingly. */
-struct type *
-init_type (enum type_code code, int length, int flags,
- const char *name, struct objfile *objfile)
+static void
+set_type_code (struct type *type, enum type_code code)
{
- struct type *type;
-
- type = alloc_type (objfile);
TYPE_CODE (type) = code;
- TYPE_LENGTH (type) = length;
-
- gdb_assert (!(flags & (TYPE_FLAG_MIN - 1)));
- if (flags & TYPE_FLAG_UNSIGNED)
- TYPE_UNSIGNED (type) = 1;
- if (flags & TYPE_FLAG_NOSIGN)
- TYPE_NOSIGN (type) = 1;
- if (flags & TYPE_FLAG_STUB)
- TYPE_STUB (type) = 1;
- if (flags & TYPE_FLAG_TARGET_STUB)
- TYPE_TARGET_STUB (type) = 1;
- if (flags & TYPE_FLAG_STATIC)
- TYPE_STATIC (type) = 1;
- if (flags & TYPE_FLAG_PROTOTYPED)
- TYPE_PROTOTYPED (type) = 1;
- if (flags & TYPE_FLAG_INCOMPLETE)
- TYPE_INCOMPLETE (type) = 1;
- if (flags & TYPE_FLAG_VARARGS)
- TYPE_VARARGS (type) = 1;
- if (flags & TYPE_FLAG_VECTOR)
- TYPE_VECTOR (type) = 1;
- if (flags & TYPE_FLAG_STUB_SUPPORTED)
- 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;
-
- TYPE_NAME (type) = name;
-
- /* C++ fancies. */
-
- if (name && strcmp (name, "char") == 0)
- TYPE_NOSIGN (type) = 1;
switch (code)
{
INIT_FUNC_SPECIFIC (type);
break;
}
+}
+
+/* Helper function to verify floating-point format and size.
+ BIT is the type size in bits; if BIT equals -1, the size is
+ determined by the floatformat. Returns size to be used. */
+
+static int
+verify_floatformat (int bit, const struct floatformat **floatformats)
+{
+ gdb_assert (floatformats != NULL);
+ gdb_assert (floatformats[0] != NULL && floatformats[1] != NULL);
+
+ if (bit == -1)
+ bit = floatformats[0]->totalsize;
+ gdb_assert (bit >= 0);
+
+ size_t len = bit / TARGET_CHAR_BIT;
+ gdb_assert (len >= floatformat_totalsize_bytes (floatformats[0]));
+ gdb_assert (len >= floatformat_totalsize_bytes (floatformats[1]));
+
+ return bit;
+}
+
+/* Helper function to initialize the standard scalar types.
+
+ 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 (struct objfile *objfile, enum type_code code, int length,
+ const char *name)
+{
+ struct type *type;
+
+ type = alloc_type (objfile);
+ set_type_code (type, code);
+ TYPE_LENGTH (type) = length;
+ TYPE_NAME (type) = name;
+
return type;
}
+
+/* Allocate a TYPE_CODE_INT type structure associated with OBJFILE.
+ 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 *
+init_integer_type (struct objfile *objfile,
+ int bit, int unsigned_p, const char *name)
+{
+ struct type *t;
+
+ t = init_type (objfile, TYPE_CODE_INT, bit / TARGET_CHAR_BIT, name);
+ if (unsigned_p)
+ TYPE_UNSIGNED (t) = 1;
+
+ return t;
+}
+
+/* Allocate a TYPE_CODE_CHAR type structure associated with OBJFILE.
+ 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 *
+init_character_type (struct objfile *objfile,
+ int bit, int unsigned_p, const char *name)
+{
+ struct type *t;
+
+ t = init_type (objfile, TYPE_CODE_CHAR, bit / TARGET_CHAR_BIT, name);
+ if (unsigned_p)
+ TYPE_UNSIGNED (t) = 1;
+
+ return t;
+}
+
+/* Allocate a TYPE_CODE_BOOL type structure associated with OBJFILE.
+ 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 *
+init_boolean_type (struct objfile *objfile,
+ int bit, int unsigned_p, const char *name)
+{
+ struct type *t;
+
+ t = init_type (objfile, TYPE_CODE_BOOL, bit / TARGET_CHAR_BIT, name);
+ if (unsigned_p)
+ TYPE_UNSIGNED (t) = 1;
+
+ return t;
+}
+
+/* Allocate a TYPE_CODE_FLT type structure associated with OBJFILE.
+ 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 *
+init_float_type (struct objfile *objfile,
+ int bit, const char *name,
+ const struct floatformat **floatformats)
+{
+ struct type *t;
+
+ bit = verify_floatformat (bit, floatformats);
+ t = init_type (objfile, TYPE_CODE_FLT, bit / TARGET_CHAR_BIT, name);
+ TYPE_FLOATFORMAT (t) = floatformats;
+
+ return t;
+}
+
+/* Allocate a TYPE_CODE_DECFLOAT type structure associated with OBJFILE.
+ BIT is the type size in bits. NAME is the type name. */
+
+struct type *
+init_decfloat_type (struct objfile *objfile, int bit, const char *name)
+{
+ struct type *t;
+
+ t = init_type (objfile, TYPE_CODE_DECFLOAT, bit / TARGET_CHAR_BIT, name);
+ return t;
+}
+
+/* Allocate a TYPE_CODE_COMPLEX type structure associated with OBJFILE.
+ NAME is the type name. TARGET_TYPE is the component float type. */
+
+struct type *
+init_complex_type (struct objfile *objfile,
+ const char *name, struct type *target_type)
+{
+ struct type *t;
+
+ t = init_type (objfile, TYPE_CODE_COMPLEX,
+ 2 * TYPE_LENGTH (target_type), name);
+ TYPE_TARGET_TYPE (t) = target_type;
+ return t;
+}
+
+/* Allocate a TYPE_CODE_PTR type structure associated with OBJFILE.
+ BIT is the pointer type size in bits. NAME is the type name.
+ TARGET_TYPE is the pointer target type. Always sets the pointer type's
+ TYPE_UNSIGNED flag. */
+
+struct type *
+init_pointer_type (struct objfile *objfile,
+ int bit, const char *name, struct type *target_type)
+{
+ struct type *t;
+
+ t = init_type (objfile, TYPE_CODE_PTR, bit / TARGET_CHAR_BIT, name);
+ TYPE_TARGET_TYPE (t) = target_type;
+ TYPE_UNSIGNED (t) = 1;
+ return t;
+}
+
\f
/* Queries on types. */
{
struct rank rank = {0,0};
- if (types_equal (parm, arg))
- return EXACT_MATCH_BADNESS;
-
/* Resolve typedefs */
if (TYPE_CODE (parm) == TYPE_CODE_TYPEDEF)
parm = check_typedef (parm);
if (TYPE_CODE (arg) == TYPE_CODE_TYPEDEF)
arg = check_typedef (arg);
+ if (value != NULL)
+ {
+ /* An rvalue argument cannot be bound to a non-const lvalue
+ reference parameter... */
+ if (VALUE_LVAL (value) == not_lval
+ && TYPE_CODE (parm) == TYPE_CODE_REF
+ && !TYPE_CONST (parm->main_type->target_type))
+ return INCOMPATIBLE_TYPE_BADNESS;
+
+ /* ... and an lvalue argument cannot be bound to an rvalue
+ reference parameter. [C++ 13.3.3.1.4p3] */
+ if (VALUE_LVAL (value) != not_lval
+ && TYPE_CODE (parm) == TYPE_CODE_RVALUE_REF)
+ return INCOMPATIBLE_TYPE_BADNESS;
+ }
+
+ if (types_equal (parm, arg))
+ return EXACT_MATCH_BADNESS;
+
+ /* An lvalue reference to a function should get higher priority than an
+ rvalue reference to a function. */
+
+ if (value != NULL && TYPE_CODE (arg) == TYPE_CODE_RVALUE_REF
+ && TYPE_CODE (TYPE_TARGET_TYPE (arg)) == TYPE_CODE_FUNC)
+ {
+ return (sum_ranks (rank_one_type (parm,
+ lookup_pointer_type (TYPE_TARGET_TYPE (arg)), NULL),
+ DIFFERENT_REFERENCE_TYPE_BADNESS));
+ }
+
+ /* If a conversion to one type of reference is an identity conversion, and a
+ conversion to the second type of reference is a non-identity conversion,
+ choose the first type. */
+
+ if (value != NULL && TYPE_IS_REFERENCE (parm) && TYPE_IS_REFERENCE (arg)
+ && TYPE_CODE (parm) != TYPE_CODE (arg))
+ {
+ return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm),
+ TYPE_TARGET_TYPE (arg), NULL), DIFFERENT_REFERENCE_TYPE_BADNESS));
+ }
+
+ /* An rvalue should be first tried to bind to an rvalue reference, and then to
+ an lvalue reference. */
+
+ if (value != NULL && TYPE_CODE (parm) == TYPE_CODE_REF
+ && VALUE_LVAL (value) == not_lval)
+ {
+ if (TYPE_IS_REFERENCE (arg))
+ arg = TYPE_TARGET_TYPE (arg);
+ return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL),
+ LVALUE_REFERENCE_TO_RVALUE_BINDING_BADNESS));
+ }
+
/* See through references, since we can almost make non-references
references. */
- if (TYPE_CODE (arg) == TYPE_CODE_REF)
+
+ if (TYPE_IS_REFERENCE (arg))
return (sum_ranks (rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL),
REFERENCE_CONVERSION_BADNESS));
- if (TYPE_CODE (parm) == TYPE_CODE_REF)
+ if (TYPE_IS_REFERENCE (parm))
return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL),
REFERENCE_CONVERSION_BADNESS));
if (overload_debug)
TYPE_INSTANCE_FLAGS (type));
if (TYPE_CONST (type))
{
- puts_filtered (" TYPE_FLAG_CONST");
+ puts_filtered (" TYPE_CONST");
}
if (TYPE_VOLATILE (type))
{
- puts_filtered (" TYPE_FLAG_VOLATILE");
+ puts_filtered (" TYPE_VOLATILE");
}
if (TYPE_CODE_SPACE (type))
{
- puts_filtered (" TYPE_FLAG_CODE_SPACE");
+ puts_filtered (" TYPE_CODE_SPACE");
}
if (TYPE_DATA_SPACE (type))
{
- puts_filtered (" TYPE_FLAG_DATA_SPACE");
+ puts_filtered (" TYPE_DATA_SPACE");
}
if (TYPE_ADDRESS_CLASS_1 (type))
{
- puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_1");
+ puts_filtered (" TYPE_ADDRESS_CLASS_1");
}
if (TYPE_ADDRESS_CLASS_2 (type))
{
- puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
+ puts_filtered (" TYPE_ADDRESS_CLASS_2");
}
if (TYPE_RESTRICT (type))
{
- puts_filtered (" TYPE_FLAG_RESTRICT");
+ puts_filtered (" TYPE_RESTRICT");
}
if (TYPE_ATOMIC (type))
{
- puts_filtered (" TYPE_FLAG_ATOMIC");
+ puts_filtered (" TYPE_ATOMIC");
}
puts_filtered ("\n");
printfi_filtered (spaces, "flags");
if (TYPE_UNSIGNED (type))
{
- puts_filtered (" TYPE_FLAG_UNSIGNED");
+ puts_filtered (" TYPE_UNSIGNED");
}
if (TYPE_NOSIGN (type))
{
- puts_filtered (" TYPE_FLAG_NOSIGN");
+ puts_filtered (" TYPE_NOSIGN");
}
if (TYPE_STUB (type))
{
- puts_filtered (" TYPE_FLAG_STUB");
+ puts_filtered (" TYPE_STUB");
}
if (TYPE_TARGET_STUB (type))
{
- puts_filtered (" TYPE_FLAG_TARGET_STUB");
+ puts_filtered (" TYPE_TARGET_STUB");
}
if (TYPE_STATIC (type))
{
- puts_filtered (" TYPE_FLAG_STATIC");
+ puts_filtered (" TYPE_STATIC");
}
if (TYPE_PROTOTYPED (type))
{
- puts_filtered (" TYPE_FLAG_PROTOTYPED");
+ puts_filtered (" TYPE_PROTOTYPED");
}
if (TYPE_INCOMPLETE (type))
{
- puts_filtered (" TYPE_FLAG_INCOMPLETE");
+ puts_filtered (" TYPE_INCOMPLETE");
}
if (TYPE_VARARGS (type))
{
- puts_filtered (" TYPE_FLAG_VARARGS");
+ puts_filtered (" TYPE_VARARGS");
}
/* This is used for things like AltiVec registers on ppc. Gcc emits
an attribute for the array type, which tells whether or not we
have a vector, instead of a regular array. */
if (TYPE_VECTOR (type))
{
- puts_filtered (" TYPE_FLAG_VECTOR");
+ puts_filtered (" TYPE_VECTOR");
}
if (TYPE_FIXED_INSTANCE (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),
+ "[%d] bitpos %s bitsize %d type ",
+ idx, plongest (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' (",
struct type *
arch_type (struct gdbarch *gdbarch,
- enum type_code code, int length, char *name)
+ enum type_code code, int length, const char *name)
{
struct type *type;
type = alloc_type_arch (gdbarch);
- TYPE_CODE (type) = code;
+ set_type_code (type, code);
TYPE_LENGTH (type) = length;
if (name)
struct type *
arch_integer_type (struct gdbarch *gdbarch,
- int bit, int unsigned_p, char *name)
+ int bit, int unsigned_p, const char *name)
{
struct type *t;
t = arch_type (gdbarch, TYPE_CODE_INT, bit / TARGET_CHAR_BIT, name);
if (unsigned_p)
TYPE_UNSIGNED (t) = 1;
- if (name && strcmp (name, "char") == 0)
- TYPE_NOSIGN (t) = 1;
return t;
}
struct type *
arch_character_type (struct gdbarch *gdbarch,
- int bit, int unsigned_p, char *name)
+ int bit, int unsigned_p, const char *name)
{
struct type *t;
struct type *
arch_boolean_type (struct gdbarch *gdbarch,
- int bit, int unsigned_p, char *name)
+ int bit, int unsigned_p, const char *name)
{
struct type *t;
struct type *
arch_float_type (struct gdbarch *gdbarch,
- int bit, char *name, const struct floatformat **floatformats)
+ int bit, const char *name,
+ const struct floatformat **floatformats)
{
struct type *t;
- if (bit == -1)
- {
- gdb_assert (floatformats != NULL);
- gdb_assert (floatformats[0] != NULL && floatformats[1] != NULL);
- bit = floatformats[0]->totalsize;
- }
- gdb_assert (bit >= 0);
-
+ bit = verify_floatformat (bit, floatformats);
t = arch_type (gdbarch, TYPE_CODE_FLT, bit / TARGET_CHAR_BIT, name);
TYPE_FLOATFORMAT (t) = floatformats;
+
+ return t;
+}
+
+/* Allocate a TYPE_CODE_DECFLOAT type structure associated with GDBARCH.
+ BIT is the type size in bits. NAME is the type name. */
+
+struct type *
+arch_decfloat_type (struct gdbarch *gdbarch, int bit, const char *name)
+{
+ struct type *t;
+
+ t = arch_type (gdbarch, TYPE_CODE_DECFLOAT, bit / TARGET_CHAR_BIT, name);
return t;
}
struct type *
arch_complex_type (struct gdbarch *gdbarch,
- char *name, struct type *target_type)
+ const char *name, struct type *target_type)
{
struct type *t;
return t;
}
+/* Allocate a TYPE_CODE_PTR type structure associated with GDBARCH.
+ BIT is the pointer type size in bits. NAME is the type name.
+ TARGET_TYPE is the pointer target type. Always sets the pointer type's
+ TYPE_UNSIGNED flag. */
+
+struct type *
+arch_pointer_type (struct gdbarch *gdbarch,
+ int bit, const char *name, struct type *target_type)
+{
+ struct type *t;
+
+ t = arch_type (gdbarch, TYPE_CODE_PTR, bit / TARGET_CHAR_BIT, name);
+ TYPE_TARGET_TYPE (t) = target_type;
+ TYPE_UNSIGNED (t) = 1;
+ return t;
+}
+
/* 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)
+arch_flags_type (struct gdbarch *gdbarch, const char *name, int length)
{
- int nfields = length * TARGET_CHAR_BIT;
+ int max_nfields = length * TARGET_CHAR_BIT;
struct type *type;
type = arch_type (gdbarch, TYPE_CODE_FLAGS, length, name);
TYPE_UNSIGNED (type) = 1;
- TYPE_NFIELDS (type) = nfields;
+ TYPE_NFIELDS (type) = 0;
+ /* Pre-allocate enough space assuming every field is one bit. */
TYPE_FIELDS (type)
- = (struct field *) TYPE_ZALLOC (type, nfields * sizeof (struct field));
+ = (struct field *) TYPE_ZALLOC (type, max_nfields * sizeof (struct field));
return type;
}
/* Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
- position BITPOS is called NAME. */
+ position BITPOS is called NAME. Pass NAME as "" for fields that
+ should not be printed. */
void
-append_flags_type_flag (struct type *type, int bitpos, char *name)
+append_flags_type_field (struct type *type, int start_bitpos, int nr_bits,
+ struct type *field_type, const char *name)
{
+ int type_bitsize = TYPE_LENGTH (type) * TARGET_CHAR_BIT;
+ int field_nr = TYPE_NFIELDS (type);
+
gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLAGS);
- gdb_assert (bitpos < TYPE_NFIELDS (type));
- gdb_assert (bitpos >= 0);
+ gdb_assert (TYPE_NFIELDS (type) + 1 <= type_bitsize);
+ gdb_assert (start_bitpos >= 0 && start_bitpos < type_bitsize);
+ gdb_assert (nr_bits >= 1 && nr_bits <= type_bitsize);
+ gdb_assert (name != NULL);
- if (name)
- {
- TYPE_FIELD_NAME (type, bitpos) = xstrdup (name);
- SET_FIELD_BITPOS (TYPE_FIELD (type, bitpos), bitpos);
- }
- else
- {
- /* Don't show this field to the user. */
- SET_FIELD_BITPOS (TYPE_FIELD (type, bitpos), -1);
- }
+ TYPE_FIELD_NAME (type, field_nr) = xstrdup (name);
+ TYPE_FIELD_TYPE (type, field_nr) = field_type;
+ SET_FIELD_BITPOS (TYPE_FIELD (type, field_nr), start_bitpos);
+ TYPE_FIELD_BITSIZE (type, field_nr) = nr_bits;
+ ++TYPE_NFIELDS (type);
+}
+
+/* Special version of append_flags_type_field to add a flag field.
+ 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, const char *name)
+{
+ struct gdbarch *gdbarch = get_type_arch (type);
+
+ append_flags_type_field (type, bitpos, 1,
+ builtin_type (gdbarch)->builtin_bool,
+ name);
}
/* 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)
+arch_composite_type (struct gdbarch *gdbarch, const char *name,
+ enum type_code code)
{
struct type *t;
the caller should do so. Return the new field. */
struct field *
-append_composite_type_field_raw (struct type *t, char *name,
+append_composite_type_field_raw (struct type *t, const char *name,
struct type *field)
{
struct field *f;
ALIGNMENT (if non-zero) specifies the minimum field alignment. */
void
-append_composite_type_field_aligned (struct type *t, char *name,
+append_composite_type_field_aligned (struct type *t, const char *name,
struct type *field, int alignment)
{
struct field *f = append_composite_type_field_raw (t, name, field);
/* Add new field with name NAME and type FIELD to composite type T. */
void
-append_composite_type_field (struct type *t, char *name,
+append_composite_type_field (struct type *t, const char *name,
struct type *field)
{
append_composite_type_field_aligned (t, name, field, 0);
builtin_type->builtin_char
= arch_integer_type (gdbarch, TARGET_CHAR_BIT,
!gdbarch_char_signed (gdbarch), "char");
+ TYPE_NOSIGN (builtin_type->builtin_char) = 1;
builtin_type->builtin_signed_char
= arch_integer_type (gdbarch, TARGET_CHAR_BIT,
0, "signed char");
/* The following three are about decimal floating point types, which
are 32-bits, 64-bits and 128-bits respectively. */
builtin_type->builtin_decfloat
- = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 32 / 8, "_Decimal32");
+ = arch_decfloat_type (gdbarch, 32, "_Decimal32");
builtin_type->builtin_decdouble
- = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 64 / 8, "_Decimal64");
+ = arch_decfloat_type (gdbarch, 64, "_Decimal64");
builtin_type->builtin_declong
- = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 128 / 8, "_Decimal128");
+ = arch_decfloat_type (gdbarch, 128, "_Decimal128");
/* "True" character types. */
builtin_type->builtin_true_char
/* Wide character types. */
builtin_type->builtin_char16
- = arch_integer_type (gdbarch, 16, 0, "char16_t");
+ = arch_integer_type (gdbarch, 16, 1, "char16_t");
builtin_type->builtin_char32
- = arch_integer_type (gdbarch, 32, 0, "char32_t");
-
+ = arch_integer_type (gdbarch, 32, 1, "char32_t");
+ builtin_type->builtin_wchar
+ = arch_integer_type (gdbarch, gdbarch_wchar_bit (gdbarch),
+ !gdbarch_wchar_signed (gdbarch), "wchar_t");
/* Default data/code pointer types. */
builtin_type->builtin_data_ptr
/* Basic types. */
objfile_type->builtin_void
- = init_type (TYPE_CODE_VOID, 1,
- 0,
- "void", objfile);
-
+ = init_type (objfile, TYPE_CODE_VOID, 1, "void");
objfile_type->builtin_char
- = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
- (TYPE_FLAG_NOSIGN
- | (gdbarch_char_signed (gdbarch) ? 0 : TYPE_FLAG_UNSIGNED)),
- "char", objfile);
+ = init_integer_type (objfile, TARGET_CHAR_BIT,
+ !gdbarch_char_signed (gdbarch), "char");
+ TYPE_NOSIGN (objfile_type->builtin_char) = 1;
objfile_type->builtin_signed_char
- = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
- 0,
- "signed char", objfile);
+ = init_integer_type (objfile, TARGET_CHAR_BIT,
+ 0, "signed char");
objfile_type->builtin_unsigned_char
- = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
- TYPE_FLAG_UNSIGNED,
- "unsigned char", objfile);
+ = init_integer_type (objfile, TARGET_CHAR_BIT,
+ 1, "unsigned char");
objfile_type->builtin_short
- = init_type (TYPE_CODE_INT,
- gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT,
- 0, "short", objfile);
+ = init_integer_type (objfile, gdbarch_short_bit (gdbarch),
+ 0, "short");
objfile_type->builtin_unsigned_short
- = init_type (TYPE_CODE_INT,
- gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT,
- TYPE_FLAG_UNSIGNED, "unsigned short", objfile);
+ = init_integer_type (objfile, gdbarch_short_bit (gdbarch),
+ 1, "unsigned short");
objfile_type->builtin_int
- = init_type (TYPE_CODE_INT,
- gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT,
- 0, "int", objfile);
+ = init_integer_type (objfile, gdbarch_int_bit (gdbarch),
+ 0, "int");
objfile_type->builtin_unsigned_int
- = init_type (TYPE_CODE_INT,
- gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT,
- TYPE_FLAG_UNSIGNED, "unsigned int", objfile);
+ = init_integer_type (objfile, gdbarch_int_bit (gdbarch),
+ 1, "unsigned int");
objfile_type->builtin_long
- = init_type (TYPE_CODE_INT,
- gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT,
- 0, "long", objfile);
+ = init_integer_type (objfile, gdbarch_long_bit (gdbarch),
+ 0, "long");
objfile_type->builtin_unsigned_long
- = init_type (TYPE_CODE_INT,
- gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT,
- TYPE_FLAG_UNSIGNED, "unsigned long", objfile);
+ = init_integer_type (objfile, gdbarch_long_bit (gdbarch),
+ 1, "unsigned long");
objfile_type->builtin_long_long
- = init_type (TYPE_CODE_INT,
- gdbarch_long_long_bit (gdbarch) / TARGET_CHAR_BIT,
- 0, "long long", objfile);
+ = init_integer_type (objfile, gdbarch_long_long_bit (gdbarch),
+ 0, "long long");
objfile_type->builtin_unsigned_long_long
- = init_type (TYPE_CODE_INT,
- gdbarch_long_long_bit (gdbarch) / TARGET_CHAR_BIT,
- TYPE_FLAG_UNSIGNED, "unsigned long long", objfile);
-
+ = init_integer_type (objfile, gdbarch_long_long_bit (gdbarch),
+ 1, "unsigned long long");
objfile_type->builtin_float
- = init_type (TYPE_CODE_FLT,
- gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT,
- 0, "float", objfile);
- TYPE_FLOATFORMAT (objfile_type->builtin_float)
- = gdbarch_float_format (gdbarch);
+ = init_float_type (objfile, gdbarch_float_bit (gdbarch),
+ "float", gdbarch_float_format (gdbarch));
objfile_type->builtin_double
- = init_type (TYPE_CODE_FLT,
- gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT,
- 0, "double", objfile);
- TYPE_FLOATFORMAT (objfile_type->builtin_double)
- = gdbarch_double_format (gdbarch);
+ = init_float_type (objfile, gdbarch_double_bit (gdbarch),
+ "double", gdbarch_double_format (gdbarch));
objfile_type->builtin_long_double
- = init_type (TYPE_CODE_FLT,
- gdbarch_long_double_bit (gdbarch) / TARGET_CHAR_BIT,
- 0, "long double", objfile);
- TYPE_FLOATFORMAT (objfile_type->builtin_long_double)
- = gdbarch_long_double_format (gdbarch);
+ = init_float_type (objfile, gdbarch_long_double_bit (gdbarch),
+ "long double", gdbarch_long_double_format (gdbarch));
/* This type represents a type that was unrecognized in symbol read-in. */
objfile_type->builtin_error
- = init_type (TYPE_CODE_ERROR, 0, 0, "<unknown type>", objfile);
+ = init_type (objfile, TYPE_CODE_ERROR, 0, "<unknown type>");
/* The following set of types is used for symbols with no
debug information. */
objfile_type->nodebug_text_symbol
- = init_type (TYPE_CODE_FUNC, 1, 0,
- "<text variable, no debug info>", objfile);
+ = init_type (objfile, TYPE_CODE_FUNC, 1,
+ "<text variable, no debug info>");
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);
+ = init_type (objfile, TYPE_CODE_FUNC, 1,
+ "<text gnu-indirect-function variable, no debug info>");
TYPE_TARGET_TYPE (objfile_type->nodebug_text_gnu_ifunc_symbol)
= objfile_type->nodebug_text_symbol;
+ TYPE_GNU_IFUNC (objfile_type->nodebug_text_gnu_ifunc_symbol) = 1;
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;
+ = init_pointer_type (objfile, gdbarch_addr_bit (gdbarch),
+ "<text from jump slot in .got.plt, no debug info>",
+ objfile_type->nodebug_text_symbol);
objfile_type->nodebug_data_symbol
- = init_type (TYPE_CODE_INT,
- gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0,
- "<data variable, no debug info>", objfile);
+ = init_integer_type (objfile, gdbarch_int_bit (gdbarch), 0,
+ "<data variable, no debug info>");
objfile_type->nodebug_unknown_symbol
- = init_type (TYPE_CODE_INT, 1, 0,
- "<variable (not text or data), no debug info>", objfile);
+ = init_integer_type (objfile, TARGET_CHAR_BIT, 0,
+ "<variable (not text or data), no debug info>");
objfile_type->nodebug_tls_symbol
- = init_type (TYPE_CODE_INT,
- gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0,
- "<thread local variable, no debug info>", objfile);
+ = init_integer_type (objfile, gdbarch_int_bit (gdbarch), 0,
+ "<thread local variable, no debug info>");
/* NOTE: on some targets, addresses and pointers are not necessarily
the same.
are indeed in the unified virtual address space. */
objfile_type->builtin_core_addr
- = init_type (TYPE_CODE_INT,
- gdbarch_addr_bit (gdbarch) / 8,
- TYPE_FLAG_UNSIGNED, "__CORE_ADDR", objfile);
+ = init_integer_type (objfile, gdbarch_addr_bit (gdbarch), 1,
+ "__CORE_ADDR");
set_objfile_data (objfile, objfile_type_data, objfile_type);
return objfile_type;
projects / deliverable / binutils-gdb.git / blobdiff