return target_translate_tls_address (debaton->objfile, offset);
}
+struct piece_closure
+{
+ /* The number of pieces used to describe this variable. */
+ int n_pieces;
+
+ /* The architecture, used only for DWARF_VALUE_STACK. */
+ struct gdbarch *arch;
+
+ /* The pieces themselves. */
+ struct dwarf_expr_piece *pieces;
+};
+
+/* Allocate a closure for a value formed from separately-described
+ PIECES. */
+
+static struct piece_closure *
+allocate_piece_closure (int n_pieces, struct dwarf_expr_piece *pieces,
+ struct gdbarch *arch)
+{
+ struct piece_closure *c = XZALLOC (struct piece_closure);
+
+ c->n_pieces = n_pieces;
+ c->arch = arch;
+ c->pieces = XCALLOC (n_pieces, struct dwarf_expr_piece);
+
+ memcpy (c->pieces, pieces, n_pieces * sizeof (struct dwarf_expr_piece));
+
+ return c;
+}
+
+static void
+read_pieced_value (struct value *v)
+{
+ int i;
+ long offset = 0;
+ gdb_byte *contents;
+ struct piece_closure *c = (struct piece_closure *) value_computed_closure (v);
+ struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (v));
+
+ contents = value_contents_raw (v);
+ for (i = 0; i < c->n_pieces; i++)
+ {
+ struct dwarf_expr_piece *p = &c->pieces[i];
+ switch (p->location)
+ {
+ case DWARF_VALUE_REGISTER:
+ {
+ struct gdbarch *arch = get_frame_arch (frame);
+ bfd_byte regval[MAX_REGISTER_SIZE];
+ int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch,
+ p->v.expr.value);
+ get_frame_register (frame, gdb_regnum, regval);
+ memcpy (contents + offset, regval, p->size);
+ }
+ break;
+
+ case DWARF_VALUE_MEMORY:
+ if (p->v.expr.in_stack_memory)
+ read_stack (p->v.expr.value, contents + offset, p->size);
+ else
+ read_memory (p->v.expr.value, contents + offset, p->size);
+ break;
+
+ case DWARF_VALUE_STACK:
+ {
+ gdb_byte bytes[sizeof (ULONGEST)];
+ size_t n;
+ int addr_size = gdbarch_addr_bit (c->arch) / 8;
+ store_unsigned_integer (bytes, addr_size,
+ gdbarch_byte_order (c->arch),
+ p->v.expr.value);
+ n = p->size;
+ if (n > addr_size)
+ n = addr_size;
+ memcpy (contents + offset, bytes, n);
+ }
+ break;
+
+ case DWARF_VALUE_LITERAL:
+ {
+ size_t n = p->size;
+ if (n > p->v.literal.length)
+ n = p->v.literal.length;
+ memcpy (contents + offset, p->v.literal.data, n);
+ }
+ break;
+
+ default:
+ internal_error (__FILE__, __LINE__, _("invalid location type"));
+ }
+ offset += p->size;
+ }
+}
+
+static void
+write_pieced_value (struct value *to, struct value *from)
+{
+ int i;
+ long offset = 0;
+ gdb_byte *contents;
+ struct piece_closure *c = (struct piece_closure *) value_computed_closure (to);
+ struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (to));
+
+ if (frame == NULL)
+ {
+ set_value_optimized_out (to, 1);
+ return;
+ }
+
+ contents = value_contents_raw (from);
+ for (i = 0; i < c->n_pieces; i++)
+ {
+ struct dwarf_expr_piece *p = &c->pieces[i];
+ switch (p->location)
+ {
+ case DWARF_VALUE_REGISTER:
+ {
+ struct gdbarch *arch = get_frame_arch (frame);
+ int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->v.expr.value);
+ put_frame_register (frame, gdb_regnum, contents + offset);
+ }
+ break;
+ case DWARF_VALUE_MEMORY:
+ write_memory (p->v.expr.value, contents + offset, p->size);
+ break;
+ default:
+ set_value_optimized_out (to, 1);
+ return;
+ }
+ offset += p->size;
+ }
+}
+
+static void *
+copy_pieced_value_closure (struct value *v)
+{
+ struct piece_closure *c = (struct piece_closure *) value_computed_closure (v);
+
+ return allocate_piece_closure (c->n_pieces, c->pieces, c->arch);
+}
+
+static void
+free_pieced_value_closure (struct value *v)
+{
+ struct piece_closure *c = (struct piece_closure *) value_computed_closure (v);
+
+ xfree (c->pieces);
+ xfree (c);
+}
+
+/* Functions for accessing a variable described by DW_OP_piece. */
+static struct lval_funcs pieced_value_funcs = {
+ read_pieced_value,
+ write_pieced_value,
+ copy_pieced_value_closure,
+ free_pieced_value_closure
+};
+
/* Evaluate a location description, starting at DATA and with length
SIZE, to find the current location of variable VAR in the context
of FRAME. */
dwarf_expr_eval (ctx, data, size);
if (ctx->num_pieces > 0)
{
- int i;
- long offset = 0;
- bfd_byte *contents;
-
- retval = allocate_value (SYMBOL_TYPE (var));
- contents = value_contents_raw (retval);
- for (i = 0; i < ctx->num_pieces; i++)
- {
- struct dwarf_expr_piece *p = &ctx->pieces[i];
- if (p->in_reg)
- {
- struct gdbarch *arch = get_frame_arch (frame);
- bfd_byte regval[MAX_REGISTER_SIZE];
- int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->value);
- get_frame_register (frame, gdb_regnum, regval);
- memcpy (contents + offset, regval, p->size);
- }
- else /* In memory? */
- {
- read_memory (p->value, contents + offset, p->size);
- }
- offset += p->size;
- }
- }
- else if (ctx->in_reg)
- {
- struct gdbarch *arch = get_frame_arch (frame);
- CORE_ADDR dwarf_regnum = dwarf_expr_fetch (ctx, 0);
- int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_regnum);
- retval = value_from_register (SYMBOL_TYPE (var), gdb_regnum, frame);
+ struct piece_closure *c;
+ struct frame_id frame_id = get_frame_id (frame);
+
+ c = allocate_piece_closure (ctx->num_pieces, ctx->pieces, ctx->gdbarch);
+ retval = allocate_computed_value (SYMBOL_TYPE (var),
+ &pieced_value_funcs,
+ c);
+ VALUE_FRAME_ID (retval) = frame_id;
}
else
{
- CORE_ADDR address = dwarf_expr_fetch (ctx, 0);
-
- retval = allocate_value (SYMBOL_TYPE (var));
- VALUE_LVAL (retval) = lval_memory;
- set_value_lazy (retval, 1);
- set_value_stack (retval, 1);
- set_value_address (retval, address);
+ switch (ctx->location)
+ {
+ case DWARF_VALUE_REGISTER:
+ {
+ struct gdbarch *arch = get_frame_arch (frame);
+ CORE_ADDR dwarf_regnum = dwarf_expr_fetch (ctx, 0);
+ int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_regnum);
+ retval = value_from_register (SYMBOL_TYPE (var), gdb_regnum, frame);
+ }
+ break;
+
+ case DWARF_VALUE_MEMORY:
+ {
+ CORE_ADDR address = dwarf_expr_fetch (ctx, 0);
+ int in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
+
+ retval = allocate_value (SYMBOL_TYPE (var));
+ VALUE_LVAL (retval) = lval_memory;
+ set_value_lazy (retval, 1);
+ if (in_stack_memory)
+ set_value_stack (retval, 1);
+ set_value_address (retval, address);
+ }
+ break;
+
+ case DWARF_VALUE_STACK:
+ {
+ gdb_byte bytes[sizeof (ULONGEST)];
+ ULONGEST value = (ULONGEST) dwarf_expr_fetch (ctx, 0);
+ bfd_byte *contents;
+ size_t n = ctx->addr_size;
+
+ store_unsigned_integer (bytes, ctx->addr_size,
+ gdbarch_byte_order (ctx->gdbarch),
+ value);
+ retval = allocate_value (SYMBOL_TYPE (var));
+ contents = value_contents_raw (retval);
+ if (n > TYPE_LENGTH (SYMBOL_TYPE (var)))
+ n = TYPE_LENGTH (SYMBOL_TYPE (var));
+ memcpy (contents, bytes, n);
+ }
+ break;
+
+ case DWARF_VALUE_LITERAL:
+ {
+ bfd_byte *contents;
+ size_t n = ctx->len;
+
+ retval = allocate_value (SYMBOL_TYPE (var));
+ contents = value_contents_raw (retval);
+ if (n > TYPE_LENGTH (SYMBOL_TYPE (var)))
+ n = TYPE_LENGTH (SYMBOL_TYPE (var));
+ memcpy (contents, ctx->data, n);
+ }
+ break;
+
+ default:
+ internal_error (__FILE__, __LINE__, _("invalid location type"));
+ }
}
set_value_initialized (retval, ctx->initialized);
return retval;
}
-
-
-
-
\f
/* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
dwarf_expr_eval (ctx, data, size);
- in_reg = ctx->in_reg;
+ in_reg = ctx->location == DWARF_VALUE_REGISTER;
if (ctx->num_pieces > 0)
{
/* If the location has several pieces, and any of them are in
registers, then we will need a frame to fetch them from. */
for (i = 0; i < ctx->num_pieces; i++)
- if (ctx->pieces[i].in_reg)
+ if (ctx->pieces[i].location == DWARF_VALUE_REGISTER)
in_reg = 1;
}