diff mbox

[RFA] c++/16675 (incorrect sizeof reference types)

Message ID 532C8408.9030905@redhat.com
State Committed
Headers show

Commit Message

Keith Seitz March 21, 2014, 6:25 p.m. UTC
Hi,

This bug is easily demonstrated (from the bugzilla):

     typedef unsigned char a4[4];
     a4 p1;
     a4& p2 = p1;
     std::cout<<sizeof(p2);

(gdb) p sizeof (p2)
$1 = 8

Yet if you run the thing, it prints "4".

Regarding the sizeof operator and references, $5.3.3/2 of the n3290 
draft says, "When applied to a reference or a reference type, the result 
is the size of the referenced type."

The following patch implements this change in the c++ parser (when type 
names are used) and expression evaluator (when variable names are used).

No regressions on native x86_64-linux or native-gdbserver.

Keith

ChangeLog
2014-03-20  Keith Seitz  <keiths@redhat.com>

	PR c++/16675
	* c-exp.y (exp : SIZEOF '(' type ')'): Handle reference types.
	* eval.c (evaluate_subexp_for_sizeof): Refactor and handle
	reference types.

testsuite/ChangeLog
2014-03-20  Keith Seitz  <keiths@redhat.com>

	PR c++/16675
	* gdb.cp/cpsizeof.exp: New file.
	* gdb.cp/cpsizeof.cc: New file.

Comments

Tom Tromey April 10, 2014, 5:05 p.m. UTC | #1
>>>>> "Keith" == Keith Seitz <keiths@redhat.com> writes:

Keith> 2014-03-20  Keith Seitz  <keiths@redhat.com>

Keith> 	PR c++/16675
Keith> 	* c-exp.y (exp : SIZEOF '(' type ')'): Handle reference types.
Keith> 	* eval.c (evaluate_subexp_for_sizeof): Refactor and handle
Keith> 	reference types.

Keith> testsuite/ChangeLog
Keith> 2014-03-20  Keith Seitz  <keiths@redhat.com>

Keith> 	PR c++/16675
Keith> 	* gdb.cp/cpsizeof.exp: New file.
Keith> 	* gdb.cp/cpsizeof.cc: New file.

This is ok.  Thanks.

Tom
diff mbox

Patch

diff --git a/gdb/c-exp.y b/gdb/c-exp.y
index 11631ba..6cbc9f8 100644
--- a/gdb/c-exp.y
+++ b/gdb/c-exp.y
@@ -771,13 +771,22 @@  exp	:	SELECTOR '(' name ')'
 	;
 
 exp	:	SIZEOF '(' type ')'	%prec UNARY
-			{ write_exp_elt_opcode (OP_LONG);
+			{ struct type *type = $3;
+			  write_exp_elt_opcode (OP_LONG);
 			  write_exp_elt_type (lookup_signed_typename
 					      (parse_language, parse_gdbarch,
 					       "int"));
-			  CHECK_TYPEDEF ($3);
-			  write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
+			  CHECK_TYPEDEF (type);
+
+			    /* $5.3.3/2 of the C++ Standard (n3290 draft)
+			       says of sizeof:  "When applied to a reference
+			       or a reference type, the result is the size of
+			       the referenced type."  */
+			  if (TYPE_CODE (type) == TYPE_CODE_REF)
+			    type = check_typedef (TYPE_TARGET_TYPE (type));
+			  write_exp_elt_longcst ((LONGEST) TYPE_LENGTH (type));
 			  write_exp_elt_opcode (OP_LONG); }
+
 	;
 
 exp	:	REINTERPRET_CAST '<' type_exp '>' '(' exp ')' %prec UNARY
diff --git a/gdb/eval.c b/gdb/eval.c
index 36615e1..c1e47e0 100644
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -3025,31 +3025,39 @@  evaluate_subexp_for_sizeof (struct expression *exp, int *pos)
 	  && TYPE_CODE (type) != TYPE_CODE_REF
 	  && TYPE_CODE (type) != TYPE_CODE_ARRAY)
 	error (_("Attempt to take contents of a non-pointer value."));
-      type = check_typedef (TYPE_TARGET_TYPE (type));
-      return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
+      type = TYPE_TARGET_TYPE (type);
+      break;
 
     case UNOP_MEMVAL:
       (*pos) += 3;
