PNaCl: Disable parts of InstCombine that introduce *.with.overflow intrinsics

lib/Transforms/InstCombine/InstCombineCompares.cpp

 //===- InstCombineCompares.cpp --------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the visitICmp and visitFCmp functions.
@@ skipping 1924 matching lines @@
     // addition in wider type, and explicitly checks for overflow using
     // comparisons against INT_MIN and INT_MAX.  Simplify this by using the
     // sadd_with_overflow intrinsic.
     //
     // TODO: This could probably be generalized to handle other overflow-safe
     // operations if we worked out the formulas to compute the appropriate
     // magic constants.
     //
     // sum = a + b
     // if (sum+128 >u 255)  ...  -> llvm.sadd.with.overflow.i8
-    {
-    ConstantInt *CI2;    // I = icmp ugt (add (add A, B), CI2), CI
-    if (I.getPredicate() == ICmpInst::ICMP_UGT &&
-        match(Op0, m_Add(m_Add(m_Value(A), m_Value(B)), m_ConstantInt(CI2))))
-      if (Instruction *Res = ProcessUGT_ADDCST_ADD(I, A, B, CI2, CI, *this))
-        return Res;
+    // @LOCALMOD-BEGIN
+    // This is disabled for PNaCl, because we don't support the
+    // with.overflow intrinsics in PNaCl's stable ABI.
+    if (0) {
+      ConstantInt *CI2;    // I = icmp ugt (add (add A, B), CI2), CI
+      if (I.getPredicate() == ICmpInst::ICMP_UGT &&
+          match(Op0, m_Add(m_Add(m_Value(A), m_Value(B)), m_ConstantInt(CI2))))
+        if (Instruction *Res = ProcessUGT_ADDCST_ADD(I, A, B, CI2, CI, *this))
+          return Res;
     }
+    // @LOCALMOD-END
 
     // (icmp ne/eq (sub A B) 0) -> (icmp ne/eq A, B)
     if (I.isEquality() && CI->isZero() &&
         match(Op0, m_Sub(m_Value(A), m_Value(B)))) {
       // (icmp cond A B) if cond is equality
       return new ICmpInst(I.getPredicate(), A, B);
     }
 
     // If we have an icmp le or icmp ge instruction, turn it into the
     // appropriate icmp lt or icmp gt instruction.  This allows us to rely on
@@ skipping 585 matching lines @@
   { Value *A, *B;
     // ~x < ~y --> y < x
     // ~x < cst --> ~cst < x
     if (match(Op0, m_Not(m_Value(A)))) {
       if (match(Op1, m_Not(m_Value(B))))
         return new ICmpInst(I.getPredicate(), B, A);
       if (ConstantInt *RHSC = dyn_cast<ConstantInt>(Op1))
         return new ICmpInst(I.getPredicate(), ConstantExpr::getNot(RHSC), A);
     }
 
-    // (a+b) <u a  --> llvm.uadd.with.overflow.
-    // (a+b) <u b  --> llvm.uadd.with.overflow.
-    if (I.getPredicate() == ICmpInst::ICMP_ULT &&
-        match(Op0, m_Add(m_Value(A), m_Value(B))) &&
-        (Op1 == A || Op1 == B))
-      if (Instruction *R = ProcessUAddIdiom(I, Op0, *this))
-        return R;
+    // @LOCALMOD-BEGIN
+    // This is disabled for PNaCl, because we don't support the
+    // with.overflow intrinsics in PNaCl's stable ABI.
+    if (0) {
+      // (a+b) <u a  --> llvm.uadd.with.overflow.
+      // (a+b) <u b  --> llvm.uadd.with.overflow.
+      if (I.getPredicate() == ICmpInst::ICMP_ULT &&
+          match(Op0, m_Add(m_Value(A), m_Value(B))) &&
+          (Op1 == A || Op1 == B))
+        if (Instruction *R = ProcessUAddIdiom(I, Op0, *this))
+          return R;
 
-    // a >u (a+b)  --> llvm.uadd.with.overflow.
-    // b >u (a+b)  --> llvm.uadd.with.overflow.
-    if (I.getPredicate() == ICmpInst::ICMP_UGT &&
-        match(Op1, m_Add(m_Value(A), m_Value(B))) &&
-        (Op0 == A || Op0 == B))
-      if (Instruction *R = ProcessUAddIdiom(I, Op1, *this))
-        return R;
+      // a >u (a+b)  --> llvm.uadd.with.overflow.
+      // b >u (a+b)  --> llvm.uadd.with.overflow.
+      if (I.getPredicate() == ICmpInst::ICMP_UGT &&
+          match(Op1, m_Add(m_Value(A), m_Value(B))) &&
+          (Op0 == A || Op0 == B))
+        if (Instruction *R = ProcessUAddIdiom(I, Op1, *this))
+          return R;
+    }
+    // @LOCALMOD-END
   }
 
   if (I.isEquality()) {
     Value *A, *B, *C, *D;
 
     if (match(Op0, m_Xor(m_Value(A), m_Value(B)))) {
       if (A == Op1 || B == Op1) {    // (A^B) == A  ->  B == 0
         Value *OtherVal = A == Op1 ? B : A;
         return new ICmpInst(I.getPredicate(), OtherVal,
                             Constant::getNullValue(A->getType()));
@@ skipping 501 matching lines @@
 
   // fcmp (fpext x), (fpext y) -> fcmp x, y
   if (FPExtInst *LHSExt = dyn_cast<FPExtInst>(Op0))
     if (FPExtInst *RHSExt = dyn_cast<FPExtInst>(Op1))
       if (LHSExt->getSrcTy() == RHSExt->getSrcTy())
         return new FCmpInst(I.getPredicate(), LHSExt->getOperand(0),
                             RHSExt->getOperand(0));
 
   return Changed ? &I : 0;
 }