aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--gdb/ChangeLog24
-rw-r--r--gdb/ada-lang.c16
-rw-r--r--gdb/dwarf2loc.c3
-rw-r--r--gdb/findvar.c40
-rw-r--r--gdb/valarith.c10
-rw-r--r--gdb/valops.c2
-rw-r--r--gdb/value.c12
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 <jan.kratochvil@redhat.com>
+
+ 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 <aburgess@broadcom.com>
* 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;
generated by cgit v1.1 at 2024-11-24 07:29:15 +0000