#include "ax-gdb.h"
#include "regcache.h"
#include "objfiles.h"
-#include "exceptions.h"
#include "block.h"
#include "gdbcmd.h"
#include "dwarf2loc.h"
#include "dwarf2-frame.h"
-#include <string.h>
-#include "gdb_assert.h"
-
extern int dwarf2_always_disassemble;
static void dwarf_expr_frame_base_1 (struct symbol *framefunc, CORE_ADDR pc,
/* This is entry PC record present only at entry point
of a function. Verify it is really the function entry point. */
- struct block *pc_block = block_for_pc (pc);
+ const struct block *pc_block = block_for_pc (pc);
struct symbol *pc_func = NULL;
if (pc_block)
{
struct frame_info *frame;
struct dwarf2_per_cu_data *per_cu;
+ CORE_ADDR obj_address;
};
/* Helper functions for dwarf2_evaluate_loc_desc. */
{
struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
struct gdbarch *gdbarch = get_frame_arch (debaton->frame);
- CORE_ADDR result;
- int regnum;
+ int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);
- regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);
- result = address_from_register (builtin_type (gdbarch)->builtin_data_ptr,
- regnum, debaton->frame);
- return result;
+ return address_from_register (regnum, debaton->frame);
}
/* Implement struct dwarf_expr_context_funcs' "get_reg_value" callback. */
this_base method. */
struct symbol *framefunc;
struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
- struct block *bl = get_frame_block (debaton->frame, NULL);
+ const struct block *bl = get_frame_block (debaton->frame, NULL);
if (bl == NULL)
error (_("frame address is not available."));
baton_local.frame = caller_frame;
baton_local.per_cu = caller_per_cu;
+ baton_local.obj_address = 0;
saved_ctx.gdbarch = ctx->gdbarch;
saved_ctx.addr_size = ctx->addr_size;
return dwarf2_read_addr_index (debaton->per_cu, index);
}
+/* Callback function for get_object_address. Return the address of the VLA
+ object. */
+
+static CORE_ADDR
+dwarf_expr_get_obj_addr (void *baton)
+{
+ struct dwarf_expr_baton *debaton = baton;
+
+ gdb_assert (debaton != NULL);
+
+ if (debaton->obj_address == 0)
+ error (_("Location address is not set."));
+
+ return debaton->obj_address;
+}
+
/* VALUE must be of type lval_computed with entry_data_value_funcs. Perform
the indirect method on it, that is use its stored target value, the sole
purpose of entry_data_value_funcs.. */
{
NULL, /* read */
NULL, /* write */
- NULL, /* check_validity */
- NULL, /* check_any_valid */
NULL, /* indirect */
entry_data_value_coerce_ref,
NULL, /* check_synthetic_pointer */
struct value *outer_val, *target_val, *val;
struct call_site_parameter *parameter;
struct dwarf2_per_cu_data *caller_per_cu;
- CORE_ADDR addr;
parameter = dwarf_expr_reg_to_entry_parameter (frame, kind, kind_u,
&caller_per_cu);
target_type, caller_frame,
caller_per_cu);
- /* value_as_address dereferences TYPE_CODE_REF. */
- addr = extract_typed_address (value_contents (outer_val), checked_type);
-
- /* The target entry value has artificial address of the entry value
- reference. */
- VALUE_LVAL (target_val) = lval_memory;
- set_value_address (target_val, addr);
-
release_value (target_val);
val = allocate_computed_value (type, &entry_data_value_funcs,
target_val /* closure */);
memset (buffer, 0, this_size);
if (optim)
- set_value_optimized_out (v, 1);
+ mark_value_bits_optimized_out (v, offset, this_size_bits);
if (unavail)
mark_value_bits_unavailable (v, offset, this_size_bits);
}
break;
case DWARF_VALUE_OPTIMIZED_OUT:
- set_value_optimized_out (v, 1);
+ mark_value_bits_optimized_out (v, offset, this_size_bits);
break;
default:
if (frame == NULL)
{
- set_value_optimized_out (to, 1);
+ mark_value_bytes_optimized_out (to, 0, TYPE_LENGTH (value_type (to)));
return;
}
source_buffer, this_size);
break;
default:
- set_value_optimized_out (to, 1);
+ mark_value_bytes_optimized_out (to, 0, TYPE_LENGTH (value_type (to)));
break;
}
offset += this_size_bits;
do_cleanups (cleanup);
}
-/* A helper function that checks bit validity in a pieced value.
- CHECK_FOR indicates the kind of validity checking.
- DWARF_VALUE_MEMORY means to check whether any bit is valid.
- DWARF_VALUE_OPTIMIZED_OUT means to check whether any bit is
- optimized out.
- DWARF_VALUE_IMPLICIT_POINTER means to check whether the bits are an
- implicit pointer. */
+/* An implementation of an lval_funcs method to see whether a value is
+ a synthetic pointer. */
static int
-check_pieced_value_bits (const struct value *value, int bit_offset,
- int bit_length,
- enum dwarf_value_location check_for)
+check_pieced_synthetic_pointer (const struct value *value, int bit_offset,
+ int bit_length)
{
struct piece_closure *c
= (struct piece_closure *) value_computed_closure (value);
int i;
- int validity = (check_for == DWARF_VALUE_MEMORY
- || check_for == DWARF_VALUE_IMPLICIT_POINTER);
bit_offset += 8 * value_offset (value);
if (value_bitsize (value))
else
bit_length -= this_size_bits;
- if (check_for == DWARF_VALUE_IMPLICIT_POINTER)
- {
- if (p->location != DWARF_VALUE_IMPLICIT_POINTER)
- return 0;
- }
- else if (p->location == DWARF_VALUE_OPTIMIZED_OUT
- || p->location == DWARF_VALUE_IMPLICIT_POINTER)
- {
- if (validity)
- return 0;
- }
- else
- {
- if (!validity)
- return 1;
- }
+ if (p->location != DWARF_VALUE_IMPLICIT_POINTER)
+ return 0;
}
- return validity;
-}
-
-static int
-check_pieced_value_validity (const struct value *value, int bit_offset,
- int bit_length)
-{
- return check_pieced_value_bits (value, bit_offset, bit_length,
- DWARF_VALUE_MEMORY);
-}
-
-static int
-check_pieced_value_invalid (const struct value *value)
-{
- return check_pieced_value_bits (value, 0,
- 8 * TYPE_LENGTH (value_type (value)),
- DWARF_VALUE_OPTIMIZED_OUT);
-}
-
-/* An implementation of an lval_funcs method to see whether a value is
- a synthetic pointer. */
-
-static int
-check_pieced_synthetic_pointer (const struct value *value, int bit_offset,
- int bit_length)
-{
- return check_pieced_value_bits (value, bit_offset, bit_length,
- DWARF_VALUE_IMPLICIT_POINTER);
+ return 1;
}
/* A wrapper function for get_frame_address_in_block. */
static const struct lval_funcs pieced_value_funcs = {
read_pieced_value,
write_pieced_value,
- check_pieced_value_validity,
- check_pieced_value_invalid,
indirect_pieced_value,
NULL, /* coerce_ref */
check_pieced_synthetic_pointer,
dwarf_expr_dwarf_call,
dwarf_expr_get_base_type,
dwarf_expr_push_dwarf_reg_entry_value,
- dwarf_expr_get_addr_index
+ dwarf_expr_get_addr_index,
+ dwarf_expr_get_obj_addr
};
/* Evaluate a location description, starting at DATA and with length
baton.frame = frame;
baton.per_cu = per_cu;
+ baton.obj_address = 0;
ctx = new_dwarf_expr_context ();
old_chain = make_cleanup_free_dwarf_expr_context (ctx);
retval = value_from_register (type, gdb_regnum, frame);
if (value_optimized_out (retval))
{
+ struct value *tmp;
+
/* This means the register has undefined value / was
not saved. As we're computing the location of some
variable etc. in the program, not a value for
generic optimized out value instead, so that we show
<optimized out> instead of <not saved>. */
do_cleanups (value_chain);
- retval = allocate_optimized_out_value (type);
+ tmp = allocate_value (type);
+ value_contents_copy (tmp, 0, retval, 0, TYPE_LENGTH (type));
+ retval = tmp;
}
}
break;
static int
dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton *dlbaton,
- CORE_ADDR addr, CORE_ADDR *valp)
+ CORE_ADDR addr,
+ CORE_ADDR *valp)
{
struct dwarf_expr_context *ctx;
struct dwarf_expr_baton baton;
baton.frame = get_selected_frame (NULL);
baton.per_cu = dlbaton->per_cu;
+ baton.obj_address = addr;
objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
/* See dwarf2loc.h. */
int
-dwarf2_evaluate_property (const struct dynamic_prop *prop, CORE_ADDR address,
- CORE_ADDR *value)
+dwarf2_evaluate_property (const struct dynamic_prop *prop,
+ CORE_ADDR address, CORE_ADDR *value)
{
if (prop == NULL)
return 0;
return 1;
}
+/* DW_OP_push_object_address has a frame already passed through. */
+
+static CORE_ADDR
+needs_get_obj_addr (void *baton)
+{
+ /* Nothing to do. */
+ return 1;
+}
+
/* Virtual method table for dwarf2_loc_desc_needs_frame below. */
static const struct dwarf_expr_context_funcs needs_frame_ctx_funcs =
needs_frame_dwarf_call,
NULL, /* get_base_type */
needs_dwarf_reg_entry_value,
- needs_get_addr_index
+ needs_get_addr_index,
+ needs_get_obj_addr
};
/* Return non-zero iff the location expression at DATA (length SIZE)
{
const gdb_byte *datastart;
size_t datalen;
- struct block *b;
+ const struct block *b;
struct symbol *framefunc;
b = block_for_pc (expr->scope);
unimplemented (op);
break;
+ case DW_OP_push_object_address:
+ unimplemented (op);
+ break;
+
case DW_OP_skip:
offset = extract_signed_integer (op_ptr, 2, byte_order);
op_ptr += 2;
}
else if (data[0] == DW_OP_fbreg)
{
- struct block *b;
+ const struct block *b;
struct symbol *framefunc;
int frame_reg = 0;
int64_t frame_offset;
projects / platform / upstream / binutils.git / blobdiff