reg_nonzero_bits_for_combine misunderstood

[Paulo Matos]

Hi,

I have found a code generation bug in our port. I have tracked it down to a 
place whose code hasn't changed in years so I guess I am misunderstanding 
something.

reg_nonzero_bits_for_combine has:
  rsp = &reg_stat[REGNO (x)];
  if (rsp->last_set_value != 0
      && (rsp->last_set_mode == mode
          || (GET_MODE_CLASS (rsp->last_set_mode) == MODE_INT
              && GET_MODE_CLASS (mode) == MODE_INT))
      && ((rsp->last_set_label >= label_tick_ebb_start
           && rsp->last_set_label < label_tick)
          || (rsp->last_set_label == label_tick
              && DF_INSN_LUID (rsp->last_set) < subst_low_luid)
          || (REGNO (x) >= FIRST_PSEUDO_REGISTER
              && REG_N_SETS (REGNO (x)) == 1
              && !REGNO_REG_SET_P
                  (DF_LR_IN (ENTRY_BLOCK_PTR->next_bb), REGNO (x)))))
    {
      *nonzero &= rsp->last_set_nonzero_bits;
      return NULL;
    }

The condition 
(rsp->last_set_mode == mode
          || (GET_MODE_CLASS (rsp->last_set_mode) == MODE_INT
              && GET_MODE_CLASS (mode) == MODE_INT))

is strange because if a register changes mode, we can't be sure if nonzero bits 
are the same anymore.

Here's the issue I found. Testcase is (can't reproduce on x86_64), but for 
illustration purposes:
#include <stdint.h>
#include <stdio.h>
int64_t c;
int8_t *d;
int32_t *e;
uint8_t div (uint8_t a, uint8_t b)
{
  return b == 0 ? 1 : a / b;
}

__attribute__((noinline)) void
foo (void)
{
  *e = (c = div (1, *d));
}

int
main(void)
{
  int32_t my_e;
  int8_t my_d = 1;
  e = &my_e;
  d = &my_d;
  foo ();
  if (c == 0xffffffff00000001)
    abort ();
  return 0;
}

This aborts on my port for -O2 and above.

The issue is that on my port we call for div udivmodsi (SI 32bits) which leaves 
the return register (64bit) as 0xffffffffxxxxxxxx, where 0xxxxxxxxx is the 
correct return value of udivmodsi. After udivmod we have (return register is 
r8):
r100:DI <- zero_extend:DI (subreg:QI (r8:SI, 0))

The subreg is because div returns 8bits (QImode), and zero extend is because we 
are extending to 64bits. GCC knows by inspection that nonzero_bits for r8 in 
SImode is 1, because the result of div can only be 0 or 1, but then GCC goes on 
to simplify the expression to:
r100:DI <- zero_extend:DI (r8:QI)

and after several attempts to do (r8:DI << 56) >> 56, or (r8:DI & 1), it 
decides that since nonzero_bits for r8:DI is 1 (which shouldn't be), and mask 
is 1 then r8:DI & 1 == r8:DI generating:
r100:DI <- r8:DI

The decision that then r8:DI & 1 == r8:DI comes from simplify_and_const_int_1:
  /* If we are only masking insignificant bits, return VAROP.  */
  if (constop == nonzero)
    return varop;

But the problem is that if the mode of the register is larger than the mode of 
the register when last set then we can't know anything about nonzero_bits. 

Patching my port with:
ndex 38f4f3f..2dee1e1 100755
--- a/gcc/combine.c
+++ b/gcc/combine.c
@@ -9500,7 +9500,8 @@ reg_nonzero_bits_for_combine (const_rtx x, enum 
machine_mode mode,
   if (rsp->last_set_value != 0
       && (rsp->last_set_mode == mode
          || (GET_MODE_CLASS (rsp->last_set_mode) == MODE_INT
-             && GET_MODE_CLASS (mode) == MODE_INT))
+             && GET_MODE_CLASS (mode) == MODE_INT
+             && GET_MODE_PRECISION (rsp->last_set_mode) >= GET_MODE_PRECISION 
(mode)))
       && ((rsp->last_set_label >= label_tick_ebb_start
           && rsp->last_set_label < label_tick)
          || (rsp->last_set_label == label_tick
@@ -9513,6 +9514,10 @@ reg_nonzero_bits_for_combine (const_rtx x, enum 
machine_mode mode,
       *nonzero &= rsp->last_set_nonzero_bits;
       return NULL;
     }
+  else if (GET_MODE_CLASS (rsp->last_set_mode) == MODE_INT
+          && GET_MODE_CLASS (mode) == MODE_INT
+          && GET_MODE_PRECISION (rsp->last_set_mode) < GET_MODE_PRECISION 
(mode))
+    return NULL;
 
   tem = get_last_value (x);

Fixed the problem. Any comments?
If you have no comments and like the patch I will submit it formally to 
gcc-patches.

Paulo Matos