gdb/

	Display @entry parameter values even for references.
	* ada-valprint.c (ada_val_print_1) <TYPE_CODE_REF>: Try also
	coerce_ref_if_computed.
	* c-valprint.c (c_val_print) <TYPE_CODE_REF>: Likewise.
	* dwarf2expr.c (dwarf_block_to_dwarf_reg_deref): New function.
	(execute_stack_op) <DW_OP_GNU_entry_value>: Add -1 deref_size to the
	existing push_dwarf_reg_entry_value call.  Add new detection calling
	dwarf_block_to_dwarf_reg_deref.  Update the error message.
	(ctx_no_push_dwarf_reg_entry_value): New parameter deref_size.
	* dwarf2expr.h
	(struct dwarf_expr_context_funcs) <push_dwarf_reg_entry_value>: Add new
	parameter deref_size, describe it in the comment.
	(ctx_no_push_dwarf_reg_entry_value): Add new parameter deref_size.
	(dwarf_block_to_dwarf_reg_deref): New declaration.
	* dwarf2loc.c (dwarf_entry_parameter_to_value): Add new parameter
	deref_size, describe it in the function comment.  New variables
	data_src and size, fetch the alternative block accoring to DEREF_SIZE.
	(dwarf_expr_push_dwarf_reg_entry_value): Add new parameter deref_size,
	describe it in the function comment.  Fetch the alternative block
	accoring to DEREF_SIZE.
	(entry_data_value_coerce_ref, entry_data_value_copy_closure)
	(entry_data_value_free_closure, entry_data_value_funcs): New.
	(value_of_dwarf_reg_entry): New variables checked_type, target_type,
	outer_val, target_val, val and addr.  Try to fetch and create also
	referenced value content.
	(pieced_value_funcs): NULL value for coerce_ref.
	(needs_dwarf_reg_entry_value): Add new parameter deref_size.
	* f-valprint.c (f_val_print) <TYPE_CODE_REF>: Try also
	coerce_ref_if_computed.
	* opencl-lang.c (opencl_value_funcs): NULL value for coerce_ref.
	* p-valprint.c (pascal_val_print) <TYPE_CODE_REF>: Likewise.
	* stack.c (read_frame_arg): Compare also dereferenced values.
	* value.c (value_computed_funcs): Make the parameter v const, use
	value_lval_const for it.
	(value_lval_const, coerce_ref_if_computed): New function.
	(coerce_ref): New variable retval.  Call also coerce_ref_if_computed.
	* value.h (struct lval_funcs): New field coerce_ref.
	(value_computed_funcs): Make the parameter v const.
	(value_lval_const, coerce_ref_if_computed): New declarations.

gdb/testsuite/
	Display @entry parameter values even for references.
	* gdb.arch/amd64-entry-value.cc (reference, datap, datap_input): New
	functions.
	(main): New variables regvar, nodatavarp, stackvar1, stackvar2.  Call
	reference and datap_input.
	* gdb.arch/amd64-entry-value.exp (reference, breakhere_reference): New
	breakpoints.
	(continue to breakpoint: entry_reference: reference)
	(entry_reference: bt at entry)
	(continue to breakpoint: entry_reference: breakhere_reference)
	(entry_reference: bt, entry_reference: ptype regparam)
	(entry_reference: p regparam, entry_reference: ptype regparam@entry)
	(entry_reference: p regparam@entry, entry_reference: p &regparam@entry)
	(entry_reference: p regcopy, entry_reference: p nodataparam)
	(entry_reference: p nodataparam@entry): New tests.

15 files changed, 496 insertions, 47 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 5d1339e..e7cb998 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,5 +1,47 @@
 2011-10-09  Jan Kratochvil  <jan.kratochvil@redhat.com>
 
