X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fgdbtypes.c;h=defc00d34e54110f3709d6177b2c11dacbb0dd8b;hb=aa0061181ab00081e9907447561e589d6edee9f2;hp=919cac9f9abfa05864a08175af2096f98d58b18e;hpb=220475ed8b0c1ef7b4eabf64bcc723e14fd78209;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c index 919cac9f9a..defc00d34e 100644 --- a/gdb/gdbtypes.c +++ b/gdb/gdbtypes.c @@ -1,6 +1,6 @@ /* 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. @@ -384,15 +384,21 @@ lookup_pointer_type (struct type *type) /* 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) { @@ -421,7 +427,10 @@ make_reference_type (struct type *type, struct type **typeptr) } 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 @@ -429,10 +438,9 @@ make_reference_type (struct type *type, struct type **typeptr) 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); @@ -449,9 +457,25 @@ make_reference_type (struct type *type, struct type **typeptr) 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 @@ -756,7 +780,7 @@ replace_type (struct type *ntype, struct type *type) 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); @@ -1080,7 +1104,9 @@ create_array_type_with_stride (struct type *result_type, TYPE_CODE (result_type) = TYPE_CODE_ARRAY; TYPE_TARGET_TYPE (result_type) = element_type; - if (has_static_range (TYPE_RANGE_DATA (range_type))) + if (has_static_range (TYPE_RANGE_DATA (range_type)) + && (!type_not_associated (result_type) + && !type_not_allocated (result_type))) { LONGEST low_bound, high_bound; @@ -1117,7 +1143,7 @@ create_array_type_with_stride (struct type *result_type, 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; @@ -1419,7 +1445,6 @@ lookup_typename (const struct language_defn *language, 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; @@ -1571,7 +1596,6 @@ struct type * lookup_struct_elt_type (struct type *type, const char *name, int noerr) { int i; - char *type_name; for (;;) { @@ -1585,9 +1609,9 @@ lookup_struct_elt_type (struct type *type, const char *name, int noerr) 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 @@ -1639,9 +1663,8 @@ lookup_struct_elt_type (struct type *type, const char *name, int noerr) 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 @@ -1819,6 +1842,12 @@ is_dynamic_type_internal (struct type *type, int top_level) || TYPE_DATA_LOCATION_KIND (type) == PROP_LOCLIST)) return 1; + if (TYPE_ASSOCIATED_PROP (type)) + return 1; + + if (TYPE_ALLOCATED_PROP (type)) + return 1; + switch (TYPE_CODE (type)) { case TYPE_CODE_RANGE: @@ -1881,7 +1910,6 @@ resolve_dynamic_range (struct type *dyn_range_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); @@ -1936,13 +1964,31 @@ resolve_dynamic_array (struct type *type, struct type *elt_type; struct type *range_type; struct type *ary_dim; + struct dynamic_prop *prop; gdb_assert (TYPE_CODE (type) == TYPE_CODE_ARRAY); + type = copy_type (type); + elt_type = type; range_type = check_typedef (TYPE_INDEX_TYPE (elt_type)); range_type = resolve_dynamic_range (range_type, addr_stack); + /* Resolve allocated/associated here before creating a new array type, which + will update the length of the array accordingly. */ + prop = TYPE_ALLOCATED_PROP (type); + if (prop != NULL && dwarf2_evaluate_property (prop, NULL, addr_stack, &value)) + { + TYPE_DYN_PROP_ADDR (prop) = value; + TYPE_DYN_PROP_KIND (prop) = PROP_CONST; + } + prop = TYPE_ASSOCIATED_PROP (type); + if (prop != NULL && dwarf2_evaluate_property (prop, NULL, addr_stack, &value)) + { + TYPE_DYN_PROP_ADDR (prop) = value; + TYPE_DYN_PROP_KIND (prop) = PROP_CONST; + } + ary_dim = check_typedef (TYPE_TARGET_TYPE (elt_type)); if (ary_dim != NULL && TYPE_CODE (ary_dim) == TYPE_CODE_ARRAY) @@ -1950,9 +1996,8 @@ resolve_dynamic_array (struct type *type, else elt_type = TYPE_TARGET_TYPE (type); - return create_array_type_with_stride (copy_type (type), - elt_type, range_type, - TYPE_FIELD_BITSIZE (type, 0)); + return create_array_type_with_stride (type, elt_type, range_type, + TYPE_FIELD_BITSIZE (type, 0)); } /* Resolve dynamic bounds of members of the union TYPE to static @@ -2039,7 +2084,9 @@ resolve_dynamic_struct (struct type *type, 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) @@ -2065,8 +2112,13 @@ resolve_dynamic_struct (struct type *type, 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. */ @@ -2199,6 +2251,37 @@ add_dyn_prop (enum dynamic_prop_node_kind prop_kind, struct dynamic_prop prop, 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 @@ -2368,7 +2451,6 @@ check_typedef (struct type *type) 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)) @@ -2401,7 +2483,7 @@ safe_parse_type (struct gdbarch *gdbarch, char *p, int length) /* 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 @@ -2415,7 +2497,6 @@ safe_parse_type (struct gdbarch *gdbarch, char *p, int length) END_CATCH /* Stop suppressing error messages. */ - ui_file_delete (gdb_stderr); gdb_stderr = saved_gdb_stderr; return type; @@ -2621,54 +2702,13 @@ allocate_gnat_aux_type (struct type *type) *(TYPE_GNAT_SPECIFIC (type)) = gnat_aux_default; } -/* Helper function to initialize the standard scalar types. +/* Helper function to initialize a newly allocated type. Set type code + to CODE and initialize the type-specific fields accordingly. */ - 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, - 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) { @@ -2684,8 +2724,163 @@ init_type (enum type_code code, int length, int flags, 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; +} + /* Queries on types. */ @@ -3375,6 +3570,30 @@ types_deeply_equal (struct type *type1, struct type *type2) return result; } + +/* Allocated status of type TYPE. Return zero if type TYPE is allocated. + Otherwise return one. */ + +int +type_not_allocated (const struct type *type) +{ + struct dynamic_prop *prop = TYPE_ALLOCATED_PROP (type); + + return (prop && TYPE_DYN_PROP_KIND (prop) == PROP_CONST + && !TYPE_DYN_PROP_ADDR (prop)); +} + +/* Associated status of type TYPE. Return zero if type TYPE is associated. + Otherwise return one. */ + +int +type_not_associated (const struct type *type) +{ + struct dynamic_prop *prop = TYPE_ASSOCIATED_PROP (type); + + return (prop && TYPE_DYN_PROP_KIND (prop) == PROP_CONST + && !TYPE_DYN_PROP_ADDR (prop)); +} /* Compare one type (PARM) for compatibility with another (ARG). * PARM is intended to be the parameter type of a function; and @@ -3403,10 +3622,11 @@ rank_one_type (struct type *parm, struct type *arg, struct value *value) /* 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) @@ -4117,77 +4337,77 @@ recursive_dump_type (struct type *type, int spaces) 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)) { @@ -4213,8 +4433,8 @@ recursive_dump_type (struct type *type, int spaces) 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' (", @@ -4545,12 +4765,12 @@ copy_type (const struct type *type) 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) @@ -4565,15 +4785,13 @@ arch_type (struct gdbarch *gdbarch, 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; } @@ -4584,7 +4802,7 @@ arch_integer_type (struct gdbarch *gdbarch, 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; @@ -4601,7 +4819,7 @@ arch_character_type (struct gdbarch *gdbarch, 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; @@ -4619,20 +4837,27 @@ arch_boolean_type (struct gdbarch *gdbarch, 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; } @@ -4641,7 +4866,7 @@ arch_float_type (struct gdbarch *gdbarch, struct type * arch_complex_type (struct gdbarch *gdbarch, - char *name, struct type *target_type) + const char *name, struct type *target_type) { struct type *t; @@ -4651,51 +4876,86 @@ arch_complex_type (struct gdbarch *gdbarch, 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; @@ -4711,7 +4971,7 @@ arch_composite_type (struct gdbarch *gdbarch, char *name, enum type_code code) 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; @@ -4730,7 +4990,7 @@ append_composite_type_field_raw (struct type *t, char *name, 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); @@ -4770,7 +5030,7 @@ append_composite_type_field_aligned (struct type *t, char *name, /* 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); @@ -4796,6 +5056,7 @@ gdbtypes_post_init (struct gdbarch *gdbarch) 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"); @@ -4849,11 +5110,11 @@ gdbtypes_post_init (struct gdbarch *gdbarch) /* 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 @@ -4939,109 +5200,81 @@ objfile_type (struct objfile *objfile) /* 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, "", objfile); + = init_type (objfile, TYPE_CODE_ERROR, 0, ""); /* 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, - "", objfile); + = init_type (objfile, TYPE_CODE_FUNC, 1, + ""); 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, - "", - objfile); + = init_type (objfile, TYPE_CODE_FUNC, 1, + ""); 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, - "", - objfile); - TYPE_TARGET_TYPE (objfile_type->nodebug_got_plt_symbol) - = objfile_type->nodebug_text_symbol; + = init_pointer_type (objfile, gdbarch_addr_bit (gdbarch), + "", + objfile_type->nodebug_text_symbol); objfile_type->nodebug_data_symbol - = init_type (TYPE_CODE_INT, - gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0, - "", objfile); + = init_integer_type (objfile, gdbarch_int_bit (gdbarch), 0, + ""); objfile_type->nodebug_unknown_symbol - = init_type (TYPE_CODE_INT, 1, 0, - "", objfile); + = init_integer_type (objfile, TARGET_CHAR_BIT, 0, + ""); objfile_type->nodebug_tls_symbol - = init_type (TYPE_CODE_INT, - gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0, - "", objfile); + = init_integer_type (objfile, gdbarch_int_bit (gdbarch), 0, + ""); /* NOTE: on some targets, addresses and pointers are not necessarily the same. @@ -5063,9 +5296,8 @@ objfile_type (struct objfile *objfile) 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;