/* DWARF 2 location expression support for GDB.
- Copyright (C) 2003-2013 Free Software Foundation, Inc.
+ Copyright (C) 2003-2015 Free Software Foundation, Inc.
Contributed by Daniel Jacobowitz, MontaVista Software, Inc.
#include "ax-gdb.h"
#include "regcache.h"
#include "objfiles.h"
-#include "exceptions.h"
#include "block.h"
#include "gdbcmd.h"
#include "dwarf2expr.h"
#include "dwarf2loc.h"
#include "dwarf2-frame.h"
+#include "compile/compile.h"
-#include "gdb_string.h"
-#include "gdb_assert.h"
+extern int dwarf_always_disassemble;
-DEF_VEC_I(int);
-
-extern int dwarf2_always_disassemble;
-
-static void dwarf_expr_frame_base_1 (struct symbol *framefunc, CORE_ADDR pc,
- const gdb_byte **start, size_t *length);
-
-static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs;
+extern const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs;
static struct value *dwarf2_evaluate_loc_desc_full (struct type *type,
struct frame_info *frame,
DEBUG_LOC_INVALID_ENTRY = -2
};
+/* Helper function which throws an error if a synthetic pointer is
+ invalid. */
+
+static void
+invalid_synthetic_pointer (void)
+{
+ error (_("access outside bounds of object "
+ "referenced via synthetic pointer"));
+}
+
/* Decode the addresses in a non-dwo .debug_loc entry.
A pointer to the next byte to examine is returned in *NEW_PTR.
The encoded low,high addresses are return in *LOW,*HIGH.
/* 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. */
/* Using the frame specified in BATON, return the value of register
REGNUM, treated as a pointer. */
static CORE_ADDR
-dwarf_expr_read_reg (void *baton, int dwarf_regnum)
+dwarf_expr_read_addr_from_reg (void *baton, int dwarf_regnum)
{
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. */
+
+static struct value *
+dwarf_expr_get_reg_value (void *baton, struct type *type, int dwarf_regnum)
+{
+ 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);
+
+ return value_from_register (type, regnum, debaton->frame);
}
/* Read memory at ADDR (length LEN) into BUF. */
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."));
something has gone wrong. */
gdb_assert (framefunc != NULL);
- dwarf_expr_frame_base_1 (framefunc,
- get_frame_address_in_block (debaton->frame),
- start, length);
+ func_get_frame_base_dwarf_block (framefunc,
+ get_frame_address_in_block (debaton->frame),
+ start, length);
}
+/* Implement find_frame_base_location method for LOC_BLOCK functions using
+ DWARF expression for its DW_AT_frame_base. */
+
static void
-dwarf_expr_frame_base_1 (struct symbol *framefunc, CORE_ADDR pc,
- const gdb_byte **start, size_t *length)
+locexpr_find_frame_base_location (struct symbol *framefunc, CORE_ADDR pc,
+ const gdb_byte **start, size_t *length)
{
- if (SYMBOL_LOCATION_BATON (framefunc) == NULL)
- *length = 0;
- else if (SYMBOL_COMPUTED_OPS (framefunc) == &dwarf2_loclist_funcs)
- {
- struct dwarf2_loclist_baton *symbaton;
+ struct dwarf2_locexpr_baton *symbaton = SYMBOL_LOCATION_BATON (framefunc);
- symbaton = SYMBOL_LOCATION_BATON (framefunc);
- *start = dwarf2_find_location_expression (symbaton, length, pc);
- }
- else
+ *length = symbaton->size;
+ *start = symbaton->data;
+}
+
+/* Implement the struct symbol_block_ops::get_frame_base method. */
+
+static CORE_ADDR
+block_op_get_frame_base (struct symbol *framefunc, struct frame_info *frame)
+{
+ struct gdbarch *gdbarch;
+ struct type *type;
+ struct dwarf2_locexpr_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 = 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 expression for its DW_AT_frame_base. */
+
+const struct symbol_block_ops dwarf2_block_frame_base_locexpr_funcs =
+{
+ locexpr_find_frame_base_location,
+ block_op_get_frame_base
+};
+
+/* Implement find_frame_base_location method for LOC_BLOCK functions using
+ DWARF location list for its DW_AT_frame_base. */
+
+static void
+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);
+
+ *start = dwarf2_find_location_expression (symbaton, length, pc);
+}
+
+/* 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
+};
+
+/* See dwarf2loc.h. */
+
+void
+func_get_frame_base_dwarf_block (struct symbol *framefunc, CORE_ADDR pc,
+ const gdb_byte **start, size_t *length)
+{
+ if (SYMBOL_BLOCK_OPS (framefunc) != NULL)
{
- struct dwarf2_locexpr_baton *symbaton;
+ const struct symbol_block_ops *ops_block = SYMBOL_BLOCK_OPS (framefunc);
- symbaton = SYMBOL_LOCATION_BATON (framefunc);
- if (symbaton != NULL)
- {
- *length = symbaton->size;
- *start = symbaton->data;
- }
- else
- *length = 0;
+ ops_block->find_frame_base_location (framefunc, pc, start, length);
}
+ else
+ *length = 0;
if (*length == 0)
error (_("Could not find the frame base for \"%s\"."),
dwarf_block = FIELD_DWARF_BLOCK (call_site->target);
if (dwarf_block == NULL)
{
- struct minimal_symbol *msym;
+ struct bound_minimal_symbol msym;
msym = lookup_minimal_symbol_by_pc (call_site->pc - 1);
throw_error (NO_ENTRY_VALUE_ERROR,
_("DW_AT_GNU_call_site_target is not specified "
"at %s in %s"),
paddress (call_site_gdbarch, call_site->pc),
- msym == NULL ? "???" : SYMBOL_PRINT_NAME (msym));
+ (msym.minsym == NULL ? "???"
+ : MSYMBOL_PRINT_NAME (msym.minsym)));
}
if (caller_frame == NULL)
{
- struct minimal_symbol *msym;
+ struct bound_minimal_symbol msym;
msym = lookup_minimal_symbol_by_pc (call_site->pc - 1);
throw_error (NO_ENTRY_VALUE_ERROR,
"requires known frame which is currently not "
"available at %s in %s"),
paddress (call_site_gdbarch, call_site->pc),
- msym == NULL ? "???" : SYMBOL_PRINT_NAME (msym));
+ (msym.minsym == NULL ? "???"
+ : MSYMBOL_PRINT_NAME (msym.minsym)));
}
caller_arch = get_frame_arch (caller_frame);
case FIELD_LOC_KIND_PHYSNAME:
{
const char *physname;
- struct minimal_symbol *msym;
+ struct bound_minimal_symbol msym;
physname = FIELD_STATIC_PHYSNAME (call_site->target);
/* Handle both the mangled and demangled PHYSNAME. */
msym = lookup_minimal_symbol (physname, NULL, NULL);
- if (msym == NULL)
+ if (msym.minsym == NULL)
{
msym = lookup_minimal_symbol_by_pc (call_site->pc - 1);
throw_error (NO_ENTRY_VALUE_ERROR,
_("Cannot find function \"%s\" for a call site target "
"at %s in %s"),
physname, paddress (call_site_gdbarch, call_site->pc),
- msym == NULL ? "???" : SYMBOL_PRINT_NAME (msym));
+ (msym.minsym == NULL ? "???"
+ : MSYMBOL_PRINT_NAME (msym.minsym)));
}
- return SYMBOL_VALUE_ADDRESS (msym);
+ return BMSYMBOL_VALUE_ADDRESS (msym);
}
case FIELD_LOC_KIND_PHYSADDR:
if (target_addr == verify_addr)
{
- struct minimal_symbol *msym;
+ struct bound_minimal_symbol msym;
msym = lookup_minimal_symbol_by_pc (verify_addr);
throw_error (NO_ENTRY_VALUE_ERROR,
_("DW_OP_GNU_entry_value resolving has found "
"function \"%s\" at %s can call itself via tail "
"calls"),
- msym == NULL ? "???" : SYMBOL_PRINT_NAME (msym),
+ (msym.minsym == NULL ? "???"
+ : MSYMBOL_PRINT_NAME (msym.minsym)),
paddress (gdbarch, verify_addr));
}
tailcall_dump (struct gdbarch *gdbarch, const struct call_site *call_site)
{
CORE_ADDR addr = call_site->pc;
- struct minimal_symbol *msym = lookup_minimal_symbol_by_pc (addr - 1);
+ struct bound_minimal_symbol msym = lookup_minimal_symbol_by_pc (addr - 1);
fprintf_unfiltered (gdb_stdlog, " %s(%s)", paddress (gdbarch, addr),
- msym == NULL ? "???" : SYMBOL_PRINT_NAME (msym));
+ (msym.minsym == NULL ? "???"
+ : MSYMBOL_PRINT_NAME (msym.minsym)));
}
* (length - 1));
result->length = length;
result->callers = result->callees = length;
- memcpy (result->call_site, VEC_address (call_sitep, chain),
- sizeof (*result->call_site) * length);
+ if (!VEC_empty (call_sitep, chain))
+ memcpy (result->call_site, VEC_address (call_sitep, chain),
+ sizeof (*result->call_site) * length);
*resultp = result;
if (entry_values_debug)
/* See call_site_find_chain_1 why there is no way to reach the bottom callee
PC again. In such case there must be two different code paths to reach
- it, therefore some of the former determined intermediate PCs must differ
- and the unambiguous chain gets shortened. */
- gdb_assert (result->callers + result->callees < result->length);
+ it. CALLERS + CALLEES equal to LENGTH in the case of self tail-call. */
+ gdb_assert (result->callers + result->callees <= result->length);
}
/* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
if (retval == NULL)
{
- struct minimal_symbol *msym_caller, *msym_callee;
+ struct bound_minimal_symbol msym_caller, msym_callee;
msym_caller = lookup_minimal_symbol_by_pc (caller_pc);
msym_callee = lookup_minimal_symbol_by_pc (callee_pc);
_("There are no unambiguously determinable intermediate "
"callers or callees between caller function \"%s\" at %s "
"and callee function \"%s\" at %s"),
- (msym_caller == NULL
- ? "???" : SYMBOL_PRINT_NAME (msym_caller)),
+ (msym_caller.minsym == NULL
+ ? "???" : MSYMBOL_PRINT_NAME (msym_caller.minsym)),
paddress (gdbarch, caller_pc),
- (msym_callee == NULL
- ? "???" : SYMBOL_PRINT_NAME (msym_callee)),
+ (msym_callee.minsym == NULL
+ ? "???" : MSYMBOL_PRINT_NAME (msym_callee.minsym)),
paddress (gdbarch, callee_pc));
}
call_site_find_chain (struct gdbarch *gdbarch, CORE_ADDR caller_pc,
CORE_ADDR callee_pc)
{
- volatile struct gdb_exception e;
struct call_site_chain *retval = NULL;
- TRY_CATCH (e, RETURN_MASK_ERROR)
+ TRY
{
retval = call_site_find_chain_1 (gdbarch, caller_pc, callee_pc);
}
- if (e.reason < 0)
+ CATCH (e, RETURN_MASK_ERROR)
{
if (e.error == NO_ENTRY_VALUE_ERROR)
{
else
throw_exception (e);
}
+ END_CATCH
+
return retval;
}
caller_frame = get_prev_frame (frame);
if (gdbarch != frame_unwind_arch (frame))
{
- struct minimal_symbol *msym = lookup_minimal_symbol_by_pc (func_addr);
+ struct bound_minimal_symbol msym
+ = lookup_minimal_symbol_by_pc (func_addr);
struct gdbarch *caller_gdbarch = frame_unwind_arch (frame);
throw_error (NO_ENTRY_VALUE_ERROR,
"(of %s (%s)) does not match caller gdbarch %s"),
gdbarch_bfd_arch_info (gdbarch)->printable_name,
paddress (gdbarch, func_addr),
- msym == NULL ? "???" : SYMBOL_PRINT_NAME (msym),
+ (msym.minsym == NULL ? "???"
+ : MSYMBOL_PRINT_NAME (msym.minsym)),
gdbarch_bfd_arch_info (caller_gdbarch)->printable_name);
}
if (caller_frame == NULL)
{
- struct minimal_symbol *msym = lookup_minimal_symbol_by_pc (func_addr);
+ struct bound_minimal_symbol msym
+ = lookup_minimal_symbol_by_pc (func_addr);
throw_error (NO_ENTRY_VALUE_ERROR, _("DW_OP_GNU_entry_value resolving "
"requires caller of %s (%s)"),
paddress (gdbarch, func_addr),
- msym == NULL ? "???" : SYMBOL_PRINT_NAME (msym));
+ (msym.minsym == NULL ? "???"
+ : MSYMBOL_PRINT_NAME (msym.minsym)));
}
caller_pc = get_frame_pc (caller_frame);
call_site = call_site_for_pc (gdbarch, caller_pc);
{
struct minimal_symbol *target_msym, *func_msym;
- target_msym = lookup_minimal_symbol_by_pc (target_addr);
- func_msym = lookup_minimal_symbol_by_pc (func_addr);
+ target_msym = lookup_minimal_symbol_by_pc (target_addr).minsym;
+ func_msym = lookup_minimal_symbol_by_pc (func_addr).minsym;
throw_error (NO_ENTRY_VALUE_ERROR,
_("DW_OP_GNU_entry_value resolving expects callee %s at %s "
"but the called frame is for %s at %s"),
(target_msym == NULL ? "???"
- : SYMBOL_PRINT_NAME (target_msym)),
+ : MSYMBOL_PRINT_NAME (target_msym)),
paddress (gdbarch, target_addr),
- func_msym == NULL ? "???" : SYMBOL_PRINT_NAME (func_msym),
+ func_msym == NULL ? "???" : MSYMBOL_PRINT_NAME (func_msym),
paddress (gdbarch, func_addr));
}
}
if (iparams == call_site->parameter_count)
{
- struct minimal_symbol *msym = lookup_minimal_symbol_by_pc (caller_pc);
+ struct minimal_symbol *msym
+ = lookup_minimal_symbol_by_pc (caller_pc).minsym;
/* DW_TAG_GNU_call_site_parameter will be missing just if GCC could not
determine its value. */
throw_error (NO_ENTRY_VALUE_ERROR, _("Cannot find matching parameter "
"at DW_TAG_GNU_call_site %s at %s"),
paddress (gdbarch, caller_pc),
- msym == NULL ? "???" : SYMBOL_PRINT_NAME (msym));
+ msym == NULL ? "???" : MSYMBOL_PRINT_NAME (msym));
}
*per_cu_return = call_site->per_cu;
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 */);
int n_pieces, struct dwarf_expr_piece *pieces,
int addr_size)
{
- struct piece_closure *c = XZALLOC (struct piece_closure);
+ struct piece_closure *c = XCNEW (struct piece_closure);
int i;
c->refc = 1;
c->per_cu = per_cu;
c->n_pieces = n_pieces;
c->addr_size = addr_size;
- c->pieces = XCALLOC (n_pieces, struct dwarf_expr_piece);
+ c->pieces = XCNEWVEC (struct dwarf_expr_piece, n_pieces);
memcpy (c->pieces, pieces, n_pieces * sizeof (struct dwarf_expr_piece));
for (i = 0; i < n_pieces; ++i)
struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (v));
size_t type_len;
size_t buffer_size = 0;
- char *buffer = NULL;
+ gdb_byte *buffer = NULL;
struct cleanup *cleanup;
int bits_big_endian
= gdbarch_bits_big_endian (get_type_arch (value_type (v)));
bits_to_skip -= this_size_bits;
continue;
}
- if (this_size_bits > type_len - offset)
- this_size_bits = type_len - offset;
if (bits_to_skip > 0)
{
dest_offset_bits = 0;
dest_offset_bits = offset;
source_offset_bits = 0;
}
+ if (this_size_bits > type_len - offset)
+ this_size_bits = type_len - offset;
this_size = (this_size_bits + source_offset_bits % 8 + 7) / 8;
source_offset = source_offset_bits / 8;
{
struct gdbarch *arch = get_frame_arch (frame);
int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->v.regno);
- 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 (gdb_regnum != -1)
{
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,
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_bytes_unavailable (v, offset, this_size);
+ mark_value_bits_unavailable (v, offset, this_size_bits);
}
}
else
break;
case DWARF_VALUE_OPTIMIZED_OUT:
- set_value_optimized_out (v, 1);
+ mark_value_bits_optimized_out (v, offset, this_size_bits);
break;
default:
struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (to));
size_t type_len;
size_t buffer_size = 0;
- char *buffer = NULL;
+ gdb_byte *buffer = NULL;
struct cleanup *cleanup;
int bits_big_endian
= gdbarch_bits_big_endian (get_type_arch (value_type (to)));
if (frame == NULL)
{
- set_value_optimized_out (to, 1);
+ mark_value_bytes_optimized_out (to, 0, TYPE_LENGTH (value_type (to)));
return;
}
{
struct gdbarch *arch = get_frame_arch (frame);
int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (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 (gdb_regnum != -1)
{
+ 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;
&optim, &unavail))
{
if (optim)
- error (_("Can't do read-modify-write to "
- "update bitfield; containing word has been "
- "optimized out"));
+ 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 "
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. */
int i, bit_offset, bit_length;
struct dwarf_expr_piece *piece = NULL;
LONGEST byte_offset;
+ enum bfd_endian byte_order;
type = check_typedef (value_type (value));
if (TYPE_CODE (type) != TYPE_CODE_PTR)
frame = get_selected_frame (_("No frame selected."));
- /* This is an offset requested by GDB, such as value subcripts. */
- byte_offset = value_as_address (value);
+ /* This is an offset requested by GDB, such as value subscripts.
+ However, due to how synthetic pointers are implemented, this is
+ always presented to us as a pointer type. This means we have to
+ sign-extend it manually as appropriate. Use raw
+ extract_signed_integer directly rather than value_as_address and
+ sign extend afterwards on architectures that would need it
+ (mostly everywhere except MIPS, which has signed addresses) as
+ the later would go through gdbarch_pointer_to_address and thus
+ return a CORE_ADDR with high bits set on architectures that
+ encode address spaces and other things in CORE_ADDR. */
+ byte_order = gdbarch_byte_order (get_frame_arch (frame));
+ byte_offset = extract_signed_integer (value_contents (value),
+ TYPE_LENGTH (type), byte_order);
+ byte_offset += piece->v.ptr.offset;
gdb_assert (piece);
baton
get_frame_address_in_block_wrapper,
frame);
- return dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type), frame,
- baton.data, baton.size, baton.per_cu,
- piece->v.ptr.offset + byte_offset);
+ if (baton.data != NULL)
+ return dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type), frame,
+ baton.data, baton.size, baton.per_cu,
+ byte_offset);
+
+ {
+ 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);
+ }
+
+ do_cleanups (cleanup);
+ return result;
+ }
}
static void *
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,
free_pieced_value_closure
};
-/* Helper function which throws an error if a synthetic pointer is
- invalid. */
-
-static void
-invalid_synthetic_pointer (void)
-{
- error (_("access outside bounds of object "
- "referenced via synthetic pointer"));
-}
-
/* Virtual method table for dwarf2_evaluate_loc_desc_full below. */
-static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs =
+const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs =
{
- dwarf_expr_read_reg,
+ dwarf_expr_read_addr_from_reg,
+ dwarf_expr_get_reg_value,
dwarf_expr_read_mem,
dwarf_expr_frame_base,
dwarf_expr_frame_cfa,
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
struct dwarf_expr_context *ctx;
struct cleanup *old_chain, *value_chain;
struct objfile *objfile = dwarf2_per_cu_objfile (per_cu);
- volatile struct gdb_exception ex;
if (byte_offset < 0)
invalid_synthetic_pointer ();
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);
ctx->baton = &baton;
ctx->funcs = &dwarf_expr_ctx_funcs;
- TRY_CATCH (ex, RETURN_MASK_ERROR)
+ TRY
{
dwarf_expr_eval (ctx, data, size);
}
- if (ex.reason < 0)
+ CATCH (ex, RETURN_MASK_ERROR)
{
if (ex.error == NOT_AVAILABLE_ERROR)
{
else
throw_exception (ex);
}
+ END_CATCH
if (ctx->num_pieces > 0)
{
case DWARF_VALUE_REGISTER:
{
struct gdbarch *arch = get_frame_arch (frame);
- ULONGEST dwarf_regnum = value_as_long (dwarf_expr_fetch (ctx, 0));
+ 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);
if (byte_offset != 0)
error (_("cannot use offset on synthetic pointer to register"));
do_cleanups (value_chain);
- if (gdb_regnum != -1)
- retval = value_from_register (type, gdb_regnum, frame);
- else
- error (_("Unable to access DWARF register number %s"),
- paddress (arch, dwarf_regnum));
+ 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;
+ }
}
break;
int in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
do_cleanups (value_chain);
- retval = allocate_value_lazy (type);
- VALUE_LVAL (retval) = lval_memory;
+ retval = value_at_lazy (type, address + byte_offset);
if (in_stack_memory)
set_value_stack (retval, 1);
- set_value_address (retval, address + byte_offset);
}
break;
return dwarf2_evaluate_loc_desc_full (type, frame, data, size, per_cu, 0);
}
+/* Evaluates a dwarf expression and stores the result in VAL, expecting
+ that the dwarf expression only produces a single CORE_ADDR. FRAME is the
+ frame in which the expression is evaluated. ADDR is a context (location of
+ a variable) and might be needed to evaluate the location expression.
+ Returns 1 on success, 0 otherwise. */
+
+static int
+dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton *dlbaton,
+ struct frame_info *frame,
+ CORE_ADDR addr,
+ CORE_ADDR *valp)
+{
+ struct dwarf_expr_context *ctx;
+ struct dwarf_expr_baton baton;
+ struct objfile *objfile;
+ struct cleanup *cleanup;
+
+ if (dlbaton == NULL || dlbaton->size == 0)
+ return 0;
+
+ ctx = new_dwarf_expr_context ();
+ cleanup = make_cleanup_free_dwarf_expr_context (ctx);
+
+ baton.frame = frame;
+ baton.per_cu = dlbaton->per_cu;
+ baton.obj_address = addr;
+
+ objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
+
+ ctx->gdbarch = get_objfile_arch (objfile);
+ ctx->addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
+ ctx->ref_addr_size = dwarf2_per_cu_ref_addr_size (dlbaton->per_cu);
+ ctx->offset = dwarf2_per_cu_text_offset (dlbaton->per_cu);
+ ctx->funcs = &dwarf_expr_ctx_funcs;
+ ctx->baton = &baton;
+
+ dwarf_expr_eval (ctx, dlbaton->data, dlbaton->size);
+
+ switch (ctx->location)
+ {
+ case DWARF_VALUE_REGISTER:
+ case DWARF_VALUE_MEMORY:
+ case DWARF_VALUE_STACK:
+ *valp = dwarf_expr_fetch_address (ctx, 0);
+ if (ctx->location == DWARF_VALUE_REGISTER)
+ *valp = dwarf_expr_read_addr_from_reg (&baton, *valp);
+ do_cleanups (cleanup);
+ return 1;
+ case DWARF_VALUE_LITERAL:
+ *valp = extract_signed_integer (ctx->data, ctx->len,
+ gdbarch_byte_order (ctx->gdbarch));
+ do_cleanups (cleanup);
+ return 1;
+ /* Unsupported dwarf values. */
+ case DWARF_VALUE_OPTIMIZED_OUT:
+ case DWARF_VALUE_IMPLICIT_POINTER:
+ break;
+ }
+
+ do_cleanups (cleanup);
+ return 0;
+}
+
+/* See dwarf2loc.h. */
+
+int
+dwarf2_evaluate_property (const struct dynamic_prop *prop,
+ struct frame_info *frame,
+ struct property_addr_info *addr_stack,
+ CORE_ADDR *value)
+{
+ if (prop == NULL)
+ return 0;
+
+ if (frame == NULL && has_stack_frames ())
+ frame = get_selected_frame (NULL);
+
+ switch (prop->kind)
+ {
+ case PROP_LOCEXPR:
+ {
+ const struct dwarf2_property_baton *baton = prop->data.baton;
+
+ if (dwarf2_locexpr_baton_eval (&baton->locexpr, frame,
+ addr_stack ? addr_stack->addr : 0,
+ value))
+ {
+ if (baton->referenced_type)
+ {
+ struct value *val = value_at (baton->referenced_type, *value);
+
+ *value = value_as_address (val);
+ }
+ return 1;
+ }
+ }
+ break;
+
+ case PROP_LOCLIST:
+ {
+ struct dwarf2_property_baton *baton = prop->data.baton;
+ CORE_ADDR pc = get_frame_address_in_block (frame);
+ const gdb_byte *data;
+ struct value *val;
+ size_t size;
+
+ data = dwarf2_find_location_expression (&baton->loclist, &size, pc);
+ if (data != NULL)
+ {
+ val = dwarf2_evaluate_loc_desc (baton->referenced_type, frame, data,
+ size, baton->loclist.per_cu);
+ if (!value_optimized_out (val))
+ {
+ *value = value_as_address (val);
+ return 1;
+ }
+ }
+ }
+ break;
+
+ case PROP_CONST:
+ *value = prop->data.const_val;
+ return 1;
+
+ case PROP_ADDR_OFFSET:
+ {
+ struct dwarf2_property_baton *baton = prop->data.baton;
+ struct property_addr_info *pinfo;
+ struct value *val;
+
+ for (pinfo = addr_stack; pinfo != NULL; pinfo = pinfo->next)
+ if (pinfo->type == baton->referenced_type)
+ break;
+ if (pinfo == NULL)
+ error (_("cannot find reference address for offset property"));
+ if (pinfo->valaddr != NULL)
+ val = value_from_contents
+ (baton->offset_info.type,
+ pinfo->valaddr + baton->offset_info.offset);
+ else
+ val = value_at (baton->offset_info.type,
+ pinfo->addr + baton->offset_info.offset);
+ *value = value_as_address (val);
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+/* See dwarf2loc.h. */
+
+void
+dwarf2_compile_property_to_c (struct ui_file *stream,
+ const char *result_name,
+ struct gdbarch *gdbarch,
+ unsigned char *registers_used,
+ const struct dynamic_prop *prop,
+ CORE_ADDR pc,
+ struct symbol *sym)
+{
+ struct dwarf2_property_baton *baton = prop->data.baton;
+ const gdb_byte *data;
+ size_t size;
+ struct dwarf2_per_cu_data *per_cu;
+
+ if (prop->kind == PROP_LOCEXPR)
+ {
+ data = baton->locexpr.data;
+ size = baton->locexpr.size;
+ per_cu = baton->locexpr.per_cu;
+ }
+ else
+ {
+ gdb_assert (prop->kind == PROP_LOCLIST);
+
+ data = dwarf2_find_location_expression (&baton->loclist, &size, pc);
+ per_cu = baton->loclist.per_cu;
+ }
+
+ compile_dwarf_bounds_to_c (stream, result_name, prop, sym, pc,
+ gdbarch, registers_used,
+ dwarf2_per_cu_addr_size (per_cu),
+ data, data + size, per_cu);
+}
+
\f
/* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
/* Reads from registers do require a frame. */
static CORE_ADDR
-needs_frame_read_reg (void *baton, int regnum)
+needs_frame_read_addr_from_reg (void *baton, int regnum)
{
struct needs_frame_baton *nf_baton = baton;
return 1;
}
+/* struct dwarf_expr_context_funcs' "get_reg_value" callback:
+ Reads from registers do require a frame. */
+
+static struct value *
+needs_frame_get_reg_value (void *baton, struct type *type, int regnum)
+{
+ struct needs_frame_baton *nf_baton = baton;
+
+ nf_baton->needs_frame = 1;
+ return value_zero (type, not_lval);
+}
+
/* Reads from memory do not require a frame. */
static void
needs_frame_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
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_read_reg,
+ needs_frame_read_addr_from_reg,
+ needs_frame_get_reg_value,
needs_frame_read_mem,
needs_frame_frame_base,
needs_frame_frame_cfa,
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)
op);
}
-/* A helper function to convert a DWARF register to an arch register.
- ARCH is the architecture.
- DWARF_REG is the register.
- This will throw an exception if the DWARF register cannot be
- translated to an architecture register. */
+/* See dwarf2loc.h. */
-static int
-translate_register (struct gdbarch *arch, int dwarf_reg)
+int
+dwarf2_reg_to_regnum_or_error (struct gdbarch *arch, int dwarf_reg)
{
int reg = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_reg);
if (reg == -1)
{
ULONGEST nbytes = (nbits + 7) / 8;
- gdb_assert (nbits > 0 && nbits <= sizeof (LONGEST));
+ gdb_assert (nbytes > 0 && nbytes <= sizeof (LONGEST));
- if (trace_kludge)
+ if (expr->tracing)
ax_trace_quick (expr, nbytes);
if (nbits <= 8)
unsigned int addr_size_bits = 8 * addr_size;
int bits_big_endian = gdbarch_bits_big_endian (arch);
- offsets = xmalloc ((op_end - op_ptr) * sizeof (int));
+ offsets = XNEWVEC (int, op_end - op_ptr);
cleanups = make_cleanup (xfree, offsets);
for (i = 0; i < op_end - op_ptr; ++i)
while (op_ptr < op_end)
{
- enum dwarf_location_atom op = *op_ptr;
+ enum dwarf_location_atom op = (enum dwarf_location_atom) *op_ptr;
uint64_t uoffset, reg;
int64_t offset;
int i;
case DW_OP_reg30:
case DW_OP_reg31:
dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
- loc->u.reg = translate_register (arch, op - DW_OP_reg0);
+ loc->u.reg = dwarf2_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 = translate_register (arch, reg);
+ loc->u.reg = dwarf2_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 = translate_register (arch, op - DW_OP_breg0);
+ i = dwarf2_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 = translate_register (arch, reg);
+ i = dwarf2_reg_to_regnum_or_error (arch, reg);
ax_reg (expr, i);
if (offset != 0)
{
{
const gdb_byte *datastart;
size_t datalen;
- struct block *b;
+ const struct block *b;
struct symbol *framefunc;
b = block_for_pc (expr->scope);
if (!framefunc)
error (_("No function found for block"));
- dwarf_expr_frame_base_1 (framefunc, expr->scope,
- &datastart, &datalen);
+ func_get_frame_base_dwarf_block (framefunc, expr->scope,
+ &datastart, &datalen);
op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size, datastart,
else
size = addr_size;
- switch (size)
- {
- case 8:
- ax_simple (expr, aop_ref8);
- break;
- case 16:
- ax_simple (expr, aop_ref16);
- break;
- case 32:
- ax_simple (expr, aop_ref32);
- break;
- case 64:
- ax_simple (expr, aop_ref64);
- break;
- default:
- /* Note that get_DW_OP_name will never return
- NULL here. */
- error (_("Unsupported size %d in %s"),
- size, get_DW_OP_name (op));
- }
+ if (size != 1 && size != 2 && size != 4 && size != 8)
+ error (_("Unsupported size %d in %s"),
+ size, get_DW_OP_name (op));
+ access_memory (arch, expr, size * TARGET_CHAR_BIT);
}
break;
break;
case DW_OP_call_frame_cfa:
- dwarf2_compile_cfa_to_ax (expr, loc, arch, expr->scope, per_cu);
- loc->kind = axs_lvalue_memory;
+ {
+ int regnum;
+ CORE_ADDR text_offset;
+ LONGEST off;
+ const gdb_byte *cfa_start, *cfa_end;
+
+ if (dwarf2_fetch_cfa_info (arch, expr->scope, per_cu,
+ ®num, &off,
+ &text_offset, &cfa_start, &cfa_end))
+ {
+ /* Register. */
+ ax_reg (expr, regnum);
+ if (off != 0)
+ {
+ ax_const_l (expr, off);
+ ax_simple (expr, aop_add);
+ }
+ }
+ else
+ {
+ /* Another expression. */
+ ax_const_l (expr, text_offset);
+ dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size,
+ cfa_start, cfa_end, per_cu);
+ }
+
+ loc->kind = axs_lvalue_memory;
+ }
break;
case DW_OP_GNU_push_tls_address:
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;
error (_("No function found for block for symbol \"%s\"."),
SYMBOL_PRINT_NAME (symbol));
- dwarf_expr_frame_base_1 (framefunc, addr, &base_data, &base_size);
+ func_get_frame_base_dwarf_block (framefunc, addr, &base_data, &base_size);
if (base_data[0] >= DW_OP_breg0 && base_data[0] <= DW_OP_breg31)
{
fprintf_filtered (stream,
_("a thread-local variable at offset 0x%s "
"in the thread-local storage for `%s'"),
- phex_nz (offset, addr_size), objfile->name);
+ phex_nz (offset, addr_size), objfile_name (objfile));
data += 1 + addr_size + 1;
}
fprintf_filtered (stream,
_("a thread-local variable at offset 0x%s "
"in the thread-local storage for `%s'"),
- phex_nz (offset, addr_size), objfile->name);
+ phex_nz (offset, addr_size), objfile_name (objfile));
++data;
}
&& (all
|| (data[0] != DW_OP_piece && data[0] != DW_OP_bit_piece)))
{
- enum dwarf_location_atom op = *data++;
+ enum dwarf_location_atom op = (enum dwarf_location_atom) *data++;
uint64_t ul;
int64_t l;
const char *name;
else
fprintf_filtered (stream, _(", and "));
- if (!dwarf2_always_disassemble)
+ if (!dwarf_always_disassemble)
{
data = locexpr_describe_location_piece (symbol, stream,
addr, objfile, per_cu,
get_objfile_arch (objfile),
addr_size, offset_size, data,
data, end, 0,
- dwarf2_always_disassemble,
+ dwarf_always_disassemble,
per_cu);
}
dlbaton->per_cu);
}
+/* symbol_computed_ops 'generate_c_location' method. */
+
+static void
+locexpr_generate_c_location (struct symbol *sym, struct ui_file *stream,
+ struct gdbarch *gdbarch,
+ unsigned char *registers_used,
+ CORE_ADDR pc, const char *result_name)
+{
+ struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (sym);
+ unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
+
+ if (dlbaton->size == 0)
+ error (_("symbol \"%s\" is optimized out"), SYMBOL_NATURAL_NAME (sym));
+
+ compile_dwarf_expr_to_c (stream, result_name,
+ sym, pc, gdbarch, registers_used, addr_size,
+ dlbaton->data, dlbaton->data + dlbaton->size,
+ dlbaton->per_cu);
+}
+
/* The set of location functions used with the DWARF-2 expression
evaluator. */
const struct symbol_computed_ops dwarf2_locexpr_funcs = {
locexpr_read_variable_at_entry,
locexpr_read_needs_frame,
locexpr_describe_location,
- locexpr_tracepoint_var_ref
+ 0, /* location_has_loclist */
+ locexpr_tracepoint_var_ref,
+ locexpr_generate_c_location
};
low += base_address;
high += base_address;
+ low = gdbarch_adjust_dwarf2_addr (gdbarch, low);
+ high = gdbarch_adjust_dwarf2_addr (gdbarch, high);
+
length = extract_unsigned_integer (loc_ptr, 2, byte_order);
loc_ptr += 2;
dlbaton->per_cu);
}
+/* symbol_computed_ops 'generate_c_location' method. */
+
+static void
+loclist_generate_c_location (struct symbol *sym, struct ui_file *stream,
+ struct gdbarch *gdbarch,
+ unsigned char *registers_used,
+ CORE_ADDR pc, const char *result_name)
+{
+ struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (sym);
+ unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
+ const gdb_byte *data;
+ size_t size;
+
+ data = dwarf2_find_location_expression (dlbaton, &size, pc);
+ if (size == 0)
+ error (_("symbol \"%s\" is optimized out"), SYMBOL_NATURAL_NAME (sym));
+
+ compile_dwarf_expr_to_c (stream, result_name,
+ sym, pc, gdbarch, registers_used, addr_size,
+ data, data + size,
+ dlbaton->per_cu);
+}
+
/* The set of location functions used with the DWARF-2 expression
evaluator and location lists. */
const struct symbol_computed_ops dwarf2_loclist_funcs = {
loclist_read_variable_at_entry,
loclist_read_needs_frame,
loclist_describe_location,
- loclist_tracepoint_var_ref
+ 1, /* location_has_loclist */
+ loclist_tracepoint_var_ref,
+ loclist_generate_c_location
};
/* Provide a prototype to silence -Wmissing-prototypes. */