#include <vector>
#include <unordered_set>
#include "common/underlying.h"
+#include "common/byte-vector.h"
extern int dwarf_always_disassemble;
struct piece_closure
{
/* Reference count. */
- int refc;
+ int refc = 0;
/* The CU from which this closure's expression came. */
- struct dwarf2_per_cu_data *per_cu;
-
- /* The number of pieces used to describe this variable. */
- int n_pieces;
+ struct dwarf2_per_cu_data *per_cu = NULL;
- /* The pieces themselves. */
- struct dwarf_expr_piece *pieces;
+ /* The pieces describing this variable. */
+ std::vector<dwarf_expr_piece> pieces;
/* Frame ID of frame to which a register value is relative, used
only by DWARF_VALUE_REGISTER. */
static struct piece_closure *
allocate_piece_closure (struct dwarf2_per_cu_data *per_cu,
- int n_pieces, struct dwarf_expr_piece *pieces,
+ std::vector<dwarf_expr_piece> &&pieces,
struct frame_info *frame)
{
- struct piece_closure *c = XCNEW (struct piece_closure);
+ struct piece_closure *c = new piece_closure;
int i;
c->refc = 1;
c->per_cu = per_cu;
- c->n_pieces = n_pieces;
- c->pieces = XCNEWVEC (struct dwarf_expr_piece, n_pieces);
+ c->pieces = std::move (pieces);
if (frame == NULL)
c->frame_id = null_frame_id;
else
c->frame_id = get_frame_id (frame);
- memcpy (c->pieces, pieces, n_pieces * sizeof (struct dwarf_expr_piece));
- for (i = 0; i < n_pieces; ++i)
- if (c->pieces[i].location == DWARF_VALUE_STACK)
- value_incref (c->pieces[i].v.value);
+ for (dwarf_expr_piece &piece : c->pieces)
+ if (piece.location == DWARF_VALUE_STACK)
+ value_incref (piece.v.value);
return c;
}
#endif /* GDB_SELF_TEST */
+/* Return the number of bytes overlapping a contiguous chunk of N_BITS
+ bits whose first bit is located at bit offset START. */
+
+static size_t
+bits_to_bytes (ULONGEST start, ULONGEST n_bits)
+{
+ return (start % 8 + n_bits + 7) / 8;
+}
+
+/* Read or write a pieced value V. If FROM != NULL, operate in "write
+ mode": copy FROM into the pieces comprising V. If FROM == NULL,
+ operate in "read mode": fetch the contents of the (lazy) value V by
+ composing it from its pieces. */
+
static void
-read_pieced_value (struct value *v)
+rw_pieced_value (struct value *v, struct value *from)
{
int i;
- long offset = 0;
+ LONGEST offset = 0, max_offset;
ULONGEST bits_to_skip;
- gdb_byte *contents;
+ gdb_byte *v_contents;
+ const gdb_byte *from_contents;
struct piece_closure *c
= (struct piece_closure *) value_computed_closure (v);
- size_t type_len;
- size_t buffer_size = 0;
- std::vector<gdb_byte> buffer;
+ gdb::byte_vector buffer;
int bits_big_endian
= gdbarch_bits_big_endian (get_type_arch (value_type (v)));
- if (value_type (v) != value_enclosing_type (v))
- internal_error (__FILE__, __LINE__,
- _("Should not be able to create a lazy value with "
- "an enclosing type"));
+ if (from != NULL)
+ {
+ from_contents = value_contents (from);
+ v_contents = NULL;
+ }
+ else
+ {
+ if (value_type (v) != value_enclosing_type (v))
+ internal_error (__FILE__, __LINE__,
+ _("Should not be able to create a lazy value with "
+ "an enclosing type"));
+ v_contents = value_contents_raw (v);
+ from_contents = NULL;
+ }
- contents = value_contents_raw (v);
bits_to_skip = 8 * value_offset (v);
if (value_bitsize (v))
{
bits_to_skip += (8 * value_offset (value_parent (v))
+ value_bitpos (v));
- type_len = value_bitsize (v);
+ if (from != NULL
+ && (gdbarch_byte_order (get_type_arch (value_type (from)))
+ == BFD_ENDIAN_BIG))
+ {
+ /* Use the least significant bits of FROM. */
+ max_offset = 8 * TYPE_LENGTH (value_type (from));
+ offset = max_offset - value_bitsize (v);
+ }
+ else
+ max_offset = value_bitsize (v);
}
else
- type_len = 8 * TYPE_LENGTH (value_type (v));
+ max_offset = 8 * TYPE_LENGTH (value_type (v));
+
+ /* Advance to the first non-skipped piece. */
+ for (i = 0; i < c->pieces.size () && bits_to_skip >= c->pieces[i].size; i++)
+ bits_to_skip -= c->pieces[i].size;
- for (i = 0; i < c->n_pieces && offset < type_len; i++)
+ for (; i < c->pieces.size () && offset < max_offset; i++)
{
struct dwarf_expr_piece *p = &c->pieces[i];
- size_t this_size, this_size_bits;
- long dest_offset_bits, source_offset_bits, source_offset;
- const gdb_byte *intermediate_buffer;
-
- /* Compute size, source, and destination offsets for copying, in
- bits. */
- this_size_bits = p->size;
- if (bits_to_skip > 0 && bits_to_skip >= this_size_bits)
- {
- bits_to_skip -= this_size_bits;
- continue;
- }
- if (bits_to_skip > 0)
- {
- dest_offset_bits = 0;
- source_offset_bits = bits_to_skip;
- this_size_bits -= bits_to_skip;
- bits_to_skip = 0;
- }
- else
- {
- dest_offset_bits = offset;
- source_offset_bits = 0;
- }
- if (this_size_bits > type_len - offset)
- this_size_bits = type_len - offset;
+ size_t this_size_bits, this_size;
- this_size = (this_size_bits + source_offset_bits % 8 + 7) / 8;
- source_offset = source_offset_bits / 8;
- if (buffer_size < this_size)
- {
- buffer_size = this_size;
- buffer.reserve (buffer_size);
- }
- intermediate_buffer = buffer.data ();
+ this_size_bits = p->size - bits_to_skip;
+ if (this_size_bits > max_offset - offset)
+ this_size_bits = max_offset - offset;
- /* Copy from the source to DEST_BUFFER. */
switch (p->location)
{
case DWARF_VALUE_REGISTER:
struct frame_info *frame = frame_find_by_id (c->frame_id);
struct gdbarch *arch = get_frame_arch (frame);
int gdb_regnum = dwarf_reg_to_regnum_or_error (arch, p->v.regno);
+ ULONGEST reg_bits = 8 * register_size (arch, gdb_regnum);
int optim, unavail;
- LONGEST reg_offset = source_offset;
if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
- && this_size < register_size (arch, gdb_regnum))
+ && p->offset + p->size < reg_bits)
{
/* Big-endian, and we want less than full size. */
- reg_offset = register_size (arch, gdb_regnum) - this_size;
- /* We want the lower-order THIS_SIZE_BITS of the bytes
- we extract from the register. */
- source_offset_bits += 8 * this_size - this_size_bits;
+ bits_to_skip += reg_bits - (p->offset + p->size);
}
+ else
+ bits_to_skip += p->offset;
+
+ this_size = bits_to_bytes (bits_to_skip, this_size_bits);
+ buffer.resize (this_size);
- if (!get_frame_register_bytes (frame, gdb_regnum, reg_offset,
- this_size, buffer.data (),
- &optim, &unavail))
+ if (from == NULL)
{
- /* Just so garbage doesn't ever shine through. */
- memset (buffer.data (), 0, this_size);
+ /* Read mode. */
+ if (!get_frame_register_bytes (frame, gdb_regnum,
+ bits_to_skip / 8,
+ this_size, buffer.data (),
+ &optim, &unavail))
+ {
+ if (optim)
+ mark_value_bits_optimized_out (v, offset,
+ this_size_bits);
+ if (unavail)
+ mark_value_bits_unavailable (v, offset,
+ this_size_bits);
+ break;
+ }
- if (optim)
- mark_value_bits_optimized_out (v, offset, this_size_bits);
- if (unavail)
- mark_value_bits_unavailable (v, offset, this_size_bits);
+ copy_bitwise (v_contents, offset,
+ buffer.data (), bits_to_skip % 8,
+ this_size_bits, bits_big_endian);
}
+ else
+ {
+ /* Write mode. */
+ if (bits_to_skip % 8 != 0 || this_size_bits % 8 != 0)
+ {
+ /* Data is copied non-byte-aligned into the register.
+ Need some bits from original register value. */
+ get_frame_register_bytes (frame, gdb_regnum,
+ bits_to_skip / 8,
+ this_size, buffer.data (),
+ &optim, &unavail);
+ if (optim)
+ throw_error (OPTIMIZED_OUT_ERROR,
+ _("Can't do read-modify-write to "
+ "update bitfield; containing word "
+ "has been optimized out"));
+ if (unavail)
+ throw_error (NOT_AVAILABLE_ERROR,
+ _("Can't do read-modify-write to "
+ "update bitfield; containing word "
+ "is unavailable"));
+ }
- copy_bitwise (contents, dest_offset_bits,
- intermediate_buffer, source_offset_bits % 8,
- this_size_bits, bits_big_endian);
+ copy_bitwise (buffer.data (), bits_to_skip % 8,
+ from_contents, offset,
+ this_size_bits, bits_big_endian);
+ put_frame_register_bytes (frame, gdb_regnum,
+ bits_to_skip / 8,
+ this_size, buffer.data ());
+ }
}
break;
case DWARF_VALUE_MEMORY:
- read_value_memory (v, offset,
- p->v.mem.in_stack_memory,
- p->v.mem.addr + source_offset,
- buffer.data (), this_size);
- copy_bitwise (contents, dest_offset_bits,
- intermediate_buffer, source_offset_bits % 8,
- this_size_bits, bits_big_endian);
+ {
+ bits_to_skip += p->offset;
+
+ CORE_ADDR start_addr = p->v.mem.addr + bits_to_skip / 8;
+
+ if (bits_to_skip % 8 == 0 && this_size_bits % 8 == 0
+ && offset % 8 == 0)
+ {
+ /* Everything is byte-aligned; no buffer needed. */
+ if (from != NULL)
+ write_memory_with_notification (start_addr,
+ (from_contents
+ + offset / 8),
+ this_size_bits / 8);
+ else
+ read_value_memory (v, offset,
+ p->v.mem.in_stack_memory,
+ p->v.mem.addr + bits_to_skip / 8,
+ v_contents + offset / 8,
+ this_size_bits / 8);
+ break;
+ }
+
+ this_size = bits_to_bytes (bits_to_skip, this_size_bits);
+ buffer.resize (this_size);
+
+ if (from == NULL)
+ {
+ /* Read mode. */
+ read_value_memory (v, offset,
+ p->v.mem.in_stack_memory,
+ p->v.mem.addr + bits_to_skip / 8,
+ buffer.data (), this_size);
+ copy_bitwise (v_contents, offset,
+ buffer.data (), bits_to_skip % 8,
+ this_size_bits, bits_big_endian);
+ }
+ else
+ {
+ /* Write mode. */
+ if (bits_to_skip % 8 != 0 || this_size_bits % 8 != 0)
+ {
+ if (this_size <= 8)
+ {
+ /* Perform a single read for small sizes. */
+ read_memory (start_addr, buffer.data (),
+ this_size);
+ }
+ else
+ {
+ /* Only the first and last bytes can possibly have
+ any bits reused. */
+ read_memory (start_addr, buffer.data (), 1);
+ read_memory (start_addr + this_size - 1,
+ &buffer[this_size - 1], 1);
+ }
+ }
+
+ copy_bitwise (buffer.data (), bits_to_skip % 8,
+ from_contents, offset,
+ this_size_bits, bits_big_endian);
+ write_memory_with_notification (start_addr,
+ buffer.data (),
+ this_size);
+ }
+ }
break;
case DWARF_VALUE_STACK:
{
+ if (from != NULL)
+ {
+ mark_value_bits_optimized_out (v, offset, this_size_bits);
+ break;
+ }
+
struct objfile *objfile = dwarf2_per_cu_objfile (c->per_cu);
struct gdbarch *objfile_gdbarch = get_objfile_arch (objfile);
ULONGEST stack_value_size_bits
= 8 * TYPE_LENGTH (value_type (p->v.value));
/* Use zeroes if piece reaches beyond stack value. */
- if (p->size > stack_value_size_bits)
+ if (p->offset + p->size > stack_value_size_bits)
break;
/* Piece is anchored at least significant bit end. */
if (gdbarch_byte_order (objfile_gdbarch) == BFD_ENDIAN_BIG)
- source_offset_bits += stack_value_size_bits - p->size;
+ bits_to_skip += stack_value_size_bits - p->offset - p->size;
+ else
+ bits_to_skip += p->offset;
- copy_bitwise (contents, dest_offset_bits,
+ copy_bitwise (v_contents, offset,
value_contents_all (p->v.value),
- source_offset_bits,
+ bits_to_skip,
this_size_bits, bits_big_endian);
}
break;
case DWARF_VALUE_LITERAL:
{
- size_t n = this_size;
+ if (from != NULL)
+ {
+ mark_value_bits_optimized_out (v, offset, this_size_bits);
+ break;
+ }
- if (n > p->v.literal.length - source_offset)
- n = (p->v.literal.length >= source_offset
- ? p->v.literal.length - source_offset
- : 0);
- if (n != 0)
- intermediate_buffer = p->v.literal.data + source_offset;
+ ULONGEST literal_size_bits = 8 * p->v.literal.length;
+ size_t n = this_size_bits;
- copy_bitwise (contents, dest_offset_bits,
- intermediate_buffer, source_offset_bits % 8,
- this_size_bits, bits_big_endian);
+ /* Cut off at the end of the implicit value. */
+ bits_to_skip += p->offset;
+ if (bits_to_skip >= literal_size_bits)
+ break;
+ if (n > literal_size_bits - bits_to_skip)
+ n = literal_size_bits - bits_to_skip;
+
+ copy_bitwise (v_contents, offset,
+ p->v.literal.data, bits_to_skip,
+ n, bits_big_endian);
}
break;
- /* These bits show up as zeros -- but do not cause the value
- to be considered optimized-out. */
case DWARF_VALUE_IMPLICIT_POINTER:
+ if (from != NULL)
+ {
+ mark_value_bits_optimized_out (v, offset, this_size_bits);
+ break;
+ }
+
+ /* These bits show up as zeros -- but do not cause the value to
+ be considered optimized-out. */
break;
case DWARF_VALUE_OPTIMIZED_OUT:
}
offset += this_size_bits;
+ bits_to_skip = 0;
}
}
+
static void
-write_pieced_value (struct value *to, struct value *from)
+read_pieced_value (struct value *v)
{
- int i;
- long offset = 0;
- ULONGEST bits_to_skip;
- const gdb_byte *contents;
- struct piece_closure *c
- = (struct piece_closure *) value_computed_closure (to);
- size_t type_len;
- size_t buffer_size = 0;
- std::vector<gdb_byte> buffer;
- int bits_big_endian
- = gdbarch_bits_big_endian (get_type_arch (value_type (to)));
-
- contents = value_contents (from);
- bits_to_skip = 8 * value_offset (to);
- if (value_bitsize (to))
- {
- bits_to_skip += (8 * value_offset (value_parent (to))
- + value_bitpos (to));
- type_len = value_bitsize (to);
- }
- else
- type_len = 8 * TYPE_LENGTH (value_type (to));
-
- for (i = 0; i < c->n_pieces && offset < type_len; i++)
- {
- struct dwarf_expr_piece *p = &c->pieces[i];
- size_t this_size_bits, this_size;
- long dest_offset_bits, source_offset_bits, dest_offset, source_offset;
- int need_bitwise;
- const gdb_byte *source_buffer;
-
- this_size_bits = p->size;
- if (bits_to_skip > 0 && bits_to_skip >= this_size_bits)
- {
- bits_to_skip -= this_size_bits;
- continue;
- }
- if (bits_to_skip > 0)
- {
- dest_offset_bits = bits_to_skip;
- source_offset_bits = 0;
- this_size_bits -= bits_to_skip;
- bits_to_skip = 0;
- }
- else
- {
- dest_offset_bits = 0;
- source_offset_bits = offset;
- }
- if (this_size_bits > type_len - offset)
- this_size_bits = type_len - offset;
-
- this_size = (this_size_bits + dest_offset_bits % 8 + 7) / 8;
- source_offset = source_offset_bits / 8;
- dest_offset = dest_offset_bits / 8;
-
- /* Check whether the data can be transferred byte-wise. */
- if (dest_offset_bits % 8 == 0 && source_offset_bits % 8 == 0
- && this_size_bits % 8 == 0)
- {
- source_buffer = contents + source_offset;
- need_bitwise = 0;
- }
- else
- {
- if (buffer_size < this_size)
- {
- buffer_size = this_size;
- buffer.reserve (buffer_size);
- }
- source_buffer = buffer.data ();
- need_bitwise = 1;
- }
-
- switch (p->location)
- {
- case DWARF_VALUE_REGISTER:
- {
- struct frame_info *frame = frame_find_by_id (c->frame_id);
- struct gdbarch *arch = get_frame_arch (frame);
- int gdb_regnum = dwarf_reg_to_regnum_or_error (arch, p->v.regno);
- int reg_offset = dest_offset;
-
- if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
- && this_size <= register_size (arch, gdb_regnum))
- {
- /* Big-endian, and we want less than full size. */
- reg_offset = register_size (arch, gdb_regnum) - this_size;
- }
-
- if (need_bitwise)
- {
- int optim, unavail;
-
- if (!get_frame_register_bytes (frame, gdb_regnum, reg_offset,
- this_size, buffer.data (),
- &optim, &unavail))
- {
- if (optim)
- throw_error (OPTIMIZED_OUT_ERROR,
- _("Can't do read-modify-write to "
- "update bitfield; containing word "
- "has been optimized out"));
- if (unavail)
- throw_error (NOT_AVAILABLE_ERROR,
- _("Can't do read-modify-write to update "
- "bitfield; containing word "
- "is unavailable"));
- }
- copy_bitwise (buffer.data (), dest_offset_bits,
- contents, source_offset_bits,
- this_size_bits,
- bits_big_endian);
- }
-
- put_frame_register_bytes (frame, gdb_regnum, reg_offset,
- this_size, source_buffer);
- }
- break;
- case DWARF_VALUE_MEMORY:
- if (need_bitwise)
- {
- /* Only the first and last bytes can possibly have any
- bits reused. */
- read_memory (p->v.mem.addr + dest_offset, buffer.data (), 1);
- read_memory (p->v.mem.addr + dest_offset + this_size - 1,
- &buffer[this_size - 1], 1);
- copy_bitwise (buffer.data (), dest_offset_bits,
- contents, source_offset_bits,
- this_size_bits,
- bits_big_endian);
- }
+ rw_pieced_value (v, NULL);
+}
- write_memory (p->v.mem.addr + dest_offset,
- source_buffer, this_size);
- break;
- default:
- mark_value_bytes_optimized_out (to, 0, TYPE_LENGTH (value_type (to)));
- break;
- }
- offset += this_size_bits;
- }
+static void
+write_pieced_value (struct value *to, struct value *from)
+{
+ rw_pieced_value (to, from);
}
/* An implementation of an lval_funcs method to see whether a value is
if (value_bitsize (value))
bit_offset += value_bitpos (value);
- for (i = 0; i < c->n_pieces && bit_length > 0; i++)
+ for (i = 0; i < c->pieces.size () && bit_length > 0; i++)
{
struct dwarf_expr_piece *p = &c->pieces[i];
size_t this_size_bits = p->size;
struct type *type)
{
struct value *result = NULL;
- struct obstack temp_obstack;
- struct cleanup *cleanup;
const gdb_byte *bytes;
LONGEST len;
- obstack_init (&temp_obstack);
- cleanup = make_cleanup_obstack_free (&temp_obstack);
+ auto_obstack temp_obstack;
bytes = dwarf2_fetch_constant_bytes (die, per_cu, &temp_obstack, &len);
if (bytes != NULL)
else
result = allocate_optimized_out_value (TYPE_TARGET_TYPE (type));
- do_cleanups (cleanup);
-
return result;
}
if (value_bitsize (value))
bit_offset += value_bitpos (value);
- for (i = 0; i < c->n_pieces && bit_length > 0; i++)
+ for (i = 0; i < c->pieces.size () && bit_length > 0; i++)
{
struct dwarf_expr_piece *p = &c->pieces[i];
size_t this_size_bits = p->size;
/* gdb represents synthetic pointers as pieced values with a single
piece. */
gdb_assert (closure != NULL);
- gdb_assert (closure->n_pieces == 1);
+ gdb_assert (closure->pieces.size () == 1);
- return indirect_synthetic_pointer (closure->pieces->v.ptr.die_sect_off,
- closure->pieces->v.ptr.offset,
- closure->per_cu, frame, type);
+ return indirect_synthetic_pointer
+ (closure->pieces[0].v.ptr.die_sect_off,
+ closure->pieces[0].v.ptr.offset,
+ closure->per_cu, frame, type);
}
else
{
--c->refc;
if (c->refc == 0)
{
- int i;
-
- for (i = 0; i < c->n_pieces; ++i)
- if (c->pieces[i].location == DWARF_VALUE_STACK)
- value_free (c->pieces[i].v.value);
+ for (dwarf_expr_piece &p : c->pieces)
+ if (p.location == DWARF_VALUE_STACK)
+ value_free (p.v.value);
- xfree (c->pieces);
- xfree (c);
+ delete c;
}
}
}
END_CATCH
- if (ctx.num_pieces > 0)
+ if (ctx.pieces.size () > 0)
{
struct piece_closure *c;
ULONGEST bit_size = 0;
int i;
- for (i = 0; i < ctx.num_pieces; ++i)
- bit_size += ctx.pieces[i].size;
- if (8 * (subobj_byte_offset + TYPE_LENGTH (subobj_type)) > bit_size)
+ for (dwarf_expr_piece &piece : ctx.pieces)
+ bit_size += piece.size;
+ /* Complain if the expression is larger than the size of the
+ outer type. */
+ if (bit_size > 8 * TYPE_LENGTH (type))
invalid_synthetic_pointer ();
- c = allocate_piece_closure (per_cu, ctx.num_pieces, ctx.pieces,
- frame);
+ c = allocate_piece_closure (per_cu, std::move (ctx.pieces), frame);
/* We must clean up the value chain after creating the piece
closure but before allocating the result. */
free_values.free_to_mark ();
{
struct type *ptr_type;
CORE_ADDR address = ctx.fetch_address (0);
- int in_stack_memory = ctx.fetch_in_stack_memory (0);
+ bool in_stack_memory = ctx.fetch_in_stack_memory (0);
/* DW_OP_deref_size (and possibly other operations too) may
create a pointer instead of an address. Ideally, the
size_t len = TYPE_LENGTH (subobj_type);
size_t max = TYPE_LENGTH (type);
struct gdbarch *objfile_gdbarch = get_objfile_arch (objfile);
- struct cleanup *cleanup;
if (subobj_byte_offset + len > max)
invalid_synthetic_pointer ();
below. */
value_incref (value);
free_values.free_to_mark ();
- cleanup = make_cleanup_value_free (value);
+ gdb_value_up value_holder (value);
retval = allocate_value (subobj_type);
memcpy (value_contents_raw (retval),
value_contents_all (value) + subobj_byte_offset, len);
-
- do_cleanups (cleanup);
}
break;
in_reg = ctx.location == DWARF_VALUE_REGISTER;
- if (ctx.num_pieces > 0)
- {
- int i;
-
- /* 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].location == DWARF_VALUE_REGISTER)
- in_reg = 1;
- }
+ /* If the location has several pieces, and any of them are in
+ registers, then we will need a frame to fetch them from. */
+ for (dwarf_expr_piece &p : ctx.pieces)
+ if (p.location == DWARF_VALUE_REGISTER)
+ in_reg = 1;
if (in_reg)
ctx.needs = SYMBOL_NEEDS_FRAME;
void
dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc,
- struct gdbarch *arch, unsigned int addr_size,
- const gdb_byte *op_ptr, const gdb_byte *op_end,
+ unsigned int addr_size, const gdb_byte *op_ptr,
+ const gdb_byte *op_end,
struct dwarf2_per_cu_data *per_cu)
{
+ gdbarch *arch = expr->gdbarch;
int i;
std::vector<int> dw_labels, patches;
const gdb_byte * const base = op_ptr;
&datastart, &datalen);
op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
- dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size, datastart,
+ dwarf2_compile_expr_to_ax (expr, loc, addr_size, datastart,
datastart + datalen, per_cu);
if (loc->kind == axs_lvalue_register)
require_rvalue (expr, loc);
{
/* Another expression. */
ax_const_l (expr, text_offset);
- dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size,
- cfa_start, cfa_end, per_cu);
+ dwarf2_compile_expr_to_ax (expr, loc, addr_size, cfa_start,
+ cfa_end, per_cu);
}
loc->kind = axs_lvalue_memory;
/* DW_OP_call_ref is currently not supported. */
gdb_assert (block.per_cu == per_cu);
- dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size,
- block.data, block.data + block.size,
- per_cu);
+ dwarf2_compile_expr_to_ax (expr, loc, addr_size, block.data,
+ block.data + block.size, per_cu);
}
break;
any necessary bytecode in AX. */
static void
-locexpr_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
- struct agent_expr *ax, struct axs_value *value)
+locexpr_tracepoint_var_ref (struct symbol *symbol, struct agent_expr *ax,
+ struct axs_value *value)
{
struct dwarf2_locexpr_baton *dlbaton
= (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (symbol);
if (dlbaton->size == 0)
value->optimized_out = 1;
else
- dwarf2_compile_expr_to_ax (ax, value, gdbarch, addr_size,
- dlbaton->data, dlbaton->data + dlbaton->size,
- dlbaton->per_cu);
+ dwarf2_compile_expr_to_ax (ax, value, addr_size, dlbaton->data,
+ dlbaton->data + dlbaton->size, dlbaton->per_cu);
}
/* symbol_computed_ops 'generate_c_location' method. */
/* Describe the location of SYMBOL as an agent value in VALUE, generating
any necessary bytecode in AX. */
static void
-loclist_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
- struct agent_expr *ax, struct axs_value *value)
+loclist_tracepoint_var_ref (struct symbol *symbol, struct agent_expr *ax,
+ struct axs_value *value)
{
struct dwarf2_loclist_baton *dlbaton
= (struct dwarf2_loclist_baton *) SYMBOL_LOCATION_BATON (symbol);
if (size == 0)
value->optimized_out = 1;
else
- dwarf2_compile_expr_to_ax (ax, value, gdbarch, addr_size, data, data + size,
+ dwarf2_compile_expr_to_ax (ax, value, addr_size, data, data + size,
dlbaton->per_cu);
}
loclist_generate_c_location
};
-/* Provide a prototype to silence -Wmissing-prototypes. */
-extern initialize_file_ftype _initialize_dwarf2loc;
-
void
_initialize_dwarf2loc (void)
{
&setdebuglist, &showdebuglist);
#if GDB_SELF_TEST
- register_self_test (selftests::copy_bitwise_tests);
+ selftests::register_test ("copy_bitwise", selftests::copy_bitwise_tests);
#endif
}
projects / deliverable / binutils-gdb.git / blobdiff