diff options
| -rw-r--r-- | gdb/ChangeLog | 31 | ||||
| -rw-r--r-- | gdb/ax-gdb.c | 52 | ||||
| -rw-r--r-- | gdb/c-typeprint.c | 10 | ||||
| -rw-r--r-- | gdb/d10v-tdep.c | 4 | ||||
| -rw-r--r-- | gdb/dstread.c | 19 | ||||
| -rw-r--r-- | gdb/expprint.c | 2 | ||||
| -rw-r--r-- | gdb/gdbtypes.c | 12 | ||||
| -rw-r--r-- | gdb/gdbtypes.h | 26 | ||||
| -rw-r--r-- | gdb/hpread.c | 51 | ||||
| -rw-r--r-- | gdb/mdebugread.c | 4 | ||||
| -rw-r--r-- | gdb/p-lang.c | 4 | ||||
| -rw-r--r-- | gdb/valops.c | 2 | ||||
| -rw-r--r-- | gdb/x86-64-tdep.c | 14 |
13 files changed, 128 insertions, 103 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 6ec785baa3e..98247ae67fe 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,34 @@ +2002-05-13 Daniel Jacobowitz <drow@mvista.com> + + * ax-gdb.c (gen_sign_extend, gen_fetch, gen_usual_unary) + (gen_cast, gen_scale, gen_add, gen_sub, gen_binop, gen_deref) + (gen_address_of, gen_struct_ref, gen_repeat): Use type + access macros. + * c-typeprint.c (cp_type_print_method_args): Likewise. + (c_type_print_args): Likewise. + * d10v-tdep.c (d10v_push_arguments): Likewise. + (d10v_extract_return_value): Likewise. + * expprint.c (print_subexp): Likewise. + * gdbtypes.c (lookup_primitive_typename): Likewise. + (lookup_template_type, add_mangled_type, print_arg_types): Likewise. + * gdbtypes.h (TYPE_UNSIGNED, TYPE_NOSIGN, TYPE_STUB) + (TYPE_TARGET_STUB, TYPE_STATIC, TYPE_CONST, TYPE_VOLATILE) + (TYPE_PROTOTYPED, TYPE_INCOMPLETE, TYPE_CODE_SPACE, TYPE_VARARGS) + (TYPE_VECTOR): Likewise. + * hpread.c (hpread_read_struct_type) + (fix_static_member_physnames, fixup_class_method_type) + (hpread_type_lookup): Likewise. + * mdebugread.c (parse_symbol, parse_type): Likewise. + * p-lang.c (is_pascal_string_type): Likewise. + * valops.c (hand_function_call): Likewise. + * x86-64-tdep.c (classify_argument): Likewise. + + * hpread.c (hpread_read_function_type) + (hpread_read_doc_function_type): Call replace_type. + * dstread.c (create_new_type): Delete. + (decode_dst_structure, process_dst_function): Call alloc_type. + Use type access macros. + 2002-05-12 Mark Kettenis <kettenis@gnu.org> * i387-tdep.c (i387_supply_fxsave): Skip the SSE registers if diff --git a/gdb/ax-gdb.c b/gdb/ax-gdb.c index aa9f92a9610..368b9df12a1 100644 --- a/gdb/ax-gdb.c +++ b/gdb/ax-gdb.c @@ -353,7 +353,7 @@ gen_sign_extend (struct agent_expr *ax, struct type *type) { /* Do we need to sign-extend this? */ if (!TYPE_UNSIGNED (type)) - ax_ext (ax, type->length * TARGET_CHAR_BIT); + ax_ext (ax, TYPE_LENGTH (type) * TARGET_CHAR_BIT); } @@ -363,7 +363,7 @@ gen_sign_extend (struct agent_expr *ax, struct type *type) static void gen_extend (struct agent_expr *ax, struct type *type) { - int bits = type->length * TARGET_CHAR_BIT; + int bits = TYPE_LENGTH (type) * TARGET_CHAR_BIT; /* I just had to. */ ((TYPE_UNSIGNED (type) ? ax_zero_ext : ax_ext) (ax, bits)); } @@ -381,7 +381,7 @@ gen_fetch (struct agent_expr *ax, struct type *type) ax_trace_quick (ax, TYPE_LENGTH (type)); } - switch (type->code) + switch (TYPE_CODE (type)) { case TYPE_CODE_PTR: case TYPE_CODE_ENUM: @@ -389,7 +389,7 @@ gen_fetch (struct agent_expr *ax, struct type *type) case TYPE_CODE_CHAR: /* It's a scalar value, so we know how to dereference it. How many bytes long is it? */ - switch (type->length) + switch (TYPE_LENGTH (type)) { case 8 / TARGET_CHAR_BIT: ax_simple (ax, aop_ref8); @@ -699,7 +699,7 @@ gen_usual_unary (struct agent_expr *ax, struct axs_value *value) the stack. Should we tweak the type? */ /* Some types require special handling. */ - switch (value->type->code) + switch (TYPE_CODE (value->type)) { /* Functions get converted to a pointer to the function. */ case TYPE_CODE_FUNC: @@ -874,7 +874,7 @@ gen_cast (struct agent_expr *ax, struct axs_value *value, struct type *type) /* Dereference typedefs. */ type = check_typedef (type); - switch (type->code) + switch (TYPE_CODE (type)) { case TYPE_CODE_PTR: /* It's implementation-defined, and I'll bet this is what GCC @@ -925,9 +925,9 @@ gen_scale (struct agent_expr *ax, enum agent_op op, struct type *type) { struct type *element = TYPE_TARGET_TYPE (type); - if (element->length != 1) + if (TYPE_LENGTH (element) != 1) { - ax_const_l (ax, element->length); + ax_const_l (ax, TYPE_LENGTH (element)); ax_simple (ax, op); } } @@ -943,8 +943,8 @@ gen_add (struct agent_expr *ax, struct axs_value *value, struct axs_value *value1, struct axs_value *value2, char *name) { /* Is it INT+PTR? */ - if (value1->type->code == TYPE_CODE_INT - && value2->type->code == TYPE_CODE_PTR) + if (TYPE_CODE (value1->type) == TYPE_CODE_INT + && TYPE_CODE (value2->type) == TYPE_CODE_PTR) { /* Swap the values and proceed normally. */ ax_simple (ax, aop_swap); @@ -955,8 +955,8 @@ gen_add (struct agent_expr *ax, struct axs_value *value, } /* Is it PTR+INT? */ - else if (value1->type->code == TYPE_CODE_PTR - && value2->type->code == TYPE_CODE_INT) + else if (TYPE_CODE (value1->type) == TYPE_CODE_PTR + && TYPE_CODE (value2->type) == TYPE_CODE_INT) { gen_scale (ax, aop_mul, value1->type); ax_simple (ax, aop_add); @@ -966,8 +966,8 @@ gen_add (struct agent_expr *ax, struct axs_value *value, /* Must be number + number; the usual binary conversions will have brought them both to the same width. */ - else if (value1->type->code == TYPE_CODE_INT - && value2->type->code == TYPE_CODE_INT) + else if (TYPE_CODE (value1->type) == TYPE_CODE_INT + && TYPE_CODE (value2->type) == TYPE_CODE_INT) { ax_simple (ax, aop_add); gen_extend (ax, value1->type); /* Catch overflow. */ @@ -989,10 +989,10 @@ static void gen_sub (struct agent_expr *ax, struct axs_value *value, struct axs_value *value1, struct axs_value *value2) { - if (value1->type->code == TYPE_CODE_PTR) + if (TYPE_CODE (value1->type) == TYPE_CODE_PTR) { /* Is it PTR - INT? */ - if (value2->type->code == TYPE_CODE_INT) + if (TYPE_CODE (value2->type) == TYPE_CODE_INT) { gen_scale (ax, aop_mul, value1->type); ax_simple (ax, aop_sub); @@ -1003,7 +1003,7 @@ gen_sub (struct agent_expr *ax, struct axs_value *value, /* Is it PTR - PTR? Strictly speaking, the types ought to match, but this is what the normal GDB expression evaluator tests for. */ - else if (value2->type->code == TYPE_CODE_PTR + else if (TYPE_CODE (value2->type) == TYPE_CODE_PTR && (TYPE_LENGTH (TYPE_TARGET_TYPE (value1->type)) == TYPE_LENGTH (TYPE_TARGET_TYPE (value2->type)))) { @@ -1018,8 +1018,8 @@ an integer nor a pointer of the same type."); } /* Must be number + number. */ - else if (value1->type->code == TYPE_CODE_INT - && value2->type->code == TYPE_CODE_INT) + else if (TYPE_CODE (value1->type) == TYPE_CODE_INT + && TYPE_CODE (value2->type) == TYPE_CODE_INT) { ax_simple (ax, aop_sub); gen_extend (ax, value1->type); /* Catch overflow. */ @@ -1044,8 +1044,8 @@ gen_binop (struct agent_expr *ax, struct axs_value *value, enum agent_op op_unsigned, int may_carry, char *name) { /* We only handle INT op INT. */ - if ((value1->type->code != TYPE_CODE_INT) - || (value2->type->code != TYPE_CODE_INT)) + if ((TYPE_CODE (value1->type) != TYPE_CODE_INT) + || (TYPE_CODE (value2->type) != TYPE_CODE_INT)) error ("Illegal combination of types in %s.", name); ax_simple (ax, @@ -1092,7 +1092,7 @@ gen_deref (struct agent_expr *ax, struct axs_value *value) { /* The caller should check the type, because several operators use this, and we don't know what error message to generate. */ - if (value->type->code != TYPE_CODE_PTR) + if (TYPE_CODE (value->type) != TYPE_CODE_PTR) internal_error (__FILE__, __LINE__, "gen_deref: expected a pointer"); @@ -1102,7 +1102,7 @@ gen_deref (struct agent_expr *ax, struct axs_value *value) T" to "T", and mark the value as an lvalue in memory. Leave it to the consumer to actually dereference it. */ value->type = check_typedef (TYPE_TARGET_TYPE (value->type)); - value->kind = ((value->type->code == TYPE_CODE_FUNC) + value->kind = ((TYPE_CODE (value->type) == TYPE_CODE_FUNC) ? axs_rvalue : axs_lvalue_memory); } @@ -1114,7 +1114,7 @@ gen_address_of (struct agent_expr *ax, struct axs_value *value) /* Special case for taking the address of a function. The ANSI standard describes this as a special case, too, so this arrangement is not without motivation. */ - if (value->type->code == TYPE_CODE_FUNC) + if (TYPE_CODE (value->type) == TYPE_CODE_FUNC) /* The value's already an rvalue on the stack, so we just need to change the type. */ value->type = lookup_pointer_type (value->type); @@ -1346,7 +1346,7 @@ gen_struct_ref (struct agent_expr *ax, struct axs_value *value, char *field, /* Follow pointers until we reach a non-pointer. These aren't the C semantics, but they're what the normal GDB evaluator does, so we should at least be consistent. */ - while (value->type->code == TYPE_CODE_PTR) + while (TYPE_CODE (value->type) == TYPE_CODE_PTR) { gen_usual_unary (ax, value); gen_deref (ax, value); @@ -1410,7 +1410,7 @@ gen_repeat (union exp_element **pc, struct agent_expr *ax, if (!v) error ("Right operand of `@' must be a constant, in agent expressions."); - if (v->type->code != TYPE_CODE_INT) + if (TYPE_CODE (v->type) != TYPE_CODE_INT) error ("Right operand of `@' must be an integer."); length = value_as_long (v); if (length <= 0) diff --git a/gdb/c-typeprint.c b/gdb/c-typeprint.c index 0c460e9dd5f..8436bcadfd2 100644 --- a/gdb/c-typeprint.c +++ b/gdb/c-typeprint.c @@ -158,7 +158,7 @@ cp_type_print_method_args (struct type **args, char *prefix, char *varstring, fprintf_symbol_filtered (stream, prefix, language_cplus, DMGL_ANSI); fprintf_symbol_filtered (stream, varstring, language_cplus, DMGL_ANSI); fputs_filtered ("(", stream); - if (args && args[!staticp] && args[!staticp]->code != TYPE_CODE_VOID) + if (args && args[!staticp] && TYPE_CODE (args[!staticp]) != TYPE_CODE_VOID) { i = !staticp; /* skip the class variable */ while (1) @@ -169,7 +169,7 @@ cp_type_print_method_args (struct type **args, char *prefix, char *varstring, fprintf_filtered (stream, " ..."); break; } - else if (args[i]->code != TYPE_CODE_VOID) + else if (TYPE_CODE (args[i]) != TYPE_CODE_VOID) { fprintf_filtered (stream, ", "); } @@ -346,7 +346,7 @@ c_type_print_args (struct type *type, struct ui_file *stream) { fprintf_filtered (stream, "..."); } - else if ((args[1]->code == TYPE_CODE_VOID) && + else if ((TYPE_CODE (args[1]) == TYPE_CODE_VOID) && (current_language->la_language == language_cplus)) { fprintf_filtered (stream, "void"); @@ -354,7 +354,7 @@ c_type_print_args (struct type *type, struct ui_file *stream) else { for (i = 1; - args[i] != NULL && args[i]->code != TYPE_CODE_VOID; + args[i] != NULL && TYPE_CODE (args[i]) != TYPE_CODE_VOID; i++) { c_print_type (args[i], "", stream, -1, 0); @@ -362,7 +362,7 @@ c_type_print_args (struct type *type, struct ui_file *stream) { fprintf_filtered (stream, "..."); } - else if (args[i + 1]->code != TYPE_CODE_VOID) + else if (TYPE_CODE (args[i + 1]) != TYPE_CODE_VOID) { fprintf_filtered (stream, ","); wrap_here (" "); diff --git a/gdb/d10v-tdep.c b/gdb/d10v-tdep.c index d5f5b05106f..58600fb92ea 100644 --- a/gdb/d10v-tdep.c +++ b/gdb/d10v-tdep.c @@ -1037,7 +1037,7 @@ d10v_push_arguments (int nargs, struct value **args, CORE_ADDR sp, struct type *type = check_typedef (VALUE_TYPE (arg)); char *contents = VALUE_CONTENTS (arg); int len = TYPE_LENGTH (type); - /* printf ("push: type=%d len=%d\n", type->code, len); */ + /* printf ("push: type=%d len=%d\n", TYPE_CODE (type), len); */ { int aligned_regnum = (regnum + 1) & ~1; if (len <= 2 && regnum <= ARGN_REGNUM) @@ -1091,7 +1091,7 @@ d10v_extract_return_value (struct type *type, char regbuf[REGISTER_BYTES], char *valbuf) { int len; - /* printf("RET: TYPE=%d len=%d r%d=0x%x\n",type->code, TYPE_LENGTH (type), RET1_REGNUM - R0_REGNUM, (int) extract_unsigned_integer (regbuf + REGISTER_BYTE(RET1_REGNUM), REGISTER_RAW_SIZE (RET1_REGNUM))); */ + /* printf("RET: TYPE=%d len=%d r%d=0x%x\n", TYPE_CODE (type), TYPE_LENGTH (type), RET1_REGNUM - R0_REGNUM, (int) extract_unsigned_integer (regbuf + REGISTER_BYTE(RET1_REGNUM), REGISTER_RAW_SIZE (RET1_REGNUM))); */ { len = TYPE_LENGTH (type); if (len == 1) diff --git a/gdb/dstread.c b/gdb/dstread.c index c3a73f064cd..abcce097a27 100644 --- a/gdb/dstread.c +++ b/gdb/dstread.c @@ -705,17 +705,6 @@ dst_sym_addr (dst_sect_ref_t *ref) + ref->sect_offset; } -static struct type * -create_new_type (struct objfile *objfile) -{ - struct type *type; - - type = (struct type *) - obstack_alloc (&objfile->symbol_obstack, sizeof (struct type)); - memset (type, 0, sizeof (struct type)); - return type; -} - static struct symbol * create_new_symbol (struct objfile *objfile, char *name) { @@ -865,7 +854,7 @@ decode_dst_structure (struct objfile *objfile, dst_rec_ptr_t entry, int code, xfree (name); return type; } - type = create_new_type (objfile); + type = alloc_type (objfile); TYPE_NAME (type) = obstack_copy0 (&objfile->symbol_obstack, name, strlen (name)); xfree (name); @@ -1306,10 +1295,10 @@ process_dst_function (struct objfile *objfile, dst_rec_ptr_t entry, char *name, if (!type->function_type) { - ftype = create_new_type (objfile); + ftype = alloc_type (objfile); type->function_type = ftype; - ftype->target_type = type; - ftype->code = TYPE_CODE_FUNC; + TYPE_TARGET_TYPE (ftype) = type; + TYPE_CODE (ftype) = TYPE_CODE_FUNC; } SYMBOL_TYPE (sym) = type->function_type; diff --git a/gdb/expprint.c b/gdb/expprint.c index cb617113971..09e7db69b3a 100644 --- a/gdb/expprint.c +++ b/gdb/expprint.c @@ -334,7 +334,7 @@ print_subexp (register struct expression *exp, register int *pos, (*pos) += 2; if ((int) prec > (int) PREC_PREFIX) fputs_filtered ("(", stream); - if (exp->elts[pc + 1].type->code == TYPE_CODE_FUNC && + if (TYPE_CODE (exp->elts[pc + 1].type) == TYPE_CODE_FUNC && exp->elts[pc + 3].opcode == OP_LONG) { /* We have a minimal symbol fn, probably. It's encoded diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c index 732c92818bf..fff720d4838 100644 --- a/gdb/gdbtypes.c +++ b/gdb/gdbtypes.c @@ -936,7 +936,7 @@ lookup_primitive_typename (char *name) for (p = current_language->la_builtin_type_vector; *p != NULL; p++) { - if (STREQ ((**p)->name, name)) + if (STREQ (TYPE_NAME (**p), name)) { return (**p); } @@ -1081,10 +1081,10 @@ struct type * lookup_template_type (char *name, struct type *type, struct block *block) { struct symbol *sym; - char *nam = (char *) alloca (strlen (name) + strlen (type->name) + 4); + char *nam = (char *) alloca (strlen (name) + strlen (TYPE_NAME (type)) + 4); strcpy (nam, name); strcat (nam, "<"); - strcat (nam, type->name); + strcat (nam, TYPE_NAME (type)); strcat (nam, " >"); /* FIXME, extra space still introduced in gcc? */ sym = lookup_symbol (nam, block, VAR_NAMESPACE, 0, (struct symtab **) NULL); @@ -1511,8 +1511,8 @@ add_mangled_type (struct extra *pextras, struct type *t) complain (&msg, tcode); } } - if (t->target_type) - add_mangled_type (pextras, t->target_type); + if (TYPE_TARGET_TYPE (t)) + add_mangled_type (pextras, TYPE_TARGET_TYPE (t)); } #if 0 @@ -2713,7 +2713,7 @@ print_arg_types (struct type **args, int spaces) while (*args != NULL) { recursive_dump_type (*args, spaces + 2); - if ((*args++)->code == TYPE_CODE_VOID) + if (TYPE_CODE (*args++) == TYPE_CODE_VOID) { break; } diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h index 0411aaacb62..914d4781126 100644 --- a/gdb/gdbtypes.h +++ b/gdb/gdbtypes.h @@ -148,21 +148,21 @@ enum type_code type is signed (unless TYPE_FLAG_NOSIGN (below) is set). */ #define TYPE_FLAG_UNSIGNED (1 << 0) -#define TYPE_UNSIGNED(t) ((t)->flags & TYPE_FLAG_UNSIGNED) +#define TYPE_UNSIGNED(t) (TYPE_FLAGS (t) & TYPE_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! */ #define TYPE_FLAG_NOSIGN (1 << 1) -#define TYPE_NOSIGN(t) ((t)->flags & TYPE_FLAG_NOSIGN) +#define TYPE_NOSIGN(t) (TYPE_FLAGS (t) & TYPE_FLAG_NOSIGN) /* This appears in a type's flags word if it is a stub type (e.g., if someone referenced a type that wasn't defined in a source file via (struct sir_not_appearing_in_this_film *)). */ #define TYPE_FLAG_STUB (1 << 2) -#define TYPE_STUB(t) ((t)->flags & TYPE_FLAG_STUB) +#define TYPE_STUB(t) (TYPE_FLAGS (t) & TYPE_FLAG_STUB) /* The target type of this type is a stub type, and this type needs to be updated if it gets un-stubbed in check_typedef. @@ -171,7 +171,7 @@ enum type_code Also, set for TYPE_CODE_TYPEDEF. */ #define TYPE_FLAG_TARGET_STUB (1 << 3) -#define TYPE_TARGET_STUB(t) ((t)->flags & TYPE_FLAG_TARGET_STUB) +#define TYPE_TARGET_STUB(t) (TYPE_FLAGS (t) & TYPE_FLAG_TARGET_STUB) /* Static type. If this is set, the corresponding type had * a static modifier. @@ -180,21 +180,21 @@ enum type_code */ #define TYPE_FLAG_STATIC (1 << 4) -#define TYPE_STATIC(t) ((t)->flags & TYPE_FLAG_STATIC) +#define TYPE_STATIC(t) (TYPE_FLAGS (t) & TYPE_FLAG_STATIC) /* Constant type. If this is set, the corresponding type has a * const modifier. */ #define TYPE_FLAG_CONST (1 << 5) -#define TYPE_CONST(t) ((t)->flags & TYPE_FLAG_CONST) +#define TYPE_CONST(t) (TYPE_FLAGS (t) & TYPE_FLAG_CONST) /* Volatile type. If this is set, the corresponding type has a * volatile modifier. */ #define TYPE_FLAG_VOLATILE (1 << 6) -#define TYPE_VOLATILE(t) ((t)->flags & TYPE_FLAG_VOLATILE) +#define TYPE_VOLATILE(t) (TYPE_FLAGS (t) & TYPE_FLAG_VOLATILE) /* This is a function type which appears to have a prototype. We need this @@ -202,7 +202,7 @@ enum type_code or to just do the standard conversions. This is used with a short field. */ #define TYPE_FLAG_PROTOTYPED (1 << 7) -#define TYPE_PROTOTYPED(t) ((t)->flags & TYPE_FLAG_PROTOTYPED) +#define TYPE_PROTOTYPED(t) (TYPE_FLAGS (t) & TYPE_FLAG_PROTOTYPED) /* This flag is used to indicate that processing for this type is incomplete. @@ -213,7 +213,7 @@ enum type_code the method can be assigned correct types.) */ #define TYPE_FLAG_INCOMPLETE (1 << 8) -#define TYPE_INCOMPLETE(t) ((t)->flags & TYPE_FLAG_INCOMPLETE) +#define TYPE_INCOMPLETE(t) (TYPE_FLAGS (t) & TYPE_FLAG_INCOMPLETE) /* Instruction-space delimited type. This is for Harvard architectures which have separate instruction and data address spaces (and perhaps @@ -235,10 +235,10 @@ enum type_code is instruction space, and for data objects is data memory. */ #define TYPE_FLAG_CODE_SPACE (1 << 9) -#define TYPE_CODE_SPACE(t) ((t)->flags & TYPE_FLAG_CODE_SPACE) +#define TYPE_CODE_SPACE(t) (TYPE_FLAGS (t) & TYPE_FLAG_CODE_SPACE) #define TYPE_FLAG_DATA_SPACE (1 << 10) -#define TYPE_DATA_SPACE(t) ((t)->flags & TYPE_FLAG_DATA_SPACE) +#define TYPE_DATA_SPACE(t) (TYPE_FLAGS (t) & TYPE_FLAG_DATA_SPACE) /* FIXME: Kludge to mark a varargs function type for C++ member function argument processing. Currently only used in dwarf2read.c, @@ -246,13 +246,13 @@ enum type_code another flag. */ #define TYPE_FLAG_VARARGS (1 << 11) -#define TYPE_VARARGS(t) ((t)->flags & TYPE_FLAG_VARARGS) +#define TYPE_VARARGS(t) (TYPE_FLAGS (t) & TYPE_FLAG_VARARGS) /* Identify a vector type. Gcc is handling this by adding an extra attribute to the array type. We slurp that in as a new flag of a type. This is used only in dwarf2read.c. */ #define TYPE_FLAG_VECTOR (1 << 12) -#define TYPE_VECTOR(t) ((t)->flags & TYPE_FLAG_VECTOR) +#define TYPE_VECTOR(t) (TYPE_FLAGS (t) & TYPE_FLAG_VECTOR) struct type diff --git a/gdb/hpread.c b/gdb/hpread.c index ca153f9ca46..fe3d3438d5f 100644 --- a/gdb/hpread.c +++ b/gdb/hpread.c @@ -3230,7 +3230,7 @@ hpread_read_function_type (dnttpointer hp_type, union dnttentry *dn_bufp, else /* expect DNTT_TYPE_FUNC_TEMPLATE */ type1 = lookup_function_type (hpread_type_lookup (dn_bufp->dfunc_template.retval, objfile)); - memcpy ((char *) type, (char *) type1, sizeof (struct type)); + replace_type (type, type1); /* Mark it -- in the middle of processing */ TYPE_FLAGS (type) |= TYPE_FLAG_INCOMPLETE; @@ -3407,7 +3407,7 @@ hpread_read_doc_function_type (dnttpointer hp_type, union dnttentry *dn_bufp, dn_bufp->dblock.kind == DNTT_TYPE_DOC_MEMFUNC) type1 = lookup_function_type (hpread_type_lookup (dn_bufp->ddocfunc.retval, objfile)); - memcpy ((char *) type, (char *) type1, sizeof (struct type)); + replace_type (type, type1); /* Mark it -- in the middle of processing */ TYPE_FLAGS (type) |= TYPE_FLAG_INCOMPLETE; @@ -3968,23 +3968,28 @@ hpread_read_struct_type (dnttpointer hp_type, union dnttentry *dn_bufp, fn_p->field.fn_fields[ix].type = memtype; /* The argument list */ - fn_p->field.fn_fields[ix].type->type_specific.arg_types = - (struct type **) obstack_alloc (&objfile->type_obstack, - sizeof (struct type *) * (memtype->nfields + 1)); - for (i = 0; i < memtype->nfields; i++) - fn_p->field.fn_fields[ix].type->type_specific.arg_types[i] = memtype->fields[i].type; + TYPE_TYPE_SPECIFIC (fn_p->field.fn_fields[ix].type).arg_types + = (struct type **) obstack_alloc (&objfile->type_obstack, + (sizeof (struct type *) + * (TYPE_NFIELDS (memtype) + + 1))); + for (i = 0; i < TYPE_NFIELDS (memtype); i++) + TYPE_TYPE_SPECIFIC (fn_p->field.fn_fields[ix].type) + .arg_types[i] = TYPE_FIELDS (memtype)[i].type; /* void termination */ - fn_p->field.fn_fields[ix].type->type_specific.arg_types[memtype->nfields] = builtin_type_void; + TYPE_TYPE_SPECIFIC (fn_p->field.fn_fields[ix].type) + .arg_types[TYPE_NFIELDS (memtype)] = builtin_type_void; /* pai: It's not clear why this args field has to be set. Perhaps * it should be eliminated entirely. */ fn_p->field.fn_fields[ix].args = (struct type **) obstack_alloc (&objfile->type_obstack, - sizeof (struct type *) * (memtype->nfields + 1)); - for (i = 0; i < memtype->nfields; i++) - fn_p->field.fn_fields[ix].args[i] = memtype->fields[i].type; + sizeof (struct type *) * (TYPE_NFIELDS (memtype) + 1)); + for (i = 0; i < TYPE_NFIELDS (memtype); i++) + fn_p->field.fn_fields[ix].args[i] + = TYPE_FIELDS (memtype)[i].type; /* null-terminated, unlike arg_types above e */ - fn_p->field.fn_fields[ix].args[memtype->nfields] = NULL; + fn_p->field.fn_fields[ix].args[TYPE_NFIELDS (memtype)] = NULL; } /* For virtual functions, fill in the voffset field with the * virtual table offset. (This is just copied over from the @@ -4428,7 +4433,7 @@ fix_static_member_physnames (struct type *type, char *class_name, if (TYPE_FIELD_STATIC_PHYSNAME (type, i)) return; /* physnames are already set */ - SET_FIELD_PHYSNAME (type->fields[i], + SET_FIELD_PHYSNAME (TYPE_FIELDS (type)[i], obstack_alloc (&objfile->type_obstack, strlen (class_name) + strlen (TYPE_FIELD_NAME (type, i)) + 3)); strcpy (TYPE_FIELD_STATIC_PHYSNAME (type, i), class_name); @@ -4465,23 +4470,23 @@ fixup_class_method_type (struct type *class, struct type *method, /* Set the method type */ TYPE_FN_FIELD_TYPE (TYPE_FN_FIELDLIST1 (class, i), j) = method; /* The argument list */ - (TYPE_FN_FIELD_TYPE (TYPE_FN_FIELDLIST1 (class, i), j))->type_specific.arg_types + TYPE_TYPE_SPECIFIC (TYPE_FN_FIELD_TYPE (TYPE_FN_FIELDLIST1 (class, i), j)).arg_types = (struct type **) obstack_alloc (&objfile->type_obstack, - sizeof (struct type *) * (method->nfields + 1)); - for (k = 0; k < method->nfields; k++) - (TYPE_FN_FIELD_TYPE (TYPE_FN_FIELDLIST1 (class, i), j))->type_specific.arg_types[k] = method->fields[k].type; + sizeof (struct type *) * (TYPE_NFIELDS (method) + 1)); + for (k = 0; k < TYPE_NFIELDS (method); k++) + TYPE_TYPE_SPECIFIC (TYPE_FN_FIELD_TYPE (TYPE_FN_FIELDLIST1 (class, i), j)).arg_types[k] = TYPE_FIELDS (method)[k].type; /* void termination */ - (TYPE_FN_FIELD_TYPE (TYPE_FN_FIELDLIST1 (class, i), j))->type_specific.arg_types[method->nfields] = builtin_type_void; + TYPE_TYPE_SPECIFIC (TYPE_FN_FIELD_TYPE (TYPE_FN_FIELDLIST1 (class, i), j)).arg_types[TYPE_NFIELDS (method)] = builtin_type_void; /* pai: It's not clear why this args field has to be set. Perhaps * it should be eliminated entirely. */ (TYPE_FN_FIELD (TYPE_FN_FIELDLIST1 (class, i), j)).args = (struct type **) obstack_alloc (&objfile->type_obstack, - sizeof (struct type *) * (method->nfields + 1)); - for (k = 0; k < method->nfields; k++) - (TYPE_FN_FIELD (TYPE_FN_FIELDLIST1 (class, i), j)).args[k] = method->fields[k].type; + sizeof (struct type *) * (TYPE_NFIELDS (method) + 1)); + for (k = 0; k < TYPE_NFIELDS (method); k++) + (TYPE_FN_FIELD (TYPE_FN_FIELDLIST1 (class, i), j)).args[k] = TYPE_FIELDS (method)[k].type; /* null-terminated, unlike arg_types above */ - (TYPE_FN_FIELD (TYPE_FN_FIELDLIST1 (class, i), j)).args[method->nfields] = NULL; + (TYPE_FN_FIELD (TYPE_FN_FIELDLIST1 (class, i), j)).args[TYPE_NFIELDS (method)] = NULL; /* Break out of both loops -- only one method to fix up in a class */ goto finish; @@ -4850,7 +4855,7 @@ hpread_type_lookup (dnttpointer hp_type, struct objfile *objfile) } /* Build the correct name. */ - structtype->name + TYPE_NAME (structtype) = (char *) obstack_alloc (&objfile->type_obstack, strlen (prefix) + strlen (suffix) + 1); TYPE_NAME (structtype) = strcpy (TYPE_NAME (structtype), prefix); diff --git a/gdb/mdebugread.c b/gdb/mdebugread.c index c974c9e874a..14d2c0f753e 100644 --- a/gdb/mdebugread.c +++ b/gdb/mdebugread.c @@ -832,7 +832,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, else { t = parse_type (cur_fd, ax, sh->index + 1, 0, bigend, name); - if (STREQ (name, "malloc") && t->code == TYPE_CODE_VOID) + if (STREQ (name, "malloc") && TYPE_CODE (t) == TYPE_CODE_VOID) { /* I don't know why, but, at least under Alpha GNU/Linux, when linking against a malloc without debugging @@ -1604,7 +1604,7 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs, dereference them. */ while (TYPE_CODE (tp) == TYPE_CODE_PTR || TYPE_CODE (tp) == TYPE_CODE_ARRAY) - tp = tp->target_type; + tp = TYPE_TARGET_TYPE (tp); /* Make sure that TYPE_CODE(tp) has an expected type code. Any type may be returned from cross_ref if file indirect entries diff --git a/gdb/p-lang.c b/gdb/p-lang.c index 4796da5f17b..8e13b6e860a 100644 --- a/gdb/p-lang.c +++ b/gdb/p-lang.c @@ -58,7 +58,7 @@ is_pascal_string_type (struct type *type,int *length_pos, if (length_pos) *length_pos = TYPE_FIELD_BITPOS (type, 0) / TARGET_CHAR_BIT; if (length_size) - *length_size = TYPE_FIELD_TYPE (type, 0)->length; + *length_size = TYPE_LENGTH (TYPE_FIELD_TYPE (type, 0)); if (string_pos) *string_pos = TYPE_FIELD_BITPOS (type, 1) / TARGET_CHAR_BIT; if (char_size) @@ -76,7 +76,7 @@ is_pascal_string_type (struct type *type,int *length_pos, if (length_pos) *length_pos = TYPE_FIELD_BITPOS (type, 1) / TARGET_CHAR_BIT; if (length_size) - *length_size = TYPE_FIELD_TYPE (type, 1)->length; + *length_size = TYPE_LENGTH (TYPE_FIELD_TYPE (type, 1)); if (string_pos) *string_pos = TYPE_FIELD_BITPOS (type, 2) / TARGET_CHAR_BIT; /* FIXME: how can I detect wide chars in GPC ?? */ diff --git a/gdb/valops.c b/gdb/valops.c index cd5d4ca87f8..798e31fc646 100644 --- a/gdb/valops.c +++ b/gdb/valops.c @@ -1488,7 +1488,7 @@ hand_function_call (struct value *function, int nargs, struct value **args) if (param_type) /* if this parameter is a pointer to function */ if (TYPE_CODE (param_type) == TYPE_CODE_PTR) - if (TYPE_CODE (param_type->target_type) == TYPE_CODE_FUNC) + if (TYPE_CODE (TYPE_TARGET_TYPE (param_type)) == TYPE_CODE_FUNC) /* elz: FIXME here should go the test about the compiler used to compile the target. We want to issue the error message only if the compiler used was HP's aCC. diff --git a/gdb/x86-64-tdep.c b/gdb/x86-64-tdep.c index 70a5d9cbb0f..94f57a5a539 100644 --- a/gdb/x86-64-tdep.c +++ b/gdb/x86-64-tdep.c @@ -372,18 +372,18 @@ classify_argument (struct type *type, case TYPE_CODE_STRUCT: { int j; - for (j = 0; j < type->nfields; ++j) + for (j = 0; j < TYPE_NFIELDS (type); ++j) { - int num = classify_argument (type->fields[j].type, + int num = classify_argument (TYPE_FIELDS (type)[j].type, subclasses, - (type->fields[j].loc.bitpos + (TYPE_FIELDS (type)[j].loc.bitpos + bit_offset) % 256); if (!num) return 0; for (i = 0; i < num; i++) { int pos = - (type->fields[j].loc.bitpos + bit_offset) / 8 / 8; + (TYPE_FIELDS (type)[j].loc.bitpos + bit_offset) / 8 / 8; classes[i + pos] = merge_classes (subclasses[i], classes[i + pos]); } @@ -394,7 +394,7 @@ classify_argument (struct type *type, { int num; - num = classify_argument (type->target_type, + num = classify_argument (TYPE_TARGET_TYPE (type), subclasses, bit_offset); if (!num) return 0; @@ -413,10 +413,10 @@ classify_argument (struct type *type, { int j; { - for (j = 0; j < type->nfields; ++j) + for (j = 0; j < TYPE_NFIELDS (type); ++j) { int num; - num = classify_argument (type->fields[j].type, + num = classify_argument (TYPE_FIELDS (type)[j].type, subclasses, bit_offset); if (!num) return 0; |