/* Internal type definitions for GDB.
- Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
- 2002, 2003, 2004, 2006, 2007, 2008, 2009, 2010
- Free Software Foundation, Inc.
+ Copyright (C) 1992-2004, 2006-2012 Free Software Foundation, Inc.
Contributed by Cygnus Support, using pieces from other GDB modules.
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
TYPE_FLAG_VECTOR = (1 << 15),
TYPE_FLAG_FIXED_INSTANCE = (1 << 16),
TYPE_FLAG_STUB_SUPPORTED = (1 << 17),
+ TYPE_FLAG_GNU_IFUNC = (1 << 18),
/* Used for error-checking. */
TYPE_FLAG_MIN = TYPE_FLAG_UNSIGNED
};
/* 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)
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)
(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)
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)
#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
owned by an architecture; TYPE_OBJFILE is NULL in this case. */
#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)
/* Instruction-space delimited type. This is for Harvard architectures
which have separate instruction and data address spaces (and perhaps
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_PHYSNAME, /* physname */
+ FIELD_LOC_KIND_DWARF_BLOCK /* dwarf_block */
};
/* A discriminant to determine which field in the main_type.type_specific
TYPE_SPECIFIC_CPLUS_STUFF,
TYPE_SPECIFIC_GNAT_STUFF,
TYPE_SPECIFIC_FLOATFORMAT,
- TYPE_SPECIFIC_CALLING_CONVENTION
+ TYPE_SPECIFIC_FUNC
};
/* This structure is space-critical.
struct main_type
{
- /* Code for kind of type */
+ /* Code for kind of type. */
ENUM_BITFIELD(type_code) code : 8;
unsigned int flag_varargs : 1;
unsigned int flag_vector : 1;
unsigned int flag_stub_supported : 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;
/* 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.
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
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
{
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.
- For a range bound or enum value, this is the value itself. */
+ 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;
+ /* 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. */
+ Otherwise, physname is the mangled label of the static field. */
CORE_ADDR physaddr;
- char *physname;
+ const char *physname;
+
+ /* 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;
unsigned int artificial : 1;
/* Discriminant for union field_location. */
- ENUM_BITFIELD(field_loc_kind) loc_kind : 2;
+ ENUM_BITFIELD(field_loc_kind) loc_kind : 3;
/* Size of this field, in bits, or zero if not packed.
If non-zero in an array type, indicates the element size in
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.
NULL for range bounds, array domains, and member function
arguments. */
- char *name;
+ const char *name;
} *fields;
- /* Union member used for range types. */
+ /* Union member used for range types. */
struct range_bounds
{
- /* Low bound of range. */
+ /* Low bound of range. */
LONGEST low;
- /* High bound of range. */
+ /* High bound of range. */
LONGEST high;
{
/* 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;
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;
};
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
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. */
-
- short nfn_fields_total;
-
/* Number of template arguments. */
unsigned short n_template_arguments;
dynamic. Zero if not yet computed. */
int is_dynamic : 2;
- /* 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.
+ /* Non-zero if this type came from a Java CU. */
+ unsigned int is_java : 1;
+
+ /* 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{};
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;
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. */
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;
*fn_fieldlists;
/* Pointer to information about enclosing scope, if this is a
- * local type. If it is not a local type, this is NULL
- */
+ local type. If it is not a local type, this is NULL. */
struct local_type_info
{
char *file;
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 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;
+ };
+
+/* 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
+ {
+ /* DW_TAG_formal_parameter's DW_AT_location's DW_OP_regX as DWARF
+ register number, for register passed parameters. If -1 then use
+ fb_offset. */
+ int dwarf_reg;
+
+ /* Offset from the callee's frame base, for stack passed parameters.
+ This equals offset from the caller's stack pointer. Valid only if
+ DWARF_REGNUM is -1. */
+ CORE_ADDR fb_offset;
+
+ /* 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;
#define INIT_CPLUS_SPECIFIC(type) \
(TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_CPLUS_STUFF, \
- TYPE_RAW_CPLUS_SPECIFIC (type) = (struct cplus_struct_type*) &cplus_struct_default)
+ 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_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
#define TYPE_NAME(thistype) TYPE_MAIN_TYPE(thistype)->name
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)->flds_bnds.fields
#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_HIGH_BOUND_UNDEFINED(TYPE_INDEX_TYPE(arraytype))
#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_SPECIFIC_FIELD(thistype) \
TYPE_MAIN_TYPE(thistype)->type_specific_field
#define TYPE_TYPE_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific
#define TYPE_FLOATFORMAT(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.floatformat
#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.calling_convention
+#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_FIELD_NAME(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 \
#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))
#define SET_FIELD_PHYSADDR(thisfld, addr) \
(FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_PHYSADDR, \
FIELD_STATIC_PHYSADDR (thisfld) = (addr))
+#define SET_FIELD_DWARF_BLOCK(thisfld, addr) \
+ (FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_DWARF_BLOCK, \
+ FIELD_DWARF_BLOCK (thisfld) = (addr))
#define FIELD_ARTIFICIAL(thisfld) ((thisfld).artificial)
#define FIELD_BITSIZE(thisfld) ((thisfld).bitsize)
#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_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)))
+#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) : _("<unnamed 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. */
{
/* 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;
(*) () 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. */
/* 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;
/* 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) \
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 const char *type_name_no_tag_or_error (struct type *type);
extern struct type *lookup_struct_elt_type (struct type *, char *, int);
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 struct type *check_typedef (struct type *);
extern char *gdb_mangle_name (struct type *, int, int);
extern struct type *lookup_typename (const struct language_defn *,
- struct gdbarch *, char *,
+ struct gdbarch *, const char *,
const struct block *, int);
extern struct type *lookup_template_type (char *, 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 *);
#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 of pointer to boolean. */
+extern const struct rank BOOL_PTR_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;
+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);
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);
projects / deliverable / binutils-gdb.git / blobdiff