#include "ax.h"
#include "ax-gdb.h"
#include "regcache.h"
+#include "objfiles.h"
#include "elf/dwarf2.h"
#include "dwarf2expr.h"
static char *
find_location_expression (struct dwarf2_loclist_baton *baton,
- int *locexpr_length, CORE_ADDR pc)
+ size_t *locexpr_length, CORE_ADDR pc)
{
- CORE_ADDR base_address = baton->base_address;
CORE_ADDR low, high;
char *loc_ptr, *buf_end;
unsigned int addr_size = TARGET_ADDR_BIT / TARGET_CHAR_BIT, length;
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,
+ SECT_OFF_TEXT (baton->objfile));
+ CORE_ADDR base_address = baton->base_address + base_offset;
loc_ptr = baton->data;
buf_end = baton->data + baton->size;
type will be returned in LVALP, and for lval_memory the register
save address will be returned in ADDRP. */
static CORE_ADDR
-dwarf_expr_read_reg (void *baton, int dwarf_regnum, enum lval_type *lvalp,
- CORE_ADDR *addrp)
+dwarf_expr_read_reg (void *baton, int dwarf_regnum)
{
struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
- CORE_ADDR result;
+ CORE_ADDR result, save_addr;
+ enum lval_type lval_type;
char *buf;
int optimized, regnum, realnum, regsize;
regsize = register_size (current_gdbarch, regnum);
buf = (char *) alloca (regsize);
- frame_register (debaton->frame, regnum, &optimized, lvalp, addrp, &realnum,
- buf);
- result = extract_address (buf, regsize);
+ frame_register (debaton->frame, regnum, &optimized, &lval_type, &save_addr,
+ &realnum, buf);
+ /* NOTE: cagney/2003-05-22: This extract is assuming that a DWARF 2
+ address is always unsigned. That may or may not be true. */
+ result = extract_unsigned_integer (buf, regsize);
return result;
}
framefunc = get_frame_function (debaton->frame);
- if (SYMBOL_LOCATION_FUNCS (framefunc) == &dwarf2_loclist_funcs)
+ if (SYMBOL_OPS (framefunc) == &dwarf2_loclist_funcs)
{
struct dwarf2_loclist_baton *symbaton;
symbaton = SYMBOL_LOCATION_BATON (framefunc);
addr = target_get_thread_local_address (inferior_ptid,
debaton->objfile,
offset);
+ /* It wouldn't be wrong here to try a gdbarch method, too; finding
+ TLS is an ABI-specific thing. But we don't do that yet. */
else
error ("Cannot find thread-local variables on this target");
ctx->get_tls_address = dwarf_expr_tls_address;
dwarf_expr_eval (ctx, data, size);
-
- retval = allocate_value (SYMBOL_TYPE (var));
- VALUE_BFD_SECTION (retval) = SYMBOL_BFD_SECTION (var);
+ result = dwarf_expr_fetch (ctx, 0);
if (ctx->in_reg)
{
- store_unsigned_integer (VALUE_CONTENTS_RAW (retval),
- TYPE_LENGTH (SYMBOL_TYPE (var)),
- dwarf_expr_fetch (ctx, 0));
- VALUE_LVAL (retval) = lval_register;
- VALUE_REGNO (retval) = ctx->regnum;
+ int regnum = DWARF2_REG_TO_REGNUM (result);
+ retval = value_from_register (SYMBOL_TYPE (var), regnum, frame);
}
else
{
- result = dwarf_expr_fetch (ctx, 0);
+ retval = allocate_value (SYMBOL_TYPE (var));
+ VALUE_BFD_SECTION (retval) = SYMBOL_BFD_SECTION (var);
+
VALUE_LVAL (retval) = lval_memory;
VALUE_LAZY (retval) = 1;
VALUE_ADDRESS (retval) = result;
/* Reads from registers do require a frame. */
static CORE_ADDR
-needs_frame_read_reg (void *baton, int regnum, enum lval_type *lvalp,
- CORE_ADDR *addrp)
+needs_frame_read_reg (void *baton, int regnum)
{
struct needs_frame_baton *nf_baton = baton;
nf_baton->needs_frame = 1;
{
struct needs_frame_baton baton;
struct dwarf_expr_context *ctx;
+ int in_reg;
baton.needs_frame = 0;
dwarf_expr_eval (ctx, data, size);
+ in_reg = ctx->in_reg;
+
free_dwarf_expr_context (ctx);
- return baton.needs_frame;
+ return baton.needs_frame || in_reg;
}
static void
return 1;
}
+ /* The location expression for a TLS variable looks like this (on a
+ 64-bit LE machine):
+
+ DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
+ (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
+
+ 0x3 is the encoding for DW_OP_addr, which has an operand as long
+ as the size of an address on the target machine (here is 8
+ bytes). 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
+ The operand represents the offset at which the variable is within
+ the thread local storage. */
+
+ if (dlbaton->size > 1
+ && dlbaton->data[dlbaton->size - 1] == DW_OP_GNU_push_tls_address)
+ if (dlbaton->data[0] == DW_OP_addr)
+ {
+ int bytes_read;
+ CORE_ADDR offset = dwarf2_read_address (&dlbaton->data[1],
+ &dlbaton->data[dlbaton->size - 1],
+ &bytes_read);
+ fprintf_filtered (stream,
+ "a thread-local variable at offset %s in the "
+ "thread-local storage for `%s'",
+ paddr_nz (offset), dlbaton->objfile->name);
+ return 1;
+ }
+
+
fprintf_filtered (stream,
"a variable with complex or multiple locations (DWARF2)");
return 1;
/* The set of location functions used with the DWARF-2 expression
evaluator. */
-struct location_funcs dwarf2_locexpr_funcs = {
+const struct symbol_ops dwarf2_locexpr_funcs = {
locexpr_read_variable,
locexpr_read_needs_frame,
locexpr_describe_location,
struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
struct value *val;
unsigned char *data;
- int size;
+ size_t size;
data = find_location_expression (dlbaton, &size,
frame ? get_frame_pc (frame) : 0);
{
struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
unsigned char *data;
- int size;
+ size_t size;
data = find_location_expression (dlbaton, &size, ax->scope);
if (data == NULL)
/* The set of location functions used with the DWARF-2 expression
evaluator and location lists. */
-struct location_funcs dwarf2_loclist_funcs = {
+const struct symbol_ops dwarf2_loclist_funcs = {
loclist_read_variable,
loclist_read_needs_frame,
loclist_describe_location,