Merge GDB 7.5.1

gdb/dwarf2loc.c

 /* DWARF 2 location expression support for GDB.
 
    Copyright (C) 2003, 2005, 2007-2012 Free Software Foundation, Inc.
 
    Contributed by Daniel Jacobowitz, MontaVista Software, Inc.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ skipping 24 matching lines @@
 #include "gdbcmd.h"
 
 #include "dwarf2.h"
 #include "dwarf2expr.h"
 #include "dwarf2loc.h"
 #include "dwarf2-frame.h"
 
 #include "gdb_string.h"
 #include "gdb_assert.h"
 
+DEF_VEC_I(int);
+
 extern int dwarf2_always_disassemble;
 
 static void dwarf_expr_frame_base_1 (struct symbol *framefunc, CORE_ADDR pc,
                                      const gdb_byte **start, size_t *length);
 
 static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs;
 
 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);
 
+/* Until these have formal names, we define these here.
+   ref: http://gcc.gnu.org/wiki/DebugFission
+   Each entry in .debug_loc.dwo begins with a byte that describes the entry,
+   and is then followed by data specific to that entry.  */
+
+enum debug_loc_kind
+{
+  /* Indicates the end of the list of entries.  */
+  DEBUG_LOC_END_OF_LIST = 0,
+
+  /* This is followed by an unsigned LEB128 number that is an index into
+     .debug_addr and specifies the base address for all following entries.  */
+  DEBUG_LOC_BASE_ADDRESS = 1,
+
+  /* This is followed by two unsigned LEB128 numbers that are indices into
+     .debug_addr and specify the beginning and ending addresses, and then
+     a normal location expression as in .debug_loc.  */
+  DEBUG_LOC_START_END = 2,
+
+  /* This is followed by an unsigned LEB128 number that is an index into
+     .debug_addr and specifies the beginning address, and a 4 byte unsigned
+     number that specifies the length, and then a normal location expression
+     as in .debug_loc.  */
+  DEBUG_LOC_START_LENGTH = 3,
+
+  /* An internal value indicating there is insufficient data.  */
+  DEBUG_LOC_BUFFER_OVERFLOW = -1,
+
+  /* An internal value indicating an invalid kind of entry was found.  */
+  DEBUG_LOC_INVALID_ENTRY = -2
+};
+
+/* Decode the addresses in a non-dwo .debug_loc entry.
+   A pointer to the next byte to examine is returned in *NEW_PTR.
+   The encoded low,high addresses are return in *LOW,*HIGH.
+   The result indicates the kind of entry found.  */
+
+static enum debug_loc_kind
+decode_debug_loc_addresses (const gdb_byte *loc_ptr, const gdb_byte *buf_end,
+                            const gdb_byte **new_ptr,
+                            CORE_ADDR *low, CORE_ADDR *high,
+                            enum bfd_endian byte_order,
+                            unsigned int addr_size,
+                            int signed_addr_p)
+{
+  CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
+
+  if (buf_end - loc_ptr < 2 * addr_size)
+    return DEBUG_LOC_BUFFER_OVERFLOW;
+
+  if (signed_addr_p)
+    *low = extract_signed_integer (loc_ptr, addr_size, byte_order);
+  else
+    *low = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
+  loc_ptr += addr_size;
+
+  if (signed_addr_p)
+    *high = extract_signed_integer (loc_ptr, addr_size, byte_order);
+  else
+    *high = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
+  loc_ptr += addr_size;
+
+  *new_ptr = loc_ptr;
+
+  /* A base-address-selection entry.  */
+  if ((*low & base_mask) == base_mask)
+    return DEBUG_LOC_BASE_ADDRESS;
+
+  /* An end-of-list entry.  */
+  if (*low == 0 && *high == 0)
+    return DEBUG_LOC_END_OF_LIST;
+
+  return DEBUG_LOC_START_END;
+}
+
+/* Decode the addresses in .debug_loc.dwo entry.
+   A pointer to the next byte to examine is returned in *NEW_PTR.
+   The encoded low,high addresses are return in *LOW,*HIGH.
+   The result indicates the kind of entry found.  */
+
+static enum debug_loc_kind
+decode_debug_loc_dwo_addresses (struct dwarf2_per_cu_data *per_cu,
+                                const gdb_byte *loc_ptr,
+                                const gdb_byte *buf_end,
+                                const gdb_byte **new_ptr,
+                                CORE_ADDR *low, CORE_ADDR *high,
+                                enum bfd_endian byte_order)
+{
+  uint64_t low_index, high_index;
+
+  if (loc_ptr == buf_end)
+    return DEBUG_LOC_BUFFER_OVERFLOW;
+
+  switch (*loc_ptr++)
+    {
+    case DEBUG_LOC_END_OF_LIST:
+      *new_ptr = loc_ptr;
+      return DEBUG_LOC_END_OF_LIST;
+    case DEBUG_LOC_BASE_ADDRESS:
+      *low = 0;
+      loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &high_index);
+      if (loc_ptr == NULL)
+        return DEBUG_LOC_BUFFER_OVERFLOW;
+      *high = dwarf2_read_addr_index (per_cu, high_index);
+      *new_ptr = loc_ptr;
+      return DEBUG_LOC_BASE_ADDRESS;
+    case DEBUG_LOC_START_END:
+      loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &low_index);
+      if (loc_ptr == NULL)
+        return DEBUG_LOC_BUFFER_OVERFLOW;
+      *low = dwarf2_read_addr_index (per_cu, low_index);
+      loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &high_index);
+      if (loc_ptr == NULL)
+        return DEBUG_LOC_BUFFER_OVERFLOW;
+      *high = dwarf2_read_addr_index (per_cu, high_index);
+      *new_ptr = loc_ptr;
+      return DEBUG_LOC_START_END;
+    case DEBUG_LOC_START_LENGTH:
+      loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &low_index);
+      if (loc_ptr == NULL)
+        return DEBUG_LOC_BUFFER_OVERFLOW;
+      *low = dwarf2_read_addr_index (per_cu, low_index);
+      if (loc_ptr + 4 > buf_end)
+        return DEBUG_LOC_BUFFER_OVERFLOW;
+      *high = *low;
+      *high += extract_unsigned_integer (loc_ptr, 4, byte_order);
+      *new_ptr = loc_ptr + 4;
+      return DEBUG_LOC_START_LENGTH;
+    default:
+      return DEBUG_LOC_INVALID_ENTRY;
+    }
+}
+
 /* 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.  */
 
 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 length;
   struct objfile *objfile = dwarf2_per_cu_objfile (baton->per_cu);
   struct gdbarch *gdbarch = get_objfile_arch (objfile);
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   unsigned int addr_size = dwarf2_per_cu_addr_size (baton->per_cu);
   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 = dwarf2_per_cu_text_offset (baton->per_cu);
   CORE_ADDR base_address = baton->base_address + base_offset;
