feat(compiler)!: Add Uint32 and Uint64 types (#1531)

* feat(compiler): Add unsigned int types

update format/docs

* fix random, signed/unsigned conversion, change to operators

* removed deprecated int64 functions

* remove extraneous incRefs

* made docs more accurate

* updated tests

Author: alex-snezhko

compiler/src/codegen/comp_utils.re

@@ -40,16 +40,22 @@ let rec compile_const = (c): Literal.t => {
   let identity: 'a. 'a => 'a = x => x;
   let conv_int32 = n => Int32.(add(mul(2l, n), 1l));
   let conv_int64 = n => Int64.(add(mul(2L, n), 1L));
+  let conv_uint32 = n => Int32.(add(mul(2l, n), 1l));
+  let conv_uint64 = n => Int64.(add(mul(2L, n), 1L));
   let conv_float32 = identity;
   let conv_float64 = identity;
   switch (c) {
   | MConstLiteral(MConstLiteral(_) as c) => compile_const(c)
   | MConstI32(n) => Literal.int32(conv_int32(n))
   | MConstI64(n) => Literal.int64(conv_int64(n))
+  | MConstU32(n) => Literal.int32(conv_uint32(n))
+  | MConstU64(n) => Literal.int64(conv_uint64(n))
   | MConstF32(n) => Literal.float32(conv_float32(n))
   | MConstF64(n) => Literal.float64(conv_float64(n))
   | MConstLiteral(MConstI32(n)) => Literal.int32(n)
   | MConstLiteral(MConstI64(n)) => Literal.int64(n)
+  | MConstLiteral(MConstU32(n)) => Literal.int32(n)
+  | MConstLiteral(MConstU64(n)) => Literal.int64(n)
   | MConstLiteral(MConstF32(n)) => Literal.float32(n)
   | MConstLiteral(MConstF64(n)) => Literal.float64(n)
   };

compiler/src/codegen/compcore.re

@@ -2047,6 +2047,94 @@ let allocate_record = (wasm_mod, env, ttag, elts) => {
   );
 };
 
+let allocate_uint_uninitialized = (wasm_mod, env, is_32_bit) => {
+  let get_swap = () => get_swap(wasm_mod, env, 0);
+  let make_alloc = () =>
+    heap_allocate(wasm_mod, env, if (is_32_bit) {2} else {4});
+
+  let (tag, label) =
+    if (is_32_bit) {
+      (Uint32Type, "allocate_unitialized_uint32");
+    } else {
+      (Uint64Type, "allocate_unitialized_uint64");
+    };
+
+  let preamble = [
+    store(
+      ~offset=0,
+      wasm_mod,
+      tee_swap(~skip_incref=true, wasm_mod, env, 0, make_alloc()),
+      Expression.Const.make(
+        wasm_mod,
+        const_int32(tag_val_of_heap_tag_type(tag)),
+      ),
+    ),
+  ];
+  let postamble = [get_swap()];
+  Expression.Block.make(
+    wasm_mod,
+    gensym_label(label),
+    List.concat([preamble, postamble]),
+  );
+};
+
+type alloc_uint_type =
+  | Uint32(Expression.t)
+  | Uint64(Expression.t);
+
+let allocate_uint = (wasm_mod, env, uint_value) => {
+  let get_swap = () => get_swap(wasm_mod, env, 0);
+
+  let (tag, instrs, needed_words, label) =
+    switch (uint_value) {
+    | Uint32(uint32) => (
+        Uint32Type,
+        [store(~offset=4, ~ty=Type.int32, wasm_mod, get_swap(), uint32)],
+        2,
+        "allocate_uint32",
+      )
+    | Uint64(uint64) => (
+        Uint64Type,
+        [store(~offset=8, ~ty=Type.int64, wasm_mod, get_swap(), uint64)],
+        // Allocate 4 words to store with 8-byte alignment
+        4,
+        "allocate_uint64",
+      )
+    };
+
+  let preamble = [
+    store(
+      ~offset=0,
+      wasm_mod,
+      tee_swap(
+        ~skip_incref=true,
+        wasm_mod,
+        env,
+        0,
+        heap_allocate(wasm_mod, env, needed_words),
+      ),
+      Expression.Const.make(
+        wasm_mod,
+        const_int32(tag_val_of_heap_tag_type(tag)),
+      ),
+    ),
+  ];
+  let postamble = [get_swap()];
+  Expression.Block.make(
+    wasm_mod,
+    gensym_label(label),
+    List.concat([preamble, instrs, postamble]),
+  );
+};
+
+let allocate_uint32 = (wasm_mod, env, i) => {
+  allocate_uint(wasm_mod, env, Uint32(i));
+};
+
+let allocate_uint64 = (wasm_mod, env, i) => {
+  allocate_uint(wasm_mod, env, Uint64(i));
+};
+
 type alloc_number_type =
   | Int32(Expression.t)
   | Int64(Expression.t)
@@ -2289,6 +2377,8 @@ let compile_prim0 = (wasm_mod, env, p0): Expression.t => {
     allocate_number_uninitialized(wasm_mod, env, BoxedFloat64)
   | AllocateRational =>
     allocate_number_uninitialized(wasm_mod, env, BoxedRational)
+  | AllocateUint32 => allocate_uint_uninitialized(wasm_mod, env, true)
+  | AllocateUint64 => allocate_uint_uninitialized(wasm_mod, env, false)
   | Unreachable => Expression.Unreachable.make(wasm_mod)
   };
 };
