From 41e8491fdf450e560451afb71c2d6c20708f78d6 Mon Sep 17 00:00:00 2001 From: Jan Kratochvil Date: Wed, 12 Jan 2011 16:10:05 +0000 Subject: [PATCH] gdb/ Make value allocations more lazy. * ada-lang.c (coerce_unspec_val_to_type): Use allocate_value_lazy instead of allocate_value and set_value_lazy when possible. * dwarf2loc.c (dwarf2_evaluate_loc_desc_full): Use allocate_value_lazy instead of allocate_value and set_value_lazy. * findvar.c (value_of_register_lazy): Likewise. (read_var_value): Remove V preallocation, call just check_typedef in advance. Move allocate_value to LOC_CONST, LOC_LABEL, LOC_CONST_BYTES. Use allocate_value_lazy in LOC_STATIC, LOC_ARG, LOC_REF_ARG, LOC_LOCAL, LOC_BLOCK. Set ADDR instead of set_value_address and break in LOC_BLOCK. Use allocate_value_lazy and remove lval_memory set in LOC_REGPARM_ADDR. Use allocate_value_lazy in LOC_UNRESOLVED and LOC_OPTIMIZED_OUT. Add setting lval_memory at the end, remove set_value_lazy there. * valarith.c (value_subscripted_rvalue): Use allocate_value_lazy instead of allocate_value and set_value_lazy when possible. * valops.c (value_fetch_lazy): Do nop for value_optimized_out VAL. * value.c (allocate_computed_value): Use allocate_value_lazy instead of allocate_value and set_value_lazy. (value_from_contents_and_address): Use allocate_value_lazy instead of allocate_value and set_value_lazy when possible. --- gdb/ChangeLog | 24 ++++++++++++++++++++++++ gdb/ada-lang.c | 16 +++++++++------- gdb/dwarf2loc.c | 3 +-- gdb/findvar.c | 40 +++++++++++++++++++++++----------------- gdb/valarith.c | 10 ++++++---- gdb/valops.c | 2 ++ gdb/value.c | 12 +++++++----- 7 files changed, 72 insertions(+), 35 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index aff33a5..f925b9f 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,27 @@ +2011-01-12 Jan Kratochvil + + Make value allocations more lazy. + * ada-lang.c (coerce_unspec_val_to_type): Use allocate_value_lazy + instead of allocate_value and set_value_lazy when possible. + * dwarf2loc.c (dwarf2_evaluate_loc_desc_full): Use allocate_value_lazy + instead of allocate_value and set_value_lazy. + * findvar.c (value_of_register_lazy): Likewise. + (read_var_value): Remove V preallocation, call just check_typedef in + advance. Move allocate_value to LOC_CONST, LOC_LABEL, + LOC_CONST_BYTES. Use allocate_value_lazy in LOC_STATIC, LOC_ARG, + LOC_REF_ARG, LOC_LOCAL, LOC_BLOCK. Set ADDR instead of + set_value_address and break in LOC_BLOCK. Use allocate_value_lazy and + remove lval_memory set in LOC_REGPARM_ADDR. Use allocate_value_lazy + in LOC_UNRESOLVED and LOC_OPTIMIZED_OUT. Add setting lval_memory at + the end, remove set_value_lazy there. + * valarith.c (value_subscripted_rvalue): Use allocate_value_lazy + instead of allocate_value and set_value_lazy when possible. + * valops.c (value_fetch_lazy): Do nop for value_optimized_out VAL. + * value.c (allocate_computed_value): Use allocate_value_lazy instead + of allocate_value and set_value_lazy. + (value_from_contents_and_address): Use allocate_value_lazy instead of + allocate_value and set_value_lazy when possible. + 2011-01-12 Andrew Burgess * disasm.c (dump_insns): Support dumping opcodes for MI. diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c index 73de1a0..890e091 100644 --- a/gdb/ada-lang.c +++ b/gdb/ada-lang.c @@ -556,17 +556,19 @@ coerce_unspec_val_to_type (struct value *val, struct type *type) trying to allocate some memory for it. */ check_size (type); - result = allocate_value (type); + if (value_lazy (val) + || TYPE_LENGTH (type) > TYPE_LENGTH (value_type (val))) + result = allocate_value_lazy (type); + else + { + result = allocate_value (type); + memcpy (value_contents_raw (result), value_contents (val), + TYPE_LENGTH (type)); + } set_value_component_location (result, val); set_value_bitsize (result, value_bitsize (val)); set_value_bitpos (result, value_bitpos (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); - else - memcpy (value_contents_raw (result), value_contents (val), - TYPE_LENGTH (type)); return result; } } diff --git a/gdb/dwarf2loc.c b/gdb/dwarf2loc.c index 43fb7c5..d9580c6 100644 --- a/gdb/dwarf2loc.c +++ b/gdb/dwarf2loc.c @@ -1123,9 +1123,8 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame, CORE_ADDR address = dwarf_expr_fetch_address (ctx, 0); int in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0); - retval = allocate_value (type); + retval = allocate_value_lazy (type); VALUE_LVAL (retval) = lval_memory; - set_value_lazy (retval, 1); if (in_stack_memory) set_value_stack (retval, 1); set_value_address (retval, address + byte_offset); diff --git a/gdb/findvar.c b/gdb/findvar.c index 718c85b..6463342 100644 --- a/gdb/findvar.c +++ b/gdb/findvar.c @@ -306,11 +306,10 @@ value_of_register_lazy (struct frame_info *frame, int regnum) /* We should have a valid (i.e. non-sentinel) frame. */ gdb_assert (frame_id_p (get_frame_id (frame))); - reg_val = allocate_value (register_type (gdbarch, regnum)); + reg_val = allocate_value_lazy (register_type (gdbarch, regnum)); VALUE_LVAL (reg_val) = lval_register; VALUE_REGNUM (reg_val) = regnum; VALUE_FRAME_ID (reg_val) = get_frame_id (frame); - set_value_lazy (reg_val, 1); return reg_val; } @@ -411,15 +410,12 @@ read_var_value (struct symbol *var, struct frame_info *frame) CORE_ADDR addr; int len; - if (SYMBOL_CLASS (var) == LOC_COMPUTED - || SYMBOL_CLASS (var) == LOC_REGISTER) - /* These cases do not use V. */ - v = NULL; - else - { - v = allocate_value (type); - VALUE_LVAL (v) = lval_memory; /* The most likely possibility. */ - } + /* Call check_typedef on our type to make sure that, if TYPE is + a TYPE_CODE_TYPEDEF, its length is set to the length of the target type + instead of zero. However, we do not replace the typedef type by the + target type, because we want to keep the typedef in order to be able to + set the returned value type description correctly. */ + check_typedef (type); len = TYPE_LENGTH (type); @@ -430,6 +426,7 @@ read_var_value (struct symbol *var, struct frame_info *frame) { case LOC_CONST: /* Put the constant back in target format. */ + v = allocate_value (type); store_signed_integer (value_contents_raw (v), len, gdbarch_byte_order (get_type_arch (type)), (LONGEST) SYMBOL_VALUE (var)); @@ -438,6 +435,7 @@ read_var_value (struct symbol *var, struct frame_info *frame) case LOC_LABEL: /* Put the constant back in target format. */ + v = allocate_value (type); if (overlay_debugging) { CORE_ADDR addr @@ -453,11 +451,13 @@ read_var_value (struct symbol *var, struct frame_info *frame) return v; case LOC_CONST_BYTES: + v = allocate_value (type); memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var), len); VALUE_LVAL (v) = not_lval; return v; case LOC_STATIC: + v = allocate_value_lazy (type); if (overlay_debugging) addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var), SYMBOL_OBJ_SECTION (var)); @@ -470,6 +470,7 @@ read_var_value (struct symbol *var, struct frame_info *frame) if (!addr) return 0; addr += SYMBOL_VALUE (var); + v = allocate_value_lazy (type); break; case LOC_REF_ARG: @@ -483,12 +484,14 @@ read_var_value (struct symbol *var, struct frame_info *frame) argref += SYMBOL_VALUE (var); ref = value_at (lookup_pointer_type (type), argref); addr = value_as_address (ref); + v = allocate_value_lazy (type); break; } case LOC_LOCAL: addr = get_frame_locals_address (frame); addr += SYMBOL_VALUE (var); + v = allocate_value_lazy (type); break; case LOC_TYPEDEF: @@ -496,12 +499,13 @@ read_var_value (struct symbol *var, struct frame_info *frame) break; case LOC_BLOCK: + v = allocate_value_lazy (type); if (overlay_debugging) - set_value_address (v, symbol_overlayed_address - (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_OBJ_SECTION (var))); + addr = symbol_overlayed_address + (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_OBJ_SECTION (var)); else - set_value_address (v, BLOCK_START (SYMBOL_BLOCK_VALUE (var))); - return v; + addr = BLOCK_START (SYMBOL_BLOCK_VALUE (var)); + break; case LOC_REGISTER: case LOC_REGPARM_ADDR: @@ -520,7 +524,7 @@ read_var_value (struct symbol *var, struct frame_info *frame) error (_("Value of register variable not available.")); addr = value_as_address (regval); - VALUE_LVAL (v) = lval_memory; + v = allocate_value_lazy (type); } else { @@ -559,10 +563,12 @@ read_var_value (struct symbol *var, struct frame_info *frame) if (obj_section && (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0) addr = target_translate_tls_address (obj_section->objfile, addr); + v = allocate_value_lazy (type); } break; case LOC_OPTIMIZED_OUT: + v = allocate_value_lazy (type); VALUE_LVAL (v) = not_lval; set_value_optimized_out (v, 1); return v; @@ -572,8 +578,8 @@ read_var_value (struct symbol *var, struct frame_info *frame) break; } + VALUE_LVAL (v) = lval_memory; set_value_address (v, addr); - set_value_lazy (v, 1); return v; } diff --git a/gdb/valarith.c b/gdb/valarith.c index a2bf7b0..265532c 100644 --- a/gdb/valarith.c +++ b/gdb/valarith.c @@ -205,12 +205,14 @@ value_subscripted_rvalue (struct value *array, LONGEST index, int lowerbound) && elt_offs >= TYPE_LENGTH (array_type))) error (_("no such vector element")); - v = allocate_value (elt_type); if (VALUE_LVAL (array) == lval_memory && value_lazy (array)) - set_value_lazy (v, 1); + v = allocate_value_lazy (elt_type); else - memcpy (value_contents_writeable (v), - value_contents (array) + elt_offs, elt_size); + { + v = allocate_value (elt_type); + memcpy (value_contents_writeable (v), + value_contents (array) + elt_offs, elt_size); + } set_value_component_location (v, array); VALUE_REGNUM (v) = VALUE_REGNUM (array); diff --git a/gdb/valops.c b/gdb/valops.c index 9dc51ee..19d5238 100644 --- a/gdb/valops.c +++ b/gdb/valops.c @@ -1104,6 +1104,8 @@ value_fetch_lazy (struct value *val) } else if (VALUE_LVAL (val) == lval_computed) value_computed_funcs (val)->read (val); + else if (value_optimized_out (val)) + /* Keep it optimized out. */; else internal_error (__FILE__, __LINE__, _("Unexpected lazy value type.")); diff --git a/gdb/value.c b/gdb/value.c index 9769d83..db83ea2 100644 --- a/gdb/value.c +++ b/gdb/value.c @@ -332,12 +332,11 @@ allocate_computed_value (struct type *type, struct lval_funcs *funcs, void *closure) { - struct value *v = allocate_value (type); + struct value *v = allocate_value_lazy (type); VALUE_LVAL (v) = lval_computed; v->location.computed.funcs = funcs; v->location.computed.closure = closure; - set_value_lazy (v, 1); return v; } @@ -2400,12 +2399,15 @@ value_from_contents_and_address (struct type *type, const gdb_byte *valaddr, CORE_ADDR address) { - struct value *v = allocate_value (type); + struct value *v; if (valaddr == NULL) - set_value_lazy (v, 1); + v = allocate_value_lazy (type); else - memcpy (value_contents_raw (v), valaddr, TYPE_LENGTH (type)); + { + v = allocate_value (type); + memcpy (value_contents_raw (v), valaddr, TYPE_LENGTH (type)); + } set_value_address (v, address); VALUE_LVAL (v) = lval_memory; return v; -- 2.7.4