[Bug tree-optimization/16437] New c-torture failures after bitfield patch

["jsm at polyomino dot org dot uk" <gcc-bugzilla at gcc dot gnu dot org>]

------- Additional Comments From jsm at polyomino dot org dot uk  2004-07-09 22:58 -------
Subject: Re:  New: New c-torture failures after
 bitfield patch

I'll test the following patch tomorrow.  It appears to fix the included
testcase (from building cc1 and testing manually).  I don't know whether
it fixes the original testcases on x86_64 (but if it passes testing I'll
apply it anyway as a fix for the included testcase).

TREE_OVERFLOW and TREE_CONSTANT_OVERFLOW will join TREE_COMPLEXITY and
NON_LVALUE_EXPR on my little list.  I very much doubt we get them right
everywhere apart from the case fixed here, the integer_zerop handling is
nonintuitive though I explained it when it was queried, and what use there
is for them belongs in front-end datastructures.

2004-07-09  Joseph S. Myers  <jsm@polyomino.org.uk>

	PR tree-optimization/16437
	* c-common.c (shorten_compare): Don't mark result of conversion to
	narrower signed type as overflowing.
	* fold-const.c (decode_field_reference): Determine whether
	signedness comes from outer type using precision rather than size.

testsuite:
2004-07-09  Joseph S. Myers  <jsm@polyomino.org.uk>

	PR tree-optimization/16437
	* gcc.c-torture/execute/bitfld-4.c: New test.

diff -rupN GCC.orig/gcc/c-common.c GCC/gcc/c-common.c
--- GCC.orig/gcc/c-common.c	2004-07-08 08:35:40.000000000 +0000
+++ GCC/gcc/c-common.c	2004-07-09 21:17:58.000000000 +0000
@@ -1924,7 +1924,12 @@ shorten_compare (tree *op0_ptr, tree *op
 	*restype_ptr = c_common_signed_type (*restype_ptr);
 
       if (TREE_TYPE (primop1) != *restype_ptr)
-	primop1 = convert (*restype_ptr, primop1);
+	{
+	  tree tmp = convert (*restype_ptr, primop1);
+	  TREE_OVERFLOW (tmp) = TREE_OVERFLOW (primop1);
+	  TREE_CONSTANT_OVERFLOW (tmp) = TREE_CONSTANT_OVERFLOW (primop1);
+	  primop1 = tmp;
+	}
       if (type != *restype_ptr)
 	{
 	  minval = convert (*restype_ptr, minval);
diff -rupN GCC.orig/gcc/fold-const.c GCC/gcc/fold-const.c
--- GCC.orig/gcc/fold-const.c	2004-07-09 16:49:23.000000000 +0000
+++ GCC/gcc/fold-const.c	2004-07-09 22:21:37.000000000 +0000
@@ -3296,7 +3296,7 @@ decode_field_reference (tree exp, HOST_W
   /* If the number of bits in the reference is the same as the bitsize of
      the outer type, then the outer type gives the signedness. Otherwise
      (in case of a small bitfield) the signedness is unchanged.  */
-  if (outer_type && *pbitsize == tree_low_cst (TYPE_SIZE (outer_type), 1))
+  if (outer_type && *pbitsize == TYPE_PRECISION (outer_type))
     *punsignedp = TYPE_UNSIGNED (outer_type);
 
   /* Compute the mask to access the bitfield.  */
diff -rupN GCC.orig/gcc/testsuite/gcc.c-torture/execute/bitfld-4.c GCC/gcc/testsuite/gcc.c-torture/execute/bitfld-4.c
--- GCC.orig/gcc/testsuite/gcc.c-torture/execute/bitfld-4.c	1970-01-01 00:00:00.000000000 +0000
+++ GCC/gcc/testsuite/gcc.c-torture/execute/bitfld-4.c	2004-07-09 21:14:37.000000000 +0000
@@ -0,0 +1,21 @@
+/* When comparisons of bit-fields to unsigned constants got shortened,
+   the shortened signed constant was wrongly marked as overflowing,
+   leading to a later integer_zerop failure and misoptimization.
+
+   Related to bug tree-optimization/16437 but shows the problem on
+   32-bit systems.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+
+extern void abort (void);
+
+struct s { int a:12, b:20; };
+
+struct s x = { -123, -456 };
+
+int
+main (void)
+{
+  if (x.a != -123U || x.b != -456U)
+    abort ();
+  return 0;
+}




-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=16437