/* DWARF 2 location expression support for GDB.
- Copyright 2003, 2005 Free Software Foundation, Inc.
+ Copyright (C) 2003, 2005 Free Software Foundation, Inc.
Contributed by Daniel Jacobowitz, MontaVista Software, Inc.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA. */
#include "defs.h"
#include "ui-out.h"
For now, only return the first matching location expression; there
can be more than one in the list. */
-static char *
+static gdb_byte *
find_location_expression (struct dwarf2_loclist_baton *baton,
size_t *locexpr_length, CORE_ADDR pc)
{
CORE_ADDR low, high;
- char *loc_ptr, *buf_end;
- unsigned int addr_size = TARGET_ADDR_BIT / TARGET_CHAR_BIT, length;
+ gdb_byte *loc_ptr, *buf_end;
+ int length;
+ unsigned int addr_size = TARGET_ADDR_BIT / TARGET_CHAR_BIT;
CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
/* Adjust base_address for relocatable objects. */
CORE_ADDR base_offset = ANOFFSET (baton->objfile->section_offsets,
struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
CORE_ADDR result, save_addr;
enum lval_type lval_type;
- char *buf;
+ gdb_byte *buf;
int optimized, regnum, realnum, regsize;
regnum = DWARF2_REG_TO_REGNUM (dwarf_regnum);
regsize = register_size (current_gdbarch, regnum);
- buf = (char *) alloca (regsize);
+ buf = alloca (regsize);
frame_register (debaton->frame, regnum, &optimized, &lval_type, &save_addr,
&realnum, buf);
/* Read memory at ADDR (length LEN) into BUF. */
static void
-dwarf_expr_read_mem (void *baton, char *buf, CORE_ADDR addr, size_t len)
+dwarf_expr_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
{
read_memory (addr, buf, len);
}
describing the frame base. Return a pointer to it in START and
its length in LENGTH. */
static void
-dwarf_expr_frame_base (void *baton, unsigned char **start, size_t * length)
+dwarf_expr_frame_base (void *baton, gdb_byte **start, size_t * length)
{
/* FIXME: cagney/2003-03-26: This code should be using
get_frame_base_address(), and then implement a dwarf2 specific
if (SYMBOL_OPS (framefunc) == &dwarf2_loclist_funcs)
{
struct dwarf2_loclist_baton *symbaton;
+ struct frame_info *frame = debaton->frame;
+
symbaton = SYMBOL_LOCATION_BATON (framefunc);
*start = find_location_expression (symbaton, length,
- get_frame_pc (debaton->frame));
+ get_frame_address_in_block (frame));
}
else
{
dwarf_expr_tls_address (void *baton, CORE_ADDR offset)
{
struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
- CORE_ADDR addr;
+ volatile CORE_ADDR addr = 0;
- if (target_get_thread_local_address_p ())
+ if (target_get_thread_local_address_p ()
+ && gdbarch_fetch_tls_load_module_address_p (current_gdbarch))
{
ptid_t ptid = inferior_ptid;
struct objfile *objfile = debaton->objfile;
- volatile struct exception ex;
+ volatile struct gdb_exception ex;
TRY_CATCH (ex, RETURN_MASK_ALL)
{
- addr = target_get_thread_local_address (ptid, objfile, offset);
+ CORE_ADDR lm_addr;
+
+ /* Fetch the load module address for this objfile. */
+ lm_addr = gdbarch_fetch_tls_load_module_address (current_gdbarch,
+ objfile);
+ /* If it's 0, throw the appropriate exception. */
+ if (lm_addr == 0)
+ throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR,
+ _("TLS load module not found"));
+
+ addr = target_get_thread_local_address (ptid, lm_addr, offset);
}
/* If an error occurred, print TLS related messages here. Otherwise,
throw the error to some higher catcher. */
of FRAME. */
static struct value *
dwarf2_evaluate_loc_desc (struct symbol *var, struct frame_info *frame,
- unsigned char *data, unsigned short size,
+ gdb_byte *data, unsigned short size,
struct objfile *objfile)
{
struct gdbarch *arch = get_frame_arch (frame);
dwarf_expr_eval (ctx, data, size);
if (ctx->num_pieces > 0)
{
- /* We haven't implemented splicing together pieces from
- arbitrary sources yet. */
- error (_("The value of variable '%s' is distributed across several\n"
- "locations, and GDB cannot access its value.\n"),
- SYMBOL_NATURAL_NAME (var));
+ int i;
+ long offset = 0;
+ bfd_byte *contents;
+
+ retval = allocate_value (SYMBOL_TYPE (var));
+ contents = value_contents_raw (retval);
+ for (i = 0; i < ctx->num_pieces; i++)
+ {
+ struct dwarf_expr_piece *p = &ctx->pieces[i];
+ if (p->in_reg)
+ {
+ bfd_byte regval[MAX_REGISTER_SIZE];
+ int gdb_regnum = DWARF2_REG_TO_REGNUM (p->value);
+ get_frame_register (frame, gdb_regnum, regval);
+ memcpy (contents + offset, regval, p->size);
+ }
+ else /* In memory? */
+ {
+ read_memory (p->value, contents + offset, p->size);
+ }
+ offset += p->size;
+ }
}
else if (ctx->in_reg)
{
/* Reads from memory do not require a frame. */
static void
-needs_frame_read_mem (void *baton, char *buf, CORE_ADDR addr, size_t len)
+needs_frame_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
{
memset (buf, 0, len);
}
/* Frame-relative accesses do require a frame. */
static void
-needs_frame_frame_base (void *baton, unsigned char **start, size_t * length)
+needs_frame_frame_base (void *baton, gdb_byte **start, size_t * length)
{
- static char lit0 = DW_OP_lit0;
+ static gdb_byte lit0 = DW_OP_lit0;
struct needs_frame_baton *nf_baton = baton;
*start = &lit0;
requires a frame to evaluate. */
static int
-dwarf2_loc_desc_needs_frame (unsigned char *data, unsigned short size)
+dwarf2_loc_desc_needs_frame (gdb_byte *data, unsigned short size)
{
struct needs_frame_baton baton;
struct dwarf_expr_context *ctx;
}
static void
-dwarf2_tracepoint_var_ref (struct symbol * symbol, struct agent_expr * ax,
- struct axs_value * value, unsigned char *data,
+dwarf2_tracepoint_var_ref (struct symbol *symbol, struct agent_expr *ax,
+ struct axs_value *value, gdb_byte *data,
int size)
{
if (size == 0)
as above. */
int frame_reg;
LONGEST frame_offset;
- unsigned char *buf_end;
+ gdb_byte *buf_end;
buf_end = read_sleb128 (data + 1, data + size, &frame_offset);
if (buf_end != data + size)
ax_const_l (ax, frame_offset);
ax_simple (ax, aop_add);
- ax_const_l (ax, frame_offset);
+ value->kind = axs_lvalue_memory;
+ }
+ else if (data[0] >= DW_OP_breg0
+ && data[0] <= DW_OP_breg31)
+ {
+ unsigned int reg;
+ LONGEST offset;
+ gdb_byte *buf_end;
+
+ reg = data[0] - DW_OP_breg0;
+ buf_end = read_sleb128 (data + 1, data + size, &offset);
+ if (buf_end != data + size)
+ error (_("Unexpected opcode after DW_OP_breg%u for symbol \"%s\"."),
+ reg, SYMBOL_PRINT_NAME (symbol));
+
+ ax_reg (ax, reg);
+ ax_const_l (ax, offset);
ax_simple (ax, aop_add);
+
value->kind = axs_lvalue_memory;
}
else
- error (_("Unsupported DWARF opcode in the location of \"%s\"."),
- SYMBOL_PRINT_NAME (symbol));
+ error (_("Unsupported DWARF opcode 0x%x in the location of \"%s\"."),
+ data[0], SYMBOL_PRINT_NAME (symbol));
}
\f
/* Return the value of SYMBOL in FRAME using the DWARF-2 expression
{
struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
struct value *val;
- unsigned char *data;
+ gdb_byte *data;
size_t size;
data = find_location_expression (dlbaton, &size,
- frame ? get_frame_pc (frame) : 0);
+ frame ? get_frame_address_in_block (frame)
+ : 0);
if (data == NULL)
{
val = allocate_value (SYMBOL_TYPE (symbol));
struct axs_value * value)
{
struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
- unsigned char *data;
+ gdb_byte *data;
size_t size;
data = find_location_expression (dlbaton, &size, ax->scope);
projects / binutils-gdb.git / blobdiff