/* DWARF 2 location expression support for GDB.
- Copyright (C) 2003, 2005, 2007, 2008, 2009, 2010
+ Copyright (C) 2003, 2005, 2007, 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
Contributed by Daniel Jacobowitz, MontaVista Software, Inc.
dwarf_expr_frame_base_1 (struct symbol *framefunc, CORE_ADDR pc,
const gdb_byte **start, size_t *length);
-/* A helper function for dealing with location lists. Given a
+static struct value *
+dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame,
+ const gdb_byte *data, unsigned short size,
+ struct dwarf2_per_cu_data *per_cu,
+ LONGEST byte_offset);
+
+/* A function for dealing with location lists. Given a
symbol baton (BATON) and a pc value (PC), find the appropriate
location expression, set *LOCEXPR_LENGTH, and return a pointer
to the beginning of the expression. Returns NULL on failure.
For now, only return the first matching location expression; there
can be more than one in the list. */
-static const gdb_byte *
-find_location_expression (struct dwarf2_loclist_baton *baton,
- size_t *locexpr_length, CORE_ADDR pc)
+const gdb_byte *
+dwarf2_find_location_expression (struct dwarf2_loclist_baton *baton,
+ size_t *locexpr_length, CORE_ADDR pc)
{
CORE_ADDR low, high;
const gdb_byte *loc_ptr, *buf_end;
int signed_addr_p = bfd_get_sign_extend_vma (objfile->obfd);
CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
/* Adjust base_address for relocatable objects. */
- CORE_ADDR base_offset = ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
+ CORE_ADDR base_offset = dwarf2_per_cu_text_offset (baton->per_cu);
CORE_ADDR base_address = baton->base_address + base_offset;
loc_ptr = baton->data;
while (1)
{
if (buf_end - loc_ptr < 2 * addr_size)
- error (_("find_location_expression: Corrupted DWARF expression."));
+ error (_("dwarf2_find_location_expression: "
+ "Corrupted DWARF expression."));
if (signed_addr_p)
low = extract_signed_integer (loc_ptr, addr_size, byte_order);
struct dwarf2_loclist_baton *symbaton;
symbaton = SYMBOL_LOCATION_BATON (framefunc);
- *start = find_location_expression (symbaton, length, pc);
+ *start = dwarf2_find_location_expression (symbaton, length, pc);
}
else
{
return dwarf2_frame_cfa (debaton->frame);
}
+/* Helper function for dwarf2_evaluate_loc_desc. Computes the PC for
+ the frame in BATON. */
+
+static CORE_ADDR
+dwarf_expr_frame_pc (void *baton)
+{
+ struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
+
+ return get_frame_address_in_block (debaton->frame);
+}
+
/* Using the objfile specified in BATON, find the address for the
current thread's thread-local storage with offset OFFSET. */
static CORE_ADDR
return target_translate_tls_address (objfile, offset);
}
-/* Call DWARF subroutine from DW_AT_location of DIE at DIE_OFFSET in current CU
- (as is PER_CU). State of the CTX is not affected by the call and return. */
+/* Call DWARF subroutine from DW_AT_location of DIE at DIE_OFFSET in
+ current CU (as is PER_CU). State of the CTX is not affected by the
+ call and return. */
static void
per_cu_dwarf_call (struct dwarf_expr_context *ctx, size_t die_offset,
- struct dwarf2_per_cu_data *per_cu)
+ struct dwarf2_per_cu_data *per_cu,
+ CORE_ADDR (*get_frame_pc) (void *baton),
+ void *baton)
{
struct dwarf2_locexpr_baton block;
- block = dwarf2_fetch_die_location_block (die_offset, per_cu);
+ block = dwarf2_fetch_die_location_block (die_offset, per_cu,
+ get_frame_pc, baton);
/* DW_OP_call_ref is currently not supported. */
gdb_assert (block.per_cu == per_cu);
{
struct dwarf_expr_baton *debaton = ctx->baton;
- return per_cu_dwarf_call (ctx, die_offset, debaton->per_cu);
+ return per_cu_dwarf_call (ctx, die_offset, debaton->per_cu,
+ ctx->get_frame_pc, ctx->baton);
}
struct piece_closure
/* Reference count. */
int refc;
+ /* 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;
PIECES. */
static struct piece_closure *
-allocate_piece_closure (int n_pieces, struct dwarf_expr_piece *pieces,
+allocate_piece_closure (struct dwarf2_per_cu_data *per_cu,
+ int n_pieces, struct dwarf_expr_piece *pieces,
int addr_size)
{
struct piece_closure *c = XZALLOC (struct piece_closure);
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);
long offset = 0;
ULONGEST bits_to_skip;
gdb_byte *contents;
- struct piece_closure *c = (struct piece_closure *) value_computed_closure (v);
+ struct piece_closure *c
+ = (struct piece_closure *) value_computed_closure (v);
struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (v));
size_t type_len;
size_t buffer_size = 0;
}
break;
+ /* These bits show up as zeros -- but do not cause the value
+ to be considered optimized-out. */
+ case DWARF_VALUE_IMPLICIT_POINTER:
+ break;
+
case DWARF_VALUE_OPTIMIZED_OUT:
set_value_optimized_out (v, 1);
break;
internal_error (__FILE__, __LINE__, _("invalid location type"));
}
- if (p->location != DWARF_VALUE_OPTIMIZED_OUT)
+ if (p->location != DWARF_VALUE_OPTIMIZED_OUT
+ && p->location != DWARF_VALUE_IMPLICIT_POINTER)
copy_bitwise (contents, dest_offset_bits,
intermediate_buffer, source_offset_bits % 8,
this_size_bits, bits_big_endian);
long offset = 0;
ULONGEST bits_to_skip;
const gdb_byte *contents;
- struct piece_closure *c = (struct piece_closure *) value_computed_closure (to);
+ struct piece_closure *c
+ = (struct piece_closure *) value_computed_closure (to);
struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (to));
size_t type_len;
size_t buffer_size = 0;
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. */
+
static int
check_pieced_value_bits (const struct value *value, int bit_offset,
- int bit_length, int validity)
+ int bit_length,
+ enum dwarf_value_location check_for)
{
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 (p->location == DWARF_VALUE_OPTIMIZED_OUT)
+ 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;
check_pieced_value_validity (const struct value *value, int bit_offset,
int bit_length)
{
- return check_pieced_value_bits (value, bit_offset, bit_length, 1);
+ 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)), 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);
+}
+
+/* A wrapper function for get_frame_address_in_block. */
+
+static CORE_ADDR
+get_frame_address_in_block_wrapper (void *baton)
+{
+ return get_frame_address_in_block (baton);
+}
+
+/* An implementation of an lval_funcs method to indirect through a
+ pointer. This handles the synthetic pointer case when needed. */
+
+static struct value *
+indirect_pieced_value (struct value *value)
+{
+ struct piece_closure *c
+ = (struct piece_closure *) value_computed_closure (value);
+ struct type *type;
+ struct frame_info *frame;
+ struct dwarf2_locexpr_baton baton;
+ int i, bit_offset, bit_length;
+ struct dwarf_expr_piece *piece = NULL;
+ struct value *result;
+ LONGEST byte_offset;
+
+ type = value_type (value);
+ if (TYPE_CODE (type) != TYPE_CODE_PTR)
+ return NULL;
+
+ bit_length = 8 * TYPE_LENGTH (type);
+ bit_offset = 8 * value_offset (value);
+ if (value_bitsize (value))
+ bit_offset += value_bitpos (value);
+
+ for (i = 0; i < c->n_pieces && bit_length > 0; i++)
+ {
+ struct dwarf_expr_piece *p = &c->pieces[i];
+ size_t this_size_bits = p->size;
+
+ if (bit_offset > 0)
+ {
+ if (bit_offset >= this_size_bits)
+ {
+ bit_offset -= this_size_bits;
+ continue;
+ }
+
+ bit_length -= this_size_bits - bit_offset;
+ bit_offset = 0;
+ }
+ else
+ bit_length -= this_size_bits;
+
+ if (p->location != DWARF_VALUE_IMPLICIT_POINTER)
+ return NULL;
+
+ if (bit_length != 0)
+ error (_("Invalid use of DW_OP_GNU_implicit_pointer"));
+
+ piece = p;
+ break;
+ }
+
+ frame = get_selected_frame (_("No frame selected."));
+ byte_offset = value_as_address (value);
+
+ baton = dwarf2_fetch_die_location_block (piece->v.ptr.die, c->per_cu,
+ get_frame_address_in_block_wrapper,
+ frame);
+
+ result = dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type), frame,
+ baton.data, baton.size, baton.per_cu,
+ byte_offset);
+
+ return result;
}
static void *
copy_pieced_value_closure (const struct value *v)
{
- struct piece_closure *c = (struct piece_closure *) value_computed_closure (v);
+ struct piece_closure *c
+ = (struct piece_closure *) value_computed_closure (v);
++c->refc;
return c;
static void
free_pieced_value_closure (struct value *v)
{
- struct piece_closure *c = (struct piece_closure *) value_computed_closure (v);
+ struct piece_closure *c
+ = (struct piece_closure *) value_computed_closure (v);
--c->refc;
if (c->refc == 0)
write_pieced_value,
check_pieced_value_validity,
check_pieced_value_invalid,
+ indirect_pieced_value,
+ check_pieced_synthetic_pointer,
copy_pieced_value_closure,
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"));
+}
+
/* Evaluate a location description, starting at DATA and with length
- SIZE, to find the current location of variable of TYPE in the context
- of FRAME. */
+ SIZE, to find the current location of variable of TYPE in the
+ context of FRAME. BYTE_OFFSET is applied after the contents are
+ computed. */
static struct value *
-dwarf2_evaluate_loc_desc (struct type *type, struct frame_info *frame,
- const gdb_byte *data, unsigned short size,
- struct dwarf2_per_cu_data *per_cu)
+dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame,
+ const gdb_byte *data, unsigned short size,
+ struct dwarf2_per_cu_data *per_cu,
+ LONGEST byte_offset)
{
struct value *retval;
struct dwarf_expr_baton baton;
struct cleanup *old_chain;
struct objfile *objfile = dwarf2_per_cu_objfile (per_cu);
+ if (byte_offset < 0)
+ invalid_synthetic_pointer ();
+
if (size == 0)
{
retval = allocate_value (type);
ctx->gdbarch = get_objfile_arch (objfile);
ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
- ctx->offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
+ ctx->offset = dwarf2_per_cu_text_offset (per_cu);
ctx->baton = &baton;
ctx->read_reg = dwarf_expr_read_reg;
ctx->read_mem = dwarf_expr_read_mem;
ctx->get_frame_base = dwarf_expr_frame_base;
ctx->get_frame_cfa = dwarf_expr_frame_cfa;
+ ctx->get_frame_pc = dwarf_expr_frame_pc;
ctx->get_tls_address = dwarf_expr_tls_address;
ctx->dwarf_call = dwarf_expr_dwarf_call;
{
struct piece_closure *c;
struct frame_id frame_id = get_frame_id (frame);
+ ULONGEST bit_size = 0;
+ int i;
+
+ for (i = 0; i < ctx->num_pieces; ++i)
+ bit_size += ctx->pieces[i].size;
+ if (8 * (byte_offset + TYPE_LENGTH (type)) > bit_size)
+ invalid_synthetic_pointer ();
- c = allocate_piece_closure (ctx->num_pieces, ctx->pieces,
+ c = allocate_piece_closure (per_cu, ctx->num_pieces, ctx->pieces,
ctx->addr_size);
retval = allocate_computed_value (type, &pieced_value_funcs, c);
VALUE_FRAME_ID (retval) = frame_id;
+ set_value_offset (retval, byte_offset);
}
else
{
ULONGEST dwarf_regnum = 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"));
if (gdb_regnum != -1)
retval = value_from_register (type, gdb_regnum, frame);
else
CORE_ADDR address = dwarf_expr_fetch_address (ctx, 0);
int in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
- retval = allocate_value (type);
+ retval = allocate_value_lazy (type);
VALUE_LVAL (retval) = lval_memory;
- set_value_lazy (retval, 1);
if (in_stack_memory)
set_value_stack (retval, 1);
- set_value_address (retval, address);
+ set_value_address (retval, address + byte_offset);
}
break;
case DWARF_VALUE_STACK:
{
ULONGEST value = dwarf_expr_fetch (ctx, 0);
- bfd_byte *contents;
+ bfd_byte *contents, *tem;
size_t n = ctx->addr_size;
+ if (byte_offset + TYPE_LENGTH (type) > n)
+ invalid_synthetic_pointer ();
+
+ tem = alloca (n);
+ store_unsigned_integer (tem, n,
+ gdbarch_byte_order (ctx->gdbarch),
+ value);
+
+ tem += byte_offset;
+ n -= byte_offset;
+
retval = allocate_value (type);
contents = value_contents_raw (retval);
if (n > TYPE_LENGTH (type))
n = TYPE_LENGTH (type);
- store_unsigned_integer (contents, n,
- gdbarch_byte_order (ctx->gdbarch),
- value);
+ memcpy (contents, tem, n);
}
break;
case DWARF_VALUE_LITERAL:
{
bfd_byte *contents;
+ const bfd_byte *data;
size_t n = ctx->len;
+ if (byte_offset + TYPE_LENGTH (type) > n)
+ invalid_synthetic_pointer ();
+
retval = allocate_value (type);
contents = value_contents_raw (retval);
+
+ data = ctx->data + byte_offset;
+ n -= byte_offset;
+
if (n > TYPE_LENGTH (type))
n = TYPE_LENGTH (type);
- memcpy (contents, ctx->data, n);
+ memcpy (contents, data, n);
}
break;
+ /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
+ operation by execute_stack_op. */
+ case DWARF_VALUE_IMPLICIT_POINTER:
/* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
it can only be encountered when making a piece. */
case DWARF_VALUE_OPTIMIZED_OUT:
return retval;
}
+
+/* The exported interface to dwarf2_evaluate_loc_desc_full; it always
+ passes 0 as the byte_offset. */
+
+struct value *
+dwarf2_evaluate_loc_desc (struct type *type, struct frame_info *frame,
+ const gdb_byte *data, unsigned short size,
+ struct dwarf2_per_cu_data *per_cu)
+{
+ return dwarf2_evaluate_loc_desc_full (type, frame, data, size, per_cu, 0);
+}
+
\f
/* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
{
struct needs_frame_baton *nf_baton = ctx->baton;
- return per_cu_dwarf_call (ctx, die_offset, nf_baton->per_cu);
+ return per_cu_dwarf_call (ctx, die_offset, nf_baton->per_cu,
+ ctx->get_frame_pc, ctx->baton);
}
/* Return non-zero iff the location expression at DATA (length SIZE)
ctx->gdbarch = get_objfile_arch (objfile);
ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
- ctx->offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
+ ctx->offset = dwarf2_per_cu_text_offset (per_cu);
ctx->baton = &baton;
ctx->read_reg = needs_frame_read_reg;
ctx->read_mem = needs_frame_read_mem;
ctx->get_frame_base = needs_frame_frame_base;
ctx->get_frame_cfa = needs_frame_frame_cfa;
+ ctx->get_frame_pc = needs_frame_frame_cfa;
ctx->get_tls_address = needs_frame_tls_address;
ctx->dwarf_call = needs_frame_dwarf_call;
}
}
+/* A helper function to return the frame's PC. */
+
+static CORE_ADDR
+get_ax_pc (void *baton)
+{
+ struct agent_expr *expr = baton;
+
+ return expr->scope;
+}
+
/* Compile a DWARF location expression to an agent expression.
EXPR is the agent expression we are building.
index, not an address. We don't support things like
branching between the address and the TLS op. */
if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address)
- {
- struct objfile *objfile = dwarf2_per_cu_objfile (per_cu);
-
- uoffset += ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
- }
+ uoffset += dwarf2_per_cu_text_offset (per_cu);
ax_const_l (expr, uoffset);
break;
uoffset = extract_unsigned_integer (op_ptr, size, byte_order);
op_ptr += size;
- block = dwarf2_fetch_die_location_block (uoffset, per_cu);
+ block = dwarf2_fetch_die_location_block (uoffset, per_cu,
+ get_ax_pc, expr);
/* DW_OP_call_ref is currently not supported. */
gdb_assert (block.per_cu == per_cu);
struct symbol *framefunc;
int frame_reg = 0;
LONGEST frame_offset;
- const gdb_byte *base_data, *new_data;
+ const gdb_byte *base_data, *new_data, *save_data = data;
size_t base_size;
LONGEST base_offset = 0;
buf_end = read_sleb128 (base_data + 1,
base_data + base_size, &base_offset);
if (buf_end != base_data + base_size)
- error (_("Unexpected opcode after DW_OP_breg%u for symbol \"%s\"."),
+ error (_("Unexpected opcode after "
+ "DW_OP_breg%u for symbol \"%s\"."),
frame_reg, SYMBOL_PRINT_NAME (symbol));
}
else if (base_data[0] >= DW_OP_reg0 && base_data[0] <= DW_OP_reg31)
{
/* We don't know what to do with the frame base expression,
so we can't trace this variable; give up. */
- error (_("Cannot describe location of symbol \"%s\"; "
- "DWARF 2 encoding not handled, "
- "first opcode in base data is 0x%x."),
- SYMBOL_PRINT_NAME (symbol), base_data[0]);
+ return save_data;
}
regno = gdbarch_dwarf2_reg_to_regnum (gdbarch, frame_reg);
- fprintf_filtered (stream, _("a variable at frame base reg $%s offset %s+%s"),
+ fprintf_filtered (stream,
+ _("a variable at frame base reg $%s offset %s+%s"),
gdbarch_register_name (gdbarch, regno),
plongest (base_offset), plongest (frame_offset));
}
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.
+ bytes). Note that more recent version of GCC emit DW_OP_const4u
+ or DW_OP_const8u, depending on address size, rather than
+ DW_OP_addr. 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. */
else if (data + 1 + addr_size < end
- && data[0] == DW_OP_addr
+ && (data[0] == DW_OP_addr
+ || (addr_size == 4 && data[0] == DW_OP_const4u)
+ || (addr_size == 8 && data[0] == DW_OP_const8u))
&& data[1 + addr_size] == DW_OP_GNU_push_tls_address
&& piece_end_p (data + 2 + addr_size, end))
{
pulongest (ul), pulongest (offset));
}
break;
+
+ case DW_OP_GNU_implicit_pointer:
+ {
+ ul = extract_unsigned_integer (data, offset_size,
+ gdbarch_byte_order (arch));
+ data += offset_size;
+
+ data = read_sleb128 (data, end, &l);
+
+ fprintf_filtered (stream, " DIE %s offset %s",
+ phex_nz (ul, offset_size),
+ plongest (l));
+ }
+ break;
}
fprintf_filtered (stream, "\n");
if (!dwarf2_always_disassemble)
{
- data = locexpr_describe_location_piece (symbol, stream, addr, objfile,
+ data = locexpr_describe_location_piece (symbol, stream,
+ addr, objfile,
data, end, addr_size);
/* If we printed anything, or if we have an empty piece,
then don't disassemble. */
disassemble = 0;
}
if (disassemble)
- data = disassemble_dwarf_expression (stream, get_objfile_arch (objfile),
+ data = disassemble_dwarf_expression (stream,
+ get_objfile_arch (objfile),
addr_size, offset_size, data, end,
dwarf2_always_disassemble);
unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
int offset_size = dwarf2_per_cu_offset_size (dlbaton->per_cu);
- locexpr_describe_location_1 (symbol, addr, stream, dlbaton->data, dlbaton->size,
+ locexpr_describe_location_1 (symbol, addr, stream,
+ dlbaton->data, dlbaton->size,
objfile, addr_size, offset_size);
}
struct value *val;
const gdb_byte *data;
size_t size;
+ CORE_ADDR pc = frame ? get_frame_address_in_block (frame) : 0;
- data = find_location_expression (dlbaton, &size,
- frame ? get_frame_address_in_block (frame)
- : 0);
+ data = dwarf2_find_location_expression (dlbaton, &size, pc);
if (data == NULL)
{
val = allocate_value (SYMBOL_TYPE (symbol));
int signed_addr_p = bfd_get_sign_extend_vma (objfile->obfd);
CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
/* Adjust base_address for relocatable objects. */
- CORE_ADDR base_offset = ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
+ CORE_ADDR base_offset = dwarf2_per_cu_text_offset (dlbaton->per_cu);
CORE_ADDR base_address = dlbaton->base_address + base_offset;
loc_ptr = dlbaton->data;
size_t size;
unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
- data = find_location_expression (dlbaton, &size, ax->scope);
+ data = dwarf2_find_location_expression (dlbaton, &size, ax->scope);
if (data == NULL || size == 0)
value->optimized_out = 1;
else