X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fgdbtypes.h;h=643c61006befb298011c488e72885b2dc878dd75;hb=9f1b45b0da430a7a7abf9e54acbe6f2ef9d3a763;hp=9d83bb32f5dbb9ab947f6aacb8e8fc51af602bf0;hpb=e9bb382b835d19c078eca9908ec6fe66f7af67fa;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h index 9d83bb32f5..643c61006b 100644 --- a/gdb/gdbtypes.h +++ b/gdb/gdbtypes.h @@ -1,7 +1,6 @@ /* Internal type definitions for GDB. - Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, - 2002, 2003, 2004, 2006, 2007, 2008, 2009 Free Software Foundation, Inc. + Copyright (C) 1992-2014 Free Software Foundation, Inc. Contributed by Cygnus Support, using pieces from other GDB modules. @@ -31,6 +30,21 @@ struct block; struct value_print_options; struct language_defn; +/* These declarations are DWARF-specific as some of the gdbtypes.h data types + are already DWARF-specific. */ + +/* Offset relative to the start of its containing CU (compilation unit). */ +typedef struct +{ + unsigned int cu_off; +} cu_offset; + +/* Offset relative to the start of its .debug_info or .debug_types section. */ +typedef struct +{ + unsigned int sect_off; +} sect_offset; + /* Some macros for char-based bitfields. */ #define B_SET(a,x) ((a)[(x)>>3] |= (1 << ((x)&7))) @@ -44,7 +58,8 @@ struct language_defn; enum type_code { - TYPE_CODE_UNDEF, /* Not used; catches errors */ + TYPE_CODE_BITSTRING = -1, /* Deprecated */ + TYPE_CODE_UNDEF = 0, /* Not used; catches errors */ TYPE_CODE_PTR, /* Pointer type */ /* Array type with lower & upper bounds. @@ -86,7 +101,7 @@ enum type_code TYPE_CODE_VOID, TYPE_CODE_SET, /* Pascal sets */ - TYPE_CODE_RANGE, /* Range (integers within spec'd bounds) */ + TYPE_CODE_RANGE, /* Range (integers within spec'd bounds). */ /* A string type which is like an array of character but prints differently (at least for (the deleted) CHILL). It does not @@ -95,10 +110,6 @@ enum type_code a new type code. */ TYPE_CODE_STRING, - /* String of bits; like TYPE_CODE_SET but prints differently (at - least for (the deleted) CHILL). */ - TYPE_CODE_BITSTRING, - /* Unknown type. The length field is valid if we were able to deduce that much about the type, or 0 if we don't even know that. */ TYPE_CODE_ERROR, @@ -130,13 +141,13 @@ enum type_code TYPE_CODE_COMPLEX, /* Complex float */ TYPE_CODE_TYPEDEF, - TYPE_CODE_TEMPLATE, /* C++ template */ - TYPE_CODE_TEMPLATE_ARG, /* C++ template arg */ TYPE_CODE_NAMESPACE, /* C++ namespace. */ TYPE_CODE_DECFLOAT, /* Decimal floating point. */ + TYPE_CODE_MODULE, /* Fortran module. */ + /* Internal function type. */ TYPE_CODE_INTERNAL_FUNCTION }; @@ -158,18 +169,18 @@ enum type_code enum type_flag_value { - TYPE_FLAG_UNSIGNED = (1 << 6), - TYPE_FLAG_NOSIGN = (1 << 7), - TYPE_FLAG_STUB = (1 << 8), - TYPE_FLAG_TARGET_STUB = (1 << 9), - TYPE_FLAG_STATIC = (1 << 10), - TYPE_FLAG_PROTOTYPED = (1 << 11), - TYPE_FLAG_INCOMPLETE = (1 << 12), - TYPE_FLAG_VARARGS = (1 << 13), - TYPE_FLAG_VECTOR = (1 << 14), - TYPE_FLAG_FIXED_INSTANCE = (1 << 15), - TYPE_FLAG_STUB_SUPPORTED = (1 << 16), - TYPE_FLAG_NOTTEXT = (1 << 17), + TYPE_FLAG_UNSIGNED = (1 << 8), + TYPE_FLAG_NOSIGN = (1 << 9), + TYPE_FLAG_STUB = (1 << 10), + TYPE_FLAG_TARGET_STUB = (1 << 11), + TYPE_FLAG_STATIC = (1 << 12), + TYPE_FLAG_PROTOTYPED = (1 << 13), + TYPE_FLAG_INCOMPLETE = (1 << 14), + TYPE_FLAG_VARARGS = (1 << 15), + TYPE_FLAG_VECTOR = (1 << 16), + TYPE_FLAG_FIXED_INSTANCE = (1 << 17), + TYPE_FLAG_STUB_SUPPORTED = (1 << 18), + TYPE_FLAG_GNU_IFUNC = (1 << 19), /* Used for error-checking. */ TYPE_FLAG_MIN = TYPE_FLAG_UNSIGNED @@ -185,17 +196,19 @@ enum type_instance_flag_value TYPE_INSTANCE_FLAG_CODE_SPACE = (1 << 2), TYPE_INSTANCE_FLAG_DATA_SPACE = (1 << 3), TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1 = (1 << 4), - TYPE_INSTANCE_FLAG_ADDRESS_CLASS_2 = (1 << 5) + TYPE_INSTANCE_FLAG_ADDRESS_CLASS_2 = (1 << 5), + TYPE_INSTANCE_FLAG_NOTTEXT = (1 << 6), + TYPE_INSTANCE_FLAG_RESTRICT = (1 << 7) }; /* Unsigned integer type. If this is not set for a TYPE_CODE_INT, the - type is signed (unless TYPE_FLAG_NOSIGN (below) is set). */ + type is signed (unless TYPE_FLAG_NOSIGN (below) is set). */ #define TYPE_UNSIGNED(t) (TYPE_MAIN_TYPE (t)->flag_unsigned) /* No sign for this type. In C++, "char", "signed char", and "unsigned char" are distinct types; so we need an extra flag to indicate the - absence of a sign! */ + absence of a sign! */ #define TYPE_NOSIGN(t) (TYPE_MAIN_TYPE (t)->flag_nosign) @@ -209,21 +222,21 @@ enum type_instance_flag_value be updated if it gets un-stubbed in check_typedef. Used for arrays and ranges, in which TYPE_LENGTH of the array/range gets set based on the TYPE_LENGTH of the target type. - Also, set for TYPE_CODE_TYPEDEF. */ + Also, set for TYPE_CODE_TYPEDEF. */ #define TYPE_TARGET_STUB(t) (TYPE_MAIN_TYPE (t)->flag_target_stub) /* Static type. If this is set, the corresponding type had - * a static modifier. - * Note: This may be unnecessary, since static data members - * are indicated by other means (bitpos == -1) - */ + a static modifier. + Note: This may be unnecessary, since static data members + are indicated by other means (bitpos == -1). */ #define TYPE_STATIC(t) (TYPE_MAIN_TYPE (t)->flag_static) -/* This is a function type which appears to have a prototype. We need this - for function calls in order to tell us if it's necessary to coerce the args, - or to just do the standard conversions. This is used with a short field. */ +/* This is a function type which appears to have a prototype. We need + this for function calls in order to tell us if it's necessary to + coerce the args, or to just do the standard conversions. This is + used with a short field. */ #define TYPE_PROTOTYPED(t) (TYPE_MAIN_TYPE (t)->flag_prototyped) @@ -233,7 +246,7 @@ enum type_instance_flag_value (Mostly intended for HP platforms, where class methods, for instance, can be encountered before their classes in the debug info; the incomplete type has to be marked so that the class and - the method can be assigned correct types.) */ + the method can be assigned correct types.) */ #define TYPE_INCOMPLETE(t) (TYPE_MAIN_TYPE (t)->flag_incomplete) @@ -254,7 +267,7 @@ enum type_instance_flag_value connected by naming conventions. This flag indicates that the type is an ordinary (unencoded) GDB type that has been created from the necessary run-time information, and does not need further - interpretation. Optionally marks ordinary, fixed-size GDB type. */ + interpretation. Optionally marks ordinary, fixed-size GDB type. */ #define TYPE_FIXED_INSTANCE(t) (TYPE_MAIN_TYPE (t)->flag_fixed_instance) @@ -268,7 +281,13 @@ enum type_instance_flag_value /* Not textual. By default, GDB treats all single byte integers as characters (or elements of strings) unless this flag is set. */ -#define TYPE_NOTTEXT(t) (TYPE_MAIN_TYPE (t)->flag_nottext) +#define TYPE_NOTTEXT(t) (TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_NOTTEXT) + +/* Used only for TYPE_CODE_FUNC where it specifies the real function + address is returned by this function call. TYPE_TARGET_TYPE determines the + final returned function type to be presented to user. */ + +#define TYPE_GNU_IFUNC(t) (TYPE_MAIN_TYPE (t)->flag_gnu_ifunc) /* Type owner. If TYPE_OBJFILE_OWNED is true, the type is owned by the objfile retrieved as TYPE_OBJFILE. Otherweise, the type is @@ -278,17 +297,34 @@ enum type_instance_flag_value #define TYPE_OWNER(t) TYPE_MAIN_TYPE(t)->owner #define TYPE_OBJFILE(t) (TYPE_OBJFILE_OWNED(t)? TYPE_OWNER(t).objfile : NULL) +/* True if this type was declared using the "class" keyword. This is + only valid for C++ structure types, and only used for displaying + the type. If false, the structure was declared as a "struct". */ + +#define TYPE_DECLARED_CLASS(t) (TYPE_MAIN_TYPE (t)->flag_declared_class) + +/* True if this type is a "flag" enum. A flag enum is one where all + the values are pairwise disjoint when "and"ed together. This + affects how enum values are printed. */ + +#define TYPE_FLAG_ENUM(t) (TYPE_MAIN_TYPE (t)->flag_flag_enum) + /* Constant type. If this is set, the corresponding type has a - * const modifier. - */ + const modifier. */ #define TYPE_CONST(t) (TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_CONST) /* Volatile type. If this is set, the corresponding type has a - * volatile modifier. - */ + volatile modifier. */ -#define TYPE_VOLATILE(t) (TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_VOLATILE) +#define TYPE_VOLATILE(t) \ + (TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_VOLATILE) + +/* Restrict type. If this is set, the corresponding type has a + restrict modifier. */ + +#define TYPE_RESTRICT(t) \ + (TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_RESTRICT) /* Instruction-space delimited type. This is for Harvard architectures which have separate instruction and data address spaces (and perhaps @@ -334,17 +370,38 @@ enum type_instance_flag_value enum field_loc_kind { FIELD_LOC_KIND_BITPOS, /* bitpos */ + FIELD_LOC_KIND_ENUMVAL, /* enumval */ FIELD_LOC_KIND_PHYSADDR, /* physaddr */ FIELD_LOC_KIND_PHYSNAME, /* physname */ FIELD_LOC_KIND_DWARF_BLOCK /* dwarf_block */ }; +/* A discriminant to determine which field in the main_type.type_specific + union is being used, if any. + + For types such as TYPE_CODE_FLT or TYPE_CODE_FUNC, the use of this + discriminant is really redundant, as we know from the type code + which field is going to be used. As such, it would be possible to + reduce the size of this enum in order to save a bit or two for + other fields of struct main_type. But, since we still have extra + room , and for the sake of clarity and consistency, we treat all fields + of the union the same way. */ + +enum type_specific_kind +{ + TYPE_SPECIFIC_NONE, + TYPE_SPECIFIC_CPLUS_STUFF, + TYPE_SPECIFIC_GNAT_STUFF, + TYPE_SPECIFIC_FLOATFORMAT, + TYPE_SPECIFIC_FUNC +}; + /* This structure is space-critical. Its layout has been tweaked to reduce the space used. */ struct main_type { - /* Code for kind of type */ + /* Code for kind of type. */ ENUM_BITFIELD(type_code) code : 8; @@ -362,9 +419,21 @@ struct main_type unsigned int flag_varargs : 1; unsigned int flag_vector : 1; unsigned int flag_stub_supported : 1; - unsigned int flag_nottext : 1; + unsigned int flag_gnu_ifunc : 1; unsigned int flag_fixed_instance : 1; unsigned int flag_objfile_owned : 1; + /* True if this type was declared with "class" rather than + "struct". */ + unsigned int flag_declared_class : 1; + + /* True if this is an enum type with disjoint values. This affects + how the enum is printed. */ + + unsigned int flag_flag_enum : 1; + + /* A discriminant telling us which field of the type_specific union + is being used for this type, if any. */ + ENUM_BITFIELD(type_specific_kind) type_specific_field : 3; /* Number of fields described for this type. This field appears at this location because it packs nicely here. */ @@ -387,9 +456,11 @@ struct main_type /* Name of this type, or NULL if none. This is used for printing only, except by poorly designed C++ code. - For looking up a name, look for a symbol in the VAR_DOMAIN. */ + For looking up a name, look for a symbol in the VAR_DOMAIN. + This is generally allocated in the objfile's obstack. + However coffread.c uses malloc. */ - char *name; + const char *name; /* Tag name for this type, or NULL if none. This means that the name of the type consists of a keyword followed by the tag name. @@ -402,7 +473,7 @@ struct main_type One more legitimate use is that if TYPE_FLAG_STUB is set, this is the name to use to look for definitions in other files. */ - char *tag_name; + const char *tag_name; /* Every type is now associated with a particular objfile, and the type is allocated on the objfile_obstack for that objfile. One problem @@ -414,7 +485,7 @@ struct main_type existing type, but to do this we need a backpointer to the objfile from the existing type. Yes this is somewhat ugly, but without major overhaul of the internal type system, it can't be avoided - for now. */ + for now. */ union type_owner { @@ -427,6 +498,9 @@ struct main_type For a function or method type, describes the type of the return value. For a range type, describes the type of the full range. For a complex type, describes the type of each coordinate. + For a special record or union type encoding a dynamic-sized type + in GNAT, a memoized pointer to a corresponding static version of + the type. Unused otherwise. */ struct type *target_type; @@ -447,61 +521,90 @@ struct main_type because we can allocate the space for a type before we know what to put in it. */ - struct field + union { - union field_location + struct field { - /* Position of this field, counting in bits from start of - containing structure. - For gdbarch_bits_big_endian=1 targets, it is the bit offset to the MSB. - For gdbarch_bits_big_endian=0 targets, it is the bit offset to the LSB. - For a range bound or enum value, this is the value itself. */ + union field_location + { + /* Position of this field, counting in bits from start of + containing structure. For gdbarch_bits_big_endian=1 + targets, it is the bit offset to the MSB. For + gdbarch_bits_big_endian=0 targets, it is the bit offset to + the LSB. */ + + int bitpos; - int bitpos; + /* Enum value. */ + LONGEST enumval; - /* For a static field, if TYPE_FIELD_STATIC_HAS_ADDR then physaddr - is the location (in the target) of the static field. - Otherwise, physname is the mangled label of the static field. */ + /* For a static field, if TYPE_FIELD_STATIC_HAS_ADDR then physaddr + is the location (in the target) of the static field. + Otherwise, physname is the mangled label of the static field. */ - CORE_ADDR physaddr; - char *physname; + CORE_ADDR physaddr; + const char *physname; - /* The field location can be computed by evaluating the following DWARF - block. This can be used in Fortran variable-length arrays, for - instance. */ + /* The field location can be computed by evaluating the following DWARF + block. Its DATA is allocated on objfile_obstack - no CU load is + needed to access it. */ - struct dwarf2_locexpr_baton *dwarf_block; - } - loc; + struct dwarf2_locexpr_baton *dwarf_block; + } + loc; - /* For a function or member type, this is 1 if the argument is marked - artificial. Artificial arguments should not be shown to the - user. For TYPE_CODE_RANGE it is set if the specific bound is not - defined. */ - unsigned int artificial : 1; + /* For a function or member type, this is 1 if the argument is marked + artificial. Artificial arguments should not be shown to the + user. For TYPE_CODE_RANGE it is set if the specific bound is not + defined. */ + unsigned int artificial : 1; - /* Discriminant for union field_location. */ - ENUM_BITFIELD(field_loc_kind) loc_kind : 2; + /* Discriminant for union field_location. */ + ENUM_BITFIELD(field_loc_kind) loc_kind : 3; - /* Size of this field, in bits, or zero if not packed. - For an unpacked field, the field's type's length - says how many bytes the field occupies. */ + /* Size of this field, in bits, or zero if not packed. + If non-zero in an array type, indicates the element size in + bits (used only in Ada at the moment). + For an unpacked field, the field's type's length + says how many bytes the field occupies. */ - unsigned int bitsize : 29; + unsigned int bitsize : 28; - /* In a struct or union type, type of this field. - In a function or member type, type of this argument. - In an array type, the domain-type of the array. */ + /* In a struct or union type, type of this field. + In a function or member type, type of this argument. + In an array type, the domain-type of the array. */ - struct type *type; + struct type *type; - /* Name of field, value or argument. - NULL for range bounds, array domains, and member function - arguments. */ + /* Name of field, value or argument. + NULL for range bounds, array domains, and member function + arguments. */ - char *name; + const char *name; + } *fields; - } *fields; + /* Union member used for range types. */ + + struct range_bounds + { + /* Low bound of range. */ + + LONGEST low; + + /* High bound of range. */ + + LONGEST high; + + /* Flags indicating whether the values of low and high are + valid. When true, the respective range value is + undefined. Currently used only for FORTRAN arrays. */ + + char low_undefined; + char high_undefined; + + } *bounds; + + } flds_bnds; /* For types with virtual functions (TYPE_CODE_STRUCT), VPTR_BASETYPE is the base class which defined the virtual function table pointer. @@ -523,10 +626,14 @@ struct main_type { /* CPLUS_STUFF is for TYPE_CODE_STRUCT. It is initialized to point to cplus_struct_default, a default static instance of a struct - cplus_struct_type. */ + cplus_struct_type. */ struct cplus_struct_type *cplus_stuff; + /* GNAT_STUFF is for types for which the GNAT Ada compiler + provides additional information. */ + struct gnat_aux_type *gnat_stuff; + /* FLOATFORMAT is for TYPE_CODE_FLT. It is a pointer to two floatformat objects that describe the floating-point value that resides within the type. The first is for big endian @@ -534,10 +641,8 @@ struct main_type const struct floatformat **floatformat; - /* For TYPE_CODE_FUNC types, the calling convention for targets - supporting multiple ABIs. Right now this is only fetched from - the Dwarf-2 DW_AT_calling_convention attribute. */ - unsigned calling_convention; + /* For TYPE_CODE_FUNC types, */ + struct func_type *func_stuff; } type_specific; }; @@ -564,7 +669,14 @@ struct type struct type *chain; /* Flags specific to this instance of the type, indicating where - on the ring we are. */ + on the ring we are. + + For TYPE_CODE_TYPEDEF the flags of the typedef type should be binary + or-ed with the target type, with a special case for address class and + space class. For example if this typedef does not specify any new + qualifiers, TYPE_INSTANCE_FLAGS is 0 and the instance flags are + completely inherited from the target type. No qualifiers can be cleared + by the typedef. See also check_typedef. */ int instance_flags; /* Length of storage for a value of this type. This is what @@ -612,32 +724,27 @@ struct cplus_struct_type short n_baseclasses; /* Number of methods with unique names. All overloaded methods with - the same name count only once. */ + the same name count only once. */ short nfn_fields; - /* Number of methods described for this type, not including the - methods that it derives from. */ + /* Number of template arguments. */ + unsigned short n_template_arguments; - short nfn_fields_total; + /* One if this struct is a dynamic class, as defined by the + Itanium C++ ABI: if it requires a virtual table pointer, + because it or any of its base classes have one or more virtual + member functions or virtual base classes. Minus one if not + dynamic. Zero if not yet computed. */ + int is_dynamic : 2; - /* The "declared_type" field contains a code saying how the - user really declared this type, e.g., "class s", "union s", - "struct s". - The 3 above things come out from the C++ compiler looking like classes, - but we keep track of the real declaration so we can give - the correct information on "ptype". (Note: TEMPLATE may not - belong in this list...) */ + /* Non-zero if this type came from a Java CU. */ + unsigned int is_java : 1; -#define DECLARED_TYPE_CLASS 0 -#define DECLARED_TYPE_UNION 1 -#define DECLARED_TYPE_STRUCT 2 -#define DECLARED_TYPE_TEMPLATE 3 - short declared_type; /* One of the above codes */ - - /* For derived classes, the number of base classes is given by n_baseclasses - and virtual_field_bits is a bit vector containing one bit per base class. - If the base class is virtual, the corresponding bit will be set. + /* For derived classes, the number of base classes is given by + n_baseclasses and virtual_field_bits is a bit vector containing + one bit per base class. If the base class is virtual, the + corresponding bit will be set. I.E, given: class A{}; @@ -645,26 +752,26 @@ struct cplus_struct_type class C : public B, public virtual A {}; B is a baseclass of C; A is a virtual baseclass for C. - This is a C++ 2.0 language feature. */ + This is a C++ 2.0 language feature. */ B_TYPE *virtual_field_bits; /* For classes with private fields, the number of fields is given by nfields and private_field_bits is a bit vector containing one bit per field. - If the field is private, the corresponding bit will be set. */ + If the field is private, the corresponding bit will be set. */ B_TYPE *private_field_bits; /* For classes with protected fields, the number of fields is given by nfields and protected_field_bits is a bit vector containing one bit per field. - If the field is private, the corresponding bit will be set. */ + If the field is private, the corresponding bit will be set. */ B_TYPE *protected_field_bits; - /* for classes with fields to be ignored, either this is optimized out - or this field has length 0 */ + /* For classes with fields to be ignored, either this is optimized out + or this field has length 0. */ B_TYPE *ignore_field_bits; @@ -673,14 +780,16 @@ struct cplus_struct_type arguments that the method expects, and then the name after it has been renamed to make it distinct. - fn_fieldlists points to an array of nfn_fields of these. */ + fn_fieldlists points to an array of nfn_fields of these. */ struct fn_fieldlist { - /* The overloaded name. */ + /* The overloaded name. + This is generally allocated in the objfile's obstack. + However stabsread.c sometimes uses malloc. */ - char *name; + const char *name; /* The number of methods with this name. */ @@ -702,22 +811,22 @@ struct cplus_struct_type arguments. See gdb_mangle_name for the conversion from this format to the one used if is_stub is clear. */ - char *physname; + const char *physname; /* The function type for the method. (This comment used to say "The return value of the method", - but that's wrong. The function type + but that's wrong. The function type is expected here, i.e. something with TYPE_CODE_FUNC, - and *not* the return-value type). */ + and *not* the return-value type). */ struct type *type; /* For virtual functions. - First baseclass that defines this virtual function. */ + First baseclass that defines this virtual function. */ struct type *fcontext; - /* Attributes. */ + /* Attributes. */ unsigned int is_const:1; unsigned int is_volatile:1; @@ -735,8 +844,12 @@ struct cplus_struct_type to reconstruct the rest of the fields). */ unsigned int is_stub:1; + /* True if this function is a constructor, false + otherwise. */ + unsigned int is_constructor : 1; + /* Unused. */ - unsigned int dummy:4; + unsigned int dummy:3; /* Index into that baseclass's virtual function table, minus 2; else if static: VOFFSET_STATIC; else: 0. */ @@ -751,58 +864,186 @@ struct cplus_struct_type } *fn_fieldlists; - /* If this "struct type" describes a template, then it - * has arguments. "template_args" points to an array of - * template arg descriptors, of length "ntemplate_args". - * The only real information in each of these template arg descriptors - * is a name. "type" will typically just point to a "struct type" with - * the placeholder TYPE_CODE_TEMPLATE_ARG type. - */ - short ntemplate_args; - struct template_arg + /* typedefs defined inside this class. TYPEDEF_FIELD points to an array of + TYPEDEF_FIELD_COUNT elements. */ + struct typedef_field { - char *name; + /* Unqualified name to be prefixed by owning class qualified name. */ + const char *name; + + /* Type this typedef named NAME represents. */ struct type *type; } - *template_args; + *typedef_field; + unsigned typedef_field_count; - /* Pointer to information about enclosing scope, if this is a - * local type. If it is not a local type, this is NULL - */ - struct local_type_info - { - char *file; - int line; - } - *localtype_ptr; + /* The template arguments. This is an array with + N_TEMPLATE_ARGUMENTS elements. This is NULL for non-template + classes. */ + struct symbol **template_arguments; }; -/* Struct used in computing virtual base list */ -struct vbase +/* Struct used to store conversion rankings. */ +struct rank { - struct type *vbasetype; /* pointer to virtual base */ - struct vbase *next; /* next in chain */ + short rank; + + /* When two conversions are of the same type and therefore have the same + rank, subrank is used to differentiate the two. + Eg: Two derived-class-pointer to base-class-pointer conversions would + both have base pointer conversion rank, but the conversion with the + shorter distance to the ancestor is preferable. 'subrank' would be used + to reflect that. */ + short subrank; }; -/* Struct used for ranking a function for overload resolution */ +/* Struct used for ranking a function for overload resolution. */ struct badness_vector { int length; - int *rank; + struct rank *rank; + }; + +/* GNAT Ada-specific information for various Ada types. */ +struct gnat_aux_type + { + /* Parallel type used to encode information about dynamic types + used in Ada (such as variant records, variable-size array, + etc). */ + struct type* descriptive_type; + }; + +/* For TYPE_CODE_FUNC types, */ +struct func_type + { + /* The calling convention for targets supporting multiple ABIs. Right now + this is only fetched from the Dwarf-2 DW_AT_calling_convention + attribute. */ + unsigned calling_convention; + + /* Only those DW_TAG_GNU_call_site's in this function that have + DW_AT_GNU_tail_call set are linked in this list. Function without its + tail call list complete (DW_AT_GNU_all_tail_call_sites or its superset + DW_AT_GNU_all_call_sites) has TAIL_CALL_LIST NULL, even if some + DW_TAG_GNU_call_site's exist in such function. */ + struct call_site *tail_call_list; + }; + +/* struct call_site_parameter can be referenced in callees by several ways. */ + +enum call_site_parameter_kind +{ + /* Use field call_site_parameter.u.dwarf_reg. */ + CALL_SITE_PARAMETER_DWARF_REG, + + /* Use field call_site_parameter.u.fb_offset. */ + CALL_SITE_PARAMETER_FB_OFFSET, + + /* Use field call_site_parameter.u.param_offset. */ + CALL_SITE_PARAMETER_PARAM_OFFSET +}; + +/* A place where a function gets called from, represented by + DW_TAG_GNU_call_site. It can be looked up from symtab->call_site_htab. */ + +struct call_site + { + /* Address of the first instruction after this call. It must be the first + field as we overload core_addr_hash and core_addr_eq for it. */ + CORE_ADDR pc; + + /* List successor with head in FUNC_TYPE.TAIL_CALL_LIST. */ + struct call_site *tail_call_next; + + /* Describe DW_AT_GNU_call_site_target. Missing attribute uses + FIELD_LOC_KIND_DWARF_BLOCK with FIELD_DWARF_BLOCK == NULL. */ + struct + { + union field_location loc; + + /* Discriminant for union field_location. */ + ENUM_BITFIELD(field_loc_kind) loc_kind : 3; + } + target; + + /* Size of the PARAMETER array. */ + unsigned parameter_count; + + /* CU of the function where the call is located. It gets used for DWARF + blocks execution in the parameter array below. */ + struct dwarf2_per_cu_data *per_cu; + + /* Describe DW_TAG_GNU_call_site's DW_TAG_formal_parameter. */ + struct call_site_parameter + { + ENUM_BITFIELD (call_site_parameter_kind) kind : 2; + + union call_site_parameter_u + { + /* DW_TAG_formal_parameter's DW_AT_location's DW_OP_regX as DWARF + register number, for register passed parameters. */ + int dwarf_reg; + + /* Offset from the callee's frame base, for stack passed parameters. + This equals offset from the caller's stack pointer. */ + CORE_ADDR fb_offset; + + /* Offset relative to the start of this PER_CU to + DW_TAG_formal_parameter which is referenced by both caller and + the callee. */ + cu_offset param_offset; + } + u; + + /* DW_TAG_formal_parameter's DW_AT_GNU_call_site_value. It is never + NULL. */ + const gdb_byte *value; + size_t value_size; + + /* DW_TAG_formal_parameter's DW_AT_GNU_call_site_data_value. It may be + NULL if not provided by DWARF. */ + const gdb_byte *data_value; + size_t data_value_size; + } + parameter[1]; }; /* The default value of TYPE_CPLUS_SPECIFIC(T) points to the - this shared static structure. */ + this shared static structure. */ extern const struct cplus_struct_type cplus_struct_default; extern void allocate_cplus_struct_type (struct type *); #define INIT_CPLUS_SPECIFIC(type) \ - (TYPE_CPLUS_SPECIFIC(type)=(struct cplus_struct_type*)&cplus_struct_default) + (TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_CPLUS_STUFF, \ + TYPE_RAW_CPLUS_SPECIFIC (type) = (struct cplus_struct_type*) \ + &cplus_struct_default) + #define ALLOCATE_CPLUS_STRUCT_TYPE(type) allocate_cplus_struct_type (type) + #define HAVE_CPLUS_STRUCT(type) \ - (TYPE_CPLUS_SPECIFIC(type) != &cplus_struct_default) + (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_CPLUS_STUFF \ + && TYPE_RAW_CPLUS_SPECIFIC (type) != &cplus_struct_default) + +extern const struct gnat_aux_type gnat_aux_default; + +extern void allocate_gnat_aux_type (struct type *); + +#define INIT_GNAT_SPECIFIC(type) \ + (TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_GNAT_STUFF, \ + TYPE_GNAT_SPECIFIC (type) = (struct gnat_aux_type *) &gnat_aux_default) +#define ALLOCATE_GNAT_AUX_TYPE(type) allocate_gnat_aux_type (type) +/* A macro that returns non-zero if the type-specific data should be + read as "gnat-stuff". */ +#define HAVE_GNAT_AUX_INFO(type) \ + (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_GNAT_STUFF) + +#define INIT_FUNC_SPECIFIC(type) \ + (TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_FUNC, \ + TYPE_MAIN_TYPE (type)->type_specific.func_stuff \ + = TYPE_ZALLOC (type, \ + sizeof (*TYPE_MAIN_TYPE (type)->type_specific.func_stuff))) #define TYPE_INSTANCE_FLAGS(thistype) (thistype)->instance_flags #define TYPE_MAIN_TYPE(thistype) (thistype)->main_type @@ -818,22 +1059,26 @@ extern void allocate_cplus_struct_type (struct type *); calls check_typedef, TYPE_LENGTH (VALUE_TYPE (X)) is safe. */ #define TYPE_LENGTH(thistype) (thistype)->length /* Note that TYPE_CODE can be TYPE_CODE_TYPEDEF, so if you want the real - type, you need to do TYPE_CODE (check_type (this_type)). */ + type, you need to do TYPE_CODE (check_type (this_type)). */ #define TYPE_CODE(thistype) TYPE_MAIN_TYPE(thistype)->code #define TYPE_NFIELDS(thistype) TYPE_MAIN_TYPE(thistype)->nfields -#define TYPE_FIELDS(thistype) TYPE_MAIN_TYPE(thistype)->fields -#define TYPE_TEMPLATE_ARGS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->template_args +#define TYPE_FIELDS(thistype) TYPE_MAIN_TYPE(thistype)->flds_bnds.fields #define TYPE_INDEX_TYPE(type) TYPE_FIELD_TYPE (type, 0) -#define TYPE_LOW_BOUND(range_type) TYPE_FIELD_BITPOS (range_type, 0) -#define TYPE_HIGH_BOUND(range_type) TYPE_FIELD_BITPOS (range_type, 1) +#define TYPE_RANGE_DATA(thistype) TYPE_MAIN_TYPE(thistype)->flds_bnds.bounds +#define TYPE_LOW_BOUND(range_type) TYPE_RANGE_DATA(range_type)->low +#define TYPE_HIGH_BOUND(range_type) TYPE_RANGE_DATA(range_type)->high +#define TYPE_LOW_BOUND_UNDEFINED(range_type) \ + TYPE_RANGE_DATA(range_type)->low_undefined +#define TYPE_HIGH_BOUND_UNDEFINED(range_type) \ + TYPE_RANGE_DATA(range_type)->high_undefined -/* Moto-specific stuff for FORTRAN arrays */ +/* Moto-specific stuff for FORTRAN arrays. */ #define TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED(arraytype) \ - (TYPE_FIELD_ARTIFICIAL(TYPE_INDEX_TYPE((arraytype)),1)) + TYPE_HIGH_BOUND_UNDEFINED(TYPE_INDEX_TYPE(arraytype)) #define TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED(arraytype) \ - (TYPE_FIELD_ARTIFICIAL(TYPE_INDEX_TYPE((arraytype)),0)) + TYPE_LOW_BOUND_UNDEFINED(TYPE_INDEX_TYPE(arraytype)) #define TYPE_ARRAY_UPPER_BOUND_VALUE(arraytype) \ (TYPE_HIGH_BOUND(TYPE_INDEX_TYPE((arraytype)))) @@ -848,19 +1093,32 @@ extern void allocate_cplus_struct_type (struct type *); #define TYPE_VPTR_FIELDNO(thistype) TYPE_MAIN_TYPE(thistype)->vptr_fieldno #define TYPE_FN_FIELDS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->fn_fields #define TYPE_NFN_FIELDS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->nfn_fields -#define TYPE_NFN_FIELDS_TOTAL(thistype) TYPE_CPLUS_SPECIFIC(thistype)->nfn_fields_total -#define TYPE_NTEMPLATE_ARGS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->ntemplate_args -#define TYPE_DECLARED_TYPE(thistype) TYPE_CPLUS_SPECIFIC(thistype)->declared_type +#define TYPE_SPECIFIC_FIELD(thistype) \ + TYPE_MAIN_TYPE(thistype)->type_specific_field #define TYPE_TYPE_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific -#define TYPE_CPLUS_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.cplus_stuff +/* We need this tap-dance with the TYPE_RAW_SPECIFIC because of the case + where we're trying to print an Ada array using the C language. + In that case, there is no "cplus_stuff", but the C language assumes + that there is. What we do, in that case, is pretend that there is + an implicit one which is the default cplus stuff. */ +#define TYPE_CPLUS_SPECIFIC(thistype) \ + (!HAVE_CPLUS_STRUCT(thistype) \ + ? (struct cplus_struct_type*)&cplus_struct_default \ + : TYPE_RAW_CPLUS_SPECIFIC(thistype)) +#define TYPE_RAW_CPLUS_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.cplus_stuff #define TYPE_FLOATFORMAT(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.floatformat -#define TYPE_CALLING_CONVENTION(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.calling_convention -#define TYPE_BASECLASS(thistype,index) TYPE_MAIN_TYPE(thistype)->fields[index].type +#define TYPE_GNAT_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.gnat_stuff +#define TYPE_DESCRIPTIVE_TYPE(thistype) TYPE_GNAT_SPECIFIC(thistype)->descriptive_type +#define TYPE_CALLING_CONVENTION(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.func_stuff->calling_convention +#define TYPE_TAIL_CALL_LIST(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.func_stuff->tail_call_list +#define TYPE_BASECLASS(thistype,index) TYPE_FIELD_TYPE(thistype, index) #define TYPE_N_BASECLASSES(thistype) TYPE_CPLUS_SPECIFIC(thistype)->n_baseclasses -#define TYPE_BASECLASS_NAME(thistype,index) TYPE_MAIN_TYPE(thistype)->fields[index].name +#define TYPE_BASECLASS_NAME(thistype,index) TYPE_FIELD_NAME(thistype, index) #define TYPE_BASECLASS_BITPOS(thistype,index) TYPE_FIELD_BITPOS(thistype,index) #define BASETYPE_VIA_PUBLIC(thistype, index) \ ((!TYPE_FIELD_PRIVATE(thistype, index)) && (!TYPE_FIELD_PROTECTED(thistype, index))) +#define TYPE_CPLUS_DYNAMIC(thistype) TYPE_CPLUS_SPECIFIC (thistype)->is_dynamic +#define TYPE_CPLUS_REALLY_JAVA(thistype) TYPE_CPLUS_SPECIFIC (thistype)->is_java #define BASETYPE_VIA_VIRTUAL(thistype, index) \ (TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits == NULL ? 0 \ @@ -869,13 +1127,19 @@ extern void allocate_cplus_struct_type (struct type *); #define FIELD_TYPE(thisfld) ((thisfld).type) #define FIELD_NAME(thisfld) ((thisfld).name) #define FIELD_LOC_KIND(thisfld) ((thisfld).loc_kind) -#define FIELD_BITPOS(thisfld) ((thisfld).loc.bitpos) +#define FIELD_BITPOS_LVAL(thisfld) ((thisfld).loc.bitpos) +#define FIELD_BITPOS(thisfld) (FIELD_BITPOS_LVAL (thisfld) + 0) +#define FIELD_ENUMVAL_LVAL(thisfld) ((thisfld).loc.enumval) +#define FIELD_ENUMVAL(thisfld) (FIELD_ENUMVAL_LVAL (thisfld) + 0) #define FIELD_STATIC_PHYSNAME(thisfld) ((thisfld).loc.physname) #define FIELD_STATIC_PHYSADDR(thisfld) ((thisfld).loc.physaddr) #define FIELD_DWARF_BLOCK(thisfld) ((thisfld).loc.dwarf_block) #define SET_FIELD_BITPOS(thisfld, bitpos) \ (FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_BITPOS, \ - FIELD_BITPOS (thisfld) = (bitpos)) + FIELD_BITPOS_LVAL (thisfld) = (bitpos)) +#define SET_FIELD_ENUMVAL(thisfld, enumval) \ + (FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_ENUMVAL, \ + FIELD_ENUMVAL_LVAL (thisfld) = (enumval)) #define SET_FIELD_PHYSNAME(thisfld, name) \ (FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_PHYSNAME, \ FIELD_STATIC_PHYSNAME (thisfld) = (name)) @@ -888,18 +1152,18 @@ extern void allocate_cplus_struct_type (struct type *); #define FIELD_ARTIFICIAL(thisfld) ((thisfld).artificial) #define FIELD_BITSIZE(thisfld) ((thisfld).bitsize) -#define TYPE_FIELD(thistype, n) TYPE_MAIN_TYPE(thistype)->fields[n] +#define TYPE_FIELD(thistype, n) TYPE_MAIN_TYPE(thistype)->flds_bnds.fields[n] #define TYPE_FIELD_TYPE(thistype, n) FIELD_TYPE(TYPE_FIELD(thistype, n)) #define TYPE_FIELD_NAME(thistype, n) FIELD_NAME(TYPE_FIELD(thistype, n)) #define TYPE_FIELD_LOC_KIND(thistype, n) FIELD_LOC_KIND (TYPE_FIELD (thistype, n)) #define TYPE_FIELD_BITPOS(thistype, n) FIELD_BITPOS (TYPE_FIELD (thistype, n)) +#define TYPE_FIELD_ENUMVAL(thistype, n) FIELD_ENUMVAL (TYPE_FIELD (thistype, n)) #define TYPE_FIELD_STATIC_PHYSNAME(thistype, n) FIELD_STATIC_PHYSNAME (TYPE_FIELD (thistype, n)) #define TYPE_FIELD_STATIC_PHYSADDR(thistype, n) FIELD_STATIC_PHYSADDR (TYPE_FIELD (thistype, n)) #define TYPE_FIELD_DWARF_BLOCK(thistype, n) FIELD_DWARF_BLOCK (TYPE_FIELD (thistype, n)) #define TYPE_FIELD_ARTIFICIAL(thistype, n) FIELD_ARTIFICIAL(TYPE_FIELD(thistype,n)) #define TYPE_FIELD_BITSIZE(thistype, n) FIELD_BITSIZE(TYPE_FIELD(thistype,n)) #define TYPE_FIELD_PACKED(thistype, n) (FIELD_BITSIZE(TYPE_FIELD(thistype,n))!=0) -#define TYPE_TEMPLATE_ARG(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->template_args[n] #define TYPE_FIELD_PRIVATE_BITS(thistype) \ TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits @@ -936,6 +1200,13 @@ extern void allocate_cplus_struct_type (struct type *); #define TYPE_FN_FIELDLIST_NAME(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].name #define TYPE_FN_FIELDLIST_LENGTH(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].length +#define TYPE_N_TEMPLATE_ARGUMENTS(thistype) \ + TYPE_CPLUS_SPECIFIC (thistype)->n_template_arguments +#define TYPE_TEMPLATE_ARGUMENTS(thistype) \ + TYPE_CPLUS_SPECIFIC (thistype)->template_arguments +#define TYPE_TEMPLATE_ARGUMENT(thistype, n) \ + TYPE_CPLUS_SPECIFIC (thistype)->template_arguments[n] + #define TYPE_FN_FIELD(thisfn, n) (thisfn)[n] #define TYPE_FN_FIELD_PHYSNAME(thisfn, n) (thisfn)[n].physname #define TYPE_FN_FIELD_TYPE(thisfn, n) (thisfn)[n].type @@ -952,26 +1223,46 @@ extern void allocate_cplus_struct_type (struct type *); #define TYPE_FN_FIELD_ARTIFICIAL(thisfn, n) ((thisfn)[n].is_artificial) #define TYPE_FN_FIELD_ABSTRACT(thisfn, n) ((thisfn)[n].is_abstract) #define TYPE_FN_FIELD_STUB(thisfn, n) ((thisfn)[n].is_stub) +#define TYPE_FN_FIELD_CONSTRUCTOR(thisfn, n) ((thisfn)[n].is_constructor) #define TYPE_FN_FIELD_FCONTEXT(thisfn, n) ((thisfn)[n].fcontext) #define TYPE_FN_FIELD_VOFFSET(thisfn, n) ((thisfn)[n].voffset-2) #define TYPE_FN_FIELD_VIRTUAL_P(thisfn, n) ((thisfn)[n].voffset > 1) #define TYPE_FN_FIELD_STATIC_P(thisfn, n) ((thisfn)[n].voffset == VOFFSET_STATIC) -#define TYPE_LOCALTYPE_PTR(thistype) (TYPE_CPLUS_SPECIFIC(thistype)->localtype_ptr) -#define TYPE_LOCALTYPE_FILE(thistype) (TYPE_CPLUS_SPECIFIC(thistype)->localtype_ptr->file) -#define TYPE_LOCALTYPE_LINE(thistype) (TYPE_CPLUS_SPECIFIC(thistype)->localtype_ptr->line) - -#define TYPE_IS_OPAQUE(thistype) (((TYPE_CODE (thistype) == TYPE_CODE_STRUCT) || \ - (TYPE_CODE (thistype) == TYPE_CODE_UNION)) && \ - (TYPE_NFIELDS (thistype) == 0) && \ - (TYPE_CPLUS_SPECIFIC (thistype) && (TYPE_NFN_FIELDS (thistype) == 0)) && \ - (TYPE_STUB (thistype) || !TYPE_STUB_SUPPORTED (thistype))) +#define TYPE_TYPEDEF_FIELD_ARRAY(thistype) \ + TYPE_CPLUS_SPECIFIC (thistype)->typedef_field +#define TYPE_TYPEDEF_FIELD(thistype, n) \ + TYPE_CPLUS_SPECIFIC (thistype)->typedef_field[n] +#define TYPE_TYPEDEF_FIELD_NAME(thistype, n) \ + TYPE_TYPEDEF_FIELD (thistype, n).name +#define TYPE_TYPEDEF_FIELD_TYPE(thistype, n) \ + TYPE_TYPEDEF_FIELD (thistype, n).type +#define TYPE_TYPEDEF_FIELD_COUNT(thistype) \ + TYPE_CPLUS_SPECIFIC (thistype)->typedef_field_count + +#define TYPE_IS_OPAQUE(thistype) \ + (((TYPE_CODE (thistype) == TYPE_CODE_STRUCT) \ + || (TYPE_CODE (thistype) == TYPE_CODE_UNION)) \ + && (TYPE_NFIELDS (thistype) == 0) \ + && (!HAVE_CPLUS_STRUCT (thistype) \ + || TYPE_NFN_FIELDS (thistype) == 0) \ + && (TYPE_STUB (thistype) || !TYPE_STUB_SUPPORTED (thistype))) + +/* A helper macro that returns the name of a type or "unnamed type" if the type + has no name. */ +#define TYPE_SAFE_NAME(type) \ + (TYPE_NAME (type) ? TYPE_NAME (type) : _("")) + +/* A helper macro that returns the name of an error type. If the type + has a name, it is used; otherwise, a default is used. */ +#define TYPE_ERROR_NAME(type) \ + (TYPE_NAME (type) ? TYPE_NAME (type) : _("")) struct builtin_type { /* Integral types. */ - /* Implicit size/sign (based on the the architecture's ABI). */ + /* Implicit size/sign (based on the architecture's ABI). */ struct type *builtin_void; struct type *builtin_char; struct type *builtin_short; @@ -1017,6 +1308,9 @@ struct builtin_type struct type *builtin_int128; struct type *builtin_uint128; + /* Wide character types. */ + struct type *builtin_char16; + struct type *builtin_char32; /* Pointer types. */ @@ -1034,6 +1328,10 @@ struct builtin_type (*) () can server as a generic function pointer. */ struct type *builtin_func_ptr; + /* `function returning pointer to function (returning void)' type. + The final void return type is not significant for it. */ + struct type *builtin_func_func; + /* Special-purpose types. */ @@ -1074,6 +1372,8 @@ struct objfile_type /* Types used for symbols with no debug information. */ struct type *nodebug_text_symbol; + struct type *nodebug_text_gnu_ifunc_symbol; + struct type *nodebug_got_plt_symbol; struct type *nodebug_data_symbol; struct type *nodebug_unknown_symbol; struct type *nodebug_tls_symbol; @@ -1084,6 +1384,7 @@ extern const struct objfile_type *objfile_type (struct objfile *objfile); /* Explicit floating-point formats. See "floatformat.h". */ +extern const struct floatformat *floatformats_ieee_half[BFD_ENDIAN_UNKNOWN]; extern const struct floatformat *floatformats_ieee_single[BFD_ENDIAN_UNKNOWN]; extern const struct floatformat *floatformats_ieee_double[BFD_ENDIAN_UNKNOWN]; extern const struct floatformat *floatformats_ieee_double_littlebyte_bigword[BFD_ENDIAN_UNKNOWN]; @@ -1097,24 +1398,14 @@ extern const struct floatformat *floatformats_vax_d[BFD_ENDIAN_UNKNOWN]; extern const struct floatformat *floatformats_ibm_long_double[BFD_ENDIAN_UNKNOWN]; -/* Maximum and minimum values of built-in types */ - -#define MAX_OF_TYPE(t) \ - (TYPE_UNSIGNED(t) ? UMAX_OF_SIZE(TYPE_LENGTH(t)) \ - : MAX_OF_SIZE(TYPE_LENGTH(t))) - -#define MIN_OF_TYPE(t) \ - (TYPE_UNSIGNED(t) ? UMIN_OF_SIZE(TYPE_LENGTH(t)) \ - : MIN_OF_SIZE(TYPE_LENGTH(t))) - /* Allocate space for storing data associated with a particular type. We ensure that the space is allocated using the same mechanism that - was used to allocate the space for the type structure itself. I.E. + was used to allocate the space for the type structure itself. I.e. if the type is on an objfile's objfile_obstack, then the space for data associated with that type will also be allocated on the objfile_obstack. If the type is not associated with any particular objfile (such as builtin types), then the data space will be allocated with xmalloc, - the same as for the type structure. */ + the same as for the type structure. */ #define TYPE_ALLOC(t,size) \ (TYPE_OBJFILE_OWNED (t) \ @@ -1140,8 +1431,12 @@ extern struct type *alloc_type_copy (const struct type *); objfile's architecture is returned. */ extern struct gdbarch *get_type_arch (const struct type *); +/* This returns the target type (or NULL) of TYPE, also skipping + past typedefs. */ +extern struct type *get_target_type (struct type *type); + /* Helper function to construct objfile-owned types. */ -extern struct type *init_type (enum type_code, int, int, char *, +extern struct type *init_type (enum type_code, int, int, const char *, struct objfile *); /* Helper functions to construct architecture-owned types. */ @@ -1156,7 +1451,7 @@ extern struct type *arch_complex_type (struct gdbarch *, char *, /* Helper functions to construct a struct or record type. An initially empty type is created using arch_composite_type(). - Fields are then added using append_struct_type_field(). A union + Fields are then added using append_composite_type_field*(). A union type has its size set to the largest field. A struct type has each field packed against the previous. */ @@ -1168,6 +1463,8 @@ extern void append_composite_type_field_aligned (struct type *t, char *name, struct type *field, int alignment); +struct field *append_composite_type_field_raw (struct type *t, char *name, + struct type *field); /* Helper functions to construct a bit flags type. An initially empty type is created using arch_flag_type(). Flags are then added using @@ -1185,11 +1482,13 @@ extern struct type *make_reference_type (struct type *, struct type **); extern struct type *make_cv_type (int, int, struct type *, struct type **); +extern struct type *make_restrict_type (struct type *); + extern void replace_type (struct type *, struct type *); -extern int address_space_name_to_int (char *); +extern int address_space_name_to_int (struct gdbarch *, char *); -extern const char *address_space_int_to_name (int); +extern const char *address_space_int_to_name (struct gdbarch *, int); extern struct type *make_type_with_address_space (struct type *type, int space_identifier); @@ -1205,11 +1504,15 @@ extern void smash_to_method_type (struct type *type, struct type *domain, extern void smash_to_memberptr_type (struct type *, struct type *, struct type *); +extern void smash_to_methodptr_type (struct type *, struct type *); + extern struct type *allocate_stub_method (struct type *); -extern char *type_name_no_tag (const struct type *); +extern const char *type_name_no_tag (const struct type *); -extern struct type *lookup_struct_elt_type (struct type *, char *, int); +extern const char *type_name_no_tag_or_error (struct type *type); + +extern struct type *lookup_struct_elt_type (struct type *, const char *, int); extern struct type *make_pointer_type (struct type *, struct type **); @@ -1219,24 +1522,32 @@ extern struct type *make_function_type (struct type *, struct type **); extern struct type *lookup_function_type (struct type *); -extern struct type *create_range_type (struct type *, struct type *, int, - int); +extern struct type *lookup_function_type_with_arguments (struct type *, + int, + struct type **); + +extern struct type *create_range_type (struct type *, struct type *, LONGEST, + LONGEST); extern struct type *create_array_type (struct type *, struct type *, struct type *); -extern struct type *lookup_array_range_type (struct type *, int, int); +extern struct type *lookup_array_range_type (struct type *, LONGEST, LONGEST); extern struct type *create_string_type (struct type *, struct type *, struct type *); -extern struct type *lookup_string_range_type (struct type *, int, int); +extern struct type *lookup_string_range_type (struct type *, LONGEST, LONGEST); extern struct type *create_set_type (struct type *, struct type *); extern struct type *lookup_unsigned_typename (const struct language_defn *, - struct gdbarch *,char *); + struct gdbarch *, const char *); extern struct type *lookup_signed_typename (const struct language_defn *, - struct gdbarch *,char *); + struct gdbarch *, const char *); + +extern void get_unsigned_type_max (struct type *, ULONGEST *); + +extern void get_signed_type_minmax (struct type *, LONGEST *, LONGEST *); extern struct type *check_typedef (struct type *); @@ -1250,61 +1561,84 @@ extern void check_stub_method_group (struct type *, int); extern char *gdb_mangle_name (struct type *, int, int); extern struct type *lookup_typename (const struct language_defn *, - struct gdbarch *, char *, - struct block *, int); + struct gdbarch *, const char *, + const struct block *, int); extern struct type *lookup_template_type (char *, struct type *, - struct block *); + const struct block *); extern int get_vptr_fieldno (struct type *, struct type **); extern int get_discrete_bounds (struct type *, LONGEST *, LONGEST *); +extern int get_array_bounds (struct type *type, LONGEST *low_bound, + LONGEST *high_bound); + +extern int class_types_same_p (const struct type *, const struct type *); + extern int is_ancestor (struct type *, struct type *); +extern int is_public_ancestor (struct type *, struct type *); + +extern int is_unique_ancestor (struct type *, struct value *); + /* Overload resolution */ #define LENGTH_MATCH(bv) ((bv)->rank[0]) -/* Badness if parameter list length doesn't match arg list length */ -#define LENGTH_MISMATCH_BADNESS 100 -/* Dummy badness value for nonexistent parameter positions */ -#define TOO_FEW_PARAMS_BADNESS 100 -/* Badness if no conversion among types */ -#define INCOMPATIBLE_TYPE_BADNESS 100 - -/* Badness of integral promotion */ -#define INTEGER_PROMOTION_BADNESS 1 -/* Badness of floating promotion */ -#define FLOAT_PROMOTION_BADNESS 1 -/* Badness of integral conversion */ -#define INTEGER_CONVERSION_BADNESS 2 -/* Badness of floating conversion */ -#define FLOAT_CONVERSION_BADNESS 2 -/* Badness of integer<->floating conversions */ -#define INT_FLOAT_CONVERSION_BADNESS 2 -/* Badness of converting to a boolean */ -#define BOOLEAN_CONVERSION_BADNESS 2 -/* Badness of pointer conversion */ -#define POINTER_CONVERSION_BADNESS 2 -/* Badness of conversion of pointer to void pointer */ -#define VOID_PTR_CONVERSION_BADNESS 2 -/* Badness of converting derived to base class */ -#define BASE_CONVERSION_BADNESS 2 -/* Badness of converting from non-reference to reference */ -#define REFERENCE_CONVERSION_BADNESS 2 +/* Badness if parameter list length doesn't match arg list length. */ +extern const struct rank LENGTH_MISMATCH_BADNESS; + +/* Dummy badness value for nonexistent parameter positions. */ +extern const struct rank TOO_FEW_PARAMS_BADNESS; +/* Badness if no conversion among types. */ +extern const struct rank INCOMPATIBLE_TYPE_BADNESS; + +/* Badness of an exact match. */ +extern const struct rank EXACT_MATCH_BADNESS; + +/* Badness of integral promotion. */ +extern const struct rank INTEGER_PROMOTION_BADNESS; +/* Badness of floating promotion. */ +extern const struct rank FLOAT_PROMOTION_BADNESS; +/* Badness of converting a derived class pointer + to a base class pointer. */ +extern const struct rank BASE_PTR_CONVERSION_BADNESS; +/* Badness of integral conversion. */ +extern const struct rank INTEGER_CONVERSION_BADNESS; +/* Badness of floating conversion. */ +extern const struct rank FLOAT_CONVERSION_BADNESS; +/* Badness of integer<->floating conversions. */ +extern const struct rank INT_FLOAT_CONVERSION_BADNESS; +/* Badness of conversion of pointer to void pointer. */ +extern const struct rank VOID_PTR_CONVERSION_BADNESS; +/* Badness of conversion to boolean. */ +extern const struct rank BOOL_CONVERSION_BADNESS; +/* Badness of converting derived to base class. */ +extern const struct rank BASE_CONVERSION_BADNESS; +/* Badness of converting from non-reference to reference. */ +extern const struct rank REFERENCE_CONVERSION_BADNESS; +/* Badness of converting integer 0 to NULL pointer. */ +extern const struct rank NULL_POINTER_CONVERSION; /* Non-standard conversions allowed by the debugger */ -/* Converting a pointer to an int is usually OK */ -#define NS_POINTER_CONVERSION_BADNESS 10 +/* Converting a pointer to an int is usually OK. */ +extern const struct rank NS_POINTER_CONVERSION_BADNESS; + +/* Badness of converting a (non-zero) integer constant + to a pointer. */ +extern const struct rank NS_INTEGER_POINTER_CONVERSION_BADNESS; +extern struct rank sum_ranks (struct rank a, struct rank b); +extern int compare_ranks (struct rank a, struct rank b); extern int compare_badness (struct badness_vector *, struct badness_vector *); extern struct badness_vector *rank_function (struct type **, int, - struct type **, int); + struct value **, int); -extern int rank_one_type (struct type *, struct type *); +extern struct rank rank_one_type (struct type *, struct type *, + struct value *); extern void recursive_dump_type (struct type *, int); @@ -1320,6 +1654,8 @@ extern int can_dereference (struct type *); extern int is_integral_type (struct type *); +extern int is_scalar_type_recursive (struct type *); + extern void maintenance_print_type (char *, int); extern htab_t create_copied_types_hash (struct objfile *objfile); @@ -1330,4 +1666,8 @@ extern struct type *copy_type_recursive (struct objfile *objfile, extern struct type *copy_type (const struct type *type); +extern int types_equal (struct type *, struct type *); + +extern int types_deeply_equal (struct type *, struct type *); + #endif /* GDBTYPES_H */