Re: c/3651: shifting unsigned long on 64 bit machine incorrectly does sign extension

[Richard Henderson <rth@redhat.com>]

The following reply was made to PR c/3651; it has been noted by GNATS.

From: Richard Henderson <rth@redhat.com>
To: mark.dewing@intel.com
Cc: gcc-gnats@gcc.gnu.org, gcc-patches@gcc.gnu.org
Subject: Re: c/3651: shifting unsigned long on 64 bit machine incorrectly does sign extension
Date: Tue, 17 Jul 2001 02:01:55 -0700

 On Wed, Jul 11, 2001 at 07:09:17PM -0000, mark.dewing@intel.com wrote:
 > Right shifting an unsigned long should not do a sign
 > extension.  This shift on an unsigned long variable works
 > okay, but doing this shift on an expression that has
 > been cast to unsigned long does not.
 > This problem also occurs on Alpha Tru64 with gcc 2.7.2.1
 > and IRIX with gcc 2.8.1 in 64 bit mode.
 
 I'm currently testing the following patch on alphaev6-linux.
 Assuming no regressions, I'll check it in tomorrow.
 
 
 r~
 
 
 	* c-typeck.c (build_binary_op): Do not shorten unsigned
 	right shift after sign extension.
 
 Index: c-typeck.c
 ===================================================================
 RCS file: /cvs/gcc/gcc/gcc/c-typeck.c,v
 retrieving revision 1.128
 diff -c -p -d -r1.128 c-typeck.c
 *** c-typeck.c	2001/07/07 01:07:17	1.128
 --- c-typeck.c	2001/07/17 08:56:46
 *************** build_binary_op (code, orig_op0, orig_op
 *** 2469,2490 ****
   	      /* We can shorten only if the shift count is less than the
   		 number of bits in the smaller type size.  */
   	      && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
 ! 	      /* If arg is sign-extended and then unsigned-shifted,
 ! 		 we can simulate this with a signed shift in arg's type
 ! 		 only if the extended result is at least twice as wide
 ! 		 as the arg.  Otherwise, the shift could use up all the
 ! 		 ones made by sign-extension and bring in zeros.
 ! 		 We can't optimize that case at all, but in most machines
 ! 		 it never happens because available widths are 2**N.  */
 ! 	      && (!TREE_UNSIGNED (final_type)
 ! 		  || unsigned_arg
 ! 		  || (2 * TYPE_PRECISION (TREE_TYPE (arg0))
 ! 		      <= TYPE_PRECISION (result_type))))
   	    {
   	      /* Do an unsigned shift if the operand was zero-extended.  */
   	      result_type
 ! 		= signed_or_unsigned_type (unsigned_arg,
 ! 					   TREE_TYPE (arg0));
   	      /* Convert value-to-be-shifted to that type.  */
   	      if (TREE_TYPE (op0) != result_type)
   		op0 = convert (result_type, op0);
 --- 2469,2480 ----
   	      /* We can shorten only if the shift count is less than the
   		 number of bits in the smaller type size.  */
   	      && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
 ! 	      /* We cannot drop an unsigned shift after sign-extension.  */
 ! 	      && (!TREE_UNSIGNED (final_type) || unsigned_arg))
   	    {
   	      /* Do an unsigned shift if the operand was zero-extended.  */
   	      result_type
 ! 		= signed_or_unsigned_type (unsigned_arg, TREE_TYPE (arg0));
   	      /* Convert value-to-be-shifted to that type.  */
   	      if (TREE_TYPE (op0) != result_type)
   		op0 = convert (result_type, op0);
 Index: testsuite/gcc.c-torture/execute/20010717-1.c
 ===================================================================
 RCS file: 20010717-1.c
 diff -N 20010717-1.c
 *** /dev/null	Tue May  5 13:32:27 1998
 --- 20010717-1.c	Tue Jul 17 01:56:46 2001
 ***************
 *** 0 ****
 --- 1,28 ----
 + static void test (unsigned long, unsigned long);
 + extern void abort (void);
 + 
 + int
 + main ()
 + {
 +   int i, j;
 +   unsigned long u, r1, r2;
 + 
 +   i = -16;
 +   j = 1;
 +   u = i + j;
 + 
 +   /* no sign extension upon shift */
 +   r1 = u >> 1;
 +   /* sign extension upon shift, but there shouldn't be */
 +   r2 = ((unsigned long) (i + j)) >> 1;
 +   test (r1, r2);
 + 
 +   return 0;
 + }
 + 
 + static void
 + test (unsigned long x, unsigned long y)
 + {
 +   if (x != y)
 +     abort ();
 + }