Adding the decimal functions for LLVM

crates/compiler/builtins/roc/Num.roc

@@ -121,6 +121,8 @@ module [
     maxI128,
     minU128,
     maxU128,
+    minDec,
+    maxDec,
     minF32,
     maxF32,
     minF64,
@@ -145,6 +147,8 @@ module [
     toU64Checked,
     toU128,
     toU128Checked,
+    toDec,
+    toDecChecked,
     toF32,
     toF32Checked,
     toF64,
@@ -1386,6 +1390,12 @@ minU128 = 0
 maxU128 : U128
 maxU128 = 340282366920938463463374607431768211455
 
+minDec : Dec
+minDec = -170141183460469231731.687303715884105728
+
+maxDec : Dec
+maxDec = 170141183460469231731.687303715884105727
+
 minF32 : F32
 minF32 = -3.40282347e38
 
@@ -1411,6 +1421,7 @@ toU32 : Int * -> U32
 toU64 : Int * -> U64
 toU128 : Int * -> U128
 
+toDec : Num * -> Dec
 ## Converts a [Num] to an [F32]. If the given number can't be precisely represented in an [F32],
 ## the returned number may be different from the given number.
 toF32 : Num * -> F32
@@ -1432,6 +1443,7 @@ toU16Checked : Int * -> Result U16 [OutOfBounds]
 toU32Checked : Int * -> Result U32 [OutOfBounds]
 toU64Checked : Int * -> Result U64 [OutOfBounds]
 toU128Checked : Int * -> Result U128 [OutOfBounds]
+toDecChecked : Num * -> Result Dec [OutOfBounds]
 toF32Checked : Num * -> Result F32 [OutOfBounds]
 toF64Checked : Num * -> Result F64 [OutOfBounds]
 

crates/compiler/can/src/builtins.rs

@@ -35,7 +35,7 @@ macro_rules! map_symbol_to_lowlevel_and_arity {
                 Symbol::NUM_TO_U128 => Some(lowlevel_1(Symbol::NUM_TO_U128, LowLevel::NumIntCast, var_store)),
 
                 Symbol::NUM_INT_CAST => Some(lowlevel_1(Symbol::NUM_INT_CAST, LowLevel::NumIntCast, var_store)),
-
+                Symbol::NUM_TO_DEC => Some(lowlevel_1(Symbol::NUM_TO_DEC, LowLevel::NumToDecCast, var_store)),
                 Symbol::NUM_TO_F32 => Some(lowlevel_1(Symbol::NUM_TO_F32, LowLevel::NumToFloatCast, var_store)),
                 Symbol::NUM_TO_F64 => Some(lowlevel_1(Symbol::NUM_TO_F64, LowLevel::NumToFloatCast, var_store)),
 
@@ -50,6 +50,8 @@ macro_rules! map_symbol_to_lowlevel_and_arity {
                 Symbol::NUM_TO_U64_CHECKED => Some(to_num_checked(Symbol::NUM_TO_U64_CHECKED, var_store, LowLevel::NumToIntChecked)),
                 Symbol::NUM_TO_U128_CHECKED => Some(to_num_checked(Symbol::NUM_TO_U128_CHECKED, var_store, LowLevel::NumToIntChecked)),
 
+                Symbol::NUM_TO_DEC_CHECKED => Some(to_num_checked(Symbol::NUM_TO_DEC_CHECKED, var_store, LowLevel::NumToDecChecked)),
+
                 Symbol::NUM_TO_F32_CHECKED => Some(to_num_checked(Symbol::NUM_TO_F32_CHECKED, var_store, LowLevel::NumToFloatChecked)),
                 Symbol::NUM_TO_F64_CHECKED => Some(to_num_checked(Symbol::NUM_TO_F64_CHECKED, var_store, LowLevel::NumToFloatChecked)),
 
@@ -79,7 +81,8 @@ macro_rules! map_symbol_to_lowlevel_and_arity {
                 LowLevel::NumToFloatCast => unreachable!(),
                 LowLevel::NumToIntChecked => unreachable!(),
                 LowLevel::NumToFloatChecked => unreachable!(),
-
+                LowLevel::NumToDecCast => unreachable!(),
+                LowLevel::NumToDecChecked => unreachable!(),
                 // these are used internally and not tied to a symbol
                 LowLevel::Hash => unimplemented!(),
                 LowLevel::PtrCast => unimplemented!(),

crates/compiler/gen_dev/src/lib.rs

@@ -1883,6 +1883,7 @@ trait Backend<'a> {
 
                 self.build_num_int_cast(sym, &args[0], source_width, target_width)
             }
+
             LowLevel::NumIsMultipleOf => {
                 let int_width = arg_layouts[0].try_int_width().unwrap();
                 let intrinsic = bitcode::NUM_IS_MULTIPLE_OF[int_width].to_string();

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

@@ -1065,6 +1065,7 @@ pub fn module_from_builtins<'ctx>(
         "__modti3",
         "__muloti4",
         "__udivti3",
+        "__fixdfti",
         "__umodti3",
         // Roc special functions
         "__roc_force_longjmp",

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

@@ -1169,6 +1169,135 @@ pub(crate) fn run_low_level<'a, 'ctx>(
             let Ok(value) = result else { todo!() };
             value.into()
         }
+        NumToDecCast | NumToDecChecked => {
+            let checked = matches!(op, NumToDecChecked);
+            const DEC_RIGHT_DIGITS: u64 = 10u64.pow(18);
+            const MAX_DEC_F: f64 = 170_141_183_460_469_231_731.687_303_715_884_105_727;
+            const MAX_DEC_IH: u64 = 9;
+            const MAX_DEC_IL: u64 = 4120486797000000000;
+            let to = env.context.i128_type();
+            let float_type = env.context.f64_type();
+            let llvm_digits = to.const_int(DEC_RIGHT_DIGITS, false);
+            let llvm_max_dec_f = float_type.const_float(MAX_DEC_F);
+            let llvm_max_dec_i = to.const_int_arbitrary_precision(&[MAX_DEC_IL, MAX_DEC_IH]);
+            let llvm_min_dec_i = to
+                .const_int_arbitrary_precision(&[MAX_DEC_IL, MAX_DEC_IH])
+                .const_not();
+            let llvm_divisor = float_type.const_float(DEC_RIGHT_DIGITS as f64);
+
+            arguments_with_layouts!((arg, arg_layout));
+            //Get the actual value that we are converting to
+            let result = match layout_interner.get_repr(arg_layout) {
+                //If integer
+                LayoutRepr::Builtin(Builtin::Int(width)) => {
+                    //Extend to I128
+                    let Ok(converted_value) = (if width.is_signed() {
+                        env.builder
+                            .build_int_s_extend(arg.into_int_value(), to, "inc_cast")
+                    } else {
+                        env.builder
+                            .build_int_z_extend(arg.into_int_value(), to, "inc_cast")
+                    }) else {
+                        todo!()
+                    };
+                    //Add decimal places
+                    let Ok(result) =
+                        env.builder
+                            .build_int_mul(converted_value, llvm_digits, "deci_cast")
+                    else {
+                        todo!()
+                    };
+                    result.as_basic_value_enum()
+                }
+                LayoutRepr::Builtin(Builtin::Float(_)) => {
+                    let Ok(float_result) = env.builder.build_float_mul(
+                        arg.into_float_value(),
+                        llvm_divisor,
+                        "decf_cast",
+                    ) else {
+                        todo!()
+                    };
+                    let Ok(int_result) =
+                        env.builder
+                            .build_float_to_signed_int(float_result, to, "dec_place")
+                    else {
+                        todo!()
+                    };
+                    int_result.as_basic_value_enum()
+                }
+                LayoutRepr::Builtin(Builtin::Decimal) => arg,
+                _ => {
+                    todo!()
+                }
+            };
+            //Look and see if the conversion is checked or not
+            if checked {
+                let bool_false = env.context.bool_type().const_zero();
+                let with_overflow = match layout_interner.get_repr(arg_layout) {
+                    //If the value being is converted into a integer
+                    LayoutRepr::Builtin(Builtin::Int(width)) => {
+                        //`Dec` can always fit `I64`s and `U64`s and smaller, no need to check at runtime
+                        if width.stack_size() <= 4 {
+                            bool_false
+                        } else if width.is_signed() {
+                            let compare_arg = env
+                                .builder
+                                .build_int_z_extend_or_bit_cast(
+                                    arg.into_int_value(),
+                                    to,
+                                    "int_cast",
+                                )
+                                .unwrap();
+                            //If VA > +Dec
+                            let pos_res = env.builder.new_build_int_compare(
+                                inkwell::IntPredicate::SGT,
+                                compare_arg,
+                                llvm_max_dec_i,
+                                "int_compare",
+                            );
+                            //If VA < -Dec
+                            let neg_res = env.builder.new_build_int_compare(
+                                inkwell::IntPredicate::SGT,
+                                llvm_min_dec_i,
+                                compare_arg,
+                                "int_compare",
+                            );
+                            env.builder.new_build_or(pos_res, neg_res, "or_ops")
+                        } else {
+                            env.builder.new_build_int_compare(
+                                inkwell::IntPredicate::SGT,
+                                arg.into_int_value(),
+                                llvm_max_dec_i,
+                                "int_compare",
+                            )
+                        }
+                    }
+                    LayoutRepr::Builtin(Builtin::Float(_)) => env.builder.new_build_float_compare(
+                        inkwell::FloatPredicate::OGT,
+                        arg.into_float_value(),
+                        llvm_max_dec_f,
+                        "float_compare",
+                    ),
+                    //A decimal can obviously fit itself
+                    LayoutRepr::Builtin(Builtin::Decimal) => bool_false,
+                    _ => {
+                        unreachable!()
+                    }
+                };
+
+                let return_int_type: BasicTypeEnum = env.context.i128_type().into();
+                result_with(
+                    env,
+                    return_int_type,
+                    result,
+                    env.context.bool_type().into(),
+                    with_overflow,
+                )
+                .into()
+            } else {
+                result
+            }
+        }
         NumToFloatCast => {
             arguments_with_layouts!((arg, arg_layout));
 
@@ -2876,3 +3005,25 @@ fn load_symbol_and_lambda_set<'a, 'ctx>(
         other => panic!("Not a lambda set: {other:?}, {ptr:?}"),
     }
 }
+use inkwell::types::BasicTypeEnum;
+///Change from a basic LLVM value to a Roc `Result`
+fn result_with<'ctx>(
+    env: &Env<'_, 'ctx, '_>,
+    good_type: BasicTypeEnum,
+    good_value: impl BasicValue<'ctx>,
+    bad_type: BasicTypeEnum,
+    bad_value: impl BasicValue<'ctx>,
+) -> StructValue<'ctx> {
+    let struct_type = env.context.struct_type(&[good_type, bad_type], false);
+    let return_value = struct_type.const_zero();
+    let return_value = env
+        .builder
+        .build_insert_value(return_value, good_value, 0, "good_value")
+        .unwrap();
+    let return_value = env
+        .builder
+        .build_insert_value(return_value, bad_value, 1, "is_bad")
+        .unwrap();
+
+    return_value.into_struct_value()
+}

crates/compiler/gen_wasm/src/low_level.rs

@@ -2066,6 +2066,12 @@ impl<'a> LowLevelCall<'a> {
                     _ => todo!("{:?}: {:?} -> {:?}", self.lowlevel, arg_type, ret_type),
                 }
             }
+            NumToDecCast => {
+                todo!("Need to implement this");
+            }
+            NumToDecChecked => {
+                todo!("Need to implement this");
+            }
             NumToFloatCast => {
                 self.load_args(backend);
                 let arg_layout = backend.storage.symbol_layouts[&self.arguments[0]];

crates/compiler/module/src/low_level.rs

@@ -95,8 +95,10 @@ pub enum LowLevel {
     NumShiftRightZfBy,
     NumIntCast,
     NumToFloatCast,
+    NumToDecCast,
     NumToIntChecked,
     NumToFloatChecked,
+    NumToDecChecked,
     NumToStr,
     NumCountLeadingZeroBits,
     NumCountTrailingZeroBits,
@@ -216,7 +218,8 @@ macro_rules! map_symbol_to_lowlevel {
                 LowLevel::NumToFloatCast => unreachable!(),
                 LowLevel::NumToIntChecked => unreachable!(),
                 LowLevel::NumToFloatChecked => unreachable!(),
-
+                LowLevel::NumToDecCast => unreachable!(),
+                LowLevel::NumToDecChecked => unreachable!(),
 
                 // these are used internally and not tied to a symbol
                 LowLevel::Hash => unimplemented!(),

crates/compiler/module/src/symbol.rs

@@ -1349,6 +1349,10 @@ define_builtins! {
         166 NUM_NAN_F64: "nanF64"
         167 NUM_INFINITY_F32: "infinityF32"
         168 NUM_INFINITY_F64: "infinityF64"
+        169 NUM_TO_DEC: "toDec"
+        170 NUM_TO_DEC_CHECKED: "toDecChecked"
+        171 NUM_MAX_DEC: "maxDec"
+        172 NUM_MIN_DEC: "minDec"
     }
     4 BOOL: "Bool" => {
         0 BOOL_BOOL: "Bool" exposed_type=true // the Bool.Bool type alias

crates/compiler/mono/src/drop_specialization.rs

@@ -1592,6 +1592,8 @@ fn low_level_no_rc(lowlevel: &LowLevel) -> RC {
         | NumToIntChecked
         | NumToFloatCast
         | NumToFloatChecked
+        | NumToDecCast
+        | NumToDecChecked
         | NumCountLeadingZeroBits
         | NumCountTrailingZeroBits
         | NumCountOneBits

crates/compiler/mono/src/inc_dec.rs

@@ -1289,6 +1289,8 @@ pub(crate) fn lowlevel_borrow_signature(op: LowLevel) -> &'static [Ownership] {
         | NumAsin
         | NumIntCast
         | NumToIntChecked
+        | NumToDecCast
+        | NumToDecChecked
         | NumToFloatCast
         | NumToFloatChecked
         | NumCountLeadingZeroBits

crates/compiler/mono/src/low_level.rs

@@ -96,6 +96,7 @@ enum FirstOrder {
     NumShiftRightZfBy,
     NumIntCast,
     NumFloatCast,
+    NumToDecCast,
     Eq,
     NotEq,
     And,

crates/compiler/test_gen/src/gen_num.rs

@@ -4116,3 +4116,39 @@ fn cast_signed_unsigned() {
     assert_evals_to!(r"Num.toU8 127i8", 127, u8);
     assert_evals_to!(r"Num.toI8 127u8", 127, i8);
 }
+
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-wasm"))]
+fn min_max_dec() {
+    assert_evals_to!(r"Num.minDec", i128::MIN, i128);
+    assert_evals_to!(r"Num.maxDec", i128::MAX, i128);
+}
+#[allow(clippy::non_minimal_cfg)]
+#[test]
+#[cfg(any(feature = "gen-llvm"))]
+fn float_to_dec() {
+    assert_evals_to!(r"Num.toDec 0f64", RocDec::from_str("0").unwrap(), RocDec);
+    assert_evals_to!(r"Num.toDecChecked 0f64",RocResult::ok(RocDec::from_str("0").unwrap()),RocResult<RocDec,()>);
+    assert_evals_to!(r"Num.toDecChecked 999999999999999999999999999.999999999f64",RocResult::err(()),RocResult<RocDec,()>);
+    assert_evals_to!(r"Num.toDecChecked 0f64", RocResult::ok(RocDec::from_str("0").unwrap()), RocResult<RocDec, ()>);
+}
+#[allow(clippy::non_minimal_cfg)]
+#[test]
+#[cfg(any(feature = "gen-llvm"))]
+fn num_to_dec() {
+    assert_evals_to!(r"Num.toDec 0u64", RocDec::from_str("0").unwrap(), RocDec);
+    assert_evals_to!(
+        r"Num.toDec 100u64",
+        RocDec::from_str("100").unwrap(),
+        RocDec
+    );
+    assert_evals_to!(r"Num.toDec 0i64", RocDec::from_str("0").unwrap(), RocDec);
+    assert_evals_to!(
+        r"Num.toDec 100i64",
+        RocDec::from_str("100").unwrap(),
+        RocDec
+    );
+    assert_evals_to!(r"Num.toDecChecked -100i64",RocResult::ok(RocDec::from_str("-100").unwrap()), RocResult<RocDec, ()>);
+    assert_evals_to!(r"Num.toDecChecked 100i64",RocResult::ok(RocDec::from_str("100").unwrap()), RocResult<RocDec, ()>);
+    assert_evals_to!(r"Num.toDecChecked 999999999999999999999999999u128",RocResult::err(()),RocResult<RocDec,()>);
+}