Use m_APInt in SimplifyCFG

[tjablin]

Summary

Switch from m_Constant to m_APInt per David's request. NFC.

[majnemer]

LGTM

[cycheng]

Committed r272977 (On behalf of Tom)

lib/Transforms/Utils/SimplifyCFG.cpp

bool matchInstruction(Instruction *I, bool isEQ) {
     ICmpInst *ICI;
     ConstantInt *C;
     if (!((ICI = dyn_cast<ICmpInst>(I)) &&
           (C = GetConstantInt(I->getOperand(1), DL)))) {
       return false;
     }
 
     Value *RHSVal;
-    ConstantInt *RHSC;
+    const APInt *RHSC;
 
     // Pattern match a special case
     // (x & ~2^z) == y --> x == y || x == y|2^z
     // This undoes a transformation done by instcombine to fuse 2 compares.
     if (ICI->getPredicate() == (isEQ ? ICmpInst::ICMP_EQ : ICmpInst::ICMP_NE)) {
 
       // It's a little bit hard to see why the following transformations are
       // correct. Here is a CVC3 program to verify them for 64-bit values:
if (ICI->getPredicate() == (isEQ ? ICmpInst::ICMP_EQ : ICmpInst::ICMP_NE)) {
 
       // Pattern match a special case:
       /*
         QUERY( (y & ~mask = y) =>
                ((x & ~mask = y) <=> (x = y OR x = (y |  mask)))
         );
       */
       if (match(ICI->getOperand(0),
-                m_And(m_Value(RHSVal), m_ConstantInt(RHSC)))) {
-        APInt Mask = ~RHSC->getValue();
+                m_And(m_Value(RHSVal), m_APInt(RHSC)))) {
+        APInt Mask = ~*RHSC;
         if (Mask.isPowerOf2() && (C->getValue() & ~Mask) == C->getValue()) {
           // If we already have a value for the switch, it has to match!
           if (!setValueOnce(RHSVal))
             return false;
 
           Vals.push_back(C);
           Vals.push_back(
               ConstantInt::get(C->getContext(),
bool matchInstruction(Instruction *I, bool isEQ) {
 
     // If we have "x ult 3", for example, then we can add 0,1,2 to the set.
     ConstantRange Span = ConstantRange::makeAllowedICmpRegion(
         ICI->getPredicate(), C->getValue());
 
     // Shift the range if the compare is fed by an add. This is the range
     // compare idiom as emitted by instcombine.
     Value *CandidateVal = I->getOperand(0);
-    if (match(I->getOperand(0), m_Add(m_Value(RHSVal), m_ConstantInt(RHSC)))) {
-      Span = Span.subtract(RHSC->getValue());
+    if (match(I->getOperand(0), m_Add(m_Value(RHSVal), m_APInt(RHSC)))) {
+      Span = Span.subtract(*RHSC);
       CandidateVal = RHSVal;
     }
 
     // If this is an and/!= check, then we are looking to build the set of
     // value that *don't* pass the and chain. I.e. to turn "x ugt 2" into
     // x != 0 && x != 1.
     if (!isEQ)
       Span = Span.inverse();