Automatic date update in version.in

[deliverable/binutils-gdb.git] / gdb / dwarf2expr.c

diff --git a/gdb/dwarf2expr.c b/gdb/dwarf2expr.c
index e0aafc7f49e680e6c09966a7112cfe366cc5d49e..071b83fa7042a4bd5ac7c4cd14af4a7b2ab10c65 100644 (file)
--- a/gdb/dwarf2expr.c
+++ b/gdb/dwarf2expr.c
@@ -1,7 +1,6 @@
 /* DWARF 2 Expression Evaluator.
 
-   Copyright (C) 2001-2003, 2005, 2007-2012 Free Software Foundation,
-   Inc.
+   Copyright (C) 2001-2015 Free Software Foundation, Inc.
 
    Contributed by Daniel Berlin (dan@dberlin.org)
 
@@ -27,7 +26,6 @@
 #include "gdbcore.h"
 #include "dwarf2.h"
 #include "dwarf2expr.h"
-#include "gdb_assert.h"
 
 /* Local prototypes.  */
 
@@ -342,7 +340,7 @@ add_piece (struct dwarf_expr_context *ctx, ULONGEST size, ULONGEST offset)
     }
   else if (p->location == DWARF_VALUE_IMPLICIT_POINTER)
     {
-      p->v.ptr.die.cu_off = ctx->len;
+      p->v.ptr.die.sect_off = ctx->len;
       p->v.ptr.offset = value_as_long (dwarf_expr_fetch (ctx, 0));
     }
   else if (p->location == DWARF_VALUE_REGISTER)
@@ -725,6 +723,12 @@ execute_stack_op (struct dwarf_expr_context *ctx,
          break;
 
        case DW_OP_GNU_addr_index:
+         op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
+         result = (ctx->funcs->get_addr_index) (ctx->baton, uoffset);
+         result += ctx->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 = (ctx->funcs->get_addr_index) (ctx->baton, uoffset);
          result_val = value_from_ulongest (address_type, result);
@@ -866,7 +870,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
              error (_("DWARF-2 expression error: DW_OP_GNU_implicit_pointer "
                       "is not allowed in frame context"));
 
-           /* The referred-to DIE of cu_offset kind.  */
+           /* The referred-to DIE of sect_offset kind.  */
            ctx->len = extract_unsigned_integer (op_ptr, ctx->ref_addr_size,
                                                 byte_order);
            op_ptr += ctx->ref_addr_size;
@@ -916,7 +920,8 @@ execute_stack_op (struct dwarf_expr_context *ctx,
        case DW_OP_breg31:
          {
            op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
-           result = (ctx->funcs->read_reg) (ctx->baton, op - DW_OP_breg0);
+           result = (ctx->funcs->read_addr_from_reg) (ctx->baton,
+                                                      op - DW_OP_breg0);
            result += offset;
            result_val = value_from_ulongest (address_type, result);
          }
@@ -925,7 +930,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
          {
            op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
            op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
-           result = (ctx->funcs->read_reg) (ctx->baton, reg);
+           result = (ctx->funcs->read_addr_from_reg) (ctx->baton, reg);
            result += offset;
            result_val = value_from_ulongest (address_type, result);
          }
@@ -950,8 +955,9 @@ execute_stack_op (struct dwarf_expr_context *ctx,
            if (ctx->location == DWARF_VALUE_MEMORY)
              result = dwarf_expr_fetch_address (ctx, 0);
            else if (ctx->location == DWARF_VALUE_REGISTER)
-             result = (ctx->funcs->read_reg) (ctx->baton,
-                                    value_as_long (dwarf_expr_fetch (ctx, 0)));
+             result = (ctx->funcs->read_addr_from_reg)
+                         (ctx->baton,
+                          value_as_long (dwarf_expr_fetch (ctx, 0)));
            else
              error (_("Not implemented: computing frame "
                       "base using explicit value operator"));
@@ -1355,33 +1361,35 @@ execute_stack_op (struct dwarf_expr_context *ctx,
        case DW_OP_GNU_entry_value:
          {
            uint64_t len;
-           int dwarf_reg;
            CORE_ADDR deref_size;
+           union call_site_parameter_u kind_u;
 
            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."));
 
-           dwarf_reg = dwarf_block_to_dwarf_reg (op_ptr, op_ptr + len);
-           if (dwarf_reg != -1)
+           kind_u.dwarf_reg = dwarf_block_to_dwarf_reg (op_ptr, op_ptr + len);
+           if (kind_u.dwarf_reg != -1)
              {
                op_ptr += len;
-               ctx->funcs->push_dwarf_reg_entry_value (ctx, dwarf_reg,
-                                                       0 /* unused */,
+               ctx->funcs->push_dwarf_reg_entry_value (ctx,
+                                                 CALL_SITE_PARAMETER_DWARF_REG,
+                                                       kind_u,
                                                        -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)
+           kind_u.dwarf_reg = dwarf_block_to_dwarf_reg_deref (op_ptr,
+                                                              op_ptr + len,
+                                                              &deref_size);
+           if (kind_u.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);
+               ctx->funcs->push_dwarf_reg_entry_value (ctx,
+                                                 CALL_SITE_PARAMETER_DWARF_REG,
+                                                       kind_u, deref_size);
                goto no_push;
              }
 
@@ -1390,6 +1398,20 @@ execute_stack_op (struct dwarf_expr_context *ctx,
                     "or for DW_OP_breg*(0)+DW_OP_deref*"));
          }
 
+       case DW_OP_GNU_parameter_ref:
+         {
+           union call_site_parameter_u kind_u;
+
+           kind_u.param_offset.cu_off = extract_unsigned_integer (op_ptr, 4,
+                                                                  byte_order);
+           op_ptr += 4;
+           ctx->funcs->push_dwarf_reg_entry_value (ctx,
+                                              CALL_SITE_PARAMETER_PARAM_OFFSET,
+                                                   kind_u,
+                                                   -1 /* deref_size */);
+         }
+         goto no_push;
+
        case DW_OP_GNU_const_type:
          {
            cu_offset type_die;
@@ -1418,10 +1440,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
            type_die.cu_off = uoffset;
 
            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));
+           result_val = ctx->funcs->get_reg_value (ctx->baton, type, reg);
          }
          break;
 
@@ -1458,6 +1477,12 @@ execute_stack_op (struct dwarf_expr_context *ctx,
          }
          break;
 
+       case DW_OP_push_object_address:
+         /* Return the address of the object we are currently observing.  */
+         result = (ctx->funcs->get_object_address) (ctx->baton);
+         result_val = value_from_ulongest (address_type, result);
+         break;
+
        default:
          error (_("Unhandled dwarf expression opcode 0x%x"), op);
        }
@@ -1533,7 +1558,8 @@ ctx_no_get_base_type (struct dwarf_expr_context *ctx, cu_offset die)
 
 void
 ctx_no_push_dwarf_reg_entry_value (struct dwarf_expr_context *ctx,
-                                  int dwarf_reg, CORE_ADDR fb_offset,
+                                  enum call_site_parameter_kind kind,
+                                  union call_site_parameter_u kind_u,
                                   int deref_size)
 {
   internal_error (__FILE__, __LINE__,