+	Display @entry parameter values even for references.
+	* ada-valprint.c (ada_val_print_1) <TYPE_CODE_REF>: Try also
+	coerce_ref_if_computed.
+	* c-valprint.c (c_val_print) <TYPE_CODE_REF>: Likewise.
+	* dwarf2expr.c (dwarf_block_to_dwarf_reg_deref): New function.
+	(execute_stack_op) <DW_OP_GNU_entry_value>: Add -1 deref_size to the
+	existing push_dwarf_reg_entry_value call.  Add new detection calling
+	dwarf_block_to_dwarf_reg_deref.  Update the error message.
+	(ctx_no_push_dwarf_reg_entry_value): New parameter deref_size.
+	* dwarf2expr.h
+	(struct dwarf_expr_context_funcs) <push_dwarf_reg_entry_value>: Add new
+	parameter deref_size, describe it in the comment.
+	(ctx_no_push_dwarf_reg_entry_value): Add new parameter deref_size.
+	(dwarf_block_to_dwarf_reg_deref): New declaration.
+	* dwarf2loc.c (dwarf_entry_parameter_to_value): Add new parameter
+	deref_size, describe it in the function comment.  New variables
+	data_src and size, fetch the alternative block accoring to DEREF_SIZE.
+	(dwarf_expr_push_dwarf_reg_entry_value): Add new parameter deref_size,
+	describe it in the function comment.  Fetch the alternative block
+	accoring to DEREF_SIZE.
+	(entry_data_value_coerce_ref, entry_data_value_copy_closure)
+	(entry_data_value_free_closure, entry_data_value_funcs): New.
+	(value_of_dwarf_reg_entry): New variables checked_type, target_type,
+	outer_val, target_val, val and addr.  Try to fetch and create also
+	referenced value content.
+	(pieced_value_funcs): NULL value for coerce_ref.
+	(needs_dwarf_reg_entry_value): Add new parameter deref_size.
+	* f-valprint.c (f_val_print) <TYPE_CODE_REF>: Try also
+	coerce_ref_if_computed.
+	* opencl-lang.c (opencl_value_funcs): NULL value for coerce_ref.
+	* p-valprint.c (pascal_val_print) <TYPE_CODE_REF>: Likewise.
+	* stack.c (read_frame_arg): Compare also dereferenced values.
+	* value.c (value_computed_funcs): Make the parameter v const, use
+	value_lval_const for it.
+	(value_lval_const, coerce_ref_if_computed): New function.
+	(coerce_ref): New variable retval.  Call also coerce_ref_if_computed.
+	* value.h (struct lval_funcs): New field coerce_ref.
+	(value_computed_funcs): Make the parameter v const.
+	(value_lval_const, coerce_ref_if_computed): New declarations.
+
+2011-10-09  Jan Kratochvil  <jan.kratochvil@redhat.com>
+
 	Support @entry in input expressions.
 	* c-exp.y (ENTRY, unknown_cpp_name): New.
 	(exp: UNKNOWN_CPP_NAME): Change to `exp: unknown_cpp_name'.
diff --git a/gdb/ada-valprint.c b/gdb/ada-valprint.c
index 7b9e3ee..8a72b9e 100644
--- a/gdb/ada-valprint.c
+++ b/gdb/ada-valprint.c
@@ -898,9 +898,18 @@ ada_val_print_1 (struct type *type, const gdb_byte *valaddr,
       
       if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
         {
-          CORE_ADDR deref_val_int
-	    = unpack_pointer (type, valaddr + offset_aligned);
+          CORE_ADDR deref_val_int;
+	  struct value *deref_val;
 
+	  deref_val = coerce_ref_if_computed (original_value);
+	  if (deref_val)
+	    {
+	      common_val_print (deref_val, stream, recurse + 1, options,
+				current_language);
+	      break;
+	    }
+
+          deref_val_int = unpack_pointer (type, valaddr + offset_aligned);
           if (deref_val_int != 0)
             {
               struct value *deref_val =
diff --git a/gdb/c-valprint.c b/gdb/c-valprint.c
index 76579d2..3461b08 100644
--- a/gdb/c-valprint.c
+++ b/gdb/c-valprint.c
@@ -380,10 +380,19 @@ c_val_print (struct type *type, const gdb_byte *valaddr,
 	{
 	  if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
 	    {
-	      struct value *deref_val =
-		value_at
-		(TYPE_TARGET_TYPE (type),
-		 unpack_pointer (type, valaddr + embedded_offset));
+	      struct value *deref_val;
+
+	      deref_val = coerce_ref_if_computed (original_value);
+	      if (deref_val != NULL)
+		{
+		  /* More complicated computed references are not supported.  */
+		  gdb_assert (embedded_offset == 0);
+		}
+	      else
+		deref_val = value_at (TYPE_TARGET_TYPE (type),
+				      unpack_pointer (type,
+						      (valaddr
+						       + embedded_offset)));
 
 	      common_val_print (deref_val, stream, recurse, options,
 				current_language);
diff --git a/gdb/dwarf2expr.c b/gdb/dwarf2expr.c
index 4fccc26..71aff6a 100644
--- a/gdb/dwarf2expr.c
+++ b/gdb/dwarf2expr.c
@@ -518,6 +518,63 @@ dwarf_block_to_dwarf_reg (const gdb_byte *buf, const gdb_byte *buf_end)
   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.  */
 
@@ -1304,12 +1361,27 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 	      {
 		op_ptr += len;
 		ctx->funcs->push_dwarf_reg_entry_value (ctx, dwarf_reg,
-							0 /* unused */);
+							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*"));
+		     "supported only for single DW_OP_reg* "
+		     "or for DW_OP_breg*(0)+DW_OP_deref*"));
 	  }
 
 	case DW_OP_GNU_const_type:
@@ -1460,7 +1532,8 @@ ctx_no_get_base_type (struct dwarf_expr_context *ctx, size_t die)
 
 void
 ctx_no_push_dwarf_reg_entry_value (struct dwarf_expr_context *ctx,
-				   int dwarf_reg, CORE_ADDR fb_offset)
+				   int dwarf_reg, CORE_ADDR fb_offset,
+				   int deref_size)
 {
   internal_error (__FILE__, __LINE__,
 		  _("Support for DW_OP_GNU_entry_value is unimplemented"));
diff --git a/gdb/dwarf2expr.h b/gdb/dwarf2expr.h
index c014ce2..a319ca3 100644
--- a/gdb/dwarf2expr.h
+++ b/gdb/dwarf2expr.h
@@ -67,9 +67,11 @@ struct dwarf_expr_context_funcs
      number DWARF_REG specifying the push_dwarf_reg_entry_value parameter is
      not -1 FB_OFFSET is ignored.  Otherwise FB_OFFSET specifies stack
      parameter offset against caller's stack pointer (which equals the callee's
-     frame base).  */
+     frame base).  If DEREF_SIZE is not -1 then use
+     DW_AT_GNU_call_site_data_value instead of DW_AT_GNU_call_site_value.  */
   void (*push_dwarf_reg_entry_value) (struct dwarf_expr_context *ctx,
-				      int dwarf_reg, CORE_ADDR fb_offset);
+				      int dwarf_reg, CORE_ADDR fb_offset,
+				      int deref_size);
 
 #if 0
   /* Not yet implemented.  */
@@ -277,10 +279,15 @@ CORE_ADDR ctx_no_get_tls_address (void *baton, CORE_ADDR offset);
 void ctx_no_dwarf_call (struct dwarf_expr_context *ctx, size_t die_offset);
 struct type *ctx_no_get_base_type (struct dwarf_expr_context *ctx, size_t die);
 void ctx_no_push_dwarf_reg_entry_value (struct dwarf_expr_context *ctx,
-					int dwarf_reg, CORE_ADDR fb_offset);
+					int dwarf_reg, CORE_ADDR fb_offset,
+					int deref_size);
 
 int dwarf_block_to_dwarf_reg (const gdb_byte *buf, const gdb_byte *buf_end);
 
+int dwarf_block_to_dwarf_reg_deref (const gdb_byte *buf,
+				    const gdb_byte *buf_end,
+				    CORE_ADDR *deref_size_return);
+
 int dwarf_block_to_fb_offset (const gdb_byte *buf, const gdb_byte *buf_end,
 			      CORE_ADDR *fb_offset_return);
 
diff --git a/gdb/dwarf2loc.c b/gdb/dwarf2loc.c
index a44d3d2..0e1179c 100644
--- a/gdb/dwarf2loc.c
+++ b/gdb/dwarf2loc.c
@@ -910,7 +910,9 @@ dwarf_expr_reg_to_entry_parameter (struct frame_info *frame, int dwarf_reg,
   return parameter;
 }
 
-/* Return value for PARAMETER for DW_AT_GNU_call_site_value.
+/* Return value for PARAMETER matching DEREF_SIZE.  If DEREF_SIZE is -1, return
+   the normal DW_AT_GNU_call_site_value block.  Otherwise return the
+   DW_AT_GNU_call_site_data_value (dereferenced) block.
 
    TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
    struct value.
@@ -920,33 +922,44 @@ dwarf_expr_reg_to_entry_parameter (struct frame_info *frame, int dwarf_reg,
 
 static struct value *
 dwarf_entry_parameter_to_value (struct call_site_parameter *parameter,
-				struct type *type,
+				CORE_ADDR deref_size, struct type *type,
 				struct frame_info *caller_frame,
 				struct dwarf2_per_cu_data *per_cu)
 {
+  const gdb_byte *data_src;
   gdb_byte *data;
+  size_t size;
+
+  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"));
 
   /* 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 (parameter->value_size + 1);
-  memcpy (data, parameter->value, parameter->value_size);
-  data[parameter->value_size] = DW_OP_stack_value;
+  data = alloca (size + 1);
+  memcpy (data, data_src, size);
+  data[size] = DW_OP_stack_value;
 
-  return dwarf2_evaluate_loc_desc (type, caller_frame, data,
-				   parameter->value_size + 1, per_cu);
+  return dwarf2_evaluate_loc_desc (type, caller_frame, data, size + 1, per_cu);
 }
 
-/* Execute call_site_parameter's DWARF block 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 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.
 
    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)
+				       int dwarf_reg, CORE_ADDR fb_offset,
+				       int deref_size)
 {
   struct dwarf_expr_baton *debaton;
   struct frame_info *frame, *caller_frame;
@@ -964,8 +977,13 @@ dwarf_expr_push_dwarf_reg_entry_value (struct dwarf_expr_context *ctx,
 
   parameter = dwarf_expr_reg_to_entry_parameter (frame, dwarf_reg, fb_offset,
 						 &caller_per_cu);
-  data_src = parameter->value;
-  size = parameter->value_size;
+  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;
@@ -987,6 +1005,62 @@ dwarf_expr_push_dwarf_reg_entry_value (struct dwarf_expr_context *ctx,
   ctx->baton = saved_ctx.baton;
 }
 
+/* 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;
+
+  if (TYPE_CODE (checked_type) != TYPE_CODE_REF)
+    return NULL;
+
+  target_val = value_computed_closure (value);
+  value_incref (target_val);
+  return target_val;
+}
+
+/* Implement copy_closure.  */
+
+static void *
+entry_data_value_copy_closure (const struct value *v)
+{
+  struct value *target_val = value_computed_closure (v);
+
+  value_incref (target_val);
+  return target_val;
+}
+
+/* Implement free_closure.  */
+
+static void
+entry_data_value_free_closure (struct value *v)
+{
+  struct value *target_val = value_computed_closure (v);
+
+  value_free (target_val);
+}
+
+/* Vector for methods for an entry value reference where the referenced value
+   is stored in the caller.  On the first dereference use
+   DW_AT_GNU_call_site_data_value in the caller.  */
+
+static const struct lval_funcs entry_data_value_funcs =
+{
+  NULL,	/* read */
+  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
@@ -999,15 +1073,53 @@ static struct value *
 value_of_dwarf_reg_entry (struct type *type, struct frame_info *frame,
 			  int dwarf_reg, CORE_ADDR fb_offset)
 {
+  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,
 						 &caller_per_cu);
 
-  return dwarf_entry_parameter_to_value (parameter, type, caller_frame,
-					 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.  */
+
+  if (TYPE_CODE (checked_type) != TYPE_CODE_REF
+      || TYPE_TARGET_TYPE (checked_type) == NULL)
+    return outer_val;
+
+  target_val = dwarf_entry_parameter_to_value (parameter,
+					       TYPE_LENGTH (target_type),
+					       target_type, caller_frame,
+					       caller_per_cu);
+
+  /* value_as_address dereferences TYPE_CODE_REF.  */
+  addr = extract_typed_address (value_contents (outer_val), checked_type);
+
+  /* The target entry value has artificial address of the entry value
+     reference.  */
+  VALUE_LVAL (target_val) = lval_memory;
+  set_value_address (target_val, addr);
+
+  release_value (target_val);
+  val = allocate_computed_value (type, &entry_data_value_funcs,
+				 target_val /* closure */);
+
+  /* Copy the referencing pointer to the new computed value.  */
+  memcpy (value_contents_raw (val), value_contents_raw (outer_val),
+	  TYPE_LENGTH (checked_type));
+  set_value_lazy (val, 0);
+
+  return val;
 }
 
 /* Read parameter of TYPE at (callee) FRAME's function entry.  DATA and
@@ -1799,6 +1911,7 @@ static const struct lval_funcs pieced_value_funcs = {
   check_pieced_value_validity,
   check_pieced_value_invalid,
   indirect_pieced_value,
+  NULL,	/* coerce_ref */
   check_pieced_synthetic_pointer,
   copy_pieced_value_closure,
   free_pieced_value_closure
@@ -2118,7 +2231,7 @@ needs_frame_dwarf_call (struct dwarf_expr_context *ctx, size_t die_offset)
 
 static void
 needs_dwarf_reg_entry_value (struct dwarf_expr_context *ctx,
-			     int dwarf_reg, CORE_ADDR fb_offset)
+			     int dwarf_reg, CORE_ADDR fb_offset, int deref_size)
 {
   struct needs_frame_baton *nf_baton = ctx->baton;
 
diff --git a/gdb/f-valprint.c b/gdb/f-valprint.c
index 66b425d..b800d89 100644
--- a/gdb/f-valprint.c
+++ b/gdb/f-valprint.c
@@ -346,10 +346,19 @@ f_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
 	{
 	  if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
 	    {
-	      struct value *deref_val =
-		value_at
-		(TYPE_TARGET_TYPE (type),
-		 unpack_pointer (type, valaddr + embedded_offset));
+	      struct value *deref_val;
+
+	      deref_val = coerce_ref_if_computed (original_value);
+	      if (deref_val != NULL)
+		{
+		  /* More complicated computed references are not supported.  */
+		  gdb_assert (embedded_offset == 0);
+		}
+	      else
+		deref_val = value_at (TYPE_TARGET_TYPE (type),
+				      unpack_pointer (type,
+						      (valaddr
+						       + embedded_offset)));
 
 	      common_val_print (deref_val, stream, recurse,
 				options, current_language);
diff --git a/gdb/opencl-lang.c b/gdb/opencl-lang.c
index 79ad5f6..05955b4 100644
--- a/gdb/opencl-lang.c
+++ b/gdb/opencl-lang.c
@@ -360,7 +360,8 @@ static const struct lval_funcs opencl_value_funcs =
     lval_func_write,
     lval_func_check_validity,
     lval_func_check_any_valid,
-    NULL,
+    NULL,	/* indirect */
+    NULL,	/* coerce_ref */
     lval_func_check_synthetic_pointer,
     lval_func_copy_closure,
     lval_func_free_closure
diff --git a/gdb/p-valprint.c b/gdb/p-valprint.c
index d2efa5b..e55b122 100644
--- a/gdb/p-valprint.c
+++ b/gdb/p-valprint.c
@@ -272,10 +272,19 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr,
 	{
 	  if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
 	    {
-	      struct value *deref_val =
-		value_at
-		(TYPE_TARGET_TYPE (type),
-		 unpack_pointer (type, valaddr + embedded_offset));
+	      struct value *deref_val;
+
+	      deref_val = coerce_ref_if_computed (original_value);
+	      if (deref_val != NULL)
+		{
+		  /* More complicated computed references are not supported.  */
+		  gdb_assert (embedded_offset == 0);
+		}
+	      else
+		deref_val = value_at (TYPE_TARGET_TYPE (type),
+				      unpack_pointer (type,
+						      (valaddr
+						       + embedded_offset)));
 
 	      common_val_print (deref_val, stream, recurse + 1, options,
 				current_language);
diff --git a/gdb/stack.c b/gdb/stack.c
index 397b345..b01dc1c 100644
--- a/gdb/stack.c
+++ b/gdb/stack.c
@@ -350,8 +350,50 @@ read_frame_arg (struct symbol *sym, struct frame_info *frame,
 	      if (!value_optimized_out (val)
 		  && value_available_contents_eq (val, 0, entryval, 0, len))
 		{
-		  entryval = NULL;
-		  val_equal = 1;
+		  struct value *val_deref, *entryval_deref;
+
+		  /* DW_AT_GNU_call_site_value does match with the current
+		     value.  If it is a reference still try to verify if
+		     dereferenced DW_AT_GNU_call_site_data_value does not
+		     differ.  */
+
+		  TRY_CATCH (except, RETURN_MASK_ERROR)
+		    {
+		      unsigned len_deref;
+
+		      val_deref = coerce_ref (val);
+		      if (value_lazy (val_deref))
+			value_fetch_lazy (val_deref);
+		      len_deref = TYPE_LENGTH (value_type (val_deref));
+
+		      entryval_deref = coerce_ref (entryval);
+		      if (value_lazy (entryval_deref))
+			value_fetch_lazy (entryval_deref);
+
+		      /* If the reference addresses match but dereferenced
+			 content does not match print them.  */
+		      if (val != val_deref
+			  && value_available_contents_eq (val_deref, 0,
+							  entryval_deref, 0,
+							  len_deref))
+			val_equal = 1;
+		    }
+
+		  /* Value was not a reference; and its content matches.  */
+		  if (val == val_deref)
+		    val_equal = 1;
+		  /* If the dereferenced content could not be fetched do not
+		     display anything.  */
+		  else if (except.error == NO_ENTRY_VALUE_ERROR)
+		    val_equal = 1;
+		  else if (except.message)
+		    {
+		      entryval_error = alloca (strlen (except.message) + 1);
+		      strcpy (entryval_error, except.message);
+		    }
+
+		  if (val_equal)
+		    entryval = NULL;
 		}
 	    }
 
diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog
index e3df529a..1a7b5da 100644
--- a/gdb/testsuite/ChangeLog
+++ b/gdb/testsuite/ChangeLog
@@ -1,5 +1,23 @@
 2011-10-09  Jan Kratochvil  <jan.kratochvil@redhat.com>
 
+	Display @entry parameter values even for references.
+	* gdb.arch/amd64-entry-value.cc (reference, datap, datap_input): New
+	functions.
+	(main): New variables regvar, nodatavarp, stackvar1, stackvar2.  Call
+	reference and datap_input.
+	* gdb.arch/amd64-entry-value.exp (reference, breakhere_reference): New
+	breakpoints.
+	(continue to breakpoint: entry_reference: reference)
+	(entry_reference: bt at entry)
+	(continue to breakpoint: entry_reference: breakhere_reference)
+	(entry_reference: bt, entry_reference: ptype regparam)
+	(entry_reference: p regparam, entry_reference: ptype regparam@entry)
+	(entry_reference: p regparam@entry, entry_reference: p &regparam@entry)
+	(entry_reference: p regcopy, entry_reference: p nodataparam)
+	(entry_reference: p nodataparam@entry): New tests.
+
+2011-10-09  Jan Kratochvil  <jan.kratochvil@redhat.com>
+
 	Support @entry in input expressions.
 	* gdb.arch/amd64-entry-value.exp (entry: p i@entry, entry: p j@entry)
 	(entry_stack: p s1@entry, entry_stack: p s2@entry)
diff --git a/gdb/testsuite/gdb.arch/amd64-entry-value.cc b/gdb/testsuite/gdb.arch/amd64-entry-value.cc
index 7b7d050..2202e28 100644
--- a/gdb/testsuite/gdb.arch/amd64-entry-value.cc
+++ b/gdb/testsuite/gdb.arch/amd64-entry-value.cc
@@ -135,6 +135,40 @@ asm ("breakhere_stacktest:");
   e (v, v);
 }
 
+/* nodataparam has DW_AT_GNU_call_site_value but it does not have
+   DW_AT_GNU_call_site_data_value.  GDB should not display dereferenced @entry
+   value for it.  */
+
+static void __attribute__((noinline, noclone))
+reference (int &regparam, int &nodataparam, int r3, int r4, int r5, int r6,
+	   int &stackparam1, int &stackparam2)
+{
+  int regcopy = regparam, nodatacopy = nodataparam;
+  int stackcopy1 = stackparam1, stackcopy2 = stackparam2;
+
+  regparam = 21;
+  nodataparam = 22;
+  stackparam1 = 31;
+  stackparam2 = 32;
+  e (v, v);
+asm ("breakhere_reference:");
+  e (v, v);
+}
+
+static int *__attribute__((noinline, noclone))
+datap ()
+{
+  static int two = 2;
+
+  return &two;
+}
+
+static void __attribute__((noinline, noclone))
+datap_input (int *datap)
+{
+  (*datap)++;
+}
+
 static int __attribute__((noinline, noclone))
 data (void)
 {
@@ -183,6 +217,12 @@ main ()
   validity (5, data ());
   invalid (data2 ());
 
+  {
+    int regvar = 1, *nodatavarp = datap (), stackvar1 = 11, stackvar2 = 12;
+    reference (regvar, *nodatavarp, 3, 4, 5, 6, stackvar1, stackvar2);
+    datap_input (nodatavarp);
+  }
+
   if (v)
     a (1, 1.25);
   else
diff --git a/gdb/testsuite/gdb.arch/amd64-entry-value.exp b/gdb/testsuite/gdb.arch/amd64-entry-value.exp
index 10a82ab..185249c 100644
--- a/gdb/testsuite/gdb.arch/amd64-entry-value.exp
+++ b/gdb/testsuite/gdb.arch/amd64-entry-value.exp
@@ -42,6 +42,8 @@ gdb_breakpoint "different"
 gdb_breakpoint "breakhere_different"
 gdb_breakpoint "breakhere_validity"
 gdb_breakpoint "breakhere_invalid"
+gdb_breakpoint "reference"
+gdb_breakpoint "breakhere_reference"
 
 
 # Test @entry values for register passed parameters.
@@ -158,6 +160,38 @@ gdb_test_no_output "set print entry-values default" "entry_invalid: set print en
 gdb_test "frame" {\(inv=<optimized out>\).*} "entry_invalid: frame: default"
 
 
+# Test @entry values for DW_AT_GNU_call_site_data_value parameters.
+
+gdb_continue_to_breakpoint "entry_reference: reference"
+
+# GCC PR debug/49980: Missing stackparam1@entry and stackparam2@entry.
+gdb_test "bt" "#0 +reference \\(regparam=regparam@entry=@0x\[0-9a-f\]+: 1, nodataparam=@0x\[0-9a-f\]+: 2, \[^\r\n\]+, stackparam1=@0x\[0-9a-f\]+: 11, stackparam2=@0x\[0-9a-f\]+: 12\\) \[^\r\n\]*\r\n#1 +0x\[0-9a-f\]+ in main \\(\\) \[^\r\n\]*" \
+	 "entry_reference: bt at entry"
+
+gdb_continue_to_breakpoint "entry_reference: breakhere_reference"
+
+# GCC PR debug/49980: Missing stackparam1@entry and stackparam2@entry.
+gdb_test "bt" "#0 +reference \\(regparam=@0x\[0-9a-f\]+: 21, regparam@entry=@0x\[0-9a-f\]+: 1, nodataparam=@0x\[0-9a-f\]+: 22, \[^\r\n\]+, stackparam1=@0x\[0-9a-f\]+: 31, stackparam2=@0x\[0-9a-f\]+: 32\\) \[^\r\n\]*\r\n#1 +0x\[0-9a-f\]+ in main \\(\\) \[^\r\n\]*" \
+	 "entry_reference: bt"
+gdb_test "ptype regparam" " = int &" "entry_reference: ptype regparam"
+
+set test "entry_reference: p regparam"
+set addr ""
+gdb_test_multiple "p regparam" $test {
+    -re " = \\(int &\\) @(0x\[0-9a-f\]+): 21\r\n$gdb_prompt $" {
+	set addr $expect_out(1,string)
+	pass $test
+    }
+}
+
+gdb_test "ptype regparam@entry" " = int &" "entry_reference: ptype regparam@entry"
+gdb_test "p regparam@entry" " = \\(int &\\) @$addr: 1" "entry_reference: p regparam@entry"
+gdb_test "p &regparam@entry" " = \\(int \\*\\) $addr" "entry_reference: p &regparam@entry"
+gdb_test "p regcopy" " = 1" "entry_reference: p regcopy"
+gdb_test "p nodataparam" " = \\(int &\\) @0x\[0-9a-f\]+: 22" "entry_reference: p nodataparam"
+gdb_test "p nodataparam@entry" "Cannot resolve DW_AT_GNU_call_site_data_value" "entry_reference: p nodataparam@entry"
+
+
 # Test virtual tail call frames.
 
 gdb_continue_to_breakpoint "tailcall: breakhere"
diff --git a/gdb/value.c b/gdb/value.c
index 087cdfd..e72670b 100644
--- a/gdb/value.c
+++ b/gdb/value.c
@@ -1063,9 +1063,9 @@ set_value_pointed_to_offset (struct value *value, int val)
 }
 
 const struct lval_funcs *
-value_computed_funcs (struct value *v)
+value_computed_funcs (const struct value *v)
 {
-  gdb_assert (VALUE_LVAL (v) == lval_computed);
+  gdb_assert (value_lval_const (v) == lval_computed);
 
   return v->location.computed.funcs;
 }
@@ -1084,6 +1084,12 @@ deprecated_value_lval_hack (struct value *value)
   return &value->lval;
 }
 
+enum lval_type
+value_lval_const (const struct value *value)
+{
+  return value->lval;
+}
+
 CORE_ADDR
 value_address (const struct value *value)
 {
@@ -3083,15 +3089,39 @@ value_from_history_ref (char *h, char **endp)
 }
 
 struct value *
+coerce_ref_if_computed (const struct value *arg)
+{
+  const struct lval_funcs *funcs;
+
+  if (TYPE_CODE (check_typedef (value_type (arg))) != TYPE_CODE_REF)
+    return NULL;
+
+  if (value_lval_const (arg) != lval_computed)
+    return NULL;
+
+  funcs = value_computed_funcs (arg);
+  if (funcs->coerce_ref == NULL)
+    return NULL;
+
+  return funcs->coerce_ref (arg);
+}
+
+struct value *
 coerce_ref (struct value *arg)
 {
   struct type *value_type_arg_tmp = check_typedef (value_type (arg));
+  struct value *retval;
 
-  if (TYPE_CODE (value_type_arg_tmp) == TYPE_CODE_REF)
-    arg = value_at_lazy (TYPE_TARGET_TYPE (value_type_arg_tmp),
-			 unpack_pointer (value_type (arg),		
-					 value_contents (arg)));
-  return arg;
+  retval = coerce_ref_if_computed (arg);
+  if (retval)
+    return retval;
+
+  if (TYPE_CODE (value_type_arg_tmp) != TYPE_CODE_REF)
+    return arg;
+
+  return value_at_lazy (TYPE_TARGET_TYPE (value_type_arg_tmp),
+			unpack_pointer (value_type (arg),
+					value_contents (arg)));
 }
 
 struct value *
diff --git a/gdb/value.h b/gdb/value.h
index 83c94fc..dc2ac13 100644
--- a/gdb/value.h
+++ b/gdb/value.h
@@ -180,6 +180,11 @@ struct lval_funcs
      will fall back to ordinary indirection.  */
   struct value *(*indirect) (struct value *value);
 
+  /* If non-NULL, this is used to implement reference resolving for
+     this value.  This method may return NULL, in which case coerce_ref
+     will fall back to ordinary references resolving.  */
+  struct value *(*coerce_ref) (const struct value *value);
+
   /* If non-NULL, this is used to determine whether the indicated bits
      of VALUE are a synthetic pointer.  */
   int (*check_synthetic_pointer) (const struct value *value,
@@ -213,7 +218,7 @@ extern struct value *allocate_optimized_out_value (struct type *type);
 
 /* If VALUE is lval_computed, return its lval_funcs structure.  */
 
-extern const struct lval_funcs *value_computed_funcs (struct value *value);
+extern const struct lval_funcs *value_computed_funcs (const struct value *);
 
 /* If VALUE is lval_computed, return its closure.  The meaning of the
    returned value depends on the functions VALUE uses.  */
@@ -314,6 +319,9 @@ extern void set_value_component_location (struct value *component,
 extern enum lval_type *deprecated_value_lval_hack (struct value *);
 #define VALUE_LVAL(val) (*deprecated_value_lval_hack (val))
 
+/* Like VALUE_LVAL, except the parameter can be const.  */
+extern enum lval_type value_lval_const (const struct value *value);
+
 /* If lval == lval_memory, return the address in the inferior.  If
    lval == lval_register, return the byte offset into the registers
    structure.  Otherwise, return 0.  The returned address
@@ -340,6 +348,11 @@ extern struct frame_id *deprecated_value_frame_id_hack (struct value *);
 extern short *deprecated_value_regnum_hack (struct value *);
 #define VALUE_REGNUM(val) (*deprecated_value_regnum_hack (val))
 
+/* Return value after lval_funcs->coerce_ref (after check_typedef).  Return
+   NULL if lval_funcs->coerce_ref is not applicable for whatever reason.  */
+
+extern struct value *coerce_ref_if_computed (const struct value *arg);
+
 /* Convert a REF to the object referenced.  */
 
 extern struct value *coerce_ref (struct value *value);