darlinghq/darling-gdb
1
0
Fork 0
mirror of https://github.com/darlinghq/darling-gdb.git synced 2024-11-24 04:29:49 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

2009-05-27 Tom Tromey <tromey@redhat.com>

Browse Source 
Paul Pluzhnikov  <ppluzhnikov@google.com>

	* mi/mi-main.c (mi_cmd_data_evaluate_expression): Use
	value_address.
	* cli/cli-dump.c (dump_value_to_file): Use value_address.
	* valprint.c (common_val_print): Likewise.
	* v850-tdep.c (v850_push_dummy_call): Use value_address.
	* tracepoint.c (encode_actions): Use value_address.
	* printcmd.c (print_formatted): Use value_address.
	(x_command): Likewise.
	* p-valprint.c (pascal_object_print_static_field): Use
	value_address.
	* mn10300-tdep.c (mn10300_push_dummy_call): Use value_address.
	* mips-tdep.c (mips_eabi_push_dummy_call): Use value_address.
	* m32r-tdep.c (m32r_push_dummy_call): Use value_address.
	* jv-valprint.c (java_value_print): Use value_address.
	* infcall.c (find_function_addr): Use value_address.
	* gnu-v3-abi.c (gnuv3_rtti_type): Use value_address.
	* gnu-v2-abi.c (gnuv2_value_rtti_type): Use value_address.
	* frv-tdep.c (frv_push_dummy_call): Use value_address.
	* frame.c (frame_register_unwind): Use value_address.
	(frame_unwind_register_value): Likewise.
	* darwin-nat-info.c (info_mach_region_command): Use
	value_address.
	* cp-valprint.c (cp_print_static_field): Use value_address.
	* c-valprint.c (c_value_print): Use value_address.
	* breakpoint.c (update_watchpoint): Use value_address.
	(can_use_hardware_watchpoint): Likewise.
	* ada-valprint.c (ada_val_print_1): Use value_address.
	(ada_value_print): Likewise.
	* ada-tasks.c (read_fat_string_value): Use value_address.
	* jv-lang.c (java_link_class_type): Use set_value_address.
	(java_link_class_type): Likewise.
	(get_java_utf8_name): Use value_address.
	(type_from_class): Likewise.
	(java_link_class_type): Likewise.
	* findvar.c (value_of_register): Use set_value_address.
	(read_var_value): Likewise.
	(read_var_value): Likewise.
	* eval.c (evaluate_subexp_standard): Use set_value_address.
	(evaluate_subexp_standard): Use value_address.
	* dwarf2loc.c (dwarf2_evaluate_loc_desc): Use set_value_address.
	* ada-lang.c (coerce_unspec_val_to_type): Use set_value_address.
	(ada_value_primitive_packed_val): Likewise.
	(ensure_lval): Likewise.
	(thin_data_pntr): Use value_address.
	(desc_bounds): Likewise.
	(ada_value_primitive_packed_val): Likewise.
	(value_assign_to_component): Likewise.
	(ensure_lval): Likewise.
	(make_array_descriptor): Likewise.
	(ada_to_fixed_value): Likewise.
	(unwrap_value): Likewise.
	* value.c (deprecated_value_address_hack): Remove.
	(value_address): New function.
	(value_raw_address): Likewise.
	(set_value_address): Likewise.
	(value_fn_field): Use set_value_address.
	(value_from_contents_and_address): Likewise.
	(value_fn_field): Likewise.
	(allocate_value_lazy): Don't use VALUE_ADDRESS.
	(value_as_address): Use value_address.
	(value_static_field): Likewise.
	* valops.c (search_struct_field): Use set_value_address.
	(value_at): Likewise.
	(value_at_lazy): Likewise.
	(value_repeat): Likewise.
	(value_cast_structs): Use value_address.
	(value_cast): Likewise.
	(value_fetch_lazy): Likewise.
	(value_assign): Likewise.
	(value_repeat): Likewise.
	(address_of_variable): Likewise.
	(value_coerce_array): Likewise.
	(value_coerce_function): Likewise.
	(value_addr): Likewise.
	(search_struct_field): Likewise.
	(search_struct_method): Likewise.
	(find_method_list): Likewise.
	(value_struct_elt_for_reference): Likewise.
	(value_full_object): Likewise.
	* jv-valprint.c (java_value_print): Use set_value_address.
	* value.h (deprecated_value_address_hack): Remove.
	(VALUE_ADDRESS): Remove.
	(value_address): Declare.
	(value_raw_address): Declare.
	(set_value_address): Declare.
This commit is contained in:
Tom Tromey 2009-05-28 00:53:52 +00:00
parent 2c74e83381
commit 42ae523077
31 changed files with 239 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

89
gdb/ChangeLog
View File

