/* DWARF 2 location expression support for GDB.
- Copyright (C) 2003-2015 Free Software Foundation, Inc.
+ Copyright (C) 2003-2016 Free Software Foundation, Inc.
Contributed by Daniel Jacobowitz, MontaVista Software, Inc.
#include "objfiles.h"
#include "block.h"
#include "gdbcmd.h"
-
+#include "complaints.h"
#include "dwarf2.h"
#include "dwarf2expr.h"
#include "dwarf2loc.h"
}
/* Otherwise, a location expression entry.
- If the entry is from a DWO, don't add base address: the entry is
- from .debug_addr which has absolute addresses. */
- if (! baton->from_dwo)
+ If the entry is from a DWO, don't add base address: the entry is from
+ .debug_addr which already has the DWARF "base address". We still add
+ base_offset in case we're debugging a PIE executable. */
+ if (baton->from_dwo)
+ {
+ low += base_offset;
+ high += base_offset;
+ }
+ else
{
low += base_address;
high += base_address;
{
struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
struct gdbarch *gdbarch = get_frame_arch (debaton->frame);
- int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);
+ int regnum = dwarf_reg_to_regnum_or_error (gdbarch, dwarf_regnum);
return address_from_register (regnum, debaton->frame);
}
{
struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
struct gdbarch *gdbarch = get_frame_arch (debaton->frame);
- int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);
+ int regnum = dwarf_reg_to_regnum_or_error (gdbarch, dwarf_regnum);
return value_from_register (type, regnum, debaton->frame);
}
locexpr_find_frame_base_location (struct symbol *framefunc, CORE_ADDR pc,
const gdb_byte **start, size_t *length)
{
- struct dwarf2_locexpr_baton *symbaton = SYMBOL_LOCATION_BATON (framefunc);
+ struct dwarf2_locexpr_baton *symbaton
+ = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (framefunc);
*length = symbaton->size;
*start = symbaton->data;
}
-/* Implement the struct symbol_block_ops::get_frame_base method. */
+/* Implement the struct symbol_block_ops::get_frame_base method for
+ LOC_BLOCK functions using a DWARF expression as its DW_AT_frame_base. */
static CORE_ADDR
-block_op_get_frame_base (struct symbol *framefunc, struct frame_info *frame)
+locexpr_get_frame_base (struct symbol *framefunc, struct frame_info *frame)
{
struct gdbarch *gdbarch;
struct type *type;
gdbarch = get_frame_arch (frame);
type = builtin_type (gdbarch)->builtin_data_ptr;
- dlbaton = SYMBOL_LOCATION_BATON (framefunc);
+ dlbaton = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (framefunc);
SYMBOL_BLOCK_OPS (framefunc)->find_frame_base_location
(framefunc, get_frame_pc (frame), &start, &length);
const struct symbol_block_ops dwarf2_block_frame_base_locexpr_funcs =
{
locexpr_find_frame_base_location,
- block_op_get_frame_base
+ locexpr_get_frame_base
};
/* Implement find_frame_base_location method for LOC_BLOCK functions using
loclist_find_frame_base_location (struct symbol *framefunc, CORE_ADDR pc,
const gdb_byte **start, size_t *length)
{
- struct dwarf2_loclist_baton *symbaton = SYMBOL_LOCATION_BATON (framefunc);
+ struct dwarf2_loclist_baton *symbaton
+ = (struct dwarf2_loclist_baton *) SYMBOL_LOCATION_BATON (framefunc);
*start = dwarf2_find_location_expression (symbaton, length, pc);
}
+/* Implement the struct symbol_block_ops::get_frame_base method for
+ LOC_BLOCK functions using a DWARF location list as its DW_AT_frame_base. */
+
+static CORE_ADDR
+loclist_get_frame_base (struct symbol *framefunc, struct frame_info *frame)
+{
+ struct gdbarch *gdbarch;
+ struct type *type;
+ struct dwarf2_loclist_baton *dlbaton;
+ const gdb_byte *start;
+ size_t length;
+ struct value *result;
+
+ /* If this method is called, then FRAMEFUNC is supposed to be a DWARF block.
+ Thus, it's supposed to provide the find_frame_base_location method as
+ well. */
+ gdb_assert (SYMBOL_BLOCK_OPS (framefunc)->find_frame_base_location != NULL);
+
+ gdbarch = get_frame_arch (frame);
+ type = builtin_type (gdbarch)->builtin_data_ptr;
+ dlbaton = (struct dwarf2_loclist_baton *) SYMBOL_LOCATION_BATON (framefunc);
+
+ SYMBOL_BLOCK_OPS (framefunc)->find_frame_base_location
+ (framefunc, get_frame_pc (frame), &start, &length);
+ result = dwarf2_evaluate_loc_desc (type, frame, start, length,
+ dlbaton->per_cu);
+
+ /* The DW_AT_frame_base attribute contains a location description which
+ computes the base address itself. However, the call to
+ dwarf2_evaluate_loc_desc returns a value representing a variable at
+ that address. The frame base address is thus this variable's
+ address. */
+ return value_address (result);
+}
+
/* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
function uses DWARF location list for its DW_AT_frame_base. */
const struct symbol_block_ops dwarf2_block_frame_base_loclist_funcs =
{
loclist_find_frame_base_location,
- block_op_get_frame_base
+ loclist_get_frame_base
};
/* See dwarf2loc.h. */
static void
dwarf_expr_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset)
{
- struct dwarf_expr_baton *debaton = ctx->baton;
+ struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) ctx->baton;
per_cu_dwarf_call (ctx, die_offset, debaton->per_cu,
ctx->funcs->get_frame_pc, ctx->baton);
dwarf_expr_get_base_type (struct dwarf_expr_context *ctx,
cu_offset die_offset)
{
- struct dwarf_expr_baton *debaton = ctx->baton;
+ struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) ctx->baton;
return dwarf2_get_die_type (die_offset, debaton->per_cu);
}
{
/* Create the initial chain containing all the passed PCs. */
- result = xmalloc (sizeof (*result) + sizeof (*result->call_site)
- * (length - 1));
+ result = ((struct call_site_chain *)
+ xmalloc (sizeof (*result)
+ + sizeof (*result->call_site) * (length - 1)));
result->length = length;
result->callers = result->callees = length;
if (!VEC_empty (call_sitep, chain))
/* DW_AT_GNU_call_site_value is a DWARF expression, not a DWARF
location. Postprocessing of DWARF_VALUE_MEMORY would lose the type from
DWARF block. */
- data = alloca (size + 1);
+ data = (gdb_byte *) alloca (size + 1);
memcpy (data, data_src, size);
data[size] = DW_OP_stack_value;
size_t size;
gdb_assert (ctx->funcs == &dwarf_expr_ctx_funcs);
- debaton = ctx->baton;
+ debaton = (struct dwarf_expr_baton *) ctx->baton;
frame = debaton->frame;
caller_frame = get_prev_frame (frame);
static CORE_ADDR
dwarf_expr_get_obj_addr (void *baton)
{
- struct dwarf_expr_baton *debaton = baton;
+ struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
gdb_assert (debaton != NULL);
if (TYPE_CODE (checked_type) != TYPE_CODE_REF)
return NULL;
- target_val = value_computed_closure (value);
+ target_val = (struct value *) value_computed_closure (value);
value_incref (target_val);
return target_val;
}
static void *
entry_data_value_copy_closure (const struct value *v)
{
- struct value *target_val = value_computed_closure (v);
+ struct value *target_val = (struct value *) value_computed_closure (v);
value_incref (target_val);
return target_val;
static void
entry_data_value_free_closure (struct value *v)
{
- struct value *target_val = value_computed_closure (v);
+ struct value *target_val = (struct value *) value_computed_closure (v);
value_free (target_val);
}
if (buffer_size < this_size)
{
buffer_size = this_size;
- buffer = xrealloc (buffer, buffer_size);
+ buffer = (gdb_byte *) xrealloc (buffer, buffer_size);
}
intermediate_buffer = buffer;
case DWARF_VALUE_REGISTER:
{
struct gdbarch *arch = get_frame_arch (frame);
- int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->v.regno);
+ int gdb_regnum = dwarf_reg_to_regnum_or_error (arch, p->v.regno);
+ int optim, unavail;
+ LONGEST reg_offset = source_offset;
- if (gdb_regnum != -1)
+ if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
+ && this_size < register_size (arch, gdb_regnum))
{
- int optim, unavail;
- int reg_offset = source_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;
- /* 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;
- }
-
- if (!get_frame_register_bytes (frame, gdb_regnum, reg_offset,
- this_size, buffer,
- &optim, &unavail))
- {
- /* Just so garbage doesn't ever shine through. */
- memset (buffer, 0, this_size);
-
- if (optim)
- mark_value_bits_optimized_out (v, offset, this_size_bits);
- if (unavail)
- mark_value_bits_unavailable (v, offset, this_size_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;
}
- else
+
+ if (!get_frame_register_bytes (frame, gdb_regnum, reg_offset,
+ this_size, buffer,
+ &optim, &unavail))
{
- error (_("Unable to access DWARF register number %s"),
- paddress (arch, p->v.regno));
+ /* Just so garbage doesn't ever shine through. */
+ memset (buffer, 0, this_size);
+
+ 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 (buffer_size < this_size)
{
buffer_size = this_size;
- buffer = xrealloc (buffer, buffer_size);
+ buffer = (gdb_byte *) xrealloc (buffer, buffer_size);
}
source_buffer = buffer;
need_bitwise = 1;
case DWARF_VALUE_REGISTER:
{
struct gdbarch *arch = get_frame_arch (frame);
- int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->v.regno);
+ int gdb_regnum = dwarf_reg_to_regnum_or_error (arch, p->v.regno);
+ int reg_offset = dest_offset;
- if (gdb_regnum != -1)
+ if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
+ && this_size <= register_size (arch, gdb_regnum))
{
- int reg_offset = dest_offset;
+ /* Big-endian, and we want less than full size. */
+ reg_offset = register_size (arch, gdb_regnum) - this_size;
+ }
- 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 (need_bitwise)
+ if (!get_frame_register_bytes (frame, gdb_regnum, reg_offset,
+ this_size, buffer,
+ &optim, &unavail))
{
- int optim, unavail;
-
- if (!get_frame_register_bytes (frame, gdb_regnum, reg_offset,
- this_size, buffer,
- &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, dest_offset_bits,
- contents, source_offset_bits,
- this_size_bits,
- bits_big_endian);
+ 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"));
}
-
- put_frame_register_bytes (frame, gdb_regnum, reg_offset,
- this_size, source_buffer);
- }
- else
- {
- error (_("Unable to write to DWARF register number %s"),
- paddress (arch, p->v.regno));
+ copy_bitwise (buffer, 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:
a synthetic pointer. */
static int
-check_pieced_synthetic_pointer (const struct value *value, int bit_offset,
+check_pieced_synthetic_pointer (const struct value *value, LONGEST bit_offset,
int bit_length)
{
struct piece_closure *c
static CORE_ADDR
get_frame_address_in_block_wrapper (void *baton)
{
- return get_frame_address_in_block (baton);
+ return get_frame_address_in_block ((struct frame_info *) baton);
+}
+
+/* Fetch a DW_AT_const_value through a synthetic pointer. */
+
+static struct value *
+fetch_const_value_from_synthetic_pointer (sect_offset die, LONGEST byte_offset,
+ struct dwarf2_per_cu_data *per_cu,
+ 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);
+ bytes = dwarf2_fetch_constant_bytes (die, per_cu, &temp_obstack, &len);
+
+ if (bytes != NULL)
+ {
+ if (byte_offset >= 0
+ && byte_offset + TYPE_LENGTH (TYPE_TARGET_TYPE (type)) <= len)
+ {
+ bytes += byte_offset;
+ result = value_from_contents (TYPE_TARGET_TYPE (type), bytes);
+ }
+ else
+ invalid_synthetic_pointer ();
+ }
+ else
+ result = allocate_optimized_out_value (TYPE_TARGET_TYPE (type));
+
+ do_cleanups (cleanup);
+
+ return result;
+}
+
+/* Fetch the value pointed to by a synthetic pointer. */
+
+static struct value *
+indirect_synthetic_pointer (sect_offset die, LONGEST byte_offset,
+ struct dwarf2_per_cu_data *per_cu,
+ struct frame_info *frame, struct type *type)
+{
+ /* Fetch the location expression of the DIE we're pointing to. */
+ struct dwarf2_locexpr_baton baton
+ = dwarf2_fetch_die_loc_sect_off (die, per_cu,
+ get_frame_address_in_block_wrapper, frame);
+
+ /* If pointed-to DIE has a DW_AT_location, evaluate it and return the
+ resulting value. Otherwise, it may have a DW_AT_const_value instead,
+ or it may've been optimized out. */
+ if (baton.data != NULL)
+ return dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type), frame,
+ baton.data, baton.size, baton.per_cu,
+ byte_offset);
+ else
+ return fetch_const_value_from_synthetic_pointer (die, byte_offset, per_cu,
+ type);
}
/* An implementation of an lval_funcs method to indirect through a
struct type *type;
struct frame_info *frame;
struct dwarf2_locexpr_baton baton;
- int i, bit_offset, bit_length;
+ int i, bit_length;
+ LONGEST bit_offset;
struct dwarf_expr_piece *piece = NULL;
LONGEST byte_offset;
enum bfd_endian byte_order;
break;
}
+ gdb_assert (piece != NULL);
frame = get_selected_frame (_("No frame selected."));
/* This is an offset requested by GDB, such as value subscripts.
TYPE_LENGTH (type), byte_order);
byte_offset += piece->v.ptr.offset;
- gdb_assert (piece);
- baton
- = dwarf2_fetch_die_loc_sect_off (piece->v.ptr.die, c->per_cu,
- get_frame_address_in_block_wrapper,
- frame);
+ return indirect_synthetic_pointer (piece->v.ptr.die, byte_offset, c->per_cu,
+ frame, type);
+}
- if (baton.data != NULL)
- return dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type), frame,
- baton.data, baton.size, baton.per_cu,
- byte_offset);
+/* Implementation of the coerce_ref method of lval_funcs for synthetic C++
+ references. */
- {
- struct obstack temp_obstack;
- struct cleanup *cleanup;
- const gdb_byte *bytes;
- LONGEST len;
- struct value *result;
-
- obstack_init (&temp_obstack);
- cleanup = make_cleanup_obstack_free (&temp_obstack);
-
- bytes = dwarf2_fetch_constant_bytes (piece->v.ptr.die, c->per_cu,
- &temp_obstack, &len);
- if (bytes == NULL)
- result = allocate_optimized_out_value (TYPE_TARGET_TYPE (type));
- else
- {
- if (byte_offset < 0
- || byte_offset + TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > len)
- invalid_synthetic_pointer ();
- bytes += byte_offset;
- result = value_from_contents (TYPE_TARGET_TYPE (type), bytes);
- }
+static struct value *
+coerce_pieced_ref (const struct value *value)
+{
+ struct type *type = check_typedef (value_type (value));
- do_cleanups (cleanup);
- return result;
- }
+ if (value_bits_synthetic_pointer (value, value_embedded_offset (value),
+ TARGET_CHAR_BIT * TYPE_LENGTH (type)))
+ {
+ const struct piece_closure *closure
+ = (struct piece_closure *) value_computed_closure (value);
+ struct frame_info *frame
+ = get_selected_frame (_("No frame selected."));
+
+ /* gdb represents synthetic pointers as pieced values with a single
+ piece. */
+ gdb_assert (closure != NULL);
+ gdb_assert (closure->n_pieces == 1);
+
+ return indirect_synthetic_pointer (closure->pieces->v.ptr.die,
+ closure->pieces->v.ptr.offset,
+ closure->per_cu, frame, type);
+ }
+ else
+ {
+ /* Else: not a synthetic reference; do nothing. */
+ return NULL;
+ }
}
static void *
read_pieced_value,
write_pieced_value,
indirect_pieced_value,
- NULL, /* coerce_ref */
+ coerce_pieced_ref,
check_pieced_synthetic_pointer,
copy_pieced_value_closure,
free_pieced_value_closure
struct gdbarch *arch = get_frame_arch (frame);
int dwarf_regnum
= longest_to_int (value_as_long (dwarf_expr_fetch (ctx, 0)));
- int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_regnum);
+ int gdb_regnum = dwarf_reg_to_regnum_or_error (arch, dwarf_regnum);
if (byte_offset != 0)
error (_("cannot use offset on synthetic pointer to register"));
do_cleanups (value_chain);
- if (gdb_regnum == -1)
- error (_("Unable to access DWARF register number %d"),
- dwarf_regnum);
- 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
- inspecting a register ($pc, $sp, etc.), return a
- generic optimized out value instead, so that we show
- <optimized out> instead of <not saved>. */
- do_cleanups (value_chain);
- tmp = allocate_value (type);
- value_contents_copy (tmp, 0, retval, 0, TYPE_LENGTH (type));
- retval = tmp;
- }
+ 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
+ inspecting a register ($pc, $sp, etc.), return a
+ generic optimized out value instead, so that we show
+ <optimized out> instead of <not saved>. */
+ do_cleanups (value_chain);
+ tmp = allocate_value (type);
+ value_contents_copy (tmp, 0, retval, 0, TYPE_LENGTH (type));
+ retval = tmp;
+ }
}
break;
case DWARF_VALUE_MEMORY:
{
+ struct type *ptr_type;
CORE_ADDR address = dwarf_expr_fetch_address (ctx, 0);
int in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
+ /* DW_OP_deref_size (and possibly other operations too) may
+ create a pointer instead of an address. Ideally, the
+ pointer to address conversion would be performed as part
+ of those operations, but the type of the object to
+ which the address refers is not known at the time of
+ the operation. Therefore, we do the conversion here
+ since the type is readily available. */
+
+ switch (TYPE_CODE (type))
+ {
+ case TYPE_CODE_FUNC:
+ case TYPE_CODE_METHOD:
+ ptr_type = builtin_type (ctx->gdbarch)->builtin_func_ptr;
+ break;
+ default:
+ ptr_type = builtin_type (ctx->gdbarch)->builtin_data_ptr;
+ break;
+ }
+ address = value_as_address (value_from_pointer (ptr_type, address));
+
do_cleanups (value_chain);
retval = value_at_lazy (type, address + byte_offset);
if (in_stack_memory)
{
case PROP_LOCEXPR:
{
- const struct dwarf2_property_baton *baton = prop->data.baton;
+ const struct dwarf2_property_baton *baton
+ = (const struct dwarf2_property_baton *) prop->data.baton;
if (dwarf2_locexpr_baton_eval (&baton->locexpr, frame,
addr_stack ? addr_stack->addr : 0,
case PROP_LOCLIST:
{
- struct dwarf2_property_baton *baton = prop->data.baton;
+ struct dwarf2_property_baton *baton
+ = (struct dwarf2_property_baton *) prop->data.baton;
CORE_ADDR pc = get_frame_address_in_block (frame);
const gdb_byte *data;
struct value *val;
case PROP_ADDR_OFFSET:
{
- struct dwarf2_property_baton *baton = prop->data.baton;
+ struct dwarf2_property_baton *baton
+ = (struct dwarf2_property_baton *) prop->data.baton;
struct property_addr_info *pinfo;
struct value *val;
CORE_ADDR pc,
struct symbol *sym)
{
- struct dwarf2_property_baton *baton = prop->data.baton;
+ struct dwarf2_property_baton *baton
+ = (struct dwarf2_property_baton *) prop->data.baton;
const gdb_byte *data;
size_t size;
struct dwarf2_per_cu_data *per_cu;
static CORE_ADDR
needs_frame_read_addr_from_reg (void *baton, int regnum)
{
- struct needs_frame_baton *nf_baton = baton;
+ struct needs_frame_baton *nf_baton = (struct needs_frame_baton *) baton;
nf_baton->needs_frame = 1;
return 1;
static struct value *
needs_frame_get_reg_value (void *baton, struct type *type, int regnum)
{
- struct needs_frame_baton *nf_baton = baton;
+ struct needs_frame_baton *nf_baton = (struct needs_frame_baton *) baton;
nf_baton->needs_frame = 1;
return value_zero (type, not_lval);
needs_frame_frame_base (void *baton, const gdb_byte **start, size_t * length)
{
static gdb_byte lit0 = DW_OP_lit0;
- struct needs_frame_baton *nf_baton = baton;
+ struct needs_frame_baton *nf_baton = (struct needs_frame_baton *) baton;
*start = &lit0;
*length = 1;
static CORE_ADDR
needs_frame_frame_cfa (void *baton)
{
- struct needs_frame_baton *nf_baton = baton;
+ struct needs_frame_baton *nf_baton = (struct needs_frame_baton *) baton;
nf_baton->needs_frame = 1;
return 1;
static CORE_ADDR
needs_frame_tls_address (void *baton, CORE_ADDR offset)
{
- struct needs_frame_baton *nf_baton = baton;
+ struct needs_frame_baton *nf_baton = (struct needs_frame_baton *) baton;
nf_baton->needs_frame = 1;
return 1;
static void
needs_frame_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset)
{
- struct needs_frame_baton *nf_baton = ctx->baton;
+ struct needs_frame_baton *nf_baton = (struct needs_frame_baton *) ctx->baton;
per_cu_dwarf_call (ctx, die_offset, nf_baton->per_cu,
ctx->funcs->get_frame_pc, ctx->baton);
enum call_site_parameter_kind kind,
union call_site_parameter_u kind_u, int deref_size)
{
- struct needs_frame_baton *nf_baton = ctx->baton;
+ struct needs_frame_baton *nf_baton = (struct needs_frame_baton *) ctx->baton;
nf_baton->needs_frame = 1;
op);
}
-/* See dwarf2loc.h. */
+/* See dwarf2loc.h.
+
+ This is basically a wrapper on gdbarch_dwarf2_reg_to_regnum so that we
+ can issue a complaint, which is better than having every target's
+ implementation of dwarf2_reg_to_regnum do it. */
int
-dwarf2_reg_to_regnum_or_error (struct gdbarch *arch, int dwarf_reg)
+dwarf_reg_to_regnum (struct gdbarch *arch, int dwarf_reg)
{
int reg = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_reg);
+
+ if (reg == -1)
+ {
+ complaint (&symfile_complaints,
+ _("bad DWARF register number %d"), dwarf_reg);
+ }
+ return reg;
+}
+
+/* Subroutine of dwarf_reg_to_regnum_or_error to simplify it.
+ Throw an error because DWARF_REG is bad. */
+
+static void
+throw_bad_regnum_error (ULONGEST dwarf_reg)
+{
+ /* Still want to print -1 as "-1".
+ We *could* have int and ULONGEST versions of dwarf2_reg_to_regnum_or_error
+ but that's overkill for now. */
+ if ((int) dwarf_reg == dwarf_reg)
+ error (_("Unable to access DWARF register number %d"), (int) dwarf_reg);
+ error (_("Unable to access DWARF register number %s"),
+ pulongest (dwarf_reg));
+}
+
+/* See dwarf2loc.h. */
+
+int
+dwarf_reg_to_regnum_or_error (struct gdbarch *arch, ULONGEST dwarf_reg)
+{
+ int reg;
+
+ if (dwarf_reg > INT_MAX)
+ throw_bad_regnum_error (dwarf_reg);
+ /* Yes, we will end up issuing a complaint and an error if DWARF_REG is
+ bad, but that's ok. */
+ reg = dwarf_reg_to_regnum (arch, (int) dwarf_reg);
if (reg == -1)
- error (_("Unable to access DWARF register number %d"), dwarf_reg);
+ throw_bad_regnum_error (dwarf_reg);
return reg;
}
static CORE_ADDR
get_ax_pc (void *baton)
{
- struct agent_expr *expr = baton;
+ struct agent_expr *expr = (struct agent_expr *) baton;
return expr->scope;
}
case DW_OP_reg30:
case DW_OP_reg31:
dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
- loc->u.reg = dwarf2_reg_to_regnum_or_error (arch, op - DW_OP_reg0);
+ loc->u.reg = dwarf_reg_to_regnum_or_error (arch, op - DW_OP_reg0);
loc->kind = axs_lvalue_register;
break;
case DW_OP_regx:
op_ptr = safe_read_uleb128 (op_ptr, op_end, ®);
dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
- loc->u.reg = dwarf2_reg_to_regnum_or_error (arch, reg);
+ loc->u.reg = dwarf_reg_to_regnum_or_error (arch, reg);
loc->kind = axs_lvalue_register;
break;
case DW_OP_breg30:
case DW_OP_breg31:
op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
- i = dwarf2_reg_to_regnum_or_error (arch, op - DW_OP_breg0);
+ i = dwarf_reg_to_regnum_or_error (arch, op - DW_OP_breg0);
ax_reg (expr, i);
if (offset != 0)
{
{
op_ptr = safe_read_uleb128 (op_ptr, op_end, ®);
op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
- i = dwarf2_reg_to_regnum_or_error (arch, reg);
+ i = dwarf_reg_to_regnum_or_error (arch, reg);
ax_reg (expr, i);
if (offset != 0)
{
static struct value *
locexpr_read_variable (struct symbol *symbol, struct frame_info *frame)
{
- struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
+ struct dwarf2_locexpr_baton *dlbaton
+ = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (symbol);
struct value *val;
val = dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol), frame, dlbaton->data,
static struct value *
locexpr_read_variable_at_entry (struct symbol *symbol, struct frame_info *frame)
{
- struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
+ struct dwarf2_locexpr_baton *dlbaton
+ = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (symbol);
return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol), frame, dlbaton->data,
dlbaton->size);
static int
locexpr_read_needs_frame (struct symbol *symbol)
{
- struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
+ struct dwarf2_locexpr_baton *dlbaton
+ = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (symbol);
return dwarf2_loc_desc_needs_frame (dlbaton->data, dlbaton->size,
dlbaton->per_cu);
{
int regnum;
- regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);
+ /* This doesn't use dwarf_reg_to_regnum_or_error on purpose.
+ We'd rather print *something* here than throw an error. */
+ regnum = dwarf_reg_to_regnum (gdbarch, dwarf_regnum);
+ /* gdbarch_register_name may just return "", return something more
+ descriptive for bad register numbers. */
+ if (regnum == -1)
+ {
+ /* The text is output as "$bad_register_number".
+ That is why we use the underscores. */
+ return _("bad_register_number");
+ }
return gdbarch_register_name (gdbarch, regnum);
}
locexpr_describe_location (struct symbol *symbol, CORE_ADDR addr,
struct ui_file *stream)
{
- struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
+ struct dwarf2_locexpr_baton *dlbaton
+ = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (symbol);
struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
int offset_size = dwarf2_per_cu_offset_size (dlbaton->per_cu);
locexpr_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
struct agent_expr *ax, struct axs_value *value)
{
- struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
+ struct dwarf2_locexpr_baton *dlbaton
+ = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (symbol);
unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
if (dlbaton->size == 0)
unsigned char *registers_used,
CORE_ADDR pc, const char *result_name)
{
- struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (sym);
+ struct dwarf2_locexpr_baton *dlbaton
+ = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (sym);
unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
if (dlbaton->size == 0)
static struct value *
loclist_read_variable (struct symbol *symbol, struct frame_info *frame)
{
- struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
+ struct dwarf2_loclist_baton *dlbaton
+ = (struct dwarf2_loclist_baton *) SYMBOL_LOCATION_BATON (symbol);
struct value *val;
const gdb_byte *data;
size_t size;
static struct value *
loclist_read_variable_at_entry (struct symbol *symbol, struct frame_info *frame)
{
- struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
+ struct dwarf2_loclist_baton *dlbaton
+ = (struct dwarf2_loclist_baton *) SYMBOL_LOCATION_BATON (symbol);
const gdb_byte *data;
size_t size;
CORE_ADDR pc;
loclist_describe_location (struct symbol *symbol, CORE_ADDR addr,
struct ui_file *stream)
{
- struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
+ struct dwarf2_loclist_baton *dlbaton
+ = (struct dwarf2_loclist_baton *) SYMBOL_LOCATION_BATON (symbol);
const gdb_byte *loc_ptr, *buf_end;
struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
struct gdbarch *gdbarch = get_objfile_arch (objfile);
loclist_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
struct agent_expr *ax, struct axs_value *value)
{
- struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
+ struct dwarf2_loclist_baton *dlbaton
+ = (struct dwarf2_loclist_baton *) SYMBOL_LOCATION_BATON (symbol);
const gdb_byte *data;
size_t size;
unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
unsigned char *registers_used,
CORE_ADDR pc, const char *result_name)
{
- struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (sym);
+ struct dwarf2_loclist_baton *dlbaton
+ = (struct dwarf2_loclist_baton *) SYMBOL_LOCATION_BATON (sym);
unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
const gdb_byte *data;
size_t size;
projects / deliverable / binutils-gdb.git / blobdiff