Fix i128 saturating ops

Turns out these are not in llvm 7.1 so we need to implement them directly.
This is done without branches to try to get fast codegen.

Author: LegNeato

crates/rustc_codegen_nvvm/src/intrinsic.rs

@@ -89,6 +89,8 @@ fn saturating_intrinsic_impl<'ll, 'tcx>(
     is_add: bool,
     args: &[OperandRef<'tcx, &'ll Value>],
 ) -> &'ll Value {
+    use crate::intrinsic::OverflowOp;
+    use rustc_codegen_ssa::common::IntPredicate;
     use rustc_middle::ty::IntTy::*;
     use rustc_middle::ty::UintTy::*;
 
@@ -107,65 +109,88 @@ fn saturating_intrinsic_impl<'ll, 'tcx>(
         _ => unreachable!(),
     };
 
-    // For 128-bit, we need to handle the constants differently
-    if width == 128 {
-        // For 128-bit saturating operations, use LLVM's saturating intrinsics directly
-        let lhs = args[0].immediate();
-        let rhs = args[1].immediate();
-        let llvm_name = format!(
-            "llvm.{}{}.sat.i128",
-            if signed { 's' } else { 'u' },
-            if is_add { "add" } else { "sub" }
-        );
-        return b.call_intrinsic(&llvm_name, &[lhs, rhs]);
+    let llty = b.type_ix(width as u64);
+    let a = args[0].immediate();
+    let c = args[1].immediate();
+
+    // Perform the operation and capture overflow flag
+    let (val, ov_i1) = b.checked_binop(
+        if is_add {
+            OverflowOp::Add
+        } else {
+            OverflowOp::Sub
+        },
+        ty,
+        a,
+        c,
+    );
+
+    // Common constants
+    let zero = b.const_int(llty, 0);
+    let one = b.const_int(llty, 1);
+    let all1 = b.const_int(llty, -1);
+    let sh = b.const_int(llty, (width - 1) as i64);
+
+    // Convert overflow flag to mask: -1 if overflow, else 0
+    let ov_m = b.select(ov_i1, all1, zero);
+
+    if !signed {
+        // MAX for add, 0 for sub
+        let clamp = if is_add { all1 } else { zero };
+
+        // Mask for non-overflow path
+        let keep = b.not(ov_m);
+
+        // Overflow → clamp
+        let l = b.and(ov_m, clamp);
+
+        // No overflow → result
+        let r = b.and(keep, val);
+
+        return b.or(l, r);
     }
 
-    let unsigned_max_value = match width {
-        8 => u8::MAX as i64,
-        16 => u16::MAX as i64,
-        32 => u32::MAX as i64,
-        64 => u64::MAX as i64,
-        _ => unreachable!(),
-    };
+    // Compute INT_MIN = 1 << (w-1)
+    let int_min = b.shl(one, sh);
 
-    let (min_value, max_value) = if signed {
-        (-((unsigned_max_value / 2) + 1), (unsigned_max_value / 2))
-    } else {
-        (0, unsigned_max_value)
-    };
+    // Compute INT_MAX = INT_MIN - 1
+    let int_max = b.sub(int_min, one);
+
+    // Mask for a < 0
+    let a_lt0 = b.icmp(IntPredicate::IntSLT, a, zero);
+    let a_neg = b.select(a_lt0, all1, zero);
 
-    let overflow_op = if is_add {
-        OverflowOp::Add
+    // Mask for a >= 0
+    let a_non = b.not(a_neg);
+
+    // Mask for c < 0
+    let c_lt0 = b.icmp(IntPredicate::IntSLT, c, zero);
+    let c_neg = b.select(c_lt0, all1, zero);
+
+    // Signed add overflow: a<0 → MIN, a>=0 → MAX
+    let sat = if is_add {
+        let p1 = b.and(a_neg, int_min);
+        let p2 = b.and(a_non, int_max);
+        b.or(p1, p2)
     } else {
-        OverflowOp::Sub
+        // Signed sub overflow: (a>=0 && c<0) → MAX, else MIN
+        let to_max = b.and(a_non, c_neg);
+        let to_min = b.not(to_max);
+        let p1 = b.and(to_max, int_max);
+        let p2 = b.and(to_min, int_min);
+        b.or(p1, p2)
     };
-    let llty = b.type_ix(width as u64);
-    let lhs = args[0].immediate();
-    let rhs = args[1].immediate();
 
-    let (val, overflowed) = b.checked_binop(overflow_op, ty, lhs, rhs);
+    // Mask for non-overflow path
+    let keep = b.not(ov_m);
 
-    if !signed {
-        let select_val = if is_add {
-            b.const_int(llty, -1)
-        } else {
-            b.const_int(llty, 0)
-        };
-        b.select(overflowed, select_val, val)
-    } else {
-        let const_val = b.const_int(llty, (width - 1) as i64);
-        let first_val = if is_add {
-            b.ashr(rhs, const_val)
-        } else {
-            b.lshr(rhs, const_val)
-        };
-        let second_val = if is_add {
-            b.unchecked_uadd(first_val, b.const_int(llty, max_value))
-        } else {
-            b.xor(first_val, b.const_int(llty, min_value))
-        };
-        b.select(overflowed, second_val, val)
-    }
+    // Overflow → sat value
+    let l = b.and(ov_m, sat);
+
+    // No overflow → result
+    let r = b.and(keep, val);
+
+    b.or(l, r)
 }
 
 fn get_simple_intrinsic<'ll>(