diff options
| -rw-r--r-- | gdb/ChangeLog | 32 | ||||
| -rw-r--r-- | gdb/c-valprint.c | 24 | ||||
| -rw-r--r-- | gdb/findvar.c | 4 | ||||
| -rw-r--r-- | gdb/valarith.c | 8 | ||||
| -rw-r--r-- | gdb/valops.c | 36 | ||||
| -rw-r--r-- | gdb/valprint.c | 53 | ||||
| -rw-r--r-- | gdb/value.c | 39 | ||||
| -rw-r--r-- | gdb/value.h | 4 |
8 files changed, 143 insertions, 57 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 93e054b..f0220f5 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,5 +1,37 @@ 2015-07-28 Simon Marchi <simon.marchi@ericsson.com> + * c-valprint.c (c_val_print_array): Consider addressable memory + unit size. + (c_val_print_ptr): Likewise. + (c_val_print_int): Likewise. + * findvar.c (read_frame_register_value): Likewise. + * valarith.c (find_size_for_pointer_math): Likewise. + (value_ptrdiff): Likewise. + (value_subscripted_rvalue): Likewise. + * valops.c (read_value_memory): Likewise (and rename variables). + (value_assign): Likewise. + (value_repeat): Likewise. + (value_array): Likewise. + (value_slice): Likewise. + * valprint.c (generic_val_print_ptr): Likewise. + (generic_val_print_enum): Likewise. + (generic_val_print_bool): Likewise. + (generic_val_print_int): Likewise. + (generic_val_print_char): Likewise. + (generic_val_print_float): Likewise. + (generic_val_print_decfloat): Likewise. + (generic_val_print_complex): Likewise. + (val_print_scalar_formatted): Likewise. + (val_print_array_elements): Likewise. + * value.c (set_value_parent): Likewise. + (value_contents_copy_raw): Likewise. + (set_internalvar_component): Likewise. + (value_primitive_field): Likewise. + (value_fetch_lazy): Likewise. + * value.h (read_value_memory): Update comment. + +2015-07-28 Simon Marchi <simon.marchi@ericsson.com> + * value.c (get_value_arch): New function. * value.h (get_value_arch): New declaration. diff --git a/gdb/c-valprint.c b/gdb/c-valprint.c index 2009e95..0cf2d7d 100644 --- a/gdb/c-valprint.c +++ b/gdb/c-valprint.c @@ -236,6 +236,8 @@ c_val_print_array (struct type *type, const gdb_byte *valaddr, { struct type *unresolved_elttype = TYPE_TARGET_TYPE (type); struct type *elttype = check_typedef (unresolved_elttype); + struct gdbarch *arch = get_type_arch (type); + int unit_size = gdbarch_addressable_memory_unit_size (arch); if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (unresolved_elttype) > 0) { @@ -276,7 +278,8 @@ c_val_print_array (struct type *type, const gdb_byte *valaddr, for (temp_len = 0; (temp_len < len && temp_len < options->print_max - && extract_unsigned_integer (valaddr + embedded_offset + && extract_unsigned_integer (valaddr + + embedded_offset * unit_size + temp_len * eltlen, eltlen, byte_order) != 0); ++temp_len) @@ -288,7 +291,8 @@ c_val_print_array (struct type *type, const gdb_byte *valaddr, if (temp_len == options->print_max && temp_len < len) { ULONGEST val - = extract_unsigned_integer (valaddr + embedded_offset + = extract_unsigned_integer (valaddr + + embedded_offset * unit_size + temp_len * eltlen, eltlen, byte_order); if (val != 0) @@ -299,7 +303,7 @@ c_val_print_array (struct type *type, const gdb_byte *valaddr, } LA_PRINT_STRING (stream, unresolved_elttype, - valaddr + embedded_offset, len, + valaddr + embedded_offset * unit_size, len, NULL, force_ellipses, options); i = len; } @@ -342,6 +346,9 @@ c_val_print_ptr (struct type *type, const gdb_byte *valaddr, const struct value *original_value, const struct value_print_options *options) { + struct gdbarch *arch = get_type_arch (type); + int unit_size = gdbarch_addressable_memory_unit_size (arch); + if (options->format && options->format != 's') { val_print_scalar_formatted (type, valaddr, embedded_offset, @@ -363,7 +370,8 @@ c_val_print_ptr (struct type *type, const gdb_byte *valaddr, { struct type *unresolved_elttype = TYPE_TARGET_TYPE (type); struct type *elttype = check_typedef (unresolved_elttype); - CORE_ADDR addr = unpack_pointer (type, valaddr + embedded_offset); + CORE_ADDR addr = unpack_pointer (type, + valaddr + embedded_offset * unit_size); print_unpacked_pointer (type, elttype, unresolved_elttype, valaddr, embedded_offset, addr, stream, recurse, options); @@ -430,6 +438,9 @@ c_val_print_int (struct type *type, struct type *unresolved_type, struct ui_file *stream, const struct value *original_value, const struct value_print_options *options) { + struct gdbarch *arch = get_type_arch (type); + int unit_size = gdbarch_addressable_memory_unit_size (arch); + if (options->format || options->output_format) { struct value_print_options opts = *options; @@ -441,7 +452,7 @@ c_val_print_int (struct type *type, struct type *unresolved_type, } else { - val_print_type_code_int (type, valaddr + embedded_offset, + val_print_type_code_int (type, valaddr + embedded_offset * unit_size, stream); /* C and C++ has no single byte int type, char is used instead. Since we don't know whether the value is really @@ -450,7 +461,8 @@ c_val_print_int (struct type *type, struct type *unresolved_type, if (c_textual_element_type (unresolved_type, options->format)) { fputs_filtered (" ", stream); - LA_PRINT_CHAR (unpack_long (type, valaddr + embedded_offset), + LA_PRINT_CHAR (unpack_long (type, + valaddr + embedded_offset * unit_size), unresolved_type, stream); } } diff --git a/gdb/findvar.c b/gdb/findvar.c index 2079b4b..83b4fca 100644 --- a/gdb/findvar.c +++ b/gdb/findvar.c @@ -662,7 +662,7 @@ read_frame_register_value (struct value *value, struct frame_info *frame) int offset = 0; int reg_offset = value_offset (value); int regnum = VALUE_REGNUM (value); - int len = TYPE_LENGTH (check_typedef (value_type (value))); + int len = type_length_units (check_typedef (value_type (value))); gdb_assert (VALUE_LVAL (value) == lval_register); @@ -677,7 +677,7 @@ read_frame_register_value (struct value *value, struct frame_info *frame) while (len > 0) { struct value *regval = get_frame_register_value (frame, regnum); - int reg_len = TYPE_LENGTH (value_type (regval)) - reg_offset; + int reg_len = type_length_units (value_type (regval)) - reg_offset; /* If the register length is larger than the number of bytes remaining to copy, then only copy the appropriate bytes. */ diff --git a/gdb/valarith.c b/gdb/valarith.c index 0162c10..3e349f2 100644 --- a/gdb/valarith.c +++ b/gdb/valarith.c @@ -54,7 +54,7 @@ find_size_for_pointer_math (struct type *ptr_type) gdb_assert (TYPE_CODE (ptr_type) == TYPE_CODE_PTR); ptr_target = check_typedef (TYPE_TARGET_TYPE (ptr_type)); - sz = TYPE_LENGTH (ptr_target); + sz = type_length_units (ptr_target); if (sz == 0) { if (TYPE_CODE (ptr_type) == TYPE_CODE_VOID) @@ -121,7 +121,7 @@ value_ptrdiff (struct value *arg1, struct value *arg2) "second argument is neither\n" "an integer nor a pointer of the same type.")); - sz = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1))); + sz = type_length_units (check_typedef (TYPE_TARGET_TYPE (type1))); if (sz == 0) { warning (_("Type size unknown, assuming 1. " @@ -192,12 +192,12 @@ value_subscripted_rvalue (struct value *array, LONGEST index, int lowerbound) { struct type *array_type = check_typedef (value_type (array)); struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (array_type)); - unsigned int elt_size = TYPE_LENGTH (elt_type); + unsigned int elt_size = type_length_units (elt_type); unsigned int elt_offs = elt_size * longest_to_int (index - lowerbound); struct value *v; if (index < lowerbound || (!TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (array_type) - && elt_offs >= TYPE_LENGTH (array_type))) + && elt_offs >= type_length_units (array_type))) error (_("no such vector element")); if (VALUE_LVAL (array) == lval_memory && value_lazy (array)) diff --git a/gdb/valops.c b/gdb/valops.c index d68e9f3..dac0274 100644 --- a/gdb/valops.c +++ b/gdb/valops.c @@ -958,30 +958,33 @@ read_value_memory (struct value *val, int embedded_offset, int stack, CORE_ADDR memaddr, gdb_byte *buffer, size_t length) { - ULONGEST xfered = 0; + ULONGEST xfered_total = 0; + struct gdbarch *arch = get_value_arch (val); + int unit_size = gdbarch_addressable_memory_unit_size (arch); - while (xfered < length) + while (xfered_total < length) { enum target_xfer_status status; - ULONGEST xfered_len; + ULONGEST xfered_partial; status = target_xfer_partial (current_target.beneath, TARGET_OBJECT_MEMORY, NULL, - buffer + xfered, NULL, - memaddr + xfered, length - xfered, - &xfered_len); + buffer + xfered_total * unit_size, NULL, + memaddr + xfered_total, + length - xfered_total, + &xfered_partial); if (status == TARGET_XFER_OK) /* nothing */; else if (status == TARGET_XFER_UNAVAILABLE) - mark_value_bytes_unavailable (val, embedded_offset + xfered, - xfered_len); + mark_value_bytes_unavailable (val, embedded_offset + xfered_total, + xfered_partial); else if (status == TARGET_XFER_EOF) - memory_error (TARGET_XFER_E_IO, memaddr + xfered); + memory_error (TARGET_XFER_E_IO, memaddr + xfered_total); else - memory_error (status, memaddr + xfered); + memory_error (status, memaddr + xfered_total); - xfered += xfered_len; + xfered_total += xfered_partial; QUIT; } } @@ -1089,7 +1092,7 @@ value_assign (struct value *toval, struct value *fromval) else { changed_addr = value_address (toval); - changed_len = TYPE_LENGTH (type); + changed_len = type_length_units (type); dest_buffer = value_contents (fromval); } @@ -1280,7 +1283,7 @@ value_repeat (struct value *arg1, int count) read_value_memory (val, 0, value_stack (val), value_address (val), value_contents_all_raw (val), - TYPE_LENGTH (value_enclosing_type (val))); + type_length_units (value_enclosing_type (val))); return val; } @@ -1606,10 +1609,11 @@ value_array (int lowbound, int highbound, struct value **elemvec) { error (_("bad array bounds (%d, %d)"), lowbound, highbound); } - typelength = TYPE_LENGTH (value_enclosing_type (elemvec[0])); + typelength = type_length_units (value_enclosing_type (elemvec[0])); for (idx = 1; idx < nelem; idx++) { - if (TYPE_LENGTH (value_enclosing_type (elemvec[idx])) != typelength) + if (type_length_units (value_enclosing_type (elemvec[idx])) + != typelength) { error (_("array elements must all be the same size")); } @@ -3812,7 +3816,7 @@ value_slice (struct value *array, int lowbound, int length) { slice = allocate_value (slice_type); value_contents_copy (slice, 0, array, offset, - TYPE_LENGTH (slice_type)); + type_length_units (slice_type)); } set_value_component_location (slice, array); diff --git a/gdb/valprint.c b/gdb/valprint.c index 8893830..713998c 100644 --- a/gdb/valprint.c +++ b/gdb/valprint.c @@ -433,6 +433,9 @@ generic_val_print_ptr (struct type *type, const gdb_byte *valaddr, const struct value *original_value, const struct value_print_options *options) { + struct gdbarch *gdbarch = get_type_arch (type); + int unit_size = gdbarch_addressable_memory_unit_size (gdbarch); + if (options->format && options->format != 's') { val_print_scalar_formatted (type, valaddr, embedded_offset, @@ -442,7 +445,8 @@ generic_val_print_ptr (struct type *type, const gdb_byte *valaddr, { struct type *unresolved_elttype = TYPE_TARGET_TYPE(type); struct type *elttype = check_typedef (unresolved_elttype); - CORE_ADDR addr = unpack_pointer (type, valaddr + embedded_offset); + CORE_ADDR addr = unpack_pointer (type, + valaddr + embedded_offset * unit_size); print_unpacked_pointer (type, elttype, addr, stream, options); } @@ -520,6 +524,8 @@ generic_val_print_enum (struct type *type, const gdb_byte *valaddr, unsigned int i; unsigned int len; LONGEST val; + struct gdbarch *gdbarch = get_type_arch (type); + int unit_size = gdbarch_addressable_memory_unit_size (gdbarch); if (options->format) { @@ -528,7 +534,7 @@ generic_val_print_enum (struct type *type, const gdb_byte *valaddr, return; } len = TYPE_NFIELDS (type); - val = unpack_long (type, valaddr + embedded_offset); + val = unpack_long (type, valaddr + embedded_offset * unit_size); for (i = 0; i < len; i++) { QUIT; @@ -633,6 +639,8 @@ generic_val_print_bool (struct type *type, const gdb_byte *valaddr, const struct generic_val_print_decorations *decorations) { LONGEST val; + struct gdbarch *gdbarch = get_type_arch (type); + int unit_size = gdbarch_addressable_memory_unit_size (gdbarch); if (options->format || options->output_format) { @@ -644,7 +652,7 @@ generic_val_print_bool (struct type *type, const gdb_byte *valaddr, } else { - val = unpack_long (type, valaddr + embedded_offset); + val = unpack_long (type, valaddr + embedded_offset * unit_size); if (val == 0) fputs_filtered (decorations->false_name, stream); else if (val == 1) @@ -662,6 +670,9 @@ generic_val_print_int (struct type *type, const gdb_byte *valaddr, const struct value *original_value, const struct value_print_options *options) { + struct gdbarch *gdbarch = get_type_arch (type); + int unit_size = gdbarch_addressable_memory_unit_size (gdbarch); + if (options->format || options->output_format) { struct value_print_options opts = *options; @@ -672,7 +683,8 @@ generic_val_print_int (struct type *type, const gdb_byte *valaddr, original_value, &opts, 0, stream); } else - val_print_type_code_int (type, valaddr + embedded_offset, stream); + val_print_type_code_int (type, valaddr + embedded_offset * unit_size, + stream); } /* generic_val_print helper for TYPE_CODE_CHAR. */ @@ -685,6 +697,8 @@ generic_val_print_char (struct type *type, struct type *unresolved_type, const struct value_print_options *options) { LONGEST val; + struct gdbarch *gdbarch = get_type_arch (type); + int unit_size = gdbarch_addressable_memory_unit_size (gdbarch); if (options->format || options->output_format) { @@ -697,7 +711,7 @@ generic_val_print_char (struct type *type, struct type *unresolved_type, } else { - val = unpack_long (type, valaddr + embedded_offset); + val = unpack_long (type, valaddr + embedded_offset * unit_size); if (TYPE_UNSIGNED (type)) fprintf_filtered (stream, "%u", (unsigned int) val); else @@ -715,6 +729,9 @@ generic_val_print_float (struct type *type, const gdb_byte *valaddr, const struct value *original_value, const struct value_print_options *options) { + struct gdbarch *gdbarch = get_type_arch (type); + int unit_size = gdbarch_addressable_memory_unit_size (gdbarch); + if (options->format) { val_print_scalar_formatted (type, valaddr, embedded_offset, @@ -722,7 +739,7 @@ generic_val_print_float (struct type *type, const gdb_byte *valaddr, } else { - print_floating (valaddr + embedded_offset, type, stream); + print_floating (valaddr + embedded_offset * unit_size, type, stream); } } @@ -734,11 +751,15 @@ generic_val_print_decfloat (struct type *type, const gdb_byte *valaddr, const struct value *original_value, const struct value_print_options *options) { + struct gdbarch *gdbarch = get_type_arch (type); + int unit_size = gdbarch_addressable_memory_unit_size (gdbarch); + if (options->format) val_print_scalar_formatted (type, valaddr, embedded_offset, original_value, options, 0, stream); else - print_decimal_floating (valaddr + embedded_offset, type, stream); + print_decimal_floating (valaddr + embedded_offset * unit_size, type, + stream); } /* generic_val_print helper for TYPE_CODE_COMPLEX. */ @@ -751,22 +772,25 @@ generic_val_print_complex (struct type *type, const gdb_byte *valaddr, const struct generic_val_print_decorations *decorations) { + struct gdbarch *gdbarch = get_type_arch (type); + int unit_size = gdbarch_addressable_memory_unit_size (gdbarch); + fprintf_filtered (stream, "%s", decorations->complex_prefix); if (options->format) val_print_scalar_formatted (TYPE_TARGET_TYPE (type), valaddr, embedded_offset, original_value, options, 0, stream); else - print_floating (valaddr + embedded_offset, TYPE_TARGET_TYPE (type), - stream); + print_floating (valaddr + embedded_offset * unit_size, + TYPE_TARGET_TYPE (type), stream); fprintf_filtered (stream, "%s", decorations->complex_infix); if (options->format) val_print_scalar_formatted (TYPE_TARGET_TYPE (type), valaddr, embedded_offset - + TYPE_LENGTH (TYPE_TARGET_TYPE (type)), + + type_length_units (TYPE_TARGET_TYPE (type)), original_value, options, 0, stream); else - print_floating (valaddr + embedded_offset + print_floating (valaddr + embedded_offset * unit_size + TYPE_LENGTH (TYPE_TARGET_TYPE (type)), TYPE_TARGET_TYPE (type), stream); fprintf_filtered (stream, "%s", decorations->complex_suffix); @@ -1150,6 +1174,9 @@ val_print_scalar_formatted (struct type *type, int size, struct ui_file *stream) { + struct gdbarch *arch = get_type_arch (type); + int unit_size = gdbarch_addressable_memory_unit_size (arch); + gdb_assert (val != NULL); gdb_assert (valaddr == value_contents_for_printing_const (val)); @@ -1175,7 +1202,7 @@ val_print_scalar_formatted (struct type *type, else if (!value_bytes_available (val, embedded_offset, TYPE_LENGTH (type))) val_print_unavailable (stream); else - print_scalar_formatted (valaddr + embedded_offset, type, + print_scalar_formatted (valaddr + embedded_offset * unit_size, type, options, size, stream); } @@ -1823,7 +1850,7 @@ val_print_array_elements (struct type *type, LONGEST low_pos, high_pos; elttype = TYPE_TARGET_TYPE (type); - eltlen = TYPE_LENGTH (check_typedef (elttype)); + eltlen = type_length_units (check_typedef (elttype)); index_type = TYPE_INDEX_TYPE (type); if (get_array_bounds (type, &low_bound, &high_bound)) diff --git a/gdb/value.c b/gdb/value.c index 0d540d5..2f0b2cc 100644 --- a/gdb/value.c +++ b/gdb/value.c @@ -1091,8 +1091,11 @@ set_value_parent (struct value *value, struct value *parent) gdb_byte * value_contents_raw (struct value *value) { + struct gdbarch *arch = get_value_arch (value); + int unit_size = gdbarch_addressable_memory_unit_size (arch); + allocate_value_contents (value); - return value->contents + value->embedded_offset; + return value->contents + value->embedded_offset * unit_size; } gdb_byte * @@ -1242,7 +1245,7 @@ value_ranges_copy_adjusted (struct value *dst, int dst_bit_offset, bit_length); } -/* Copy LENGTH bytes of SRC value's (all) contents +/* Copy LENGTH target addressable memory units of SRC value's (all) contents (value_contents_all) starting at SRC_OFFSET, into DST value's (all) contents, starting at DST_OFFSET. If unavailable contents are being copied from SRC, the corresponding DST contents are marked @@ -1257,8 +1260,9 @@ value_contents_copy_raw (struct value *dst, int dst_offset, struct value *src, int src_offset, int length) { range_s *r; - int i; int src_bit_offset, dst_bit_offset, bit_length; + struct gdbarch *arch = get_value_arch (src); + int unit_size = gdbarch_addressable_memory_unit_size (arch); /* A lazy DST would make that this copy operation useless, since as soon as DST's contents were un-lazied (by a later value_contents @@ -1275,14 +1279,14 @@ value_contents_copy_raw (struct value *dst, int dst_offset, TARGET_CHAR_BIT * length)); /* Copy the data. */ - memcpy (value_contents_all_raw (dst) + dst_offset, - value_contents_all_raw (src) + src_offset, - length); + memcpy (value_contents_all_raw (dst) + dst_offset * unit_size, + value_contents_all_raw (src) + src_offset * unit_size, + length * unit_size); /* Copy the meta-data, adjusted. */ - src_bit_offset = src_offset * TARGET_CHAR_BIT; - dst_bit_offset = dst_offset * TARGET_CHAR_BIT; - bit_length = length * TARGET_CHAR_BIT; + src_bit_offset = src_offset * unit_size * HOST_CHAR_BIT; + dst_bit_offset = dst_offset * unit_size * HOST_CHAR_BIT; + bit_length = length * unit_size * HOST_CHAR_BIT; value_ranges_copy_adjusted (dst, dst_bit_offset, src, src_bit_offset, @@ -2279,17 +2283,21 @@ set_internalvar_component (struct internalvar *var, int offset, int bitpos, int bitsize, struct value *newval) { gdb_byte *addr; + struct gdbarch *arch; + int unit_size; switch (var->kind) { case INTERNALVAR_VALUE: addr = value_contents_writeable (var->u.value); + arch = get_value_arch (var->u.value); + unit_size = gdbarch_addressable_memory_unit_size (arch); if (bitsize) modify_field (value_type (var->u.value), addr + offset, value_as_long (newval), bitpos, bitsize); else - memcpy (addr + offset, value_contents (newval), + memcpy (addr + offset * unit_size, value_contents (newval), TYPE_LENGTH (value_type (newval))); break; @@ -3000,6 +3008,8 @@ value_primitive_field (struct value *arg1, int offset, { struct value *v; struct type *type; + struct gdbarch *arch = get_value_arch (arg1); + int unit_size = gdbarch_addressable_memory_unit_size (arch); arg_type = check_typedef (arg_type); type = TYPE_FIELD_TYPE (arg_type, fieldno); @@ -3078,7 +3088,8 @@ value_primitive_field (struct value *arg1, int offset, else { /* Plain old data member */ - offset += TYPE_FIELD_BITPOS (arg_type, fieldno) / 8; + offset += (TYPE_FIELD_BITPOS (arg_type, fieldno) + / (HOST_CHAR_BIT * unit_size)); /* Lazy register values with offsets are not supported. */ if (VALUE_LVAL (arg1) == lval_register && value_lazy (arg1)) @@ -3091,7 +3102,7 @@ value_primitive_field (struct value *arg1, int offset, v = allocate_value (type); value_contents_copy_raw (v, value_embedded_offset (v), arg1, value_embedded_offset (arg1) + offset, - TYPE_LENGTH (type)); + type_length_units (type)); } v->offset = (value_offset (arg1) + offset + value_embedded_offset (arg1)); @@ -3833,7 +3844,7 @@ value_fetch_lazy (struct value *val) if (TYPE_LENGTH (type)) read_value_memory (val, 0, value_stack (val), addr, value_contents_all_raw (val), - TYPE_LENGTH (type)); + type_length_units (type)); } else if (VALUE_LVAL (val) == lval_register) { @@ -3892,7 +3903,7 @@ value_fetch_lazy (struct value *val) set_value_lazy (val, 0); value_contents_copy (val, value_embedded_offset (val), new_val, value_embedded_offset (new_val), - TYPE_LENGTH (type)); + type_length_units (type)); if (frame_debug) { diff --git a/gdb/value.h b/gdb/value.h index e25f52b..82deaf2 100644 --- a/gdb/value.h +++ b/gdb/value.h @@ -571,8 +571,8 @@ extern int value_contents_eq (const struct value *val1, int offset1, const struct value *val2, int offset2, int length); -/* Read LENGTH bytes of memory starting at MEMADDR into BUFFER, which - is (or will be copied to) VAL's contents buffer offset by +/* Read LENGTH addressable memory units starting at MEMADDR into BUFFER, + which is (or will be copied to) VAL's contents buffer offset by EMBEDDED_OFFSET (that is, to &VAL->contents[EMBEDDED_OFFSET]). Marks value contents ranges as unavailable if the corresponding memory is likewise unavailable. STACK indicates whether the memory |