diff options
author | Andrew Cagney <cagney@redhat.com> | 2004-11-12 21:45:08 +0000 |
---|---|---|
committer | Andrew Cagney <cagney@redhat.com> | 2004-11-12 21:45:08 +0000 |
commit | df407dfe2e8452c0a3edfcf50d55942ff0273433 (patch) | |
tree | 11b770a7071b50d36d54f0e817d8c8c4f60ce076 /gdb/valops.c | |
parent | 69e5711542042a5b591907f8f96d28fd8d2c3c17 (diff) | |
download | fsf-binutils-gdb-df407dfe2e8452c0a3edfcf50d55942ff0273433.zip fsf-binutils-gdb-df407dfe2e8452c0a3edfcf50d55942ff0273433.tar.gz fsf-binutils-gdb-df407dfe2e8452c0a3edfcf50d55942ff0273433.tar.bz2 |
2004-11-12 Andrew Cagney <cagney@gnu.org>
* value.h (VALUE_TYPE, VALUE_NEXT, VALUE_OFFSET, VALUE_BITSIZE)
(VALUE_BITPOS): Delete.
(value_type, value_offset, value_bitsize, value_bitpos): Declare.
* value.c (value_type, value_offset, value_bitpos)
(value_bitsize): New functions. Update references.
* arm-tdep.c, gnu-v3-abi.c, hpacc-abi.c, gnu-v2-abi.c: Update.
* f-valprint.c, cp-valprint.c, c-valprint.c: Update.
* ada-valprint.c, typeprint.c, scm-valprint.c, scm-exp.c: Update.
* p-valprint.c, jv-valprint.c, jv-lang.c, varobj.c: Update.
* objc-lang.c, ada-lang.c, std-regs.c, stack.c: Update.
* infcall.c, linespec.c, printcmd.c, valarith.c: Update.
* valops.c, eval.c, findvar.c, breakpoint.c: Update.
* tracepoint.c, ax-gdb.c, mi/mi-main.c, cli/cli-dump.c:
* rs6000-tdep.c, ppc-sysv-tdep.c: Update.
Diffstat (limited to 'gdb/valops.c')
-rw-r--r-- | gdb/valops.c | 142 |
1 files changed, 71 insertions, 71 deletions
diff --git a/gdb/valops.c b/gdb/valops.c index 3e40a6d..a6a54e1 100644 --- a/gdb/valops.c +++ b/gdb/valops.c @@ -207,13 +207,13 @@ value_cast (struct type *type, struct value *arg2) int convert_to_boolean = 0; - if (VALUE_TYPE (arg2) == type) + if (value_type (arg2) == type) return arg2; CHECK_TYPEDEF (type); code1 = TYPE_CODE (type); arg2 = coerce_ref (arg2); - type2 = check_typedef (VALUE_TYPE (arg2)); + type2 = check_typedef (value_type (arg2)); /* A cast to an undetermined-length array_type, such as (TYPE [])OBJECT, is treated like a cast to (TYPE [N])OBJECT, @@ -239,8 +239,8 @@ value_cast (struct type *type, struct value *arg2) TYPE_TARGET_TYPE (range_type), low_bound, new_length + low_bound - 1); - VALUE_TYPE (arg2) = create_array_type ((struct type *) NULL, - element_type, range_type); + arg2->type = create_array_type ((struct type *) NULL, + element_type, range_type); return arg2; } } @@ -252,7 +252,7 @@ value_cast (struct type *type, struct value *arg2) if (TYPE_CODE (type2) == TYPE_CODE_FUNC) arg2 = value_coerce_function (arg2); - type2 = check_typedef (VALUE_TYPE (arg2)); + type2 = check_typedef (value_type (arg2)); code2 = TYPE_CODE (type2); if (code1 == TYPE_CODE_COMPLEX) @@ -281,7 +281,7 @@ value_cast (struct type *type, struct value *arg2) arg2, 0, type2, 1); if (v) { - VALUE_TYPE (v) = type; + v->type = type; return v; } } @@ -379,7 +379,7 @@ value_cast (struct type *type, struct value *arg2) if (v) { v = value_addr (v); - VALUE_TYPE (v) = type; + v->type = type; return v; } } @@ -396,7 +396,7 @@ value_cast (struct type *type, struct value *arg2) { CORE_ADDR addr2 = value_as_address (arg2); addr2 -= (VALUE_ADDRESS (v) - + VALUE_OFFSET (v) + + value_offset (v) + VALUE_EMBEDDED_OFFSET (v)); return value_from_pointer (type, addr2); } @@ -404,13 +404,13 @@ value_cast (struct type *type, struct value *arg2) } /* No superclass found, just fall through to change ptr type. */ } - VALUE_TYPE (arg2) = type; + arg2->type = type; arg2 = value_change_enclosing_type (arg2, type); VALUE_POINTED_TO_OFFSET (arg2) = 0; /* pai: chk_val */ return arg2; } else if (VALUE_LVAL (arg2) == lval_memory) - return value_at_lazy (type, VALUE_ADDRESS (arg2) + VALUE_OFFSET (arg2)); + return value_at_lazy (type, VALUE_ADDRESS (arg2) + value_offset (arg2)); else if (code1 == TYPE_CODE_VOID) { return value_zero (builtin_type_void, not_lval); @@ -499,10 +499,10 @@ value_at_lazy (struct type *type, CORE_ADDR addr) int value_fetch_lazy (struct value *val) { - CORE_ADDR addr = VALUE_ADDRESS (val) + VALUE_OFFSET (val); + CORE_ADDR addr = VALUE_ADDRESS (val) + value_offset (val); int length = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val)); - struct type *type = VALUE_TYPE (val); + struct type *type = value_type (val); if (length) read_memory (addr, VALUE_CONTENTS_ALL_RAW (val), length); @@ -526,7 +526,7 @@ value_assign (struct value *toval, struct value *fromval) toval = coerce_ref (toval); - type = VALUE_TYPE (toval); + type = value_type (toval); if (VALUE_LVAL (toval) != lval_internalvar) fromval = value_cast (type, fromval); else @@ -550,9 +550,9 @@ value_assign (struct value *toval, struct value *fromval) case lval_internalvar_component: set_internalvar_component (VALUE_INTERNALVAR (toval), - VALUE_OFFSET (toval), - VALUE_BITPOS (toval), - VALUE_BITSIZE (toval), + value_offset (toval), + value_bitpos (toval), + value_bitsize (toval), fromval); break; @@ -563,12 +563,12 @@ value_assign (struct value *toval, struct value *fromval) int changed_len; char buffer[sizeof (LONGEST)]; - if (VALUE_BITSIZE (toval)) + if (value_bitsize (toval)) { /* We assume that the argument to read_memory is in units of host chars. FIXME: Is that correct? */ - changed_len = (VALUE_BITPOS (toval) - + VALUE_BITSIZE (toval) + changed_len = (value_bitpos (toval) + + value_bitsize (toval) + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT; @@ -576,16 +576,16 @@ value_assign (struct value *toval, struct value *fromval) error ("Can't handle bitfields which don't fit in a %d bit word.", (int) sizeof (LONGEST) * HOST_CHAR_BIT); - read_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval), + read_memory (VALUE_ADDRESS (toval) + value_offset (toval), buffer, changed_len); modify_field (buffer, value_as_long (fromval), - VALUE_BITPOS (toval), VALUE_BITSIZE (toval)); - changed_addr = VALUE_ADDRESS (toval) + VALUE_OFFSET (toval); + value_bitpos (toval), value_bitsize (toval)); + changed_addr = VALUE_ADDRESS (toval) + value_offset (toval); dest_buffer = buffer; } else { - changed_addr = VALUE_ADDRESS (toval) + VALUE_OFFSET (toval); + changed_addr = VALUE_ADDRESS (toval) + value_offset (toval); changed_len = TYPE_LENGTH (type); dest_buffer = VALUE_CONTENTS (fromval); } @@ -643,14 +643,14 @@ value_assign (struct value *toval, struct value *fromval) { int offset; for (reg_offset = value_reg, offset = 0; - offset + register_size (current_gdbarch, reg_offset) <= VALUE_OFFSET (toval); + offset + register_size (current_gdbarch, reg_offset) <= value_offset (toval); reg_offset++); - byte_offset = VALUE_OFFSET (toval) - offset; + byte_offset = value_offset (toval) - offset; } /* Compute the number of register aligned values that need to be copied. */ - if (VALUE_BITSIZE (toval)) + if (value_bitsize (toval)) amount_to_copy = byte_offset + 1; else amount_to_copy = byte_offset + TYPE_LENGTH (type); @@ -665,10 +665,10 @@ value_assign (struct value *toval, struct value *fromval) frame_register_read (frame, regno, buffer + amount_copied); /* Modify what needs to be modified. */ - if (VALUE_BITSIZE (toval)) + if (value_bitsize (toval)) modify_field (buffer + byte_offset, value_as_long (fromval), - VALUE_BITPOS (toval), VALUE_BITSIZE (toval)); + value_bitpos (toval), value_bitsize (toval)); else memcpy (buffer + byte_offset, VALUE_CONTENTS (fromval), TYPE_LENGTH (type)); @@ -724,11 +724,11 @@ value_assign (struct value *toval, struct value *fromval) /* If the field does not entirely fill a LONGEST, then zero the sign bits. If the field is signed, and is negative, then sign extend. */ - if ((VALUE_BITSIZE (toval) > 0) - && (VALUE_BITSIZE (toval) < 8 * (int) sizeof (LONGEST))) + if ((value_bitsize (toval) > 0) + && (value_bitsize (toval) < 8 * (int) sizeof (LONGEST))) { LONGEST fieldval = value_as_long (fromval); - LONGEST valmask = (((ULONGEST) 1) << VALUE_BITSIZE (toval)) - 1; + LONGEST valmask = (((ULONGEST) 1) << value_bitsize (toval)) - 1; fieldval &= valmask; if (!TYPE_UNSIGNED (type) && (fieldval & (valmask ^ (valmask >> 1)))) @@ -740,7 +740,7 @@ value_assign (struct value *toval, struct value *fromval) val = value_copy (toval); memcpy (VALUE_CONTENTS_RAW (val), VALUE_CONTENTS (fromval), TYPE_LENGTH (type)); - VALUE_TYPE (val) = type; + val->type = type; val = value_change_enclosing_type (val, VALUE_ENCLOSING_TYPE (fromval)); VALUE_EMBEDDED_OFFSET (val) = VALUE_EMBEDDED_OFFSET (fromval); VALUE_POINTED_TO_OFFSET (val) = VALUE_POINTED_TO_OFFSET (fromval); @@ -762,11 +762,11 @@ value_repeat (struct value *arg1, int count) val = allocate_repeat_value (VALUE_ENCLOSING_TYPE (arg1), count); - read_memory (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1), + read_memory (VALUE_ADDRESS (arg1) + value_offset (arg1), VALUE_CONTENTS_ALL_RAW (val), TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val))); VALUE_LVAL (val) = lval_memory; - VALUE_ADDRESS (val) = VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1); + VALUE_ADDRESS (val) = VALUE_ADDRESS (arg1) + value_offset (arg1); return val; } @@ -826,13 +826,13 @@ value_of_variable (struct symbol *var, struct block *b) struct value * value_coerce_array (struct value *arg1) { - struct type *type = check_typedef (VALUE_TYPE (arg1)); + struct type *type = check_typedef (value_type (arg1)); if (VALUE_LVAL (arg1) != lval_memory) error ("Attempt to take address of value not located in memory."); return value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)), - (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1))); + (VALUE_ADDRESS (arg1) + value_offset (arg1))); } /* Given a value which is a function, return a value which is a pointer @@ -846,8 +846,8 @@ value_coerce_function (struct value *arg1) if (VALUE_LVAL (arg1) != lval_memory) error ("Attempt to take address of value not located in memory."); - retval = value_from_pointer (lookup_pointer_type (VALUE_TYPE (arg1)), - (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1))); + retval = value_from_pointer (lookup_pointer_type (value_type (arg1)), + (VALUE_ADDRESS (arg1) + value_offset (arg1))); return retval; } @@ -858,14 +858,14 @@ value_addr (struct value *arg1) { struct value *arg2; - struct type *type = check_typedef (VALUE_TYPE (arg1)); + struct type *type = check_typedef (value_type (arg1)); if (TYPE_CODE (type) == TYPE_CODE_REF) { /* Copy the value, but change the type from (T&) to (T*). We keep the same location information, which is efficient, and allows &(&X) to get the location containing the reference. */ arg2 = value_copy (arg1); - VALUE_TYPE (arg2) = lookup_pointer_type (TYPE_TARGET_TYPE (type)); + arg2->type = lookup_pointer_type (TYPE_TARGET_TYPE (type)); return arg2; } if (TYPE_CODE (type) == TYPE_CODE_FUNC) @@ -875,9 +875,9 @@ value_addr (struct value *arg1) error ("Attempt to take address of value not located in memory."); /* Get target memory address */ - arg2 = value_from_pointer (lookup_pointer_type (VALUE_TYPE (arg1)), + arg2 = value_from_pointer (lookup_pointer_type (value_type (arg1)), (VALUE_ADDRESS (arg1) - + VALUE_OFFSET (arg1) + + value_offset (arg1) + VALUE_EMBEDDED_OFFSET (arg1))); /* This may be a pointer to a base subobject; so remember the @@ -898,7 +898,7 @@ value_ind (struct value *arg1) arg1 = coerce_array (arg1); - base_type = check_typedef (VALUE_TYPE (arg1)); + base_type = check_typedef (value_type (arg1)); if (TYPE_CODE (base_type) == TYPE_CODE_MEMBER) error ("not implemented: member types in value_ind"); @@ -921,7 +921,7 @@ value_ind (struct value *arg1) arg2 = value_at_lazy (enc_type, (value_as_address (arg1) - VALUE_POINTED_TO_OFFSET (arg1))); /* Re-adjust type */ - VALUE_TYPE (arg2) = TYPE_TARGET_TYPE (base_type); + arg2->type = TYPE_TARGET_TYPE (base_type); /* Add embedding info */ arg2 = value_change_enclosing_type (arg2, enc_type); VALUE_EMBEDDED_OFFSET (arg2) = VALUE_POINTED_TO_OFFSET (arg1); @@ -1146,7 +1146,7 @@ typecmp (int staticp, int varargs, int nargs, return i + 1; tt1 = check_typedef (t1[i].type); - tt2 = check_typedef (VALUE_TYPE (t2[i])); + tt2 = check_typedef (value_type (t2[i])); if (TYPE_CODE (tt1) == TYPE_CODE_REF /* We should be doing hairy argument matching, as below. */ @@ -1183,7 +1183,7 @@ typecmp (int staticp, int varargs, int nargs, /* We should be doing much hairier argument matching (see section 13.2 of the ARM), but as a quick kludge, just check for the same type code. */ - if (TYPE_CODE (t1[i].type) != TYPE_CODE (VALUE_TYPE (t2[i]))) + if (TYPE_CODE (t1[i].type) != TYPE_CODE (value_type (t2[i]))) return i + 1; } if (varargs || t2[i] == NULL) @@ -1293,7 +1293,7 @@ search_struct_field (char *name, struct value *arg1, int offset, boffset = baseclass_offset (type, i, VALUE_CONTENTS (arg1) + offset, VALUE_ADDRESS (arg1) - + VALUE_OFFSET (arg1) + offset); + + value_offset (arg1) + offset); if (boffset == -1) error ("virtual baseclass botch"); @@ -1306,7 +1306,7 @@ search_struct_field (char *name, struct value *arg1, int offset, { CORE_ADDR base_addr; - base_addr = VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1) + boffset; + base_addr = VALUE_ADDRESS (arg1) + value_offset (arg1) + boffset; if (target_read_memory (base_addr, VALUE_CONTENTS_RAW (v2), TYPE_LENGTH (basetype)) != 0) error ("virtual baseclass botch"); @@ -1317,7 +1317,7 @@ search_struct_field (char *name, struct value *arg1, int offset, { VALUE_LVAL (v2) = VALUE_LVAL (arg1); VALUE_ADDRESS (v2) = VALUE_ADDRESS (arg1); - VALUE_OFFSET (v2) = VALUE_OFFSET (arg1) + boffset; + v2->offset = value_offset (arg1) + boffset; if (VALUE_LAZY (arg1)) VALUE_LAZY (v2) = 1; else @@ -1529,7 +1529,7 @@ search_struct_method (char *name, struct value **arg1p, { base_valaddr = (char *) alloca (TYPE_LENGTH (baseclass)); if (target_read_memory (VALUE_ADDRESS (*arg1p) - + VALUE_OFFSET (*arg1p) + offset, + + value_offset (*arg1p) + offset, base_valaddr, TYPE_LENGTH (baseclass)) != 0) error ("virtual baseclass botch"); @@ -1540,7 +1540,7 @@ search_struct_method (char *name, struct value **arg1p, base_offset = baseclass_offset (type, i, base_valaddr, VALUE_ADDRESS (*arg1p) - + VALUE_OFFSET (*arg1p) + offset); + + value_offset (*arg1p) + offset); if (base_offset == -1) error ("virtual baseclass botch"); } @@ -1591,7 +1591,7 @@ value_struct_elt (struct value **argp, struct value **args, *argp = coerce_array (*argp); - t = check_typedef (VALUE_TYPE (*argp)); + t = check_typedef (value_type (*argp)); /* Follow pointers until we get to a non-pointer. */ @@ -1599,9 +1599,9 @@ value_struct_elt (struct value **argp, struct value **args, { *argp = value_ind (*argp); /* Don't coerce fn pointer to fn and then back again! */ - if (TYPE_CODE (VALUE_TYPE (*argp)) != TYPE_CODE_FUNC) + if (TYPE_CODE (value_type (*argp)) != TYPE_CODE_FUNC) *argp = coerce_array (*argp); - t = check_typedef (VALUE_TYPE (*argp)); + t = check_typedef (value_type (*argp)); } if (TYPE_CODE (t) == TYPE_CODE_MEMBER) @@ -1753,7 +1753,7 @@ find_method_list (struct value **argp, char *method, int offset, else { /* probably g++ runtime model */ - base_offset = VALUE_OFFSET (*argp) + offset; + base_offset = value_offset (*argp) + offset; base_offset = baseclass_offset (type, i, VALUE_CONTENTS (*argp) + base_offset, @@ -1791,16 +1791,16 @@ value_find_oload_method_list (struct value **argp, char *method, int offset, { struct type *t; - t = check_typedef (VALUE_TYPE (*argp)); + t = check_typedef (value_type (*argp)); /* code snarfed from value_struct_elt */ while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF) { *argp = value_ind (*argp); /* Don't coerce fn pointer to fn and then back again! */ - if (TYPE_CODE (VALUE_TYPE (*argp)) != TYPE_CODE_FUNC) + if (TYPE_CODE (value_type (*argp)) != TYPE_CODE_FUNC) *argp = coerce_array (*argp); - t = check_typedef (VALUE_TYPE (*argp)); + t = check_typedef (value_type (*argp)); } if (TYPE_CODE (t) == TYPE_CODE_MEMBER) @@ -1869,12 +1869,12 @@ find_overload_match (struct type **arg_types, int nargs, char *name, int method, /* Get the list of overloaded methods or functions */ if (method) { - obj_type_name = TYPE_NAME (VALUE_TYPE (obj)); + obj_type_name = TYPE_NAME (value_type (obj)); /* Hack: evaluate_subexp_standard often passes in a pointer value rather than the object itself, so try again */ if ((!obj_type_name || !*obj_type_name) && - (TYPE_CODE (VALUE_TYPE (obj)) == TYPE_CODE_PTR)) - obj_type_name = TYPE_NAME (TYPE_TARGET_TYPE (VALUE_TYPE (obj))); + (TYPE_CODE (value_type (obj)) == TYPE_CODE_PTR)) + obj_type_name = TYPE_NAME (TYPE_TARGET_TYPE (value_type (obj))); fns_ptr = value_find_oload_method_list (&temp, name, 0, &num_fns, @@ -1961,8 +1961,8 @@ find_overload_match (struct type **arg_types, int nargs, char *name, int method, if (objp) { - if (TYPE_CODE (VALUE_TYPE (temp)) != TYPE_CODE_PTR - && TYPE_CODE (VALUE_TYPE (*objp)) == TYPE_CODE_PTR) + if (TYPE_CODE (value_type (temp)) != TYPE_CODE_PTR + && TYPE_CODE (value_type (*objp)) == TYPE_CODE_PTR) { temp = value_addr (temp); } @@ -2322,7 +2322,7 @@ check_field (struct value *arg1, const char *name) arg1 = coerce_array (arg1); - t = VALUE_TYPE (arg1); + t = value_type (arg1); /* Follow pointers until we get to a non-pointer. */ @@ -2632,7 +2632,7 @@ value_full_object (struct value *argp, struct type *rtype, int xfull, int xtop, used for its computation. */ new_val = value_at_lazy (real_type, VALUE_ADDRESS (argp) - top + (using_enc ? 0 : VALUE_EMBEDDED_OFFSET (argp))); - VALUE_TYPE (new_val) = VALUE_TYPE (argp); + new_val->type = value_type (argp); VALUE_EMBEDDED_OFFSET (new_val) = using_enc ? top + VALUE_EMBEDDED_OFFSET (argp) : top; return new_val; } @@ -2718,7 +2718,7 @@ value_slice (struct value *array, int lowbound, int length) LONGEST lowerbound, upperbound; struct value *slice; struct type *array_type; - array_type = check_typedef (VALUE_TYPE (array)); + array_type = check_typedef (value_type (array)); if (TYPE_CODE (array_type) != TYPE_CODE_ARRAY && TYPE_CODE (array_type) != TYPE_CODE_STRING && TYPE_CODE (array_type) != TYPE_CODE_BITSTRING) @@ -2778,7 +2778,7 @@ value_slice (struct value *array, int lowbound, int length) else VALUE_LVAL (slice) = VALUE_LVAL (array); VALUE_ADDRESS (slice) = VALUE_ADDRESS (array); - VALUE_OFFSET (slice) = VALUE_OFFSET (array) + offset; + slice->offset = value_offset (array) + offset; } return slice; } @@ -2812,9 +2812,9 @@ static struct value * cast_into_complex (struct type *type, struct value *val) { struct type *real_type = TYPE_TARGET_TYPE (type); - if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_COMPLEX) + if (TYPE_CODE (value_type (val)) == TYPE_CODE_COMPLEX) { - struct type *val_real_type = TYPE_TARGET_TYPE (VALUE_TYPE (val)); + struct type *val_real_type = TYPE_TARGET_TYPE (value_type (val)); struct value *re_val = allocate_value (val_real_type); struct value *im_val = allocate_value (val_real_type); @@ -2826,8 +2826,8 @@ cast_into_complex (struct type *type, struct value *val) return value_literal_complex (re_val, im_val, type); } - else if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FLT - || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_INT) + else if (TYPE_CODE (value_type (val)) == TYPE_CODE_FLT + || TYPE_CODE (value_type (val)) == TYPE_CODE_INT) return value_literal_complex (val, value_zero (real_type, not_lval), type); else error ("cannot cast non-number to complex"); |