-      type = check_typedef (exp->elts[pc + 1].type);
-      return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
+      type = exp->elts[pc + 1].type;
+      break;
 
     case UNOP_MEMVAL_TYPE:
       (*pos) += 1;
       val = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
-      type = check_typedef (value_type (val));
-      return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
+      type = value_type (val);
+      break;
 
     case OP_VAR_VALUE:
       (*pos) += 4;
-      type = check_typedef (SYMBOL_TYPE (exp->elts[pc + 2].symbol));
-      return
-	value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
+      type = SYMBOL_TYPE (exp->elts[pc + 2].symbol);
+      break;
 
     default:
       val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
-      return value_from_longest (size_type,
-				 (LONGEST) TYPE_LENGTH (value_type (val)));
+      type = value_type (val);
+      break;
     }
+
+  /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
+     "When applied to a reference or a reference type, the result is
+     the size of the referenced type."  */
+  CHECK_TYPEDEF (type);
+  if (exp->language_defn->la_language == language_cplus
+      && TYPE_CODE (type) == TYPE_CODE_REF)
+    type = check_typedef (TYPE_TARGET_TYPE (type));
+  return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
 }
 
 /* Parse a type expression in the string [P..P+LENGTH).  */
diff --git a/gdb/testsuite/gdb.cp/cpsizeof.cc b/gdb/testsuite/gdb.cp/cpsizeof.cc
new file mode 100644
index 0000000..0760cfc
--- /dev/null
+++ b/gdb/testsuite/gdb.cp/cpsizeof.cc
@@ -0,0 +1,71 @@ 
+/* This testcase is part of GDB, the GNU debugger.
+
+   Copyright 2014 Free Software Foundation, Inc.
+
+   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
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+struct Class
+{
+  int a;
+  char b;
+  long c;
+
+  Class () : a (1), b ('2'), c (3) { }
+};
+
+union Union
+{
+  Class *kp;
+  char a;
+  int b;
+  long c;
+};
+
+enum Enum { A, B, C, D };
+
+typedef unsigned char a4[4];
+typedef unsigned char a8[8];
+typedef unsigned char a12[12];
+typedef Class c4[4];
+typedef Union u8[8];
+typedef Enum e12[12];
+
+#define T(N)					\
+  N N ## obj;					\
+  N& N ## _ref = N ## obj;			\
+  N* N ## p = &(N ## obj);			\
+  N*& N ## p_ref = N ## p;			\
+  int size_ ## N = sizeof (N ## _ref);		\
+  int size_ ## N ## p = sizeof (N ## p_ref);	\
+
+int
+main (void)
+{
+  T (char);
+  T (int);
+  T (long);
+  T (float);
+  T (double);
+  T (a4);
+  T (a8);
+  T (a12);
+  T (Class);
+  T (Union);
+  T (Enum);
+  T (c4);
+  T (u8);
+  T (e12);
+
+  return 0; /* break here */
+}
diff --git a/gdb/testsuite/gdb.cp/cpsizeof.exp b/gdb/testsuite/gdb.cp/cpsizeof.exp
new file mode 100644
index 0000000..f55af9c
--- /dev/null
+++ b/gdb/testsuite/gdb.cp/cpsizeof.exp
@@ -0,0 +1,40 @@ 
+# sizeof() tests [c++/16675]
+# Copyright 2014 Free Software Foundation, Inc.
+
+# 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
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+standard_testfile .cc
+
+if {[skip_cplus_tests]} { continue }
+
+if {[prepare_for_testing ${testfile}.exp $testfile $srcfile {debug c++}] } {
+     return -1
+}
+
+if {![runto_main]} {
+    perror "could not run to main"
+    continue
+}
+
+gdb_breakpoint [gdb_get_line_number "break here"]
+gdb_continue_to_breakpoint "break here"
+
+# Compare sizeof from the compiler and gdb.  Do this once with the actual
+# type name and once with a reference variable.
+foreach v {char int long float double a4 a8 a12 Class Union Enum c4 u8 e12} {
+    gdb_test "print size_$v == sizeof (${v}&)" "= true"
+    gdb_test "print size_$v == sizeof (${v}_ref)" "= true"
+    gdb_test "print size_${v}p == sizeof (${v}*&)" "= true"
+    gdb_test "print size_${v}p == sizeof (${v}p_ref)" "= true"
+}