+  const gdb_byte *loc_ptr, *buf_end;
 
   loc_ptr = baton->data;
   buf_end = baton->data + baton->size;
 
   while (1)
     {
-      if (buf_end - loc_ptr < 2 * addr_size)
-        error (_("dwarf2_find_location_expression: "
-                 "Corrupted DWARF expression."));
+      CORE_ADDR low = 0, high = 0; /* init for gcc -Wall */
+      int length;
+      enum debug_loc_kind kind;
+      const gdb_byte *new_ptr = NULL; /* init for gcc -Wall */
 
-      if (signed_addr_p)
-        low = extract_signed_integer (loc_ptr, addr_size, byte_order);
+      if (baton->from_dwo)
+        kind = decode_debug_loc_dwo_addresses (baton->per_cu,
+                                               loc_ptr, buf_end, &new_ptr,
+                                               &low, &high, byte_order);
       else
-        low = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
-      loc_ptr += addr_size;
-
-      if (signed_addr_p)
-        high = extract_signed_integer (loc_ptr, addr_size, byte_order);
-      else
-        high = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
-      loc_ptr += addr_size;
-
-      /* A base-address-selection entry.  */
-      if ((low & base_mask) == base_mask)
+        kind = decode_debug_loc_addresses (loc_ptr, buf_end, &new_ptr,
+                                           &low, &high,
+                                           byte_order, addr_size,
+                                           signed_addr_p);
+      loc_ptr = new_ptr;
+      switch (kind)
         {
+        case DEBUG_LOC_END_OF_LIST:
+          *locexpr_length = 0;
+          return NULL;
+        case DEBUG_LOC_BASE_ADDRESS:
           base_address = high + base_offset;
           continue;
-        }
-
-      /* An end-of-list entry.  */
-      if (low == 0 && high == 0)
-        {
-          *locexpr_length = 0;
-          return NULL;
+        case DEBUG_LOC_START_END:
+        case DEBUG_LOC_START_LENGTH:
+          break;
+        case DEBUG_LOC_BUFFER_OVERFLOW:
+        case DEBUG_LOC_INVALID_ENTRY:
+          error (_("dwarf2_find_location_expression: "
+                   "Corrupted DWARF expression."));
+        default:
+          gdb_assert_not_reached ("bad debug_loc_kind");
         }
 
       /* Otherwise, a location expression entry.  */
       low += base_address;
       high += base_address;
 
       length = extract_unsigned_integer (loc_ptr, 2, byte_order);
       loc_ptr += 2;
 
       if (low == high && pc == low)
@@ skipping 148 matching lines @@
   struct objfile *objfile = dwarf2_per_cu_objfile (debaton->per_cu);
 
   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.  */
 
 static void
-per_cu_dwarf_call (struct dwarf_expr_context *ctx, size_t die_offset,
+per_cu_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset,
                    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,
                                            get_frame_pc, baton);
 
   /* DW_OP_call_ref is currently not supported.  */
   gdb_assert (block.per_cu == per_cu);
 
   dwarf_expr_eval (ctx, block.data, block.size);
 }
 
 /* Helper interface of per_cu_dwarf_call for dwarf2_evaluate_loc_desc.  */
 
 static void
