/* DWARF 2 Expression Evaluator.
- Copyright (C) 2001-2016 Free Software Foundation, Inc.
+ Copyright (C) 2001-2017 Free Software Foundation, Inc.
Contributed by Daniel Berlin (dan@dberlin.org)
#include "dwarf2.h"
#include "dwarf2expr.h"
#include "dwarf2loc.h"
+#include "common/underlying.h"
/* Cookie for gdbarch data. */
}
else if (p->location == DWARF_VALUE_IMPLICIT_POINTER)
{
- p->v.ptr.die.sect_off = this->len;
+ p->v.ptr.die_sect_off = (sect_offset) this->len;
p->v.ptr.offset = value_as_long (fetch (0));
}
else if (p->location == DWARF_VALUE_REGISTER)
return TYPE_LENGTH (t1) == TYPE_LENGTH (t2);
}
-/* A convenience function to call get_base_type 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. */
-
-struct type *
-dwarf_expr_context::get_base_type (cu_offset die, int size)
-{
- struct type *result;
-
- if (this->funcs->get_base_type)
- {
- result = this->funcs->get_base_type (this, 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 (this->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. */
return *buf - DW_OP_reg0;
}
- if (*buf == DW_OP_GNU_regval_type)
+ if (*buf == DW_OP_regval_type || *buf == DW_OP_GNU_regval_type)
{
buf++;
buf = gdb_read_uleb128 (buf, buf_end, &dwarf_reg);
case DW_OP_GNU_addr_index:
op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
- result = (this->funcs->get_addr_index) (this->baton, uoffset);
+ result = this->get_addr_index (uoffset);
result += this->offset;
result_val = value_from_ulongest (address_type, result);
break;
case DW_OP_GNU_const_index:
op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
- result = (this->funcs->get_addr_index) (this->baton, uoffset);
+ result = this->get_addr_index (uoffset);
result_val = value_from_ulongest (address_type, result);
break;
dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_stack_value");
goto no_push;
+ case DW_OP_implicit_pointer:
case DW_OP_GNU_implicit_pointer:
{
int64_t len;
if (this->ref_addr_size == -1)
- error (_("DWARF-2 expression error: DW_OP_GNU_implicit_pointer "
+ error (_("DWARF-2 expression error: DW_OP_implicit_pointer "
"is not allowed in frame context"));
/* The referred-to DIE of sect_offset kind. */
this->location = DWARF_VALUE_IMPLICIT_POINTER;
dwarf_expr_require_composition (op_ptr, op_end,
- "DW_OP_GNU_implicit_pointer");
+ "DW_OP_implicit_pointer");
}
break;
case DW_OP_breg31:
{
op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
- result = (this->funcs->read_addr_from_reg) (this->baton,
- op - DW_OP_breg0);
+ result = this->read_addr_from_reg (op - DW_OP_breg0);
result += offset;
result_val = value_from_ulongest (address_type, result);
}
{
op_ptr = safe_read_uleb128 (op_ptr, op_end, ®);
op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
- result = (this->funcs->read_addr_from_reg) (this->baton, reg);
+ result = this->read_addr_from_reg (reg);
result += offset;
result_val = value_from_ulongest (address_type, result);
}
/* FIXME: cagney/2003-03-26: This code should be using
get_frame_base_address(), and then implement a dwarf2
specific this_base method. */
- (this->funcs->get_frame_base) (this->baton, &datastart, &datalen);
+ this->get_frame_base (&datastart, &datalen);
eval (datastart, datalen);
if (this->location == DWARF_VALUE_MEMORY)
result = fetch_address (0);
else if (this->location == DWARF_VALUE_REGISTER)
- result = (this->funcs->read_addr_from_reg)
- (this->baton,
- value_as_long (fetch (0)));
+ result = this->read_addr_from_reg (value_as_long (fetch (0)));
else
error (_("Not implemented: computing frame "
"base using explicit value operator"));
case DW_OP_deref:
case DW_OP_deref_size:
+ case DW_OP_deref_type:
case DW_OP_GNU_deref_type:
{
int addr_size = (op == DW_OP_deref ? this->addr_size : *op_ptr++);
pop ();
- if (op == DW_OP_GNU_deref_type)
+ if (op == DW_OP_deref_type || op == DW_OP_GNU_deref_type)
{
- cu_offset type_die;
-
op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
- type_die.cu_off = uoffset;
- type = get_base_type (type_die, 0);
+ cu_offset type_die_cu_off = (cu_offset) uoffset;
+ type = get_base_type (type_die_cu_off, 0);
}
else
type = address_type;
- (this->funcs->read_mem) (this->baton, buf, addr, addr_size);
+ this->read_mem (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. */
break;
case DW_OP_call_frame_cfa:
- result = (this->funcs->get_frame_cfa) (this->baton);
+ result = this->get_frame_cfa ();
result_val = value_from_ulongest (address_type, result);
in_stack_memory = 1;
break;
returned. */
result = value_as_long (fetch (0));
pop ();
- result = (this->funcs->get_tls_address) (this->baton, result);
+ result = this->get_tls_address (result);
result_val = value_from_ulongest (address_type, result);
break;
case DW_OP_call2:
{
- cu_offset offset;
-
- offset.cu_off = extract_unsigned_integer (op_ptr, 2, byte_order);
+ cu_offset cu_off
+ = (cu_offset) extract_unsigned_integer (op_ptr, 2, byte_order);
op_ptr += 2;
- this->funcs->dwarf_call (this, offset);
+ this->dwarf_call (cu_off);
}
goto no_push;
case DW_OP_call4:
{
- cu_offset offset;
-
- offset.cu_off = extract_unsigned_integer (op_ptr, 4, byte_order);
+ cu_offset cu_off
+ = (cu_offset) extract_unsigned_integer (op_ptr, 4, byte_order);
op_ptr += 4;
- this->funcs->dwarf_call (this, offset);
+ this->dwarf_call (cu_off);
}
goto no_push;
+ case DW_OP_entry_value:
case DW_OP_GNU_entry_value:
{
uint64_t len;
op_ptr = safe_read_uleb128 (op_ptr, op_end, &len);
if (op_ptr + len > op_end)
- error (_("DW_OP_GNU_entry_value: too few bytes available."));
+ error (_("DW_OP_entry_value: too few bytes available."));
kind_u.dwarf_reg = dwarf_block_to_dwarf_reg (op_ptr, op_ptr + len);
if (kind_u.dwarf_reg != -1)
{
op_ptr += len;
- this->funcs->push_dwarf_reg_entry_value (this,
- CALL_SITE_PARAMETER_DWARF_REG,
- kind_u,
- -1 /* deref_size */);
+ this->push_dwarf_reg_entry_value (CALL_SITE_PARAMETER_DWARF_REG,
+ kind_u,
+ -1 /* deref_size */);
goto no_push;
}
if (deref_size == -1)
deref_size = this->addr_size;
op_ptr += len;
- this->funcs->push_dwarf_reg_entry_value (this,
- CALL_SITE_PARAMETER_DWARF_REG,
- kind_u, deref_size);
+ this->push_dwarf_reg_entry_value (CALL_SITE_PARAMETER_DWARF_REG,
+ kind_u, deref_size);
goto no_push;
}
- error (_("DWARF-2 expression error: DW_OP_GNU_entry_value is "
+ error (_("DWARF-2 expression error: DW_OP_entry_value is "
"supported only for single DW_OP_reg* "
"or for DW_OP_breg*(0)+DW_OP_deref*"));
}
{
union call_site_parameter_u kind_u;
- kind_u.param_offset.cu_off = extract_unsigned_integer (op_ptr, 4,
- byte_order);
+ kind_u.param_cu_off
+ = (cu_offset) extract_unsigned_integer (op_ptr, 4, byte_order);
op_ptr += 4;
- this->funcs->push_dwarf_reg_entry_value (this,
- CALL_SITE_PARAMETER_PARAM_OFFSET,
- kind_u,
- -1 /* deref_size */);
+ this->push_dwarf_reg_entry_value (CALL_SITE_PARAMETER_PARAM_OFFSET,
+ kind_u,
+ -1 /* deref_size */);
}
goto no_push;
+ case DW_OP_const_type:
case DW_OP_GNU_const_type:
{
- cu_offset type_die;
int n;
const gdb_byte *data;
struct type *type;
op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
- type_die.cu_off = uoffset;
+ cu_offset type_die_cu_off = (cu_offset) uoffset;
+
n = *op_ptr++;
data = op_ptr;
op_ptr += n;
- type = get_base_type (type_die, n);
+ type = get_base_type (type_die_cu_off, n);
result_val = value_from_contents (type, data);
}
break;
+ case DW_OP_regval_type:
case DW_OP_GNU_regval_type:
{
- cu_offset type_die;
struct type *type;
op_ptr = safe_read_uleb128 (op_ptr, op_end, ®);
op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
- type_die.cu_off = uoffset;
+ cu_offset type_die_cu_off = (cu_offset) uoffset;
- type = get_base_type (type_die, 0);
- result_val = this->funcs->get_reg_value (this->baton, type, reg);
+ type = get_base_type (type_die_cu_off, 0);
+ result_val = this->get_reg_value (type, reg);
}
break;
+ case DW_OP_convert:
case DW_OP_GNU_convert:
+ case DW_OP_reinterpret:
case DW_OP_GNU_reinterpret:
{
- cu_offset type_die;
struct type *type;
op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
- type_die.cu_off = uoffset;
+ cu_offset type_die_cu_off = (cu_offset) uoffset;
- if (type_die.cu_off == 0)
+ if (to_underlying (type_die_cu_off) == 0)
type = address_type;
else
- type = get_base_type (type_die, 0);
+ type = get_base_type (type_die_cu_off, 0);
result_val = fetch (0);
pop ();
- if (op == DW_OP_GNU_convert)
+ if (op == DW_OP_convert || op == DW_OP_GNU_convert)
result_val = value_cast (type, result_val);
else if (type == value_type (result_val))
{
}
else if (TYPE_LENGTH (type)
!= TYPE_LENGTH (value_type (result_val)))
- error (_("DW_OP_GNU_reinterpret has wrong size"));
+ error (_("DW_OP_reinterpret has wrong size"));
else
result_val
= value_from_contents (type,
case DW_OP_push_object_address:
/* Return the address of the object we are currently observing. */
- result = (this->funcs->get_object_address) (this->baton);
+ result = this->get_object_address ();
result_val = value_from_ulongest (address_type, result);
break;
gdb_assert (this->recursion_depth >= 0);
}
-/* 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_form_tls_address");
-}
-
-/* Stub dwarf_expr_context_funcs.dwarf_call implementation. */
-
-void
-ctx_no_dwarf_call (struct dwarf_expr_context *ctx, cu_offset 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, cu_offset 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,
- enum call_site_parameter_kind kind,
- union call_site_parameter_u kind_u,
- int deref_size)
-{
- internal_error (__FILE__, __LINE__,
- _("Support for DW_OP_GNU_entry_value is unimplemented"));
-}
-
-/* Stub dwarf_expr_context_funcs.get_addr_index implementation. */
-
-CORE_ADDR
-ctx_no_get_addr_index (void *baton, unsigned int index)
-{
- error (_("%s is invalid in this context"), "DW_OP_GNU_addr_index");
-}
-
/* Provide a prototype to silence -Wmissing-prototypes. */
extern initialize_file_ftype _initialize_dwarf2expr;