@@ -2312,6 +2402,8 @@ let compile_prim1 = (wasm_mod, env, p1, arg, loc): Expression.t => {
   | NewInt64 => allocate_number(wasm_mod, env, Int64(compiled_arg))
   | NewFloat32 => allocate_number(wasm_mod, env, Float32(compiled_arg))
   | NewFloat64 => allocate_number(wasm_mod, env, Float64(compiled_arg))
+  | NewUint32 => allocate_uint(wasm_mod, env, Uint32(compiled_arg))
+  | NewUint64 => allocate_uint(wasm_mod, env, Uint64(compiled_arg))
   | LoadAdtVariant => load(~offset=12, wasm_mod, compiled_arg)
   | StringSize
   | BytesSize => load(~offset=4, wasm_mod, compiled_arg)
@@ -2724,6 +2816,18 @@ let compile_allocation = (wasm_mod, env, alloc_type) =>
       env,
       Expression.Const.make(wasm_mod, Literal.int64(i)),
     )
+  | MUint32(i) =>
+    allocate_uint32(
+      wasm_mod,
+      env,
+      Expression.Const.make(wasm_mod, Literal.int32(i)),
+    )
+  | MUint64(i) =>
+    allocate_uint64(
+      wasm_mod,
+      env,
+      Expression.Const.make(wasm_mod, Literal.int64(i)),
+    )
   | MFloat32(i) =>
     allocate_float32(
       wasm_mod,

compiler/src/codegen/mashtree.re

@@ -174,6 +174,8 @@ type prim0 =
   Parsetree.prim0 =
     | AllocateInt32
     | AllocateInt64
+    | AllocateUint32
+    | AllocateUint64
     | AllocateFloat32
     | AllocateFloat64
     | AllocateRational
@@ -188,6 +190,8 @@ type prim1 =
     | AllocateBigInt
     | NewInt32
     | NewInt64
+    | NewUint32
+    | NewUint64
     | NewFloat32
     | NewFloat64
     | BuiltinId
@@ -284,6 +288,8 @@ type primn =
 type constant =
   | MConstI32(int32)
   | MConstI64(int64)
+  | MConstU32(int32)
+  | MConstU64(int64)
   | MConstF32(float)
   | MConstF64(float)
   | MConstLiteral(constant); /* Special case for things which should not be encoded */
@@ -322,6 +328,8 @@ type allocation_type =
   | MChar(string)
   | MInt32(int32)
   | MInt64(int64)
+  | MUint32(int32)
+  | MUint64(int64)
   | MFloat32(float)
   | MFloat64(float)
   | MRational({

compiler/src/codegen/transl_anf.re

@@ -529,6 +529,8 @@ let compile_const = (c: Asttypes.constant) =>
   | Const_bigint(_) => failwith("compile_const: Const_bigint post-ANF")
   | Const_int32(i32) => MConstI32(i32)
   | Const_int64(i64) => MConstI64(i64)
+  | Const_uint32(u32) => MConstU32(u32)
+  | Const_uint64(u64) => MConstU64(u64)
   | Const_float32(f) => MConstF32(f)
   | Const_float64(f) => MConstF64(f)
   | Const_wasmi32(i32) => MConstLiteral(MConstI32(i32))
@@ -890,6 +892,8 @@ let rec compile_comp = (~id=?, env, c) => {
       )
     | CInt32(i) => MAllocate(MInt32(i))
     | CInt64(i) => MAllocate(MInt64(i))
+    | CUint32(i) => MAllocate(MUint32(i))
+    | CUint64(i) => MAllocate(MUint64(i))
     | CFloat32(f) => MAllocate(MFloat32(f))
     | CFloat64(f) => MAllocate(MFloat64(f))
     | CGetTupleItem(idx, tup) =>

compiler/src/codegen/value_tags.re

@@ -10,7 +10,9 @@ type heap_tag_type =
   | BoxedNumberType
   | LambdaType
   | TupleType
-  | BytesType;
+  | BytesType
+  | Uint32Type
+  | Uint64Type;
 
 let tag_val_of_heap_tag_type =
   fun
@@ -21,7 +23,9 @@ let tag_val_of_heap_tag_type =
   | BoxedNumberType => 5
   | LambdaType => 6
   | TupleType => 7
-  | BytesType => 8;
+  | BytesType => 8
+  | Uint32Type => 9
+  | Uint64Type => 10;
 
 let heap_tag_type_of_tag_val =
   fun
@@ -33,6 +37,8 @@ let heap_tag_type_of_tag_val =
   | 6 => LambdaType
   | 7 => TupleType
   | 8 => BytesType
+  | 9 => Uint32Type
+  | 10 => Uint64Type
   | x => failwith(Printf.sprintf("Unknown tag type: %d", x));
 
 [@deriving sexp]

compiler/src/middle_end/analyze_free_vars.re

@@ -131,6 +131,8 @@ module FreeVarsArg: Anf_iterator.IterArgument = {
       | CNumber(_)
       | CInt32(_)
       | CInt64(_)
+      | CUint32(_)
+      | CUint64(_)
       | CFloat32(_)
       | CFloat64(_)
       | CBytes(_)

compiler/src/middle_end/analyze_purity.re

@@ -41,7 +41,9 @@ module PurityArg: Anf_iterator.IterArgument = {
       | CImmExpr({imm_desc: ImmTrap}) => false
       | CImmExpr(_) => true
       | CPrim0(
-          AllocateInt32 | AllocateInt64 | AllocateFloat32 | AllocateFloat64 |
+          AllocateInt32 | AllocateInt64 | AllocateUint32 | AllocateUint64 |
+          AllocateFloat32 |
+          AllocateFloat64 |
           AllocateRational,
         ) =>
         true
@@ -51,6 +53,8 @@ module PurityArg: Anf_iterator.IterArgument = {
           BuiltinId |
           NewInt32 |
           NewInt64 |
+          NewUint32 |
+          NewUint64 |
           NewFloat32 |
           NewFloat64 |
           LoadAdtVariant |
@@ -137,6 +141,8 @@ module PurityArg: Anf_iterator.IterArgument = {
       | CNumber(_)
       | CInt32(_)
       | CInt64(_)
+      | CUint32(_)
+      | CUint64(_)
       | CFloat32(_)
       | CFloat64(_)
       | CBytes(_)

compiler/src/middle_end/analyze_tail_calls.re

@@ -80,6 +80,8 @@ let rec analyze_comp_expression =
   | CNumber(_)
   | CInt32(_)
   | CInt64(_)
+  | CUint32(_)
+  | CUint64(_)
   | CFloat32(_)
   | CFloat64(_)
   | CPrim0(_)

compiler/src/middle_end/anf_helper.re

@@ -49,6 +49,10 @@ module Comp = {
     mk(~loc?, ~attributes?, ~allocation_type=Managed, ~env?, CInt32(i));
   let int64 = (~loc=?, ~attributes=?, ~env=?, i) =>
     mk(~loc?, ~attributes?, ~allocation_type=Managed, ~env?, CInt64(i));
+  let uint32 = (~loc=?, ~attributes=?, ~env=?, i) =>
+    mk(~loc?, ~attributes?, ~allocation_type=Managed, ~env?, CUint32(i));
+  let uint64 = (~loc=?, ~attributes=?, ~env=?, i) =>
+    mk(~loc?, ~attributes?, ~allocation_type=Managed, ~env?, CUint64(i));
   let float32 = (~loc=?, ~attributes=?, ~env=?, i) =>
     mk(~loc?, ~attributes?, ~allocation_type=Managed, ~env?, CFloat32(i));
   let float64 = (~loc=?, ~attributes=?, ~env=?, i) =>

compiler/src/middle_end/anf_helper.rei

@@ -49,6 +49,12 @@ module Comp: {
   let int64:
     (~loc: loc=?, ~attributes: attributes=?, ~env: env=?, int64) =>
     comp_expression;
+  let uint32:
+    (~loc: loc=?, ~attributes: attributes=?, ~env: env=?, int32) =>
+    comp_expression;
+  let uint64:
+    (~loc: loc=?, ~attributes: attributes=?, ~env: env=?, int64) =>
+    comp_expression;
   let float32:
     (~loc: loc=?, ~attributes: attributes=?, ~env: env=?, float) =>
     comp_expression;