gen-dev: complete Num{Mul,Add,Sub}Saturated impls

MulSaturated and AddSaturated are now implemented for u128, i128
SubSaturated is now implemented for Dec even if it's a little strange to
saturate at a decimal value:

```
» Num.subSaturated -170_141_183_460_469_231_731dec 1

-170141183460469231731.687303715884105728 : Dec
```

I decided to rm the `build_num_{mul,add}_saturated` methods because
they don't require any asm-specifics. They either call out to bitcode, or
use the non-saturated version for floats.

crates/compiler/gen_dev/src/generic64/mod.rs

@@ -1432,28 +1432,20 @@ impl<
         src2: Symbol,
         layout: InLayout<'a>,
     ) {
-        match self.layout_interner.get_repr(layout) {
+        match self.interner().get_repr(layout) {
-            LayoutRepr::Builtin(Builtin::Int(width @ quadword_and_smaller!())) => {
+            LayoutRepr::Builtin(Builtin::Int(int_width)) => {
-                let intrinsic = bitcode::NUM_ADD_SATURATED_INT[width].to_string();
+                let intrinsic = bitcode::NUM_ADD_SATURATED_INT[int_width].to_string();
                 self.build_fn_call(&dst, intrinsic, &[src1, src2], &[layout, layout], &layout);
             }
-            LayoutRepr::Builtin(Builtin::Float(FloatWidth::F64)) => {
+            LayoutRepr::Builtin(Builtin::Float(_)) => {
-                let dst_reg = self.storage_manager.claim_float_reg(&mut self.buf, &dst);
+                // saturated add is just normal add
-                let src1_reg = self.storage_manager.load_to_float_reg(&mut self.buf, &src1);
+                self.build_num_add(&dst, &src1, &src2, &layout)
-                let src2_reg = self.storage_manager.load_to_float_reg(&mut self.buf, &src2);
-                ASM::add_freg64_freg64_freg64(&mut self.buf, dst_reg, src1_reg, src2_reg);
-            }
-            LayoutRepr::Builtin(Builtin::Float(FloatWidth::F32)) => {
-                let dst_reg = self.storage_manager.claim_float_reg(&mut self.buf, &dst);
-                let src1_reg = self.storage_manager.load_to_float_reg(&mut self.buf, &src1);
-                let src2_reg = self.storage_manager.load_to_float_reg(&mut self.buf, &src2);
-                ASM::add_freg32_freg32_freg32(&mut self.buf, dst_reg, src1_reg, src2_reg);
             }
             LayoutRepr::Builtin(Builtin::Decimal) => {
                 let intrinsic = bitcode::DEC_ADD_SATURATED.to_string();
                 self.build_fn_call(&dst, intrinsic, &[src1, src2], &[layout, layout], &layout);
             }
-            x => todo!("NumAddSaturated: layout, {:?}", x),
+            other => internal_error!("NumAddSaturated is not defined for {other:?}"),
         }
     }
 
@@ -1481,6 +1473,30 @@ impl<
         )
     }
 
+    fn build_num_sub_saturated(
+        &mut self,
+        dst: Symbol,
+        src1: Symbol,
+        src2: Symbol,
+        layout: InLayout<'a>,
+    ) {
+        match self.interner().get_repr(layout) {
+            LayoutRepr::Builtin(Builtin::Int(int_width)) => {
+                let intrinsic = bitcode::NUM_SUB_SATURATED_INT[int_width].to_string();
+                self.build_fn_call(&dst, intrinsic, &[src1, src2], &[layout, layout], &layout);
+            }
+            LayoutRepr::Builtin(Builtin::Float(_)) => {
+                // saturated sub is just normal sub
+                self.build_num_sub(&dst, &src1, &src2, &layout)
+            }
+            LayoutRepr::Builtin(Builtin::Decimal) => {
+                let intrinsic = bitcode::DEC_SUB_SATURATED.to_string();
+                self.build_fn_call(&dst, intrinsic, &[src1, src2], &[layout, layout], &layout);
+            }
+            other => internal_error!("NumSubSaturated is not defined for {other:?}"),
+        }
+    }
+
     fn build_num_sub_checked(
         &mut self,
         dst: &Symbol,
@@ -1619,28 +1635,20 @@ impl<
         src2: Symbol,
         layout: InLayout<'a>,
     ) {
-        match self.layout_interner.get_repr(layout) {
+        match self.interner().get_repr(layout) {
-            LayoutRepr::Builtin(Builtin::Int(width @ quadword_and_smaller!())) => {
+            LayoutRepr::Builtin(Builtin::Int(int_width)) => {
-                let intrinsic = bitcode::NUM_MUL_SATURATED_INT[width].to_string();
+                let intrinsic = bitcode::NUM_MUL_SATURATED_INT[int_width].to_string();
                 self.build_fn_call(&dst, intrinsic, &[src1, src2], &[layout, layout], &layout);
             }
-            LayoutRepr::Builtin(Builtin::Float(FloatWidth::F64)) => {
+            LayoutRepr::Builtin(Builtin::Float(_)) => {
-                let dst_reg = self.storage_manager.claim_float_reg(&mut self.buf, &dst);
+                // saturated mul is just normal mul
-                let src1_reg = self.storage_manager.load_to_float_reg(&mut self.buf, &src1);
+                self.build_num_mul(&dst, &src1, &src2, &layout)
-                let src2_reg = self.storage_manager.load_to_float_reg(&mut self.buf, &src2);
-                ASM::mul_freg64_freg64_freg64(&mut self.buf, dst_reg, src1_reg, src2_reg);
-            }
-            LayoutRepr::Builtin(Builtin::Float(FloatWidth::F32)) => {
-                let dst_reg = self.storage_manager.claim_float_reg(&mut self.buf, &dst);
-                let src1_reg = self.storage_manager.load_to_float_reg(&mut self.buf, &src1);
-                let src2_reg = self.storage_manager.load_to_float_reg(&mut self.buf, &src2);
-                ASM::mul_freg32_freg32_freg32(&mut self.buf, dst_reg, src1_reg, src2_reg);
             }
             LayoutRepr::Builtin(Builtin::Decimal) => {
                 let intrinsic = bitcode::DEC_MUL_SATURATED.to_string();
                 self.build_fn_call(&dst, intrinsic, &[src1, src2], &[layout, layout], &layout);
             }
-            x => todo!("NumMulSaturated: layout, {:?}", x),
+            other => internal_error!("NumMulSaturated is not defined for {other:?}"),
         }
     }
 

crates/compiler/gen_dev/src/lib.rs

@@ -1005,7 +1005,7 @@ trait Backend<'a> {
         }
     }
 
-    /// build_run_low_level builds the low level opertation and outputs to the specified symbol.
+    /// build_run_low_level builds the low level operation and outputs to the specified symbol.
     /// The builder must keep track of the symbol because it may be referred to later.
     fn build_run_low_level(
         &mut self,
@@ -1068,9 +1068,6 @@ trait Backend<'a> {
             LowLevel::NumAddChecked => {
                 self.build_num_add_checked(sym, &args[0], &args[1], &arg_layouts[0], ret_layout)
             }
-            LowLevel::NumSubChecked => {
-                self.build_num_sub_checked(sym, &args[0], &args[1], &arg_layouts[0], ret_layout)
-            }
             LowLevel::NumAcos => self.build_fn_call(
                 sym,
                 bitcode::NUM_ACOS[FloatWidth::F64].to_string(),
@@ -1239,27 +1236,12 @@ trait Backend<'a> {
                 );
                 self.build_num_sub_wrap(sym, &args[0], &args[1], ret_layout)
             }
-            LowLevel::NumSubSaturated => match self.interner().get_repr(*ret_layout) {
+            LowLevel::NumSubSaturated => {
-                LayoutRepr::Builtin(Builtin::Int(int_width)) => self.build_fn_call(
+                self.build_num_sub_saturated(*sym, args[0], args[1], *ret_layout)
-                    sym,
-                    bitcode::NUM_SUB_SATURATED_INT[int_width].to_string(),
-                    args,
-                    arg_layouts,
-                    ret_layout,
-                ),
-                LayoutRepr::Builtin(Builtin::Float(FloatWidth::F32)) => {
-                    self.build_num_sub(sym, &args[0], &args[1], ret_layout)
             }
-                LayoutRepr::Builtin(Builtin::Float(FloatWidth::F64)) => {
+            LowLevel::NumSubChecked => {
-                    // saturated sub is just normal sub
+                self.build_num_sub_checked(sym, &args[0], &args[1], &arg_layouts[0], ret_layout)
-                    self.build_num_sub(sym, &args[0], &args[1], ret_layout)
             }
-                LayoutRepr::Builtin(Builtin::Decimal) => {
-                    // self.load_args_and_call_zig(backend, bitcode::DEC_SUB_SATURATED)
-                    todo!()
-                }
-                _ => internal_error!("invalid return type"),
-            },
             LowLevel::NumBitwiseAnd => {
                 if let LayoutRepr::Builtin(Builtin::Int(int_width)) =
                     self.interner().get_repr(*ret_layout)
@@ -2392,16 +2374,6 @@ trait Backend<'a> {
         layout: &InLayout<'a>,
     );
 
-    /// build_num_sub_checked stores the sum of src1 and src2 into dst.
-    fn build_num_sub_checked(
-        &mut self,
-        dst: &Symbol,
-        src1: &Symbol,
-        src2: &Symbol,
-        num_layout: &InLayout<'a>,
-        return_layout: &InLayout<'a>,
-    );
-
     /// build_num_mul stores `src1 * src2` into dst.
     fn build_num_mul(&mut self, dst: &Symbol, src1: &Symbol, src2: &Symbol, layout: &InLayout<'a>);
 
@@ -2460,6 +2432,25 @@ trait Backend<'a> {
         layout: &InLayout<'a>,
     );
 
+    /// build_num_sub_saturated stores the `src1 - src2` difference into dst.
+    fn build_num_sub_saturated(
+        &mut self,
+        dst: Symbol,
+        src1: Symbol,
+        src2: Symbol,
+        layout: InLayout<'a>,
+    );
+
+    /// build_num_sub_checked stores the difference of src1 and src2 into dst.
+    fn build_num_sub_checked(
+        &mut self,
+        dst: &Symbol,
+        src1: &Symbol,
+        src2: &Symbol,
+        num_layout: &InLayout<'a>,
+        return_layout: &InLayout<'a>,
+    );
+
     /// stores the `src1 & src2` into dst.
     fn build_int_bitwise_and(
         &mut self,

crates/compiler/gen_llvm/src/llvm/lowlevel.rs

@@ -1758,7 +1758,7 @@ fn build_float_binop<'ctx>(
     };
 
     match op {
-        NumAdd => bd.new_build_float_add(lhs, rhs, "add_float").into(),
+        NumAdd | NumAddSaturated => bd.new_build_float_add(lhs, rhs, "add_float").into(),
         NumAddChecked => {
             let context = env.context;
 
@@ -1785,7 +1785,7 @@ fn build_float_binop<'ctx>(
             struct_value.into()
         }
         NumAddWrap => unreachable!("wrapping addition is not defined on floats"),
-        NumSub => bd.new_build_float_sub(lhs, rhs, "sub_float").into(),
+        NumSub | NumSubSaturated => bd.new_build_float_sub(lhs, rhs, "sub_float").into(),
         NumSubChecked => {
             let context = env.context;
 
@@ -1812,8 +1812,7 @@ fn build_float_binop<'ctx>(
             struct_value.into()
         }
         NumSubWrap => unreachable!("wrapping subtraction is not defined on floats"),
-        NumMul => bd.new_build_float_mul(lhs, rhs, "mul_float").into(),
+        NumMul | NumMulSaturated => bd.new_build_float_mul(lhs, rhs, "mul_float").into(),
-        NumMulSaturated => bd.new_build_float_mul(lhs, rhs, "mul_float").into(),
         NumMulChecked => {
             let context = env.context;
 
@@ -1855,7 +1854,7 @@ fn build_float_binop<'ctx>(
             &bitcode::NUM_POW[float_width],
         ),
         _ => {
-            unreachable!("Unrecognized int binary operation: {:?}", op);
+            unreachable!("Unrecognized float binary operation: {:?}", op);
         }
     }
 }
@@ -2286,6 +2285,9 @@ fn build_dec_binop<'a, 'ctx>(
             rhs,
             "Decimal multiplication overflowed",
         ),
+        NumAddSaturated => dec_binary_op(env, bitcode::DEC_ADD_SATURATED, lhs, rhs),
+        NumSubSaturated => dec_binary_op(env, bitcode::DEC_SUB_SATURATED, lhs, rhs),
+        NumMulSaturated => dec_binary_op(env, bitcode::DEC_MUL_SATURATED, lhs, rhs),
         NumDivFrac => dec_binop_with_unchecked(env, bitcode::DEC_DIV, lhs, rhs),
 
         NumLt => call_bitcode_fn(env, &[lhs, rhs], &bitcode::NUM_LESS_THAN[IntWidth::I128]),

crates/compiler/test_gen/src/gen_num.rs

@@ -3000,161 +3000,199 @@ fn u8_mul_greater_than_i8() {
 #[test]
 #[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
 fn add_saturated() {
+    assert_evals_to!("Num.addSaturated 200u8 200u8", 255u8, u8);
+    assert_evals_to!("Num.addSaturated 100i8 100i8", 127i8, i8);
+    assert_evals_to!("Num.addSaturated -100i8 -100i8", -128i8, i8);
+    assert_evals_to!("Num.addSaturated 40000u16 40000u16", 65535u16, u16);
+    assert_evals_to!("Num.addSaturated 20000i16 20000i16", 32767i16, i16);
+    assert_evals_to!("Num.addSaturated -20000i16 -20000i16", -32768i16, i16);
     assert_evals_to!(
-        indoc!(
+        "Num.addSaturated 3000000000u32 3000000000u32",
-            r"
+        4294967295u32,
-            x : U8
+        u32
-            x = 200
+    );
-            y : U8
+    assert_evals_to!(
-            y = 200
+        "Num.addSaturated 2000000000i32 2000000000i32",
-            Num.addSaturated x y
+        2147483647i32,
-            "
+        i32
-        ),
+    );
-        255,
+    assert_evals_to!(
-        u8
+        "Num.addSaturated -2000000000i32 -2000000000i32",
+        -2147483648i32,
+        i32
+    );
+    assert_evals_to!(
+        "Num.addSaturated 10000000000000000000u64 10000000000000000000u64",
+        18446744073709551615u64,
+        u64
+    );
+    assert_evals_to!(
+        "Num.addSaturated 5000000000000000000i64 5000000000000000000i64 ",
+        9223372036854775807i64,
+        i64
+    );
+    assert_evals_to!(
+        "Num.addSaturated -5000000000000000000i64 -5000000000000000000i64 ",
+        -9223372036854775808i64,
+        i64
+    );
+    assert_evals_to!(
+        "Num.addSaturated -5000000000000000000i64 -5000000000000000000i64 ",
+        -9223372036854775808i64,
+        i64
+    );
+    assert_evals_to!(
+        "Num.addSaturated Num.maxF32 Num.maxF32",
+        std::f32::INFINITY,
+        f32
+    );
+    assert_evals_to!(
+        "Num.addSaturated Num.minF32 Num.minF32",
+        std::f32::NEG_INFINITY,
+        f32
+    );
+    assert_evals_to!(
+        "Num.addSaturated Num.maxF64 Num.maxF64",
+        std::f64::INFINITY,
+        f64
+    );
+    assert_evals_to!(
+        "Num.addSaturated Num.minF64 Num.minF64",
+        std::f64::NEG_INFINITY,
+        f64
     );
 
     assert_evals_to!(
-        indoc!(
+        "Num.addSaturated 170_141_183_460_469_231_731dec 1",
-            r"
+        RocDec::from_str("170141183460469231731.687303715884105727").unwrap(),
-            x : I8
+        RocDec
-            x = 100
-            y : I8
-            y = 100
-            Num.addSaturated x y
-            "
-        ),
-        127,
-        i8
     );
-
     assert_evals_to!(
-        indoc!(
+        "Num.addSaturated -170_141_183_460_469_231_731dec -1",
-            r"
+        RocDec::from_str("-170141183460469231731.687303715884105728").unwrap(),
-            x : I8
+        RocDec
-            x = -100
-            y : I8
-            y = -100
-            Num.addSaturated x y
-            "
-        ),
-        -128,
-        i8
     );
 }
 
 #[test]
 #[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
 fn sub_saturated() {
+    assert_evals_to!("Num.subSaturated 1u8 10u8", 0u8, u8);
+    assert_evals_to!("Num.subSaturated 100i8 -100i8", 127i8, i8);
+    assert_evals_to!("Num.subSaturated -100i8 100i8", -128i8, i8);
+    assert_evals_to!("Num.subSaturated 1u16 10u16", 0u16, u16);
+    assert_evals_to!("Num.subSaturated 20000i16 -20000i16", 32767i16, i16);
+    assert_evals_to!("Num.subSaturated -20000i16 20000i16", -32768i16, i16);
+    assert_evals_to!("Num.subSaturated 1u32 10u32", 0u32, u32);
     assert_evals_to!(
-        indoc!(
+        "Num.subSaturated 2000000000i32 -2000000000i32",
-            r"
+        2147483647i32,
-            x : U8
+        i32
-            x = 10
-            y : U8
-            y = 20
-            Num.subSaturated x y
-            "
-        ),
-        0,
-        u8
     );
     assert_evals_to!(
-        indoc!(
+        "Num.subSaturated -2000000000i32 2000000000i32",
-            r"
+        -2147483648i32,
-            x : I8
+        i32
-            x = -100
+    );
-            y : I8
+    assert_evals_to!("Num.subSaturated 1u64 10u64", 0u64, u64);
-            y = 100
+    assert_evals_to!(
-            Num.subSaturated x y
+        "Num.subSaturated 5000000000000000000i64 -5000000000000000000i64 ",
-            "
+        9223372036854775807i64,
-        ),
+        i64
-        -128,
-        i8
     );
     assert_evals_to!(
-        indoc!(
+        "Num.subSaturated -5000000000000000000i64 5000000000000000000i64 ",
-            r"
+        -9223372036854775808i64,
-            x : I8
+        i64
-            x = 100
+    );
-            y : I8
+    assert_evals_to!(
-            y = -100
+        "Num.subSaturated -5000000000000000000i64 5000000000000000000i64 ",
-            Num.subSaturated x y
+        -9223372036854775808i64,
-            "
+        i64
-        ),
+    );
-        127,
+    assert_evals_to!(
-        i8
+        "Num.subSaturated Num.maxF32 -Num.maxF32",
+        std::f32::INFINITY,
+        f32
+    );
+    assert_evals_to!(
+        "Num.subSaturated Num.minF32 -Num.minF32",
+        std::f32::NEG_INFINITY,
+        f32
+    );
+    assert_evals_to!(
+        "Num.subSaturated Num.maxF64 -Num.maxF64",
+        std::f64::INFINITY,
+        f64
+    );
+    assert_evals_to!(
+        "Num.subSaturated Num.minF64 -Num.minF64",
+        std::f64::NEG_INFINITY,
+        f64
+    );
+
+    assert_evals_to!(
+        "Num.subSaturated 170_141_183_460_469_231_731dec -1",
+        RocDec::from_str("170141183460469231731.687303715884105727").unwrap(),
+        RocDec
+    );
+    assert_evals_to!(
+        "Num.subSaturated -170_141_183_460_469_231_731dec 1",
+        RocDec::from_str("-170141183460469231731.687303715884105728").unwrap(),
+        RocDec
     );
 }
 
 #[test]
 #[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
 fn mul_saturated() {
+    assert_evals_to!("Num.mulSaturated 200u8 2", 255u8, u8);
+    assert_evals_to!("Num.mulSaturated 100i8 2", 127i8, i8);
+    assert_evals_to!("Num.mulSaturated -100i8 2", -128i8, i8);
+    assert_evals_to!("Num.mulSaturated 40000u16 2", 65535u16, u16);
+    assert_evals_to!("Num.mulSaturated 20000i16 2", 32767i16, i16);
+    assert_evals_to!("Num.mulSaturated -20000i16 2", -32768i16, i16);
+    assert_evals_to!("Num.mulSaturated 3000000000u32 2", 4294967295u32, u32);
+    assert_evals_to!("Num.mulSaturated 2000000000i32 2", 2147483647i32, i32);
+    assert_evals_to!("Num.mulSaturated -2000000000i32 2", -2147483648i32, i32);
     assert_evals_to!(
-        indoc!(
+        "Num.mulSaturated 10000000000000000000u64 2",
-            r"
+        18446744073709551615u64,
-            x : U8
+        u64
-            x = 20
-            y : U8
-            y = 20
-            Num.mulSaturated x y
-            "
-        ),
-        255,
-        u8
     );
     assert_evals_to!(
-        indoc!(
+        "Num.mulSaturated 5000000000000000000i64 2",
-            r"
+        9223372036854775807i64,
-            x : I8
+        i64
-            x = -20
-            y : I8
-            y = -20
-            Num.mulSaturated x y
-            "
-        ),
-        127,
-        i8
     );
     assert_evals_to!(
-        indoc!(
+        "Num.mulSaturated -5000000000000000000i64 2",
-            r"
+        -9223372036854775808i64,
-            x : I8
+        i64
-            x = 20
-            y : I8
-            y = -20
-            Num.mulSaturated x y
-            "
-        ),
-        -128,
-        i8
     );
     assert_evals_to!(
-        indoc!(
+        "Num.mulSaturated -5000000000000000000i64 2",
-            r"
+        -9223372036854775808i64,
-            x : I8
+        i64
-            x = -20
+    );
-            y : I8
+    assert_evals_to!("Num.mulSaturated Num.maxF32 2", std::f32::INFINITY, f32);
-            y = 20
+    assert_evals_to!("Num.mulSaturated Num.minF32 2", std::f32::NEG_INFINITY, f32);
-            Num.mulSaturated x y
+    assert_evals_to!("Num.mulSaturated Num.maxF64 2", std::f64::INFINITY, f64);
-            "
+    assert_evals_to!("Num.mulSaturated Num.minF64 2", std::f64::NEG_INFINITY, f64);
-        ),
+
-        -128,
+    // TODO: This doesn't work anywhere? It returns -1.374607431768211456 : Dec ?
-        i8
+    /*
+    assert_evals_to!(
+        "Num.mulSaturated 170_141_183_460_469_231_731dec 2",
+        RocDec::from_str("170141183460469231731.687303715884105727").unwrap(),
+        RocDec
     );
     assert_evals_to!(
-        indoc!(
+        "Num.mulSaturated -170_141_183_460_469_231_731dec 2",
-            r"
+        RocDec::from_str("-170141183460469231731.687303715884105728").unwrap(),
-            x : I8
+        RocDec
-            x = 20
-            y : I8
-            y = 20
-            Num.mulSaturated x y
-            "
-        ),
-        127,
-        i8
     );
+    */
 }
 
 #[test]