[InstSimplify] Hoist some basic simplifications from `simplifyAndInst` to helper; NFC

[RKSimon]

LGTM

[nikic]

I don't think it's a good idea to share these, because not all of these are valid for ptrmask.

[goldstein.w.n]

This has been ported to github PR.

llvm/lib/Analysis/InstructionSimplify.cpp

if (ConstantExpr::getNot(C1) == C2) {
       Type *Ty = Op0->getType();
       return Opcode == Instruction::And ? ConstantInt::getNullValue(Ty)
                                         : ConstantInt::getAllOnesValue(Ty);
     }
   }
   return nullptr;
 }
 
+static Value *
+trySimplifyingAndLikeUsingOp(Value *Op, const SimplifyQuery &Q, Type *ResTy) {
+  // X & poison -> poison
+  if (isa<PoisonValue>(Op))
+    return PoisonValue::get(ResTy);
+
+  // X & undef -> 0
+  if (Q.isUndefValue(Op))
+    return Constant::getNullValue(ResTy);
+
+  // X & 0 = 0
+  if (match(Op, m_Zero()))
+    return Constant::getNullValue(ResTy);
+
+  return nullptr;
+}
+
 /// Given operands for an And, see if we can fold the result.
 /// If not, this returns null.
 static Value *simplifyAndInst(Value *Op0, Value *Op1, const SimplifyQuery &Q,
                               unsigned MaxRecurse) {
   if (Constant *C = foldOrCommuteConstant(Instruction::And, Op0, Op1, Q))
     return C;
 
-  // X & poison -> poison
-  if (isa<PoisonValue>(Op1))
-    return Op1;
-
-  // X & undef -> 0
-  if (Q.isUndefValue(Op1))
-    return Constant::getNullValue(Op0->getType());
+  if (auto R = trySimplifyingAndLikeUsingOp(Op1, Q, Op0->getType()))
+    return R;
 
   // X & X = X
   if (Op0 == Op1)
     return Op0;
 
-  // X & 0 = 0
-  if (match(Op1, m_Zero()))
-    return Constant::getNullValue(Op0->getType());
-
   // X & -1 = X
   if (match(Op1, m_AllOnes()))
     return Op0;
 
   // A & ~A  =  ~A & A  =  0
   if (match(Op0, m_Not(m_Specific(Op1))) || match(Op1, m_Not(m_Specific(Op0))))
     return Constant::getNullValue(Op0->getType());