@ -1,3 +1,92 @@
2009-05-27 Tom Tromey <tromey@redhat.com>
Paul Pluzhnikov <ppluzhnikov@google.com>
* mi/mi-main.c (mi_cmd_data_evaluate_expression): Use
value_address.
* cli/cli-dump.c (dump_value_to_file): Use value_address.
* valprint.c (common_val_print): Likewise.
* v850-tdep.c (v850_push_dummy_call): Use value_address.
* tracepoint.c (encode_actions): Use value_address.
* printcmd.c (print_formatted): Use value_address.
(x_command): Likewise.
* p-valprint.c (pascal_object_print_static_field): Use
value_address.
* mn10300-tdep.c (mn10300_push_dummy_call): Use value_address.
* mips-tdep.c (mips_eabi_push_dummy_call): Use value_address.
* m32r-tdep.c (m32r_push_dummy_call): Use value_address.
* jv-valprint.c (java_value_print): Use value_address.
* infcall.c (find_function_addr): Use value_address.
* gnu-v3-abi.c (gnuv3_rtti_type): Use value_address.
* gnu-v2-abi.c (gnuv2_value_rtti_type): Use value_address.
* frv-tdep.c (frv_push_dummy_call): Use value_address.
* frame.c (frame_register_unwind): Use value_address.
(frame_unwind_register_value): Likewise.
* darwin-nat-info.c (info_mach_region_command): Use
value_address.
* cp-valprint.c (cp_print_static_field): Use value_address.
* c-valprint.c (c_value_print): Use value_address.
* breakpoint.c (update_watchpoint): Use value_address.
(can_use_hardware_watchpoint): Likewise.
* ada-valprint.c (ada_val_print_1): Use value_address.
(ada_value_print): Likewise.
* ada-tasks.c (read_fat_string_value): Use value_address.
* jv-lang.c (java_link_class_type): Use set_value_address.
(java_link_class_type): Likewise.
(get_java_utf8_name): Use value_address.
(type_from_class): Likewise.
(java_link_class_type): Likewise.
* findvar.c (value_of_register): Use set_value_address.
(read_var_value): Likewise.
(read_var_value): Likewise.
* eval.c (evaluate_subexp_standard): Use set_value_address.
(evaluate_subexp_standard): Use value_address.
* dwarf2loc.c (dwarf2_evaluate_loc_desc): Use set_value_address.
* ada-lang.c (coerce_unspec_val_to_type): Use set_value_address.
(ada_value_primitive_packed_val): Likewise.
(ensure_lval): Likewise.
(thin_data_pntr): Use value_address.
(desc_bounds): Likewise.
(ada_value_primitive_packed_val): Likewise.
(value_assign_to_component): Likewise.
(ensure_lval): Likewise.
(make_array_descriptor): Likewise.
(ada_to_fixed_value): Likewise.
(unwrap_value): Likewise.
* value.c (deprecated_value_address_hack): Remove.
(value_address): New function.
(value_raw_address): Likewise.
(set_value_address): Likewise.
(value_fn_field): Use set_value_address.
(value_from_contents_and_address): Likewise.
(value_fn_field): Likewise.
(allocate_value_lazy): Don't use VALUE_ADDRESS.
(value_as_address): Use value_address.
(value_static_field): Likewise.
* valops.c (search_struct_field): Use set_value_address.
(value_at): Likewise.
(value_at_lazy): Likewise.
(value_repeat): Likewise.
(value_cast_structs): Use value_address.
(value_cast): Likewise.
(value_fetch_lazy): Likewise.
(value_assign): Likewise.
(value_repeat): Likewise.
(address_of_variable): Likewise.
(value_coerce_array): Likewise.
(value_coerce_function): Likewise.
(value_addr): Likewise.
(search_struct_field): Likewise.
(search_struct_method): Likewise.
(find_method_list): Likewise.
(value_struct_elt_for_reference): Likewise.
(value_full_object): Likewise.
* jv-valprint.c (java_value_print): Use set_value_address.
* value.h (deprecated_value_address_hack): Remove.
(VALUE_ADDRESS): Remove.
(value_address): Declare.
(value_raw_address): Declare.
(set_value_address): Declare.
2009-05-27 Tom Tromey <tromey@redhat.com>
Thiago Jung Bauermann <bauerman@br.ibm.com>
Phil Muldoon <pmuldoon@redhat.com>

40
gdb/ada-lang.c
View File

