[InstCombine] Teach SimplifyDemandedInstructionBits that even if we reach an instruction that has multiple uses, if we know all the bits for the demanded bits for this context we can go ahead and create a constant.

[craig.topper]

Summary

Currently if we reach an instruction with multiples uses we know we can't do any optimizations to that instruction itself since we only have the demanded bits for one of the users. But if we know all of the bits are zero/one for that one user we can still go ahead and create a constant to give to that user.

This might then reduce the instruction to having a single use and allow additional optimizations on the other path.

This picks up an additional transformation that the patch for D31120 didn't catch.

[craig.topper]

Add the test case update. The first 3 of them are the same as D31120

[spatel]

LGTM. It would be nice to lift everything in the:

if (Depth != 0 && !I->hasOneUse()) {

block into a helper function to make it easier to read as an NFC change ahead of this. SimplifyDemandedUseBits has grown to over 700 lines.

llvm/trunk/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp

if (I->getOpcode() == Instruction::And) {
     if ((DemandedMask & RHSKnownZero) == DemandedMask)
       return I->getOperand(0);
     if ((DemandedMask & LHSKnownZero) == DemandedMask)
       return I->getOperand(1);
   }
 
   // Compute the KnownZero/KnownOne bits to simplify things downstream.
   computeKnownBits(I, KnownZero, KnownOne, Depth, CxtI);
+
+  // If this user is only demanding bits that we know, return the known
+  // constant.
+  if ((DemandedMask & (KnownZero|KnownOne)) == DemandedMask)
+    return Constant::getIntegerValue(ITy, KnownOne);
+
   return nullptr;
 }
 
 
 /// Helper routine of SimplifyDemandedUseBits. It tries to simplify
 /// "E1 = (X lsr C1) << C2", where the C1 and C2 are constant, into
 /// "E2 = X << (C2 - C1)" or "E2 = X >> (C1 - C2)", depending on the sign
 /// of "C2-C1".

llvm/trunk/test/Transforms/InstCombine/and2.ll

;
   %w = mul i32 %z, %x ; to keep the shift from being removed
   ret i32 %w
 }
 
 ; The sub in this test cannot be removed because we need to keep the negation of %b. TODO: But we should be able to replace the LHS of it with a 0.
 define i32 @test14(i32 %a, i32 %b) {
 ; CHECK-LABEL: @test14(
 ; CHECK-NEXT:    [[X:%.*]] = shl i32 [[A:%.*]], 8
-; CHECK-NEXT:    [[Y:%.*]] = sub i32 [[X]], [[B:%.*]]
+; CHECK-NEXT:    [[Y:%.*]] = sub i32 0, [[B:%.*]]
 ; CHECK-NEXT:    [[Z:%.*]] = and i32 [[Y]], 128
 ; CHECK-NEXT:    [[W:%.*]] = mul i32 [[Z]], [[X]]
 ; CHECK-NEXT:    ret i32 [[W]]
 ;
   %x = shl i32 %a, 8
   %y = sub i32 %x, %b
   %z = and i32 %y, 128
   %w = mul i32 %z, %x ; to keep the shift from being removed
   ret i32 %w
 }