[SCCP] Mark constant xor %blah, %blah even if the lattice value is overdefined

[davide]

Summary

I think this is OK, but there might be cases where this break I'm currently missing.
In general, it should be able to avoid some spurious overdefined values, which is good.

[escha]

This would work with 'sub' too, right?

[davide]

In D22601#490428, @escha wrote:

This would work with 'sub' too, right?

Probably. I'll fix that if we agree this transform is actually valid.

[eli.friedman]

The transformation valid... but I don't think it makes sense to perform it here. SCCP doesn't add any power to the transformation over instsimplify.

[davide]

In D22601#491764, @eli.friedman wrote:

The transformation valid... but I don't think it makes sense to perform it here. SCCP doesn't add any power to the transformation over instsimplify.

I was worried about that. We already do some similar transformations in visitBinaryOp()

if (I.getOpcode() == Instruction::And) {
  // X and 0 = 0
  if (NonOverdefVal->getConstant()->isNullValue())
    return markConstant(IV, &I, NonOverdefVal->getConstant());
} else {
  if (ConstantInt *CI = NonOverdefVal->getConstantInt())
    if (CI->isAllOnesValue())     // X or -1 = -1
      return markConstant(IV, &I, NonOverdefVal->getConstant());
}

maybe we should get rid of these?

[eli.friedman]

There, SCCP actually does add power to the transformation; consider a construct like the following:

int f();
int g() { 
    int x = 0;
    for (int i = 0; i < 1000000; ++i) {
        x &= f();
    }
    return x;
}

SCCP can prove that this function returns zero.

[davide]

Oh, I see now. Thanks! Abandoning this then.

lib/Transforms/Scalar/SCCP.cpp

 
   // If something is undef, wait for it to resolve.
   if (!V1State.isOverdefined() && !V2State.isOverdefined())
     return;
 
   // Otherwise, one of our operands is overdefined.  Try to produce something
   // better than overdefined with some tricks.
 
+  // If this is a xor %blah, %blah, it doesn't matter if %blah is overdefined,
+  // we can just mark that constant.
+  if (I.getOpcode() == Instruction::Xor) {
+    if (I.getOperand(0) == I.getOperand(1)) {
+      markConstant(IV, &I, Constant::getNullValue(I.getType()));
+      return;
+    }
+  }
+
   // If this is an AND or OR with 0 or -1, it doesn't matter that the other
   // operand is overdefined.
   if (I.getOpcode() == Instruction::And || I.getOpcode() == Instruction::Or) {
     LatticeVal *NonOverdefVal = nullptr;
     if (!V1State.isOverdefined())
       NonOverdefVal = &V1State;
     else if (!V2State.isOverdefined())
       NonOverdefVal = &V2State;

test/Transforms/SCCP/xor.ll

+; RUN: opt -S -sccp %s | FileCheck %s
+
+define i32 @myxor(i32 %x) {
+  %patatino = xor i32 %x, %x
+  ret i32 %patatino
+}
+
+; CHECK: define i32 @myxor(i32 %x) {
+; CHECK-NEXT:   ret i32 0
+; CHECK-NEXT: }