@ -485,7 +485,7 @@ coerce_unspec_val_to_type (struct value *val, struct type *type)
set_value_component_location (result, val);
set_value_bitsize (result, value_bitsize (val));
set_value_bitpos (result, value_bitpos (val));
VALUE_ADDRESS (result) += value_offset (val);
set_value_address (result, value_address (val));
if (value_lazy (val)
|| TYPE_LENGTH (type) > TYPE_LENGTH (value_type (val)))
set_value_lazy (result, 1);
@ -1287,8 +1287,7 @@ thin_data_pntr (struct value *val)
if (TYPE_CODE (type) == TYPE_CODE_PTR)
return value_cast (data_type, value_copy (val));
else
return value_from_longest (data_type,
VALUE_ADDRESS (val) + value_offset (val));
return value_from_longest (data_type, value_address (val));
}
/* True iff TYPE indicates a "thick" array pointer type. */
@ -1353,7 +1352,7 @@ desc_bounds (struct value *arr)
if (TYPE_CODE (type) == TYPE_CODE_PTR)
addr = value_as_long (arr);
else
addr = VALUE_ADDRESS (arr) + value_offset (arr);
addr = value_address (arr);
return
value_from_longest (lookup_pointer_type (bounds_type),
@ -1968,9 +1967,9 @@ ada_value_primitive_packed_val (struct value *obj, const gdb_byte *valaddr,
else if (VALUE_LVAL (obj) == lval_memory && value_lazy (obj))
{
v = value_at (type,
VALUE_ADDRESS (obj) + value_offset (obj) + offset);
value_address (obj) + offset);
bytes = (unsigned char *) alloca (len);
read_memory (VALUE_ADDRESS (v), bytes, len);
read_memory (value_address (v), bytes, len);
}
else
{
@ -1980,15 +1979,17 @@ ada_value_primitive_packed_val (struct value *obj, const gdb_byte *valaddr,
if (obj != NULL)
{
CORE_ADDR new_addr;
set_value_component_location (v, obj);
VALUE_ADDRESS (v) += value_offset (obj) + offset;
new_addr = value_address (obj) + offset;
set_value_bitpos (v, bit_offset + value_bitpos (obj));
set_value_bitsize (v, bit_size);
if (value_bitpos (v) >= HOST_CHAR_BIT)
{
VALUE_ADDRESS (v) += 1;
++new_addr;
set_value_bitpos (v, value_bitpos (v) - HOST_CHAR_BIT);
}
set_value_address (v, new_addr);
}
else
set_value_bitsize (v, bit_size);
@ -2181,7 +2182,7 @@ ada_value_assign (struct value *toval, struct value *fromval)
int from_size;
char *buffer = (char *) alloca (len);
struct value *val;
CORE_ADDR to_addr = VALUE_ADDRESS (toval) + value_offset (toval);
CORE_ADDR to_addr = value_address (toval);
if (TYPE_CODE (type) == TYPE_CODE_FLT)
fromval = value_cast (type, fromval);
@ -2222,8 +2223,7 @@ value_assign_to_component (struct value *container, struct value *component,
struct value *val)
{
LONGEST offset_in_container =
(LONGEST) (VALUE_ADDRESS (component) + value_offset (component)
- VALUE_ADDRESS (container) - value_offset (container));
(LONGEST) (value_address (component) - value_address (container));
int bit_offset_in_container =
value_bitpos (component) - value_bitpos (container);
int bits;
@ -3750,7 +3750,7 @@ parse_old_style_renaming (struct type *type,
/* Return an lvalue containing the value VAL. This is the identity on
lvalues, and otherwise has the side-effect of pushing a copy of VAL
on the stack, using and updating *SP as the stack pointer, and
returning an lvalue whose VALUE_ADDRESS points to the copy. */
returning an lvalue whose value_address points to the copy. */
static struct value *
ensure_lval (struct value *val, CORE_ADDR *sp)
@ -3764,12 +3764,12 @@ ensure_lval (struct value *val, CORE_ADDR *sp)
indicated. */
if (gdbarch_inner_than (current_gdbarch, 1, 2))
{
/* Stack grows downward. Align SP and VALUE_ADDRESS (val) after
/* Stack grows downward. Align SP and value_address (val) after
reserving sufficient space. */
*sp -= len;
if (gdbarch_frame_align_p (current_gdbarch))
*sp = gdbarch_frame_align (current_gdbarch, *sp);
VALUE_ADDRESS (val) = *sp;
set_value_address (val, *sp);
}
else
{
@ -3777,14 +3777,14 @@ ensure_lval (struct value *val, CORE_ADDR *sp)
then again, re-align the frame. */
if (gdbarch_frame_align_p (current_gdbarch))
*sp = gdbarch_frame_align (current_gdbarch, *sp);
VALUE_ADDRESS (val) = *sp;
set_value_address (val, *sp);
*sp += len;
if (gdbarch_frame_align_p (current_gdbarch))
*sp = gdbarch_frame_align (current_gdbarch, *sp);
}
VALUE_LVAL (val) = lval_memory;
write_memory (VALUE_ADDRESS (val), value_contents_raw (val), len);
write_memory (value_address (val), value_contents_raw (val), len);
}
return val;
@ -3873,12 +3873,12 @@ make_array_descriptor (struct type *type, struct value *arr, CORE_ADDR *sp)
bounds = ensure_lval (bounds, sp);
modify_general_field (value_contents_writeable (descriptor),
VALUE_ADDRESS (ensure_lval (arr, sp)),
value_address (ensure_lval (arr, sp)),
fat_pntr_data_bitpos (desc_type),
fat_pntr_data_bitsize (desc_type));
modify_general_field (value_contents_writeable (descriptor),
VALUE_ADDRESS (bounds),
value_address (bounds),
fat_pntr_bounds_bitpos (desc_type),
fat_pntr_bounds_bitsize (desc_type));
@ -7430,7 +7430,7 @@ static struct value *
ada_to_fixed_value (struct value *val)
{
return ada_to_fixed_value_create (value_type (val),
VALUE_ADDRESS (val) + value_offset (val),
value_address (val),
val);
}
@ -7776,7 +7776,7 @@ unwrap_value (struct value *val)
return
coerce_unspec_val_to_type
(val, ada_to_fixed_type (raw_real_type, 0,
VALUE_ADDRESS (val) + value_offset (val),
value_address (val),
NULL, 1));
}
}

2
gdb/ada-tasks.c
View File

@ -271,7 +271,7 @@ read_fat_string_value (char *dest, struct value *val, int max_len)
/* Extract LEN characters from the fat string. */
array_val = value_ind (value_field (val, array_fieldno));
read_memory (VALUE_ADDRESS (array_val), dest, len);
read_memory (value_address (array_val), dest, len);
/* Add the NUL character to close the string. */
dest[len] = '\0';

6
gdb/ada-valprint.c
View File

@ -690,7 +690,7 @@ ada_val_print_1 (struct type *type, const gdb_byte *valaddr0,
}
else
retn = ada_val_print_1 (value_type (val), value_contents (val), 0,
VALUE_ADDRESS (val), stream, recurse, options);
value_address (val), stream, recurse, options);
value_free_to_mark (mark);
return retn;
}
@ -894,7 +894,7 @@ ada_val_print_1 (struct type *type, const gdb_byte *valaddr0,
deref_val_int));
val_print (value_type (deref_val),
value_contents (deref_val), 0,
VALUE_ADDRESS (deref_val), stream, recurse + 1,
value_address (deref_val), stream, recurse + 1,
options, current_language);
}
else
@ -934,7 +934,7 @@ ada_value_print (struct value *val0, struct ui_file *stream,
const struct value_print_options *options)
{
const gdb_byte *valaddr = value_contents (val0);
CORE_ADDR address = VALUE_ADDRESS (val0) + value_offset (val0);
CORE_ADDR address = value_address (val0);
struct type *type =
ada_to_fixed_type (value_type (val0), valaddr, address, NULL, 1);
struct value *val =

4
gdb/breakpoint.c
View File

@ -992,7 +992,7 @@ update_watchpoint (struct breakpoint *b, int reparse)
int len, type;
struct bp_location *loc, **tmp;
addr = VALUE_ADDRESS (v) + value_offset (v);
addr = value_address (v);
len = TYPE_LENGTH (value_type (v));
type = hw_write;
if (b->type == bp_read_watchpoint)
@ -6339,7 +6339,7 @@ can_use_hardware_watchpoint (struct value *v)
|| (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
&& TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
{
CORE_ADDR vaddr = VALUE_ADDRESS (v) + value_offset (v);
CORE_ADDR vaddr = value_address (v);
int len = TYPE_LENGTH (value_type (v));
if (!target_region_ok_for_hw_watchpoint (vaddr, len))

6
gdb/c-valprint.c
View File

@ -668,7 +668,7 @@ c_value_print (struct value *val, struct ui_file *stream,
/* Print out object: enclosing type is same as real_type if full */
return val_print (value_enclosing_type (val),
value_contents_all (val), 0,
VALUE_ADDRESS (val), stream, 0,
value_address (val), stream, 0,
&opts, current_language);
/* Note: When we look up RTTI entries, we don't get any information on
const or volatile attributes */
@ -680,7 +680,7 @@ c_value_print (struct value *val, struct ui_file *stream,
TYPE_NAME (value_enclosing_type (val)));
return val_print (value_enclosing_type (val),
value_contents_all (val), 0,
VALUE_ADDRESS (val), stream, 0,
value_address (val), stream, 0,
&opts, current_language);
}
/* Otherwise, we end up at the return outside this "if" */
@ -688,6 +688,6 @@ c_value_print (struct value *val, struct ui_file *stream,
return val_print (val_type, value_contents_all (val),
value_embedded_offset (val),
VALUE_ADDRESS (val) + value_offset (val),
value_address (val),
stream, 0, &opts, current_language);
}

2
gdb/cli/cli-dump.c
View File

@ -296,7 +296,7 @@ dump_value_to_file (char *cmd, char *mode, char *file_format)
if (VALUE_LVAL (val))
{
vaddr = VALUE_ADDRESS (val);
vaddr = value_address (val);
}
else
{

10
gdb/cp-valprint.c
View File

@ -461,6 +461,7 @@ cp_print_static_field (struct type *type,
if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
{
CORE_ADDR *first_dont_print;
CORE_ADDR addr;
int i;
first_dont_print
@ -470,7 +471,7 @@ cp_print_static_field (struct type *type,
while (--i >= 0)
{
if (VALUE_ADDRESS (val) == first_dont_print[i])
if (value_address (val) == first_dont_print[i])
{
fputs_filtered ("<same as static member of an already"
" seen type>",
@ -479,12 +480,13 @@ cp_print_static_field (struct type *type,
}
}
obstack_grow (&dont_print_statmem_obstack, (char *) &VALUE_ADDRESS (val),
addr = value_address (val);
obstack_grow (&dont_print_statmem_obstack, (char *) &addr,
sizeof (CORE_ADDR));
CHECK_TYPEDEF (type);
cp_print_value_fields (type, type, value_contents_all (val),
value_embedded_offset (val), VALUE_ADDRESS (val),
value_embedded_offset (val), addr,
stream, recurse, options, NULL, 1);
return;
}
@ -492,7 +494,7 @@ cp_print_static_field (struct type *type,
opts = *options;
opts.deref_ref = 0;
val_print (type, value_contents_all (val),
value_embedded_offset (val), VALUE_ADDRESS (val),
value_embedded_offset (val), value_address (val),
stream, recurse, &opts, current_language);
}

2
gdb/darwin-nat-info.c
View File

@ -684,7 +684,7 @@ info_mach_region_command (char *exp, int from_tty)
if (TYPE_CODE (value_type (val)) == TYPE_CODE_FUNC
&& VALUE_LVAL (val) == lval_memory)
{
address = VALUE_ADDRESS (val);
address = value_address (val);
}
else
{

2
gdb/dwarf2loc.c
View File

@ -264,7 +264,7 @@ dwarf2_evaluate_loc_desc (struct symbol *var, struct frame_info *frame,
retval = allocate_value (SYMBOL_TYPE (var));
VALUE_LVAL (retval) = lval_memory;
set_value_lazy (retval, 1);
VALUE_ADDRESS (retval) = address;
set_value_address (retval, address);
}
set_value_initialized (retval, ctx->initialized);

6
gdb/eval.c
View File

@ -1211,9 +1211,9 @@ evaluate_subexp_standard (struct type *expect_type,
if (TYPE_CODE (value_type (method)) != TYPE_CODE_FUNC)
error (_("method address has symbol information with non-function type; skipping"));
if (struct_return)
VALUE_ADDRESS (method) = value_as_address (msg_send_stret);
set_value_address (method, value_as_address (msg_send_stret));
else
VALUE_ADDRESS (method) = value_as_address (msg_send);
set_value_address (method, value_as_address (msg_send));
called_method = method;
}
else
@ -1437,7 +1437,7 @@ evaluate_subexp_standard (struct type *expect_type,
of the ``this'' pointer if necessary, so modify argvec[1] to
reflect any ``this'' changes. */
arg2 = value_from_longest (lookup_pointer_type(value_type (temp)),
VALUE_ADDRESS (temp) + value_offset (temp)
value_address (temp)
+ value_embedded_offset (temp));
argvec[1] = arg2; /* the ``this'' pointer */
}

10
gdb/findvar.c
View File

@ -275,7 +275,7 @@ value_of_register (int regnum, struct frame_info *frame)
memcpy (value_contents_raw (reg_val), raw_buffer,
register_size (gdbarch, regnum));
VALUE_LVAL (reg_val) = lval;
VALUE_ADDRESS (reg_val) = addr;
set_value_address (reg_val, addr);
VALUE_REGNUM (reg_val) = regnum;
set_value_optimized_out (reg_val, optim);
VALUE_FRAME_ID (reg_val) = get_frame_id (frame);
@ -477,10 +477,10 @@ read_var_value (struct symbol *var, struct frame_info *frame)
case LOC_BLOCK:
if (overlay_debugging)
VALUE_ADDRESS (v) = symbol_overlayed_address
(BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_OBJ_SECTION (var));
set_value_address (v, symbol_overlayed_address
(BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_OBJ_SECTION (var)));
else
VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
set_value_address (v, BLOCK_START (SYMBOL_BLOCK_VALUE (var)));
return v;
case LOC_REGISTER:
@ -551,7 +551,7 @@ read_var_value (struct symbol *var, struct frame_info *frame)
break;
}
VALUE_ADDRESS (v) = addr;
set_value_address (v, addr);
set_value_lazy (v, 1);
return v;
}

4
gdb/frame.c
View File

@ -602,7 +602,7 @@ frame_register_unwind (struct frame_info *frame, int regnum,
*optimizedp = value_optimized_out (value);
*lvalp = VALUE_LVAL (value);
*addrp = VALUE_ADDRESS (value);
*addrp = value_address (value);
*realnump = VALUE_REGNUM (value);
if (bufferp)
@ -688,7 +688,7 @@ frame_unwind_register_value (struct frame_info *frame, int regnum)
VALUE_REGNUM (value));
else if (VALUE_LVAL (value) == lval_memory)
fprintf_unfiltered (gdb_stdlog, " address=0x%s",
paddr_nz (VALUE_ADDRESS (value)));
paddr_nz (value_address (value)));
else
fprintf_unfiltered (gdb_stdlog, " computed");

2
gdb/frv-tdep.c
View File

@ -1230,7 +1230,7 @@ frv_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
if (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION)
{
store_unsigned_integer (valbuf, 4, VALUE_ADDRESS (arg));
store_unsigned_integer (valbuf, 4, value_address (arg));
typecode = TYPE_CODE_PTR;
len = 4;
val = valbuf;

2
gdb/gnu-v2-abi.c
View File

@ -242,7 +242,7 @@ gnuv2_value_rtti_type (struct value *v, int *full, int *top, int *using_enc)
we'd waste a bunch of time figuring out we already know the type.
Besides, we don't care about the type, just the actual pointer
*/
if (VALUE_ADDRESS (value_field (v, known_type_vptr_fieldno)) == 0)
if (value_address (value_field (v, known_type_vptr_fieldno)) == 0)
return NULL;
vtbl = value_as_address (value_field (v, known_type_vptr_fieldno));

3
gdb/gnu-v3-abi.c
View File

@ -269,8 +269,7 @@ gnuv3_rtti_type (struct value *value,
/* Find the linker symbol for this vtable. */
vtable_symbol
= lookup_minimal_symbol_by_pc (VALUE_ADDRESS (vtable)
+ value_offset (vtable)
= lookup_minimal_symbol_by_pc (value_address (vtable)
+ value_embedded_offset (vtable));
if (! vtable_symbol)
return NULL;

2
gdb/infcall.c
View File

@ -217,7 +217,7 @@ find_function_addr (struct value *function, struct type **retval_type)
/* Determine address to call. */
if (code == TYPE_CODE_FUNC || code == TYPE_CODE_METHOD)
{
funaddr = VALUE_ADDRESS (function);
funaddr = value_address (function);
value_type = TYPE_TARGET_TYPE (ftype);
}
else if (code == TYPE_CODE_PTR)

16
gdb/jv-lang.c
View File

@ -211,8 +211,7 @@ get_java_utf8_name (struct obstack *obstack, struct value *name)
CORE_ADDR data_addr;
temp = value_struct_elt (&temp, NULL, "length", NULL, "structure");
name_length = (int) value_as_long (temp);
data_addr = VALUE_ADDRESS (temp) + value_offset (temp)
+ TYPE_LENGTH (value_type (temp));
data_addr = value_address (temp) + TYPE_LENGTH (value_type (temp));
chrs = obstack_alloc (obstack, name_length + 1);
chrs[name_length] = '\0';
read_memory (data_addr, (gdb_byte *) chrs, name_length);
@ -267,7 +266,7 @@ type_from_class (struct value *clas)
return NULL;
clas = value_ind (clas);
}
addr = VALUE_ADDRESS (clas) + value_offset (clas);
addr = value_address (clas);
#if 0
get_java_class_symtab ();
@ -422,8 +421,7 @@ java_link_class_type (struct type *type, struct value *clas)
fields = NULL;
nfields--; /* First set up dummy "class" field. */
SET_FIELD_PHYSADDR (TYPE_FIELD (type, nfields),
VALUE_ADDRESS (clas) + value_offset (clas));
SET_FIELD_PHYSADDR (TYPE_FIELD (type, nfields), value_address (clas));
TYPE_FIELD_NAME (type, nfields) = "class";
TYPE_FIELD_TYPE (type, nfields) = value_type (clas);
SET_TYPE_FIELD_PRIVATE (type, nfields);
@ -440,7 +438,9 @@ java_link_class_type (struct type *type, struct value *clas)
}
else
{ /* Re-use field value for next field. */
VALUE_ADDRESS (field) += TYPE_LENGTH (value_type (field));
CORE_ADDR addr
= value_address (field) + TYPE_LENGTH (value_type (field));
set_value_address (field, addr);
set_value_lazy (field, 1);
}
temp = field;
@ -510,7 +510,9 @@ java_link_class_type (struct type *type, struct value *clas)
}
else
{ /* Re-use method value for next method. */
VALUE_ADDRESS (method) += TYPE_LENGTH (value_type (method));
CORE_ADDR addr
= value_address (method) + TYPE_LENGTH (value_type (method));
set_value_address (method, addr);
set_value_lazy (method, 1);
}

6
gdb/jv-valprint.c
View File

@ -45,7 +45,7 @@ java_value_print (struct value *val, struct ui_file *stream,
struct value_print_options opts;
type = value_type (val);
address = VALUE_ADDRESS (val) + value_offset (val);
address = value_address (val);
if (is_object_type (type))
{
@ -143,8 +143,8 @@ java_value_print (struct value *val, struct ui_file *stream,
struct value *v = allocate_value (el_type);
struct value *next_v = allocate_value (el_type);
VALUE_ADDRESS (v) = address + JAVA_OBJECT_SIZE + 4;
VALUE_ADDRESS (next_v) = VALUE_ADDRESS (v);
set_value_address (v, address + JAVA_OBJECT_SIZE + 4);
set_value_address (next_v, value_raw_address (v));
while (i < length && things_printed < options->print_max)
{

2
gdb/m32r-tdep.c
View File

@ -713,7 +713,7 @@ m32r_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
if (len > 8
&& (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION))
{
store_unsigned_integer (valbuf, 4, VALUE_ADDRESS (args[argnum]));
store_unsigned_integer (valbuf, 4, value_address (args[argnum]));
typecode = TYPE_CODE_PTR;
len = 4;
val = valbuf;

2
gdb/mi/mi-main.c
View File

@ -788,7 +788,7 @@ mi_cmd_data_evaluate_expression (char *command, char **argv, int argc)
get_user_print_options (&opts);
opts.deref_ref = 0;
val_print (value_type (val), value_contents (val),
value_embedded_offset (val), VALUE_ADDRESS (val),
value_embedded_offset (val), value_address (val),
stb->stream, 0, &opts, current_language);
ui_out_field_stream (uiout, "value", stb);

2
gdb/mips-tdep.c
View File

@ -2766,7 +2766,7 @@ mips_eabi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
if (len > regsize
&& (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION))
{
store_unsigned_integer (valbuf, regsize, VALUE_ADDRESS (arg));
store_unsigned_integer (valbuf, regsize, value_address (arg));
typecode = TYPE_CODE_PTR;
len = regsize;
val = valbuf;

2
gdb/mn10300-tdep.c
View File

@ -1267,7 +1267,7 @@ mn10300_push_dummy_call (struct gdbarch *gdbarch,
/* Change to pointer-to-type. */
arg_len = push_size;
store_unsigned_integer (valbuf, push_size,
VALUE_ADDRESS (*args));
value_address (*args));
val = &valbuf[0];
}
else

9
gdb/p-valprint.c
View File

@ -930,7 +930,7 @@ pascal_object_print_static_field (struct value *val,
if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
{
CORE_ADDR *first_dont_print;
CORE_ADDR *first_dont_print, addr;
int i;
first_dont_print
@ -940,7 +940,7 @@ pascal_object_print_static_field (struct value *val,
while (--i >= 0)
{
if (VALUE_ADDRESS (val) == first_dont_print[i])
if (value_address (val) == first_dont_print[i])
{
fputs_filtered ("<same as static member of an already seen type>",
stream);
@ -948,11 +948,12 @@ pascal_object_print_static_field (struct value *val,
}
}
obstack_grow (&dont_print_statmem_obstack, (char *) &VALUE_ADDRESS (val),
addr = value_address (val);
obstack_grow (&dont_print_statmem_obstack, (char *) &addr,
sizeof (CORE_ADDR));
CHECK_TYPEDEF (type);
pascal_object_print_value_fields (type, value_contents (val), VALUE_ADDRESS (val),
pascal_object_print_value_fields (type, value_contents (val), addr,
stream, recurse, options, NULL, 1);
return;
}

12
gdb/printcmd.c
View File

@ -270,7 +270,7 @@ print_formatted (struct value *val, int size,
int len = TYPE_LENGTH (type);
if (VALUE_LVAL (val) == lval_memory)
next_address = VALUE_ADDRESS (val) + len;
next_address = value_address (val) + len;
if (size)
{
@ -279,9 +279,9 @@ print_formatted (struct value *val, int size,
case 's':
{
struct type *elttype = value_type (val);
next_address = (VALUE_ADDRESS (val)
next_address = (value_address (val)
+ val_print_string (elttype,
VALUE_ADDRESS (val), -1,
value_address (val), -1,
stream, options));
}
return;
@ -289,8 +289,8 @@ print_formatted (struct value *val, int size,
case 'i':
/* We often wrap here if there are long symbolic names. */
wrap_here (" ");
next_address = (VALUE_ADDRESS (val)
+ gdb_print_insn (VALUE_ADDRESS (val), stream,
next_address = (value_address (val)
+ gdb_print_insn (value_address (val), stream,
&branch_delay_insns));
return;
}
@ -1325,7 +1325,7 @@ x_command (char *exp, int from_tty)
if (/* last_format == 'i' && */
TYPE_CODE (value_type (val)) == TYPE_CODE_FUNC
&& VALUE_LVAL (val) == lval_memory)
next_address = VALUE_ADDRESS (val);
next_address = value_address (val);
else
next_address = value_as_address (val);
do_cleanups (old_chain);

2
gdb/tracepoint.c
View File

@ -1144,7 +1144,7 @@ encode_actions (struct breakpoint *t, char ***tdp_actions,
case UNOP_MEMVAL:
/* safe because we know it's a simple expression */
tempval = evaluate_expression (exp);
addr = VALUE_ADDRESS (tempval) + value_offset (tempval);
addr = value_address (tempval);
len = TYPE_LENGTH (check_typedef (exp->elts[1].type));
add_memrange (collect, memrange_absolute, addr, len);
break;

2
gdb/v850-tdep.c
View File

@ -705,7 +705,7 @@ v850_push_dummy_call (struct gdbarch *gdbarch,
if (!v850_type_is_scalar (value_type (*args))
&& TYPE_LENGTH (value_type (*args)) > E_MAX_RETTYPE_SIZE_IN_REGS)
{
store_unsigned_integer (valbuf, 4, VALUE_ADDRESS (*args));
store_unsigned_integer (valbuf, 4, value_address (*args));
len = 4;
val = valbuf;
}

57
gdb/valops.c
View File

@ -254,10 +254,8 @@ value_cast_structs (struct type *type, struct value *v2)
if (v)
{
/* Downcasting is possible (t1 is superclass of v2). */
CORE_ADDR addr2 = VALUE_ADDRESS (v2);
addr2 -= (VALUE_ADDRESS (v)
+ value_offset (v)
+ value_embedded_offset (v));
CORE_ADDR addr2 = value_address (v2);
addr2 -= value_address (v) + value_embedded_offset (v);
return value_at (type, addr2);
}
}
@ -510,8 +508,7 @@ value_cast (struct type *type, struct value *arg2)
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));
else if (code1 == TYPE_CODE_VOID)
{
return value_zero (builtin_type_void, not_lval);
@ -593,7 +590,7 @@ value_at (struct type *type, CORE_ADDR addr)
read_memory (addr, value_contents_all_raw (val), TYPE_LENGTH (type));
VALUE_LVAL (val) = lval_memory;
VALUE_ADDRESS (val) = addr;
set_value_address (val, addr);
return val;
}
@ -611,7 +608,7 @@ value_at_lazy (struct type *type, CORE_ADDR addr)
val = allocate_value_lazy (type);
VALUE_LVAL (val) = lval_memory;
VALUE_ADDRESS (val) = addr;
set_value_address (val, addr);
return val;
}
@ -637,7 +634,7 @@ value_fetch_lazy (struct value *val)
allocate_value_contents (val);
if (VALUE_LVAL (val) == lval_memory)
{
CORE_ADDR addr = VALUE_ADDRESS (val) + value_offset (val);
CORE_ADDR addr = value_address (val);
int length = TYPE_LENGTH (check_typedef (value_enclosing_type (val)));
if (length)
@ -709,7 +706,7 @@ value_fetch_lazy (struct value *val)
VALUE_REGNUM (new_val));
else if (VALUE_LVAL (new_val) == lval_memory)
fprintf_unfiltered (gdb_stdlog, " address=0x%s",
paddr_nz (VALUE_ADDRESS (new_val)));
paddr_nz (value_address (new_val)));
else
fprintf_unfiltered (gdb_stdlog, " computed");
@ -813,16 +810,15 @@ 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),
buffer, changed_len);
read_memory (value_address (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);
changed_addr = value_address (toval);
dest_buffer = buffer;
}
else
{
changed_addr = VALUE_ADDRESS (toval) + value_offset (toval);
changed_addr = value_address (toval);
changed_len = TYPE_LENGTH (type);
dest_buffer = value_contents (fromval);
}
@ -985,11 +981,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_contents_all_raw (val),
TYPE_LENGTH (value_enclosing_type (val)));
VALUE_LVAL (val) = lval_memory;
VALUE_ADDRESS (val) = VALUE_ADDRESS (arg1) + value_offset (arg1);
set_value_address (val, value_address (arg1));
return val;
}
@ -1039,7 +1035,7 @@ address_of_variable (struct symbol *var, struct block *b)
if ((VALUE_LVAL (val) == lval_memory && value_lazy (val))
|| TYPE_CODE (type) == TYPE_CODE_FUNC)
{
CORE_ADDR addr = VALUE_ADDRESS (val);
CORE_ADDR addr = value_address (val);
return value_from_pointer (lookup_pointer_type (type), addr);
}
@ -1155,7 +1151,7 @@ value_coerce_array (struct value *arg1)
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));
}
/* Given a value which is a function, return a value which is a pointer
@ -1170,7 +1166,7 @@ value_coerce_function (struct value *arg1)
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)));
value_address (arg1));
return retval;
}
@ -1205,8 +1201,7 @@ value_addr (struct value *arg1)
/* Get target memory address */
arg2 = value_from_pointer (lookup_pointer_type (value_type (arg1)),
(VALUE_ADDRESS (arg1)
+ value_offset (arg1)
(value_address (arg1)
+ value_embedded_offset (arg1)));
/* This may be a pointer to a base subobject; so remember the
@ -1618,8 +1613,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_address (arg1) + offset);
if (boffset == -1)
error (_("virtual baseclass botch"));
@ -1633,14 +1627,13 @@ search_struct_field (char *name, struct value *arg1, int offset,
CORE_ADDR base_addr;
v2 = allocate_value (basetype);
base_addr =
VALUE_ADDRESS (arg1) + value_offset (arg1) + boffset;
base_addr = value_address (arg1) + boffset;
if (target_read_memory (base_addr,
value_contents_raw (v2),
TYPE_LENGTH (basetype)) != 0)
error (_("virtual baseclass botch"));
VALUE_LVAL (v2) = lval_memory;
VALUE_ADDRESS (v2) = base_addr;
set_value_address (v2, base_addr);
}
else
{
@ -1763,8 +1756,7 @@ search_struct_method (char *name, struct value **arg1p,
if (offset < 0 || offset >= TYPE_LENGTH (type))
{
gdb_byte *tmp = alloca (TYPE_LENGTH (baseclass));
if (target_read_memory (VALUE_ADDRESS (*arg1p)
+ value_offset (*arg1p) + offset,
if (target_read_memory (value_address (*arg1p) + offset,
tmp, TYPE_LENGTH (baseclass)) != 0)
error (_("virtual baseclass botch"));
base_valaddr = tmp;
@ -1773,8 +1765,7 @@ search_struct_method (char *name, struct value **arg1p,
base_valaddr = value_contents (*arg1p) + offset;
base_offset = baseclass_offset (type, i, base_valaddr,
VALUE_ADDRESS (*arg1p)
+ value_offset (*arg1p) + offset);
value_address (*arg1p) + offset);
if (base_offset == -1)
error (_("virtual baseclass botch"));
}
@ -1983,7 +1974,7 @@ find_method_list (struct value **argp, char *method,
base_offset = value_offset (*argp) + offset;
base_offset = baseclass_offset (type, i,
value_contents (*argp) + base_offset,
VALUE_ADDRESS (*argp) + base_offset);
value_address (*argp) + base_offset);
if (base_offset == -1)
error (_("virtual baseclass botch"));
}
@ -2743,7 +2734,7 @@ value_struct_elt_for_reference (struct type *domain, int offset,
result = allocate_value (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f, j)));
cplus_make_method_ptr (value_type (result),
value_contents_writeable (result),
VALUE_ADDRESS (v), 0);
value_address (v), 0);
}
}
return result;
@ -2902,7 +2893,7 @@ value_full_object (struct value *argp,
/* Go back by the computed top_offset from the beginning of the
object, adjusting for the embedded offset of argp if that's what
value_rtti_type used for its computation. */
new_val = value_at_lazy (real_type, VALUE_ADDRESS (argp) - top +
new_val = value_at_lazy (real_type, value_address (argp) - top +
(using_enc ? 0 : value_embedded_offset (argp)));
deprecated_set_value_type (new_val, value_type (argp));
set_value_embedded_offset (new_val, (using_enc

2
gdb/valprint.c
View File

@ -315,7 +315,7 @@ common_val_print (struct value *val, struct ui_file *stream, int recurse,
return 0;
return val_print (value_type (val), value_contents_all (val),
value_embedded_offset (val), VALUE_ADDRESS (val),
value_embedded_offset (val), value_address (val),
stream, recurse, options, language);
}

44
gdb/value.c
View File

@ -249,7 +249,7 @@ allocate_value_lazy (struct type *type)
val->type = type;
val->enclosing_type = type;
VALUE_LVAL (val) = not_lval;
VALUE_ADDRESS (val) = 0;
val->location.address = 0;
VALUE_FRAME_ID (val) = null_frame_id;
val->offset = 0;
val->bitpos = 0;
@ -525,10 +525,30 @@ deprecated_value_lval_hack (struct value *value)
return &value->lval;
}
CORE_ADDR *
deprecated_value_address_hack (struct value *value)
CORE_ADDR
value_address (struct value *value)
{
return &value->location.address;
if (value->lval == lval_internalvar
|| value->lval == lval_internalvar_component)
return 0;
return value->location.address + value->offset;
}
CORE_ADDR
value_raw_address (struct value *value)
{
if (value->lval == lval_internalvar
|| value->lval == lval_internalvar_component)
return 0;
return value->location.address;
}
void
set_value_address (struct value *value, CORE_ADDR addr)
{
gdb_assert (value->lval != lval_internalvar
&& value->lval != lval_internalvar_component);
value->location.address = addr;
}
struct internalvar **
@ -1292,7 +1312,7 @@ value_as_address (struct value *val)
Upon entry to this function, if VAL is a value of type `function'
(that is, TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FUNC), then
VALUE_ADDRESS (val) is the address of the function. This is what
value_address (val) is the address of the function. This is what
you'll get if you evaluate an expression like `main'. The call
to COERCE_ARRAY below actually does all the usual unary
conversions, which includes converting values of type `function'
@ -1312,7 +1332,7 @@ value_as_address (struct value *val)
function, just return its address directly. */
if (TYPE_CODE (value_type (val)) == TYPE_CODE_FUNC
|| TYPE_CODE (value_type (val)) == TYPE_CODE_METHOD)
return VALUE_ADDRESS (val);
return value_address (val);
val = coerce_array (val);
@ -1543,7 +1563,7 @@ value_static_field (struct type *type, int fieldno)
}
if (retval && VALUE_LVAL (retval) == lval_memory)
SET_FIELD_PHYSADDR (TYPE_FIELD (type, fieldno),
VALUE_ADDRESS (retval));
value_address (retval));
}
return retval;
}
@ -1688,7 +1708,7 @@ value_fn_field (struct value **arg1p, struct fn_field *f, int j, struct type *ty
v = allocate_value (ftype);
if (sym)
{
VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
set_value_address (v, BLOCK_START (SYMBOL_BLOCK_VALUE (sym)));
}
else
{
@ -1697,9 +1717,9 @@ value_fn_field (struct value **arg1p, struct fn_field *f, int j, struct type *ty
struct objfile *objfile = msymbol_objfile (msym);
struct gdbarch *gdbarch = get_objfile_arch (objfile);
VALUE_ADDRESS (v)
= gdbarch_convert_from_func_ptr_addr
(gdbarch, SYMBOL_VALUE_ADDRESS (msym), &current_target);
set_value_address (v,
gdbarch_convert_from_func_ptr_addr
(gdbarch, SYMBOL_VALUE_ADDRESS (msym), &current_target));
}
if (arg1p)
@ -1912,7 +1932,7 @@ value_from_contents_and_address (struct type *type,
set_value_lazy (v, 1);
else
memcpy (value_contents_raw (v), valaddr, TYPE_LENGTH (type));
VALUE_ADDRESS (v) = address;
set_value_address (v, address);
VALUE_LVAL (v) = lval_memory;
return v;
}

17
gdb/value.h
View File

@ -272,11 +272,18 @@ extern void set_value_component_location (struct value *component,
extern enum lval_type *deprecated_value_lval_hack (struct value *);
#define VALUE_LVAL(val) (*deprecated_value_lval_hack (val))
/* If lval == lval_memory, this is the address in the inferior. If
lval == lval_register, this is the byte offset into the registers
structure. */
extern CORE_ADDR *deprecated_value_address_hack (struct value *);
#define VALUE_ADDRESS(val) (*deprecated_value_address_hack (val))
/* If lval == lval_memory, return the address in the inferior. If
lval == lval_register, return the byte offset into the registers
structure. Otherwise, return 0. The returned address
includes the offset, if any. */
extern CORE_ADDR value_address (struct value *);
/* Like value_address, except the result does not include value's
offset. */
extern CORE_ADDR value_raw_address (struct value *);
/* Set the address of a value. */
extern void set_value_address (struct value *, CORE_ADDR);
/* Pointer to internal variable. */
extern struct internalvar **deprecated_value_internalvar_hack (struct value *);