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 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.
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;
}
}
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);
/* 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;
}
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);
{
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));
case LOC_LABEL:
/* Put the constant back in target format. */
+ v = allocate_value (type);
if (overlay_debugging)
{
CORE_ADDR addr
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));
if (!addr)
return 0;
addr += SYMBOL_VALUE (var);
+ v = allocate_value_lazy (type);
break;
case LOC_REF_ARG:
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:
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:
error (_("Value of register variable not available."));
addr = value_as_address (regval);
- VALUE_LVAL (v) = lval_memory;
+ v = allocate_value_lazy (type);
}
else
{
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;
break;
}
+ VALUE_LVAL (v) = lval_memory;
set_value_address (v, addr);
- set_value_lazy (v, 1);
return v;
}
&& 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);
}
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."));
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;
}
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;
projects / binutils-gdb.git / commitdiff