/* Support routines for manipulating internal types for GDB.
- Copyright (C) 1992-2015 Free Software Foundation, Inc.
+ Copyright (C) 1992-2016 Free Software Foundation, Inc.
Contributed by Cygnus Support, using pieces from other GDB modules.
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;
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))
*(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. */
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
/* 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;