-dwarf_expr_dwarf_call (struct dwarf_expr_context *ctx, size_t die_offset)
+dwarf_expr_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset)
 {
   struct dwarf_expr_baton *debaton = ctx->baton;
 
   per_cu_dwarf_call (ctx, die_offset, debaton->per_cu,
                      ctx->funcs->get_frame_pc, ctx->baton);
 }
 
 /* Callback function for dwarf2_evaluate_loc_desc.  */
 
 static struct type *
-dwarf_expr_get_base_type (struct dwarf_expr_context *ctx, size_t die_offset)
+dwarf_expr_get_base_type (struct dwarf_expr_context *ctx,
+                          cu_offset die_offset)
 {
   struct dwarf_expr_baton *debaton = ctx->baton;
 
   return dwarf2_get_die_type (die_offset, debaton->per_cu);
 }
 
 /* See dwarf2loc.h.  */
 
 int entry_values_debug = 0;
 
@@ skipping 315 matching lines @@
    assumed frames between them use GDBARCH.  Use depth first search so we can
    keep single CHAIN of call_site's back to CALLER_PC.  Function recursion
    would have needless GDB stack overhead.  Caller is responsible for xfree of
    the returned result.  Any unreliability results in thrown
    NO_ENTRY_VALUE_ERROR.  */
 
 static struct call_site_chain *
 call_site_find_chain_1 (struct gdbarch *gdbarch, CORE_ADDR caller_pc,
                         CORE_ADDR callee_pc)
 {
-  struct func_type *func_specific;
   struct obstack addr_obstack;
   struct cleanup *back_to_retval, *back_to_workdata;
   struct call_site_chain *retval = NULL;
   struct call_site *call_site;
 
   /* Mark CALL_SITEs so we do not visit the same ones twice.  */
   htab_t addr_hash;
 
   /* CHAIN contains only the intermediate CALL_SITEs.  Neither CALLER_PC's
      call_site nor any possible call_site at CALLEE_PC's function is there.
@@ skipping 143 matching lines @@
             exception_print (gdb_stdout, e);
 
           return NULL;
         }
       else
         throw_exception (e);
     }
   return retval;
 }
 
-/* Fetch call_site_parameter from caller matching the parameters.  FRAME is for
-   callee.  See DWARF_REG and FB_OFFSET description at struct
-   dwarf_expr_context_funcs->push_dwarf_reg_entry_value.
+/* Return 1 if KIND and KIND_U match PARAMETER.  Return 0 otherwise.  */
+
+static int
+call_site_parameter_matches (struct call_site_parameter *parameter,
+                             enum call_site_parameter_kind kind,
+                             union call_site_parameter_u kind_u)
+{
+  if (kind == parameter->kind)
+    switch (kind)
+      {
+      case CALL_SITE_PARAMETER_DWARF_REG:
+        return kind_u.dwarf_reg == parameter->u.dwarf_reg;
+      case CALL_SITE_PARAMETER_FB_OFFSET:
+        return kind_u.fb_offset == parameter->u.fb_offset;
+      case CALL_SITE_PARAMETER_PARAM_OFFSET:
+        return kind_u.param_offset.cu_off == parameter->u.param_offset.cu_off;
+      }
+  return 0;
+}
+
+/* Fetch call_site_parameter from caller matching KIND and KIND_U.
+   FRAME is for callee.
 
    Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
    otherwise.  */
 
 static struct call_site_parameter *
-dwarf_expr_reg_to_entry_parameter (struct frame_info *frame, int dwarf_reg,
-                                   CORE_ADDR fb_offset,
+dwarf_expr_reg_to_entry_parameter (struct frame_info *frame,
+                                   enum call_site_parameter_kind kind,
+                                   union call_site_parameter_u kind_u,
                                    struct dwarf2_per_cu_data **per_cu_return)
 {
   CORE_ADDR func_addr = get_frame_func (frame);
   CORE_ADDR caller_pc;
   struct gdbarch *gdbarch = get_frame_arch (frame);
   struct frame_info *caller_frame = get_prev_frame (frame);
   struct call_site *call_site;
   int iparams;
-  struct value *val;
-  struct dwarf2_locexpr_baton *dwarf_block;
   /* Initialize it just to avoid a GCC false warning.  */
   struct call_site_parameter *parameter = NULL;
   CORE_ADDR target_addr;
 
   if (gdbarch != frame_unwind_arch (frame))
     {
       struct minimal_symbol *msym = lookup_minimal_symbol_by_pc (func_addr);
       struct gdbarch *caller_gdbarch = frame_unwind_arch (frame);
 
       throw_error (NO_ENTRY_VALUE_ERROR,
@@ skipping 34 matching lines @@
                    paddress (gdbarch, func_addr));
     }
 
   /* No entry value based parameters would be reliable if this function can
      call itself via tail calls.  */
   func_verify_no_selftailcall (gdbarch, func_addr);
 
   for (iparams = 0; iparams < call_site->parameter_count; iparams++)
     {
       parameter = &call_site->parameter[iparams];
-      if (parameter->dwarf_reg == -1 && dwarf_reg == -1)
-        {
-          if (parameter->fb_offset == fb_offset)
-            break;
-        }
-      else if (parameter->dwarf_reg == dwarf_reg)
+      if (call_site_parameter_matches (parameter, kind, kind_u))
         break;
     }
   if (iparams == call_site->parameter_count)
     {
       struct minimal_symbol *msym = lookup_minimal_symbol_by_pc (caller_pc);
 
       /* DW_TAG_GNU_call_site_parameter will be missing just if GCC could not
          determine its value.  */
       throw_error (NO_ENTRY_VALUE_ERROR, _("Cannot find matching parameter "
                                            "at DW_TAG_GNU_call_site %s at %s"),
@@ skipping 36 matching lines @@
   /* DW_AT_GNU_call_site_value is a DWARF expression, not a DWARF
      location.  Postprocessing of DWARF_VALUE_MEMORY would lose the type from
      DWARF block.  */
   data = alloca (size + 1);
   memcpy (data, data_src, size);
   data[size] = DW_OP_stack_value;
 
   return dwarf2_evaluate_loc_desc (type, caller_frame, data, size + 1, per_cu);
 }
 
-/* Execute call_site_parameter's DWARF block matching DEREF_SIZE for caller of
-   the CTX's frame.  CTX must be of dwarf_expr_ctx_funcs kind.  See DWARF_REG
-   and FB_OFFSET description at struct
-   dwarf_expr_context_funcs->push_dwarf_reg_entry_value.
+/* Execute DWARF block of call_site_parameter which matches KIND and KIND_U.
+   Choose DEREF_SIZE value of that parameter.  Search caller of the CTX's
+   frame.  CTX must be of dwarf_expr_ctx_funcs kind.
 
    The CTX caller can be from a different CU - per_cu_dwarf_call implementation
    can be more simple as it does not support cross-CU DWARF executions.  */
 
 static void
 dwarf_expr_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)
 {
   struct dwarf_expr_baton *debaton;
   struct frame_info *frame, *caller_frame;
   struct dwarf2_per_cu_data *caller_per_cu;
   struct dwarf_expr_baton baton_local;
   struct dwarf_expr_context saved_ctx;
   struct call_site_parameter *parameter;
   const gdb_byte *data_src;
   size_t size;
 
   gdb_assert (ctx->funcs == &dwarf_expr_ctx_funcs);
   debaton = ctx->baton;
   frame = debaton->frame;
   caller_frame = get_prev_frame (frame);
 
-  parameter = dwarf_expr_reg_to_entry_parameter (frame, dwarf_reg, fb_offset,
+  parameter = dwarf_expr_reg_to_entry_parameter (frame, kind, kind_u,
                                                  &caller_per_cu);
   data_src = deref_size == -1 ? parameter->value : parameter->data_value;
   size = deref_size == -1 ? parameter->value_size : parameter->data_value_size;
 
   /* DEREF_SIZE size is not verified here.  */
   if (data_src == NULL)
     throw_error (NO_ENTRY_VALUE_ERROR,
                  _("Cannot resolve DW_AT_GNU_call_site_data_value"));
 
   baton_local.frame = caller_frame;
   baton_local.per_cu = caller_per_cu;
 
   saved_ctx.gdbarch = ctx->gdbarch;
   saved_ctx.addr_size = ctx->addr_size;
   saved_ctx.offset = ctx->offset;
   saved_ctx.baton = ctx->baton;
   ctx->gdbarch = get_objfile_arch (dwarf2_per_cu_objfile (baton_local.per_cu));
   ctx->addr_size = dwarf2_per_cu_addr_size (baton_local.per_cu);
   ctx->offset = dwarf2_per_cu_text_offset (baton_local.per_cu);
   ctx->baton = &baton_local;
 
   dwarf_expr_eval (ctx, data_src, size);
 
   ctx->gdbarch = saved_ctx.gdbarch;
   ctx->addr_size = saved_ctx.addr_size;
   ctx->offset = saved_ctx.offset;
   ctx->baton = saved_ctx.baton;
 }
 
+/* Callback function for dwarf2_evaluate_loc_desc.
+   Fetch the address indexed by DW_OP_GNU_addr_index.  */
+
+static CORE_ADDR
+dwarf_expr_get_addr_index (void *baton, unsigned int index)
+{
+  struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
+
+  return dwarf2_read_addr_index (debaton->per_cu, index);
+}
+
 /* VALUE must be of type lval_computed with entry_data_value_funcs.  Perform
    the indirect method on it, that is use its stored target value, the sole
    purpose of entry_data_value_funcs..  */
 
 static struct value *
 entry_data_value_coerce_ref (const struct value *value)
 {
   struct type *checked_type = check_typedef (value_type (value));
   struct value *target_val;
 
@@ skipping 36 matching lines @@
   NULL, /* write */
   NULL, /* check_validity */
   NULL, /* check_any_valid */
   NULL, /* indirect */
   entry_data_value_coerce_ref,
   NULL, /* check_synthetic_pointer */
   entry_data_value_copy_closure,
   entry_data_value_free_closure
 };
 
-/* Read parameter of TYPE at (callee) FRAME's function entry.  DWARF_REG and
-   FB_OFFSET are used to match DW_AT_location at the caller's
-   DW_TAG_GNU_call_site_parameter.  See DWARF_REG and FB_OFFSET description at
-   struct dwarf_expr_context_funcs->push_dwarf_reg_entry_value.
+/* Read parameter of TYPE at (callee) FRAME's function entry.  KIND and KIND_U
+   are used to match DW_AT_location at the caller's
+   DW_TAG_GNU_call_site_parameter.
 
    Function always returns non-NULL value.  It throws NO_ENTRY_VALUE_ERROR if it
    cannot resolve the parameter for any reason.  */
 
 static struct value *
 value_of_dwarf_reg_entry (struct type *type, struct frame_info *frame,
-                          int dwarf_reg, CORE_ADDR fb_offset)
+                          enum call_site_parameter_kind kind,
+                          union call_site_parameter_u kind_u)
 {
   struct type *checked_type = check_typedef (type);
   struct type *target_type = TYPE_TARGET_TYPE (checked_type);
   struct frame_info *caller_frame = get_prev_frame (frame);
   struct value *outer_val, *target_val, *val;
   struct call_site_parameter *parameter;
   struct dwarf2_per_cu_data *caller_per_cu;
   CORE_ADDR addr;
 
-  parameter = dwarf_expr_reg_to_entry_parameter (frame, dwarf_reg, fb_offset,
+  parameter = dwarf_expr_reg_to_entry_parameter (frame, kind, kind_u,
                                                  &caller_per_cu);
 
   outer_val = dwarf_entry_parameter_to_value (parameter, -1 /* deref_size */,
                                               type, caller_frame,
                                               caller_per_cu);
 
   /* Check if DW_AT_GNU_call_site_data_value cannot be used.  If it should be
      used and it is not available do not fall back to OUTER_VAL - dereferencing
      TYPE_CODE_REF with non-entry data value would give current value - not the
      entry value.  */
@@ skipping 31 matching lines @@
    SIZE are DWARF block used to match DW_AT_location at the caller's
    DW_TAG_GNU_call_site_parameter.
 
    Function always returns non-NULL value.  It throws NO_ENTRY_VALUE_ERROR if it
    cannot resolve the parameter for any reason.  */
 
 static struct value *
 value_of_dwarf_block_entry (struct type *type, struct frame_info *frame,
                             const gdb_byte *block, size_t block_len)
 {
-  int dwarf_reg;
-  CORE_ADDR fb_offset;
+  union call_site_parameter_u kind_u;
 
-  dwarf_reg = dwarf_block_to_dwarf_reg (block, block + block_len);
-  if (dwarf_reg != -1)
-    return value_of_dwarf_reg_entry (type, frame, dwarf_reg, 0 /* unused */);
+  kind_u.dwarf_reg = dwarf_block_to_dwarf_reg (block, block + block_len);
+  if (kind_u.dwarf_reg != -1)
+    return value_of_dwarf_reg_entry (type, frame, CALL_SITE_PARAMETER_DWARF_REG,
+                                     kind_u);
 
-  if (dwarf_block_to_fb_offset (block, block + block_len, &fb_offset))
-    return value_of_dwarf_reg_entry (type, frame, -1, fb_offset);
+  if (dwarf_block_to_fb_offset (block, block + block_len, &kind_u.fb_offset))
+    return value_of_dwarf_reg_entry (type, frame, CALL_SITE_PARAMETER_FB_OFFSET,
+                                     kind_u);
 
   /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
      suppressed during normal operation.  The expression can be arbitrary if
      there is no caller-callee entry value binding expected.  */
   throw_error (NO_ENTRY_VALUE_ERROR,
                _("DWARF-2 expression error: DW_OP_GNU_entry_value is supported "
                  "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
 }
 
 struct piece_closure
@@ skipping 777 matching lines @@
 static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs =
 {
   dwarf_expr_read_reg,
   dwarf_expr_read_mem,
   dwarf_expr_frame_base,
   dwarf_expr_frame_cfa,
   dwarf_expr_frame_pc,
   dwarf_expr_tls_address,
   dwarf_expr_dwarf_call,
   dwarf_expr_get_base_type,
-  dwarf_expr_push_dwarf_reg_entry_value
+  dwarf_expr_push_dwarf_reg_entry_value,
+  dwarf_expr_get_addr_index
 };
 
 /* 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.  BYTE_OFFSET is applied after the contents are
    computed.  */
 
 static struct value *
 dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame,
                                const gdb_byte *data, unsigned short size,
@@ skipping 256 matching lines @@
 
 /* Thread-local accesses do require a frame.  */
 static CORE_ADDR
 needs_frame_tls_address (void *baton, CORE_ADDR offset)
 {
   struct needs_frame_baton *nf_baton = baton;
 
   nf_baton->needs_frame = 1;
   return 1;
 }