/* DWARF 2 Expression Evaluator.
- Copyright (C) 2001, 2002, 2003, 2005, 2007, 2008, 2009, 2010, 2011
- Free Software Foundation, Inc.
+ Copyright (C) 2001-2003, 2005, 2007-2012 Free Software Foundation,
+ Inc.
Contributed by Daniel Berlin (dan@dberlin.org)
static void execute_stack_op (struct dwarf_expr_context *,
const gdb_byte *, const gdb_byte *);
+/* Cookie for gdbarch data. */
+
+static struct gdbarch_data *dwarf_arch_cookie;
+
+/* This holds gdbarch-specific types used by the DWARF expression
+ evaluator. See comments in execute_stack_op. */
+
+struct dwarf_gdbarch_types
+{
+ struct type *dw_types[3];
+};
+
+/* Allocate and fill in dwarf_gdbarch_types for an arch. */
+
+static void *
+dwarf_gdbarch_types_init (struct gdbarch *gdbarch)
+{
+ struct dwarf_gdbarch_types *types
+ = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct dwarf_gdbarch_types);
+
+ /* The types themselves are lazily initialized. */
+
+ return types;
+}
+
+/* Return the type used for DWARF operations where the type is
+ unspecified in the DWARF spec. Only certain sizes are
+ supported. */
+
+static struct type *
+dwarf_expr_address_type (struct dwarf_expr_context *ctx)
+{
+ struct dwarf_gdbarch_types *types = gdbarch_data (ctx->gdbarch,
+ dwarf_arch_cookie);
+ int ndx;
+
+ if (ctx->addr_size == 2)
+ ndx = 0;
+ else if (ctx->addr_size == 4)
+ ndx = 1;
+ else if (ctx->addr_size == 8)
+ ndx = 2;
+ else
+ error (_("Unsupported address size in DWARF expressions: %d bits"),
+ 8 * ctx->addr_size);
+
+ if (types->dw_types[ndx] == NULL)
+ types->dw_types[ndx]
+ = arch_integer_type (ctx->gdbarch,
+ 8 * ctx->addr_size,
+ 0, "<signed DWARF address type>");
+
+ return types->dw_types[ndx];
+}
+
/* Create a new context for the expression evaluator. */
struct dwarf_expr_context *
/* Push VALUE onto CTX's stack. */
-void
-dwarf_expr_push (struct dwarf_expr_context *ctx, ULONGEST value,
+static void
+dwarf_expr_push (struct dwarf_expr_context *ctx, struct value *value,
int in_stack_memory)
{
struct dwarf_stack_value *v;
- /* We keep all stack elements within the range defined by the
- DWARF address size. */
- if (ctx->addr_size < sizeof (ULONGEST))
- value &= ((ULONGEST) 1 << (ctx->addr_size * HOST_CHAR_BIT)) - 1;
-
dwarf_expr_grow_stack (ctx, 1);
v = &ctx->stack[ctx->stack_len++];
v->value = value;
v->in_stack_memory = in_stack_memory;
}
-/* Pop the top item off of CTX's stack. */
+/* Push VALUE onto CTX's stack. */
void
+dwarf_expr_push_address (struct dwarf_expr_context *ctx, CORE_ADDR value,
+ int in_stack_memory)
+{
+ dwarf_expr_push (ctx,
+ value_from_ulongest (dwarf_expr_address_type (ctx), value),
+ in_stack_memory);
+}
+
+/* Pop the top item off of CTX's stack. */
+
+static void
dwarf_expr_pop (struct dwarf_expr_context *ctx)
{
if (ctx->stack_len <= 0)
/* Retrieve the N'th item on CTX's stack. */
-ULONGEST
+struct value *
dwarf_expr_fetch (struct dwarf_expr_context *ctx, int n)
{
if (ctx->stack_len <= n)
"stack only has %d elements on it."),
n, ctx->stack_len);
return ctx->stack[ctx->stack_len - (1 + n)].value;
+}
+/* Require that TYPE be an integral type; throw an exception if not. */
+
+static void
+dwarf_require_integral (struct type *type)
+{
+ if (TYPE_CODE (type) != TYPE_CODE_INT
+ && TYPE_CODE (type) != TYPE_CODE_CHAR
+ && TYPE_CODE (type) != TYPE_CODE_BOOL)
+ error (_("integral type expected in DWARF expression"));
+}
+
+/* Return the unsigned form of TYPE. TYPE is necessarily an integral
+ type. */
+
+static struct type *
+get_unsigned_type (struct gdbarch *gdbarch, struct type *type)
+{
+ switch (TYPE_LENGTH (type))
+ {
+ case 1:
+ return builtin_type (gdbarch)->builtin_uint8;
+ case 2:
+ return builtin_type (gdbarch)->builtin_uint16;
+ case 4:
+ return builtin_type (gdbarch)->builtin_uint32;
+ case 8:
+ return builtin_type (gdbarch)->builtin_uint64;
+ default:
+ error (_("no unsigned variant found for type, while evaluating "
+ "DWARF expression"));
+ }
+}
+
+/* Return the signed form of TYPE. TYPE is necessarily an integral
+ type. */
+
+static struct type *
+get_signed_type (struct gdbarch *gdbarch, struct type *type)
+{
+ switch (TYPE_LENGTH (type))
+ {
+ case 1:
+ return builtin_type (gdbarch)->builtin_int8;
+ case 2:
+ return builtin_type (gdbarch)->builtin_int16;
+ case 4:
+ return builtin_type (gdbarch)->builtin_int32;
+ case 8:
+ return builtin_type (gdbarch)->builtin_int64;
+ default:
+ error (_("no signed variant found for type, while evaluating "
+ "DWARF expression"));
+ }
}
/* Retrieve the N'th item on CTX's stack, converted to an address. */
CORE_ADDR
dwarf_expr_fetch_address (struct dwarf_expr_context *ctx, int n)
{
- ULONGEST result = dwarf_expr_fetch (ctx, n);
+ struct value *result_val = dwarf_expr_fetch (ctx, n);
+ enum bfd_endian byte_order = gdbarch_byte_order (ctx->gdbarch);
+ ULONGEST result;
+
+ dwarf_require_integral (value_type (result_val));
+ result = extract_unsigned_integer (value_contents (result_val),
+ TYPE_LENGTH (value_type (result_val)),
+ byte_order);
/* For most architectures, calling extract_unsigned_integer() alone
is sufficient for extracting an address. However, some
for those architectures which require it. */
if (gdbarch_integer_to_address_p (ctx->gdbarch))
{
- enum bfd_endian byte_order = gdbarch_byte_order (ctx->gdbarch);
gdb_byte *buf = alloca (ctx->addr_size);
- struct type *int_type;
-
- switch (ctx->addr_size)
- {
- case 2:
- int_type = builtin_type (ctx->gdbarch)->builtin_uint16;
- break;
- case 4:
- int_type = builtin_type (ctx->gdbarch)->builtin_uint32;
- break;
- case 8:
- int_type = builtin_type (ctx->gdbarch)->builtin_uint64;
- break;
- default:
- internal_error (__FILE__, __LINE__,
- _("Unsupported address size.\n"));
- }
+ struct type *int_type = get_unsigned_type (ctx->gdbarch,
+ value_type (result_val));
store_unsigned_integer (buf, ctx->addr_size, byte_order, result);
return gdbarch_integer_to_address (ctx->gdbarch, int_type, buf);
"stack only has %d elements on it."),
n, ctx->stack_len);
return ctx->stack[ctx->stack_len - (1 + n)].in_stack_memory;
-
}
/* Return true if the expression stack is empty. */
else if (p->location == DWARF_VALUE_IMPLICIT_POINTER)
{
p->v.ptr.die = ctx->len;
- p->v.ptr.offset = (LONGEST) dwarf_expr_fetch (ctx, 0);
+ p->v.ptr.offset = value_as_long (dwarf_expr_fetch (ctx, 0));
}
+ else if (p->location == DWARF_VALUE_REGISTER)
+ p->v.regno = value_as_long (dwarf_expr_fetch (ctx, 0));
else
{
p->v.value = dwarf_expr_fetch (ctx, 0);
/* Decode the unsigned LEB128 constant at BUF into the variable pointed to
by R, and return the new value of BUF. Verify that it doesn't extend
- past BUF_END. */
+ past BUF_END. R can be NULL, the constant is then only skipped. */
const gdb_byte *
read_uleb128 (const gdb_byte *buf, const gdb_byte *buf_end, ULONGEST * r)
error (_("read_uleb128: Corrupted DWARF expression."));
byte = *buf++;
- result |= (byte & 0x7f) << shift;
+ result |= ((ULONGEST) (byte & 0x7f)) << shift;
if ((byte & 0x80) == 0)
break;
shift += 7;
}
- *r = result;
+ if (r)
+ *r = result;
return buf;
}
/* Decode the signed LEB128 constant at BUF into the variable pointed to
by R, and return the new value of BUF. Verify that it doesn't extend
- past BUF_END. */
+ past BUF_END. R can be NULL, the constant is then only skipped. */
const gdb_byte *
read_sleb128 (const gdb_byte *buf, const gdb_byte *buf_end, LONGEST * r)
error (_("read_sleb128: Corrupted DWARF expression."));
byte = *buf++;
- result |= (byte & 0x7f) << shift;
+ result |= ((ULONGEST) (byte & 0x7f)) << shift;
shift += 7;
if ((byte & 0x80) == 0)
break;
}
if (shift < (sizeof (*r) * 8) && (byte & 0x40) != 0)
- result |= -(1 << shift);
+ result |= -(((LONGEST) 1) << shift);
- *r = result;
+ if (r)
+ *r = result;
return buf;
}
\f
checked at the other place that this function is called. */
if (op_ptr != op_end && *op_ptr != DW_OP_piece && *op_ptr != DW_OP_bit_piece)
error (_("DWARF-2 expression error: `%s' operations must be "
- "used either alone or in conjuction with DW_OP_piece "
+ "used either alone or in conjunction with DW_OP_piece "
"or DW_OP_bit_piece."),
op_name);
}
+/* Return true iff the types T1 and T2 are "the same". This only does
+ checks that might reasonably be needed to compare DWARF base
+ types. */
+
+static int
+base_types_equal_p (struct type *t1, struct type *t2)
+{
+ if (TYPE_CODE (t1) != TYPE_CODE (t2))
+ return 0;
+ if (TYPE_UNSIGNED (t1) != TYPE_UNSIGNED (t2))
+ return 0;
+ return TYPE_LENGTH (t1) == TYPE_LENGTH (t2);
+}
+
+/* A convenience function to call get_base_type on CTX and return the
+ result. DIE is the DIE whose type we need. SIZE is non-zero if
+ this function should verify that the resulting type has the correct
+ size. */
+
+static struct type *
+dwarf_get_base_type (struct dwarf_expr_context *ctx, ULONGEST die, int size)
+{
+ struct type *result;
+
+ if (ctx->funcs->get_base_type)
+ {
+ result = ctx->funcs->get_base_type (ctx, die);
+ if (result == NULL)
+ error (_("Could not find type for DW_OP_GNU_const_type"));
+ if (size != 0 && TYPE_LENGTH (result) != size)
+ error (_("DW_OP_GNU_const_type has different sizes for type and data"));
+ }
+ else
+ /* Anything will do. */
+ result = builtin_type (ctx->gdbarch)->builtin_int;
+
+ return result;
+}
+
+/* If <BUF..BUF_END] contains DW_FORM_block* with single DW_OP_reg* return the
+ DWARF register number. Otherwise return -1. */
+
+int
+dwarf_block_to_dwarf_reg (const gdb_byte *buf, const gdb_byte *buf_end)
+{
+ ULONGEST dwarf_reg;
+
+ if (buf_end <= buf)
+ return -1;
+ if (*buf >= DW_OP_reg0 && *buf <= DW_OP_reg31)
+ {
+ if (buf_end - buf != 1)
+ return -1;
+ return *buf - DW_OP_reg0;
+ }
+
+ if (*buf == DW_OP_GNU_regval_type)
+ {
+ buf++;
+ buf = read_uleb128 (buf, buf_end, &dwarf_reg);
+ buf = read_uleb128 (buf, buf_end, NULL);
+ }
+ else if (*buf == DW_OP_regx)
+ {
+ buf++;
+ buf = read_uleb128 (buf, buf_end, &dwarf_reg);
+ }
+ else
+ return -1;
+ if (buf != buf_end || (int) dwarf_reg != dwarf_reg)
+ return -1;
+ return dwarf_reg;
+}
+
+/* If <BUF..BUF_END] contains DW_FORM_block* with just DW_OP_breg*(0) and
+ DW_OP_deref* return the DWARF register number. Otherwise return -1.
+ DEREF_SIZE_RETURN contains -1 for DW_OP_deref; otherwise it contains the
+ size from DW_OP_deref_size. */
+
+int
+dwarf_block_to_dwarf_reg_deref (const gdb_byte *buf, const gdb_byte *buf_end,
+ CORE_ADDR *deref_size_return)
+{
+ ULONGEST dwarf_reg;
+ LONGEST offset;
+
+ if (buf_end <= buf)
+ return -1;
+ if (*buf >= DW_OP_breg0 && *buf <= DW_OP_breg31)
+ {
+ dwarf_reg = *buf - DW_OP_breg0;
+ buf++;
+ }
+ else if (*buf == DW_OP_bregx)
+ {
+ buf++;
+ buf = read_uleb128 (buf, buf_end, &dwarf_reg);
+ if ((int) dwarf_reg != dwarf_reg)
+ return -1;
+ }
+ else
+ return -1;
+
+ buf = read_sleb128 (buf, buf_end, &offset);
+ if (offset != 0)
+ return -1;
+
+ if (buf >= buf_end)
+ return -1;
+
+ if (*buf == DW_OP_deref)
+ {
+ buf++;
+ *deref_size_return = -1;
+ }
+ else if (*buf == DW_OP_deref_size)
+ {
+ buf++;
+ if (buf >= buf_end)
+ return -1;
+ *deref_size_return = *buf++;
+ }
+ else
+ return -1;
+
+ if (buf != buf_end)
+ return -1;
+
+ return dwarf_reg;
+}
+
+/* If <BUF..BUF_END] contains DW_FORM_block* with single DW_OP_fbreg(X) fill
+ in FB_OFFSET_RETURN with the X offset and return 1. Otherwise return 0. */
+
+int
+dwarf_block_to_fb_offset (const gdb_byte *buf, const gdb_byte *buf_end,
+ CORE_ADDR *fb_offset_return)
+{
+ LONGEST fb_offset;
+
+ if (buf_end <= buf)
+ return 0;
+
+ if (*buf != DW_OP_fbreg)
+ return 0;
+ buf++;
+
+ buf = read_sleb128 (buf, buf_end, &fb_offset);
+ *fb_offset_return = fb_offset;
+ if (buf != buf_end || fb_offset != (LONGEST) *fb_offset_return)
+ return 0;
+
+ return 1;
+}
+
+/* If <BUF..BUF_END] contains DW_FORM_block* with single DW_OP_bregSP(X) fill
+ in SP_OFFSET_RETURN with the X offset and return 1. Otherwise return 0.
+ The matched SP register number depends on GDBARCH. */
+
+int
+dwarf_block_to_sp_offset (struct gdbarch *gdbarch, const gdb_byte *buf,
+ const gdb_byte *buf_end, CORE_ADDR *sp_offset_return)
+{
+ ULONGEST dwarf_reg;
+ LONGEST sp_offset;
+
+ if (buf_end <= buf)
+ return 0;
+ if (*buf >= DW_OP_breg0 && *buf <= DW_OP_breg31)
+ {
+ dwarf_reg = *buf - DW_OP_breg0;
+ buf++;
+ }
+ else
+ {
+ if (*buf != DW_OP_bregx)
+ return 0;
+ buf++;
+ buf = read_uleb128 (buf, buf_end, &dwarf_reg);
+ }
+
+ if (gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_reg)
+ != gdbarch_sp_regnum (gdbarch))
+ return 0;
+
+ buf = read_sleb128 (buf, buf_end, &sp_offset);
+ *sp_offset_return = sp_offset;
+ if (buf != buf_end || sp_offset != (LONGEST) *sp_offset_return)
+ return 0;
+
+ return 1;
+}
+
/* The engine for the expression evaluator. Using the context in CTX,
evaluate the expression between OP_PTR and OP_END. */
execute_stack_op (struct dwarf_expr_context *ctx,
const gdb_byte *op_ptr, const gdb_byte *op_end)
{
-#define sign_ext(x) ((LONGEST) (((x) ^ sign_bit) - sign_bit))
- ULONGEST sign_bit = (ctx->addr_size >= sizeof (ULONGEST) ? 0
- : ((ULONGEST) 1) << (ctx->addr_size * 8 - 1));
enum bfd_endian byte_order = gdbarch_byte_order (ctx->gdbarch);
+ /* Old-style "untyped" DWARF values need special treatment in a
+ couple of places, specifically DW_OP_mod and DW_OP_shr. We need
+ a special type for these values so we can distinguish them from
+ values that have an explicit type, because explicitly-typed
+ values do not need special treatment. This special type must be
+ different (in the `==' sense) from any base type coming from the
+ CU. */
+ struct type *address_type = dwarf_expr_address_type (ctx);
ctx->location = DWARF_VALUE_MEMORY;
ctx->initialized = 1; /* Default is initialized. */
int in_stack_memory = 0;
ULONGEST uoffset, reg;
LONGEST offset;
+ struct value *result_val = NULL;
+
+ /* The DWARF expression might have a bug causing an infinite
+ loop. In that case, quitting is the only way out. */
+ QUIT;
switch (op)
{
case DW_OP_lit30:
case DW_OP_lit31:
result = op - DW_OP_lit0;
+ result_val = value_from_ulongest (address_type, result);
break;
case DW_OP_addr:
branching between the address and the TLS op. */
if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address)
result += ctx->offset;
+ result_val = value_from_ulongest (address_type, result);
break;
case DW_OP_const1u:
result = extract_unsigned_integer (op_ptr, 1, byte_order);
+ result_val = value_from_ulongest (address_type, result);
op_ptr += 1;
break;
case DW_OP_const1s:
result = extract_signed_integer (op_ptr, 1, byte_order);
+ result_val = value_from_ulongest (address_type, result);
op_ptr += 1;
break;
case DW_OP_const2u:
result = extract_unsigned_integer (op_ptr, 2, byte_order);
+ result_val = value_from_ulongest (address_type, result);
op_ptr += 2;
break;
case DW_OP_const2s:
result = extract_signed_integer (op_ptr, 2, byte_order);
+ result_val = value_from_ulongest (address_type, result);
op_ptr += 2;
break;
case DW_OP_const4u:
result = extract_unsigned_integer (op_ptr, 4, byte_order);
+ result_val = value_from_ulongest (address_type, result);
op_ptr += 4;
break;
case DW_OP_const4s:
result = extract_signed_integer (op_ptr, 4, byte_order);
+ result_val = value_from_ulongest (address_type, result);
op_ptr += 4;
break;
case DW_OP_const8u:
result = extract_unsigned_integer (op_ptr, 8, byte_order);
+ result_val = value_from_ulongest (address_type, result);
op_ptr += 8;
break;
case DW_OP_const8s:
result = extract_signed_integer (op_ptr, 8, byte_order);
+ result_val = value_from_ulongest (address_type, result);
op_ptr += 8;
break;
case DW_OP_constu:
op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
result = uoffset;
+ result_val = value_from_ulongest (address_type, result);
break;
case DW_OP_consts:
op_ptr = read_sleb128 (op_ptr, op_end, &offset);
result = offset;
+ result_val = value_from_ulongest (address_type, result);
break;
/* The DW_OP_reg operations are required to occur alone in
&& *op_ptr != DW_OP_bit_piece
&& *op_ptr != DW_OP_GNU_uninit)
error (_("DWARF-2 expression error: DW_OP_reg operations must be "
- "used either alone or in conjuction with DW_OP_piece "
+ "used either alone or in conjunction with DW_OP_piece "
"or DW_OP_bit_piece."));
result = op - DW_OP_reg0;
+ result_val = value_from_ulongest (address_type, result);
ctx->location = DWARF_VALUE_REGISTER;
break;
dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
result = reg;
+ result_val = value_from_ulongest (address_type, result);
ctx->location = DWARF_VALUE_REGISTER;
break;
ULONGEST die;
LONGEST len;
+ if (ctx->ref_addr_size == -1)
+ error (_("DWARF-2 expression error: DW_OP_GNU_implicit_pointer "
+ "is not allowed in frame context"));
+
/* The referred-to DIE. */
- ctx->len = extract_unsigned_integer (op_ptr, ctx->addr_size,
+ ctx->len = extract_unsigned_integer (op_ptr, ctx->ref_addr_size,
byte_order);
- op_ptr += ctx->addr_size;
+ op_ptr += ctx->ref_addr_size;
/* The byte offset into the data. */
op_ptr = read_sleb128 (op_ptr, op_end, &len);
result = (ULONGEST) len;
+ result_val = value_from_ulongest (address_type, result);
ctx->location = DWARF_VALUE_IMPLICIT_POINTER;
dwarf_expr_require_composition (op_ptr, op_end,
case DW_OP_breg31:
{
op_ptr = read_sleb128 (op_ptr, op_end, &offset);
- result = (ctx->read_reg) (ctx->baton, op - DW_OP_breg0);
+ result = (ctx->funcs->read_reg) (ctx->baton, op - DW_OP_breg0);
result += offset;
+ result_val = value_from_ulongest (address_type, result);
}
break;
case DW_OP_bregx:
{
op_ptr = read_uleb128 (op_ptr, op_end, ®);
op_ptr = read_sleb128 (op_ptr, op_end, &offset);
- result = (ctx->read_reg) (ctx->baton, reg);
+ result = (ctx->funcs->read_reg) (ctx->baton, reg);
result += offset;
+ result_val = value_from_ulongest (address_type, result);
}
break;
case DW_OP_fbreg:
/* FIXME: cagney/2003-03-26: This code should be using
get_frame_base_address(), and then implement a dwarf2
specific this_base method. */
- (ctx->get_frame_base) (ctx->baton, &datastart, &datalen);
+ (ctx->funcs->get_frame_base) (ctx->baton, &datastart, &datalen);
dwarf_expr_eval (ctx, datastart, datalen);
if (ctx->location == DWARF_VALUE_MEMORY)
result = dwarf_expr_fetch_address (ctx, 0);
else if (ctx->location == DWARF_VALUE_REGISTER)
- result = (ctx->read_reg) (ctx->baton, dwarf_expr_fetch (ctx, 0));
+ result = (ctx->funcs->read_reg) (ctx->baton,
+ value_as_long (dwarf_expr_fetch (ctx, 0)));
else
error (_("Not implemented: computing frame "
"base using explicit value operator"));
result = result + offset;
+ result_val = value_from_ulongest (address_type, result);
in_stack_memory = 1;
ctx->stack_len = before_stack_len;
ctx->location = DWARF_VALUE_MEMORY;
break;
case DW_OP_dup:
- result = dwarf_expr_fetch (ctx, 0);
+ result_val = dwarf_expr_fetch (ctx, 0);
in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
break;
case DW_OP_pick:
offset = *op_ptr++;
- result = dwarf_expr_fetch (ctx, offset);
+ result_val = dwarf_expr_fetch (ctx, offset);
in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, offset);
break;
}
case DW_OP_over:
- result = dwarf_expr_fetch (ctx, 1);
+ result_val = dwarf_expr_fetch (ctx, 1);
in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 1);
break;
case DW_OP_deref:
case DW_OP_deref_size:
+ case DW_OP_GNU_deref_type:
{
int addr_size = (op == DW_OP_deref ? ctx->addr_size : *op_ptr++);
gdb_byte *buf = alloca (addr_size);
CORE_ADDR addr = dwarf_expr_fetch_address (ctx, 0);
+ struct type *type;
+
dwarf_expr_pop (ctx);
- (ctx->read_mem) (ctx->baton, buf, addr, addr_size);
- result = extract_unsigned_integer (buf, addr_size, byte_order);
+ if (op == DW_OP_GNU_deref_type)
+ {
+ ULONGEST type_die;
+
+ op_ptr = read_uleb128 (op_ptr, op_end, &type_die);
+ type = dwarf_get_base_type (ctx, type_die, 0);
+ }
+ else
+ type = address_type;
+
+ (ctx->funcs->read_mem) (ctx->baton, buf, addr, addr_size);
+
+ /* If the size of the object read from memory is different
+ from the type length, we need to zero-extend it. */
+ if (TYPE_LENGTH (type) != addr_size)
+ {
+ ULONGEST result =
+ extract_unsigned_integer (buf, addr_size, byte_order);
+
+ buf = alloca (TYPE_LENGTH (type));
+ store_unsigned_integer (buf, TYPE_LENGTH (type),
+ byte_order, result);
+ }
+
+ result_val = value_from_contents_and_address (type, buf, addr);
break;
}
case DW_OP_neg:
case DW_OP_not:
case DW_OP_plus_uconst:
- /* Unary operations. */
- result = dwarf_expr_fetch (ctx, 0);
- dwarf_expr_pop (ctx);
+ {
+ /* Unary operations. */
+ result_val = dwarf_expr_fetch (ctx, 0);
+ dwarf_expr_pop (ctx);
- switch (op)
- {
- case DW_OP_abs:
- if (sign_ext (result) < 0)
- result = -result;
- break;
- case DW_OP_neg:
- result = -result;
- break;
- case DW_OP_not:
- result = ~result;
- break;
- case DW_OP_plus_uconst:
- op_ptr = read_uleb128 (op_ptr, op_end, ®);
- result += reg;
- break;
- }
+ switch (op)
+ {
+ case DW_OP_abs:
+ if (value_less (result_val,
+ value_zero (value_type (result_val), not_lval)))
+ result_val = value_neg (result_val);
+ break;
+ case DW_OP_neg:
+ result_val = value_neg (result_val);
+ break;
+ case DW_OP_not:
+ dwarf_require_integral (value_type (result_val));
+ result_val = value_complement (result_val);
+ break;
+ case DW_OP_plus_uconst:
+ dwarf_require_integral (value_type (result_val));
+ result = value_as_long (result_val);
+ op_ptr = read_uleb128 (op_ptr, op_end, ®);
+ result += reg;
+ result_val = value_from_ulongest (address_type, result);
+ break;
+ }
+ }
break;
case DW_OP_and:
case DW_OP_ne:
{
/* Binary operations. */
- ULONGEST first, second;
+ struct value *first, *second;
second = dwarf_expr_fetch (ctx, 0);
dwarf_expr_pop (ctx);
first = dwarf_expr_fetch (ctx, 0);
dwarf_expr_pop (ctx);
+ if (! base_types_equal_p (value_type (first), value_type (second)))
+ error (_("Incompatible types on DWARF stack"));
+
switch (op)
{
case DW_OP_and:
- result = first & second;
+ dwarf_require_integral (value_type (first));
+ dwarf_require_integral (value_type (second));
+ result_val = value_binop (first, second, BINOP_BITWISE_AND);
break;
case DW_OP_div:
- if (!second)
- error (_("Division by zero"));
- result = sign_ext (first) / sign_ext (second);
+ result_val = value_binop (first, second, BINOP_DIV);
break;
case DW_OP_minus:
- result = first - second;
+ result_val = value_binop (first, second, BINOP_SUB);
break;
case DW_OP_mod:
- if (!second)
- error (_("Division by zero"));
- result = first % second;
+ {
+ int cast_back = 0;
+ struct type *orig_type = value_type (first);
+
+ /* We have to special-case "old-style" untyped values
+ -- these must have mod computed using unsigned
+ math. */
+ if (orig_type == address_type)
+ {
+ struct type *utype
+ = get_unsigned_type (ctx->gdbarch, orig_type);
+
+ cast_back = 1;
+ first = value_cast (utype, first);
+ second = value_cast (utype, second);
+ }
+ /* Note that value_binop doesn't handle float or
+ decimal float here. This seems unimportant. */
+ result_val = value_binop (first, second, BINOP_MOD);
+ if (cast_back)
+ result_val = value_cast (orig_type, result_val);
+ }
break;
case DW_OP_mul:
- result = first * second;
+ result_val = value_binop (first, second, BINOP_MUL);
break;
case DW_OP_or:
- result = first | second;
+ dwarf_require_integral (value_type (first));
+ dwarf_require_integral (value_type (second));
+ result_val = value_binop (first, second, BINOP_BITWISE_IOR);
break;
case DW_OP_plus:
- result = first + second;
+ result_val = value_binop (first, second, BINOP_ADD);
break;
case DW_OP_shl:
- result = first << second;
+ dwarf_require_integral (value_type (first));
+ dwarf_require_integral (value_type (second));
+ result_val = value_binop (first, second, BINOP_LSH);
break;
case DW_OP_shr:
- result = first >> second;
+ dwarf_require_integral (value_type (first));
+ dwarf_require_integral (value_type (second));
+ if (!TYPE_UNSIGNED (value_type (first)))
+ {
+ struct type *utype
+ = get_unsigned_type (ctx->gdbarch, value_type (first));
+
+ first = value_cast (utype, first);
+ }
+
+ result_val = value_binop (first, second, BINOP_RSH);
+ /* Make sure we wind up with the same type we started
+ with. */
+ if (value_type (result_val) != value_type (second))
+ result_val = value_cast (value_type (second), result_val);
break;
case DW_OP_shra:
- result = sign_ext (first) >> second;
+ dwarf_require_integral (value_type (first));
+ dwarf_require_integral (value_type (second));
+ if (TYPE_UNSIGNED (value_type (first)))
+ {
+ struct type *stype
+ = get_signed_type (ctx->gdbarch, value_type (first));
+
+ first = value_cast (stype, first);
+ }
+
+ result_val = value_binop (first, second, BINOP_RSH);
+ /* Make sure we wind up with the same type we started
+ with. */
+ if (value_type (result_val) != value_type (second))
+ result_val = value_cast (value_type (second), result_val);
break;
case DW_OP_xor:
- result = first ^ second;
+ dwarf_require_integral (value_type (first));
+ dwarf_require_integral (value_type (second));
+ result_val = value_binop (first, second, BINOP_BITWISE_XOR);
break;
case DW_OP_le:
- result = sign_ext (first) <= sign_ext (second);
+ /* A <= B is !(B < A). */
+ result = ! value_less (second, first);
+ result_val = value_from_ulongest (address_type, result);
break;
case DW_OP_ge:
- result = sign_ext (first) >= sign_ext (second);
+ /* A >= B is !(A < B). */
+ result = ! value_less (first, second);
+ result_val = value_from_ulongest (address_type, result);
break;
case DW_OP_eq:
- result = sign_ext (first) == sign_ext (second);
+ result = value_equal (first, second);
+ result_val = value_from_ulongest (address_type, result);
break;
case DW_OP_lt:
- result = sign_ext (first) < sign_ext (second);
+ result = value_less (first, second);
+ result_val = value_from_ulongest (address_type, result);
break;
case DW_OP_gt:
- result = sign_ext (first) > sign_ext (second);
+ /* A > B is B < A. */
+ result = value_less (second, first);
+ result_val = value_from_ulongest (address_type, result);
break;
case DW_OP_ne:
- result = sign_ext (first) != sign_ext (second);
+ result = ! value_equal (first, second);
+ result_val = value_from_ulongest (address_type, result);
break;
default:
internal_error (__FILE__, __LINE__,
break;
case DW_OP_call_frame_cfa:
- result = (ctx->get_frame_cfa) (ctx->baton);
+ result = (ctx->funcs->get_frame_cfa) (ctx->baton);
+ result_val = value_from_ulongest (address_type, result);
in_stack_memory = 1;
break;
control block at which the variable is located. Nothing
should follow this operator, so the top of stack would be
returned. */
- result = dwarf_expr_fetch (ctx, 0);
+ result = value_as_long (dwarf_expr_fetch (ctx, 0));
dwarf_expr_pop (ctx);
- result = (ctx->get_tls_address) (ctx->baton, result);
+ result = (ctx->funcs->get_tls_address) (ctx->baton, result);
+ result_val = value_from_ulongest (address_type, result);
break;
case DW_OP_skip:
goto no_push;
case DW_OP_bra:
- offset = extract_signed_integer (op_ptr, 2, byte_order);
- op_ptr += 2;
- if (dwarf_expr_fetch (ctx, 0) != 0)
- op_ptr += offset;
- dwarf_expr_pop (ctx);
+ {
+ struct value *val;
+
+ offset = extract_signed_integer (op_ptr, 2, byte_order);
+ op_ptr += 2;
+ val = dwarf_expr_fetch (ctx, 0);
+ dwarf_require_integral (value_type (val));
+ if (value_as_long (val) != 0)
+ op_ptr += offset;
+ dwarf_expr_pop (ctx);
+ }
goto no_push;
case DW_OP_nop:
case DW_OP_call2:
result = extract_unsigned_integer (op_ptr, 2, byte_order);
op_ptr += 2;
- ctx->dwarf_call (ctx, result);
+ ctx->funcs->dwarf_call (ctx, result);
goto no_push;
case DW_OP_call4:
result = extract_unsigned_integer (op_ptr, 4, byte_order);
op_ptr += 4;
- ctx->dwarf_call (ctx, result);
+ ctx->funcs->dwarf_call (ctx, result);
goto no_push;
case DW_OP_GNU_entry_value:
- /* This operation is not yet supported by GDB. */
- ctx->location = DWARF_VALUE_OPTIMIZED_OUT;
- ctx->stack_len = 0;
- ctx->num_pieces = 0;
- goto abort_expression;
+ {
+ ULONGEST len;
+ int dwarf_reg;
+ CORE_ADDR deref_size;
+
+ op_ptr = read_uleb128 (op_ptr, op_end, &len);
+ if (op_ptr + len > op_end)
+ error (_("DW_OP_GNU_entry_value: too few bytes available."));
+
+ dwarf_reg = dwarf_block_to_dwarf_reg (op_ptr, op_ptr + len);
+ if (dwarf_reg != -1)
+ {
+ op_ptr += len;
+ ctx->funcs->push_dwarf_reg_entry_value (ctx, dwarf_reg,
+ 0 /* unused */,
+ -1 /* deref_size */);
+ goto no_push;
+ }
+
+ dwarf_reg = dwarf_block_to_dwarf_reg_deref (op_ptr, op_ptr + len,
+ &deref_size);
+ if (dwarf_reg != -1)
+ {
+ if (deref_size == -1)
+ deref_size = ctx->addr_size;
+ op_ptr += len;
+ ctx->funcs->push_dwarf_reg_entry_value (ctx, dwarf_reg,
+ 0 /* unused */,
+ deref_size);
+ goto no_push;
+ }
+
+ error (_("DWARF-2 expression error: DW_OP_GNU_entry_value is "
+ "supported only for single DW_OP_reg* "
+ "or for DW_OP_breg*(0)+DW_OP_deref*"));
+ }
+
+ case DW_OP_GNU_const_type:
+ {
+ ULONGEST type_die;
+ int n;
+ const gdb_byte *data;
+ struct type *type;
+
+ op_ptr = read_uleb128 (op_ptr, op_end, &type_die);
+ n = *op_ptr++;
+ data = op_ptr;
+ op_ptr += n;
+
+ type = dwarf_get_base_type (ctx, type_die, n);
+ result_val = value_from_contents (type, data);
+ }
+ break;
+
+ case DW_OP_GNU_regval_type:
+ {
+ ULONGEST type_die;
+ struct type *type;
+
+ op_ptr = read_uleb128 (op_ptr, op_end, ®);
+ op_ptr = read_uleb128 (op_ptr, op_end, &type_die);
+
+ type = dwarf_get_base_type (ctx, type_die, 0);
+ result = (ctx->funcs->read_reg) (ctx->baton, reg);
+ result_val = value_from_ulongest (address_type, result);
+ result_val = value_from_contents (type,
+ value_contents_all (result_val));
+ }
+ break;
+
+ case DW_OP_GNU_convert:
+ case DW_OP_GNU_reinterpret:
+ {
+ ULONGEST type_die;
+ struct type *type;
+
+ op_ptr = read_uleb128 (op_ptr, op_end, &type_die);
+
+ if (type_die == 0)
+ type = address_type;
+ else
+ type = dwarf_get_base_type (ctx, type_die, 0);
+
+ result_val = dwarf_expr_fetch (ctx, 0);
+ dwarf_expr_pop (ctx);
+
+ if (op == DW_OP_GNU_convert)
+ result_val = value_cast (type, result_val);
+ else if (type == value_type (result_val))
+ {
+ /* Nothing. */
+ }
+ else if (TYPE_LENGTH (type)
+ != TYPE_LENGTH (value_type (result_val)))
+ error (_("DW_OP_GNU_reinterpret has wrong size"));
+ else
+ result_val
+ = value_from_contents (type,
+ value_contents_all (result_val));
+ }
+ break;
default:
error (_("Unhandled dwarf expression opcode 0x%x"), op);
}
/* Most things push a result value. */
- dwarf_expr_push (ctx, result, in_stack_memory);
+ gdb_assert (result_val != NULL);
+ dwarf_expr_push (ctx, result_val, in_stack_memory);
no_push:
;
}
abort_expression:
ctx->recursion_depth--;
gdb_assert (ctx->recursion_depth >= 0);
-#undef sign_ext
+}
+
+/* Stub dwarf_expr_context_funcs.get_frame_base implementation. */
+
+void
+ctx_no_get_frame_base (void *baton, const gdb_byte **start, size_t *length)
+{
+ error (_("%s is invalid in this context"), "DW_OP_fbreg");
+}
+
+/* Stub dwarf_expr_context_funcs.get_frame_cfa implementation. */
+
+CORE_ADDR
+ctx_no_get_frame_cfa (void *baton)
+{
+ error (_("%s is invalid in this context"), "DW_OP_call_frame_cfa");
+}
+
+/* Stub dwarf_expr_context_funcs.get_frame_pc implementation. */
+
+CORE_ADDR
+ctx_no_get_frame_pc (void *baton)
+{
+ error (_("%s is invalid in this context"), "DW_OP_GNU_implicit_pointer");
+}
+
+/* Stub dwarf_expr_context_funcs.get_tls_address implementation. */
+
+CORE_ADDR
+ctx_no_get_tls_address (void *baton, CORE_ADDR offset)
+{
+ error (_("%s is invalid in this context"), "DW_OP_GNU_push_tls_address");
+}
+
+/* Stub dwarf_expr_context_funcs.dwarf_call implementation. */
+
+void
+ctx_no_dwarf_call (struct dwarf_expr_context *ctx, size_t die_offset)
+{
+ error (_("%s is invalid in this context"), "DW_OP_call*");
+}
+
+/* Stub dwarf_expr_context_funcs.get_base_type implementation. */
+
+struct type *
+ctx_no_get_base_type (struct dwarf_expr_context *ctx, size_t die)
+{
+ error (_("Support for typed DWARF is not supported in this context"));
+}
+
+/* Stub dwarf_expr_context_funcs.push_dwarf_block_entry_value
+ implementation. */
+
+void
+ctx_no_push_dwarf_reg_entry_value (struct dwarf_expr_context *ctx,
+ int dwarf_reg, CORE_ADDR fb_offset,
+ int deref_size)
+{
+ internal_error (__FILE__, __LINE__,
+ _("Support for DW_OP_GNU_entry_value is unimplemented"));
+}
+
+void
+_initialize_dwarf2expr (void)
+{
+ dwarf_arch_cookie
+ = gdbarch_data_register_post_init (dwarf_gdbarch_types_init);
}
projects / external / binutils.git / blobdiff