From ee9edef09734f68b85fbcf9f0a92b341b040c693 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Tue, 8 Aug 2023 09:50:35 +0200
Subject: [PATCH 001/260] Keep heap state on upgrade

---
 src/codegen/compile.ml | 46 ++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 44 insertions(+), 2 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 023c08ba7aa..e9e0646e96b 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -7155,8 +7155,49 @@ module BlobStream : Stream = struct
 
 end
 
+module Stabilization = struct
+  (* TODO: Define memory layout and predefined address for actor object *)
+  let register_globals env =
+    (* Only reserve static memory without appending a data segment.
+       This is necessary because data segments are overwritten on upgrade
+       and we need to retain the old actor object address at this location. 
+       The Wasm memory is guaranteed to be zero-initialized on canister installation.
+    *)
+    let static_address = E.reserve_static_memory env Heap.word_size in
+    E.add_global32 env "__actor_object" Mutable static_address;
+    ()
 
-(* Stabilization (serialization to/from stable memory) of both:
+  let actor_address env =
+    G.i (GlobalGet (nr (E.get_global env "__actor_object")))
+
+  let load_actor env =
+    actor_address env ^^ load_unskewed_ptr
+    
+  let save_actor env =
+    let (set_value, get_value) = new_local env "value" in
+    set_value ^^
+    actor_address env ^^ get_value ^^ store_unskewed_ptr
+
+  let empty_actor env t =
+    let (_, fs) = Type.as_obj t in
+    let fs' = List.map
+      (fun f -> (f.Type.lab, fun () -> Opt.null_lit env))
+      fs
+    in
+    Object.lit_raw env fs'
+
+  let stabilize env t =
+    save_actor env
+
+  let destabilize env t =
+    load_actor env ^^
+    G.i (Test (Wasm.Values.I32 I32Op.Eqz)) ^^
+    G.if1 I32Type
+      (empty_actor env t)
+      (load_actor env)
+end
+
+(* OldStabilization (serialization to/from stable memory) of both:
    * stable variables; and
    * virtual stable memory.
    c.f.
@@ -7164,7 +7205,7 @@ end
    * ../../design/StableMemory.md
 *)
 
-module Stabilization = struct
+module OldStabilization = struct
 
   let extend64 code = code ^^ G.i (Convert (Wasm.Values.I64 I64Op.ExtendUI32))
 
@@ -11253,6 +11294,7 @@ let compile mode rts (prog : Ir.prog) : Wasm_exts.CustomModule.extended_module =
   GC.register_globals env;
   StableMem.register_globals env;
   Serialization.Registers.register_globals env;
+  Stabilization.register_globals env;
 
   (* See Note [Candid subtype checks] *)
   let set_serialization_globals = Serialization.register_delayed_globals env in

From d22060cd38e628b3fe2f07714df200adb7c642c1 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Tue, 8 Aug 2023 16:25:23 +0200
Subject: [PATCH 002/260] Disable unused code

---
 src/codegen/compile.ml | 23 +++++++++++++++++++----
 1 file changed, 19 insertions(+), 4 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index e9e0646e96b..e0a50f319e3 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -665,7 +665,7 @@ let compile_eq_const = function
 let compile_op64_const op i =
     compile_const_64 i ^^
     G.i (Binary (Wasm.Values.I64 op))
-let compile_add64_const = compile_op64_const I64Op.Add
+let _compile_add64_const = compile_op64_const I64Op.Add
 let compile_sub64_const = compile_op64_const I64Op.Sub
 let compile_mul64_const = compile_op64_const I64Op.Mul
 let _compile_divU64_const = compile_op64_const I64Op.DivU
@@ -1139,9 +1139,11 @@ module Heap = struct
 
   (* At this level of abstraction, heap objects are just flat arrays of words *)
 
+(*
   let load_field_unskewed (i : int32) : G.t =
     let offset = Int32.mul word_size i in
     G.i (Load {ty = I32Type; align = 2; offset; sz = None})
+*)
 
   let load_field (i : int32) : G.t =
     let offset = Int32.(add (mul word_size i) ptr_unskew) in
@@ -1153,11 +1155,13 @@ module Heap = struct
 
   (* Although we occasionally want to treat two consecutive
      32 bit fields as one 64 bit number *)
-  
+
   (* Requires little-endian encoding, see also `Stream` in `types.rs` *)
+(*
   let load_field64_unskewed (i : int32) : G.t =
     let offset = Int32.mul word_size i in
     G.i (Load {ty = I64Type; align = 2; offset; sz = None})
+*)
 
   let load_field64 (i : int32) : G.t =
     let offset = Int32.(add (mul word_size i) ptr_unskew) in
@@ -1712,6 +1716,7 @@ module Tagged = struct
     (if !Flags.sanity then check_forwarding_for_store env I32Type else G.nop) ^^
     Heap.store_field index
 
+(*
   let load_field_unskewed env index =
     (if !Flags.sanity then check_forwarding env true else G.nop) ^^
     Heap.load_field_unskewed index
@@ -1719,6 +1724,7 @@ module Tagged = struct
   let load_field64_unskewed env index =
     (if !Flags.sanity then check_forwarding env true else G.nop) ^^
     Heap.load_field64_unskewed index
+*)
 
   let load_field64 env index =
     (if !Flags.sanity then check_forwarding env false else G.nop) ^^
@@ -3826,6 +3832,7 @@ module Blob = struct
 
   let dyn_alloc_scratch env = alloc env ^^ payload_ptr_unskewed env
 
+(*
   (* TODO: rewrite using MemoryFill *)
   let clear env =
     Func.share_code1 env "blob_clear" ("x", I32Type) [] (fun env get_x ->
@@ -3849,6 +3856,7 @@ module Blob = struct
         get_ptr ^^
         compile_add_const Heap.word_size ^^
         set_ptr))
+*)
 
 end (* Blob *)
 
@@ -4916,7 +4924,7 @@ end (* Cycles *)
 module StableMem = struct
 
   (* start from 1 to avoid accidental reads of 0 *)
-  let version = Int32.of_int 1
+  let _version = Int32.of_int 1
 
   let register_globals env =
     (* size (in pages) *)
@@ -5009,12 +5017,12 @@ module StableMem = struct
             IC.system_call env "stable64_write"))
     | _ -> assert false
 
+(*
   let _read_word32 env =
     read env false "word32" I32Type 4l load_unskewed_ptr
   let write_word32 env =
     write env false "word32" I32Type 4l store_unskewed_ptr
 
-
   (* read and clear word32 from stable mem offset on stack *)
   let read_and_clear_word32 env =
     match E.mode env with
@@ -5041,6 +5049,7 @@ module StableMem = struct
             get_word
         ))
     | _ -> assert false
+*)
 
   (* ensure_pages : ensure at least num pages allocated,
      growing (real) stable memory if needed *)
@@ -5070,6 +5079,7 @@ module StableMem = struct
             get_size)
     | _ -> assert false
 
+(*
   (* ensure stable memory includes [offset..offset+size), assumes size > 0 *)
   let ensure env =
     match E.mode env with
@@ -5098,6 +5108,7 @@ module StableMem = struct
           G.i (Compare (Wasm.Values.I64 I64Op.LtS)) ^^
           E.then_trap_with env "Out of stable memory.")
     | _ -> assert false
+*)
 
   (* API *)
 
@@ -7082,6 +7093,7 @@ end (* MakeSerialization *)
 
 module Serialization = MakeSerialization(BumpStream)
 
+(*
 module BlobStream : Stream = struct
   let create env get_data_size set_token get_token header =
     let header_size = Int32.of_int (String.length header) in
@@ -7154,6 +7166,7 @@ module BlobStream : Stream = struct
     BigNum.compile_store_to_stream_signed env
 
 end
+*)
 
 module Stabilization = struct
   (* TODO: Define memory layout and predefined address for actor object *)
@@ -7197,6 +7210,7 @@ module Stabilization = struct
       (load_actor env)
 end
 
+(*
 (* OldStabilization (serialization to/from stable memory) of both:
    * stable variables; and
    * virtual stable memory.
@@ -7507,6 +7521,7 @@ module OldStabilization = struct
         end
     | _ -> assert false
 end
+*)
 
 module GCRoots = struct
   let register env static_roots =

From 4c85e4002d0ec46ecfe71ccb967a3c3d99bc6991 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Tue, 8 Aug 2023 17:14:08 +0200
Subject: [PATCH 003/260] Allocate blob literals in heap

---
 src/codegen/compile.ml | 20 ++++++++++++++++----
 1 file changed, 16 insertions(+), 4 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index e0a50f319e3..4bb5d34d6b6 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -3668,14 +3668,12 @@ module Blob = struct
       BigNum.from_word32 env
     )
 
-  let vanilla_lit env s =
+  let static_lit env s =
     Tagged.shared_static_obj env Tagged.Blob StaticBytes.[
       I32 (Int32.of_int (String.length s));
       Bytes s;
     ]
 
-  let lit env s = compile_unboxed_const (vanilla_lit env s)
-
   let lit_ptr_len env s =
     compile_unboxed_const (Int32.add ptr_unskew (E.add_static env StaticBytes.[Bytes s])) ^^
     compile_unboxed_const (Int32.of_int (String.length s))
@@ -3691,6 +3689,19 @@ module Blob = struct
     Tagged.load_forwarding_pointer env ^^
     compile_add_const (unskewed_payload_offset env)
 
+  (* TODO: Implement dynamic sharing with lazy instantiation on the heap, 
+    the static memory only denotes singleton address per upgrade mode, 
+    the static singleton address needs to be re-initialized on upgrade *)
+  let lit env s = 
+    let blob_length = Int32.of_int (String.length s) in
+    let (set_new_blob, get_new_blob) = new_local env "new_blob" in
+    compile_unboxed_const blob_length ^^ alloc env ^^ set_new_blob ^^
+    get_new_blob ^^ payload_ptr_unskewed env ^^ (* target address *)
+    compile_unboxed_const (static_lit env s) ^^ payload_ptr_unskewed env ^^ (* source address *)
+    compile_unboxed_const blob_length ^^ (* copy length *)
+    Heap.memcpy env ^^
+    get_new_blob
+
   let as_ptr_len env = Func.share_code1 env "as_ptr_size" ("x", I32Type) [I32Type; I32Type] (
     fun env get_x ->
       get_x ^^ payload_ptr_unskewed env ^^
@@ -7629,7 +7640,7 @@ module StackRep = struct
     | Const.Word32 n   -> BoxedSmallWord.vanilla_lit env n
     | Const.Word64 n   -> BoxedWord64.vanilla_lit env n
     | Const.Float64 f  -> Float.vanilla_lit env f
-    | Const.Blob t     -> Blob.vanilla_lit env t
+    | Const.Blob t     -> assert false
     | Const.Null       -> Opt.null_vanilla_lit env
 
   let rec materialize_const_t env (p, cv) : int32 =
@@ -7678,6 +7689,7 @@ module StackRep = struct
     | Vanilla, UnboxedFloat64 -> Float.unbox env
 
     | Const (_, Const.Lit (Const.Bool b)), Vanilla -> Bool.lit b
+    | Const (_, Const.Lit (Const.Blob t)), Vanilla -> Blob.lit env t
     | Const c, Vanilla -> compile_unboxed_const (materialize_const_t env c)
     | Const (_, Const.Lit (Const.Word32 n)), UnboxedWord32 -> compile_unboxed_const n
     | Const (_, Const.Lit (Const.Word64 n)), UnboxedWord64 -> compile_const_64 n

From f69c2910fb11d7ce75dee8a503d0ed822a01a3b3 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Wed, 9 Aug 2023 13:57:22 +0200
Subject: [PATCH 004/260] Introduce persistent metadata

---
 rts/motoko-rts/src/gc/copying.rs              |  3 +-
 rts/motoko-rts/src/gc/generational.rs         |  6 +-
 .../src/gc/generational/write_barrier.rs      |  4 +-
 rts/motoko-rts/src/gc/incremental.rs          | 12 ++-
 .../src/gc/incremental/partitioned_heap.rs    |  5 ++
 rts/motoko-rts/src/gc/mark_compact.rs         |  3 +-
 rts/motoko-rts/src/lib.rs                     |  1 +
 rts/motoko-rts/src/memory/ic.rs               |  6 --
 rts/motoko-rts/src/memory/ic/linear_memory.rs |  8 +-
 rts/motoko-rts/src/persistence.rs             | 90 +++++++++++++++++++
 src/codegen/compile.ml                        | 32 +++----
 src/linking/linkModule.ml                     |  3 +
 12 files changed, 130 insertions(+), 43 deletions(-)
 create mode 100644 rts/motoko-rts/src/persistence.rs

diff --git a/rts/motoko-rts/src/gc/copying.rs b/rts/motoko-rts/src/gc/copying.rs
index f1b0b20c5f7..70041e382c2 100644
--- a/rts/motoko-rts/src/gc/copying.rs
+++ b/rts/motoko-rts/src/gc/copying.rs
@@ -1,6 +1,7 @@
 use crate::constants::WORD_SIZE;
 use crate::mem_utils::{memcpy_bytes, memcpy_words};
 use crate::memory::Memory;
+use crate::persistence::HEAP_START;
 use crate::types::*;
 
 use motoko_rts_macros::ic_mem_fn;
@@ -29,7 +30,7 @@ unsafe fn copying_gc<M: Memory>(mem: &mut M) {
 
     copying_gc_internal(
         mem,
-        ic::get_aligned_heap_base(),
+        HEAP_START,
         // get_hp
         || linear_memory::get_hp_unskewed(),
         // set_hp
diff --git a/rts/motoko-rts/src/gc/generational.rs b/rts/motoko-rts/src/gc/generational.rs
index 1ea995573ea..09cbdb5f8e7 100644
--- a/rts/motoko-rts/src/gc/generational.rs
+++ b/rts/motoko-rts/src/gc/generational.rs
@@ -80,10 +80,10 @@ unsafe fn generational_gc<M: Memory>(mem: &mut M) {
 
 #[cfg(feature = "ic")]
 unsafe fn get_limits() -> Limits {
-    use crate::memory::ic::{self, linear_memory};
-    assert!(linear_memory::LAST_HP >= ic::get_aligned_heap_base());
+    use crate::{memory::ic::linear_memory, persistence::HEAP_START};
+    assert!(linear_memory::LAST_HP >= HEAP_START);
     Limits {
-        base: ic::get_aligned_heap_base(),
+        base: HEAP_START,
         last_free: linear_memory::LAST_HP,
         free: (linear_memory::get_hp_unskewed()),
     }
diff --git a/rts/motoko-rts/src/gc/generational/write_barrier.rs b/rts/motoko-rts/src/gc/generational/write_barrier.rs
index 1c8b43493fa..95b9db3820d 100644
--- a/rts/motoko-rts/src/gc/generational/write_barrier.rs
+++ b/rts/motoko-rts/src/gc/generational/write_barrier.rs
@@ -12,9 +12,9 @@ pub static mut LAST_HP: usize = 0;
 #[cfg(feature = "ic")]
 /// (Re-)initialize the write barrier for generational GC.
 pub(crate) unsafe fn init_generational_write_barrier<M: Memory>(mem: &mut M) {
-    use crate::memory::ic::{self, linear_memory};
+    use crate::{memory::ic::linear_memory, persistence::HEAP_START};
     REMEMBERED_SET = Some(RememberedSet::new(mem));
-    HEAP_BASE = ic::get_aligned_heap_base();
+    HEAP_BASE = HEAP_START;
     LAST_HP = linear_memory::LAST_HP;
 }
 
diff --git a/rts/motoko-rts/src/gc/incremental.rs b/rts/motoko-rts/src/gc/incremental.rs
index b136ddea147..478fbaf5cfb 100644
--- a/rts/motoko-rts/src/gc/incremental.rs
+++ b/rts/motoko-rts/src/gc/incremental.rs
@@ -10,7 +10,7 @@ use core::cell::RefCell;
 
 use motoko_rts_macros::ic_mem_fn;
 
-use crate::{memory::Memory, types::*, visitor::visit_pointer_fields};
+use crate::{memory::Memory, persistence::HEAP_START, types::*, visitor::visit_pointer_fields};
 
 use self::{
     partitioned_heap::{PartitionedHeap, PartitionedHeapIterator, UNINITIALIZED_HEAP},
@@ -37,8 +37,7 @@ pub mod time;
 
 #[ic_mem_fn(ic_only)]
 unsafe fn initialize_incremental_gc<M: Memory>(mem: &mut M) {
-    use crate::memory::ic;
-    IncrementalGC::<M>::initialize(mem, ic::get_aligned_heap_base());
+    IncrementalGC::<M>::initialize(mem, HEAP_START);
 }
 
 #[ic_mem_fn(ic_only)]
@@ -101,7 +100,7 @@ unsafe fn record_gc_stop<M: Memory>() {
     use crate::memory::ic::{self, partitioned_memory};
 
     let heap_size = partitioned_memory::get_heap_size();
-    let static_size = Bytes(ic::get_aligned_heap_base() as u32);
+    let static_size = Bytes(HEAP_START as u32);
     debug_assert!(heap_size >= static_size);
     let dynamic_size = heap_size - static_size;
     ic::MAX_LIVE = ::core::cmp::max(ic::MAX_LIVE, dynamic_size);
@@ -166,6 +165,11 @@ impl<'a, M: Memory + 'a> IncrementalGC<'a, M> {
     /// (Re-)Initialize the entire incremental garbage collector.
     /// Called on a runtime system start with incremental GC and also during RTS testing.
     pub unsafe fn initialize(mem: &'a mut M, heap_base: usize) {
+        println!(
+            100,
+            "INITIALIZE INCREMENTAL GC {}",
+            &mut STATE.borrow_mut().partitioned_heap as *mut PartitionedHeap as usize
+        );
         let state = STATE.get_mut();
         state.phase = Phase::Pause;
         state.partitioned_heap = PartitionedHeap::new(mem, heap_base);
diff --git a/rts/motoko-rts/src/gc/incremental/partitioned_heap.rs b/rts/motoko-rts/src/gc/incremental/partitioned_heap.rs
index 2238150c771..92ac06f1b46 100644
--- a/rts/motoko-rts/src/gc/incremental/partitioned_heap.rs
+++ b/rts/motoko-rts/src/gc/incremental/partitioned_heap.rs
@@ -371,6 +371,11 @@ pub const UNINITIALIZED_HEAP: PartitionedHeap = PartitionedHeap {
 
 impl PartitionedHeap {
     pub unsafe fn new<M: Memory>(mem: &mut M, heap_base: usize) -> PartitionedHeap {
+        println!(
+            100,
+            "INITIALIZE PARTITIONED HEAP {}",
+            size_of::<PartitionedHeap>().to_bytes().as_usize()
+        );
         let allocation_index = heap_base / PARTITION_SIZE;
         mem.grow_memory(((allocation_index + 1) * PARTITION_SIZE) as u64);
         let partitions = from_fn(|index| Partition {
diff --git a/rts/motoko-rts/src/gc/mark_compact.rs b/rts/motoko-rts/src/gc/mark_compact.rs
index c19ce3e8d57..09d2f61f75a 100644
--- a/rts/motoko-rts/src/gc/mark_compact.rs
+++ b/rts/motoko-rts/src/gc/mark_compact.rs
@@ -11,6 +11,7 @@ use mark_stack::{alloc_mark_stack, free_mark_stack, pop_mark_stack, push_mark_st
 use crate::constants::WORD_SIZE;
 use crate::mem_utils::memcpy_words;
 use crate::memory::Memory;
+use crate::persistence::HEAP_START;
 use crate::types::*;
 use crate::visitor::{pointer_to_dynamic_heap, visit_pointer_fields};
 
@@ -44,7 +45,7 @@ unsafe fn compacting_gc<M: Memory>(mem: &mut M) {
 
     compacting_gc_internal(
         mem,
-        ic::get_aligned_heap_base(),
+        HEAP_START,
         // get_hp
         || linear_memory::get_hp_unskewed(),
         // set_hp
diff --git a/rts/motoko-rts/src/lib.rs b/rts/motoko-rts/src/lib.rs
index 51b68028d19..58dabc776c2 100644
--- a/rts/motoko-rts/src/lib.rs
+++ b/rts/motoko-rts/src/lib.rs
@@ -31,6 +31,7 @@ mod idl;
 pub mod leb128;
 mod mem_utils;
 pub mod memory;
+pub mod persistence;
 pub mod principal_id;
 mod static_checks;
 pub mod stream;
diff --git a/rts/motoko-rts/src/memory/ic.rs b/rts/motoko-rts/src/memory/ic.rs
index 68b4effccaa..50e710ce96e 100644
--- a/rts/motoko-rts/src/memory/ic.rs
+++ b/rts/motoko-rts/src/memory/ic.rs
@@ -14,15 +14,9 @@ use motoko_rts_macros::*;
 
 // Provided by generated code
 extern "C" {
-    fn get_heap_base() -> usize;
     pub(crate) fn get_static_roots() -> Value;
 }
 
-pub(crate) unsafe fn get_aligned_heap_base() -> usize {
-    // align to 32 bytes
-    ((get_heap_base() + 31) / 32) * 32
-}
-
 /// Maximum live data retained in a GC.
 pub(crate) static mut MAX_LIVE: Bytes<u32> = Bytes(0);
 
diff --git a/rts/motoko-rts/src/memory/ic/linear_memory.rs b/rts/motoko-rts/src/memory/ic/linear_memory.rs
index 14c94de5adc..426aab494c3 100644
--- a/rts/motoko-rts/src/memory/ic/linear_memory.rs
+++ b/rts/motoko-rts/src/memory/ic/linear_memory.rs
@@ -1,7 +1,7 @@
 use core::arch::wasm32;
 
-use super::{get_aligned_heap_base, IcMemory, Memory};
-use crate::types::*;
+use super::{IcMemory, Memory};
+use crate::{persistence::HEAP_START, types::*};
 
 /// Amount of garbage collected so far.
 pub(crate) static mut RECLAIMED: Bytes<u64> = Bytes(0);
@@ -23,7 +23,7 @@ pub(crate) unsafe fn get_hp_unskewed() -> usize {
 pub(crate) static mut LAST_HP: usize = 0;
 
 pub(crate) unsafe fn initialize() {
-    LAST_HP = get_aligned_heap_base();
+    LAST_HP = HEAP_START;
     set_hp_unskewed(LAST_HP);
 }
 
@@ -39,7 +39,7 @@ pub unsafe extern "C" fn get_total_allocations() -> Bytes<u64> {
 
 #[no_mangle]
 pub unsafe extern "C" fn get_heap_size() -> Bytes<u32> {
-    Bytes((get_hp_unskewed() - get_aligned_heap_base()) as u32)
+    Bytes((get_hp_unskewed() - HEAP_START) as u32)
 }
 
 impl Memory for IcMemory {
diff --git a/rts/motoko-rts/src/persistence.rs b/rts/motoko-rts/src/persistence.rs
new file mode 100644
index 00000000000..174bc2aeec7
--- /dev/null
+++ b/rts/motoko-rts/src/persistence.rs
@@ -0,0 +1,90 @@
+//! Orthogonal persistence support
+//!
+//! Persistent metadata table, located at 4MB, in the static partition space.
+
+use core::mem::size_of;
+
+use motoko_rts_macros::ic_mem_fn;
+
+use crate::{barriers::write_with_barrier, memory::Memory, types::Value};
+
+const FINGERPRINT: [char; 32] = [
+    'M', 'O', 'T', 'O', 'K', 'O', ' ', 'O', 'R', 'T', 'H', 'O', 'G', 'O', 'N', 'A', 'L', ' ', 'P',
+    'E', 'R', 'S', 'I', 'S', 'T', 'E', 'N', 'C', 'E', ' ', '3', '2',
+];
+const VERSION: usize = 1;
+const NO_ACTOR: Value = Value::from_scalar(0);
+
+// Use a long-term representation by relying on C layout.
+#[repr(C)]
+struct PersistentMetadata {
+    fingerprint: [char; 32],
+    version: usize,
+    actor: Value, // Must be added to the root set, use forwarding
+}
+
+const METATDATA_ADDRESS: usize = 4 * 1024 * 1024;
+const METADATA_RESERVE: usize = 128 * 1024;
+
+// TODO: Include partition table in reserved space.
+#[cfg(feature = "ic")]
+pub const HEAP_START: usize = METATDATA_ADDRESS + METADATA_RESERVE;
+
+const _: () = assert!(size_of::<PersistentMetadata>() <= METADATA_RESERVE);
+
+impl PersistentMetadata {
+    fn get() -> *mut Self {
+        METATDATA_ADDRESS as *mut Self
+    }
+
+    unsafe fn is_initialized(self: *mut Self) -> bool {
+        // Wasm memory is zero-initialized according to the Wasm specification.
+        let initialized = (*self).version != 0;
+        assert!(initialized || (*self).fingerprint == ['\0'; 32] && (*self).actor == NO_ACTOR);
+        initialized
+    }
+
+    unsafe fn check_version(self: *const Self) {
+        if (*self).version != VERSION {
+            panic!(
+                "Incompatible persistent memory version: {} instead of {}.",
+                (*self).version,
+                VERSION
+            );
+        }
+    }
+
+    unsafe fn initialize(self: *mut Self) {
+        debug_assert!(!self.is_initialized());
+        (*self).fingerprint = FINGERPRINT;
+        (*self).version = VERSION;
+        (*self).actor = NO_ACTOR;
+    }
+}
+
+#[ic_mem_fn]
+pub unsafe fn initialize_memory<M: Memory>(mem: &mut M) {
+    mem.grow_memory(HEAP_START as u64);
+    let metadata = PersistentMetadata::get();
+    if metadata.is_initialized() {
+        metadata.check_version();
+    } else {
+        metadata.initialize();
+    }
+    println!(100, "MEMORY INITIALIZED {HEAP_START:#x}");
+}
+
+/// Returns scalar 0 if no actor is stored.
+#[no_mangle]
+pub unsafe extern "C" fn load_actor() -> Value {
+    let metadata = PersistentMetadata::get();
+    (*metadata).actor.forward_if_possible()
+}
+
+#[ic_mem_fn]
+pub unsafe fn save_actor<M: Memory>(mem: &mut M, actor: Value) {
+    assert!(actor != NO_ACTOR);
+    let metadata = PersistentMetadata::get();
+    let location = &mut (*metadata).actor as *mut Value;
+    write_with_barrier(mem, location, actor);
+}
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 4bb5d34d6b6..9a0d973cd83 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -924,6 +924,9 @@ module RTS = struct
 
   (* The connection to the C and Rust parts of the RTS *)
   let system_imports env =
+    E.add_func_import env "rts" "initialize_memory" [] [];
+    E.add_func_import env "rts" "load_actor" [] [I32Type];
+    E.add_func_import env "rts" "save_actor" [I32Type] [];
     E.add_func_import env "rts" "memcpy" [I32Type; I32Type; I32Type] [I32Type]; (* standard libc memcpy *)
     E.add_func_import env "rts" "memcmp" [I32Type; I32Type; I32Type] [I32Type];
     E.add_func_import env "rts" "version" [] [I32Type];
@@ -7180,28 +7183,10 @@ end
 *)
 
 module Stabilization = struct
-  (* TODO: Define memory layout and predefined address for actor object *)
-  let register_globals env =
-    (* Only reserve static memory without appending a data segment.
-       This is necessary because data segments are overwritten on upgrade
-       and we need to retain the old actor object address at this location. 
-       The Wasm memory is guaranteed to be zero-initialized on canister installation.
-    *)
-    let static_address = E.reserve_static_memory env Heap.word_size in
-    E.add_global32 env "__actor_object" Mutable static_address;
-    ()
-
-  let actor_address env =
-    G.i (GlobalGet (nr (E.get_global env "__actor_object")))
-
-  let load_actor env =
-    actor_address env ^^ load_unskewed_ptr
+  let load_actor env = E.call_import env "rts" "load_actor"
+    
+  let save_actor env = E.call_import env "rts" "save_actor"
     
-  let save_actor env =
-    let (set_value, get_value) = new_local env "value" in
-    set_value ^^
-    actor_address env ^^ get_value ^^ store_unskewed_ptr
-
   let empty_actor env t =
     let (_, fs) = Type.as_obj t in
     let fs' = List.map
@@ -11093,6 +11078,7 @@ and compile_init_func mod_env ((cu, flavor) : Ir.prog) =
   | ProgU ds ->
     Func.define_built_in mod_env "init" [] [] (fun env ->
       let _ae, codeW = compile_decs env VarEnv.empty_ae ds Freevars.S.empty in
+      E.call_import mod_env "rts" "initialize_memory" ^^
       codeW G.nop
     )
   | ActorU (as_opt, ds, fs, up, _t) ->
@@ -11186,6 +11172,9 @@ and main_actor as_opt mod_env ds fs up =
     env.E.service := metadata "candid:service" up.meta.candid.service;
     env.E.args := metadata "candid:args" up.meta.candid.args;
 
+    (* Initialize persistent memory *)
+    E.call_import mod_env "rts" "initialize_memory" ^^
+
     (* Deserialize any arguments *)
     begin match as_opt with
       | None
@@ -11321,7 +11310,6 @@ let compile mode rts (prog : Ir.prog) : Wasm_exts.CustomModule.extended_module =
   GC.register_globals env;
   StableMem.register_globals env;
   Serialization.Registers.register_globals env;
-  Stabilization.register_globals env;
 
   (* See Note [Candid subtype checks] *)
   let set_serialization_globals = Serialization.register_delayed_globals env in
diff --git a/src/linking/linkModule.ml b/src/linking/linkModule.ml
index dc37b5e0227..0cf3f7ddfb5 100644
--- a/src/linking/linkModule.ml
+++ b/src/linking/linkModule.ml
@@ -766,6 +766,9 @@ let link (em1 : extended_module) libname (em2 : extended_module) =
   let lib_heap_start = align dylink.memory_alignment old_heap_start in
   let new_heap_start = align 4l (Int32.add lib_heap_start dylink.memory_size) in
 
+  (* Data segments must fit below 4MB according to the persistent heap layout. *)
+  assert ((Int32.to_int new_heap_start) <= 4 * 1024 * 1024);
+
   let old_table_size = read_table_size em1.module_ in
   let lib_table_start = align dylink.table_alignment old_table_size in
 

From e3cf57290057ec06c3f33aa952cb50ae12532f64 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Wed, 9 Aug 2023 14:30:59 +0200
Subject: [PATCH 005/260] Place GC state in persistent memory

---
 rts/motoko-rts/src/gc/copying.rs              |  5 +-
 rts/motoko-rts/src/gc/generational.rs         |  4 +-
 .../src/gc/generational/write_barrier.rs      |  2 +-
 rts/motoko-rts/src/gc/incremental.rs          | 49 ++++++++-----------
 rts/motoko-rts/src/gc/incremental/barriers.rs |  8 +--
 .../src/gc/incremental/mark_bitmap.rs         |  2 +-
 .../src/gc/incremental/partitioned_heap.rs    | 34 +------------
 rts/motoko-rts/src/gc/mark_compact.rs         |  5 +-
 rts/motoko-rts/src/lib.rs                     |  1 +
 rts/motoko-rts/src/memory/ic.rs               |  4 ++
 rts/motoko-rts/src/memory/ic/linear_memory.rs |  4 +-
 rts/motoko-rts/src/persistence.rs             | 12 +++--
 src/codegen/compile.ml                        |  5 --
 13 files changed, 52 insertions(+), 83 deletions(-)

diff --git a/rts/motoko-rts/src/gc/copying.rs b/rts/motoko-rts/src/gc/copying.rs
index 70041e382c2..0e306c3c3ed 100644
--- a/rts/motoko-rts/src/gc/copying.rs
+++ b/rts/motoko-rts/src/gc/copying.rs
@@ -1,14 +1,15 @@
 use crate::constants::WORD_SIZE;
 use crate::mem_utils::{memcpy_bytes, memcpy_words};
 use crate::memory::Memory;
-use crate::persistence::HEAP_START;
 use crate::types::*;
 
 use motoko_rts_macros::ic_mem_fn;
 
 #[no_mangle]
 #[cfg(feature = "ic")]
+#[allow(unreachable_code)]
 pub unsafe extern "C" fn initialize_copying_gc() {
+    panic!("Copying GC is not supported with the persistent heap");
     crate::memory::ic::linear_memory::initialize();
 }
 
@@ -26,7 +27,7 @@ unsafe fn schedule_copying_gc<M: Memory>(mem: &mut M) {
 
 #[ic_mem_fn(ic_only)]
 unsafe fn copying_gc<M: Memory>(mem: &mut M) {
-    use crate::memory::ic::{self, linear_memory};
+    use crate::memory::ic::{self, linear_memory, HEAP_START};
 
     copying_gc_internal(
         mem,
diff --git a/rts/motoko-rts/src/gc/generational.rs b/rts/motoko-rts/src/gc/generational.rs
index 09cbdb5f8e7..ca740fde297 100644
--- a/rts/motoko-rts/src/gc/generational.rs
+++ b/rts/motoko-rts/src/gc/generational.rs
@@ -28,7 +28,9 @@ use self::mark_stack::{free_mark_stack, pop_mark_stack};
 use self::write_barrier::REMEMBERED_SET;
 
 #[ic_mem_fn(ic_only)]
+#[allow(unreachable_code, unused_variables)]
 unsafe fn initialize_generational_gc<M: Memory>(mem: &mut M) {
+    panic!("Generational GC is not supported with the persistent heap");
     crate::memory::ic::linear_memory::initialize();
     write_barrier::init_generational_write_barrier(mem);
 }
@@ -80,7 +82,7 @@ unsafe fn generational_gc<M: Memory>(mem: &mut M) {
 
 #[cfg(feature = "ic")]
 unsafe fn get_limits() -> Limits {
-    use crate::{memory::ic::linear_memory, persistence::HEAP_START};
+    use crate::memory::ic::{linear_memory, HEAP_START};
     assert!(linear_memory::LAST_HP >= HEAP_START);
     Limits {
         base: HEAP_START,
diff --git a/rts/motoko-rts/src/gc/generational/write_barrier.rs b/rts/motoko-rts/src/gc/generational/write_barrier.rs
index 95b9db3820d..53fb3a87723 100644
--- a/rts/motoko-rts/src/gc/generational/write_barrier.rs
+++ b/rts/motoko-rts/src/gc/generational/write_barrier.rs
@@ -12,7 +12,7 @@ pub static mut LAST_HP: usize = 0;
 #[cfg(feature = "ic")]
 /// (Re-)initialize the write barrier for generational GC.
 pub(crate) unsafe fn init_generational_write_barrier<M: Memory>(mem: &mut M) {
-    use crate::{memory::ic::linear_memory, persistence::HEAP_START};
+    use crate::memory::ic::{linear_memory, HEAP_START};
     REMEMBERED_SET = Some(RememberedSet::new(mem));
     HEAP_BASE = HEAP_START;
     LAST_HP = linear_memory::LAST_HP;
diff --git a/rts/motoko-rts/src/gc/incremental.rs b/rts/motoko-rts/src/gc/incremental.rs
index 478fbaf5cfb..6435c9d35fa 100644
--- a/rts/motoko-rts/src/gc/incremental.rs
+++ b/rts/motoko-rts/src/gc/incremental.rs
@@ -6,14 +6,18 @@
 //! - Focus on reclaiming high-garbage partitions.
 //! - Compacting heap space with partition evacuations.
 //! - Incremental copying enabled by forwarding pointers.
-use core::cell::RefCell;
 
 use motoko_rts_macros::ic_mem_fn;
 
-use crate::{memory::Memory, persistence::HEAP_START, types::*, visitor::visit_pointer_fields};
+use crate::{
+    memory::Memory,
+    persistence::{get_incremenmtal_gc_state, HEAP_START, initialize_memory},
+    types::*,
+    visitor::visit_pointer_fields,
+};
 
 use self::{
-    partitioned_heap::{PartitionedHeap, PartitionedHeapIterator, UNINITIALIZED_HEAP},
+    partitioned_heap::{PartitionedHeap, PartitionedHeapIterator},
     phases::{
         evacuation_increment::EvacuationIncrement,
         mark_increment::{MarkIncrement, MarkState},
@@ -37,12 +41,14 @@ pub mod time;
 
 #[ic_mem_fn(ic_only)]
 unsafe fn initialize_incremental_gc<M: Memory>(mem: &mut M) {
-    IncrementalGC::<M>::initialize(mem, HEAP_START);
+    println!(100, "INITIALIZE INCREMENTAL GC");
+    initialize_memory(mem);
+    IncrementalGC::<M>::initialize(mem, get_incremenmtal_gc_state(), HEAP_START);
 }
 
 #[ic_mem_fn(ic_only)]
 unsafe fn schedule_incremental_gc<M: Memory>(mem: &mut M) {
-    let state = STATE.borrow();
+    let state = get_incremenmtal_gc_state();
     assert!(state.phase != Phase::Stop);
     let running = state.phase != Phase::Pause;
     if running || should_start() {
@@ -53,7 +59,7 @@ unsafe fn schedule_incremental_gc<M: Memory>(mem: &mut M) {
 #[ic_mem_fn(ic_only)]
 unsafe fn incremental_gc<M: Memory>(mem: &mut M) {
     use self::roots::root_set;
-    let state = STATE.get_mut();
+    let state = get_incremenmtal_gc_state();
     if state.phase == Phase::Pause {
         record_gc_start::<M>();
     }
@@ -136,6 +142,7 @@ enum Phase {
     Stop,     // GC stopped on canister upgrade.
 }
 
+/// GC state retained over multiple GC increments.
 pub struct State {
     phase: Phase,
     partitioned_heap: PartitionedHeap,
@@ -144,15 +151,6 @@ pub struct State {
     iterator_state: Option<PartitionedHeapIterator>,
 }
 
-/// GC state retained over multiple GC increments.
-static mut STATE: RefCell<State> = RefCell::new(State {
-    phase: Phase::Pause,
-    partitioned_heap: UNINITIALIZED_HEAP,
-    allocation_count: 0,
-    mark_state: None,
-    iterator_state: None,
-});
-
 /// Incremental GC.
 /// Each GC call has its new GC instance that shares the common GC state `STATE`.
 pub struct IncrementalGC<'a, M: Memory> {
@@ -164,13 +162,7 @@ pub struct IncrementalGC<'a, M: Memory> {
 impl<'a, M: Memory + 'a> IncrementalGC<'a, M> {
     /// (Re-)Initialize the entire incremental garbage collector.
     /// Called on a runtime system start with incremental GC and also during RTS testing.
-    pub unsafe fn initialize(mem: &'a mut M, heap_base: usize) {
-        println!(
-            100,
-            "INITIALIZE INCREMENTAL GC {}",
-            &mut STATE.borrow_mut().partitioned_heap as *mut PartitionedHeap as usize
-        );
-        let state = STATE.get_mut();
+    pub unsafe fn initialize(mem: &'a mut M, state: &mut State, heap_base: usize) {
         state.phase = Phase::Pause;
         state.partitioned_heap = PartitionedHeap::new(mem, heap_base);
         state.allocation_count = 0;
@@ -196,6 +188,7 @@ impl<'a, M: Memory + 'a> IncrementalGC<'a, M> {
     /// * The mark phase can only be started on an empty call stack.
     /// * The update phase can only be completed on an empty call stack.
     pub unsafe fn empty_call_stack_increment(&mut self, roots: Roots) {
+        println!(100, "GC INCREMENT");
         assert!(self.state.phase != Phase::Stop);
         if self.pausing() {
             self.start_marking(roots);
@@ -399,14 +392,12 @@ unsafe fn count_allocation(state: &mut State) {
 /// the compiler must not schedule the GC during stabilization anyway.
 #[no_mangle]
 pub unsafe extern "C" fn stop_gc_on_upgrade() {
-    STATE.get_mut().phase = Phase::Stop;
-}
-
-pub unsafe fn incremental_gc_state() -> &'static mut State {
-    STATE.get_mut()
+    get_incremenmtal_gc_state().phase = Phase::Stop;
 }
 
 pub unsafe fn get_partitioned_heap() -> &'static mut PartitionedHeap {
-    debug_assert!(STATE.get_mut().partitioned_heap.is_initialized());
-    &mut STATE.get_mut().partitioned_heap
+    debug_assert!(get_incremenmtal_gc_state()
+        .partitioned_heap
+        .is_initialized());
+    &mut get_incremenmtal_gc_state().partitioned_heap
 }
diff --git a/rts/motoko-rts/src/gc/incremental/barriers.rs b/rts/motoko-rts/src/gc/incremental/barriers.rs
index dd67c08d01b..ca8f351bbce 100644
--- a/rts/motoko-rts/src/gc/incremental/barriers.rs
+++ b/rts/motoko-rts/src/gc/incremental/barriers.rs
@@ -5,8 +5,8 @@
 use motoko_rts_macros::ic_mem_fn;
 
 use crate::{
-    gc::incremental::incremental_gc_state,
     memory::Memory,
+    persistence::get_incremenmtal_gc_state,
     types::{is_skewed, Value},
 };
 
@@ -14,7 +14,7 @@ use super::{count_allocation, post_allocation_barrier, pre_write_barrier, Phase}
 
 #[no_mangle]
 pub unsafe extern "C" fn running_gc() -> bool {
-    incremental_gc_state().phase != Phase::Pause
+    get_incremenmtal_gc_state().phase != Phase::Pause
 }
 
 /// Write a potential pointer value with a pre-update barrier and resolving pointer forwarding.
@@ -30,7 +30,7 @@ pub unsafe fn write_with_barrier<M: Memory>(mem: &mut M, location: *mut Value, v
     debug_assert!(!is_skewed(location as u32));
     debug_assert_ne!(location, core::ptr::null_mut());
 
-    let state = incremental_gc_state();
+    let state = get_incremenmtal_gc_state();
     pre_write_barrier(mem, state, *location);
     *location = value.forward_if_possible();
 }
@@ -47,7 +47,7 @@ pub unsafe fn write_with_barrier<M: Memory>(mem: &mut M, location: *mut Value, v
 /// * Keep track of concurrent allocations to adjust the GC increment time limit.
 #[no_mangle]
 pub unsafe extern "C" fn allocation_barrier(new_object: Value) -> Value {
-    let state = incremental_gc_state();
+    let state = get_incremenmtal_gc_state();
     if state.phase != Phase::Pause {
         post_allocation_barrier(state, new_object);
         count_allocation(state);
diff --git a/rts/motoko-rts/src/gc/incremental/mark_bitmap.rs b/rts/motoko-rts/src/gc/incremental/mark_bitmap.rs
index e614d5b2b4a..8afc38e73d9 100644
--- a/rts/motoko-rts/src/gc/incremental/mark_bitmap.rs
+++ b/rts/motoko-rts/src/gc/incremental/mark_bitmap.rs
@@ -35,7 +35,7 @@ pub struct MarkBitmap {
     pointer: *mut u8,
 }
 
-pub const DEFAULT_MARK_BITMAP: MarkBitmap = MarkBitmap {
+const DEFAULT_MARK_BITMAP: MarkBitmap = MarkBitmap {
     pointer: null_mut(),
 };
 
diff --git a/rts/motoko-rts/src/gc/incremental/partitioned_heap.rs b/rts/motoko-rts/src/gc/incremental/partitioned_heap.rs
index 92ac06f1b46..4984dd2dc7d 100644
--- a/rts/motoko-rts/src/gc/incremental/partitioned_heap.rs
+++ b/rts/motoko-rts/src/gc/incremental/partitioned_heap.rs
@@ -46,7 +46,7 @@ use crate::{
 };
 
 use super::{
-    mark_bitmap::{BitmapIterator, MarkBitmap, BITMAP_SIZE, DEFAULT_MARK_BITMAP},
+    mark_bitmap::{BitmapIterator, MarkBitmap, BITMAP_SIZE},
     sort::sort,
     time::BoundedTime,
 };
@@ -86,20 +86,6 @@ pub struct Partition {
     update: bool,        // Specifies whether the pointers in the partition have to be updated.
 }
 
-/// Optimization: Avoiding `Option` or `Lazy`.
-const UNINITIALIZED_PARTITION: Partition = Partition {
-    index: usize::MAX,
-    free: false,
-    large_content: false,
-    marked_size: 0,
-    static_size: 0,
-    dynamic_size: 0,
-    bitmap: DEFAULT_MARK_BITMAP,
-    temporary: false,
-    evacuate: false,
-    update: false,
-};
-
 impl Partition {
     pub fn get_index(&self) -> usize {
         self.index
@@ -356,26 +342,8 @@ pub struct PartitionedHeap {
     precomputed_heap_size: usize, // Occupied heap size, excluding the dynamic heap in the allocation partition.
 }
 
-/// Optimization: Avoiding `Option` or `LazyCell`.
-pub const UNINITIALIZED_HEAP: PartitionedHeap = PartitionedHeap {
-    partitions: [UNINITIALIZED_PARTITION; MAX_PARTITIONS],
-    heap_base: 0,
-    allocation_index: 0,
-    free_partitions: 0,
-    evacuating: false,
-    reclaimed: 0,
-    bitmap_allocation_pointer: 0,
-    gc_running: false,
-    precomputed_heap_size: 0,
-};
-
 impl PartitionedHeap {
     pub unsafe fn new<M: Memory>(mem: &mut M, heap_base: usize) -> PartitionedHeap {
-        println!(
-            100,
-            "INITIALIZE PARTITIONED HEAP {}",
-            size_of::<PartitionedHeap>().to_bytes().as_usize()
-        );
         let allocation_index = heap_base / PARTITION_SIZE;
         mem.grow_memory(((allocation_index + 1) * PARTITION_SIZE) as u64);
         let partitions = from_fn(|index| Partition {
diff --git a/rts/motoko-rts/src/gc/mark_compact.rs b/rts/motoko-rts/src/gc/mark_compact.rs
index 09d2f61f75a..685e80c63cc 100644
--- a/rts/motoko-rts/src/gc/mark_compact.rs
+++ b/rts/motoko-rts/src/gc/mark_compact.rs
@@ -11,7 +11,6 @@ use mark_stack::{alloc_mark_stack, free_mark_stack, pop_mark_stack, push_mark_st
 use crate::constants::WORD_SIZE;
 use crate::mem_utils::memcpy_words;
 use crate::memory::Memory;
-use crate::persistence::HEAP_START;
 use crate::types::*;
 use crate::visitor::{pointer_to_dynamic_heap, visit_pointer_fields};
 
@@ -19,7 +18,9 @@ use motoko_rts_macros::ic_mem_fn;
 
 #[no_mangle]
 #[cfg(feature = "ic")]
+#[allow(unreachable_code)]
 pub unsafe extern "C" fn initialize_compacting_gc() {
+    panic!("Compacting GC is not supported with the persistent heap");
     crate::memory::ic::linear_memory::initialize();
 }
 
@@ -41,7 +42,7 @@ unsafe fn schedule_compacting_gc<M: Memory>(mem: &mut M) {
 
 #[ic_mem_fn(ic_only)]
 unsafe fn compacting_gc<M: Memory>(mem: &mut M) {
-    use crate::memory::ic::{self, linear_memory};
+    use crate::memory::ic::{self, linear_memory, HEAP_START};
 
     compacting_gc_internal(
         mem,
diff --git a/rts/motoko-rts/src/lib.rs b/rts/motoko-rts/src/lib.rs
index 58dabc776c2..2a2adf34d79 100644
--- a/rts/motoko-rts/src/lib.rs
+++ b/rts/motoko-rts/src/lib.rs
@@ -31,6 +31,7 @@ mod idl;
 pub mod leb128;
 mod mem_utils;
 pub mod memory;
+#[incremental_gc]
 pub mod persistence;
 pub mod principal_id;
 mod static_checks;
diff --git a/rts/motoko-rts/src/memory/ic.rs b/rts/motoko-rts/src/memory/ic.rs
index 50e710ce96e..94915932553 100644
--- a/rts/motoko-rts/src/memory/ic.rs
+++ b/rts/motoko-rts/src/memory/ic.rs
@@ -12,6 +12,10 @@ use crate::types::{Bytes, Value};
 use core::arch::wasm32;
 use motoko_rts_macros::*;
 
+// TODO: Remove once the classical GCs have been removed.
+#[non_incremental_gc]
+pub const HEAP_START: usize = 4 * 1024 * 1024 + 128 * 1024;
+
 // Provided by generated code
 extern "C" {
     pub(crate) fn get_static_roots() -> Value;
diff --git a/rts/motoko-rts/src/memory/ic/linear_memory.rs b/rts/motoko-rts/src/memory/ic/linear_memory.rs
index 426aab494c3..af2ee92bc4b 100644
--- a/rts/motoko-rts/src/memory/ic/linear_memory.rs
+++ b/rts/motoko-rts/src/memory/ic/linear_memory.rs
@@ -1,7 +1,7 @@
 use core::arch::wasm32;
 
-use super::{IcMemory, Memory};
-use crate::{persistence::HEAP_START, types::*};
+use super::{IcMemory, Memory, HEAP_START};
+use crate::types::*;
 
 /// Amount of garbage collected so far.
 pub(crate) static mut RECLAIMED: Bytes<u64> = Bytes(0);
diff --git a/rts/motoko-rts/src/persistence.rs b/rts/motoko-rts/src/persistence.rs
index 174bc2aeec7..3ba0a40a5f9 100644
--- a/rts/motoko-rts/src/persistence.rs
+++ b/rts/motoko-rts/src/persistence.rs
@@ -6,7 +6,7 @@ use core::mem::size_of;
 
 use motoko_rts_macros::ic_mem_fn;
 
-use crate::{barriers::write_with_barrier, memory::Memory, types::Value};
+use crate::{barriers::write_with_barrier, gc::incremental::State, memory::Memory, types::Value};
 
 const FINGERPRINT: [char; 32] = [
     'M', 'O', 'T', 'O', 'K', 'O', ' ', 'O', 'R', 'T', 'H', 'O', 'G', 'O', 'N', 'A', 'L', ' ', 'P',
@@ -21,6 +21,7 @@ struct PersistentMetadata {
     fingerprint: [char; 32],
     version: usize,
     actor: Value, // Must be added to the root set, use forwarding
+    incremental_gc_state: State,
 }
 
 const METATDATA_ADDRESS: usize = 4 * 1024 * 1024;
@@ -62,16 +63,16 @@ impl PersistentMetadata {
     }
 }
 
-#[ic_mem_fn]
 pub unsafe fn initialize_memory<M: Memory>(mem: &mut M) {
     mem.grow_memory(HEAP_START as u64);
     let metadata = PersistentMetadata::get();
     if metadata.is_initialized() {
+        println!(100, "MEMORY REUSED");
         metadata.check_version();
     } else {
+        println!(100, "MEMORY INITIALIZED");
         metadata.initialize();
     }
-    println!(100, "MEMORY INITIALIZED {HEAP_START:#x}");
 }
 
 /// Returns scalar 0 if no actor is stored.
@@ -88,3 +89,8 @@ pub unsafe fn save_actor<M: Memory>(mem: &mut M, actor: Value) {
     let location = &mut (*metadata).actor as *mut Value;
     write_with_barrier(mem, location, actor);
 }
+
+pub(crate) unsafe fn get_incremenmtal_gc_state() -> &'static mut State {
+    let metadata = PersistentMetadata::get();
+    &mut (*metadata).incremental_gc_state
+}
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 9a0d973cd83..ad4253ce7cb 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -924,7 +924,6 @@ module RTS = struct
 
   (* The connection to the C and Rust parts of the RTS *)
   let system_imports env =
-    E.add_func_import env "rts" "initialize_memory" [] [];
     E.add_func_import env "rts" "load_actor" [] [I32Type];
     E.add_func_import env "rts" "save_actor" [I32Type] [];
     E.add_func_import env "rts" "memcpy" [I32Type; I32Type; I32Type] [I32Type]; (* standard libc memcpy *)
@@ -11078,7 +11077,6 @@ and compile_init_func mod_env ((cu, flavor) : Ir.prog) =
   | ProgU ds ->
     Func.define_built_in mod_env "init" [] [] (fun env ->
       let _ae, codeW = compile_decs env VarEnv.empty_ae ds Freevars.S.empty in
-      E.call_import mod_env "rts" "initialize_memory" ^^
       codeW G.nop
     )
   | ActorU (as_opt, ds, fs, up, _t) ->
@@ -11172,9 +11170,6 @@ and main_actor as_opt mod_env ds fs up =
     env.E.service := metadata "candid:service" up.meta.candid.service;
     env.E.args := metadata "candid:args" up.meta.candid.args;
 
-    (* Initialize persistent memory *)
-    E.call_import mod_env "rts" "initialize_memory" ^^
-
     (* Deserialize any arguments *)
     begin match as_opt with
       | None

From 2103e65b8734849a364ead632fbf2a908320a623 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 10 Aug 2023 15:30:54 +0200
Subject: [PATCH 006/260] Place static roots in the dynamic heap

---
 rts/motoko-rts/src/gc/copying.rs              |   2 +-
 rts/motoko-rts/src/gc/generational.rs         |   2 +-
 rts/motoko-rts/src/gc/incremental.rs          |   2 +-
 rts/motoko-rts/src/gc/incremental/roots.rs    |   7 +-
 rts/motoko-rts/src/gc/mark_compact.rs         |   2 +-
 rts/motoko-rts/src/memory/ic.rs               |   7 +-
 rts/motoko-rts/src/memory/ic/linear_memory.rs |   4 +
 rts/motoko-rts/src/persistence.rs             |  36 +++--
 src/codegen/compile.ml                        | 123 +++++++++---------
 9 files changed, 102 insertions(+), 83 deletions(-)

diff --git a/rts/motoko-rts/src/gc/copying.rs b/rts/motoko-rts/src/gc/copying.rs
index 0e306c3c3ed..8a2376a54a9 100644
--- a/rts/motoko-rts/src/gc/copying.rs
+++ b/rts/motoko-rts/src/gc/copying.rs
@@ -36,7 +36,7 @@ unsafe fn copying_gc<M: Memory>(mem: &mut M) {
         || linear_memory::get_hp_unskewed(),
         // set_hp
         |hp| linear_memory::set_hp_unskewed(hp),
-        ic::get_static_roots(),
+        ic::linear_memory::get_static_roots(),
         crate::continuation_table::continuation_table_loc(),
         // note_live_size
         |live_size| ic::MAX_LIVE = ::core::cmp::max(ic::MAX_LIVE, live_size),
diff --git a/rts/motoko-rts/src/gc/generational.rs b/rts/motoko-rts/src/gc/generational.rs
index ca740fde297..b9083ac2872 100644
--- a/rts/motoko-rts/src/gc/generational.rs
+++ b/rts/motoko-rts/src/gc/generational.rs
@@ -49,7 +49,7 @@ unsafe fn generational_gc<M: Memory>(mem: &mut M) {
 
     let old_limits = get_limits();
     let roots = Roots {
-        static_roots: ic::get_static_roots(),
+        static_roots: ic::linear_memory::get_static_roots(),
         continuation_table_ptr_loc: crate::continuation_table::continuation_table_loc(),
     };
     let heap = Heap {
diff --git a/rts/motoko-rts/src/gc/incremental.rs b/rts/motoko-rts/src/gc/incremental.rs
index 6435c9d35fa..2a016d4aec3 100644
--- a/rts/motoko-rts/src/gc/incremental.rs
+++ b/rts/motoko-rts/src/gc/incremental.rs
@@ -11,7 +11,7 @@ use motoko_rts_macros::ic_mem_fn;
 
 use crate::{
     memory::Memory,
-    persistence::{get_incremenmtal_gc_state, HEAP_START, initialize_memory},
+    persistence::{get_incremenmtal_gc_state, initialize_memory, HEAP_START},
     types::*,
     visitor::visit_pointer_fields,
 };
diff --git a/rts/motoko-rts/src/gc/incremental/roots.rs b/rts/motoko-rts/src/gc/incremental/roots.rs
index b33be52ef3c..d1477b98bcc 100644
--- a/rts/motoko-rts/src/gc/incremental/roots.rs
+++ b/rts/motoko-rts/src/gc/incremental/roots.rs
@@ -10,10 +10,11 @@ pub struct Roots {
 
 #[cfg(feature = "ic")]
 pub unsafe fn root_set() -> Roots {
-    use crate::memory::ic;
+    use crate::continuation_table::continuation_table_loc;
+    use crate::persistence::get_static_root;
     Roots {
-        static_roots: ic::get_static_roots(),
-        continuation_table_location: crate::continuation_table::continuation_table_loc(),
+        static_roots: get_static_root(),
+        continuation_table_location: continuation_table_loc(),
     }
 }
 
diff --git a/rts/motoko-rts/src/gc/mark_compact.rs b/rts/motoko-rts/src/gc/mark_compact.rs
index 685e80c63cc..c6716cfc2cf 100644
--- a/rts/motoko-rts/src/gc/mark_compact.rs
+++ b/rts/motoko-rts/src/gc/mark_compact.rs
@@ -51,7 +51,7 @@ unsafe fn compacting_gc<M: Memory>(mem: &mut M) {
         || linear_memory::get_hp_unskewed(),
         // set_hp
         |hp| linear_memory::set_hp_unskewed(hp),
-        ic::get_static_roots(),
+        ic::linear_memory::get_static_roots(),
         crate::continuation_table::continuation_table_loc(),
         // note_live_size
         |live_size| ic::MAX_LIVE = ::core::cmp::max(ic::MAX_LIVE, live_size),
diff --git a/rts/motoko-rts/src/memory/ic.rs b/rts/motoko-rts/src/memory/ic.rs
index 94915932553..1fe07f0ef7a 100644
--- a/rts/motoko-rts/src/memory/ic.rs
+++ b/rts/motoko-rts/src/memory/ic.rs
@@ -8,7 +8,7 @@ pub mod partitioned_memory;
 use super::Memory;
 use crate::constants::WASM_PAGE_SIZE;
 use crate::rts_trap_with;
-use crate::types::{Bytes, Value};
+use crate::types::Bytes;
 use core::arch::wasm32;
 use motoko_rts_macros::*;
 
@@ -16,11 +16,6 @@ use motoko_rts_macros::*;
 #[non_incremental_gc]
 pub const HEAP_START: usize = 4 * 1024 * 1024 + 128 * 1024;
 
-// Provided by generated code
-extern "C" {
-    pub(crate) fn get_static_roots() -> Value;
-}
-
 /// Maximum live data retained in a GC.
 pub(crate) static mut MAX_LIVE: Bytes<u32> = Bytes(0);
 
diff --git a/rts/motoko-rts/src/memory/ic/linear_memory.rs b/rts/motoko-rts/src/memory/ic/linear_memory.rs
index af2ee92bc4b..18262afae7f 100644
--- a/rts/motoko-rts/src/memory/ic/linear_memory.rs
+++ b/rts/motoko-rts/src/memory/ic/linear_memory.rs
@@ -12,6 +12,10 @@ extern "C" {
     fn getHP() -> u32;
 }
 
+pub(crate) fn get_static_roots() -> Value {
+    unimplemented!()
+}
+
 pub(crate) unsafe fn set_hp_unskewed(new_hp: usize) {
     setHP(skew(new_hp))
 }
diff --git a/rts/motoko-rts/src/persistence.rs b/rts/motoko-rts/src/persistence.rs
index 3ba0a40a5f9..e502bc4eddb 100644
--- a/rts/motoko-rts/src/persistence.rs
+++ b/rts/motoko-rts/src/persistence.rs
@@ -13,15 +13,16 @@ const FINGERPRINT: [char; 32] = [
     'E', 'R', 'S', 'I', 'S', 'T', 'E', 'N', 'C', 'E', ' ', '3', '2',
 ];
 const VERSION: usize = 1;
-const NO_ACTOR: Value = Value::from_scalar(0);
+const NO_OBJECT: Value = Value::from_scalar(0);
 
 // Use a long-term representation by relying on C layout.
 #[repr(C)]
 struct PersistentMetadata {
     fingerprint: [char; 32],
     version: usize,
-    actor: Value, // Must be added to the root set, use forwarding
+    stable_actor: Value, // Must be added to the root set, use forwarding
     incremental_gc_state: State,
+    static_root: Value,
 }
 
 const METATDATA_ADDRESS: usize = 4 * 1024 * 1024;
@@ -41,7 +42,9 @@ impl PersistentMetadata {
     unsafe fn is_initialized(self: *mut Self) -> bool {
         // Wasm memory is zero-initialized according to the Wasm specification.
         let initialized = (*self).version != 0;
-        assert!(initialized || (*self).fingerprint == ['\0'; 32] && (*self).actor == NO_ACTOR);
+        assert!(
+            initialized || (*self).fingerprint == ['\0'; 32] && (*self).stable_actor == NO_OBJECT
+        );
         initialized
     }
 
@@ -59,7 +62,8 @@ impl PersistentMetadata {
         debug_assert!(!self.is_initialized());
         (*self).fingerprint = FINGERPRINT;
         (*self).version = VERSION;
-        (*self).actor = NO_ACTOR;
+        (*self).stable_actor = NO_OBJECT;
+        (*self).static_root = NO_OBJECT;
     }
 }
 
@@ -77,16 +81,16 @@ pub unsafe fn initialize_memory<M: Memory>(mem: &mut M) {
 
 /// Returns scalar 0 if no actor is stored.
 #[no_mangle]
-pub unsafe extern "C" fn load_actor() -> Value {
+pub unsafe extern "C" fn load_stable_actor() -> Value {
     let metadata = PersistentMetadata::get();
-    (*metadata).actor.forward_if_possible()
+    (*metadata).stable_actor.forward_if_possible()
 }
 
 #[ic_mem_fn]
-pub unsafe fn save_actor<M: Memory>(mem: &mut M, actor: Value) {
-    assert!(actor != NO_ACTOR);
+pub unsafe fn save_stable_actor<M: Memory>(mem: &mut M, actor: Value) {
+    assert!(actor != NO_OBJECT);
     let metadata = PersistentMetadata::get();
-    let location = &mut (*metadata).actor as *mut Value;
+    let location = &mut (*metadata).stable_actor as *mut Value;
     write_with_barrier(mem, location, actor);
 }
 
@@ -94,3 +98,17 @@ pub(crate) unsafe fn get_incremenmtal_gc_state() -> &'static mut State {
     let metadata = PersistentMetadata::get();
     &mut (*metadata).incremental_gc_state
 }
+
+#[ic_mem_fn]
+pub unsafe fn set_static_root<M: Memory>(mem: &mut M, value: Value) {
+    let metadata = PersistentMetadata::get();
+    let location = &mut (*metadata).static_root as *mut Value;
+    write_with_barrier(mem, location, value);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn get_static_root() -> Value {
+    let metadata = PersistentMetadata::get();
+    assert!((*metadata).static_root != NO_OBJECT);
+    (*metadata).static_root
+}
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index ad4253ce7cb..b50a215c7a7 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -301,8 +301,9 @@ module E = struct
     static_memory : (int32 * string) list ref; (* Content of static memory *)
     static_memory_frozen : bool ref;
       (* Sanity check: Nothing should bump end_of_static_memory once it has been read *)
-    static_roots : int32 list ref;
-      (* GC roots in static memory. (Everything that may be mutable.) *)
+    static_variables : int32 ref;
+      (* Number of static variables (MutBox), accessed by index via the runtime system,
+         and belonging to the GC root set. *)
 
     (* Types accumulated in global typtbl (for candid subtype checks)
        See Note [Candid subtype checks]
@@ -348,7 +349,7 @@ module E = struct
     end_of_static_memory = ref dyn_mem;
     static_memory = ref [];
     static_memory_frozen = ref false;
-    static_roots = ref [];
+    static_variables = ref 0l;
     typtbl_typs = ref [];
     (* Metadata *)
     args = ref None;
@@ -592,11 +593,13 @@ module E = struct
     env.static_memory_frozen := true;
     !(env.end_of_static_memory)
 
-  let add_static_root (env : t) ptr =
-    env.static_roots := ptr :: !(env.static_roots)
+  let add_static_variable (env : t) : int32 =
+    let index = !(env.static_variables) in
+    env.static_variables := Int32.add index 1l;
+    index
 
-  let get_static_roots (env : t) =
-    !(env.static_roots)
+  let count_static_variables (env : t) =
+    !(env.static_variables)
 
   let get_static_memory env =
     !(env.static_memory)
@@ -924,8 +927,10 @@ module RTS = struct
 
   (* The connection to the C and Rust parts of the RTS *)
   let system_imports env =
-    E.add_func_import env "rts" "load_actor" [] [I32Type];
-    E.add_func_import env "rts" "save_actor" [I32Type] [];
+    E.add_func_import env "rts" "load_stable_actor" [] [I32Type];
+    E.add_func_import env "rts" "save_stable_actor" [I32Type] [];
+    E.add_func_import env "rts" "set_static_root" [I32Type] [];
+    E.add_func_import env "rts" "get_static_root" [] [I32Type];
     E.add_func_import env "rts" "memcpy" [I32Type; I32Type; I32Type] [I32Type]; (* standard libc memcpy *)
     E.add_func_import env "rts" "memcmp" [I32Type; I32Type; I32Type] [I32Type];
     E.add_func_import env "rts" "version" [] [I32Type];
@@ -1891,13 +1896,6 @@ module MutBox = struct
   let alloc env =
     Tagged.obj env Tagged.MutBox [ compile_unboxed_zero ]
 
-  let static env =
-    let ptr = Tagged.new_static_obj env Tagged.MutBox StaticBytes.[
-      I32 0l; (* zero *)
-    ] in
-    E.add_static_root env ptr;
-    ptr
-
   let load_field env =
     Tagged.load_forwarding_pointer env ^^
     Tagged.load_field env (field env)
@@ -7182,9 +7180,9 @@ end
 *)
 
 module Stabilization = struct
-  let load_actor env = E.call_import env "rts" "load_actor"
+  let load_stable_actor env = E.call_import env "rts" "load_stable_actor"
     
-  let save_actor env = E.call_import env "rts" "save_actor"
+  let save_stable_actor env = E.call_import env "rts" "save_stable_actor"
     
   let empty_actor env t =
     let (_, fs) = Type.as_obj t in
@@ -7195,14 +7193,14 @@ module Stabilization = struct
     Object.lit_raw env fs'
 
   let stabilize env t =
-    save_actor env
+    save_stable_actor env
 
   let destabilize env t =
-    load_actor env ^^
+    load_stable_actor env ^^
     G.i (Test (Wasm.Values.I32 I32Op.Eqz)) ^^
     G.if1 I32Type
       (empty_actor env t)
-      (load_actor env)
+      (load_stable_actor env)
 end
 
 (*
@@ -7519,20 +7517,20 @@ end
 *)
 
 module GCRoots = struct
-  let register env static_roots =
-
-    let get_static_roots = E.add_fun env "get_static_roots" (Func.of_body env [] [I32Type] (fun env ->
-      compile_unboxed_const static_roots
-    )) in
-
-    E.add_export env (nr {
-      name = Lib.Utf8.decode "get_static_roots";
-      edesc = nr (FuncExport (nr get_static_roots))
-    })
+  let create_root_array env = Func.share_code0 env "create_root_array" [I32Type] (fun env ->
+    let length = Int32.to_int (E.count_static_variables env) in
+    let variables = Lib.List.table length (fun _ -> MutBox.alloc env) in
+    Arr.lit env variables
+  )
 
-  let store_static_roots env =
-    Arr.vanilla_lit env (E.get_static_roots env)
+  let register_static_variables env =
+    create_root_array env ^^
+    E.call_import env "rts" "set_static_root"
 
+  let get_static_variable env index = 
+    E.call_import env "rts" "get_static_root" ^^
+    compile_unboxed_const index ^^
+    Arr.idx env
 end (* GCRoots *)
 
 module StackRep = struct
@@ -7700,9 +7698,9 @@ module VarEnv = struct
     (* A Wasm Local of the current function, that points to memory location,
        which is a MutBox.  Used for mutable captured data *)
     | HeapInd of int32
-    (* A static mutable memory location (static address of a MutBox object) *)
-    (* TODO: Do we need static immutable? *)
-    | HeapStatic of int32
+    (* A static variable accessed by an index via the runtime system, refers to a MutBox,
+       belonging to the GC root set *)
+    | Static of int32
     (* Not materialized (yet), statically known constant, static location on demand *)
     | Const of Const.t
     (* public method *)
@@ -7711,7 +7709,7 @@ module VarEnv = struct
   let is_non_local : varloc -> bool = function
     | Local _
     | HeapInd _ -> false
-    | HeapStatic _
+    | Static _
     | PublicMethod _
     | Const _ -> true
 
@@ -7771,8 +7769,8 @@ module VarEnv = struct
       E.add_local_name env i name;
       ({ ae with vars = NameEnv.add name ((HeapInd i), typ) ae.vars }, i)
 
-  let add_local_heap_static (ae : t) name ptr typ =
-      { ae with vars = NameEnv.add name ((HeapStatic ptr), typ) ae.vars }
+  let add_static_variable (ae : t) name index typ =
+      { ae with vars = NameEnv.add name ((Static index), typ) ae.vars }
 
   let add_local_public_method (ae : t) name (fi, exported_name) typ =
       { ae with vars = NameEnv.add name ((PublicMethod (fi, exported_name) : varloc), typ) ae.vars }
@@ -7797,9 +7795,9 @@ module VarEnv = struct
         E.add_local_name env i name;
         let ae' = { ae with vars = NameEnv.add name ((Local (SR.Vanilla, i)), typ) ae.vars } in
         add_arguments env ae' as_local remainder
-      else (* needs to go to static memory *)
-        let ptr = MutBox.static env in
-        let ae' = add_local_heap_static ae name ptr typ in
+      else
+        let index = E.add_static_variable env in
+        let ae' = add_static_variable ae name index typ in
         add_arguments env ae' as_local remainder
 
   let add_argument_locals env (ae : t) =
@@ -7866,24 +7864,27 @@ module Var = struct
       G.i (LocalGet (nr i)),
       SR.Vanilla,
       MutBox.store_field env
-    | (Some ((HeapStatic ptr), typ), Flags.Generational) when potential_pointer typ ->
-      compile_unboxed_const ptr,
+    | (Some ((Static index), typ), Flags.Generational) when potential_pointer typ ->
+      let (set_static_variable, get_static_variable) = new_local env "static_variable" in
+      GCRoots.get_static_variable env index ^^
+      Tagged.load_forwarding_pointer env ^^ (* not needed for this GC, but only for forward pointer sanity checks *)
+      set_static_variable ^^
+      get_static_variable,
       SR.Vanilla,
       MutBox.store_field env ^^
-      compile_unboxed_const ptr ^^
-      Tagged.load_forwarding_pointer env ^^ (* not needed for this GC, but only for forward pointer sanity checks *)
+      get_static_variable ^^
       compile_add_const ptr_unskew ^^
       compile_add_const (Int32.mul (MutBox.field env) Heap.word_size) ^^
       E.call_import env "rts" "post_write_barrier"
-    | (Some ((HeapStatic ptr), typ), Flags.Incremental) when potential_pointer typ ->
-      compile_unboxed_const ptr ^^
+    | (Some ((Static index), typ), Flags.Incremental) when potential_pointer typ ->
+      GCRoots.get_static_variable env index ^^
       Tagged.load_forwarding_pointer env ^^
       compile_add_const ptr_unskew ^^
       compile_add_const (Int32.mul (MutBox.field env) Heap.word_size),
       SR.Vanilla,
       Tagged.write_with_barrier env
-    | (Some ((HeapStatic ptr), typ), _) ->
-      compile_unboxed_const ptr,
+    | (Some ((Static index), typ), _) ->
+      GCRoots.get_static_variable env index,
       SR.Vanilla,
       MutBox.store_field env
     | (Some ((Const _), _), _) -> fatal "set_val: %s is const" var
@@ -7914,8 +7915,10 @@ module Var = struct
       sr, G.i (LocalGet (nr i))
     | Some (HeapInd i) ->
       SR.Vanilla, G.i (LocalGet (nr i)) ^^ MutBox.load_field env
-    | Some (HeapStatic i) ->
-      SR.Vanilla, compile_unboxed_const i ^^ MutBox.load_field env
+    | Some (Static index) ->
+      SR.Vanilla, 
+      GCRoots.get_static_variable env index ^^
+      MutBox.load_field env
     | Some (Const c) ->
       SR.Const c, G.nop
     | Some (PublicMethod (_, name)) ->
@@ -7956,12 +7959,12 @@ module Var = struct
      In the IR, mutable fields of objects are pre-allocated as MutBox objects,
      to allow the async/await.
      So we expect the variable to be in a HeapInd (pointer to MutBox on the heap),
-     or HeapStatic (statically known MutBox in the static memory) and we use
-     the pointer.
+     or Static (static variable represented as a MutBox that is accessed via the 
+     runtime system) and we use the pointer.
   *)
   let get_aliased_box env ae var = match VarEnv.lookup_var ae var with
     | Some (HeapInd i) -> G.i (LocalGet (nr i))
-    | Some (HeapStatic i) -> compile_unboxed_const i
+    | Some (Static index) -> GCRoots.get_static_variable env index
     | _ -> assert false
 
   let capture_aliased_box env ae var = match VarEnv.lookup_var ae var with
@@ -8633,7 +8636,7 @@ module AllocHow = struct
   let how_of_ae ae : allocHow =
     M.map (fun (l, _) -> match l with
     | VarEnv.Const _        -> (Const : how)
-    | VarEnv.HeapStatic _   -> StoreStatic
+    | VarEnv.Static _       -> StoreStatic
     | VarEnv.HeapInd _      -> StoreHeap
     | VarEnv.Local (sr, _)  -> LocalMut sr (* conservatively assume mutable *)
     | VarEnv.PublicMethod _ -> LocalMut SR.Vanilla
@@ -8667,8 +8670,8 @@ module AllocHow = struct
       let alloc_code = MutBox.alloc env ^^ G.i (LocalSet (nr i)) in
       (ae1, alloc_code)
     | StoreStatic ->
-      let ptr = MutBox.static env in
-      let ae1 = VarEnv.add_local_heap_static ae name ptr typ in
+      let index = E.add_static_variable env in
+      let ae1 = VarEnv.add_static_variable ae name index typ in
       (ae1, G.nop)
 
   let add_local_for_alias env ae how name typ : VarEnv.t * G.t =
@@ -11209,8 +11212,6 @@ and conclude_module env set_serialization_globals start_fi_o =
   (* See Note [Candid subtype checks] *)
   Serialization.set_delayed_globals env set_serialization_globals;
 
-  let static_roots = GCRoots.store_static_roots env in
-
   (* declare before building GC *)
 
   (* add beginning-of-heap pointer, may be changed by linker *)
@@ -11219,7 +11220,6 @@ and conclude_module env set_serialization_globals start_fi_o =
   E.export_global env "__heap_base";
 
   Heap.register env;
-  GCRoots.register env static_roots;
   IC.register env;
 
   set_heap_base (E.get_end_of_static_memory env);
@@ -11227,6 +11227,7 @@ and conclude_module env set_serialization_globals start_fi_o =
   (* Wrap the start function with the RTS initialization *)
   let rts_start_fi = E.add_fun env "rts_start" (Func.of_body env [] [] (fun env1 ->
     E.call_import env "rts" ("initialize_" ^ E.gc_strategy_name !Flags.gc_strategy ^ "_gc") ^^
+    GCRoots.register_static_variables env ^^
     match start_fi_o with
     | Some fi ->
       G.i (Call fi)

From 801eeb6288e0102ef6e63169c514af0776dc17df Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 10 Aug 2023 18:14:24 +0200
Subject: [PATCH 007/260] Reorganize static root

---
 rts/motoko-rts/src/gc/incremental/roots.rs | 79 ++++++++++------------
 rts/motoko-rts/src/persistence.rs          | 15 +---
 2 files changed, 37 insertions(+), 57 deletions(-)

diff --git a/rts/motoko-rts/src/gc/incremental/roots.rs b/rts/motoko-rts/src/gc/incremental/roots.rs
index d1477b98bcc..5e196d15c8a 100644
--- a/rts/motoko-rts/src/gc/incremental/roots.rs
+++ b/rts/motoko-rts/src/gc/incremental/roots.rs
@@ -1,21 +1,25 @@
-use crate::{types::Value, visitor::pointer_to_dynamic_heap};
+use motoko_rts_macros::ic_mem_fn;
+
+use crate::{memory::Memory, types::Value, visitor::pointer_to_dynamic_heap};
+
+use super::barriers::write_with_barrier;
+
+/// Root referring to all canister variables.
+/// This root is reinitialized on each canister upgrade.
+/// The scalar sentinel denotes an uninitialized root.
+static mut STATIC_ROOT: Value = Value::from_scalar(0);
 
 /// GC root set.
-#[derive(Clone, Copy)]
-pub struct Roots {
-    pub static_roots: Value,
-    pub continuation_table_location: *mut Value,
-    // If new roots are added in future, extend `visit_roots()`.
-}
+pub type Roots = [*mut Value; 3];
 
 #[cfg(feature = "ic")]
 pub unsafe fn root_set() -> Roots {
-    use crate::continuation_table::continuation_table_loc;
-    use crate::persistence::get_static_root;
-    Roots {
-        static_roots: get_static_root(),
-        continuation_table_location: continuation_table_loc(),
-    }
+    use crate::{continuation_table::continuation_table_loc, persistence::stable_actor_location};
+    [
+        static_root_location(),
+        continuation_table_loc(),
+        stable_actor_location(),
+    ]
 }
 
 pub unsafe fn visit_roots<C, V: Fn(&mut C, *mut Value)>(
@@ -24,39 +28,26 @@ pub unsafe fn visit_roots<C, V: Fn(&mut C, *mut Value)>(
     context: &mut C,
     visit_field: V,
 ) {
-    visit_static_roots(roots.static_roots, heap_base, context, &visit_field);
-    visit_continuation_table(
-        roots.continuation_table_location,
-        heap_base,
-        context,
-        &visit_field,
-    );
-}
-
-unsafe fn visit_static_roots<C, V: Fn(&mut C, *mut Value)>(
-    static_roots: Value,
-    heap_base: usize,
-    context: &mut C,
-    visit_field: &V,
-) {
-    let root_array = static_roots.as_array();
-    for index in 0..root_array.len() {
-        let mutbox = root_array.get(index).as_mutbox();
-        debug_assert!((mutbox as usize) < heap_base);
-        let field = &mut (*mutbox).field;
-        if pointer_to_dynamic_heap(field, heap_base) {
-            visit_field(context, field);
+    for location in roots {
+        // TODO: Check whether all pointers lead to dynamic heap, no static heap
+        if pointer_to_dynamic_heap(location, heap_base) {
+            visit_field(context, location);
         }
     }
 }
 
-unsafe fn visit_continuation_table<C, V: Fn(&mut C, *mut Value)>(
-    continuation_table_location: *mut Value,
-    heap_base: usize,
-    context: &mut C,
-    visit_field: &V,
-) {
-    if pointer_to_dynamic_heap(continuation_table_location, heap_base) {
-        visit_field(context, continuation_table_location);
-    }
+unsafe fn static_root_location() -> *mut Value {
+    &mut STATIC_ROOT as *mut Value
+}
+
+#[ic_mem_fn]
+pub unsafe fn set_static_root<M: Memory>(mem: &mut M, value: Value) {
+    let location = &mut STATIC_ROOT as *mut Value;
+    write_with_barrier(mem, location, value);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn get_static_root() -> Value {
+    assert!(STATIC_ROOT.is_ptr());
+    STATIC_ROOT
 }
diff --git a/rts/motoko-rts/src/persistence.rs b/rts/motoko-rts/src/persistence.rs
index e502bc4eddb..a57f342b94a 100644
--- a/rts/motoko-rts/src/persistence.rs
+++ b/rts/motoko-rts/src/persistence.rs
@@ -22,7 +22,6 @@ struct PersistentMetadata {
     version: usize,
     stable_actor: Value, // Must be added to the root set, use forwarding
     incremental_gc_state: State,
-    static_root: Value,
 }
 
 const METATDATA_ADDRESS: usize = 4 * 1024 * 1024;
@@ -63,7 +62,6 @@ impl PersistentMetadata {
         (*self).fingerprint = FINGERPRINT;
         (*self).version = VERSION;
         (*self).stable_actor = NO_OBJECT;
-        (*self).static_root = NO_OBJECT;
     }
 }
 
@@ -99,16 +97,7 @@ pub(crate) unsafe fn get_incremenmtal_gc_state() -> &'static mut State {
     &mut (*metadata).incremental_gc_state
 }
 
-#[ic_mem_fn]
-pub unsafe fn set_static_root<M: Memory>(mem: &mut M, value: Value) {
-    let metadata = PersistentMetadata::get();
-    let location = &mut (*metadata).static_root as *mut Value;
-    write_with_barrier(mem, location, value);
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn get_static_root() -> Value {
+pub(crate) unsafe fn stable_actor_location() -> *mut Value {
     let metadata = PersistentMetadata::get();
-    assert!((*metadata).static_root != NO_OBJECT);
-    (*metadata).static_root
+    &mut (*metadata).stable_actor as *mut Value
 }

From bc7e8e152fb337be41dc03b56a0009199427a485 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 11 Aug 2023 11:23:53 +0200
Subject: [PATCH 008/260] Place static optional values in the heap

---
 rts/motoko-rts/src/gc/incremental/roots.rs |  8 +-
 rts/motoko-rts/src/persistence.rs          | 85 +++++++++++++++++-----
 src/codegen/compile.ml                     | 52 +++++--------
 3 files changed, 91 insertions(+), 54 deletions(-)

diff --git a/rts/motoko-rts/src/gc/incremental/roots.rs b/rts/motoko-rts/src/gc/incremental/roots.rs
index 5e196d15c8a..d1fd77f7a51 100644
--- a/rts/motoko-rts/src/gc/incremental/roots.rs
+++ b/rts/motoko-rts/src/gc/incremental/roots.rs
@@ -10,15 +10,19 @@ use super::barriers::write_with_barrier;
 static mut STATIC_ROOT: Value = Value::from_scalar(0);
 
 /// GC root set.
-pub type Roots = [*mut Value; 3];
+pub type Roots = [*mut Value; 4];
 
 #[cfg(feature = "ic")]
 pub unsafe fn root_set() -> Roots {
-    use crate::{continuation_table::continuation_table_loc, persistence::stable_actor_location};
+    use crate::{
+        continuation_table::continuation_table_loc,
+        persistence::{null_singleton_location, stable_actor_location},
+    };
     [
         static_root_location(),
         continuation_table_loc(),
         stable_actor_location(),
+        null_singleton_location(),
     ]
 }
 
diff --git a/rts/motoko-rts/src/persistence.rs b/rts/motoko-rts/src/persistence.rs
index a57f342b94a..cebd977d7a4 100644
--- a/rts/motoko-rts/src/persistence.rs
+++ b/rts/motoko-rts/src/persistence.rs
@@ -2,25 +2,40 @@
 //!
 //! Persistent metadata table, located at 4MB, in the static partition space.
 
-use core::mem::size_of;
-
 use motoko_rts_macros::ic_mem_fn;
 
-use crate::{barriers::write_with_barrier, gc::incremental::State, memory::Memory, types::Value};
+use crate::{
+    barriers::{allocation_barrier, write_with_barrier},
+    gc::incremental::State,
+    memory::Memory,
+    types::{size_of, Null, Value, TAG_NULL},
+};
 
 const FINGERPRINT: [char; 32] = [
     'M', 'O', 'T', 'O', 'K', 'O', ' ', 'O', 'R', 'T', 'H', 'O', 'G', 'O', 'N', 'A', 'L', ' ', 'P',
     'E', 'R', 'S', 'I', 'S', 'T', 'E', 'N', 'C', 'E', ' ', '3', '2',
 ];
 const VERSION: usize = 1;
-const NO_OBJECT: Value = Value::from_scalar(0);
+// The `Value` representation in the default-initialized Wasm memory.
+// The GC ignores this value since it is a scalar representation.
+const DEFAULT_VALUE: Value = Value::from_scalar(0);
 
 // Use a long-term representation by relying on C layout.
+// The `Value` references belong to the GC root set and require forwarding pointer resolution.
 #[repr(C)]
 struct PersistentMetadata {
+    // Predefined character sequence in the memory to double check the orthogonal persistence mode.
     fingerprint: [char; 32],
+    // Version of the orthogonal persistence. To be increased on every persistent memory layout modification.
     version: usize,
-    stable_actor: Value, // Must be added to the root set, use forwarding
+    // Reference to the stable sub-record of the actor, comprising all stable actor fields. Set before upgrade.
+    // Constitutes a GC root and requires pointer forwarding.
+    stable_actor: Value,
+    // Singleton of the top-level null value. To be retained across upgrades.
+    // Constitutes a GC root and requires pointer forwarding.
+    null_singleton: Value,
+    // The state of the incremental GC including the partitioned heap description.
+    // The GC continues work after upgrades.
     incremental_gc_state: State,
 }
 
@@ -31,7 +46,7 @@ const METADATA_RESERVE: usize = 128 * 1024;
 #[cfg(feature = "ic")]
 pub const HEAP_START: usize = METATDATA_ADDRESS + METADATA_RESERVE;
 
-const _: () = assert!(size_of::<PersistentMetadata>() <= METADATA_RESERVE);
+const _: () = assert!(core::mem::size_of::<PersistentMetadata>() <= METADATA_RESERVE);
 
 impl PersistentMetadata {
     fn get() -> *mut Self {
@@ -42,7 +57,10 @@ impl PersistentMetadata {
         // Wasm memory is zero-initialized according to the Wasm specification.
         let initialized = (*self).version != 0;
         assert!(
-            initialized || (*self).fingerprint == ['\0'; 32] && (*self).stable_actor == NO_OBJECT
+            initialized
+                || (*self).fingerprint == ['\0'; 32]
+                    && (*self).stable_actor == DEFAULT_VALUE
+                    && (*self).null_singleton == DEFAULT_VALUE
         );
         initialized
     }
@@ -57,47 +75,78 @@ impl PersistentMetadata {
         }
     }
 
-    unsafe fn initialize(self: *mut Self) {
+    unsafe fn initialize<M: Memory>(self: *mut Self, mem: &mut M) {
         debug_assert!(!self.is_initialized());
         (*self).fingerprint = FINGERPRINT;
         (*self).version = VERSION;
-        (*self).stable_actor = NO_OBJECT;
+        (*self).stable_actor = DEFAULT_VALUE;
+        (*self).null_singleton = alloc_null(mem);
     }
 }
 
+/// Initialize fresh peristent memory after the canister installation or
+/// reuse the persistent memory on a canister upgrade.
 pub unsafe fn initialize_memory<M: Memory>(mem: &mut M) {
     mem.grow_memory(HEAP_START as u64);
     let metadata = PersistentMetadata::get();
     if metadata.is_initialized() {
-        println!(100, "MEMORY REUSED");
         metadata.check_version();
     } else {
-        println!(100, "MEMORY INITIALIZED");
-        metadata.initialize();
+        metadata.initialize(mem);
     }
 }
 
-/// Returns scalar 0 if no actor is stored.
+/// Returns the stable sub-record of the actor of the upgraded canister version.
+/// Returns scalar 0 if no actor is stored after on a fresh memory.
 #[no_mangle]
 pub unsafe extern "C" fn load_stable_actor() -> Value {
     let metadata = PersistentMetadata::get();
     (*metadata).stable_actor.forward_if_possible()
 }
 
+/// Save the stable sub-record, the stable variables, of a canister before an upgrade.
 #[ic_mem_fn]
 pub unsafe fn save_stable_actor<M: Memory>(mem: &mut M, actor: Value) {
-    assert!(actor != NO_OBJECT);
+    assert!(actor != DEFAULT_VALUE);
     let metadata = PersistentMetadata::get();
     let location = &mut (*metadata).stable_actor as *mut Value;
     write_with_barrier(mem, location, actor);
 }
 
-pub(crate) unsafe fn get_incremenmtal_gc_state() -> &'static mut State {
+// GC root pointer required for GC marking and updating.
+pub(crate) unsafe fn stable_actor_location() -> *mut Value {
     let metadata = PersistentMetadata::get();
-    &mut (*metadata).incremental_gc_state
+    &mut (*metadata).stable_actor as *mut Value
 }
 
-pub(crate) unsafe fn stable_actor_location() -> *mut Value {
+unsafe fn alloc_null<M: Memory>(mem: &mut M) -> Value {
+    let value = mem.alloc_words(size_of::<Null>());
+    let null = value.get_ptr() as *mut Null;
+    (*null).header.tag = TAG_NULL;
+    (*null).header.init_forward(value);
+    allocation_barrier(value);
+    value
+}
+
+/// Get the null singleton used for top-level optional types.
+/// Serves for optimized null checks by pointer comparison.
+/// The forwarding pointer of this object is already resolved.
+/// NOTE: The forwarding pointer of the other comparison argument needs
+/// to be resolved too.
+#[no_mangle]
+pub unsafe extern "C" fn null_singleton() -> Value {
     let metadata = PersistentMetadata::get();
-    &mut (*metadata).stable_actor as *mut Value
+    (*metadata).null_singleton.forward_if_possible()
+}
+
+// GC root pointer required for GC marking and updating.
+pub(crate) unsafe fn null_singleton_location() -> *mut Value {
+    let metadata = PersistentMetadata::get();
+    &mut (*metadata).null_singleton as *mut Value
+}
+
+// GC root pointer required for GC marking and updating.
+pub(crate) unsafe fn get_incremenmtal_gc_state() -> &'static mut State {
+    let metadata = PersistentMetadata::get();
+    &mut (*metadata).incremental_gc_state
 }
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index b50a215c7a7..c51738034d4 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -931,6 +931,7 @@ module RTS = struct
     E.add_func_import env "rts" "save_stable_actor" [I32Type] [];
     E.add_func_import env "rts" "set_static_root" [I32Type] [];
     E.add_func_import env "rts" "get_static_root" [] [I32Type];
+    E.add_func_import env "rts" "null_singleton" [] [I32Type];
     E.add_func_import env "rts" "memcpy" [I32Type; I32Type; I32Type] [I32Type]; (* standard libc memcpy *)
     E.add_func_import env "rts" "memcmp" [I32Type; I32Type; I32Type] [I32Type];
     E.add_func_import env "rts" "version" [] [I32Type];
@@ -1916,9 +1917,9 @@ module Opt = struct
        │ null │
        └──────┘
 
-       A special null value. It is fully static, and because it is unique, can
-       be recognized by pointer comparison (only the GC will care about the heap
-       tag).
+       A special null value. This is a singleton object stored in the persistent memory
+       and retained across all objects. This serves for efficient null checks by using 
+       pointer comparison (and applying pointer forwarding resolution beforehand).
 
 
     2. ┌──────┬─────────┐
@@ -1942,22 +1943,18 @@ module Opt = struct
 
   let some_payload_field = Tagged.header_size
 
-  (* This relies on the fact that add_static deduplicates *)
-  let null_vanilla_lit env : int32 =
-    Tagged.shared_static_obj env Tagged.Null []
-
   let null_lit env =
-    compile_unboxed_const (null_vanilla_lit env)
-
-  let vanilla_lit env ptr : int32 =
-    Tagged.shared_static_obj env Tagged.Some StaticBytes.[
-      I32 ptr
-    ]
+    E.call_import env "rts" "null_singleton" (* forwarding pointer already resolved *)
 
- let is_some env =
+  let is_some env =
+    (* resolve forwarding pointer on pointer equality check *)
+    Tagged.load_forwarding_pointer env ^^
     null_lit env ^^
     G.i (Compare (Wasm.Values.I32 I32Op.Ne))
 
+  let alloc_some env get_payload =
+    Tagged.obj env Tagged.Some [ get_payload ]
+
   let inject env e =
     e ^^
     Func.share_code1 env "opt_inject" ("x", I32Type) [I32Type] (fun env get_x ->
@@ -1968,13 +1965,8 @@ module Opt = struct
             ( get_x ) (* true literal, no wrapping *)
             ( get_x ^^ Tagged.branch_default env [I32Type]
               ( get_x ) (* default tag, no wrapping *)
-              [ Tagged.Null,
-                (* NB: even ?null does not require allocation: We use a static
-                  singleton for that: *)
-                compile_unboxed_const (vanilla_lit env (null_vanilla_lit env))
-              ; Tagged.Some,
-                Tagged.obj env Tagged.Some [get_x]
-              ]
+              [ Tagged.Null, alloc_some env get_x
+              ; Tagged.Some, alloc_some env get_x ]
             )
         )
     )
@@ -3689,9 +3681,6 @@ module Blob = struct
     Tagged.load_forwarding_pointer env ^^
     compile_add_const (unskewed_payload_offset env)
 
-  (* TODO: Implement dynamic sharing with lazy instantiation on the heap, 
-    the static memory only denotes singleton address per upgrade mode, 
-    the static singleton address needs to be re-initialized on upgrade *)
   let lit env s = 
     let blob_length = Int32.of_int (String.length s) in
     let (set_new_blob, get_new_blob) = new_local env "new_blob" in
@@ -7622,8 +7611,8 @@ module StackRep = struct
     | Const.Word32 n   -> BoxedSmallWord.vanilla_lit env n
     | Const.Word64 n   -> BoxedWord64.vanilla_lit env n
     | Const.Float64 f  -> Float.vanilla_lit env f
-    | Const.Blob t     -> assert false
-    | Const.Null       -> Opt.null_vanilla_lit env
+    | Const.Blob t     -> assert false (* TODO: Handle case, e.g. part of array literal *)
+    | Const.Null       -> assert false (* TODO: Handle case, e.g. part of array literal *)
 
   let rec materialize_const_t env (p, cv) : int32 =
     Lib.Promise.lazy_value p (fun () -> materialize_const_v env cv)
@@ -7642,14 +7631,7 @@ module StackRep = struct
       let ptr = materialize_const_t env c in
       Variant.vanilla_lit env i ptr
     | Const.Lit l -> materialize_lit env l
-    | Const.Opt c ->
-      let rec kernel = Const.(function
-        | (_, Lit Null) -> None
-        | (_, Opt c) -> kernel c
-        | (_, other) -> Some (materialize_const_v env other)) in
-      match kernel c with
-      | Some ptr -> ptr
-      | None -> Opt.vanilla_lit env (materialize_const_t env c)
+    | Const.Opt c -> assert false (* TODO: Handle case, e.g. part of array literal *)
 
   let adjust env (sr_in : t) sr_out =
     if eq sr_in sr_out
@@ -7672,6 +7654,8 @@ module StackRep = struct
 
     | Const (_, Const.Lit (Const.Bool b)), Vanilla -> Bool.lit b
     | Const (_, Const.Lit (Const.Blob t)), Vanilla -> Blob.lit env t
+    | Const (_, Const.Lit (Const.Null)), Vanilla -> Opt.null_lit env
+    | Const (_, Const.Opt c), Vanilla -> Opt.inject env (compile_unboxed_const (materialize_const_t env c))
     | Const c, Vanilla -> compile_unboxed_const (materialize_const_t env c)
     | Const (_, Const.Lit (Const.Word32 n)), UnboxedWord32 -> compile_unboxed_const n
     | Const (_, Const.Lit (Const.Word64 n)), UnboxedWord64 -> compile_const_64 n

From 9f9262d263b696b853757f817330f89946de620b Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 11 Aug 2023 13:48:37 +0200
Subject: [PATCH 009/260] Redesign constant materialization

---
 src/codegen/compile.ml | 36 ++++++++++++++++++++++++++++++------
 1 file changed, 30 insertions(+), 6 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index c51738034d4..c7390abd2f3 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -161,6 +161,8 @@ module Const = struct
 
   let t_of_v v = (Lib.Promise.make (), v)
 
+  let get_value (_, v) = v
+
 end (* Const *)
 
 module SR = struct
@@ -7600,7 +7602,7 @@ module StackRep = struct
     | UnboxedTuple n -> G.table n (fun _ -> G.i Drop)
     | Const _ | Unreachable -> G.nop
 
-  (* Materializes a Const.lit: If necessary, puts
+  (* (* Materializes a Const.lit: If necessary, puts
      bytes into static memory, and returns a vanilla value.
   *)
   let materialize_lit env (lit : Const.lit) : int32 =
@@ -7631,7 +7633,28 @@ module StackRep = struct
       let ptr = materialize_const_t env c in
       Variant.vanilla_lit env i ptr
     | Const.Lit l -> materialize_lit env l
-    | Const.Opt c -> assert false (* TODO: Handle case, e.g. part of array literal *)
+    | Const.Opt c -> assert false TODO: Handle case, e.g. part of array literal *)
+
+  (* let rec new_materialize_lazy env (promise, value) : G.t =
+    Lib.Promise.lazy_value promise (fun () -> new_materialize_constant env value) *)
+
+  let rec materialize_constant env = function
+    | Const.Lit (Const.Bool b) -> Bool.lit b
+    | Const.Lit (Const.Blob t) -> Blob.lit env t
+    | Const.Lit (Const.Null) -> Opt.null_lit env
+    | Const.Lit (Const.BigInt n) -> compile_unboxed_const (BigNum.vanilla_lit env n) (* TODO: Redesign for heap allocations *)
+    | Const.Lit (Const.Word32 n) -> compile_unboxed_const (BoxedSmallWord.vanilla_lit env n) (* TODO: Redesign for heap allocations *)
+    | Const.Lit (Const.Word64 n) -> compile_unboxed_const (BoxedWord64.vanilla_lit env n) (* TODO: Redesign for heap allocations *)
+    | Const.Lit (Const.Float64 f) -> compile_unboxed_const (Float.vanilla_lit env f) (* TODO: Redesign for heap allocations *)
+    | Const.Opt c -> Opt.inject env (materialize_constant env (Const.get_value c))
+    | Const.Fun (get_fi, _) -> compile_unboxed_const (Closure.static_closure env (get_fi ())) (* TODO: Redesign for heap allocations *)
+    | Const.Message fi -> assert false
+    | Const.Unit -> compile_unboxed_const Tuple.unit_vanilla_lit (* TODO: Redesign for heap allocations *)
+    | Const.Tag (i, c) -> Variant.inject env i (materialize_constant env (Const.get_value c))
+
+    | Const.Lit (Const.Vanilla n) -> assert false
+    | Const.Array cs -> assert false
+    | Const.Obj l -> assert false
 
   let adjust env (sr_in : t) sr_out =
     if eq sr_in sr_out
@@ -7652,18 +7675,19 @@ module StackRep = struct
     | UnboxedFloat64, Vanilla -> Float.box env
     | Vanilla, UnboxedFloat64 -> Float.unbox env
 
-    | Const (_, Const.Lit (Const.Bool b)), Vanilla -> Bool.lit b
+    | Const (_, value), Vanilla -> materialize_constant env value
+    (* | Const (_, Const.Lit (Const.Bool b)), Vanilla -> Bool.lit b
     | Const (_, Const.Lit (Const.Blob t)), Vanilla -> Blob.lit env t
     | Const (_, Const.Lit (Const.Null)), Vanilla -> Opt.null_lit env
-    | Const (_, Const.Opt c), Vanilla -> Opt.inject env (compile_unboxed_const (materialize_const_t env c))
-    | Const c, Vanilla -> compile_unboxed_const (materialize_const_t env c)
+    | Const (_, Const.Opt c), Vanilla -> Opt.inject env (materialize_const_t env c))
+    | Const c, Vanilla -> compile_unboxed_const (materialize_const_t env c) *)
     | Const (_, Const.Lit (Const.Word32 n)), UnboxedWord32 -> compile_unboxed_const n
     | Const (_, Const.Lit (Const.Word64 n)), UnboxedWord64 -> compile_const_64 n
     | Const (_, Const.Lit (Const.Float64 f)), UnboxedFloat64 -> Float.compile_unboxed_const f
     | Const c, UnboxedTuple 0 -> G.nop
     | Const (_, Const.Array cs), UnboxedTuple n ->
       assert (n = List.length cs);
-      G.concat_map (fun c -> compile_unboxed_const (materialize_const_t env c)) cs
+      G.concat_map (fun c -> materialize_constant env (Const.get_value c)) cs
     | _, _ ->
       Printf.eprintf "Unknown stack_rep conversion %s -> %s\n"
         (to_string sr_in) (to_string sr_out);

From 296bbcd50071277a92f22266a2005a538808c9bc Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 11 Aug 2023 14:02:51 +0200
Subject: [PATCH 010/260] Place static Word64 in dynamic heap

---
 src/codegen/compile.ml | 43 ++++++------------------------------------
 1 file changed, 6 insertions(+), 37 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index c7390abd2f3..45b5ad4f870 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -2037,12 +2037,6 @@ module Variant = struct
     get_variant_tag env ^^
     compile_eq_const (hash_variant_label env l)
 
-  let vanilla_lit env i ptr =
-    Tagged.shared_static_obj env Tagged.Variant StaticBytes.[
-      I32 (hash_variant_label env i);
-      I32 ptr
-    ]
-
 end (* Variant *)
 
 
@@ -2125,14 +2119,6 @@ module BoxedWord64 = struct
 
   let payload_field = Tagged.header_size
 
-  let vanilla_lit env i =
-    if BitTagged.can_tag_const i
-    then BitTagged.tag_const i
-    else
-      Tagged.shared_static_obj env Tagged.Bits64 StaticBytes.[
-        I64 i
-      ]
-
   let compile_box env compile_elem : G.t =
     let (set_i, get_i) = new_local env "boxed_i64" in
     let size = if !Flags.gc_strategy = Flags.Incremental then 4l else 3l in
@@ -2142,6 +2128,11 @@ module BoxedWord64 = struct
     get_i ^^
     Tagged.allocation_barrier env
 
+  let lit env i =
+    if BitTagged.can_tag_const i
+    then compile_unboxed_const (BitTagged.tag_const i)
+    else compile_box env (compile_const_64 i)
+
   let box env = Func.share_code1 env "box_i64" ("n", I64Type) [I32Type] (fun env get_n ->
       get_n ^^ BitTagged.if_can_tag_i64 env [I32Type]
         (get_n ^^ BitTagged.tag)
@@ -3477,22 +3468,6 @@ module Object = struct
 
   module FieldEnv = Env.Make(String)
 
-  (* This is for static objects *)
-  let vanilla_lit env (fs : (string * int32) list) : int32 =
-    let (hashes, ptrs) = fs
-      |> List.map (fun (n, ptr) -> (Mo_types.Hash.hash n,ptr))
-      |> List.sort compare
-      |> List.split
-    in
-
-    let hash_ptr = E.add_static env StaticBytes.[ i32s hashes ] in
-
-    Tagged.shared_static_obj env Tagged.Object StaticBytes.[
-      I32 (Int32.of_int (List.length fs));
-      I32 hash_ptr;
-      i32s ptrs;
-    ]
-
   (* This is for non-recursive objects, i.e. ObjNewE *)
   (* The instructions in the field already create the indirection if needed *)
   let lit_raw env (fs : (string * (unit -> G.t)) list ) =
@@ -4011,12 +3986,6 @@ module Arr = struct
      | Type.Array element_type -> element_type
      | _ -> assert false
 
-  let vanilla_lit env ptrs =
-    Tagged.shared_static_obj env Tagged.Array StaticBytes.[
-      I32 (Int32.of_int (List.length ptrs));
-      i32s ptrs;
-    ]
-
   (* Compile an array literal. *)
   let lit env element_instructions =
     Tagged.obj env Tagged.Array
@@ -7644,7 +7613,7 @@ module StackRep = struct
     | Const.Lit (Const.Null) -> Opt.null_lit env
     | Const.Lit (Const.BigInt n) -> compile_unboxed_const (BigNum.vanilla_lit env n) (* TODO: Redesign for heap allocations *)
     | Const.Lit (Const.Word32 n) -> compile_unboxed_const (BoxedSmallWord.vanilla_lit env n) (* TODO: Redesign for heap allocations *)
-    | Const.Lit (Const.Word64 n) -> compile_unboxed_const (BoxedWord64.vanilla_lit env n) (* TODO: Redesign for heap allocations *)
+    | Const.Lit (Const.Word64 n) -> BoxedWord64.lit env n
     | Const.Lit (Const.Float64 f) -> compile_unboxed_const (Float.vanilla_lit env f) (* TODO: Redesign for heap allocations *)
     | Const.Opt c -> Opt.inject env (materialize_constant env (Const.get_value c))
     | Const.Fun (get_fi, _) -> compile_unboxed_const (Closure.static_closure env (get_fi ())) (* TODO: Redesign for heap allocations *)

From f2eb3dd429b3a85f67190199728503499d24d060 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 11 Aug 2023 14:04:11 +0200
Subject: [PATCH 011/260] Remove redundant code

---
 src/codegen/compile.ml | 41 -----------------------------------------
 1 file changed, 41 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 45b5ad4f870..cbed72171b2 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -7571,42 +7571,6 @@ module StackRep = struct
     | UnboxedTuple n -> G.table n (fun _ -> G.i Drop)
     | Const _ | Unreachable -> G.nop
 
-  (* (* Materializes a Const.lit: If necessary, puts
-     bytes into static memory, and returns a vanilla value.
-  *)
-  let materialize_lit env (lit : Const.lit) : int32 =
-    match lit with
-    | Const.Vanilla n  -> n
-    | Const.Bool n     -> Bool.vanilla_lit n
-    | Const.BigInt n   -> BigNum.vanilla_lit env n
-    | Const.Word32 n   -> BoxedSmallWord.vanilla_lit env n
-    | Const.Word64 n   -> BoxedWord64.vanilla_lit env n
-    | Const.Float64 f  -> Float.vanilla_lit env f
-    | Const.Blob t     -> assert false (* TODO: Handle case, e.g. part of array literal *)
-    | Const.Null       -> assert false (* TODO: Handle case, e.g. part of array literal *)
-
-  let rec materialize_const_t env (p, cv) : int32 =
-    Lib.Promise.lazy_value p (fun () -> materialize_const_v env cv)
-
-  and materialize_const_v env = function
-    | Const.Fun (get_fi, _) -> Closure.static_closure env (get_fi ())
-    | Const.Message fi -> assert false
-    | Const.Obj fs ->
-      let fs' = List.map (fun (n, c) -> (n, materialize_const_t env c)) fs in
-      Object.vanilla_lit env fs'
-    | Const.Unit -> Tuple.unit_vanilla_lit
-    | Const.Array cs ->
-      let ptrs = List.map (materialize_const_t env) cs in
-      Arr.vanilla_lit env ptrs
-    | Const.Tag (i, c) ->
-      let ptr = materialize_const_t env c in
-      Variant.vanilla_lit env i ptr
-    | Const.Lit l -> materialize_lit env l
-    | Const.Opt c -> assert false TODO: Handle case, e.g. part of array literal *)
-
-  (* let rec new_materialize_lazy env (promise, value) : G.t =
-    Lib.Promise.lazy_value promise (fun () -> new_materialize_constant env value) *)
-
   let rec materialize_constant env = function
     | Const.Lit (Const.Bool b) -> Bool.lit b
     | Const.Lit (Const.Blob t) -> Blob.lit env t
@@ -7645,11 +7609,6 @@ module StackRep = struct
     | Vanilla, UnboxedFloat64 -> Float.unbox env
 
     | Const (_, value), Vanilla -> materialize_constant env value
-    (* | Const (_, Const.Lit (Const.Bool b)), Vanilla -> Bool.lit b
-    | Const (_, Const.Lit (Const.Blob t)), Vanilla -> Blob.lit env t
-    | Const (_, Const.Lit (Const.Null)), Vanilla -> Opt.null_lit env
-    | Const (_, Const.Opt c), Vanilla -> Opt.inject env (materialize_const_t env c))
-    | Const c, Vanilla -> compile_unboxed_const (materialize_const_t env c) *)
     | Const (_, Const.Lit (Const.Word32 n)), UnboxedWord32 -> compile_unboxed_const n
     | Const (_, Const.Lit (Const.Word64 n)), UnboxedWord64 -> compile_const_64 n
     | Const (_, Const.Lit (Const.Float64 f)), UnboxedFloat64 -> Float.compile_unboxed_const f

From 41d9107526741d874df1de9d8dd7da55d348eda1 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 11 Aug 2023 14:33:11 +0200
Subject: [PATCH 012/260] Simplify constant representation

---
 src/codegen/compile.ml | 103 ++++++++++++++++++-----------------------
 1 file changed, 45 insertions(+), 58 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index cbed72171b2..d79c8b357e0 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -102,7 +102,7 @@ module Const = struct
     | Blob of string
     | Null
 
-  let lit_eq = function
+  let lit_eq l1 l2 = match l1, l2 with
     | Vanilla i, Vanilla j -> i = j
     | BigInt i, BigInt j -> Big_int.eq_big_int i j
     | Word32 i, Word32 j -> i = j
@@ -146,22 +146,16 @@ module Const = struct
   type v =
     | Fun of (unit -> int32) * fun_rhs (* function pointer calculated upon first use *)
     | Message of int32 (* anonymous message, only temporary *)
-    | Obj of (string * t) list
+    | Obj of (string * v) list
     | Unit
-    | Array of t list (* also tuples, but not nullary *)
-    | Tag of (string * t)
-    | Opt of t
+    | Array of v list (* also tuples, but not nullary *)
+    | Tag of (string * v)
+    | Opt of v
     | Lit of lit
 
-  (* A constant known value together with a vanilla pointer.
-     Typically a static memory location, could be an unboxed scalar.
-     Filled on demand.
-   *)
-  and t = (int32 Lib.Promise.t * v)
-
-  let t_of_v v = (Lib.Promise.make (), v)
-
-  let get_value (_, v) = v
+  let eq v1 v2 = match v1, v2 with
+    | Lit l1, Lit l2 -> lit_eq l1 l2
+    | _ -> v1 = v2
 
 end (* Const *)
 
@@ -181,7 +175,7 @@ module SR = struct
     | UnboxedWord32
     | UnboxedFloat64
     | Unreachable
-    | Const of Const.t
+    | Const of Const.v
 
   let unit = UnboxedTuple 0
 
@@ -190,16 +184,9 @@ module SR = struct
   (* Because t contains Const.t, and that contains Const.v, and that contains
      Const.lit, and that contains Big_int, we cannot just use normal `=`. So we
      have to write our own equality.
-
-     This equalty is, I believe, used when joining branches. So for Const, we
-     just compare the promises, and do not descend into the Const.v. This is
-     conservative; the only downside is that if a branch returns different
-     Const.t with (semantically) the same Const.v we do not propagate that as
-     Const, but materialize before the branch.
-     Which is not really expected or important.
   *)
   let eq (t1 : t) (t2 : t) = match t1, t2 with
-    | Const (p1, _), Const (p2, _) -> p1 == p2
+    | Const c1, Const c2 -> Const.eq c1 c2
     | _ -> t1 = t2
 
   let to_var_type : t -> value_type = function
@@ -7579,11 +7566,11 @@ module StackRep = struct
     | Const.Lit (Const.Word32 n) -> compile_unboxed_const (BoxedSmallWord.vanilla_lit env n) (* TODO: Redesign for heap allocations *)
     | Const.Lit (Const.Word64 n) -> BoxedWord64.lit env n
     | Const.Lit (Const.Float64 f) -> compile_unboxed_const (Float.vanilla_lit env f) (* TODO: Redesign for heap allocations *)
-    | Const.Opt c -> Opt.inject env (materialize_constant env (Const.get_value c))
+    | Const.Opt c -> Opt.inject env (materialize_constant env c)
     | Const.Fun (get_fi, _) -> compile_unboxed_const (Closure.static_closure env (get_fi ())) (* TODO: Redesign for heap allocations *)
     | Const.Message fi -> assert false
     | Const.Unit -> compile_unboxed_const Tuple.unit_vanilla_lit (* TODO: Redesign for heap allocations *)
-    | Const.Tag (i, c) -> Variant.inject env i (materialize_constant env (Const.get_value c))
+    | Const.Tag (i, c) -> Variant.inject env i (materialize_constant env c)
 
     | Const.Lit (Const.Vanilla n) -> assert false
     | Const.Array cs -> assert false
@@ -7608,14 +7595,14 @@ module StackRep = struct
     | UnboxedFloat64, Vanilla -> Float.box env
     | Vanilla, UnboxedFloat64 -> Float.unbox env
 
-    | Const (_, value), Vanilla -> materialize_constant env value
-    | Const (_, Const.Lit (Const.Word32 n)), UnboxedWord32 -> compile_unboxed_const n
-    | Const (_, Const.Lit (Const.Word64 n)), UnboxedWord64 -> compile_const_64 n
-    | Const (_, Const.Lit (Const.Float64 f)), UnboxedFloat64 -> Float.compile_unboxed_const f
+    | Const value, Vanilla -> materialize_constant env value
+    | Const Const.Lit (Const.Word32 n), UnboxedWord32 -> compile_unboxed_const n
+    | Const Const.Lit (Const.Word64 n), UnboxedWord64 -> compile_const_64 n
+    | Const Const.Lit (Const.Float64 f), UnboxedFloat64 -> Float.compile_unboxed_const f
     | Const c, UnboxedTuple 0 -> G.nop
-    | Const (_, Const.Array cs), UnboxedTuple n ->
+    | Const Const.Array cs, UnboxedTuple n ->
       assert (n = List.length cs);
-      G.concat_map (fun c -> materialize_constant env (Const.get_value c)) cs
+      G.concat_map (fun c -> materialize_constant env c) cs
     | _, _ ->
       Printf.eprintf "Unknown stack_rep conversion %s -> %s\n"
         (to_string sr_in) (to_string sr_out);
@@ -7637,8 +7624,8 @@ module VarEnv = struct
     (* A static variable accessed by an index via the runtime system, refers to a MutBox,
        belonging to the GC root set *)
     | Static of int32
-    (* Not materialized (yet), statically known constant, static location on demand *)
-    | Const of Const.t
+    (* Constant literals can reside in dynamic heap *)
+    | Const of Const.v
     (* public method *)
     | PublicMethod of int32 * string
 
@@ -7917,7 +7904,7 @@ end (* Var *)
 module Internals = struct
   let call_prelude_function env ae var =
     match VarEnv.lookup_var ae var with
-    | Some (VarEnv.Const (_, Const.Fun (mk_fi, _))) ->
+    | Some (VarEnv.Const Const.Fun (mk_fi, _)) ->
        compile_unboxed_zero ^^ (* A dummy closure *)
        G.i (Call (nr (mk_fi ())))
     | _ -> assert false
@@ -8008,13 +7995,13 @@ module FuncDec = struct
     if Type.is_shared_sort sort
     then begin
       let (fi, fill) = E.reserve_fun pre_env name in
-      ( Const.t_of_v (Const.Message fi), fun env ae ->
+      ( Const.Message fi, fun env ae ->
         fill (compile_const_message env ae sort control args mk_body ret_tys at)
       )
     end else begin
       assert (control = Type.Returns);
       let lf = E.make_lazy_function pre_env name in
-      ( Const.t_of_v (Const.Fun ((fun () -> Lib.AllocOnUse.use lf), fun_rhs)), fun env ae ->
+      ( Const.Fun ((fun () -> Lib.AllocOnUse.use lf), fun_rhs), fun env ae ->
         let restore_no_env _env ae _ = ae, unmodified in
         Lib.AllocOnUse.def lf (lazy (compile_local_function env ae restore_no_env args mk_body ret_tys at))
       )
@@ -8654,7 +8641,7 @@ let const_lit_of_lit : Ir.lit -> Const.lit = function
   | FloatLit f    -> Const.Float64 f
 
 let const_of_lit lit =
-  Const.t_of_v (Const.Lit (const_lit_of_lit lit))
+  Const.Lit (const_lit_of_lit lit)
 
 let compile_lit lit =
   SR.Const (const_of_lit lit), G.nop
@@ -9347,7 +9334,7 @@ and compile_prim_invocation (env : E.t) ae p es at =
 
     (* we duplicate this pattern match to emulate pattern guards *)
     let call_as_prim = match fun_sr, sort with
-      | SR.Const (_, Const.Fun (mk_fi, Const.PrimWrapper prim)), _ ->
+      | SR.Const Const.Fun (mk_fi, Const.PrimWrapper prim), _ ->
          begin match n_args, e2.it with
          | 0, _ -> true
          | 1, _ -> true
@@ -9357,7 +9344,7 @@ and compile_prim_invocation (env : E.t) ae p es at =
       | _ -> false in
 
     begin match fun_sr, sort with
-      | SR.Const (_, Const.Fun (mk_fi, Const.PrimWrapper prim)), _ when call_as_prim ->
+      | SR.Const Const.Fun (mk_fi, Const.PrimWrapper prim), _ when call_as_prim ->
          assert (sort = Type.Local);
          (* Handle argument tuples *)
          begin match n_args, e2.it with
@@ -9376,7 +9363,7 @@ and compile_prim_invocation (env : E.t) ae p es at =
            (* ugly case; let's just call this as a function for now *)
            raise (Invalid_argument "call_as_prim was true?")
          end
-      | SR.Const (_, Const.Fun (mk_fi, _)), _ ->
+      | SR.Const Const.Fun (mk_fi, _), _ ->
          assert (sort = Type.Local);
          StackRep.of_arity return_arity,
 
@@ -9457,7 +9444,7 @@ and compile_prim_invocation (env : E.t) ae p es at =
   | DotPrim name, [e] ->
     let sr, code1 = compile_exp env ae e in
     begin match sr with
-    | SR.Const (_, Const.Obj fs) ->
+    | SR.Const Const.Obj fs ->
       let c = List.assoc name fs in
       SR.Const c, code1
     | _ ->
@@ -10779,7 +10766,7 @@ and compile_dec env pre_ae how v2en dec : VarEnv.t * G.t * (VarEnv.t -> scope_wr
   | LetD ({it = VarP v; _}, e) when E.NameEnv.mem v v2en ->
     let (const, fill) = compile_const_exp env pre_ae e in
     let fi = match const with
-      | (_, Const.Message fi) -> fi
+      | Const.Message fi -> fi
       | _ -> assert false in
     let pre_ae1 = VarEnv.add_local_public_method pre_ae v (fi, (E.NameEnv.find v v2en)) e.note.Note.typ in
     G.( pre_ae1, nop, (fun ae -> fill env ae; nop), unmodified)
@@ -10849,7 +10836,7 @@ and compile_decs env ae decs captured_in_body : VarEnv.t * scope_wrap =
 (* This compiles expressions determined to be const as per the analysis in
    ir_passes/const.ml. See there for more details.
 *)
-and compile_const_exp env pre_ae exp : Const.t * (E.t -> VarEnv.t -> unit) =
+and compile_const_exp env pre_ae exp : Const.v * (E.t -> VarEnv.t -> unit) =
   match exp.it with
   | FuncE (name, sort, control, typ_binds, args, res_tys, e) ->
     let fun_rhs =
@@ -10905,34 +10892,34 @@ and compile_const_exp env pre_ae exp : Const.t * (E.t -> VarEnv.t -> unit) =
             | _ -> fatal "compile_const_exp/ObjE: \"%s\" not found" f.it.var
           in f.it.name, st) fs
     in
-    (Const.t_of_v (Const.Obj static_fs), fun _ _ -> ())
+    (Const.Obj static_fs), fun _ _ -> ()
   | PrimE (DotPrim name, [e]) ->
     let (object_ct, fill) = compile_const_exp env pre_ae e in
     let fs = match object_ct with
-      | _, Const.Obj fs -> fs
+      | Const.Obj fs -> fs
       | _ -> fatal "compile_const_exp/DotE: not a static object" in
     let member_ct = List.assoc name fs in
     (member_ct, fill)
   | PrimE (ProjPrim i, [e]) ->
     let (object_ct, fill) = compile_const_exp env pre_ae e in
     let cs = match object_ct with
-      | _, Const.Array cs -> cs
+      | Const.Array cs -> cs
       | _ -> fatal "compile_const_exp/ProjE: not a static tuple" in
     (List.nth cs i, fill)
-  | LitE l -> Const.(t_of_v (Lit (const_lit_of_lit l))), (fun _ _ -> ())
-  | PrimE (TupPrim, []) -> Const.t_of_v Const.Unit, (fun _ _ -> ())
+  | LitE l -> Const.(Lit (const_lit_of_lit l)), (fun _ _ -> ())
+  | PrimE (TupPrim, []) -> Const.Unit, (fun _ _ -> ())
   | PrimE (ArrayPrim (Const, _), es)
   | PrimE (TupPrim, es) ->
     let (cs, fills) = List.split (List.map (compile_const_exp env pre_ae) es) in
-    Const.(t_of_v (Array cs)),
+    (Const.Array cs),
     (fun env ae -> List.iter (fun fill -> fill env ae) fills)
   | PrimE (TagPrim i, [e]) ->
     let (arg_ct, fill) = compile_const_exp env pre_ae e in
-    Const.(t_of_v (Tag (i, arg_ct))),
+    (Const.Tag (i, arg_ct)),
     fill
   | PrimE (OptPrim, [e]) ->
     let (arg_ct, fill) = compile_const_exp env pre_ae e in
-    Const.(t_of_v (Opt arg_ct)),
+    (Const.Opt arg_ct),
     fill
 
   | _ -> assert false
@@ -10958,7 +10945,7 @@ and destruct_const_pat ae pat const : VarEnv.t option = match pat.it with
   | WildP -> Some ae
   | VarP v -> Some (VarEnv.add_local_const ae v const pat.note)
   | ObjP pfs ->
-    let fs = match const with (_, Const.Obj fs) -> fs | _ -> assert false in
+    let fs = match const with Const.Obj fs -> fs | _ -> assert false in
     List.fold_left (fun ae (pf : pat_field) ->
       match ae, List.find_opt (fun (n, _) -> pf.it.name = n) fs with
       | None, _ -> None
@@ -10970,26 +10957,26 @@ and destruct_const_pat ae pat const : VarEnv.t option = match pat.it with
     if l = None then destruct_const_pat ae p2 const
     else l
   | TupP ps ->
-    let cs = match const with (_, Const.Array cs) -> cs | (_, Const.Unit) -> [] | _ -> assert false in
+    let cs = match const with Const.Array cs -> cs | Const.Unit -> [] | _ -> assert false in
     let go ae p c = match ae with
       | Some ae -> destruct_const_pat ae p c
       | _ -> None in
     List.fold_left2 go (Some ae) ps cs
   | LitP lp ->
     begin match const with
-    | (_, Const.Lit lc) when Const.lit_eq (const_lit_of_lit lp, lc) -> Some ae
+    | Const.Lit lc when Const.lit_eq (const_lit_of_lit lp) lc -> Some ae
     | _ -> None
     end
   | OptP p ->
     begin match const with
-      | (_, Const.Opt c) -> destruct_const_pat ae p c
-      | (_, Const.(Lit Null)) -> None
+      | Const.Opt c -> destruct_const_pat ae p c
+      | Const.(Lit Null) -> None
       | _ -> assert false
     end
   | TagP (i, p) ->
      match const with
-     | (_, Const.Tag (ic, c)) when i = ic -> destruct_const_pat ae p c
-     | (_, Const.Tag _) -> None
+     | Const.Tag (ic, c) when i = ic -> destruct_const_pat ae p c
+     | Const.Tag _ -> None
      | _ -> assert false
 
 and compile_const_dec env pre_ae dec : (VarEnv.t -> VarEnv.t) * (E.t -> VarEnv.t -> unit) =

From 0d8bd41f7a4ec2fb55f550779029f2c9d411de11 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 11 Aug 2023 14:36:11 +0200
Subject: [PATCH 013/260] Place static Word32 in dynamic heap

---
 src/codegen/compile.ml | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index d79c8b357e0..646f704b03f 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -2224,14 +2224,6 @@ module BoxedSmallWord = struct
 
   let payload_field env = Tagged.header_size env
 
-  let vanilla_lit env i =
-    if BitTagged.can_tag_const (Int64.of_int (Int32.to_int i))
-    then BitTagged.tag_const (Int64.of_int (Int32.to_int i))
-    else
-      Tagged.shared_static_obj env Tagged.Bits32 StaticBytes.[
-        I32 i
-      ]
-
   let compile_box env compile_elem : G.t =
     let (set_i, get_i) = new_local env "boxed_i32" in
     let size = if !Flags.gc_strategy = Flags.Incremental then 3l else 2l in
@@ -2241,6 +2233,11 @@ module BoxedSmallWord = struct
     get_i ^^
     Tagged.allocation_barrier env
 
+  let lit env i =
+    if BitTagged.can_tag_const (Int64.of_int (Int32.to_int i))
+    then compile_unboxed_const (BitTagged.tag_const (Int64.of_int (Int32.to_int i)))
+    else compile_box env (compile_unboxed_const i)
+
   let box env = Func.share_code1 env "box_i32" ("n", I32Type) [I32Type] (fun env get_n ->
       get_n ^^ compile_shrU_const 30l ^^
       G.i (Unary (Wasm.Values.I32 I32Op.Popcnt)) ^^
@@ -7563,7 +7560,7 @@ module StackRep = struct
     | Const.Lit (Const.Blob t) -> Blob.lit env t
     | Const.Lit (Const.Null) -> Opt.null_lit env
     | Const.Lit (Const.BigInt n) -> compile_unboxed_const (BigNum.vanilla_lit env n) (* TODO: Redesign for heap allocations *)
-    | Const.Lit (Const.Word32 n) -> compile_unboxed_const (BoxedSmallWord.vanilla_lit env n) (* TODO: Redesign for heap allocations *)
+    | Const.Lit (Const.Word32 n) -> BoxedSmallWord.lit env n
     | Const.Lit (Const.Word64 n) -> BoxedWord64.lit env n
     | Const.Lit (Const.Float64 f) -> compile_unboxed_const (Float.vanilla_lit env f) (* TODO: Redesign for heap allocations *)
     | Const.Opt c -> Opt.inject env (materialize_constant env c)

From 99124a0cea30980330b5cc1ee39425ff83d238e0 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 11 Aug 2023 14:43:02 +0200
Subject: [PATCH 014/260] Code refactoring

---
 src/codegen/compile.ml | 28 ++++++++++++++++++----------
 1 file changed, 18 insertions(+), 10 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 646f704b03f..4525258a8cd 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -2106,6 +2106,15 @@ module BoxedWord64 = struct
 
   let payload_field = Tagged.header_size
 
+  let lit env i =
+    if BitTagged.can_tag_const i
+    then 
+      compile_unboxed_const (BitTagged.tag_const i)
+    else
+      Tagged.obj env Tagged.Bits64 [
+        compile_const_64 i
+      ]
+
   let compile_box env compile_elem : G.t =
     let (set_i, get_i) = new_local env "boxed_i64" in
     let size = if !Flags.gc_strategy = Flags.Incremental then 4l else 3l in
@@ -2115,11 +2124,6 @@ module BoxedWord64 = struct
     get_i ^^
     Tagged.allocation_barrier env
 
-  let lit env i =
-    if BitTagged.can_tag_const i
-    then compile_unboxed_const (BitTagged.tag_const i)
-    else compile_box env (compile_const_64 i)
-
   let box env = Func.share_code1 env "box_i64" ("n", I64Type) [I32Type] (fun env get_n ->
       get_n ^^ BitTagged.if_can_tag_i64 env [I32Type]
         (get_n ^^ BitTagged.tag)
@@ -2224,6 +2228,15 @@ module BoxedSmallWord = struct
 
   let payload_field env = Tagged.header_size env
 
+  let lit env i =
+    if BitTagged.can_tag_const (Int64.of_int (Int32.to_int i))
+    then
+      compile_unboxed_const (BitTagged.tag_const (Int64.of_int (Int32.to_int i)))
+    else
+      Tagged.obj env Tagged.Bits32 [
+        compile_unboxed_const i
+      ]
+
   let compile_box env compile_elem : G.t =
     let (set_i, get_i) = new_local env "boxed_i32" in
     let size = if !Flags.gc_strategy = Flags.Incremental then 3l else 2l in
@@ -2233,11 +2246,6 @@ module BoxedSmallWord = struct
     get_i ^^
     Tagged.allocation_barrier env
 
-  let lit env i =
-    if BitTagged.can_tag_const (Int64.of_int (Int32.to_int i))
-    then compile_unboxed_const (BitTagged.tag_const (Int64.of_int (Int32.to_int i)))
-    else compile_box env (compile_unboxed_const i)
-
   let box env = Func.share_code1 env "box_i32" ("n", I32Type) [I32Type] (fun env get_n ->
       get_n ^^ compile_shrU_const 30l ^^
       G.i (Unary (Wasm.Values.I32 I32Op.Popcnt)) ^^

From 9fa9ae277f1506b9d5f3ffefaa109cbc1d31b957 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 11 Aug 2023 14:55:17 +0200
Subject: [PATCH 015/260] Place static BigNum in dynamic heap

---
 src/codegen/compile.ml | 31 ++++++++++++++-----------------
 1 file changed, 14 insertions(+), 17 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 4525258a8cd..e4ee0f93c3e 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -2653,7 +2653,7 @@ sig
   val compile_load_from_data_buf : E.t -> G.t -> bool -> G.t
 
   (* literals *)
-  val vanilla_lit : E.t -> Big_int.big_int -> int32
+  val lit : E.t -> Big_int.big_int -> G.t
 
   (* arithmetic *)
   val compile_abs : E.t -> G.t
@@ -2963,10 +2963,10 @@ module MakeCompact (Num : BigNumType) : BigNumType = struct
       (get_n ^^ compile_unboxed_const 0l ^^ G.i (Compare (Wasm.Values.I32 I32Op.LtS)))
       (get_n ^^ Num.compile_is_negative env)
 
-  let vanilla_lit env = function
+  let lit env = function
     | n when Big_int.is_int_big_int n && BitTagged.can_tag_const (Big_int.int64_of_big_int n) ->
-      BitTagged.tag_const (Big_int.int64_of_big_int n)
-    | n -> Num.vanilla_lit env n
+      compile_unboxed_const (BitTagged.tag_const (Big_int.int64_of_big_int n))
+    | n -> Num.lit env n
 
   let compile_neg env =
     Func.share_code1 env "B_neg" ("n", I32Type) [I32Type] (fun env get_n ->
@@ -3317,7 +3317,7 @@ module BigNumLibtommath : BigNumType = struct
     | false -> get_data_buf ^^ E.call_import env "rts" "bigint_leb128_decode"
     | true -> get_data_buf ^^ E.call_import env "rts" "bigint_sleb128_decode"
 
-  let vanilla_lit env n =
+  let lit env n =
     (* See enum mp_sign *)
     let sign = if Big_int.sign_big_int n >= 0 then 0l else 1l in
 
@@ -3331,22 +3331,19 @@ module BigNumLibtommath : BigNumType = struct
         then []
         else
           let (a, b) = Big_int.quomod_big_int n twoto28 in
-          [ Big_int.int32_of_big_int b ] @ go a
+          [ compile_unboxed_const (Big_int.int32_of_big_int b) ] @ go a
       in go n
     in
     (* how many 32 bit digits *)
     let size = Int32.of_int (List.length limbs) in
 
     (* cf. mp_int in tommath.h *)
-    let ptr = Tagged.shared_static_obj env Tagged.BigInt StaticBytes.[
-      I32 size; (* used *)
-      I32 size; (* size; relying on Heap.word_size == size_of(mp_digit) *)
-      I32 sign;
-      I32 0l; (* dp; this will be patched in BigInt::mp_int_ptr in the RTS when used *)
-      i32s limbs
-
-    ] in
-    ptr
+    Tagged.obj env Tagged.BigInt ([
+      compile_unboxed_const size; (* used *)
+      compile_unboxed_const size; (* size; relying on Heap.word_size == size_of(mp_digit) *)
+      compile_unboxed_const sign;
+      compile_unboxed_const 0l; (* dp; this will be patched in BigInt::mp_int_ptr in the RTS when used *)
+    ] @ limbs)
 
   let assert_nonneg env =
     Func.share_code1 env "assert_nonneg" ("n", I32Type) [I32Type] (fun env get_n ->
@@ -4819,7 +4816,7 @@ module Cycles = struct
     let (set_val, get_val) = new_local env "cycles" in
     set_val ^^
     get_val ^^
-    compile_unboxed_const (BigNum.vanilla_lit env (Big_int.power_int_positive_int 2 128)) ^^
+    BigNum.lit env (Big_int.power_int_positive_int 2 128) ^^
     BigNum.compile_relop env Lt ^^
     E.else_trap_with env "cycles out of bounds" ^^
 
@@ -7567,7 +7564,7 @@ module StackRep = struct
     | Const.Lit (Const.Bool b) -> Bool.lit b
     | Const.Lit (Const.Blob t) -> Blob.lit env t
     | Const.Lit (Const.Null) -> Opt.null_lit env
-    | Const.Lit (Const.BigInt n) -> compile_unboxed_const (BigNum.vanilla_lit env n) (* TODO: Redesign for heap allocations *)
+    | Const.Lit (Const.BigInt n) -> BigNum.lit env n
     | Const.Lit (Const.Word32 n) -> BoxedSmallWord.lit env n
     | Const.Lit (Const.Word64 n) -> BoxedWord64.lit env n
     | Const.Lit (Const.Float64 f) -> compile_unboxed_const (Float.vanilla_lit env f) (* TODO: Redesign for heap allocations *)

From d0e43084a8b51672b05de79e58e9f43199494aa7 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 11 Aug 2023 14:57:07 +0200
Subject: [PATCH 016/260] Place static Float64 in dynamic heap

---
 src/codegen/compile.ml | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index e4ee0f93c3e..a395535511b 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -52,7 +52,7 @@ module StaticBytes = struct
 
   type t_ =
     | I32 of int32
-    | I64 of int64
+    (* | I64 of int64 *)
     | Seq of t
     | Bytes of string
 
@@ -62,7 +62,7 @@ module StaticBytes = struct
 
   let rec add : Buffer.t -> t_ -> unit = fun buf -> function
     | I32 i -> Buffer.add_int32_le buf i
-    | I64 i -> Buffer.add_int64_le buf i
+    (* | I64 i -> Buffer.add_int64_le buf i *)
     | Seq xs -> List.iter (add buf) xs
     | Bytes b -> Buffer.add_string buf b
 
@@ -2474,9 +2474,9 @@ module Float = struct
 
   let compile_unboxed_const f = G.i (Const (nr (Wasm.Values.F64 f)))
 
-  let vanilla_lit env f =
-    Tagged.shared_static_obj env Tagged.Bits64 StaticBytes.[
-      I64 (Wasm.F64.to_bits f)
+  let lit env f =
+    Tagged.obj env Tagged.Bits64 [
+      compile_const_64 (Wasm.F64.to_bits f)
     ]
 
   let box env = Func.share_code1 env "box_f64" ("f", F64Type) [I32Type] (fun env get_f ->
@@ -7567,7 +7567,7 @@ module StackRep = struct
     | Const.Lit (Const.BigInt n) -> BigNum.lit env n
     | Const.Lit (Const.Word32 n) -> BoxedSmallWord.lit env n
     | Const.Lit (Const.Word64 n) -> BoxedWord64.lit env n
-    | Const.Lit (Const.Float64 f) -> compile_unboxed_const (Float.vanilla_lit env f) (* TODO: Redesign for heap allocations *)
+    | Const.Lit (Const.Float64 f) -> Float.lit env f
     | Const.Opt c -> Opt.inject env (materialize_constant env c)
     | Const.Fun (get_fi, _) -> compile_unboxed_const (Closure.static_closure env (get_fi ())) (* TODO: Redesign for heap allocations *)
     | Const.Message fi -> assert false

From db6f1cba6953e10acd09643032d749cb445a6bbc Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 11 Aug 2023 15:00:15 +0200
Subject: [PATCH 017/260] Place static closure in dynamic heap

---
 src/codegen/compile.ml | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index a395535511b..784feec5fb4 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -2078,10 +2078,10 @@ module Closure = struct
     G.i (CallIndirect (nr ty)) ^^
     FakeMultiVal.load env (Lib.List.make n_res I32Type)
 
-  let static_closure env fi : int32 =
-    Tagged.shared_static_obj env Tagged.Closure StaticBytes.[
-      I32 (E.add_fun_ptr env fi);
-      I32 0l
+  let alloc env fi =
+    Tagged.obj env Tagged.Closure [
+      compile_unboxed_const (E.add_fun_ptr env fi);
+      compile_unboxed_const 0l
     ]
 
 end (* Closure *)
@@ -7569,7 +7569,7 @@ module StackRep = struct
     | Const.Lit (Const.Word64 n) -> BoxedWord64.lit env n
     | Const.Lit (Const.Float64 f) -> Float.lit env f
     | Const.Opt c -> Opt.inject env (materialize_constant env c)
-    | Const.Fun (get_fi, _) -> compile_unboxed_const (Closure.static_closure env (get_fi ())) (* TODO: Redesign for heap allocations *)
+    | Const.Fun (get_fi, _) -> Closure.alloc env (get_fi ())
     | Const.Message fi -> assert false
     | Const.Unit -> compile_unboxed_const Tuple.unit_vanilla_lit (* TODO: Redesign for heap allocations *)
     | Const.Tag (i, c) -> Variant.inject env i (materialize_constant env c)

From 09c066398ce13484eef39316ffabd09c678a6f80 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 11 Aug 2023 15:01:53 +0200
Subject: [PATCH 018/260] Code refactoring

---
 src/codegen/compile.ml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 784feec5fb4..83b62fab09d 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -7571,7 +7571,7 @@ module StackRep = struct
     | Const.Opt c -> Opt.inject env (materialize_constant env c)
     | Const.Fun (get_fi, _) -> Closure.alloc env (get_fi ())
     | Const.Message fi -> assert false
-    | Const.Unit -> compile_unboxed_const Tuple.unit_vanilla_lit (* TODO: Redesign for heap allocations *)
+    | Const.Unit -> Tuple.compile_unit
     | Const.Tag (i, c) -> Variant.inject env i (materialize_constant env c)
 
     | Const.Lit (Const.Vanilla n) -> assert false

From 8f92638ceed01ce80cd59cfbaf3576a3a4aa95f7 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 11 Aug 2023 15:03:07 +0200
Subject: [PATCH 019/260] Code refactoring

---
 src/codegen/compile.ml | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 83b62fab09d..fb0649423a2 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -7573,10 +7573,7 @@ module StackRep = struct
     | Const.Message fi -> assert false
     | Const.Unit -> Tuple.compile_unit
     | Const.Tag (i, c) -> Variant.inject env i (materialize_constant env c)
-
-    | Const.Lit (Const.Vanilla n) -> assert false
-    | Const.Array cs -> assert false
-    | Const.Obj l -> assert false
+    | _ -> assert false
 
   let adjust env (sr_in : t) sr_out =
     if eq sr_in sr_out

From b7a43804b9a77e6c6890536907d5577d591f7cbd Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 11 Aug 2023 15:26:27 +0200
Subject: [PATCH 020/260] Simplify blob/text data segments

---
 src/codegen/compile.ml | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index fb0649423a2..412cecb3b31 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -567,7 +567,7 @@ module E = struct
       let ptr = add_mutable_static_bytes env b  in
       env.static_strings := StringEnv.add b ptr !(env.static_strings);
       ptr
-
+  
   let object_pool_find (env: t) (key: string) : int32 option =
     StringEnv.find_opt key !(env.object_pool)
 
@@ -1574,7 +1574,7 @@ module Tagged = struct
     | Bits32 (* Contains a 32 bit unsigned number *)
     | BigInt
     | Concat (* String concatenation, used by rts/text.c *)
-    | Null (* For opt. Static singleton! *)
+    | Null (* For opt. Singleton in persistent heap *)
     | OneWordFiller (* Only used by the RTS *)
     | FreeSpace (* Only used by the RTS *)
     | ArraySliceMinimum (* Used by the GC for incremental array marking *)
@@ -3626,14 +3626,11 @@ module Blob = struct
       BigNum.from_word32 env
     )
 
-  let static_lit env s =
-    Tagged.shared_static_obj env Tagged.Blob StaticBytes.[
-      I32 (Int32.of_int (String.length s));
-      Bytes s;
-    ]
+  let static_data env s =
+    compile_unboxed_const (Int32.add ptr_unskew (E.add_static env StaticBytes.[Bytes s]))
 
   let lit_ptr_len env s =
-    compile_unboxed_const (Int32.add ptr_unskew (E.add_static env StaticBytes.[Bytes s])) ^^
+    static_data env s ^^
     compile_unboxed_const (Int32.of_int (String.length s))
 
   let alloc env =
@@ -3652,7 +3649,7 @@ module Blob = struct
     let (set_new_blob, get_new_blob) = new_local env "new_blob" in
     compile_unboxed_const blob_length ^^ alloc env ^^ set_new_blob ^^
     get_new_blob ^^ payload_ptr_unskewed env ^^ (* target address *)
-    compile_unboxed_const (static_lit env s) ^^ payload_ptr_unskewed env ^^ (* source address *)
+    static_data env s ^^ (* source address *)
     compile_unboxed_const blob_length ^^ (* copy length *)
     Heap.memcpy env ^^
     get_new_blob

From ec9a29bf8bc63109ddc1070857a1fc1faf5e410b Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 11 Aug 2023 16:05:56 +0200
Subject: [PATCH 021/260] Simplify code

---
 src/codegen/compile.ml | 66 +++---------------------------------------
 1 file changed, 4 insertions(+), 62 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 412cecb3b31..ad5dfe72bb3 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -279,13 +279,6 @@ module E = struct
     named_imports : int32 NameEnv.t ref;
     built_in_funcs : lazy_function NameEnv.t ref;
     static_strings : int32 StringEnv.t ref;
-      (* Pool for shared static objects. Their lookup needs to be specifically
-         handled by using the tag and the payload without the forwarding pointer.
-         This is because the forwarding pointer depends on the allocation adddress.
-         The lookup is different to `static_string` that has no such
-         allocation-dependent content and can thus be immediately looked up by
-         the string value. *)
-    object_pool : int32 StringEnv.t ref;
     end_of_static_memory : int32 ref; (* End of statically allocated memory *)
     static_memory : (int32 * string) list ref; (* Content of static memory *)
     static_memory_frozen : bool ref;
@@ -334,7 +327,6 @@ module E = struct
     named_imports = ref NameEnv.empty;
     built_in_funcs = ref NameEnv.empty;
     static_strings = ref StringEnv.empty;
-    object_pool = ref StringEnv.empty;
     end_of_static_memory = ref dyn_mem;
     static_memory = ref [];
     static_memory_frozen = ref false;
@@ -535,10 +527,6 @@ module E = struct
     env.end_of_static_memory := Int32.add ptr aligned;
     ptr
 
-  let write_static_memory (env : t) ptr data =
-    env.static_memory := !(env.static_memory) @ [ (ptr, data) ];
-    ()
-
   let add_mutable_static_bytes (env : t) data : int32 =
     let ptr = reserve_static_memory env (Int32.of_int (String.length data)) in
     env.static_memory := !(env.static_memory) @ [ (ptr, data) ];
@@ -568,13 +556,6 @@ module E = struct
       env.static_strings := StringEnv.add b ptr !(env.static_strings);
       ptr
   
-  let object_pool_find (env: t) (key: string) : int32 option =
-    StringEnv.find_opt key !(env.object_pool)
-
-  let object_pool_add (env: t) (key: string) (ptr : int32)  : unit =
-    env.object_pool := StringEnv.add key ptr !(env.object_pool);
-    ()
-
   let add_static_unskewed (env : t) (data : StaticBytes.t) : int32 =
     Int32.add (add_static env data) ptr_unskew
 
@@ -676,17 +657,6 @@ let compile_eq64_const i =
   compile_const_64 i ^^
   G.i (Compare (Wasm.Values.I64 I64Op.Eq))
 
-(* more random utilities *)
-
-let bytes_of_int32 (i : int32) : string =
-  let b = Buffer.create 4 in
-  let i = Int32.to_int i in
-  Buffer.add_char b (Char.chr (i land 0xff));
-  Buffer.add_char b (Char.chr ((i lsr 8) land 0xff));
-  Buffer.add_char b (Char.chr ((i lsr 16) land 0xff));
-  Buffer.add_char b (Char.chr ((i lsr 24) land 0xff));
-  Buffer.contents b
-
 (* A common variant of todo *)
 
 let todo_trap env fn se = todo fn se (E.trap_with env ("TODO: " ^ fn))
@@ -1839,34 +1809,6 @@ module Tagged = struct
     get_object ^^
     allocation_barrier env
 
-  let new_static_obj env tag payload =
-    let payload = StaticBytes.as_bytes payload in
-    let header_size = Int32.(mul Heap.word_size (header_size env)) in
-    let size = Int32.(add header_size (Int32.of_int (String.length payload))) in
-    let unskewed_ptr = E.reserve_static_memory env size in
-    let skewed_ptr = Int32.(add unskewed_ptr ptr_skew) in
-    let tag = bytes_of_int32 (int_of_tag tag) in
-    let forward = bytes_of_int32 skewed_ptr in (* forwarding pointer *)
-    (if !Flags.gc_strategy = Flags.Incremental then
-      let incremental_gc_data = tag ^ forward ^ payload in
-      E.write_static_memory env unskewed_ptr incremental_gc_data
-    else
-      let non_incremental_gc_data = tag ^ payload in
-      E.write_static_memory env unskewed_ptr non_incremental_gc_data
-    );
-    skewed_ptr
-
-  let shared_static_obj env tag payload =
-    let tag_word = bytes_of_int32 (int_of_tag tag) in
-    let payload_bytes = StaticBytes.as_bytes payload in
-    let key = tag_word ^ payload_bytes in
-    match E.object_pool_find env key with
-    | Some ptr -> ptr (* no forwarding pointer dereferencing needed as static objects do not move *)
-    | None ->
-      let ptr = new_static_obj env tag payload in
-      E.object_pool_add env key ptr;
-      ptr
-
 end (* Tagged *)
 
 module MutBox = struct
@@ -6019,11 +5961,11 @@ module MakeSerialization (Strm : Stream) = struct
 
   (* This value is returned by deserialize_go if deserialization fails in a way
      that should be recoverable by opt parsing.
-     By virtue of being a deduped static value, it can be detected by pointer
-     comparison.
+     It is an (invalid) sentinel pointer value (in skewed format) and can be used for pointer comparison.
+     It will be never placed on the heap and must not be dereferenced.
+     If unskewed, it refers to the unallocated last Wasm memory page.
   *)
-  let coercion_error_value env : int32 =
-    Tagged.shared_static_obj env Tagged.CoercionFailure []
+  let coercion_error_value env = 0xffff_fffdl
 
   (* See Note [Candid subtype checks] *)
   let with_rel_buf_opt env extended get_typtbl_size1 f =

From 5c1d5aaeaf8bc319bd7b7ac51e6e80e83d92a800 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 14 Aug 2023 09:14:59 +0200
Subject: [PATCH 022/260] Fix typo

---
 rts/motoko-rts/src/gc/incremental.rs          | 14 +++++++-------
 rts/motoko-rts/src/gc/incremental/barriers.rs |  8 ++++----
 rts/motoko-rts/src/persistence.rs             |  2 +-
 3 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/rts/motoko-rts/src/gc/incremental.rs b/rts/motoko-rts/src/gc/incremental.rs
index 2a016d4aec3..344ff51cd21 100644
--- a/rts/motoko-rts/src/gc/incremental.rs
+++ b/rts/motoko-rts/src/gc/incremental.rs
@@ -11,7 +11,7 @@ use motoko_rts_macros::ic_mem_fn;
 
 use crate::{
     memory::Memory,
-    persistence::{get_incremenmtal_gc_state, initialize_memory, HEAP_START},
+    persistence::{get_incremental_gc_state, initialize_memory, HEAP_START},
     types::*,
     visitor::visit_pointer_fields,
 };
@@ -43,12 +43,12 @@ pub mod time;
 unsafe fn initialize_incremental_gc<M: Memory>(mem: &mut M) {
     println!(100, "INITIALIZE INCREMENTAL GC");
     initialize_memory(mem);
-    IncrementalGC::<M>::initialize(mem, get_incremenmtal_gc_state(), HEAP_START);
+    IncrementalGC::<M>::initialize(mem, get_incremental_gc_state(), HEAP_START);
 }
 
 #[ic_mem_fn(ic_only)]
 unsafe fn schedule_incremental_gc<M: Memory>(mem: &mut M) {
-    let state = get_incremenmtal_gc_state();
+    let state = get_incremental_gc_state();
     assert!(state.phase != Phase::Stop);
     let running = state.phase != Phase::Pause;
     if running || should_start() {
@@ -59,7 +59,7 @@ unsafe fn schedule_incremental_gc<M: Memory>(mem: &mut M) {
 #[ic_mem_fn(ic_only)]
 unsafe fn incremental_gc<M: Memory>(mem: &mut M) {
     use self::roots::root_set;
-    let state = get_incremenmtal_gc_state();
+    let state = get_incremental_gc_state();
     if state.phase == Phase::Pause {
         record_gc_start::<M>();
     }
@@ -392,12 +392,12 @@ unsafe fn count_allocation(state: &mut State) {
 /// the compiler must not schedule the GC during stabilization anyway.
 #[no_mangle]
 pub unsafe extern "C" fn stop_gc_on_upgrade() {
-    get_incremenmtal_gc_state().phase = Phase::Stop;
+    get_incremental_gc_state().phase = Phase::Stop;
 }
 
 pub unsafe fn get_partitioned_heap() -> &'static mut PartitionedHeap {
-    debug_assert!(get_incremenmtal_gc_state()
+    debug_assert!(get_incremental_gc_state()
         .partitioned_heap
         .is_initialized());
-    &mut get_incremenmtal_gc_state().partitioned_heap
+    &mut get_incremental_gc_state().partitioned_heap
 }
diff --git a/rts/motoko-rts/src/gc/incremental/barriers.rs b/rts/motoko-rts/src/gc/incremental/barriers.rs
index ca8f351bbce..ce24ae2cdec 100644
--- a/rts/motoko-rts/src/gc/incremental/barriers.rs
+++ b/rts/motoko-rts/src/gc/incremental/barriers.rs
@@ -6,7 +6,7 @@ use motoko_rts_macros::ic_mem_fn;
 
 use crate::{
     memory::Memory,
-    persistence::get_incremenmtal_gc_state,
+    persistence::get_incremental_gc_state,
     types::{is_skewed, Value},
 };
 
@@ -14,7 +14,7 @@ use super::{count_allocation, post_allocation_barrier, pre_write_barrier, Phase}
 
 #[no_mangle]
 pub unsafe extern "C" fn running_gc() -> bool {
-    get_incremenmtal_gc_state().phase != Phase::Pause
+    get_incremental_gc_state().phase != Phase::Pause
 }
 
 /// Write a potential pointer value with a pre-update barrier and resolving pointer forwarding.
@@ -30,7 +30,7 @@ pub unsafe fn write_with_barrier<M: Memory>(mem: &mut M, location: *mut Value, v
     debug_assert!(!is_skewed(location as u32));
     debug_assert_ne!(location, core::ptr::null_mut());
 
-    let state = get_incremenmtal_gc_state();
+    let state = get_incremental_gc_state();
     pre_write_barrier(mem, state, *location);
     *location = value.forward_if_possible();
 }
@@ -47,7 +47,7 @@ pub unsafe fn write_with_barrier<M: Memory>(mem: &mut M, location: *mut Value, v
 /// * Keep track of concurrent allocations to adjust the GC increment time limit.
 #[no_mangle]
 pub unsafe extern "C" fn allocation_barrier(new_object: Value) -> Value {
-    let state = get_incremenmtal_gc_state();
+    let state = get_incremental_gc_state();
     if state.phase != Phase::Pause {
         post_allocation_barrier(state, new_object);
         count_allocation(state);
diff --git a/rts/motoko-rts/src/persistence.rs b/rts/motoko-rts/src/persistence.rs
index cebd977d7a4..b6aac045f35 100644
--- a/rts/motoko-rts/src/persistence.rs
+++ b/rts/motoko-rts/src/persistence.rs
@@ -146,7 +146,7 @@ pub(crate) unsafe fn null_singleton_location() -> *mut Value {
 }
 
 // GC root pointer required for GC marking and updating.
-pub(crate) unsafe fn get_incremenmtal_gc_state() -> &'static mut State {
+pub(crate) unsafe fn get_incremental_gc_state() -> &'static mut State {
     let metadata = PersistentMetadata::get();
     &mut (*metadata).incremental_gc_state
 }

From ebba6fb85fa2e6eb22d4eef4956a8e2d62258ec6 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 14 Aug 2023 09:58:51 +0200
Subject: [PATCH 023/260] Adjust RTS unit testing

---
 rts/motoko-rts-tests/src/gc.rs                | 31 ++++++++------
 .../src/gc/incremental/roots.rs               | 11 +++--
 rts/motoko-rts/src/gc/incremental.rs          | 40 ++++++++++++++-----
 rts/motoko-rts/src/gc/incremental/barriers.rs |  5 ++-
 .../src/gc/incremental/mark_bitmap.rs         |  5 ++-
 .../src/gc/incremental/mark_stack.rs          |  1 +
 .../src/gc/incremental/partitioned_heap.rs    | 37 +++++++++++++++++
 .../gc/incremental/phases/mark_increment.rs   |  2 +
 rts/motoko-rts/src/gc/incremental/roots.rs    | 13 +++---
 rts/motoko-rts/src/lib.rs                     |  1 +
 rts/motoko-rts/src/persistence.rs             |  2 +
 11 files changed, 113 insertions(+), 35 deletions(-)

diff --git a/rts/motoko-rts-tests/src/gc.rs b/rts/motoko-rts-tests/src/gc.rs
index faacd4301c8..82485952eff 100644
--- a/rts/motoko-rts-tests/src/gc.rs
+++ b/rts/motoko-rts-tests/src/gc.rs
@@ -168,9 +168,11 @@ fn initialize_gc(_heap: &mut MotokoHeap) {}
 
 #[incremental_gc]
 fn initialize_gc(heap: &mut MotokoHeap) {
-    use motoko_rts::gc::incremental::{get_partitioned_heap, IncrementalGC};
+    use motoko_rts::gc::incremental::{
+        get_incremental_gc_state, get_partitioned_heap, IncrementalGC,
+    };
     unsafe {
-        IncrementalGC::initialize(heap, heap.heap_base_address());
+        IncrementalGC::initialize(heap, get_incremental_gc_state(), heap.heap_base_address());
         let allocation_size = heap.heap_ptr_address() - heap.heap_base_address();
 
         // Synchronize the partitioned heap with one big combined allocation by starting from the base pointer as the heap pointer.
@@ -188,11 +190,13 @@ fn reset_gc() {}
 #[incremental_gc]
 fn reset_gc() {
     use crate::memory::TestMemory;
-    use motoko_rts::gc::incremental::{partitioned_heap::PARTITION_SIZE, IncrementalGC};
+    use motoko_rts::gc::incremental::{
+        get_incremental_gc_state, partitioned_heap::PARTITION_SIZE, IncrementalGC,
+    };
 
     let mut memory = TestMemory::new(Words(PARTITION_SIZE as u32));
     unsafe {
-        IncrementalGC::initialize(&mut memory, 0);
+        IncrementalGC::initialize(&mut memory, get_incremental_gc_state(), 0);
     }
 }
 
@@ -534,19 +538,22 @@ impl GC {
 
     #[incremental_gc]
     fn run(&self, heap: &mut MotokoHeap, _round: usize) -> bool {
-        let static_roots = Value::from_ptr(heap.static_root_array_address());
-        let continuation_table_ptr_address = heap.continuation_table_ptr_address() as *mut Value;
+        let static_root = heap.static_root_array_address() as *mut Value;
+        let continuation_table_location = heap.continuation_table_ptr_address() as *mut Value;
+        let unused_root = &mut Value::from_scalar(0) as *mut Value;
 
         match self {
             GC::Incremental => unsafe {
-                use motoko_rts::gc::incremental::{incremental_gc_state, IncrementalGC};
+                use motoko_rts::gc::incremental::{get_incremental_gc_state, IncrementalGC};
                 const INCREMENTS_UNTIL_COMPLETION: usize = 16;
                 for _ in 0..INCREMENTS_UNTIL_COMPLETION {
-                    let roots = motoko_rts::gc::incremental::roots::Roots {
-                        static_roots,
-                        continuation_table_location: continuation_table_ptr_address,
-                    };
-                    IncrementalGC::instance(heap, incremental_gc_state())
+                    let roots = [
+                        static_root,
+                        continuation_table_location,
+                        unused_root,
+                        unused_root,
+                    ];
+                    IncrementalGC::instance(heap, get_incremental_gc_state())
                         .empty_call_stack_increment(roots);
                 }
                 false
diff --git a/rts/motoko-rts-tests/src/gc/incremental/roots.rs b/rts/motoko-rts-tests/src/gc/incremental/roots.rs
index ddcfd3e03bd..9f34b110454 100644
--- a/rts/motoko-rts-tests/src/gc/incremental/roots.rs
+++ b/rts/motoko-rts-tests/src/gc/incremental/roots.rs
@@ -65,13 +65,16 @@ unsafe fn check_visit_continuation_table(heap: &MotokoHeap, continuation_ids: &[
 }
 
 unsafe fn get_roots(heap: &MotokoHeap) -> Roots {
-    let static_roots = Value::from_ptr(heap.static_root_array_address());
+    let static_root = heap.static_root_array_address() as *mut Value;
     let continuation_table_location = heap.continuation_table_ptr_address() as *mut Value;
+    let unused_root = &mut Value::from_scalar(0) as *mut Value;
     assert_ne!(continuation_table_location, null_mut());
-    Roots {
-        static_roots,
+    [
+        static_root,
         continuation_table_location,
-    }
+        unused_root,
+        unused_root,
+    ]
 }
 
 fn object_id(heap: &MotokoHeap, address: usize) -> u32 {
diff --git a/rts/motoko-rts/src/gc/incremental.rs b/rts/motoko-rts/src/gc/incremental.rs
index 344ff51cd21..1d80b03fcb1 100644
--- a/rts/motoko-rts/src/gc/incremental.rs
+++ b/rts/motoko-rts/src/gc/incremental.rs
@@ -9,12 +9,7 @@
 
 use motoko_rts_macros::ic_mem_fn;
 
-use crate::{
-    memory::Memory,
-    persistence::{get_incremental_gc_state, initialize_memory, HEAP_START},
-    types::*,
-    visitor::visit_pointer_fields,
-};
+use crate::{memory::Memory, types::*, visitor::visit_pointer_fields};
 
 use self::{
     partitioned_heap::{PartitionedHeap, PartitionedHeapIterator},
@@ -41,7 +36,8 @@ pub mod time;
 
 #[ic_mem_fn(ic_only)]
 unsafe fn initialize_incremental_gc<M: Memory>(mem: &mut M) {
-    println!(100, "INITIALIZE INCREMENTAL GC");
+    use crate::persistence::{initialize_memory, HEAP_START};
+
     initialize_memory(mem);
     IncrementalGC::<M>::initialize(mem, get_incremental_gc_state(), HEAP_START);
 }
@@ -104,6 +100,7 @@ unsafe fn record_gc_start<M: Memory>() {
 #[cfg(feature = "ic")]
 unsafe fn record_gc_stop<M: Memory>() {
     use crate::memory::ic::{self, partitioned_memory};
+    use crate::persistence::HEAP_START;
 
     let heap_size = partitioned_memory::get_heap_size();
     let static_size = Bytes(HEAP_START as u32);
@@ -134,6 +131,7 @@ const INCREMENT_ALLOCATION_FACTOR: usize = 10; // Additional time factor per con
 
 // Performance note: Storing the phase-specific state in the enum would be nicer but it is much slower.
 #[derive(PartialEq)]
+#[repr(C)]
 enum Phase {
     Pause,    // Inactive, waiting for the next GC run.
     Mark,     // Incremental marking.
@@ -143,6 +141,8 @@ enum Phase {
 }
 
 /// GC state retained over multiple GC increments.
+/// Use a long-term representation by relying on C layout.
+#[repr(C)]
 pub struct State {
     phase: Phase,
     partitioned_heap: PartitionedHeap,
@@ -188,7 +188,6 @@ impl<'a, M: Memory + 'a> IncrementalGC<'a, M> {
     /// * The mark phase can only be started on an empty call stack.
     /// * The update phase can only be completed on an empty call stack.
     pub unsafe fn empty_call_stack_increment(&mut self, roots: Roots) {
-        println!(100, "GC INCREMENT");
         assert!(self.state.phase != Phase::Stop);
         if self.pausing() {
             self.start_marking(roots);
@@ -396,8 +395,27 @@ pub unsafe extern "C" fn stop_gc_on_upgrade() {
 }
 
 pub unsafe fn get_partitioned_heap() -> &'static mut PartitionedHeap {
-    debug_assert!(get_incremental_gc_state()
-        .partitioned_heap
-        .is_initialized());
+    debug_assert!(get_incremental_gc_state().partitioned_heap.is_initialized());
     &mut get_incremental_gc_state().partitioned_heap
 }
+
+#[cfg(feature = "ic")]
+pub unsafe fn get_incremental_gc_state() -> &'static mut State {
+    crate::persistence::get_incremental_gc_state()
+}
+
+// For RTS unit testing only.
+#[cfg(not(feature = "ic"))]
+static mut TEST_GC_STATE: State = State {
+    phase: Phase::Pause,
+    partitioned_heap: partitioned_heap::UNINITIALIZED_HEAP,
+    allocation_count: 0,
+    mark_state: None,
+    iterator_state: None,
+};
+
+// For RTS unit testing only.
+#[cfg(not(feature = "ic"))]
+pub unsafe fn get_incremental_gc_state() -> &'static mut State {
+    &mut TEST_GC_STATE
+}
diff --git a/rts/motoko-rts/src/gc/incremental/barriers.rs b/rts/motoko-rts/src/gc/incremental/barriers.rs
index ce24ae2cdec..091c255892a 100644
--- a/rts/motoko-rts/src/gc/incremental/barriers.rs
+++ b/rts/motoko-rts/src/gc/incremental/barriers.rs
@@ -6,11 +6,12 @@ use motoko_rts_macros::ic_mem_fn;
 
 use crate::{
     memory::Memory,
-    persistence::get_incremental_gc_state,
     types::{is_skewed, Value},
 };
 
-use super::{count_allocation, post_allocation_barrier, pre_write_barrier, Phase};
+use super::{
+    count_allocation, get_incremental_gc_state, post_allocation_barrier, pre_write_barrier, Phase,
+};
 
 #[no_mangle]
 pub unsafe extern "C" fn running_gc() -> bool {
diff --git a/rts/motoko-rts/src/gc/incremental/mark_bitmap.rs b/rts/motoko-rts/src/gc/incremental/mark_bitmap.rs
index 8afc38e73d9..d6f5cde880f 100644
--- a/rts/motoko-rts/src/gc/incremental/mark_bitmap.rs
+++ b/rts/motoko-rts/src/gc/incremental/mark_bitmap.rs
@@ -31,11 +31,13 @@ const BITMAP_FRACTION: usize = (WORD_SIZE * u8::BITS) as usize;
 pub const BITMAP_SIZE: usize = PARTITION_SIZE / BITMAP_FRACTION;
 
 /// Partition-associated mark bitmap.
+/// Use a long-term representation by relying on C layout.
+#[repr(C)]
 pub struct MarkBitmap {
     pointer: *mut u8,
 }
 
-const DEFAULT_MARK_BITMAP: MarkBitmap = MarkBitmap {
+pub(crate) const DEFAULT_MARK_BITMAP: MarkBitmap = MarkBitmap {
     pointer: null_mut(),
 };
 
@@ -97,6 +99,7 @@ impl MarkBitmap {
 /// Adopted and adjusted from `mark_compact/bitmap.rs`.
 /// The iterator separates advancing `next()` from inspection `current_marked_offset()`
 /// to better support the incremental evacuation and update GC increments.
+#[repr(C)]
 pub struct BitmapIterator {
     /// Start address of the mark bitmap. Must be 64-bit-aligned.
     bitmap_pointer: *mut u8,
diff --git a/rts/motoko-rts/src/gc/incremental/mark_stack.rs b/rts/motoko-rts/src/gc/incremental/mark_stack.rs
index b5d249c7245..8e192e93598 100644
--- a/rts/motoko-rts/src/gc/incremental/mark_stack.rs
+++ b/rts/motoko-rts/src/gc/incremental/mark_stack.rs
@@ -31,6 +31,7 @@ use core::ptr::null_mut;
 use crate::memory::{alloc_blob, Memory};
 use crate::types::{size_of, Blob, Value};
 
+#[repr(C)]
 pub struct MarkStack {
     last: *mut StackTable,
     top: usize, // index of next free entry in the last stack table
diff --git a/rts/motoko-rts/src/gc/incremental/partitioned_heap.rs b/rts/motoko-rts/src/gc/incremental/partitioned_heap.rs
index 4984dd2dc7d..2a48e1f5e6f 100644
--- a/rts/motoko-rts/src/gc/incremental/partitioned_heap.rs
+++ b/rts/motoko-rts/src/gc/incremental/partitioned_heap.rs
@@ -73,6 +73,8 @@ const MAX_PARTITIONS: usize = (WASM_MEMORY_BYTE_SIZE.0 / PARTITION_SIZE as u64)
 pub const SURVIVAL_RATE_THRESHOLD: f64 = 0.85;
 
 /// Heap partition of size `PARTITION_SIZE`.
+/// Use a long-term representation by relying on C layout.
+#[repr(C)]
 pub struct Partition {
     index: usize,        // Index of the partition `0..MAX_PARTITIONS`.
     free: bool,          // Denotes a free partition (which may still contain static space).
@@ -86,6 +88,22 @@ pub struct Partition {
     update: bool,        // Specifies whether the pointers in the partition have to be updated.
 }
 
+/// For RTS unit testing only.
+/// Optimization: Avoiding `Option` or `Lazy`.
+#[cfg(not(feature = "ic"))]
+const UNINITIALIZED_PARTITION: Partition = Partition {
+    index: usize::MAX,
+    free: false,
+    large_content: false,
+    marked_size: 0,
+    static_size: 0,
+    dynamic_size: 0,
+    bitmap: super::mark_bitmap::DEFAULT_MARK_BITMAP,
+    temporary: false,
+    evacuate: false,
+    update: false,
+};
+
 impl Partition {
     pub fn get_index(&self) -> usize {
         self.index
@@ -222,6 +240,8 @@ impl Partition {
 
 /// Iterates over all partitions and their contained marked objects, by skipping
 /// free partitions, the subsequent partitions of large objects, and unmarked objects.
+/// Use a long-term representation by relying on C layout.
+#[repr(C)]
 pub struct PartitionedHeapIterator {
     partition_index: usize,
     bitmap_iterator: Option<BitmapIterator>,
@@ -330,6 +350,8 @@ impl PartitionedHeapIterator {
 }
 
 /// Partitioned heap used by the incremental GC.
+/// Use a long-term representation by relying on C layout.
+#[repr(C)]
 pub struct PartitionedHeap {
     partitions: [Partition; MAX_PARTITIONS],
     heap_base: usize,
@@ -342,6 +364,21 @@ pub struct PartitionedHeap {
     precomputed_heap_size: usize, // Occupied heap size, excluding the dynamic heap in the allocation partition.
 }
 
+/// For RTS unit testing only.
+/// Optimization: Avoiding `Option` or `LazyCell`.
+#[cfg(not(feature = "ic"))]
+pub const UNINITIALIZED_HEAP: PartitionedHeap = PartitionedHeap {
+    partitions: [UNINITIALIZED_PARTITION; MAX_PARTITIONS],
+    heap_base: 0,
+    allocation_index: 0,
+    free_partitions: 0,
+    evacuating: false,
+    reclaimed: 0,
+    bitmap_allocation_pointer: 0,
+    gc_running: false,
+    precomputed_heap_size: 0,
+};
+
 impl PartitionedHeap {
     pub unsafe fn new<M: Memory>(mem: &mut M, heap_base: usize) -> PartitionedHeap {
         let allocation_index = heap_base / PARTITION_SIZE;
diff --git a/rts/motoko-rts/src/gc/incremental/phases/mark_increment.rs b/rts/motoko-rts/src/gc/incremental/phases/mark_increment.rs
index 298a4562711..4580fb32ebe 100644
--- a/rts/motoko-rts/src/gc/incremental/phases/mark_increment.rs
+++ b/rts/motoko-rts/src/gc/incremental/phases/mark_increment.rs
@@ -12,6 +12,8 @@ use crate::{
     visitor::visit_pointer_fields,
 };
 
+/// Use a long-term representation by relying on C layout.
+#[repr(C)]
 pub struct MarkState {
     mark_stack: MarkStack,
     complete: bool,
diff --git a/rts/motoko-rts/src/gc/incremental/roots.rs b/rts/motoko-rts/src/gc/incremental/roots.rs
index d1fd77f7a51..4de6a99d73f 100644
--- a/rts/motoko-rts/src/gc/incremental/roots.rs
+++ b/rts/motoko-rts/src/gc/incremental/roots.rs
@@ -1,12 +1,11 @@
 use motoko_rts_macros::ic_mem_fn;
 
-use crate::{memory::Memory, types::Value, visitor::pointer_to_dynamic_heap};
-
-use super::barriers::write_with_barrier;
+use crate::{types::Value, visitor::pointer_to_dynamic_heap};
 
 /// Root referring to all canister variables.
 /// This root is reinitialized on each canister upgrade.
 /// The scalar sentinel denotes an uninitialized root.
+#[cfg(feature = "ic")]
 static mut STATIC_ROOT: Value = Value::from_scalar(0);
 
 /// GC root set.
@@ -40,17 +39,21 @@ pub unsafe fn visit_roots<C, V: Fn(&mut C, *mut Value)>(
     }
 }
 
+#[cfg(feature = "ic")]
 unsafe fn static_root_location() -> *mut Value {
     &mut STATIC_ROOT as *mut Value
 }
 
-#[ic_mem_fn]
-pub unsafe fn set_static_root<M: Memory>(mem: &mut M, value: Value) {
+#[ic_mem_fn(ic_only)]
+pub unsafe fn set_static_root<M: crate::memory::Memory>(mem: &mut M, value: Value) {
+    use super::barriers::write_with_barrier;
+
     let location = &mut STATIC_ROOT as *mut Value;
     write_with_barrier(mem, location, value);
 }
 
 #[no_mangle]
+#[cfg(feature = "ic")]
 pub unsafe extern "C" fn get_static_root() -> Value {
     assert!(STATIC_ROOT.is_ptr());
     STATIC_ROOT
diff --git a/rts/motoko-rts/src/lib.rs b/rts/motoko-rts/src/lib.rs
index 2a2adf34d79..af5c503f6f9 100644
--- a/rts/motoko-rts/src/lib.rs
+++ b/rts/motoko-rts/src/lib.rs
@@ -32,6 +32,7 @@ pub mod leb128;
 mod mem_utils;
 pub mod memory;
 #[incremental_gc]
+#[cfg(feature = "ic")]
 pub mod persistence;
 pub mod principal_id;
 mod static_checks;
diff --git a/rts/motoko-rts/src/persistence.rs b/rts/motoko-rts/src/persistence.rs
index b6aac045f35..06af1dc9126 100644
--- a/rts/motoko-rts/src/persistence.rs
+++ b/rts/motoko-rts/src/persistence.rs
@@ -86,6 +86,7 @@ impl PersistentMetadata {
 
 /// Initialize fresh peristent memory after the canister installation or
 /// reuse the persistent memory on a canister upgrade.
+#[cfg(feature = "ic")]
 pub unsafe fn initialize_memory<M: Memory>(mem: &mut M) {
     mem.grow_memory(HEAP_START as u64);
     let metadata = PersistentMetadata::get();
@@ -146,6 +147,7 @@ pub(crate) unsafe fn null_singleton_location() -> *mut Value {
 }
 
 // GC root pointer required for GC marking and updating.
+#[cfg(feature = "ic")]
 pub(crate) unsafe fn get_incremental_gc_state() -> &'static mut State {
     let metadata = PersistentMetadata::get();
     &mut (*metadata).incremental_gc_state

From a1ba8032311f471fcd3e1cd7e6a23c6b8ecc838d Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 14 Aug 2023 10:04:30 +0200
Subject: [PATCH 024/260] Guard against static heap pointers

---
 rts/motoko-rts/src/visitor.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/rts/motoko-rts/src/visitor.rs b/rts/motoko-rts/src/visitor.rs
index 7c05492e269..47108bc6935 100644
--- a/rts/motoko-rts/src/visitor.rs
+++ b/rts/motoko-rts/src/visitor.rs
@@ -129,5 +129,7 @@ pub unsafe fn visit_pointer_fields<C, F, G>(
 pub unsafe fn pointer_to_dynamic_heap(field_addr: *mut Value, heap_base: usize) -> bool {
     // NB. pattern matching on `field_addr.get()` generates inefficient code
     let field_value = (*field_addr).get_raw();
-    is_ptr(field_value) && unskew(field_value as usize) >= heap_base
+    // NOTE: Pointers to static space is no longer allowed.
+    debug_assert!(!is_ptr(field_value) || unskew(field_value as usize) >= heap_base);
+    is_ptr(field_value)
 }

From 39ecec0ab8084774bc2b9f4b3d5dcf914bee9c6d Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 14 Aug 2023 16:06:04 +0200
Subject: [PATCH 025/260] Remove static heap in GC unit test

---
 rts/motoko-rts-tests/src/gc.rs                | 107 ++++++--
 rts/motoko-rts-tests/src/gc/heap.rs           | 256 +++++++++---------
 .../src/gc/incremental/roots.rs               |   4 +-
 rts/motoko-rts/src/debug.rs                   |   8 +-
 4 files changed, 221 insertions(+), 154 deletions(-)

diff --git a/rts/motoko-rts-tests/src/gc.rs b/rts/motoko-rts-tests/src/gc.rs
index 82485952eff..d5931ebcc2d 100644
--- a/rts/motoko-rts-tests/src/gc.rs
+++ b/rts/motoko-rts-tests/src/gc.rs
@@ -141,7 +141,8 @@ fn test_gc(
         &**heap.heap(),
         heap.heap_base_offset(),
         heap.heap_ptr_offset(),
-        heap.continuation_table_ptr_offset(),
+        heap.static_root_array_variable_offset(),
+        heap.continuation_table_variable_offset(),
     );
 
     for round in 0..3 {
@@ -149,7 +150,8 @@ fn test_gc(
 
         let heap_base_offset = heap.heap_base_offset();
         let heap_ptr_offset = heap.heap_ptr_offset();
-        let continuation_table_ptr_offset = heap.continuation_table_ptr_offset();
+        let static_array_variable_offset = heap.static_root_array_variable_offset();
+        let continuation_table_variable_offset = heap.continuation_table_variable_offset();
         check_dynamic_heap(
             check_all_reclaimed, // check for unreachable objects
             refs,
@@ -158,7 +160,8 @@ fn test_gc(
             &**heap.heap(),
             heap_base_offset,
             heap_ptr_offset,
-            continuation_table_ptr_offset,
+            static_array_variable_offset,
+            continuation_table_variable_offset,
         );
     }
 }
@@ -217,7 +220,8 @@ fn check_dynamic_heap(
     heap: &[u8],
     heap_base_offset: usize,
     heap_ptr_offset: usize,
-    continuation_table_ptr_offset: usize,
+    static_root_array_variable_offset: usize, 
+    continuation_table_variable_offset: usize,
 ) {
     let incremental = cfg!(feature = "incremental_gc");
     let objects_map: FxHashMap<ObjectIdx, &[ObjectIdx]> = objects
@@ -231,8 +235,11 @@ fn check_dynamic_heap(
     // Maps objects to their addresses (not offsets!). Used when debugging duplicate objects.
     let mut seen: FxHashMap<ObjectIdx, usize> = Default::default();
 
-    let continuation_table_addr = unskew_pointer(read_word(heap, continuation_table_ptr_offset));
-    let continuation_table_offset = continuation_table_addr as usize - heap.as_ptr() as usize;
+    let static_root_array_address = unskew_pointer(read_word(heap, static_root_array_variable_offset));
+    let static_root_array_offset = static_root_array_address as usize - heap.as_ptr() as usize;
+
+    let continuation_table_address = unskew_pointer(read_word(heap, continuation_table_variable_offset));
+    let continuation_table_offset = continuation_table_address as usize - heap.as_ptr() as usize;
 
     while offset < heap_ptr_offset {
         let object_offset = offset;
@@ -240,6 +247,14 @@ fn check_dynamic_heap(
         // Address of the current object. Used for debugging.
         let address = offset as usize + heap.as_ptr() as usize;
 
+        if object_offset == static_root_array_offset {
+            check_static_root_array(object_offset, roots, heap);
+            offset += (size_of::<Array>() + Words(roots.len() as u32))
+                .to_bytes()
+                .as_usize();
+            continue;
+        }
+
         if object_offset == continuation_table_offset {
             check_continuation_table(object_offset, continuation_table, heap);
             offset += (size_of::<Array>() + Words(continuation_table.len() as u32))
@@ -269,7 +284,10 @@ fn check_dynamic_heap(
 
             let is_forwarded = forward != make_pointer(address as u32);
 
-            if incremental && tag == TAG_BLOB {
+            if tag == TAG_MUTBOX {
+                // MutBoxes of static root array, will be scanned indirectly when checking the static root array.
+                offset += WORD_SIZE;
+            } else if incremental && tag == TAG_BLOB {
                 assert!(!is_forwarded);
                 // in-heap mark stack blobs
                 let length = read_word(heap, offset);
@@ -278,7 +296,7 @@ fn check_dynamic_heap(
                 if incremental {
                     assert!(tag == TAG_ARRAY || tag >= TAG_ARRAY_SLICE_MIN);
                 } else {
-                    assert_eq!(tag, TAG_ARRAY);
+                    assert!(tag == TAG_ARRAY);
                 }
 
                 if is_forwarded {
@@ -318,12 +336,11 @@ fn check_dynamic_heap(
                     for field_idx in 1..n_fields {
                         let field = read_word(heap, offset);
                         offset += WORD_SIZE;
+
                         // Get index of the object pointed by the field
                         let pointee_address = field.wrapping_add(1); // unskew
-                        let pointee_offset = (pointee_address as usize) - (heap.as_ptr() as usize);
-                        let pointee_idx_offset =
-                            pointee_offset as usize + size_of::<Array>().to_bytes().as_usize(); // skip array header (incl. length)
-                        let pointee_idx = get_scalar_value(read_word(heap, pointee_idx_offset));
+
+                        let pointee_idx = read_object_id(pointee_address, heap);
                         let expected_pointee_idx =
                             object_expected_pointees[(field_idx - 1) as usize];
                         assert_eq!(
@@ -418,6 +435,48 @@ fn compute_reachable_objects(
     closure
 }
 
+fn check_static_root_array(mut offset: usize, roots: &[ObjectIdx], heap: &[u8]) {
+    let incremental = cfg!(feature = "incremental_gc");
+
+    let array_address = heap.as_ptr() as usize + offset;
+    assert_eq!(read_word(heap, offset), TAG_ARRAY);
+    offset += WORD_SIZE;
+
+    if incremental {
+        assert_eq!(read_word(heap, offset), make_pointer(array_address as u32));
+        offset += WORD_SIZE;
+    }
+
+    assert_eq!(read_word(heap, offset), roots.len() as u32);
+    offset += WORD_SIZE;
+
+    for obj in roots.iter() {
+        let mutbox_address = unskew_pointer(read_word(heap, offset));
+        offset += WORD_SIZE;
+
+        let object_address = unskew_pointer(read_mutbox_field(mutbox_address, heap));
+        let idx = read_object_id(object_address, heap);
+        assert_eq!(idx, *obj);
+    }
+}
+
+fn read_mutbox_field(mutbox_address: u32, heap: &[u8]) -> u32 {
+    let incremental = cfg!(feature = "incremental_gc");
+
+    let mut mutbox_offset = mutbox_address as usize - heap.as_ptr() as usize;
+        
+    let mutbox_tag = read_word(heap, mutbox_offset);
+    assert_eq!(mutbox_tag, TAG_MUTBOX);
+    mutbox_offset += WORD_SIZE;
+
+    if incremental {
+        assert_eq!(read_word(heap, mutbox_offset), make_pointer(mutbox_address));
+        mutbox_offset += WORD_SIZE;
+    }
+
+    read_word(heap, mutbox_offset)
+}
+
 fn check_continuation_table(mut offset: usize, continuation_table: &[ObjectIdx], heap: &[u8]) {
     let incremental = cfg!(feature = "incremental_gc");
 
@@ -437,20 +496,28 @@ fn check_continuation_table(mut offset: usize, continuation_table: &[ObjectIdx],
         let ptr = unskew_pointer(read_word(heap, offset));
         offset += WORD_SIZE;
 
-        // Skip object header for idx
-        let idx_address = ptr as usize + size_of::<Array>().to_bytes().as_usize();
-        let idx = get_scalar_value(read_word(heap, idx_address - heap.as_ptr() as usize));
-
+        let idx = read_object_id(ptr, heap);
         assert_eq!(idx, *obj);
     }
 }
 
+fn read_object_id(object_address: u32, heap: &[u8]) -> ObjectIdx {
+    let incremental = cfg!(feature = "incremental_gc");
+
+    let tag = read_word(heap, object_address as usize - heap.as_ptr() as usize);
+    assert!(tag == TAG_ARRAY || tag >= TAG_ARRAY_SLICE_MIN && incremental);
+
+    // Skip object header for idx
+    let idx_address = object_address as usize + size_of::<Array>().to_bytes().as_usize();
+    get_scalar_value(read_word(heap, idx_address - heap.as_ptr() as usize))
+}
+
 impl GC {
     #[non_incremental_gc]
     fn run(&self, heap: &mut MotokoHeap, _round: usize) -> bool {
         let heap_base = heap.heap_base_address();
-        let static_roots = Value::from_ptr(heap.static_root_array_address());
-        let continuation_table_ptr_address = heap.continuation_table_ptr_address() as *mut Value;
+        let static_roots = Value::from_ptr(heap.static_root_array_variable_address());
+        let continuation_table_ptr_address = heap.continuation_table_variable_address() as *mut Value;
 
         let heap_1 = heap.clone();
         let heap_2 = heap.clone();
@@ -538,8 +605,8 @@ impl GC {
 
     #[incremental_gc]
     fn run(&self, heap: &mut MotokoHeap, _round: usize) -> bool {
-        let static_root = heap.static_root_array_address() as *mut Value;
-        let continuation_table_location = heap.continuation_table_ptr_address() as *mut Value;
+        let static_root = heap.static_root_array_variable_address() as *mut Value;
+        let continuation_table_location = heap.continuation_table_variable_address() as *mut Value;
         let unused_root = &mut Value::from_scalar(0) as *mut Value;
 
         match self {
diff --git a/rts/motoko-rts-tests/src/gc/heap.rs b/rts/motoko-rts-tests/src/gc/heap.rs
index b687d97045a..33417f62fd9 100644
--- a/rts/motoko-rts-tests/src/gc/heap.rs
+++ b/rts/motoko-rts-tests/src/gc/heap.rs
@@ -90,19 +90,24 @@ impl MotokoHeap {
         self.inner.borrow().heap_base_address()
     }
 
-    /// Get the address of the static root array
-    pub fn static_root_array_address(&self) -> usize {
-        self.inner.borrow().static_root_array_address()
+    /// Get the offset of the variable pointing to the static root array.
+    pub fn static_root_array_variable_offset(&self) -> usize {
+        self.inner.borrow().static_root_array_variable_offset
     }
 
-    /// Get the offset of the continuation table pointer
-    pub fn continuation_table_ptr_offset(&self) -> usize {
-        self.inner.borrow().continuation_table_ptr_offset
+    /// Get the address of the variable pointing to the static root array.
+    pub fn static_root_array_variable_address(&self) -> usize {
+        self.inner.borrow().static_root_array_variable_address()
     }
 
-    /// Get the address of the continuation table pointer
-    pub fn continuation_table_ptr_address(&self) -> usize {
-        self.inner.borrow().continuation_table_ptr_address()
+    /// Get the offset of the variable pointing to the continuation table.
+    pub fn continuation_table_variable_offset(&self) -> usize {
+        self.inner.borrow().continuation_table_variable_offset
+    }
+
+    /// Get the address of the variable pointing to the continuation table.
+    pub fn continuation_table_variable_address(&self) -> usize {
+        self.inner.borrow().continuation_table_variable_address()
     }
 
     /// Get the heap as an array. Use `offset` values returned by the methods above to read.
@@ -117,8 +122,8 @@ impl MotokoHeap {
             motoko_rts::debug::dump_heap(
                 self.heap_base_address() as u32,
                 self.heap_ptr_address() as u32,
-                Value::from_ptr(self.static_root_array_address()),
-                self.continuation_table_ptr_address() as *mut Value,
+                self.static_root_array_variable_address() as *mut Value,
+                self.continuation_table_variable_address() as *mut Value,
             );
         }
     }
@@ -138,14 +143,15 @@ struct MotokoHeapInner {
     /// Where the dynamic heap ends, i.e. the heap pointer
     heap_ptr_offset: usize,
 
-    /// Offset of the static root array: an array of pointers below `heap_base`
-    static_root_array_offset: usize,
+    /// Offset of the static root array.
+    ///
+    /// Reminder: This location is in static memory and points to an array in the dynamic heap.
+    static_root_array_variable_offset: usize,
 
     /// Offset of the continuation table pointer.
     ///
-    /// Reminder: this location is in static heap and will have pointer to an array in dynamic
-    /// heap.
-    continuation_table_ptr_offset: usize,
+    /// Reminder: This location is in static memory and points to an array in the dynamic heap.
+    continuation_table_variable_offset: usize,
 }
 
 impl MotokoHeapInner {
@@ -184,14 +190,14 @@ impl MotokoHeapInner {
         self._heap_ptr_last = self.address_to_offset(address);
     }
 
-    /// Get static root array address in the process's address space
-    fn static_root_array_address(&self) -> usize {
-        self.offset_to_address(self.static_root_array_offset)
+    /// Get the address of the variable pointing to the static root array.
+    fn static_root_array_variable_address(&self) -> usize {
+        self.offset_to_address(self.static_root_array_variable_offset)
     }
 
-    /// Get the address of the continuation table pointer
-    fn continuation_table_ptr_address(&self) -> usize {
-        self.offset_to_address(self.continuation_table_ptr_offset)
+    /// Get the address of the variable pointing to the continuation table.
+    fn continuation_table_variable_address(&self) -> usize {
+        self.offset_to_address(self.continuation_table_variable_offset)
     }
 
     fn new(
@@ -210,31 +216,30 @@ impl MotokoHeapInner {
             );
         }
 
-        // Each object will have array header plus one word for id per object + one word for each reference. Static heap will
-        // have an array (header + length) with one element, one MutBox for each root. +1 for
-        // continuation table pointer.
-        let static_heap_size_bytes = (size_of::<Array>().as_usize()
-            + roots.len()
-            + (roots.len() * size_of::<MutBox>().as_usize())
-            + 1)
+        // Two pointers, one to the static root array, and the other to the continuation table.
+        let root_pointers_size_bytes = 2 * WORD_SIZE;
+
+        // Each object will have array header plus one word for id per object + one word for each reference. 
+        // The static root is an array (header + length) with one element, one MutBox for each static variable. 
+        let static_root_set_size_bytes = (size_of::<Array>().as_usize() + roots.len()
+            + roots.len() * size_of::<MutBox>().as_usize())
             * WORD_SIZE;
 
-        let dynamic_heap_size_without_continuation_table_bytes = {
+        let continuation_table_size_byes = (size_of::<Array>() + Words(continuation_table.len() as u32)).to_bytes().as_usize();
+
+        let dynamic_objects_size_bytes = {
             let object_headers_words = map.len() * (size_of::<Array>().as_usize() + 1);
             let references_words = map.iter().map(|(_, refs)| refs.len()).sum::<usize>();
             (object_headers_words + references_words) * WORD_SIZE
         };
 
-        let dynamic_heap_size_bytes = dynamic_heap_size_without_continuation_table_bytes
-            + (size_of::<Array>() + Words(continuation_table.len() as u32))
-                .to_bytes()
-                .as_usize();
+        let dynamic_heap_size_bytes = dynamic_objects_size_bytes + static_root_set_size_bytes + continuation_table_size_byes;
 
-        let total_heap_size_bytes = static_heap_size_bytes + dynamic_heap_size_bytes;
+        let total_heap_size_bytes = root_pointers_size_bytes + dynamic_heap_size_bytes;
 
         let heap_size = heap_size_for_gc(
             gc,
-            static_heap_size_bytes,
+            root_pointers_size_bytes,
             dynamic_heap_size_bytes,
             map.len(),
         );
@@ -244,33 +249,35 @@ impl MotokoHeapInner {
         let mut heap = vec![0u8; heap_size + 28];
 
         // Align the dynamic heap starts at a 32-byte multiple.
-        let realign = (32 - (heap.as_ptr() as usize + static_heap_size_bytes) % 32) % 32;
+        let realign = (32 - (heap.as_ptr() as usize + root_pointers_size_bytes) % 32) % 32;
         assert_eq!(realign % 4, 0);
 
         // Maps `ObjectIdx`s into their offsets in the heap
-        let object_addrs: FxHashMap<ObjectIdx, usize> = create_dynamic_heap(
+        let (static_root_array_address, continuation_table_address) = create_dynamic_heap(
             map,
+            roots,
             continuation_table,
-            &mut heap[static_heap_size_bytes + realign..heap_size + realign],
+            &mut heap[root_pointers_size_bytes + realign..heap_size + realign],
         );
 
-        // Closure table pointer is the last word in static heap
-        let continuation_table_ptr_offset = static_heap_size_bytes - WORD_SIZE;
-        create_static_heap(
-            roots,
-            &object_addrs,
-            continuation_table_ptr_offset,
-            static_heap_size_bytes + dynamic_heap_size_without_continuation_table_bytes,
-            &mut heap[realign..static_heap_size_bytes + realign],
+        // Root pointers in static memory space.
+        let static_root_array_variable_offset = root_pointers_size_bytes - 2 * WORD_SIZE;
+        let continuation_table_variable_offset = root_pointers_size_bytes - WORD_SIZE;
+        create_static_memory(
+            static_root_array_variable_offset,
+            continuation_table_variable_offset,
+            static_root_array_address,
+            continuation_table_address,
+            &mut heap[realign..root_pointers_size_bytes + realign],
         );
 
         MotokoHeapInner {
             heap: heap.into_boxed_slice(),
-            heap_base_offset: static_heap_size_bytes + realign,
-            _heap_ptr_last: static_heap_size_bytes + realign,
+            heap_base_offset: root_pointers_size_bytes + realign,
+            _heap_ptr_last: root_pointers_size_bytes + realign,
             heap_ptr_offset: total_heap_size_bytes + realign,
-            static_root_array_offset: realign,
-            continuation_table_ptr_offset: continuation_table_ptr_offset + realign,
+            static_root_array_variable_offset: static_root_array_variable_offset + realign,
+            continuation_table_variable_offset: continuation_table_variable_offset + realign,
         }
     }
 
@@ -387,13 +394,13 @@ fn heap_size_for_gc(
 /// Given a heap description (as a map from objects to objects), and the dynamic part of the heap
 /// (as an array), initialize the dynamic heap with objects.
 ///
-/// Returns a mapping from object indices (`ObjectIdx`) to their addresses (see module
-/// documentation for "offset" and "address" definitions).
+/// Returns a pair containing the address of the static root array and the address of the continuation table.
 fn create_dynamic_heap(
     refs: &[(ObjectIdx, Vec<ObjectIdx>)],
+    static_roots: &[ObjectIdx],
     continuation_table: &[ObjectIdx],
     dynamic_heap: &mut [u8],
-) -> FxHashMap<ObjectIdx, usize> {
+) -> (u32, u32) {
     let incremental = cfg!(feature = "incremental_gc");
     let heap_start = dynamic_heap.as_ptr() as usize;
 
@@ -405,7 +412,7 @@ fn create_dynamic_heap(
         let mut heap_offset = 0;
         for (obj, refs) in refs {
             object_addrs.insert(*obj, heap_start + heap_offset);
-
+            
             // Store object header
             let address = u32::try_from(heap_start + heap_offset).unwrap();
             write_word(dynamic_heap, heap_offset, TAG_ARRAY);
@@ -427,7 +434,7 @@ fn create_dynamic_heap(
             // Store object value (idx)
             write_word(dynamic_heap, heap_offset, make_scalar(*obj));
             heap_offset += WORD_SIZE;
-
+            
             // Leave space for the fields
             heap_offset += refs.len() * WORD_SIZE;
         }
@@ -448,19 +455,64 @@ fn create_dynamic_heap(
         }
     }
 
-    // Add the continuation table
+    // Add the static root table
     let n_objects = refs.len();
     // fields+1 for the scalar field (idx)
     let n_fields: usize = refs.iter().map(|(_, fields)| fields.len() + 1).sum();
-    let continuation_table_offset = (size_of::<Array>() * n_objects as u32)
+    let root_section_offset = (size_of::<Array>() * n_objects as u32)
         .to_bytes()
         .as_usize()
         + n_fields * WORD_SIZE;
 
+    let mut heap_offset = root_section_offset;
+    let mut root_mutboxes = vec![];
     {
-        let mut heap_offset = continuation_table_offset;
+        for root_id in static_roots {
+            let mutbox_address = u32::try_from(heap_start + heap_offset).unwrap();
+            root_mutboxes.push(mutbox_address);
+            write_word(dynamic_heap, heap_offset, TAG_MUTBOX);
+            heap_offset += WORD_SIZE;
+
+            if incremental {
+                write_word(
+                    dynamic_heap,
+                    heap_offset,
+                    make_pointer(mutbox_address),
+                );
+                heap_offset += WORD_SIZE;
+            }
+
+            let root_ptr = *object_addrs.get(root_id).unwrap();
+            write_word(dynamic_heap, heap_offset, make_pointer(root_ptr as u32));
+            heap_offset += WORD_SIZE;
+        }
+    }
+    let static_root_array_address = u32::try_from(heap_start + heap_offset).unwrap();
+    {
+        write_word(dynamic_heap, heap_offset, TAG_ARRAY);
+        heap_offset += WORD_SIZE;
+
+        if incremental {
+            write_word(
+                dynamic_heap,
+                heap_offset,
+                make_pointer(static_root_array_address),
+            );
+            heap_offset += WORD_SIZE;
+        }
 
-        let continuation_table_address = u32::try_from(heap_start + heap_offset).unwrap();
+        assert_eq!(static_roots.len(), root_mutboxes.len());
+        write_word(dynamic_heap, heap_offset, root_mutboxes.len() as u32);
+        heap_offset += WORD_SIZE;
+        
+        for mutbox_address in root_mutboxes {
+            write_word(dynamic_heap, heap_offset, make_pointer(mutbox_address));
+            heap_offset += WORD_SIZE;
+        }
+    }
+    
+    let continuation_table_address = u32::try_from(heap_start + heap_offset).unwrap();
+    {
         write_word(dynamic_heap, heap_offset, TAG_ARRAY);
         heap_offset += WORD_SIZE;
 
@@ -483,80 +535,28 @@ fn create_dynamic_heap(
         }
     }
 
-    object_addrs
+    (static_root_array_address, continuation_table_address)
 }
 
-/// Given a root set (`roots`, may contain duplicates), a mapping from object indices to addresses
-/// (`object_addrs`), and the static part of the heap, initialize the static heap with the static
-/// root array.
-fn create_static_heap(
-    roots: &[ObjectIdx],
-    object_addrs: &FxHashMap<ObjectIdx, usize>,
-    continuation_table_ptr_offset: usize,
-    continuation_table_offset: usize,
+/// Static memory part containing the root pointers.
+fn create_static_memory(
+    static_root_array_variable_offset: usize,
+    continuation_table_variable_offset: usize,
+    static_root_array_address: u32,
+    continuation_table_address: u32,
     heap: &mut [u8],
 ) {
-    let incremental = cfg!(feature = "incremental_gc");
-    let root_addresses: Vec<usize> = roots
-        .iter()
-        .map(|obj| *object_addrs.get(obj).unwrap())
-        .collect();
-
-    // Create static root array. Each element of the array is a MutBox pointing to the actual
-    // root.
-    let array_addr = u32::try_from(heap.as_ptr() as usize).unwrap();
-    let mut offset = 0;
-    write_word(heap, offset, TAG_ARRAY);
-    offset += WORD_SIZE;
-
-    if incremental {
-        write_word(heap, offset, make_pointer(array_addr));
-        offset += WORD_SIZE;
-    }
-
-    write_word(heap, offset, u32::try_from(roots.len()).unwrap());
-    offset += WORD_SIZE;
-
-    // Current offset in the heap for the next static roots array element
-    let mut root_addr_offset = size_of::<Array>().to_bytes().as_usize();
-    assert_eq!(offset, root_addr_offset);
-
-    // Current offset in the heap for the MutBox of the next root
-    let mut mutbox_offset = (size_of::<Array>().as_usize() + roots.len()) * WORD_SIZE;
-
-    for root_address in root_addresses {
-        // Add a MutBox for the object
-        let mutbox_addr = heap.as_ptr() as usize + mutbox_offset;
-        let mutbox_ptr = make_pointer(u32::try_from(mutbox_addr).unwrap());
-
-        offset = mutbox_offset;
-        write_word(heap, offset, TAG_MUTBOX);
-        offset += WORD_SIZE;
-
-        if incremental {
-            write_word(heap, offset, mutbox_ptr);
-            offset += WORD_SIZE;
-        }
-
-        write_word(
-            heap,
-            offset,
-            make_pointer(u32::try_from(root_address).unwrap()),
-        );
-        offset += WORD_SIZE;
-
-        write_word(heap, root_addr_offset, mutbox_ptr);
-
-        root_addr_offset += WORD_SIZE;
-        mutbox_offset += size_of::<MutBox>().to_bytes().as_usize();
-        assert_eq!(offset, mutbox_offset);
-    }
+    // Write static array pointer as the second last word in static memory
+    write_word(
+        heap,
+        static_root_array_variable_offset,
+        make_pointer(static_root_array_address),
+    );
 
-    // Write continuation table pointer as the last word in static heap
-    let continuation_table_ptr = continuation_table_offset as u32 + heap.as_ptr() as u32;
+    // Write continuation table pointer as the last word in static memory
     write_word(
         heap,
-        continuation_table_ptr_offset,
-        make_pointer(continuation_table_ptr),
+        continuation_table_variable_offset,
+        make_pointer(continuation_table_address),
     );
 }
diff --git a/rts/motoko-rts-tests/src/gc/incremental/roots.rs b/rts/motoko-rts-tests/src/gc/incremental/roots.rs
index 9f34b110454..f8be0beaa4f 100644
--- a/rts/motoko-rts-tests/src/gc/incremental/roots.rs
+++ b/rts/motoko-rts-tests/src/gc/incremental/roots.rs
@@ -65,8 +65,8 @@ unsafe fn check_visit_continuation_table(heap: &MotokoHeap, continuation_ids: &[
 }
 
 unsafe fn get_roots(heap: &MotokoHeap) -> Roots {
-    let static_root = heap.static_root_array_address() as *mut Value;
-    let continuation_table_location = heap.continuation_table_ptr_address() as *mut Value;
+    let static_root = heap.static_root_array_variable_address() as *mut Value;
+    let continuation_table_location = heap.continuation_table_variable_address() as *mut Value;
     let unused_root = &mut Value::from_scalar(0) as *mut Value;
     assert_ne!(continuation_table_location, null_mut());
     [
diff --git a/rts/motoko-rts/src/debug.rs b/rts/motoko-rts/src/debug.rs
index e5007115ab0..4c36a959bea 100644
--- a/rts/motoko-rts/src/debug.rs
+++ b/rts/motoko-rts/src/debug.rs
@@ -23,11 +23,11 @@ pub unsafe extern "C" fn print_value(value: Value) {
 pub unsafe fn dump_heap(
     heap_base: u32,
     hp: u32,
-    static_roots: Value,
-    continuation_table_loc: *mut Value,
+    static_root_location: *mut Value,
+    continuation_table_location: *mut Value,
 ) {
-    print_continuation_table(continuation_table_loc);
-    print_static_roots(static_roots);
+    print_continuation_table(continuation_table_location);
+    print_static_roots(*static_root_location);
     print_heap(heap_base, hp);
 }
 

From 9b2df7ea042cdecaec61f4b9e8ba8f46ca23b916 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 14 Aug 2023 16:17:07 +0200
Subject: [PATCH 026/260] Adjust GC root set unit test

---
 rts/motoko-rts-tests/src/gc.rs                | 13 +++++----
 rts/motoko-rts-tests/src/gc/heap.rs           | 29 ++++++++++---------
 .../src/gc/incremental/roots.rs               | 13 ++++++---
 3 files changed, 32 insertions(+), 23 deletions(-)

diff --git a/rts/motoko-rts-tests/src/gc.rs b/rts/motoko-rts-tests/src/gc.rs
index d5931ebcc2d..0e74c6da215 100644
--- a/rts/motoko-rts-tests/src/gc.rs
+++ b/rts/motoko-rts-tests/src/gc.rs
@@ -220,7 +220,7 @@ fn check_dynamic_heap(
     heap: &[u8],
     heap_base_offset: usize,
     heap_ptr_offset: usize,
-    static_root_array_variable_offset: usize, 
+    static_root_array_variable_offset: usize,
     continuation_table_variable_offset: usize,
 ) {
     let incremental = cfg!(feature = "incremental_gc");
@@ -235,10 +235,12 @@ fn check_dynamic_heap(
     // Maps objects to their addresses (not offsets!). Used when debugging duplicate objects.
     let mut seen: FxHashMap<ObjectIdx, usize> = Default::default();
 
-    let static_root_array_address = unskew_pointer(read_word(heap, static_root_array_variable_offset));
+    let static_root_array_address =
+        unskew_pointer(read_word(heap, static_root_array_variable_offset));
     let static_root_array_offset = static_root_array_address as usize - heap.as_ptr() as usize;
 
-    let continuation_table_address = unskew_pointer(read_word(heap, continuation_table_variable_offset));
+    let continuation_table_address =
+        unskew_pointer(read_word(heap, continuation_table_variable_offset));
     let continuation_table_offset = continuation_table_address as usize - heap.as_ptr() as usize;
 
     while offset < heap_ptr_offset {
@@ -464,7 +466,7 @@ fn read_mutbox_field(mutbox_address: u32, heap: &[u8]) -> u32 {
     let incremental = cfg!(feature = "incremental_gc");
 
     let mut mutbox_offset = mutbox_address as usize - heap.as_ptr() as usize;
-        
+
     let mutbox_tag = read_word(heap, mutbox_offset);
     assert_eq!(mutbox_tag, TAG_MUTBOX);
     mutbox_offset += WORD_SIZE;
@@ -517,7 +519,8 @@ impl GC {
     fn run(&self, heap: &mut MotokoHeap, _round: usize) -> bool {
         let heap_base = heap.heap_base_address();
         let static_roots = Value::from_ptr(heap.static_root_array_variable_address());
-        let continuation_table_ptr_address = heap.continuation_table_variable_address() as *mut Value;
+        let continuation_table_ptr_address =
+            heap.continuation_table_variable_address() as *mut Value;
 
         let heap_1 = heap.clone();
         let heap_2 = heap.clone();
diff --git a/rts/motoko-rts-tests/src/gc/heap.rs b/rts/motoko-rts-tests/src/gc/heap.rs
index 33417f62fd9..d343b351d98 100644
--- a/rts/motoko-rts-tests/src/gc/heap.rs
+++ b/rts/motoko-rts-tests/src/gc/heap.rs
@@ -219,13 +219,17 @@ impl MotokoHeapInner {
         // Two pointers, one to the static root array, and the other to the continuation table.
         let root_pointers_size_bytes = 2 * WORD_SIZE;
 
-        // Each object will have array header plus one word for id per object + one word for each reference. 
-        // The static root is an array (header + length) with one element, one MutBox for each static variable. 
-        let static_root_set_size_bytes = (size_of::<Array>().as_usize() + roots.len()
+        // Each object will have array header plus one word for id per object + one word for each reference.
+        // The static root is an array (header + length) with one element, one MutBox for each static variable.
+        let static_root_set_size_bytes = (size_of::<Array>().as_usize()
+            + roots.len()
             + roots.len() * size_of::<MutBox>().as_usize())
             * WORD_SIZE;
 
-        let continuation_table_size_byes = (size_of::<Array>() + Words(continuation_table.len() as u32)).to_bytes().as_usize();
+        let continuation_table_size_byes = (size_of::<Array>()
+            + Words(continuation_table.len() as u32))
+        .to_bytes()
+        .as_usize();
 
         let dynamic_objects_size_bytes = {
             let object_headers_words = map.len() * (size_of::<Array>().as_usize() + 1);
@@ -233,7 +237,8 @@ impl MotokoHeapInner {
             (object_headers_words + references_words) * WORD_SIZE
         };
 
-        let dynamic_heap_size_bytes = dynamic_objects_size_bytes + static_root_set_size_bytes + continuation_table_size_byes;
+        let dynamic_heap_size_bytes =
+            dynamic_objects_size_bytes + static_root_set_size_bytes + continuation_table_size_byes;
 
         let total_heap_size_bytes = root_pointers_size_bytes + dynamic_heap_size_bytes;
 
@@ -412,7 +417,7 @@ fn create_dynamic_heap(
         let mut heap_offset = 0;
         for (obj, refs) in refs {
             object_addrs.insert(*obj, heap_start + heap_offset);
-            
+
             // Store object header
             let address = u32::try_from(heap_start + heap_offset).unwrap();
             write_word(dynamic_heap, heap_offset, TAG_ARRAY);
@@ -434,7 +439,7 @@ fn create_dynamic_heap(
             // Store object value (idx)
             write_word(dynamic_heap, heap_offset, make_scalar(*obj));
             heap_offset += WORD_SIZE;
-            
+
             // Leave space for the fields
             heap_offset += refs.len() * WORD_SIZE;
         }
@@ -474,11 +479,7 @@ fn create_dynamic_heap(
             heap_offset += WORD_SIZE;
 
             if incremental {
-                write_word(
-                    dynamic_heap,
-                    heap_offset,
-                    make_pointer(mutbox_address),
-                );
+                write_word(dynamic_heap, heap_offset, make_pointer(mutbox_address));
                 heap_offset += WORD_SIZE;
             }
 
@@ -504,13 +505,13 @@ fn create_dynamic_heap(
         assert_eq!(static_roots.len(), root_mutboxes.len());
         write_word(dynamic_heap, heap_offset, root_mutboxes.len() as u32);
         heap_offset += WORD_SIZE;
-        
+
         for mutbox_address in root_mutboxes {
             write_word(dynamic_heap, heap_offset, make_pointer(mutbox_address));
             heap_offset += WORD_SIZE;
         }
     }
-    
+
     let continuation_table_address = u32::try_from(heap_start + heap_offset).unwrap();
     {
         write_word(dynamic_heap, heap_offset, TAG_ARRAY);
diff --git a/rts/motoko-rts-tests/src/gc/incremental/roots.rs b/rts/motoko-rts-tests/src/gc/incremental/roots.rs
index f8be0beaa4f..73bd88e2288 100644
--- a/rts/motoko-rts-tests/src/gc/incremental/roots.rs
+++ b/rts/motoko-rts-tests/src/gc/incremental/roots.rs
@@ -32,9 +32,14 @@ unsafe fn check_visit_static_roots(heap: &MotokoHeap, root_ids: &[ObjectIdx]) {
         |context, field| {
             let object = *field;
             let array = object.as_array();
-            if array.len() == 1 {
-                let id = object_id(&heap, array as usize);
-                context.push(id);
+            if array.len() == root_ids.len() as u32 {
+                for index in 0..array.len() {
+                    let mutbox_value = array.get(index);
+                    let mutbox = mutbox_value.as_mutbox();
+                    let root_address = (*mutbox).field.get_ptr();
+                    let root_id = object_id(heap, root_address);
+                    context.push(root_id);
+                }
             }
         },
     );
@@ -51,7 +56,7 @@ unsafe fn check_visit_continuation_table(heap: &MotokoHeap, continuation_ids: &[
         |context, field| {
             let object = *field;
             let array = object.as_array();
-            if array.len() != 1 {
+            if array.len() == continuation_ids.len() as u32 {
                 assert_eq!(context.len(), 0);
                 for index in 0..array.len() {
                     let element = array.get(index);

From 9843b5f491377d6a8e57152587102a18ca69159a Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 14 Aug 2023 16:34:17 +0200
Subject: [PATCH 027/260] Do not stop GC on upgrade

---
 rts/motoko-rts/src/gc/incremental.rs | 16 ----------------
 src/codegen/compile.ml               |  1 -
 2 files changed, 17 deletions(-)

diff --git a/rts/motoko-rts/src/gc/incremental.rs b/rts/motoko-rts/src/gc/incremental.rs
index 1d80b03fcb1..422a45f7b13 100644
--- a/rts/motoko-rts/src/gc/incremental.rs
+++ b/rts/motoko-rts/src/gc/incremental.rs
@@ -45,7 +45,6 @@ unsafe fn initialize_incremental_gc<M: Memory>(mem: &mut M) {
 #[ic_mem_fn(ic_only)]
 unsafe fn schedule_incremental_gc<M: Memory>(mem: &mut M) {
     let state = get_incremental_gc_state();
-    assert!(state.phase != Phase::Stop);
     let running = state.phase != Phase::Pause;
     if running || should_start() {
         incremental_gc(mem);
@@ -137,7 +136,6 @@ enum Phase {
     Mark,     // Incremental marking.
     Evacuate, // Incremental evacuation compaction.
     Update,   // Incremental pointer updates.
-    Stop,     // GC stopped on canister upgrade.
 }
 
 /// GC state retained over multiple GC increments.
@@ -188,7 +186,6 @@ impl<'a, M: Memory + 'a> IncrementalGC<'a, M> {
     /// * The mark phase can only be started on an empty call stack.
     /// * The update phase can only be completed on an empty call stack.
     pub unsafe fn empty_call_stack_increment(&mut self, roots: Roots) {
-        assert!(self.state.phase != Phase::Stop);
         if self.pausing() {
             self.start_marking(roots);
         }
@@ -333,9 +330,6 @@ unsafe fn post_allocation_barrier(state: &mut State, new_object: Value) {
 ///     The fields may still point to old object locations that are forwarded.
 /// * During the update phase
 ///   - New objects do not need to be marked as they are allocated in non-evacuated partitions.
-/// * When GC is stopped on canister upgrade:
-///   - The GC will not resume and thus marking is irrelevant.
-///   - This is necessary because the upgrade serialization alters tags to store other information.
 unsafe fn mark_new_allocation(state: &mut State, new_object: Value) {
     debug_assert!(state.phase == Phase::Mark || state.phase == Phase::Evacuate);
     let object = new_object.get_ptr() as *mut Obj;
@@ -360,9 +354,6 @@ unsafe fn mark_new_allocation(state: &mut State, new_object: Value) {
 ///     and pointer writes must be handled by barriers.
 ///   - Allocation barrier: Resolve the forwarding for all pointers in the new allocation.
 ///   - Write barrier: Resolve forwarding for the written pointer value.
-/// * When the GC is stopped on canister upgrade:
-///   - The GC will not resume and thus pointer updates are irrelevant. The runtime system
-///     continues to resolve the forwarding for all remaining old pointers.
 unsafe fn update_new_allocation(state: &State, new_object: Value) {
     debug_assert!(state.phase == Phase::Update);
     if state.partitioned_heap.updates_needed() {
@@ -387,13 +378,6 @@ unsafe fn count_allocation(state: &mut State) {
     }
 }
 
-/// Stop the GC before performing upgrade. This is only a safe-guard since
-/// the compiler must not schedule the GC during stabilization anyway.
-#[no_mangle]
-pub unsafe extern "C" fn stop_gc_on_upgrade() {
-    get_incremental_gc_state().phase = Phase::Stop;
-}
-
 pub unsafe fn get_partitioned_heap() -> &'static mut PartitionedHeap {
     debug_assert!(get_incremental_gc_state().partitioned_heap.is_initialized());
     &mut get_incremental_gc_state().partitioned_heap
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index ad5dfe72bb3..9dd221c0202 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -867,7 +867,6 @@ module RTS = struct
     E.add_func_import env "rts" "incremental_gc" [] [];
     E.add_func_import env "rts" "write_with_barrier" [I32Type; I32Type] [];
     E.add_func_import env "rts" "allocation_barrier" [I32Type] [I32Type];
-    E.add_func_import env "rts" "stop_gc_on_upgrade" [] [];
     E.add_func_import env "rts" "running_gc" [] [I32Type];
     ()
 

From 5059daadcc08fdb272371554e8b7d3447f4d3f11 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Wed, 16 Aug 2023 10:38:39 +0200
Subject: [PATCH 028/260] Focus on the incremental GC

---
 bin/wrapper.sh                                |   8 +-
 default.nix                                   |  30 -
 doc/md/compiler-ref.md                        |   4 -
 rts/Makefile                                  |  45 +-
 rts/motoko-rts-macros/src/lib.rs              |  31 --
 rts/motoko-rts-tests/Cargo.toml               |   3 -
 rts/motoko-rts-tests/src/gc.rs                | 230 ++------
 rts/motoko-rts-tests/src/gc/compacting.rs     |  10 -
 .../src/gc/compacting/bitmap.rs               | 165 ------
 .../src/gc/compacting/mark_stack.rs           | 106 ----
 rts/motoko-rts-tests/src/gc/generational.rs   |  10 -
 .../src/gc/generational/mark_stack.rs         |  89 ---
 .../src/gc/generational/remembered_set.rs     |  96 ----
 rts/motoko-rts-tests/src/gc/heap.rs           | 159 +-----
 .../src/gc/incremental/roots.rs               |   4 +-
 rts/motoko-rts-tests/src/gc/utils.rs          |  27 -
 rts/motoko-rts-tests/src/memory.rs            |   5 -
 rts/motoko-rts-tests/src/stream.rs            |   3 +-
 rts/motoko-rts/Cargo.toml                     |   3 -
 rts/motoko-rts/native/Cargo.toml              |   3 -
 rts/motoko-rts/src/barriers.rs                |  21 -
 rts/motoko-rts/src/gc.rs                      |  25 -
 rts/motoko-rts/src/gc/copying.rs              | 216 --------
 rts/motoko-rts/src/gc/generational.rs         | 517 ------------------
 .../src/gc/generational/mark_stack.rs         |  74 ---
 .../src/gc/generational/remembered_set.rs     | 275 ----------
 .../src/gc/generational/sanity_checks.rs      | 173 ------
 .../src/gc/generational/write_barrier.rs      |  46 --
 rts/motoko-rts/src/gc/mark_compact.rs         | 293 ----------
 rts/motoko-rts/src/lib.rs                     |   8 -
 rts/motoko-rts/src/memory/ic.rs               |   8 -
 rts/motoko-rts/src/memory/ic/linear_memory.rs |  74 ---
 rts/motoko-rts/src/static_checks.rs           |   6 -
 rts/motoko-rts/src/types.rs                   |  47 +-
 src/codegen/compile.ml                        | 376 ++++---------
 src/exes/moc.ml                               |  16 -
 src/js/common.ml                              |   4 -
 src/mo_config/flags.ml                        |   3 -
 src/pipeline/pipeline.ml                      |   8 +-
 src/rts/gen.sh                                |   7 +-
 src/rts/rts.ml                                |   7 +-
 src/rts/rts.mli                               |   7 +-
 42 files changed, 200 insertions(+), 3042 deletions(-)
 delete mode 100644 rts/motoko-rts-tests/src/gc/compacting.rs
 delete mode 100644 rts/motoko-rts-tests/src/gc/compacting/bitmap.rs
 delete mode 100644 rts/motoko-rts-tests/src/gc/compacting/mark_stack.rs
 delete mode 100644 rts/motoko-rts-tests/src/gc/generational.rs
 delete mode 100644 rts/motoko-rts-tests/src/gc/generational/mark_stack.rs
 delete mode 100644 rts/motoko-rts-tests/src/gc/generational/remembered_set.rs
 delete mode 100644 rts/motoko-rts/src/gc/copying.rs
 delete mode 100644 rts/motoko-rts/src/gc/generational.rs
 delete mode 100644 rts/motoko-rts/src/gc/generational/mark_stack.rs
 delete mode 100644 rts/motoko-rts/src/gc/generational/remembered_set.rs
 delete mode 100644 rts/motoko-rts/src/gc/generational/sanity_checks.rs
 delete mode 100644 rts/motoko-rts/src/gc/generational/write_barrier.rs
 delete mode 100644 rts/motoko-rts/src/gc/mark_compact.rs
 delete mode 100644 rts/motoko-rts/src/memory/ic/linear_memory.rs

diff --git a/bin/wrapper.sh b/bin/wrapper.sh
index 45b7b341078..ffb6e673478 100755
--- a/bin/wrapper.sh
+++ b/bin/wrapper.sh
@@ -18,7 +18,7 @@ declare -A envs # list of expected environment variables with paths to products
 # Define build products here
 real[moc]=src/moc
 hint[moc]="make -C $rel_root/src moc"
-envs[moc]="MOC_NON_INCREMENTAL_RELEASE_RTS MOC_NON_INCREMENTAL_DEBUG_RTS MOC_INCREMENTAL_RELEASE_RTS MOC_INCREMENTAL_DEBUG_RTS"
+envs[moc]="MOC_RELEASE_RTS MOC_DEBUG_RTS"
 real[mo-ld]=src/mo-ld
 hint[mo-ld]="make -C $rel_root/src mo-ld"
 real[mo-doc]=src/mo-doc
@@ -32,10 +32,8 @@ hint[candid-tests]="make -C $rel_root/src candid-tests"
 
 rts_hint="make -C $rel_root/rts"
 
-real[MOC_NON_INCREMENTAL_RELEASE_RTS]=rts/mo-rts.wasm
-real[MOC_NON_INCREMENTAL_DEBUG_RTS]=rts/mo-rts-debug.wasm
-real[MOC_INCREMENTAL_RELEASE_RTS]=rts/mo-rts-incremental.wasm
-real[MOC_INCREMENTAL_DEBUG_RTS]=rts/mo-rts-incremental-debug.wasm
+real[MOC_RELEASE_RTS]=rts/mo-rts.wasm
+real[MOC_DEBUG_RTS]=rts/mo-rts-debug.wasm
 
 for var in ${envs[moc]}; do
   hint[$var]=$rts_hint
diff --git a/default.nix b/default.nix
index d248d3f353c..8a88072fdcf 100644
--- a/default.nix
+++ b/default.nix
@@ -257,8 +257,6 @@ rec {
         mkdir -p $out/rts
         cp mo-rts.wasm $out/rts
         cp mo-rts-debug.wasm $out/rts
-        cp mo-rts-incremental.wasm $out/rts
-        cp mo-rts-incremental-debug.wasm $out/rts
       '';
 
       # This needs to be self-contained. Remove mention of nix path in debug
@@ -269,11 +267,6 @@ rec {
           -t ${rtsDeps} \
           -t ${rustStdDeps} \
           $out/rts/mo-rts.wasm $out/rts/mo-rts-debug.wasm
-        remove-references-to \
-          -t ${nixpkgs.rustc-nightly} \
-          -t ${rtsDeps} \
-          -t ${rustStdDeps} \
-          $out/rts/mo-rts-incremental.wasm $out/rts/mo-rts-incremental-debug.wasm
       '';
 
       allowedRequisites = [];
@@ -363,26 +356,6 @@ rec {
       (test_subdir dir deps).overrideAttrs {
           EXTRA_MOC_ARGS = "--sanity-checks";
       };
-      
-    generational_gc_subdir = dir: deps:
-      (test_subdir dir deps).overrideAttrs {
-          EXTRA_MOC_ARGS = "--generational-gc";
-      };
-
-    snty_compacting_gc_subdir = dir: deps:
-      (test_subdir dir deps).overrideAttrs {
-          EXTRA_MOC_ARGS = "--sanity-checks --compacting-gc";
-      };
-
-    snty_generational_gc_subdir = dir: deps:
-      (test_subdir dir deps).overrideAttrs {
-          EXTRA_MOC_ARGS = "--sanity-checks --generational-gc";
-      };
-
-    snty_incremental_gc_subdir = dir: deps:
-      (test_subdir dir deps).overrideAttrs {
-          EXTRA_MOC_ARGS = "--sanity-checks --incremental-gc";
-      };
 
     perf_subdir = dir: deps:
       (test_subdir dir deps).overrideAttrs (args: {
@@ -497,9 +470,6 @@ rec {
       ic-ref-run = test_subdir "run-drun"   [ moc ic-ref-run ];
       drun       = test_subdir "run-drun"   [ moc nixpkgs.drun ];
       drun-dbg   = snty_subdir "run-drun"   [ moc nixpkgs.drun ];
-      drun-compacting-gc = snty_compacting_gc_subdir "run-drun" [ moc nixpkgs.drun ] ;
-      drun-generational-gc = snty_generational_gc_subdir "run-drun" [ moc nixpkgs.drun ] ;
-      drun-incremental-gc = snty_incremental_gc_subdir "run-drun" [ moc nixpkgs.drun ] ;
       fail       = test_subdir "fail"       [ moc ];
       repl       = test_subdir "repl"       [ moc ];
       ld         = test_subdir "ld"         ([ mo-ld ] ++ ldTestDeps);
diff --git a/doc/md/compiler-ref.md b/doc/md/compiler-ref.md
index 27a9bcea383..29bd7b7d7ef 100644
--- a/doc/md/compiler-ref.md
+++ b/doc/md/compiler-ref.md
@@ -26,15 +26,11 @@ You can use the following options with the `moc` command.
 | `--args0 <file>`                          | Read additional `NUL` separated command line arguments from `<file>`.                                                                                 |
 | `-c`                                      | Compile to WebAssembly.                                                                                                                               |
 | `--check`                                 | Performs type checking only.                                                                                                                          |
-| `--compacting-gc`                         | Use compacting GC                                                                                                                                     |
-| `--copying-gc`                            | Use copying GC (default)                                                                                                                              |
 | `--debug`                                 | Respects debug expressions in the source (the default).                                                                                               |
 | `--error-detail <n>`                      | Set level of error message detail for syntax errors, n in \[0..3\] (default 2).                                                                       |
-| `--generational-gc`                       | Use generational GC                                                                                                                                   |
 | `-help`,`--help`                          | Displays usage information.                                                                                                                           |
 | `--hide-warnings`                         | Hides compiler warnings.                                                                                                                              |
 | `-Werror`                                 | Treat warnings as errors.                                                                                                                             |
-| `--incremental-gc`                        | Use incremental GC (only for beta-testing)                                                                                                            |
 | `--idl`                                   | Compile binary and emit Candid IDL specification to `.did` file.                                                                                      |
 | `-i`                                      | Runs the compiler in an interactive read–eval–print loop (REPL) shell so you can evaluate program execution (implies -r).                             |
 | `--map`                                   | Outputs a JavaScript source map.                                                                                                                      |
diff --git a/rts/Makefile b/rts/Makefile
index e27dfd06dbb..e4fc8b0cbd0 100644
--- a/rts/Makefile
+++ b/rts/Makefile
@@ -112,7 +112,7 @@ CLANG_FLAGS = \
 
 .PHONY: all
 
-all: mo-rts.wasm mo-rts-debug.wasm mo-rts-incremental.wasm mo-rts-incremental-debug.wasm
+all: mo-rts.wasm mo-rts-debug.wasm
 
 _build:
 	mkdir -p $@
@@ -226,28 +226,17 @@ RTS_RELEASE_BUILD=$(RTS_BUILD) --release
 RTS_DEBUG_TARGET=motoko-rts/target/wasm32-unknown-emscripten/debug/libmotoko_rts.a
 RTS_RELEASE_TARGET=motoko-rts/target/wasm32-unknown-emscripten/release/libmotoko_rts.a
 
-RTS_RUST_NON_INCREMENTAL_WASM_A=_build/wasm/libmotoko_rts.a
-RTS_RUST_NON_INCREMENTAL_DEBUG_WASM_A=_build/wasm/libmotoko_rts_debug.a
+RTS_RUST_WASM_A=_build/wasm/libmotoko_rts.a
+RTS_RUST_DEBUG_WASM_A=_build/wasm/libmotoko_rts_debug.a
 
-RTS_RUST_INCREMENTAL_WASM_A=_build/wasm/libmotoko_rts_incremental.a
-RTS_RUST_INCREMENTAL_DEBUG_WASM_A=_build/wasm/libmotoko_rts_incremental_debug.a
-
-$(RTS_RUST_NON_INCREMENTAL_WASM_A): $(RTS_DEPENDENCIES)
+$(RTS_RUST_WASM_A): $(RTS_DEPENDENCIES)
 	$(RTS_RELEASE_BUILD)
 	cp $(RTS_RELEASE_TARGET) $@
 
-$(RTS_RUST_NON_INCREMENTAL_DEBUG_WASM_A): $(RTS_DEPENDENCIES)
+$(RTS_RUST_DEBUG_WASM_A): $(RTS_DEPENDENCIES)
 	$(RTS_DEBUG_BUILD)
 	cp $(RTS_DEBUG_TARGET) $@
 
-$(RTS_RUST_INCREMENTAL_WASM_A): $(RTS_DEPENDENCIES)
-	$(RTS_RELEASE_BUILD) --features incremental_gc
-	cp $(RTS_RELEASE_TARGET) $@
-
-$(RTS_RUST_INCREMENTAL_DEBUG_WASM_A): $(RTS_DEPENDENCIES)
-	$(RTS_DEBUG_BUILD) --features incremental_gc
-	cp $(RTS_DEBUG_TARGET) $@
-
 #
 # The test suite
 #
@@ -258,16 +247,10 @@ TEST_RUN=wasmtime --disable-cache motoko-rts-tests/target/wasm32-wasi/debug/moto
 
 .PHONY: test
 
-test: test-non-incremental test-incremental
-
-test-non-incremental: $(TEST_DEPENDENCIES)
+test: $(TEST_DEPENDENCIES)
 	$(TEST_BUILD)
 	$(TEST_RUN)
 
-test-incremental: $(TEST_DEPENDENCIES)
-	$(TEST_BUILD) --features incremental_gc
-	$(TEST_RUN)
-
 #
 # Putting it all together
 #
@@ -295,22 +278,12 @@ LINKER_OPTIONS=\
   $(EXPORTED_SYMBOLS:%=--export=%) \
   --whole-archive
 
-mo-rts.wasm: $(RTS_RUST_NON_INCREMENTAL_WASM_A) $(WASM_A_DEPENDENCIES)
-	$(WASM_LD) -o $@ \
-		$(LINKER_OPTIONS) \
-		$+
-
-mo-rts-debug.wasm: $(RTS_RUST_NON_INCREMENTAL_DEBUG_WASM_A) $(WASM_A_DEPENDENCIES)
-	$(WASM_LD) -o $@ \
-		$(LINKER_OPTIONS) \
-		$+
-
-mo-rts-incremental.wasm: $(RTS_RUST_INCREMENTAL_WASM_A) $(WASM_A_DEPENDENCIES)
+mo-rts.wasm: $(RTS_RUST_WASM_A) $(WASM_A_DEPENDENCIES)
 	$(WASM_LD) -o $@ \
 		$(LINKER_OPTIONS) \
 		$+
 
-mo-rts-incremental-debug.wasm: $(RTS_RUST_INCREMENTAL_DEBUG_WASM_A) $(WASM_A_DEPENDENCIES)
+mo-rts-debug.wasm: $(RTS_RUST_DEBUG_WASM_A) $(WASM_A_DEPENDENCIES)
 	$(WASM_LD) -o $@ \
 		$(LINKER_OPTIONS) \
 		$+
@@ -325,8 +298,6 @@ clean:
 	  _build \
 	  mo-rts.wasm \
 	  mo-rts-debug.wasm \
-	  mo-rts-incremental.wasm \
-	  mo-rts-incremental-debug.wasm \
 	  motoko-rts/target \
 	  motoko-rts-tests/target \
 	  motoko-rts-macros/target \
diff --git a/rts/motoko-rts-macros/src/lib.rs b/rts/motoko-rts-macros/src/lib.rs
index e4dd417c849..49ac0e18d3e 100644
--- a/rts/motoko-rts-macros/src/lib.rs
+++ b/rts/motoko-rts-macros/src/lib.rs
@@ -136,34 +136,3 @@ pub fn ic_mem_fn(attr: TokenStream, input: TokenStream) -> TokenStream {
     )
     .into()
 }
-
-/// Feature macro for incremental GC features, in particular forwarding pointers.
-/// Equivalent to using the attribute `#[cfg(feature = "incremental_gc")]`.
-#[proc_macro_attribute]
-pub fn incremental_gc(attr: TokenStream, input: TokenStream) -> TokenStream {
-    assert!(attr.is_empty());
-    let block = syn::parse_macro_input!(input as syn::Item);
-    quote!(
-        #[cfg(feature = "incremental_gc")]
-        #block
-    )
-    .into()
-}
-
-/// Feature macro for non-incremental GC features, in particular forwarding pointers.
-/// Equivalent to using the attribute `#[cfg(not(feature = "incremental_gc"))]`.
-#[proc_macro_attribute]
-pub fn non_incremental_gc(attr: TokenStream, input: TokenStream) -> TokenStream {
-    assert!(attr.is_empty());
-    let block = syn::parse_macro_input!(input as syn::Item);
-    quote!(
-        #[cfg(not(feature = "incremental_gc"))]
-        #block
-    )
-    .into()
-}
-
-#[proc_macro]
-pub fn is_incremental_gc(_item: TokenStream) -> TokenStream {
-    "cfg!(feature = \"incremental_gc\")".parse().unwrap()
-}
diff --git a/rts/motoko-rts-tests/Cargo.toml b/rts/motoko-rts-tests/Cargo.toml
index 3640bf9114c..3e28860e452 100644
--- a/rts/motoko-rts-tests/Cargo.toml
+++ b/rts/motoko-rts-tests/Cargo.toml
@@ -4,9 +4,6 @@ version = "0.1.0"
 authors = ["dfinity <sdk@dfinity.org"]
 edition = "2018"
 
-[features]
-incremental_gc = ["motoko-rts/incremental_gc"]
-
 [dependencies]
 byteorder = "1.4.3"
 fxhash = "0.2.1"
diff --git a/rts/motoko-rts-tests/src/gc.rs b/rts/motoko-rts-tests/src/gc.rs
index 0e74c6da215..1f32eccc2e6 100644
--- a/rts/motoko-rts-tests/src/gc.rs
+++ b/rts/motoko-rts-tests/src/gc.rs
@@ -5,21 +5,14 @@
 //
 // To convert an offset into an address, add heap array's address to the offset.
 
-#[non_incremental_gc]
-mod compacting;
-#[non_incremental_gc]
-mod generational;
 mod heap;
-#[incremental_gc]
 mod incremental;
 mod random;
 mod utils;
 
-use motoko_rts_macros::*;
-
 use heap::MotokoHeap;
 use utils::{
-    get_scalar_value, make_pointer, read_word, unskew_pointer, ObjectIdx, GC, GC_IMPLS, WORD_SIZE,
+    get_scalar_value, make_pointer, read_word, unskew_pointer, ObjectIdx, WORD_SIZE,
 };
 
 use motoko_rts::types::*;
@@ -48,13 +41,6 @@ pub fn test() {
     test_gc_components();
 }
 
-#[non_incremental_gc]
-fn test_gc_components() {
-    compacting::test();
-    generational::test();
-}
-
-#[incremental_gc]
 fn test_gc_components() {
     incremental::test();
 }
@@ -110,25 +96,20 @@ struct TestHeap {
 
 /// Test all GC implementations with the given heap
 fn test_gcs(heap_descr: &TestHeap) {
-    for gc in &GC_IMPLS {
-        test_gc(
-            *gc,
-            &heap_descr.heap,
-            &heap_descr.roots,
-            &heap_descr.continuation_table,
-        );
-    }
-
+    test_gc(
+        &heap_descr.heap,
+        &heap_descr.roots,
+        &heap_descr.continuation_table,
+    );
     reset_gc();
 }
 
 fn test_gc(
-    gc: GC,
     refs: &[(ObjectIdx, Vec<ObjectIdx>)],
     roots: &[ObjectIdx],
     continuation_table: &[ObjectIdx],
 ) {
-    let mut heap = MotokoHeap::new(refs, roots, continuation_table, gc);
+    let mut heap = MotokoHeap::new(refs, roots, continuation_table);
 
     initialize_gc(&mut heap);
 
@@ -145,8 +126,8 @@ fn test_gc(
         heap.continuation_table_variable_offset(),
     );
 
-    for round in 0..3 {
-        let check_all_reclaimed = gc.run(&mut heap, round);
+    for _ in 0..3 {
+        let check_all_reclaimed = run(&mut heap);
 
         let heap_base_offset = heap.heap_base_offset();
         let heap_ptr_offset = heap.heap_ptr_offset();
@@ -166,10 +147,6 @@ fn test_gc(
     }
 }
 
-#[non_incremental_gc]
-fn initialize_gc(_heap: &mut MotokoHeap) {}
-
-#[incremental_gc]
 fn initialize_gc(heap: &mut MotokoHeap) {
     use motoko_rts::gc::incremental::{
         get_incremental_gc_state, get_partitioned_heap, IncrementalGC,
@@ -187,10 +164,6 @@ fn initialize_gc(heap: &mut MotokoHeap) {
     }
 }
 
-#[non_incremental_gc]
-fn reset_gc() {}
-
-#[incremental_gc]
 fn reset_gc() {
     use crate::memory::TestMemory;
     use motoko_rts::gc::incremental::{
@@ -223,7 +196,6 @@ fn check_dynamic_heap(
     static_root_array_variable_offset: usize,
     continuation_table_variable_offset: usize,
 ) {
-    let incremental = cfg!(feature = "incremental_gc");
     let objects_map: FxHashMap<ObjectIdx, &[ObjectIdx]> = objects
         .iter()
         .map(|(obj, refs)| (*obj, refs.as_slice()))
@@ -269,41 +241,29 @@ fn check_dynamic_heap(
         offset += WORD_SIZE;
 
         if tag == TAG_ONE_WORD_FILLER {
-            assert!(incremental);
         } else if tag == TAG_FREE_SPACE {
-            assert!(incremental);
             let words = read_word(heap, offset) as usize;
             offset += WORD_SIZE;
             offset += words * WORD_SIZE;
         } else {
             let forward;
-            if incremental {
-                forward = read_word(heap, offset);
-                offset += WORD_SIZE;
-            } else {
-                forward = make_pointer(address as u32);
-            }
+            forward = read_word(heap, offset);
+            offset += WORD_SIZE;
 
             let is_forwarded = forward != make_pointer(address as u32);
 
             if tag == TAG_MUTBOX {
                 // MutBoxes of static root array, will be scanned indirectly when checking the static root array.
                 offset += WORD_SIZE;
-            } else if incremental && tag == TAG_BLOB {
+            } else if tag == TAG_BLOB {
                 assert!(!is_forwarded);
                 // in-heap mark stack blobs
                 let length = read_word(heap, offset);
                 offset += WORD_SIZE + length as usize;
             } else {
-                if incremental {
-                    assert!(tag == TAG_ARRAY || tag >= TAG_ARRAY_SLICE_MIN);
-                } else {
-                    assert!(tag == TAG_ARRAY);
-                }
-
+                assert!(tag == TAG_ARRAY || tag >= TAG_ARRAY_SLICE_MIN);
+                
                 if is_forwarded {
-                    assert!(incremental);
-
                     let forward_offset = forward as usize - heap.as_ptr() as usize;
                     let length = read_word(
                         heap,
@@ -438,17 +398,13 @@ fn compute_reachable_objects(
 }
 
 fn check_static_root_array(mut offset: usize, roots: &[ObjectIdx], heap: &[u8]) {
-    let incremental = cfg!(feature = "incremental_gc");
-
     let array_address = heap.as_ptr() as usize + offset;
     assert_eq!(read_word(heap, offset), TAG_ARRAY);
     offset += WORD_SIZE;
 
-    if incremental {
-        assert_eq!(read_word(heap, offset), make_pointer(array_address as u32));
-        offset += WORD_SIZE;
-    }
-
+    assert_eq!(read_word(heap, offset), make_pointer(array_address as u32));
+    offset += WORD_SIZE;
+    
     assert_eq!(read_word(heap, offset), roots.len() as u32);
     offset += WORD_SIZE;
 
@@ -463,34 +419,26 @@ fn check_static_root_array(mut offset: usize, roots: &[ObjectIdx], heap: &[u8])
 }
 
 fn read_mutbox_field(mutbox_address: u32, heap: &[u8]) -> u32 {
-    let incremental = cfg!(feature = "incremental_gc");
-
     let mut mutbox_offset = mutbox_address as usize - heap.as_ptr() as usize;
 
     let mutbox_tag = read_word(heap, mutbox_offset);
     assert_eq!(mutbox_tag, TAG_MUTBOX);
     mutbox_offset += WORD_SIZE;
 
-    if incremental {
-        assert_eq!(read_word(heap, mutbox_offset), make_pointer(mutbox_address));
-        mutbox_offset += WORD_SIZE;
-    }
+    assert_eq!(read_word(heap, mutbox_offset), make_pointer(mutbox_address));
+    mutbox_offset += WORD_SIZE;
 
     read_word(heap, mutbox_offset)
 }
 
 fn check_continuation_table(mut offset: usize, continuation_table: &[ObjectIdx], heap: &[u8]) {
-    let incremental = cfg!(feature = "incremental_gc");
-
     let table_addr = heap.as_ptr() as usize + offset;
     assert_eq!(read_word(heap, offset), TAG_ARRAY);
     offset += WORD_SIZE;
 
-    if incremental {
-        assert_eq!(read_word(heap, offset), make_pointer(table_addr as u32));
-        offset += WORD_SIZE;
-    }
-
+    assert_eq!(read_word(heap, offset), make_pointer(table_addr as u32));
+    offset += WORD_SIZE;
+ 
     assert_eq!(read_word(heap, offset), continuation_table.len() as u32);
     offset += WORD_SIZE;
 
@@ -504,130 +452,32 @@ fn check_continuation_table(mut offset: usize, continuation_table: &[ObjectIdx],
 }
 
 fn read_object_id(object_address: u32, heap: &[u8]) -> ObjectIdx {
-    let incremental = cfg!(feature = "incremental_gc");
-
     let tag = read_word(heap, object_address as usize - heap.as_ptr() as usize);
-    assert!(tag == TAG_ARRAY || tag >= TAG_ARRAY_SLICE_MIN && incremental);
+    assert!(tag == TAG_ARRAY || tag >= TAG_ARRAY_SLICE_MIN);
 
     // Skip object header for idx
     let idx_address = object_address as usize + size_of::<Array>().to_bytes().as_usize();
     get_scalar_value(read_word(heap, idx_address - heap.as_ptr() as usize))
 }
 
-impl GC {
-    #[non_incremental_gc]
-    fn run(&self, heap: &mut MotokoHeap, _round: usize) -> bool {
-        let heap_base = heap.heap_base_address();
-        let static_roots = Value::from_ptr(heap.static_root_array_variable_address());
-        let continuation_table_ptr_address =
-            heap.continuation_table_variable_address() as *mut Value;
-
-        let heap_1 = heap.clone();
-        let heap_2 = heap.clone();
-
-        match self {
-            GC::Copying => {
-                unsafe {
-                    motoko_rts::gc::copying::copying_gc_internal(
-                        heap,
-                        heap_base,
-                        // get_hp
-                        || heap_1.heap_ptr_address(),
-                        // set_hp
-                        move |hp| heap_2.set_heap_ptr_address(hp as usize),
-                        static_roots,
-                        continuation_table_ptr_address,
-                        // note_live_size
-                        |_live_size| {},
-                        // note_reclaimed
-                        |_reclaimed| {},
-                    );
-                }
-                true
-            }
-
-            GC::MarkCompact => {
-                unsafe {
-                    motoko_rts::gc::mark_compact::compacting_gc_internal(
-                        heap,
-                        heap_base,
-                        // get_hp
-                        || heap_1.heap_ptr_address(),
-                        // set_hp
-                        move |hp| heap_2.set_heap_ptr_address(hp as usize),
-                        static_roots,
-                        continuation_table_ptr_address,
-                        // note_live_size
-                        |_live_size| {},
-                        // note_reclaimed
-                        |_reclaimed| {},
-                    );
-                }
-                true
-            }
-
-            GC::Generational => {
-                use motoko_rts::gc::generational::{
-                    remembered_set::RememberedSet,
-                    write_barrier::{LAST_HP, REMEMBERED_SET},
-                    GenerationalGC, Strategy,
-                };
-
-                let strategy = match _round {
-                    0 => Strategy::Young,
-                    _ => Strategy::Full,
-                };
-                unsafe {
-                    REMEMBERED_SET = Some(RememberedSet::new(heap));
-                    LAST_HP = heap_1.last_ptr_address();
-
-                    let limits = motoko_rts::gc::generational::Limits {
-                        base: heap_base as usize,
-                        last_free: heap_1.last_ptr_address(),
-                        free: heap_1.heap_ptr_address(),
-                    };
-                    let roots = motoko_rts::gc::generational::Roots {
-                        static_roots,
-                        continuation_table_ptr_loc: continuation_table_ptr_address,
-                    };
-                    let gc_heap = motoko_rts::gc::generational::Heap {
-                        mem: heap,
-                        limits,
-                        roots,
-                    };
-                    let mut gc = GenerationalGC::new(gc_heap, strategy);
-                    gc.run();
-                    let free = gc.heap.limits.free;
-                    heap.set_last_ptr_address(free);
-                    heap.set_heap_ptr_address(free);
-                }
-                _round >= 2
-            }
-        }
-    }
+fn run(heap: &mut MotokoHeap) -> bool {
+    let static_root = heap.static_root_array_variable_address() as *mut Value;
+    let continuation_table_location = heap.continuation_table_variable_address() as *mut Value;
+    let unused_root = &mut Value::from_scalar(0) as *mut Value;
 
-    #[incremental_gc]
-    fn run(&self, heap: &mut MotokoHeap, _round: usize) -> bool {
-        let static_root = heap.static_root_array_variable_address() as *mut Value;
-        let continuation_table_location = heap.continuation_table_variable_address() as *mut Value;
-        let unused_root = &mut Value::from_scalar(0) as *mut Value;
-
-        match self {
-            GC::Incremental => unsafe {
-                use motoko_rts::gc::incremental::{get_incremental_gc_state, IncrementalGC};
-                const INCREMENTS_UNTIL_COMPLETION: usize = 16;
-                for _ in 0..INCREMENTS_UNTIL_COMPLETION {
-                    let roots = [
-                        static_root,
-                        continuation_table_location,
-                        unused_root,
-                        unused_root,
-                    ];
-                    IncrementalGC::instance(heap, get_incremental_gc_state())
-                        .empty_call_stack_increment(roots);
-                }
-                false
-            },
+    unsafe {
+        use motoko_rts::gc::incremental::{get_incremental_gc_state, IncrementalGC};
+        const INCREMENTS_UNTIL_COMPLETION: usize = 16;
+        for _ in 0..INCREMENTS_UNTIL_COMPLETION {
+            let roots = [
+                static_root,
+                continuation_table_location,
+                unused_root,
+                unused_root,
+            ];
+            IncrementalGC::instance(heap, get_incremental_gc_state())
+                .empty_call_stack_increment(roots);
         }
+        false
     }
 }
diff --git a/rts/motoko-rts-tests/src/gc/compacting.rs b/rts/motoko-rts-tests/src/gc/compacting.rs
deleted file mode 100644
index 42cfa936cd2..00000000000
--- a/rts/motoko-rts-tests/src/gc/compacting.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-mod bitmap;
-mod mark_stack;
-
-pub fn test() {
-    println!("Testing compacting GC components ...");
-    unsafe {
-        bitmap::test();
-        mark_stack::test();
-    }
-}
diff --git a/rts/motoko-rts-tests/src/gc/compacting/bitmap.rs b/rts/motoko-rts-tests/src/gc/compacting/bitmap.rs
deleted file mode 100644
index 6d3815f66cd..00000000000
--- a/rts/motoko-rts-tests/src/gc/compacting/bitmap.rs
+++ /dev/null
@@ -1,165 +0,0 @@
-use crate::memory::TestMemory;
-
-use motoko_rts::constants::WORD_SIZE;
-use motoko_rts::gc::mark_compact::bitmap::{
-    alloc_bitmap, free_bitmap, get_bit, iter_bits, set_bit, BITMAP_ITER_END,
-};
-use motoko_rts::memory::Memory;
-use motoko_rts::types::{Bytes, Words};
-
-use std::collections::HashSet;
-
-use proptest::strategy::Strategy;
-use proptest::test_runner::{Config, TestCaseError, TestCaseResult, TestRunner};
-
-pub unsafe fn test() {
-    println!("  Testing bitmap ...");
-    println!("    Testing set_bit/get_bit");
-
-    {
-        let mut mem = TestMemory::new(Words(1024));
-        test_set_get(&mut mem, vec![0, 33]).unwrap();
-    }
-
-    let mut proptest_runner = TestRunner::new(Config {
-        cases: 100,
-        failure_persistence: None,
-        ..Default::default()
-    });
-
-    proptest_runner
-        .run(&bit_index_vec_strategy(), |bits| {
-            // Max bit idx = 65,534, requires 2048 words. Add 2 words for Blob header (header +
-            // length).
-            let mut mem = TestMemory::new(Words(2051));
-            test_set_get_proptest(&mut mem, bits)
-        })
-        .unwrap();
-
-    println!("    Testing bit iteration");
-    proptest_runner
-        .run(&bit_index_set_strategy(), |bits| {
-            // Same as above
-            let mut mem = TestMemory::new(Words(2051));
-            test_bit_iter(&mut mem, bits)
-        })
-        .unwrap();
-}
-
-/// Generates vectors of bit indices
-fn bit_index_vec_strategy() -> impl Strategy<Value = Vec<u16>> {
-    proptest::collection::vec(0u16..u16::MAX, 0..1_000)
-}
-
-/// Same as `bit_index_vec_strategy`, but generates sets
-fn bit_index_set_strategy() -> impl Strategy<Value = HashSet<u16>> {
-    proptest::collection::hash_set(0u16..u16::MAX, 0..1_000)
-}
-
-fn test_set_get_proptest<M: Memory>(mem: &mut M, bits: Vec<u16>) -> TestCaseResult {
-    test_set_get(mem, bits).map_err(|err| TestCaseError::Fail(err.into()))
-}
-
-fn test_set_get<M: Memory>(mem: &mut M, mut bits: Vec<u16>) -> Result<(), String> {
-    if bits.is_empty() {
-        return Ok(());
-    }
-
-    unsafe {
-        alloc_bitmap(
-            mem,
-            Bytes((u32::from(*bits.iter().max().unwrap()) + 1) * WORD_SIZE),
-            0,
-        );
-
-        for bit in &bits {
-            set_bit(u32::from(*bit));
-            if !get_bit(u32::from(*bit)) {
-                return Err("set-get error".to_string());
-            }
-        }
-
-        bits.sort();
-
-        let mut last_bit: Option<u16> = None;
-        for bit in bits {
-            // Bits from the last set bit up to current bit should be 0
-            if let Some(last_bit) = last_bit {
-                for i in last_bit + 1..bit {
-                    if get_bit(u32::from(i)) {
-                        return Err(format!("get_bit({}) of unset bit is true", i));
-                    }
-                }
-            }
-
-            // Current bit should be set
-            if !get_bit(u32::from(bit)) {
-                return Err("get_bit of set bit is false".to_string());
-            }
-
-            last_bit = Some(bit);
-        }
-
-        free_bitmap()
-    }
-
-    Ok(())
-}
-
-fn test_bit_iter<M: Memory>(mem: &mut M, bits: HashSet<u16>) -> TestCaseResult {
-    // If the max bit is N, the heap size is at least N+1 words
-    let heap_size = Words(u32::from(
-        bits.iter().max().map(|max_bit| max_bit + 1).unwrap_or(0),
-    ))
-    .to_bytes();
-
-    unsafe {
-        alloc_bitmap(mem, heap_size, 0);
-
-        for bit in bits.iter() {
-            set_bit(u32::from(*bit));
-        }
-
-        let mut bits_sorted = bits.into_iter().collect::<Vec<_>>();
-        bits_sorted.sort();
-
-        let mut bit_vec_iter = bits_sorted.into_iter();
-        let mut bit_map_iter = iter_bits();
-
-        while let Some(vec_bit) = bit_vec_iter.next() {
-            match bit_map_iter.next() {
-                BITMAP_ITER_END => {
-                    return Err(TestCaseError::Fail(
-                        "bitmap iterator didn't yield but there are more bits".into(),
-                    ));
-                }
-                map_bit => {
-                    if map_bit != u32::from(vec_bit) {
-                        return Err(TestCaseError::Fail(
-                            format!(
-                                "bitmap iterator yields {}, but actual bit is {}",
-                                map_bit, vec_bit
-                            )
-                            .into(),
-                        ));
-                    }
-                }
-            }
-        }
-
-        let map_bit = bit_map_iter.next();
-        if map_bit != BITMAP_ITER_END {
-            return Err(TestCaseError::Fail(
-                format!(
-                    "bitmap iterator yields {}, but there are no more bits left",
-                    map_bit
-                )
-                .into(),
-            ));
-        }
-
-        free_bitmap()
-    }
-
-    Ok(())
-}
diff --git a/rts/motoko-rts-tests/src/gc/compacting/mark_stack.rs b/rts/motoko-rts-tests/src/gc/compacting/mark_stack.rs
deleted file mode 100644
index 87ab1c130a0..00000000000
--- a/rts/motoko-rts-tests/src/gc/compacting/mark_stack.rs
+++ /dev/null
@@ -1,106 +0,0 @@
-use crate::memory::TestMemory;
-
-use motoko_rts::gc::mark_compact::mark_stack::{
-    alloc_mark_stack, free_mark_stack, grow_stack, pop_mark_stack, push_mark_stack,
-    INIT_STACK_SIZE, STACK_BASE, STACK_PTR, STACK_TOP,
-};
-use motoko_rts::memory::Memory;
-use motoko_rts::types::*;
-
-use proptest::test_runner::{Config, TestCaseError, TestCaseResult, TestRunner};
-
-pub unsafe fn test() {
-    println!("  Testing mark stack ...");
-
-    test_push_pop();
-    test_grow_stack();
-}
-
-fn test_push_pop() {
-    println!("    Testing push/pop");
-
-    let mut proptest_runner = TestRunner::new(Config {
-        cases: 100,
-        failure_persistence: None,
-        ..Default::default()
-    });
-
-    proptest_runner
-        .run(&(0u32..1000u32), |n_objs| {
-            let mut mem = TestMemory::new(Words(1024 * 1024));
-            test_(&mut mem, n_objs)
-        })
-        .unwrap();
-}
-
-static TAGS: [Tag; 14] = [
-    TAG_OBJECT,
-    TAG_OBJ_IND,
-    TAG_ARRAY,
-    TAG_BITS64,
-    TAG_MUTBOX,
-    TAG_CLOSURE,
-    TAG_SOME,
-    TAG_VARIANT,
-    TAG_BLOB,
-    TAG_FWD_PTR,
-    TAG_BITS32,
-    TAG_BIGINT,
-    TAG_CONCAT,
-    TAG_NULL,
-];
-
-fn test_<M: Memory>(mem: &mut M, n_objs: u32) -> TestCaseResult {
-    let objs: Vec<u32> = (0..n_objs).collect();
-
-    unsafe {
-        alloc_mark_stack(mem);
-
-        for obj in &objs {
-            push_mark_stack(mem, *obj as usize, TAGS[(*obj as usize) % TAGS.len()]);
-        }
-
-        for obj in objs.iter().copied().rev() {
-            let popped = pop_mark_stack();
-            if popped != Some((obj as usize, TAGS[(obj as usize) % TAGS.len()])) {
-                free_mark_stack();
-                return Err(TestCaseError::Fail(
-                    format!(
-                        "Unexpected object popped, expected={:?}, popped={:?}",
-                        obj, popped
-                    )
-                    .into(),
-                ));
-            }
-        }
-
-        free_mark_stack();
-    }
-
-    Ok(())
-}
-
-unsafe fn test_grow_stack() {
-    println!("    Testing grow_stack");
-
-    // Allow doubling twice
-    let mut mem = TestMemory::new(
-        size_of::<Blob>() + INIT_STACK_SIZE + INIT_STACK_SIZE + INIT_STACK_SIZE * 2,
-    );
-
-    alloc_mark_stack(&mut mem);
-
-    let mut current_size = INIT_STACK_SIZE.as_usize();
-    assert_eq!(STACK_BASE.add(current_size), STACK_TOP);
-    assert_eq!(STACK_BASE, STACK_PTR);
-
-    grow_stack(&mut mem);
-    current_size *= 2;
-    assert_eq!(STACK_BASE.add(current_size), STACK_TOP);
-    assert_eq!(STACK_BASE, STACK_PTR);
-
-    grow_stack(&mut mem);
-    current_size *= 2;
-    assert_eq!(STACK_BASE.add(current_size), STACK_TOP);
-    assert_eq!(STACK_BASE, STACK_PTR);
-}
diff --git a/rts/motoko-rts-tests/src/gc/generational.rs b/rts/motoko-rts-tests/src/gc/generational.rs
deleted file mode 100644
index 5a86ed7cf10..00000000000
--- a/rts/motoko-rts-tests/src/gc/generational.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-mod mark_stack;
-mod remembered_set;
-
-pub fn test() {
-    println!("Testing generational GC ...");
-    unsafe {
-        mark_stack::test();
-        remembered_set::test();
-    }
-}
diff --git a/rts/motoko-rts-tests/src/gc/generational/mark_stack.rs b/rts/motoko-rts-tests/src/gc/generational/mark_stack.rs
deleted file mode 100644
index 959b913e87d..00000000000
--- a/rts/motoko-rts-tests/src/gc/generational/mark_stack.rs
+++ /dev/null
@@ -1,89 +0,0 @@
-use crate::memory::TestMemory;
-
-use motoko_rts::gc::generational::mark_stack::{
-    alloc_mark_stack, free_mark_stack, grow_stack, pop_mark_stack, push_mark_stack,
-    INIT_STACK_SIZE, STACK_BASE, STACK_PTR, STACK_TOP,
-};
-use motoko_rts::memory::Memory;
-use motoko_rts::types::*;
-
-use proptest::test_runner::{Config, TestCaseError, TestCaseResult, TestRunner};
-
-pub unsafe fn test() {
-    println!("  Testing mark stack ...");
-
-    test_push_pop();
-    test_grow_stack();
-}
-
-fn test_push_pop() {
-    println!("    Testing push/pop");
-
-    let mut proptest_runner = TestRunner::new(Config {
-        cases: 100,
-        failure_persistence: None,
-        ..Default::default()
-    });
-
-    proptest_runner
-        .run(&(0u32..1000u32), |n_objs| {
-            let mut mem = TestMemory::new(Words(1024 * 1024));
-            test_(&mut mem, n_objs)
-        })
-        .unwrap();
-}
-
-fn test_<M: Memory>(mem: &mut M, n_objs: u32) -> TestCaseResult {
-    let objs: Vec<u32> = (0..n_objs).collect();
-
-    unsafe {
-        alloc_mark_stack(mem);
-
-        for obj in &objs {
-            push_mark_stack(mem, *obj as usize);
-        }
-
-        for obj in objs.iter().copied().rev() {
-            let popped = pop_mark_stack();
-            if popped != Some(obj as usize) {
-                free_mark_stack();
-                return Err(TestCaseError::Fail(
-                    format!(
-                        "Unexpected object popped, expected={:?}, popped={:?}",
-                        obj, popped
-                    )
-                    .into(),
-                ));
-            }
-        }
-
-        free_mark_stack();
-    }
-
-    Ok(())
-}
-
-unsafe fn test_grow_stack() {
-    println!("    Testing grow_stack");
-
-    // Allow doubling twice
-    let mut mem = TestMemory::new(
-        size_of::<Blob>() + INIT_STACK_SIZE + INIT_STACK_SIZE + INIT_STACK_SIZE * 2,
-    );
-
-    alloc_mark_stack(&mut mem);
-
-    let mut current_size = INIT_STACK_SIZE.as_usize();
-    assert_eq!(STACK_BASE.add(current_size), STACK_TOP);
-    assert_eq!(STACK_BASE, STACK_PTR);
-
-    grow_stack(&mut mem);
-    current_size *= 2;
-    assert_eq!(STACK_BASE.add(current_size), STACK_TOP);
-    assert_eq!(STACK_BASE, STACK_PTR);
-
-    grow_stack(&mut mem);
-    current_size *= 2;
-    assert_eq!(STACK_BASE.add(current_size), STACK_TOP);
-    assert_eq!(STACK_BASE, STACK_PTR);
-}
diff --git a/rts/motoko-rts-tests/src/gc/generational/remembered_set.rs b/rts/motoko-rts-tests/src/gc/generational/remembered_set.rs
deleted file mode 100644
index c71de353b15..00000000000
--- a/rts/motoko-rts-tests/src/gc/generational/remembered_set.rs
+++ /dev/null
@@ -1,96 +0,0 @@
-use std::collections::HashSet;
-
-use crate::memory::TestMemory;
-use motoko_rts::gc::generational::remembered_set::{
-    RememberedSet, INITIAL_TABLE_LENGTH, OCCUPATION_THRESHOLD_PERCENT,
-};
-use motoko_rts::types::{Value, Words};
-
-const GROW_LIMIT: u32 = INITIAL_TABLE_LENGTH * OCCUPATION_THRESHOLD_PERCENT / 100;
-
-pub unsafe fn test() {
-    println!("  Testing remembered set ...");
-
-    test_remembered_set(0);
-    test_remembered_set(1);
-    test_remembered_set(INITIAL_TABLE_LENGTH / 2);
-    test_remembered_set(GROW_LIMIT - 1);
-    test_remembered_set(GROW_LIMIT);
-    test_remembered_set(GROW_LIMIT + 1);
-    test_remembered_set(INITIAL_TABLE_LENGTH);
-    test_remembered_set(2 * GROW_LIMIT - 1);
-    test_remembered_set(2 * GROW_LIMIT);
-    test_remembered_set(2 * GROW_LIMIT + 1);
-    test_remembered_set(128 * GROW_LIMIT);
-}
-
-unsafe fn test_remembered_set(amount: u32) {
-    test_insert_iterate(amount);
-    test_duplicates(amount);
-    test_collisions(amount);
-}
-
-unsafe fn test_insert_iterate(amount: u32) {
-    let mut mem = TestMemory::new(Words(2 * amount + 1024 * 1024));
-
-    let mut remembered_set = RememberedSet::new(&mut mem);
-    let mut test_set: HashSet<u32> = HashSet::new();
-    // start at 1 since 0 is the null ptr and not stored in the remembered set
-    for value in 1..amount + 1 {
-        remembered_set.insert(&mut mem, Value::from_raw(value));
-        test_set.insert(value);
-    }
-
-    let mut iterator = remembered_set.iterate();
-    for _ in 1..amount + 1 {
-        assert!(iterator.has_next());
-        let value = iterator.current().get_raw();
-        assert!(test_set.contains(&value));
-        iterator.next();
-    }
-    assert!(!iterator.has_next());
-}
-
-unsafe fn test_duplicates(amount: u32) {
-    let mut mem = TestMemory::new(Words(2 * amount + 1024 * 1024));
-
-    let mut remembered_set = RememberedSet::new(&mut mem);
-    // start at 1 since 0 is the null ptr and not stored in the remembered set
-    for value in 1..amount + 1 {
-        remembered_set.insert(&mut mem, Value::from_raw(value));
-    }
-
-    let count = remembered_set.count();
-    for value in 1..amount + 1 {
-        remembered_set.insert(&mut mem, Value::from_raw(value));
-        assert_eq!(remembered_set.count(), count);
-    }
-}
-
-unsafe fn test_collisions(amount: u32) {
-    let mut mem = TestMemory::new(Words(2 * amount + 1024 * 1024));
-
-    let mut remembered_set = RememberedSet::new(&mut mem);
-    let mut test_set: HashSet<u32> = HashSet::new();
-
-    // start at 1 since 0 is the null ptr and not stored in the remembered set
-    for index in 1..amount + 1 {
-        const FACTOR: u32 = 1024 * 1024;
-        let value = if index <= u32::MAX / FACTOR {
-            index * FACTOR
-        } else {
-            index
-        };
-        remembered_set.insert(&mut mem, Value::from_raw(value));
-        test_set.insert(value);
-    }
-
-    let mut iterator = remembered_set.iterate();
-    for _ in 1..amount + 1 {
-        assert!(iterator.has_next());
-        let value = iterator.current().get_raw();
-        assert!(test_set.contains(&value));
-        iterator.next();
-    }
-    assert!(!iterator.has_next());
-}
diff --git a/rts/motoko-rts-tests/src/gc/heap.rs b/rts/motoko-rts-tests/src/gc/heap.rs
index d343b351d98..195101f8fb1 100644
--- a/rts/motoko-rts-tests/src/gc/heap.rs
+++ b/rts/motoko-rts-tests/src/gc/heap.rs
@@ -1,4 +1,4 @@
-use super::utils::{make_pointer, make_scalar, write_word, ObjectIdx, GC, WORD_SIZE};
+use super::utils::{make_pointer, make_scalar, write_word, ObjectIdx, WORD_SIZE};
 
 use motoko_rts::memory::Memory;
 use motoko_rts::types::*;
@@ -8,7 +8,8 @@ use std::convert::TryFrom;
 use std::rc::Rc;
 
 use fxhash::{FxHashMap, FxHashSet};
-use motoko_rts_macros::*;
+
+use motoko_rts::gc::incremental::partitioned_heap::PARTITION_SIZE;
 
 /// Represents Motoko heaps. Reference counted (implements `Clone`) so we can clone and move values
 /// of this type to GC callbacks.
@@ -38,14 +39,12 @@ impl MotokoHeap {
         map: &[(ObjectIdx, Vec<ObjectIdx>)],
         roots: &[ObjectIdx],
         continuation_table: &[ObjectIdx],
-        gc: GC,
     ) -> MotokoHeap {
         MotokoHeap {
             inner: Rc::new(RefCell::new(MotokoHeapInner::new(
                 map,
                 roots,
                 continuation_table,
-                gc,
             ))),
         }
     }
@@ -66,25 +65,6 @@ impl MotokoHeap {
         self.inner.borrow().heap_ptr_address()
     }
 
-    /// Update the heap pointer given as an address in the current process.
-    #[non_incremental_gc]
-    pub fn set_heap_ptr_address(&self, address: usize) {
-        self.inner.borrow_mut().set_heap_ptr_address(address)
-    }
-
-    /// Get the last heap pointer, as address in the current process. The address can be used to mutate
-    /// the heap.
-    #[non_incremental_gc]
-    pub fn last_ptr_address(&self) -> usize {
-        self.inner.borrow().last_ptr_address()
-    }
-
-    /// Update the last heap pointer given as an address in the current process.
-    #[non_incremental_gc]
-    pub fn set_last_ptr_address(&self, address: usize) {
-        self.inner.borrow_mut().set_last_ptr_address(address)
-    }
-
     /// Get the beginning of dynamic heap, as an address in the current process
     pub fn heap_base_address(&self) -> usize {
         self.inner.borrow().heap_base_address()
@@ -178,18 +158,6 @@ impl MotokoHeapInner {
         self.heap_ptr_offset = self.address_to_offset(address);
     }
 
-    /// Get last heap pointer (i.e. where the dynamic heap ends last GC run) in the process's address space
-    #[non_incremental_gc]
-    fn last_ptr_address(&self) -> usize {
-        self.offset_to_address(self._heap_ptr_last)
-    }
-
-    /// Set last heap pointer
-    #[non_incremental_gc]
-    fn set_last_ptr_address(&mut self, address: usize) {
-        self._heap_ptr_last = self.address_to_offset(address);
-    }
-
     /// Get the address of the variable pointing to the static root array.
     fn static_root_array_variable_address(&self) -> usize {
         self.offset_to_address(self.static_root_array_variable_offset)
@@ -204,7 +172,6 @@ impl MotokoHeapInner {
         map: &[(ObjectIdx, Vec<ObjectIdx>)],
         roots: &[ObjectIdx],
         continuation_table: &[ObjectIdx],
-        gc: GC,
     ) -> MotokoHeapInner {
         // Check test correctness: an object should appear at most once in `map`
         {
@@ -242,12 +209,7 @@ impl MotokoHeapInner {
 
         let total_heap_size_bytes = root_pointers_size_bytes + dynamic_heap_size_bytes;
 
-        let heap_size = heap_size_for_gc(
-            gc,
-            root_pointers_size_bytes,
-            dynamic_heap_size_bytes,
-            map.len(),
-        );
+        let heap_size = heap_size_for_gc();
 
         // The Worst-case unalignment w.r.t. 32-byte alignment is 28 (assuming
         // that we have general word alignment). So we over-allocate 28 bytes.
@@ -286,12 +248,6 @@ impl MotokoHeapInner {
         }
     }
 
-    #[non_incremental_gc]
-    unsafe fn alloc_words(&mut self, n: Words<u32>) -> Value {
-        self.linear_alloc_words(n)
-    }
-
-    #[incremental_gc]
     unsafe fn alloc_words(&mut self, n: Words<u32>) -> Value {
         let mut dummy_memory = DummyMemory {};
         let result =
@@ -335,65 +291,9 @@ impl Memory for DummyMemory {
 }
 
 /// Compute the size of the heap to be allocated for the GC test.
-#[non_incremental_gc]
-fn heap_size_for_gc(
-    gc: GC,
-    static_heap_size_bytes: usize,
-    dynamic_heap_size_bytes: usize,
-    n_objects: usize,
-) -> usize {
-    let total_heap_size_bytes = static_heap_size_bytes + dynamic_heap_size_bytes;
-    match gc {
-        GC::Copying => {
-            let to_space_bytes = dynamic_heap_size_bytes;
-            total_heap_size_bytes + to_space_bytes
-        }
-        GC::MarkCompact => {
-            let bitmap_size_bytes = {
-                let dynamic_heap_bytes = Bytes(dynamic_heap_size_bytes as u32);
-                // `...to_words().to_bytes()` below effectively rounds up heap size to word size
-                // then gets the bytes
-                let dynamic_heap_words = dynamic_heap_bytes.to_words();
-                let mark_bit_bytes = dynamic_heap_words.to_bytes();
-
-                // The bitmap implementation rounds up to 64-bits to be able to read as many
-                // bits as possible in one instruction and potentially skip 64 words in the
-                // heap with single 64-bit comparison
-                (((mark_bit_bytes.as_u32() + 7) / 8) * 8) + size_of::<Blob>().to_bytes().as_u32()
-            };
-            // In the worst case the entire heap will be pushed to the mark stack, but in tests
-            // we limit the size
-            let mark_stack_words = n_objects.clamp(
-                motoko_rts::gc::mark_compact::mark_stack::INIT_STACK_SIZE.as_usize(),
-                super::utils::MAX_MARK_STACK_SIZE,
-            ) + size_of::<Blob>().as_usize();
-
-            total_heap_size_bytes + bitmap_size_bytes as usize + (mark_stack_words * WORD_SIZE)
-        }
-        GC::Generational => {
-            const ROUNDS: usize = 3;
-            const REMEMBERED_SET_MAXIMUM_SIZE: usize = 1024 * 1024 * WORD_SIZE;
-            let size = heap_size_for_gc(
-                GC::MarkCompact,
-                static_heap_size_bytes,
-                dynamic_heap_size_bytes,
-                n_objects,
-            );
-            size + ROUNDS * REMEMBERED_SET_MAXIMUM_SIZE
-        }
-    }
-}
-
-#[incremental_gc]
 fn heap_size_for_gc(
-    gc: GC,
-    _static_heap_size_bytes: usize,
-    _dynamic_heap_size_bytes: usize,
-    _n_objects: usize,
 ) -> usize {
-    match gc {
-        GC::Incremental => 3 * motoko_rts::gc::incremental::partitioned_heap::PARTITION_SIZE,
-    }
+    3 * PARTITION_SIZE
 }
 
 /// Given a heap description (as a map from objects to objects), and the dynamic part of the heap
@@ -406,7 +306,6 @@ fn create_dynamic_heap(
     continuation_table: &[ObjectIdx],
     dynamic_heap: &mut [u8],
 ) -> (u32, u32) {
-    let incremental = cfg!(feature = "incremental_gc");
     let heap_start = dynamic_heap.as_ptr() as usize;
 
     // Maps objects to their addresses
@@ -423,11 +322,9 @@ fn create_dynamic_heap(
             write_word(dynamic_heap, heap_offset, TAG_ARRAY);
             heap_offset += WORD_SIZE;
 
-            if incremental {
-                write_word(dynamic_heap, heap_offset, make_pointer(address)); // forwarding pointer
-                heap_offset += WORD_SIZE;
-            }
-
+            write_word(dynamic_heap, heap_offset, make_pointer(address)); // forwarding pointer
+            heap_offset += WORD_SIZE;
+            
             // Store length: idx + refs
             write_word(
                 dynamic_heap,
@@ -478,11 +375,9 @@ fn create_dynamic_heap(
             write_word(dynamic_heap, heap_offset, TAG_MUTBOX);
             heap_offset += WORD_SIZE;
 
-            if incremental {
-                write_word(dynamic_heap, heap_offset, make_pointer(mutbox_address));
-                heap_offset += WORD_SIZE;
-            }
-
+            write_word(dynamic_heap, heap_offset, make_pointer(mutbox_address));
+            heap_offset += WORD_SIZE;
+            
             let root_ptr = *object_addrs.get(root_id).unwrap();
             write_word(dynamic_heap, heap_offset, make_pointer(root_ptr as u32));
             heap_offset += WORD_SIZE;
@@ -493,15 +388,13 @@ fn create_dynamic_heap(
         write_word(dynamic_heap, heap_offset, TAG_ARRAY);
         heap_offset += WORD_SIZE;
 
-        if incremental {
-            write_word(
-                dynamic_heap,
-                heap_offset,
-                make_pointer(static_root_array_address),
-            );
-            heap_offset += WORD_SIZE;
-        }
-
+        write_word(
+            dynamic_heap,
+            heap_offset,
+            make_pointer(static_root_array_address),
+        );
+        heap_offset += WORD_SIZE;
+        
         assert_eq!(static_roots.len(), root_mutboxes.len());
         write_word(dynamic_heap, heap_offset, root_mutboxes.len() as u32);
         heap_offset += WORD_SIZE;
@@ -517,15 +410,13 @@ fn create_dynamic_heap(
         write_word(dynamic_heap, heap_offset, TAG_ARRAY);
         heap_offset += WORD_SIZE;
 
-        if incremental {
-            write_word(
-                dynamic_heap,
-                heap_offset,
-                make_pointer(continuation_table_address),
-            );
-            heap_offset += WORD_SIZE;
-        }
-
+        write_word(
+            dynamic_heap,
+            heap_offset,
+            make_pointer(continuation_table_address),
+        );
+        heap_offset += WORD_SIZE;
+        
         write_word(dynamic_heap, heap_offset, continuation_table.len() as u32);
         heap_offset += WORD_SIZE;
 
diff --git a/rts/motoko-rts-tests/src/gc/incremental/roots.rs b/rts/motoko-rts-tests/src/gc/incremental/roots.rs
index 73bd88e2288..9a2c23e9783 100644
--- a/rts/motoko-rts-tests/src/gc/incremental/roots.rs
+++ b/rts/motoko-rts-tests/src/gc/incremental/roots.rs
@@ -7,7 +7,7 @@ use motoko_rts::{
 
 use crate::gc::{
     heap::MotokoHeap,
-    utils::{ObjectIdx, GC, WORD_SIZE},
+    utils::{ObjectIdx, WORD_SIZE},
 };
 
 pub unsafe fn test() {
@@ -17,7 +17,7 @@ pub unsafe fn test() {
     let root_ids = [2, 4, 6, 8];
     let continuation_ids = [3, 5, 7];
 
-    let heap = MotokoHeap::new(&object_map, &root_ids, &continuation_ids, GC::Incremental);
+    let heap = MotokoHeap::new(&object_map, &root_ids, &continuation_ids);
     check_visit_static_roots(&heap, &root_ids);
     check_visit_continuation_table(&heap, &continuation_ids);
 }
diff --git a/rts/motoko-rts-tests/src/gc/utils.rs b/rts/motoko-rts-tests/src/gc/utils.rs
index a168e726f68..48d3e6e9063 100644
--- a/rts/motoko-rts-tests/src/gc/utils.rs
+++ b/rts/motoko-rts-tests/src/gc/utils.rs
@@ -1,5 +1,4 @@
 use byteorder::{ReadBytesExt, WriteBytesExt, LE};
-use motoko_rts_macros::*;
 
 /// A unique object index, used in heap descriptions.
 ///
@@ -10,32 +9,6 @@ pub type ObjectIdx = u32;
 /// Same as RTS `WORD_SIZE`, but `usize`
 pub const WORD_SIZE: usize = motoko_rts::constants::WORD_SIZE as usize;
 
-// Max allowed size for the mark stack in mark-compact GC tests
-#[non_incremental_gc]
-pub const MAX_MARK_STACK_SIZE: usize = 100;
-
-/// Enum for the GC implementations. GC functions are generic so we can't put them into arrays or
-/// other data types, we use this type instead.
-#[non_incremental_gc]
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum GC {
-    Copying,
-    MarkCompact,
-    Generational,
-}
-
-#[incremental_gc]
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum GC {
-    Incremental,
-}
-
-#[non_incremental_gc]
-pub static GC_IMPLS: [GC; 3] = [GC::Copying, GC::MarkCompact, GC::Generational];
-
-#[incremental_gc]
-pub static GC_IMPLS: [GC; 1] = [GC::Incremental];
-
 /// Read a little-endian (Wasm) word from given offset
 pub fn read_word(heap: &[u8], offset: usize) -> u32 {
     (&heap[offset..]).read_u32::<LE>().unwrap()
diff --git a/rts/motoko-rts-tests/src/memory.rs b/rts/motoko-rts-tests/src/memory.rs
index 351f260f449..9f725a015b8 100644
--- a/rts/motoko-rts-tests/src/memory.rs
+++ b/rts/motoko-rts-tests/src/memory.rs
@@ -1,6 +1,5 @@
 use motoko_rts::memory::Memory;
 use motoko_rts::types::{Value, Words};
-use motoko_rts_macros::*;
 
 pub struct TestMemory {
     heap: Box<[u8]>,
@@ -15,22 +14,18 @@ impl TestMemory {
         TestMemory { heap, hp }
     }
 
-    #[incremental_gc]
     pub fn heap_base(&self) -> usize {
         self.heap.as_ptr() as usize
     }
 
-    #[incremental_gc]
     pub fn heap_end(&self) -> usize {
         self.heap_base() + self.heap.len()
     }
 
-    #[incremental_gc]
     pub fn heap_pointer(&self) -> usize {
         self.hp
     }
 
-    #[incremental_gc]
     pub fn set_heap_pointer(&mut self, heap_pointer: usize) {
         assert!(heap_pointer >= self.heap_base());
         assert!(heap_pointer <= self.heap_end());
diff --git a/rts/motoko-rts-tests/src/stream.rs b/rts/motoko-rts-tests/src/stream.rs
index 3321ea7142f..f830ee10e81 100644
--- a/rts/motoko-rts-tests/src/stream.rs
+++ b/rts/motoko-rts-tests/src/stream.rs
@@ -4,7 +4,6 @@ use crate::memory::TestMemory;
 
 use motoko_rts::stream::alloc_stream;
 use motoko_rts::types::{size_of, Blob, Bytes, Stream, Value, Words};
-use motoko_rts_macros::is_incremental_gc;
 
 pub unsafe fn test() {
     println!("Testing streaming ...");
@@ -34,7 +33,7 @@ pub unsafe fn test() {
     println!("  Testing stream decay");
     let blob = stream.as_stream().split();
     assert_eq!(blob.as_blob().len(), Bytes(STREAM_SMALL_SIZE));
-    const REMAINDER: u32 = if is_incremental_gc!() { 20 } else { 24 };
+    const REMAINDER: u32 = 20;
     assert_eq!(stream.as_blob().len(), Bytes(REMAINDER));
 
     println!("  Testing stream filling (blocks)");
diff --git a/rts/motoko-rts/Cargo.toml b/rts/motoko-rts/Cargo.toml
index 3d1e3c26ac8..d29a7d4c6ae 100644
--- a/rts/motoko-rts/Cargo.toml
+++ b/rts/motoko-rts/Cargo.toml
@@ -25,9 +25,6 @@ ic = []
 # This feature enables extensive memory sanity checks in the incremental GC.
 memory_check = []
 
-# Incremental GC, using the extended object header containing the forwarding pointer. 
-incremental_gc = []
-
 [dependencies]
 libc = { version = "0.2.139", default_features = false }
 motoko-rts-macros = { path = "../motoko-rts-macros" }
diff --git a/rts/motoko-rts/native/Cargo.toml b/rts/motoko-rts/native/Cargo.toml
index c72c906b9b0..5a31d3798f4 100644
--- a/rts/motoko-rts/native/Cargo.toml
+++ b/rts/motoko-rts/native/Cargo.toml
@@ -8,9 +8,6 @@ edition = "2018"
 crate-type = ["rlib"]
 path = "../src/lib.rs"
 
-[features]
-incremental_gc = []
-
 [dependencies]
 libc = { version = "0.2.112", default_features = false }
 motoko-rts-macros = { path = "../../motoko-rts-macros" }
diff --git a/rts/motoko-rts/src/barriers.rs b/rts/motoko-rts/src/barriers.rs
index 8c4adb9ee47..7a3e7759070 100644
--- a/rts/motoko-rts/src/barriers.rs
+++ b/rts/motoko-rts/src/barriers.rs
@@ -1,34 +1,13 @@
 use crate::{memory::Memory, types::Value};
-use motoko_rts_macros::*;
 
-#[incremental_gc]
 pub unsafe fn init_with_barrier<M: Memory>(_mem: &mut M, location: *mut Value, value: Value) {
     *location = value.forward_if_possible();
 }
 
-#[non_incremental_gc]
-pub unsafe fn init_with_barrier<M: Memory>(mem: &mut M, location: *mut Value, value: Value) {
-    *location = value;
-    crate::gc::generational::write_barrier::post_write_barrier(mem, location as usize);
-}
-
-#[incremental_gc]
 pub unsafe fn write_with_barrier<M: Memory>(mem: &mut M, location: *mut Value, value: Value) {
     crate::gc::incremental::barriers::write_with_barrier(mem, location, value);
 }
 
-#[non_incremental_gc]
-pub unsafe fn write_with_barrier<M: Memory>(mem: &mut M, location: *mut Value, value: Value) {
-    *location = value;
-    crate::gc::generational::write_barrier::post_write_barrier(mem, location as usize);
-}
-
-#[incremental_gc]
 pub unsafe fn allocation_barrier(new_object: Value) -> Value {
     crate::gc::incremental::barriers::allocation_barrier(new_object)
 }
-
-#[non_incremental_gc]
-pub unsafe fn allocation_barrier(new_object: Value) -> Value {
-    new_object
-}
diff --git a/rts/motoko-rts/src/gc.rs b/rts/motoko-rts/src/gc.rs
index f3e1cde2ddd..a2b3e2acd74 100644
--- a/rts/motoko-rts/src/gc.rs
+++ b/rts/motoko-rts/src/gc.rs
@@ -1,26 +1 @@
-#[non_incremental_gc]
-pub mod copying;
-#[non_incremental_gc]
-pub mod generational;
-#[incremental_gc]
 pub mod incremental;
-#[non_incremental_gc]
-pub mod mark_compact;
-
-use motoko_rts_macros::*;
-
-#[cfg(feature = "ic")]
-#[non_incremental_gc]
-unsafe fn should_do_gc(max_live: crate::types::Bytes<u64>) -> bool {
-    use crate::memory::ic::linear_memory::{get_hp_unskewed, LAST_HP};
-
-    // A factor of last heap size. We allow at most this much allocation before doing GC.
-    const HEAP_GROWTH_FACTOR: f64 = 1.5;
-
-    let heap_limit = core::cmp::min(
-        (f64::from(LAST_HP as u32) * HEAP_GROWTH_FACTOR) as u64,
-        (u64::from(LAST_HP as u32) + max_live.0) / 2,
-    );
-
-    u64::from(get_hp_unskewed() as u32) >= heap_limit
-}
diff --git a/rts/motoko-rts/src/gc/copying.rs b/rts/motoko-rts/src/gc/copying.rs
deleted file mode 100644
index 8a2376a54a9..00000000000
--- a/rts/motoko-rts/src/gc/copying.rs
+++ /dev/null
@@ -1,216 +0,0 @@
-use crate::constants::WORD_SIZE;
-use crate::mem_utils::{memcpy_bytes, memcpy_words};
-use crate::memory::Memory;
-use crate::types::*;
-
-use motoko_rts_macros::ic_mem_fn;
-
-#[no_mangle]
-#[cfg(feature = "ic")]
-#[allow(unreachable_code)]
-pub unsafe extern "C" fn initialize_copying_gc() {
-    panic!("Copying GC is not supported with the persistent heap");
-    crate::memory::ic::linear_memory::initialize();
-}
-
-#[ic_mem_fn(ic_only)]
-unsafe fn schedule_copying_gc<M: Memory>(mem: &mut M) {
-    // Half of the heap.
-    // NB. This expression is evaluated in compile time to a constant.
-    let max_live: Bytes<u64> =
-        Bytes(u64::from((crate::constants::WASM_HEAP_SIZE / 2).as_u32()) * u64::from(WORD_SIZE));
-
-    if super::should_do_gc(max_live) {
-        copying_gc(mem);
-    }
-}
-
-#[ic_mem_fn(ic_only)]
-unsafe fn copying_gc<M: Memory>(mem: &mut M) {
-    use crate::memory::ic::{self, linear_memory, HEAP_START};
-
-    copying_gc_internal(
-        mem,
-        HEAP_START,
-        // get_hp
-        || linear_memory::get_hp_unskewed(),
-        // set_hp
-        |hp| linear_memory::set_hp_unskewed(hp),
-        ic::linear_memory::get_static_roots(),
-        crate::continuation_table::continuation_table_loc(),
-        // note_live_size
-        |live_size| ic::MAX_LIVE = ::core::cmp::max(ic::MAX_LIVE, live_size),
-        // note_reclaimed
-        |reclaimed| linear_memory::RECLAIMED += Bytes(u64::from(reclaimed.as_u32())),
-    );
-
-    linear_memory::LAST_HP = linear_memory::get_hp_unskewed();
-}
-
-pub unsafe fn copying_gc_internal<
-    M: Memory,
-    GetHp: Fn() -> usize,
-    SetHp: FnMut(usize),
-    NoteLiveSize: Fn(Bytes<u32>),
-    NoteReclaimed: Fn(Bytes<u32>),
->(
-    mem: &mut M,
-    heap_base: usize,
-    get_hp: GetHp,
-    mut set_hp: SetHp,
-    static_roots: Value,
-    continuation_table_ptr_loc: *mut Value,
-    note_live_size: NoteLiveSize,
-    note_reclaimed: NoteReclaimed,
-) {
-    let begin_from_space = heap_base as usize;
-    let end_from_space = get_hp();
-    let begin_to_space = end_from_space;
-
-    let static_roots = static_roots.as_array();
-
-    // Evacuate roots
-    evac_static_roots(mem, begin_from_space, begin_to_space, static_roots);
-
-    if (*continuation_table_ptr_loc).is_ptr() {
-        evac(
-            mem,
-            begin_from_space,
-            begin_to_space,
-            continuation_table_ptr_loc as usize,
-        );
-    }
-
-    // Scavenge to-space
-    let mut p = begin_to_space;
-    while p < get_hp() {
-        let size = block_size(p);
-        scav(mem, begin_from_space, begin_to_space, Value::from_ptr(p));
-        p += size.to_bytes().as_usize();
-    }
-
-    let end_to_space = get_hp();
-
-    // Note the stats
-    let new_live_size = end_to_space - begin_to_space;
-    note_live_size(Bytes(new_live_size as u32));
-
-    let reclaimed = (end_from_space - begin_from_space) - (end_to_space - begin_to_space);
-    note_reclaimed(Bytes(reclaimed as u32));
-
-    // Copy to-space to the beginning of from-space
-    memcpy_bytes(
-        begin_from_space,
-        begin_to_space,
-        Bytes((end_to_space - begin_to_space) as u32),
-    );
-
-    // Reset the heap pointer
-    let new_hp = begin_from_space + (end_to_space - begin_to_space);
-    set_hp(new_hp);
-}
-
-/// Evacuate (copy) an object in from-space to to-space.
-///
-/// Arguments:
-///
-/// - begin_from_space: Where the dynamic heap starts. Used for two things:
-///
-///   - An object is static if its address is below this value. These objects either don't point to
-///     dynamic heap, or are listed in static_roots array. Objects in static_roots are scavenged
-///     separately in `evac_static_roots` below. So we skip these objects here.
-///
-///   - After all objects are evacuated we move to-space to from-space, to be able to do that the
-///     pointers need to point to their (eventual) locations in from-space, which is calculated with
-///     `address_in_to_space - begin_to_space + begin_from_space`.
-///
-/// - begin_to_space: Where to-space starts. See above for how this is used.
-///
-/// - ptr_loc: Location of the object to evacuate, e.g. an object field address.
-///
-unsafe fn evac<M: Memory>(
-    mem: &mut M,
-    begin_from_space: usize,
-    begin_to_space: usize,
-    ptr_loc: usize,
-) {
-    // Field holds a skewed pointer to the object to evacuate
-    let ptr_loc = ptr_loc as *mut Value;
-
-    // Check object alignment to avoid undefined behavior. See also static_checks module.
-    debug_assert_eq!((*ptr_loc).get_ptr() as u32 % WORD_SIZE, 0);
-
-    // Update the field if the object is already evacuated
-    if (*ptr_loc).tag() == TAG_FWD_PTR {
-        let block = (*ptr_loc).get_ptr() as *const FwdPtr;
-        let fwd = (*block).fwd;
-        *ptr_loc = fwd;
-        return;
-    }
-
-    let obj = (*ptr_loc).get_ptr() as *mut Obj;
-
-    let obj_size = block_size(obj as usize);
-
-    // Allocate space in to-space for the object
-    let obj_addr = mem.alloc_words(obj_size).get_ptr();
-
-    // Copy object to to-space
-    memcpy_words(obj_addr, obj as usize, obj_size);
-
-    // Final location of the object after copying to-space back to from-space
-    let obj_loc = (obj_addr - begin_to_space) + begin_from_space;
-
-    // Set forwarding pointer
-    let fwd = obj as *mut FwdPtr;
-    (*fwd).tag = TAG_FWD_PTR;
-    (*fwd).fwd = Value::from_ptr(obj_loc);
-
-    // Update evacuated field
-    *ptr_loc = Value::from_ptr(obj_loc);
-
-    // Update forwarding pointer
-    let to_space_obj = obj_addr as *mut Obj;
-    debug_assert!(obj_size.as_usize() > size_of::<Obj>().as_usize());
-    debug_assert!(to_space_obj.tag() >= TAG_OBJECT && to_space_obj.tag() <= TAG_NULL);
-}
-
-unsafe fn scav<M: Memory>(
-    mem: &mut M,
-    begin_from_space: usize,
-    begin_to_space: usize,
-    block: Value,
-) {
-    if !block.is_obj() {
-        // Skip `OneWordFiller` and `FreeSpace` that have no regular object header.
-        return;
-    }
-    let obj = block.get_ptr() as *mut Obj;
-
-    crate::visitor::visit_pointer_fields(
-        mem,
-        obj,
-        obj.tag(),
-        begin_from_space,
-        |mem, field_addr| {
-            evac(mem, begin_from_space, begin_to_space, field_addr as usize);
-        },
-        |_, _, arr| arr.len(),
-    );
-}
-
-// We have a special evacuation routine for "static roots" array: we don't evacuate elements of
-// "static roots", we just scavenge them.
-unsafe fn evac_static_roots<M: Memory>(
-    mem: &mut M,
-    begin_from_space: usize,
-    begin_to_space: usize,
-    roots: *mut Array,
-) {
-    // The array and the objects pointed by the array are all static so we don't evacuate them. We
-    // only evacuate fields of objects in the array.
-    for i in 0..roots.len() {
-        let obj = roots.get(i);
-        scav(mem, begin_from_space, begin_to_space, obj);
-    }
-}
diff --git a/rts/motoko-rts/src/gc/generational.rs b/rts/motoko-rts/src/gc/generational.rs
deleted file mode 100644
index b9083ac2872..00000000000
--- a/rts/motoko-rts/src/gc/generational.rs
+++ /dev/null
@@ -1,517 +0,0 @@
-//! Generational compacting GC.
-//! Two generations: young and old.
-//! Frequent collection of young generation, sporadic full collection (old + young).
-//! Young generation collection requires an extra root set of old-to-young pointers.
-//! A write barrier catches all pointers leading from old to young generation.
-//! Compaction is based on the existing Motoko RTS threaded mark & compact GC.
-
-pub mod mark_stack;
-pub mod remembered_set;
-#[cfg(feature = "memory_check")]
-mod sanity_checks;
-pub mod write_barrier;
-
-use crate::gc::generational::mark_stack::{alloc_mark_stack, push_mark_stack};
-use crate::gc::mark_compact::bitmap::{
-    alloc_bitmap, free_bitmap, get_bit, iter_bits, set_bit, BITMAP_ITER_END,
-};
-
-use crate::constants::WORD_SIZE;
-use crate::mem_utils::memcpy_words;
-use crate::memory::Memory;
-use crate::types::*;
-use crate::visitor::{pointer_to_dynamic_heap, visit_pointer_fields};
-
-use motoko_rts_macros::ic_mem_fn;
-
-use self::mark_stack::{free_mark_stack, pop_mark_stack};
-use self::write_barrier::REMEMBERED_SET;
-
-#[ic_mem_fn(ic_only)]
-#[allow(unreachable_code, unused_variables)]
-unsafe fn initialize_generational_gc<M: Memory>(mem: &mut M) {
-    panic!("Generational GC is not supported with the persistent heap");
-    crate::memory::ic::linear_memory::initialize();
-    write_barrier::init_generational_write_barrier(mem);
-}
-
-#[ic_mem_fn(ic_only)]
-unsafe fn schedule_generational_gc<M: Memory>(mem: &mut M) {
-    let limits = get_limits();
-    if decide_strategy(&limits).is_some() {
-        generational_gc(mem);
-    }
-}
-
-#[ic_mem_fn(ic_only)]
-unsafe fn generational_gc<M: Memory>(mem: &mut M) {
-    use crate::memory::ic;
-
-    let old_limits = get_limits();
-    let roots = Roots {
-        static_roots: ic::linear_memory::get_static_roots(),
-        continuation_table_ptr_loc: crate::continuation_table::continuation_table_loc(),
-    };
-    let heap = Heap {
-        mem,
-        limits: get_limits(),
-        roots,
-    };
-    let strategy = decide_strategy(&heap.limits);
-
-    let strategy = strategy.unwrap_or(Strategy::Young);
-    let mut gc = GenerationalGC::new(heap, strategy);
-
-    #[cfg(feature = "memory_check")]
-    sanity_checks::verify_snapshot(&gc.heap, false);
-
-    gc.run();
-
-    let new_limits = &gc.heap.limits;
-    set_limits(&gc.heap.limits);
-    update_statistics(&old_limits, new_limits);
-    update_strategy(strategy, new_limits);
-
-    #[cfg(feature = "memory_check")]
-    sanity_checks::check_memory(&gc.heap.limits, &gc.heap.roots);
-    #[cfg(feature = "memory_check")]
-    sanity_checks::take_snapshot(&mut gc.heap);
-
-    write_barrier::init_generational_write_barrier(gc.heap.mem);
-}
-
-#[cfg(feature = "ic")]
-unsafe fn get_limits() -> Limits {
-    use crate::memory::ic::{linear_memory, HEAP_START};
-    assert!(linear_memory::LAST_HP >= HEAP_START);
-    Limits {
-        base: HEAP_START,
-        last_free: linear_memory::LAST_HP,
-        free: (linear_memory::get_hp_unskewed()),
-    }
-}
-
-#[cfg(feature = "ic")]
-unsafe fn set_limits(limits: &Limits) {
-    use crate::memory::ic::linear_memory;
-    linear_memory::set_hp_unskewed(limits.free);
-    linear_memory::LAST_HP = limits.free;
-}
-
-#[cfg(feature = "ic")]
-unsafe fn update_statistics(old_limits: &Limits, new_limits: &Limits) {
-    use crate::memory::ic::{self, linear_memory};
-    let live_size = Bytes(new_limits.free as u32 - new_limits.base as u32);
-    ic::MAX_LIVE = ::core::cmp::max(ic::MAX_LIVE, live_size);
-    linear_memory::RECLAIMED += Bytes(old_limits.free as u64 - new_limits.free as u64);
-}
-
-#[derive(PartialEq, Clone, Copy, Debug)]
-pub enum Strategy {
-    Young,
-    Full,
-}
-
-#[cfg(feature = "ic")]
-static mut OLD_GENERATION_THRESHOLD: usize = 32 * 1024 * 1024;
-
-#[cfg(feature = "ic")]
-static mut PASSED_CRITICAL_LIMIT: bool = false;
-
-#[cfg(feature = "ic")]
-const CRITICAL_MEMORY_LIMIT: usize = (4096 - 512) * 1024 * 1024;
-
-#[cfg(feature = "ic")]
-unsafe fn decide_strategy(limits: &Limits) -> Option<Strategy> {
-    const YOUNG_GENERATION_THRESHOLD: usize = 8 * 1024 * 1024;
-
-    assert!(limits.base <= limits.last_free);
-    let old_generation_size = limits.last_free - limits.base;
-    assert!(limits.last_free <= limits.free);
-    let young_generation_size = limits.free - limits.last_free;
-
-    if limits.free >= CRITICAL_MEMORY_LIMIT && !PASSED_CRITICAL_LIMIT {
-        PASSED_CRITICAL_LIMIT = true;
-        Some(Strategy::Full)
-    } else if old_generation_size > OLD_GENERATION_THRESHOLD {
-        Some(Strategy::Full)
-    } else if young_generation_size > YOUNG_GENERATION_THRESHOLD {
-        Some(Strategy::Young)
-    } else {
-        None
-    }
-}
-
-#[cfg(feature = "ic")]
-unsafe fn update_strategy(strategy: Strategy, limits: &Limits) {
-    const GROWTH_RATE: f64 = 2.0;
-    if strategy == Strategy::Full {
-        OLD_GENERATION_THRESHOLD = ((limits.free - limits.base) as f64 * GROWTH_RATE) as usize;
-        if limits.free < CRITICAL_MEMORY_LIMIT {
-            PASSED_CRITICAL_LIMIT = false
-        }
-    }
-}
-
-pub struct Heap<'a, M: Memory> {
-    pub mem: &'a mut M,
-    pub limits: Limits,
-    pub roots: Roots,
-}
-
-pub struct Roots {
-    pub static_roots: Value,
-    pub continuation_table_ptr_loc: *mut Value,
-    // For possible future additional roots, please extend the functionality in:
-    // * `mark_root_set`
-    // * `thread_initial_phase`
-}
-
-pub struct Limits {
-    pub base: usize,
-    pub last_free: usize, // this separates the old generation from the young generation
-    pub free: usize,
-}
-
-pub struct GenerationalGC<'a, M: Memory> {
-    pub heap: Heap<'a, M>,
-    marked_space: usize,
-    strategy: Strategy,
-}
-
-impl<'a, M: Memory> GenerationalGC<'a, M> {
-    pub fn new(heap: Heap<M>, strategy: Strategy) -> GenerationalGC<M> {
-        GenerationalGC {
-            heap,
-            marked_space: 0,
-            strategy,
-        }
-    }
-
-    pub unsafe fn run(&mut self) {
-        self.alloc_mark_structures();
-        self.mark_phase();
-        self.compact_phase();
-        self.free_mark_structures();
-    }
-
-    unsafe fn alloc_mark_structures(&mut self) {
-        const BITMAP_ALIGNMENT: usize = 8 * WORD_SIZE as usize;
-        let heap_prefix = match self.strategy {
-            Strategy::Young => self.heap.limits.last_free / BITMAP_ALIGNMENT * BITMAP_ALIGNMENT,
-            Strategy::Full => self.heap.limits.base,
-        };
-        let heap_size = Bytes((self.heap.limits.free - heap_prefix) as u32);
-        alloc_bitmap(self.heap.mem, heap_size, heap_prefix as u32 / WORD_SIZE);
-        alloc_mark_stack(self.heap.mem);
-    }
-
-    unsafe fn free_mark_structures(&mut self) {
-        free_mark_stack();
-        free_bitmap();
-    }
-
-    unsafe fn mark_phase(&mut self) {
-        self.marked_space = 0;
-        self.mark_root_set();
-        self.mark_all_reachable();
-    }
-
-    unsafe fn mark_root_set(&mut self) {
-        self.mark_static_roots();
-
-        let continuation_table = *self.heap.roots.continuation_table_ptr_loc;
-        if continuation_table.is_ptr() && continuation_table.get_ptr() >= self.generation_base() {
-            self.mark_object(continuation_table);
-        }
-
-        if self.strategy == Strategy::Young {
-            self.mark_additional_young_root_set();
-        }
-    }
-
-    unsafe fn mark_static_roots(&mut self) {
-        let root_array = self.heap.roots.static_roots.as_array();
-        for i in 0..root_array.len() {
-            let object = root_array.get(i).as_obj();
-            assert_eq!(object.tag(), TAG_MUTBOX);
-            assert!((object as usize) < self.heap.limits.base);
-            self.mark_root_mutbox_fields(object as *mut MutBox);
-        }
-    }
-
-    unsafe fn mark_additional_young_root_set(&mut self) {
-        let mut iterator = REMEMBERED_SET.as_ref().unwrap().iterate();
-        while iterator.has_next() {
-            let location = iterator.current().get_raw() as *mut Value;
-            let value = *location;
-            // Check whether the location still refers to young object as this may have changed
-            // due to subsequent writes to that location after the write barrier recording.
-            if value.points_to_or_beyond(self.heap.limits.last_free) {
-                self.mark_object(value);
-            }
-            iterator.next();
-        }
-    }
-
-    unsafe fn mark_object(&mut self, object: Value) {
-        let pointer = object.get_ptr() as u32;
-        assert!(pointer >= self.generation_base() as u32);
-        assert_eq!(pointer % WORD_SIZE, 0);
-
-        let obj_idx = pointer / WORD_SIZE;
-        if get_bit(obj_idx) {
-            return;
-        }
-        set_bit(obj_idx);
-
-        push_mark_stack(self.heap.mem, pointer as usize);
-        self.marked_space += block_size(pointer as usize).to_bytes().as_usize();
-    }
-
-    unsafe fn mark_all_reachable(&mut self) {
-        while let Some(obj) = pop_mark_stack() {
-            self.mark_fields(obj as *mut Obj);
-        }
-    }
-
-    unsafe fn mark_fields(&mut self, object: *mut Obj) {
-        visit_pointer_fields(
-            self,
-            object,
-            object.tag(),
-            self.generation_base(),
-            |gc, field_address| {
-                let field_value = *field_address;
-                gc.mark_object(field_value);
-
-                // Should become a debug assertion in future.
-                gc.barrier_coverage_check(field_address);
-            },
-            |gc, slice_start, array| {
-                const SLICE_INCREMENT: u32 = 255;
-                debug_assert!(SLICE_INCREMENT >= TAG_ARRAY_SLICE_MIN);
-                if array.len() - slice_start > SLICE_INCREMENT {
-                    let new_start = slice_start + SLICE_INCREMENT;
-                    // Remember to visit the array suffix later, store the next visit offset in the tag.
-                    (*array).header.tag = new_start;
-                    push_mark_stack(gc.heap.mem, array as usize);
-                    new_start
-                } else {
-                    // No further visits of this array. Restore the tag.
-                    (*array).header.tag = TAG_ARRAY;
-                    array.len()
-                }
-            },
-        );
-    }
-
-    unsafe fn barrier_coverage_check(&self, field_address: *mut Value) {
-        if self.strategy == Strategy::Full
-            && (field_address as usize) >= self.heap.limits.base
-            && (field_address as usize) < self.heap.limits.last_free
-            && (*field_address).points_to_or_beyond(self.heap.limits.last_free)
-        {
-            assert!(REMEMBERED_SET
-                .as_ref()
-                .unwrap()
-                .contains(Value::from_raw(field_address as u32)));
-        }
-    }
-
-    unsafe fn mark_root_mutbox_fields(&mut self, mutbox: *mut MutBox) {
-        let field_address = &mut (*mutbox).field;
-        if pointer_to_dynamic_heap(field_address, self.generation_base()) {
-            self.mark_object(*field_address);
-        }
-    }
-
-    unsafe fn compact_phase(&mut self) {
-        if self.is_compaction_beneficial() {
-            self.thread_initial_phase();
-            self.move_phase();
-        }
-    }
-
-    fn is_compaction_beneficial(&self) -> bool {
-        // Returns false if the survival rate is f64::INF for an empty generation.
-        const SURVIVAL_THRESHOLD: f64 = 0.95;
-        self.survival_rate() < SURVIVAL_THRESHOLD
-    }
-
-    fn generation_base(&self) -> usize {
-        match self.strategy {
-            Strategy::Young => self.heap.limits.last_free,
-            Strategy::Full => self.heap.limits.base,
-        }
-    }
-
-    fn generation_size(&self) -> usize {
-        self.heap.limits.free - self.generation_base()
-    }
-
-    fn survival_rate(&self) -> f64 {
-        // Returns f64::INF if the generation size is zero, e.g. on forced GC.
-        self.marked_space as f64 / self.generation_size() as f64
-    }
-
-    unsafe fn thread_initial_phase(&mut self) {
-        self.thread_all_backward_pointers();
-
-        // For static roots, also forward pointers are threaded.
-        // Therefore, this must happen after the heap traversal for backwards pointer threading.
-        self.thread_static_roots();
-
-        let continuation_table = *self.heap.roots.continuation_table_ptr_loc;
-        if continuation_table.is_ptr() && continuation_table.get_ptr() >= self.generation_base() {
-            self.thread(self.heap.roots.continuation_table_ptr_loc);
-        }
-
-        // For the young generation GC run, the forward pointers from the old generation must be threaded too.
-        if self.strategy == Strategy::Young {
-            self.thread_old_generation_pointers();
-        }
-    }
-
-    unsafe fn thread_static_roots(&self) {
-        let root_array = self.heap.roots.static_roots.as_array();
-        for i in 0..root_array.len() {
-            let object = root_array.get(i).as_obj();
-            assert_eq!(object.tag(), TAG_MUTBOX);
-            assert!((object as usize) < self.heap.limits.base);
-            self.thread_root_mutbox_fields(object as *mut MutBox);
-        }
-    }
-
-    unsafe fn thread_root_mutbox_fields(&self, mutbox: *mut MutBox) {
-        let field_addr = &mut (*mutbox).field;
-        if pointer_to_dynamic_heap(field_addr, self.generation_base()) {
-            self.thread(field_addr);
-        }
-    }
-
-    unsafe fn thread_all_backward_pointers(&mut self) {
-        let mut bitmap_iter = iter_bits();
-        let mut bit = bitmap_iter.next();
-        while bit != BITMAP_ITER_END {
-            let object = (bit * WORD_SIZE) as *mut Obj;
-            self.thread_backward_pointer_fields(object);
-            bit = bitmap_iter.next();
-        }
-    }
-
-    unsafe fn thread_backward_pointer_fields(&mut self, object: *mut Obj) {
-        debug_assert!(object.tag() < TAG_ARRAY_SLICE_MIN);
-        visit_pointer_fields(
-            &mut (),
-            object,
-            object.tag(),
-            self.generation_base(),
-            |_, field_address| {
-                let field_value = *field_address;
-                // Thread if backwards or self pointer
-                if field_value.get_ptr() <= object as usize {
-                    (&self).thread(field_address);
-                }
-            },
-            |_, _, array| array.len(),
-        );
-    }
-
-    // Thread forward pointers in old generation leading to young generation
-    unsafe fn thread_old_generation_pointers(&mut self) {
-        let mut iterator = REMEMBERED_SET.as_ref().unwrap().iterate();
-        while iterator.has_next() {
-            let location = iterator.current().get_raw() as *mut Value;
-            assert!(
-                (location as usize) >= self.heap.limits.base
-                    && (location as usize) < self.heap.limits.last_free
-            );
-            let value = *location;
-            // value in the location may have changed since recording by the write barrer
-            if value.points_to_or_beyond(self.heap.limits.last_free) {
-                self.thread(location);
-            }
-            iterator.next();
-        }
-    }
-
-    unsafe fn move_phase(&mut self) {
-        REMEMBERED_SET = None; // no longer valid when the moving phase starts
-        let mut free = self.heap.limits.base;
-
-        let mut bitmap_iter = iter_bits();
-        if self.strategy == Strategy::Young {
-            free = self.heap.limits.last_free;
-        }
-        let mut bit = bitmap_iter.next();
-        while bit != BITMAP_ITER_END {
-            let old_pointer = (bit * WORD_SIZE) as *mut Obj;
-            let new_pointer = free;
-
-            // Unthread backwards pointers as well as forward pointers of static objects.
-            // In the case of a young collection, also unthread forward pointers of old objects.
-            self.unthread(old_pointer, new_pointer);
-
-            // Move the object
-            let object_size = block_size(old_pointer as usize);
-            if new_pointer as usize != old_pointer as usize {
-                memcpy_words(new_pointer as usize, old_pointer as usize, object_size);
-                debug_assert!(object_size.as_usize() > size_of::<Obj>().as_usize());
-
-                // Update forwarding pointer
-                let new_obj = new_pointer as *mut Obj;
-                debug_assert!(new_obj.tag() >= TAG_OBJECT && new_obj.tag() <= TAG_NULL);
-            }
-
-            free += object_size.to_bytes().as_usize();
-
-            // Thread forward pointers of the object, even if not moved
-            self.thread_forward_pointers(new_pointer as *mut Obj);
-
-            bit = bitmap_iter.next();
-        }
-
-        self.heap.limits.free = free;
-    }
-
-    /// Thread forward pointers in object
-    unsafe fn thread_forward_pointers(&mut self, object: *mut Obj) {
-        visit_pointer_fields(
-            &mut (),
-            object,
-            object.tag(),
-            self.generation_base(),
-            |_, field_address| {
-                if (*field_address).get_ptr() > object as usize {
-                    (&self).thread(field_address)
-                }
-            },
-            |_, _, array| array.len(),
-        );
-    }
-
-    unsafe fn thread(&self, field: *mut Value) {
-        let pointed = (*field).get_ptr() as *mut Obj;
-        assert!(self.should_be_threaded(pointed));
-        let pointed_header = pointed.tag();
-        *field = Value::from_raw(pointed_header);
-        (*pointed).tag = field as u32;
-    }
-
-    unsafe fn unthread(&self, object: *mut Obj, new_location: usize) {
-        assert!(self.should_be_threaded(object));
-        let mut header = object.tag();
-        while header & 0b1 == 0 {
-            let tmp = (header as *const Obj).tag();
-            (*(header as *mut Value)) = Value::from_ptr(new_location);
-            header = tmp;
-        }
-        assert!(header >= TAG_OBJECT && header <= TAG_NULL);
-        (*object).tag = header;
-    }
-
-    unsafe fn should_be_threaded(&self, object: *mut Obj) -> bool {
-        object as usize >= self.generation_base()
-    }
-}
diff --git a/rts/motoko-rts/src/gc/generational/mark_stack.rs b/rts/motoko-rts/src/gc/generational/mark_stack.rs
deleted file mode 100644
index 3bc6134e533..00000000000
--- a/rts/motoko-rts/src/gc/generational/mark_stack.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-//! A stack for marking heap objects (for GC). Adopted from mark & compact GC.
-//! Simplified to only store object pointers without tags.
-
-use crate::memory::{alloc_blob, Memory};
-use crate::types::{Blob, Words};
-
-use core::ptr::null_mut;
-
-/// Initial stack size
-pub const INIT_STACK_SIZE: Words<u32> = Words(64);
-
-/// Pointer to the `blob` object for the mark stack. Used to get the capacity of the stack.
-static mut STACK_BLOB_PTR: *mut Blob = null_mut();
-
-/// Bottom of the mark stack
-pub static mut STACK_BASE: *mut usize = null_mut();
-
-/// Top of the mark stack
-pub static mut STACK_TOP: *mut usize = null_mut();
-
-/// Next free slot in the mark stack
-pub static mut STACK_PTR: *mut usize = null_mut();
-
-/// Allocate the mark stack at the start of each GC run
-pub unsafe fn alloc_mark_stack<M: Memory>(mem: &mut M) {
-    assert!(STACK_BLOB_PTR.is_null());
-
-    // Allocating an actual object here to not break dump_heap
-    // No post allocation barrier as this RTS-internal blob will be collected by the GC.
-    STACK_BLOB_PTR = alloc_blob(mem, INIT_STACK_SIZE.to_bytes()).get_ptr() as *mut Blob;
-    STACK_BASE = STACK_BLOB_PTR.payload_addr() as *mut usize;
-    STACK_PTR = STACK_BASE;
-    STACK_TOP = STACK_BASE.add(INIT_STACK_SIZE.as_usize());
-}
-
-/// Deallocate the mark stack after each GC run
-pub unsafe fn free_mark_stack() {
-    STACK_BLOB_PTR = null_mut();
-    STACK_BASE = null_mut();
-    STACK_PTR = null_mut();
-    STACK_TOP = null_mut();
-}
-
-/// Doubles the stack size
-pub unsafe fn grow_stack<M: Memory>(mem: &mut M) {
-    let stack_cap: Words<u32> = STACK_BLOB_PTR.len().to_words();
-    let p = mem.alloc_words(stack_cap).get_ptr() as *mut usize;
-
-    // Make sure nothing was allocated after the stack
-    assert_eq!(STACK_TOP, p);
-
-    let new_cap: Words<u32> = stack_cap * 2;
-    (*STACK_BLOB_PTR).len = new_cap.to_bytes();
-    STACK_TOP = STACK_BASE.add(new_cap.as_usize());
-}
-
-/// Push a new unskewed object pointer to be marked later
-pub unsafe fn push_mark_stack<M: Memory>(mem: &mut M, object: usize) {
-    if STACK_PTR == STACK_TOP {
-        grow_stack(mem);
-    }
-    *STACK_PTR = object;
-    STACK_PTR = STACK_PTR.add(1);
-}
-
-/// Pop a unskewed object pointer if existend to be visited next
-pub unsafe fn pop_mark_stack() -> Option<usize> {
-    if STACK_PTR == STACK_BASE {
-        return None;
-    }
-    STACK_PTR = STACK_PTR.sub(1);
-    let object = *STACK_PTR;
-    return Some(object);
-}
diff --git a/rts/motoko-rts/src/gc/generational/remembered_set.rs b/rts/motoko-rts/src/gc/generational/remembered_set.rs
deleted file mode 100644
index 03c1cdc13a0..00000000000
--- a/rts/motoko-rts/src/gc/generational/remembered_set.rs
+++ /dev/null
@@ -1,275 +0,0 @@
-//! Remembered set.
-//! Serves for recording pointer locations trapped by the write barrier.
-//!
-//! Hash-set implementation. Linked-list collision handling.
-//!
-//! Hash function = (ptr / WORD_SIZE) % TABLE_SIZE
-//!
-//! Hash-table (length N):
-//! ----------------------------------
-//! | entry[0]   | collision_ptr[0]   |
-//! ----------------------------------
-//! | entry[1]   | collision_ptr[1]   |
-//! ----------------------------------
-//! |  ...                           |
-//! ----------------------------------
-//! | entry[N-1] | collision_ptr[N-1] |
-//! ----------------------------------
-//!
-//! Per collision a new linked list node is appended:
-//!
-//!                               Collision node
-//!                        ------------------------------
-//! prev_collision_ptr --> | entry | next_collision_ptr |
-//!                        ------------------------------
-//!
-//! Amortized hash-table growth when exceeding a defined threshold.
-//!
-//! Growth factor 2 for faster bitwise modulo calculation.
-//!
-//! NOTE: Remembered set structure is not recorded by write barriers
-//! as it is discarded by each GC run.
-//!
-//! NOTE: The table must be blobs, as their entries must not be
-//! analyzed by the GC.
-
-use core::mem::size_of;
-use core::ptr::null_mut;
-
-use crate::constants::WORD_SIZE;
-use crate::memory::{alloc_blob, Memory};
-use crate::types::{block_size, Blob, Bytes, Value};
-
-pub struct RememberedSet {
-    hash_table: *mut Blob,
-    count: u32, // contained entries
-}
-
-#[repr(C)]
-struct HashEntry {
-    pub value: Value,
-    pub next_collision_ptr: *mut CollisionNode,
-}
-
-#[repr(C)]
-struct CollisionNode {
-    pub header: Blob,
-    pub entry: HashEntry,
-}
-
-pub struct RememberedSetIterator {
-    hash_table: *mut Blob,
-    hash_index: u32,
-    current_entry: *mut HashEntry,
-}
-
-pub const INITIAL_TABLE_LENGTH: u32 = 1024;
-const GROWTH_FACTOR: u32 = 2;
-pub const OCCUPATION_THRESHOLD_PERCENT: u32 = 65;
-
-impl RememberedSet {
-    pub unsafe fn new<M: Memory>(mem: &mut M) -> RememberedSet {
-        let hash_table = new_table(mem, INITIAL_TABLE_LENGTH);
-        RememberedSet {
-            hash_table,
-            count: 0,
-        }
-    }
-
-    pub unsafe fn insert<M: Memory>(&mut self, mem: &mut M, value: Value) {
-        debug_assert!(!is_null_ptr_value(value));
-        let index = self.hash_index(value);
-        let entry = table_get(self.hash_table, index);
-        if is_null_ptr_value((*entry).value) {
-            debug_assert_eq!((*entry).next_collision_ptr, null_mut());
-            table_set(self.hash_table, index, value);
-        } else {
-            let mut current = entry;
-            while (*current).value.get_raw() != value.get_raw()
-                && (*current).next_collision_ptr != null_mut()
-            {
-                let next_node = (*current).next_collision_ptr;
-                current = &mut (*next_node).entry;
-                debug_assert!(!is_null_ptr_value((*current).value));
-            }
-            if (*current).value.get_raw() == value.get_raw() {
-                // duplicate
-                return;
-            }
-            debug_assert!(!is_null_ptr_value((*current).value));
-            (*current).next_collision_ptr = new_collision_node(mem, value);
-        }
-        self.count += 1;
-        if self.count > table_length(self.hash_table) * OCCUPATION_THRESHOLD_PERCENT / 100 {
-            self.grow(mem);
-        }
-    }
-
-    // Only used for debug assertions (barrier coverage check).
-    pub unsafe fn contains(&self, value: Value) -> bool {
-        debug_assert!(!is_null_ptr_value(value));
-        let index = self.hash_index(value);
-        let entry = table_get(self.hash_table, index);
-        if !is_null_ptr_value((*entry).value) {
-            let mut current = entry;
-            while (*current).value.get_raw() != value.get_raw()
-                && (*current).next_collision_ptr != null_mut()
-            {
-                let next_node = (*current).next_collision_ptr;
-                current = &mut (*next_node).entry;
-                debug_assert!(!is_null_ptr_value((*current).value));
-            }
-            if (*current).value.get_raw() == value.get_raw() {
-                return true;
-            }
-        }
-        false
-    }
-
-    pub unsafe fn hash_index(&self, value: Value) -> u32 {
-        // Future optimization: Use bitwise modulo, check for power of 2
-        let raw = value.get_raw();
-        let length = table_length(self.hash_table);
-        debug_assert_eq!((raw / WORD_SIZE) % length, (raw / WORD_SIZE) & (length - 1));
-        (raw / WORD_SIZE) & (length - 1)
-    }
-
-    pub unsafe fn iterate(&self) -> RememberedSetIterator {
-        RememberedSetIterator::init(self)
-    }
-
-    pub fn count(&self) -> u32 {
-        self.count
-    }
-
-    unsafe fn grow<M: Memory>(&mut self, mem: &mut M) {
-        let old_count = self.count;
-        let mut iterator = self.iterate();
-        let new_length = table_length(self.hash_table) * GROWTH_FACTOR;
-        self.hash_table = new_table(mem, new_length);
-        self.count = 0;
-        while iterator.has_next() {
-            let value = iterator.current();
-            debug_assert!(!is_null_ptr_value(value));
-            self.insert(mem, value);
-            iterator.next();
-        }
-        assert_eq!(self.count, old_count);
-    }
-}
-
-impl RememberedSetIterator {
-    pub unsafe fn init(remembered_set: &RememberedSet) -> RememberedSetIterator {
-        let mut first_entry = table_get(remembered_set.hash_table, 0);
-        if is_null_ptr_value((*first_entry).value) {
-            first_entry = null_mut()
-        }
-        let mut iterator = RememberedSetIterator {
-            hash_table: remembered_set.hash_table,
-            hash_index: 0,
-            current_entry: first_entry,
-        };
-        iterator.skip_free();
-        iterator
-    }
-
-    unsafe fn skip_free(&mut self) {
-        let length = table_length(self.hash_table);
-        if self.hash_index == length {
-            return;
-        }
-        if self.current_entry != null_mut() {
-            debug_assert!(!is_null_ptr_value((*self.current_entry).value));
-            return;
-        }
-        self.hash_index += 1;
-        while self.hash_index < length
-            && is_null_ptr_value((*table_get(self.hash_table, self.hash_index)).value)
-        {
-            debug_assert_eq!(
-                (*table_get(self.hash_table, self.hash_index)).next_collision_ptr,
-                null_mut()
-            );
-            self.hash_index += 1
-        }
-        if self.hash_index < length {
-            self.current_entry = table_get(self.hash_table, self.hash_index);
-            debug_assert!(!is_null_ptr_value((*self.current_entry).value));
-        } else {
-            self.current_entry = null_mut();
-        }
-    }
-
-    pub unsafe fn has_next(&self) -> bool {
-        self.current_entry != null_mut()
-    }
-
-    pub unsafe fn current(&self) -> Value {
-        debug_assert!(self.has_next());
-        debug_assert!(!is_null_ptr_value((*self.current_entry).value));
-        (*self.current_entry).value
-    }
-
-    pub unsafe fn next(&mut self) {
-        debug_assert!(self.has_next());
-        let next_node = (*self.current_entry).next_collision_ptr;
-        if next_node == null_mut() {
-            self.current_entry = null_mut()
-        } else {
-            self.current_entry = &mut (*next_node).entry as *mut HashEntry;
-        }
-        self.skip_free()
-    }
-}
-
-unsafe fn new_table<M: Memory>(mem: &mut M, size: u32) -> *mut Blob {
-    // No post allocation barrier as this RTS-internal blob will be collected by the GC.
-    let table = alloc_blob(mem, Bytes(size * size_of::<HashEntry>() as u32)).as_blob_mut();
-    for index in 0..size {
-        table_set(table, index, null_ptr_value());
-    }
-    table
-}
-
-unsafe fn new_collision_node<M: Memory>(mem: &mut M, value: Value) -> *mut CollisionNode {
-    debug_assert!(!is_null_ptr_value(value));
-    // No post allocation barrier as this RTS-internal blob will be collected by the GC.
-    let node =
-        alloc_blob(mem, Bytes(size_of::<HashEntry>() as u32)).as_blob_mut() as *mut CollisionNode;
-    (*node).entry = HashEntry {
-        value,
-        next_collision_ptr: null_mut(),
-    };
-    node
-}
-
-unsafe fn table_get(table: *mut Blob, index: u32) -> *mut HashEntry {
-    debug_assert!(table != null_mut());
-    let entry =
-        (table.payload_addr() as u32 + index * size_of::<HashEntry>() as u32) as *mut HashEntry;
-    debug_assert!(
-        entry as u32 + size_of::<HashEntry>() as u32
-            <= table as u32 + block_size(table as usize).to_bytes().as_u32()
-    );
-    entry
-}
-
-unsafe fn table_set(table: *mut Blob, index: u32, value: Value) {
-    let entry = table_get(table, index);
-    (*entry).value = value;
-    (*entry).next_collision_ptr = null_mut();
-}
-
-unsafe fn table_length(table: *mut Blob) -> u32 {
-    debug_assert!(table != null_mut());
-    debug_assert!(table.len().as_u32() % size_of::<HashEntry>() as u32 == 0);
-    table.len().as_u32() / size_of::<HashEntry>() as u32
-}
-
-unsafe fn null_ptr_value() -> Value {
-    Value::from_raw((null_mut() as *mut usize) as u32)
-}
-
-unsafe fn is_null_ptr_value(value: Value) -> bool {
-    value.get_raw() as *mut usize == null_mut()
-}
diff --git a/rts/motoko-rts/src/gc/generational/sanity_checks.rs b/rts/motoko-rts/src/gc/generational/sanity_checks.rs
deleted file mode 100644
index 2fd5531af9b..00000000000
--- a/rts/motoko-rts/src/gc/generational/sanity_checks.rs
+++ /dev/null
@@ -1,173 +0,0 @@
-//! Extensive sanity checks for generational GC features.
-//! * Write barrier coverage by memory snapshot comparisons.
-//! * Memory sanity check, including a full heap scan.
-#![allow(dead_code)]
-
-use core::ptr::null_mut;
-
-use super::write_barrier::REMEMBERED_SET;
-use super::{Heap, Limits, Roots};
-use crate::mem_utils::memcpy_bytes;
-use crate::memory::{alloc_blob, Memory};
-use crate::types::*;
-use crate::visitor::{pointer_to_dynamic_heap, visit_pointer_fields};
-
-static mut SNAPSHOT: *mut Blob = null_mut();
-
-/// Take a memory snapshot. To be initiated after GC run.
-pub unsafe fn take_snapshot<M: Memory>(heap: &mut Heap<M>) {
-    let length = Bytes(heap.limits.free as u32);
-    // No post allocation barrier as this RTS-internal blob will be collected by the GC.
-    let blob = alloc_blob(heap.mem, length).get_ptr() as *mut Blob;
-    memcpy_bytes(blob.payload_addr() as usize, 0, length);
-    SNAPSHOT = blob;
-}
-
-/// Verify write barrier coverage by comparing the memory against the previous snapshot.
-/// To be initiated before the next GC run. No effect if no snapshpot has been taken.
-pub unsafe fn verify_snapshot<M: Memory>(heap: &Heap<M>, verify_roots: bool) {
-    if SNAPSHOT.is_null() {
-        return;
-    }
-    assert!(heap.limits.base <= heap.limits.free);
-    if verify_roots {
-        verify_static_roots(heap.roots.static_roots.as_array(), heap.limits.free);
-    }
-    verify_heap(&heap.limits);
-    SNAPSHOT = null_mut();
-}
-
-unsafe fn verify_static_roots(static_roots: *mut Array, last_free: usize) {
-    for index in 0..static_roots.len() {
-        let current = static_roots.get(index).as_obj();
-        assert_eq!(current.tag(), TAG_MUTBOX); // check tag
-        let mutbox = current as *mut MutBox;
-        let current_field = &mut (*mutbox).field;
-        if relevant_field(current_field, last_free) {
-            verify_field(current_field);
-        }
-    }
-}
-
-unsafe fn verify_heap(limits: &Limits) {
-    assert!(SNAPSHOT.len().as_usize() <= limits.free);
-    let mut pointer = limits.base;
-    while pointer < SNAPSHOT.len().as_usize() {
-        if Value::from_ptr(pointer).is_obj() {
-            let current = pointer as *mut Obj;
-            let previous = (SNAPSHOT.payload_addr() as usize + pointer) as *mut Obj;
-            assert!(current.tag() == previous.tag());
-            visit_pointer_fields(
-                &mut (),
-                current,
-                current.tag(),
-                0,
-                |_, current_field| {
-                    if relevant_field(current_field, limits.last_free) {
-                        verify_field(current_field);
-                    }
-                },
-                |_, slice_start, arr| {
-                    assert!(slice_start == 0);
-                    arr.len()
-                },
-            );
-        }
-        pointer += block_size(pointer).to_bytes().as_usize();
-    }
-}
-
-unsafe fn relevant_field(current_field: *mut Value, last_free: usize) -> bool {
-    if (current_field as usize) < last_free {
-        let value = *current_field;
-        value.is_ptr() && value.get_ptr() as usize >= last_free
-    } else {
-        false
-    }
-}
-
-unsafe fn verify_field(current_field: *mut Value) {
-    let memory_copy = SNAPSHOT.payload_addr() as usize;
-    let previous_field = (memory_copy + current_field as usize) as *mut Value;
-    if *previous_field != *current_field && !recorded(current_field as u32) {
-        panic!("Missing write barrier at {:#x}", current_field as usize);
-    }
-}
-
-unsafe fn recorded(value: u32) -> bool {
-    match &REMEMBERED_SET {
-        None => panic!("No remembered set"),
-        Some(remembered_set) => remembered_set.contains(Value::from_raw(value)),
-    }
-}
-
-pub struct MemoryChecker<'a> {
-    limits: &'a Limits,
-    roots: &'a Roots,
-}
-
-pub unsafe fn check_memory(limits: &Limits, roots: &Roots) {
-    let checker = MemoryChecker { limits, roots };
-    checker.check_memory();
-}
-
-impl<'a> MemoryChecker<'a> {
-    unsafe fn check_memory(&self) {
-        self.check_static_roots();
-        if (*self.roots.continuation_table_ptr_loc).is_ptr() {
-            self.check_object(*self.roots.continuation_table_ptr_loc);
-        }
-        self.check_heap();
-    }
-
-    unsafe fn check_static_roots(&self) {
-        let root_array = self.roots.static_roots.as_array();
-        for i in 0..root_array.len() {
-            let obj = root_array.get(i).as_obj();
-            assert_eq!(obj.tag(), TAG_MUTBOX);
-            assert!((obj as usize) < self.limits.base);
-            let mutbox = obj as *mut MutBox;
-            let field_addr = &mut (*mutbox).field;
-            if pointer_to_dynamic_heap(field_addr, self.limits.base as usize) {
-                let object = *field_addr;
-                self.check_object(object);
-            }
-        }
-    }
-
-    unsafe fn check_object(&self, object: Value) {
-        self.check_object_header(object);
-        visit_pointer_fields(
-            &mut (),
-            object.as_obj(),
-            object.tag(),
-            0,
-            |_, field_address| {
-                // Ignore null pointers used in text_iter.
-                if (*field_address).get_ptr() as *mut Obj != null_mut() {
-                    (&self).check_object_header(*field_address);
-                }
-            },
-            |_, _, arr| arr.len(),
-        );
-    }
-
-    unsafe fn check_object_header(&self, object: Value) {
-        assert!(object.is_ptr());
-        let pointer = object.get_ptr();
-        assert!(pointer < self.limits.free);
-        let tag = object.tag();
-        assert!(tag >= TAG_OBJECT && tag <= TAG_NULL);
-    }
-
-    unsafe fn check_heap(&self) {
-        let mut pointer = self.limits.base;
-        while pointer < self.limits.free {
-            let block = Value::from_ptr(pointer as usize);
-            if block.tag() != TAG_ONE_WORD_FILLER {
-                self.check_object(block);
-            }
-            pointer += block_size(pointer as usize).to_bytes().as_usize();
-        }
-    }
-}
diff --git a/rts/motoko-rts/src/gc/generational/write_barrier.rs b/rts/motoko-rts/src/gc/generational/write_barrier.rs
deleted file mode 100644
index 53fb3a87723..00000000000
--- a/rts/motoko-rts/src/gc/generational/write_barrier.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-//! Write barrier, used for generational GC
-
-use super::remembered_set::RememberedSet;
-use crate::memory::Memory;
-use crate::types::Value;
-use motoko_rts_macros::ic_mem_fn;
-
-pub static mut REMEMBERED_SET: Option<RememberedSet> = None;
-pub static mut HEAP_BASE: usize = 0;
-pub static mut LAST_HP: usize = 0;
-
-#[cfg(feature = "ic")]
-/// (Re-)initialize the write barrier for generational GC.
-pub(crate) unsafe fn init_generational_write_barrier<M: Memory>(mem: &mut M) {
-    use crate::memory::ic::{linear_memory, HEAP_START};
-    REMEMBERED_SET = Some(RememberedSet::new(mem));
-    HEAP_BASE = HEAP_START;
-    LAST_HP = linear_memory::LAST_HP;
-}
-
-/// Write barrier to be called AFTER the pointer store, used for the generational GC.
-/// `location`: location of modified pointer (address of object field or array element).
-///
-/// As the barrier is called after the write, `*location` refers to the NEW value.
-/// No effect if the write barrier is deactivated.
-#[ic_mem_fn]
-pub unsafe fn post_write_barrier<M: Memory>(mem: &mut M, location: usize) {
-    // Must be an unskewed address.
-    debug_assert_eq!(location & 0b1, 0);
-    // Checks have been optimized according to the frequency of occurrence.
-    // Only record locations inside old generation. Static roots are anyway marked by GC.
-    if location < LAST_HP {
-        // Nested ifs are more efficient when counting instructions on IC (explicit return counts as an instruction).
-        let value = *(location as *mut Value);
-        if value.points_to_or_beyond(LAST_HP) {
-            #[allow(clippy::collapsible_if)]
-            if location >= HEAP_BASE {
-                // Trap pointers that lead from old generation (or static roots) to young generation.
-                REMEMBERED_SET
-                    .as_mut()
-                    .unwrap()
-                    .insert(mem, Value::from_raw(location as u32));
-            }
-        }
-    }
-}
diff --git a/rts/motoko-rts/src/gc/mark_compact.rs b/rts/motoko-rts/src/gc/mark_compact.rs
deleted file mode 100644
index c6716cfc2cf..00000000000
--- a/rts/motoko-rts/src/gc/mark_compact.rs
+++ /dev/null
@@ -1,293 +0,0 @@
-//! Implements threaded compaction as described in "High-Performance Garbage Collection for
-//! Memory-Constrained Environments" section 5.1.2, which is an improved version of the original
-//! threaded compaction algorithm described in The Garbage Collection Handbook section 3.3.
-
-pub mod bitmap;
-pub mod mark_stack;
-
-use bitmap::{alloc_bitmap, free_bitmap, get_bit, iter_bits, set_bit, BITMAP_ITER_END};
-use mark_stack::{alloc_mark_stack, free_mark_stack, pop_mark_stack, push_mark_stack};
-
-use crate::constants::WORD_SIZE;
-use crate::mem_utils::memcpy_words;
-use crate::memory::Memory;
-use crate::types::*;
-use crate::visitor::{pointer_to_dynamic_heap, visit_pointer_fields};
-
-use motoko_rts_macros::ic_mem_fn;
-
-#[no_mangle]
-#[cfg(feature = "ic")]
-#[allow(unreachable_code)]
-pub unsafe extern "C" fn initialize_compacting_gc() {
-    panic!("Compacting GC is not supported with the persistent heap");
-    crate::memory::ic::linear_memory::initialize();
-}
-
-#[ic_mem_fn(ic_only)]
-unsafe fn schedule_compacting_gc<M: Memory>(mem: &mut M) {
-    // 512 MiB slack for mark stack + allocation area for the next message
-    let slack: u64 = 512 * 1024 * 1024;
-    let heap_size_bytes: u64 =
-        u64::from(crate::constants::WASM_HEAP_SIZE.as_u32()) * u64::from(WORD_SIZE);
-    // Larger than necessary to keep things simple
-    let max_bitmap_size_bytes = heap_size_bytes / 32;
-    // NB. `max_live` is evaluated in compile time to a constant
-    let max_live: Bytes<u64> = Bytes(heap_size_bytes - slack - max_bitmap_size_bytes);
-
-    if super::should_do_gc(max_live) {
-        compacting_gc(mem);
-    }
-}
-
-#[ic_mem_fn(ic_only)]
-unsafe fn compacting_gc<M: Memory>(mem: &mut M) {
-    use crate::memory::ic::{self, linear_memory, HEAP_START};
-
-    compacting_gc_internal(
-        mem,
-        HEAP_START,
-        // get_hp
-        || linear_memory::get_hp_unskewed(),
-        // set_hp
-        |hp| linear_memory::set_hp_unskewed(hp),
-        ic::linear_memory::get_static_roots(),
-        crate::continuation_table::continuation_table_loc(),
-        // note_live_size
-        |live_size| ic::MAX_LIVE = ::core::cmp::max(ic::MAX_LIVE, live_size),
-        // note_reclaimed
-        |reclaimed| linear_memory::RECLAIMED += Bytes(u64::from(reclaimed.as_u32())),
-    );
-
-    linear_memory::LAST_HP = linear_memory::get_hp_unskewed();
-}
-
-pub unsafe fn compacting_gc_internal<
-    M: Memory,
-    GetHp: Fn() -> usize,
-    SetHp: Fn(usize),
-    NoteLiveSize: Fn(Bytes<u32>),
-    NoteReclaimed: Fn(Bytes<u32>),
->(
-    mem: &mut M,
-    heap_base: usize,
-    get_hp: GetHp,
-    set_hp: SetHp,
-    static_roots: Value,
-    continuation_table_ptr_loc: *mut Value,
-    note_live_size: NoteLiveSize,
-    note_reclaimed: NoteReclaimed,
-) {
-    let old_hp = get_hp() as u32;
-
-    assert_eq!(heap_base % 32, 0);
-
-    mark_compact(
-        mem,
-        set_hp,
-        heap_base,
-        old_hp,
-        static_roots,
-        continuation_table_ptr_loc,
-    );
-
-    let reclaimed = old_hp - (get_hp() as u32);
-    note_reclaimed(Bytes(reclaimed));
-
-    let live = get_hp() - heap_base;
-    note_live_size(Bytes(live as u32));
-}
-
-unsafe fn mark_compact<M: Memory, SetHp: Fn(usize)>(
-    mem: &mut M,
-    set_hp: SetHp,
-    heap_base: usize,
-    heap_end: u32,
-    static_roots: Value,
-    continuation_table_ptr_loc: *mut Value,
-) {
-    let mem_size = Bytes(heap_end - heap_base as u32);
-
-    alloc_bitmap(mem, mem_size, heap_base as u32 / WORD_SIZE);
-    alloc_mark_stack(mem);
-
-    mark_static_roots(mem, static_roots, heap_base);
-
-    if (*continuation_table_ptr_loc).is_ptr() {
-        mark_object(mem, *continuation_table_ptr_loc);
-        // Similar to `mark_root_mutbox_fields`, `continuation_table_ptr_loc` is in static heap so
-        // it will be readable when we unthread the continuation table
-        thread(continuation_table_ptr_loc);
-    }
-
-    mark_stack(mem, heap_base);
-
-    update_refs(set_hp, heap_base);
-
-    free_mark_stack();
-    free_bitmap();
-}
-
-unsafe fn mark_static_roots<M: Memory>(mem: &mut M, static_roots: Value, heap_base: usize) {
-    let root_array = static_roots.as_array();
-
-    // Static objects are not in the dynamic heap so don't need marking.
-    for i in 0..root_array.len() {
-        let obj = root_array.get(i).as_obj();
-        // Root array should only have pointers to other static MutBoxes
-        debug_assert_eq!(obj.tag(), TAG_MUTBOX); // check tag
-        debug_assert!((obj as usize) < heap_base); // check that MutBox is static
-        mark_root_mutbox_fields(mem, obj as *mut MutBox, heap_base);
-    }
-}
-
-unsafe fn mark_object<M: Memory>(mem: &mut M, obj: Value) {
-    let obj_tag = obj.tag();
-    let obj = obj.get_ptr() as u32;
-
-    // Check object alignment to avoid undefined behavior. See also static_checks module.
-    debug_assert_eq!(obj % WORD_SIZE, 0);
-
-    let obj_idx = obj / WORD_SIZE;
-
-    if get_bit(obj_idx) {
-        // Already marked
-        return;
-    }
-
-    set_bit(obj_idx);
-    push_mark_stack(mem, obj as usize, obj_tag);
-}
-
-unsafe fn mark_stack<M: Memory>(mem: &mut M, heap_base: usize) {
-    while let Some((obj, tag)) = pop_mark_stack() {
-        mark_fields(mem, obj as *mut Obj, tag, heap_base)
-    }
-}
-
-unsafe fn mark_fields<M: Memory>(mem: &mut M, obj: *mut Obj, obj_tag: Tag, heap_base: usize) {
-    visit_pointer_fields(
-        mem,
-        obj,
-        obj_tag,
-        heap_base,
-        |mem, field_addr| {
-            let field_value = *field_addr;
-            mark_object(mem, field_value);
-
-            // Thread if backwards or self pointer
-            if field_value.get_ptr() <= obj as usize {
-                thread(field_addr);
-            }
-        },
-        |mem, slice_start, arr| {
-            const SLICE_INCREMENT: u32 = 127;
-            debug_assert!(SLICE_INCREMENT >= TAG_ARRAY_SLICE_MIN);
-            if arr.len() - slice_start > SLICE_INCREMENT {
-                let new_start = slice_start + SLICE_INCREMENT;
-                // push an entire (suffix) array slice
-                push_mark_stack(mem, arr as usize, new_start);
-                new_start
-            } else {
-                arr.len()
-            }
-        },
-    );
-}
-
-/// Specialized version of `mark_fields` for root `MutBox`es.
-unsafe fn mark_root_mutbox_fields<M: Memory>(mem: &mut M, mutbox: *mut MutBox, heap_base: usize) {
-    let field_addr = &mut (*mutbox).field;
-    if pointer_to_dynamic_heap(field_addr, heap_base) {
-        mark_object(mem, *field_addr);
-        // It's OK to thread forward pointers here as the static objects won't be moved, so we will
-        // be able to unthread objects pointed by these fields later.
-        thread(field_addr);
-    }
-}
-
-/// Linearly scan the heap, for each live object:
-///
-/// - Mark step threads all backwards pointers and pointers from roots, so unthread to update those
-///   pointers to the objects new location.
-///
-/// - Move the object
-///
-/// - Thread forward pointers of the object
-///
-unsafe fn update_refs<SetHp: Fn(usize)>(set_hp: SetHp, heap_base: usize) {
-    let mut free = heap_base;
-
-    let mut bitmap_iter = iter_bits();
-    let mut bit = bitmap_iter.next();
-    while bit != BITMAP_ITER_END {
-        let p = (bit * WORD_SIZE) as *mut Obj;
-        let p_new = free;
-
-        // Update backwards references to the object's new location and restore object header
-        unthread(p, p_new);
-
-        // Move the object
-        let p_size_words = block_size(p as usize);
-        if p_new as usize != p as usize {
-            memcpy_words(p_new as usize, p as usize, p_size_words);
-
-            debug_assert!(p_size_words.as_usize() > size_of::<Obj>().as_usize());
-            // Update forwarding pointer
-            let new_obj = p_new as *mut Obj;
-            debug_assert!(new_obj.tag() >= TAG_OBJECT && new_obj.tag() <= TAG_NULL);
-        }
-
-        free += p_size_words.to_bytes().as_usize();
-
-        // Thread forward pointers of the object
-        thread_fwd_pointers(p_new as *mut Obj, heap_base);
-
-        bit = bitmap_iter.next();
-    }
-
-    set_hp(free);
-}
-
-/// Thread forward pointers in object
-unsafe fn thread_fwd_pointers(obj: *mut Obj, heap_base: usize) {
-    visit_pointer_fields(
-        &mut (),
-        obj,
-        obj.tag(),
-        heap_base,
-        |_, field_addr| {
-            if (*field_addr).get_ptr() > obj as usize {
-                thread(field_addr)
-            }
-        },
-        |_, _, arr| arr.len(),
-    );
-}
-
-/// Thread a pointer field
-unsafe fn thread(field: *mut Value) {
-    // Store pointed object's header in the field, field address in the pointed object's header
-    let pointed = (*field).as_obj();
-    let pointed_header = pointed.tag();
-    *field = Value::from_raw(pointed_header);
-    (*pointed).tag = field as u32;
-}
-
-/// Unthread all references at given header, replacing with `new_loc`. Restores object header.
-unsafe fn unthread(obj: *mut Obj, new_loc: usize) {
-    let mut header = obj.tag();
-
-    // All objects and fields are word-aligned, and tags have the lowest bit set, so use the lowest
-    // bit to distinguish a header (tag) from a field address.
-    while header & 0b1 == 0 {
-        let tmp = (header as *const Obj).tag();
-        (*(header as *mut Value)) = Value::from_ptr(new_loc);
-        header = tmp;
-    }
-
-    // At the end of the chain is the original header for the object
-    debug_assert!(header >= TAG_OBJECT && header <= TAG_NULL);
-
-    (*obj).tag = header;
-}
diff --git a/rts/motoko-rts/src/lib.rs b/rts/motoko-rts/src/lib.rs
index af5c503f6f9..0dcde17bb0a 100644
--- a/rts/motoko-rts/src/lib.rs
+++ b/rts/motoko-rts/src/lib.rs
@@ -31,7 +31,6 @@ mod idl;
 pub mod leb128;
 mod mem_utils;
 pub mod memory;
-#[incremental_gc]
 #[cfg(feature = "ic")]
 pub mod persistence;
 pub mod principal_id;
@@ -53,13 +52,6 @@ unsafe fn version<M: memory::Memory>(mem: &mut M) -> types::Value {
     text::text_of_str(mem, "0.1")
 }
 
-#[non_incremental_gc]
-#[ic_mem_fn(ic_only)]
-unsafe fn alloc_words<M: memory::Memory>(mem: &mut M, n: types::Words<u32>) -> types::Value {
-    mem.alloc_words(n)
-}
-
-#[incremental_gc]
 #[ic_mem_fn(ic_only)]
 unsafe fn alloc_words<M: memory::Memory>(mem: &mut M, n: types::Words<u32>) -> types::Value {
     crate::gc::incremental::get_partitioned_heap().allocate(mem, n)
diff --git a/rts/motoko-rts/src/memory/ic.rs b/rts/motoko-rts/src/memory/ic.rs
index 1fe07f0ef7a..135a0f4ad3f 100644
--- a/rts/motoko-rts/src/memory/ic.rs
+++ b/rts/motoko-rts/src/memory/ic.rs
@@ -1,8 +1,5 @@
 // This module is only enabled when compiling the RTS for IC or WASI.
 
-#[non_incremental_gc]
-pub mod linear_memory;
-#[incremental_gc]
 pub mod partitioned_memory;
 
 use super::Memory;
@@ -10,11 +7,6 @@ use crate::constants::WASM_PAGE_SIZE;
 use crate::rts_trap_with;
 use crate::types::Bytes;
 use core::arch::wasm32;
-use motoko_rts_macros::*;
-
-// TODO: Remove once the classical GCs have been removed.
-#[non_incremental_gc]
-pub const HEAP_START: usize = 4 * 1024 * 1024 + 128 * 1024;
 
 /// Maximum live data retained in a GC.
 pub(crate) static mut MAX_LIVE: Bytes<u32> = Bytes(0);
diff --git a/rts/motoko-rts/src/memory/ic/linear_memory.rs b/rts/motoko-rts/src/memory/ic/linear_memory.rs
deleted file mode 100644
index 18262afae7f..00000000000
--- a/rts/motoko-rts/src/memory/ic/linear_memory.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-use core::arch::wasm32;
-
-use super::{IcMemory, Memory, HEAP_START};
-use crate::types::*;
-
-/// Amount of garbage collected so far.
-pub(crate) static mut RECLAIMED: Bytes<u64> = Bytes(0);
-
-// Heap pointer (skewed)
-extern "C" {
-    fn setHP(new_hp: usize);
-    fn getHP() -> u32;
-}
-
-pub(crate) fn get_static_roots() -> Value {
-    unimplemented!()
-}
-
-pub(crate) unsafe fn set_hp_unskewed(new_hp: usize) {
-    setHP(skew(new_hp))
-}
-pub(crate) unsafe fn get_hp_unskewed() -> usize {
-    unskew(getHP() as usize)
-}
-
-/// Heap pointer after last GC
-pub(crate) static mut LAST_HP: usize = 0;
-
-pub(crate) unsafe fn initialize() {
-    LAST_HP = HEAP_START;
-    set_hp_unskewed(LAST_HP);
-}
-
-#[no_mangle]
-unsafe extern "C" fn get_reclaimed() -> Bytes<u64> {
-    RECLAIMED
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn get_total_allocations() -> Bytes<u64> {
-    Bytes(u64::from(get_heap_size().as_u32())) + get_reclaimed()
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn get_heap_size() -> Bytes<u32> {
-    Bytes((get_hp_unskewed() - HEAP_START) as u32)
-}
-
-impl Memory for IcMemory {
-    #[inline]
-    unsafe fn alloc_words(&mut self, n: Words<u32>) -> Value {
-        let bytes = n.to_bytes();
-        let delta = u64::from(bytes.as_u32());
-
-        // Update heap pointer
-        let old_hp = u64::from(getHP());
-        let new_hp = old_hp + delta;
-
-        // Grow memory if needed
-        if new_hp > ((wasm32::memory_size(0) as u64) << 16) {
-            self.grow_memory(new_hp)
-        }
-
-        debug_assert!(new_hp <= u64::from(core::u32::MAX));
-        setHP(new_hp as usize);
-
-        Value::from_raw(old_hp as u32)
-    }
-
-    #[inline(never)]
-    unsafe fn grow_memory(&mut self, ptr: u64) {
-        super::grow_memory(ptr);
-    }
-}
diff --git a/rts/motoko-rts/src/static_checks.rs b/rts/motoko-rts/src/static_checks.rs
index 9ea55c1f79c..ccf20b1d90d 100644
--- a/rts/motoko-rts/src/static_checks.rs
+++ b/rts/motoko-rts/src/static_checks.rs
@@ -1,7 +1,6 @@
 //! Compile-time assertions to make sure object layouts are as expected
 
 use crate::types::*;
-use motoko_rts_macros::*;
 
 use core::mem::{align_of, size_of};
 
@@ -11,13 +10,8 @@ use core::mem::{align_of, size_of};
 const WORD_SIZE: usize = crate::constants::WORD_SIZE as usize;
 
 #[allow(unused)]
-#[incremental_gc]
 const HEADER_SIZE: usize = 2 * WORD_SIZE;
 
-#[allow(unused)]
-#[non_incremental_gc]
-const HEADER_SIZE: usize = WORD_SIZE;
-
 // We cannot use `assert_eq` below as `assert_eq` is not const yet
 
 // Check platform word size
diff --git a/rts/motoko-rts/src/types.rs b/rts/motoko-rts/src/types.rs
index 76e4cef973c..4efb03104a5 100644
--- a/rts/motoko-rts/src/types.rs
+++ b/rts/motoko-rts/src/types.rs
@@ -24,8 +24,6 @@ use crate::memory::Memory;
 use crate::tommath_bindings::{mp_digit, mp_int};
 use core::ops::{Add, AddAssign, Div, Mul, Sub, SubAssign};
 use core::ptr::null;
-use motoko_rts_macros::is_incremental_gc;
-use motoko_rts_macros::*;
 
 use crate::constants::WORD_SIZE;
 use crate::rts_trap_with;
@@ -268,22 +266,16 @@ impl Value {
     /// Check that the forwarding pointer is valid.
     #[inline]
     pub unsafe fn check_forwarding_pointer(self) {
-        if is_incremental_gc!() {
-            debug_assert!(
-                self.forward().get_ptr() == self.get_ptr()
-                    || self.forward().forward().get_ptr() == self.forward().get_ptr()
-            );
-        }
+        debug_assert!(
+            self.forward().get_ptr() == self.get_ptr()
+                || self.forward().forward().get_ptr() == self.forward().get_ptr()
+        );
     }
 
     /// Check whether the object's forwarding pointer refers to a different location.
     pub unsafe fn is_forwarded(self) -> bool {
-        if is_incremental_gc!() {
-            self.check_forwarding_pointer();
-            self.forward().get_ptr() != self.get_ptr()
-        } else {
-            false
-        }
+        self.check_forwarding_pointer();
+        self.forward().get_ptr() != self.get_ptr()
     }
 
     /// Get the object tag. No forwarding. Can be applied to any block, regular objects
@@ -294,7 +286,6 @@ impl Value {
     }
 
     /// Get the forwarding pointer. Used by the incremental GC.
-    #[incremental_gc]
     pub unsafe fn forward(self) -> Value {
         debug_assert!(self.is_obj());
         debug_assert!(self.get_ptr() as *const Obj != null());
@@ -302,15 +293,9 @@ impl Value {
         (*obj).forward
     }
 
-    /// Get the forwarding pointer. Used by the incremental GC.
-    #[non_incremental_gc]
-    pub unsafe fn forward(self) -> Value {
-        self
-    }
-
     /// Resolve forwarding if the value is a pointer. Otherwise, return the same value.
     pub unsafe fn forward_if_possible(self) -> Value {
-        if is_incremental_gc!() && self.is_ptr() && self.get_ptr() as *const Obj != null() {
+        if self.is_ptr() && self.get_ptr() as *const Obj != null() {
             // Ignore null pointers used in text_iter.
             self.forward()
         } else {
@@ -460,32 +445,20 @@ pub const TAG_ARRAY_SLICE_MIN: Tag = 32;
 #[repr(C)] // See the note at the beginning of this module
 pub struct Obj {
     pub tag: Tag,
-    // Cannot use `#[incremental_gc]` as Rust only allows non-macro attributes for fields.
-    #[cfg(feature = "incremental_gc")]
     /// Forwarding pointer to support object moving in the incremental GC.
     pub forward: Value,
 }
 
 impl Obj {
-    #[incremental_gc]
     pub fn init_forward(&mut self, value: Value) {
         self.forward = value;
     }
 
-    #[non_incremental_gc]
-    pub fn init_forward(&mut self, _value: Value) {}
-
     /// Check whether the object's forwarding pointer refers to a different location.
-    #[incremental_gc]
     pub unsafe fn is_forwarded(self: *const Self) -> bool {
         (*self).forward.get_ptr() != self as usize
     }
 
-    #[non_incremental_gc]
-    pub unsafe fn is_forwarded(self: *const Self) -> bool {
-        false
-    }
-
     pub unsafe fn tag(self: *const Self) -> Tag {
         (*self).tag
     }
@@ -758,16 +731,10 @@ impl BigInt {
         self.add(1) as *mut mp_digit // skip closure header
     }
 
-    #[incremental_gc]
     pub unsafe fn forward(self: *mut Self) -> *mut Self {
         (*self).header.forward.as_bigint()
     }
 
-    #[non_incremental_gc]
-    pub unsafe fn forward(self: *mut Self) -> *mut Self {
-        self
-    }
-
     pub unsafe fn from_payload(ptr: *mut mp_digit) -> *mut Self {
         let bigint = (ptr as *mut u32).sub(size_of::<BigInt>().as_usize()) as *mut BigInt;
         bigint.forward()
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 9dd221c0202..158240b67bb 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -577,17 +577,8 @@ module E = struct
   let mem_size env =
     Int32.(add (div (get_end_of_static_memory env) page_size) 1l)
 
-  let gc_strategy_name gc_strategy = match gc_strategy with
-    | Flags.MarkCompact -> "compacting"
-    | Flags.Copying -> "copying"
-    | Flags.Generational -> "generational"
-    | Flags.Incremental -> "incremental"
-
   let collect_garbage env =
-    (* GC function name = "schedule_"? ("compacting" | "copying" | "generational" | "incremental") "_gc" *)
-    let name = gc_strategy_name !Flags.gc_strategy in
-    let gc_fn = if !Flags.force_gc then name else "schedule_" ^ name in
-    call_import env "rts" (gc_fn ^ "_gc")
+    call_import env "rts" "schedule_incremental_gc"
 
   (* See Note [Candid subtype checks] *)
   (* NB: we don't bother detecting duplicate registrations here because the code sharing machinery
@@ -861,30 +852,14 @@ module Func = struct
 end (* Func *)
 
 module RTS = struct
-  let incremental_gc_imports env =
+  (* The connection to the C and Rust parts of the RTS *)
+  let system_imports env =
     E.add_func_import env "rts" "initialize_incremental_gc" [] [];
     E.add_func_import env "rts" "schedule_incremental_gc" [] [];
     E.add_func_import env "rts" "incremental_gc" [] [];
     E.add_func_import env "rts" "write_with_barrier" [I32Type; I32Type] [];
     E.add_func_import env "rts" "allocation_barrier" [I32Type] [I32Type];
     E.add_func_import env "rts" "running_gc" [] [I32Type];
-    ()
-
-  let non_incremental_gc_imports env =
-    E.add_func_import env "rts" "initialize_copying_gc" [] [];
-    E.add_func_import env "rts" "initialize_compacting_gc" [] [];
-    E.add_func_import env "rts" "initialize_generational_gc" [] [];
-    E.add_func_import env "rts" "schedule_copying_gc" [] [];
-    E.add_func_import env "rts" "schedule_compacting_gc" [] [];
-    E.add_func_import env "rts" "schedule_generational_gc" [] [];
-    E.add_func_import env "rts" "copying_gc" [] [];
-    E.add_func_import env "rts" "compacting_gc" [] [];
-    E.add_func_import env "rts" "generational_gc" [] [];
-    E.add_func_import env "rts" "post_write_barrier" [I32Type] [];
-    ()
-
-  (* The connection to the C and Rust parts of the RTS *)
-  let system_imports env =
     E.add_func_import env "rts" "load_stable_actor" [] [I32Type];
     E.add_func_import env "rts" "save_stable_actor" [I32Type] [];
     E.add_func_import env "rts" "set_static_root" [I32Type] [];
@@ -1002,10 +977,6 @@ module RTS = struct
     E.add_func_import env "rts" "stream_shutdown" [I32Type] [];
     E.add_func_import env "rts" "stream_reserve" [I32Type; I32Type] [I32Type];
     E.add_func_import env "rts" "stream_stable_dest" [I32Type; I64Type; I64Type] [];
-    if !Flags.gc_strategy = Flags.Incremental then
-      incremental_gc_imports env
-    else
-      non_incremental_gc_imports env;
     ()
 
 end (* RTS *)
@@ -1019,9 +990,7 @@ module GC = struct
 
   let register_globals env =
     E.add_global64 env "__mutator_instructions" Mutable 0L;
-    E.add_global64 env "__collector_instructions" Mutable 0L;
-    if !Flags.gc_strategy <> Flags.Incremental then
-      E.add_global32 env "_HP" Mutable 0l
+    E.add_global64 env "__collector_instructions" Mutable 0L
 
   let get_mutator_instructions env =
     G.i (GlobalGet (nr (E.get_global env "__mutator_instructions")))
@@ -1033,17 +1002,6 @@ module GC = struct
   let set_collector_instructions env =
     G.i (GlobalSet (nr (E.get_global env "__collector_instructions")))
 
-  let get_heap_pointer env =
-    if !Flags.gc_strategy <> Flags.Incremental then
-      G.i (GlobalGet (nr (E.get_global env "_HP")))
-    else
-      assert false
-  let set_heap_pointer env =
-    if !Flags.gc_strategy <> Flags.Incremental then
-      G.i (GlobalSet (nr (E.get_global env "_HP")))
-    else
-      assert false
-
   let record_mutator_instructions env =
     match E.mode env with
     | Flags.(ICMode | RefMode)  ->
@@ -1098,9 +1056,6 @@ module Heap = struct
     compile_unboxed_const n ^^
     E.call_import env "rts" "alloc_words"
 
-  let ensure_allocated env =
-    alloc env 0l ^^ G.i Drop (* dummy allocation, ensures that the page HP points into is backed *)
-    
   (* Heap objects *)
 
   (* At this level of abstraction, heap objects are just flat arrays of words *)
@@ -1498,7 +1453,6 @@ end (* BitTagged *)
 
 module Tagged = struct
   (* Tagged objects all have an object header consisting of a tag and a forwarding pointer.
-     The forwarding pointer is only reserved if compiled for the incremental GC.
      The tag is to describe their runtime type and serves to traverse the heap
      (serialization, GC), but also for objectification of arrays.
 
@@ -1578,63 +1532,31 @@ module Tagged = struct
     | CoercionFailure -> 0xfffffffel
     | StableSeen -> 0xffffffffl
 
-  (* Declare `env` for lazy computation of the header size when the compile environment with compile flags are defined *)
-  let header_size env = 
-    if !Flags.gc_strategy = Flags.Incremental then 2l else 1l
+  let header_size = 2l
   
   (* The tag *)
   let tag_field = 0l
-  let forwarding_pointer_field env = 
-    assert (!Flags.gc_strategy = Flags.Incremental);
-    1l
+  let forwarding_pointer_field = 1l
 
   (* Note: post-allocation barrier must be applied after initialization *)
   let alloc env size tag =
     assert (size > 1l);
     let name = Printf.sprintf "alloc_size<%d>_tag<%d>" (Int32.to_int size) (Int32.to_int (int_of_tag tag)) in
-    (* Computes a (conservative) mask for the bumped HP, so that the existence of non-zero bits under it
-       guarantees that a page boundary crossing didn't happen (i.e. no ripple-carry). *)
-    let overflow_mask increment =
-      let n = Int32.to_int increment in
-      assert (n > 0 && n < 0x8000);
-      let page_mask = Int32.sub page_size 1l in
-      (* We can extend the mask to the right if the bump increment is a power of two. *)
-      let ext = if Numerics.Nat16.(to_int (popcnt (of_int n))) = 1 then increment else 0l in
-      Int32.(logor ext (logand page_mask (shift_left minus_one (16 - Numerics.Nat16.(to_int (clz (of_int n))))))) in
 
     Func.share_code0 env name [I32Type] (fun env ->
       let set_object, get_object = new_local env "new_object" in
-      let size_in_bytes = Int32.(mul size Heap.word_size) in
-      let half_page_size = Int32.div page_size 2l in
-      (if !Flags.gc_strategy <> Flags.Incremental && size_in_bytes < half_page_size then
-         GC.get_heap_pointer env ^^
-         GC.get_heap_pointer env ^^
-         compile_add_const size_in_bytes ^^
-         GC.set_heap_pointer env ^^
-         GC.get_heap_pointer env ^^
-         compile_bitand_const (overflow_mask size_in_bytes) ^^
-         G.if0
-           G.nop (* no page crossing *)
-           (Heap.ensure_allocated env) (* ensure that HP's page is allocated *)
-       else
-         Heap.alloc env size) ^^
+      Heap.alloc env size ^^
       set_object ^^ get_object ^^
       compile_unboxed_const (int_of_tag tag) ^^
       Heap.store_field tag_field ^^
-      (if !Flags.gc_strategy = Flags.Incremental then
-        get_object ^^ (* object pointer *)
-        get_object ^^ (* forwarding pointer *)
-        Heap.store_field (forwarding_pointer_field env)
-      else 
-        G.nop) ^^
+      get_object ^^ (* object pointer *)
+      get_object ^^ (* forwarding pointer *)
+      Heap.store_field forwarding_pointer_field ^^
       get_object
     )
 
   let load_forwarding_pointer env =
-    (if !Flags.gc_strategy = Flags.Incremental then
-      Heap.load_field (forwarding_pointer_field env)
-    else
-      G.nop)
+    Heap.load_field forwarding_pointer_field
 
   let store_tag env tag =
     load_forwarding_pointer env ^^
@@ -1646,33 +1568,29 @@ module Tagged = struct
     Heap.load_field tag_field
 
   let check_forwarding env unskewed =
-    (if !Flags.gc_strategy = Flags.Incremental then
-      let name = "check_forwarding_" ^ if unskewed then "unskewed" else "skewed" in
-      Func.share_code1 env name ("object", I32Type) [I32Type] (fun env get_object ->
-        let set_object = G.setter_for get_object in
-        (if unskewed then
-          get_object ^^
-          compile_unboxed_const ptr_skew ^^
-          G.i (Binary (Wasm.Values.I32 I32Op.Add)) ^^
-          set_object
-        else G.nop) ^^
-        get_object ^^
-        load_forwarding_pointer env ^^
-        get_object ^^
-        G.i (Compare (Wasm.Values.I32 I32Op.Eq)) ^^
-        E.else_trap_with env "missing object forwarding" ^^
+    let name = "check_forwarding_" ^ if unskewed then "unskewed" else "skewed" in
+    Func.share_code1 env name ("object", I32Type) [I32Type] (fun env get_object ->
+      let set_object = G.setter_for get_object in
+      (if unskewed then
         get_object ^^
-        (if unskewed then
-          compile_unboxed_const ptr_unskew ^^
-          G.i (Binary (Wasm.Values.I32 I32Op.Add))
-        else G.nop))
-    else G.nop)
-
+        compile_unboxed_const ptr_skew ^^
+        G.i (Binary (Wasm.Values.I32 I32Op.Add)) ^^
+        set_object
+      else G.nop) ^^
+      get_object ^^
+      load_forwarding_pointer env ^^
+      get_object ^^
+      G.i (Compare (Wasm.Values.I32 I32Op.Eq)) ^^
+      E.else_trap_with env "missing object forwarding" ^^
+      get_object ^^
+      (if unskewed then
+        compile_unboxed_const ptr_unskew ^^
+        G.i (Binary (Wasm.Values.I32 I32Op.Add))
+      else G.nop))
+  
   let check_forwarding_for_store env typ =
-    (if !Flags.gc_strategy = Flags.Incremental then
-      let (set_value, get_value, _) = new_local_ env typ "value" in
-      set_value ^^ check_forwarding env false ^^ get_value
-    else G.nop)
+    let (set_value, get_value, _) = new_local_ env typ "value" in
+    set_value ^^ check_forwarding env false ^^ get_value
 
   let load_field env index =
     (if !Flags.sanity then check_forwarding env false else G.nop) ^^
@@ -1774,10 +1692,7 @@ module Tagged = struct
     branch_with env retty (List.filter (fun (tag,c) -> can_have_tag ty tag) branches)
 
   let allocation_barrier env =
-    (if !Flags.gc_strategy = Flags.Incremental then
-      E.call_import env "rts" "allocation_barrier"
-    else
-      G.nop)
+    E.call_import env "rts" "allocation_barrier"
 
   let write_with_barrier env =
     let (set_value, get_value) = new_local env "written_value" in
@@ -1795,14 +1710,14 @@ module Tagged = struct
 
   let obj env tag element_instructions : G.t =
     let n = List.length element_instructions in
-    let size = (Int32.add (Wasm.I32.of_int_u n) (header_size env)) in
+    let size = (Int32.add (Wasm.I32.of_int_u n) header_size) in
     let (set_object, get_object) = new_local env "new_object" in
     alloc env size tag ^^
     set_object ^^
     let init_elem idx instrs : G.t =
       get_object ^^
       instrs ^^
-      Heap.store_field (Int32.add (Wasm.I32.of_int_u idx) (header_size env))
+      Heap.store_field (Int32.add (Wasm.I32.of_int_u idx) header_size)
     in
     G.concat_mapi init_elem element_instructions ^^
     get_object ^^
@@ -1819,7 +1734,6 @@ module MutBox = struct
        └──────┴─────┴─────────┘
 
      The object header includes the obj tag (MutBox) and the forwarding pointer.
-     The forwarding pointer is only reserved if compiled for the incremental GC.
   *)
 
   let field = Tagged.header_size
@@ -1829,14 +1743,14 @@ module MutBox = struct
 
   let load_field env =
     Tagged.load_forwarding_pointer env ^^
-    Tagged.load_field env (field env)
+    Tagged.load_field env field
 
   let store_field env =
     let (set_mutbox_value, get_mutbox_value) = new_local env "mutbox_value" in
     set_mutbox_value ^^
     Tagged.load_forwarding_pointer env ^^
     get_mutbox_value ^^
-    Tagged.store_field env (field env)
+    Tagged.store_field env field
 end
 
 
@@ -1908,7 +1822,7 @@ module Opt = struct
 
   let load_some_payload_field env =
     Tagged.load_forwarding_pointer env ^^
-    Tagged.load_field env (some_payload_field env)
+    Tagged.load_field env some_payload_field
 
   let project env =
     Func.share_code1 env "opt_project" ("x", I32Type) [I32Type] (fun env get_x ->
@@ -1940,11 +1854,10 @@ module Variant = struct
        └──────┴─────┴────────────┴─────────┘
 
      The object header includes the obj tag (TAG_VARIANT) and the forwarding pointer.
-     The forwarding pointer is only reserved if compiled for the incremental GC.
   *)
 
   let variant_tag_field = Tagged.header_size
-  let payload_field env = Int32.add (variant_tag_field env) 1l
+  let payload_field = Int32.add variant_tag_field 1l
 
   let hash_variant_label env : Mo_types.Type.lab -> int32 =
     E.hash env
@@ -1954,11 +1867,11 @@ module Variant = struct
 
   let get_variant_tag env =
     Tagged.load_forwarding_pointer env ^^
-    Tagged.load_field env (variant_tag_field env)
+    Tagged.load_field env variant_tag_field
 
   let project env =
     Tagged.load_forwarding_pointer env ^^
-    Tagged.load_field env (payload_field env)
+    Tagged.load_field env payload_field
 
   (* Test if the top of the stack points to a variant with this label *)
   let test_is env l =
@@ -1979,24 +1892,22 @@ module Closure = struct
        └──────┴─────┴───────┴──────┴──────────────┘
 
      The object header includes the object tag (TAG_CLOSURE) and the forwarding pointer.
-     The forwarding pointer is only reserved if compiled for the incremental GC.
-
   *)
-  let header_size env = Int32.add (Tagged.header_size env) 2l
+  let header_size = Int32.add Tagged.header_size 2l
 
   let funptr_field = Tagged.header_size
-  let len_field env = Int32.add 1l (Tagged.header_size env)
+  let len_field = Int32.add 1l Tagged.header_size
 
   let load_data env i =
     Tagged.load_forwarding_pointer env ^^
-    Tagged.load_field env (Int32.add (header_size env) i)
+    Tagged.load_field env (Int32.add header_size i)
 
   let store_data env i =
     let (set_closure_data, get_closure_data) = new_local env "closure_data" in
     set_closure_data ^^
     Tagged.load_forwarding_pointer env ^^
     get_closure_data ^^
-    Tagged.store_field env (Int32.add (header_size env) i)
+    Tagged.store_field env (Int32.add header_size i)
 
   let prepare_closure_call env =
     Tagged.load_forwarding_pointer env
@@ -2014,7 +1925,7 @@ module Closure = struct
       FakeMultiVal.ty (Lib.List.make n_res I32Type))) in
     (* get the table index *)
     Tagged.load_forwarding_pointer env ^^
-    Tagged.load_field env (funptr_field env) ^^
+    Tagged.load_field env funptr_field ^^
     (* All done: Call! *)
     G.i (CallIndirect (nr ty)) ^^
     FakeMultiVal.load env (Lib.List.make n_res I32Type)
@@ -2041,8 +1952,6 @@ module BoxedWord64 = struct
        └──────┴─────┴─────┴─────┘
 
      The object header includes the object tag (Bits64) and the forwarding pointer.
-     The forwarding pointer is only reserved if compiled for the incremental GC.
-
   *)
 
   let payload_field = Tagged.header_size
@@ -2058,10 +1967,10 @@ module BoxedWord64 = struct
 
   let compile_box env compile_elem : G.t =
     let (set_i, get_i) = new_local env "boxed_i64" in
-    let size = if !Flags.gc_strategy = Flags.Incremental then 4l else 3l in
+    let size = 4l in
     Tagged.alloc env size Tagged.Bits64 ^^
     set_i ^^
-    get_i ^^ compile_elem ^^ Tagged.store_field64 env (payload_field env) ^^
+    get_i ^^ compile_elem ^^ Tagged.store_field64 env payload_field ^^
     get_i ^^
     Tagged.allocation_barrier env
 
@@ -2075,7 +1984,7 @@ module BoxedWord64 = struct
       get_n ^^
       BitTagged.if_tagged_scalar env [I64Type]
         ( get_n ^^ BitTagged.untag env)
-        ( get_n ^^ Tagged.load_forwarding_pointer env ^^ Tagged.load_field64 env (payload_field env))
+        ( get_n ^^ Tagged.load_forwarding_pointer env ^^ Tagged.load_field64 env payload_field)
     )
 end (* BoxedWord64 *)
 
@@ -2167,7 +2076,7 @@ module BoxedSmallWord = struct
 
   *)
 
-  let payload_field env = Tagged.header_size env
+  let payload_field = Tagged.header_size
 
   let lit env i =
     if BitTagged.can_tag_const (Int64.of_int (Int32.to_int i))
@@ -2180,10 +2089,10 @@ module BoxedSmallWord = struct
 
   let compile_box env compile_elem : G.t =
     let (set_i, get_i) = new_local env "boxed_i32" in
-    let size = if !Flags.gc_strategy = Flags.Incremental then 3l else 2l in
+    let size = 3l in
     Tagged.alloc env size Tagged.Bits32 ^^
     set_i ^^
-    get_i ^^ compile_elem ^^ Tagged.store_field env (payload_field env) ^^
+    get_i ^^ compile_elem ^^ Tagged.store_field env payload_field ^^
     get_i ^^
     Tagged.allocation_barrier env
 
@@ -2200,7 +2109,7 @@ module BoxedSmallWord = struct
       get_n ^^
       BitTagged.if_tagged_scalar env [I32Type]
         (get_n ^^ BitTagged.untag_i32)
-        (get_n ^^ Tagged.load_forwarding_pointer env ^^ Tagged.load_field env (payload_field env))
+        (get_n ^^ Tagged.load_forwarding_pointer env ^^ Tagged.load_field env payload_field)
     )
 
   let _lit env n = compile_unboxed_const n ^^ box env
@@ -2408,10 +2317,9 @@ module Float = struct
      debug inspection (or GC representation change) arises.
 
      The object header includes the object tag (Bits64) and the forwarding pointer.
-     The forwarding pointer is only reserved if compiled for the incremental GC.
   *)
 
-  let payload_field env = Tagged.header_size env
+  let payload_field = Tagged.header_size
 
   let compile_unboxed_const f = G.i (Const (nr (Wasm.Values.F64 f)))
 
@@ -2422,15 +2330,15 @@ module Float = struct
 
   let box env = Func.share_code1 env "box_f64" ("f", F64Type) [I32Type] (fun env get_f ->
     let (set_i, get_i) = new_local env "boxed_f64" in
-    let size = Int32.add (Tagged.header_size env)  2l in
+    let size = Int32.add Tagged.header_size  2l in
     Tagged.alloc env size Tagged.Bits64 ^^
     set_i ^^
-    get_i ^^ get_f ^^ Tagged.store_field_float64 env (payload_field env) ^^
+    get_i ^^ get_f ^^ Tagged.store_field_float64 env payload_field ^^
     get_i ^^
     Tagged.allocation_barrier env
   )
 
-  let unbox env = Tagged.load_forwarding_pointer env ^^ Tagged.load_field_float64 env (payload_field env)
+  let unbox env = Tagged.load_forwarding_pointer env ^^ Tagged.load_field_float64 env payload_field
 
 end (* Float *)
 
@@ -3373,7 +3281,6 @@ module Object = struct
           └─────────────┴─────────────┴───┘
 
     The object header includes the object tag (Object) and the forwarding pointer.
-    The forwarding pointer is only reserved if compiled for the incremental GC.
 
     The field hash array lives in static memory (so no size header needed).
     The hash_ptr is skewed.
@@ -3390,11 +3297,11 @@ module Object = struct
     not for the implementing of sharing of mutable stable values.
   *)
 
-  let header_size env = Int32.add (Tagged.header_size env) 2l
+  let header_size = Int32.add Tagged.header_size 2l
 
   (* Number of object fields *)
-  let size_field env = Int32.add (Tagged.header_size env) 0l
-  let hash_ptr_field env = Int32.add (Tagged.header_size env) 1l
+  let size_field = Int32.add Tagged.header_size 0l
+  let hash_ptr_field = Int32.add Tagged.header_size 1l
 
   module FieldEnv = Env.Make(String)
 
@@ -3422,18 +3329,18 @@ module Object = struct
 
     (* Allocate memory *)
     let (set_ri, get_ri, ri) = new_local_ env I32Type "obj" in
-    Tagged.alloc env (Int32.add (header_size env) sz) Tagged.Object ^^
+    Tagged.alloc env (Int32.add header_size sz) Tagged.Object ^^
     set_ri ^^
 
     (* Set size *)
     get_ri ^^
     compile_unboxed_const sz ^^
-    Tagged.store_field env (size_field env) ^^
+    Tagged.store_field env size_field ^^
 
     (* Set hash_ptr *)
     get_ri ^^
     compile_unboxed_const hash_ptr ^^
-    Tagged.store_field env (hash_ptr_field env) ^^
+    Tagged.store_field env hash_ptr_field ^^
 
     (* Write all the fields *)
     let init_field (name, mk_is) : G.t =
@@ -3441,7 +3348,7 @@ module Object = struct
       get_ri ^^
       mk_is () ^^
       let i = FieldEnv.find name name_pos_map in
-      let offset = Int32.add (header_size env) i in
+      let offset = Int32.add header_size i in
       Tagged.store_field env offset
     in
     G.concat_map init_field fs ^^
@@ -3459,14 +3366,14 @@ module Object = struct
 
       get_x ^^ Tagged.load_forwarding_pointer env ^^ set_x ^^
 
-      get_x ^^ Tagged.load_field env (hash_ptr_field env) ^^
+      get_x ^^ Tagged.load_field env hash_ptr_field ^^
 
       (* Linearly scan through the fields (binary search can come later) *)
       (* unskew h_ptr and advance both to low bound *)
       compile_add_const Int32.(add ptr_unskew (mul Heap.word_size (of_int low_bound))) ^^
       set_h_ptr ^^
       get_x ^^
-      compile_add_const Int32.(mul Heap.word_size (add (header_size env) (of_int low_bound))) ^^
+      compile_add_const Int32.(mul Heap.word_size (add header_size (of_int low_bound))) ^^
       set_x ^^
       G.loop0 (
           get_h_ptr ^^ load_unskewed_ptr ^^
@@ -3489,7 +3396,7 @@ module Object = struct
       get_x ^^ get_hash ^^
       idx_hash_raw env low_bound ^^
       load_ptr ^^ Tagged.load_forwarding_pointer env ^^
-      compile_add_const (Int32.mul (MutBox.field env) Heap.word_size)
+      compile_add_const (Int32.mul MutBox.field Heap.word_size)
     )
     else idx_hash_raw env low_bound
 
@@ -3545,7 +3452,6 @@ module Blob = struct
      └──────┴─────┴─────────┴──────────────────┘
 
     The object header includes the object tag (Blob) and the forwarding pointer.
-    The forwarding pointer is only reserved if compiled for the incremental GC.
 
     This heap object is used for various kinds of binary, non-pointer data.
 
@@ -3553,12 +3459,12 @@ module Blob = struct
     Unicode.
   *)
 
-  let header_size env = Int32.add (Tagged.header_size env) 1l
-  let len_field env = Int32.add (Tagged.header_size env) 0l
+  let header_size = Int32.add Tagged.header_size 1l
+  let len_field = Int32.add Tagged.header_size 0l
 
   let len env =
     Tagged.load_forwarding_pointer env ^^
-    Tagged.load_field env (len_field env)
+    Tagged.load_field env len_field
 
   let len_nat env =
     Func.share_code1 env "blob_len" ("text", I32Type) [I32Type] (fun env get ->
@@ -3579,7 +3485,7 @@ module Blob = struct
     (* uninitialized blob payload is allowed by the barrier *)
     Tagged.allocation_barrier env
 
-  let unskewed_payload_offset env = Int32.(add ptr_unskew (mul Heap.word_size (header_size env)))
+  let unskewed_payload_offset env = Int32.(add ptr_unskew (mul Heap.word_size header_size))
   
   let payload_ptr_unskewed env =
     Tagged.load_forwarding_pointer env ^^
@@ -3776,7 +3682,6 @@ module Text = struct
      └──────┴─────┴─────────┴───────┴───────┘
 
     The object header includes the object tag (TAG_CONCAT defined in rts/types.rs) and the forwarding pointer
-    The forwarding pointer is only reserved if compiled for the incremental GC.
 
     This is internal to rts/text.c, with the exception of GC-related code.
   *)
@@ -3850,30 +3755,29 @@ module Arr = struct
      └──────┴─────┴──────────┴────────┴───┘
 
      The object  header includes the object tag (Array) and the forwarding pointer.
-     The forwarding pointer is only reserved if compiled for the incremental GC.
 
      No difference between mutable and immutable arrays.
   *)
 
-  let header_size env = Int32.add (Tagged.header_size env) 1l
+  let header_size = Int32.add Tagged.header_size 1l
   let element_size = 4l
-  let len_field env = Int32.add (Tagged.header_size env) 0l
+  let len_field = Int32.add Tagged.header_size 0l
 
   let len env =
     Tagged.load_forwarding_pointer env ^^
-    Tagged.load_field env (len_field env)
+    Tagged.load_field env len_field
 
   (* Static array access. No checking *)
   let load_field env n =
     Tagged.load_forwarding_pointer env ^^
-    Tagged.load_field env Int32.(add n (header_size env))
+    Tagged.load_field env Int32.(add n header_size)
 
   (* Dynamic array access. Returns the address (not the value) of the field.
      Does no bounds checking *)
   let unsafe_idx env =
     Func.share_code2 env "Array.unsafe_idx" (("array", I32Type), ("idx", I32Type)) [I32Type] (fun env get_array get_idx ->
       get_idx ^^
-      compile_add_const (header_size env) ^^
+      compile_add_const header_size ^^
       compile_mul_const element_size ^^
       get_array ^^
       Tagged.load_forwarding_pointer env ^^
@@ -3892,7 +3796,7 @@ module Arr = struct
       E.else_trap_with env "Array index out of bounds" ^^
 
       get_idx ^^
-      compile_add_const (header_size env) ^^
+      compile_add_const header_size ^^
       compile_mul_const element_size ^^
       get_array ^^
       Tagged.load_forwarding_pointer env ^^
@@ -3932,7 +3836,7 @@ module Arr = struct
     get_array ^^ Tagged.load_forwarding_pointer env ^^ set_array ^^
 
     (* Initial element pointer, skewed *)
-    compile_unboxed_const (header_size env) ^^
+    compile_unboxed_const header_size ^^
     compile_mul_const element_size ^^
     get_array ^^
     G.i (Binary (Wasm.Values.I32 I32Op.Add)) ^^
@@ -3940,7 +3844,7 @@ module Arr = struct
 
     (* Upper pointer boundary, skewed *)
     get_array ^^
-    Tagged.load_field env (len_field env) ^^
+    Tagged.load_field env len_field ^^
     compile_mul_const element_size ^^
     get_pointer ^^
     G.i (Binary (Wasm.Values.I32 I32Op.Add)) ^^
@@ -4080,7 +3984,7 @@ module Tuple = struct
   (* Expects on the stack the pointer to the array. *)
   let load_n env n =
     Tagged.load_forwarding_pointer env ^^
-    Tagged.load_field env (Int32.add (Arr.header_size env) n)
+    Tagged.load_field env (Int32.add Arr.header_size n)
 
   (* Takes n elements of the stack and produces an argument tuple *)
   let from_stack env n =
@@ -5151,31 +5055,6 @@ module RTS_Exports = struct
       edesc = nr (FuncExport (nr rts_trap_fi))
     });
 
-    if !Flags.gc_strategy <> Flags.Incremental then
-    begin
-      let set_hp_fi =
-        E.add_fun env "__set_hp" (
-        Func.of_body env ["new_hp", I32Type] [] (fun env ->
-          G.i (LocalGet (nr 0l)) ^^
-          GC.set_heap_pointer env
-        )
-      ) in
-      E.add_export env (nr {
-        name = Lib.Utf8.decode "setHP";
-        edesc = nr (FuncExport (nr set_hp_fi))
-      });
-
-      let get_hp_fi = E.add_fun env "__get_hp" (
-        Func.of_body env [] [I32Type] (fun env ->
-          GC.get_heap_pointer env
-        )
-      ) in
-      E.add_export env (nr {
-        name = Lib.Utf8.decode "getHP";
-        edesc = nr (FuncExport (nr get_hp_fi))
-      })
-    end;
-
     let stable64_write_moc_fi =
       if E.mode env = Flags.WASIMode then
         E.add_fun env "stable64_write_moc" (
@@ -7017,7 +6896,7 @@ module BlobStream : Stream = struct
 
   let absolute_offset env get_token =
     let offset = 8l in (* see invariant in `stream.rs` *)
-    let filled_field = Int32.add (Blob.len_field env) offset in
+    let filled_field = Int32.add Blob.len_field offset in
     get_token ^^ Tagged.load_field_unskewed env filled_field
 
   let checkpoint _env _get_token = G.i Drop
@@ -7140,7 +7019,7 @@ module OldStabilization = struct
 
     let ptr64_field env = 
       let offset = 1l in (* see invariant in `stream.rs` *)
-      Int32.add (Blob.len_field env) offset (* see invariant in `stream.rs`, padding for 64-bit after Stream header *)
+      Int32.add Blob.len_field offset (* see invariant in `stream.rs`, padding for 64-bit after Stream header *)
 
     let terminate env get_token get_data_size header_size =
       get_token ^^
@@ -7177,10 +7056,7 @@ module OldStabilization = struct
     let (set_dst, get_dst) = new_local env "dst" in
     let (set_len, get_len) = new_local env "len" in
 
-    (if !Flags.gc_strategy = Flags.Incremental then
-      E.call_import env "rts" "stop_gc_on_upgrade"
-    else
-      G.nop) ^^
+    E.call_import env "rts" "stop_gc_on_upgrade" ^^
 
 
     Externalization.serialize env [t] ^^
@@ -7699,57 +7575,36 @@ module Var = struct
 
   (* Returns desired stack representation, preparation code and code to consume
      the value onto the stack *)
-  let set_val env ae var : G.t * SR.t * G.t = match (VarEnv.lookup ae var, !Flags.gc_strategy) with
-    | (Some ((Local (sr, i)), _), _) ->
+  let set_val env ae var : G.t * SR.t * G.t = match VarEnv.lookup ae var with
+    | Some ((Local (sr, i)), _) ->
       G.nop,
       sr,
       G.i (LocalSet (nr i))
-    | (Some ((HeapInd i), typ), Flags.Generational) when potential_pointer typ ->
-      G.i (LocalGet (nr i)),
-      SR.Vanilla,
-      MutBox.store_field env ^^
-      G.i (LocalGet (nr i)) ^^
-      Tagged.load_forwarding_pointer env ^^ (* not needed for this GC, but only for forward pointer sanity checks *)
-      compile_add_const ptr_unskew ^^
-      compile_add_const (Int32.mul (MutBox.field env) Heap.word_size) ^^
-      E.call_import env "rts" "post_write_barrier"
-    | (Some ((HeapInd i), typ), Flags.Incremental) when potential_pointer typ ->
+    | Some ((HeapInd i), typ) when potential_pointer typ ->
       G.i (LocalGet (nr i)) ^^
       Tagged.load_forwarding_pointer env ^^
       compile_add_const ptr_unskew ^^
-      compile_add_const (Int32.mul (MutBox.field env) Heap.word_size),
+      compile_add_const (Int32.mul MutBox.field Heap.word_size),
       SR.Vanilla,
       Tagged.write_with_barrier env
-    | (Some ((HeapInd i), typ), _) ->
+    | Some ((HeapInd i), typ) ->
       G.i (LocalGet (nr i)),
       SR.Vanilla,
       MutBox.store_field env
-    | (Some ((Static index), typ), Flags.Generational) when potential_pointer typ ->
-      let (set_static_variable, get_static_variable) = new_local env "static_variable" in
-      GCRoots.get_static_variable env index ^^
-      Tagged.load_forwarding_pointer env ^^ (* not needed for this GC, but only for forward pointer sanity checks *)
-      set_static_variable ^^
-      get_static_variable,
-      SR.Vanilla,
-      MutBox.store_field env ^^
-      get_static_variable ^^
-      compile_add_const ptr_unskew ^^
-      compile_add_const (Int32.mul (MutBox.field env) Heap.word_size) ^^
-      E.call_import env "rts" "post_write_barrier"
-    | (Some ((Static index), typ), Flags.Incremental) when potential_pointer typ ->
+    | Some ((Static index), typ) when potential_pointer typ ->
       GCRoots.get_static_variable env index ^^
       Tagged.load_forwarding_pointer env ^^
       compile_add_const ptr_unskew ^^
-      compile_add_const (Int32.mul (MutBox.field env) Heap.word_size),
+      compile_add_const (Int32.mul MutBox.field Heap.word_size),
       SR.Vanilla,
       Tagged.write_with_barrier env
-    | (Some ((Static index), typ), _) ->
+    | Some ((Static index), typ) ->
       GCRoots.get_static_variable env index,
       SR.Vanilla,
       MutBox.store_field env
-    | (Some ((Const _), _), _) -> fatal "set_val: %s is const" var
-    | (Some ((PublicMethod _), _), _) -> fatal "set_val: %s is PublicMethod" var
-    | (None, _)   -> fatal "set_val: %s missing" var
+    | Some ((Const _), _) -> fatal "set_val: %s is const" var
+    | Some ((PublicMethod _), _) -> fatal "set_val: %s is PublicMethod" var
+    | None -> fatal "set_val: %s missing" var
 
   (* Stores the payload. Returns stack preparation code, and code that consumes the values from the stack *)
   let set_val_vanilla env ae var : G.t * G.t =
@@ -7983,18 +7838,18 @@ module FuncDec = struct
 
       let code =
         (* Allocate a heap object for the closure *)
-        Tagged.alloc env (Int32.add (Closure.header_size env) len) Tagged.Closure ^^
+        Tagged.alloc env (Int32.add Closure.header_size len) Tagged.Closure ^^
         set_clos ^^
 
         (* Store the function pointer number: *)
         get_clos ^^
         compile_unboxed_const (E.add_fun_ptr env fi) ^^
-        Tagged.store_field env (Closure.funptr_field env) ^^
+        Tagged.store_field env Closure.funptr_field ^^
 
         (* Store the length *)
         get_clos ^^
         compile_unboxed_const len ^^
-        Tagged.store_field env (Closure.len_field env) ^^
+        Tagged.store_field env Closure.len_field ^^
 
         (* Store all captured values *)
         store_env ^^
@@ -9199,46 +9054,25 @@ let compile_load_field env typ name =
 *)
 let rec compile_lexp (env : E.t) ae lexp : G.t * SR.t * G.t =
   (fun (code, sr, fill_code) -> G.(with_region lexp.at code, sr, with_region lexp.at fill_code)) @@
-  match lexp.it, !Flags.gc_strategy with
-  | VarLE var, _ -> Var.set_val env ae var
-  | IdxLE (e1, e2), Flags.Generational when potential_pointer (Arr.element_type env e1.note.Note.typ) ->
-    let (set_field, get_field) = new_local env "field" in
-    compile_array_index env ae e1 e2 ^^
-    set_field ^^ (* peepholes to tee *)
-    get_field,
-    SR.Vanilla,
-    store_ptr ^^
-    get_field ^^
-    compile_add_const ptr_unskew ^^
-    E.call_import env "rts" "post_write_barrier"
-  | IdxLE (e1, e2), Flags.Incremental when potential_pointer (Arr.element_type env e1.note.Note.typ) ->
+  match lexp.it with
+  | VarLE var -> Var.set_val env ae var
+  | IdxLE (e1, e2) when potential_pointer (Arr.element_type env e1.note.Note.typ) ->
     compile_array_index env ae e1 e2 ^^
     compile_add_const ptr_unskew,
     SR.Vanilla,
     Tagged.write_with_barrier env
-  | IdxLE (e1, e2), _ ->
+  | IdxLE (e1, e2) ->
     compile_array_index env ae e1 e2,
     SR.Vanilla,
     store_ptr
-  | DotLE (e, n), Flags.Generational when potential_pointer (Object.field_type env e.note.Note.typ n) ->
-    let (set_field, get_field) = new_local env "field" in
-    compile_exp_vanilla env ae e ^^
-    Object.idx env e.note.Note.typ n ^^
-    set_field ^^ (* peepholes to tee *)
-    get_field,
-    SR.Vanilla,
-    store_ptr ^^
-    get_field ^^
-    compile_add_const ptr_unskew ^^
-    E.call_import env "rts" "post_write_barrier"
-  | DotLE (e, n), Flags.Incremental when potential_pointer (Object.field_type env e.note.Note.typ n) ->
+  | DotLE (e, n) when potential_pointer (Object.field_type env e.note.Note.typ n) ->
     compile_exp_vanilla env ae e ^^
     (* Only real objects have mutable fields, no need to branch on the tag *)
     Object.idx env e.note.Note.typ n ^^
     compile_add_const ptr_unskew,
     SR.Vanilla,
     Tagged.write_with_barrier env
-  | DotLE (e, n), _ ->
+  | DotLE (e, n) ->
     compile_exp_vanilla env ae e ^^
     (* Only real objects have mutable fields, no need to branch on the tag *)
     Object.idx env e.note.Note.typ n,
@@ -9425,7 +9259,7 @@ and compile_prim_invocation (env : E.t) ae p es at =
        fields, effectively arriving at the desired element *)
     G.i (Binary (Wasm.Values.I32 I32Op.Add)) ^^
     (* Not using Tagged.load_field since it is not a proper pointer to the array start *)
-    Heap.load_field (Arr.header_size env) (* loads the element at the byte offset *)
+    Heap.load_field Arr.header_size (* loads the element at the byte offset *)
   | GetPastArrayOffset spacing, [e] ->
     let shift =
       match spacing with
@@ -11086,7 +10920,7 @@ and conclude_module env set_serialization_globals start_fi_o =
 
   (* Wrap the start function with the RTS initialization *)
   let rts_start_fi = E.add_fun env "rts_start" (Func.of_body env [] [] (fun env1 ->
-    E.call_import env "rts" ("initialize_" ^ E.gc_strategy_name !Flags.gc_strategy ^ "_gc") ^^
+    E.call_import env "rts" ("initialize_incremental_gc") ^^
     GCRoots.register_static_variables env ^^
     match start_fi_o with
     | Some fi ->
diff --git a/src/exes/moc.ml b/src/exes/moc.ml
index f118b506296..6db95348069 100644
--- a/src/exes/moc.ml
+++ b/src/exes/moc.ml
@@ -141,22 +141,6 @@ let argspec = [
     set_mode Compile ()), (* similar to --idl *)
       " compile and emit signature of stable types to `.most` file";
 
-  "--generational-gc",
-  Arg.Unit (fun () -> Flags.gc_strategy := Mo_config.Flags.Generational),
-  " use generational GC";
-
-  "--incremental-gc",
-  Arg.Unit (fun () -> Flags.gc_strategy := Mo_config.Flags.Incremental),
-  " use incremental GC";
-    
-  "--compacting-gc",
-  Arg.Unit (fun () -> Flags.gc_strategy := Mo_config.Flags.MarkCompact),
-  " use compacting GC";
-
-  "--copying-gc",
-  Arg.Unit (fun () -> Flags.gc_strategy := Mo_config.Flags.Copying),
-  " use copying GC (default)";
-
   "--force-gc",
   Arg.Unit (fun () -> Flags.force_gc := true),
   " disable GC scheduling, always do GC after an update message (for testing)";
diff --git a/src/js/common.ml b/src/js/common.ml
index aa027ce6326..3e3f623ad03 100644
--- a/src/js/common.ml
+++ b/src/js/common.ml
@@ -221,8 +221,4 @@ let gc_flags option =
   match Js.to_string option with
   | "force" -> Flags.force_gc := true
   | "scheduling" -> Flags.force_gc := false
-  | "copying" -> Flags.gc_strategy := Mo_config.Flags.Copying
-  | "marking" -> Flags.gc_strategy := Mo_config.Flags.MarkCompact
-  | "generational" -> Flags.gc_strategy := Mo_config.Flags.Generational
-  | "incremental" -> Flags.gc_strategy := Mo_config.Flags.Incremental
   | _ -> raise (Invalid_argument "gc_flags: Unexpected flag")
diff --git a/src/mo_config/flags.ml b/src/mo_config/flags.ml
index aa031b5548e..bcdfd6d635c 100644
--- a/src/mo_config/flags.ml
+++ b/src/mo_config/flags.ml
@@ -4,8 +4,6 @@ module M = Map.Make(String)
 
 type compile_mode = WasmMode | ICMode | RefMode | WASIMode
 
-type gc_strategy = MarkCompact | Copying | Generational | Incremental
-
 let trace = ref false
 let verbose = ref false
 let print_warnings = ref true
@@ -39,7 +37,6 @@ let omit_metadata_names : string list ref = ref []
 let compiled = ref false
 let error_detail = ref 2
 let sanity = ref false
-let gc_strategy = ref Copying
 let force_gc = ref false
 let global_timer = ref true
 let experimental_field_aliasing = ref false
diff --git a/src/pipeline/pipeline.ml b/src/pipeline/pipeline.ml
index 9867532496e..efde3582809 100644
--- a/src/pipeline/pipeline.ml
+++ b/src/pipeline/pipeline.ml
@@ -660,11 +660,9 @@ let ir_passes mode prog_ir name =
 (* Compilation *)
 
 let load_as_rts () =
-  let rts = match (!Flags.gc_strategy, !Flags.sanity) with
-    | (Flags.Incremental, false) -> Rts.wasm_incremental_release
-    | (Flags.Incremental, true) -> Rts.wasm_incremental_debug
-    | (_, false) -> Rts.wasm_non_incremental_release
-    | (_, true) -> Rts.wasm_non_incremental_debug
+  let rts = match !Flags.sanity with
+    | false -> Rts.wasm_release
+    | true -> Rts.wasm_debug
   in
   Wasm_exts.CustomModuleDecode.decode "rts.wasm" (Lazy.force rts)
 
diff --git a/src/rts/gen.sh b/src/rts/gen.sh
index c4b90696ae0..513d2df5b52 100755
--- a/src/rts/gen.sh
+++ b/src/rts/gen.sh
@@ -11,8 +11,5 @@ if [ -z "$1" ]; then
   exit 1
 fi
 
-perl -0777 -ne 'print "let wasm_non_incremental_release = lazy \""; printf "\\x%02x", $_ for unpack("C*", $_); print "\"\n";' "$1/mo-rts.wasm" > "$file"
-perl -0777 -ne 'print "let wasm_non_incremental_debug = lazy \""; printf "\\x%02x", $_ for unpack("C*", $_); print "\"";' "$1/mo-rts-debug.wasm" >> "$file"
-
-perl -0777 -ne 'print "let wasm_incremental_release = lazy \""; printf "\\x%02x", $_ for unpack("C*", $_); print "\"\n";' "$1/mo-rts-incremental.wasm" >> "$file"
-perl -0777 -ne 'print "let wasm_incremental_debug = lazy \""; printf "\\x%02x", $_ for unpack("C*", $_); print "\"";' "$1/mo-rts-incremental-debug.wasm" >> "$file"
+perl -0777 -ne 'print "let wasm_release = lazy \""; printf "\\x%02x", $_ for unpack("C*", $_); print "\"\n";' "$1/mo-rts.wasm" > "$file"
+perl -0777 -ne 'print "let wasm_debug = lazy \""; printf "\\x%02x", $_ for unpack("C*", $_); print "\"";' "$1/mo-rts-debug.wasm" >> "$file"
diff --git a/src/rts/rts.ml b/src/rts/rts.ml
index db1d9529e6b..39fff73cb41 100644
--- a/src/rts/rts.ml
+++ b/src/rts/rts.ml
@@ -19,8 +19,5 @@ let load_file env =
     Printf.eprintf "Environment variable %s not set. Please run moc via the bin/moc wrapper (which should be in your PATH in the nix-shell)." env;
     exit 1
 
-let wasm_non_incremental_release : string Lazy.t = lazy (load_file "MOC_NON_INCREMENTAL_RELEASE_RTS")
-let wasm_non_incremental_debug : string Lazy.t = lazy (load_file "MOC_NON_INCREMENTAL_DEBUG_RTS")
-
-let wasm_incremental_release : string Lazy.t = lazy (load_file "MOC_INCREMENTAL_RELEASE_RTS")
-let wasm_incremental_debug : string Lazy.t = lazy (load_file "MOC_INCREMENTAL_DEBUG_RTS")
+let wasm_release : string Lazy.t = lazy (load_file "MOC_RELEASE_RTS")
+let wasm_debug : string Lazy.t = lazy (load_file "MOC_DEBUG_RTS")
diff --git a/src/rts/rts.mli b/src/rts/rts.mli
index 1955b88014b..27b30301429 100644
--- a/src/rts/rts.mli
+++ b/src/rts/rts.mli
@@ -1,5 +1,2 @@
-val wasm_non_incremental_release : string Lazy.t
-val wasm_non_incremental_debug : string Lazy.t
-
-val wasm_incremental_release : string Lazy.t
-val wasm_incremental_debug : string Lazy.t
+val wasm_release : string Lazy.t
+val wasm_debug : string Lazy.t

From 04f027b73d27c06fa093dac9cab63c4dcf152c96 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Wed, 16 Aug 2023 11:46:12 +0200
Subject: [PATCH 029/260] Bug fix

---
 src/codegen/compile.ml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 158240b67bb..89223939603 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -7293,7 +7293,8 @@ module GCRoots = struct
   let get_static_variable env index = 
     E.call_import env "rts" "get_static_root" ^^
     compile_unboxed_const index ^^
-    Arr.idx env
+    Arr.idx env ^^
+    load_ptr
 end (* GCRoots *)
 
 module StackRep = struct

From d9b4253d4d438659987509cef8452a05dd5ea934 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Wed, 16 Aug 2023 12:02:30 +0200
Subject: [PATCH 030/260] Code refactoring

---
 src/codegen/compile.ml | 428 ++++++-----------------------------------
 1 file changed, 64 insertions(+), 364 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 89223939603..a3e7c42afb1 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -629,7 +629,6 @@ let compile_eq_const = function
 let compile_op64_const op i =
     compile_const_64 i ^^
     G.i (Binary (Wasm.Values.I64 op))
-let _compile_add64_const = compile_op64_const I64Op.Add
 let compile_sub64_const = compile_op64_const I64Op.Sub
 let compile_mul64_const = compile_op64_const I64Op.Mul
 let _compile_divU64_const = compile_op64_const I64Op.DivU
@@ -1060,12 +1059,6 @@ module Heap = struct
 
   (* At this level of abstraction, heap objects are just flat arrays of words *)
 
-(*
-  let load_field_unskewed (i : int32) : G.t =
-    let offset = Int32.mul word_size i in
-    G.i (Load {ty = I32Type; align = 2; offset; sz = None})
-*)
-
   let load_field (i : int32) : G.t =
     let offset = Int32.(add (mul word_size i) ptr_unskew) in
     G.i (Load {ty = I32Type; align = 2; offset; sz = None})
@@ -1078,12 +1071,6 @@ module Heap = struct
      32 bit fields as one 64 bit number *)
 
   (* Requires little-endian encoding, see also `Stream` in `types.rs` *)
-(*
-  let load_field64_unskewed (i : int32) : G.t =
-    let offset = Int32.mul word_size i in
-    G.i (Load {ty = I64Type; align = 2; offset; sz = None})
-*)
-
   let load_field64 (i : int32) : G.t =
     let offset = Int32.(add (mul word_size i) ptr_unskew) in
     G.i (Load {ty = I64Type; align = 2; offset; sz = None})
@@ -1600,16 +1587,6 @@ module Tagged = struct
     (if !Flags.sanity then check_forwarding_for_store env I32Type else G.nop) ^^
     Heap.store_field index
 
-(*
-  let load_field_unskewed env index =
-    (if !Flags.sanity then check_forwarding env true else G.nop) ^^
-    Heap.load_field_unskewed index
-
-  let load_field64_unskewed env index =
-    (if !Flags.sanity then check_forwarding env true else G.nop) ^^
-    Heap.load_field64_unskewed index
-*)
-
   let load_field64 env index =
     (if !Flags.sanity then check_forwarding env false else G.nop) ^^
     Heap.load_field64 index
@@ -3642,32 +3619,6 @@ module Blob = struct
 
   let dyn_alloc_scratch env = alloc env ^^ payload_ptr_unskewed env
 
-(*
-  (* TODO: rewrite using MemoryFill *)
-  let clear env =
-    Func.share_code1 env "blob_clear" ("x", I32Type) [] (fun env get_x ->
-      let (set_ptr, get_ptr) = new_local env "ptr" in
-      let (set_len, get_len) = new_local env "len" in
-      get_x ^^
-      as_ptr_len env ^^
-      set_len ^^
-      set_ptr ^^
-
-      (* round to word size *)
-      get_len ^^
-      compile_add_const (Int32.sub Heap.word_size 1l) ^^
-      compile_divU_const Heap.word_size ^^
-
-      (* clear all words *)
-      from_0_to_n env (fun get_i ->
-        get_ptr ^^
-        compile_unboxed_const 0l ^^
-        store_unskewed_ptr ^^
-        get_ptr ^^
-        compile_add_const Heap.word_size ^^
-        set_ptr))
-*)
-
 end (* Blob *)
 
 module Text = struct
@@ -4724,10 +4675,6 @@ end (* Cycles *)
 
 
 module StableMem = struct
-
-  (* start from 1 to avoid accidental reads of 0 *)
-  let _version = Int32.of_int 1
-
   let register_globals env =
     (* size (in pages) *)
     E.add_global64 env "__stablemem_size" Mutable 0L
@@ -4819,40 +4766,6 @@ module StableMem = struct
             IC.system_call env "stable64_write"))
     | _ -> assert false
 
-(*
-  let _read_word32 env =
-    read env false "word32" I32Type 4l load_unskewed_ptr
-  let write_word32 env =
-    write env false "word32" I32Type 4l store_unskewed_ptr
-
-  (* read and clear word32 from stable mem offset on stack *)
-  let read_and_clear_word32 env =
-    match E.mode env with
-    | Flags.ICMode | Flags.RefMode ->
-      Func.share_code1 env "__stablemem_read_and_clear_word32"
-        ("offset", I64Type) [I32Type]
-        (fun env get_offset ->
-          Stack.with_words env "temp_ptr" 1l (fun get_temp_ptr ->
-            let (set_word, get_word) = new_local env "word" in
-            (* read word *)
-            get_temp_ptr ^^ G.i (Convert (Wasm.Values.I64 I64Op.ExtendUI32)) ^^
-            get_offset ^^
-            compile_const_64 4L ^^
-            IC.system_call env "stable64_read" ^^
-            get_temp_ptr ^^ load_unskewed_ptr ^^
-            set_word ^^
-            (* write 0 *)
-            get_temp_ptr ^^ compile_unboxed_const 0l ^^ store_unskewed_ptr ^^
-            get_offset ^^
-            get_temp_ptr ^^ G.i (Convert (Wasm.Values.I64 I64Op.ExtendUI32)) ^^
-            compile_const_64 4L ^^
-            IC.system_call env "stable64_write" ^^
-            (* return word *)
-            get_word
-        ))
-    | _ -> assert false
-*)
-
   (* ensure_pages : ensure at least num pages allocated,
      growing (real) stable memory if needed *)
   let ensure_pages env =
@@ -4881,37 +4794,6 @@ module StableMem = struct
             get_size)
     | _ -> assert false
 
-(*
-  (* ensure stable memory includes [offset..offset+size), assumes size > 0 *)
-  let ensure env =
-    match E.mode env with
-    | Flags.ICMode | Flags.RefMode ->
-      Func.share_code2 env "__stablemem_ensure"
-        (("offset", I64Type), ("size", I64Type)) []
-        (fun env get_offset get_size ->
-          let (set_sum, get_sum) = new_local64 env "sum" in
-          get_offset ^^
-          get_size ^^
-          G.i (Binary (Wasm.Values.I64 I64Op.Add)) ^^
-          set_sum ^^
-          (* check for overflow *)
-          get_sum ^^
-          get_offset ^^
-          G.i (Compare (Wasm.Values.I64 I64Op.LtU)) ^^
-          E.then_trap_with env "Range overflow" ^^
-          (* ensure page *)
-          get_sum ^^
-          compile_const_64 (Int64.of_int page_size_bits) ^^
-          G.i (Binary (Wasm.Values.I64 I64Op.ShrU)) ^^
-          compile_add64_const 1L ^^
-          ensure_pages env ^^
-          (* Check result *)
-          compile_const_64 0L ^^
-          G.i (Compare (Wasm.Values.I64 I64Op.LtS)) ^^
-          E.then_trap_with env "Out of stable memory.")
-    | _ -> assert false
-*)
-
   (* API *)
 
   let logical_grow env =
@@ -6870,81 +6752,6 @@ end (* MakeSerialization *)
 
 module Serialization = MakeSerialization(BumpStream)
 
-(*
-module BlobStream : Stream = struct
-  let create env get_data_size set_token get_token header =
-    let header_size = Int32.of_int (String.length header) in
-    get_data_size ^^ compile_add_const header_size ^^
-    E.call_import env "rts" "alloc_stream" ^^ set_token ^^ (* allocation barrier called in alloc_stream *)
-    get_token ^^
-    Blob.lit env header ^^
-    E.call_import env "rts" "stream_write_text"
-
-  let check_filled env get_token get_data_size =
-    G.i Drop
-
-  let terminate env get_token _get_data_size _header_size =
-    get_token ^^ E.call_import env "rts" "stream_split" ^^
-    let set_blob, get_blob = new_local env "blob" in
-    set_blob ^^
-    get_blob ^^ Blob.payload_ptr_unskewed env ^^
-    get_blob ^^ Blob.len env
-
-  let finalize_buffer code = code
-
-  let name_for fn_name ts = "@Bl_" ^ fn_name ^ "<" ^ Typ_hash.typ_seq_hash ts ^ ">"
-
-  let absolute_offset env get_token =
-    let offset = 8l in (* see invariant in `stream.rs` *)
-    let filled_field = Int32.add Blob.len_field offset in
-    get_token ^^ Tagged.load_field_unskewed env filled_field
-
-  let checkpoint _env _get_token = G.i Drop
-
-  let reserve env get_token bytes =
-    get_token ^^ compile_unboxed_const bytes ^^ E.call_import env "rts" "stream_reserve"
-
-  let write_word_leb env get_token code =
-    let set_word, get_word = new_local env "word" in
-    code ^^ set_word ^^
-    I32Leb.compile_store_to_data_buf_unsigned env get_word
-      (get_token ^^ I32Leb.compile_leb128_size get_word ^^ E.call_import env "rts" "stream_reserve") ^^
-    G.i Drop
-
-  let write_word_32 env get_token code =
-    reserve env get_token Heap.word_size ^^
-    code ^^
-    G.i (Store {ty = I32Type; align = 0; offset = 0l; sz = None})
-
-  let write_byte env get_token code =
-    get_token ^^ code ^^
-    E.call_import env "rts" "stream_write_byte"
-
-  let write_blob env get_token get_x =
-    let set_len, get_len = new_local env "len" in
-    get_x ^^ Blob.len env ^^ set_len ^^
-    write_word_leb env get_token get_len ^^
-    get_token ^^
-    get_x ^^ Blob.payload_ptr_unskewed env ^^
-    get_len ^^
-    E.call_import env "rts" "stream_write"
-
-  let write_text env get_token get_x =
-    write_word_leb env get_token (get_x ^^ Text.size env) ^^
-    get_token ^^ get_x ^^
-    E.call_import env "rts" "stream_write_text"
-
-  let write_bignum_leb env get_token get_x =
-    get_token ^^ get_x ^^
-    BigNum.compile_store_to_stream_unsigned env
-
-  let write_bignum_sleb env get_token get_x =
-    get_token ^^ get_x ^^
-    BigNum.compile_store_to_stream_signed env
-
-end
-*)
-
 module Stabilization = struct
   let load_stable_actor env = E.call_import env "rts" "load_stable_actor"
     
@@ -6970,7 +6777,8 @@ module Stabilization = struct
 end
 
 (*
-(* OldStabilization (serialization to/from stable memory) of both:
+(* OldStabilization as migration code: 
+  Deserializing a last time from explicit stable memory into the stable heap:
    * stable variables; and
    * virtual stable memory.
    c.f.
@@ -6979,177 +6787,69 @@ end
 *)
 
 module OldStabilization = struct
+  (* start from 1 to avoid accidental reads of 0 *)
+  let stable_memory_version = Int32.of_int 1
 
   let extend64 code = code ^^ G.i (Convert (Wasm.Values.I64 I64Op.ExtendUI32))
+  let compile_add64_const = compile_op64_const I64Op.Add
 
-  (* The below stream implementation is geared towards the
-     tail section of stable memory, where the serialised
-     stable variables go. As such a few intimate details of
-     the stable memory layout are burnt in, such as the
-     variable `N` from the design document. *)
-  module StableMemoryStream : Stream = struct
-    include BlobStream
-
-    let name_for fn_name ts = "@Sm_" ^ fn_name ^ "<" ^ Typ_hash.typ_seq_hash ts ^ ">"
+  let _read_word32 env =
+    StableMem.read env false "word32" I32Type 4l load_unskewed_ptr
+  let write_word32 env =
+    StableMem.write env false "word32" I32Type 4l store_unskewed_ptr
 
-    let create env get_data_size set_token get_token header =
-      create env (compile_unboxed_const 0x8000l) set_token get_token header ^^
-        (* TODO: push header directly? *)
+  (* read and clear word32 from stable mem offset on stack *)
+  let read_and_clear_word32 env =
+    match E.mode env with
+    | Flags.ICMode | Flags.RefMode ->
+      Func.share_code1 env "__stablemem_read_and_clear_word32"
+        ("offset", I64Type) [I32Type]
+        (fun env get_offset ->
+          Stack.with_words env "temp_ptr" 1l (fun get_temp_ptr ->
+            let (set_word, get_word) = new_local env "word" in
+            (* read word *)
+            get_temp_ptr ^^ G.i (Convert (Wasm.Values.I64 I64Op.ExtendUI32)) ^^
+            get_offset ^^
+            compile_const_64 4L ^^
+            IC.system_call env "stable64_read" ^^
+            get_temp_ptr ^^ load_unskewed_ptr ^^
+            set_word ^^
+            (* write 0 *)
+            get_temp_ptr ^^ compile_unboxed_const 0l ^^ store_unskewed_ptr ^^
+            get_offset ^^
+            get_temp_ptr ^^ G.i (Convert (Wasm.Values.I64 I64Op.ExtendUI32)) ^^
+            compile_const_64 4L ^^
+            IC.system_call env "stable64_write" ^^
+            (* return word *)
+            get_word
+        ))
+    | _ -> assert false
 
+  (* TODO: rewrite using MemoryFill *)
+  let blob_clear env =
+    Func.share_code1 env "blob_clear" ("x", I32Type) [] (fun env get_x ->
+      let (set_ptr, get_ptr) = new_local env "ptr" in
       let (set_len, get_len) = new_local env "len" in
-      get_data_size ^^
-      compile_add_const (Int32.of_int (String.length header)) ^^
+      get_x ^^
+      Blob.as_ptr_len env ^^
       set_len ^^
+      set_ptr ^^
 
-      let (set_dst, get_dst) = new_local64 env "dst" in
-      StableMem.get_mem_size env ^^
-      compile_shl64_const (Int64.of_int page_size_bits) ^^
-      compile_add64_const 4L ^^ (* `N` is now on the stack *)
-      set_dst ^^
-
-      get_dst ^^
-      extend64 get_len ^^
-      StableMem.ensure env ^^
-
-      get_token ^^
-      get_dst ^^
-      get_dst ^^ extend64 get_len ^^
-      G.i (Binary (Wasm.Values.I64 I64Op.Add)) ^^
-      E.call_import env "rts" "stream_stable_dest"
-
-    let ptr64_field env = 
-      let offset = 1l in (* see invariant in `stream.rs` *)
-      Int32.add Blob.len_field offset (* see invariant in `stream.rs`, padding for 64-bit after Stream header *)
-
-    let terminate env get_token get_data_size header_size =
-      get_token ^^
-      E.call_import env "rts" "stream_shutdown" ^^
-      compile_unboxed_zero ^^ (* no need to write *)
-      get_token ^^
-      Tagged.load_field64_unskewed env (ptr64_field env) ^^
-      StableMem.get_mem_size env ^^
-      compile_shl64_const (Int64.of_int page_size_bits) ^^
-      G.i (Binary (Wasm.Values.I64 I64Op.Sub)) ^^
-      compile_sub64_const 4L ^^  (* `N` is now subtracted *)
-      G.i (Convert (Wasm.Values.I32 I32Op.WrapI64))
-
-    let finalize_buffer _ = G.nop (* everything is outputted already *)
-
-    (* Returns a 32-bit unsigned int that is the number of bytes that would
-       have been written to stable memory if flushed. The difference
-       of two such numbers will always be an exact byte distance. *)
-    let absolute_offset env get_token =
-      let start64_field = Int32.add (ptr64_field env) 2l in (* see invariant in `stream.rs` *)
-      absolute_offset env get_token ^^
-      get_token ^^
-      Tagged.load_field64_unskewed env (ptr64_field env) ^^
-      get_token ^^
-      Tagged.load_field64_unskewed env start64_field ^^
-      G.i (Binary (Wasm.Values.I64 I64Op.Sub)) ^^
-      G.i (Convert (Wasm.Values.I32 I32Op.WrapI64)) ^^
-      G.i (Binary (Wasm.Values.I32 I32Op.Add))
-  end
-
-  module Externalization = MakeSerialization(StableMemoryStream)
-
-  let stabilize env t =
-    let (set_dst, get_dst) = new_local env "dst" in
-    let (set_len, get_len) = new_local env "len" in
-
-    E.call_import env "rts" "stop_gc_on_upgrade" ^^
-
-
-    Externalization.serialize env [t] ^^
-    set_len ^^
-    set_dst ^^
-
-    StableMem.get_mem_size env ^^
-    G.i (Test (Wasm.Values.I64 I64Op.Eqz)) ^^
-    G.if0
-      begin (* ensure [0,..,3,...len+4) *)
-        compile_const_64 0L ^^
-        extend64 get_len ^^
-        compile_add64_const 4L ^^  (* reserve one word for size *)
-        StableMem.ensure env ^^
-
-        (* write len to initial word of stable memory*)
-        compile_const_64 0L ^^
-        get_len ^^
-        StableMem.write_word32 env ^^
-
-        (* copy data to following stable memory *)
-        Externalization.Strm.finalize_buffer
-          begin
-            compile_const_64 4L ^^
-            extend64 get_dst ^^
-            extend64 get_len ^^
-            IC.system_call env "stable64_write"
-          end
-      end
-      begin
-        let (set_N, get_N) = new_local64 env "N" in
-
-        (* let N = !size * page_size *)
-        StableMem.get_mem_size env ^^
-        compile_shl64_const (Int64.of_int page_size_bits) ^^
-        set_N ^^
-
-        (* grow mem to page including address
-           N + 4 + len + 4 + 4 + 4 = N + len + 16
-        *)
-        get_N ^^
-        extend64 get_len ^^
-        compile_add64_const 16L ^^
-        StableMem.ensure env ^^
-
-        get_N ^^
-        get_len ^^
-        StableMem.write_word32 env ^^
-
-        (* copy data to following stable memory *)
-        Externalization.Strm.finalize_buffer
-          begin
-            get_N ^^
-            compile_add64_const 4L ^^
-            extend64 get_dst ^^
-            extend64 get_len ^^
-            IC.system_call env "stable64_write"
-          end ^^
-
-        (* let M = pagesize * ic0.stable64_size64() - 1 *)
-        (* M is beginning of last page *)
-        let (set_M, get_M) = new_local64 env "M" in
-        IC.system_call env "stable64_size" ^^
-        compile_sub64_const 1L ^^
-        compile_shl64_const (Int64.of_int page_size_bits) ^^
-        set_M ^^
-
-        (* store mem_size at M + (pagesize - 12) *)
-        get_M ^^
-        compile_add64_const (Int64.sub page_size64 12L) ^^
-        StableMem.get_mem_size env ^^
-        G.i (Convert (Wasm.Values.I32 I32Op.WrapI64)) ^^
-        (* TODO: write word64 *)
-        StableMem.write_word32 env ^^
-
-        (* save first word at M + (pagesize - 8);
-           mark first word as 0 *)
-        get_M ^^
-        compile_add64_const (Int64.sub page_size64 8L) ^^
-        compile_const_64 0L ^^
-        StableMem.read_and_clear_word32 env ^^
-        StableMem.write_word32 env ^^
-
-        (* save version at M + (pagesize - 4) *)
-        get_M ^^
-          compile_add64_const (Int64.sub page_size64 4L) ^^
-        (* TODO bump version? *)
-        compile_unboxed_const StableMem.version ^^
-        StableMem.write_word32 env
+      (* round to word size *)
+      get_len ^^
+      compile_add_const (Int32.sub Heap.word_size 1l) ^^
+      compile_divU_const Heap.word_size ^^
 
-      end
+      (* clear all words *)
+      from_0_to_n env (fun get_i ->
+        get_ptr ^^
+        compile_unboxed_const 0l ^^
+        store_unskewed_ptr ^^
+        get_ptr ^^
+        compile_add_const Heap.word_size ^^
+        set_ptr))
 
-  let destabilize env ty =
+  let _destabilize env ty =
     match E.mode env with
     | Flags.ICMode | Flags.RefMode ->
       let (set_pages, get_pages) = new_local64 env "pages" in
@@ -7175,7 +6875,7 @@ module OldStabilization = struct
           let (set_len, get_len) = new_local env "len" in
           let (set_offset, get_offset) = new_local64 env "offset" in
           compile_const_64 0L ^^
-          StableMem.read_and_clear_word32 env ^^
+          read_and_clear_word32 env ^^
           set_marker ^^
 
           get_marker ^^
@@ -7194,28 +6894,28 @@ module OldStabilization = struct
               (* read version *)
               get_M ^^
               compile_add64_const (Int64.sub page_size64 4L) ^^
-              StableMem.read_and_clear_word32 env ^^
+              read_and_clear_word32 env ^^
               set_version ^^
 
               (* check version *)
               get_version ^^
-              compile_unboxed_const StableMem.version ^^
+              compile_unboxed_const stable_memory_version ^^
               G.i (Compare (Wasm.Values.I32 I32Op.GtU)) ^^
               E.then_trap_with env (Printf.sprintf
                 "higher stable memory version (expected %s)"
-                (Int32.to_string StableMem.version)) ^^
+                (Int32.to_string stable_memory_version)) ^^
 
               (* restore StableMem bytes [0..4) *)
               compile_const_64 0L ^^
               get_M ^^
               compile_add64_const (Int64.sub page_size64 8L) ^^
-              StableMem.read_and_clear_word32 env ^^
-              StableMem.write_word32 env ^^
+              read_and_clear_word32 env ^^
+              write_word32 env ^^
 
               (* restore mem_size *)
               get_M ^^
               compile_add64_const (Int64.sub page_size64 12L) ^^
-              extend64 (StableMem.read_and_clear_word32 env) ^^ (*TODO: use 64 bits *)
+              extend64 (read_and_clear_word32 env) ^^ (*TODO: use 64 bits *)
               StableMem.set_mem_size env ^^
 
               StableMem.get_mem_size env ^^
@@ -7224,7 +6924,7 @@ module OldStabilization = struct
 
               (* set len *)
               get_N ^^
-              StableMem.read_and_clear_word32 env ^^
+              read_and_clear_word32 env ^^
               set_len ^^
 
               (* set offset *)
@@ -7264,7 +6964,7 @@ module OldStabilization = struct
 
           (* clear blob contents *)
           get_blob ^^
-          Blob.clear env ^^
+          blob_clear env ^^
 
           (* copy zeros from blob to stable memory *)
           get_offset ^^

From 1cb23ac8012ca6c904b35ee689ce64a7036356b4 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Wed, 16 Aug 2023 13:48:07 +0200
Subject: [PATCH 031/260] Make all necessary runtime state persistent

---
 rts/motoko-rts-tests/src/gc.rs                |  10 +-
 rts/motoko-rts-tests/src/gc/heap.rs           |  11 +-
 rts/motoko-rts/src/continuation_table.rs      |  21 +-
 rts/motoko-rts/src/gc/incremental.rs          |  61 ++++--
 .../src/gc/incremental/partitioned_heap.rs    |   4 -
 rts/motoko-rts/src/gc/mark_compact/bitmap.rs  | 201 ------------------
 .../src/gc/mark_compact/mark_stack.rs         |  75 -------
 rts/motoko-rts/src/memory/ic.rs               |   9 -
 .../src/memory/ic/partitioned_memory.rs       |   5 +
 rts/motoko-rts/src/persistence.rs             |   3 +-
 10 files changed, 77 insertions(+), 323 deletions(-)
 delete mode 100644 rts/motoko-rts/src/gc/mark_compact/bitmap.rs
 delete mode 100644 rts/motoko-rts/src/gc/mark_compact/mark_stack.rs

diff --git a/rts/motoko-rts-tests/src/gc.rs b/rts/motoko-rts-tests/src/gc.rs
index 1f32eccc2e6..295ffe78c7a 100644
--- a/rts/motoko-rts-tests/src/gc.rs
+++ b/rts/motoko-rts-tests/src/gc.rs
@@ -11,9 +11,7 @@ mod random;
 mod utils;
 
 use heap::MotokoHeap;
-use utils::{
-    get_scalar_value, make_pointer, read_word, unskew_pointer, ObjectIdx, WORD_SIZE,
-};
+use utils::{get_scalar_value, make_pointer, read_word, unskew_pointer, ObjectIdx, WORD_SIZE};
 
 use motoko_rts::types::*;
 
@@ -262,7 +260,7 @@ fn check_dynamic_heap(
                 offset += WORD_SIZE + length as usize;
             } else {
                 assert!(tag == TAG_ARRAY || tag >= TAG_ARRAY_SLICE_MIN);
-                
+
                 if is_forwarded {
                     let forward_offset = forward as usize - heap.as_ptr() as usize;
                     let length = read_word(
@@ -404,7 +402,7 @@ fn check_static_root_array(mut offset: usize, roots: &[ObjectIdx], heap: &[u8])
 
     assert_eq!(read_word(heap, offset), make_pointer(array_address as u32));
     offset += WORD_SIZE;
-    
+
     assert_eq!(read_word(heap, offset), roots.len() as u32);
     offset += WORD_SIZE;
 
@@ -438,7 +436,7 @@ fn check_continuation_table(mut offset: usize, continuation_table: &[ObjectIdx],
 
     assert_eq!(read_word(heap, offset), make_pointer(table_addr as u32));
     offset += WORD_SIZE;
- 
+
     assert_eq!(read_word(heap, offset), continuation_table.len() as u32);
     offset += WORD_SIZE;
 
diff --git a/rts/motoko-rts-tests/src/gc/heap.rs b/rts/motoko-rts-tests/src/gc/heap.rs
index 195101f8fb1..00298e76ff0 100644
--- a/rts/motoko-rts-tests/src/gc/heap.rs
+++ b/rts/motoko-rts-tests/src/gc/heap.rs
@@ -291,8 +291,7 @@ impl Memory for DummyMemory {
 }
 
 /// Compute the size of the heap to be allocated for the GC test.
-fn heap_size_for_gc(
-) -> usize {
+fn heap_size_for_gc() -> usize {
     3 * PARTITION_SIZE
 }
 
@@ -324,7 +323,7 @@ fn create_dynamic_heap(
 
             write_word(dynamic_heap, heap_offset, make_pointer(address)); // forwarding pointer
             heap_offset += WORD_SIZE;
-            
+
             // Store length: idx + refs
             write_word(
                 dynamic_heap,
@@ -377,7 +376,7 @@ fn create_dynamic_heap(
 
             write_word(dynamic_heap, heap_offset, make_pointer(mutbox_address));
             heap_offset += WORD_SIZE;
-            
+
             let root_ptr = *object_addrs.get(root_id).unwrap();
             write_word(dynamic_heap, heap_offset, make_pointer(root_ptr as u32));
             heap_offset += WORD_SIZE;
@@ -394,7 +393,7 @@ fn create_dynamic_heap(
             make_pointer(static_root_array_address),
         );
         heap_offset += WORD_SIZE;
-        
+
         assert_eq!(static_roots.len(), root_mutboxes.len());
         write_word(dynamic_heap, heap_offset, root_mutboxes.len() as u32);
         heap_offset += WORD_SIZE;
@@ -416,7 +415,7 @@ fn create_dynamic_heap(
             make_pointer(continuation_table_address),
         );
         heap_offset += WORD_SIZE;
-        
+
         write_word(dynamic_heap, heap_offset, continuation_table.len() as u32);
         heap_offset += WORD_SIZE;
 
diff --git a/rts/motoko-rts/src/continuation_table.rs b/rts/motoko-rts/src/continuation_table.rs
index b0be5f4dbda..98ec500d085 100644
--- a/rts/motoko-rts/src/continuation_table.rs
+++ b/rts/motoko-rts/src/continuation_table.rs
@@ -1,5 +1,10 @@
 //! This file implements the data structure the Motoko runtime uses to keep track of outstanding
-//! continuations. It needs to support the following operations
+//! continuations.
+//!
+//! The structure is re-initialized on canister upgrades. This is why it is not part of the
+//! persistent metadata, cf. `persistence::PersistentMetadata`.
+//!
+//! It needs to support the following operations
 //!
 //!  1. Adding a continuation (any heap pointer) and getting an index (i32)
 //!  2. Looking up a continuation by index, which also frees it
@@ -22,7 +27,7 @@
 //! the free list. Since all indices are relative to the payload begin, they stay valid. We never
 //! shrink the table.
 
-use crate::barriers::allocation_barrier;
+use crate::barriers::{allocation_barrier, write_with_barrier};
 use crate::memory::{alloc_array, Memory};
 use crate::rts_trap_with;
 use crate::types::Value;
@@ -31,6 +36,9 @@ use motoko_rts_macros::ic_mem_fn;
 
 const INITIAL_SIZE: u32 = 256;
 
+// The static variables are re-initialized on canister upgrades and therefore not part of the
+// persistent metadata.
+
 // Skewed pointer to the `Array` object. This needs to be a skewed pointer to be able to pass its
 // location to the GC.
 static mut TABLE: Value = Value::from_scalar(0);
@@ -61,8 +69,8 @@ unsafe fn double_continuation_table<M: Memory>(mem: &mut M) {
 
     let new_size = old_size * 2;
 
-    TABLE = alloc_array(mem, new_size);
-    let new_array = TABLE.as_array();
+    let new_table = alloc_array(mem, new_size);
+    let new_array = new_table.as_array();
 
     for i in 0..old_size {
         let old_value = old_array.get(i);
@@ -72,7 +80,10 @@ unsafe fn double_continuation_table<M: Memory>(mem: &mut M) {
     for i in old_size..new_size {
         new_array.set_scalar(i, Value::from_scalar(i + 1));
     }
-    allocation_barrier(TABLE);
+    allocation_barrier(new_table);
+
+    let location = &mut TABLE as *mut Value;
+    write_with_barrier(mem, location, new_table);
 }
 
 pub unsafe fn table_initialized() -> bool {
diff --git a/rts/motoko-rts/src/gc/incremental.rs b/rts/motoko-rts/src/gc/incremental.rs
index 422a45f7b13..dbe257dd8c6 100644
--- a/rts/motoko-rts/src/gc/incremental.rs
+++ b/rts/motoko-rts/src/gc/incremental.rs
@@ -6,13 +6,17 @@
 //! - Focus on reclaiming high-garbage partitions.
 //! - Compacting heap space with partition evacuations.
 //! - Incremental copying enabled by forwarding pointers.
+//!
+//! The entire GC state including the scheduling statistics must be
+//! retained across upgrades and therefore be stored part of the
+//! persistent metadata, cf. `persistence::PersistentMetadata`.
 
 use motoko_rts_macros::ic_mem_fn;
 
 use crate::{memory::Memory, types::*, visitor::visit_pointer_fields};
 
 use self::{
-    partitioned_heap::{PartitionedHeap, PartitionedHeapIterator},
+    partitioned_heap::{PartitionedHeap, PartitionedHeapIterator, UNINITIALIZED_HEAP},
     phases::{
         evacuation_increment::EvacuationIncrement,
         mark_increment::{MarkIncrement, MarkState},
@@ -64,9 +68,6 @@ unsafe fn incremental_gc<M: Memory>(mem: &mut M) {
     }
 }
 
-#[cfg(feature = "ic")]
-static mut LAST_ALLOCATIONS: Bytes<u64> = Bytes(0u64);
-
 #[cfg(feature = "ic")]
 unsafe fn should_start() -> bool {
     use self::partitioned_heap::PARTITION_SIZE;
@@ -84,8 +85,9 @@ unsafe fn should_start() -> bool {
     };
 
     let current_allocations = partitioned_memory::get_total_allocations();
-    debug_assert!(current_allocations >= LAST_ALLOCATIONS);
-    let absolute_growth = current_allocations - LAST_ALLOCATIONS;
+    let state = get_incremental_gc_state();
+    debug_assert!(current_allocations >= state.statistics.last_allocations);
+    let absolute_growth = current_allocations - state.statistics.last_allocations;
     let relative_growth = absolute_growth.0 as f64 / heap_size.as_usize() as f64;
     relative_growth > growth_threshold && heap_size.as_usize() >= PARTITION_SIZE
 }
@@ -93,19 +95,31 @@ unsafe fn should_start() -> bool {
 #[cfg(feature = "ic")]
 unsafe fn record_gc_start<M: Memory>() {
     use crate::memory::ic::partitioned_memory;
-    LAST_ALLOCATIONS = partitioned_memory::get_total_allocations();
+
+    let state = get_incremental_gc_state();
+    state.statistics.last_allocations = partitioned_memory::get_total_allocations();
 }
 
 #[cfg(feature = "ic")]
 unsafe fn record_gc_stop<M: Memory>() {
-    use crate::memory::ic::{self, partitioned_memory};
+    use crate::memory::ic::partitioned_memory;
     use crate::persistence::HEAP_START;
 
     let heap_size = partitioned_memory::get_heap_size();
     let static_size = Bytes(HEAP_START as u32);
     debug_assert!(heap_size >= static_size);
     let dynamic_size = heap_size - static_size;
-    ic::MAX_LIVE = ::core::cmp::max(ic::MAX_LIVE, dynamic_size);
+    let state = get_incremental_gc_state();
+    state.statistics.max_live = ::core::cmp::max(state.statistics.max_live, dynamic_size);
+}
+
+// Persistent GC statistics used for scheduling and diagnostics.
+#[cfg(feature = "ic")]
+struct Statistics {
+    // Total number of allocation at the start of the last GC run.
+    last_allocations: Bytes<u64>,
+    // Maximum heap size the end of a GC run.
+    max_live: Bytes<u32>,
 }
 
 /// GC phases per run. Each of the following phases is performed in potentially multiple increments.
@@ -147,8 +161,24 @@ pub struct State {
     allocation_count: usize, // Number of allocations during an active GC run.
     mark_state: Option<MarkState>,
     iterator_state: Option<PartitionedHeapIterator>,
+    #[cfg(feature = "ic")]
+    statistics: Statistics,
 }
 
+/// Optimization: Avoiding `Option` or `Lazy`.
+pub(crate) const UNINITIALIZED_STATE: State = State {
+    phase: Phase::Pause,
+    partitioned_heap: UNINITIALIZED_HEAP,
+    allocation_count: 0,
+    mark_state: None,
+    iterator_state: None,
+    #[cfg(feature = "ic")]
+    statistics: Statistics {
+        last_allocations: Bytes(0),
+        max_live: Bytes(0),
+    },
+};
+
 /// Incremental GC.
 /// Each GC call has its new GC instance that shares the common GC state `STATE`.
 pub struct IncrementalGC<'a, M: Memory> {
@@ -388,15 +418,14 @@ pub unsafe fn get_incremental_gc_state() -> &'static mut State {
     crate::persistence::get_incremental_gc_state()
 }
 
+#[cfg(feature = "ic")]
+pub unsafe fn get_max_live_size() -> Bytes<u32> {
+    get_incremental_gc_state().statistics.max_live
+}
+
 // For RTS unit testing only.
 #[cfg(not(feature = "ic"))]
-static mut TEST_GC_STATE: State = State {
-    phase: Phase::Pause,
-    partitioned_heap: partitioned_heap::UNINITIALIZED_HEAP,
-    allocation_count: 0,
-    mark_state: None,
-    iterator_state: None,
-};
+static mut TEST_GC_STATE: State = UNINITIALIZED_STATE;
 
 // For RTS unit testing only.
 #[cfg(not(feature = "ic"))]
diff --git a/rts/motoko-rts/src/gc/incremental/partitioned_heap.rs b/rts/motoko-rts/src/gc/incremental/partitioned_heap.rs
index 2a48e1f5e6f..a7b8c5653f8 100644
--- a/rts/motoko-rts/src/gc/incremental/partitioned_heap.rs
+++ b/rts/motoko-rts/src/gc/incremental/partitioned_heap.rs
@@ -88,9 +88,7 @@ pub struct Partition {
     update: bool,        // Specifies whether the pointers in the partition have to be updated.
 }
 
-/// For RTS unit testing only.
 /// Optimization: Avoiding `Option` or `Lazy`.
-#[cfg(not(feature = "ic"))]
 const UNINITIALIZED_PARTITION: Partition = Partition {
     index: usize::MAX,
     free: false,
@@ -364,9 +362,7 @@ pub struct PartitionedHeap {
     precomputed_heap_size: usize, // Occupied heap size, excluding the dynamic heap in the allocation partition.
 }
 
-/// For RTS unit testing only.
 /// Optimization: Avoiding `Option` or `LazyCell`.
-#[cfg(not(feature = "ic"))]
 pub const UNINITIALIZED_HEAP: PartitionedHeap = PartitionedHeap {
     partitions: [UNINITIALIZED_PARTITION; MAX_PARTITIONS],
     heap_base: 0,
diff --git a/rts/motoko-rts/src/gc/mark_compact/bitmap.rs b/rts/motoko-rts/src/gc/mark_compact/bitmap.rs
deleted file mode 100644
index dc86885489a..00000000000
--- a/rts/motoko-rts/src/gc/mark_compact/bitmap.rs
+++ /dev/null
@@ -1,201 +0,0 @@
-use crate::mem_utils::memzero;
-use crate::memory::{alloc_blob, Memory};
-use crate::types::{size_of, Blob, Bytes, Obj};
-
-/* How the Wasm-heap maps to the bitmap
-
-  +---- RTS stack ----+---- Motoko statics ----+---- Dynamic heap ------+ Heap limit
-                  (prefix words)                   bitmap lives here -> | BM |
-                                                                       /      \
-                                                                      /        \
-                                       each bit represents a word -> /...bits...\
-                                          in the dynamic heap
-
-## Marking with absolute addresses
-
-When marking, we need to map an address to a bit in the bitmap. Internally the
-bitmap is kept in a (non-moving) blob after the dynamic heap (DH). To
-efficiently mark the right bit in the bitmap, we maintain a pointer that points
-_before the start of the bitmap_ such that `address / 8` and `address % 8`
-will address the right bit:
-
-
-       +---- BITMAP_FORBIDDEN_PTR         +---- BITMAP_PTR
-       v                                  v
-       ,          (forbidden)             ,...................... bitmap ..........~~....,
-       |   heap_prefix_words / 8 bytes    |               heap_size / 32 bytes           |
-       |   get_bitmap_forbidden_size()    |                   BITMAP_SIZE                |
-       ^                                  ^                                              ^
-      /           ^^^^^^^^^^^              \                                             |
-     /            corresponds               \                 ^^^^^^^^^^^               /
-    /                                        \                corresponds              /
-   /                                          \                                       /
-  +---- Rts stack ----+---- Motoko statics ----+--------- Dynamic heap ----------~~--+
-                                               !
-                                               ! 32-byte aligned
-
-
-Debug assertions guard the forbidden bytes from access, as this area potentially
-overlaps with the Motoko dynamic heap.
-
-## The alignment caveat
-
-For this scheme to work, it is essential that the start of the DH is an address that
-is divisible by 32 (`heap_prefix_words % 8 == 0`). Otherwise the `address / 8`
-and `address % 8` operations on the DH's starting address will not yield the
-least significant bit in the BM.
-
-## Example calculation
-
-Assume the DH is at 0x80000. Assume heap limit being at 0xB0000. Then the BM thus
-could be placed at 0xB0008. Since the heap_prefix_words is 0x20000,
-BITMAP_FORBIDDEN_PTR = 0xB0008 - 0x20000 / 8 = 0xAC008.
-
-Now let's mark the address 0x80548 in the DH. Its absolute word number is 0x20152.
-The `(0x20152 / 8, 0x20152 % 8)`-rule gives a bit position 2 with byte offset 0x402A,
-thus we mark bit 2 in byte 0xAC004 + 0x402A = 0xB002E, which is in the BM.
-
- */
-
-/// Current bitmap
-static mut BITMAP_FORBIDDEN_PTR: *mut u8 = core::ptr::null_mut();
-static mut BITMAP_PTR: *mut u8 = core::ptr::null_mut();
-static mut BITMAP_SIZE: u32 = 0;
-
-unsafe fn get_bitmap_forbidden_size() -> usize {
-    BITMAP_PTR as usize - BITMAP_FORBIDDEN_PTR as usize
-}
-
-pub unsafe fn alloc_bitmap<M: Memory>(mem: &mut M, heap_size: Bytes<u32>, heap_prefix_words: u32) {
-    // See Note "How the Wasm-heap maps to the bitmap" above
-    debug_assert_eq!(heap_prefix_words % 8, 0);
-    // We will have at most this many objects in the heap, each requiring a bit
-    let n_bits = heap_size.to_words().as_u32();
-    // Each byte will hold 8 bits.
-    BITMAP_SIZE = (n_bits + 7) / 8;
-    // Also round allocation up to 8-bytes to make iteration efficient. We want to be able to read
-    // 64 bits in a single read and check as many bits as possible with a single `word != 0`.
-    let bitmap_bytes = Bytes(((BITMAP_SIZE + 7) / 8) * 8);
-    // Allocating an actual object here as otherwise dump_heap gets confused
-    // No post allocation barrier as this RTS-internal blob will be collected by the GC.
-    let blob = alloc_blob(mem, bitmap_bytes).get_ptr() as *mut Blob;
-    memzero(blob.payload_addr() as usize, bitmap_bytes.to_words());
-
-    BITMAP_PTR = blob.payload_addr();
-    BITMAP_FORBIDDEN_PTR = BITMAP_PTR.sub(heap_prefix_words as usize / 8)
-}
-
-pub unsafe fn free_bitmap() {
-    BITMAP_PTR = core::ptr::null_mut();
-    BITMAP_FORBIDDEN_PTR = core::ptr::null_mut();
-    BITMAP_SIZE = 0;
-}
-
-pub unsafe fn get_bit(idx: u32) -> bool {
-    let (byte_idx, bit_idx) = (idx / 8, idx % 8);
-    debug_assert!(byte_idx as usize >= get_bitmap_forbidden_size());
-    debug_assert!(get_bitmap_forbidden_size() + BITMAP_SIZE as usize > byte_idx as usize);
-    let byte = *BITMAP_FORBIDDEN_PTR.add(byte_idx as usize);
-    (byte >> bit_idx) & 0b1 != 0
-}
-
-pub unsafe fn set_bit(idx: u32) {
-    let (byte_idx, bit_idx) = (idx / 8, idx % 8);
-    debug_assert!(byte_idx as usize >= get_bitmap_forbidden_size());
-    debug_assert!(get_bitmap_forbidden_size() + BITMAP_SIZE as usize > byte_idx as usize);
-    let byte = *BITMAP_FORBIDDEN_PTR.add(byte_idx as usize);
-    let new_byte = byte | (0b1 << bit_idx);
-    *BITMAP_FORBIDDEN_PTR.add(byte_idx as usize) = new_byte;
-}
-
-pub struct BitmapIter {
-    /// Size of the bitmap, in bits. Does not change after initialization.
-    size: u32,
-    /// Current bit index
-    current_bit_idx: u32,
-    /// Current 64-bit word in the bitmap that we're iterating. We read in 64-bit chunks to be able
-    /// to check as many bits as possible with a single `word != 0`.
-    current_word: u64,
-    /// How many leading bits are initially zeroed in the current_word
-    leading_zeros: u32,
-}
-
-pub unsafe fn iter_bits() -> BitmapIter {
-    let blob_len_bytes = (BITMAP_PTR.sub(size_of::<Blob>().to_bytes().as_usize()) as *mut Obj)
-        .as_blob()
-        .len()
-        .as_u32();
-
-    debug_assert_eq!(blob_len_bytes % 8, 0);
-
-    let blob_len_64bit_words = blob_len_bytes / 8;
-
-    let current_word = if blob_len_64bit_words == 0 {
-        0
-    } else {
-        let bitmap_ptr64 = BITMAP_PTR as *const u64;
-        bitmap_ptr64.read_unaligned()
-    };
-
-    debug_assert!(BITMAP_PTR as usize >= BITMAP_FORBIDDEN_PTR as usize);
-    let forbidden_bits = get_bitmap_forbidden_size() as u32 * 8;
-
-    BitmapIter {
-        size: blob_len_bytes * 8 + forbidden_bits,
-        current_bit_idx: forbidden_bits,
-        current_word,
-        leading_zeros: current_word.leading_zeros(),
-    }
-}
-
-/// This value marks the end-of-stream in `BitmapIter`. Using this value instead of `None` for
-/// end-of-stream reduces Wasm instructions executed by ~2.7% in some cases.
-//
-// Heap is 4GiB and each 32-bit word gets a bit, so this is one larger than the bit for the last
-// word in heap.
-//
-// (We actually need less bits than that as when the heap is full we can't allocate bitmap and mark
-// stack and can't do GC)
-pub const BITMAP_ITER_END: u32 = u32::MAX;
-
-impl BitmapIter {
-    /// Returns the next bit, or `BITMAP_ITER_END` if there are no more bits set.
-    pub fn next(&mut self) -> u32 {
-        debug_assert!(self.current_bit_idx <= self.size);
-
-        if self.current_bit_idx == self.size {
-            return BITMAP_ITER_END;
-        }
-
-        // Outer loop iterates 64-bit words
-        loop {
-            // Examine the least significant bit(s) in the current word
-            if self.current_word != 0 {
-                let shift_amt = self.current_word.trailing_zeros();
-                self.current_word >>= shift_amt;
-                self.current_word >>= 1;
-                let bit_idx = self.current_bit_idx + shift_amt;
-                self.current_bit_idx = bit_idx + 1;
-                return bit_idx;
-            }
-
-            // Move on to next word (always 64-bit boundary)
-            self.current_bit_idx += self.leading_zeros;
-            unsafe {
-                debug_assert_eq!(
-                    (self.current_bit_idx - get_bitmap_forbidden_size() as u32 * 8) % 64,
-                    0
-                )
-            }
-            if self.current_bit_idx == self.size {
-                return BITMAP_ITER_END;
-            }
-            self.current_word = unsafe {
-                let ptr64 =
-                    BITMAP_FORBIDDEN_PTR.add(self.current_bit_idx as usize / 8) as *const u64;
-                ptr64.read_unaligned()
-            };
-            self.leading_zeros = self.current_word.leading_zeros();
-        }
-    }
-}
diff --git a/rts/motoko-rts/src/gc/mark_compact/mark_stack.rs b/rts/motoko-rts/src/gc/mark_compact/mark_stack.rs
deleted file mode 100644
index 990cf32ff25..00000000000
--- a/rts/motoko-rts/src/gc/mark_compact/mark_stack.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-//! A stack for marking heap objects (for GC). There should be no allocation after the stack
-//! otherwise things will break as we push. This invariant is checked in debug builds.
-
-use crate::memory::{alloc_blob, Memory};
-use crate::types::{Blob, Tag, Words};
-
-use core::ptr::null_mut;
-
-/// Initial stack size
-pub const INIT_STACK_SIZE: Words<u32> = Words(64);
-
-/// Pointer to the `blob` object for the mark stack. Used to get the capacity of the stack.
-static mut STACK_BLOB_PTR: *mut Blob = null_mut();
-
-/// Bottom of the mark stack
-pub static mut STACK_BASE: *mut usize = null_mut();
-
-/// Top of the mark stack
-pub static mut STACK_TOP: *mut usize = null_mut();
-
-/// Next free slot in the mark stack
-pub static mut STACK_PTR: *mut usize = null_mut();
-
-pub unsafe fn alloc_mark_stack<M: Memory>(mem: &mut M) {
-    debug_assert!(STACK_BLOB_PTR.is_null());
-
-    // Allocating an actual object here to not break dump_heap
-    // No post allocation barrier as this RTS-internal blob will be collected by the GC.
-    STACK_BLOB_PTR = alloc_blob(mem, INIT_STACK_SIZE.to_bytes()).get_ptr() as *mut Blob;
-    STACK_BASE = STACK_BLOB_PTR.payload_addr() as *mut usize;
-    STACK_PTR = STACK_BASE;
-    STACK_TOP = STACK_BASE.add(INIT_STACK_SIZE.as_usize());
-}
-
-pub unsafe fn free_mark_stack() {
-    STACK_BLOB_PTR = null_mut();
-    STACK_BASE = null_mut();
-    STACK_PTR = null_mut();
-    STACK_TOP = null_mut();
-}
-
-/// Doubles the stack size
-pub unsafe fn grow_stack<M: Memory>(mem: &mut M) {
-    let stack_cap: Words<u32> = STACK_BLOB_PTR.len().to_words();
-    let p = mem.alloc_words(stack_cap).get_ptr() as *mut usize;
-
-    // Make sure nothing was allocated after the stack
-    debug_assert_eq!(STACK_TOP, p);
-
-    let new_cap: Words<u32> = stack_cap * 2;
-    (*STACK_BLOB_PTR).len = new_cap.to_bytes();
-    STACK_TOP = STACK_BASE.add(new_cap.as_usize());
-}
-
-pub unsafe fn push_mark_stack<M: Memory>(mem: &mut M, obj: usize, obj_tag: Tag) {
-    // We add 2 words in a push, and `STACK_PTR` and `STACK_TOP` are both multiples of 2, so we can
-    // do simple equality check here
-    if STACK_PTR == STACK_TOP {
-        grow_stack(mem);
-    }
-
-    *STACK_PTR = obj;
-    *STACK_PTR.add(1) = obj_tag as usize;
-    STACK_PTR = STACK_PTR.add(2);
-}
-
-pub unsafe fn pop_mark_stack() -> Option<(usize, Tag)> {
-    if STACK_PTR == STACK_BASE {
-        return None;
-    }
-    STACK_PTR = STACK_PTR.sub(2);
-    let p = *STACK_PTR;
-    let tag = *STACK_PTR.add(1);
-    return Some((p, tag as u32));
-}
diff --git a/rts/motoko-rts/src/memory/ic.rs b/rts/motoko-rts/src/memory/ic.rs
index 135a0f4ad3f..7e466595e0d 100644
--- a/rts/motoko-rts/src/memory/ic.rs
+++ b/rts/motoko-rts/src/memory/ic.rs
@@ -5,17 +5,8 @@ pub mod partitioned_memory;
 use super::Memory;
 use crate::constants::WASM_PAGE_SIZE;
 use crate::rts_trap_with;
-use crate::types::Bytes;
 use core::arch::wasm32;
 
-/// Maximum live data retained in a GC.
-pub(crate) static mut MAX_LIVE: Bytes<u32> = Bytes(0);
-
-#[no_mangle]
-unsafe extern "C" fn get_max_live_size() -> Bytes<u32> {
-    MAX_LIVE
-}
-
 /// Provides a `Memory` implementation, to be used in functions compiled for IC or WASI. The
 /// `Memory` implementation allocates in Wasm heap with Wasm `memory.grow` instruction.
 pub struct IcMemory;
diff --git a/rts/motoko-rts/src/memory/ic/partitioned_memory.rs b/rts/motoko-rts/src/memory/ic/partitioned_memory.rs
index acf16a48132..8ec4ec5fe55 100644
--- a/rts/motoko-rts/src/memory/ic/partitioned_memory.rs
+++ b/rts/motoko-rts/src/memory/ic/partitioned_memory.rs
@@ -16,6 +16,11 @@ pub unsafe extern "C" fn get_heap_size() -> Bytes<u32> {
     crate::gc::incremental::get_partitioned_heap().occupied_size()
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn get_max_live_size() -> Bytes<u32> {
+    crate::gc::incremental::get_max_live_size()
+}
+
 impl Memory for IcMemory {
     #[inline]
     unsafe fn alloc_words(&mut self, n: Words<u32>) -> Value {
diff --git a/rts/motoko-rts/src/persistence.rs b/rts/motoko-rts/src/persistence.rs
index 06af1dc9126..0bbd4a14118 100644
--- a/rts/motoko-rts/src/persistence.rs
+++ b/rts/motoko-rts/src/persistence.rs
@@ -6,7 +6,7 @@ use motoko_rts_macros::ic_mem_fn;
 
 use crate::{
     barriers::{allocation_barrier, write_with_barrier},
-    gc::incremental::State,
+    gc::incremental::{State, UNINITIALIZED_STATE},
     memory::Memory,
     types::{size_of, Null, Value, TAG_NULL},
 };
@@ -81,6 +81,7 @@ impl PersistentMetadata {
         (*self).version = VERSION;
         (*self).stable_actor = DEFAULT_VALUE;
         (*self).null_singleton = alloc_null(mem);
+        (*self).incremental_gc_state = UNINITIALIZED_STATE;
     }
 }
 

From f9e87886f1a7fd146f6288d83f98782df48af104 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Wed, 16 Aug 2023 13:51:22 +0200
Subject: [PATCH 032/260] Code refactoring

---
 rts/motoko-rts/src/gc/incremental.rs          | 14 ++---
 rts/motoko-rts/src/memory/ic.rs               | 61 +++++++++++++------
 .../src/memory/ic/partitioned_memory.rs       | 34 -----------
 3 files changed, 51 insertions(+), 58 deletions(-)
 delete mode 100644 rts/motoko-rts/src/memory/ic/partitioned_memory.rs

diff --git a/rts/motoko-rts/src/gc/incremental.rs b/rts/motoko-rts/src/gc/incremental.rs
index dbe257dd8c6..0d496d4a7f1 100644
--- a/rts/motoko-rts/src/gc/incremental.rs
+++ b/rts/motoko-rts/src/gc/incremental.rs
@@ -71,20 +71,20 @@ unsafe fn incremental_gc<M: Memory>(mem: &mut M) {
 #[cfg(feature = "ic")]
 unsafe fn should_start() -> bool {
     use self::partitioned_heap::PARTITION_SIZE;
-    use crate::memory::ic::partitioned_memory;
+    use crate::memory::ic;
 
     const CRITICAL_HEAP_LIMIT: Bytes<u32> = Bytes(u32::MAX - 768 * 1024 * 1024);
     const CRITICAL_GROWTH_THRESHOLD: f64 = 0.01;
     const NORMAL_GROWTH_THRESHOLD: f64 = 0.65;
 
-    let heap_size = partitioned_memory::get_heap_size();
+    let heap_size = ic::get_heap_size();
     let growth_threshold = if heap_size > CRITICAL_HEAP_LIMIT {
         CRITICAL_GROWTH_THRESHOLD
     } else {
         NORMAL_GROWTH_THRESHOLD
     };
 
-    let current_allocations = partitioned_memory::get_total_allocations();
+    let current_allocations = ic::get_total_allocations();
     let state = get_incremental_gc_state();
     debug_assert!(current_allocations >= state.statistics.last_allocations);
     let absolute_growth = current_allocations - state.statistics.last_allocations;
@@ -94,18 +94,18 @@ unsafe fn should_start() -> bool {
 
 #[cfg(feature = "ic")]
 unsafe fn record_gc_start<M: Memory>() {
-    use crate::memory::ic::partitioned_memory;
+    use crate::memory::ic;
 
     let state = get_incremental_gc_state();
-    state.statistics.last_allocations = partitioned_memory::get_total_allocations();
+    state.statistics.last_allocations = ic::get_total_allocations();
 }
 
 #[cfg(feature = "ic")]
 unsafe fn record_gc_stop<M: Memory>() {
-    use crate::memory::ic::partitioned_memory;
+    use crate::memory::ic;
     use crate::persistence::HEAP_START;
 
-    let heap_size = partitioned_memory::get_heap_size();
+    let heap_size = ic::get_heap_size();
     let static_size = Bytes(HEAP_START as u32);
     debug_assert!(heap_size >= static_size);
     let dynamic_size = heap_size - static_size;
diff --git a/rts/motoko-rts/src/memory/ic.rs b/rts/motoko-rts/src/memory/ic.rs
index 7e466595e0d..97b05269b5c 100644
--- a/rts/motoko-rts/src/memory/ic.rs
+++ b/rts/motoko-rts/src/memory/ic.rs
@@ -1,31 +1,58 @@
 // This module is only enabled when compiling the RTS for IC or WASI.
 
-pub mod partitioned_memory;
-
 use super::Memory;
 use crate::constants::WASM_PAGE_SIZE;
 use crate::rts_trap_with;
+use crate::types::{Bytes, Value, Words};
 use core::arch::wasm32;
 
 /// Provides a `Memory` implementation, to be used in functions compiled for IC or WASI. The
 /// `Memory` implementation allocates in Wasm heap with Wasm `memory.grow` instruction.
 pub struct IcMemory;
 
-/// Page allocation. Ensures that the memory up to, but excluding, the given pointer is allocated,
-/// with the slight exception of not allocating the extra page for address 0xFFFF_0000.
-unsafe fn grow_memory(ptr: u64) {
-    debug_assert_eq!(0xFFFF_0000, usize::MAX - WASM_PAGE_SIZE.as_usize() + 1);
-    if ptr > 0xFFFF_0000 {
-        // spare the last wasm memory page
-        rts_trap_with("Cannot grow memory")
-    };
-    let page_size = u64::from(WASM_PAGE_SIZE.as_u32());
-    let total_pages_needed = ((ptr + page_size - 1) / page_size) as usize;
-    let current_pages = wasm32::memory_size(0);
-    if total_pages_needed > current_pages {
-        if wasm32::memory_grow(0, total_pages_needed - current_pages) == core::usize::MAX {
-            // replica signals that there is not enough memory
-            rts_trap_with("Cannot grow memory");
+impl Memory for IcMemory {
+    #[inline]
+    unsafe fn alloc_words(&mut self, n: Words<u32>) -> Value {
+        crate::gc::incremental::get_partitioned_heap().allocate(self, n)
+    }
+
+    /// Page allocation. Ensures that the memory up to, but excluding, the given pointer is allocated,
+    /// with the slight exception of not allocating the extra page for address 0xFFFF_0000.
+    #[inline(never)]
+    unsafe fn grow_memory(&mut self, ptr: u64) {
+        debug_assert_eq!(0xFFFF_0000, usize::MAX - WASM_PAGE_SIZE.as_usize() + 1);
+        if ptr > 0xFFFF_0000 {
+            // spare the last wasm memory page
+            rts_trap_with("Cannot grow memory")
+        };
+        let page_size = u64::from(WASM_PAGE_SIZE.as_u32());
+        let total_pages_needed = ((ptr + page_size - 1) / page_size) as usize;
+        let current_pages = wasm32::memory_size(0);
+        if total_pages_needed > current_pages {
+            if wasm32::memory_grow(0, total_pages_needed - current_pages) == core::usize::MAX {
+                // replica signals that there is not enough memory
+                rts_trap_with("Cannot grow memory");
+            }
         }
     }
 }
+
+#[no_mangle]
+unsafe extern "C" fn get_reclaimed() -> Bytes<u64> {
+    crate::gc::incremental::get_partitioned_heap().reclaimed_size()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn get_total_allocations() -> Bytes<u64> {
+    Bytes(u64::from(get_heap_size().as_u32())) + get_reclaimed()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn get_heap_size() -> Bytes<u32> {
+    crate::gc::incremental::get_partitioned_heap().occupied_size()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn get_max_live_size() -> Bytes<u32> {
+    crate::gc::incremental::get_max_live_size()
+}
diff --git a/rts/motoko-rts/src/memory/ic/partitioned_memory.rs b/rts/motoko-rts/src/memory/ic/partitioned_memory.rs
deleted file mode 100644
index 8ec4ec5fe55..00000000000
--- a/rts/motoko-rts/src/memory/ic/partitioned_memory.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-use super::{IcMemory, Memory};
-use crate::types::*;
-
-#[no_mangle]
-unsafe extern "C" fn get_reclaimed() -> Bytes<u64> {
-    crate::gc::incremental::get_partitioned_heap().reclaimed_size()
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn get_total_allocations() -> Bytes<u64> {
-    Bytes(u64::from(get_heap_size().as_u32())) + get_reclaimed()
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn get_heap_size() -> Bytes<u32> {
-    crate::gc::incremental::get_partitioned_heap().occupied_size()
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn get_max_live_size() -> Bytes<u32> {
-    crate::gc::incremental::get_max_live_size()
-}
-
-impl Memory for IcMemory {
-    #[inline]
-    unsafe fn alloc_words(&mut self, n: Words<u32>) -> Value {
-        crate::gc::incremental::get_partitioned_heap().allocate(self, n)
-    }
-
-    #[inline(never)]
-    unsafe fn grow_memory(&mut self, ptr: u64) {
-        super::grow_memory(ptr);
-    }
-}

From e1d5fc1ec5938e85bce47e4caf93c953022ddeda Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Wed, 16 Aug 2023 15:20:40 +0200
Subject: [PATCH 033/260] Update .gitignore

---
 rts/.gitignore | 2 --
 1 file changed, 2 deletions(-)

diff --git a/rts/.gitignore b/rts/.gitignore
index 5099a3e57b9..31939c72d62 100644
--- a/rts/.gitignore
+++ b/rts/.gitignore
@@ -1,5 +1,3 @@
 mo-rts.wasm
 mo-rts-debug.wasm
-mo-rts-incremental.wasm
-mo-rts-incremental-debug.wasm
 _build

From 79d0f79158b44c29c94f6bb382d4cf2003eb914d Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 17 Aug 2023 10:15:30 +0200
Subject: [PATCH 034/260] Use specific IC branch that retains the heap on
 upgrade

---
 nix/sources.json | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/nix/sources.json b/nix/sources.json
index d17eccb4c6a..7f246f6e526 100644
--- a/nix/sources.json
+++ b/nix/sources.json
@@ -21,16 +21,15 @@
         "version": "3.2.25"
     },
     "ic": {
-        "branch": "master",
-        "builtin": false,
+        "branch": "luc/stable-heap-on-release",
         "description": "Internet Computer blockchain source: the client/replica software run by nodes",
         "homepage": "",
-        "owner": "dfinity",
+        "owner": "luc-blaeser",
         "repo": "ic",
-        "rev": "629f7fc8e82ff52e6373a528dcd29f9066563ad4",
-        "sha256": "1jadgk4jfgvkw3i5nlxikg0wi6144d46sca165g9xgqpsr8hkm00",
+        "rev": "af7331a313bc76a12d0d8bb9e6f8ddc72c2a6b5d",
+        "sha256": "1w66vfsk9cvvcdlhhsiyf4zqms9l0mkmfpkdmwlpdjcs1ikjf1bb",
         "type": "tarball",
-        "url": "https://github.com/dfinity/ic/archive/629f7fc8e82ff52e6373a528dcd29f9066563ad4.tar.gz",
+        "url": "https://github.com/luc-blaeser/ic/archive/af7331a313bc76a12d0d8bb9e6f8ddc72c2a6b5d.tar.gz",
         "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
     },
     "ic-hs": {

From d67e4bdca2f54c189a2c1017263f9e4bce57c49b Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 17 Aug 2023 10:32:58 +0200
Subject: [PATCH 035/260] Add missing constant materialization

---
 src/codegen/compile.ml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index a3e7c42afb1..25ed24a3031 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -7076,6 +7076,7 @@ module StackRep = struct
     | Const _ | Unreachable -> G.nop
 
   let rec materialize_constant env = function
+    | Const.Lit (Const.Vanilla l) -> compile_unboxed_const l
     | Const.Lit (Const.Bool b) -> Bool.lit b
     | Const.Lit (Const.Blob t) -> Blob.lit env t
     | Const.Lit (Const.Null) -> Opt.null_lit env
@@ -7088,6 +7089,7 @@ module StackRep = struct
     | Const.Message fi -> assert false
     | Const.Unit -> Tuple.compile_unit
     | Const.Tag (i, c) -> Variant.inject env i (materialize_constant env c)
+    | Const.Array cs -> Arr.lit env (List.map (fun c -> materialize_constant env c) cs)
     | _ -> assert false
 
   let adjust env (sr_in : t) sr_out =

From 755e3cdc65b4a329c5b65326a5e63eccd666b314 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 17 Aug 2023 15:19:28 +0200
Subject: [PATCH 036/260] Create the null object after memory initialization

---
 rts/motoko-rts-tests/src/bigint.rs            |  8 +--
 .../src/continuation_table.rs                 | 13 ++--
 rts/motoko-rts-tests/src/crc32.rs             |  8 ++-
 rts/motoko-rts-tests/src/gc.rs                | 14 ++---
 rts/motoko-rts-tests/src/memory.rs            | 15 ++++-
 rts/motoko-rts-tests/src/principal_id.rs      |  8 ++-
 rts/motoko-rts-tests/src/stream.rs            |  8 ++-
 rts/motoko-rts-tests/src/text.rs              |  6 +-
 rts/motoko-rts/src/gc/incremental.rs          | 59 ++++++++++---------
 .../src/gc/incremental/partitioned_heap.rs    | 27 ---------
 rts/motoko-rts/src/persistence.rs             | 25 ++++++--
 11 files changed, 96 insertions(+), 95 deletions(-)

diff --git a/rts/motoko-rts-tests/src/bigint.rs b/rts/motoko-rts-tests/src/bigint.rs
index c37dac2b824..2bf93a7dde8 100644
--- a/rts/motoko-rts-tests/src/bigint.rs
+++ b/rts/motoko-rts-tests/src/bigint.rs
@@ -1,8 +1,8 @@
-use crate::memory::TestMemory;
+use crate::memory::{initialize_test_memory, reset_test_memory, TestMemory};
 
 use motoko_rts::bigint::{self, *};
 use motoko_rts::buf::Buf;
-use motoko_rts::types::{Bytes, Value, Words};
+use motoko_rts::types::{Bytes, Value};
 
 // mp functions below are implemented separately for tests as we can't modify mp_int source code to
 // pass a generic heap argument (then monomorphise it for IC).
@@ -27,8 +27,7 @@ unsafe extern "C" fn mp_realloc(
 pub unsafe fn test() {
     println!("Testing BigInt ...");
 
-    // Not sure how much we will need in these tests but 1G should be enough
-    let mut heap = TestMemory::new(Words(1024 * 1024));
+    let mut heap = initialize_test_memory();
     HEAP = &mut heap;
 
     assert!(bigint_eq(
@@ -63,6 +62,7 @@ pub unsafe fn test() {
     }
 
     HEAP = std::ptr::null_mut();
+    reset_test_memory();
     drop(heap);
 }
 
diff --git a/rts/motoko-rts-tests/src/continuation_table.rs b/rts/motoko-rts-tests/src/continuation_table.rs
index 877eb4714c7..2decbfd0aae 100644
--- a/rts/motoko-rts-tests/src/continuation_table.rs
+++ b/rts/motoko-rts-tests/src/continuation_table.rs
@@ -1,12 +1,12 @@
 use std::array::from_fn;
 
-use crate::memory::TestMemory;
+use crate::memory::{initialize_test_memory, reset_test_memory};
 
 use motoko_rts::continuation_table::{
     continuation_count, recall_continuation, remember_continuation,
 };
 use motoko_rts::memory::alloc_blob;
-use motoko_rts::types::{size_of, Array, Blob, Bytes, Value, Words};
+use motoko_rts::types::{Bytes, Value};
 
 pub unsafe fn test() {
     println!("Testing continuation table ...");
@@ -15,12 +15,7 @@ pub unsafe fn test() {
 
     const N: usize = 2000; // >256, to exercise `double_continuation_table`
 
-    // Array will be doubled 3 times, so 256 + 512 + 1024 + 2048 = 3840 words, plus each array will
-    // have an array header. Also add the set of N pointers to empty blobs.
-    let mut heap = TestMemory::new(Words(
-        3840 + 4 * size_of::<Array>().to_bytes().as_u32()
-            + N as u32 * size_of::<Blob>().to_bytes().as_u32(),
-    ));
+    let mut heap = initialize_test_memory();
 
     let pointers: [Value; N] = from_fn(|_| alloc_blob(&mut heap, Bytes(0)));
 
@@ -48,4 +43,6 @@ pub unsafe fn test() {
         );
         assert_eq!(continuation_count(), i as u32);
     }
+
+    reset_test_memory();
 }
diff --git a/rts/motoko-rts-tests/src/crc32.rs b/rts/motoko-rts-tests/src/crc32.rs
index 167c46d6fc1..dc40f8352e8 100644
--- a/rts/motoko-rts-tests/src/crc32.rs
+++ b/rts/motoko-rts-tests/src/crc32.rs
@@ -1,13 +1,13 @@
-use crate::memory::TestMemory;
+use crate::memory::{initialize_test_memory, reset_test_memory};
 
 use motoko_rts::principal_id::{base32_of_checksummed_blob, base32_to_blob};
 use motoko_rts::text::{text_compare, text_of_ptr_size};
-use motoko_rts::types::{Bytes, Words};
+use motoko_rts::types::Bytes;
 
 pub unsafe fn test() {
     println!("Testing crc32 ...");
 
-    let mut heap = TestMemory::new(Words(1024 * 1024));
+    let mut heap = initialize_test_memory();
 
     //
     // Encoding
@@ -78,4 +78,6 @@ pub unsafe fn test() {
         ),
         0
     );
+
+    reset_test_memory();
 }
diff --git a/rts/motoko-rts-tests/src/gc.rs b/rts/motoko-rts-tests/src/gc.rs
index 295ffe78c7a..7f903700fbe 100644
--- a/rts/motoko-rts-tests/src/gc.rs
+++ b/rts/motoko-rts-tests/src/gc.rs
@@ -147,10 +147,11 @@ fn test_gc(
 
 fn initialize_gc(heap: &mut MotokoHeap) {
     use motoko_rts::gc::incremental::{
-        get_incremental_gc_state, get_partitioned_heap, IncrementalGC,
+        get_partitioned_heap, set_incremental_gc_state, IncrementalGC,
     };
     unsafe {
-        IncrementalGC::initialize(heap, get_incremental_gc_state(), heap.heap_base_address());
+        let state = IncrementalGC::initial_gc_state(heap, heap.heap_base_address());
+        set_incremental_gc_state(Some(state));
         let allocation_size = heap.heap_ptr_address() - heap.heap_base_address();
 
         // Synchronize the partitioned heap with one big combined allocation by starting from the base pointer as the heap pointer.
@@ -163,14 +164,9 @@ fn initialize_gc(heap: &mut MotokoHeap) {
 }
 
 fn reset_gc() {
-    use crate::memory::TestMemory;
-    use motoko_rts::gc::incremental::{
-        get_incremental_gc_state, partitioned_heap::PARTITION_SIZE, IncrementalGC,
-    };
-
-    let mut memory = TestMemory::new(Words(PARTITION_SIZE as u32));
+    use motoko_rts::gc::incremental::set_incremental_gc_state;
     unsafe {
-        IncrementalGC::initialize(&mut memory, get_incremental_gc_state(), 0);
+        set_incremental_gc_state(None);
     }
 }
 
diff --git a/rts/motoko-rts-tests/src/memory.rs b/rts/motoko-rts-tests/src/memory.rs
index 9f725a015b8..7e1280a9ae0 100644
--- a/rts/motoko-rts-tests/src/memory.rs
+++ b/rts/motoko-rts-tests/src/memory.rs
@@ -1,5 +1,7 @@
+use motoko_rts::gc::incremental::partitioned_heap::PARTITION_SIZE;
+use motoko_rts::gc::incremental::{set_incremental_gc_state, IncrementalGC};
 use motoko_rts::memory::Memory;
-use motoko_rts::types::{Value, Words};
+use motoko_rts::types::{Bytes, Value, Words};
 
 pub struct TestMemory {
     heap: Box<[u8]>,
@@ -59,3 +61,14 @@ impl Memory for TestMemory {
         }
     }
 }
+
+pub unsafe fn initialize_test_memory() -> TestMemory {
+    let mut memory = TestMemory::new(Bytes(PARTITION_SIZE as u32).to_words());
+    let state = IncrementalGC::initial_gc_state(&mut memory, 0);
+    set_incremental_gc_state(Some(state));
+    memory
+}
+
+pub unsafe fn reset_test_memory() {
+    set_incremental_gc_state(None);
+}
diff --git a/rts/motoko-rts-tests/src/principal_id.rs b/rts/motoko-rts-tests/src/principal_id.rs
index be37cb33d5b..8c9a8d3eb99 100644
--- a/rts/motoko-rts-tests/src/principal_id.rs
+++ b/rts/motoko-rts-tests/src/principal_id.rs
@@ -1,13 +1,13 @@
-use crate::memory::TestMemory;
+use crate::memory::{initialize_test_memory, reset_test_memory};
 
 use motoko_rts::principal_id::{blob_of_principal, principal_of_blob};
 use motoko_rts::text::{text_compare, text_of_ptr_size, text_of_str};
-use motoko_rts::types::{Bytes, Words};
+use motoko_rts::types::Bytes;
 
 pub unsafe fn test() {
     println!("Testing principal id encoding ...");
 
-    let mut heap = TestMemory::new(Words(1024 * 1024));
+    let mut heap = initialize_test_memory();
 
     //
     // Encoding
@@ -46,4 +46,6 @@ pub unsafe fn test() {
         ),
         0
     );
+
+    reset_test_memory();
 }
diff --git a/rts/motoko-rts-tests/src/stream.rs b/rts/motoko-rts-tests/src/stream.rs
index f830ee10e81..fcff8036779 100644
--- a/rts/motoko-rts-tests/src/stream.rs
+++ b/rts/motoko-rts-tests/src/stream.rs
@@ -1,14 +1,14 @@
 //! Stream tests
 
-use crate::memory::TestMemory;
+use crate::memory::{initialize_test_memory, reset_test_memory};
 
 use motoko_rts::stream::alloc_stream;
-use motoko_rts::types::{size_of, Blob, Bytes, Stream, Value, Words};
+use motoko_rts::types::{size_of, Blob, Bytes, Stream, Value};
 
 pub unsafe fn test() {
     println!("Testing streaming ...");
 
-    let mut mem = TestMemory::new(Words(1024 * 1024));
+    let mut mem = initialize_test_memory();
 
     const STREAM_SMALL_SIZE: u32 = 60;
 
@@ -87,4 +87,6 @@ pub unsafe fn test() {
     assert_eq!(WRITTEN, Bytes(STREAM_LARGE_SIZE + STREAM_RESERVE_SIZE1)); // all at once
     stream.shutdown();
     assert_eq!(WRITTEN, Bytes(STREAM_LARGE_SIZE + STREAM_RESERVE_SIZE1 + 1)); // u8 too
+
+    reset_test_memory();
 }
diff --git a/rts/motoko-rts-tests/src/text.rs b/rts/motoko-rts-tests/src/text.rs
index 3fbbc3d8e0c..5a08d9f384a 100644
--- a/rts/motoko-rts-tests/src/text.rs
+++ b/rts/motoko-rts-tests/src/text.rs
@@ -1,6 +1,6 @@
 //! Text and text iterator tests
 
-use crate::memory::TestMemory;
+use crate::memory::{initialize_test_memory, reset_test_memory, TestMemory};
 
 use motoko_rts::memory::Memory;
 use motoko_rts::text::{
@@ -48,7 +48,7 @@ impl<'a, M: Memory> Iterator for TextIter<'a, M> {
 pub unsafe fn test() {
     println!("Testing text and text iterators ...");
 
-    let mut mem = TestMemory::new(Words(1024 * 1024));
+    let mut mem = initialize_test_memory();
 
     println!("  Testing decode_code_point and text_singleton for ASCII");
     for i in 0..=255u32 {
@@ -93,6 +93,8 @@ pub unsafe fn test() {
             },
         )
         .unwrap();
+
+    reset_test_memory();
 }
 
 unsafe fn concat1<M: Memory>(mem: &mut M) {
diff --git a/rts/motoko-rts/src/gc/incremental.rs b/rts/motoko-rts/src/gc/incremental.rs
index 0d496d4a7f1..15f1651aa2d 100644
--- a/rts/motoko-rts/src/gc/incremental.rs
+++ b/rts/motoko-rts/src/gc/incremental.rs
@@ -16,7 +16,7 @@ use motoko_rts_macros::ic_mem_fn;
 use crate::{memory::Memory, types::*, visitor::visit_pointer_fields};
 
 use self::{
-    partitioned_heap::{PartitionedHeap, PartitionedHeapIterator, UNINITIALIZED_HEAP},
+    partitioned_heap::{PartitionedHeap, PartitionedHeapIterator},
     phases::{
         evacuation_increment::EvacuationIncrement,
         mark_increment::{MarkIncrement, MarkState},
@@ -40,10 +40,9 @@ pub mod time;
 
 #[ic_mem_fn(ic_only)]
 unsafe fn initialize_incremental_gc<M: Memory>(mem: &mut M) {
-    use crate::persistence::{initialize_memory, HEAP_START};
+    use crate::persistence::initialize_memory;
 
     initialize_memory(mem);
-    IncrementalGC::<M>::initialize(mem, get_incremental_gc_state(), HEAP_START);
 }
 
 #[ic_mem_fn(ic_only)]
@@ -114,7 +113,6 @@ unsafe fn record_gc_stop<M: Memory>() {
 }
 
 // Persistent GC statistics used for scheduling and diagnostics.
-#[cfg(feature = "ic")]
 struct Statistics {
     // Total number of allocation at the start of the last GC run.
     last_allocations: Bytes<u64>,
@@ -161,24 +159,9 @@ pub struct State {
     allocation_count: usize, // Number of allocations during an active GC run.
     mark_state: Option<MarkState>,
     iterator_state: Option<PartitionedHeapIterator>,
-    #[cfg(feature = "ic")]
     statistics: Statistics,
 }
 
-/// Optimization: Avoiding `Option` or `Lazy`.
-pub(crate) const UNINITIALIZED_STATE: State = State {
-    phase: Phase::Pause,
-    partitioned_heap: UNINITIALIZED_HEAP,
-    allocation_count: 0,
-    mark_state: None,
-    iterator_state: None,
-    #[cfg(feature = "ic")]
-    statistics: Statistics {
-        last_allocations: Bytes(0),
-        max_live: Bytes(0),
-    },
-};
-
 /// Incremental GC.
 /// Each GC call has its new GC instance that shares the common GC state `STATE`.
 pub struct IncrementalGC<'a, M: Memory> {
@@ -190,12 +173,20 @@ pub struct IncrementalGC<'a, M: Memory> {
 impl<'a, M: Memory + 'a> IncrementalGC<'a, M> {
     /// (Re-)Initialize the entire incremental garbage collector.
     /// Called on a runtime system start with incremental GC and also during RTS testing.
-    pub unsafe fn initialize(mem: &'a mut M, state: &mut State, heap_base: usize) {
-        state.phase = Phase::Pause;
-        state.partitioned_heap = PartitionedHeap::new(mem, heap_base);
-        state.allocation_count = 0;
-        state.mark_state = None;
-        state.iterator_state = None;
+    pub unsafe fn initial_gc_state(mem: &'a mut M, heap_base: usize) -> State {
+        let partitioned_heap = PartitionedHeap::new(mem, heap_base);
+        let statistics = Statistics {
+            last_allocations: Bytes(0),
+            max_live: Bytes(0),
+        };
+        State {
+            phase: Phase::Pause,
+            partitioned_heap,
+            allocation_count: 0,
+            mark_state: None,
+            iterator_state: None,
+            statistics,
+        }
     }
 
     /// Each GC schedule point can get a new GC instance that shares the common GC state.
@@ -423,12 +414,22 @@ pub unsafe fn get_max_live_size() -> Bytes<u32> {
     get_incremental_gc_state().statistics.max_live
 }
 
-// For RTS unit testing only.
+/// For RTS unit testing only.
 #[cfg(not(feature = "ic"))]
-static mut TEST_GC_STATE: State = UNINITIALIZED_STATE;
+static mut TEST_GC_STATE: Option<State> = None;
 
-// For RTS unit testing only.
+/// For RTS unit testing only.
 #[cfg(not(feature = "ic"))]
 pub unsafe fn get_incremental_gc_state() -> &'static mut State {
-    &mut TEST_GC_STATE
+    let state = TEST_GC_STATE.as_mut().unwrap();
+    // Read the statistics to get rid of unused warnings.
+    assert!(state.statistics.last_allocations == Bytes(0));
+    assert!(state.statistics.max_live == Bytes(0));
+    state
+}
+
+/// For RTS unit testing only.
+#[cfg(not(feature = "ic"))]
+pub unsafe fn set_incremental_gc_state(state: Option<State>) {
+    TEST_GC_STATE = state;
 }
diff --git a/rts/motoko-rts/src/gc/incremental/partitioned_heap.rs b/rts/motoko-rts/src/gc/incremental/partitioned_heap.rs
index a7b8c5653f8..cffba859a10 100644
--- a/rts/motoko-rts/src/gc/incremental/partitioned_heap.rs
+++ b/rts/motoko-rts/src/gc/incremental/partitioned_heap.rs
@@ -88,20 +88,6 @@ pub struct Partition {
     update: bool,        // Specifies whether the pointers in the partition have to be updated.
 }
 
-/// Optimization: Avoiding `Option` or `Lazy`.
-const UNINITIALIZED_PARTITION: Partition = Partition {
-    index: usize::MAX,
-    free: false,
-    large_content: false,
-    marked_size: 0,
-    static_size: 0,
-    dynamic_size: 0,
-    bitmap: super::mark_bitmap::DEFAULT_MARK_BITMAP,
-    temporary: false,
-    evacuate: false,
-    update: false,
-};
-
 impl Partition {
     pub fn get_index(&self) -> usize {
         self.index
@@ -362,19 +348,6 @@ pub struct PartitionedHeap {
     precomputed_heap_size: usize, // Occupied heap size, excluding the dynamic heap in the allocation partition.
 }
 
-/// Optimization: Avoiding `Option` or `LazyCell`.
-pub const UNINITIALIZED_HEAP: PartitionedHeap = PartitionedHeap {
-    partitions: [UNINITIALIZED_PARTITION; MAX_PARTITIONS],
-    heap_base: 0,
-    allocation_index: 0,
-    free_partitions: 0,
-    evacuating: false,
-    reclaimed: 0,
-    bitmap_allocation_pointer: 0,
-    gc_running: false,
-    precomputed_heap_size: 0,
-};
-
 impl PartitionedHeap {
     pub unsafe fn new<M: Memory>(mem: &mut M, heap_base: usize) -> PartitionedHeap {
         let allocation_index = heap_base / PARTITION_SIZE;
diff --git a/rts/motoko-rts/src/persistence.rs b/rts/motoko-rts/src/persistence.rs
index 0bbd4a14118..f3ff0ffef9e 100644
--- a/rts/motoko-rts/src/persistence.rs
+++ b/rts/motoko-rts/src/persistence.rs
@@ -6,7 +6,7 @@ use motoko_rts_macros::ic_mem_fn;
 
 use crate::{
     barriers::{allocation_barrier, write_with_barrier},
-    gc::incremental::{State, UNINITIALIZED_STATE},
+    gc::incremental::{IncrementalGC, State},
     memory::Memory,
     types::{size_of, Null, Value, TAG_NULL},
 };
@@ -31,12 +31,12 @@ struct PersistentMetadata {
     // Reference to the stable sub-record of the actor, comprising all stable actor fields. Set before upgrade.
     // Constitutes a GC root and requires pointer forwarding.
     stable_actor: Value,
-    // Singleton of the top-level null value. To be retained across upgrades.
-    // Constitutes a GC root and requires pointer forwarding.
-    null_singleton: Value,
     // The state of the incremental GC including the partitioned heap description.
     // The GC continues work after upgrades.
     incremental_gc_state: State,
+    // Singleton of the top-level null value. To be retained across upgrades.
+    // Constitutes a GC root and requires pointer forwarding.
+    null_singleton: Value,
 }
 
 const METATDATA_ADDRESS: usize = 4 * 1024 * 1024;
@@ -80,8 +80,8 @@ impl PersistentMetadata {
         (*self).fingerprint = FINGERPRINT;
         (*self).version = VERSION;
         (*self).stable_actor = DEFAULT_VALUE;
-        (*self).null_singleton = alloc_null(mem);
-        (*self).incremental_gc_state = UNINITIALIZED_STATE;
+        (*self).incremental_gc_state = IncrementalGC::initial_gc_state(mem, HEAP_START);
+        (*self).null_singleton = DEFAULT_VALUE;
     }
 }
 
@@ -95,9 +95,18 @@ pub unsafe fn initialize_memory<M: Memory>(mem: &mut M) {
         metadata.check_version();
     } else {
         metadata.initialize(mem);
+        allocate_initial_objects(mem);
     }
 }
 
+/// Allocate initial objects only after the partitioned heap has been initialized.
+#[cfg(feature = "ic")]
+unsafe fn allocate_initial_objects<M: Memory>(mem: &mut M) {
+    let metadata = PersistentMetadata::get();
+    debug_assert!((*metadata).null_singleton == DEFAULT_VALUE);
+    (*metadata).null_singleton = alloc_null(mem);
+}
+
 /// Returns the stable sub-record of the actor of the upgraded canister version.
 /// Returns scalar 0 if no actor is stored after on a fresh memory.
 #[no_mangle]
@@ -123,6 +132,7 @@ pub(crate) unsafe fn stable_actor_location() -> *mut Value {
 
 unsafe fn alloc_null<M: Memory>(mem: &mut M) -> Value {
     let value = mem.alloc_words(size_of::<Null>());
+    debug_assert!(value.get_ptr() >= HEAP_START);
     let null = value.get_ptr() as *mut Null;
     (*null).header.tag = TAG_NULL;
     (*null).header.init_forward(value);
@@ -136,12 +146,15 @@ unsafe fn alloc_null<M: Memory>(mem: &mut M) -> Value {
 /// NOTE: The forwarding pointer of the other comparison argument needs
 /// to be resolved too.
 #[no_mangle]
+#[cfg(feature = "ic")]
 pub unsafe extern "C" fn null_singleton() -> Value {
     let metadata = PersistentMetadata::get();
+    debug_assert!((*metadata).null_singleton != DEFAULT_VALUE);
     (*metadata).null_singleton.forward_if_possible()
 }
 
 // GC root pointer required for GC marking and updating.
+#[cfg(feature = "ic")]
 pub(crate) unsafe fn null_singleton_location() -> *mut Value {
     let metadata = PersistentMetadata::get();
     &mut (*metadata).null_singleton as *mut Value

From fefa3de559c0cb437107b984602930c7c601353f Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 17 Aug 2023 15:52:58 +0200
Subject: [PATCH 037/260] Null comparison with conditional pointer forwarding
 resolution

---
 src/codegen/compile.ml | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 25ed24a3031..b90576051c5 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -1768,10 +1768,20 @@ module Opt = struct
     E.call_import env "rts" "null_singleton" (* forwarding pointer already resolved *)
 
   let is_some env =
-    (* resolve forwarding pointer on pointer equality check *)
-    Tagged.load_forwarding_pointer env ^^
-    null_lit env ^^
-    G.i (Compare (Wasm.Values.I32 I32Op.Ne))
+    Func.share_code1 env "is_some" ("x", I32Type) [I32Type] (fun env get_x ->
+      get_x ^^ BitTagged.if_tagged_scalar env [I32Type]
+        ( Bool.lit true ) (* scalar *)
+        ( get_x ^^ BitTagged.is_true_literal env ^^ (* exclude true literal since `branch_default` follows the forwarding pointer *)
+          E.if_ env [I32Type]
+            ( Bool.lit true ) (* true literal *)
+            ( (* pointer to object, resolve forwarding pointer on null pointer equality check *)
+              get_x ^^
+              Tagged.load_forwarding_pointer env ^^
+              null_lit env ^^
+              G.i (Compare (Wasm.Values.I32 I32Op.Ne))
+            )
+        )
+    )
 
   let alloc_some env get_payload =
     Tagged.obj env Tagged.Some [ get_payload ]

From e7e7a4a1f43f555502c45d4b26b2ea25b906010c Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 18 Aug 2023 15:14:40 +0200
Subject: [PATCH 038/260] Extend constant materialization

---
 src/codegen/compile.ml | 28 ++++++++++++++++------------
 1 file changed, 16 insertions(+), 12 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index b90576051c5..ae1e7370d7b 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -7086,21 +7086,25 @@ module StackRep = struct
     | Const _ | Unreachable -> G.nop
 
   let rec materialize_constant env = function
-    | Const.Lit (Const.Vanilla l) -> compile_unboxed_const l
-    | Const.Lit (Const.Bool b) -> Bool.lit b
-    | Const.Lit (Const.Blob t) -> Blob.lit env t
+    | Const.Lit (Const.Vanilla value) -> compile_unboxed_const value
+    | Const.Lit (Const.Bool number) -> Bool.lit number
+    | Const.Lit (Const.Blob payload) -> Blob.lit env payload
     | Const.Lit (Const.Null) -> Opt.null_lit env
-    | Const.Lit (Const.BigInt n) -> BigNum.lit env n
-    | Const.Lit (Const.Word32 n) -> BoxedSmallWord.lit env n
-    | Const.Lit (Const.Word64 n) -> BoxedWord64.lit env n
-    | Const.Lit (Const.Float64 f) -> Float.lit env f
-    | Const.Opt c -> Opt.inject env (materialize_constant env c)
+    | Const.Lit (Const.BigInt number) -> BigNum.lit env number
+    | Const.Lit (Const.Word32 number) -> BoxedSmallWord.lit env number
+    | Const.Lit (Const.Word64 number) -> BoxedWord64.lit env number
+    | Const.Lit (Const.Float64 number) -> Float.lit env number
+    | Const.Opt value -> Opt.inject env (materialize_constant env value)
     | Const.Fun (get_fi, _) -> Closure.alloc env (get_fi ())
-    | Const.Message fi -> assert false
+    | Const.Message _ -> assert false
     | Const.Unit -> Tuple.compile_unit
-    | Const.Tag (i, c) -> Variant.inject env i (materialize_constant env c)
-    | Const.Array cs -> Arr.lit env (List.map (fun c -> materialize_constant env c) cs)
-    | _ -> assert false
+    | Const.Tag (tag, value) -> Variant.inject env tag (materialize_constant env value)
+    | Const.Array elements -> 
+        let materialized_elements = List.map (materialize_constant env) elements in
+        Arr.lit env materialized_elements
+    | Const.Obj fields -> 
+        let materialized_fields = List.map (fun (name, value) -> (name, (fun () -> materialize_constant env value))) fields in
+        Object.lit_raw env materialized_fields
 
   let adjust env (sr_in : t) sr_out =
     if eq sr_in sr_out

From 26115012a15d574cd34dc133cad83a9d2eeeca45 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 18 Aug 2023 15:38:47 +0200
Subject: [PATCH 039/260] Adjust 64-bit boxed literals

---
 src/codegen/compile.ml | 23 +++++++++--------------
 1 file changed, 9 insertions(+), 14 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index ae1e7370d7b..bba5d530f88 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -1943,15 +1943,6 @@ module BoxedWord64 = struct
 
   let payload_field = Tagged.header_size
 
-  let lit env i =
-    if BitTagged.can_tag_const i
-    then 
-      compile_unboxed_const (BitTagged.tag_const i)
-    else
-      Tagged.obj env Tagged.Bits64 [
-        compile_const_64 i
-      ]
-
   let compile_box env compile_elem : G.t =
     let (set_i, get_i) = new_local env "boxed_i64" in
     let size = 4l in
@@ -1961,6 +1952,13 @@ module BoxedWord64 = struct
     get_i ^^
     Tagged.allocation_barrier env
 
+  let lit env i =
+    if BitTagged.can_tag_const i
+    then 
+      compile_unboxed_const (BitTagged.tag_const i)
+    else
+      compile_box env (compile_const_64 i)
+
   let box env = Func.share_code1 env "box_i64" ("n", I64Type) [I32Type] (fun env get_n ->
       get_n ^^ BitTagged.if_can_tag_i64 env [I32Type]
         (get_n ^^ BitTagged.tag)
@@ -2310,11 +2308,6 @@ module Float = struct
 
   let compile_unboxed_const f = G.i (Const (nr (Wasm.Values.F64 f)))
 
-  let lit env f =
-    Tagged.obj env Tagged.Bits64 [
-      compile_const_64 (Wasm.F64.to_bits f)
-    ]
-
   let box env = Func.share_code1 env "box_f64" ("f", F64Type) [I32Type] (fun env get_f ->
     let (set_i, get_i) = new_local env "boxed_f64" in
     let size = Int32.add Tagged.header_size  2l in
@@ -2327,6 +2320,8 @@ module Float = struct
 
   let unbox env = Tagged.load_forwarding_pointer env ^^ Tagged.load_field_float64 env payload_field
 
+  let lit env f = (compile_const_64 (Wasm.F64.to_bits f)) ^^ box env
+
 end (* Float *)
 
 

From 070b74df688d8d0abad097621d847790a20647d0 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 18 Aug 2023 15:53:17 +0200
Subject: [PATCH 040/260] Adjust float literal

---
 src/codegen/compile.ml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index bba5d530f88..733c48e0706 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -2320,7 +2320,7 @@ module Float = struct
 
   let unbox env = Tagged.load_forwarding_pointer env ^^ Tagged.load_field_float64 env payload_field
 
-  let lit env f = (compile_const_64 (Wasm.F64.to_bits f)) ^^ box env
+  let lit env f = (compile_unboxed_const f) ^^ box env
 
 end (* Float *)
 

From c0c600b8284564fc4cb7ee420e2734203f3dfce9 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 18 Aug 2023 15:54:01 +0200
Subject: [PATCH 041/260] Code refactoring

---
 src/codegen/compile.ml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 733c48e0706..b2d2c362ae7 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -2320,7 +2320,7 @@ module Float = struct
 
   let unbox env = Tagged.load_forwarding_pointer env ^^ Tagged.load_field_float64 env payload_field
 
-  let lit env f = (compile_unboxed_const f) ^^ box env
+  let lit env f = compile_unboxed_const f ^^ box env
 
 end (* Float *)
 

From 39e3604cfff0c3bf45c6329bf779ae1f9db4fb45 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 18 Aug 2023 16:06:38 +0200
Subject: [PATCH 042/260] Adjust function comparison

---
 src/codegen/compile.ml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index b2d2c362ae7..5a0f59e99c8 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -155,6 +155,7 @@ module Const = struct
 
   let eq v1 v2 = match v1, v2 with
     | Lit l1, Lit l2 -> lit_eq l1 l2
+    | Fun (f1_fp, _), Fun (f2_fp, _) -> f1_fp() = f2_fp()
     | _ -> v1 = v2
 
 end (* Const *)

From a20af45f218de788b74d0441b16239a01aac58c7 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 18 Aug 2023 16:25:27 +0200
Subject: [PATCH 043/260] Adjust tests

---
 test/run/const-func-static.mo     |  2 +-
 test/run/idl-ops.mo               |  3 +--
 test/run/idl.mo                   |  3 +--
 test/run/ok/array-len.wasm-run.ok |  2 +-
 test/run/optimise-for-array.mo    | 30 ++++++++++++++----------------
 5 files changed, 18 insertions(+), 22 deletions(-)

diff --git a/test/run/const-func-static.mo b/test/run/const-func-static.mo
index a6a4eb0de69..3c66c93986e 100644
--- a/test/run/const-func-static.mo
+++ b/test/run/const-func-static.mo
@@ -5,7 +5,7 @@ func higher_order(foo: () -> ()) = foo();
 func bar() = ();
 higher_order(bar);
 let after = Prim.rts_heap_size();
-assert(+after-before == 0);
+assert(+after-before == 16);
 Prim.debugPrint("Ignore Diff: heap size increase " # debug_show (+after-before));
 
 //SKIP run
diff --git a/test/run/idl-ops.mo b/test/run/idl-ops.mo
index 15a2746cdbd..dda6f1d37f0 100644
--- a/test/run/idl-ops.mo
+++ b/test/run/idl-ops.mo
@@ -50,8 +50,7 @@ assert((?arrayNat) == deserArrayInt (serArrayInt arrayNat));
 assert(null == deserArrayNat (serArrayInt arrayInt));
 assert((?arrayInt) == deserArrayInt (serArrayInt arrayInt));
 let heapDifference = Prim.rts_heap_size() : Int - started_with;
-// Difference between incremental and non-incremental GC
-assert(heapDifference == +6_848 or heapDifference == +7_464);
+assert(heapDifference == 26_360);
 
 //SKIP run
 //SKIP run-ir
diff --git a/test/run/idl.mo b/test/run/idl.mo
index 3ab349baf66..2c906de95ba 100644
--- a/test/run/idl.mo
+++ b/test/run/idl.mo
@@ -46,8 +46,7 @@ assert(arrayNat == deserArrayInt (serArrayInt arrayNat));
 assert(arrayInt == deserArrayInt (serArrayInt arrayInt));
 
 let heapDifference = Prim.rts_heap_size() : Int - started_with;
-// Difference between incremental and non-incremental GC
-assert(heapDifference == +4_488 or heapDifference == +4_888);
+assert(heapDifference == 19_704);
 
 //SKIP run
 //SKIP run-ir
diff --git a/test/run/ok/array-len.wasm-run.ok b/test/run/ok/array-len.wasm-run.ok
index 49fd311aadf..79d6e3a21c5 100644
--- a/test/run/ok/array-len.wasm-run.ok
+++ b/test/run/ok/array-len.wasm-run.ok
@@ -1,4 +1,4 @@
-Allocation delta:  0
+Allocation delta:  68
 a
 b
 c
diff --git a/test/run/optimise-for-array.mo b/test/run/optimise-for-array.mo
index d68faa26609..a0a6b115af9 100644
--- a/test/run/optimise-for-array.mo
+++ b/test/run/optimise-for-array.mo
@@ -5,13 +5,11 @@ import Prim "mo:⛔";
 // CHECK: (local $check0 i32)
 
 // CHECK-NOT:  call $@immut_array_size
-// DON'TCHECK: i32.load offset=(5 or 9) 
+// DON'TCHECK: i32.load offset=9
 // CHECK:      i32.load offset= 
 // CHECK:      i32.const 2
 // CHECK:      i32.shl
-// CHECK:      i32.lt_u
-// CHECK:      i32.add
-// DON'TCHECK: i32.load offset=(9 or 13)
+// DON'TCHECK: i32.load offset=13
 // CHECK:      local.tee $check0
 // CHECK-NEXT: call $print_text
 // CHECK:      i32.const 4
@@ -20,22 +18,21 @@ for (check0 in ["hello", "world"].vals()) { Prim.debugPrint check0 };
 
 
 // CHECK-NOT:  call $@mut_array_size
-// DON'TCHECK: i32.load offset=(5 or 9)
+// DON'TCHECK: i32.load offset=9
 // CHECK:      i32.load offset=
 // CHECK:      i32.const 2
-// CHECK-NEXT: i32.shl
-// CHECK:      i32.lt_u
-// CHECK:      i32.add
-// DON'TCHECK: i32.load offset=(9 or 13)
-// CHECK:      i32.load offset=
-// CHECK-NEXT: local.tee $check1
+// CHECK:      i32.shl
+// DON'TCHECK: i32.load offset=13
+// CHECK:      local.tee $check1
 // CHECK-NEXT: call $print_text
+// CHECK:      i32.const 4
+// CHECK-NEXT: i32.add
 for (check1 in [var "hello", "mutable", "world"].vals()) { Prim.debugPrint check1 };
 
 let array = [var "hello", "remutable", "world"];
 array[1] := "mutable";
 // CHECK-NOT:   call $@immut_array_size
-// DON'TCHECK:  i32.load offset=(5 or 9)
+// DON'TCHECK:  i32.load offset=9
 // CHECK:       i32.load offset=
 // CHECK:       i32.const 2
 // CHECK:       i32.shl
@@ -47,15 +44,16 @@ array[1] := "mutable";
 for (check2 in array.vals()) { Prim.debugPrint check2 };
 
 // CHECK-NOT:  call $@immut_array_size
-// DON'TCHECK: i32.load offset=(5 or 9)
+// DON'TCHECK: i32.load offset=9
 // CHECK:      i32.load offset=
 // CHECK:      i32.const 2
 // CHECK:      i32.shl
 // CHECK:      i32.lt_u
 // CHECK:      i32.add
-// DON'TCHECK: i32.load offset=(9 or 13)
-// CHECK:      i32.load offset=
-// CHECK-NEXT: local.tee $check3
+// DON'TCHECK: i32.load offset=13
+// CHECK:      local.tee $check3
+// CHECK:      i32.const 4
+// CHECK-NEXT: i32.add
 // interfering parentheses don't disturb us
 for (check3 in (((["hello", "immutable", "world"].vals())))) { Prim.debugPrint check3 };
 

From f62590a90f4f1edff7f810cfbfa0c7630e7e7c88 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 18 Aug 2023 16:26:14 +0200
Subject: [PATCH 044/260] Refine test

---
 test/run/optimise-for-array.mo | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/run/optimise-for-array.mo b/test/run/optimise-for-array.mo
index a0a6b115af9..038e79937b4 100644
--- a/test/run/optimise-for-array.mo
+++ b/test/run/optimise-for-array.mo
@@ -92,7 +92,7 @@ check6[1] := "mutable";
 // this passes the IR type check, which demonstrates that no name capture happens
 for (check6 in check6.vals()) { ignore check6 };
 
-// DON'TCHECK: i32.load offset=(5 or 9)
+// DON'TCHECK: i32.load offset=9
 // CHECK:      i32.load offset=
 // CHECK:      i32.const 2
 // CHECK:      i32.shl
@@ -101,7 +101,7 @@ for (check7 in [].vals(Prim.debugPrint "want to see you")) { };
 
 // CHECK:      local.set $num8
 // CHECK-NOT:  call $@immut_array_size
-// DON'TCHECK: i32.load offset=(5 or 9)
+// DON'TCHECK: i32.load offset=9
 // CHECK:      i32.load offset=
 // CHECK:      i32.const 1
 // CHECK:      i32.shl

From c2f01cdff02fe11b07a0951118f18f9e56e25aea Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 18 Aug 2023 16:55:48 +0200
Subject: [PATCH 045/260] Allow GC to see the null object

---
 rts/motoko-rts/src/visitor.rs | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/rts/motoko-rts/src/visitor.rs b/rts/motoko-rts/src/visitor.rs
index 47108bc6935..8c40e9aa046 100644
--- a/rts/motoko-rts/src/visitor.rs
+++ b/rts/motoko-rts/src/visitor.rs
@@ -112,14 +112,10 @@ pub unsafe fn visit_pointer_fields<C, F, G>(
             }
         }
 
-        TAG_BITS64 | TAG_BITS32 | TAG_BLOB | TAG_BIGINT => {
+        TAG_BITS64 | TAG_BITS32 | TAG_BLOB | TAG_BIGINT | TAG_NULL => {
             // These don't have pointers, skip
         }
 
-        TAG_NULL => {
-            rts_trap_with("encountered NULL object tag in visit_pointer_fields");
-        }
-
         TAG_FWD_PTR | TAG_ONE_WORD_FILLER | TAG_FREE_SPACE | _ => {
             rts_trap_with("invalid object tag in visit_pointer_fields");
         }

From 6ab0b185bd55c84e873bf331adfe5787bd856391 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 18 Aug 2023 17:08:03 +0200
Subject: [PATCH 046/260] Code refactoring

---
 .../src/gc/incremental/roots.rs               | 56 ++++++++-----------
 rts/motoko-rts/src/gc/incremental.rs          |  1 -
 .../gc/incremental/phases/mark_increment.rs   |  3 +-
 .../gc/incremental/phases/update_increment.rs |  3 +-
 rts/motoko-rts/src/gc/incremental/roots.rs    |  6 +-
 rts/motoko-rts/src/visitor.rs                 | 40 +++++++------
 6 files changed, 50 insertions(+), 59 deletions(-)

diff --git a/rts/motoko-rts-tests/src/gc/incremental/roots.rs b/rts/motoko-rts-tests/src/gc/incremental/roots.rs
index 9a2c23e9783..5454f2d55d1 100644
--- a/rts/motoko-rts-tests/src/gc/incremental/roots.rs
+++ b/rts/motoko-rts-tests/src/gc/incremental/roots.rs
@@ -25,47 +25,37 @@ pub unsafe fn test() {
 unsafe fn check_visit_static_roots(heap: &MotokoHeap, root_ids: &[ObjectIdx]) {
     let roots = get_roots(heap);
     let mut visited_static_roots = vec![];
-    visit_roots(
-        roots,
-        heap.heap_base_address(),
-        &mut visited_static_roots,
-        |context, field| {
-            let object = *field;
-            let array = object.as_array();
-            if array.len() == root_ids.len() as u32 {
-                for index in 0..array.len() {
-                    let mutbox_value = array.get(index);
-                    let mutbox = mutbox_value.as_mutbox();
-                    let root_address = (*mutbox).field.get_ptr();
-                    let root_id = object_id(heap, root_address);
-                    context.push(root_id);
-                }
+    visit_roots(roots, &mut visited_static_roots, |context, field| {
+        let object = *field;
+        let array = object.as_array();
+        if array.len() == root_ids.len() as u32 {
+            for index in 0..array.len() {
+                let mutbox_value = array.get(index);
+                let mutbox = mutbox_value.as_mutbox();
+                let root_address = (*mutbox).field.get_ptr();
+                let root_id = object_id(heap, root_address);
+                context.push(root_id);
             }
-        },
-    );
+        }
+    });
     assert_eq!(visited_static_roots, root_ids);
 }
 
 unsafe fn check_visit_continuation_table(heap: &MotokoHeap, continuation_ids: &[ObjectIdx]) {
     let roots = get_roots(heap);
     let mut visited_continuations = vec![];
-    visit_roots(
-        roots,
-        heap.heap_base_address(),
-        &mut visited_continuations,
-        |context, field| {
-            let object = *field;
-            let array = object.as_array();
-            if array.len() == continuation_ids.len() as u32 {
-                assert_eq!(context.len(), 0);
-                for index in 0..array.len() {
-                    let element = array.get(index);
-                    let id = object_id(&heap, element.get_ptr());
-                    context.push(id);
-                }
+    visit_roots(roots, &mut visited_continuations, |context, field| {
+        let object = *field;
+        let array = object.as_array();
+        if array.len() == continuation_ids.len() as u32 {
+            assert_eq!(context.len(), 0);
+            for index in 0..array.len() {
+                let element = array.get(index);
+                let id = object_id(&heap, element.get_ptr());
+                context.push(id);
             }
-        },
-    );
+        }
+    });
     assert_eq!(visited_continuations, continuation_ids);
 }
 
diff --git a/rts/motoko-rts/src/gc/incremental.rs b/rts/motoko-rts/src/gc/incremental.rs
index 15f1651aa2d..d159d9e5766 100644
--- a/rts/motoko-rts/src/gc/incremental.rs
+++ b/rts/motoko-rts/src/gc/incremental.rs
@@ -383,7 +383,6 @@ unsafe fn update_new_allocation(state: &State, new_object: Value) {
             &mut (),
             object,
             object.tag(),
-            state.partitioned_heap.base_address(),
             |_, field| {
                 *field = (*field).forward_if_possible();
             },
diff --git a/rts/motoko-rts/src/gc/incremental/phases/mark_increment.rs b/rts/motoko-rts/src/gc/incremental/phases/mark_increment.rs
index 4580fb32ebe..d98a8af3988 100644
--- a/rts/motoko-rts/src/gc/incremental/phases/mark_increment.rs
+++ b/rts/motoko-rts/src/gc/incremental/phases/mark_increment.rs
@@ -66,7 +66,7 @@ impl<'a, M: Memory + 'a> MarkIncrement<'a, M> {
     }
 
     pub unsafe fn mark_roots(&mut self, roots: Roots) {
-        visit_roots(roots, self.heap.base_address(), self, |gc, field| {
+        visit_roots(roots, self, |gc, field| {
             gc.mark_object(*field);
             gc.time.tick();
         });
@@ -115,7 +115,6 @@ impl<'a, M: Memory + 'a> MarkIncrement<'a, M> {
             self,
             object,
             object.tag(),
-            self.heap.base_address(),
             |gc, field_address| {
                 let field_value = *field_address;
                 gc.mark_object(field_value);
diff --git a/rts/motoko-rts/src/gc/incremental/phases/update_increment.rs b/rts/motoko-rts/src/gc/incremental/phases/update_increment.rs
index d82c8b3e152..a759e9c8337 100644
--- a/rts/motoko-rts/src/gc/incremental/phases/update_increment.rs
+++ b/rts/motoko-rts/src/gc/incremental/phases/update_increment.rs
@@ -49,7 +49,7 @@ impl<'a> UpdateIncrement<'a> {
     }
 
     pub unsafe fn update_roots(&mut self, roots: Roots) {
-        visit_roots(roots, self.heap.base_address(), self, |gc, field| {
+        visit_roots(roots, self, |gc, field| {
             let value = *field;
             if value.is_forwarded() {
                 *field = value.forward_if_possible();
@@ -106,7 +106,6 @@ impl<'a> UpdateIncrement<'a> {
                 self,
                 object,
                 object.tag(),
-                self.heap.base_address(),
                 |gc, field_address| {
                     *field_address = (*field_address).forward_if_possible();
                     gc.time.tick();
diff --git a/rts/motoko-rts/src/gc/incremental/roots.rs b/rts/motoko-rts/src/gc/incremental/roots.rs
index 4de6a99d73f..e973a702151 100644
--- a/rts/motoko-rts/src/gc/incremental/roots.rs
+++ b/rts/motoko-rts/src/gc/incremental/roots.rs
@@ -1,6 +1,6 @@
 use motoko_rts_macros::ic_mem_fn;
 
-use crate::{types::Value, visitor::pointer_to_dynamic_heap};
+use crate::{types::Value, visitor::is_pointer_field};
 
 /// Root referring to all canister variables.
 /// This root is reinitialized on each canister upgrade.
@@ -27,13 +27,11 @@ pub unsafe fn root_set() -> Roots {
 
 pub unsafe fn visit_roots<C, V: Fn(&mut C, *mut Value)>(
     roots: Roots,
-    heap_base: usize,
     context: &mut C,
     visit_field: V,
 ) {
     for location in roots {
-        // TODO: Check whether all pointers lead to dynamic heap, no static heap
-        if pointer_to_dynamic_heap(location, heap_base) {
+        if is_pointer_field(location) {
             visit_field(context, location);
         }
     }
diff --git a/rts/motoko-rts/src/visitor.rs b/rts/motoko-rts/src/visitor.rs
index 8c40e9aa046..00d2d2fc09d 100644
--- a/rts/motoko-rts/src/visitor.rs
+++ b/rts/motoko-rts/src/visitor.rs
@@ -9,7 +9,6 @@ use crate::types::*;
 /// * `ctx`: any context passed to the `visit_*` callbacks
 /// * `obj`: the heap object to be visited (note: its heap tag may be invalid)
 /// * `tag`: the heap object's logical tag (or start of array object's suffix slice)
-/// * `heap_base`: start address of the dynamic heap
 /// * `visit_ptr_field`: callback for individual fields
 /// * `visit_field_range`: callback for determining the suffix slice
 ///   Arguments:
@@ -24,7 +23,6 @@ pub unsafe fn visit_pointer_fields<C, F, G>(
     ctx: &mut C,
     obj: *mut Obj,
     tag: Tag,
-    heap_base: usize,
     visit_ptr_field: F,
     visit_field_range: G,
 ) where
@@ -37,7 +35,7 @@ pub unsafe fn visit_pointer_fields<C, F, G>(
             let obj_payload = obj.payload_addr();
             for i in 0..obj.size() {
                 let field_addr = obj_payload.add(i as usize);
-                if pointer_to_dynamic_heap(field_addr, heap_base) {
+                if is_pointer_field(field_addr) {
                     visit_ptr_field(ctx, obj_payload.add(i as usize));
                 }
             }
@@ -51,7 +49,7 @@ pub unsafe fn visit_pointer_fields<C, F, G>(
             debug_assert!(stop <= array.len());
             for i in slice_start..stop {
                 let field_addr = array_payload.add(i as usize);
-                if pointer_to_dynamic_heap(field_addr, heap_base) {
+                if is_pointer_field(field_addr) {
                     visit_ptr_field(ctx, field_addr);
                 }
             }
@@ -60,7 +58,7 @@ pub unsafe fn visit_pointer_fields<C, F, G>(
         TAG_MUTBOX => {
             let mutbox = obj as *mut MutBox;
             let field_addr = &mut (*mutbox).field;
-            if pointer_to_dynamic_heap(field_addr, heap_base) {
+            if is_pointer_field(field_addr) {
                 visit_ptr_field(ctx, field_addr);
             }
         }
@@ -70,7 +68,7 @@ pub unsafe fn visit_pointer_fields<C, F, G>(
             let closure_payload = closure.payload_addr();
             for i in 0..closure.size() {
                 let field_addr = closure_payload.add(i as usize);
-                if pointer_to_dynamic_heap(field_addr, heap_base) {
+                if is_pointer_field(field_addr) {
                     visit_ptr_field(ctx, field_addr);
                 }
             }
@@ -79,7 +77,7 @@ pub unsafe fn visit_pointer_fields<C, F, G>(
         TAG_SOME => {
             let some = obj as *mut Some;
             let field_addr = &mut (*some).field;
-            if pointer_to_dynamic_heap(field_addr, heap_base) {
+            if is_pointer_field(field_addr) {
                 visit_ptr_field(ctx, field_addr);
             }
         }
@@ -87,7 +85,7 @@ pub unsafe fn visit_pointer_fields<C, F, G>(
         TAG_VARIANT => {
             let variant = obj as *mut Variant;
             let field_addr = &mut (*variant).field;
-            if pointer_to_dynamic_heap(field_addr, heap_base) {
+            if is_pointer_field(field_addr) {
                 visit_ptr_field(ctx, field_addr);
             }
         }
@@ -95,11 +93,11 @@ pub unsafe fn visit_pointer_fields<C, F, G>(
         TAG_CONCAT => {
             let concat = obj as *mut Concat;
             let field1_addr = &mut (*concat).text1;
-            if pointer_to_dynamic_heap(field1_addr, heap_base) {
+            if is_pointer_field(field1_addr) {
                 visit_ptr_field(ctx, field1_addr);
             }
             let field2_addr = &mut (*concat).text2;
-            if pointer_to_dynamic_heap(field2_addr, heap_base) {
+            if is_pointer_field(field2_addr) {
                 visit_ptr_field(ctx, field2_addr);
             }
         }
@@ -107,7 +105,7 @@ pub unsafe fn visit_pointer_fields<C, F, G>(
         TAG_OBJ_IND => {
             let obj_ind = obj as *mut ObjInd;
             let field_addr = &mut (*obj_ind).field;
-            if pointer_to_dynamic_heap(field_addr, heap_base) {
+            if is_pointer_field(field_addr) {
                 visit_ptr_field(ctx, field_addr);
             }
         }
@@ -122,10 +120,18 @@ pub unsafe fn visit_pointer_fields<C, F, G>(
     }
 }
 
-pub unsafe fn pointer_to_dynamic_heap(field_addr: *mut Value, heap_base: usize) -> bool {
-    // NB. pattern matching on `field_addr.get()` generates inefficient code
-    let field_value = (*field_addr).get_raw();
-    // NOTE: Pointers to static space is no longer allowed.
-    debug_assert!(!is_ptr(field_value) || unskew(field_value as usize) >= heap_base);
-    is_ptr(field_value)
+// Temporary function can be later removed.
+pub unsafe fn is_pointer_field(field_addr: *mut Value) -> bool {
+    let field_value = *field_addr;
+    check_field_value(field_value);
+    field_value.is_ptr()
 }
+
+// Temporary check, can be later removed.
+#[cfg(feature = "ic")]
+fn check_field_value(value: Value) {
+    debug_assert!(value.is_scalar() || value.get_ptr() >= crate::persistence::HEAP_START);
+}
+
+#[cfg(not(feature = "ic"))]
+fn check_field_value(_value: Value) {}

From 88478e8b4f3b35f5d82ae9b4ed9268a029faec51 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 18 Aug 2023 18:39:15 +0200
Subject: [PATCH 047/260] Fix RTS stack size

---
 doc/md/compiler-ref.md             |  1 -
 src/codegen/compile.ml             |  7 +++--
 src/exes/moc.ml                    |  4 ---
 src/mo_config/flags.ml             |  2 --
 test/run-drun/max-stack-variant.mo |  2 +-
 test/run-drun/max-stack.mo         |  2 +-
 test/run-drun/rts-stack-pages.mo   | 50 ------------------------------
 7 files changed, 7 insertions(+), 61 deletions(-)
 delete mode 100644 test/run-drun/rts-stack-pages.mo

diff --git a/doc/md/compiler-ref.md b/doc/md/compiler-ref.md
index 29bd7b7d7ef..b3fb40a7e3f 100644
--- a/doc/md/compiler-ref.md
+++ b/doc/md/compiler-ref.md
@@ -47,7 +47,6 @@ You can use the following options with the `moc` command.
 | `--release`                               | Ignores debug expressions in the source.                                                                                                              |
 | `--stable-types`                          | Compile binary and emit signature of stable types to `.most` file.                                                                                    |
 | `--stable-compatible <pre> <post>`        | Test upgrade compatibility between stable-type signatures `<pre>` and `<post>`.                                                                       |
-| `--rts-stack-pages <n>`                   | Set maximum number of pages available for runtime system stack (default 32).
 | `--trap-on-call-error`                    | Trap, don't throw an `Error`, when an IC call fails due to destination queue full or freezing threshold is crossed.
 |                                           | Emulates behaviour of moc versions < 0.8.0.
 | `-t`                                      | Activates tracing in interpreter.
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 5a0f59e99c8..8b84209a9d2 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -1125,7 +1125,10 @@ module Stack = struct
      grows downwards.)
   *)
 
-  let end_ () = Int32.mul (Int32.of_int (!Flags.rts_stack_pages)) page_size
+  (* Predefined constant stack size of 2MB, according to the persistent memory layout. *)
+  let stack_size = 2 * 1024 * 1024
+
+  let end_ () = Int32.of_int stack_size 
 
   let register_globals env =
     (* stack pointer *)
@@ -1177,7 +1180,7 @@ module Stack = struct
   let alloc_words env n =
     let n_bytes = Int32.mul n Heap.word_size in
     (* avoid absurd allocations *)
-    assert Int32.(to_int n_bytes < !Flags.rts_stack_pages * to_int page_size);
+    assert (Int32.(to_int n_bytes) < stack_size);
     (* alloc words *)
     get_stack_ptr env ^^
     compile_unboxed_const n_bytes ^^
diff --git a/src/exes/moc.ml b/src/exes/moc.ml
index 6db95348069..b0ed5cefcb5 100644
--- a/src/exes/moc.ml
+++ b/src/exes/moc.ml
@@ -153,10 +153,6 @@ let argspec = [
   Arg.Unit (fun () -> Flags.experimental_field_aliasing := true),
   " enable experimental support for aliasing of var fields";
 
-  "--rts-stack-pages",
-  Arg.Set_int Flags.rts_stack_pages,
-  "<n>  set maximum number of pages available for runtime system stack (default " ^ (Int.to_string Flags.rts_stack_pages_default) ^ ")";
-
   "--trap-on-call-error",
   Arg.Unit (fun () -> Flags.trap_on_call_error := true),
   " Trap, don't throw an `Error`, when an IC call fails due to destination queue full or freezing threshold is crossed. Emulates behaviour of moc versions < 0.8.0."
diff --git a/src/mo_config/flags.ml b/src/mo_config/flags.ml
index bcdfd6d635c..8577b3e8a7f 100644
--- a/src/mo_config/flags.ml
+++ b/src/mo_config/flags.ml
@@ -41,6 +41,4 @@ let force_gc = ref false
 let global_timer = ref true
 let experimental_field_aliasing = ref false
 let ocaml_js = ref false
-let rts_stack_pages_default = 32 (* 2MB *)
-let rts_stack_pages : int ref = ref rts_stack_pages_default
 let trap_on_call_error = ref false
diff --git a/test/run-drun/max-stack-variant.mo b/test/run-drun/max-stack-variant.mo
index f31fe3da5f8..7c51aeae6de 100644
--- a/test/run-drun/max-stack-variant.mo
+++ b/test/run-drun/max-stack-variant.mo
@@ -1,4 +1,4 @@
-//MOC-FLAG --compacting-gc --rts-stack-pages 32 -measure-rts-stack
+//MOC-FLAG -measure-rts-stack
 import { errorMessage; performanceCounter; rts_heap_size; rts_max_stack_size; debugPrint; } = "mo:⛔";
 
 actor stack {
diff --git a/test/run-drun/max-stack.mo b/test/run-drun/max-stack.mo
index dd15bbc8c23..573e49ed15c 100644
--- a/test/run-drun/max-stack.mo
+++ b/test/run-drun/max-stack.mo
@@ -1,4 +1,4 @@
-//MOC-FLAG --compacting-gc --rts-stack-pages 32 -measure-rts-stack
+//MOC-FLAG -measure-rts-stack
 import { errorMessage; performanceCounter; rts_heap_size; rts_max_stack_size; debugPrint; } = "mo:⛔";
 
 actor stack {
diff --git a/test/run-drun/rts-stack-pages.mo b/test/run-drun/rts-stack-pages.mo
deleted file mode 100644
index 9391f9996a6..00000000000
--- a/test/run-drun/rts-stack-pages.mo
+++ /dev/null
@@ -1,50 +0,0 @@
-//MOC-FLAG --rts-stack-pages 2
-import Prim = "mo:prim";
-// tests --rts-stack-pages adjusts stack limit
-// test fails with RTS stack underflow with just 2 pages,
-// but succeeds with 32 pages (the default).
-actor a {
-
-   let x = Prim.stableMemoryGrow(1);
-   assert Prim.stableMemorySize() == 1;
-
-
-   type List<T> = ?(T, List<T>);
-
-   var map : List<(Blob, Blob)> = null;
-
-   var count : Nat32 = 0;
-
-   func fillMB(mb : Nat) : () {
-     var c = 1024;
-     while (c > 0) {
-       count += 1;
-       Prim.stableMemoryStoreNat32(0, count);
-       var k = Prim.stableMemoryLoadBlob(0, 32);
-       var v = Prim.stableMemoryLoadBlob(0, 65536);
-       map := ?((k,v), map);
-       c -= 1;
-     };
-     if (Prim.rts_heap_size() < mb * 1024 * 1024) {
-      // Difference between incremental and non-incremental GC (due to different object header lengths).
-      let toleranceMB = 2;
-      Prim.debugPrint(debug_show({heap_MB = Prim.rts_heap_size()/1024/1024/toleranceMB*toleranceMB}));
-      fillMB(mb);
-     }
-   };
-
-   fillMB(768);
-   Prim.debugPrint "serializing";
-   let blob = to_candid(map);
-   Prim.debugPrint "serialized";
-   let opt = from_candid(blob) : ?(List<(Blob,Blob)>);
-   assert (opt != null);
-   // if we got here, deserialization has succeeded
-   Prim.debugPrint "deserialized";
-   assert false;
-
-}
-//SKIP run
-//SKIP run-ir
-//SKIP run-low
-//SKIP ic-ref-run

From 938cbb743accd43ed6fb8900749f8f81b4830883 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 21 Aug 2023 13:44:44 +0200
Subject: [PATCH 048/260] Upgrade to more recent IC branch

---
 nix/sources.json | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/nix/sources.json b/nix/sources.json
index 7f246f6e526..5a5af2f0704 100644
--- a/nix/sources.json
+++ b/nix/sources.json
@@ -26,10 +26,10 @@
         "homepage": "",
         "owner": "luc-blaeser",
         "repo": "ic",
-        "rev": "af7331a313bc76a12d0d8bb9e6f8ddc72c2a6b5d",
-        "sha256": "1w66vfsk9cvvcdlhhsiyf4zqms9l0mkmfpkdmwlpdjcs1ikjf1bb",
+        "rev": "18de74c14491c06499f59404fa5434a18bb9ca50",
+        "sha256": "1zlq1d4zb594nb3hld50cp7kmzfzwmhka01xsbazxagszs61p2sk",
         "type": "tarball",
-        "url": "https://github.com/luc-blaeser/ic/archive/af7331a313bc76a12d0d8bb9e6f8ddc72c2a6b5d.tar.gz",
+        "url": "https://github.com/luc-blaeser/ic/archive/18de74c14491c06499f59404fa5434a18bb9ca50.tar.gz",
         "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
     },
     "ic-hs": {

From 49e7246f6a05f1c07cbe1c0918d4d3a67f12cefe Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 21 Aug 2023 14:48:25 +0200
Subject: [PATCH 049/260] Remove pointer to zero address in text iteration

---
 .../src/continuation_table.rs                 |  4 +--
 .../src/gc/incremental/partitioned_heap.rs    | 20 +++++++++----
 rts/motoko-rts/src/blob_iter.rs               |  9 +++---
 rts/motoko-rts/src/continuation_table.rs      | 12 ++++----
 .../src/gc/incremental/sanity_checks.rs       | 11 +++----
 rts/motoko-rts/src/text_iter.rs               | 30 ++++++++++---------
 rts/motoko-rts/src/types.rs                   | 16 +++-------
 7 files changed, 52 insertions(+), 50 deletions(-)

diff --git a/rts/motoko-rts-tests/src/continuation_table.rs b/rts/motoko-rts-tests/src/continuation_table.rs
index 2decbfd0aae..e8dbcc6b0db 100644
--- a/rts/motoko-rts-tests/src/continuation_table.rs
+++ b/rts/motoko-rts-tests/src/continuation_table.rs
@@ -26,7 +26,7 @@ pub unsafe fn test() {
     }
 
     for i in 0..N / 2 {
-        let c = recall_continuation(references[i]);
+        let c = recall_continuation(&mut heap, references[i]);
         assert_eq!(c.get_ptr(), pointers[i].get_ptr());
         assert_eq!(continuation_count(), (N - i - 1) as u32);
     }
@@ -38,7 +38,7 @@ pub unsafe fn test() {
 
     for i in (0..N).rev() {
         assert_eq!(
-            recall_continuation(references[i]).get_ptr(),
+            recall_continuation(&mut heap, references[i]).get_ptr(),
             pointers[i].get_ptr(),
         );
         assert_eq!(continuation_count(), i as u32);
diff --git a/rts/motoko-rts-tests/src/gc/incremental/partitioned_heap.rs b/rts/motoko-rts-tests/src/gc/incremental/partitioned_heap.rs
index c60f37ac4f9..c0b5bdbadd9 100644
--- a/rts/motoko-rts-tests/src/gc/incremental/partitioned_heap.rs
+++ b/rts/motoko-rts-tests/src/gc/incremental/partitioned_heap.rs
@@ -10,7 +10,9 @@ use motoko_rts::{
             Partition, PartitionedHeap, PartitionedHeapIterator, PARTITION_SIZE,
             SURVIVAL_RATE_THRESHOLD,
         },
+        set_incremental_gc_state,
         time::BoundedTime,
+        IncrementalGC,
     },
     memory::{alloc_array, alloc_blob, Memory},
     types::{Array, Blob, Bytes, Obj, Tag, Value, Words, TAG_ARRAY, TAG_BLOB},
@@ -39,6 +41,7 @@ unsafe fn test_normal_size_scenario() {
     test_survival_rate(&mut heap.inner);
     test_freeing_partitions(&mut heap, HEAP_SIZE / PARTITION_SIZE + 1);
     test_close_partition(&mut heap);
+    set_incremental_gc_state(None);
 }
 
 fn test_allocation_partitions(heap: &PartitionedHeap, number_of_partitions: usize) {
@@ -258,6 +261,9 @@ unsafe fn test_large_size_scenario() {
 unsafe fn test_allocation_sizes(sizes: &[usize], number_of_partitions: usize) {
     let total_partitions = number_of_partitions + 1; // Plus temporary partition.
     let mut heap = PartitionedTestHeap::new(total_partitions * PARTITION_SIZE);
+    let heap_base = heap.heap_base();
+    let state = IncrementalGC::initial_gc_state(&mut heap, heap_base);
+    set_incremental_gc_state(Some(state));
     assert!(heap.inner.occupied_size().as_usize() < PARTITION_SIZE + heap.heap_base());
     let mut time = BoundedTime::new(0);
     heap.inner.start_collection(&mut heap.memory, &mut time);
@@ -279,7 +285,8 @@ unsafe fn test_allocation_sizes(sizes: &[usize], number_of_partitions: usize) {
     heap.inner.complete_collection();
     heap.inner.start_collection(&mut heap.memory, &mut time);
     iterate_large_objects(&heap.inner, &[]);
-    assert!(heap.inner.occupied_size().as_usize() < PARTITION_SIZE + heap.heap_base())
+    assert!(heap.inner.occupied_size().as_usize() < PARTITION_SIZE + heap.heap_base());
+    set_incremental_gc_state(None);
 }
 
 unsafe fn unmark_all_objects(heap: &mut PartitionedTestHeap) {
@@ -329,9 +336,12 @@ unsafe fn occupied_space(partition: &Partition) -> usize {
     occupied_space
 }
 
-fn create_test_heap() -> PartitionedTestHeap {
+unsafe fn create_test_heap() -> PartitionedTestHeap {
     println!("    Create test heap...");
     let mut heap = PartitionedTestHeap::new(HEAP_SIZE);
+    let heap_base = heap.heap_base();
+    let state = IncrementalGC::initial_gc_state(&mut heap, heap_base);
+    set_incremental_gc_state(Some(state));
     let mut time = BoundedTime::new(0);
     unsafe {
         heap.inner.start_collection(&mut heap.memory, &mut time);
@@ -399,7 +409,7 @@ impl PartitionedTestHeap {
             let array = alloc_array(self, elements.len() as u32);
             for index in 0..elements.len() {
                 let raw_array = array.as_array();
-                raw_array.set_scalar(index as u32, elements[index]);
+                raw_array.set(index as u32, elements[index], self);
             }
             array
         }
@@ -428,7 +438,7 @@ impl Memory for PartitionedTestHeap {
         result
     }
 
-    unsafe fn grow_memory(&mut self, _ptr: u64) {
-        unreachable!();
+    unsafe fn grow_memory(&mut self, ptr: u64) {
+        assert!(ptr as usize <= self.memory.heap_end());
     }
 }
diff --git a/rts/motoko-rts/src/blob_iter.rs b/rts/motoko-rts/src/blob_iter.rs
index b63419f3d78..bbcf4296b89 100644
--- a/rts/motoko-rts/src/blob_iter.rs
+++ b/rts/motoko-rts/src/blob_iter.rs
@@ -1,5 +1,6 @@
 use crate::{
     barriers::allocation_barrier,
+    memory::Memory,
     types::{size_of, Array, Bytes, Value, Words, TAG_ARRAY},
 };
 
@@ -21,7 +22,7 @@ unsafe fn blob_iter<M: crate::memory::Memory>(mem: &mut M, blob: Value) -> Value
     (*iter_array).len = 2;
 
     iter_array.initialize(ITER_BLOB_IDX, blob, mem);
-    iter_array.set_scalar(ITER_POS_IDX, Value::from_scalar(0));
+    iter_array.set(ITER_POS_IDX, Value::from_scalar(0), mem);
 
     allocation_barrier(iter_ptr)
 }
@@ -38,14 +39,14 @@ unsafe extern "C" fn blob_iter_done(iter: Value) -> u32 {
 }
 
 /// Reads next byte, advances the iterator
-#[no_mangle]
-unsafe fn blob_iter_next(iter: Value) -> u32 {
+#[ic_mem_fn]
+unsafe fn blob_iter_next<M: Memory>(mem: &mut M, iter: Value) -> u32 {
     let iter_array = iter.as_array();
 
     let blob = iter_array.get(ITER_BLOB_IDX);
     let pos = iter_array.get(ITER_POS_IDX).get_scalar();
 
-    iter_array.set_scalar(ITER_POS_IDX, Value::from_scalar(pos + 1));
+    iter_array.set(ITER_POS_IDX, Value::from_scalar(pos + 1), mem);
 
     blob.as_blob().get(pos).into()
 }
diff --git a/rts/motoko-rts/src/continuation_table.rs b/rts/motoko-rts/src/continuation_table.rs
index 98ec500d085..905942644df 100644
--- a/rts/motoko-rts/src/continuation_table.rs
+++ b/rts/motoko-rts/src/continuation_table.rs
@@ -56,7 +56,7 @@ unsafe fn create_continuation_table<M: Memory>(mem: &mut M) {
 
     let table = TABLE.as_array();
     for i in 0..INITIAL_SIZE {
-        table.set_scalar(i, Value::from_scalar(i + 1));
+        table.set(i, Value::from_scalar(i + 1), mem);
     }
     allocation_barrier(TABLE);
 }
@@ -78,7 +78,7 @@ unsafe fn double_continuation_table<M: Memory>(mem: &mut M) {
     }
 
     for i in old_size..new_size {
-        new_array.set_scalar(i, Value::from_scalar(i + 1));
+        new_array.set(i, Value::from_scalar(i + 1), mem);
     }
     allocation_barrier(new_table);
 
@@ -111,7 +111,7 @@ pub unsafe fn remember_continuation<M: Memory>(mem: &mut M, ptr: Value) -> u32 {
 
     FREE_SLOT = table.get(idx).get_scalar();
 
-    table.set_pointer(idx, ptr, mem);
+    table.set(idx, ptr, mem);
 
     N_CONTINUATIONS += 1;
 
@@ -141,8 +141,8 @@ pub unsafe extern "C" fn peek_future_continuation(idx: u32) -> Value {
     ptr.as_array().get(FUTURE_ARRAY_INDEX)
 }
 
-#[no_mangle]
-pub unsafe fn recall_continuation(idx: u32) -> Value {
+#[ic_mem_fn]
+pub unsafe fn recall_continuation<M: Memory>(mem: &mut M, idx: u32) -> Value {
     if !table_initialized() {
         rts_trap_with("recall_continuation: Continuation table not allocated");
     }
@@ -155,7 +155,7 @@ pub unsafe fn recall_continuation(idx: u32) -> Value {
 
     let ptr = table.get(idx);
 
-    table.set_scalar(idx, Value::from_scalar(FREE_SLOT));
+    table.set(idx, Value::from_scalar(FREE_SLOT), mem);
 
     FREE_SLOT = idx;
 
diff --git a/rts/motoko-rts/src/gc/incremental/sanity_checks.rs b/rts/motoko-rts/src/gc/incremental/sanity_checks.rs
index aa6000bd5ad..eec09d6557a 100644
--- a/rts/motoko-rts/src/gc/incremental/sanity_checks.rs
+++ b/rts/motoko-rts/src/gc/incremental/sanity_checks.rs
@@ -102,13 +102,10 @@ impl<'a, M: Memory> MemoryChecker<'a, M> {
             0,
             |gc, field_address| {
                 let value = *field_address;
-                // Ignore null pointers used in `text_iter`.
-                if value.get_ptr() as *const Obj != null() {
-                    if value.get_ptr() >= gc.heap.base_address() {
-                        gc.check_object(value);
-                    } else {
-                        gc.check_object_header(value);
-                    }
+                if value.is_ptr() {
+                    gc.check_object(value);
+                } else {
+                    gc.check_object_header(value);
                 }
             },
             |_, _, array| array.len(),
diff --git a/rts/motoko-rts/src/text_iter.rs b/rts/motoko-rts/src/text_iter.rs
index 4129f78724f..578cdded890 100644
--- a/rts/motoko-rts/src/text_iter.rs
+++ b/rts/motoko-rts/src/text_iter.rs
@@ -10,13 +10,11 @@
 //! 1. A pointer to the text
 //! 2. 0, or a pointer to the next list entry
 
-use core::ptr::null_mut;
-
 use crate::barriers::allocation_barrier;
 use crate::memory::{alloc_array, Memory};
 use crate::rts_trap_with;
 use crate::text::decode_code_point;
-use crate::types::{Array, Value, TAG_BLOB, TAG_CONCAT};
+use crate::types::{Value, TAG_BLOB, TAG_CONCAT};
 
 use motoko_rts_macros::ic_mem_fn;
 
@@ -50,6 +48,10 @@ const ITER_BLOB_IDX: u32 = 0;
 const ITER_POS_IDX: u32 = 1;
 const ITER_TODO_IDX: u32 = 2;
 
+// Use non-pointer sentinel value as `null` to allow simpler visitor logic.
+// Anlogous to the design of `continuation_table` and `persistence`.
+const NO_OBJECT: Value = Value::from_scalar(0);
+
 /// Returns a new iterator for the text
 #[ic_mem_fn]
 pub unsafe fn text_iter<M: Memory>(mem: &mut M, text: Value) -> Value {
@@ -58,10 +60,10 @@ pub unsafe fn text_iter<M: Memory>(mem: &mut M, text: Value) -> Value {
 
     // Initialize the TODO field first, to be able to use it use the location to `find_leaf`
     let todo_addr = array.payload_addr().add(ITER_TODO_IDX as usize) as *mut _;
-    *todo_addr = Value::from_ptr(null_mut() as *mut Array as usize);
+    *todo_addr = NO_OBJECT;
 
     // Initialize position field
-    array.set_scalar(ITER_POS_IDX, Value::from_scalar(0));
+    array.set(ITER_POS_IDX, Value::from_scalar(0), mem);
 
     // Initialize blob field, no pre-update barrier, but post-update barrier.
     array.initialize(
@@ -80,7 +82,7 @@ pub unsafe extern "C" fn text_iter_done(iter: Value) -> u32 {
     let blob = array.get(ITER_BLOB_IDX).as_blob();
     let todo = array.get(ITER_TODO_IDX);
 
-    if pos >= blob.len().as_u32() && todo.get_ptr() as *mut Array == null_mut() {
+    if pos >= blob.len().as_u32() && todo == NO_OBJECT {
         1
     } else {
         0
@@ -99,7 +101,7 @@ pub unsafe fn text_iter_next<M: Memory>(mem: &mut M, iter: Value) -> u32 {
     if pos >= blob.len().as_u32() {
         let todo = iter_array.get(ITER_TODO_IDX);
 
-        if todo.get_ptr() as *mut Array == null_mut() {
+        if todo == NO_OBJECT {
             // Caller should check with text_iter_done
             rts_trap_with("text_iter_next: Iter already done");
         }
@@ -113,11 +115,11 @@ pub unsafe fn text_iter_next<M: Memory>(mem: &mut M, iter: Value) -> u32 {
             // allocation)
             let concat = text.as_concat();
 
-            todo_array.set_pointer(TODO_TEXT_IDX, (*concat).text2, mem);
-            iter_array.set_scalar(ITER_POS_IDX, Value::from_scalar(0));
+            todo_array.set(TODO_TEXT_IDX, (*concat).text2, mem);
+            iter_array.set(ITER_POS_IDX, Value::from_scalar(0), mem);
             let todo_addr = iter_array.payload_addr().add(ITER_TODO_IDX as usize);
 
-            iter_array.set_pointer(
+            iter_array.set(
                 ITER_BLOB_IDX,
                 find_leaf(mem, (*concat).text1, todo_addr),
                 mem,
@@ -128,10 +130,10 @@ pub unsafe fn text_iter_next<M: Memory>(mem: &mut M, iter: Value) -> u32 {
             // Otherwise remove the entry from the chain
             debug_assert_eq!(text.tag(), TAG_BLOB);
 
-            iter_array.set_pointer(ITER_BLOB_IDX, text, mem);
-            iter_array.set_scalar(ITER_POS_IDX, Value::from_scalar(0));
+            iter_array.set(ITER_BLOB_IDX, text, mem);
+            iter_array.set(ITER_POS_IDX, Value::from_scalar(0), mem);
 
-            iter_array.set_pointer(ITER_TODO_IDX, todo_array.get(TODO_LINK_IDX), mem);
+            iter_array.set(ITER_TODO_IDX, todo_array.get(TODO_LINK_IDX), mem);
 
             text_iter_next(mem, iter)
         }
@@ -140,7 +142,7 @@ pub unsafe fn text_iter_next<M: Memory>(mem: &mut M, iter: Value) -> u32 {
         let blob_payload = blob.payload_const();
         let mut step: u32 = 0;
         let char = decode_code_point(blob_payload.add(pos as usize), &mut step as *mut u32);
-        iter_array.set_scalar(ITER_POS_IDX, Value::from_scalar(pos + step));
+        iter_array.set(ITER_POS_IDX, Value::from_scalar(pos + step), mem);
         char
     }
 }
diff --git a/rts/motoko-rts/src/types.rs b/rts/motoko-rts/src/types.rs
index 4efb03104a5..a9715a42420 100644
--- a/rts/motoko-rts/src/types.rs
+++ b/rts/motoko-rts/src/types.rs
@@ -504,23 +504,15 @@ impl Array {
         init_with_barrier(mem, slot_addr, value);
     }
 
-    /// Write a pointer value to an array element.
-    /// Uses a incremental pre-update barrier and a generational post-update barrier.
+    /// Write a value to an array element.
+    /// The written and overwritten value can be a scalar or a pointer.
+    /// Applies an incremental pre-update barrier when needed.
     /// Resolves pointer forwarding for the written value.
-    pub unsafe fn set_pointer<M: Memory>(self: *mut Self, idx: u32, value: Value, mem: &mut M) {
-        debug_assert!(value.is_ptr());
+    pub unsafe fn set<M: Memory>(self: *mut Self, idx: u32, value: Value, mem: &mut M) {
         let slot_addr = self.element_address(idx) as *mut Value;
         write_with_barrier(mem, slot_addr, value);
     }
 
-    /// Write a scalar value to an array element.
-    /// No need for a write barrier.
-    pub unsafe fn set_scalar(self: *mut Self, idx: u32, value: Value) {
-        debug_assert!(value.is_scalar());
-        let slot_addr = self.element_address(idx);
-        *(slot_addr as *mut Value) = value;
-    }
-
     #[inline]
     unsafe fn element_address(self: *const Self, idx: u32) -> usize {
         debug_assert!(self.len() > idx);

From 7f011625e15dcf1b3e39d5fd604c56cc1b8bf8dd Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 21 Aug 2023 15:03:07 +0200
Subject: [PATCH 050/260] Restore stable memory size

---
 src/codegen/compile.ml | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 8b84209a9d2..666ea440705 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -6762,6 +6762,11 @@ end (* MakeSerialization *)
 module Serialization = MakeSerialization(BumpStream)
 
 module Stabilization = struct
+  let restore_stable_memory env =
+    (* TODO: Check version and if needed, migrate from old serialized stable format. *)
+    IC.system_call env "stable64_size" ^^
+    StableMem.set_mem_size env
+
   let load_stable_actor env = E.call_import env "rts" "load_stable_actor"
     
   let save_stable_actor env = E.call_import env "rts" "save_stable_actor"
@@ -6780,9 +6785,10 @@ module Stabilization = struct
   let destabilize env t =
     load_stable_actor env ^^
     G.i (Test (Wasm.Values.I32 I32Op.Eqz)) ^^
-    G.if1 I32Type
+    (G.if1 I32Type
       (empty_actor env t)
-      (load_stable_actor env)
+      (load_stable_actor env)) ^^
+    restore_stable_memory env
 end
 
 (*

From 483cd4060ee6affcd8fe7495e20a0c901a5d3a71 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 21 Aug 2023 15:11:52 +0200
Subject: [PATCH 051/260] Adjust test, serialization no longer overflowing

---
 ...low.drun-run.ok => stable-size-no-overflow.drun-run.ok} | 2 +-
 test/run-drun/ok/stable-size-overflow.ic-ref-run.ok        | 7 -------
 ...{stable-size-overflow.mo => stable-size-no-overflow.mo} | 0
 3 files changed, 1 insertion(+), 8 deletions(-)
 rename test/run-drun/ok/{stable-size-overflow.drun-run.ok => stable-size-no-overflow.drun-run.ok} (60%)
 delete mode 100644 test/run-drun/ok/stable-size-overflow.ic-ref-run.ok
 rename test/run-drun/{stable-size-overflow.mo => stable-size-no-overflow.mo} (100%)

diff --git a/test/run-drun/ok/stable-size-overflow.drun-run.ok b/test/run-drun/ok/stable-size-no-overflow.drun-run.ok
similarity index 60%
rename from test/run-drun/ok/stable-size-overflow.drun-run.ok
rename to test/run-drun/ok/stable-size-no-overflow.drun-run.ok
index 3969ab1cb07..fc0ac7dc610 100644
--- a/test/run-drun/ok/stable-size-overflow.drun-run.ok
+++ b/test/run-drun/ok/stable-size-no-overflow.drun-run.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
 debug.print: upgrading...
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: buffer_size overflow
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/stable-size-overflow.ic-ref-run.ok b/test/run-drun/ok/stable-size-overflow.ic-ref-run.ok
deleted file mode 100644
index 75b91bf6b36..00000000000
--- a/test/run-drun/ok/stable-size-overflow.ic-ref-run.ok
+++ /dev/null
@@ -1,7 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-debug.print: upgrading...
-<= rejected (RC_CANISTER_ERROR): Pre-upgrade trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: buffer_size overflow"
diff --git a/test/run-drun/stable-size-overflow.mo b/test/run-drun/stable-size-no-overflow.mo
similarity index 100%
rename from test/run-drun/stable-size-overflow.mo
rename to test/run-drun/stable-size-no-overflow.mo

From c563ae5a94311569098a4ecefed72281f640e3be Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 21 Aug 2023 15:21:38 +0200
Subject: [PATCH 052/260] Support `--force-gc` mode again

---
 src/codegen/compile.ml       | 4 +++-
 test/run-drun/empty-actor.mo | 2 +-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 666ea440705..51eac1a4e73 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -579,7 +579,9 @@ module E = struct
     Int32.(add (div (get_end_of_static_memory env) page_size) 1l)
 
   let collect_garbage env =
-    call_import env "rts" "schedule_incremental_gc"
+    let name = "incremental_gc" in
+    let gc_fn = if !Flags.force_gc then name else "schedule_" ^ name in
+    call_import env "rts" gc_fn
 
   (* See Note [Candid subtype checks] *)
   (* NB: we don't bother detecting duplicate registrations here because the code sharing machinery
diff --git a/test/run-drun/empty-actor.mo b/test/run-drun/empty-actor.mo
index f4a85e0220a..31684809b4f 100644
--- a/test/run-drun/empty-actor.mo
+++ b/test/run-drun/empty-actor.mo
@@ -9,7 +9,7 @@ actor {};
 // CHECK-NEXT:    i32.const 0
 // CHECK-NEXT:    call 32
 // CHECK-NEXT:    global.set 4
-// CHECK-NEXT:    call ${{copying_gc|compacting_gc|generational_gc|incremental_gc}}
+// CHECK-NEXT:    call $incremental_gc
 // CHECK-NEXT:    i32.const 0
 // CHECK-NEXT:    call 32
 // CHECK-NEXT:    global.get 4

From e57ad63c64276327c1d6e718ff0cb7239d8ae7d6 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Tue, 22 Aug 2023 16:13:07 +0200
Subject: [PATCH 053/260] More descriptive error when exceeding data segment
 capacity

---
 src/linking/linkModule.ml | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/linking/linkModule.ml b/src/linking/linkModule.ml
index 0cf3f7ddfb5..7f6656a8163 100644
--- a/src/linking/linkModule.ml
+++ b/src/linking/linkModule.ml
@@ -767,7 +767,11 @@ let link (em1 : extended_module) libname (em2 : extended_module) =
   let new_heap_start = align 4l (Int32.add lib_heap_start dylink.memory_size) in
 
   (* Data segments must fit below 4MB according to the persistent heap layout. *)
-  assert ((Int32.to_int new_heap_start) <= 4 * 1024 * 1024);
+  (if (Int32.to_int new_heap_start) > 4 * 1024 * 1024 then
+    (raise (LinkError "The Wasm data segment size exceeds the supported maxmimum of 2MB."))
+  else
+    ()
+  );
 
   let old_table_size = read_table_size em1.module_ in
   let lib_table_start = align dylink.table_alignment old_table_size in

From c073d29c5387232bd31ca571ac223fcf82bbd533 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Tue, 22 Aug 2023 16:14:06 +0200
Subject: [PATCH 054/260] Adjust test

---
 test/run-drun/class-import.mo               | 11 +++--------
 test/run-drun/ok/class-import.drun-run.ok   |  2 --
 test/run-drun/ok/class-import.ic-ref-run.ok |  2 --
 3 files changed, 3 insertions(+), 12 deletions(-)

diff --git a/test/run-drun/class-import.mo b/test/run-drun/class-import.mo
index cad8c448449..24d757f97f3 100644
--- a/test/run-drun/class-import.mo
+++ b/test/run-drun/class-import.mo
@@ -2,8 +2,9 @@ import Prim "mo:⛔";
 import Cycles = "cycles/cycles";
 import M0 "class-import/empty";
 import M1 "class-import/one";
-import M2 "class-import/two";
 import M3 "class-import/trap";
+// Too many class imports exceed the maximum data segment size of 2MB,
+// in particular if they are compiled with sanity checks.
 
 actor a {
  public func go() : async () {
@@ -21,11 +22,6 @@ actor a {
    let one : M1.One = await M1.One("one");
    await one.test();
 
-   // test two arg class
-   Cycles.add(2_000_000_000_000);
-   let two : M2.Two = await M2.Two("one","two");
-   await two.test();
-
    // test non-trapping install
    try {
      Cycles.add(2_000_000_000_000);
@@ -54,8 +50,7 @@ a.go() //OR-CALL ingress go "DIDL\x00\x00"
 //SKIP run-ir
 //SKIP run-low
 
-// check exactly 4 embedded wasms
-//CHECK:  canister_update __motoko_async_helper
+// check exactly 3 embedded wasms
 //CHECK:  canister_update __motoko_async_helper
 //CHECK:  canister_update __motoko_async_helper
 //CHECK:  canister_update __motoko_async_helper
diff --git a/test/run-drun/ok/class-import.drun-run.ok b/test/run-drun/ok/class-import.drun-run.ok
index d6c7ff9471d..b75ebe214aa 100644
--- a/test/run-drun/ok/class-import.drun-run.ok
+++ b/test/run-drun/ok/class-import.drun-run.ok
@@ -4,7 +4,5 @@ debug.print: empty
 debug.print: () tested
 debug.print: one
 debug.print: "one" tested
-debug.print: ("one", "two")
-debug.print: ("one", "two")tested
 debug.print: caught trap
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/class-import.ic-ref-run.ok b/test/run-drun/ok/class-import.ic-ref-run.ok
index 96aaf64f1b2..ae5bde48e56 100644
--- a/test/run-drun/ok/class-import.ic-ref-run.ok
+++ b/test/run-drun/ok/class-import.ic-ref-run.ok
@@ -7,7 +7,5 @@ debug.print: empty
 debug.print: () tested
 debug.print: one
 debug.print: "one" tested
-debug.print: ("one", "two")
-debug.print: ("one", "two")tested
 debug.print: caught trap
 <= replied: ()

From ab675a55d98b3eddad739d4ae77fc4972b15da9f Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 25 Aug 2023 13:39:27 +0200
Subject: [PATCH 055/260] Place object field hashes into dynamic heap

---
 rts/motoko-rts/src/debug.rs   |   2 +-
 rts/motoko-rts/src/types.rs   |   6 +-
 rts/motoko-rts/src/visitor.rs |   2 +
 src/codegen/compile.ml        | 368 +++++++++++++++++-----------------
 4 files changed, 195 insertions(+), 183 deletions(-)

diff --git a/rts/motoko-rts/src/debug.rs b/rts/motoko-rts/src/debug.rs
index 4c36a959bea..b15dc1c5510 100644
--- a/rts/motoko-rts/src/debug.rs
+++ b/rts/motoko-rts/src/debug.rs
@@ -143,7 +143,7 @@ pub(crate) unsafe fn print_boxed_object(buf: &mut WriteBuf, p: usize) {
                 buf,
                 "<Object size={:#x} hash_ptr={:#x} field=[",
                 (*object).size,
-                (*object).hash_ptr
+                (*object).hash_blob.get_raw()
             );
             for i in 0..object.size() {
                 let val = object.get(i);
diff --git a/rts/motoko-rts/src/types.rs b/rts/motoko-rts/src/types.rs
index a9715a42420..e42e4566bd8 100644
--- a/rts/motoko-rts/src/types.rs
+++ b/rts/motoko-rts/src/types.rs
@@ -528,10 +528,14 @@ impl Array {
 pub struct Object {
     pub header: Obj,
     pub size: u32,     // Number of elements
-    pub hash_ptr: u32, // Pointer to static information about object field labels. Not important for GC (does not contain pointers).
+    pub hash_blob: Value, // Pointer to a blob containing the hashes of the object field labels.
 }
 
 impl Object {
+    pub unsafe fn hash_blob_addr(self: *mut Self) -> *mut Value {
+        &mut (*self).hash_blob
+    }
+
     pub unsafe fn payload_addr(self: *mut Self) -> *mut Value {
         self.add(1) as *mut Value // skip object header
     }
diff --git a/rts/motoko-rts/src/visitor.rs b/rts/motoko-rts/src/visitor.rs
index 00d2d2fc09d..aee48bc3046 100644
--- a/rts/motoko-rts/src/visitor.rs
+++ b/rts/motoko-rts/src/visitor.rs
@@ -32,6 +32,8 @@ pub unsafe fn visit_pointer_fields<C, F, G>(
     match tag {
         TAG_OBJECT => {
             let obj = obj as *mut Object;
+            debug_assert!(is_pointer_field(obj.hash_blob_addr()));
+            visit_ptr_field(ctx, obj.hash_blob_addr());
             let obj_payload = obj.payload_addr();
             for i in 0..obj.size() {
                 let field_addr = obj_payload.add(i as usize);
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 51eac1a4e73..057096758b8 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -3251,187 +3251,6 @@ module Prim = struct
     TaggedSmallWord.shift_leftWordNtoI32 b
 end (* Prim *)
 
-module Object = struct
- (* An object with a mutable field1 and immutable field 2 has the following
-    heap layout:
-
-    ┌──────┬─────┬──────────┬──────────┬─────────┬─────────────┬───┐
-    │ obj header │ n_fields │ hash_ptr │ ind_ptr │ field2_data │ … │
-    └──────┴─────┴──────────┴┬─────────┴┬────────┴─────────────┴───┘
-         ┌───────────────────┘          │
-         │   ┌──────────────────────────┘
-         │   ↓
-         │  ╶─┬────────┬─────────────┐
-         │    │ ObjInd │ field1_data │
-         ↓    └────────┴─────────────┘
-        ╶─┬─────────────┬─────────────┬───┐
-          │ field1_hash │ field2_hash │ … │
-          └─────────────┴─────────────┴───┘
-
-    The object header includes the object tag (Object) and the forwarding pointer.
-
-    The field hash array lives in static memory (so no size header needed).
-    The hash_ptr is skewed.
-
-    The field2_data for immutable fields is a vanilla word.
-
-    The field1_data for mutable fields are pointers to either an ObjInd, or a
-    MutBox (they have the same layout). This indirection is a consequence of
-    how we compile object literals with `await` instructions, as these mutable
-    fields need to be able to alias local mutable variables.
-
-    We could alternatively switch to an allocate-first approach in the
-    await-translation of objects, and get rid of this indirection -- if it were
-    not for the implementing of sharing of mutable stable values.
-  *)
-
-  let header_size = Int32.add Tagged.header_size 2l
-
-  (* Number of object fields *)
-  let size_field = Int32.add Tagged.header_size 0l
-  let hash_ptr_field = Int32.add Tagged.header_size 1l
-
-  module FieldEnv = Env.Make(String)
-
-  (* This is for non-recursive objects, i.e. ObjNewE *)
-  (* The instructions in the field already create the indirection if needed *)
-  let lit_raw env (fs : (string * (unit -> G.t)) list ) =
-    let name_pos_map =
-      fs |>
-      (* We could store only public fields in the object, but
-         then we need to allocate separate boxes for the non-public ones:
-         List.filter (fun (_, vis, f) -> vis.it = Public) |>
-      *)
-      List.map (fun (n,_) -> (E.hash env n, n)) |>
-      List.sort compare |>
-      List.mapi (fun i (_h,n) -> (n,Int32.of_int i)) |>
-      List.fold_left (fun m (n,i) -> FieldEnv.add n i m) FieldEnv.empty in
-
-    let sz = Int32.of_int (FieldEnv.cardinal name_pos_map) in
-
-    (* Create hash array *)
-    let hashes = fs |>
-      List.map (fun (n,_) -> E.hash env n) |>
-      List.sort compare in
-    let hash_ptr = E.add_static env StaticBytes.[ i32s hashes ] in
-
-    (* Allocate memory *)
-    let (set_ri, get_ri, ri) = new_local_ env I32Type "obj" in
-    Tagged.alloc env (Int32.add header_size sz) Tagged.Object ^^
-    set_ri ^^
-
-    (* Set size *)
-    get_ri ^^
-    compile_unboxed_const sz ^^
-    Tagged.store_field env size_field ^^
-
-    (* Set hash_ptr *)
-    get_ri ^^
-    compile_unboxed_const hash_ptr ^^
-    Tagged.store_field env hash_ptr_field ^^
-
-    (* Write all the fields *)
-    let init_field (name, mk_is) : G.t =
-      (* Write the pointer to the indirection *)
-      get_ri ^^
-      mk_is () ^^
-      let i = FieldEnv.find name name_pos_map in
-      let offset = Int32.add header_size i in
-      Tagged.store_field env offset
-    in
-    G.concat_map init_field fs ^^
-
-    (* Return the pointer to the object *)
-    get_ri ^^
-    Tagged.allocation_barrier env
-
-  (* Returns a pointer to the object field (without following the field indirection) *)
-  let idx_hash_raw env low_bound =
-    let name = Printf.sprintf "obj_idx<%d>" low_bound  in
-    Func.share_code2 env name (("x", I32Type), ("hash", I32Type)) [I32Type] (fun env get_x get_hash ->
-      let set_x = G.setter_for get_x in
-      let set_h_ptr, get_h_ptr = new_local env "h_ptr" in
-
-      get_x ^^ Tagged.load_forwarding_pointer env ^^ set_x ^^
-
-      get_x ^^ Tagged.load_field env hash_ptr_field ^^
-
-      (* Linearly scan through the fields (binary search can come later) *)
-      (* unskew h_ptr and advance both to low bound *)
-      compile_add_const Int32.(add ptr_unskew (mul Heap.word_size (of_int low_bound))) ^^
-      set_h_ptr ^^
-      get_x ^^
-      compile_add_const Int32.(mul Heap.word_size (add header_size (of_int low_bound))) ^^
-      set_x ^^
-      G.loop0 (
-          get_h_ptr ^^ load_unskewed_ptr ^^
-          get_hash ^^ G.i (Compare (Wasm.Values.I32 I32Op.Eq)) ^^
-          G.if0
-            (get_x ^^ G.i Return)
-            (get_h_ptr ^^ compile_add_const Heap.word_size ^^ set_h_ptr ^^
-             get_x ^^ compile_add_const Heap.word_size ^^ set_x ^^
-             G.i (Br (nr 1l)))
-        ) ^^
-      G.i Unreachable
-    )
-
-  (* Returns a pointer to the object field (possibly following the indirection) *)
-  let idx_hash env low_bound indirect =
-    if indirect
-    then
-      let name = Printf.sprintf "obj_idx_ind<%d>" low_bound in
-      Func.share_code2 env name (("x", I32Type), ("hash", I32Type)) [I32Type] (fun env get_x get_hash ->
-      get_x ^^ get_hash ^^
-      idx_hash_raw env low_bound ^^
-      load_ptr ^^ Tagged.load_forwarding_pointer env ^^
-      compile_add_const (Int32.mul MutBox.field Heap.word_size)
-    )
-    else idx_hash_raw env low_bound
-
-  let field_type env obj_type s =
-    let _, fields = Type.as_obj_sub [s] obj_type in
-    Type.lookup_val_field s fields
-
-  (* Determines whether the field is mutable (and thus needs an indirection) *)
-  let is_mut_field env obj_type s =
-    let _, fields = Type.as_obj_sub [s] obj_type in
-    Type.is_mut (Type.lookup_val_field s fields)
-
-  (* Computes a lower bound for the positional index of a field in an object *)
-  let field_lower_bound env obj_type s =
-    let open Type in
-    let _, fields = as_obj_sub [s] obj_type in
-    List.iter (function {typ = Typ _; _} -> assert false | _ -> ()) fields;
-    let sorted_by_hash =
-      List.sort
-        (fun (h1, _) (h2, _) -> Lib.Uint32.compare h1 h2)
-        (List.map (fun f -> Lib.Uint32.of_int32 (E.hash env f.lab), f) fields) in
-    match Lib.List.index_of s (List.map (fun (_, {lab; _}) -> lab) sorted_by_hash) with
-    | Some i -> i
-    | _ -> assert false
-
-  (* Returns a pointer to the object field (without following the indirection) *)
-  let idx_raw env f =
-    compile_unboxed_const (E.hash env f) ^^
-    idx_hash_raw env 0
-
-  (* Returns a pointer to the object field (possibly following the indirection) *)
-  let idx env obj_type f =
-    compile_unboxed_const (E.hash env f) ^^
-    idx_hash env (field_lower_bound env obj_type f) (is_mut_field env obj_type f)
-
-  (* load the value (or the mutbox) *)
-  let load_idx_raw env f =
-    idx_raw env f ^^
-    load_ptr
-
-  (* load the actual value (dereferencing the mutbox) *)
-  let load_idx env obj_type f =
-    idx env obj_type f ^^
-    load_ptr
-
-end (* Object *)
-
 module Blob = struct
   (* The layout of a blob object is
 
@@ -3632,6 +3451,193 @@ module Blob = struct
 
 end (* Blob *)
 
+module Object = struct
+  (* An object with a mutable field1 and immutable field 2 has the following
+     heap layout:
+ 
+     ┌──────┬─────┬──────────┬──────────┬─────────┬─────────────┬───┐
+     │ obj header │ n_fields │ hash_ptr │ ind_ptr │ field2_data │ … │
+     └──────┴─────┴──────────┴┬─────────┴┬────────┴─────────────┴───┘
+          ┌───────────────────┘          │
+          │   ┌──────────────────────────┘
+          │   ↓
+          │  ╶─┬────────┬─────────────┐
+          │    │ ObjInd │ field1_data │
+          ↓    └────────┴─────────────┘
+          ┌─────────────┬─────────────┬─────────────┬───┐
+          │ blob header │ field1_hash │ field2_hash │ … │
+          └─────────────┴─────────────┴─────────────┴───┘        
+ 
+     The object header includes the object tag (Object) and the forwarding pointer.
+ 
+     The field hashes reside in a blob inside the dynamic heap.
+     The hash blob needs to be tracked by the GC, but not the content of the hash blob.
+     This is because the hash values are plain numbers that would look like skewed pointers.ters.
+     The hash_ptr is skewed.
+     TODO: Optimize by sharing the hash blob for objects of the same type.
+ 
+     The field2_data for immutable fields is a vanilla word.
+ 
+     The field1_data for mutable fields are pointers to either an ObjInd, or a
+     MutBox (they have the same layout). This indirection is a consequence of
+     how we compile object literals with `await` instructions, as these mutable
+     fields need to be able to alias local mutable variables.
+ 
+     We could alternatively switch to an allocate-first approach in the
+     await-translation of objects, and get rid of this indirection -- if it were
+     not for the implementing of sharing of mutable stable values.
+   *)
+ 
+  let header_size = Int32.add Tagged.header_size 2l
+ 
+  (* Number of object fields *)
+  let size_field = Int32.add Tagged.header_size 0l
+  let hash_ptr_field = Int32.add Tagged.header_size 1l
+ 
+  module FieldEnv = Env.Make(String)
+ 
+  (* This is for non-recursive objects, i.e. ObjNewE *)
+  (* The instructions in the field already create the indirection if needed *)
+  let lit_raw env (fs : (string * (unit -> G.t)) list ) =
+    let name_pos_map =
+      fs |>
+        (* We could store only public fields in the object, but
+          then we need to allocate separate boxes for the non-public ones:
+          List.filter (fun (_, vis, f) -> vis.it = Public) |>
+        *)
+        List.map (fun (n,_) -> (E.hash env n, n)) |>
+        List.sort compare |>
+        List.mapi (fun i (_h,n) -> (n,Int32.of_int i)) |>
+        List.fold_left (fun m (n,i) -> FieldEnv.add n i m) FieldEnv.empty in
+
+      let sz = Int32.of_int (FieldEnv.cardinal name_pos_map) in
+
+      (* Create hash blob *)
+      let hashes = fs |>
+        List.map (fun (n,_) -> E.hash env n) |>
+        List.sort compare in
+      let hash_blob env =
+        let hash_payload = StaticBytes.[ i32s hashes ] in
+        Blob.lit env (StaticBytes.as_bytes hash_payload) in
+
+      (* Allocate memory *)
+      let (set_ri, get_ri, ri) = new_local_ env I32Type "obj" in
+      Tagged.alloc env (Int32.add header_size sz) Tagged.Object ^^
+      set_ri ^^
+
+      (* Set size *)
+      get_ri ^^
+      compile_unboxed_const sz ^^
+      Tagged.store_field env size_field ^^
+
+      (* Set hash_ptr *)
+      get_ri ^^
+      hash_blob env ^^
+      Tagged.store_field env hash_ptr_field ^^
+
+      (* Write all the fields *)
+      let init_field (name, mk_is) : G.t =
+        (* Write the pointer to the indirection *)
+        get_ri ^^
+        mk_is () ^^
+        let i = FieldEnv.find name name_pos_map in
+        let offset = Int32.add header_size i in
+        Tagged.store_field env offset
+      in
+      G.concat_map init_field fs ^^
+
+      (* Return the pointer to the object *)
+      get_ri ^^
+      Tagged.allocation_barrier env
+ 
+  (* Returns a pointer to the object field (without following the field indirection) *)
+  let idx_hash_raw env low_bound =
+    let name = Printf.sprintf "obj_idx<%d>" low_bound  in
+    Func.share_code2 env name (("x", I32Type), ("hash", I32Type)) [I32Type] (fun env get_x get_hash ->
+      let set_x = G.setter_for get_x in
+      let set_h_ptr, get_h_ptr = new_local env "h_ptr" in
+
+      get_x ^^ Tagged.load_forwarding_pointer env ^^ set_x ^^
+
+      get_x ^^ Tagged.load_field env hash_ptr_field ^^
+      Blob.payload_ptr_unskewed env ^^
+
+      (* Linearly scan through the fields (binary search can come later) *)
+      (* unskew h_ptr and advance both to low bound *)
+      compile_add_const Int32.(mul Heap.word_size (of_int low_bound)) ^^
+      set_h_ptr ^^
+      get_x ^^
+      compile_add_const Int32.(mul Heap.word_size (add header_size (of_int low_bound))) ^^
+      set_x ^^
+      G.loop0 (
+          get_h_ptr ^^ load_unskewed_ptr ^^
+          get_hash ^^ G.i (Compare (Wasm.Values.I32 I32Op.Eq)) ^^
+          G.if0
+            (get_x ^^ G.i Return)
+            (get_h_ptr ^^ compile_add_const Heap.word_size ^^ set_h_ptr ^^
+            get_x ^^ compile_add_const Heap.word_size ^^ set_x ^^
+            G.i (Br (nr 1l)))
+        ) ^^
+      G.i Unreachable
+    )
+
+  (* Returns a pointer to the object field (possibly following the indirection) *)
+  let idx_hash env low_bound indirect =
+    if indirect
+    then
+      let name = Printf.sprintf "obj_idx_ind<%d>" low_bound in
+      Func.share_code2 env name (("x", I32Type), ("hash", I32Type)) [I32Type] (fun env get_x get_hash ->
+      get_x ^^ get_hash ^^
+      idx_hash_raw env low_bound ^^
+      load_ptr ^^ Tagged.load_forwarding_pointer env ^^
+      compile_add_const (Int32.mul MutBox.field Heap.word_size)
+    )
+    else idx_hash_raw env low_bound
+
+  let field_type env obj_type s =
+    let _, fields = Type.as_obj_sub [s] obj_type in
+    Type.lookup_val_field s fields
+
+  (* Determines whether the field is mutable (and thus needs an indirection) *)
+  let is_mut_field env obj_type s =
+    let _, fields = Type.as_obj_sub [s] obj_type in
+    Type.is_mut (Type.lookup_val_field s fields)
+
+  (* Computes a lower bound for the positional index of a field in an object *)
+  let field_lower_bound env obj_type s =
+    let open Type in
+    let _, fields = as_obj_sub [s] obj_type in
+    List.iter (function {typ = Typ _; _} -> assert false | _ -> ()) fields;
+    let sorted_by_hash =
+      List.sort
+        (fun (h1, _) (h2, _) -> Lib.Uint32.compare h1 h2)
+        (List.map (fun f -> Lib.Uint32.of_int32 (E.hash env f.lab), f) fields) in
+    match Lib.List.index_of s (List.map (fun (_, {lab; _}) -> lab) sorted_by_hash) with
+    | Some i -> i
+    | _ -> assert false
+
+  (* Returns a pointer to the object field (without following the indirection) *)
+  let idx_raw env f =
+    compile_unboxed_const (E.hash env f) ^^
+    idx_hash_raw env 0
+
+  (* Returns a pointer to the object field (possibly following the indirection) *)
+  let idx env obj_type f =
+    compile_unboxed_const (E.hash env f) ^^
+    idx_hash env (field_lower_bound env obj_type f) (is_mut_field env obj_type f)
+
+  (* load the value (or the mutbox) *)
+  let load_idx_raw env f =
+    idx_raw env f ^^
+    load_ptr
+
+  (* load the actual value (dereferencing the mutbox) *)
+  let load_idx env obj_type f =
+    idx env obj_type f ^^
+    load_ptr
+ 
+end (* Object *) 
+
 module Text = struct
   (*
   Most of the heavy lifting around text values is in rts/motoko-rts/src/text.rs

From 80deb710103c23137aea0ec9b5b7fa3ede41a780 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 25 Aug 2023 13:40:43 +0200
Subject: [PATCH 056/260] Bug fix in debug output

---
 rts/motoko-rts/src/debug.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/rts/motoko-rts/src/debug.rs b/rts/motoko-rts/src/debug.rs
index b15dc1c5510..dbe0b760118 100644
--- a/rts/motoko-rts/src/debug.rs
+++ b/rts/motoko-rts/src/debug.rs
@@ -123,13 +123,14 @@ unsafe fn print_tagged_scalar(buf: &mut WriteBuf, p: u32) {
 pub(crate) unsafe fn print_boxed_object(buf: &mut WriteBuf, p: usize) {
     let _ = write!(buf, "{:#x}: ", p);
 
-    let forward = (*(p as *mut Value)).forward();
+
+    let obj = p as *mut Obj;
+    let forward = (*obj).forward;
     if forward.get_ptr() != p {
         let _ = write!(buf, "<forwarded to {:#x}>", forward.get_ptr());
         return;
     }
 
-    let obj = p as *mut Obj;
     let tag = obj.tag();
 
     if tag == 0 {

From b221fba7c9c9af2cdc2cb3c920003fd13bd794ce Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 25 Aug 2023 13:41:00 +0200
Subject: [PATCH 057/260] Reformat

---
 rts/motoko-rts/src/debug.rs | 1 -
 rts/motoko-rts/src/types.rs | 2 +-
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/rts/motoko-rts/src/debug.rs b/rts/motoko-rts/src/debug.rs
index dbe0b760118..07426c387a8 100644
--- a/rts/motoko-rts/src/debug.rs
+++ b/rts/motoko-rts/src/debug.rs
@@ -123,7 +123,6 @@ unsafe fn print_tagged_scalar(buf: &mut WriteBuf, p: u32) {
 pub(crate) unsafe fn print_boxed_object(buf: &mut WriteBuf, p: usize) {
     let _ = write!(buf, "{:#x}: ", p);
 
-
     let obj = p as *mut Obj;
     let forward = (*obj).forward;
     if forward.get_ptr() != p {
diff --git a/rts/motoko-rts/src/types.rs b/rts/motoko-rts/src/types.rs
index e42e4566bd8..8784b2eacab 100644
--- a/rts/motoko-rts/src/types.rs
+++ b/rts/motoko-rts/src/types.rs
@@ -527,7 +527,7 @@ impl Array {
 #[repr(C)] // See the note at the beginning of this module
 pub struct Object {
     pub header: Obj,
-    pub size: u32,     // Number of elements
+    pub size: u32,        // Number of elements
     pub hash_blob: Value, // Pointer to a blob containing the hashes of the object field labels.
 }
 

From ca920edfbce492db306aff73ad89a76b7439bbdd Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 25 Aug 2023 15:32:27 +0200
Subject: [PATCH 058/260] Allow adding stable actor fields

---
 rts/motoko-rts/src/persistence.rs | 20 ++++++++++++++
 rts/motoko-rts/src/types.rs       |  7 +++++
 src/codegen/compile.ml            | 43 +++++++++++++++++++++++--------
 3 files changed, 59 insertions(+), 11 deletions(-)

diff --git a/rts/motoko-rts/src/persistence.rs b/rts/motoko-rts/src/persistence.rs
index f3ff0ffef9e..50861495996 100644
--- a/rts/motoko-rts/src/persistence.rs
+++ b/rts/motoko-rts/src/persistence.rs
@@ -130,6 +130,26 @@ pub(crate) unsafe fn stable_actor_location() -> *mut Value {
     &mut (*metadata).stable_actor as *mut Value
 }
 
+#[no_mangle]
+#[cfg(feature = "ic")]
+pub unsafe extern "C" fn contains_field(actor: Value, field_hash: u32) -> bool {
+    use crate::constants::WORD_SIZE;
+
+    let object = actor.as_object();
+    let hash_blob = (*object).hash_blob.as_blob();
+    assert_eq!(hash_blob.len().as_u32() % WORD_SIZE, 0);
+    let number_of_fields = hash_blob.len().as_u32() / WORD_SIZE;
+    let mut current_address = hash_blob.payload_const() as u32;
+    for _ in 0..number_of_fields {
+        let hash_address = current_address as *mut u32;
+        if *hash_address == field_hash {
+            return true;
+        }
+        current_address += WORD_SIZE;
+    }
+    false
+}
+
 unsafe fn alloc_null<M: Memory>(mem: &mut M) -> Value {
     let value = mem.alloc_words(size_of::<Null>());
     debug_assert!(value.get_ptr() >= HEAP_START);
diff --git a/rts/motoko-rts/src/types.rs b/rts/motoko-rts/src/types.rs
index 8784b2eacab..5d1800736f3 100644
--- a/rts/motoko-rts/src/types.rs
+++ b/rts/motoko-rts/src/types.rs
@@ -333,6 +333,13 @@ impl Value {
         self.forward().get_ptr() as *mut Array
     }
 
+    /// Get the pointer as `Object` using forwarding. In debug mode panics if the value is not a pointer.
+    pub unsafe fn as_object(self) -> *mut Object {
+        debug_assert!(self.get().is_ptr());
+        self.check_forwarding_pointer();
+        self.forward().get_ptr() as *mut Object
+    }
+
     /// Get the pointer as `Concat` using forwarding. In debug mode panics if the value is not a pointer or the
     /// pointed object is not a `Concat`.
     pub unsafe fn as_concat(self) -> *const Concat {
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 057096758b8..ed3d760a918 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -864,6 +864,7 @@ module RTS = struct
     E.add_func_import env "rts" "running_gc" [] [I32Type];
     E.add_func_import env "rts" "load_stable_actor" [] [I32Type];
     E.add_func_import env "rts" "save_stable_actor" [I32Type] [];
+    E.add_func_import env "rts" "contains_field" [I32Type; I32Type] [I32Type];
     E.add_func_import env "rts" "set_static_root" [I32Type] [];
     E.add_func_import env "rts" "get_static_root" [] [I32Type];
     E.add_func_import env "rts" "null_singleton" [] [I32Type];
@@ -3549,6 +3550,12 @@ module Object = struct
       (* Return the pointer to the object *)
       get_ri ^^
       Tagged.allocation_barrier env
+
+  (* Reflection used by orthogonal persistence: 
+     Check whether an (actor) object contains a specific field *)
+  let contains_field env field =
+    compile_unboxed_const (E.hash env field) ^^
+    E.call_import env "rts" "contains_field"
  
   (* Returns a pointer to the object field (without following the field indirection) *)
   let idx_hash_raw env low_bound =
@@ -6778,24 +6785,38 @@ module Stabilization = struct
   let load_stable_actor env = E.call_import env "rts" "load_stable_actor"
     
   let save_stable_actor env = E.call_import env "rts" "save_stable_actor"
-    
-  let empty_actor env t =
-    let (_, fs) = Type.as_obj t in
-    let fs' = List.map
-      (fun f -> (f.Type.lab, fun () -> Opt.null_lit env))
-      fs
+
+  let create_actor env actor_type get_field_value =
+    let (_, field_declarations) = Type.as_obj actor_type in
+    let field_initializers = List.map
+      (fun field -> (field.Type.lab, fun () -> (get_field_value field.Type.lab)))
+      field_declarations
     in
-    Object.lit_raw env fs'
+    Object.lit_raw env field_initializers
+
+  let empty_actor env actor_type =
+    create_actor env actor_type (fun _ ->  Opt.null_lit env)
 
-  let stabilize env t =
+  let recover_actor env actor_type =
+    let recover_field field = 
+      load_stable_actor env ^^
+      Object.contains_field env field ^^
+      (G.if1 I32Type
+        (load_stable_actor env ^^ Object.load_idx_raw env field)
+        (Opt.null_lit env)
+      ) in
+    create_actor env actor_type recover_field
+
+  let stabilize env actor_type =
     save_stable_actor env
 
-  let destabilize env t =
+  let destabilize env actor_type =
     load_stable_actor env ^^
     G.i (Test (Wasm.Values.I32 I32Op.Eqz)) ^^
     (G.if1 I32Type
-      (empty_actor env t)
-      (load_stable_actor env)) ^^
+      (empty_actor env actor_type)
+      (recover_actor env actor_type)
+    ) ^^
     restore_stable_memory env
 end
 

From 114950fe05268f658ffc6b8bfd8570fd38a80cab Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 25 Aug 2023 15:40:01 +0200
Subject: [PATCH 059/260] Adjust test

---
 test/run-drun/destabilization-crash.drun         |  3 ---
 test/run-drun/large-destabilization.drun         |  3 +++
 .../large-destabilization.mo}                    |  1 -
 test/run-drun/ok/destabilization-crash.drun.ok   | 16 ----------------
 test/run-drun/ok/large-destabilization.drun.ok   | 16 ++++++++++++++++
 5 files changed, 19 insertions(+), 20 deletions(-)
 delete mode 100644 test/run-drun/destabilization-crash.drun
 create mode 100644 test/run-drun/large-destabilization.drun
 rename test/run-drun/{destabilization-crash/destabilization-crash.mo => large-destabilization/large-destabilization.mo} (95%)
 delete mode 100644 test/run-drun/ok/destabilization-crash.drun.ok
 create mode 100644 test/run-drun/ok/large-destabilization.drun.ok

diff --git a/test/run-drun/destabilization-crash.drun b/test/run-drun/destabilization-crash.drun
deleted file mode 100644
index 1ef09703b28..00000000000
--- a/test/run-drun/destabilization-crash.drun
+++ /dev/null
@@ -1,3 +0,0 @@
-# SKIP ic-ref-run
-install $ID destabilization-crash/destabilization-crash.mo ""
-upgrade $ID destabilization-crash/destabilization-crash.mo ""
diff --git a/test/run-drun/large-destabilization.drun b/test/run-drun/large-destabilization.drun
new file mode 100644
index 00000000000..069817462cb
--- /dev/null
+++ b/test/run-drun/large-destabilization.drun
@@ -0,0 +1,3 @@
+# SKIP ic-ref-run
+install $ID large-destabilization/large-destabilization.mo ""
+upgrade $ID large-destabilization/large-destabilization.mo ""
diff --git a/test/run-drun/destabilization-crash/destabilization-crash.mo b/test/run-drun/large-destabilization/large-destabilization.mo
similarity index 95%
rename from test/run-drun/destabilization-crash/destabilization-crash.mo
rename to test/run-drun/large-destabilization/large-destabilization.mo
index 120a4a0d341..652e6ab2c95 100644
--- a/test/run-drun/destabilization-crash/destabilization-crash.mo
+++ b/test/run-drun/large-destabilization/large-destabilization.mo
@@ -38,7 +38,6 @@ actor a {
    system func postupgrade() {
      // if we get here, destabilization has succeeded
      Prim.debugPrint "postupgrade!";
-     assert false; // trap to avoid saving state to disk
    }
 
 }
diff --git a/test/run-drun/ok/destabilization-crash.drun.ok b/test/run-drun/ok/destabilization-crash.drun.ok
deleted file mode 100644
index dade05bb901..00000000000
--- a/test/run-drun/ok/destabilization-crash.drun.ok
+++ /dev/null
@@ -1,16 +0,0 @@
-ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
-ingress Completed: Reply: 0x4449444c0000
-debug.print: preupgrade!
-debug.print: {heap_MB = 64}
-debug.print: {heap_MB = 128}
-debug.print: {heap_MB = 192}
-debug.print: {heap_MB = 256}
-debug.print: {heap_MB = 320}
-debug.print: {heap_MB = 384}
-debug.print: {heap_MB = 448}
-debug.print: {heap_MB = 512}
-debug.print: {heap_MB = 576}
-debug.print: {heap_MB = 640}
-debug.print: {heap_MB = 704}
-debug.print: postupgrade!
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: assertion failed at destabilization-crash.mo:41.6-41.18
diff --git a/test/run-drun/ok/large-destabilization.drun.ok b/test/run-drun/ok/large-destabilization.drun.ok
new file mode 100644
index 00000000000..ae09687e79d
--- /dev/null
+++ b/test/run-drun/ok/large-destabilization.drun.ok
@@ -0,0 +1,16 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+debug.print: preupgrade!
+debug.print: {heap_MB = 68}
+debug.print: {heap_MB = 132}
+debug.print: {heap_MB = 196}
+debug.print: {heap_MB = 260}
+debug.print: {heap_MB = 324}
+debug.print: {heap_MB = 388}
+debug.print: {heap_MB = 452}
+debug.print: {heap_MB = 516}
+debug.print: {heap_MB = 580}
+debug.print: {heap_MB = 644}
+debug.print: {heap_MB = 708}
+debug.print: postupgrade!
+ingress Completed: Reply: 0x4449444c0000

From 12d8caf4431ed630c9aa6c219cd23358ab9a5bfe Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 25 Aug 2023 16:52:43 +0200
Subject: [PATCH 060/260] Improve error for too large data segments

---
 src/exes/moc.ml            | 6 +++++-
 src/linking/linkModule.ml  | 3 ++-
 src/linking/linkModule.mli | 1 +
 3 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/exes/moc.ml b/src/exes/moc.ml
index b0ed5cefcb5..f8cc5299fde 100644
--- a/src/exes/moc.ml
+++ b/src/exes/moc.ml
@@ -297,7 +297,11 @@ let () =
   process_metadata_names "public" !Flags.public_metadata_names;
   process_metadata_names "omit" !Flags.omit_metadata_names;
   try
-    process_files !args
+    match process_files !args with
+      (* TODO: Find a better place to gracefully handle the input-dependent linker error *)
+    | exception Linking.LinkModule.TooLargeDataSegments error_message ->
+      Printf.eprintf "Error: %s" error_message; ()
+    | () -> ()
   with
   | Sys_error msg ->
     (* IO error *)
diff --git a/src/linking/linkModule.ml b/src/linking/linkModule.ml
index 7f6656a8163..65d18c9d97b 100644
--- a/src/linking/linkModule.ml
+++ b/src/linking/linkModule.ml
@@ -274,6 +274,7 @@ let remove_non_ic_exports (em : extended_module) : extended_module =
 (* Generic linking logic *)
 
 exception LinkError of string
+exception TooLargeDataSegments of string
 
 type renumbering = int32 -> int32
 
@@ -768,7 +769,7 @@ let link (em1 : extended_module) libname (em2 : extended_module) =
 
   (* Data segments must fit below 4MB according to the persistent heap layout. *)
   (if (Int32.to_int new_heap_start) > 4 * 1024 * 1024 then
-    (raise (LinkError "The Wasm data segment size exceeds the supported maxmimum of 2MB."))
+    (raise (TooLargeDataSegments "The Wasm data segment size exceeds the supported maxmimum of 2MB."))
   else
     ()
   );
diff --git a/src/linking/linkModule.mli b/src/linking/linkModule.mli
index 407aa2d59c5..ecab52c83ae 100644
--- a/src/linking/linkModule.mli
+++ b/src/linking/linkModule.mli
@@ -4,5 +4,6 @@
    - the module containing that library
 *)
 exception LinkError of string
+exception TooLargeDataSegments of string
 
 val link : Wasm_exts.CustomModule.extended_module -> string -> Wasm_exts.CustomModule.extended_module -> Wasm_exts.CustomModule.extended_module

From 225738561cd294cbc239566616d69cbc889aa9ec Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 25 Aug 2023 17:02:06 +0200
Subject: [PATCH 061/260] Minor refactoring

---
 rts/motoko-rts/src/persistence.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/rts/motoko-rts/src/persistence.rs b/rts/motoko-rts/src/persistence.rs
index 50861495996..c8f917726c9 100644
--- a/rts/motoko-rts/src/persistence.rs
+++ b/rts/motoko-rts/src/persistence.rs
@@ -124,12 +124,14 @@ pub unsafe fn save_stable_actor<M: Memory>(mem: &mut M, actor: Value) {
     write_with_barrier(mem, location, actor);
 }
 
-// GC root pointer required for GC marking and updating.
+/// GC root pointer required for GC marking and updating.
 pub(crate) unsafe fn stable_actor_location() -> *mut Value {
     let metadata = PersistentMetadata::get();
     &mut (*metadata).stable_actor as *mut Value
 }
 
+/// Determine whether an object contains a specific field.
+/// Used for upgrading to an actor with additional stable fields.
 #[no_mangle]
 #[cfg(feature = "ic")]
 pub unsafe extern "C" fn contains_field(actor: Value, field_hash: u32) -> bool {

From 5424d168ea65a448839e653e54df48f82eed8977 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 25 Aug 2023 17:07:41 +0200
Subject: [PATCH 062/260] Comment refactoring

---
 rts/motoko-rts/src/persistence.rs | 27 +++++++++++++++------------
 1 file changed, 15 insertions(+), 12 deletions(-)

diff --git a/rts/motoko-rts/src/persistence.rs b/rts/motoko-rts/src/persistence.rs
index c8f917726c9..04beb93179e 100644
--- a/rts/motoko-rts/src/persistence.rs
+++ b/rts/motoko-rts/src/persistence.rs
@@ -16,30 +16,33 @@ const FINGERPRINT: [char; 32] = [
     'E', 'R', 'S', 'I', 'S', 'T', 'E', 'N', 'C', 'E', ' ', '3', '2',
 ];
 const VERSION: usize = 1;
-// The `Value` representation in the default-initialized Wasm memory.
-// The GC ignores this value since it is a scalar representation.
+/// The `Value` representation in the default-initialized Wasm memory.
+/// The GC ignores this value since it is a scalar representation.
 const DEFAULT_VALUE: Value = Value::from_scalar(0);
 
-// Use a long-term representation by relying on C layout.
-// The `Value` references belong to the GC root set and require forwarding pointer resolution.
+/// The persistent metadata stored at the defined location `METADTA_ADDRESS` in memory.
+/// Use a long-term representation by relying on C layout.
+/// The `Value` references belong to the GC root set and require forwarding pointer resolution.
 #[repr(C)]
 struct PersistentMetadata {
-    // Predefined character sequence in the memory to double check the orthogonal persistence mode.
+    /// Predefined character sequence in the memory to double check the orthogonal persistence mode.
     fingerprint: [char; 32],
-    // Version of the orthogonal persistence. To be increased on every persistent memory layout modification.
+    /// Version of the orthogonal persistence. To be increased on every persistent memory layout modification.
     version: usize,
-    // Reference to the stable sub-record of the actor, comprising all stable actor fields. Set before upgrade.
-    // Constitutes a GC root and requires pointer forwarding.
+    /// Reference to the stable sub-record of the actor, comprising all stable actor fields. Set before upgrade.
+    /// Constitutes a GC root and requires pointer forwarding.
     stable_actor: Value,
-    // The state of the incremental GC including the partitioned heap description.
-    // The GC continues work after upgrades.
+    /// The state of the incremental GC including the partitioned heap description.
+    /// The GC continues work after upgrades.
     incremental_gc_state: State,
-    // Singleton of the top-level null value. To be retained across upgrades.
-    // Constitutes a GC root and requires pointer forwarding.
+    /// Singleton of the top-level null value. To be retained across upgrades.
+    /// Constitutes a GC root and requires pointer forwarding.
     null_singleton: Value,
 }
 
+/// Location of the persistent metadata. Prereseved and fixed forever.
 const METATDATA_ADDRESS: usize = 4 * 1024 * 1024;
+/// The reserved maximum size of the metadata, contains a reserve for future extension of the metadata.
 const METADATA_RESERVE: usize = 128 * 1024;
 
 // TODO: Include partition table in reserved space.

From cd8131e7e4c756fccf651a098c6c8447fc93b2f7 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 28 Aug 2023 09:53:27 +0200
Subject: [PATCH 063/260] Prepare memory compatibility check

---
 rts/motoko-rts-tests/src/gc.rs                |  1 +
 .../src/gc/incremental/roots.rs               |  1 +
 rts/motoko-rts/src/gc/incremental/roots.rs    |  5 ++-
 rts/motoko-rts/src/persistence.rs             | 40 +++++++++++++++++--
 .../src/persistence/compatibility.rs          |  8 ++++
 src/codegen/compile.ml                        |  6 +++
 6 files changed, 55 insertions(+), 6 deletions(-)
 create mode 100644 rts/motoko-rts/src/persistence/compatibility.rs

diff --git a/rts/motoko-rts-tests/src/gc.rs b/rts/motoko-rts-tests/src/gc.rs
index 7f903700fbe..11842591be2 100644
--- a/rts/motoko-rts-tests/src/gc.rs
+++ b/rts/motoko-rts-tests/src/gc.rs
@@ -468,6 +468,7 @@ fn run(heap: &mut MotokoHeap) -> bool {
                 continuation_table_location,
                 unused_root,
                 unused_root,
+                unused_root,
             ];
             IncrementalGC::instance(heap, get_incremental_gc_state())
                 .empty_call_stack_increment(roots);
diff --git a/rts/motoko-rts-tests/src/gc/incremental/roots.rs b/rts/motoko-rts-tests/src/gc/incremental/roots.rs
index 5454f2d55d1..27d320b559a 100644
--- a/rts/motoko-rts-tests/src/gc/incremental/roots.rs
+++ b/rts/motoko-rts-tests/src/gc/incremental/roots.rs
@@ -69,6 +69,7 @@ unsafe fn get_roots(heap: &MotokoHeap) -> Roots {
         continuation_table_location,
         unused_root,
         unused_root,
+        unused_root,
     ]
 }
 
diff --git a/rts/motoko-rts/src/gc/incremental/roots.rs b/rts/motoko-rts/src/gc/incremental/roots.rs
index e973a702151..d758e978031 100644
--- a/rts/motoko-rts/src/gc/incremental/roots.rs
+++ b/rts/motoko-rts/src/gc/incremental/roots.rs
@@ -9,18 +9,19 @@ use crate::{types::Value, visitor::is_pointer_field};
 static mut STATIC_ROOT: Value = Value::from_scalar(0);
 
 /// GC root set.
-pub type Roots = [*mut Value; 4];
+pub type Roots = [*mut Value; 5];
 
 #[cfg(feature = "ic")]
 pub unsafe fn root_set() -> Roots {
     use crate::{
         continuation_table::continuation_table_loc,
-        persistence::{null_singleton_location, stable_actor_location},
+        persistence::{null_singleton_location, stable_actor_location, stable_type_location},
     };
     [
         static_root_location(),
         continuation_table_loc(),
         stable_actor_location(),
+        stable_type_location(),
         null_singleton_location(),
     ]
 }
diff --git a/rts/motoko-rts/src/persistence.rs b/rts/motoko-rts/src/persistence.rs
index 04beb93179e..1d2454cabf8 100644
--- a/rts/motoko-rts/src/persistence.rs
+++ b/rts/motoko-rts/src/persistence.rs
@@ -2,13 +2,16 @@
 //!
 //! Persistent metadata table, located at 4MB, in the static partition space.
 
+mod compatibility;
+
 use motoko_rts_macros::ic_mem_fn;
 
 use crate::{
     barriers::{allocation_barrier, write_with_barrier},
     gc::incremental::{IncrementalGC, State},
     memory::Memory,
-    types::{size_of, Null, Value, TAG_NULL},
+    persistence::compatibility::check_memory_compatibility,
+    types::{size_of, Null, Value, TAG_BLOB, TAG_NULL},
 };
 
 const FINGERPRINT: [char; 32] = [
@@ -32,6 +35,9 @@ struct PersistentMetadata {
     /// Reference to the stable sub-record of the actor, comprising all stable actor fields. Set before upgrade.
     /// Constitutes a GC root and requires pointer forwarding.
     stable_actor: Value,
+    /// Reference to the stable type descriptor blob, serving for heap compatibility checks on upgrades.
+    /// Constitutes a GC root and requires pointer forwarding.
+    stable_type: Value,
     /// The state of the incremental GC including the partitioned heap description.
     /// The GC continues work after upgrades.
     incremental_gc_state: State,
@@ -63,6 +69,7 @@ impl PersistentMetadata {
             initialized
                 || (*self).fingerprint == ['\0'; 32]
                     && (*self).stable_actor == DEFAULT_VALUE
+                    && (*self).stable_type == DEFAULT_VALUE
                     && (*self).null_singleton == DEFAULT_VALUE
         );
         initialized
@@ -83,6 +90,7 @@ impl PersistentMetadata {
         (*self).fingerprint = FINGERPRINT;
         (*self).version = VERSION;
         (*self).stable_actor = DEFAULT_VALUE;
+        (*self).stable_type = DEFAULT_VALUE;
         (*self).incremental_gc_state = IncrementalGC::initial_gc_state(mem, HEAP_START);
         (*self).null_singleton = DEFAULT_VALUE;
     }
@@ -107,7 +115,7 @@ pub unsafe fn initialize_memory<M: Memory>(mem: &mut M) {
 unsafe fn allocate_initial_objects<M: Memory>(mem: &mut M) {
     let metadata = PersistentMetadata::get();
     debug_assert!((*metadata).null_singleton == DEFAULT_VALUE);
-    (*metadata).null_singleton = alloc_null(mem);
+    (*metadata).null_singleton = allocate_null(mem);
 }
 
 /// Returns the stable sub-record of the actor of the upgraded canister version.
@@ -115,6 +123,7 @@ unsafe fn allocate_initial_objects<M: Memory>(mem: &mut M) {
 #[no_mangle]
 pub unsafe extern "C" fn load_stable_actor() -> Value {
     let metadata = PersistentMetadata::get();
+    assert!((*metadata).stable_type.forward_if_possible() != DEFAULT_VALUE);
     (*metadata).stable_actor.forward_if_possible()
 }
 
@@ -122,7 +131,8 @@ pub unsafe extern "C" fn load_stable_actor() -> Value {
 #[ic_mem_fn]
 pub unsafe fn save_stable_actor<M: Memory>(mem: &mut M, actor: Value) {
     assert!(actor != DEFAULT_VALUE);
-    let metadata = PersistentMetadata::get();
+    let metadata: *mut PersistentMetadata = PersistentMetadata::get();
+    assert!((*metadata).stable_type.forward_if_possible() != DEFAULT_VALUE);
     let location = &mut (*metadata).stable_actor as *mut Value;
     write_with_barrier(mem, location, actor);
 }
@@ -155,7 +165,7 @@ pub unsafe extern "C" fn contains_field(actor: Value, field_hash: u32) -> bool {
     false
 }
 
-unsafe fn alloc_null<M: Memory>(mem: &mut M) -> Value {
+unsafe fn allocate_null<M: Memory>(mem: &mut M) -> Value {
     let value = mem.alloc_words(size_of::<Null>());
     debug_assert!(value.get_ptr() >= HEAP_START);
     let null = value.get_ptr() as *mut Null;
@@ -165,6 +175,28 @@ unsafe fn alloc_null<M: Memory>(mem: &mut M) -> Value {
     value
 }
 
+/// Register the stable actor type on canister installation and upgrade.
+/// The type is stored in the persistent metadata memory for later retrieval on canister upgrades.
+/// On an upgrade, the memory compatibility between the new and existing stable type is checked.
+/// The `new_type` value points to a blob encoding the new stable actor type.
+#[ic_mem_fn]
+pub unsafe fn register_stable_type<M: Memory>(mem: &mut M, new_type: Value) {
+    assert_eq!(new_type.tag(), TAG_BLOB);
+    let metadata = PersistentMetadata::get();
+    let old_type = (*metadata).stable_type.forward_if_possible();
+    if old_type != DEFAULT_VALUE {
+        check_memory_compatibility(old_type, new_type);
+    }
+    let location = &mut (*metadata).stable_type as *mut Value;
+    write_with_barrier(mem, location, new_type);
+}
+
+/// GC root pointer required for GC marking and updating.
+pub(crate) unsafe fn stable_type_location() -> *mut Value {
+    let metadata = PersistentMetadata::get();
+    &mut (*metadata).stable_type as *mut Value
+}
+
 /// Get the null singleton used for top-level optional types.
 /// Serves for optimized null checks by pointer comparison.
 /// The forwarding pointer of this object is already resolved.
diff --git a/rts/motoko-rts/src/persistence/compatibility.rs b/rts/motoko-rts/src/persistence/compatibility.rs
new file mode 100644
index 00000000000..59464f8fbc8
--- /dev/null
+++ b/rts/motoko-rts/src/persistence/compatibility.rs
@@ -0,0 +1,8 @@
+use crate::types::Value;
+
+/// Check whether the existing persistent stable type is compatible to the new stable type.
+/// Traps if the check fails.
+/// Both arguments point to blobs encoding a stable actor type.
+pub fn check_memory_compatibility(_old_type: Value, _new_type: Value) {
+    // TODO: Implement
+}
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index ed3d760a918..31f7b8f52a7 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -862,6 +862,7 @@ module RTS = struct
     E.add_func_import env "rts" "write_with_barrier" [I32Type; I32Type] [];
     E.add_func_import env "rts" "allocation_barrier" [I32Type] [I32Type];
     E.add_func_import env "rts" "running_gc" [] [I32Type];
+    E.add_func_import env "rts" "register_stable_type" [I32Type] [];
     E.add_func_import env "rts" "load_stable_actor" [] [I32Type];
     E.add_func_import env "rts" "save_stable_actor" [I32Type] [];
     E.add_func_import env "rts" "contains_field" [I32Type; I32Type] [I32Type];
@@ -6786,6 +6787,10 @@ module Stabilization = struct
     
   let save_stable_actor env = E.call_import env "rts" "save_stable_actor"
 
+  let register_stable_type env actor_type = 
+    Blob.lit env "" ^^
+    E.call_import env "rts" "register_stable_type"
+
   let create_actor env actor_type get_field_value =
     let (_, field_declarations) = Type.as_obj actor_type in
     let field_initializers = List.map
@@ -6811,6 +6816,7 @@ module Stabilization = struct
     save_stable_actor env
 
   let destabilize env actor_type =
+    register_stable_type env actor_type ^^
     load_stable_actor env ^^
     G.i (Test (Wasm.Values.I32 I32Op.Eqz)) ^^
     (G.if1 I32Type

From 4d26bd10422d7229ee8f3a80f6ef34194a45b370 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 28 Aug 2023 16:21:18 +0200
Subject: [PATCH 064/260] Draft the memory compatibility check

---
 rts/motoko-rts/src/persistence.rs             |   6 +-
 .../src/persistence/compatibility.rs          | 248 +++++++++++++++++-
 src/codegen/compile.ml                        |   5 +-
 src/codegen/persistence.ml                    | 116 ++++++++
 4 files changed, 365 insertions(+), 10 deletions(-)
 create mode 100644 src/codegen/persistence.ml

diff --git a/rts/motoko-rts/src/persistence.rs b/rts/motoko-rts/src/persistence.rs
index 1d2454cabf8..a43fa180264 100644
--- a/rts/motoko-rts/src/persistence.rs
+++ b/rts/motoko-rts/src/persistence.rs
@@ -10,7 +10,7 @@ use crate::{
     barriers::{allocation_barrier, write_with_barrier},
     gc::incremental::{IncrementalGC, State},
     memory::Memory,
-    persistence::compatibility::check_memory_compatibility,
+    persistence::compatibility::memory_compatible,
     types::{size_of, Null, Value, TAG_BLOB, TAG_NULL},
 };
 
@@ -184,8 +184,8 @@ pub unsafe fn register_stable_type<M: Memory>(mem: &mut M, new_type: Value) {
     assert_eq!(new_type.tag(), TAG_BLOB);
     let metadata = PersistentMetadata::get();
     let old_type = (*metadata).stable_type.forward_if_possible();
-    if old_type != DEFAULT_VALUE {
-        check_memory_compatibility(old_type, new_type);
+    if old_type != DEFAULT_VALUE && !memory_compatible(old_type, new_type) {
+        panic!("Memory-incompatible program upgrade");
     }
     let location = &mut (*metadata).stable_type as *mut Value;
     write_with_barrier(mem, location, new_type);
diff --git a/rts/motoko-rts/src/persistence/compatibility.rs b/rts/motoko-rts/src/persistence/compatibility.rs
index 59464f8fbc8..d35da8b5844 100644
--- a/rts/motoko-rts/src/persistence/compatibility.rs
+++ b/rts/motoko-rts/src/persistence/compatibility.rs
@@ -1,8 +1,246 @@
-use crate::types::Value;
+//! Persistent type compatibility check.
+//! Determines whether the a new actor type is compatible with the existing persistent state.
+//!
+//! This is determined by focusing on the stable actor fields (comprised in `stable_actor`).
+//!
+//! To be compatible, all the fields of an actor must be compatible to the previous state.
+//! A field is compatible if at least one of the condition holds:
+//! * The field is declared flexible, i.e. not stable, in the previous or new actor version.
+//! * The previous actor does not contain a field with that same name.
+//! * The field type is compatible to the type of the equally named field in the previous version.
+//!
+//! A new type is compatible to a previous type if
+//! * the types are identical
+//! * The new type is sub-type of the previous field.
+//!
+//! The existing sub-type relations are also memory-compatible at the runtime system level:
+//! * Nat can be interpreted as Int.
+//! * If record fields are dropped in a declaration, old records with more fields can still
+//!   be accessed.
+//!   -> However, redundant old fields should be removed in the future, e.g. by the GC.
+//! * Variant options can be added, without invalidating the existing variant tags.
+//!
+//! Binary format of the stable type encoding, generated by the Motoko compiler backend, `persistence.ml`.
+//!
+//! All composed non-primitive types are encoded in a table without defined order, except for the
+//! first entry.
+//! The first type in the table denotes the stable sub-type of the actor, ie. all its stable field
+//! declarations, without option wrapping.
+//!
+//! Non-primitive types are referred to by a positive index according to the type table.
+//! Primitive types are encoded by predefined negative indices.
+//! All numbers (type indices etc.) are encoded as little endian i32.
+//!
+//! ```
+//! <type_table> ::= length:i32 (<type>)^length
+//! <type> ::= <object>
+//! <object> ::= 1l field_list
+//! <field_list> ::= length:i32 (<field>)^length
+//! <field> ::= label_hash:i32 type_index:i32
+//! ```
+//!
+//! Predefined primitive type indices
+//!
+//! Type    | Index
+//! ------- | --------
+//! Nat     | -1l
 
-/// Check whether the existing persistent stable type is compatible to the new stable type.
-/// Traps if the check fails.
+use crate::types::{size_of, Value};
+
+const OBJECT_ENCODING_TAG: i32 = 1;
+
+const ACTOR_TYPE_INDEX: i32 = 0;
+
+const OBJECT_ENCODING_HEADER: usize = 2; // object_tag field_list_length
+const FIELD_ENCODING_LENGTH: usize = 2; // label_hash type_index
+
+struct EncodedData {
+    words: *const i32,
+    size: usize,
+}
+
+impl EncodedData {
+    pub fn new(words: *const i32, size: usize) -> EncodedData {
+        EncodedData { words, size }
+    }
+
+    unsafe fn read(&self, offset: usize) -> i32 {
+        assert!(offset < self.size);
+        let location = self.words.add(offset);
+        *location
+    }
+
+    unsafe fn sub_view(&self, offset: usize, length: usize) -> EncodedData {
+        assert!(offset + length <= self.size);
+        EncodedData {
+            words: self.words.add(offset),
+            size: length,
+        }
+    }
+}
+
+struct TypeTable {
+    data: EncodedData,
+}
+
+impl TypeTable {
+    unsafe fn new(value: Value) -> TypeTable {
+        let blob = value.as_blob();
+        assert_eq!(blob.len().as_usize() % size_of::<i32>().as_usize(), 0);
+        let words = blob.payload_const() as *const i32;
+        let size = blob.len().as_usize() / size_of::<i32>().as_usize();
+        let data = EncodedData::new(words, size);
+        TypeTable { data }
+    }
+
+    unsafe fn count_types(&self) -> usize {
+        let count = self.data.read(0);
+        assert!(count >= 0);
+        count as usize
+    }
+
+    unsafe fn get_type(&self, type_index: i32) -> Type {
+        assert!(type_index <= self.count_types() as i32);
+        assert_eq!(type_index, 0); // TODO: Skip over other types
+        let start = 1;
+        let tag = self.data.read(start);
+        assert_eq!(tag, OBJECT_ENCODING_TAG);
+        let count_fields = self.data.read(start + 1);
+        assert!(count_fields >= 0);
+        let size = OBJECT_ENCODING_HEADER + count_fields as usize * FIELD_ENCODING_LENGTH;
+        let type_view = self.data.sub_view(start, size);
+        let object_type = ObjectType::new(type_view);
+        Type::Object(object_type)
+    }
+
+    unsafe fn get_actor(&self) -> ObjectType {
+        match self.get_type(ACTOR_TYPE_INDEX) {
+            Type::Object(object_type) => object_type,
+            // _ => panic!("Invalid stable type encoding")
+        }
+    }
+}
+
+enum Type {
+    Object(ObjectType),
+}
+
+struct ObjectType {
+    data: EncodedData,
+}
+
+impl ObjectType {
+    unsafe fn new(data: EncodedData) -> ObjectType {
+        assert_eq!(data.read(0), OBJECT_ENCODING_TAG);
+        ObjectType { data }
+    }
+
+    unsafe fn count_fields(&self) -> usize {
+        assert_eq!(self.data.read(0), OBJECT_ENCODING_TAG);
+        let count = self.data.read(1);
+        assert!(count >= 0);
+        count as usize
+    }
+
+    unsafe fn get_field(&self, field_index: usize) -> Field {
+        let field_offset = OBJECT_ENCODING_HEADER + field_index * FIELD_ENCODING_LENGTH;
+        let label_hash = self.data.read(field_offset);
+        let type_index = self.data.read(field_offset + 1);
+        Field {
+            label_hash,
+            type_index,
+        }
+    }
+
+    unsafe fn find_field(&self, label_hash: i32) -> Option<Field> {
+        for field_index in 0..self.count_fields() {
+            let field = self.get_field(field_index);
+            if field.label_hash == label_hash {
+                return Some(field);
+            }
+        }
+        None
+    }
+}
+
+struct Field {
+    label_hash: i32,
+    type_index: i32,
+}
+
+fn type_compatible(
+    _new_type_table: &TypeTable,
+    new_type_index: i32,
+    _old_type_table: &TypeTable,
+    old_type_index: i32,
+) -> bool {
+    unsafe {
+        println!(100, "COMPATIBLE {new_type_index} {old_type_index}");
+    }
+    if new_type_index < 0 {
+        new_type_index == old_type_index
+    } else {
+        false
+    }
+}
+
+// TODO: Unit test this funcionality
+
+// TODO: Use visited table for handling recursion and avoiding repeated type checks.
+
+/// Test whether the new stable type complies with the existing old stable type.
 /// Both arguments point to blobs encoding a stable actor type.
-pub fn check_memory_compatibility(_old_type: Value, _new_type: Value) {
-    // TODO: Implement
+pub unsafe fn memory_compatible(old_type: Value, new_type: Value) -> bool {
+    let new_type_table = TypeTable::new(new_type);
+    let old_type_table = TypeTable::new(old_type);
+    let new_actor = new_type_table.get_actor();
+    let old_actor = old_type_table.get_actor();
+    for new_field_index in 0..new_actor.count_fields() {
+        let new_field = new_actor.get_field(new_field_index);
+        println!(100, "CHECK ACTOR FIELD {} {}", new_field.label_hash, old_actor.find_field(new_field.label_hash).is_some());
+        match old_actor.find_field(new_field.label_hash) {
+            Some(old_field) => {
+                if !type_compatible(
+                    &new_type_table,
+                    new_field.type_index,
+                    &old_type_table,
+                    old_field.type_index,
+                ) {
+                    return false;
+                }
+            }
+            None => {}
+        }
+    }
+    true
+
+    // // TODO: Implement supported sub-type relations
+
+    // // Identical types
+    // let old_descriptor = old_type.as_blob();
+    // let new_descriptor = new_type.as_blob();
+    // let old_size = old_descriptor.len().as_usize();
+    // let new_size = new_descriptor.len().as_usize();
+    // if old_size != new_size {
+    //     return false;
+    // }
+
+    // assert_eq!(old_size, new_size);
+    // let comparison = memcmp(
+    //     old_descriptor.payload_const() as *const c_void,
+    //     new_descriptor.payload_const() as *const c_void,
+    //     old_size,
+    // );
+
+    // comparison == 0
 }
+
+// pub unsafe fn print_type_descriptor(value: Value) {
+//     let descriptor = value.as_blob();
+//     let size = descriptor.len().as_usize();
+//     println!(100, "OUTPUT {}", size);
+//     for index in 0..size {
+//         println!(100, "{:#x} ", *descriptor.payload_const().add(index));
+//     }
+//     println!(100, "---");
+// }
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 31f7b8f52a7..359c8e5fe68 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -6787,8 +6787,9 @@ module Stabilization = struct
     
   let save_stable_actor env = E.call_import env "rts" "save_stable_actor"
 
-  let register_stable_type env actor_type = 
-    Blob.lit env "" ^^
+  let register_stable_type env actor_type =
+    let type_descriptor = Persistence.encode_stable_type actor_type in
+    Blob.lit env type_descriptor ^^
     E.call_import env "rts" "register_stable_type"
 
   let create_actor env actor_type get_field_value =
diff --git a/src/codegen/persistence.ml b/src/codegen/persistence.ml
new file mode 100644
index 00000000000..1889e442162
--- /dev/null
+++ b/src/codegen/persistence.ml
@@ -0,0 +1,116 @@
+(* Support for orthogonal persistence using stable heap and in-place memory upgrades 
+   without serialization or deserialization to secondary stable memory. *)
+
+(*
+  // The first type denotes the stable actor object.
+  // Non-primitive types are referred to by a positive index according to the type table.
+  // Primitive types are encoded by negative indices.
+  // All numbers (type indices etc.) are encoded as little endian i32.
+  <type_table> ::= length:i32 (<type>)^length
+  <type> ::= <object>
+  <object> ::= 1l field_list
+  <field_list> ::= length:i32 (<field>)^length
+  <field> ::= label_hash:i32 type_index:i32
+  
+  Predefined primitive type indices:
+  Nat -1l
+*)
+
+open Mo_types
+
+let encode_i32 number =
+  let buffer = Buffer.create 4 in
+  Buffer.add_int32_le buffer number;
+  Buffer.contents buffer
+
+let list_to_string list = List.fold_left (^) "" list
+
+module TypeTable = struct
+  let empty = []
+
+  let length table = List.length table
+
+  let index_of table typ =
+    match Lib.List.index_of typ table with
+    | Some index -> index
+    | None -> assert false
+
+  let contains_type table typ =
+    match List.find_opt (fun entry -> entry = typ) table with
+    | Some _ -> true
+    | None -> false
+
+  let add_type table typ =
+    let open Type in
+    match typ with
+    | Prim _ -> table
+    | _ when contains_type table typ -> table
+    | _ -> 
+      Printf.printf "ADD TYPE %s\n" (Type.string_of_typ typ);
+      List.append table [typ]
+end
+
+let rec collect_type table typ =
+  let table = TypeTable.add_type table typ in
+  let open Type in
+  match typ with
+  | Prim _ -> table
+  | Obj (Object, field_list) ->
+    let field_types = List.map (fun field -> field.typ) field_list in
+    collect_types table field_types
+  | _ -> 
+    Printf.printf "ERROR TYPE %s\n" (Type.string_of_typ typ);
+    assert false
+
+and collect_types table type_list =
+  match type_list with
+  | [] -> table
+  | first::remainder -> collect_types (collect_type table first) remainder
+  
+let encode_list encode_element list = 
+  let length = Int32.of_int (List.length list) in
+  let elements = List.map encode_element list in
+  encode_i32 length ^ list_to_string elements
+
+let type_index table typ =
+  let open Type in
+  match typ with
+  | Prim Nat -> -1l
+  | Prim _ -> assert false
+  | _ -> Int32.of_int (TypeTable.index_of table typ)
+
+let encode_field table field =
+  let open Type in
+  let field_hash = Hash.hash field.lab in
+  encode_i32 field_hash ^ 
+  encode_i32 (type_index table field.typ)
+  
+let encode_complex_type table typ =
+  let open Type in
+  match typ with
+  | Obj (Object, field_list) -> 
+    encode_i32 1l ^ 
+    encode_list (encode_field table) field_list
+  | _ -> assert false
+
+let encode_type_table table =
+  encode_list (encode_complex_type table) table
+
+let unwrap_optional typ =
+  let open Type in
+  match typ with
+  | Opt inner_type -> inner_type
+  | _ -> assert false
+
+(* Encode the stable type to enable a memory compatibility check on upgrade. *)
+(* See `persistence::compatibility` in the runtime system for the encoding format. *)
+let encode_stable_type (stable_type: Type.typ) : string =
+  let open Type in 
+  match stable_type with
+  | Obj (Memory, field_list) -> 
+      let unwrap_field field = {lab = field.lab; typ = unwrap_optional field.typ; depr = field.depr} in
+      let stable_fields = List.map unwrap_field field_list in
+      let stable_actor = Obj (Object, stable_fields) in
+      let table = collect_type TypeTable.empty stable_actor in
+      encode_type_table table
+  | _ -> assert false

From 5bb8424754fd1f9fb3b5a2168e2de9d5c1488626 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 28 Aug 2023 16:59:46 +0200
Subject: [PATCH 065/260] Add sub-type cache

---
 rts/motoko-rts/src/mem_utils.rs               |   4 +
 rts/motoko-rts/src/persistence.rs             |   2 +-
 .../src/persistence/compatibility.rs          | 132 ++++++++++++------
 3 files changed, 95 insertions(+), 43 deletions(-)

diff --git a/rts/motoko-rts/src/mem_utils.rs b/rts/motoko-rts/src/mem_utils.rs
index 9cdab95bca7..b71d1b8d253 100644
--- a/rts/motoko-rts/src/mem_utils.rs
+++ b/rts/motoko-rts/src/mem_utils.rs
@@ -11,3 +11,7 @@ pub(crate) unsafe fn memcpy_bytes(to: usize, from: usize, n: Bytes<u32>) {
 pub(crate) unsafe fn memzero(to: usize, n: Words<u32>) {
     libc::memset(to as *mut _, 0, n.to_bytes().as_usize());
 }
+
+pub(crate) unsafe fn memzero_bytes(to: usize, n: Bytes<u32>) {
+    libc::memset(to as *mut _, 0, n.as_usize());
+}
diff --git a/rts/motoko-rts/src/persistence.rs b/rts/motoko-rts/src/persistence.rs
index a43fa180264..f19c393a02a 100644
--- a/rts/motoko-rts/src/persistence.rs
+++ b/rts/motoko-rts/src/persistence.rs
@@ -184,7 +184,7 @@ pub unsafe fn register_stable_type<M: Memory>(mem: &mut M, new_type: Value) {
     assert_eq!(new_type.tag(), TAG_BLOB);
     let metadata = PersistentMetadata::get();
     let old_type = (*metadata).stable_type.forward_if_possible();
-    if old_type != DEFAULT_VALUE && !memory_compatible(old_type, new_type) {
+    if old_type != DEFAULT_VALUE && !memory_compatible(mem, old_type, new_type) {
         panic!("Memory-incompatible program upgrade");
     }
     let location = &mut (*metadata).stable_type as *mut Value;
diff --git a/rts/motoko-rts/src/persistence/compatibility.rs b/rts/motoko-rts/src/persistence/compatibility.rs
index d35da8b5844..53dbbf9e860 100644
--- a/rts/motoko-rts/src/persistence/compatibility.rs
+++ b/rts/motoko-rts/src/persistence/compatibility.rs
@@ -45,7 +45,11 @@
 //! ------- | --------
 //! Nat     | -1l
 
-use crate::types::{size_of, Value};
+use crate::{
+    mem_utils::memzero_bytes,
+    memory::{alloc_blob, Memory},
+    types::{size_of, Bytes, Value},
+};
 
 const OBJECT_ENCODING_TAG: i32 = 1;
 
@@ -168,7 +172,58 @@ struct Field {
     type_index: i32,
 }
 
-fn type_compatible(
+/// To break recursion and optimize repeated checks
+struct SubTypeCache {
+    bitmap: *mut u8,
+    count_new_types: usize,
+    count_old_types: usize,
+}
+
+impl SubTypeCache {
+    pub unsafe fn new<M: Memory>(
+        mem: &mut M,
+        new_types: &TypeTable,
+        old_types: &TypeTable,
+    ) -> SubTypeCache {
+        let count_new_types = new_types.count_types();
+        let count_old_types = old_types.count_types();
+        let bit_size = count_new_types * count_old_types;
+        let byte_size = Bytes((bit_size as u32 + u8::BITS - 1) / u8::BITS);
+        let blob = alloc_blob(mem, byte_size);
+        let bitmap = blob.as_blob_mut().payload_addr();
+        memzero_bytes(bitmap as usize, byte_size);
+        SubTypeCache {
+            bitmap,
+            count_new_types,
+            count_old_types,
+        }
+    }
+
+    pub unsafe fn visited(&self, new_type_index: i32, old_type_index: i32) -> bool {
+        let (byte, bit_index) = self.position(new_type_index, old_type_index);
+        (*byte >> bit_index) & 0b1 != 0
+    }
+
+    pub unsafe fn visit(&mut self, new_type_index: i32, old_type_index: i32) {
+        let (byte, bit_index) = self.position(new_type_index, old_type_index);
+        *byte |= 0b1 << bit_index;
+    }
+
+    unsafe fn position(&self, new_type_index: i32, old_type_index: i32) -> (*mut u8, usize) {
+        assert!(new_type_index >= 0);
+        assert!(old_type_index >= 0);
+        assert!((new_type_index as usize) < self.count_new_types);
+        assert!((old_type_index as usize) < self.count_old_types);
+        let index = new_type_index as usize * self.count_old_types + old_type_index as usize;
+        let byte_index = index / u8::BITS as usize;
+        let bit_index = index % u8::BITS as usize;
+        let byte = self.bitmap.add(byte_index);
+        (byte, bit_index)
+    }
+}
+
+unsafe fn type_compatible(
+    cache: &mut SubTypeCache,
     _new_type_table: &TypeTable,
     new_type_index: i32,
     _old_type_table: &TypeTable,
@@ -177,30 +232,41 @@ fn type_compatible(
     unsafe {
         println!(100, "COMPATIBLE {new_type_index} {old_type_index}");
     }
-    if new_type_index < 0 {
+    if new_type_index >= 0 && old_type_index >= 0 {
+        if cache.visited(new_type_index, old_type_index) {
+            return true;
+        }
+        cache.visit(new_type_index, old_type_index);
+
+        // TODO: Implement check
+        unimplemented!()
+    } else if new_type_index < 0 {
         new_type_index == old_type_index
     } else {
         false
     }
 }
 
-// TODO: Unit test this funcionality
-
-// TODO: Use visited table for handling recursion and avoiding repeated type checks.
-
-/// Test whether the new stable type complies with the existing old stable type.
-/// Both arguments point to blobs encoding a stable actor type.
-pub unsafe fn memory_compatible(old_type: Value, new_type: Value) -> bool {
-    let new_type_table = TypeTable::new(new_type);
-    let old_type_table = TypeTable::new(old_type);
+unsafe fn compatible_actor_fields<M: Memory>(
+    mem: &mut M,
+    new_type_table: TypeTable,
+    old_type_table: TypeTable,
+) -> bool {
+    let mut cache = SubTypeCache::new(mem, &new_type_table, &old_type_table);
     let new_actor = new_type_table.get_actor();
     let old_actor = old_type_table.get_actor();
     for new_field_index in 0..new_actor.count_fields() {
         let new_field = new_actor.get_field(new_field_index);
-        println!(100, "CHECK ACTOR FIELD {} {}", new_field.label_hash, old_actor.find_field(new_field.label_hash).is_some());
+        println!(
+            100,
+            "CHECK ACTOR FIELD {} {}",
+            new_field.label_hash,
+            old_actor.find_field(new_field.label_hash).is_some()
+        );
         match old_actor.find_field(new_field.label_hash) {
             Some(old_field) => {
                 if !type_compatible(
+                    &mut cache,
                     &new_type_table,
                     new_field.type_index,
                     &old_type_table,
@@ -213,34 +279,16 @@ pub unsafe fn memory_compatible(old_type: Value, new_type: Value) -> bool {
         }
     }
     true
-
-    // // TODO: Implement supported sub-type relations
-
-    // // Identical types
-    // let old_descriptor = old_type.as_blob();
-    // let new_descriptor = new_type.as_blob();
-    // let old_size = old_descriptor.len().as_usize();
-    // let new_size = new_descriptor.len().as_usize();
-    // if old_size != new_size {
-    //     return false;
-    // }
-
-    // assert_eq!(old_size, new_size);
-    // let comparison = memcmp(
-    //     old_descriptor.payload_const() as *const c_void,
-    //     new_descriptor.payload_const() as *const c_void,
-    //     old_size,
-    // );
-
-    // comparison == 0
 }
 
-// pub unsafe fn print_type_descriptor(value: Value) {
-//     let descriptor = value.as_blob();
-//     let size = descriptor.len().as_usize();
-//     println!(100, "OUTPUT {}", size);
-//     for index in 0..size {
-//         println!(100, "{:#x} ", *descriptor.payload_const().add(index));
-//     }
-//     println!(100, "---");
-// }
+// TODO: Unit test this funcionality
+
+// TODO: Use visited table for handling recursion and avoiding repeated type checks.
+
+/// Test whether the new stable type complies with the existing old stable type.
+/// Both arguments point to blobs encoding a stable actor type.
+pub unsafe fn memory_compatible<M: Memory>(mem: &mut M, old_type: Value, new_type: Value) -> bool {
+    let new_type_table = TypeTable::new(new_type);
+    let old_type_table = TypeTable::new(old_type);
+    compatible_actor_fields(mem, new_type_table, old_type_table)
+}

From 589542e94c49ff019a2928b6a9372724e184be6d Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 28 Aug 2023 17:06:54 +0200
Subject: [PATCH 066/260] Code refactoring

---
 .../src/persistence/compatibility.rs          | 27 +++++++------------
 src/codegen/persistence.ml                    |  6 ++---
 2 files changed, 11 insertions(+), 22 deletions(-)

diff --git a/rts/motoko-rts/src/persistence/compatibility.rs b/rts/motoko-rts/src/persistence/compatibility.rs
index 53dbbf9e860..d5cc1f3992f 100644
--- a/rts/motoko-rts/src/persistence/compatibility.rs
+++ b/rts/motoko-rts/src/persistence/compatibility.rs
@@ -172,19 +172,21 @@ struct Field {
     type_index: i32,
 }
 
-/// To break recursion and optimize repeated checks
-struct SubTypeCache {
+/// Cache for remembering previous type compatibility checks.
+/// Necessary to avoid infinite loops on type recursion.
+/// Helpful to optimize repeated checks.
+struct TypeCheckCache {
     bitmap: *mut u8,
     count_new_types: usize,
     count_old_types: usize,
 }
 
-impl SubTypeCache {
+impl TypeCheckCache {
     pub unsafe fn new<M: Memory>(
         mem: &mut M,
         new_types: &TypeTable,
         old_types: &TypeTable,
-    ) -> SubTypeCache {
+    ) -> TypeCheckCache {
         let count_new_types = new_types.count_types();
         let count_old_types = old_types.count_types();
         let bit_size = count_new_types * count_old_types;
@@ -192,7 +194,7 @@ impl SubTypeCache {
         let blob = alloc_blob(mem, byte_size);
         let bitmap = blob.as_blob_mut().payload_addr();
         memzero_bytes(bitmap as usize, byte_size);
-        SubTypeCache {
+        TypeCheckCache {
             bitmap,
             count_new_types,
             count_old_types,
@@ -223,15 +225,12 @@ impl SubTypeCache {
 }
 
 unsafe fn type_compatible(
-    cache: &mut SubTypeCache,
+    cache: &mut TypeCheckCache,
     _new_type_table: &TypeTable,
     new_type_index: i32,
     _old_type_table: &TypeTable,
     old_type_index: i32,
 ) -> bool {
-    unsafe {
-        println!(100, "COMPATIBLE {new_type_index} {old_type_index}");
-    }
     if new_type_index >= 0 && old_type_index >= 0 {
         if cache.visited(new_type_index, old_type_index) {
             return true;
@@ -252,17 +251,11 @@ unsafe fn compatible_actor_fields<M: Memory>(
     new_type_table: TypeTable,
     old_type_table: TypeTable,
 ) -> bool {
-    let mut cache = SubTypeCache::new(mem, &new_type_table, &old_type_table);
+    let mut cache = TypeCheckCache::new(mem, &new_type_table, &old_type_table);
     let new_actor = new_type_table.get_actor();
     let old_actor = old_type_table.get_actor();
     for new_field_index in 0..new_actor.count_fields() {
         let new_field = new_actor.get_field(new_field_index);
-        println!(
-            100,
-            "CHECK ACTOR FIELD {} {}",
-            new_field.label_hash,
-            old_actor.find_field(new_field.label_hash).is_some()
-        );
         match old_actor.find_field(new_field.label_hash) {
             Some(old_field) => {
                 if !type_compatible(
@@ -283,8 +276,6 @@ unsafe fn compatible_actor_fields<M: Memory>(
 
 // TODO: Unit test this funcionality
 
-// TODO: Use visited table for handling recursion and avoiding repeated type checks.
-
 /// Test whether the new stable type complies with the existing old stable type.
 /// Both arguments point to blobs encoding a stable actor type.
 pub unsafe fn memory_compatible<M: Memory>(mem: &mut M, old_type: Value, new_type: Value) -> bool {
diff --git a/src/codegen/persistence.ml b/src/codegen/persistence.ml
index 1889e442162..a05f320a8a4 100644
--- a/src/codegen/persistence.ml
+++ b/src/codegen/persistence.ml
@@ -45,9 +45,7 @@ module TypeTable = struct
     match typ with
     | Prim _ -> table
     | _ when contains_type table typ -> table
-    | _ -> 
-      Printf.printf "ADD TYPE %s\n" (Type.string_of_typ typ);
-      List.append table [typ]
+    | _ -> List.append table [typ]
 end
 
 let rec collect_type table typ =
@@ -59,7 +57,7 @@ let rec collect_type table typ =
     let field_types = List.map (fun field -> field.typ) field_list in
     collect_types table field_types
   | _ -> 
-    Printf.printf "ERROR TYPE %s\n" (Type.string_of_typ typ);
+    Printf.printf "UNSUPPORTED PERSISTENT TYPE %s\n" (Type.string_of_typ typ);
     assert false
 
 and collect_types table type_list =

From be38c4e4d600d12d481cb251db7d66d6e023f45d Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Tue, 29 Aug 2023 09:27:03 +0200
Subject: [PATCH 067/260] Add test case

---
 test/run-drun/add-remove-stable-fields.drun   | 19 +++++++++++++
 .../add-remove-stable-fields/version0.mo      | 13 +++++++++
 .../add-remove-stable-fields/version1.mo      | 16 +++++++++++
 .../add-remove-stable-fields/version2.mo      | 13 +++++++++
 .../ok/add-remove-stable-fields.drun.ok       | 27 +++++++++++++++++++
 5 files changed, 88 insertions(+)
 create mode 100644 test/run-drun/add-remove-stable-fields.drun
 create mode 100644 test/run-drun/add-remove-stable-fields/version0.mo
 create mode 100644 test/run-drun/add-remove-stable-fields/version1.mo
 create mode 100644 test/run-drun/add-remove-stable-fields/version2.mo
 create mode 100644 test/run-drun/ok/add-remove-stable-fields.drun.ok

diff --git a/test/run-drun/add-remove-stable-fields.drun b/test/run-drun/add-remove-stable-fields.drun
new file mode 100644
index 00000000000..fa59f82bbc3
--- /dev/null
+++ b/test/run-drun/add-remove-stable-fields.drun
@@ -0,0 +1,19 @@
+# SKIP ic-ref-run
+install $ID add-remove-stable-fields/version0.mo ""
+ingress $ID increase "DIDL\x00\x01\x7d\x0F"
+ingress $ID show "DIDL\x00\x00"
+upgrade $ID add-remove-stable-fields/version0.mo ""
+ingress $ID increase "DIDL\x00\x01\x7d\x0F"
+ingress $ID show "DIDL\x00\x00"
+upgrade $ID add-remove-stable-fields/version1.mo ""
+ingress $ID increase "DIDL\x00\x01\x7d\x0F"
+ingress $ID show "DIDL\x00\x00"
+upgrade $ID add-remove-stable-fields/version1.mo ""
+ingress $ID increase "DIDL\x00\x01\x7d\x0F"
+ingress $ID show "DIDL\x00\x00"
+upgrade $ID add-remove-stable-fields/version2.mo ""
+ingress $ID increase "DIDL\x00\x01\x7d\x0F"
+ingress $ID show "DIDL\x00\x00"
+upgrade $ID add-remove-stable-fields/version2.mo ""
+ingress $ID increase "DIDL\x00\x01\x7d\x0F"
+ingress $ID show "DIDL\x00\x00"
diff --git a/test/run-drun/add-remove-stable-fields/version0.mo b/test/run-drun/add-remove-stable-fields/version0.mo
new file mode 100644
index 00000000000..585ee7f7630
--- /dev/null
+++ b/test/run-drun/add-remove-stable-fields/version0.mo
@@ -0,0 +1,13 @@
+import Prim "mo:prim";
+
+actor {
+    stable var firstValue = 0;
+
+    public func increase() : async () {
+        firstValue += 0;
+    };
+
+    public func show() : async () {
+        Prim.debugPrint("firstValue " # debug_show (firstValue));
+    };
+};
diff --git a/test/run-drun/add-remove-stable-fields/version1.mo b/test/run-drun/add-remove-stable-fields/version1.mo
new file mode 100644
index 00000000000..c11b3762b66
--- /dev/null
+++ b/test/run-drun/add-remove-stable-fields/version1.mo
@@ -0,0 +1,16 @@
+import Prim "mo:prim";
+
+actor {
+    stable var firstValue = 0;
+    stable var secondValue = 0;
+
+    public func increase() : async () {
+        firstValue += 1;
+        secondValue += 1;
+    };
+
+    public func show() : async () {
+        Prim.debugPrint("firstValue=" # debug_show (firstValue));
+        Prim.debugPrint("secondValue=" # debug_show (secondValue));
+    };
+};
diff --git a/test/run-drun/add-remove-stable-fields/version2.mo b/test/run-drun/add-remove-stable-fields/version2.mo
new file mode 100644
index 00000000000..55274e4b171
--- /dev/null
+++ b/test/run-drun/add-remove-stable-fields/version2.mo
@@ -0,0 +1,13 @@
+import Prim "mo:prim";
+
+actor {
+    stable var secondValue = 0;
+
+    public func increase() : async () {
+        secondValue += 1;
+    };
+
+    public func show() : async () {
+        Prim.debugPrint("secondValue=" # debug_show (secondValue));
+    };
+};
diff --git a/test/run-drun/ok/add-remove-stable-fields.drun.ok b/test/run-drun/ok/add-remove-stable-fields.drun.ok
new file mode 100644
index 00000000000..39bb51dad33
--- /dev/null
+++ b/test/run-drun/ok/add-remove-stable-fields.drun.ok
@@ -0,0 +1,27 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: firstValue 0
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: firstValue 0
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: firstValue=1
+debug.print: secondValue=1
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: firstValue=2
+debug.print: secondValue=2
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: secondValue=3
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: secondValue=4
+ingress Completed: Reply: 0x4449444c0000

From eb0366d9a9557f6030c0eebf7ce2ee82813f5428 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Tue, 29 Aug 2023 11:30:23 +0200
Subject: [PATCH 068/260] Add unit test

---
 rts/motoko-rts-tests/src/main.rs              |   3 +
 rts/motoko-rts-tests/src/persistence.rs       |  21 ++
 .../src/persistence/compatibility.rs          | 257 ++++++++++++++++++
 rts/motoko-rts/src/lib.rs                     |   1 -
 rts/motoko-rts/src/persistence.rs             |  16 +-
 5 files changed, 292 insertions(+), 6 deletions(-)
 create mode 100644 rts/motoko-rts-tests/src/persistence.rs
 create mode 100644 rts/motoko-rts-tests/src/persistence/compatibility.rs

diff --git a/rts/motoko-rts-tests/src/main.rs b/rts/motoko-rts-tests/src/main.rs
index 3b2e92fadbc..ec4ea2ae139 100644
--- a/rts/motoko-rts-tests/src/main.rs
+++ b/rts/motoko-rts-tests/src/main.rs
@@ -7,6 +7,7 @@ mod crc32;
 mod gc;
 mod leb128;
 mod memory;
+mod persistence;
 mod principal_id;
 mod stream;
 mod text;
@@ -21,6 +22,8 @@ fn main() {
     }
 
     unsafe {
+        persistence::test();
+
         test_read_write_64_bit();
         bigint::test();
         bitrel::test();
diff --git a/rts/motoko-rts-tests/src/persistence.rs b/rts/motoko-rts-tests/src/persistence.rs
new file mode 100644
index 00000000000..19c64c672d9
--- /dev/null
+++ b/rts/motoko-rts-tests/src/persistence.rs
@@ -0,0 +1,21 @@
+mod compatibility;
+
+use motoko_rts::persistence::allocate_null;
+use motoko_rts::types::TAG_NULL;
+
+use crate::memory::{initialize_test_memory, reset_test_memory};
+
+pub fn test() {
+    println!("Testing orthogonal persistence ...");
+    unsafe {
+        compatibility::test();
+        test_null_allocation();
+    }
+}
+
+unsafe fn test_null_allocation() {
+    let mut heap = initialize_test_memory();
+    let value = allocate_null(&mut heap);
+    assert_eq!(value.tag(), TAG_NULL);
+    reset_test_memory();
+}
diff --git a/rts/motoko-rts-tests/src/persistence/compatibility.rs b/rts/motoko-rts-tests/src/persistence/compatibility.rs
new file mode 100644
index 00000000000..02e5b0876ae
--- /dev/null
+++ b/rts/motoko-rts-tests/src/persistence/compatibility.rs
@@ -0,0 +1,257 @@
+use motoko_rts::memory::{alloc_blob, Memory};
+use motoko_rts::persistence::compatibility::memory_compatible;
+use motoko_rts::types::{Bytes, Value};
+use std::hash::Hasher;
+use std::{collections::hash_map::DefaultHasher, hash::Hash};
+
+use crate::memory::{initialize_test_memory, reset_test_memory, TestMemory};
+
+struct BinaryData {
+    byte_sequence: Vec<u8>,
+}
+
+impl BinaryData {
+    fn new() -> BinaryData {
+        BinaryData {
+            byte_sequence: vec![],
+        }
+    }
+
+    fn write_i32(&mut self, value: i32) {
+        for byte in value.to_le_bytes() {
+            self.byte_sequence.push(byte);
+        }
+    }
+
+    fn write_hash(&mut self, value: &str) {
+        let mut hasher = DefaultHasher::new();
+        value.hash(&mut hasher);
+        self.write_i32(hasher.finish() as i32);
+    }
+
+    unsafe fn make_blob<M: Memory>(&self, mem: &mut M) -> Value {
+        let length = Bytes(self.byte_sequence.len() as u32);
+        let value = alloc_blob(mem, length);
+        let target = value.as_blob_mut();
+
+        for index in 0..length.as_usize() {
+            let byte = target.payload_addr().add(index);
+            *byte = *self.byte_sequence.get(index).unwrap();
+        }
+        value
+    }
+}
+
+#[derive(PartialEq, Clone)]
+enum Type {
+    Nat,
+    Object(ObjectType),
+}
+
+impl Type {
+    fn is_primitive(&self) -> bool {
+        match &self {
+            Self::Nat => true,
+            Self::Object(_) => false,
+        }
+    }
+
+    fn inner_types(&self) -> Vec<Type> {
+        match &self {
+            Self::Nat => vec![],
+            Self::Object(object_type) => object_type.inner_types(),
+        }
+    }
+
+    fn serialize(&self, output: &mut BinaryData, table: &TypeTable) {
+        match &self {
+            Self::Nat => unreachable!(),
+            Self::Object(object_type) => object_type.serialize(output, table),
+        }
+    }
+
+    fn type_id(&self, table: &TypeTable) -> i32 {
+        const NAT_TYPE_ID: i32 = -1;
+        match &self {
+            Self::Nat => NAT_TYPE_ID,
+            Self::Object(_) => table.index_of(self),
+        }
+    }
+}
+
+#[derive(PartialEq, Clone)]
+struct Field {
+    name: String,
+    field_type: Type,
+}
+
+impl Field {
+    fn serialize(&self, output: &mut BinaryData, table: &TypeTable) {
+        output.write_hash(&self.name);
+        output.write_i32(self.field_type.type_id(table));
+    }
+}
+
+#[derive(PartialEq, Clone)]
+struct ObjectType {
+    fields: Vec<Field>,
+}
+
+impl ObjectType {
+    fn inner_types(&self) -> Vec<Type> {
+        self.fields
+            .iter()
+            .map(|field| field.field_type.clone())
+            .collect()
+    }
+
+    fn serialize(&self, output: &mut BinaryData, table: &TypeTable) {
+        const OBJECT_TAG: i32 = 1;
+        output.write_i32(OBJECT_TAG);
+        output.write_i32(self.fields.len() as i32);
+        for field in &self.fields {
+            field.serialize(output, table);
+        }
+    }
+}
+
+struct TypeTable {
+    types: Vec<Type>,
+}
+
+impl TypeTable {
+    fn new(actor_type: Type) -> TypeTable {
+        let mut table = TypeTable { types: vec![] };
+        table.collect_types(actor_type);
+        table
+    }
+
+    fn collect_types(&mut self, current_type: Type) {
+        if !current_type.is_primitive() && !self.types.contains(&current_type) {
+            self.types.push(current_type.clone());
+            for inner_type in current_type.inner_types() {
+                self.collect_types(inner_type);
+            }
+        }
+    }
+
+    fn index_of(&self, search_type: &Type) -> i32 {
+        assert!(!search_type.is_primitive());
+        for index in 0..self.types.len() {
+            if self.types.get(index).unwrap() == search_type {
+                return index as i32;
+            }
+        }
+        unreachable!()
+    }
+
+    fn serialize(&self) -> BinaryData {
+        let mut output = BinaryData::new();
+        output.write_i32(self.types.len() as i32);
+        for current_type in &self.types {
+            current_type.serialize(&mut output, &self);
+        }
+        output
+    }
+}
+
+unsafe fn build<M: Memory>(mem: &mut M, actor_type: Type) -> Value {
+    TypeTable::new(actor_type).serialize().make_blob(mem)
+}
+
+unsafe fn is_compatible<M: Memory>(mem: &mut M, old_type: Type, new_type: Type) -> bool {
+    let old_type_blob = build(mem, old_type);
+    let new_type_blob = build(mem, new_type);
+    memory_compatible(mem, old_type_blob, new_type_blob)
+}
+
+pub unsafe fn test() {
+    println!("  Testing memory compatibility...");
+    let mut heap = initialize_test_memory();
+    test_sucessful_cases(&mut heap);
+    test_failing_cases(&mut heap);
+    reset_test_memory();
+}
+
+unsafe fn test_sucessful_cases(heap: &mut TestMemory) {
+    test_empty_actor(heap);
+    test_reordered_actor_fields(heap);
+    test_removed_actor_fields(heap);
+    test_added_actor_fields(heap);
+}
+
+unsafe fn test_empty_actor(heap: &mut TestMemory) {
+    let old_type = Type::Object(ObjectType { fields: vec![] });
+    let new_type = Type::Object(ObjectType { fields: vec![] });
+    assert!(is_compatible(heap, old_type, new_type));
+}
+
+unsafe fn test_reordered_actor_fields(heap: &mut TestMemory) {
+    let field1 = Field {
+        name: String::from("Field1"),
+        field_type: Type::Nat,
+    };
+    let field2 = Field {
+        name: String::from("Field2"),
+        field_type: Type::Nat,
+    };
+
+    let old_type = Type::Object(ObjectType {
+        fields: vec![field1.clone(), field2.clone()],
+    });
+    let new_type = Type::Object(ObjectType {
+        fields: vec![field2.clone(), field1.clone()],
+    });
+
+    assert!(is_compatible(heap, old_type, new_type));
+}
+
+unsafe fn test_removed_actor_fields(heap: &mut TestMemory) {
+    let field1 = Field {
+        name: String::from("Field1"),
+        field_type: Type::Nat,
+    };
+    let field2 = Field {
+        name: String::from("Field2"),
+        field_type: Type::Nat,
+    };
+    let field3 = Field {
+        name: String::from("Field3"),
+        field_type: Type::Nat,
+    };
+
+    let old_type = Type::Object(ObjectType {
+        fields: vec![field1.clone(), field2.clone(), field3.clone()],
+    });
+    let new_type = Type::Object(ObjectType {
+        fields: vec![field2.clone()],
+    });
+
+    assert!(is_compatible(heap, old_type, new_type));
+}
+
+unsafe fn test_added_actor_fields(heap: &mut TestMemory) {
+    let field1 = Field {
+        name: String::from("Field1"),
+        field_type: Type::Nat,
+    };
+    let field2 = Field {
+        name: String::from("Field2"),
+        field_type: Type::Nat,
+    };
+    let field3 = Field {
+        name: String::from("Field3"),
+        field_type: Type::Nat,
+    };
+
+    let old_type = Type::Object(ObjectType {
+        fields: vec![field2.clone()],
+    });
+    let new_type = Type::Object(ObjectType {
+        fields: vec![field1.clone(), field2.clone(), field3.clone()],
+    });
+
+    assert!(is_compatible(heap, old_type, new_type));
+}
+
+unsafe fn test_failing_cases(_heap: &mut TestMemory) {}
diff --git a/rts/motoko-rts/src/lib.rs b/rts/motoko-rts/src/lib.rs
index 0dcde17bb0a..f0b9886aa05 100644
--- a/rts/motoko-rts/src/lib.rs
+++ b/rts/motoko-rts/src/lib.rs
@@ -31,7 +31,6 @@ mod idl;
 pub mod leb128;
 mod mem_utils;
 pub mod memory;
-#[cfg(feature = "ic")]
 pub mod persistence;
 pub mod principal_id;
 mod static_checks;
diff --git a/rts/motoko-rts/src/persistence.rs b/rts/motoko-rts/src/persistence.rs
index f19c393a02a..b9960baa6c7 100644
--- a/rts/motoko-rts/src/persistence.rs
+++ b/rts/motoko-rts/src/persistence.rs
@@ -2,22 +2,24 @@
 //!
 //! Persistent metadata table, located at 4MB, in the static partition space.
 
-mod compatibility;
+pub mod compatibility;
 
 use motoko_rts_macros::ic_mem_fn;
 
 use crate::{
     barriers::{allocation_barrier, write_with_barrier},
-    gc::incremental::{IncrementalGC, State},
+    gc::incremental::State,
     memory::Memory,
     persistence::compatibility::memory_compatible,
     types::{size_of, Null, Value, TAG_BLOB, TAG_NULL},
 };
 
+#[cfg(feature = "ic")]
 const FINGERPRINT: [char; 32] = [
     'M', 'O', 'T', 'O', 'K', 'O', ' ', 'O', 'R', 'T', 'H', 'O', 'G', 'O', 'N', 'A', 'L', ' ', 'P',
     'E', 'R', 'S', 'I', 'S', 'T', 'E', 'N', 'C', 'E', ' ', '3', '2',
 ];
+#[cfg(feature = "ic")]
 const VERSION: usize = 1;
 /// The `Value` representation in the default-initialized Wasm memory.
 /// The GC ignores this value since it is a scalar representation.
@@ -52,7 +54,6 @@ const METATDATA_ADDRESS: usize = 4 * 1024 * 1024;
 const METADATA_RESERVE: usize = 128 * 1024;
 
 // TODO: Include partition table in reserved space.
-#[cfg(feature = "ic")]
 pub const HEAP_START: usize = METATDATA_ADDRESS + METADATA_RESERVE;
 
 const _: () = assert!(core::mem::size_of::<PersistentMetadata>() <= METADATA_RESERVE);
@@ -62,6 +63,7 @@ impl PersistentMetadata {
         METATDATA_ADDRESS as *mut Self
     }
 
+    #[cfg(feature = "ic")]
     unsafe fn is_initialized(self: *mut Self) -> bool {
         // Wasm memory is zero-initialized according to the Wasm specification.
         let initialized = (*self).version != 0;
@@ -75,6 +77,7 @@ impl PersistentMetadata {
         initialized
     }
 
+    #[cfg(feature = "ic")]
     unsafe fn check_version(self: *const Self) {
         if (*self).version != VERSION {
             panic!(
@@ -85,7 +88,9 @@ impl PersistentMetadata {
         }
     }
 
+    #[cfg(feature = "ic")]
     unsafe fn initialize<M: Memory>(self: *mut Self, mem: &mut M) {
+        use crate::gc::incremental::IncrementalGC;
         debug_assert!(!self.is_initialized());
         (*self).fingerprint = FINGERPRINT;
         (*self).version = VERSION;
@@ -137,6 +142,7 @@ pub unsafe fn save_stable_actor<M: Memory>(mem: &mut M, actor: Value) {
     write_with_barrier(mem, location, actor);
 }
 
+#[cfg(feature = "ic")]
 /// GC root pointer required for GC marking and updating.
 pub(crate) unsafe fn stable_actor_location() -> *mut Value {
     let metadata = PersistentMetadata::get();
@@ -165,9 +171,8 @@ pub unsafe extern "C" fn contains_field(actor: Value, field_hash: u32) -> bool {
     false
 }
 
-unsafe fn allocate_null<M: Memory>(mem: &mut M) -> Value {
+pub unsafe fn allocate_null<M: Memory>(mem: &mut M) -> Value {
     let value = mem.alloc_words(size_of::<Null>());
-    debug_assert!(value.get_ptr() >= HEAP_START);
     let null = value.get_ptr() as *mut Null;
     (*null).header.tag = TAG_NULL;
     (*null).header.init_forward(value);
@@ -192,6 +197,7 @@ pub unsafe fn register_stable_type<M: Memory>(mem: &mut M, new_type: Value) {
 }
 
 /// GC root pointer required for GC marking and updating.
+#[cfg(feature = "ic")]
 pub(crate) unsafe fn stable_type_location() -> *mut Value {
     let metadata = PersistentMetadata::get();
     &mut (*metadata).stable_type as *mut Value

From 40e1f35d186b0646a9679516e93fb672737c0e39 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Tue, 29 Aug 2023 13:43:53 +0200
Subject: [PATCH 069/260] Unit test for recursive types

---
 .../src/persistence/compatibility.rs          | 199 +++++++++++-------
 .../src/persistence/compatibility.rs          | 105 ++++++---
 2 files changed, 201 insertions(+), 103 deletions(-)

diff --git a/rts/motoko-rts-tests/src/persistence/compatibility.rs b/rts/motoko-rts-tests/src/persistence/compatibility.rs
index 02e5b0876ae..44cb8b2de05 100644
--- a/rts/motoko-rts-tests/src/persistence/compatibility.rs
+++ b/rts/motoko-rts-tests/src/persistence/compatibility.rs
@@ -42,75 +42,55 @@ impl BinaryData {
     }
 }
 
-#[derive(PartialEq, Clone)]
+#[derive(Clone)]
 enum Type {
-    Nat,
     Object(ObjectType),
 }
 
 impl Type {
-    fn is_primitive(&self) -> bool {
+    fn serialize(&self, output: &mut BinaryData) {
         match &self {
-            Self::Nat => true,
-            Self::Object(_) => false,
-        }
-    }
-
-    fn inner_types(&self) -> Vec<Type> {
-        match &self {
-            Self::Nat => vec![],
-            Self::Object(object_type) => object_type.inner_types(),
+            Self::Object(object_type) => object_type.serialize(output),
         }
     }
+}
 
-    fn serialize(&self, output: &mut BinaryData, table: &TypeTable) {
-        match &self {
-            Self::Nat => unreachable!(),
-            Self::Object(object_type) => object_type.serialize(output, table),
-        }
-    }
+#[derive(Clone)]
+struct TypeReference {
+    index: i32,
+}
 
-    fn type_id(&self, table: &TypeTable) -> i32 {
-        const NAT_TYPE_ID: i32 = -1;
-        match &self {
-            Self::Nat => NAT_TYPE_ID,
-            Self::Object(_) => table.index_of(self),
-        }
+impl TypeReference {
+    fn nat() -> TypeReference {
+        TypeReference { index: -1 }
     }
 }
 
-#[derive(PartialEq, Clone)]
+#[derive(Clone)]
 struct Field {
     name: String,
-    field_type: Type,
+    field_type: TypeReference,
 }
 
 impl Field {
-    fn serialize(&self, output: &mut BinaryData, table: &TypeTable) {
+    fn serialize(&self, output: &mut BinaryData) {
         output.write_hash(&self.name);
-        output.write_i32(self.field_type.type_id(table));
+        output.write_i32(self.field_type.index);
     }
 }
 
-#[derive(PartialEq, Clone)]
+#[derive(Clone)]
 struct ObjectType {
     fields: Vec<Field>,
 }
 
 impl ObjectType {
-    fn inner_types(&self) -> Vec<Type> {
-        self.fields
-            .iter()
-            .map(|field| field.field_type.clone())
-            .collect()
-    }
-
-    fn serialize(&self, output: &mut BinaryData, table: &TypeTable) {
+    fn serialize(&self, output: &mut BinaryData) {
         const OBJECT_TAG: i32 = 1;
         output.write_i32(OBJECT_TAG);
         output.write_i32(self.fields.len() as i32);
         for field in &self.fields {
-            field.serialize(output, table);
+            field.serialize(output);
         }
     }
 }
@@ -120,51 +100,38 @@ struct TypeTable {
 }
 
 impl TypeTable {
-    fn new(actor_type: Type) -> TypeTable {
-        let mut table = TypeTable { types: vec![] };
-        table.collect_types(actor_type);
-        table
-    }
-
-    fn collect_types(&mut self, current_type: Type) {
-        if !current_type.is_primitive() && !self.types.contains(&current_type) {
-            self.types.push(current_type.clone());
-            for inner_type in current_type.inner_types() {
-                self.collect_types(inner_type);
-            }
-        }
-    }
-
-    fn index_of(&self, search_type: &Type) -> i32 {
-        assert!(!search_type.is_primitive());
-        for index in 0..self.types.len() {
-            if self.types.get(index).unwrap() == search_type {
-                return index as i32;
-            }
-        }
-        unreachable!()
+    fn new(types: Vec<Type>) -> TypeTable {
+        TypeTable { types }
     }
 
     fn serialize(&self) -> BinaryData {
         let mut output = BinaryData::new();
         output.write_i32(self.types.len() as i32);
         for current_type in &self.types {
-            current_type.serialize(&mut output, &self);
+            current_type.serialize(&mut output);
         }
         output
     }
 }
 
-unsafe fn build<M: Memory>(mem: &mut M, actor_type: Type) -> Value {
-    TypeTable::new(actor_type).serialize().make_blob(mem)
+unsafe fn build<M: Memory>(mem: &mut M, types: Vec<Type>) -> Value {
+    TypeTable::new(types).serialize().make_blob(mem)
 }
 
-unsafe fn is_compatible<M: Memory>(mem: &mut M, old_type: Type, new_type: Type) -> bool {
-    let old_type_blob = build(mem, old_type);
-    let new_type_blob = build(mem, new_type);
+unsafe fn are_compatible<M: Memory>(
+    mem: &mut M,
+    old_types: Vec<Type>,
+    new_types: Vec<Type>,
+) -> bool {
+    let old_type_blob = build(mem, old_types);
+    let new_type_blob = build(mem, new_types);
     memory_compatible(mem, old_type_blob, new_type_blob)
 }
 
+unsafe fn is_compatible<M: Memory>(mem: &mut M, old_type: Type, new_type: Type) -> bool {
+    are_compatible(mem, vec![old_type], vec![new_type])
+}
+
 pub unsafe fn test() {
     println!("  Testing memory compatibility...");
     let mut heap = initialize_test_memory();
@@ -178,6 +145,8 @@ unsafe fn test_sucessful_cases(heap: &mut TestMemory) {
     test_reordered_actor_fields(heap);
     test_removed_actor_fields(heap);
     test_added_actor_fields(heap);
+    test_direct_recursive_type(heap);
+    test_indirect_recursive_type(heap);
 }
 
 unsafe fn test_empty_actor(heap: &mut TestMemory) {
@@ -189,11 +158,11 @@ unsafe fn test_empty_actor(heap: &mut TestMemory) {
 unsafe fn test_reordered_actor_fields(heap: &mut TestMemory) {
     let field1 = Field {
         name: String::from("Field1"),
-        field_type: Type::Nat,
+        field_type: TypeReference::nat(),
     };
     let field2 = Field {
         name: String::from("Field2"),
-        field_type: Type::Nat,
+        field_type: TypeReference::nat(),
     };
 
     let old_type = Type::Object(ObjectType {
@@ -209,15 +178,15 @@ unsafe fn test_reordered_actor_fields(heap: &mut TestMemory) {
 unsafe fn test_removed_actor_fields(heap: &mut TestMemory) {
     let field1 = Field {
         name: String::from("Field1"),
-        field_type: Type::Nat,
+        field_type: TypeReference::nat(),
     };
     let field2 = Field {
         name: String::from("Field2"),
-        field_type: Type::Nat,
+        field_type: TypeReference::nat(),
     };
     let field3 = Field {
         name: String::from("Field3"),
-        field_type: Type::Nat,
+        field_type: TypeReference::nat(),
     };
 
     let old_type = Type::Object(ObjectType {
@@ -233,15 +202,15 @@ unsafe fn test_removed_actor_fields(heap: &mut TestMemory) {
 unsafe fn test_added_actor_fields(heap: &mut TestMemory) {
     let field1 = Field {
         name: String::from("Field1"),
-        field_type: Type::Nat,
+        field_type: TypeReference::nat(),
     };
     let field2 = Field {
         name: String::from("Field2"),
-        field_type: Type::Nat,
+        field_type: TypeReference::nat(),
     };
     let field3 = Field {
         name: String::from("Field3"),
-        field_type: Type::Nat,
+        field_type: TypeReference::nat(),
     };
 
     let old_type = Type::Object(ObjectType {
@@ -254,4 +223,82 @@ unsafe fn test_added_actor_fields(heap: &mut TestMemory) {
     assert!(is_compatible(heap, old_type, new_type));
 }
 
-unsafe fn test_failing_cases(_heap: &mut TestMemory) {}
+unsafe fn test_direct_recursive_type(heap: &mut TestMemory) {
+    let actor_field = Field {
+        name: String::from("ActorField"),
+        field_type: TypeReference { index: 1 },
+    };
+    let actor_type = Type::Object(ObjectType {
+        fields: vec![actor_field],
+    });
+    let recursive_field = Field {
+        name: String::from("RecursiveField"),
+        field_type: TypeReference { index: 1 },
+    };
+    let recursive_type = Type::Object(ObjectType {
+        fields: vec![recursive_field],
+    });
+    let types = vec![actor_type, recursive_type];
+    assert!(are_compatible(heap, types.clone(), types.clone()));
+}
+
+unsafe fn test_indirect_recursive_type(heap: &mut TestMemory) {
+    let actor_type = Type::Object(ObjectType {
+        fields: vec![Field {
+            name: String::from("ActorField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let first_type = Type::Object(ObjectType {
+        fields: vec![Field {
+            name: String::from("Field1"),
+            field_type: TypeReference { index: 2 },
+        }],
+    });
+    let second_type = Type::Object(ObjectType {
+        fields: vec![Field {
+            name: String::from("Field2"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let types = vec![actor_type, first_type, second_type];
+    assert!(are_compatible(heap, types.clone(), types.clone()));
+}
+
+unsafe fn test_failing_cases(heap: &mut TestMemory) {
+    test_recursion_mismatch(heap);
+}
+
+unsafe fn test_recursion_mismatch(heap: &mut TestMemory) {
+    let old_actor_field = Field {
+        name: String::from("ActorField"),
+        field_type: TypeReference { index: 1 },
+    };
+    let old_actor = Type::Object(ObjectType {
+        fields: vec![old_actor_field],
+    });
+    let recursive_field = Field {
+        name: String::from("Field"),
+        field_type: TypeReference { index: 1 },
+    };
+    let recursive_type = Type::Object(ObjectType {
+        fields: vec![recursive_field],
+    });
+    let new_actor_field = Field {
+        name: String::from("ActorField"),
+        field_type: TypeReference { index: 1 },
+    };
+    let new_actor = Type::Object(ObjectType {
+        fields: vec![new_actor_field],
+    });
+    let non_recursive_field = Field {
+        name: String::from("Field"),
+        field_type: TypeReference::nat(),
+    };
+    let non_recursive_type = Type::Object(ObjectType {
+        fields: vec![non_recursive_field],
+    });
+    let old_types = vec![old_actor, recursive_type];
+    let new_types = vec![new_actor, non_recursive_type];
+    assert!(!are_compatible(heap, old_types, new_types));
+}
diff --git a/rts/motoko-rts/src/persistence/compatibility.rs b/rts/motoko-rts/src/persistence/compatibility.rs
index d5cc1f3992f..a8a2a268bb4 100644
--- a/rts/motoko-rts/src/persistence/compatibility.rs
+++ b/rts/motoko-rts/src/persistence/compatibility.rs
@@ -74,11 +74,11 @@ impl EncodedData {
         *location
     }
 
-    unsafe fn sub_view(&self, offset: usize, length: usize) -> EncodedData {
-        assert!(offset + length <= self.size);
+    unsafe fn sub_view(&self, offset: usize) -> EncodedData {
+        assert!(offset <= self.size);
         EncodedData {
             words: self.words.add(offset),
-            size: length,
+            size: self.size - offset,
         }
     }
 }
@@ -105,16 +105,13 @@ impl TypeTable {
 
     unsafe fn get_type(&self, type_index: i32) -> Type {
         assert!(type_index <= self.count_types() as i32);
-        assert_eq!(type_index, 0); // TODO: Skip over other types
-        let start = 1;
-        let tag = self.data.read(start);
-        assert_eq!(tag, OBJECT_ENCODING_TAG);
-        let count_fields = self.data.read(start + 1);
-        assert!(count_fields >= 0);
-        let size = OBJECT_ENCODING_HEADER + count_fields as usize * FIELD_ENCODING_LENGTH;
-        let type_view = self.data.sub_view(start, size);
-        let object_type = ObjectType::new(type_view);
-        Type::Object(object_type)
+        let mut start = 1;
+        for _ in 0..type_index {
+            let type_view = self.data.sub_view(start);
+            start += Type::size(type_view);
+        }
+        let type_view = self.data.sub_view(start);
+        Type::get_type(type_view)
     }
 
     unsafe fn get_actor(&self) -> ObjectType {
@@ -129,6 +126,22 @@ enum Type {
     Object(ObjectType),
 }
 
+impl Type {
+    unsafe fn size(data: EncodedData) -> usize {
+        match Self::get_type(data) {
+            Self::Object(object_type) => object_type.size(),
+        }
+    }
+
+    unsafe fn get_type(data: EncodedData) -> Type {
+        let tag = data.read(0);
+        match tag {
+            OBJECT_ENCODING_TAG => Self::Object(ObjectType::new(data)),
+            _ => unimplemented!(),
+        }
+    }
+}
+
 struct ObjectType {
     data: EncodedData,
 }
@@ -139,6 +152,10 @@ impl ObjectType {
         ObjectType { data }
     }
 
+    unsafe fn size(&self) -> usize {
+        OBJECT_ENCODING_HEADER + self.count_fields() * FIELD_ENCODING_LENGTH
+    }
+
     unsafe fn count_fields(&self) -> usize {
         assert_eq!(self.data.read(0), OBJECT_ENCODING_TAG);
         let count = self.data.read(1);
@@ -224,25 +241,59 @@ impl TypeCheckCache {
     }
 }
 
+unsafe fn object_compatible(
+    cache: &mut TypeCheckCache,
+    new_type_table: &TypeTable,
+    new_object: &ObjectType,
+    old_type_table: &TypeTable,
+    old_object: &ObjectType,
+) -> bool {
+    for field_index in 0..new_object.count_fields() {
+        let new_field = new_object.get_field(field_index);
+        match old_object.find_field(new_field.label_hash) {
+            None => {
+                return false;
+            }
+            Some(old_field) => {
+                if !type_compatible(
+                    cache,
+                    new_type_table,
+                    new_field.type_index,
+                    old_type_table,
+                    old_field.type_index,
+                ) {
+                    return false;
+                }
+            }
+        }
+    }
+    true
+}
+
 unsafe fn type_compatible(
     cache: &mut TypeCheckCache,
-    _new_type_table: &TypeTable,
+    new_type_table: &TypeTable,
     new_type_index: i32,
-    _old_type_table: &TypeTable,
+    old_type_table: &TypeTable,
     old_type_index: i32,
 ) -> bool {
-    if new_type_index >= 0 && old_type_index >= 0 {
-        if cache.visited(new_type_index, old_type_index) {
-            return true;
-        }
-        cache.visit(new_type_index, old_type_index);
-
-        // TODO: Implement check
-        unimplemented!()
-    } else if new_type_index < 0 {
-        new_type_index == old_type_index
-    } else {
-        false
+    if new_type_index < 0 || old_type_index < 0 {
+        return new_type_index == old_type_index;
+    }
+    if cache.visited(new_type_index, old_type_index) {
+        return true;
+    }
+    cache.visit(new_type_index, old_type_index);
+    let new_type = new_type_table.get_type(new_type_index);
+    let old_type = old_type_table.get_type(old_type_index);
+    match (&new_type, &old_type) {
+        (Type::Object(new_object), Type::Object(old_object)) => object_compatible(
+            cache,
+            new_type_table,
+            new_object,
+            old_type_table,
+            old_object,
+        ),
     }
 }
 

From 3d708e2f04b4a734aac2806a970526453c8249ba Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Tue, 29 Aug 2023 13:53:49 +0200
Subject: [PATCH 070/260] Code refactoring, added test case

---
 .../src/persistence/compatibility.rs          |  68 +++++++++
 .../src/persistence/compatibility.rs          | 137 ++++++++----------
 2 files changed, 132 insertions(+), 73 deletions(-)

diff --git a/rts/motoko-rts-tests/src/persistence/compatibility.rs b/rts/motoko-rts-tests/src/persistence/compatibility.rs
index 44cb8b2de05..734b67b8b0e 100644
--- a/rts/motoko-rts-tests/src/persistence/compatibility.rs
+++ b/rts/motoko-rts-tests/src/persistence/compatibility.rs
@@ -145,6 +145,7 @@ unsafe fn test_sucessful_cases(heap: &mut TestMemory) {
     test_reordered_actor_fields(heap);
     test_removed_actor_fields(heap);
     test_added_actor_fields(heap);
+    test_removed_object_fields(heap);
     test_direct_recursive_type(heap);
     test_indirect_recursive_type(heap);
 }
@@ -223,6 +224,39 @@ unsafe fn test_added_actor_fields(heap: &mut TestMemory) {
     assert!(is_compatible(heap, old_type, new_type));
 }
 
+unsafe fn test_removed_object_fields(heap: &mut TestMemory) {
+    let actor_type = Type::Object(ObjectType {
+        fields: vec![Field {
+            name: String::from("ActorField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+
+    let field1 = Field {
+        name: String::from("Field1"),
+        field_type: TypeReference::nat(),
+    };
+    let field2 = Field {
+        name: String::from("Field2"),
+        field_type: TypeReference::nat(),
+    };
+    let field3 = Field {
+        name: String::from("Field3"),
+        field_type: TypeReference::nat(),
+    };
+
+    let old_type = Type::Object(ObjectType {
+        fields: vec![field1.clone(), field2.clone(), field3.clone()],
+    });
+    let new_type = Type::Object(ObjectType {
+        fields: vec![field2.clone()],
+    });
+
+    let old_types = vec![actor_type.clone(), old_type];
+    let new_types = vec![actor_type.clone(), new_type];
+    assert!(are_compatible(heap, old_types, new_types));
+}
+
 unsafe fn test_direct_recursive_type(heap: &mut TestMemory) {
     let actor_field = Field {
         name: String::from("ActorField"),
@@ -266,6 +300,7 @@ unsafe fn test_indirect_recursive_type(heap: &mut TestMemory) {
 }
 
 unsafe fn test_failing_cases(heap: &mut TestMemory) {
+    test_added_object_fields(heap);
     test_recursion_mismatch(heap);
 }
 
@@ -302,3 +337,36 @@ unsafe fn test_recursion_mismatch(heap: &mut TestMemory) {
     let new_types = vec![new_actor, non_recursive_type];
     assert!(!are_compatible(heap, old_types, new_types));
 }
+
+unsafe fn test_added_object_fields(heap: &mut TestMemory) {
+    let actor_type = Type::Object(ObjectType {
+        fields: vec![Field {
+            name: String::from("ActorField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+
+    let field1 = Field {
+        name: String::from("Field1"),
+        field_type: TypeReference::nat(),
+    };
+    let field2 = Field {
+        name: String::from("Field2"),
+        field_type: TypeReference::nat(),
+    };
+    let field3 = Field {
+        name: String::from("Field3"),
+        field_type: TypeReference::nat(),
+    };
+
+    let old_type = Type::Object(ObjectType {
+        fields: vec![field2.clone()],
+    });
+    let new_type = Type::Object(ObjectType {
+        fields: vec![field1.clone(), field2.clone(), field3.clone()],
+    });
+
+    let old_types = vec![actor_type.clone(), old_type];
+    let new_types = vec![actor_type.clone(), new_type];
+    assert!(!are_compatible(heap, old_types, new_types));
+}
diff --git a/rts/motoko-rts/src/persistence/compatibility.rs b/rts/motoko-rts/src/persistence/compatibility.rs
index a8a2a268bb4..eae19e2417a 100644
--- a/rts/motoko-rts/src/persistence/compatibility.rs
+++ b/rts/motoko-rts/src/persistence/compatibility.rs
@@ -241,96 +241,87 @@ impl TypeCheckCache {
     }
 }
 
-unsafe fn object_compatible(
-    cache: &mut TypeCheckCache,
-    new_type_table: &TypeTable,
-    new_object: &ObjectType,
-    old_type_table: &TypeTable,
-    old_object: &ObjectType,
-) -> bool {
-    for field_index in 0..new_object.count_fields() {
-        let new_field = new_object.get_field(field_index);
-        match old_object.find_field(new_field.label_hash) {
-            None => {
-                return false;
-            }
-            Some(old_field) => {
-                if !type_compatible(
-                    cache,
-                    new_type_table,
-                    new_field.type_index,
-                    old_type_table,
-                    old_field.type_index,
-                ) {
-                    return false;
-                }
-            }
-        }
-    }
-    true
+struct CompatibilityChecker {
+    cache: TypeCheckCache,
+    new_type_table: TypeTable,
+    old_type_table: TypeTable,
 }
 
-unsafe fn type_compatible(
-    cache: &mut TypeCheckCache,
-    new_type_table: &TypeTable,
-    new_type_index: i32,
-    old_type_table: &TypeTable,
-    old_type_index: i32,
-) -> bool {
-    if new_type_index < 0 || old_type_index < 0 {
-        return new_type_index == old_type_index;
-    }
-    if cache.visited(new_type_index, old_type_index) {
-        return true;
-    }
-    cache.visit(new_type_index, old_type_index);
-    let new_type = new_type_table.get_type(new_type_index);
-    let old_type = old_type_table.get_type(old_type_index);
-    match (&new_type, &old_type) {
-        (Type::Object(new_object), Type::Object(old_object)) => object_compatible(
+impl CompatibilityChecker {
+    unsafe fn new<M: Memory>(
+        mem: &mut M,
+        new_type_table: TypeTable,
+        old_type_table: TypeTable,
+    ) -> CompatibilityChecker {
+        let cache = TypeCheckCache::new(mem, &new_type_table, &old_type_table);
+        CompatibilityChecker {
             cache,
             new_type_table,
-            new_object,
             old_type_table,
-            old_object,
-        ),
+        }
     }
-}
 
-unsafe fn compatible_actor_fields<M: Memory>(
-    mem: &mut M,
-    new_type_table: TypeTable,
-    old_type_table: TypeTable,
-) -> bool {
-    let mut cache = TypeCheckCache::new(mem, &new_type_table, &old_type_table);
-    let new_actor = new_type_table.get_actor();
-    let old_actor = old_type_table.get_actor();
-    for new_field_index in 0..new_actor.count_fields() {
-        let new_field = new_actor.get_field(new_field_index);
-        match old_actor.find_field(new_field.label_hash) {
-            Some(old_field) => {
-                if !type_compatible(
-                    &mut cache,
-                    &new_type_table,
-                    new_field.type_index,
-                    &old_type_table,
-                    old_field.type_index,
-                ) {
+    unsafe fn object_compatible(
+        &mut self,
+        new_object: &ObjectType,
+        old_object: &ObjectType,
+    ) -> bool {
+        for field_index in 0..new_object.count_fields() {
+            let new_field = new_object.get_field(field_index);
+            match old_object.find_field(new_field.label_hash) {
+                None => {
                     return false;
                 }
+                Some(old_field) => {
+                    if !self.type_compatible(new_field.type_index, old_field.type_index) {
+                        return false;
+                    }
+                }
+            }
+        }
+        true
+    }
+
+    unsafe fn type_compatible(&mut self, new_type_index: i32, old_type_index: i32) -> bool {
+        if new_type_index < 0 || old_type_index < 0 {
+            return new_type_index == old_type_index;
+        }
+        if self.cache.visited(new_type_index, old_type_index) {
+            return true;
+        }
+        self.cache.visit(new_type_index, old_type_index);
+        let new_type = self.new_type_table.get_type(new_type_index);
+        let old_type = self.old_type_table.get_type(old_type_index);
+        match (&new_type, &old_type) {
+            (Type::Object(new_object), Type::Object(old_object)) => {
+                self.object_compatible(new_object, old_object)
             }
-            None => {}
         }
     }
-    true
-}
 
-// TODO: Unit test this funcionality
+    unsafe fn compatible_actor_fields(&mut self) -> bool {
+        let new_actor = self.new_type_table.get_actor();
+        let old_actor = self.old_type_table.get_actor();
+        for new_field_index in 0..new_actor.count_fields() {
+            let new_field = new_actor.get_field(new_field_index);
+            match old_actor.find_field(new_field.label_hash) {
+                Some(old_field) => {
+                    if !self.type_compatible(new_field.type_index, old_field.type_index) {
+                        return false;
+                    }
+                }
+                None => {}
+            }
+        }
+        true
+    }
+}
 
 /// Test whether the new stable type complies with the existing old stable type.
 /// Both arguments point to blobs encoding a stable actor type.
 pub unsafe fn memory_compatible<M: Memory>(mem: &mut M, old_type: Value, new_type: Value) -> bool {
     let new_type_table = TypeTable::new(new_type);
     let old_type_table = TypeTable::new(old_type);
-    compatible_actor_fields(mem, new_type_table, old_type_table)
+    let mut checker = CompatibilityChecker::new(mem, new_type_table, old_type_table);
+    checker.compatible_actor_fields()
 }

From b3ac218c3be032846118cc7b01ba25efb0dd5580 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Tue, 29 Aug 2023 15:00:54 +0200
Subject: [PATCH 071/260] Upgrade check: Support mutable variables

---
 .../src/persistence/compatibility.rs          | 81 ++++++++++++++++++-
 .../src/persistence/compatibility.rs          | 43 +++++++++-
 src/codegen/persistence.ml                    | 10 ++-
 .../ok/upgrade-remove-add-fields.drun.ok      | 33 ++++++++
 test/run-drun/upgrade-remove-add-fields.drun  | 19 +++++
 .../upgrade-remove-add-fields/version0.mo     | 21 +++++
 .../upgrade-remove-add-fields/version1.mo     | 15 ++++
 .../upgrade-remove-add-fields/version2.mo     | 18 +++++
 8 files changed, 231 insertions(+), 9 deletions(-)
 create mode 100644 test/run-drun/ok/upgrade-remove-add-fields.drun.ok
 create mode 100644 test/run-drun/upgrade-remove-add-fields.drun
 create mode 100644 test/run-drun/upgrade-remove-add-fields/version0.mo
 create mode 100644 test/run-drun/upgrade-remove-add-fields/version1.mo
 create mode 100644 test/run-drun/upgrade-remove-add-fields/version2.mo

diff --git a/rts/motoko-rts-tests/src/persistence/compatibility.rs b/rts/motoko-rts-tests/src/persistence/compatibility.rs
index 734b67b8b0e..521096ebb6a 100644
--- a/rts/motoko-rts-tests/src/persistence/compatibility.rs
+++ b/rts/motoko-rts-tests/src/persistence/compatibility.rs
@@ -1,5 +1,7 @@
 use motoko_rts::memory::{alloc_blob, Memory};
-use motoko_rts::persistence::compatibility::memory_compatible;
+use motoko_rts::persistence::compatibility::{
+    memory_compatible, MUTABLE_ENCODING_TAG, OBJECT_ENCODING_TAG,
+};
 use motoko_rts::types::{Bytes, Value};
 use std::hash::Hasher;
 use std::{collections::hash_map::DefaultHasher, hash::Hash};
@@ -45,12 +47,14 @@ impl BinaryData {
 #[derive(Clone)]
 enum Type {
     Object(ObjectType),
+    Mutable(MutableType),
 }
 
 impl Type {
     fn serialize(&self, output: &mut BinaryData) {
         match &self {
             Self::Object(object_type) => object_type.serialize(output),
+            Self::Mutable(mutable_type) => mutable_type.serialize(output),
         }
     }
 }
@@ -86,8 +90,7 @@ struct ObjectType {
 
 impl ObjectType {
     fn serialize(&self, output: &mut BinaryData) {
-        const OBJECT_TAG: i32 = 1;
-        output.write_i32(OBJECT_TAG);
+        output.write_i32(OBJECT_ENCODING_TAG);
         output.write_i32(self.fields.len() as i32);
         for field in &self.fields {
             field.serialize(output);
@@ -95,6 +98,18 @@ impl ObjectType {
     }
 }
 
+#[derive(Clone)]
+struct MutableType {
+    variable_type: TypeReference,
+}
+
+impl MutableType {
+    fn serialize(&self, output: &mut BinaryData) {
+        output.write_i32(MUTABLE_ENCODING_TAG);
+        output.write_i32(self.variable_type.index);
+    }
+}
+
 struct TypeTable {
     types: Vec<Type>,
 }
@@ -144,6 +159,7 @@ unsafe fn test_sucessful_cases(heap: &mut TestMemory) {
     test_empty_actor(heap);
     test_reordered_actor_fields(heap);
     test_removed_actor_fields(heap);
+    test_mutable_fields(heap);
     test_added_actor_fields(heap);
     test_removed_object_fields(heap);
     test_direct_recursive_type(heap);
@@ -224,6 +240,21 @@ unsafe fn test_added_actor_fields(heap: &mut TestMemory) {
     assert!(is_compatible(heap, old_type, new_type));
 }
 
+unsafe fn test_mutable_fields(heap: &mut TestMemory) {
+    let actor_type = Type::Object(ObjectType {
+        fields: vec![Field {
+            name: String::from("ActorField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let mutable_type = Type::Mutable(MutableType {
+        variable_type: TypeReference::nat(),
+    });
+    let old_types = vec![actor_type.clone(), mutable_type.clone()];
+    let new_types = vec![actor_type.clone(), mutable_type.clone()];
+    assert!(are_compatible(heap, old_types, new_types));
+}
+
 unsafe fn test_removed_object_fields(heap: &mut TestMemory) {
     let actor_type = Type::Object(ObjectType {
         fields: vec![Field {
@@ -301,6 +332,8 @@ unsafe fn test_indirect_recursive_type(heap: &mut TestMemory) {
 
 unsafe fn test_failing_cases(heap: &mut TestMemory) {
     test_added_object_fields(heap);
+    test_mutable_mismatch(heap);
+    test_immutable_mismatch(heap);
     test_recursion_mismatch(heap);
 }
 
@@ -370,3 +403,45 @@ unsafe fn test_added_object_fields(heap: &mut TestMemory) {
     let new_types = vec![actor_type.clone(), new_type];
     assert!(!are_compatible(heap, old_types, new_types));
 }
+
+unsafe fn test_mutable_mismatch(heap: &mut TestMemory) {
+    let old_actor = Type::Object(ObjectType {
+        fields: vec![Field {
+            name: String::from("ActorField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let mutable_type = Type::Mutable(MutableType {
+        variable_type: TypeReference::nat(),
+    });
+    let new_actor = Type::Object(ObjectType {
+        fields: vec![Field {
+            name: String::from("ActorField"),
+            field_type: TypeReference::nat(),
+        }],
+    });
+    let old_types = vec![old_actor, mutable_type];
+    let new_types = vec![new_actor];
+    assert!(!are_compatible(heap, old_types, new_types));
+}
+
+unsafe fn test_immutable_mismatch(heap: &mut TestMemory) {
+    let old_actor = Type::Object(ObjectType {
+        fields: vec![Field {
+            name: String::from("ActorField"),
+            field_type: TypeReference::nat(),
+        }],
+    });
+    let new_actor = Type::Object(ObjectType {
+        fields: vec![Field {
+            name: String::from("ActorField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let mutable_type = Type::Mutable(MutableType {
+        variable_type: TypeReference::nat(),
+    });
+    let old_types = vec![old_actor];
+    let new_types = vec![new_actor, mutable_type];
+    assert!(!are_compatible(heap, old_types, new_types));
+}
diff --git a/rts/motoko-rts/src/persistence/compatibility.rs b/rts/motoko-rts/src/persistence/compatibility.rs
index eae19e2417a..5936a9443ac 100644
--- a/rts/motoko-rts/src/persistence/compatibility.rs
+++ b/rts/motoko-rts/src/persistence/compatibility.rs
@@ -33,8 +33,9 @@
 //!
 //! ```
 //! <type_table> ::= length:i32 (<type>)^length
-//! <type> ::= <object>
-//! <object> ::= 1l field_list
+//! <type> ::= <object> | <mutable>
+//! <object> ::= 1l <field_list>
+//! <mutable> ::= 2l type_index:i32
 //! <field_list> ::= length:i32 (<field>)^length
 //! <field> ::= label_hash:i32 type_index:i32
 //! ```
@@ -51,12 +52,14 @@ use crate::{
     types::{size_of, Bytes, Value},
 };
 
-const OBJECT_ENCODING_TAG: i32 = 1;
+pub const OBJECT_ENCODING_TAG: i32 = 1;
+pub const MUTABLE_ENCODING_TAG: i32 = 2;
 
 const ACTOR_TYPE_INDEX: i32 = 0;
 
 const OBJECT_ENCODING_HEADER: usize = 2; // object_tag field_list_length
 const FIELD_ENCODING_LENGTH: usize = 2; // label_hash type_index
+const MUTABLE_ENCODING_LENGTH: usize = 2; // object_tag type_index
 
 struct EncodedData {
     words: *const i32,
@@ -117,19 +120,21 @@ impl TypeTable {
     unsafe fn get_actor(&self) -> ObjectType {
         match self.get_type(ACTOR_TYPE_INDEX) {
             Type::Object(object_type) => object_type,
-            // _ => panic!("Invalid stable type encoding")
+            _ => panic!("Invalid stable type encoding"),
         }
     }
 }
 
 enum Type {
     Object(ObjectType),
+    Mutable(MutableType),
 }
 
 impl Type {
     unsafe fn size(data: EncodedData) -> usize {
         match Self::get_type(data) {
             Self::Object(object_type) => object_type.size(),
+            Self::Mutable(mutable_type) => mutable_type.size(),
         }
     }
 
@@ -137,6 +142,7 @@ impl Type {
         let tag = data.read(0);
         match tag {
             OBJECT_ENCODING_TAG => Self::Object(ObjectType::new(data)),
+            MUTABLE_ENCODING_TAG => Self::Mutable(MutableType::new(data)),
             _ => unimplemented!(),
         }
     }
@@ -189,6 +195,22 @@ struct Field {
     type_index: i32,
 }
 
+struct MutableType {
+    type_index: i32,
+}
+
+impl MutableType {
+    unsafe fn new(data: EncodedData) -> MutableType {
+        assert_eq!(data.read(0), MUTABLE_ENCODING_TAG);
+        let type_index = data.read(1);
+        MutableType { type_index }
+    }
+
+    unsafe fn size(&self) -> usize {
+        MUTABLE_ENCODING_LENGTH
+    }
+}
+
 /// Cache for remembering previous type compatibility checks.
 /// Necessary to avoid infinite loops on type recursion.
 /// Helpful to optimize repeated checks.
@@ -282,6 +304,14 @@ impl CompatibilityChecker {
         true
     }
 
+    unsafe fn mutable_compatible(
+        &mut self,
+        new_mutable: &MutableType,
+        old_mutable: &MutableType,
+    ) -> bool {
+        self.type_compatible(new_mutable.type_index, old_mutable.type_index)
+    }
+
     unsafe fn type_compatible(&mut self, new_type_index: i32, old_type_index: i32) -> bool {
         if new_type_index < 0 || old_type_index < 0 {
             return new_type_index == old_type_index;
@@ -296,6 +326,11 @@ impl CompatibilityChecker {
             (Type::Object(new_object), Type::Object(old_object)) => {
                 self.object_compatible(new_object, old_object)
             }
+            (Type::Object(_), _) => false,
+            (Type::Mutable(new_mutable), Type::Mutable(old_mutable)) => {
+                self.mutable_compatible(new_mutable, old_mutable)
+            }
+            (Type::Mutable(_), _) => false,
         }
     }
 
diff --git a/src/codegen/persistence.ml b/src/codegen/persistence.ml
index a05f320a8a4..20833217994 100644
--- a/src/codegen/persistence.ml
+++ b/src/codegen/persistence.ml
@@ -7,8 +7,9 @@
   // Primitive types are encoded by negative indices.
   // All numbers (type indices etc.) are encoded as little endian i32.
   <type_table> ::= length:i32 (<type>)^length
-  <type> ::= <object>
-  <object> ::= 1l field_list
+  <type> ::= <object> | <mutable>
+  <object> ::= 1l <field_list>
+  <mutable> ::= 2l type_index:i32
   <field_list> ::= length:i32 (<field>)^length
   <field> ::= label_hash:i32 type_index:i32
   
@@ -56,6 +57,8 @@ let rec collect_type table typ =
   | Obj (Object, field_list) ->
     let field_types = List.map (fun field -> field.typ) field_list in
     collect_types table field_types
+  | Mut var_type ->
+    collect_type table var_type
   | _ -> 
     Printf.printf "UNSUPPORTED PERSISTENT TYPE %s\n" (Type.string_of_typ typ);
     assert false
@@ -89,6 +92,9 @@ let encode_complex_type table typ =
   | Obj (Object, field_list) -> 
     encode_i32 1l ^ 
     encode_list (encode_field table) field_list
+  | Mut var_type ->
+    encode_i32 2l ^
+    encode_i32 (type_index table var_type)
   | _ -> assert false
 
 let encode_type_table table =
diff --git a/test/run-drun/ok/upgrade-remove-add-fields.drun.ok b/test/run-drun/ok/upgrade-remove-add-fields.drun.ok
new file mode 100644
index 00000000000..61be9d4a059
--- /dev/null
+++ b/test/run-drun/ok/upgrade-remove-add-fields.drun.ok
@@ -0,0 +1,33 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: firstField=1
+debug.print: secondField=1
+debug.print: thirdField=1
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: firstField=2
+debug.print: secondField=2
+debug.print: thirdField=2
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: secondField=3
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: secondField=4
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Memory-incompatible program upgrade
+debug.print: panic occurred in file 'src/persistence.rs' at line 193
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
+ingress Completed: Reply: 0x4449444c0000
+debug.print: secondField=5
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Memory-incompatible program upgrade
+debug.print: panic occurred in file 'src/persistence.rs' at line 193
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
+ingress Completed: Reply: 0x4449444c0000
+debug.print: secondField=6
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/upgrade-remove-add-fields.drun b/test/run-drun/upgrade-remove-add-fields.drun
new file mode 100644
index 00000000000..c9fa228534a
--- /dev/null
+++ b/test/run-drun/upgrade-remove-add-fields.drun
@@ -0,0 +1,19 @@
+# SKIP ic-ref-run
+install $ID upgrade-remove-add-fields/version0.mo ""
+ingress $ID increase "DIDL\x00\x01\x7d\x0F"
+ingress $ID show "DIDL\x00\x00"
+upgrade $ID upgrade-remove-add-fields/version0.mo ""
+ingress $ID increase "DIDL\x00\x01\x7d\x0F"
+ingress $ID show "DIDL\x00\x00"
+upgrade $ID upgrade-remove-add-fields/version1.mo ""
+ingress $ID increase "DIDL\x00\x01\x7d\x0F"
+ingress $ID show "DIDL\x00\x00"
+upgrade $ID upgrade-remove-add-fields/version1.mo ""
+ingress $ID increase "DIDL\x00\x01\x7d\x0F"
+ingress $ID show "DIDL\x00\x00"
+upgrade $ID upgrade-remove-add-fields/version2.mo ""
+ingress $ID increase "DIDL\x00\x01\x7d\x0F"
+ingress $ID show "DIDL\x00\x00"
+upgrade $ID upgrade-remove-add-fields/version2.mo ""
+ingress $ID increase "DIDL\x00\x01\x7d\x0F"
+ingress $ID show "DIDL\x00\x00"
diff --git a/test/run-drun/upgrade-remove-add-fields/version0.mo b/test/run-drun/upgrade-remove-add-fields/version0.mo
new file mode 100644
index 00000000000..cc7330c63bd
--- /dev/null
+++ b/test/run-drun/upgrade-remove-add-fields/version0.mo
@@ -0,0 +1,21 @@
+import Prim "mo:prim";
+
+actor {
+    stable var instance = {
+        var firstField = 0;
+        var secondField = 0;
+        var thirdField = 0;
+    };
+
+    public func increase() : async () {
+        instance.firstField += 1;
+        instance.secondField += 1;
+        instance.thirdField += 1;
+    };
+
+    public func show() : async () {
+        Prim.debugPrint("firstField=" # debug_show (instance.firstField));
+        Prim.debugPrint("secondField=" # debug_show (instance.secondField));
+        Prim.debugPrint("thirdField=" # debug_show (instance.thirdField));
+    };
+};
diff --git a/test/run-drun/upgrade-remove-add-fields/version1.mo b/test/run-drun/upgrade-remove-add-fields/version1.mo
new file mode 100644
index 00000000000..6a21d341207
--- /dev/null
+++ b/test/run-drun/upgrade-remove-add-fields/version1.mo
@@ -0,0 +1,15 @@
+import Prim "mo:prim";
+
+actor {
+    stable var instance = {
+        var secondField = 0;
+    };
+
+    public func increase() : async () {
+        instance.secondField += 1;
+    };
+
+    public func show() : async () {
+        Prim.debugPrint("secondField=" # debug_show (instance.secondField));
+    };
+};
diff --git a/test/run-drun/upgrade-remove-add-fields/version2.mo b/test/run-drun/upgrade-remove-add-fields/version2.mo
new file mode 100644
index 00000000000..fe72a1fdc7f
--- /dev/null
+++ b/test/run-drun/upgrade-remove-add-fields/version2.mo
@@ -0,0 +1,18 @@
+import Prim "mo:prim";
+
+actor {
+    stable var instance = {
+        var secondField = 0;
+        var newField = 0;
+    };
+
+    public func increase() : async () {
+        instance.secondField += 1;
+        instance.newField += 1;
+    };
+
+    public func show() : async () {
+        Prim.debugPrint("secondField=" # debug_show (instance.secondField));
+        Prim.debugPrint("newField=" # debug_show (instance.newField));
+    };
+};

From 31df1321aee76e906805d8cd0410677bd4713765 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Tue, 29 Aug 2023 19:31:49 +0200
Subject: [PATCH 072/260] Continue compatibility check

---
 .../src/persistence/compatibility.rs          | 53 ++++++++++++++++++-
 .../src/persistence/compatibility.rs          | 39 +++++++++++++-
 src/codegen/persistence.ml                    | 52 +++++++++++-------
 3 files changed, 123 insertions(+), 21 deletions(-)

diff --git a/rts/motoko-rts-tests/src/persistence/compatibility.rs b/rts/motoko-rts-tests/src/persistence/compatibility.rs
index 521096ebb6a..f4eb9375b6b 100644
--- a/rts/motoko-rts-tests/src/persistence/compatibility.rs
+++ b/rts/motoko-rts-tests/src/persistence/compatibility.rs
@@ -1,6 +1,6 @@
 use motoko_rts::memory::{alloc_blob, Memory};
 use motoko_rts::persistence::compatibility::{
-    memory_compatible, MUTABLE_ENCODING_TAG, OBJECT_ENCODING_TAG,
+    memory_compatible, MUTABLE_ENCODING_TAG, OBJECT_ENCODING_TAG, OPTION_ENCODING_TAG,
 };
 use motoko_rts::types::{Bytes, Value};
 use std::hash::Hasher;
@@ -48,6 +48,7 @@ impl BinaryData {
 enum Type {
     Object(ObjectType),
     Mutable(MutableType),
+    Option(OptionType),
 }
 
 impl Type {
@@ -55,6 +56,7 @@ impl Type {
         match &self {
             Self::Object(object_type) => object_type.serialize(output),
             Self::Mutable(mutable_type) => mutable_type.serialize(output),
+            Self::Option(option_type) => option_type.serialize(output),
         }
     }
 }
@@ -110,6 +112,18 @@ impl MutableType {
     }
 }
 
+#[derive(Clone)]
+struct OptionType {
+    option_type: TypeReference,
+}
+
+impl OptionType {
+    fn serialize(&self, output: &mut BinaryData) {
+        output.write_i32(OPTION_ENCODING_TAG);
+        output.write_i32(self.option_type.index);
+    }
+}
+
 struct TypeTable {
     types: Vec<Type>,
 }
@@ -164,6 +178,7 @@ unsafe fn test_sucessful_cases(heap: &mut TestMemory) {
     test_removed_object_fields(heap);
     test_direct_recursive_type(heap);
     test_indirect_recursive_type(heap);
+    test_option_types(heap);
 }
 
 unsafe fn test_empty_actor(heap: &mut TestMemory) {
@@ -330,11 +345,26 @@ unsafe fn test_indirect_recursive_type(heap: &mut TestMemory) {
     assert!(are_compatible(heap, types.clone(), types.clone()));
 }
 
+unsafe fn test_option_types(heap: &mut TestMemory) {
+    let actor_type = Type::Object(ObjectType {
+        fields: vec![Field {
+            name: String::from("OptionalField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let option_type = Type::Option(OptionType {
+        option_type: TypeReference::nat(),
+    });
+    let types = vec![actor_type, option_type];
+    assert!(are_compatible(heap, types.clone(), types.clone()));
+}
+
 unsafe fn test_failing_cases(heap: &mut TestMemory) {
     test_added_object_fields(heap);
     test_mutable_mismatch(heap);
     test_immutable_mismatch(heap);
     test_recursion_mismatch(heap);
+    test_option_mismatch(heap);
 }
 
 unsafe fn test_recursion_mismatch(heap: &mut TestMemory) {
@@ -445,3 +475,24 @@ unsafe fn test_immutable_mismatch(heap: &mut TestMemory) {
     let new_types = vec![new_actor, mutable_type];
     assert!(!are_compatible(heap, old_types, new_types));
 }
+
+unsafe fn test_option_mismatch(heap: &mut TestMemory) {
+    let old_actor = Type::Object(ObjectType {
+        fields: vec![Field {
+            name: String::from("OptionalField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let option_type = Type::Option(OptionType {
+        option_type: TypeReference::nat(),
+    });
+    let new_actor = Type::Object(ObjectType {
+        fields: vec![Field {
+            name: String::from("OptionalField"),
+            field_type: TypeReference::nat(),
+        }],
+    });
+    let old_types = vec![old_actor, option_type];
+    let new_types = vec![new_actor];
+    assert!(!are_compatible(heap, old_types, new_types));
+}
diff --git a/rts/motoko-rts/src/persistence/compatibility.rs b/rts/motoko-rts/src/persistence/compatibility.rs
index 5936a9443ac..0fd56f79889 100644
--- a/rts/motoko-rts/src/persistence/compatibility.rs
+++ b/rts/motoko-rts/src/persistence/compatibility.rs
@@ -33,9 +33,10 @@
 //!
 //! ```
 //! <type_table> ::= length:i32 (<type>)^length
-//! <type> ::= <object> | <mutable>
+//! <type> ::= <object> | <mutable> | <option>
 //! <object> ::= 1l <field_list>
 //! <mutable> ::= 2l type_index:i32
+//! <option> ::= 3l type_index:i32
 //! <field_list> ::= length:i32 (<field>)^length
 //! <field> ::= label_hash:i32 type_index:i32
 //! ```
@@ -54,12 +55,14 @@ use crate::{
 
 pub const OBJECT_ENCODING_TAG: i32 = 1;
 pub const MUTABLE_ENCODING_TAG: i32 = 2;
+pub const OPTION_ENCODING_TAG: i32 = 3;
 
 const ACTOR_TYPE_INDEX: i32 = 0;
 
 const OBJECT_ENCODING_HEADER: usize = 2; // object_tag field_list_length
 const FIELD_ENCODING_LENGTH: usize = 2; // label_hash type_index
 const MUTABLE_ENCODING_LENGTH: usize = 2; // object_tag type_index
+const OPTION_ENCODING_LENGTH: usize = 2; // object_tag type_index
 
 struct EncodedData {
     words: *const i32,
@@ -95,7 +98,7 @@ impl TypeTable {
         let blob = value.as_blob();
         assert_eq!(blob.len().as_usize() % size_of::<i32>().as_usize(), 0);
         let words = blob.payload_const() as *const i32;
-        let size = blob.len().as_usize() / size_of::<i32>().as_usize();
+        let size = blob.len().as_usize() / size_of::<i32>().to_bytes().as_usize();
         let data = EncodedData::new(words, size);
         TypeTable { data }
     }
@@ -107,6 +110,7 @@ impl TypeTable {
     }
 
     unsafe fn get_type(&self, type_index: i32) -> Type {
+        assert!(type_index >= 0);
         assert!(type_index <= self.count_types() as i32);
         let mut start = 1;
         for _ in 0..type_index {
@@ -128,6 +132,7 @@ impl TypeTable {
 enum Type {
     Object(ObjectType),
     Mutable(MutableType),
+    Option(OptionType),
 }
 
 impl Type {
@@ -135,6 +140,7 @@ impl Type {
         match Self::get_type(data) {
             Self::Object(object_type) => object_type.size(),
             Self::Mutable(mutable_type) => mutable_type.size(),
+            Self::Option(option_type) => option_type.size(),
         }
     }
 
@@ -143,6 +149,7 @@ impl Type {
         match tag {
             OBJECT_ENCODING_TAG => Self::Object(ObjectType::new(data)),
             MUTABLE_ENCODING_TAG => Self::Mutable(MutableType::new(data)),
+            OPTION_ENCODING_TAG => Self::Option(OptionType::new(data)),
             _ => unimplemented!(),
         }
     }
@@ -211,6 +218,22 @@ impl MutableType {
     }
 }
 
+struct OptionType {
+    type_index: i32,
+}
+
+impl OptionType {
+    unsafe fn new(data: EncodedData) -> OptionType {
+        assert_eq!(data.read(0), OPTION_ENCODING_TAG);
+        let type_index = data.read(1);
+        OptionType { type_index }
+    }
+
+    unsafe fn size(&self) -> usize {
+        OPTION_ENCODING_LENGTH
+    }
+}
+
 /// Cache for remembering previous type compatibility checks.
 /// Necessary to avoid infinite loops on type recursion.
 /// Helpful to optimize repeated checks.
@@ -312,6 +335,14 @@ impl CompatibilityChecker {
         self.type_compatible(new_mutable.type_index, old_mutable.type_index)
     }
 
+    unsafe fn option_compatible(
+        &mut self,
+        new_option: &OptionType,
+        old_option: &OptionType,
+    ) -> bool {
+        self.type_compatible(new_option.type_index, old_option.type_index)
+    }
+
     unsafe fn type_compatible(&mut self, new_type_index: i32, old_type_index: i32) -> bool {
         if new_type_index < 0 || old_type_index < 0 {
             return new_type_index == old_type_index;
@@ -331,6 +362,10 @@ impl CompatibilityChecker {
                 self.mutable_compatible(new_mutable, old_mutable)
             }
             (Type::Mutable(_), _) => false,
+            (Type::Option(new_option), Type::Option(old_option)) => {
+                self.option_compatible(new_option, old_option)
+            }
+            (Type::Option(_), _) => false,
         }
     }
 
diff --git a/src/codegen/persistence.ml b/src/codegen/persistence.ml
index 20833217994..dc8989d51b2 100644
--- a/src/codegen/persistence.ml
+++ b/src/codegen/persistence.ml
@@ -7,9 +7,10 @@
   // Primitive types are encoded by negative indices.
   // All numbers (type indices etc.) are encoded as little endian i32.
   <type_table> ::= length:i32 (<type>)^length
-  <type> ::= <object> | <mutable>
+  <type> ::= <object> | <mutable> | <option>
   <object> ::= 1l <field_list>
   <mutable> ::= 2l type_index:i32
+  <option> ::= 3l type_index:i32
   <field_list> ::= length:i32 (<field>)^length
   <field> ::= label_hash:i32 type_index:i32
   
@@ -32,12 +33,16 @@ module TypeTable = struct
   let length table = List.length table
 
   let index_of table typ =
-    match Lib.List.index_of typ table with
-    | Some index -> index
-    | None -> assert false
+    let rec get_index table index =
+      match table with
+      | [] -> assert false
+      | current::remainder ->
+          if Type.eq current typ then index
+          else get_index remainder (Int.add index 1) in
+    get_index table 0
 
   let contains_type table typ =
-    match List.find_opt (fun entry -> entry = typ) table with
+    match List.find_opt (fun entry -> Type.eq entry typ) table with
     | Some _ -> true
     | None -> false
 
@@ -45,23 +50,31 @@ module TypeTable = struct
     let open Type in
     match typ with
     | Prim _ -> table
-    | _ when contains_type table typ -> table
     | _ -> List.append table [typ]
 end
 
 let rec collect_type table typ =
-  let table = TypeTable.add_type table typ in
-  let open Type in
-  match typ with
-  | Prim _ -> table
-  | Obj (Object, field_list) ->
-    let field_types = List.map (fun field -> field.typ) field_list in
-    collect_types table field_types
-  | Mut var_type ->
-    collect_type table var_type
-  | _ -> 
-    Printf.printf "UNSUPPORTED PERSISTENT TYPE %s\n" (Type.string_of_typ typ);
-    assert false
+  if TypeTable.contains_type table typ then
+    table
+  else  
+    (let table = TypeTable.add_type table typ in
+    let open Type in
+    match typ with
+    | Prim _ -> table
+    | Obj (Object, field_list) ->
+      let field_types = List.map (fun field -> field.typ) field_list in
+      collect_types table field_types
+    | Mut var_type ->
+      collect_type table var_type
+    | Opt opt_type ->
+      collect_type table opt_type
+    | Con (construction, type_list) -> 
+      (match Mo_types.Cons.kind construction with
+      | Abs _ -> assert false
+      | Def (_, type_definition) -> collect_type table type_definition)
+    | _ ->
+      Printf.printf "UNSUPPORTED PERSISTENT TYPE %s\n" (Type.string_of_typ typ);
+      assert false)
 
 and collect_types table type_list =
   match type_list with
@@ -95,6 +108,9 @@ let encode_complex_type table typ =
   | Mut var_type ->
     encode_i32 2l ^
     encode_i32 (type_index table var_type)
+  | Opt opt_type ->
+    encode_i32 3l ^
+    encode_i32 (type_index table opt_type)
   | _ -> assert false
 
 let encode_type_table table =

From f2d67c58401df98f8919100ed04edf894f383cf0 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Wed, 30 Aug 2023 08:27:05 +0200
Subject: [PATCH 073/260] Add test case

---
 .../ok/upgrade-recursive-type.drun.ok         | 17 ++++++++++
 test/run-drun/upgrade-recursive-type.drun     | 13 ++++++++
 .../upgrade-recursive-type/version0.mo        | 31 ++++++++++++++++++
 .../upgrade-recursive-type/version1.mo        | 24 ++++++++++++++
 test/run.sh                                   | 32 +++++++++----------
 5 files changed, 101 insertions(+), 16 deletions(-)
 create mode 100644 test/run-drun/ok/upgrade-recursive-type.drun.ok
 create mode 100644 test/run-drun/upgrade-recursive-type.drun
 create mode 100644 test/run-drun/upgrade-recursive-type/version0.mo
 create mode 100644 test/run-drun/upgrade-recursive-type/version1.mo

diff --git a/test/run-drun/ok/upgrade-recursive-type.drun.ok b/test/run-drun/ok/upgrade-recursive-type.drun.ok
new file mode 100644
index 00000000000..e9e921de8a5
--- /dev/null
+++ b/test/run-drun/ok/upgrade-recursive-type.drun.ok
@@ -0,0 +1,17 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: CHECK 1
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: CHECK 2
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: CHECK 3
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: CHECK 4
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/upgrade-recursive-type.drun b/test/run-drun/upgrade-recursive-type.drun
new file mode 100644
index 00000000000..b7260ae98bc
--- /dev/null
+++ b/test/run-drun/upgrade-recursive-type.drun
@@ -0,0 +1,13 @@
+# SKIP ic-ref-run
+install $ID upgrade-recursive-type/version0.mo ""
+ingress $ID increase "DIDL\x00\x01\x7d\x0F"
+ingress $ID check "DIDL\x00\x00"
+upgrade $ID upgrade-recursive-type/version0.mo ""
+ingress $ID increase "DIDL\x00\x01\x7d\x0F"
+ingress $ID check "DIDL\x00\x00"
+upgrade $ID upgrade-recursive-type/version1.mo ""
+ingress $ID increase "DIDL\x00\x01\x7d\x0F"
+ingress $ID check "DIDL\x00\x00"
+upgrade $ID upgrade-recursive-type/version1.mo ""
+ingress $ID increase "DIDL\x00\x01\x7d\x0F"
+ingress $ID check "DIDL\x00\x00"
diff --git a/test/run-drun/upgrade-recursive-type/version0.mo b/test/run-drun/upgrade-recursive-type/version0.mo
new file mode 100644
index 00000000000..84d95f3aa18
--- /dev/null
+++ b/test/run-drun/upgrade-recursive-type/version0.mo
@@ -0,0 +1,31 @@
+import Prim "mo:prim";
+
+actor {
+    type Node = {
+        var value : Nat;
+        var next : ?Node;
+        var test : Nat;
+    };
+
+    let node = { var value = 0; var next = null : ?Node; var test = 0 };
+    node.next := ?node;
+
+    stable var root = node;
+
+    public func increase() : async () {
+        root.value += 1;
+        root.test := root.value;
+    };
+
+    public func check() : async () {
+        Prim.debugPrint("CHECK " # debug_show (root.value));
+        assert (root.value == root.test);
+        switch (root.next) {
+            case null Prim.trap("");
+            case (?next) {
+                assert (next.value == root.value);
+                assert (next.value == root.test);
+            };
+        };
+    };
+};
diff --git a/test/run-drun/upgrade-recursive-type/version1.mo b/test/run-drun/upgrade-recursive-type/version1.mo
new file mode 100644
index 00000000000..f6e0b4b36c4
--- /dev/null
+++ b/test/run-drun/upgrade-recursive-type/version1.mo
@@ -0,0 +1,24 @@
+import Prim "mo:prim";
+
+actor {
+    type Node = {
+        var value : Nat;
+        var next : ?Node;
+    };
+
+    stable var root = { var value = 0; var next = null : ?Node };
+
+    public func increase() : async () {
+        root.value += 1;
+    };
+
+    public func check() : async () {
+        Prim.debugPrint("CHECK " # debug_show (root.value));
+        switch (root.next) {
+            case null Prim.trap("");
+            case (?next) {
+                assert (next.value == root.value);
+            };
+        };
+    };
+};
diff --git a/test/run.sh b/test/run.sh
index 9035830ac33..529b25ab05b 100755
--- a/test/run.sh
+++ b/test/run.sh
@@ -188,22 +188,22 @@ then
   fi
 fi
 
-if [ $DTESTS = yes ]
-then
-  if ic-ref-run --help >& /dev/null
-  then
-    HAVE_ic_ref_run=yes
-  else
-    if [ $ACCEPT = yes ]
-    then
-      echo "ERROR: Could not run ic-ref-run, cannot update expected test output"
-      exit 1
-    else
-      echo "WARNING: Could not run ic-ref-run, will skip running some tests"
-      HAVE_ic_ref_run=no
-    fi
-  fi
-fi
+# if [ $DTESTS = yes ]
+# then
+#   if ic-ref-run --help >& /dev/null
+#   then
+#     HAVE_ic_ref_run=yes
+#   else
+#     if [ $ACCEPT = yes ]
+#     then
+#       echo "ERROR: Could not run ic-ref-run, cannot update expected test output"
+#       exit 1
+#     else
+#       echo "WARNING: Could not run ic-ref-run, will skip running some tests"
+#       HAVE_ic_ref_run=no
+#     fi
+#   fi
+# fi
 
 
 for file in "$@";

From ed8f4f7ef0f86118f7c71d05d714be9ae3c9c9cd Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Wed, 30 Aug 2023 08:27:40 +0200
Subject: [PATCH 074/260] Revert run script changes

---
 test/run.sh | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/test/run.sh b/test/run.sh
index 529b25ab05b..9035830ac33 100755
--- a/test/run.sh
+++ b/test/run.sh
@@ -188,22 +188,22 @@ then
   fi
 fi
 
-# if [ $DTESTS = yes ]
-# then
-#   if ic-ref-run --help >& /dev/null
-#   then
-#     HAVE_ic_ref_run=yes
-#   else
-#     if [ $ACCEPT = yes ]
-#     then
-#       echo "ERROR: Could not run ic-ref-run, cannot update expected test output"
-#       exit 1
-#     else
-#       echo "WARNING: Could not run ic-ref-run, will skip running some tests"
-#       HAVE_ic_ref_run=no
-#     fi
-#   fi
-# fi
+if [ $DTESTS = yes ]
+then
+  if ic-ref-run --help >& /dev/null
+  then
+    HAVE_ic_ref_run=yes
+  else
+    if [ $ACCEPT = yes ]
+    then
+      echo "ERROR: Could not run ic-ref-run, cannot update expected test output"
+      exit 1
+    else
+      echo "WARNING: Could not run ic-ref-run, will skip running some tests"
+      HAVE_ic_ref_run=no
+    fi
+  fi
+fi
 
 
 for file in "$@";

From 5bb6a394b207dd4510c7ef0591fc67ebc192735b Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 31 Aug 2023 10:32:19 +0200
Subject: [PATCH 075/260] Compatibility check: Support all stable primitive
 types

---
 .../src/persistence/compatibility.rs          | 204 ++++++++++++++++--
 .../src/persistence/compatibility.rs          |  23 +-
 src/codegen/persistence.ml                    |  47 +++-
 .../ok/upgrade-primitive-types.drun-run.ok    |  63 ++++++
 test/run-drun/upgrade-primitive-types.mo      |  68 ++++++
 5 files changed, 378 insertions(+), 27 deletions(-)
 create mode 100644 test/run-drun/ok/upgrade-primitive-types.drun-run.ok
 create mode 100644 test/run-drun/upgrade-primitive-types.mo

diff --git a/rts/motoko-rts-tests/src/persistence/compatibility.rs b/rts/motoko-rts-tests/src/persistence/compatibility.rs
index f4eb9375b6b..be0bb3255ee 100644
--- a/rts/motoko-rts-tests/src/persistence/compatibility.rs
+++ b/rts/motoko-rts-tests/src/persistence/compatibility.rs
@@ -66,9 +66,97 @@ struct TypeReference {
     index: i32,
 }
 
+// Keep identical to `compatibility.rs` and `persistence.ml`.
+const NULL_ENCODING_TAG: i32 = -1;
+const BOOL_ENCODING_TAG: i32 = -2;
+const NAT_ENCODING_TAG: i32 = -3;
+const NAT8_ENCODING_TAG: i32 = -4;
+const NAT16_ENCODING_TAG: i32 = -5;
+const NAT32_ENCODING_TAG: i32 = -6;
+const NAT64_ENCODING_TAG: i32 = -7;
+const INT_ENCODING_TAG: i32 = -8;
+const INT8_ENCODING_TAG: i32 = -9;
+const INT16_ENCODING_TAG: i32 = -10;
+const INT32_ENCODING_TAG: i32 = -11;
+const INT64_ENCODING_TAG: i32 = -12;
+const FLOAT_ENCODING_TAG: i32 = -13;
+const CHAR_ENCODING_TAG: i32 = -14;
+const TEXT_ENCODING_TAG: i32 = -15;
+const BLOB_ENCODING_TAG: i32 = -16;
+const PRINCIPAL_ENCODING_TAG: i32 = -16;
+
 impl TypeReference {
-    fn nat() -> TypeReference {
-        TypeReference { index: -1 }
+    fn primitive(index: i32) -> Self {
+        assert!(index < 0);
+        TypeReference { index }
+    }
+
+    fn null() -> Self {
+        Self::primitive(NULL_ENCODING_TAG)
+    }
+
+    fn bool() -> Self {
+        Self::primitive(BOOL_ENCODING_TAG)
+    }
+
+    fn nat() -> Self {
+        Self::primitive(NAT_ENCODING_TAG)
+    }
+
+    fn nat8() -> Self {
+        Self::primitive(NAT8_ENCODING_TAG)
+    }
+
+    fn nat16() -> Self {
+        Self::primitive(NAT16_ENCODING_TAG)
+    }
+
+    fn nat32() -> Self {
+        Self::primitive(NAT32_ENCODING_TAG)
+    }
+
+    fn nat64() -> Self {
+        Self::primitive(NAT64_ENCODING_TAG)
+    }
+
+    fn int() -> Self {
+        Self::primitive(INT_ENCODING_TAG)
+    }
+
+    fn int8() -> Self {
+        Self::primitive(INT8_ENCODING_TAG)
+    }
+
+    fn int16() -> Self {
+        Self::primitive(INT16_ENCODING_TAG)
+    }
+
+    fn int32() -> Self {
+        Self::primitive(INT32_ENCODING_TAG)
+    }
+
+    fn int64() -> Self {
+        Self::primitive(INT64_ENCODING_TAG)
+    }
+
+    fn float() -> Self {
+        Self::primitive(FLOAT_ENCODING_TAG)
+    }
+
+    fn char() -> Self {
+        Self::primitive(CHAR_ENCODING_TAG)
+    }
+
+    fn text() -> Self {
+        Self::primitive(TEXT_ENCODING_TAG)
+    }
+
+    fn blob() -> Self {
+        Self::primitive(BLOB_ENCODING_TAG)
+    }
+
+    fn principal() -> Self {
+        Self::primitive(PRINCIPAL_ENCODING_TAG)
     }
 }
 
@@ -171,6 +259,7 @@ pub unsafe fn test() {
 
 unsafe fn test_sucessful_cases(heap: &mut TestMemory) {
     test_empty_actor(heap);
+    test_matching_primitives(heap);
     test_reordered_actor_fields(heap);
     test_removed_actor_fields(heap);
     test_mutable_fields(heap);
@@ -187,10 +276,87 @@ unsafe fn test_empty_actor(heap: &mut TestMemory) {
     assert!(is_compatible(heap, old_type, new_type));
 }
 
+unsafe fn test_matching_primitives(heap: &mut TestMemory) {
+    let fields = vec![
+        Field {
+            name: String::from("NullField"),
+            field_type: TypeReference::null(),
+        },
+        Field {
+            name: String::from("BoolField"),
+            field_type: TypeReference::bool(),
+        },
+        Field {
+            name: String::from("NatField"),
+            field_type: TypeReference::nat(),
+        },
+        Field {
+            name: String::from("Nat8Field"),
+            field_type: TypeReference::nat8(),
+        },
+        Field {
+            name: String::from("Nat16Field"),
+            field_type: TypeReference::nat16(),
+        },
+        Field {
+            name: String::from("Nat32Field"),
+            field_type: TypeReference::nat32(),
+        },
+        Field {
+            name: String::from("Nat64Field"),
+            field_type: TypeReference::nat64(),
+        },
+        Field {
+            name: String::from("IntField"),
+            field_type: TypeReference::int(),
+        },
+        Field {
+            name: String::from("Int8Field"),
+            field_type: TypeReference::int8(),
+        },
+        Field {
+            name: String::from("Int16Field"),
+            field_type: TypeReference::int16(),
+        },
+        Field {
+            name: String::from("Int32Field"),
+            field_type: TypeReference::int32(),
+        },
+        Field {
+            name: String::from("Int64Field"),
+            field_type: TypeReference::int64(),
+        },
+        Field {
+            name: String::from("FloatField"),
+            field_type: TypeReference::float(),
+        },
+        Field {
+            name: String::from("CharField"),
+            field_type: TypeReference::char(),
+        },
+        Field {
+            name: String::from("TextField"),
+            field_type: TypeReference::text(),
+        },
+        Field {
+            name: String::from("BlobField"),
+            field_type: TypeReference::blob(),
+        },
+        Field {
+            name: String::from("PrincipalField"),
+            field_type: TypeReference::principal(),
+        },
+    ];
+
+    let types = Type::Object(ObjectType { fields });
+
+    assert!(is_compatible(heap, types.clone(), types));
+}
+
 unsafe fn test_reordered_actor_fields(heap: &mut TestMemory) {
     let field1 = Field {
         name: String::from("Field1"),
-        field_type: TypeReference::nat(),
+        field_type: TypeReference::int(),
     };
     let field2 = Field {
         name: String::from("Field2"),
@@ -210,15 +376,15 @@ unsafe fn test_reordered_actor_fields(heap: &mut TestMemory) {
 unsafe fn test_removed_actor_fields(heap: &mut TestMemory) {
     let field1 = Field {
         name: String::from("Field1"),
-        field_type: TypeReference::nat(),
+        field_type: TypeReference::nat8(),
     };
     let field2 = Field {
         name: String::from("Field2"),
-        field_type: TypeReference::nat(),
+        field_type: TypeReference::nat16(),
     };
     let field3 = Field {
         name: String::from("Field3"),
-        field_type: TypeReference::nat(),
+        field_type: TypeReference::nat32(),
     };
 
     let old_type = Type::Object(ObjectType {
@@ -234,15 +400,15 @@ unsafe fn test_removed_actor_fields(heap: &mut TestMemory) {
 unsafe fn test_added_actor_fields(heap: &mut TestMemory) {
     let field1 = Field {
         name: String::from("Field1"),
-        field_type: TypeReference::nat(),
+        field_type: TypeReference::bool(),
     };
     let field2 = Field {
         name: String::from("Field2"),
-        field_type: TypeReference::nat(),
+        field_type: TypeReference::char(),
     };
     let field3 = Field {
         name: String::from("Field3"),
-        field_type: TypeReference::nat(),
+        field_type: TypeReference::text(),
     };
 
     let old_type = Type::Object(ObjectType {
@@ -280,15 +446,15 @@ unsafe fn test_removed_object_fields(heap: &mut TestMemory) {
 
     let field1 = Field {
         name: String::from("Field1"),
-        field_type: TypeReference::nat(),
+        field_type: TypeReference::int8(),
     };
     let field2 = Field {
         name: String::from("Field2"),
-        field_type: TypeReference::nat(),
+        field_type: TypeReference::int16(),
     };
     let field3 = Field {
         name: String::from("Field3"),
-        field_type: TypeReference::nat(),
+        field_type: TypeReference::int32(),
     };
 
     let old_type = Type::Object(ObjectType {
@@ -353,7 +519,7 @@ unsafe fn test_option_types(heap: &mut TestMemory) {
         }],
     });
     let option_type = Type::Option(OptionType {
-        option_type: TypeReference::nat(),
+        option_type: TypeReference::blob(),
     });
     let types = vec![actor_type, option_type];
     assert!(are_compatible(heap, types.clone(), types.clone()));
@@ -391,7 +557,7 @@ unsafe fn test_recursion_mismatch(heap: &mut TestMemory) {
     });
     let non_recursive_field = Field {
         name: String::from("Field"),
-        field_type: TypeReference::nat(),
+        field_type: TypeReference::principal(),
     };
     let non_recursive_type = Type::Object(ObjectType {
         fields: vec![non_recursive_field],
@@ -411,15 +577,15 @@ unsafe fn test_added_object_fields(heap: &mut TestMemory) {
 
     let field1 = Field {
         name: String::from("Field1"),
-        field_type: TypeReference::nat(),
+        field_type: TypeReference::nat64(),
     };
     let field2 = Field {
         name: String::from("Field2"),
-        field_type: TypeReference::nat(),
+        field_type: TypeReference::float(),
     };
     let field3 = Field {
         name: String::from("Field3"),
-        field_type: TypeReference::nat(),
+        field_type: TypeReference::int64(),
     };
 
     let old_type = Type::Object(ObjectType {
@@ -459,7 +625,7 @@ unsafe fn test_immutable_mismatch(heap: &mut TestMemory) {
     let old_actor = Type::Object(ObjectType {
         fields: vec![Field {
             name: String::from("ActorField"),
-            field_type: TypeReference::nat(),
+            field_type: TypeReference::bool(),
         }],
     });
     let new_actor = Type::Object(ObjectType {
@@ -489,7 +655,7 @@ unsafe fn test_option_mismatch(heap: &mut TestMemory) {
     let new_actor = Type::Object(ObjectType {
         fields: vec![Field {
             name: String::from("OptionalField"),
-            field_type: TypeReference::nat(),
+            field_type: TypeReference::null(),
         }],
     });
     let old_types = vec![old_actor, option_type];
diff --git a/rts/motoko-rts/src/persistence/compatibility.rs b/rts/motoko-rts/src/persistence/compatibility.rs
index 0fd56f79889..4b091067199 100644
--- a/rts/motoko-rts/src/persistence/compatibility.rs
+++ b/rts/motoko-rts/src/persistence/compatibility.rs
@@ -42,10 +42,25 @@
 //! ```
 //!
 //! Predefined primitive type indices
-//!
-//! Type    | Index
-//! ------- | --------
-//! Nat     | -1l
+//! Type      | Index
+//! --------- | --------
+//! Null      | -1l
+//! Bool      | -2l
+//! Nat       | -3l
+//! Nat8      | -4l
+//! Nat16     | -5l
+//! Nat32     | -6l
+//! Nat64     | -7l
+//! Int       | -8l
+//! Int8      | -9l
+//! Int16     | -10l
+//! Int32     | -11l
+//! Int64     | -12l
+//! Float     | -13l
+//! Char      | -14l
+//! Text      | -15l
+//! Blob      | -16l
+//! Principal | -17l
 
 use crate::{
     mem_utils::memzero_bytes,
diff --git a/src/codegen/persistence.ml b/src/codegen/persistence.ml
index dc8989d51b2..ee4fa55a02f 100644
--- a/src/codegen/persistence.ml
+++ b/src/codegen/persistence.ml
@@ -14,8 +14,26 @@
   <field_list> ::= length:i32 (<field>)^length
   <field> ::= label_hash:i32 type_index:i32
   
-  Predefined primitive type indices:
-  Nat -1l
+  // Predefined primitive type indices
+  Type      | Index
+  --------- | --------
+  Null      | -1l
+  Bool      | -2l
+  Nat       | -3l
+  Nat8      | -4l
+  Nat16     | -5l
+  Nat32     | -6l
+  Nat64     | -7l
+  Int       | -8l
+  Int8      | -9l
+  Int16     | -10l
+  Int32     | -11l
+  Int64     | -12l
+  Float     | -13l
+  Char      | -14l
+  Text      | -15l
+  Blob      | -16l
+  Principal | -17l
 *)
 
 open Mo_types
@@ -86,11 +104,32 @@ let encode_list encode_element list =
   let elements = List.map encode_element list in
   encode_i32 length ^ list_to_string elements
 
+let primitive_type_index primitive_type =
+  let open Type in
+  match primitive_type with
+  | Null -> -1l
+  | Bool -> -2l
+  | Nat -> -3l
+  | Nat8 -> -4l
+  | Nat16 -> -5l
+  | Nat32 -> -6l
+  | Nat64 -> -7l
+  | Int -> -8l
+  | Int8 -> -9l
+  | Int16 -> -10l
+  | Int32 -> -11l
+  | Int64 -> -12l
+  | Float -> -13l
+  | Char -> -14l
+  | Text -> -15l
+  | Blob -> -16l
+  | Principal -> -17l
+  | Error -> assert false (* non-stable type *)
+
 let type_index table typ =
   let open Type in
   match typ with
-  | Prim Nat -> -1l
-  | Prim _ -> assert false
+  | Prim primitive_type -> primitive_type_index primitive_type
   | _ -> Int32.of_int (TypeTable.index_of table typ)
 
 let encode_field table field =
diff --git a/test/run-drun/ok/upgrade-primitive-types.drun-run.ok b/test/run-drun/ok/upgrade-primitive-types.drun-run.ok
new file mode 100644
index 00000000000..f413a8c56a9
--- /dev/null
+++ b/test/run-drun/ok/upgrade-primitive-types.drun-run.ok
@@ -0,0 +1,63 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+debug.print: Initialized
+ingress Completed: Reply: 0x4449444c0000
+debug.print: null
+debug.print: false
+debug.print: 1_234_567_890_123_456_789_012_345_678_901_234_567_890
+debug.print: 123
+debug.print: 12_345
+debug.print: 1_234_567_890
+debug.print: 123_456_789_012_345
+debug.print: -1_234_567_890_123_456_789_012_345_678_901_234_567_890
+debug.print: -123
+debug.print: -12_345
+debug.print: -1_234_567_890
+debug.print: -123_456_789_012_345
+debug.print: 1.234568
+debug.print: '!'
+debug.print: ""TEST""
+debug.print: "\61\62\63"
+debug.print: un4fu-tqaaa-aaaab-qadjq-cai
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Initialized
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: null
+debug.print: true
+debug.print: 1_234_567_890_123_456_789_012_345_678_901_234_567_891
+debug.print: 124
+debug.print: 12_346
+debug.print: 1_234_567_891
+debug.print: 123_456_789_012_346
+debug.print: -1_234_567_890_123_456_789_012_345_678_901_234_567_890
+debug.print: -123
+debug.print: -12_345
+debug.print: -1_234_567_890
+debug.print: -123_456_789_012_345
+debug.print: 1.334568
+debug.print: '?'
+debug.print: ""TEST" "TEST""
+debug.print: "\61\62\63"
+debug.print: un4fu-tqaaa-aaaab-qadjq-cai
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Initialized
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: null
+debug.print: false
+debug.print: 1_234_567_890_123_456_789_012_345_678_901_234_567_892
+debug.print: 125
+debug.print: 12_347
+debug.print: 1_234_567_892
+debug.print: 123_456_789_012_347
+debug.print: -1_234_567_890_123_456_789_012_345_678_901_234_567_890
+debug.print: -123
+debug.print: -12_345
+debug.print: -1_234_567_890
+debug.print: -123_456_789_012_345
+debug.print: 1.434568
+debug.print: '!'
+debug.print: ""TEST" "TEST" "TEST""
+debug.print: "\61\62\63"
+debug.print: un4fu-tqaaa-aaaab-qadjq-cai
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/upgrade-primitive-types.mo b/test/run-drun/upgrade-primitive-types.mo
new file mode 100644
index 00000000000..117c12df82e
--- /dev/null
+++ b/test/run-drun/upgrade-primitive-types.mo
@@ -0,0 +1,68 @@
+import Prim "mo:prim";
+
+actor {
+    stable var nullVariable = null;
+    stable var boolVariable = false;
+    stable var natVariable = 1234567890123456789012345678901234567890;
+    stable var nat8Variable = 123: Nat8;
+    stable var nat16Variable = 12345: Nat16;
+    stable var nat32Variable = 1234567890: Nat32;
+    stable var nat64Variable = 123456789012345: Nat64;
+    stable var intVariable = -1234567890123456789012345678901234567890;
+    stable var int8Variable = -123: Int8;
+    stable var int16Variable = -12345: Int16;
+    stable var int32Variable = -1234567890: Int32;
+    stable var int64Variable = -123456789012345: Int64;
+    stable var floatVariable = 1.234567890;
+    stable var charVariable = '!';
+    stable var textVariable = "\"TEST\"";
+    stable var blobVariable = "abc": Blob;
+    stable var principalVariable = Prim.principalOfBlob ("\00\00\00\00\00\30\00\D3\01\01": Blob);
+
+    Prim.debugPrint("Initialized");
+
+    public func increase() : async () {
+        nullVariable := null;
+        boolVariable := not boolVariable;
+        natVariable += 1;
+        nat8Variable += 1;
+        nat16Variable += 1;
+        nat32Variable += 1;
+        nat64Variable += 1;
+        floatVariable += 0.1;
+        charVariable := if (charVariable == '!') { '?' } else { '!' };
+        textVariable #= " \"TEST\"";
+    };
+
+    public func print() : async () {
+        Prim.debugPrint(debug_show(nullVariable));
+        Prim.debugPrint(debug_show(boolVariable));
+        Prim.debugPrint(debug_show(natVariable));
+        Prim.debugPrint(debug_show(nat8Variable));
+        Prim.debugPrint(debug_show(nat16Variable));
+        Prim.debugPrint(debug_show(nat32Variable));
+        Prim.debugPrint(debug_show(nat64Variable));
+        Prim.debugPrint(debug_show(intVariable));
+        Prim.debugPrint(debug_show(int8Variable));
+        Prim.debugPrint(debug_show(int16Variable));
+        Prim.debugPrint(debug_show(int32Variable));
+        Prim.debugPrint(debug_show(int64Variable));
+        Prim.debugPrint(debug_show(floatVariable));
+        Prim.debugPrint(debug_show(charVariable));
+        Prim.debugPrint(debug_show(textVariable));
+        Prim.debugPrint(debug_show(blobVariable));
+        Prim.debugPrint(debug_show(principalVariable));
+    };
+}
+
+//SKIP run
+//SKIP run-low
+//SKIP run-ir
+//SKIP comp-ref
+//CALL ingress print "DIDL\x00\x00"
+//CALL upgrade ""
+//CALL ingress increase "DIDL\x00\x00"
+//CALL ingress print "DIDL\x00\x00"
+//CALL upgrade ""
+//CALL ingress increase "DIDL\x00\x00"
+//CALL ingress print "DIDL\x00\x00"

From 963edbc5e49fadfdc0d5c8317edc59bc0cbd9af9 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 31 Aug 2023 14:12:03 +0200
Subject: [PATCH 076/260] More unit tests

---
 .../src/persistence/compatibility.rs          | 49 +++++++++++++++++--
 1 file changed, 46 insertions(+), 3 deletions(-)

diff --git a/rts/motoko-rts-tests/src/persistence/compatibility.rs b/rts/motoko-rts-tests/src/persistence/compatibility.rs
index be0bb3255ee..d5484fb7e4c 100644
--- a/rts/motoko-rts-tests/src/persistence/compatibility.rs
+++ b/rts/motoko-rts-tests/src/persistence/compatibility.rs
@@ -61,7 +61,7 @@ impl Type {
     }
 }
 
-#[derive(Clone)]
+#[derive(PartialEq, Clone)]
 struct TypeReference {
     index: i32,
 }
@@ -252,14 +252,57 @@ unsafe fn is_compatible<M: Memory>(mem: &mut M, old_type: Type, new_type: Type)
 pub unsafe fn test() {
     println!("  Testing memory compatibility...");
     let mut heap = initialize_test_memory();
+    test_primitive_types(&mut heap);
     test_sucessful_cases(&mut heap);
     test_failing_cases(&mut heap);
     reset_test_memory();
 }
 
+unsafe fn test_primitive_types(heap: &mut TestMemory) {
+    let mut is_compatible = |first: &TypeReference, second: &TypeReference| {
+        let old_types = Type::Object(ObjectType {
+            fields: vec![Field {
+                name: String::from("Field"),
+                field_type: first.clone(),
+            }],
+        });
+        let new_types = Type::Object(ObjectType {
+            fields: vec![Field {
+                name: String::from("Field"),
+                field_type: second.clone(),
+            }],
+        });
+        is_compatible(heap, old_types, new_types)
+    };
+    let all_types = [
+        TypeReference::null(),
+        TypeReference::bool(),
+        TypeReference::nat(),
+        TypeReference::nat8(),
+        TypeReference::nat16(),
+        TypeReference::nat32(),
+        TypeReference::nat64(),
+        TypeReference::int(),
+        TypeReference::int8(),
+        TypeReference::int16(),
+        TypeReference::int32(),
+        TypeReference::int64(),
+        TypeReference::float(),
+        TypeReference::char(),
+        TypeReference::text(),
+        TypeReference::blob(),
+        TypeReference::principal(),
+    ];
+    for first in &all_types {
+        for second in &all_types {
+            assert_eq!(is_compatible(first, second), first == second);
+        }
+    }
+}
+
 unsafe fn test_sucessful_cases(heap: &mut TestMemory) {
     test_empty_actor(heap);
-    test_matching_primitives(heap);
+    test_multiple_primitive_fields(heap);
     test_reordered_actor_fields(heap);
     test_removed_actor_fields(heap);
     test_mutable_fields(heap);
@@ -276,7 +319,7 @@ unsafe fn test_empty_actor(heap: &mut TestMemory) {
     assert!(is_compatible(heap, old_type, new_type));
 }
 
-unsafe fn test_matching_primitives(heap: &mut TestMemory) {
+unsafe fn test_multiple_primitive_fields(heap: &mut TestMemory) {
     let fields = vec![
         Field {
             name: String::from("NullField"),

From b9e016797da9a2b2fbc067c33a549ccf32d478e7 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 31 Aug 2023 14:21:36 +0200
Subject: [PATCH 077/260] Check array compatibility

---
 .../src/persistence/compatibility.rs          | 117 +++++++++++++++++-
 .../src/persistence/compatibility.rs          |  36 +++++-
 src/codegen/persistence.ml                    |  43 ++++---
 test/run-drun/array-upgrades.drun             |  19 +++
 test/run-drun/array-upgrades/version0.mo      |  16 +++
 test/run-drun/array-upgrades/version1.mo      |  16 +++
 test/run-drun/array-upgrades/version2.mo      |  16 +++
 test/run-drun/array-upgrades/version3.mo      |  16 +++
 test/run-drun/array-upgrades/version4.mo      |  15 +++
 test/run-drun/ok/array-upgrades.drun.ok       |  45 +++++++
 10 files changed, 320 insertions(+), 19 deletions(-)
 create mode 100644 test/run-drun/array-upgrades.drun
 create mode 100644 test/run-drun/array-upgrades/version0.mo
 create mode 100644 test/run-drun/array-upgrades/version1.mo
 create mode 100644 test/run-drun/array-upgrades/version2.mo
 create mode 100644 test/run-drun/array-upgrades/version3.mo
 create mode 100644 test/run-drun/array-upgrades/version4.mo
 create mode 100644 test/run-drun/ok/array-upgrades.drun.ok

diff --git a/rts/motoko-rts-tests/src/persistence/compatibility.rs b/rts/motoko-rts-tests/src/persistence/compatibility.rs
index d5484fb7e4c..03dc1d6e7c6 100644
--- a/rts/motoko-rts-tests/src/persistence/compatibility.rs
+++ b/rts/motoko-rts-tests/src/persistence/compatibility.rs
@@ -1,6 +1,7 @@
 use motoko_rts::memory::{alloc_blob, Memory};
 use motoko_rts::persistence::compatibility::{
-    memory_compatible, MUTABLE_ENCODING_TAG, OBJECT_ENCODING_TAG, OPTION_ENCODING_TAG,
+    memory_compatible, ARRAY_ENCODING_TAG, MUTABLE_ENCODING_TAG, OBJECT_ENCODING_TAG,
+    OPTION_ENCODING_TAG,
 };
 use motoko_rts::types::{Bytes, Value};
 use std::hash::Hasher;
@@ -49,6 +50,7 @@ enum Type {
     Object(ObjectType),
     Mutable(MutableType),
     Option(OptionType),
+    Array(ArrayType),
 }
 
 impl Type {
@@ -57,6 +59,7 @@ impl Type {
             Self::Object(object_type) => object_type.serialize(output),
             Self::Mutable(mutable_type) => mutable_type.serialize(output),
             Self::Option(option_type) => option_type.serialize(output),
+            Self::Array(array_type) => array_type.serialize(output),
         }
     }
 }
@@ -212,6 +215,18 @@ impl OptionType {
     }
 }
 
+#[derive(Clone)]
+struct ArrayType {
+    array_type: TypeReference,
+}
+
+impl ArrayType {
+    fn serialize(&self, output: &mut BinaryData) {
+        output.write_i32(ARRAY_ENCODING_TAG);
+        output.write_i32(self.array_type.index);
+    }
+}
+
 struct TypeTable {
     types: Vec<Type>,
 }
@@ -311,6 +326,9 @@ unsafe fn test_sucessful_cases(heap: &mut TestMemory) {
     test_direct_recursive_type(heap);
     test_indirect_recursive_type(heap);
     test_option_types(heap);
+    test_flat_array_types(heap);
+    test_nested_array_types(heap);
+    test_recursive_array_types(heap);
 }
 
 unsafe fn test_empty_actor(heap: &mut TestMemory) {
@@ -568,12 +586,59 @@ unsafe fn test_option_types(heap: &mut TestMemory) {
     assert!(are_compatible(heap, types.clone(), types.clone()));
 }
 
+unsafe fn test_flat_array_types(heap: &mut TestMemory) {
+    let actor_type = Type::Object(ObjectType {
+        fields: vec![Field {
+            name: String::from("ArrayField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let array_type = Type::Array(ArrayType {
+        array_type: TypeReference::nat(),
+    });
+    let types = vec![actor_type, array_type];
+    assert!(are_compatible(heap, types.clone(), types.clone()));
+}
+
+unsafe fn test_nested_array_types(heap: &mut TestMemory) {
+    let actor_type = Type::Object(ObjectType {
+        fields: vec![Field {
+            name: String::from("ArrayField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let outer_array_type = Type::Array(ArrayType {
+        array_type: TypeReference { index: 2 },
+    });
+    let inner_array_type = Type::Array(ArrayType {
+        array_type: TypeReference::nat(),
+    });
+    let types = vec![actor_type, outer_array_type, inner_array_type];
+    assert!(are_compatible(heap, types.clone(), types.clone()));
+}
+
+unsafe fn test_recursive_array_types(heap: &mut TestMemory) {
+    let actor_type = Type::Object(ObjectType {
+        fields: vec![Field {
+            name: String::from("ArrayField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let recursive_array_type = Type::Array(ArrayType {
+        array_type: TypeReference { index: 1 },
+    });
+    let types = vec![actor_type, recursive_array_type];
+    assert!(are_compatible(heap, types.clone(), types.clone()));
+}
+
 unsafe fn test_failing_cases(heap: &mut TestMemory) {
     test_added_object_fields(heap);
     test_mutable_mismatch(heap);
     test_immutable_mismatch(heap);
     test_recursion_mismatch(heap);
     test_option_mismatch(heap);
+    test_array_mismatch(heap);
+    test_array_mutability_mismatch(heap);
 }
 
 unsafe fn test_recursion_mismatch(heap: &mut TestMemory) {
@@ -698,10 +763,58 @@ unsafe fn test_option_mismatch(heap: &mut TestMemory) {
     let new_actor = Type::Object(ObjectType {
         fields: vec![Field {
             name: String::from("OptionalField"),
-            field_type: TypeReference::null(),
+            field_type: TypeReference::float(),
         }],
     });
     let old_types = vec![old_actor, option_type];
     let new_types = vec![new_actor];
     assert!(!are_compatible(heap, old_types, new_types));
 }
+
+unsafe fn test_array_mismatch(heap: &mut TestMemory) {
+    let old_actor = Type::Object(ObjectType {
+        fields: vec![Field {
+            name: String::from("ArrayField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let array_type = Type::Array(ArrayType {
+        array_type: TypeReference::nat(),
+    });
+    let new_actor = Type::Object(ObjectType {
+        fields: vec![Field {
+            name: String::from("ArrayField"),
+            field_type: TypeReference::text(),
+        }],
+    });
+    let old_types = vec![old_actor, array_type];
+    let new_types = vec![new_actor];
+    assert!(!are_compatible(heap, old_types, new_types));
+}
+
+unsafe fn test_array_mutability_mismatch(heap: &mut TestMemory) {
+    let old_actor = Type::Object(ObjectType {
+        fields: vec![Field {
+            name: String::from("ArrayField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let immutable_array_type = Type::Array(ArrayType {
+        array_type: TypeReference::nat(),
+    });
+    let new_actor = Type::Object(ObjectType {
+        fields: vec![Field {
+            name: String::from("ArrayField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let mutable_array_type = Type::Array(ArrayType {
+        array_type: TypeReference { index: 2 },
+    });
+    let mutable_variable = Type::Mutable(MutableType {
+        variable_type: TypeReference::nat(),
+    });
+    let old_types = vec![old_actor, immutable_array_type];
+    let new_types = vec![new_actor, mutable_array_type, mutable_variable];
+    assert!(!are_compatible(heap, old_types, new_types));
+}
diff --git a/rts/motoko-rts/src/persistence/compatibility.rs b/rts/motoko-rts/src/persistence/compatibility.rs
index 4b091067199..4d972ea36d4 100644
--- a/rts/motoko-rts/src/persistence/compatibility.rs
+++ b/rts/motoko-rts/src/persistence/compatibility.rs
@@ -33,10 +33,11 @@
 //!
 //! ```
 //! <type_table> ::= length:i32 (<type>)^length
-//! <type> ::= <object> | <mutable> | <option>
+//! <type> ::= <object> | <mutable> | <option> | <array>
 //! <object> ::= 1l <field_list>
 //! <mutable> ::= 2l type_index:i32
 //! <option> ::= 3l type_index:i32
+//! <array> ::= 4l type_index:i32
 //! <field_list> ::= length:i32 (<field>)^length
 //! <field> ::= label_hash:i32 type_index:i32
 //! ```
@@ -71,13 +72,15 @@ use crate::{
 pub const OBJECT_ENCODING_TAG: i32 = 1;
 pub const MUTABLE_ENCODING_TAG: i32 = 2;
 pub const OPTION_ENCODING_TAG: i32 = 3;
+pub const ARRAY_ENCODING_TAG: i32 = 4;
 
 const ACTOR_TYPE_INDEX: i32 = 0;
 
 const OBJECT_ENCODING_HEADER: usize = 2; // object_tag field_list_length
 const FIELD_ENCODING_LENGTH: usize = 2; // label_hash type_index
-const MUTABLE_ENCODING_LENGTH: usize = 2; // object_tag type_index
-const OPTION_ENCODING_LENGTH: usize = 2; // object_tag type_index
+const MUTABLE_ENCODING_LENGTH: usize = 2; // mutable_tag type_index
+const OPTION_ENCODING_LENGTH: usize = 2; // option_tag type_index
+const ARRAY_ENCODING_LENGTH: usize = 2; // array_tag type_index
 
 struct EncodedData {
     words: *const i32,
@@ -148,6 +151,7 @@ enum Type {
     Object(ObjectType),
     Mutable(MutableType),
     Option(OptionType),
+    Array(ArrayType),
 }
 
 impl Type {
@@ -156,6 +160,7 @@ impl Type {
             Self::Object(object_type) => object_type.size(),
             Self::Mutable(mutable_type) => mutable_type.size(),
             Self::Option(option_type) => option_type.size(),
+            Self::Array(array_type) => array_type.size(),
         }
     }
 
@@ -165,6 +170,7 @@ impl Type {
             OBJECT_ENCODING_TAG => Self::Object(ObjectType::new(data)),
             MUTABLE_ENCODING_TAG => Self::Mutable(MutableType::new(data)),
             OPTION_ENCODING_TAG => Self::Option(OptionType::new(data)),
+            ARRAY_ENCODING_TAG => Self::Array(ArrayType::new(data)),
             _ => unimplemented!(),
         }
     }
@@ -249,6 +255,22 @@ impl OptionType {
     }
 }
 
+struct ArrayType {
+    type_index: i32,
+}
+
+impl ArrayType {
+    unsafe fn new(data: EncodedData) -> ArrayType {
+        assert_eq!(data.read(0), ARRAY_ENCODING_TAG);
+        let type_index = data.read(1);
+        ArrayType { type_index }
+    }
+
+    unsafe fn size(&self) -> usize {
+        ARRAY_ENCODING_LENGTH
+    }
+}
+
 /// Cache for remembering previous type compatibility checks.
 /// Necessary to avoid infinite loops on type recursion.
 /// Helpful to optimize repeated checks.
@@ -358,6 +380,10 @@ impl CompatibilityChecker {
         self.type_compatible(new_option.type_index, old_option.type_index)
     }
 
+    unsafe fn array_compatible(&mut self, new_array: &ArrayType, old_array: &ArrayType) -> bool {
+        self.type_compatible(new_array.type_index, old_array.type_index)
+    }
+
     unsafe fn type_compatible(&mut self, new_type_index: i32, old_type_index: i32) -> bool {
         if new_type_index < 0 || old_type_index < 0 {
             return new_type_index == old_type_index;
@@ -381,6 +407,10 @@ impl CompatibilityChecker {
                 self.option_compatible(new_option, old_option)
             }
             (Type::Option(_), _) => false,
+            (Type::Array(new_array), Type::Array(old_array)) => {
+                self.array_compatible(new_array, old_array)
+            }
+            (Type::Array(_), _) => false,
         }
     }
 
diff --git a/src/codegen/persistence.ml b/src/codegen/persistence.ml
index ee4fa55a02f..1a3d9e5c977 100644
--- a/src/codegen/persistence.ml
+++ b/src/codegen/persistence.ml
@@ -7,10 +7,11 @@
   // Primitive types are encoded by negative indices.
   // All numbers (type indices etc.) are encoded as little endian i32.
   <type_table> ::= length:i32 (<type>)^length
-  <type> ::= <object> | <mutable> | <option>
+  <type> ::= <object> | <mutable> | <option> | <array>
   <object> ::= 1l <field_list>
   <mutable> ::= 2l type_index:i32
   <option> ::= 3l type_index:i32
+  <array> ::= 4l type_index:i32
   <field_list> ::= length:i32 (<field>)^length
   <field> ::= label_hash:i32 type_index:i32
   
@@ -68,13 +69,24 @@ module TypeTable = struct
     let open Type in
     match typ with
     | Prim _ -> table
+    | Con _ -> assert false
     | _ -> List.append table [typ]
 end
 
+let normalize_type typ =
+  let open Type in
+  match typ with
+  | Con (constructor, _) ->
+    (match Mo_types.Cons.kind constructor with
+    | Abs _ -> assert false
+    | Def (_, type_definition) -> type_definition)
+  | _ -> typ
+
 let rec collect_type table typ =
+  let typ = normalize_type typ in
   if TypeTable.contains_type table typ then
     table
-  else  
+  else
     (let table = TypeTable.add_type table typ in
     let open Type in
     match typ with
@@ -82,14 +94,12 @@ let rec collect_type table typ =
     | Obj (Object, field_list) ->
       let field_types = List.map (fun field -> field.typ) field_list in
       collect_types table field_types
-    | Mut var_type ->
-      collect_type table var_type
-    | Opt opt_type ->
-      collect_type table opt_type
-    | Con (construction, type_list) -> 
-      (match Mo_types.Cons.kind construction with
-      | Abs _ -> assert false
-      | Def (_, type_definition) -> collect_type table type_definition)
+    | Mut variable_type ->
+      collect_type table variable_type
+    | Opt optional_type ->
+      collect_type table optional_type
+    | Array element_type ->
+      collect_type table element_type
     | _ ->
       Printf.printf "UNSUPPORTED PERSISTENT TYPE %s\n" (Type.string_of_typ typ);
       assert false)
@@ -128,6 +138,7 @@ let primitive_type_index primitive_type =
 
 let type_index table typ =
   let open Type in
+  let typ = normalize_type typ in
   match typ with
   | Prim primitive_type -> primitive_type_index primitive_type
   | _ -> Int32.of_int (TypeTable.index_of table typ)
@@ -141,15 +152,19 @@ let encode_field table field =
 let encode_complex_type table typ =
   let open Type in
   match typ with
+  | Prim _ -> assert false
   | Obj (Object, field_list) -> 
     encode_i32 1l ^ 
     encode_list (encode_field table) field_list
-  | Mut var_type ->
+  | Mut variable_type ->
     encode_i32 2l ^
-    encode_i32 (type_index table var_type)
-  | Opt opt_type ->
+    encode_i32 (type_index table variable_type)
+  | Opt optional_type ->
     encode_i32 3l ^
-    encode_i32 (type_index table opt_type)
+    encode_i32 (type_index table optional_type)
+  | Array element_type ->
+    encode_i32 4l ^
+    encode_i32 (type_index table element_type)
   | _ -> assert false
 
 let encode_type_table table =
diff --git a/test/run-drun/array-upgrades.drun b/test/run-drun/array-upgrades.drun
new file mode 100644
index 00000000000..acdc7558306
--- /dev/null
+++ b/test/run-drun/array-upgrades.drun
@@ -0,0 +1,19 @@
+# SKIP ic-ref-run
+install $ID array-upgrades/version0.mo ""
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID array-upgrades/version0.mo ""
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID array-upgrades/version1.mo ""
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID array-upgrades/version1.mo ""
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID array-upgrades/version2.mo ""
+upgrade $ID array-upgrades/version3.mo ""
+upgrade $ID array-upgrades/version4.mo ""
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID array-upgrades/version4.mo ""
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID array-upgrades/version0.mo ""
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID array-upgrades/version0.mo ""
+ingress $ID print "DIDL\x00\x00"
diff --git a/test/run-drun/array-upgrades/version0.mo b/test/run-drun/array-upgrades/version0.mo
new file mode 100644
index 00000000000..a6f4dee2e9d
--- /dev/null
+++ b/test/run-drun/array-upgrades/version0.mo
@@ -0,0 +1,16 @@
+import Prim "mo:prim";
+
+// Compatible upgrade
+actor {
+    type RecursiveArray = ?[RecursiveArray];
+
+    stable var simpleArray = [var 1.0, 2.0, 3.0, 4.0];
+    stable var nestedArray = [[1, 2, 3], [4, 5, 6]];
+    stable var recursiveArray = ?[null, ?[], ?[?[null, null], null]] : RecursiveArray;
+
+    public func print() : async () {
+        Prim.debugPrint(debug_show (simpleArray));
+        Prim.debugPrint(debug_show (nestedArray));
+        Prim.debugPrint(debug_show (recursiveArray));
+    };
+};
diff --git a/test/run-drun/array-upgrades/version1.mo b/test/run-drun/array-upgrades/version1.mo
new file mode 100644
index 00000000000..2798f73c73e
--- /dev/null
+++ b/test/run-drun/array-upgrades/version1.mo
@@ -0,0 +1,16 @@
+import Prim "mo:prim";
+
+// Compatible upgrade
+actor {
+    type RecursiveArray = ?[RecursiveArray];
+
+    stable var simpleArray: [var Float] = [var];
+    stable var nestedArray: [[Nat]] = [];
+    stable var recursiveArray = ?[] : RecursiveArray;
+
+    public func print() : async () {
+        Prim.debugPrint(debug_show (simpleArray));
+        Prim.debugPrint(debug_show (nestedArray));
+        Prim.debugPrint(debug_show (recursiveArray));
+    };
+};
diff --git a/test/run-drun/array-upgrades/version2.mo b/test/run-drun/array-upgrades/version2.mo
new file mode 100644
index 00000000000..28f951e4100
--- /dev/null
+++ b/test/run-drun/array-upgrades/version2.mo
@@ -0,0 +1,16 @@
+import Prim "mo:prim";
+
+// Incompatible upgrade
+actor {
+    type RecursiveArray = ?[RecursiveArray];
+
+    stable var simpleArray: [Float] = [];
+    stable var nestedArray: [Nat] = [];
+    stable var recursiveArray = ?[] : RecursiveArray;
+
+    public func print() : async () {
+        Prim.debugPrint(debug_show (simpleArray));
+        Prim.debugPrint(debug_show (nestedArray));
+        Prim.debugPrint(debug_show (recursiveArray));
+    };
+};
diff --git a/test/run-drun/array-upgrades/version3.mo b/test/run-drun/array-upgrades/version3.mo
new file mode 100644
index 00000000000..2c20e0e875f
--- /dev/null
+++ b/test/run-drun/array-upgrades/version3.mo
@@ -0,0 +1,16 @@
+import Prim "mo:prim";
+
+// Incompatible upgrade
+actor {
+    type RecursiveArray = ?[RecursiveArray];
+
+    stable var simpleArray: [var Float] = [var];
+    stable var nestedArray: [Nat] = [];
+    stable var recursiveArray = ?[] : RecursiveArray;
+
+    public func print() : async () {
+        Prim.debugPrint(debug_show (simpleArray));
+        Prim.debugPrint(debug_show (nestedArray));
+        Prim.debugPrint(debug_show (recursiveArray));
+    };
+};
diff --git a/test/run-drun/array-upgrades/version4.mo b/test/run-drun/array-upgrades/version4.mo
new file mode 100644
index 00000000000..3bd43d15b77
--- /dev/null
+++ b/test/run-drun/array-upgrades/version4.mo
@@ -0,0 +1,15 @@
+import Prim "mo:prim";
+
+// Compatible upgrade
+actor {
+    type ArrayStructure = ?[AliasName];
+    type AliasName = ArrayStructure;
+
+    stable var simpleArray: [var Float] = [var];
+    stable var recursiveArray = ?[] : ArrayStructure;
+
+    public func print() : async () {
+        Prim.debugPrint(debug_show (simpleArray));
+        Prim.debugPrint(debug_show (recursiveArray));
+    };
+};
diff --git a/test/run-drun/ok/array-upgrades.drun.ok b/test/run-drun/ok/array-upgrades.drun.ok
new file mode 100644
index 00000000000..ed6459af71f
--- /dev/null
+++ b/test/run-drun/ok/array-upgrades.drun.ok
@@ -0,0 +1,45 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+debug.print: [var 1.000000, 2.000000, 3.000000, 4.000000]
+debug.print: [[1, 2, 3], [4, 5, 6]]
+debug.print: ?[null, ?[], ?[?[null, null], null]]
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: [var 1.000000, 2.000000, 3.000000, 4.000000]
+debug.print: [[1, 2, 3], [4, 5, 6]]
+debug.print: ?[null, ?[], ?[?[null, null], null]]
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: [var 1.000000, 2.000000, 3.000000, 4.000000]
+debug.print: [[1, 2, 3], [4, 5, 6]]
+debug.print: ?[null, ?[], ?[?[null, null], null]]
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: [var 1.000000, 2.000000, 3.000000, 4.000000]
+debug.print: [[1, 2, 3], [4, 5, 6]]
+debug.print: ?[null, ?[], ?[?[null, null], null]]
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Memory-incompatible program upgrade
+debug.print: panic occurred in file 'src/persistence.rs' at line 193
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
+debug.print: Memory-incompatible program upgrade
+debug.print: panic occurred in file 'src/persistence.rs' at line 193
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
+ingress Completed: Reply: 0x4449444c0000
+debug.print: [var 1.000000, 2.000000, 3.000000, 4.000000]
+debug.print: ?[null, ?[], ?[?[null, null], null]]
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: [var 1.000000, 2.000000, 3.000000, 4.000000]
+debug.print: ?[null, ?[], ?[?[null, null], null]]
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: [var 1.000000, 2.000000, 3.000000, 4.000000]
+debug.print: [[1, 2, 3], [4, 5, 6]]
+debug.print: ?[null, ?[], ?[?[null, null], null]]
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: [var 1.000000, 2.000000, 3.000000, 4.000000]
+debug.print: [[1, 2, 3], [4, 5, 6]]
+debug.print: ?[null, ?[], ?[?[null, null], null]]
+ingress Completed: Reply: 0x4449444c0000

From 6c17834ffb93431aa6d8997c6abb9f3e74eb9a80 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 31 Aug 2023 15:01:52 +0200
Subject: [PATCH 078/260] Code refactoring

---
 .../src/persistence/compatibility.rs          | 158 +++++++-----------
 1 file changed, 56 insertions(+), 102 deletions(-)

diff --git a/rts/motoko-rts/src/persistence/compatibility.rs b/rts/motoko-rts/src/persistence/compatibility.rs
index 4d972ea36d4..a6de715696d 100644
--- a/rts/motoko-rts/src/persistence/compatibility.rs
+++ b/rts/motoko-rts/src/persistence/compatibility.rs
@@ -76,11 +76,10 @@ pub const ARRAY_ENCODING_TAG: i32 = 4;
 
 const ACTOR_TYPE_INDEX: i32 = 0;
 
-const OBJECT_ENCODING_HEADER: usize = 2; // object_tag field_list_length
+const TYPE_TAG_LENGTH: usize = 1;
+const FIELD_LIST_HEADER: usize = 1; // field_list_length
+const TYPE_INDEX_LENGTH: usize = 1;
 const FIELD_ENCODING_LENGTH: usize = 2; // label_hash type_index
-const MUTABLE_ENCODING_LENGTH: usize = 2; // mutable_tag type_index
-const OPTION_ENCODING_LENGTH: usize = 2; // option_tag type_index
-const ARRAY_ENCODING_LENGTH: usize = 2; // array_tag type_index
 
 struct EncodedData {
     words: *const i32,
@@ -139,66 +138,66 @@ impl TypeTable {
         Type::get_type(type_view)
     }
 
-    unsafe fn get_actor(&self) -> ObjectType {
+    unsafe fn get_actor_fields(&self) -> FieldList {
         match self.get_type(ACTOR_TYPE_INDEX) {
-            Type::Object(object_type) => object_type,
+            Type::Object(field_list) => field_list,
             _ => panic!("Invalid stable type encoding"),
         }
     }
 }
 
 enum Type {
-    Object(ObjectType),
-    Mutable(MutableType),
-    Option(OptionType),
-    Array(ArrayType),
+    Object(FieldList),
+    Mutable(TypeIndex),
+    Option(TypeIndex),
+    Array(TypeIndex),
 }
 
 impl Type {
     unsafe fn size(data: EncodedData) -> usize {
-        match Self::get_type(data) {
-            Self::Object(object_type) => object_type.size(),
-            Self::Mutable(mutable_type) => mutable_type.size(),
-            Self::Option(option_type) => option_type.size(),
-            Self::Array(array_type) => array_type.size(),
-        }
+        TYPE_TAG_LENGTH
+            + match Self::get_type(data) {
+                Self::Object(field_list) => field_list.size(),
+                Self::Mutable(type_index) => type_index.size(),
+                Self::Option(type_index) => type_index.size(),
+                Self::Array(type_index) => type_index.size(),
+            }
     }
 
     unsafe fn get_type(data: EncodedData) -> Type {
         let tag = data.read(0);
+        let data = data.sub_view(TYPE_TAG_LENGTH);
         match tag {
-            OBJECT_ENCODING_TAG => Self::Object(ObjectType::new(data)),
-            MUTABLE_ENCODING_TAG => Self::Mutable(MutableType::new(data)),
-            OPTION_ENCODING_TAG => Self::Option(OptionType::new(data)),
-            ARRAY_ENCODING_TAG => Self::Array(ArrayType::new(data)),
+            OBJECT_ENCODING_TAG => Self::Object(FieldList::new(data)),
+            MUTABLE_ENCODING_TAG => Self::Mutable(TypeIndex::new(data)),
+            OPTION_ENCODING_TAG => Self::Option(TypeIndex::new(data)),
+            ARRAY_ENCODING_TAG => Self::Array(TypeIndex::new(data)),
             _ => unimplemented!(),
         }
     }
 }
 
-struct ObjectType {
+struct FieldList {
     data: EncodedData,
 }
 
-impl ObjectType {
-    unsafe fn new(data: EncodedData) -> ObjectType {
-        assert_eq!(data.read(0), OBJECT_ENCODING_TAG);
-        ObjectType { data }
+impl FieldList {
+    unsafe fn new(data: EncodedData) -> FieldList {
+        FieldList { data }
     }
 
     unsafe fn size(&self) -> usize {
-        OBJECT_ENCODING_HEADER + self.count_fields() * FIELD_ENCODING_LENGTH
+        FIELD_LIST_HEADER + self.count_fields() * FIELD_ENCODING_LENGTH
     }
 
     unsafe fn count_fields(&self) -> usize {
-        assert_eq!(self.data.read(0), OBJECT_ENCODING_TAG);
-        let count = self.data.read(1);
+        let count = self.data.read(0);
         assert!(count >= 0);
         count as usize
     }
 
     unsafe fn get_field(&self, field_index: usize) -> Field {
-        let field_offset = OBJECT_ENCODING_HEADER + field_index * FIELD_ENCODING_LENGTH;
+        let field_offset = FIELD_LIST_HEADER + field_index * FIELD_ENCODING_LENGTH;
         let label_hash = self.data.read(field_offset);
         let type_index = self.data.read(field_offset + 1);
         Field {
@@ -223,51 +222,18 @@ struct Field {
     type_index: i32,
 }
 
-struct MutableType {
-    type_index: i32,
-}
-
-impl MutableType {
-    unsafe fn new(data: EncodedData) -> MutableType {
-        assert_eq!(data.read(0), MUTABLE_ENCODING_TAG);
-        let type_index = data.read(1);
-        MutableType { type_index }
-    }
-
-    unsafe fn size(&self) -> usize {
-        MUTABLE_ENCODING_LENGTH
-    }
-}
-
-struct OptionType {
+struct TypeIndex {
     type_index: i32,
 }
 
-impl OptionType {
-    unsafe fn new(data: EncodedData) -> OptionType {
-        assert_eq!(data.read(0), OPTION_ENCODING_TAG);
-        let type_index = data.read(1);
-        OptionType { type_index }
+impl TypeIndex {
+    unsafe fn new(data: EncodedData) -> TypeIndex {
+        let type_index = data.read(0);
+        TypeIndex { type_index }
     }
 
     unsafe fn size(&self) -> usize {
-        OPTION_ENCODING_LENGTH
-    }
-}
-
-struct ArrayType {
-    type_index: i32,
-}
-
-impl ArrayType {
-    unsafe fn new(data: EncodedData) -> ArrayType {
-        assert_eq!(data.read(0), ARRAY_ENCODING_TAG);
-        let type_index = data.read(1);
-        ArrayType { type_index }
-    }
-
-    unsafe fn size(&self) -> usize {
-        ARRAY_ENCODING_LENGTH
+        TYPE_INDEX_LENGTH
     }
 }
 
@@ -343,14 +309,14 @@ impl CompatibilityChecker {
         }
     }
 
-    unsafe fn object_compatible(
+    unsafe fn compatible_fields(
         &mut self,
-        new_object: &ObjectType,
-        old_object: &ObjectType,
+        new_field_list: &FieldList,
+        old_field_list: &FieldList,
     ) -> bool {
-        for field_index in 0..new_object.count_fields() {
-            let new_field = new_object.get_field(field_index);
-            match old_object.find_field(new_field.label_hash) {
+        for field_index in 0..new_field_list.count_fields() {
+            let new_field = new_field_list.get_field(field_index);
+            match old_field_list.find_field(new_field.label_hash) {
                 None => {
                     return false;
                 }
@@ -364,24 +330,12 @@ impl CompatibilityChecker {
         true
     }
 
-    unsafe fn mutable_compatible(
+    unsafe fn compatible_type_indices(
         &mut self,
-        new_mutable: &MutableType,
-        old_mutable: &MutableType,
+        new_type: &TypeIndex,
+        old_type: &TypeIndex,
     ) -> bool {
-        self.type_compatible(new_mutable.type_index, old_mutable.type_index)
-    }
-
-    unsafe fn option_compatible(
-        &mut self,
-        new_option: &OptionType,
-        old_option: &OptionType,
-    ) -> bool {
-        self.type_compatible(new_option.type_index, old_option.type_index)
-    }
-
-    unsafe fn array_compatible(&mut self, new_array: &ArrayType, old_array: &ArrayType) -> bool {
-        self.type_compatible(new_array.type_index, old_array.type_index)
+        self.type_compatible(new_type.type_index, old_type.type_index)
     }
 
     unsafe fn type_compatible(&mut self, new_type_index: i32, old_type_index: i32) -> bool {
@@ -395,31 +349,31 @@ impl CompatibilityChecker {
         let new_type = self.new_type_table.get_type(new_type_index);
         let old_type = self.old_type_table.get_type(old_type_index);
         match (&new_type, &old_type) {
-            (Type::Object(new_object), Type::Object(old_object)) => {
-                self.object_compatible(new_object, old_object)
+            (Type::Object(new_fields), Type::Object(old_fields)) => {
+                self.compatible_fields(new_fields, old_fields)
             }
             (Type::Object(_), _) => false,
-            (Type::Mutable(new_mutable), Type::Mutable(old_mutable)) => {
-                self.mutable_compatible(new_mutable, old_mutable)
+            (Type::Mutable(new_variable), Type::Mutable(old_variable)) => {
+                self.compatible_type_indices(new_variable, old_variable)
             }
             (Type::Mutable(_), _) => false,
             (Type::Option(new_option), Type::Option(old_option)) => {
-                self.option_compatible(new_option, old_option)
+                self.compatible_type_indices(new_option, old_option)
             }
             (Type::Option(_), _) => false,
-            (Type::Array(new_array), Type::Array(old_array)) => {
-                self.array_compatible(new_array, old_array)
+            (Type::Array(new_element), Type::Array(old_element)) => {
+                self.compatible_type_indices(new_element, old_element)
             }
             (Type::Array(_), _) => false,
         }
     }
 
     unsafe fn compatible_actor_fields(&mut self) -> bool {
-        let new_actor = self.new_type_table.get_actor();
-        let old_actor = self.old_type_table.get_actor();
-        for new_field_index in 0..new_actor.count_fields() {
-            let new_field = new_actor.get_field(new_field_index);
-            match old_actor.find_field(new_field.label_hash) {
+        let new_field_list = self.new_type_table.get_actor_fields();
+        let old_field_list = self.old_type_table.get_actor_fields();
+        for new_field_index in 0..new_field_list.count_fields() {
+            let new_field = new_field_list.get_field(new_field_index);
+            match old_field_list.find_field(new_field.label_hash) {
                 Some(old_field) => {
                     if !self.type_compatible(new_field.type_index, old_field.type_index) {
                         return false;

From 7076c8aef21cf3c2f3a8f9c6d751f5dc687f75ba Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 31 Aug 2023 15:22:19 +0200
Subject: [PATCH 079/260] Code refactoring

---
 .../src/persistence/compatibility.rs          | 203 +++++++-----------
 1 file changed, 76 insertions(+), 127 deletions(-)

diff --git a/rts/motoko-rts-tests/src/persistence/compatibility.rs b/rts/motoko-rts-tests/src/persistence/compatibility.rs
index 03dc1d6e7c6..3fb82c4a8be 100644
--- a/rts/motoko-rts-tests/src/persistence/compatibility.rs
+++ b/rts/motoko-rts-tests/src/persistence/compatibility.rs
@@ -47,19 +47,31 @@ impl BinaryData {
 
 #[derive(Clone)]
 enum Type {
-    Object(ObjectType),
-    Mutable(MutableType),
-    Option(OptionType),
-    Array(ArrayType),
+    Object(FieldList),
+    Mutable(TypeReference),
+    Option(TypeReference),
+    Array(TypeReference),
 }
 
 impl Type {
     fn serialize(&self, output: &mut BinaryData) {
         match &self {
-            Self::Object(object_type) => object_type.serialize(output),
-            Self::Mutable(mutable_type) => mutable_type.serialize(output),
-            Self::Option(option_type) => option_type.serialize(output),
-            Self::Array(array_type) => array_type.serialize(output),
+            Self::Object(field_list) => {
+                output.write_i32(OBJECT_ENCODING_TAG);
+                field_list.serialize(output);
+            }
+            Self::Mutable(type_reference) => {
+                output.write_i32(MUTABLE_ENCODING_TAG);
+                output.write_i32(type_reference.index);
+            }
+            Self::Option(type_reference) => {
+                output.write_i32(OPTION_ENCODING_TAG);
+                output.write_i32(type_reference.index);
+            }
+            Self::Array(type_reference) => {
+                output.write_i32(ARRAY_ENCODING_TAG);
+                output.write_i32(type_reference.index);
+            }
         }
     }
 }
@@ -177,13 +189,12 @@ impl Field {
 }
 
 #[derive(Clone)]
-struct ObjectType {
+struct FieldList {
     fields: Vec<Field>,
 }
 
-impl ObjectType {
+impl FieldList {
     fn serialize(&self, output: &mut BinaryData) {
-        output.write_i32(OBJECT_ENCODING_TAG);
         output.write_i32(self.fields.len() as i32);
         for field in &self.fields {
             field.serialize(output);
@@ -191,42 +202,6 @@ impl ObjectType {
     }
 }
 
-#[derive(Clone)]
-struct MutableType {
-    variable_type: TypeReference,
-}
-
-impl MutableType {
-    fn serialize(&self, output: &mut BinaryData) {
-        output.write_i32(MUTABLE_ENCODING_TAG);
-        output.write_i32(self.variable_type.index);
-    }
-}
-
-#[derive(Clone)]
-struct OptionType {
-    option_type: TypeReference,
-}
-
-impl OptionType {
-    fn serialize(&self, output: &mut BinaryData) {
-        output.write_i32(OPTION_ENCODING_TAG);
-        output.write_i32(self.option_type.index);
-    }
-}
-
-#[derive(Clone)]
-struct ArrayType {
-    array_type: TypeReference,
-}
-
-impl ArrayType {
-    fn serialize(&self, output: &mut BinaryData) {
-        output.write_i32(ARRAY_ENCODING_TAG);
-        output.write_i32(self.array_type.index);
-    }
-}
-
 struct TypeTable {
     types: Vec<Type>,
 }
@@ -275,13 +250,13 @@ pub unsafe fn test() {
 
 unsafe fn test_primitive_types(heap: &mut TestMemory) {
     let mut is_compatible = |first: &TypeReference, second: &TypeReference| {
-        let old_types = Type::Object(ObjectType {
+        let old_types = Type::Object(FieldList {
             fields: vec![Field {
                 name: String::from("Field"),
                 field_type: first.clone(),
             }],
         });
-        let new_types = Type::Object(ObjectType {
+        let new_types = Type::Object(FieldList {
             fields: vec![Field {
                 name: String::from("Field"),
                 field_type: second.clone(),
@@ -332,8 +307,8 @@ unsafe fn test_sucessful_cases(heap: &mut TestMemory) {
 }
 
 unsafe fn test_empty_actor(heap: &mut TestMemory) {
-    let old_type = Type::Object(ObjectType { fields: vec![] });
-    let new_type = Type::Object(ObjectType { fields: vec![] });
+    let old_type = Type::Object(FieldList { fields: vec![] });
+    let new_type = Type::Object(FieldList { fields: vec![] });
     assert!(is_compatible(heap, old_type, new_type));
 }
 
@@ -409,7 +384,7 @@ unsafe fn test_multiple_primitive_fields(heap: &mut TestMemory) {
         },
     ];
 
-    let types = Type::Object(ObjectType { fields });
+    let types = Type::Object(FieldList { fields });
 
     assert!(is_compatible(heap, types.clone(), types));
 }
@@ -424,10 +399,10 @@ unsafe fn test_reordered_actor_fields(heap: &mut TestMemory) {
         field_type: TypeReference::nat(),
     };
 
-    let old_type = Type::Object(ObjectType {
+    let old_type = Type::Object(FieldList {
         fields: vec![field1.clone(), field2.clone()],
     });
-    let new_type = Type::Object(ObjectType {
+    let new_type = Type::Object(FieldList {
         fields: vec![field2.clone(), field1.clone()],
     });
 
@@ -448,10 +423,10 @@ unsafe fn test_removed_actor_fields(heap: &mut TestMemory) {
         field_type: TypeReference::nat32(),
     };
 
-    let old_type = Type::Object(ObjectType {
+    let old_type = Type::Object(FieldList {
         fields: vec![field1.clone(), field2.clone(), field3.clone()],
     });
-    let new_type = Type::Object(ObjectType {
+    let new_type = Type::Object(FieldList {
         fields: vec![field2.clone()],
     });
 
@@ -472,10 +447,10 @@ unsafe fn test_added_actor_fields(heap: &mut TestMemory) {
         field_type: TypeReference::text(),
     };
 
-    let old_type = Type::Object(ObjectType {
+    let old_type = Type::Object(FieldList {
         fields: vec![field2.clone()],
     });
-    let new_type = Type::Object(ObjectType {
+    let new_type = Type::Object(FieldList {
         fields: vec![field1.clone(), field2.clone(), field3.clone()],
     });
 
@@ -483,22 +458,20 @@ unsafe fn test_added_actor_fields(heap: &mut TestMemory) {
 }
 
 unsafe fn test_mutable_fields(heap: &mut TestMemory) {
-    let actor_type = Type::Object(ObjectType {
+    let actor_type = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("ActorField"),
             field_type: TypeReference { index: 1 },
         }],
     });
-    let mutable_type = Type::Mutable(MutableType {
-        variable_type: TypeReference::nat(),
-    });
+    let mutable_type = Type::Mutable(TypeReference::nat());
     let old_types = vec![actor_type.clone(), mutable_type.clone()];
     let new_types = vec![actor_type.clone(), mutable_type.clone()];
     assert!(are_compatible(heap, old_types, new_types));
 }
 
 unsafe fn test_removed_object_fields(heap: &mut TestMemory) {
-    let actor_type = Type::Object(ObjectType {
+    let actor_type = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("ActorField"),
             field_type: TypeReference { index: 1 },
@@ -518,10 +491,10 @@ unsafe fn test_removed_object_fields(heap: &mut TestMemory) {
         field_type: TypeReference::int32(),
     };
 
-    let old_type = Type::Object(ObjectType {
+    let old_type = Type::Object(FieldList {
         fields: vec![field1.clone(), field2.clone(), field3.clone()],
     });
-    let new_type = Type::Object(ObjectType {
+    let new_type = Type::Object(FieldList {
         fields: vec![field2.clone()],
     });
 
@@ -535,14 +508,14 @@ unsafe fn test_direct_recursive_type(heap: &mut TestMemory) {
         name: String::from("ActorField"),
         field_type: TypeReference { index: 1 },
     };
-    let actor_type = Type::Object(ObjectType {
+    let actor_type = Type::Object(FieldList {
         fields: vec![actor_field],
     });
     let recursive_field = Field {
         name: String::from("RecursiveField"),
         field_type: TypeReference { index: 1 },
     };
-    let recursive_type = Type::Object(ObjectType {
+    let recursive_type = Type::Object(FieldList {
         fields: vec![recursive_field],
     });
     let types = vec![actor_type, recursive_type];
@@ -550,19 +523,19 @@ unsafe fn test_direct_recursive_type(heap: &mut TestMemory) {
 }
 
 unsafe fn test_indirect_recursive_type(heap: &mut TestMemory) {
-    let actor_type = Type::Object(ObjectType {
+    let actor_type = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("ActorField"),
             field_type: TypeReference { index: 1 },
         }],
     });
-    let first_type = Type::Object(ObjectType {
+    let first_type = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("Field1"),
             field_type: TypeReference { index: 2 },
         }],
     });
-    let second_type = Type::Object(ObjectType {
+    let second_type = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("Field2"),
             field_type: TypeReference { index: 1 },
@@ -573,60 +546,50 @@ unsafe fn test_indirect_recursive_type(heap: &mut TestMemory) {
 }
 
 unsafe fn test_option_types(heap: &mut TestMemory) {
-    let actor_type = Type::Object(ObjectType {
+    let actor_type = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("OptionalField"),
             field_type: TypeReference { index: 1 },
         }],
     });
-    let option_type = Type::Option(OptionType {
-        option_type: TypeReference::blob(),
-    });
+    let option_type = Type::Option(TypeReference::blob());
     let types = vec![actor_type, option_type];
     assert!(are_compatible(heap, types.clone(), types.clone()));
 }
 
 unsafe fn test_flat_array_types(heap: &mut TestMemory) {
-    let actor_type = Type::Object(ObjectType {
+    let actor_type = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("ArrayField"),
             field_type: TypeReference { index: 1 },
         }],
     });
-    let array_type = Type::Array(ArrayType {
-        array_type: TypeReference::nat(),
-    });
+    let array_type = Type::Array(TypeReference::nat());
     let types = vec![actor_type, array_type];
     assert!(are_compatible(heap, types.clone(), types.clone()));
 }
 
 unsafe fn test_nested_array_types(heap: &mut TestMemory) {
-    let actor_type = Type::Object(ObjectType {
+    let actor_type = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("ArrayField"),
             field_type: TypeReference { index: 1 },
         }],
     });
-    let outer_array_type = Type::Array(ArrayType {
-        array_type: TypeReference { index: 2 },
-    });
-    let inner_array_type = Type::Array(ArrayType {
-        array_type: TypeReference::nat(),
-    });
+    let outer_array_type = Type::Array(TypeReference { index: 2 });
+    let inner_array_type = Type::Array(TypeReference::nat());
     let types = vec![actor_type, outer_array_type, inner_array_type];
     assert!(are_compatible(heap, types.clone(), types.clone()));
 }
 
 unsafe fn test_recursive_array_types(heap: &mut TestMemory) {
-    let actor_type = Type::Object(ObjectType {
+    let actor_type = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("ArrayField"),
             field_type: TypeReference { index: 1 },
         }],
     });
-    let recursive_array_type = Type::Array(ArrayType {
-        array_type: TypeReference { index: 1 },
-    });
+    let recursive_array_type = Type::Array(TypeReference { index: 1 });
     let types = vec![actor_type, recursive_array_type];
     assert!(are_compatible(heap, types.clone(), types.clone()));
 }
@@ -646,28 +609,28 @@ unsafe fn test_recursion_mismatch(heap: &mut TestMemory) {
         name: String::from("ActorField"),
         field_type: TypeReference { index: 1 },
     };
-    let old_actor = Type::Object(ObjectType {
+    let old_actor = Type::Object(FieldList {
         fields: vec![old_actor_field],
     });
     let recursive_field = Field {
         name: String::from("Field"),
         field_type: TypeReference { index: 1 },
     };
-    let recursive_type = Type::Object(ObjectType {
+    let recursive_type = Type::Object(FieldList {
         fields: vec![recursive_field],
     });
     let new_actor_field = Field {
         name: String::from("ActorField"),
         field_type: TypeReference { index: 1 },
     };
-    let new_actor = Type::Object(ObjectType {
+    let new_actor = Type::Object(FieldList {
         fields: vec![new_actor_field],
     });
     let non_recursive_field = Field {
         name: String::from("Field"),
         field_type: TypeReference::principal(),
     };
-    let non_recursive_type = Type::Object(ObjectType {
+    let non_recursive_type = Type::Object(FieldList {
         fields: vec![non_recursive_field],
     });
     let old_types = vec![old_actor, recursive_type];
@@ -676,7 +639,7 @@ unsafe fn test_recursion_mismatch(heap: &mut TestMemory) {
 }
 
 unsafe fn test_added_object_fields(heap: &mut TestMemory) {
-    let actor_type = Type::Object(ObjectType {
+    let actor_type = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("ActorField"),
             field_type: TypeReference { index: 1 },
@@ -696,10 +659,10 @@ unsafe fn test_added_object_fields(heap: &mut TestMemory) {
         field_type: TypeReference::int64(),
     };
 
-    let old_type = Type::Object(ObjectType {
+    let old_type = Type::Object(FieldList {
         fields: vec![field2.clone()],
     });
-    let new_type = Type::Object(ObjectType {
+    let new_type = Type::Object(FieldList {
         fields: vec![field1.clone(), field2.clone(), field3.clone()],
     });
 
@@ -709,16 +672,14 @@ unsafe fn test_added_object_fields(heap: &mut TestMemory) {
 }
 
 unsafe fn test_mutable_mismatch(heap: &mut TestMemory) {
-    let old_actor = Type::Object(ObjectType {
+    let old_actor = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("ActorField"),
             field_type: TypeReference { index: 1 },
         }],
     });
-    let mutable_type = Type::Mutable(MutableType {
-        variable_type: TypeReference::nat(),
-    });
-    let new_actor = Type::Object(ObjectType {
+    let mutable_type = Type::Mutable(TypeReference::nat());
+    let new_actor = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("ActorField"),
             field_type: TypeReference::nat(),
@@ -730,37 +691,33 @@ unsafe fn test_mutable_mismatch(heap: &mut TestMemory) {
 }
 
 unsafe fn test_immutable_mismatch(heap: &mut TestMemory) {
-    let old_actor = Type::Object(ObjectType {
+    let old_actor = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("ActorField"),
             field_type: TypeReference::bool(),
         }],
     });
-    let new_actor = Type::Object(ObjectType {
+    let new_actor = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("ActorField"),
             field_type: TypeReference { index: 1 },
         }],
     });
-    let mutable_type = Type::Mutable(MutableType {
-        variable_type: TypeReference::nat(),
-    });
+    let mutable_type = Type::Mutable(TypeReference::nat());
     let old_types = vec![old_actor];
     let new_types = vec![new_actor, mutable_type];
     assert!(!are_compatible(heap, old_types, new_types));
 }
 
 unsafe fn test_option_mismatch(heap: &mut TestMemory) {
-    let old_actor = Type::Object(ObjectType {
+    let old_actor = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("OptionalField"),
             field_type: TypeReference { index: 1 },
         }],
     });
-    let option_type = Type::Option(OptionType {
-        option_type: TypeReference::nat(),
-    });
-    let new_actor = Type::Object(ObjectType {
+    let option_type = Type::Option(TypeReference::nat());
+    let new_actor = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("OptionalField"),
             field_type: TypeReference::float(),
@@ -772,16 +729,14 @@ unsafe fn test_option_mismatch(heap: &mut TestMemory) {
 }
 
 unsafe fn test_array_mismatch(heap: &mut TestMemory) {
-    let old_actor = Type::Object(ObjectType {
+    let old_actor = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("ArrayField"),
             field_type: TypeReference { index: 1 },
         }],
     });
-    let array_type = Type::Array(ArrayType {
-        array_type: TypeReference::nat(),
-    });
-    let new_actor = Type::Object(ObjectType {
+    let array_type = Type::Array(TypeReference::nat());
+    let new_actor = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("ArrayField"),
             field_type: TypeReference::text(),
@@ -793,27 +748,21 @@ unsafe fn test_array_mismatch(heap: &mut TestMemory) {
 }
 
 unsafe fn test_array_mutability_mismatch(heap: &mut TestMemory) {
-    let old_actor = Type::Object(ObjectType {
+    let old_actor = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("ArrayField"),
             field_type: TypeReference { index: 1 },
         }],
     });
-    let immutable_array_type = Type::Array(ArrayType {
-        array_type: TypeReference::nat(),
-    });
-    let new_actor = Type::Object(ObjectType {
+    let immutable_array_type = Type::Array(TypeReference::nat());
+    let new_actor = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("ArrayField"),
             field_type: TypeReference { index: 1 },
         }],
     });
-    let mutable_array_type = Type::Array(ArrayType {
-        array_type: TypeReference { index: 2 },
-    });
-    let mutable_variable = Type::Mutable(MutableType {
-        variable_type: TypeReference::nat(),
-    });
+    let mutable_array_type = Type::Array(TypeReference { index: 2 });
+    let mutable_variable = Type::Mutable(TypeReference::nat());
     let old_types = vec![old_actor, immutable_array_type];
     let new_types = vec![new_actor, mutable_array_type, mutable_variable];
     assert!(!are_compatible(heap, old_types, new_types));

From dd001bde48c22f5367375669bfe2d769441cf89f Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 31 Aug 2023 16:38:02 +0200
Subject: [PATCH 080/260] Check tuple type compatibility

---
 .../src/persistence/compatibility.rs          | 114 +++++++++++++++++-
 .../src/persistence/compatibility.rs          |  58 ++++++++-
 src/codegen/persistence.ml                    |  11 +-
 test/run-drun/ok/tuple-upgrades.drun.ok       |  45 +++++++
 test/run-drun/tuple-upgrades.drun             |  17 +++
 test/run-drun/tuple-upgrades/version0.mo      |  15 +++
 test/run-drun/tuple-upgrades/version1.mo      |  18 +++
 test/run-drun/tuple-upgrades/version2.mo      |  10 ++
 test/run-drun/tuple-upgrades/version3.mo      |  10 ++
 test/run-drun/tuple-upgrades/version4.mo      |  10 ++
 test/run-drun/tuple-upgrades/version5.mo      |  16 +++
 11 files changed, 319 insertions(+), 5 deletions(-)
 create mode 100644 test/run-drun/ok/tuple-upgrades.drun.ok
 create mode 100644 test/run-drun/tuple-upgrades.drun
 create mode 100644 test/run-drun/tuple-upgrades/version0.mo
 create mode 100644 test/run-drun/tuple-upgrades/version1.mo
 create mode 100644 test/run-drun/tuple-upgrades/version2.mo
 create mode 100644 test/run-drun/tuple-upgrades/version3.mo
 create mode 100644 test/run-drun/tuple-upgrades/version4.mo
 create mode 100644 test/run-drun/tuple-upgrades/version5.mo

diff --git a/rts/motoko-rts-tests/src/persistence/compatibility.rs b/rts/motoko-rts-tests/src/persistence/compatibility.rs
index 3fb82c4a8be..08e59304233 100644
--- a/rts/motoko-rts-tests/src/persistence/compatibility.rs
+++ b/rts/motoko-rts-tests/src/persistence/compatibility.rs
@@ -1,7 +1,7 @@
 use motoko_rts::memory::{alloc_blob, Memory};
 use motoko_rts::persistence::compatibility::{
     memory_compatible, ARRAY_ENCODING_TAG, MUTABLE_ENCODING_TAG, OBJECT_ENCODING_TAG,
-    OPTION_ENCODING_TAG,
+    OPTION_ENCODING_TAG, TUPLE_ENCODING_TAG,
 };
 use motoko_rts::types::{Bytes, Value};
 use std::hash::Hasher;
@@ -51,6 +51,7 @@ enum Type {
     Mutable(TypeReference),
     Option(TypeReference),
     Array(TypeReference),
+    Tuple(TypeList),
 }
 
 impl Type {
@@ -72,6 +73,10 @@ impl Type {
                 output.write_i32(ARRAY_ENCODING_TAG);
                 output.write_i32(type_reference.index);
             }
+            Self::Tuple(type_list) => {
+                output.write_i32(TUPLE_ENCODING_TAG);
+                type_list.serialize(output);
+            }
         }
     }
 }
@@ -202,6 +207,20 @@ impl FieldList {
     }
 }
 
+#[derive(Clone)]
+struct TypeList {
+    items: Vec<TypeReference>,
+}
+
+impl TypeList {
+    fn serialize(&self, output: &mut BinaryData) {
+        output.write_i32(self.items.len() as i32);
+        for item in &self.items {
+            output.write_i32(item.index);
+        }
+    }
+}
+
 struct TypeTable {
     types: Vec<Type>,
 }
@@ -304,6 +323,10 @@ unsafe fn test_sucessful_cases(heap: &mut TestMemory) {
     test_flat_array_types(heap);
     test_nested_array_types(heap);
     test_recursive_array_types(heap);
+    test_empty_tuple_types(heap);
+    test_simple_tuple_types(heap);
+    test_nested_tuple_types(heap);
+    test_recursive_tuple_types(heap);
 }
 
 unsafe fn test_empty_actor(heap: &mut TestMemory) {
@@ -594,6 +617,70 @@ unsafe fn test_recursive_array_types(heap: &mut TestMemory) {
     assert!(are_compatible(heap, types.clone(), types.clone()));
 }
 
+unsafe fn test_empty_tuple_types(heap: &mut TestMemory) {
+    let actor_type = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("TupleField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let unit_type = Type::Tuple(TypeList { items: vec![] });
+    let types = vec![actor_type, unit_type];
+    assert!(are_compatible(heap, types.clone(), types.clone()));
+}
+
+unsafe fn test_simple_tuple_types(heap: &mut TestMemory) {
+    let actor_type = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("TupleField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let tuple_type = Type::Tuple(TypeList {
+        items: vec![
+            TypeReference::nat(),
+            TypeReference::text(),
+            TypeReference::int32(),
+        ],
+    });
+    let types = vec![actor_type, tuple_type];
+    assert!(are_compatible(heap, types.clone(), types.clone()));
+}
+
+unsafe fn test_nested_tuple_types(heap: &mut TestMemory) {
+    let actor_type = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("TupleField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let outer_tuple_type = Type::Tuple(TypeList {
+        items: vec![TypeReference { index: 2 }],
+    });
+    let inner_tuple_type = Type::Tuple(TypeList {
+        items: vec![TypeReference::nat()],
+    });
+    let types = vec![actor_type, outer_tuple_type, inner_tuple_type];
+    assert!(are_compatible(heap, types.clone(), types.clone()));
+}
+
+unsafe fn test_recursive_tuple_types(heap: &mut TestMemory) {
+    let actor_type = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("TupleField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let first_tuple_type = Type::Tuple(TypeList {
+        items: vec![TypeReference { index: 2 }],
+    });
+    let second_tuple_type = Type::Tuple(TypeList {
+        items: vec![TypeReference { index: 1 }],
+    });
+    let types = vec![actor_type, first_tuple_type, second_tuple_type];
+    assert!(are_compatible(heap, types.clone(), types.clone()));
+}
+
 unsafe fn test_failing_cases(heap: &mut TestMemory) {
     test_added_object_fields(heap);
     test_mutable_mismatch(heap);
@@ -602,6 +689,7 @@ unsafe fn test_failing_cases(heap: &mut TestMemory) {
     test_option_mismatch(heap);
     test_array_mismatch(heap);
     test_array_mutability_mismatch(heap);
+    test_reordered_tuple_types(heap);
 }
 
 unsafe fn test_recursion_mismatch(heap: &mut TestMemory) {
@@ -767,3 +855,27 @@ unsafe fn test_array_mutability_mismatch(heap: &mut TestMemory) {
     let new_types = vec![new_actor, mutable_array_type, mutable_variable];
     assert!(!are_compatible(heap, old_types, new_types));
 }
+
+unsafe fn test_reordered_tuple_types(heap: &mut TestMemory) {
+    let old_actor = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("TupleField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let old_tuple = Type::Tuple(TypeList {
+        items: vec![TypeReference::nat(), TypeReference::text()],
+    });
+    let new_actor = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("TupleField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let new_tuple = Type::Tuple(TypeList {
+        items: vec![TypeReference::text(), TypeReference::nat()],
+    });
+    let old_types = vec![old_actor, old_tuple];
+    let new_types = vec![new_actor, new_tuple];
+    assert!(!are_compatible(heap, old_types, new_types));
+}
diff --git a/rts/motoko-rts/src/persistence/compatibility.rs b/rts/motoko-rts/src/persistence/compatibility.rs
index a6de715696d..3c7d9196854 100644
--- a/rts/motoko-rts/src/persistence/compatibility.rs
+++ b/rts/motoko-rts/src/persistence/compatibility.rs
@@ -34,10 +34,12 @@
 //! ```
 //! <type_table> ::= length:i32 (<type>)^length
 //! <type> ::= <object> | <mutable> | <option> | <array>
+//! <type> ::= <object> | <mutable> | <option> | <array> | <tuple>
 //! <object> ::= 1l <field_list>
 //! <mutable> ::= 2l type_index:i32
 //! <option> ::= 3l type_index:i32
 //! <array> ::= 4l type_index:i32
+//! <tuple> ::= 5l length:i32 (type_index:i32)^length
 //! <field_list> ::= length:i32 (<field>)^length
 //! <field> ::= label_hash:i32 type_index:i32
 //! ```
@@ -73,11 +75,12 @@ pub const OBJECT_ENCODING_TAG: i32 = 1;
 pub const MUTABLE_ENCODING_TAG: i32 = 2;
 pub const OPTION_ENCODING_TAG: i32 = 3;
 pub const ARRAY_ENCODING_TAG: i32 = 4;
+pub const TUPLE_ENCODING_TAG: i32 = 5;
 
 const ACTOR_TYPE_INDEX: i32 = 0;
 
 const TYPE_TAG_LENGTH: usize = 1;
-const FIELD_LIST_HEADER: usize = 1; // field_list_length
+const LENGTH_HEADER: usize = 1;
 const TYPE_INDEX_LENGTH: usize = 1;
 const FIELD_ENCODING_LENGTH: usize = 2; // label_hash type_index
 
@@ -151,6 +154,7 @@ enum Type {
     Mutable(TypeIndex),
     Option(TypeIndex),
     Array(TypeIndex),
+    Tuple(TypeList),
 }
 
 impl Type {
@@ -161,6 +165,7 @@ impl Type {
                 Self::Mutable(type_index) => type_index.size(),
                 Self::Option(type_index) => type_index.size(),
                 Self::Array(type_index) => type_index.size(),
+                Self::Tuple(tuple_list) => tuple_list.size(),
             }
     }
 
@@ -172,6 +177,7 @@ impl Type {
             MUTABLE_ENCODING_TAG => Self::Mutable(TypeIndex::new(data)),
             OPTION_ENCODING_TAG => Self::Option(TypeIndex::new(data)),
             ARRAY_ENCODING_TAG => Self::Array(TypeIndex::new(data)),
+            TUPLE_ENCODING_TAG => Self::Tuple(TypeList::new(data)),
             _ => unimplemented!(),
         }
     }
@@ -187,7 +193,7 @@ impl FieldList {
     }
 
     unsafe fn size(&self) -> usize {
-        FIELD_LIST_HEADER + self.count_fields() * FIELD_ENCODING_LENGTH
+        LENGTH_HEADER + self.count_fields() * FIELD_ENCODING_LENGTH
     }
 
     unsafe fn count_fields(&self) -> usize {
@@ -197,7 +203,7 @@ impl FieldList {
     }
 
     unsafe fn get_field(&self, field_index: usize) -> Field {
-        let field_offset = FIELD_LIST_HEADER + field_index * FIELD_ENCODING_LENGTH;
+        let field_offset = LENGTH_HEADER + field_index * FIELD_ENCODING_LENGTH;
         let label_hash = self.data.read(field_offset);
         let type_index = self.data.read(field_offset + 1);
         Field {
@@ -222,6 +228,32 @@ struct Field {
     type_index: i32,
 }
 
+struct TypeList {
+    data: EncodedData,
+}
+
+impl TypeList {
+    unsafe fn new(data: EncodedData) -> TypeList {
+        TypeList { data }
+    }
+
+    unsafe fn size(&self) -> usize {
+        LENGTH_HEADER + self.count_items() * TYPE_INDEX_LENGTH
+    }
+
+    unsafe fn count_items(&self) -> usize {
+        let count = self.data.read(0);
+        assert!(count >= 0);
+        count as usize
+    }
+
+    unsafe fn get_item(&self, item_index: usize) -> TypeIndex {
+        let item_offset = LENGTH_HEADER + item_index * TYPE_INDEX_LENGTH;
+        let type_index = self.data.read(item_offset);
+        TypeIndex { type_index }
+    }
+}
+
 struct TypeIndex {
     type_index: i32,
 }
@@ -338,6 +370,22 @@ impl CompatibilityChecker {
         self.type_compatible(new_type.type_index, old_type.type_index)
     }
 
+    unsafe fn compatible_type_list(&mut self, new_tuple: &TypeList, old_tuple: &TypeList) -> bool {
+        let new_count = new_tuple.count_items();
+        let old_count = old_tuple.count_items();
+        if new_count != old_count {
+            return false;
+        }
+        for item_index in 0..new_count {
+            let new_item = new_tuple.get_item(item_index);
+            let old_item = old_tuple.get_item(item_index);
+            if !self.compatible_type_indices(&new_item, &old_item) {
+                return false;
+            }
+        }
+        true
+    }
+
     unsafe fn type_compatible(&mut self, new_type_index: i32, old_type_index: i32) -> bool {
         if new_type_index < 0 || old_type_index < 0 {
             return new_type_index == old_type_index;
@@ -365,6 +413,10 @@ impl CompatibilityChecker {
                 self.compatible_type_indices(new_element, old_element)
             }
             (Type::Array(_), _) => false,
+            (Type::Tuple(new_type_list), Type::Tuple(old_type_list)) => {
+                self.compatible_type_list(new_type_list, old_type_list)
+            }
+            (Type::Tuple(_), _) => false,
         }
     }
 
diff --git a/src/codegen/persistence.ml b/src/codegen/persistence.ml
index 1a3d9e5c977..d8ba887bad9 100644
--- a/src/codegen/persistence.ml
+++ b/src/codegen/persistence.ml
@@ -7,11 +7,12 @@
   // Primitive types are encoded by negative indices.
   // All numbers (type indices etc.) are encoded as little endian i32.
   <type_table> ::= length:i32 (<type>)^length
-  <type> ::= <object> | <mutable> | <option> | <array>
+  <type> ::= <object> | <mutable> | <option> | <array> | <tuple>
   <object> ::= 1l <field_list>
   <mutable> ::= 2l type_index:i32
   <option> ::= 3l type_index:i32
   <array> ::= 4l type_index:i32
+  <tuple> ::= 5l length:i32 (type_index:i32)^length
   <field_list> ::= length:i32 (<field>)^length
   <field> ::= label_hash:i32 type_index:i32
   
@@ -100,6 +101,8 @@ let rec collect_type table typ =
       collect_type table optional_type
     | Array element_type ->
       collect_type table element_type
+    | Tup type_list ->
+      collect_types table type_list
     | _ ->
       Printf.printf "UNSUPPORTED PERSISTENT TYPE %s\n" (Type.string_of_typ typ);
       assert false)
@@ -148,6 +151,9 @@ let encode_field table field =
   let field_hash = Hash.hash field.lab in
   encode_i32 field_hash ^ 
   encode_i32 (type_index table field.typ)
+
+let encode_tuple_item table typ =
+  encode_i32 (type_index table typ)
   
 let encode_complex_type table typ =
   let open Type in
@@ -165,6 +171,9 @@ let encode_complex_type table typ =
   | Array element_type ->
     encode_i32 4l ^
     encode_i32 (type_index table element_type)
+  | Tup type_list ->
+    encode_i32 5l ^
+    encode_list (encode_tuple_item table) type_list
   | _ -> assert false
 
 let encode_type_table table =
diff --git a/test/run-drun/ok/tuple-upgrades.drun.ok b/test/run-drun/ok/tuple-upgrades.drun.ok
new file mode 100644
index 00000000000..5a988916e8f
--- /dev/null
+++ b/test/run-drun/ok/tuple-upgrades.drun.ok
@@ -0,0 +1,45 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+debug.print: (1, 2)
+debug.print: (0, "Test", 1.230000, {key = 5; value = '_'}, [-1, +2, -3])
+debug.print: ?(2, ?(1, null, null), ?(4, ?(3, null, null), ?(5, null, null)))
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: (1, 2)
+debug.print: (0, "Test", 1.230000, {key = 5; value = '_'}, [-1, +2, -3])
+debug.print: ?(2, ?(1, null, null), ?(4, ?(3, null, null), ?(5, null, null)))
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: ()
+debug.print: (1, 2)
+debug.print: (0, "Test", 1.230000, {key = 5; value = '_'}, [-1, +2, -3])
+debug.print: ?(2, ?(1, null, null), ?(4, ?(3, null, null), ?(5, null, null)))
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: ()
+debug.print: (1, 2)
+debug.print: (0, "Test", 1.230000, {key = 5; value = '_'}, [-1, +2, -3])
+debug.print: ?(2, ?(1, null, null), ?(4, ?(3, null, null), ?(5, null, null)))
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Memory-incompatible program upgrade
+debug.print: panic occurred in file 'src/persistence.rs' at line 193
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
+debug.print: Memory-incompatible program upgrade
+debug.print: panic occurred in file 'src/persistence.rs' at line 193
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
+debug.print: Memory-incompatible program upgrade
+debug.print: panic occurred in file 'src/persistence.rs' at line 193
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
+debug.print: Memory-incompatible program upgrade
+debug.print: panic occurred in file 'src/persistence.rs' at line 193
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
+ingress Completed: Reply: 0x4449444c0000
+debug.print: (1, 2)
+debug.print: (0, "Test", 1.230000, {key = 5; value = '_'}, [-1, +2, -3])
+debug.print: ?(2, ?(1, null, null), ?(4, ?(3, null, null), ?(5, null, null)))
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: (1, 2)
+debug.print: (0, "Test", 1.230000, {key = 5; value = '_'}, [-1, +2, -3])
+debug.print: ?(2, ?(1, null, null), ?(4, ?(3, null, null), ?(5, null, null)))
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/tuple-upgrades.drun b/test/run-drun/tuple-upgrades.drun
new file mode 100644
index 00000000000..6591e7ccda3
--- /dev/null
+++ b/test/run-drun/tuple-upgrades.drun
@@ -0,0 +1,17 @@
+# SKIP ic-ref-run
+install $ID tuple-upgrades/version0.mo ""
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID tuple-upgrades/version0.mo ""
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID tuple-upgrades/version1.mo ""
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID tuple-upgrades/version1.mo ""
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID tuple-upgrades/version2.mo ""
+upgrade $ID tuple-upgrades/version3.mo ""
+upgrade $ID tuple-upgrades/version4.mo ""
+upgrade $ID tuple-upgrades/version5.mo ""
+upgrade $ID tuple-upgrades/version0.mo ""
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID tuple-upgrades/version0.mo ""
+ingress $ID print "DIDL\x00\x00"
diff --git a/test/run-drun/tuple-upgrades/version0.mo b/test/run-drun/tuple-upgrades/version0.mo
new file mode 100644
index 00000000000..695f6230a75
--- /dev/null
+++ b/test/run-drun/tuple-upgrades/version0.mo
@@ -0,0 +1,15 @@
+import Prim "mo:prim";
+
+actor {
+    type TreeType = ?(Nat, TreeType, TreeType);
+
+    stable var pair = (1, 2);
+    stable var largerTuple = (0, "Test", 1.23, { key = 5; value = '_' }, [-1, 2, -3]);
+    stable var tree: TreeType = ?(2, ?(1, null: TreeType, null: TreeType), ?(4, ?(3, null: TreeType, null: TreeType), ?(5, null: TreeType, null: TreeType)));
+
+    public func print() : async () {
+        Prim.debugPrint(debug_show (pair));
+        Prim.debugPrint(debug_show (largerTuple));
+        Prim.debugPrint(debug_show (tree));
+    };
+};
diff --git a/test/run-drun/tuple-upgrades/version1.mo b/test/run-drun/tuple-upgrades/version1.mo
new file mode 100644
index 00000000000..dac99f913d6
--- /dev/null
+++ b/test/run-drun/tuple-upgrades/version1.mo
@@ -0,0 +1,18 @@
+import Prim "mo:prim";
+
+// Compatible upgrade
+actor {
+    type TreeType = ?(Nat, TreeType, TreeType);
+
+    stable var unit = ();
+    stable var pair = (1, 2);
+    stable var largerTuple = (0, "Test", 1.23, { key = 5; value = '_' }, [-1, 2, -3]);
+    stable var tree: TreeType = ?(2, ?(1, null: TreeType, null: TreeType), ?(4, ?(3, null: TreeType, null: TreeType), ?(5, null: TreeType, null: TreeType)));
+
+    public func print() : async () {
+        Prim.debugPrint(debug_show (unit));
+        Prim.debugPrint(debug_show (pair));
+        Prim.debugPrint(debug_show (largerTuple));
+        Prim.debugPrint(debug_show (tree));
+    };
+};
diff --git a/test/run-drun/tuple-upgrades/version2.mo b/test/run-drun/tuple-upgrades/version2.mo
new file mode 100644
index 00000000000..21501f4bd7a
--- /dev/null
+++ b/test/run-drun/tuple-upgrades/version2.mo
@@ -0,0 +1,10 @@
+import Prim "mo:prim";
+
+// Incompatible upgrade
+actor {
+    stable var unit = (1);
+    
+    public func print() : async () {
+        Prim.debugPrint(debug_show (unit));
+    };
+};
diff --git a/test/run-drun/tuple-upgrades/version3.mo b/test/run-drun/tuple-upgrades/version3.mo
new file mode 100644
index 00000000000..f9a1cebc680
--- /dev/null
+++ b/test/run-drun/tuple-upgrades/version3.mo
@@ -0,0 +1,10 @@
+import Prim "mo:prim";
+
+// Incompatible upgrade
+actor {
+    stable var pair = (1);
+    
+    public func print() : async () {
+        Prim.debugPrint(debug_show (pair));
+    };
+};
diff --git a/test/run-drun/tuple-upgrades/version4.mo b/test/run-drun/tuple-upgrades/version4.mo
new file mode 100644
index 00000000000..06deb846566
--- /dev/null
+++ b/test/run-drun/tuple-upgrades/version4.mo
@@ -0,0 +1,10 @@
+import Prim "mo:prim";
+
+// Incompatible upgrade
+actor {
+    stable var largerTuple = ("Test", 0, 1.23, { key = 5; value = '_' }, [-1, 2, -3]);
+
+    public func print() : async () {
+        Prim.debugPrint(debug_show (largerTuple));
+    };
+};
diff --git a/test/run-drun/tuple-upgrades/version5.mo b/test/run-drun/tuple-upgrades/version5.mo
new file mode 100644
index 00000000000..50ed4bc5e9b
--- /dev/null
+++ b/test/run-drun/tuple-upgrades/version5.mo
@@ -0,0 +1,16 @@
+import Prim "mo:prim";
+
+// Incompatible update
+actor {
+    type TreeType = ?(Nat, TreeType, Null);
+
+    stable var pair = (1, 2);
+    stable var largerTuple = (0, "Test", 1.23, { key = 5; value = '_' }, [-1, 2, -3]);
+    stable var tree: TreeType = ?(2, ?(1, null: TreeType, null), null);
+
+    public func print() : async () {
+        Prim.debugPrint(debug_show (pair));
+        Prim.debugPrint(debug_show (largerTuple));
+        Prim.debugPrint(debug_show (tree));
+    };
+};

From 66d0920b88e3f2459483184d83ab45305a659a89 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 31 Aug 2023 16:45:37 +0200
Subject: [PATCH 081/260] Recursive type constructor resolution

---
 src/codegen/persistence.ml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/codegen/persistence.ml b/src/codegen/persistence.ml
index d8ba887bad9..a958f0ff123 100644
--- a/src/codegen/persistence.ml
+++ b/src/codegen/persistence.ml
@@ -74,13 +74,13 @@ module TypeTable = struct
     | _ -> List.append table [typ]
 end
 
-let normalize_type typ =
+let rec normalize_type typ =
   let open Type in
   match typ with
   | Con (constructor, _) ->
     (match Mo_types.Cons.kind constructor with
     | Abs _ -> assert false
-    | Def (_, type_definition) -> type_definition)
+    | Def (_, type_definition) -> normalize_type type_definition)
   | _ -> typ
 
 let rec collect_type table typ =

From 4fb4b04116b08c88b774e30022adf35a6505f041 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 31 Aug 2023 16:50:46 +0200
Subject: [PATCH 082/260] Adjust test case

---
 test/run-drun/class-import.mo               | 15 ++++-----------
 test/run-drun/class-import/empty.mo         |  9 ---------
 test/run-drun/class-import/two.mo           | 10 ----------
 test/run-drun/ok/class-import.drun-run.ok   |  2 --
 test/run-drun/ok/class-import.ic-ref-run.ok |  2 --
 5 files changed, 4 insertions(+), 34 deletions(-)
 delete mode 100644 test/run-drun/class-import/empty.mo
 delete mode 100644 test/run-drun/class-import/two.mo

diff --git a/test/run-drun/class-import.mo b/test/run-drun/class-import.mo
index 24d757f97f3..ad46fc9d203 100644
--- a/test/run-drun/class-import.mo
+++ b/test/run-drun/class-import.mo
@@ -1,8 +1,7 @@
 import Prim "mo:⛔";
 import Cycles = "cycles/cycles";
-import M0 "class-import/empty";
 import M1 "class-import/one";
-import M3 "class-import/trap";
+import M2 "class-import/trap";
 // Too many class imports exceed the maximum data segment size of 2MB,
 // in particular if they are compiled with sanity checks.
 
@@ -12,11 +11,6 @@ actor a {
    if (Cycles.balance() == 0)
      await Cycles.provisional_top_up_actor(a, 100_000_000_000_000);
 
-   // test no arg class
-   Cycles.add(2_000_000_000_000);
-   let empty : M0.Empty = await M0.Empty();
-   await empty.test();
-
    // test single arg class
    Cycles.add(2_000_000_000_000);
    let one : M1.One = await M1.One("one");
@@ -25,7 +19,7 @@ actor a {
    // test non-trapping install
    try {
      Cycles.add(2_000_000_000_000);
-     let trap : M3.Trap = await M3.Trap(false);
+     let trap : M2.Trap = await M2.Trap(false);
    }
    catch _ {
      assert false;
@@ -34,7 +28,7 @@ actor a {
    // test trapping install
    try {
      Cycles.add(2_000_000_000_000);
-     let trap : M3.Trap = await M3.Trap(true);
+     let trap : M2.Trap = await M2.Trap(true);
      assert false;
    }
    catch _ {
@@ -50,8 +44,7 @@ a.go() //OR-CALL ingress go "DIDL\x00\x00"
 //SKIP run-ir
 //SKIP run-low
 
-// check exactly 3 embedded wasms
-//CHECK:  canister_update __motoko_async_helper
+// check exactly 2 embedded wasms
 //CHECK:  canister_update __motoko_async_helper
 //CHECK:  canister_update __motoko_async_helper
 //CHECK:  canister_update __motoko_async_helper
diff --git a/test/run-drun/class-import/empty.mo b/test/run-drun/class-import/empty.mo
deleted file mode 100644
index 92d87ed151f..00000000000
--- a/test/run-drun/class-import/empty.mo
+++ /dev/null
@@ -1,9 +0,0 @@
-import Prim "mo:⛔";
-actor class Empty() {
-
-  Prim.debugPrint("empty");
-
-  public func test() : async () {
-    Prim.debugPrint(debug_show () # " tested");
-  };
-}
diff --git a/test/run-drun/class-import/two.mo b/test/run-drun/class-import/two.mo
deleted file mode 100644
index 1c542d68747..00000000000
--- a/test/run-drun/class-import/two.mo
+++ /dev/null
@@ -1,10 +0,0 @@
-import Prim "mo:⛔";
-shared actor class Two(a : Text, b : Text) {
-
-   Prim.debugPrint(debug_show((a,b)));
-
-   public func test() : async () {
-      Prim.debugPrint(debug_show((a,b)) # "tested");
-   };
-
-}
diff --git a/test/run-drun/ok/class-import.drun-run.ok b/test/run-drun/ok/class-import.drun-run.ok
index b75ebe214aa..f50ded8fc03 100644
--- a/test/run-drun/ok/class-import.drun-run.ok
+++ b/test/run-drun/ok/class-import.drun-run.ok
@@ -1,7 +1,5 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: empty
-debug.print: () tested
 debug.print: one
 debug.print: "one" tested
 debug.print: caught trap
diff --git a/test/run-drun/ok/class-import.ic-ref-run.ok b/test/run-drun/ok/class-import.ic-ref-run.ok
index ae5bde48e56..e75f640176b 100644
--- a/test/run-drun/ok/class-import.ic-ref-run.ok
+++ b/test/run-drun/ok/class-import.ic-ref-run.ok
@@ -3,8 +3,6 @@
 => update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
 <= replied: ()
 => update go()
-debug.print: empty
-debug.print: () tested
 debug.print: one
 debug.print: "one" tested
 debug.print: caught trap

From 1f26c67ac2a3b97b78d0ee7f28d061e49ec5d16a Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 1 Sep 2023 10:02:53 +0200
Subject: [PATCH 083/260] Support generic type resolution

---
 src/codegen/persistence.ml | 39 +++++++++++++++++++++++++++++++++++---
 test/run.sh                | 32 +++++++++++++++----------------
 2 files changed, 52 insertions(+), 19 deletions(-)

diff --git a/src/codegen/persistence.ml b/src/codegen/persistence.ml
index a958f0ff123..cf270202d16 100644
--- a/src/codegen/persistence.ml
+++ b/src/codegen/persistence.ml
@@ -74,13 +74,46 @@ module TypeTable = struct
     | _ -> List.append table [typ]
 end
 
+let rec resolve_generics typ type_arguments =
+  let open Type in
+  let typ = promote typ in
+  match typ with
+  | Var (_, index) -> 
+      List.nth type_arguments index
+  | Obj (sort, field_list) ->
+      Obj (sort, (resolve_field_list field_list type_arguments))
+  | Variant field_list ->
+      Variant (resolve_field_list field_list type_arguments)
+  | Array element_type ->
+      Array (resolve_generics element_type type_arguments)
+  | Opt optional_type ->
+      Opt (resolve_generics optional_type type_arguments)
+  | Tup type_list ->
+      Tup (resolve_type_list type_list type_arguments)
+  | Mut mutable_type ->
+      Mut (resolve_generics mutable_type type_arguments)
+  | Prim _ | Any | Non -> typ
+  | _ -> assert false
+
+and resolve_field_list field_list type_arguments =
+  let open Type in
+  let resolve_field field = 
+    let resolved_field_type = resolve_generics field.typ type_arguments in
+    { lab = field.lab; typ = resolved_field_type; depr = field.depr } in
+  List.map resolve_field field_list
+
+and resolve_type_list type_list type_arguments =
+  List.map (fun typ -> resolve_generics typ type_arguments) type_list
+
 let rec normalize_type typ =
   let open Type in
   match typ with
-  | Con (constructor, _) ->
+  | Con (constructor, type_arguments) ->
     (match Mo_types.Cons.kind constructor with
     | Abs _ -> assert false
-    | Def (_, type_definition) -> normalize_type type_definition)
+    | Def (_, type_definition) -> 
+      let resolved_definition = resolve_generics type_definition type_arguments in
+      normalize_type resolved_definition)
   | _ -> typ
 
 let rec collect_type table typ =
@@ -104,7 +137,7 @@ let rec collect_type table typ =
     | Tup type_list ->
       collect_types table type_list
     | _ ->
-      Printf.printf "UNSUPPORTED PERSISTENT TYPE %s\n" (Type.string_of_typ typ);
+      Printf.eprintf "Unsupported persistent type %s\n" (Type.string_of_typ typ);
       assert false)
 
 and collect_types table type_list =
diff --git a/test/run.sh b/test/run.sh
index 9035830ac33..529b25ab05b 100755
--- a/test/run.sh
+++ b/test/run.sh
@@ -188,22 +188,22 @@ then
   fi
 fi
 
-if [ $DTESTS = yes ]
-then
-  if ic-ref-run --help >& /dev/null
-  then
-    HAVE_ic_ref_run=yes
-  else
-    if [ $ACCEPT = yes ]
-    then
-      echo "ERROR: Could not run ic-ref-run, cannot update expected test output"
-      exit 1
-    else
-      echo "WARNING: Could not run ic-ref-run, will skip running some tests"
-      HAVE_ic_ref_run=no
-    fi
-  fi
-fi
+# if [ $DTESTS = yes ]
+# then
+#   if ic-ref-run --help >& /dev/null
+#   then
+#     HAVE_ic_ref_run=yes
+#   else
+#     if [ $ACCEPT = yes ]
+#     then
+#       echo "ERROR: Could not run ic-ref-run, cannot update expected test output"
+#       exit 1
+#     else
+#       echo "WARNING: Could not run ic-ref-run, will skip running some tests"
+#       HAVE_ic_ref_run=no
+#     fi
+#   fi
+# fi
 
 
 for file in "$@";

From bf25c9a1c025660ffd8a67710f6aaa269d460a14 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 1 Sep 2023 10:03:45 +0200
Subject: [PATCH 084/260] Revert run script change

---
 test/run.sh | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/test/run.sh b/test/run.sh
index 529b25ab05b..9035830ac33 100755
--- a/test/run.sh
+++ b/test/run.sh
@@ -188,22 +188,22 @@ then
   fi
 fi
 
-# if [ $DTESTS = yes ]
-# then
-#   if ic-ref-run --help >& /dev/null
-#   then
-#     HAVE_ic_ref_run=yes
-#   else
-#     if [ $ACCEPT = yes ]
-#     then
-#       echo "ERROR: Could not run ic-ref-run, cannot update expected test output"
-#       exit 1
-#     else
-#       echo "WARNING: Could not run ic-ref-run, will skip running some tests"
-#       HAVE_ic_ref_run=no
-#     fi
-#   fi
-# fi
+if [ $DTESTS = yes ]
+then
+  if ic-ref-run --help >& /dev/null
+  then
+    HAVE_ic_ref_run=yes
+  else
+    if [ $ACCEPT = yes ]
+    then
+      echo "ERROR: Could not run ic-ref-run, cannot update expected test output"
+      exit 1
+    else
+      echo "WARNING: Could not run ic-ref-run, will skip running some tests"
+      HAVE_ic_ref_run=no
+    fi
+  fi
+fi
 
 
 for file in "$@";

From 82d8ca1da2fe834080f1254580f0f8f83e15c8e8 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 1 Sep 2023 10:13:33 +0200
Subject: [PATCH 085/260] Add test case

---
 test/run-drun/ok/upgrade-generics.drun.ok  | 19 +++++++++++++++++++
 test/run-drun/upgrade-generics.drun        | 12 ++++++++++++
 test/run-drun/upgrade-generics/version0.mo | 15 +++++++++++++++
 test/run-drun/upgrade-generics/version1.mo | 15 +++++++++++++++
 test/run-drun/upgrade-generics/version2.mo | 15 +++++++++++++++
 5 files changed, 76 insertions(+)
 create mode 100644 test/run-drun/ok/upgrade-generics.drun.ok
 create mode 100644 test/run-drun/upgrade-generics.drun
 create mode 100644 test/run-drun/upgrade-generics/version0.mo
 create mode 100644 test/run-drun/upgrade-generics/version1.mo
 create mode 100644 test/run-drun/upgrade-generics/version2.mo

diff --git a/test/run-drun/ok/upgrade-generics.drun.ok b/test/run-drun/ok/upgrade-generics.drun.ok
new file mode 100644
index 00000000000..9ba941e842c
--- /dev/null
+++ b/test/run-drun/ok/upgrade-generics.drun.ok
@@ -0,0 +1,19 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+debug.print: (([0], [+1]), true)
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: (([0], [+1]), true)
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: (([0], [+1]), true)
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: (([0], [+1]), true)
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Memory-incompatible program upgrade
+debug.print: panic occurred in file 'src/persistence.rs' at line 193
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
+ingress Completed: Reply: 0x4449444c0000
+debug.print: (([0], [+1]), true)
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/upgrade-generics.drun b/test/run-drun/upgrade-generics.drun
new file mode 100644
index 00000000000..a74b6226b64
--- /dev/null
+++ b/test/run-drun/upgrade-generics.drun
@@ -0,0 +1,12 @@
+# SKIP ic-ref-run
+install $ID upgrade-generics/version0.mo ""
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID upgrade-generics/version0.mo ""
+ingress $ID print "DIDL\x00\x01\x7d\x0F"
+upgrade $ID upgrade-generics/version1.mo ""
+ingress $ID print "DIDL\x00\x01\x7d\x0F"
+upgrade $ID upgrade-generics/version1.mo ""
+ingress $ID print "DIDL\x00\x01\x7d\x0F"
+upgrade $ID upgrade-generics/version2.mo ""
+upgrade $ID upgrade-generics/version0.mo ""
+ingress $ID print "DIDL\x00\x01\x7d\x0F"
diff --git a/test/run-drun/upgrade-generics/version0.mo b/test/run-drun/upgrade-generics/version0.mo
new file mode 100644
index 00000000000..b64c5ca0fe0
--- /dev/null
+++ b/test/run-drun/upgrade-generics/version0.mo
@@ -0,0 +1,15 @@
+import Prim "mo:prim";
+
+actor {
+
+  type B<T> = [T];
+  type A<T, U> = (B<T>, B<U>);
+  module X = { public type A<U> = U };
+  type T = (A<Nat, Int>, X.A<Bool>);
+
+  stable var value = (([0], [1]), true) : T;
+
+  public func print() : async () {
+    Prim.debugPrint(debug_show (value));
+  };
+};
diff --git a/test/run-drun/upgrade-generics/version1.mo b/test/run-drun/upgrade-generics/version1.mo
new file mode 100644
index 00000000000..ef501febe2d
--- /dev/null
+++ b/test/run-drun/upgrade-generics/version1.mo
@@ -0,0 +1,15 @@
+import Prim "mo:prim";
+
+// Compatible change
+actor {
+
+  type B<T0> = [T0];
+  type A<T1, T2> = (B<T1>, B<T2>);
+  type T = (A<Nat, Int>, Bool);
+
+  stable var value = (([0], [1]), true) : T;
+
+  public func print() : async () {
+    Prim.debugPrint(debug_show (value));
+  };
+};
diff --git a/test/run-drun/upgrade-generics/version2.mo b/test/run-drun/upgrade-generics/version2.mo
new file mode 100644
index 00000000000..7199827d23c
--- /dev/null
+++ b/test/run-drun/upgrade-generics/version2.mo
@@ -0,0 +1,15 @@
+import Prim "mo:prim";
+
+// Incompatible change
+actor {
+
+  type B<T0> = [T0];
+  type A<T1, T2> = (B<T2>, B<T1>);
+  type T = (A<Nat, Int>, Bool);
+
+  stable var value = (([0], [1]), true) : T;
+
+  public func print() : async () {
+    Prim.debugPrint(debug_show (value));
+  };
+};

From e788076cdaf3497a14a1cc452906b3ac7c686d19 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 1 Sep 2023 10:22:55 +0200
Subject: [PATCH 086/260] Adjust generic resolution

---
 src/codegen/persistence.ml | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/codegen/persistence.ml b/src/codegen/persistence.ml
index cf270202d16..093bf51e64a 100644
--- a/src/codegen/persistence.ml
+++ b/src/codegen/persistence.ml
@@ -76,7 +76,6 @@ end
 
 let rec resolve_generics typ type_arguments =
   let open Type in
-  let typ = promote typ in
   match typ with
   | Var (_, index) -> 
       List.nth type_arguments index
@@ -92,8 +91,11 @@ let rec resolve_generics typ type_arguments =
       Tup (resolve_type_list type_list type_arguments)
   | Mut mutable_type ->
       Mut (resolve_generics mutable_type type_arguments)
+  | Con (constructor, inner_arguments) ->
+      promote typ
   | Prim _ | Any | Non -> typ
-  | _ -> assert false
+  | _ ->
+    assert false
 
 and resolve_field_list field_list type_arguments =
   let open Type in

From ce36cf811e0cbb147351b84d73db526ca7a0cfc6 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 1 Sep 2023 10:53:59 +0200
Subject: [PATCH 087/260] Check variant type compatibility

---
 .../src/persistence/compatibility.rs          | 109 +++++++++++++++++-
 .../src/persistence/compatibility.rs          |  13 ++-
 src/codegen/persistence.ml                    |  16 ++-
 test/run-drun/ok/variant-upgrades.drun.ok     |  20 ++++
 test/run-drun/variant-upgrades.drun           |  14 +++
 test/run-drun/variant-upgrades/version0.mo    |  21 ++++
 test/run-drun/variant-upgrades/version1.mo    |  23 ++++
 test/run-drun/variant-upgrades/version2.mo    |  22 ++++
 8 files changed, 233 insertions(+), 5 deletions(-)
 create mode 100644 test/run-drun/ok/variant-upgrades.drun.ok
 create mode 100644 test/run-drun/variant-upgrades.drun
 create mode 100644 test/run-drun/variant-upgrades/version0.mo
 create mode 100644 test/run-drun/variant-upgrades/version1.mo
 create mode 100644 test/run-drun/variant-upgrades/version2.mo

diff --git a/rts/motoko-rts-tests/src/persistence/compatibility.rs b/rts/motoko-rts-tests/src/persistence/compatibility.rs
index 08e59304233..66cba3f66f3 100644
--- a/rts/motoko-rts-tests/src/persistence/compatibility.rs
+++ b/rts/motoko-rts-tests/src/persistence/compatibility.rs
@@ -1,7 +1,7 @@
 use motoko_rts::memory::{alloc_blob, Memory};
 use motoko_rts::persistence::compatibility::{
     memory_compatible, ARRAY_ENCODING_TAG, MUTABLE_ENCODING_TAG, OBJECT_ENCODING_TAG,
-    OPTION_ENCODING_TAG, TUPLE_ENCODING_TAG,
+    OPTION_ENCODING_TAG, TUPLE_ENCODING_TAG, VARIANT_ENCODING_TAG,
 };
 use motoko_rts::types::{Bytes, Value};
 use std::hash::Hasher;
@@ -52,6 +52,7 @@ enum Type {
     Option(TypeReference),
     Array(TypeReference),
     Tuple(TypeList),
+    Variant(FieldList),
 }
 
 impl Type {
@@ -77,6 +78,10 @@ impl Type {
                 output.write_i32(TUPLE_ENCODING_TAG);
                 type_list.serialize(output);
             }
+            Self::Variant(field_list) => {
+                output.write_i32(VARIANT_ENCODING_TAG);
+                field_list.serialize(output);
+            }
         }
     }
 }
@@ -327,6 +332,8 @@ unsafe fn test_sucessful_cases(heap: &mut TestMemory) {
     test_simple_tuple_types(heap);
     test_nested_tuple_types(heap);
     test_recursive_tuple_types(heap);
+    test_reordered_variant_fields(heap);
+    test_added_variant_fields(heap);
 }
 
 unsafe fn test_empty_actor(heap: &mut TestMemory) {
@@ -681,6 +688,72 @@ unsafe fn test_recursive_tuple_types(heap: &mut TestMemory) {
     assert!(are_compatible(heap, types.clone(), types.clone()));
 }
 
+unsafe fn test_reordered_variant_fields(heap: &mut TestMemory) {
+    let actor_type = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("VariantField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+
+    let field1 = Field {
+        name: String::from("Field1"),
+        field_type: TypeReference::int8(),
+    };
+    let field2 = Field {
+        name: String::from("Field2"),
+        field_type: TypeReference::int16(),
+    };
+    let field3 = Field {
+        name: String::from("Field3"),
+        field_type: TypeReference::int32(),
+    };
+
+    let old_variant = Type::Variant(FieldList {
+        fields: vec![field3.clone(), field2.clone(), field1.clone()],
+    });
+    let new_variant = Type::Variant(FieldList {
+        fields: vec![field1.clone(), field2.clone(), field3.clone()],
+    });
+
+    let old_types = vec![actor_type.clone(), old_variant];
+    let new_types = vec![actor_type.clone(), new_variant];
+    assert!(are_compatible(heap, old_types, new_types));
+}
+
+unsafe fn test_added_variant_fields(heap: &mut TestMemory) {
+    let actor_type = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("VariantField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+
+    let field1 = Field {
+        name: String::from("Field1"),
+        field_type: TypeReference::int8(),
+    };
+    let field2 = Field {
+        name: String::from("Field2"),
+        field_type: TypeReference::int16(),
+    };
+    let field3 = Field {
+        name: String::from("Field3"),
+        field_type: TypeReference::int32(),
+    };
+
+    let old_variant = Type::Variant(FieldList {
+        fields: vec![field2.clone()],
+    });
+    let new_variant = Type::Variant(FieldList {
+        fields: vec![field1.clone(), field2.clone(), field3.clone()],
+    });
+
+    let old_types = vec![actor_type.clone(), old_variant];
+    let new_types = vec![actor_type.clone(), new_variant];
+    assert!(are_compatible(heap, old_types, new_types));
+}
+
 unsafe fn test_failing_cases(heap: &mut TestMemory) {
     test_added_object_fields(heap);
     test_mutable_mismatch(heap);
@@ -690,6 +763,7 @@ unsafe fn test_failing_cases(heap: &mut TestMemory) {
     test_array_mismatch(heap);
     test_array_mutability_mismatch(heap);
     test_reordered_tuple_types(heap);
+    test_removed_variant_fields(heap);
 }
 
 unsafe fn test_recursion_mismatch(heap: &mut TestMemory) {
@@ -879,3 +953,36 @@ unsafe fn test_reordered_tuple_types(heap: &mut TestMemory) {
     let new_types = vec![new_actor, new_tuple];
     assert!(!are_compatible(heap, old_types, new_types));
 }
+
+unsafe fn test_removed_variant_fields(heap: &mut TestMemory) {
+    let actor_type = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("VariantField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+
+    let field1 = Field {
+        name: String::from("Field1"),
+        field_type: TypeReference::int8(),
+    };
+    let field2 = Field {
+        name: String::from("Field2"),
+        field_type: TypeReference::int16(),
+    };
+    let field3 = Field {
+        name: String::from("Field3"),
+        field_type: TypeReference::int32(),
+    };
+
+    let old_variant = Type::Variant(FieldList {
+        fields: vec![field1.clone(), field2.clone(), field3.clone()],
+    });
+    let new_variant = Type::Variant(FieldList {
+        fields: vec![field2.clone()],
+    });
+
+    let old_types = vec![actor_type.clone(), old_variant];
+    let new_types = vec![actor_type.clone(), new_variant];
+    assert!(!are_compatible(heap, old_types, new_types));
+}
diff --git a/rts/motoko-rts/src/persistence/compatibility.rs b/rts/motoko-rts/src/persistence/compatibility.rs
index 3c7d9196854..2c83afdbfe0 100644
--- a/rts/motoko-rts/src/persistence/compatibility.rs
+++ b/rts/motoko-rts/src/persistence/compatibility.rs
@@ -34,12 +34,13 @@
 //! ```
 //! <type_table> ::= length:i32 (<type>)^length
 //! <type> ::= <object> | <mutable> | <option> | <array>
-//! <type> ::= <object> | <mutable> | <option> | <array> | <tuple>
+//! <type> ::= <object> | <mutable> | <option> | <array> | <tuple> | <variant>
 //! <object> ::= 1l <field_list>
 //! <mutable> ::= 2l type_index:i32
 //! <option> ::= 3l type_index:i32
 //! <array> ::= 4l type_index:i32
 //! <tuple> ::= 5l length:i32 (type_index:i32)^length
+//! <variant> ::= 6l <field_list>
 //! <field_list> ::= length:i32 (<field>)^length
 //! <field> ::= label_hash:i32 type_index:i32
 //! ```
@@ -76,6 +77,7 @@ pub const MUTABLE_ENCODING_TAG: i32 = 2;
 pub const OPTION_ENCODING_TAG: i32 = 3;
 pub const ARRAY_ENCODING_TAG: i32 = 4;
 pub const TUPLE_ENCODING_TAG: i32 = 5;
+pub const VARIANT_ENCODING_TAG: i32 = 6;
 
 const ACTOR_TYPE_INDEX: i32 = 0;
 
@@ -155,6 +157,7 @@ enum Type {
     Option(TypeIndex),
     Array(TypeIndex),
     Tuple(TypeList),
+    Variant(FieldList),
 }
 
 impl Type {
@@ -166,6 +169,7 @@ impl Type {
                 Self::Option(type_index) => type_index.size(),
                 Self::Array(type_index) => type_index.size(),
                 Self::Tuple(tuple_list) => tuple_list.size(),
+                Self::Variant(field_list) => field_list.size(),
             }
     }
 
@@ -178,6 +182,7 @@ impl Type {
             OPTION_ENCODING_TAG => Self::Option(TypeIndex::new(data)),
             ARRAY_ENCODING_TAG => Self::Array(TypeIndex::new(data)),
             TUPLE_ENCODING_TAG => Self::Tuple(TypeList::new(data)),
+            VARIANT_ENCODING_TAG => Self::Variant(FieldList::new(data)),
             _ => unimplemented!(),
         }
     }
@@ -398,6 +403,7 @@ impl CompatibilityChecker {
         let old_type = self.old_type_table.get_type(old_type_index);
         match (&new_type, &old_type) {
             (Type::Object(new_fields), Type::Object(old_fields)) => {
+                // Reversed check than for variants: Removing new object fields is allowed.
                 self.compatible_fields(new_fields, old_fields)
             }
             (Type::Object(_), _) => false,
@@ -417,6 +423,11 @@ impl CompatibilityChecker {
                 self.compatible_type_list(new_type_list, old_type_list)
             }
             (Type::Tuple(_), _) => false,
+            (Type::Variant(new_fields), Type::Variant(old_fields)) => {
+                // Reversed check than for objects: Adding new variants fields is allowed.
+                self.compatible_fields(old_fields, new_fields)
+            }
+            (Type::Variant(_), _) => false,
         }
     }
 
diff --git a/src/codegen/persistence.ml b/src/codegen/persistence.ml
index 093bf51e64a..2dd06f1571c 100644
--- a/src/codegen/persistence.ml
+++ b/src/codegen/persistence.ml
@@ -7,12 +7,13 @@
   // Primitive types are encoded by negative indices.
   // All numbers (type indices etc.) are encoded as little endian i32.
   <type_table> ::= length:i32 (<type>)^length
-  <type> ::= <object> | <mutable> | <option> | <array> | <tuple>
+  <type> ::= <object> | <mutable> | <option> | <array> | <tuple> | <variant>
   <object> ::= 1l <field_list>
   <mutable> ::= 2l type_index:i32
   <option> ::= 3l type_index:i32
   <array> ::= 4l type_index:i32
   <tuple> ::= 5l length:i32 (type_index:i32)^length
+  <variant> ::= 6l <field_list>
   <field_list> ::= length:i32 (<field>)^length
   <field> ::= label_hash:i32 type_index:i32
   
@@ -128,8 +129,7 @@ let rec collect_type table typ =
     match typ with
     | Prim _ -> table
     | Obj (Object, field_list) ->
-      let field_types = List.map (fun field -> field.typ) field_list in
-      collect_types table field_types
+      collect_fields table field_list
     | Mut variable_type ->
       collect_type table variable_type
     | Opt optional_type ->
@@ -138,10 +138,17 @@ let rec collect_type table typ =
       collect_type table element_type
     | Tup type_list ->
       collect_types table type_list
+    | Variant field_list ->
+      collect_fields table field_list
     | _ ->
       Printf.eprintf "Unsupported persistent type %s\n" (Type.string_of_typ typ);
       assert false)
 
+and collect_fields table field_list =
+  let open Type in
+  let field_types = List.map (fun field -> field.typ) field_list in
+  collect_types table field_types
+
 and collect_types table type_list =
   match type_list with
   | [] -> table
@@ -209,6 +216,9 @@ let encode_complex_type table typ =
   | Tup type_list ->
     encode_i32 5l ^
     encode_list (encode_tuple_item table) type_list
+  | Variant field_list ->
+    encode_i32 6l ^
+    encode_list (encode_field table) field_list
   | _ -> assert false
 
 let encode_type_table table =
diff --git a/test/run-drun/ok/variant-upgrades.drun.ok b/test/run-drun/ok/variant-upgrades.drun.ok
new file mode 100644
index 00000000000..d1eae564e05
--- /dev/null
+++ b/test/run-drun/ok/variant-upgrades.drun.ok
@@ -0,0 +1,20 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: #two({key = 1; name = "TEST TEST"})
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: #two({key = 1; name = "TEST TEST TEST"})
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: #two({key = 1; name = "TEST TEST TEST TEST"})
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: #two({key = 1; name = "TEST TEST TEST TEST TEST"})
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Memory-incompatible program upgrade
+debug.print: panic occurred in file 'src/persistence.rs' at line 193
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
diff --git a/test/run-drun/variant-upgrades.drun b/test/run-drun/variant-upgrades.drun
new file mode 100644
index 00000000000..6773ddcb92b
--- /dev/null
+++ b/test/run-drun/variant-upgrades.drun
@@ -0,0 +1,14 @@
+# SKIP ic-ref-run
+install $ID variant-upgrades/version0.mo ""
+ingress $ID modify "DIDL\x00\x01\x7d\x0F"
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID variant-upgrades/version0.mo ""
+ingress $ID modify "DIDL\x00\x01\x7d\x0F"
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID variant-upgrades/version1.mo ""
+ingress $ID modify "DIDL\x00\x01\x7d\x0F"
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID variant-upgrades/version1.mo ""
+ingress $ID modify "DIDL\x00\x01\x7d\x0F"
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID variant-upgrades/version2.mo ""
diff --git a/test/run-drun/variant-upgrades/version0.mo b/test/run-drun/variant-upgrades/version0.mo
new file mode 100644
index 00000000000..212799e10c5
--- /dev/null
+++ b/test/run-drun/variant-upgrades/version0.mo
@@ -0,0 +1,21 @@
+import Prim "mo:prim";
+
+actor {
+  type Variant = {
+    #one : Nat;
+    #two : { key : Nat; var name : Text };
+  };
+
+  stable var root : Variant = #two { key = 1; var name = "TEST" };
+
+  public func modify() : async () {
+    switch root {
+      case (#two record) record.name #= " TEST";
+      case _ assert false;
+    };
+  };
+
+  public func print() : async () {
+    Prim.debugPrint(debug_show (root));
+  };
+};
diff --git a/test/run-drun/variant-upgrades/version1.mo b/test/run-drun/variant-upgrades/version1.mo
new file mode 100644
index 00000000000..49843a2510a
--- /dev/null
+++ b/test/run-drun/variant-upgrades/version1.mo
@@ -0,0 +1,23 @@
+import Prim "mo:prim";
+
+// Compatible upgrade
+actor {
+  type Variant = {
+    #two : { key : Nat; var name : Text };
+    #one : Nat;
+    #three : Text;
+  };
+
+  stable var root : Variant = #three "ERROR";
+
+  public func modify() : async () {
+    switch root {
+      case (#two record) record.name #= " TEST";
+      case _ assert false;
+    };
+  };
+
+  public func print() : async () {
+    Prim.debugPrint(debug_show (root));
+  };
+};
diff --git a/test/run-drun/variant-upgrades/version2.mo b/test/run-drun/variant-upgrades/version2.mo
new file mode 100644
index 00000000000..0911e8508a5
--- /dev/null
+++ b/test/run-drun/variant-upgrades/version2.mo
@@ -0,0 +1,22 @@
+import Prim "mo:prim";
+
+// Incompatible upgrade
+actor {
+  type Variant = {
+    #two : { key : Nat; var name : Text };
+    #one : Nat;
+  };
+
+  stable var root: Variant = #one 0;
+
+  public func modify() : async () {
+    switch root {
+      case (#two record) record.name #= " TEST";
+      case _ assert false;
+    };
+  };
+
+  public func print() : async () {
+    Prim.debugPrint(debug_show(root));
+  };
+};

From b75497ce1a6b2dbee1d1d4c0fbadd5178c4cce1b Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 1 Sep 2023 13:36:12 +0200
Subject: [PATCH 088/260] Adjust generic resolution

---
 src/codegen/persistence.ml | 16 ++++++----------
 1 file changed, 6 insertions(+), 10 deletions(-)

diff --git a/src/codegen/persistence.ml b/src/codegen/persistence.ml
index 2dd06f1571c..8a7474a3c10 100644
--- a/src/codegen/persistence.ml
+++ b/src/codegen/persistence.ml
@@ -92,7 +92,7 @@ let rec resolve_generics typ type_arguments =
       Tup (resolve_type_list type_list type_arguments)
   | Mut mutable_type ->
       Mut (resolve_generics mutable_type type_arguments)
-  | Con (constructor, inner_arguments) ->
+  | Con _ ->
       promote typ
   | Prim _ | Any | Non -> typ
   | _ ->
@@ -108,19 +108,15 @@ and resolve_field_list field_list type_arguments =
 and resolve_type_list type_list type_arguments =
   List.map (fun typ -> resolve_generics typ type_arguments) type_list
 
-let rec normalize_type typ =
+let promote_type typ =
   let open Type in
   match typ with
   | Con (constructor, type_arguments) ->
-    (match Mo_types.Cons.kind constructor with
-    | Abs _ -> assert false
-    | Def (_, type_definition) -> 
-      let resolved_definition = resolve_generics type_definition type_arguments in
-      normalize_type resolved_definition)
+    resolve_generics (promote typ) type_arguments
   | _ -> typ
 
-let rec collect_type table typ =
-  let typ = normalize_type typ in
+let rec collect_type table old_typ =
+  let typ = promote_type old_typ in
   if TypeTable.contains_type table typ then
     table
   else
@@ -183,7 +179,7 @@ let primitive_type_index primitive_type =
 
 let type_index table typ =
   let open Type in
-  let typ = normalize_type typ in
+  let typ = promote_type typ in
   match typ with
   | Prim primitive_type -> primitive_type_index primitive_type
   | _ -> Int32.of_int (TypeTable.index_of table typ)

From a444c171281cd9dbf17c61a65f3f2437a2d7f2e6 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 1 Sep 2023 14:57:10 +0200
Subject: [PATCH 089/260] Support `any` and `none` type checks

---
 .../src/persistence/compatibility.rs          | 100 +++++++++++++++++-
 .../src/persistence/compatibility.rs          |  29 ++++-
 src/codegen/persistence.ml                    |  10 +-
 test/run-drun/any-upgrades.drun               |   6 ++
 test/run-drun/any-upgrades/version0.mo        |   3 +
 test/run-drun/any-upgrades/version1.mo        |   3 +
 test/run-drun/any-upgrades/version2.mo        |   3 +
 test/run-drun/ok/any-upgrades.drun.ok         |   8 ++
 8 files changed, 156 insertions(+), 6 deletions(-)
 create mode 100644 test/run-drun/any-upgrades.drun
 create mode 100644 test/run-drun/any-upgrades/version0.mo
 create mode 100644 test/run-drun/any-upgrades/version1.mo
 create mode 100644 test/run-drun/any-upgrades/version2.mo
 create mode 100644 test/run-drun/ok/any-upgrades.drun.ok

diff --git a/rts/motoko-rts-tests/src/persistence/compatibility.rs b/rts/motoko-rts-tests/src/persistence/compatibility.rs
index 66cba3f66f3..c48353c8297 100644
--- a/rts/motoko-rts-tests/src/persistence/compatibility.rs
+++ b/rts/motoko-rts-tests/src/persistence/compatibility.rs
@@ -1,7 +1,8 @@
 use motoko_rts::memory::{alloc_blob, Memory};
 use motoko_rts::persistence::compatibility::{
-    memory_compatible, ARRAY_ENCODING_TAG, MUTABLE_ENCODING_TAG, OBJECT_ENCODING_TAG,
-    OPTION_ENCODING_TAG, TUPLE_ENCODING_TAG, VARIANT_ENCODING_TAG,
+    memory_compatible, ANY_ENCODING_TAG, ARRAY_ENCODING_TAG, MUTABLE_ENCODING_TAG,
+    NONE_ENCODING_TAG, OBJECT_ENCODING_TAG, OPTION_ENCODING_TAG, TUPLE_ENCODING_TAG,
+    VARIANT_ENCODING_TAG,
 };
 use motoko_rts::types::{Bytes, Value};
 use std::hash::Hasher;
@@ -53,6 +54,8 @@ enum Type {
     Array(TypeReference),
     Tuple(TypeList),
     Variant(FieldList),
+    None,
+    Any,
 }
 
 impl Type {
@@ -82,6 +85,12 @@ impl Type {
                 output.write_i32(VARIANT_ENCODING_TAG);
                 field_list.serialize(output);
             }
+            Self::None => {
+                output.write_i32(NONE_ENCODING_TAG);
+            }
+            Self::Any => {
+                output.write_i32(ANY_ENCODING_TAG);
+            }
         }
     }
 }
@@ -334,6 +343,9 @@ unsafe fn test_sucessful_cases(heap: &mut TestMemory) {
     test_recursive_tuple_types(heap);
     test_reordered_variant_fields(heap);
     test_added_variant_fields(heap);
+    test_any_to_any(heap);
+    test_some_to_any(heap);
+    test_none_to_none(heap);
 }
 
 unsafe fn test_empty_actor(heap: &mut TestMemory) {
@@ -754,6 +766,49 @@ unsafe fn test_added_variant_fields(heap: &mut TestMemory) {
     assert!(are_compatible(heap, old_types, new_types));
 }
 
+unsafe fn test_any_to_any(heap: &mut TestMemory) {
+    let actor_type = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("Field"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let any_type = Type::Any;
+    let types = vec![actor_type, any_type];
+    assert!(are_compatible(heap, types.clone(), types.clone()));
+}
+
+unsafe fn test_some_to_any(heap: &mut TestMemory) {
+    let old_actor = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("Field"),
+            field_type: TypeReference::text(),
+        }],
+    });
+    let new_actor = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("Field"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let any_type = Type::Any;
+    let old_types = vec![old_actor];
+    let new_types = vec![new_actor, any_type];
+    assert!(are_compatible(heap, old_types, new_types));
+}
+
+unsafe fn test_none_to_none(heap: &mut TestMemory) {
+    let actor_type = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("Field"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let none_type = Type::None;
+    let types = vec![actor_type, none_type];
+    assert!(are_compatible(heap, types.clone(), types.clone()));
+}
+
 unsafe fn test_failing_cases(heap: &mut TestMemory) {
     test_added_object_fields(heap);
     test_mutable_mismatch(heap);
@@ -764,6 +819,8 @@ unsafe fn test_failing_cases(heap: &mut TestMemory) {
     test_array_mutability_mismatch(heap);
     test_reordered_tuple_types(heap);
     test_removed_variant_fields(heap);
+    test_any_to_some(heap);
+    test_any_to_none(heap);
 }
 
 unsafe fn test_recursion_mismatch(heap: &mut TestMemory) {
@@ -986,3 +1043,42 @@ unsafe fn test_removed_variant_fields(heap: &mut TestMemory) {
     let new_types = vec![actor_type.clone(), new_variant];
     assert!(!are_compatible(heap, old_types, new_types));
 }
+
+unsafe fn test_any_to_some(heap: &mut TestMemory) {
+    let old_actor = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("Field"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let any_type = Type::Any;
+    let new_actor = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("Field"),
+            field_type: TypeReference::text(),
+        }],
+    });
+    let old_types = vec![old_actor, any_type];
+    let new_types = vec![new_actor];
+    assert!(!are_compatible(heap, old_types, new_types));
+}
+
+unsafe fn test_any_to_none(heap: &mut TestMemory) {
+    let old_actor = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("Field"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let any_type = Type::Any;
+    let new_actor = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("Field"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let none_type = Type::None;
+    let old_types = vec![old_actor, any_type];
+    let new_types = vec![new_actor, none_type];
+    assert!(!are_compatible(heap, old_types, new_types));
+}
diff --git a/rts/motoko-rts/src/persistence/compatibility.rs b/rts/motoko-rts/src/persistence/compatibility.rs
index 2c83afdbfe0..a2215df3721 100644
--- a/rts/motoko-rts/src/persistence/compatibility.rs
+++ b/rts/motoko-rts/src/persistence/compatibility.rs
@@ -34,13 +34,15 @@
 //! ```
 //! <type_table> ::= length:i32 (<type>)^length
 //! <type> ::= <object> | <mutable> | <option> | <array>
-//! <type> ::= <object> | <mutable> | <option> | <array> | <tuple> | <variant>
+//! <type> ::= <object> | <mutable> | <option> | <array> | <tuple> | <variant> | <none> | <any>
 //! <object> ::= 1l <field_list>
 //! <mutable> ::= 2l type_index:i32
 //! <option> ::= 3l type_index:i32
 //! <array> ::= 4l type_index:i32
 //! <tuple> ::= 5l length:i32 (type_index:i32)^length
 //! <variant> ::= 6l <field_list>
+//! <none> ::= 7l
+//! <any> ::= 8l
 //! <field_list> ::= length:i32 (<field>)^length
 //! <field> ::= label_hash:i32 type_index:i32
 //! ```
@@ -78,6 +80,8 @@ pub const OPTION_ENCODING_TAG: i32 = 3;
 pub const ARRAY_ENCODING_TAG: i32 = 4;
 pub const TUPLE_ENCODING_TAG: i32 = 5;
 pub const VARIANT_ENCODING_TAG: i32 = 6;
+pub const NONE_ENCODING_TAG: i32 = 7;
+pub const ANY_ENCODING_TAG: i32 = 8;
 
 const ACTOR_TYPE_INDEX: i32 = 0;
 
@@ -158,6 +162,8 @@ enum Type {
     Array(TypeIndex),
     Tuple(TypeList),
     Variant(FieldList),
+    None,
+    Any,
 }
 
 impl Type {
@@ -170,6 +176,7 @@ impl Type {
                 Self::Array(type_index) => type_index.size(),
                 Self::Tuple(tuple_list) => tuple_list.size(),
                 Self::Variant(field_list) => field_list.size(),
+                Self::None | Self::Any => 0,
             }
     }
 
@@ -183,6 +190,8 @@ impl Type {
             ARRAY_ENCODING_TAG => Self::Array(TypeIndex::new(data)),
             TUPLE_ENCODING_TAG => Self::Tuple(TypeList::new(data)),
             VARIANT_ENCODING_TAG => Self::Variant(FieldList::new(data)),
+            NONE_ENCODING_TAG => Self::None,
+            ANY_ENCODING_TAG => Self::Any,
             _ => unimplemented!(),
         }
     }
@@ -391,9 +400,22 @@ impl CompatibilityChecker {
         true
     }
 
+    unsafe fn compatible_primitives(&mut self, new_type_index: i32, old_type_index: i32) -> bool {
+        debug_assert!(new_type_index < 0 || old_type_index < 0);
+        if new_type_index == old_type_index {
+            return true;
+        }
+        if new_type_index >= 0 {
+            if let Type::Any = self.new_type_table.get_type(new_type_index) {
+                return true;
+            }
+        }
+        false
+    }
+
     unsafe fn type_compatible(&mut self, new_type_index: i32, old_type_index: i32) -> bool {
         if new_type_index < 0 || old_type_index < 0 {
-            return new_type_index == old_type_index;
+            return self.compatible_primitives(new_type_index, old_type_index);
         }
         if self.cache.visited(new_type_index, old_type_index) {
             return true;
@@ -402,6 +424,7 @@ impl CompatibilityChecker {
         let new_type = self.new_type_table.get_type(new_type_index);
         let old_type = self.old_type_table.get_type(old_type_index);
         match (&new_type, &old_type) {
+            (Type::Any, _) => true,
             (Type::Object(new_fields), Type::Object(old_fields)) => {
                 // Reversed check than for variants: Removing new object fields is allowed.
                 self.compatible_fields(new_fields, old_fields)
@@ -428,6 +451,8 @@ impl CompatibilityChecker {
                 self.compatible_fields(old_fields, new_fields)
             }
             (Type::Variant(_), _) => false,
+            (Type::None, Type::None) => true,
+            (Type::None, _) => false,
         }
     }
 
diff --git a/src/codegen/persistence.ml b/src/codegen/persistence.ml
index 8a7474a3c10..f4c634f92be 100644
--- a/src/codegen/persistence.ml
+++ b/src/codegen/persistence.ml
@@ -7,13 +7,15 @@
   // Primitive types are encoded by negative indices.
   // All numbers (type indices etc.) are encoded as little endian i32.
   <type_table> ::= length:i32 (<type>)^length
-  <type> ::= <object> | <mutable> | <option> | <array> | <tuple> | <variant>
+  <type> ::= <object> | <mutable> | <option> | <array> | <tuple> | <variant> | <none> | <any>
   <object> ::= 1l <field_list>
   <mutable> ::= 2l type_index:i32
   <option> ::= 3l type_index:i32
   <array> ::= 4l type_index:i32
   <tuple> ::= 5l length:i32 (type_index:i32)^length
   <variant> ::= 6l <field_list>
+  <none> ::= 7l
+  <any> ::= 8l
   <field_list> ::= length:i32 (<field>)^length
   <field> ::= label_hash:i32 type_index:i32
   
@@ -123,7 +125,7 @@ let rec collect_type table old_typ =
     (let table = TypeTable.add_type table typ in
     let open Type in
     match typ with
-    | Prim _ -> table
+    | Prim _ | Non | Any -> table
     | Obj (Object, field_list) ->
       collect_fields table field_list
     | Mut variable_type ->
@@ -215,6 +217,10 @@ let encode_complex_type table typ =
   | Variant field_list ->
     encode_i32 6l ^
     encode_list (encode_field table) field_list
+  | Non ->
+    encode_i32 7l
+  | Any ->
+    encode_i32 8l
   | _ -> assert false
 
 let encode_type_table table =
diff --git a/test/run-drun/any-upgrades.drun b/test/run-drun/any-upgrades.drun
new file mode 100644
index 00000000000..0417a9cc91c
--- /dev/null
+++ b/test/run-drun/any-upgrades.drun
@@ -0,0 +1,6 @@
+# SKIP ic-ref-run
+install $ID any-upgrades/version0.mo ""
+upgrade $ID any-upgrades/version0.mo ""
+upgrade $ID any-upgrades/version1.mo ""
+upgrade $ID any-upgrades/version1.mo ""
+upgrade $ID any-upgrades/version2.mo ""
diff --git a/test/run-drun/any-upgrades/version0.mo b/test/run-drun/any-upgrades/version0.mo
new file mode 100644
index 00000000000..abfec2de7c4
--- /dev/null
+++ b/test/run-drun/any-upgrades/version0.mo
@@ -0,0 +1,3 @@
+actor {
+   stable var value : Any = 123;
+};
diff --git a/test/run-drun/any-upgrades/version1.mo b/test/run-drun/any-upgrades/version1.mo
new file mode 100644
index 00000000000..5a85d0618c3
--- /dev/null
+++ b/test/run-drun/any-upgrades/version1.mo
@@ -0,0 +1,3 @@
+actor {
+   stable var value : Any = "TEST";
+};
diff --git a/test/run-drun/any-upgrades/version2.mo b/test/run-drun/any-upgrades/version2.mo
new file mode 100644
index 00000000000..58d2382656c
--- /dev/null
+++ b/test/run-drun/any-upgrades/version2.mo
@@ -0,0 +1,3 @@
+actor {
+   stable var value = "TEST";
+};
diff --git a/test/run-drun/ok/any-upgrades.drun.ok b/test/run-drun/ok/any-upgrades.drun.ok
new file mode 100644
index 00000000000..fd15d4dfc3c
--- /dev/null
+++ b/test/run-drun/ok/any-upgrades.drun.ok
@@ -0,0 +1,8 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Memory-incompatible program upgrade
+debug.print: panic occurred in file 'src/persistence.rs' at line 193
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked

From cca62ec09063875f2f460535f2ddf21456e9b0e8 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 1 Sep 2023 15:17:39 +0200
Subject: [PATCH 090/260] Check actor type compatibility

---
 .../src/persistence/compatibility.rs          | 206 +++++++++++++-----
 .../src/persistence/compatibility.rs          |  11 +-
 src/codegen/persistence.ml                    |   8 +-
 3 files changed, 169 insertions(+), 56 deletions(-)

diff --git a/rts/motoko-rts-tests/src/persistence/compatibility.rs b/rts/motoko-rts-tests/src/persistence/compatibility.rs
index c48353c8297..8cbc4bb80c6 100644
--- a/rts/motoko-rts-tests/src/persistence/compatibility.rs
+++ b/rts/motoko-rts-tests/src/persistence/compatibility.rs
@@ -1,8 +1,8 @@
 use motoko_rts::memory::{alloc_blob, Memory};
 use motoko_rts::persistence::compatibility::{
-    memory_compatible, ANY_ENCODING_TAG, ARRAY_ENCODING_TAG, MUTABLE_ENCODING_TAG,
-    NONE_ENCODING_TAG, OBJECT_ENCODING_TAG, OPTION_ENCODING_TAG, TUPLE_ENCODING_TAG,
-    VARIANT_ENCODING_TAG,
+    memory_compatible, ACTOR_ENCODING_TAG, ANY_ENCODING_TAG, ARRAY_ENCODING_TAG,
+    MUTABLE_ENCODING_TAG, NONE_ENCODING_TAG, OBJECT_ENCODING_TAG, OPTION_ENCODING_TAG,
+    TUPLE_ENCODING_TAG, VARIANT_ENCODING_TAG,
 };
 use motoko_rts::types::{Bytes, Value};
 use std::hash::Hasher;
@@ -56,6 +56,7 @@ enum Type {
     Variant(FieldList),
     None,
     Any,
+    Actor(FieldList),
 }
 
 impl Type {
@@ -91,6 +92,10 @@ impl Type {
             Self::Any => {
                 output.write_i32(ANY_ENCODING_TAG);
             }
+            Self::Actor(field_list) => {
+                output.write_i32(ACTOR_ENCODING_TAG);
+                field_list.serialize(output);
+            }
         }
     }
 }
@@ -326,11 +331,12 @@ unsafe fn test_primitive_types(heap: &mut TestMemory) {
 unsafe fn test_sucessful_cases(heap: &mut TestMemory) {
     test_empty_actor(heap);
     test_multiple_primitive_fields(heap);
-    test_reordered_actor_fields(heap);
-    test_removed_actor_fields(heap);
+    test_reordered_main_actor_fields(heap);
+    test_removed_main_actor_fields(heap);
     test_mutable_fields(heap);
-    test_added_actor_fields(heap);
+    test_added_main_actor_fields(heap);
     test_removed_object_fields(heap);
+    test_removed_actor_fields(heap);
     test_direct_recursive_type(heap);
     test_indirect_recursive_type(heap);
     test_option_types(heap);
@@ -431,7 +437,7 @@ unsafe fn test_multiple_primitive_fields(heap: &mut TestMemory) {
     assert!(is_compatible(heap, types.clone(), types));
 }
 
-unsafe fn test_reordered_actor_fields(heap: &mut TestMemory) {
+unsafe fn test_reordered_main_actor_fields(heap: &mut TestMemory) {
     let field1 = Field {
         name: String::from("Field1"),
         field_type: TypeReference::int(),
@@ -451,7 +457,7 @@ unsafe fn test_reordered_actor_fields(heap: &mut TestMemory) {
     assert!(is_compatible(heap, old_type, new_type));
 }
 
-unsafe fn test_removed_actor_fields(heap: &mut TestMemory) {
+unsafe fn test_removed_main_actor_fields(heap: &mut TestMemory) {
     let field1 = Field {
         name: String::from("Field1"),
         field_type: TypeReference::nat8(),
@@ -475,7 +481,7 @@ unsafe fn test_removed_actor_fields(heap: &mut TestMemory) {
     assert!(is_compatible(heap, old_type, new_type));
 }
 
-unsafe fn test_added_actor_fields(heap: &mut TestMemory) {
+unsafe fn test_added_main_actor_fields(heap: &mut TestMemory) {
     let field1 = Field {
         name: String::from("Field1"),
         field_type: TypeReference::bool(),
@@ -500,20 +506,20 @@ unsafe fn test_added_actor_fields(heap: &mut TestMemory) {
 }
 
 unsafe fn test_mutable_fields(heap: &mut TestMemory) {
-    let actor_type = Type::Object(FieldList {
+    let main_actor = Type::Object(FieldList {
         fields: vec![Field {
-            name: String::from("ActorField"),
+            name: String::from("MainActorField"),
             field_type: TypeReference { index: 1 },
         }],
     });
     let mutable_type = Type::Mutable(TypeReference::nat());
-    let old_types = vec![actor_type.clone(), mutable_type.clone()];
-    let new_types = vec![actor_type.clone(), mutable_type.clone()];
+    let old_types = vec![main_actor.clone(), mutable_type.clone()];
+    let new_types = vec![main_actor.clone(), mutable_type.clone()];
     assert!(are_compatible(heap, old_types, new_types));
 }
 
 unsafe fn test_removed_object_fields(heap: &mut TestMemory) {
-    let actor_type = Type::Object(FieldList {
+    let main_actor = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("ActorField"),
             field_type: TypeReference { index: 1 },
@@ -540,8 +546,41 @@ unsafe fn test_removed_object_fields(heap: &mut TestMemory) {
         fields: vec![field2.clone()],
     });
 
-    let old_types = vec![actor_type.clone(), old_type];
-    let new_types = vec![actor_type.clone(), new_type];
+    let old_types = vec![main_actor.clone(), old_type];
+    let new_types = vec![main_actor.clone(), new_type];
+    assert!(are_compatible(heap, old_types, new_types));
+}
+
+unsafe fn test_removed_actor_fields(heap: &mut TestMemory) {
+    let main_actor = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("ActorField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+
+    let field1 = Field {
+        name: String::from("Field1"),
+        field_type: TypeReference::int8(),
+    };
+    let field2 = Field {
+        name: String::from("Field2"),
+        field_type: TypeReference::int16(),
+    };
+    let field3 = Field {
+        name: String::from("Field3"),
+        field_type: TypeReference::int32(),
+    };
+
+    let old_type = Type::Actor(FieldList {
+        fields: vec![field1.clone(), field2.clone(), field3.clone()],
+    });
+    let new_type = Type::Actor(FieldList {
+        fields: vec![field2.clone()],
+    });
+
+    let old_types = vec![main_actor.clone(), old_type];
+    let new_types = vec![main_actor.clone(), new_type];
     assert!(are_compatible(heap, old_types, new_types));
 }
 
@@ -550,7 +589,7 @@ unsafe fn test_direct_recursive_type(heap: &mut TestMemory) {
         name: String::from("ActorField"),
         field_type: TypeReference { index: 1 },
     };
-    let actor_type = Type::Object(FieldList {
+    let main_actor = Type::Object(FieldList {
         fields: vec![actor_field],
     });
     let recursive_field = Field {
@@ -560,12 +599,12 @@ unsafe fn test_direct_recursive_type(heap: &mut TestMemory) {
     let recursive_type = Type::Object(FieldList {
         fields: vec![recursive_field],
     });
-    let types = vec![actor_type, recursive_type];
+    let types = vec![main_actor, recursive_type];
     assert!(are_compatible(heap, types.clone(), types.clone()));
 }
 
 unsafe fn test_indirect_recursive_type(heap: &mut TestMemory) {
-    let actor_type = Type::Object(FieldList {
+    let main_actor = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("ActorField"),
             field_type: TypeReference { index: 1 },
@@ -583,36 +622,36 @@ unsafe fn test_indirect_recursive_type(heap: &mut TestMemory) {
             field_type: TypeReference { index: 1 },
         }],
     });
-    let types = vec![actor_type, first_type, second_type];
+    let types = vec![main_actor, first_type, second_type];
     assert!(are_compatible(heap, types.clone(), types.clone()));
 }
 
 unsafe fn test_option_types(heap: &mut TestMemory) {
-    let actor_type = Type::Object(FieldList {
+    let main_actor = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("OptionalField"),
             field_type: TypeReference { index: 1 },
         }],
     });
     let option_type = Type::Option(TypeReference::blob());
-    let types = vec![actor_type, option_type];
+    let types = vec![main_actor, option_type];
     assert!(are_compatible(heap, types.clone(), types.clone()));
 }
 
 unsafe fn test_flat_array_types(heap: &mut TestMemory) {
-    let actor_type = Type::Object(FieldList {
+    let main_actor = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("ArrayField"),
             field_type: TypeReference { index: 1 },
         }],
     });
     let array_type = Type::Array(TypeReference::nat());
-    let types = vec![actor_type, array_type];
+    let types = vec![main_actor, array_type];
     assert!(are_compatible(heap, types.clone(), types.clone()));
 }
 
 unsafe fn test_nested_array_types(heap: &mut TestMemory) {
-    let actor_type = Type::Object(FieldList {
+    let main_actor = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("ArrayField"),
             field_type: TypeReference { index: 1 },
@@ -620,36 +659,36 @@ unsafe fn test_nested_array_types(heap: &mut TestMemory) {
     });
     let outer_array_type = Type::Array(TypeReference { index: 2 });
     let inner_array_type = Type::Array(TypeReference::nat());
-    let types = vec![actor_type, outer_array_type, inner_array_type];
+    let types = vec![main_actor, outer_array_type, inner_array_type];
     assert!(are_compatible(heap, types.clone(), types.clone()));
 }
 
 unsafe fn test_recursive_array_types(heap: &mut TestMemory) {
-    let actor_type = Type::Object(FieldList {
+    let main_actor = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("ArrayField"),
             field_type: TypeReference { index: 1 },
         }],
     });
     let recursive_array_type = Type::Array(TypeReference { index: 1 });
-    let types = vec![actor_type, recursive_array_type];
+    let types = vec![main_actor, recursive_array_type];
     assert!(are_compatible(heap, types.clone(), types.clone()));
 }
 
 unsafe fn test_empty_tuple_types(heap: &mut TestMemory) {
-    let actor_type = Type::Object(FieldList {
+    let main_actor = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("TupleField"),
             field_type: TypeReference { index: 1 },
         }],
     });
     let unit_type = Type::Tuple(TypeList { items: vec![] });
-    let types = vec![actor_type, unit_type];
+    let types = vec![main_actor, unit_type];
     assert!(are_compatible(heap, types.clone(), types.clone()));
 }
 
 unsafe fn test_simple_tuple_types(heap: &mut TestMemory) {
-    let actor_type = Type::Object(FieldList {
+    let main_actor = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("TupleField"),
             field_type: TypeReference { index: 1 },
@@ -662,12 +701,12 @@ unsafe fn test_simple_tuple_types(heap: &mut TestMemory) {
             TypeReference::int32(),
         ],
     });
-    let types = vec![actor_type, tuple_type];
+    let types = vec![main_actor, tuple_type];
     assert!(are_compatible(heap, types.clone(), types.clone()));
 }
 
 unsafe fn test_nested_tuple_types(heap: &mut TestMemory) {
-    let actor_type = Type::Object(FieldList {
+    let main_actor = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("TupleField"),
             field_type: TypeReference { index: 1 },
@@ -679,12 +718,12 @@ unsafe fn test_nested_tuple_types(heap: &mut TestMemory) {
     let inner_tuple_type = Type::Tuple(TypeList {
         items: vec![TypeReference::nat()],
     });
-    let types = vec![actor_type, outer_tuple_type, inner_tuple_type];
+    let types = vec![main_actor, outer_tuple_type, inner_tuple_type];
     assert!(are_compatible(heap, types.clone(), types.clone()));
 }
 
 unsafe fn test_recursive_tuple_types(heap: &mut TestMemory) {
-    let actor_type = Type::Object(FieldList {
+    let main_actor = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("TupleField"),
             field_type: TypeReference { index: 1 },
@@ -696,12 +735,12 @@ unsafe fn test_recursive_tuple_types(heap: &mut TestMemory) {
     let second_tuple_type = Type::Tuple(TypeList {
         items: vec![TypeReference { index: 1 }],
     });
-    let types = vec![actor_type, first_tuple_type, second_tuple_type];
+    let types = vec![main_actor, first_tuple_type, second_tuple_type];
     assert!(are_compatible(heap, types.clone(), types.clone()));
 }
 
 unsafe fn test_reordered_variant_fields(heap: &mut TestMemory) {
-    let actor_type = Type::Object(FieldList {
+    let main_actor = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("VariantField"),
             field_type: TypeReference { index: 1 },
@@ -728,13 +767,13 @@ unsafe fn test_reordered_variant_fields(heap: &mut TestMemory) {
         fields: vec![field1.clone(), field2.clone(), field3.clone()],
     });
 
-    let old_types = vec![actor_type.clone(), old_variant];
-    let new_types = vec![actor_type.clone(), new_variant];
+    let old_types = vec![main_actor.clone(), old_variant];
+    let new_types = vec![main_actor.clone(), new_variant];
     assert!(are_compatible(heap, old_types, new_types));
 }
 
 unsafe fn test_added_variant_fields(heap: &mut TestMemory) {
-    let actor_type = Type::Object(FieldList {
+    let main_actor = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("VariantField"),
             field_type: TypeReference { index: 1 },
@@ -761,20 +800,20 @@ unsafe fn test_added_variant_fields(heap: &mut TestMemory) {
         fields: vec![field1.clone(), field2.clone(), field3.clone()],
     });
 
-    let old_types = vec![actor_type.clone(), old_variant];
-    let new_types = vec![actor_type.clone(), new_variant];
+    let old_types = vec![main_actor.clone(), old_variant];
+    let new_types = vec![main_actor.clone(), new_variant];
     assert!(are_compatible(heap, old_types, new_types));
 }
 
 unsafe fn test_any_to_any(heap: &mut TestMemory) {
-    let actor_type = Type::Object(FieldList {
+    let main_actor = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("Field"),
             field_type: TypeReference { index: 1 },
         }],
     });
     let any_type = Type::Any;
-    let types = vec![actor_type, any_type];
+    let types = vec![main_actor, any_type];
     assert!(are_compatible(heap, types.clone(), types.clone()));
 }
 
@@ -798,19 +837,22 @@ unsafe fn test_some_to_any(heap: &mut TestMemory) {
 }
 
 unsafe fn test_none_to_none(heap: &mut TestMemory) {
-    let actor_type = Type::Object(FieldList {
+    let main_actor = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("Field"),
             field_type: TypeReference { index: 1 },
         }],
     });
     let none_type = Type::None;
-    let types = vec![actor_type, none_type];
+    let types = vec![main_actor, none_type];
     assert!(are_compatible(heap, types.clone(), types.clone()));
 }
 
 unsafe fn test_failing_cases(heap: &mut TestMemory) {
     test_added_object_fields(heap);
+    test_added_actor_fields(heap);
+    test_actor_to_object(heap);
+    test_object_to_actor(heap);
     test_mutable_mismatch(heap);
     test_immutable_mismatch(heap);
     test_recursion_mismatch(heap);
@@ -858,13 +900,12 @@ unsafe fn test_recursion_mismatch(heap: &mut TestMemory) {
 }
 
 unsafe fn test_added_object_fields(heap: &mut TestMemory) {
-    let actor_type = Type::Object(FieldList {
+    let main_actor = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("ActorField"),
             field_type: TypeReference { index: 1 },
         }],
     });
-
     let field1 = Field {
         name: String::from("Field1"),
         field_type: TypeReference::nat64(),
@@ -884,9 +925,68 @@ unsafe fn test_added_object_fields(heap: &mut TestMemory) {
     let new_type = Type::Object(FieldList {
         fields: vec![field1.clone(), field2.clone(), field3.clone()],
     });
+    let old_types = vec![main_actor.clone(), old_type];
+    let new_types = vec![main_actor.clone(), new_type];
+    assert!(!are_compatible(heap, old_types, new_types));
+}
+
+unsafe fn test_added_actor_fields(heap: &mut TestMemory) {
+    let main_actor = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("ActorField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+
+    let field1 = Field {
+        name: String::from("Field1"),
+        field_type: TypeReference::nat64(),
+    };
+    let field2 = Field {
+        name: String::from("Field2"),
+        field_type: TypeReference::float(),
+    };
+    let field3 = Field {
+        name: String::from("Field3"),
+        field_type: TypeReference::int64(),
+    };
+
+    let old_type = Type::Actor(FieldList {
+        fields: vec![field2.clone()],
+    });
+    let new_type = Type::Actor(FieldList {
+        fields: vec![field1.clone(), field2.clone(), field3.clone()],
+    });
+    let old_types = vec![main_actor.clone(), old_type];
+    let new_types = vec![main_actor.clone(), new_type];
+    assert!(!are_compatible(heap, old_types, new_types));
+}
+
+unsafe fn test_actor_to_object(heap: &mut TestMemory) {
+    let main_actor = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("ActorField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let old_type = Type::Actor(FieldList { fields: vec![] });
+    let new_type = Type::Object(FieldList { fields: vec![] });
+    let old_types = vec![main_actor.clone(), old_type];
+    let new_types = vec![main_actor.clone(), new_type];
+    assert!(!are_compatible(heap, old_types, new_types));
+}
 
-    let old_types = vec![actor_type.clone(), old_type];
-    let new_types = vec![actor_type.clone(), new_type];
+unsafe fn test_object_to_actor(heap: &mut TestMemory) {
+    let main_actor = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("ActorField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let old_type = Type::Actor(FieldList { fields: vec![] });
+    let new_type = Type::Object(FieldList { fields: vec![] });
+    let old_types = vec![main_actor.clone(), old_type];
+    let new_types = vec![main_actor.clone(), new_type];
     assert!(!are_compatible(heap, old_types, new_types));
 }
 
@@ -1012,7 +1112,7 @@ unsafe fn test_reordered_tuple_types(heap: &mut TestMemory) {
 }
 
 unsafe fn test_removed_variant_fields(heap: &mut TestMemory) {
-    let actor_type = Type::Object(FieldList {
+    let main_actor = Type::Object(FieldList {
         fields: vec![Field {
             name: String::from("VariantField"),
             field_type: TypeReference { index: 1 },
@@ -1039,8 +1139,8 @@ unsafe fn test_removed_variant_fields(heap: &mut TestMemory) {
         fields: vec![field2.clone()],
     });
 
-    let old_types = vec![actor_type.clone(), old_variant];
-    let new_types = vec![actor_type.clone(), new_variant];
+    let old_types = vec![main_actor.clone(), old_variant];
+    let new_types = vec![main_actor.clone(), new_variant];
     assert!(!are_compatible(heap, old_types, new_types));
 }
 
diff --git a/rts/motoko-rts/src/persistence/compatibility.rs b/rts/motoko-rts/src/persistence/compatibility.rs
index a2215df3721..28bfb14b301 100644
--- a/rts/motoko-rts/src/persistence/compatibility.rs
+++ b/rts/motoko-rts/src/persistence/compatibility.rs
@@ -34,7 +34,7 @@
 //! ```
 //! <type_table> ::= length:i32 (<type>)^length
 //! <type> ::= <object> | <mutable> | <option> | <array>
-//! <type> ::= <object> | <mutable> | <option> | <array> | <tuple> | <variant> | <none> | <any>
+//! <type> ::= <object> | <mutable> | <option> | <array> | <tuple> | <variant> | <none> | <any> | <actor>
 //! <object> ::= 1l <field_list>
 //! <mutable> ::= 2l type_index:i32
 //! <option> ::= 3l type_index:i32
@@ -43,6 +43,7 @@
 //! <variant> ::= 6l <field_list>
 //! <none> ::= 7l
 //! <any> ::= 8l
+//! <actor> ::= 9l <field_list>
 //! <field_list> ::= length:i32 (<field>)^length
 //! <field> ::= label_hash:i32 type_index:i32
 //! ```
@@ -82,6 +83,7 @@ pub const TUPLE_ENCODING_TAG: i32 = 5;
 pub const VARIANT_ENCODING_TAG: i32 = 6;
 pub const NONE_ENCODING_TAG: i32 = 7;
 pub const ANY_ENCODING_TAG: i32 = 8;
+pub const ACTOR_ENCODING_TAG: i32 = 9;
 
 const ACTOR_TYPE_INDEX: i32 = 0;
 
@@ -164,6 +166,7 @@ enum Type {
     Variant(FieldList),
     None,
     Any,
+    Actor(FieldList),
 }
 
 impl Type {
@@ -177,6 +180,7 @@ impl Type {
                 Self::Tuple(tuple_list) => tuple_list.size(),
                 Self::Variant(field_list) => field_list.size(),
                 Self::None | Self::Any => 0,
+                Self::Actor(field_list) => field_list.size(),
             }
     }
 
@@ -192,6 +196,7 @@ impl Type {
             VARIANT_ENCODING_TAG => Self::Variant(FieldList::new(data)),
             NONE_ENCODING_TAG => Self::None,
             ANY_ENCODING_TAG => Self::Any,
+            ACTOR_ENCODING_TAG => Self::Actor(FieldList::new(data)),
             _ => unimplemented!(),
         }
     }
@@ -453,6 +458,10 @@ impl CompatibilityChecker {
             (Type::Variant(_), _) => false,
             (Type::None, Type::None) => true,
             (Type::None, _) => false,
+            (Type::Actor(new_fields), Type::Actor(old_fields)) => {
+                self.compatible_fields(new_fields, old_fields)
+            }
+            (Type::Actor(_), _) => false,
         }
     }
 
diff --git a/src/codegen/persistence.ml b/src/codegen/persistence.ml
index f4c634f92be..b8f62e5ea1b 100644
--- a/src/codegen/persistence.ml
+++ b/src/codegen/persistence.ml
@@ -7,7 +7,7 @@
   // Primitive types are encoded by negative indices.
   // All numbers (type indices etc.) are encoded as little endian i32.
   <type_table> ::= length:i32 (<type>)^length
-  <type> ::= <object> | <mutable> | <option> | <array> | <tuple> | <variant> | <none> | <any>
+  <type> ::= <object> | <mutable> | <option> | <array> | <tuple> | <variant> | <none> | <any> | <actor>
   <object> ::= 1l <field_list>
   <mutable> ::= 2l type_index:i32
   <option> ::= 3l type_index:i32
@@ -16,6 +16,7 @@
   <variant> ::= 6l <field_list>
   <none> ::= 7l
   <any> ::= 8l
+  <actor> ::= 9l <field_list>
   <field_list> ::= length:i32 (<field>)^length
   <field> ::= label_hash:i32 type_index:i32
   
@@ -126,7 +127,7 @@ let rec collect_type table old_typ =
     let open Type in
     match typ with
     | Prim _ | Non | Any -> table
-    | Obj (Object, field_list) ->
+    | Obj (sort, field_list) when sort = Actor || sort = Object ->
       collect_fields table field_list
     | Mut variable_type ->
       collect_type table variable_type
@@ -221,6 +222,9 @@ let encode_complex_type table typ =
     encode_i32 7l
   | Any ->
     encode_i32 8l
+  | Obj (Actor, field_list) -> 
+    encode_i32 9l ^ 
+    encode_list (encode_field table) field_list
   | _ -> assert false
 
 let encode_type_table table =

From 87bb037a625fe2ced20f830d250db1ce7adcf1f1 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 1 Sep 2023 15:28:43 +0200
Subject: [PATCH 091/260] Rearrange type encoding

---
 .../src/persistence/compatibility.rs          |  2 +-
 .../src/persistence/compatibility.rs          | 49 +++++++++----------
 src/codegen/persistence.ml                    | 38 +++++++-------
 3 files changed, 44 insertions(+), 45 deletions(-)

diff --git a/rts/motoko-rts-tests/src/persistence/compatibility.rs b/rts/motoko-rts-tests/src/persistence/compatibility.rs
index 8cbc4bb80c6..3502df0216a 100644
--- a/rts/motoko-rts-tests/src/persistence/compatibility.rs
+++ b/rts/motoko-rts-tests/src/persistence/compatibility.rs
@@ -49,6 +49,7 @@ impl BinaryData {
 #[derive(Clone)]
 enum Type {
     Object(FieldList),
+    Actor(FieldList),
     Mutable(TypeReference),
     Option(TypeReference),
     Array(TypeReference),
@@ -56,7 +57,6 @@ enum Type {
     Variant(FieldList),
     None,
     Any,
-    Actor(FieldList),
 }
 
 impl Type {
diff --git a/rts/motoko-rts/src/persistence/compatibility.rs b/rts/motoko-rts/src/persistence/compatibility.rs
index 28bfb14b301..3ca98b67bdf 100644
--- a/rts/motoko-rts/src/persistence/compatibility.rs
+++ b/rts/motoko-rts/src/persistence/compatibility.rs
@@ -33,17 +33,16 @@
 //!
 //! ```
 //! <type_table> ::= length:i32 (<type>)^length
-//! <type> ::= <object> | <mutable> | <option> | <array>
-//! <type> ::= <object> | <mutable> | <option> | <array> | <tuple> | <variant> | <none> | <any> | <actor>
+//! <type> ::= <object> | <actor> | <mutable> | <option> | <array> | <tuple> | <variant> | <none> | <any>
 //! <object> ::= 1l <field_list>
-//! <mutable> ::= 2l type_index:i32
-//! <option> ::= 3l type_index:i32
-//! <array> ::= 4l type_index:i32
-//! <tuple> ::= 5l length:i32 (type_index:i32)^length
-//! <variant> ::= 6l <field_list>
-//! <none> ::= 7l
-//! <any> ::= 8l
-//! <actor> ::= 9l <field_list>
+//! <actor> ::= 2l <field_list>
+//! <mutable> ::= 4l type_index:i32
+//! <option> ::= 5l type_index:i32
+//! <array> ::= 6l type_index:i32
+//! <tuple> ::= 7l length:i32 (type_index:i32)^length
+//! <variant> ::= 8l <field_list>
+//! <none> ::= 9l
+//! <any> ::= 10l
 //! <field_list> ::= length:i32 (<field>)^length
 //! <field> ::= label_hash:i32 type_index:i32
 //! ```
@@ -76,14 +75,14 @@ use crate::{
 };
 
 pub const OBJECT_ENCODING_TAG: i32 = 1;
-pub const MUTABLE_ENCODING_TAG: i32 = 2;
-pub const OPTION_ENCODING_TAG: i32 = 3;
-pub const ARRAY_ENCODING_TAG: i32 = 4;
-pub const TUPLE_ENCODING_TAG: i32 = 5;
-pub const VARIANT_ENCODING_TAG: i32 = 6;
-pub const NONE_ENCODING_TAG: i32 = 7;
-pub const ANY_ENCODING_TAG: i32 = 8;
-pub const ACTOR_ENCODING_TAG: i32 = 9;
+pub const ACTOR_ENCODING_TAG: i32 = 2;
+pub const MUTABLE_ENCODING_TAG: i32 = 4;
+pub const OPTION_ENCODING_TAG: i32 = 5;
+pub const ARRAY_ENCODING_TAG: i32 = 6;
+pub const TUPLE_ENCODING_TAG: i32 = 7;
+pub const VARIANT_ENCODING_TAG: i32 = 8;
+pub const NONE_ENCODING_TAG: i32 = 9;
+pub const ANY_ENCODING_TAG: i32 = 10;
 
 const ACTOR_TYPE_INDEX: i32 = 0;
 
@@ -159,6 +158,7 @@ impl TypeTable {
 
 enum Type {
     Object(FieldList),
+    Actor(FieldList),
     Mutable(TypeIndex),
     Option(TypeIndex),
     Array(TypeIndex),
@@ -166,7 +166,6 @@ enum Type {
     Variant(FieldList),
     None,
     Any,
-    Actor(FieldList),
 }
 
 impl Type {
@@ -174,13 +173,13 @@ impl Type {
         TYPE_TAG_LENGTH
             + match Self::get_type(data) {
                 Self::Object(field_list) => field_list.size(),
+                Self::Actor(field_list) => field_list.size(),
                 Self::Mutable(type_index) => type_index.size(),
                 Self::Option(type_index) => type_index.size(),
                 Self::Array(type_index) => type_index.size(),
                 Self::Tuple(tuple_list) => tuple_list.size(),
                 Self::Variant(field_list) => field_list.size(),
                 Self::None | Self::Any => 0,
-                Self::Actor(field_list) => field_list.size(),
             }
     }
 
@@ -189,6 +188,7 @@ impl Type {
         let data = data.sub_view(TYPE_TAG_LENGTH);
         match tag {
             OBJECT_ENCODING_TAG => Self::Object(FieldList::new(data)),
+            ACTOR_ENCODING_TAG => Self::Actor(FieldList::new(data)),
             MUTABLE_ENCODING_TAG => Self::Mutable(TypeIndex::new(data)),
             OPTION_ENCODING_TAG => Self::Option(TypeIndex::new(data)),
             ARRAY_ENCODING_TAG => Self::Array(TypeIndex::new(data)),
@@ -196,7 +196,6 @@ impl Type {
             VARIANT_ENCODING_TAG => Self::Variant(FieldList::new(data)),
             NONE_ENCODING_TAG => Self::None,
             ANY_ENCODING_TAG => Self::Any,
-            ACTOR_ENCODING_TAG => Self::Actor(FieldList::new(data)),
             _ => unimplemented!(),
         }
     }
@@ -435,6 +434,10 @@ impl CompatibilityChecker {
                 self.compatible_fields(new_fields, old_fields)
             }
             (Type::Object(_), _) => false,
+            (Type::Actor(new_fields), Type::Actor(old_fields)) => {
+                self.compatible_fields(new_fields, old_fields)
+            }
+            (Type::Actor(_), _) => false,
             (Type::Mutable(new_variable), Type::Mutable(old_variable)) => {
                 self.compatible_type_indices(new_variable, old_variable)
             }
@@ -458,10 +461,6 @@ impl CompatibilityChecker {
             (Type::Variant(_), _) => false,
             (Type::None, Type::None) => true,
             (Type::None, _) => false,
-            (Type::Actor(new_fields), Type::Actor(old_fields)) => {
-                self.compatible_fields(new_fields, old_fields)
-            }
-            (Type::Actor(_), _) => false,
         }
     }
 
diff --git a/src/codegen/persistence.ml b/src/codegen/persistence.ml
index b8f62e5ea1b..bd071f45264 100644
--- a/src/codegen/persistence.ml
+++ b/src/codegen/persistence.ml
@@ -7,16 +7,16 @@
   // Primitive types are encoded by negative indices.
   // All numbers (type indices etc.) are encoded as little endian i32.
   <type_table> ::= length:i32 (<type>)^length
-  <type> ::= <object> | <mutable> | <option> | <array> | <tuple> | <variant> | <none> | <any> | <actor>
+  <type> ::= <object> | <actor> | <mutable> | <option> | <array> | <tuple> | <variant> | <none> | <any>
   <object> ::= 1l <field_list>
-  <mutable> ::= 2l type_index:i32
-  <option> ::= 3l type_index:i32
-  <array> ::= 4l type_index:i32
-  <tuple> ::= 5l length:i32 (type_index:i32)^length
-  <variant> ::= 6l <field_list>
-  <none> ::= 7l
-  <any> ::= 8l
-  <actor> ::= 9l <field_list>
+  <actor> ::= 2l <field_list>
+  <mutable> ::= 4l type_index:i32
+  <option> ::= 5l type_index:i32
+  <array> ::= 6l type_index:i32
+  <tuple> ::= 7l length:i32 (type_index:i32)^length
+  <variant> ::= 8l <field_list>
+  <none> ::= 9l
+  <any> ::= 10l
   <field_list> ::= length:i32 (<field>)^length
   <field> ::= label_hash:i32 type_index:i32
   
@@ -203,28 +203,28 @@ let encode_complex_type table typ =
   | Obj (Object, field_list) -> 
     encode_i32 1l ^ 
     encode_list (encode_field table) field_list
+  | Obj (Actor, field_list) -> 
+    encode_i32 2l ^ 
+    encode_list (encode_field table) field_list
   | Mut variable_type ->
-    encode_i32 2l ^
+    encode_i32 4l ^
     encode_i32 (type_index table variable_type)
   | Opt optional_type ->
-    encode_i32 3l ^
+    encode_i32 5l ^
     encode_i32 (type_index table optional_type)
   | Array element_type ->
-    encode_i32 4l ^
+    encode_i32 6l ^
     encode_i32 (type_index table element_type)
   | Tup type_list ->
-    encode_i32 5l ^
+    encode_i32 7l ^
     encode_list (encode_tuple_item table) type_list
   | Variant field_list ->
-    encode_i32 6l ^
+    encode_i32 8l ^
     encode_list (encode_field table) field_list
   | Non ->
-    encode_i32 7l
+    encode_i32 9l
   | Any ->
-    encode_i32 8l
-  | Obj (Actor, field_list) -> 
-    encode_i32 9l ^ 
-    encode_list (encode_field table) field_list
+    encode_i32 10l
   | _ -> assert false
 
 let encode_type_table table =

From f91d441832a9519f0f90079d4bf791de267fe8ab Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 1 Sep 2023 17:07:13 +0200
Subject: [PATCH 092/260] Work in progress: Function type compatibility

---
 .../src/persistence/compatibility.rs          | 166 +++++++++++++++++-
 src/codegen/persistence.ml                    |  37 +++-
 2 files changed, 192 insertions(+), 11 deletions(-)

diff --git a/rts/motoko-rts/src/persistence/compatibility.rs b/rts/motoko-rts/src/persistence/compatibility.rs
index 3ca98b67bdf..520846d8456 100644
--- a/rts/motoko-rts/src/persistence/compatibility.rs
+++ b/rts/motoko-rts/src/persistence/compatibility.rs
@@ -33,9 +33,10 @@
 //!
 //! ```
 //! <type_table> ::= length:i32 (<type>)^length
-//! <type> ::= <object> | <actor> | <mutable> | <option> | <array> | <tuple> | <variant> | <none> | <any>
+//! <type> ::= <object> | <actor> | <function> | <mutable> | <option> | <array> | <tuple> | <variant> | <none> | <any>
 //! <object> ::= 1l <field_list>
 //! <actor> ::= 2l <field_list>
+//! <function> ::= 3l function_sort:i32 <type_list> <type_list>
 //! <mutable> ::= 4l type_index:i32
 //! <option> ::= 5l type_index:i32
 //! <array> ::= 6l type_index:i32
@@ -45,6 +46,7 @@
 //! <any> ::= 10l
 //! <field_list> ::= length:i32 (<field>)^length
 //! <field> ::= label_hash:i32 type_index:i32
+//! <type_list> ::= length:i32 <type_index:i32>^length
 //! ```
 //!
 //! Predefined primitive type indices
@@ -67,6 +69,13 @@
 //! Text      | -15l
 //! Blob      | -16l
 //! Principal | -17l
+//!
+//! Function sort
+//! Sort      | Encoding
+//! --------- | ---------
+//! Query     | 1l
+//! Write     | 2l
+//! Composite | 3l
 
 use crate::{
     mem_utils::memzero_bytes,
@@ -76,6 +85,7 @@ use crate::{
 
 pub const OBJECT_ENCODING_TAG: i32 = 1;
 pub const ACTOR_ENCODING_TAG: i32 = 2;
+pub const FUNCTION_ENCODING_TAG: i32 = 3;
 pub const MUTABLE_ENCODING_TAG: i32 = 4;
 pub const OPTION_ENCODING_TAG: i32 = 5;
 pub const ARRAY_ENCODING_TAG: i32 = 6;
@@ -87,6 +97,7 @@ pub const ANY_ENCODING_TAG: i32 = 10;
 const ACTOR_TYPE_INDEX: i32 = 0;
 
 const TYPE_TAG_LENGTH: usize = 1;
+const FUNCTION_SORT_LENGTH: usize = 1;
 const LENGTH_HEADER: usize = 1;
 const TYPE_INDEX_LENGTH: usize = 1;
 const FIELD_ENCODING_LENGTH: usize = 2; // label_hash type_index
@@ -159,6 +170,7 @@ impl TypeTable {
 enum Type {
     Object(FieldList),
     Actor(FieldList),
+    Function(FunctionSignature),
     Mutable(TypeIndex),
     Option(TypeIndex),
     Array(TypeIndex),
@@ -174,6 +186,7 @@ impl Type {
             + match Self::get_type(data) {
                 Self::Object(field_list) => field_list.size(),
                 Self::Actor(field_list) => field_list.size(),
+                Self::Function(signature) => signature.size(),
                 Self::Mutable(type_index) => type_index.size(),
                 Self::Option(type_index) => type_index.size(),
                 Self::Array(type_index) => type_index.size(),
@@ -189,6 +202,7 @@ impl Type {
         match tag {
             OBJECT_ENCODING_TAG => Self::Object(FieldList::new(data)),
             ACTOR_ENCODING_TAG => Self::Actor(FieldList::new(data)),
+            FUNCTION_ENCODING_TAG => Self::Function(FunctionSignature::new(data)),
             MUTABLE_ENCODING_TAG => Self::Mutable(TypeIndex::new(data)),
             OPTION_ENCODING_TAG => Self::Option(TypeIndex::new(data)),
             ARRAY_ENCODING_TAG => Self::Array(TypeIndex::new(data)),
@@ -196,7 +210,7 @@ impl Type {
             VARIANT_ENCODING_TAG => Self::Variant(FieldList::new(data)),
             NONE_ENCODING_TAG => Self::None,
             ANY_ENCODING_TAG => Self::Any,
-            _ => unimplemented!(),
+            _ => unreachable!(),
         }
     }
 }
@@ -287,6 +301,69 @@ impl TypeIndex {
     }
 }
 
+#[derive(PartialEq)]
+enum FunctionSort {
+    Query,
+    Write,
+    Composite,
+}
+
+pub const QUERY_FUNCTION_SORT: i32 = 1;
+pub const WRITE_FUNCTION_SORT: i32 = 2;
+pub const COMPOSITE_FUNCTION_SORT: i32 = 3;
+
+struct FunctionSignature {
+    data: EncodedData,
+}
+
+impl FunctionSignature {
+    unsafe fn new(data: EncodedData) -> FunctionSignature {
+        FunctionSignature { data }
+    }
+
+    unsafe fn size(&self) -> usize {
+        self.return_types_offset() + LENGTH_HEADER + self.count_return_types() * TYPE_INDEX_LENGTH
+    }
+
+    unsafe fn sort(&self) -> FunctionSort {
+        match self.data.read(0) {
+            QUERY_FUNCTION_SORT => FunctionSort::Query,
+            WRITE_FUNCTION_SORT => FunctionSort::Write,
+            COMPOSITE_FUNCTION_SORT => FunctionSort::Composite,
+            _ => unreachable!(),
+        }
+    }
+
+    unsafe fn count_parameters(&self) -> usize {
+        let count = self.data.read(FUNCTION_SORT_LENGTH);
+        assert!(count >= 0);
+        count as usize
+    }
+
+    unsafe fn get_parameter(&self, index: usize) -> TypeIndex {
+        let offset = FUNCTION_SORT_LENGTH + LENGTH_HEADER + index * TYPE_INDEX_LENGTH;
+        let type_index = self.data.read(offset);
+        TypeIndex { type_index }
+    }
+
+    unsafe fn return_types_offset(&self) -> usize {
+        FUNCTION_SORT_LENGTH + LENGTH_HEADER + self.count_parameters() * TYPE_INDEX_LENGTH
+    }
+
+    unsafe fn count_return_types(&self) -> usize {
+        let offset = self.return_types_offset();
+        let count = self.data.read(offset);
+        assert!(count >= 0);
+        count as usize
+    }
+
+    unsafe fn get_return_type(&self, index: usize) -> TypeIndex {
+        let offset = self.return_types_offset() + LENGTH_HEADER + index * TYPE_INDEX_LENGTH;
+        let type_index = self.data.read(offset);
+        TypeIndex { type_index }
+    }
+}
+
 /// Cache for remembering previous type compatibility checks.
 /// Necessary to avoid infinite loops on type recursion.
 /// Helpful to optimize repeated checks.
@@ -359,7 +436,7 @@ impl CompatibilityChecker {
         }
     }
 
-    unsafe fn compatible_fields(
+    unsafe fn compatible_object_fields(
         &mut self,
         new_field_list: &FieldList,
         old_field_list: &FieldList,
@@ -380,6 +457,27 @@ impl CompatibilityChecker {
         true
     }
 
+    unsafe fn compatible_variant_fields(
+        &mut self,
+        new_field_list: &FieldList,
+        old_field_list: &FieldList,
+    ) -> bool {
+        for field_index in 0..old_field_list.count_fields() {
+            let old_field = old_field_list.get_field(field_index);
+            match new_field_list.find_field(old_field.label_hash) {
+                None => {
+                    return false;
+                }
+                Some(new_field) => {
+                    if !self.type_compatible(new_field.type_index, old_field.type_index) {
+                        return false;
+                    }
+                }
+            }
+        }
+        true
+    }
+
     unsafe fn compatible_type_indices(
         &mut self,
         new_type: &TypeIndex,
@@ -404,6 +502,56 @@ impl CompatibilityChecker {
         true
     }
 
+    unsafe fn compatible_functions(
+        &mut self,
+        new_signature: &FunctionSignature,
+        old_signature: &FunctionSignature,
+    ) -> bool {
+        new_signature.sort() == old_signature.sort()
+            && self.compatible_parameters(new_signature, old_signature)
+            && self.compatible_return_types(new_signature, old_signature)
+    }
+
+    unsafe fn compatible_parameters(
+        &mut self,
+        new_signature: &FunctionSignature,
+        old_signature: &FunctionSignature,
+    ) -> bool {
+        let new_count = new_signature.count_parameters();
+        let old_count = old_signature.count_parameters();
+        if new_count != old_count {
+            return false;
+        }
+        for index in 0..new_count {
+            let _new_parameter = new_signature.get_parameter(index);
+            let _old_parameter = old_signature.get_parameter(index);
+            // Contravariance
+            unimplemented!()
+        }
+        true
+    }
+
+    unsafe fn compatible_return_types(
+        &mut self,
+        new_signature: &FunctionSignature,
+        old_signature: &FunctionSignature,
+    ) -> bool {
+        let new_count = new_signature.count_return_types();
+        let old_count = old_signature.count_return_types();
+        if new_count != old_count {
+            return false;
+        }
+        for index in 0..new_count {
+            let new_return_type = new_signature.get_return_type(index);
+            let old_return_type = old_signature.get_return_type(index);
+            // Covariance
+            if !self.type_compatible(new_return_type.type_index, old_return_type.type_index) {
+                return false;
+            }
+        }
+        true
+    }
+
     unsafe fn compatible_primitives(&mut self, new_type_index: i32, old_type_index: i32) -> bool {
         debug_assert!(new_type_index < 0 || old_type_index < 0);
         if new_type_index == old_type_index {
@@ -430,14 +578,17 @@ impl CompatibilityChecker {
         match (&new_type, &old_type) {
             (Type::Any, _) => true,
             (Type::Object(new_fields), Type::Object(old_fields)) => {
-                // Reversed check than for variants: Removing new object fields is allowed.
-                self.compatible_fields(new_fields, old_fields)
+                self.compatible_object_fields(new_fields, old_fields)
             }
             (Type::Object(_), _) => false,
             (Type::Actor(new_fields), Type::Actor(old_fields)) => {
-                self.compatible_fields(new_fields, old_fields)
+                self.compatible_object_fields(new_fields, old_fields)
             }
             (Type::Actor(_), _) => false,
+            (Type::Function(new_signature), Type::Function(old_signature)) => {
+                self.compatible_functions(new_signature, old_signature)
+            }
+            (Type::Function(_), _) => false,
             (Type::Mutable(new_variable), Type::Mutable(old_variable)) => {
                 self.compatible_type_indices(new_variable, old_variable)
             }
@@ -455,8 +606,7 @@ impl CompatibilityChecker {
             }
             (Type::Tuple(_), _) => false,
             (Type::Variant(new_fields), Type::Variant(old_fields)) => {
-                // Reversed check than for objects: Adding new variants fields is allowed.
-                self.compatible_fields(old_fields, new_fields)
+                self.compatible_variant_fields(new_fields, old_fields)
             }
             (Type::Variant(_), _) => false,
             (Type::None, Type::None) => true,
diff --git a/src/codegen/persistence.ml b/src/codegen/persistence.ml
index bd071f45264..ebcc0fa82f3 100644
--- a/src/codegen/persistence.ml
+++ b/src/codegen/persistence.ml
@@ -7,9 +7,10 @@
   // Primitive types are encoded by negative indices.
   // All numbers (type indices etc.) are encoded as little endian i32.
   <type_table> ::= length:i32 (<type>)^length
-  <type> ::= <object> | <actor> | <mutable> | <option> | <array> | <tuple> | <variant> | <none> | <any>
+  <type> ::= <object> | <actor> | <function> | <mutable> | <option> | <array> | <tuple> | <variant> | <none> | <any>
   <object> ::= 1l <field_list>
   <actor> ::= 2l <field_list>
+  <function> ::= 3l function_sort:i32 <type_list> <type_list>
   <mutable> ::= 4l type_index:i32
   <option> ::= 5l type_index:i32
   <array> ::= 6l type_index:i32
@@ -19,6 +20,7 @@
   <any> ::= 10l
   <field_list> ::= length:i32 (<field>)^length
   <field> ::= label_hash:i32 type_index:i32
+  <type_list> ::= length:i32 <type_index:i32>^length
   
   // Predefined primitive type indices
   Type      | Index
@@ -40,6 +42,14 @@
   Text      | -15l
   Blob      | -16l
   Principal | -17l
+
+
+  // Function sort
+  Sort      | Encoding
+  --------- | ---------
+  Query     | 1l
+  Write     | 2l
+  Composite | 3l
 *)
 
 open Mo_types
@@ -85,6 +95,10 @@ let rec resolve_generics typ type_arguments =
       List.nth type_arguments index
   | Obj (sort, field_list) ->
       Obj (sort, (resolve_field_list field_list type_arguments))
+  | Func (sort, control, bindings, parameter_list, return_list) ->
+      let resolved_parameters = resolve_type_list parameter_list type_arguments in
+      let resolved_returns = resolve_type_list return_list type_arguments in
+      Func (sort, control, bindings, resolved_parameters, resolved_returns)
   | Variant field_list ->
       Variant (resolve_field_list field_list type_arguments)
   | Array element_type ->
@@ -129,6 +143,8 @@ let rec collect_type table old_typ =
     | Prim _ | Non | Any -> table
     | Obj (sort, field_list) when sort = Actor || sort = Object ->
       collect_fields table field_list
+    | Func (Shared _, _, _, parameter_list, return_list) ->
+      collect_types table (List.append parameter_list return_list)
     | Mut variable_type ->
       collect_type table variable_type
     | Opt optional_type ->
@@ -193,8 +209,18 @@ let encode_field table field =
   encode_i32 field_hash ^ 
   encode_i32 (type_index table field.typ)
 
-let encode_tuple_item table typ =
+let encode_type_reference table typ =
   encode_i32 (type_index table typ)
+
+let encode_type_list table type_list =
+  encode_list (encode_type_reference table) type_list
+
+let function_sort_code sort =
+  let open Type in
+  match sort with
+  | Query -> 1l
+  | Write -> 2l
+  | Composite -> 3l
   
 let encode_complex_type table typ =
   let open Type in
@@ -206,6 +232,11 @@ let encode_complex_type table typ =
   | Obj (Actor, field_list) -> 
     encode_i32 2l ^ 
     encode_list (encode_field table) field_list
+  | Func (Shared sort, _, _, parameter_list, return_list) ->
+    encode_i32 3l ^ 
+    encode_i32 (function_sort_code sort) ^
+    encode_type_list table parameter_list ^
+    encode_type_list table return_list
   | Mut variable_type ->
     encode_i32 4l ^
     encode_i32 (type_index table variable_type)
@@ -217,7 +248,7 @@ let encode_complex_type table typ =
     encode_i32 (type_index table element_type)
   | Tup type_list ->
     encode_i32 7l ^
-    encode_list (encode_tuple_item table) type_list
+    encode_type_list table type_list
   | Variant field_list ->
     encode_i32 8l ^
     encode_list (encode_field table) field_list

From 0eb9bc4296e7b260cb3f3b06a6cae43c332fa7c1 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 1 Sep 2023 18:35:52 +0200
Subject: [PATCH 093/260] Check function type compatibility

---
 .../src/persistence/compatibility.rs          | 191 +++++++++++-------
 test/run-drun/function-upgrades.drun          |   8 +
 test/run-drun/function-upgrades/version0.mo   |  14 ++
 test/run-drun/function-upgrades/version1.mo   |  14 ++
 test/run-drun/function-upgrades/version2.mo   |   6 +
 test/run-drun/function-upgrades/version3.mo   |   6 +
 test/run-drun/function-upgrades/version4.mo   |   6 +
 test/run-drun/ok/function-upgrades.drun.ok    |  15 ++
 8 files changed, 182 insertions(+), 78 deletions(-)
 create mode 100644 test/run-drun/function-upgrades.drun
 create mode 100644 test/run-drun/function-upgrades/version0.mo
 create mode 100644 test/run-drun/function-upgrades/version1.mo
 create mode 100644 test/run-drun/function-upgrades/version2.mo
 create mode 100644 test/run-drun/function-upgrades/version3.mo
 create mode 100644 test/run-drun/function-upgrades/version4.mo
 create mode 100644 test/run-drun/ok/function-upgrades.drun.ok

diff --git a/rts/motoko-rts/src/persistence/compatibility.rs b/rts/motoko-rts/src/persistence/compatibility.rs
index 520846d8456..873dc401b43 100644
--- a/rts/motoko-rts/src/persistence/compatibility.rs
+++ b/rts/motoko-rts/src/persistence/compatibility.rs
@@ -77,6 +77,8 @@
 //! Write     | 2l
 //! Composite | 3l
 
+use core::mem::swap;
+
 use crate::{
     mem_utils::memzero_bytes,
     memory::{alloc_blob, Memory},
@@ -417,38 +419,46 @@ impl TypeCheckCache {
 }
 
 struct CompatibilityChecker {
-    cache: TypeCheckCache,
-    new_type_table: TypeTable,
-    old_type_table: TypeTable,
+    covariance_cache: TypeCheckCache,
+    contravariance_cache: TypeCheckCache,
+    target_type_table: TypeTable,
+    source_type_table: TypeTable,
 }
 
 impl CompatibilityChecker {
     unsafe fn new<M: Memory>(
         mem: &mut M,
-        new_type_table: TypeTable,
-        old_type_table: TypeTable,
+        target_type_table: TypeTable,
+        source_type_table: TypeTable,
     ) -> CompatibilityChecker {
-        let cache = TypeCheckCache::new(mem, &new_type_table, &old_type_table);
+        let covariance_cache = TypeCheckCache::new(mem, &target_type_table, &source_type_table);
+        let contravariance_cache = TypeCheckCache::new(mem, &source_type_table, &target_type_table);
         CompatibilityChecker {
-            cache,
-            new_type_table,
-            old_type_table,
+            covariance_cache,
+            contravariance_cache,
+            target_type_table,
+            source_type_table,
         }
     }
 
+    fn flip_variance(&mut self) {
+        swap(&mut self.covariance_cache, &mut self.contravariance_cache);
+        swap(&mut self.target_type_table, &mut self.source_type_table);
+    }
+
     unsafe fn compatible_object_fields(
         &mut self,
-        new_field_list: &FieldList,
-        old_field_list: &FieldList,
+        target_field_list: &FieldList,
+        source_field_list: &FieldList,
     ) -> bool {
-        for field_index in 0..new_field_list.count_fields() {
-            let new_field = new_field_list.get_field(field_index);
-            match old_field_list.find_field(new_field.label_hash) {
+        for field_index in 0..target_field_list.count_fields() {
+            let target_field = target_field_list.get_field(field_index);
+            match source_field_list.find_field(target_field.label_hash) {
                 None => {
                     return false;
                 }
-                Some(old_field) => {
-                    if !self.type_compatible(new_field.type_index, old_field.type_index) {
+                Some(source_field) => {
+                    if !self.type_compatible(target_field.type_index, source_field.type_index) {
                         return false;
                     }
                 }
@@ -459,17 +469,17 @@ impl CompatibilityChecker {
 
     unsafe fn compatible_variant_fields(
         &mut self,
-        new_field_list: &FieldList,
-        old_field_list: &FieldList,
+        target_field_list: &FieldList,
+        source_field_list: &FieldList,
     ) -> bool {
-        for field_index in 0..old_field_list.count_fields() {
-            let old_field = old_field_list.get_field(field_index);
-            match new_field_list.find_field(old_field.label_hash) {
+        for field_index in 0..source_field_list.count_fields() {
+            let source_field = source_field_list.get_field(field_index);
+            match target_field_list.find_field(source_field.label_hash) {
                 None => {
                     return false;
                 }
-                Some(new_field) => {
-                    if !self.type_compatible(new_field.type_index, old_field.type_index) {
+                Some(target_field) => {
+                    if !self.type_compatible(target_field.type_index, source_field.type_index) {
                         return false;
                     }
                 }
@@ -480,21 +490,25 @@ impl CompatibilityChecker {
 
     unsafe fn compatible_type_indices(
         &mut self,
-        new_type: &TypeIndex,
-        old_type: &TypeIndex,
+        target_type: &TypeIndex,
+        source_type: &TypeIndex,
     ) -> bool {
-        self.type_compatible(new_type.type_index, old_type.type_index)
+        self.type_compatible(target_type.type_index, source_type.type_index)
     }
 
-    unsafe fn compatible_type_list(&mut self, new_tuple: &TypeList, old_tuple: &TypeList) -> bool {
-        let new_count = new_tuple.count_items();
-        let old_count = old_tuple.count_items();
-        if new_count != old_count {
+    unsafe fn compatible_type_list(
+        &mut self,
+        target_tuple: &TypeList,
+        source_tuple: &TypeList,
+    ) -> bool {
+        let target_count = target_tuple.count_items();
+        let source_count = source_tuple.count_items();
+        if target_count != source_count {
             return false;
         }
-        for item_index in 0..new_count {
-            let new_item = new_tuple.get_item(item_index);
-            let old_item = old_tuple.get_item(item_index);
+        for item_index in 0..target_count {
+            let new_item = target_tuple.get_item(item_index);
+            let old_item = source_tuple.get_item(item_index);
             if !self.compatible_type_indices(&new_item, &old_item) {
                 return false;
             }
@@ -504,78 +518,99 @@ impl CompatibilityChecker {
 
     unsafe fn compatible_functions(
         &mut self,
-        new_signature: &FunctionSignature,
-        old_signature: &FunctionSignature,
+        target_signature: &FunctionSignature,
+        source_signature: &FunctionSignature,
     ) -> bool {
-        new_signature.sort() == old_signature.sort()
-            && self.compatible_parameters(new_signature, old_signature)
-            && self.compatible_return_types(new_signature, old_signature)
+        target_signature.sort() == source_signature.sort()
+            && self.compatible_parameters(target_signature, source_signature)
+            && self.compatible_return_types(target_signature, source_signature)
     }
 
     unsafe fn compatible_parameters(
         &mut self,
-        new_signature: &FunctionSignature,
-        old_signature: &FunctionSignature,
+        target_signature: &FunctionSignature,
+        source_signature: &FunctionSignature,
     ) -> bool {
-        let new_count = new_signature.count_parameters();
-        let old_count = old_signature.count_parameters();
-        if new_count != old_count {
+        let target_count = target_signature.count_parameters();
+        let source_count = source_signature.count_parameters();
+        if target_count != source_count {
             return false;
         }
-        for index in 0..new_count {
-            let _new_parameter = new_signature.get_parameter(index);
-            let _old_parameter = old_signature.get_parameter(index);
+        for index in 0..target_count {
+            let target_parameter = target_signature.get_parameter(index);
+            let source_parameter = source_signature.get_parameter(index);
             // Contravariance
-            unimplemented!()
+            if !self.reverse_compatible(source_parameter.type_index, target_parameter.type_index) {
+                return false;
+            }
         }
         true
     }
 
+    unsafe fn reverse_compatible(
+        &mut self,
+        source_type_index: i32,
+        target_type_index: i32,
+    ) -> bool {
+        self.flip_variance();
+        let result = self.type_compatible(target_type_index, source_type_index);
+        self.flip_variance();
+        result
+    }
+
     unsafe fn compatible_return_types(
         &mut self,
-        new_signature: &FunctionSignature,
-        old_signature: &FunctionSignature,
+        target_signature: &FunctionSignature,
+        source_signature: &FunctionSignature,
     ) -> bool {
-        let new_count = new_signature.count_return_types();
-        let old_count = old_signature.count_return_types();
-        if new_count != old_count {
+        let target_count = target_signature.count_return_types();
+        let source_count = source_signature.count_return_types();
+        if target_count != source_count {
             return false;
         }
-        for index in 0..new_count {
-            let new_return_type = new_signature.get_return_type(index);
-            let old_return_type = old_signature.get_return_type(index);
+        for index in 0..target_count {
+            let target_return_type = target_signature.get_return_type(index);
+            let source_return_type = source_signature.get_return_type(index);
             // Covariance
-            if !self.type_compatible(new_return_type.type_index, old_return_type.type_index) {
+            if !self.type_compatible(target_return_type.type_index, source_return_type.type_index) {
                 return false;
             }
         }
         true
     }
 
-    unsafe fn compatible_primitives(&mut self, new_type_index: i32, old_type_index: i32) -> bool {
-        debug_assert!(new_type_index < 0 || old_type_index < 0);
-        if new_type_index == old_type_index {
+    unsafe fn compatible_primitives(
+        &mut self,
+        target_type_index: i32,
+        source_type_index: i32,
+    ) -> bool {
+        debug_assert!(target_type_index < 0 || source_type_index < 0);
+        if target_type_index == source_type_index {
             return true;
         }
-        if new_type_index >= 0 {
-            if let Type::Any = self.new_type_table.get_type(new_type_index) {
+        if target_type_index >= 0 {
+            if let Type::Any = self.target_type_table.get_type(target_type_index) {
                 return true;
             }
         }
         false
     }
 
-    unsafe fn type_compatible(&mut self, new_type_index: i32, old_type_index: i32) -> bool {
-        if new_type_index < 0 || old_type_index < 0 {
-            return self.compatible_primitives(new_type_index, old_type_index);
+    unsafe fn type_compatible(&mut self, target_type_index: i32, source_type_index: i32) -> bool {
+        if target_type_index < 0 || source_type_index < 0 {
+            return self.compatible_primitives(target_type_index, source_type_index);
         }
-        if self.cache.visited(new_type_index, old_type_index) {
+        if self
+            .covariance_cache
+            .visited(target_type_index, source_type_index)
+        {
             return true;
         }
-        self.cache.visit(new_type_index, old_type_index);
-        let new_type = self.new_type_table.get_type(new_type_index);
-        let old_type = self.old_type_table.get_type(old_type_index);
-        match (&new_type, &old_type) {
+        self.covariance_cache
+            .visit(target_type_index, source_type_index);
+        let target_type = self.target_type_table.get_type(target_type_index);
+        let source_type = self.source_type_table.get_type(source_type_index);
+        match (&target_type, &source_type) {
             (Type::Any, _) => true,
             (Type::Object(new_fields), Type::Object(old_fields)) => {
                 self.compatible_object_fields(new_fields, old_fields)
@@ -614,14 +649,14 @@ impl CompatibilityChecker {
         }
     }
 
-    unsafe fn compatible_actor_fields(&mut self) -> bool {
-        let new_field_list = self.new_type_table.get_actor_fields();
-        let old_field_list = self.old_type_table.get_actor_fields();
-        for new_field_index in 0..new_field_list.count_fields() {
-            let new_field = new_field_list.get_field(new_field_index);
-            match old_field_list.find_field(new_field.label_hash) {
-                Some(old_field) => {
-                    if !self.type_compatible(new_field.type_index, old_field.type_index) {
+    unsafe fn compatible_main_actors(&mut self) -> bool {
+        let target_field_list = self.target_type_table.get_actor_fields();
+        let source_field_list = self.source_type_table.get_actor_fields();
+        for target_field_index in 0..target_field_list.count_fields() {
+            let target_field = target_field_list.get_field(target_field_index);
+            match source_field_list.find_field(target_field.label_hash) {
+                Some(source_field) => {
+                    if !self.type_compatible(target_field.type_index, source_field.type_index) {
                         return false;
                     }
                 }
@@ -638,5 +673,5 @@ pub unsafe fn memory_compatible<M: Memory>(mem: &mut M, old_type: Value, new_typ
     let new_type_table = TypeTable::new(new_type);
     let old_type_table = TypeTable::new(old_type);
     let mut checker = CompatibilityChecker::new(mem, new_type_table, old_type_table);
-    checker.compatible_actor_fields()
+    checker.compatible_main_actors()
 }
diff --git a/test/run-drun/function-upgrades.drun b/test/run-drun/function-upgrades.drun
new file mode 100644
index 00000000000..cd83b4859e0
--- /dev/null
+++ b/test/run-drun/function-upgrades.drun
@@ -0,0 +1,8 @@
+install $ID function-upgrades/version0.mo ""
+upgrade $ID function-upgrades/version0.mo ""
+upgrade $ID function-upgrades/version1.mo ""
+upgrade $ID function-upgrades/version1.mo ""
+upgrade $ID function-upgrades/version2.mo ""
+upgrade $ID function-upgrades/version3.mo ""
+upgrade $ID function-upgrades/version4.mo ""
+upgrade $ID function-upgrades/version1.mo ""
diff --git a/test/run-drun/function-upgrades/version0.mo b/test/run-drun/function-upgrades/version0.mo
new file mode 100644
index 00000000000..6e55e9c0b4c
--- /dev/null
+++ b/test/run-drun/function-upgrades/version0.mo
@@ -0,0 +1,14 @@
+actor {
+   public shared query func f0() : async () { loop {} };
+   stable let x0 = f0;
+
+   public shared composite query func f1(_ : Nat, _ : Bool) : async (Nat, Bool) {
+      loop {};
+   };
+   stable let x1 = f1;
+
+   public shared func f2(_ : {#one; #two}, _ : { oldField : Nat }) : async { oldField : Text } {
+      loop {};
+   };
+   stable let x2 = f2;
+};
diff --git a/test/run-drun/function-upgrades/version1.mo b/test/run-drun/function-upgrades/version1.mo
new file mode 100644
index 00000000000..c951177bfbb
--- /dev/null
+++ b/test/run-drun/function-upgrades/version1.mo
@@ -0,0 +1,14 @@
+actor {
+   public shared query func f0() : async () { loop {} };
+   stable let x0 = f0;
+
+   public shared composite query func f1(_ : Nat, _ : Bool) : async (Nat, Bool) {
+      loop {};
+   };
+   stable let x1 = f1;
+
+   public shared func f2(_ : {#one}, _ : { oldField : Nat; newField: Text }) : async { } {
+      loop {};
+   };
+   stable let x2 = f2;
+};
diff --git a/test/run-drun/function-upgrades/version2.mo b/test/run-drun/function-upgrades/version2.mo
new file mode 100644
index 00000000000..2f1da5cc8b7
--- /dev/null
+++ b/test/run-drun/function-upgrades/version2.mo
@@ -0,0 +1,6 @@
+actor {
+   public shared func f2(_ : {#one; #three}, _ : { oldField : Nat; newField: Text }) : async { } {
+      loop {};
+   };
+   stable let x2 = f2;
+};
diff --git a/test/run-drun/function-upgrades/version3.mo b/test/run-drun/function-upgrades/version3.mo
new file mode 100644
index 00000000000..6fe5a3ac75c
--- /dev/null
+++ b/test/run-drun/function-upgrades/version3.mo
@@ -0,0 +1,6 @@
+actor {
+   public shared func f2(_ : {#one}, _ : { newField: Text }) : async { } {
+      loop {};
+   };
+   stable let x2 = f2;
+};
diff --git a/test/run-drun/function-upgrades/version4.mo b/test/run-drun/function-upgrades/version4.mo
new file mode 100644
index 00000000000..0503260205c
--- /dev/null
+++ b/test/run-drun/function-upgrades/version4.mo
@@ -0,0 +1,6 @@
+actor {
+   public shared func f2(_ : {#one}, _ : { oldField : Nat; newField: Text }) : async { newField: Bool } {
+      loop {};
+   };
+   stable let x2 = f2;
+};
diff --git a/test/run-drun/ok/function-upgrades.drun.ok b/test/run-drun/ok/function-upgrades.drun.ok
new file mode 100644
index 00000000000..7ac57d684ec
--- /dev/null
+++ b/test/run-drun/ok/function-upgrades.drun.ok
@@ -0,0 +1,15 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Memory-incompatible program upgrade
+debug.print: panic occurred in file 'src/persistence.rs' at line 193
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
+debug.print: Memory-incompatible program upgrade
+debug.print: panic occurred in file 'src/persistence.rs' at line 193
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
+debug.print: Memory-incompatible program upgrade
+debug.print: panic occurred in file 'src/persistence.rs' at line 193
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
+ingress Completed: Reply: 0x4449444c0000

From e797c79d303c7d1dbab4cc53c63fb5c6ad40010a Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 4 Sep 2023 09:14:59 +0200
Subject: [PATCH 094/260] Adjust cache initialization

---
 rts/motoko-rts/src/persistence/compatibility.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rts/motoko-rts/src/persistence/compatibility.rs b/rts/motoko-rts/src/persistence/compatibility.rs
index 873dc401b43..8e3620e5809 100644
--- a/rts/motoko-rts/src/persistence/compatibility.rs
+++ b/rts/motoko-rts/src/persistence/compatibility.rs
@@ -432,7 +432,7 @@ impl CompatibilityChecker {
         source_type_table: TypeTable,
     ) -> CompatibilityChecker {
         let covariance_cache = TypeCheckCache::new(mem, &target_type_table, &source_type_table);
-        let contravariance_cache = TypeCheckCache::new(mem, &source_type_table, &target_type_table);
+        let contravariance_cache = TypeCheckCache::new(mem, &target_type_table, &source_type_table);
         CompatibilityChecker {
             covariance_cache,
             contravariance_cache,

From 5811ea39e001f69883994927472b9c85d58be318 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 4 Sep 2023 09:16:34 +0200
Subject: [PATCH 095/260] Revert cache initialization

---
 rts/motoko-rts/src/persistence/compatibility.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rts/motoko-rts/src/persistence/compatibility.rs b/rts/motoko-rts/src/persistence/compatibility.rs
index 8e3620e5809..873dc401b43 100644
--- a/rts/motoko-rts/src/persistence/compatibility.rs
+++ b/rts/motoko-rts/src/persistence/compatibility.rs
@@ -432,7 +432,7 @@ impl CompatibilityChecker {
         source_type_table: TypeTable,
     ) -> CompatibilityChecker {
         let covariance_cache = TypeCheckCache::new(mem, &target_type_table, &source_type_table);
-        let contravariance_cache = TypeCheckCache::new(mem, &target_type_table, &source_type_table);
+        let contravariance_cache = TypeCheckCache::new(mem, &source_type_table, &target_type_table);
         CompatibilityChecker {
             covariance_cache,
             contravariance_cache,

From e22be2b15856775d2caf7fab3021f5b27742939e Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 4 Sep 2023 09:45:59 +0200
Subject: [PATCH 096/260] Add unit tests

---
 .../src/persistence/compatibility.rs          | 439 +++++++++++++++++-
 1 file changed, 437 insertions(+), 2 deletions(-)

diff --git a/rts/motoko-rts-tests/src/persistence/compatibility.rs b/rts/motoko-rts-tests/src/persistence/compatibility.rs
index 3502df0216a..456cdfb380d 100644
--- a/rts/motoko-rts-tests/src/persistence/compatibility.rs
+++ b/rts/motoko-rts-tests/src/persistence/compatibility.rs
@@ -1,8 +1,9 @@
 use motoko_rts::memory::{alloc_blob, Memory};
 use motoko_rts::persistence::compatibility::{
     memory_compatible, ACTOR_ENCODING_TAG, ANY_ENCODING_TAG, ARRAY_ENCODING_TAG,
-    MUTABLE_ENCODING_TAG, NONE_ENCODING_TAG, OBJECT_ENCODING_TAG, OPTION_ENCODING_TAG,
-    TUPLE_ENCODING_TAG, VARIANT_ENCODING_TAG,
+    COMPOSITE_FUNCTION_SORT, FUNCTION_ENCODING_TAG, MUTABLE_ENCODING_TAG, NONE_ENCODING_TAG,
+    OBJECT_ENCODING_TAG, OPTION_ENCODING_TAG, QUERY_FUNCTION_SORT, TUPLE_ENCODING_TAG,
+    VARIANT_ENCODING_TAG, WRITE_FUNCTION_SORT,
 };
 use motoko_rts::types::{Bytes, Value};
 use std::hash::Hasher;
@@ -50,6 +51,7 @@ impl BinaryData {
 enum Type {
     Object(FieldList),
     Actor(FieldList),
+    Function(FunctionSignature),
     Mutable(TypeReference),
     Option(TypeReference),
     Array(TypeReference),
@@ -66,6 +68,10 @@ impl Type {
                 output.write_i32(OBJECT_ENCODING_TAG);
                 field_list.serialize(output);
             }
+            Self::Function(function_signature) => {
+                output.write_i32(FUNCTION_ENCODING_TAG);
+                function_signature.serialize(output);
+            }
             Self::Mutable(type_reference) => {
                 output.write_i32(MUTABLE_ENCODING_TAG);
                 output.write_i32(type_reference.index);
@@ -100,6 +106,38 @@ impl Type {
     }
 }
 
+#[derive(Clone)]
+enum FunctionSort {
+    Query,
+    Write,
+    Composite,
+}
+
+impl FunctionSort {
+    fn serialize(&self, output: &mut BinaryData) {
+        match self {
+            Self::Query => output.write_i32(QUERY_FUNCTION_SORT),
+            Self::Write => output.write_i32(WRITE_FUNCTION_SORT),
+            Self::Composite => output.write_i32(COMPOSITE_FUNCTION_SORT),
+        }
+    }
+}
+
+#[derive(Clone)]
+struct FunctionSignature {
+    sort: FunctionSort,
+    parameter_types: TypeList,
+    return_types: TypeList,
+}
+
+impl FunctionSignature {
+    fn serialize(&self, output: &mut BinaryData) {
+        self.sort.serialize(output);
+        self.parameter_types.serialize(output);
+        self.return_types.serialize(output);
+    }
+}
+
 #[derive(PartialEq, Clone)]
 struct TypeReference {
     index: i32,
@@ -352,6 +390,11 @@ unsafe fn test_sucessful_cases(heap: &mut TestMemory) {
     test_any_to_any(heap);
     test_some_to_any(heap);
     test_none_to_none(heap);
+    test_identical_functions(heap);
+    test_no_return_functions(heap);
+    test_no_parameter_functions(heap);
+    test_covariant_function_results(heap);
+    test_contravariant_parameters(heap);
 }
 
 unsafe fn test_empty_actor(heap: &mut TestMemory) {
@@ -848,6 +891,159 @@ unsafe fn test_none_to_none(heap: &mut TestMemory) {
     assert!(are_compatible(heap, types.clone(), types.clone()));
 }
 
+unsafe fn test_identical_functions(heap: &mut TestMemory) {
+    let main_actor = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("FunctionField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let parameter_types = TypeList {
+        items: vec![TypeReference::nat(), TypeReference::bool()],
+    };
+    let return_types = TypeList {
+        items: vec![TypeReference::int(), TypeReference::text()],
+    };
+    let sort = FunctionSort::Query;
+    let function = Type::Function(FunctionSignature {
+        sort,
+        parameter_types,
+        return_types,
+    });
+    let types = vec![main_actor, function];
+    assert!(are_compatible(heap, types.clone(), types.clone()));
+}
+
+unsafe fn test_no_return_functions(heap: &mut TestMemory) {
+    let main_actor = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("FunctionField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let parameter_types = TypeList {
+        items: vec![TypeReference::nat(), TypeReference::bool()],
+    };
+    let return_types = TypeList { items: vec![] };
+    let sort = FunctionSort::Composite;
+    let function = Type::Function(FunctionSignature {
+        sort,
+        parameter_types,
+        return_types,
+    });
+    let types = vec![main_actor, function];
+    assert!(are_compatible(heap, types.clone(), types.clone()));
+}
+
+unsafe fn test_no_parameter_functions(heap: &mut TestMemory) {
+    let main_actor = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("FunctionField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let parameter_types = TypeList { items: vec![] };
+    let return_types = TypeList {
+        items: vec![TypeReference::float()],
+    };
+    let sort = FunctionSort::Write;
+    let function = Type::Function(FunctionSignature {
+        sort,
+        parameter_types,
+        return_types,
+    });
+    let types = vec![main_actor, function];
+    assert!(are_compatible(heap, types.clone(), types.clone()));
+}
+
+unsafe fn test_covariant_function_results(heap: &mut TestMemory) {
+    let main_actor = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("FunctionField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let parameter_types = TypeList {
+        items: vec![TypeReference::nat(), TypeReference::bool()],
+    };
+    let return_types = TypeList {
+        items: vec![TypeReference { index: 2 }],
+    };
+    let sort = FunctionSort::Composite;
+    let function = Type::Function(FunctionSignature {
+        sort,
+        parameter_types,
+        return_types,
+    });
+
+    let field1 = Field {
+        name: String::from("Field1"),
+        field_type: TypeReference::int8(),
+    };
+    let field2 = Field {
+        name: String::from("Field2"),
+        field_type: TypeReference::int16(),
+    };
+    let field3 = Field {
+        name: String::from("Field3"),
+        field_type: TypeReference::int32(),
+    };
+
+    let old_object = Type::Actor(FieldList {
+        fields: vec![field1.clone(), field2.clone(), field3.clone()],
+    });
+    let new_object = Type::Actor(FieldList {
+        fields: vec![field2.clone()],
+    });
+
+    let old_types = vec![main_actor.clone(), function.clone(), old_object];
+    let new_types = vec![main_actor.clone(), function.clone(), new_object];
+    assert!(are_compatible(heap, old_types, new_types));
+}
+
+unsafe fn test_contravariant_parameters(heap: &mut TestMemory) {
+    let main_actor = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("FunctionField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let parameter_types = TypeList {
+        items: vec![TypeReference { index: 2 }],
+    };
+    let return_types = TypeList { items: vec![] };
+    let sort = FunctionSort::Composite;
+    let function = Type::Function(FunctionSignature {
+        sort,
+        parameter_types,
+        return_types,
+    });
+
+    let field1 = Field {
+        name: String::from("Field1"),
+        field_type: TypeReference::int8(),
+    };
+    let field2 = Field {
+        name: String::from("Field2"),
+        field_type: TypeReference::int16(),
+    };
+    let field3 = Field {
+        name: String::from("Field3"),
+        field_type: TypeReference::int32(),
+    };
+
+    let old_object = Type::Actor(FieldList {
+        fields: vec![field2.clone()],
+    });
+    let new_object = Type::Actor(FieldList {
+        fields: vec![field1.clone(), field2.clone(), field3.clone()],
+    });
+
+    let old_types = vec![main_actor.clone(), function.clone(), old_object];
+    let new_types = vec![main_actor.clone(), function.clone(), new_object];
+    assert!(are_compatible(heap, old_types, new_types));
+}
+
 unsafe fn test_failing_cases(heap: &mut TestMemory) {
     test_added_object_fields(heap);
     test_added_actor_fields(heap);
@@ -863,6 +1059,13 @@ unsafe fn test_failing_cases(heap: &mut TestMemory) {
     test_removed_variant_fields(heap);
     test_any_to_some(heap);
     test_any_to_none(heap);
+    test_mismatching_function_sort(heap);
+    test_mismatching_parameters(heap);
+    test_mismatching_parameter_count(heap);
+    test_mismatching_return_types(heap);
+    test_mismatching_return_count(heap);
+    test_invalid_result_variance(heap);
+    test_invalid_parameter_variance(heap);
 }
 
 unsafe fn test_recursion_mismatch(heap: &mut TestMemory) {
@@ -1182,3 +1385,235 @@ unsafe fn test_any_to_none(heap: &mut TestMemory) {
     let new_types = vec![new_actor, none_type];
     assert!(!are_compatible(heap, old_types, new_types));
 }
+
+unsafe fn test_mismatching_function_sort(heap: &mut TestMemory) {
+    let main_actor = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("FunctionField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let parameter_types = TypeList {
+        items: vec![TypeReference::nat()],
+    };
+    let return_types = TypeList {
+        items: vec![TypeReference::int()],
+    };
+    let old_function = Type::Function(FunctionSignature {
+        sort: FunctionSort::Query,
+        parameter_types: parameter_types.clone(),
+        return_types: return_types.clone(),
+    });
+    let new_function = Type::Function(FunctionSignature {
+        sort: FunctionSort::Write,
+        parameter_types: parameter_types.clone(),
+        return_types: return_types.clone(),
+    });
+    let old_types = vec![main_actor.clone(), old_function];
+    let new_types = vec![main_actor.clone(), new_function];
+    assert!(!are_compatible(heap, old_types, new_types));
+}
+
+unsafe fn test_mismatching_parameters(heap: &mut TestMemory) {
+    let main_actor = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("FunctionField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let old_parameter_types = TypeList {
+        items: vec![TypeReference::nat()],
+    };
+    let new_parameter_types = TypeList {
+        items: vec![TypeReference::text()],
+    };
+    let return_types = TypeList {
+        items: vec![TypeReference::int()],
+    };
+    let sort = FunctionSort::Query;
+    let old_function = Type::Function(FunctionSignature {
+        sort: sort.clone(),
+        parameter_types: old_parameter_types,
+        return_types: return_types.clone(),
+    });
+    let new_function = Type::Function(FunctionSignature {
+        sort: sort.clone(),
+        parameter_types: new_parameter_types,
+        return_types: return_types.clone(),
+    });
+    let old_types = vec![main_actor.clone(), old_function];
+    let new_types = vec![main_actor.clone(), new_function];
+    assert!(!are_compatible(heap, old_types, new_types));
+}
+
+unsafe fn test_mismatching_parameter_count(heap: &mut TestMemory) {
+    let main_actor = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("FunctionField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let old_parameter_types = TypeList {
+        items: vec![TypeReference::nat()],
+    };
+    let new_parameter_types = TypeList { items: vec![] };
+    let return_types = TypeList {
+        items: vec![TypeReference::int()],
+    };
+    let sort = FunctionSort::Query;
+    let old_function = Type::Function(FunctionSignature {
+        sort: sort.clone(),
+        parameter_types: old_parameter_types,
+        return_types: return_types.clone(),
+    });
+    let new_function = Type::Function(FunctionSignature {
+        sort: sort.clone(),
+        parameter_types: new_parameter_types,
+        return_types: return_types.clone(),
+    });
+    let old_types = vec![main_actor.clone(), old_function];
+    let new_types = vec![main_actor.clone(), new_function];
+    assert!(!are_compatible(heap, old_types, new_types));
+}
+
+unsafe fn test_mismatching_return_types(heap: &mut TestMemory) {
+    let main_actor = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("FunctionField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let parameter_types = TypeList {
+        items: vec![TypeReference::nat()],
+    };
+    let old_return_types = TypeList {
+        items: vec![TypeReference::int()],
+    };
+    let new_return_types = TypeList {
+        items: vec![TypeReference::text()],
+    };
+    let sort = FunctionSort::Query;
+    let old_function = Type::Function(FunctionSignature {
+        sort: sort.clone(),
+        parameter_types: parameter_types.clone(),
+        return_types: old_return_types,
+    });
+    let new_function = Type::Function(FunctionSignature {
+        sort: sort.clone(),
+        parameter_types: parameter_types.clone(),
+        return_types: new_return_types,
+    });
+    let old_types = vec![main_actor.clone(), old_function];
+    let new_types = vec![main_actor.clone(), new_function];
+    assert!(!are_compatible(heap, old_types, new_types));
+}
+
+unsafe fn test_mismatching_return_count(heap: &mut TestMemory) {
+    let main_actor = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("FunctionField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let parameter_types = TypeList {
+        items: vec![TypeReference::nat()],
+    };
+    let old_return_types = TypeList {
+        items: vec![TypeReference::int()],
+    };
+    let new_return_types = TypeList { items: vec![] };
+    let sort = FunctionSort::Query;
+    let old_function = Type::Function(FunctionSignature {
+        sort: sort.clone(),
+        parameter_types: parameter_types.clone(),
+        return_types: old_return_types,
+    });
+    let new_function = Type::Function(FunctionSignature {
+        sort: sort.clone(),
+        parameter_types: parameter_types.clone(),
+        return_types: new_return_types,
+    });
+    let old_types = vec![main_actor.clone(), old_function];
+    let new_types = vec![main_actor.clone(), new_function];
+    assert!(!are_compatible(heap, old_types, new_types));
+}
+
+unsafe fn test_invalid_result_variance(heap: &mut TestMemory) {
+    let main_actor = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("FunctionField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let parameter_types = TypeList {
+        items: vec![TypeReference::nat(), TypeReference::bool()],
+    };
+    let return_types = TypeList {
+        items: vec![TypeReference { index: 2 }],
+    };
+    let sort = FunctionSort::Composite;
+    let function = Type::Function(FunctionSignature {
+        sort,
+        parameter_types,
+        return_types,
+    });
+
+    let field1 = Field {
+        name: String::from("Field1"),
+        field_type: TypeReference::int8(),
+    };
+    let field2 = Field {
+        name: String::from("Field2"),
+        field_type: TypeReference::int16(),
+    };
+
+    let old_object = Type::Actor(FieldList {
+        fields: vec![field1.clone()],
+    });
+    let new_object = Type::Actor(FieldList {
+        fields: vec![field1.clone(), field2.clone()],
+    });
+
+    let old_types = vec![main_actor.clone(), function.clone(), old_object];
+    let new_types = vec![main_actor.clone(), function.clone(), new_object];
+    assert!(!are_compatible(heap, old_types, new_types));
+}
+
+unsafe fn test_invalid_parameter_variance(heap: &mut TestMemory) {
+    let main_actor = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("FunctionField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let parameter_types = TypeList {
+        items: vec![TypeReference { index: 2 }],
+    };
+    let return_types = TypeList { items: vec![] };
+    let sort = FunctionSort::Composite;
+    let function = Type::Function(FunctionSignature {
+        sort,
+        parameter_types,
+        return_types,
+    });
+
+    let field1 = Field {
+        name: String::from("Field1"),
+        field_type: TypeReference::int8(),
+    };
+    let field2 = Field {
+        name: String::from("Field2"),
+        field_type: TypeReference::int16(),
+    };
+
+    let old_object = Type::Actor(FieldList {
+        fields: vec![field1.clone(), field2.clone()],
+    });
+    let new_object = Type::Actor(FieldList {
+        fields: vec![field2.clone()],
+    });
+
+    let old_types = vec![main_actor.clone(), function.clone(), old_object];
+    let new_types = vec![main_actor.clone(), function.clone(), new_object];
+    assert!(!are_compatible(heap, old_types, new_types));
+}

From 23b54afccb2c1129faf99dd54dd838bd1995313c Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 4 Sep 2023 09:59:26 +0200
Subject: [PATCH 097/260] Support `Nat` to `Int` compatibility

---
 .../src/persistence/compatibility.rs          |  6 +++++-
 .../src/persistence/compatibility.rs          |  6 ++++++
 test/run-drun/ok/upgrade-nat-to-int.drun.ok   | 20 +++++++++++++++++++
 test/run-drun/upgrade-nat-to-int.drun         | 14 +++++++++++++
 test/run-drun/upgrade-nat-to-int/version0.mo  | 13 ++++++++++++
 test/run-drun/upgrade-nat-to-int/version1.mo  | 13 ++++++++++++
 6 files changed, 71 insertions(+), 1 deletion(-)
 create mode 100644 test/run-drun/ok/upgrade-nat-to-int.drun.ok
 create mode 100644 test/run-drun/upgrade-nat-to-int.drun
 create mode 100644 test/run-drun/upgrade-nat-to-int/version0.mo
 create mode 100644 test/run-drun/upgrade-nat-to-int/version1.mo

diff --git a/rts/motoko-rts-tests/src/persistence/compatibility.rs b/rts/motoko-rts-tests/src/persistence/compatibility.rs
index 456cdfb380d..ed9d17e667d 100644
--- a/rts/motoko-rts-tests/src/persistence/compatibility.rs
+++ b/rts/motoko-rts-tests/src/persistence/compatibility.rs
@@ -361,7 +361,11 @@ unsafe fn test_primitive_types(heap: &mut TestMemory) {
     ];
     for first in &all_types {
         for second in &all_types {
-            assert_eq!(is_compatible(first, second), first == second);
+            assert_eq!(
+                is_compatible(first, second),
+                first == second
+                    || first == &TypeReference::nat() && second == &TypeReference::int()
+            );
         }
     }
 }
diff --git a/rts/motoko-rts/src/persistence/compatibility.rs b/rts/motoko-rts/src/persistence/compatibility.rs
index 873dc401b43..c42916902e8 100644
--- a/rts/motoko-rts/src/persistence/compatibility.rs
+++ b/rts/motoko-rts/src/persistence/compatibility.rs
@@ -104,6 +104,9 @@ const LENGTH_HEADER: usize = 1;
 const TYPE_INDEX_LENGTH: usize = 1;
 const FIELD_ENCODING_LENGTH: usize = 2; // label_hash type_index
 
+const NAT_TYPE_INDEX: i32 = -3;
+const INT_TYPE_INDEX: i32 = -8;
+
 struct EncodedData {
     words: *const i32,
     size: usize,
@@ -588,6 +591,9 @@ impl CompatibilityChecker {
         if target_type_index == source_type_index {
             return true;
         }
+        if target_type_index == INT_TYPE_INDEX && source_type_index == NAT_TYPE_INDEX {
+            return true;
+        }
         if target_type_index >= 0 {
             if let Type::Any = self.target_type_table.get_type(target_type_index) {
                 return true;
diff --git a/test/run-drun/ok/upgrade-nat-to-int.drun.ok b/test/run-drun/ok/upgrade-nat-to-int.drun.ok
new file mode 100644
index 00000000000..ceac73f50b1
--- /dev/null
+++ b/test/run-drun/ok/upgrade-nat-to-int.drun.ok
@@ -0,0 +1,20 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 1
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 2
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 0
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: -2
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Memory-incompatible program upgrade
+debug.print: panic occurred in file 'src/persistence.rs' at line 193
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
diff --git a/test/run-drun/upgrade-nat-to-int.drun b/test/run-drun/upgrade-nat-to-int.drun
new file mode 100644
index 00000000000..916b550f9da
--- /dev/null
+++ b/test/run-drun/upgrade-nat-to-int.drun
@@ -0,0 +1,14 @@
+# SKIP ic-ref-run
+install $ID upgrade-nat-to-int/version0.mo ""
+ingress $ID modify "DIDL\x00\x00"
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID upgrade-nat-to-int/version0.mo ""
+ingress $ID modify "DIDL\x00\x00"
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID upgrade-nat-to-int/version1.mo ""
+ingress $ID modify "DIDL\x00\x00"
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID upgrade-nat-to-int/version1.mo ""
+ingress $ID modify "DIDL\x00\x00"
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID upgrade-nat-to-int/version0.mo ""
diff --git a/test/run-drun/upgrade-nat-to-int/version0.mo b/test/run-drun/upgrade-nat-to-int/version0.mo
new file mode 100644
index 00000000000..53f13ea1874
--- /dev/null
+++ b/test/run-drun/upgrade-nat-to-int/version0.mo
@@ -0,0 +1,13 @@
+import Prim "mo:prim";
+
+actor {
+   stable var number : Nat = 0;
+
+   public func modify() : async () {
+      number += 1;
+   };
+
+   public func print() : async () {
+      Prim.debugPrint(debug_show (number));
+   };
+};
diff --git a/test/run-drun/upgrade-nat-to-int/version1.mo b/test/run-drun/upgrade-nat-to-int/version1.mo
new file mode 100644
index 00000000000..0c20ef697c4
--- /dev/null
+++ b/test/run-drun/upgrade-nat-to-int/version1.mo
@@ -0,0 +1,13 @@
+import Prim "mo:prim";
+
+actor {
+   stable var number : Int = -123;
+
+   public func modify() : async () {
+      number -= 2;
+   };
+
+   public func print() : async () {
+      Prim.debugPrint(debug_show (number));
+   };
+};

From 0eb283c7273536922f20b58ef51758c16179820f Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 4 Sep 2023 10:37:24 +0200
Subject: [PATCH 098/260] Fix contravariance check

---
 .../src/persistence/compatibility.rs          | 55 +++++++++++++++++++
 .../src/persistence/compatibility.rs          |  2 +-
 2 files changed, 56 insertions(+), 1 deletion(-)

diff --git a/rts/motoko-rts-tests/src/persistence/compatibility.rs b/rts/motoko-rts-tests/src/persistence/compatibility.rs
index ed9d17e667d..a2de16501c9 100644
--- a/rts/motoko-rts-tests/src/persistence/compatibility.rs
+++ b/rts/motoko-rts-tests/src/persistence/compatibility.rs
@@ -399,6 +399,7 @@ unsafe fn test_sucessful_cases(heap: &mut TestMemory) {
     test_no_parameter_functions(heap);
     test_covariant_function_results(heap);
     test_contravariant_parameters(heap);
+    test_different_type_counts(heap);
 }
 
 unsafe fn test_empty_actor(heap: &mut TestMemory) {
@@ -1048,6 +1049,60 @@ unsafe fn test_contravariant_parameters(heap: &mut TestMemory) {
     assert!(are_compatible(heap, old_types, new_types));
 }
 
+unsafe fn test_different_type_counts(heap: &mut TestMemory) {
+    let main_actor = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("FunctionField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let sort = FunctionSort::Composite;
+    let old_function = Type::Function(FunctionSignature {
+        sort: sort.clone(),
+        parameter_types: TypeList {
+            items: vec![TypeReference { index: 2 }],
+        },
+        return_types: TypeList { items: vec![] },
+    });
+    let new_function = Type::Function(FunctionSignature {
+        sort: sort.clone(),
+        parameter_types: TypeList {
+            items: vec![TypeReference { index: 4 }],
+        },
+        return_types: TypeList { items: vec![] },
+    });
+    let field1 = Field {
+        name: String::from("Field1"),
+        field_type: TypeReference::int8(),
+    };
+    let field2 = Field {
+        name: String::from("Field2"),
+        field_type: TypeReference::int16(),
+    };
+    let field3 = Field {
+        name: String::from("Field3"),
+        field_type: TypeReference::int32(),
+    };
+
+    let old_object = Type::Actor(FieldList {
+        fields: vec![field2.clone()],
+    });
+    let new_object = Type::Actor(FieldList {
+        fields: vec![field1.clone(), field2.clone(), field3.clone()],
+    });
+    let unused_type = Type::None;
+
+    let old_types = vec![main_actor.clone(), old_function, old_object];
+    let new_types = vec![
+        main_actor.clone(),
+        new_function,
+        unused_type.clone(),
+        unused_type.clone(),
+        new_object,
+    ];
+    assert!(are_compatible(heap, old_types, new_types));
+}
+
 unsafe fn test_failing_cases(heap: &mut TestMemory) {
     test_added_object_fields(heap);
     test_added_actor_fields(heap);
diff --git a/rts/motoko-rts/src/persistence/compatibility.rs b/rts/motoko-rts/src/persistence/compatibility.rs
index c42916902e8..3601d8ce66a 100644
--- a/rts/motoko-rts/src/persistence/compatibility.rs
+++ b/rts/motoko-rts/src/persistence/compatibility.rs
@@ -556,7 +556,7 @@ impl CompatibilityChecker {
         target_type_index: i32,
     ) -> bool {
         self.flip_variance();
-        let result = self.type_compatible(target_type_index, source_type_index);
+        let result = self.type_compatible(source_type_index, target_type_index);
         self.flip_variance();
         result
     }

From 12af096b68e048a5f20014344865fb71b8a2cefb Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 4 Sep 2023 13:36:48 +0200
Subject: [PATCH 099/260] Revert test case changes

---
 test/run-drun/class-import.mo               | 24 +++++++++++++++------
 test/run-drun/class-import/empty.mo         |  9 ++++++++
 test/run-drun/class-import/two.mo           | 10 +++++++++
 test/run-drun/ok/class-import.drun-run.ok   |  4 ++++
 test/run-drun/ok/class-import.ic-ref-run.ok |  4 ++++
 5 files changed, 45 insertions(+), 6 deletions(-)
 create mode 100644 test/run-drun/class-import/empty.mo
 create mode 100644 test/run-drun/class-import/two.mo

diff --git a/test/run-drun/class-import.mo b/test/run-drun/class-import.mo
index ad46fc9d203..cad8c448449 100644
--- a/test/run-drun/class-import.mo
+++ b/test/run-drun/class-import.mo
@@ -1,9 +1,9 @@
 import Prim "mo:⛔";
 import Cycles = "cycles/cycles";
+import M0 "class-import/empty";
 import M1 "class-import/one";
-import M2 "class-import/trap";
-// Too many class imports exceed the maximum data segment size of 2MB,
-// in particular if they are compiled with sanity checks.
+import M2 "class-import/two";
+import M3 "class-import/trap";
 
 actor a {
  public func go() : async () {
@@ -11,15 +11,25 @@ actor a {
    if (Cycles.balance() == 0)
      await Cycles.provisional_top_up_actor(a, 100_000_000_000_000);
 
+   // test no arg class
+   Cycles.add(2_000_000_000_000);
+   let empty : M0.Empty = await M0.Empty();
+   await empty.test();
+
    // test single arg class
    Cycles.add(2_000_000_000_000);
    let one : M1.One = await M1.One("one");
    await one.test();
 
+   // test two arg class
+   Cycles.add(2_000_000_000_000);
+   let two : M2.Two = await M2.Two("one","two");
+   await two.test();
+
    // test non-trapping install
    try {
      Cycles.add(2_000_000_000_000);
-     let trap : M2.Trap = await M2.Trap(false);
+     let trap : M3.Trap = await M3.Trap(false);
    }
    catch _ {
      assert false;
@@ -28,7 +38,7 @@ actor a {
    // test trapping install
    try {
      Cycles.add(2_000_000_000_000);
-     let trap : M2.Trap = await M2.Trap(true);
+     let trap : M3.Trap = await M3.Trap(true);
      assert false;
    }
    catch _ {
@@ -44,7 +54,9 @@ a.go() //OR-CALL ingress go "DIDL\x00\x00"
 //SKIP run-ir
 //SKIP run-low
 
-// check exactly 2 embedded wasms
+// check exactly 4 embedded wasms
+//CHECK:  canister_update __motoko_async_helper
+//CHECK:  canister_update __motoko_async_helper
 //CHECK:  canister_update __motoko_async_helper
 //CHECK:  canister_update __motoko_async_helper
 //CHECK:  canister_update __motoko_async_helper
diff --git a/test/run-drun/class-import/empty.mo b/test/run-drun/class-import/empty.mo
new file mode 100644
index 00000000000..92d87ed151f
--- /dev/null
+++ b/test/run-drun/class-import/empty.mo
@@ -0,0 +1,9 @@
+import Prim "mo:⛔";
+actor class Empty() {
+
+  Prim.debugPrint("empty");
+
+  public func test() : async () {
+    Prim.debugPrint(debug_show () # " tested");
+  };
+}
diff --git a/test/run-drun/class-import/two.mo b/test/run-drun/class-import/two.mo
new file mode 100644
index 00000000000..1c542d68747
--- /dev/null
+++ b/test/run-drun/class-import/two.mo
@@ -0,0 +1,10 @@
+import Prim "mo:⛔";
+shared actor class Two(a : Text, b : Text) {
+
+   Prim.debugPrint(debug_show((a,b)));
+
+   public func test() : async () {
+      Prim.debugPrint(debug_show((a,b)) # "tested");
+   };
+
+}
diff --git a/test/run-drun/ok/class-import.drun-run.ok b/test/run-drun/ok/class-import.drun-run.ok
index f50ded8fc03..d6c7ff9471d 100644
--- a/test/run-drun/ok/class-import.drun-run.ok
+++ b/test/run-drun/ok/class-import.drun-run.ok
@@ -1,6 +1,10 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
+debug.print: empty
+debug.print: () tested
 debug.print: one
 debug.print: "one" tested
+debug.print: ("one", "two")
+debug.print: ("one", "two")tested
 debug.print: caught trap
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/class-import.ic-ref-run.ok b/test/run-drun/ok/class-import.ic-ref-run.ok
index e75f640176b..96aaf64f1b2 100644
--- a/test/run-drun/ok/class-import.ic-ref-run.ok
+++ b/test/run-drun/ok/class-import.ic-ref-run.ok
@@ -3,7 +3,11 @@
 => update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
 <= replied: ()
 => update go()
+debug.print: empty
+debug.print: () tested
 debug.print: one
 debug.print: "one" tested
+debug.print: ("one", "two")
+debug.print: ("one", "two")tested
 debug.print: caught trap
 <= replied: ()

From 95ef9fc7b58161e76b4aa153b66e1878080c42c9 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 4 Sep 2023 13:41:07 +0200
Subject: [PATCH 100/260] Increase reserved data segment section

---
 rts/motoko-rts/src/persistence.rs | 4 ++--
 src/linking/linkModule.ml         | 7 ++++---
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/rts/motoko-rts/src/persistence.rs b/rts/motoko-rts/src/persistence.rs
index b9960baa6c7..8ed646959dc 100644
--- a/rts/motoko-rts/src/persistence.rs
+++ b/rts/motoko-rts/src/persistence.rs
@@ -1,6 +1,6 @@
 //! Orthogonal persistence support
 //!
-//! Persistent metadata table, located at 4MB, in the static partition space.
+//! Persistent metadata table, located at 6MB, in the static partition space.
 
 pub mod compatibility;
 
@@ -49,7 +49,7 @@ struct PersistentMetadata {
 }
 
 /// Location of the persistent metadata. Prereseved and fixed forever.
-const METATDATA_ADDRESS: usize = 4 * 1024 * 1024;
+const METATDATA_ADDRESS: usize = 6 * 1024 * 1024;
 /// The reserved maximum size of the metadata, contains a reserve for future extension of the metadata.
 const METADATA_RESERVE: usize = 128 * 1024;
 
diff --git a/src/linking/linkModule.ml b/src/linking/linkModule.ml
index 65d18c9d97b..c78942b6a72 100644
--- a/src/linking/linkModule.ml
+++ b/src/linking/linkModule.ml
@@ -767,9 +767,10 @@ let link (em1 : extended_module) libname (em2 : extended_module) =
   let lib_heap_start = align dylink.memory_alignment old_heap_start in
   let new_heap_start = align 4l (Int32.add lib_heap_start dylink.memory_size) in
 
-  (* Data segments must fit below 4MB according to the persistent heap layout. *)
-  (if (Int32.to_int new_heap_start) > 4 * 1024 * 1024 then
-    (raise (TooLargeDataSegments "The Wasm data segment size exceeds the supported maxmimum of 2MB."))
+  (* Data segments must fit below 6MB according to the persistent heap layout. 
+     The first 2MB are reserved for the Rust call stacks such that data segments are limited to 4MB. *)
+  (if (Int32.to_int new_heap_start) > 6 * 1024 * 1024 then
+    (raise (TooLargeDataSegments "The Wasm data segment size exceeds the supported maxmimum of 4MB."))
   else
     ()
   );

From de7600a4a8c60b3c78b91da482eb4c3bf6af7282 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 4 Sep 2023 15:11:02 +0200
Subject: [PATCH 101/260] Migrate from old serialization

---
 src/codegen/compile.ml                        | 102 ++++++++--------
 test/run-drun/forward-migration.drun          |  13 ++
 .../forward-migration/new-stabilization.mo    |  48 ++++++++
 test/run-drun/ok/forward-migration.drun.ok    | 113 ++++++++++++++++++
 4 files changed, 222 insertions(+), 54 deletions(-)
 create mode 100644 test/run-drun/forward-migration.drun
 create mode 100644 test/run-drun/forward-migration/new-stabilization.mo
 create mode 100644 test/run-drun/ok/forward-migration.drun.ok

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 359c8e5fe68..97580a0a3cb 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -6777,57 +6777,6 @@ end (* MakeSerialization *)
 
 module Serialization = MakeSerialization(BumpStream)
 
-module Stabilization = struct
-  let restore_stable_memory env =
-    (* TODO: Check version and if needed, migrate from old serialized stable format. *)
-    IC.system_call env "stable64_size" ^^
-    StableMem.set_mem_size env
-
-  let load_stable_actor env = E.call_import env "rts" "load_stable_actor"
-    
-  let save_stable_actor env = E.call_import env "rts" "save_stable_actor"
-
-  let register_stable_type env actor_type =
-    let type_descriptor = Persistence.encode_stable_type actor_type in
-    Blob.lit env type_descriptor ^^
-    E.call_import env "rts" "register_stable_type"
-
-  let create_actor env actor_type get_field_value =
-    let (_, field_declarations) = Type.as_obj actor_type in
-    let field_initializers = List.map
-      (fun field -> (field.Type.lab, fun () -> (get_field_value field.Type.lab)))
-      field_declarations
-    in
-    Object.lit_raw env field_initializers
-
-  let empty_actor env actor_type =
-    create_actor env actor_type (fun _ ->  Opt.null_lit env)
-
-  let recover_actor env actor_type =
-    let recover_field field = 
-      load_stable_actor env ^^
-      Object.contains_field env field ^^
-      (G.if1 I32Type
-        (load_stable_actor env ^^ Object.load_idx_raw env field)
-        (Opt.null_lit env)
-      ) in
-    create_actor env actor_type recover_field
-
-  let stabilize env actor_type =
-    save_stable_actor env
-
-  let destabilize env actor_type =
-    register_stable_type env actor_type ^^
-    load_stable_actor env ^^
-    G.i (Test (Wasm.Values.I32 I32Op.Eqz)) ^^
-    (G.if1 I32Type
-      (empty_actor env actor_type)
-      (recover_actor env actor_type)
-    ) ^^
-    restore_stable_memory env
-end
-
-(*
 (* OldStabilization as migration code: 
   Deserializing a last time from explicit stable memory into the stable heap:
    * stable variables; and
@@ -6836,7 +6785,6 @@ end
    * ../../design/Stable.md
    * ../../design/StableMemory.md
 *)
-
 module OldStabilization = struct
   (* start from 1 to avoid accidental reads of 0 *)
   let stable_memory_version = Int32.of_int 1
@@ -6900,7 +6848,7 @@ module OldStabilization = struct
         compile_add_const Heap.word_size ^^
         set_ptr))
 
-  let _destabilize env ty =
+  let old_destabilize env ty =
     match E.mode env with
     | Flags.ICMode | Flags.RefMode ->
       let (set_pages, get_pages) = new_local64 env "pages" in
@@ -7028,7 +6976,53 @@ module OldStabilization = struct
         end
     | _ -> assert false
 end
-*)
+
+module Stabilization = struct
+  let restore_stable_memory env =
+    (* TODO: Check version and if needed, migrate from old serialized stable format. *)
+    IC.system_call env "stable64_size" ^^
+    StableMem.set_mem_size env
+
+  let load_stable_actor env = E.call_import env "rts" "load_stable_actor"
+    
+  let save_stable_actor env = E.call_import env "rts" "save_stable_actor"
+
+  let register_stable_type env actor_type =
+    let type_descriptor = Persistence.encode_stable_type actor_type in
+    Blob.lit env type_descriptor ^^
+    E.call_import env "rts" "register_stable_type"
+
+  let create_actor env actor_type get_field_value =
+    let (_, field_declarations) = Type.as_obj actor_type in
+    let field_initializers = List.map
+      (fun field -> (field.Type.lab, fun () -> (get_field_value field.Type.lab)))
+      field_declarations
+    in
+    Object.lit_raw env field_initializers
+
+  let recover_actor env actor_type =
+    let recover_field field = 
+      load_stable_actor env ^^
+      Object.contains_field env field ^^
+      (G.if1 I32Type
+        (load_stable_actor env ^^ Object.load_idx_raw env field)
+        (Opt.null_lit env)
+      ) in
+    create_actor env actor_type recover_field
+
+  let stabilize env actor_type =
+    save_stable_actor env
+
+  let destabilize env actor_type =
+    register_stable_type env actor_type ^^
+    load_stable_actor env ^^
+    G.i (Test (Wasm.Values.I32 I32Op.Eqz)) ^^
+    (G.if1 I32Type
+      (OldStabilization.old_destabilize env actor_type)
+      (recover_actor env actor_type)
+    ) ^^
+    restore_stable_memory env
+end
 
 module GCRoots = struct
   let create_root_array env = Func.share_code0 env "create_root_array" [I32Type] (fun env ->
diff --git a/test/run-drun/forward-migration.drun b/test/run-drun/forward-migration.drun
new file mode 100644
index 00000000000..1d41887cae0
--- /dev/null
+++ b/test/run-drun/forward-migration.drun
@@ -0,0 +1,13 @@
+# SKIP ic-ref-run
+install $ID forward-migration/old-stabilization.wasm ""
+ingress $ID populate "DIDL\x00\x00"
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID forward-migration/old-stabilization.wasm ""
+ingress $ID populate "DIDL\x00\x00"
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID forward-migration/new-stabilization.mo ""
+ingress $ID populate "DIDL\x00\x00"
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID forward-migration/new-stabilization.mo ""
+ingress $ID populate "DIDL\x00\x00"
+ingress $ID print "DIDL\x00\x00"
diff --git a/test/run-drun/forward-migration/new-stabilization.mo b/test/run-drun/forward-migration/new-stabilization.mo
new file mode 100644
index 00000000000..8ddef0fc68e
--- /dev/null
+++ b/test/run-drun/forward-migration/new-stabilization.mo
@@ -0,0 +1,48 @@
+import Prim "mo:prim";
+
+actor {
+   type Node<K, V> = ?{ key : K; value : V; var next : Node<K, V> };
+   type List<K, V> = {
+      var first : Node<K, V>;
+      var last : Node<K, V>;
+   };
+   stable let list : List<Nat, Text> = {
+      var first = null;
+      var last = null;
+   };
+   stable var counter = 0;
+
+   func insert<K, V>(list : List<K, V>, key : K, value : V) {
+      let node : Node<K, V> = ?{ key; value; var next = null };
+      switch (list.last) {
+         case null {
+            list.first := node;
+         };
+         case (?previous) {
+            previous.next := node;
+         };
+      };
+      list.last := node;
+   };
+
+   public func populate() : async () {
+      let limit = counter + 10;
+      while (counter < limit) {
+         insert(list, counter, debug_show (counter));
+         counter += 1;
+      };
+   };
+
+   public func print() : async () {
+      var current = list.first;
+      loop {
+         switch current {
+            case null return;
+            case (?node) {
+               Prim.debugPrint(debug_show (node.key) # " " # node.value);
+               current := node.next;
+            };
+         };
+      };
+   };
+};
diff --git a/test/run-drun/ok/forward-migration.drun.ok b/test/run-drun/ok/forward-migration.drun.ok
new file mode 100644
index 00000000000..1b45b19ee2e
--- /dev/null
+++ b/test/run-drun/ok/forward-migration.drun.ok
@@ -0,0 +1,113 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 0 0
+debug.print: 1 1
+debug.print: 2 2
+debug.print: 3 3
+debug.print: 4 4
+debug.print: 5 5
+debug.print: 6 6
+debug.print: 7 7
+debug.print: 8 8
+debug.print: 9 9
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 0 0
+debug.print: 1 1
+debug.print: 2 2
+debug.print: 3 3
+debug.print: 4 4
+debug.print: 5 5
+debug.print: 6 6
+debug.print: 7 7
+debug.print: 8 8
+debug.print: 9 9
+debug.print: 10 10
+debug.print: 11 11
+debug.print: 12 12
+debug.print: 13 13
+debug.print: 14 14
+debug.print: 15 15
+debug.print: 16 16
+debug.print: 17 17
+debug.print: 18 18
+debug.print: 19 19
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: Stable memory error: Aliased at wrong type, expected: M1=?r(key:N,next!:!1,value:t)
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 0 0
+debug.print: 1 1
+debug.print: 2 2
+debug.print: 3 3
+debug.print: 4 4
+debug.print: 5 5
+debug.print: 6 6
+debug.print: 7 7
+debug.print: 8 8
+debug.print: 9 9
+debug.print: 10 10
+debug.print: 11 11
+debug.print: 12 12
+debug.print: 13 13
+debug.print: 14 14
+debug.print: 15 15
+debug.print: 16 16
+debug.print: 17 17
+debug.print: 18 18
+debug.print: 19 19
+debug.print: 20 20
+debug.print: 21 21
+debug.print: 22 22
+debug.print: 23 23
+debug.print: 24 24
+debug.print: 25 25
+debug.print: 26 26
+debug.print: 27 27
+debug.print: 28 28
+debug.print: 29 29
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: Stable memory error: Aliased at wrong type, expected: M1=?r(key:N,next!:!1,value:t)
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 0 0
+debug.print: 1 1
+debug.print: 2 2
+debug.print: 3 3
+debug.print: 4 4
+debug.print: 5 5
+debug.print: 6 6
+debug.print: 7 7
+debug.print: 8 8
+debug.print: 9 9
+debug.print: 10 10
+debug.print: 11 11
+debug.print: 12 12
+debug.print: 13 13
+debug.print: 14 14
+debug.print: 15 15
+debug.print: 16 16
+debug.print: 17 17
+debug.print: 18 18
+debug.print: 19 19
+debug.print: 20 20
+debug.print: 21 21
+debug.print: 22 22
+debug.print: 23 23
+debug.print: 24 24
+debug.print: 25 25
+debug.print: 26 26
+debug.print: 27 27
+debug.print: 28 28
+debug.print: 29 29
+debug.print: 30 30
+debug.print: 31 31
+debug.print: 32 32
+debug.print: 33 33
+debug.print: 34 34
+debug.print: 35 35
+debug.print: 36 36
+debug.print: 37 37
+debug.print: 38 38
+debug.print: 39 39
+ingress Completed: Reply: 0x4449444c0000

From a3b9d768d2f27ab1e5fc8d3c306a616ca7ce4cf1 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 4 Sep 2023 15:26:28 +0200
Subject: [PATCH 102/260] Include missing `wasm` file

---
 test/.gitignore                                |   1 -
 .../forward-migration/old-stabilization.wasm   | Bin 0 -> 599846 bytes
 2 files changed, 1 deletion(-)
 create mode 100644 test/run-drun/forward-migration/old-stabilization.wasm

diff --git a/test/.gitignore b/test/.gitignore
index 0ecb692adfc..dbedeec1b7b 100644
--- a/test/.gitignore
+++ b/test/.gitignore
@@ -15,7 +15,6 @@ _profile_build
 *.diff
 *.wat
 *.wat.stderr
-*.wasm
 *.wasm-run
 *.run
 *.wat-run
diff --git a/test/run-drun/forward-migration/old-stabilization.wasm b/test/run-drun/forward-migration/old-stabilization.wasm
new file mode 100644
index 0000000000000000000000000000000000000000..39a680bebcfd8513c80d60d5072a8a924c09b2d9
GIT binary patch
literal 599846
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%0A&E@Cko
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
z%0D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

literal 0
HcmV?d00001


From 394f8739150aa038b42913168eaf7fdc183d8da9 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 4 Sep 2023 15:42:10 +0200
Subject: [PATCH 103/260] Adjust test case

---
 test/run-drun/forward-migration.drun          |  13 --
 test/run-drun/migrate-stabilization.drun      |  14 +++
 .../new-stabilization.mo                      |   2 +
 .../old-stabilization-source.txt              |   1 +
 .../old-stabilization.wasm                    | Bin 599846 -> 599897 bytes
 test/run-drun/ok/forward-migration.drun.ok    | 113 ------------------
 .../run-drun/ok/migrate-stabilization.drun.ok |   0
 7 files changed, 17 insertions(+), 126 deletions(-)
 delete mode 100644 test/run-drun/forward-migration.drun
 create mode 100644 test/run-drun/migrate-stabilization.drun
 rename test/run-drun/{forward-migration => migrate-stabilization}/new-stabilization.mo (95%)
 create mode 100644 test/run-drun/migrate-stabilization/old-stabilization-source.txt
 rename test/run-drun/{forward-migration => migrate-stabilization}/old-stabilization.wasm (81%)
 delete mode 100644 test/run-drun/ok/forward-migration.drun.ok
 create mode 100644 test/run-drun/ok/migrate-stabilization.drun.ok

diff --git a/test/run-drun/forward-migration.drun b/test/run-drun/forward-migration.drun
deleted file mode 100644
index 1d41887cae0..00000000000
--- a/test/run-drun/forward-migration.drun
+++ /dev/null
@@ -1,13 +0,0 @@
-# SKIP ic-ref-run
-install $ID forward-migration/old-stabilization.wasm ""
-ingress $ID populate "DIDL\x00\x00"
-ingress $ID print "DIDL\x00\x00"
-upgrade $ID forward-migration/old-stabilization.wasm ""
-ingress $ID populate "DIDL\x00\x00"
-ingress $ID print "DIDL\x00\x00"
-upgrade $ID forward-migration/new-stabilization.mo ""
-ingress $ID populate "DIDL\x00\x00"
-ingress $ID print "DIDL\x00\x00"
-upgrade $ID forward-migration/new-stabilization.mo ""
-ingress $ID populate "DIDL\x00\x00"
-ingress $ID print "DIDL\x00\x00"
diff --git a/test/run-drun/migrate-stabilization.drun b/test/run-drun/migrate-stabilization.drun
new file mode 100644
index 00000000000..884157d7a91
--- /dev/null
+++ b/test/run-drun/migrate-stabilization.drun
@@ -0,0 +1,14 @@
+# SKIP ic-ref-run
+install $ID migrate-stabilization/old-stabilization.wasm ""
+ingress $ID populate "DIDL\x00\x00"
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID migrate-stabilization/old-stabilization.wasm ""
+ingress $ID populate "DIDL\x00\x00"
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID migrate-stabilization/new-stabilization.mo ""
+ingress $ID populate "DIDL\x00\x00"
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID migrate-stabilization/new-stabilization.mo ""
+ingress $ID populate "DIDL\x00\x00"
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID migrate-stabilization/old-stabilization.wasm ""
diff --git a/test/run-drun/forward-migration/new-stabilization.mo b/test/run-drun/migrate-stabilization/new-stabilization.mo
similarity index 95%
rename from test/run-drun/forward-migration/new-stabilization.mo
rename to test/run-drun/migrate-stabilization/new-stabilization.mo
index 8ddef0fc68e..c941993cb8f 100644
--- a/test/run-drun/forward-migration/new-stabilization.mo
+++ b/test/run-drun/migrate-stabilization/new-stabilization.mo
@@ -12,6 +12,8 @@ actor {
    };
    stable var counter = 0;
 
+   Prim.debugPrint("INITIALIZED: " # debug_show(counter));
+
    func insert<K, V>(list : List<K, V>, key : K, value : V) {
       let node : Node<K, V> = ?{ key; value; var next = null };
       switch (list.last) {
diff --git a/test/run-drun/migrate-stabilization/old-stabilization-source.txt b/test/run-drun/migrate-stabilization/old-stabilization-source.txt
new file mode 100644
index 00000000000..1f243b469a0
--- /dev/null
+++ b/test/run-drun/migrate-stabilization/old-stabilization-source.txt
@@ -0,0 +1 @@
+old-destabilization.wasm is compiled from `new-destabilzation.mo` with old `moc` compiler using `--sanity-checks`.
diff --git a/test/run-drun/forward-migration/old-stabilization.wasm b/test/run-drun/migrate-stabilization/old-stabilization.wasm
similarity index 81%
rename from test/run-drun/forward-migration/old-stabilization.wasm
rename to test/run-drun/migrate-stabilization/old-stabilization.wasm
index 39a680bebcfd8513c80d60d5072a8a924c09b2d9..4ae5850831a4da754aeb86bb515104dfe363a393 100644
GIT binary patch
delta 34215
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
DzSwNT

delta 34184
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

diff --git a/test/run-drun/ok/forward-migration.drun.ok b/test/run-drun/ok/forward-migration.drun.ok
deleted file mode 100644
index 1b45b19ee2e..00000000000
--- a/test/run-drun/ok/forward-migration.drun.ok
+++ /dev/null
@@ -1,113 +0,0 @@
-ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
-ingress Completed: Reply: 0x4449444c0000
-ingress Completed: Reply: 0x4449444c0000
-debug.print: 0 0
-debug.print: 1 1
-debug.print: 2 2
-debug.print: 3 3
-debug.print: 4 4
-debug.print: 5 5
-debug.print: 6 6
-debug.print: 7 7
-debug.print: 8 8
-debug.print: 9 9
-ingress Completed: Reply: 0x4449444c0000
-ingress Completed: Reply: 0x4449444c0000
-ingress Completed: Reply: 0x4449444c0000
-debug.print: 0 0
-debug.print: 1 1
-debug.print: 2 2
-debug.print: 3 3
-debug.print: 4 4
-debug.print: 5 5
-debug.print: 6 6
-debug.print: 7 7
-debug.print: 8 8
-debug.print: 9 9
-debug.print: 10 10
-debug.print: 11 11
-debug.print: 12 12
-debug.print: 13 13
-debug.print: 14 14
-debug.print: 15 15
-debug.print: 16 16
-debug.print: 17 17
-debug.print: 18 18
-debug.print: 19 19
-ingress Completed: Reply: 0x4449444c0000
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: Stable memory error: Aliased at wrong type, expected: M1=?r(key:N,next!:!1,value:t)
-ingress Completed: Reply: 0x4449444c0000
-debug.print: 0 0
-debug.print: 1 1
-debug.print: 2 2
-debug.print: 3 3
-debug.print: 4 4
-debug.print: 5 5
-debug.print: 6 6
-debug.print: 7 7
-debug.print: 8 8
-debug.print: 9 9
-debug.print: 10 10
-debug.print: 11 11
-debug.print: 12 12
-debug.print: 13 13
-debug.print: 14 14
-debug.print: 15 15
-debug.print: 16 16
-debug.print: 17 17
-debug.print: 18 18
-debug.print: 19 19
-debug.print: 20 20
-debug.print: 21 21
-debug.print: 22 22
-debug.print: 23 23
-debug.print: 24 24
-debug.print: 25 25
-debug.print: 26 26
-debug.print: 27 27
-debug.print: 28 28
-debug.print: 29 29
-ingress Completed: Reply: 0x4449444c0000
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: Stable memory error: Aliased at wrong type, expected: M1=?r(key:N,next!:!1,value:t)
-ingress Completed: Reply: 0x4449444c0000
-debug.print: 0 0
-debug.print: 1 1
-debug.print: 2 2
-debug.print: 3 3
-debug.print: 4 4
-debug.print: 5 5
-debug.print: 6 6
-debug.print: 7 7
-debug.print: 8 8
-debug.print: 9 9
-debug.print: 10 10
-debug.print: 11 11
-debug.print: 12 12
-debug.print: 13 13
-debug.print: 14 14
-debug.print: 15 15
-debug.print: 16 16
-debug.print: 17 17
-debug.print: 18 18
-debug.print: 19 19
-debug.print: 20 20
-debug.print: 21 21
-debug.print: 22 22
-debug.print: 23 23
-debug.print: 24 24
-debug.print: 25 25
-debug.print: 26 26
-debug.print: 27 27
-debug.print: 28 28
-debug.print: 29 29
-debug.print: 30 30
-debug.print: 31 31
-debug.print: 32 32
-debug.print: 33 33
-debug.print: 34 34
-debug.print: 35 35
-debug.print: 36 36
-debug.print: 37 37
-debug.print: 38 38
-debug.print: 39 39
-ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/migrate-stabilization.drun.ok b/test/run-drun/ok/migrate-stabilization.drun.ok
new file mode 100644
index 00000000000..e69de29bb2d

From 7bdd8cd5d6d90f89ecc329dcfcb2275cc27a3849 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 4 Sep 2023 16:00:06 +0200
Subject: [PATCH 104/260] Fix blob comparison in deserialization

---
 src/codegen/compile.ml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 97580a0a3cb..1967fcd6147 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -6124,7 +6124,7 @@ module MakeSerialization (Strm : Stream) = struct
         end begin
           (* Decoded before. Check type hash *)
           ReadBuf.read_word32 env get_data_buf ^^ Blob.lit env (typ_hash t) ^^
-          G.i (Compare (Wasm.Values.I32 I32Op.Eq)) ^^
+          Blob.compare env (Some Operator.EqOp) ^^
           E.else_trap_with env ("Stable memory error: Aliased at wrong type, expected: " ^ typ_hash t)
         end ^^
 

From 9c2736b16ec9cfa0bdc34ea20339b57fdb5a6578 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 4 Sep 2023 21:31:42 +0200
Subject: [PATCH 105/260] Upgrade stable memory version

---
 src/codegen/compile.ml                        | 181 +++++++++++++++---
 .../run-drun/ok/migrate-stabilization.drun.ok | 118 ++++++++++++
 2 files changed, 272 insertions(+), 27 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 1967fcd6147..e7ff6cd98dd 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -632,6 +632,7 @@ let compile_eq_const = function
 let compile_op64_const op i =
     compile_const_64 i ^^
     G.i (Binary (Wasm.Values.I64 op))
+let compile_add64_const = compile_op64_const I64Op.Add
 let compile_sub64_const = compile_op64_const I64Op.Sub
 let compile_mul64_const = compile_op64_const I64Op.Mul
 let _compile_divU64_const = compile_op64_const I64Op.DivU
@@ -712,6 +713,12 @@ let load_unskewed_ptr : G.t =
 let store_unskewed_ptr : G.t =
   G.i (Store {ty = I32Type; align = 2; offset = 0l; sz = None})
 
+let load_unskewed_ptr64 : G.t =
+  G.i (Load {ty = I64Type; align = 2; offset = 0l; sz = None})
+
+let store_unskewed_ptr64 : G.t =
+  G.i (Store {ty = I64Type; align = 2; offset = 0l; sz = None})
+  
 let load_ptr : G.t =
   G.i (Load {ty = I32Type; align = 2; offset = ptr_unskew; sz = None})
 
@@ -4791,6 +4798,18 @@ module StableMem = struct
             IC.system_call env "stable64_write"))
     | _ -> assert false
 
+  let write_word32 env =
+    write env false "word32" I32Type 4l store_unskewed_ptr
+
+  let write_word64 env =
+    write env false "word64" I64Type 8l store_unskewed_ptr64
+
+  let read_word32 env =
+    read env false "word32" I32Type 4l load_unskewed_ptr
+  
+  let read_word64 env =
+    read env false "word64" I64Type 8l load_unskewed_ptr64
+  
   (* ensure_pages : ensure at least num pages allocated,
      growing (real) stable memory if needed *)
   let ensure_pages env =
@@ -4819,6 +4838,35 @@ module StableMem = struct
             get_size)
     | _ -> assert false
 
+      (* ensure stable memory includes [offset..offset+size), assumes size > 0 *)
+  let ensure env =
+    match E.mode env with
+    | Flags.ICMode | Flags.RefMode ->
+      Func.share_code2 env "__stablemem_ensure"
+        (("offset", I64Type), ("size", I64Type)) []
+        (fun env get_offset get_size ->
+          let (set_sum, get_sum) = new_local64 env "sum" in
+          get_offset ^^
+          get_size ^^
+          G.i (Binary (Wasm.Values.I64 I64Op.Add)) ^^
+          set_sum ^^
+          (* check for overflow *)
+          get_sum ^^
+          get_offset ^^
+          G.i (Compare (Wasm.Values.I64 I64Op.LtU)) ^^
+          E.then_trap_with env "Range overflow" ^^
+          (* ensure page *)
+          get_sum ^^
+          compile_const_64 (Int64.of_int page_size_bits) ^^
+          G.i (Binary (Wasm.Values.I64 I64Op.ShrU)) ^^
+          compile_add64_const 1L ^^
+          ensure_pages env ^^
+          (* Check result *)
+          compile_const_64 0L ^^
+          G.i (Compare (Wasm.Values.I64 I64Op.LtS)) ^^
+          E.then_trap_with env "Out of stable memory.")
+    | _ -> assert false
+
   (* API *)
 
   let logical_grow env =
@@ -6786,12 +6834,10 @@ module Serialization = MakeSerialization(BumpStream)
    * ../../design/StableMemory.md
 *)
 module OldStabilization = struct
-  (* start from 1 to avoid accidental reads of 0 *)
-  let stable_memory_version = Int32.of_int 1
+  let old_stable_memory_version = Int32.of_int 1
 
   let extend64 code = code ^^ G.i (Convert (Wasm.Values.I64 I64Op.ExtendUI32))
-  let compile_add64_const = compile_op64_const I64Op.Add
-
+  
   let _read_word32 env =
     StableMem.read env false "word32" I32Type 4l load_unskewed_ptr
   let write_word32 env =
@@ -6898,11 +6944,11 @@ module OldStabilization = struct
 
               (* check version *)
               get_version ^^
-              compile_unboxed_const stable_memory_version ^^
+              compile_unboxed_const old_stable_memory_version ^^
               G.i (Compare (Wasm.Values.I32 I32Op.GtU)) ^^
               E.then_trap_with env (Printf.sprintf
                 "higher stable memory version (expected %s)"
-                (Int32.to_string stable_memory_version)) ^^
+                (Int32.to_string old_stable_memory_version)) ^^
 
               (* restore StableMem bytes [0..4) *)
               compile_const_64 0L ^^
@@ -6977,12 +7023,96 @@ module OldStabilization = struct
     | _ -> assert false
 end
 
-module Stabilization = struct
-  let restore_stable_memory env =
-    (* TODO: Check version and if needed, migrate from old serialized stable format. *)
+(* New stable memory layout.
+   Invalidates old versions operating on the new persistent layout.
+  If size == 0: empty
+  If logical size N > 0:
+    [0..N]          <stable memory>
+            <zero padding>
+    [end-12..end-4] <size N>
+    [end-4..end]    <new version>
+  ending at page boundary
+*)
+module NewStableMemory = struct
+  let new_stable_memory_version = 3l
+
+  let physical_size env =
     IC.system_call env "stable64_size" ^^
-    StableMem.set_mem_size env
+    compile_shl64_const (Int64.of_int page_size_bits)
+
+  let backup env =
+    let (set_total_size, get_total_size) = new_local64 env "total_size" in
+    physical_size env ^^
+    set_total_size ^^
+    get_total_size ^^
+    G.i (Test (Wasm.Values.I64 I64Op.Eqz)) ^^
+    G.if0
+      G.nop
+      begin
+        (* grow logical memory by 12 bytes: 
+           logical size (8 bytes) + new version (4 bytes) *)
+        StableMem.get_mem_size env ^^
+        compile_shl64_const (Int64.of_int page_size_bits) ^^
+        compile_const_64 12L ^^
+        StableMem.ensure env ^^
+
+        (* get the potentially extended physical size *)
+        physical_size env ^^
+        set_total_size ^^
+
+        (* store logical memory size *)
+        get_total_size ^^
+        compile_sub64_const 12L ^^
+        StableMem.get_mem_size env ^^
+        StableMem.write_word64 env ^^
+
+        (* save version *)
+        get_total_size ^^ 
+        compile_sub64_const 4L ^^
+        compile_unboxed_const new_stable_memory_version ^^
+        StableMem.write_word32 env
+      end
+
+  let restore env =
+    let (set_total_size, get_total_size) = new_local64 env "total_size" in
+    physical_size env ^^
+    set_total_size ^^
+    get_total_size ^^
+    G.i (Test (Wasm.Values.I64 I64Op.Eqz)) ^^
+    G.if0
+      begin
+        compile_const_64 0L ^^ StableMem.set_mem_size env
+      end
+      begin
+        (* check the version *)
+        get_total_size ^^
+        compile_sub64_const 4L ^^
+        StableMem.read_word32 env ^^
+        compile_eq_const new_stable_memory_version ^^
+        E.else_trap_with env (Printf.sprintf
+          "unsupported stable memory version (expected %s)"
+           (Int32.to_string new_stable_memory_version)) ^^
+        
+        (* restore logical size *)
+        get_total_size ^^
+        compile_sub64_const 12L ^^
+        StableMem.read_word64 env ^^
+        StableMem.set_mem_size env ^^
+
+        (* clear size and version *)
+        get_total_size ^^
+        compile_sub64_const 12L ^^
+        compile_const_64 0L ^^
+        StableMem.write_word64 env ^^
 
+        get_total_size ^^
+        compile_sub64_const 4L ^^
+        compile_unboxed_const 0l ^^
+        StableMem.write_word32 env 
+      end
+end
+
+module Persistence = struct
   let load_stable_actor env = E.call_import env "rts" "load_stable_actor"
     
   let save_stable_actor env = E.call_import env "rts" "save_stable_actor"
@@ -7010,18 +7140,22 @@ module Stabilization = struct
       ) in
     create_actor env actor_type recover_field
 
-  let stabilize env actor_type =
-    save_stable_actor env
+  let save env actor_type =
+    save_stable_actor env ^^
+    NewStableMemory.backup env
 
-  let destabilize env actor_type =
+  let load env actor_type =
     register_stable_type env actor_type ^^
     load_stable_actor env ^^
     G.i (Test (Wasm.Values.I32 I32Op.Eqz)) ^^
-    (G.if1 I32Type
-      (OldStabilization.old_destabilize env actor_type)
-      (recover_actor env actor_type)
-    ) ^^
-    restore_stable_memory env
+    G.if1 I32Type
+      begin
+        OldStabilization.old_destabilize env actor_type
+      end
+      begin
+        recover_actor env actor_type ^^
+        NewStableMemory.restore env
+      end
 end
 
 module GCRoots = struct
@@ -9771,19 +9905,12 @@ and compile_prim_invocation (env : E.t) ae p es at =
     SR.Vanilla, IC.method_name env
 
   | ICStableRead ty, [] ->
-    (*
-      * On initial install:
-        1. return record of nulls
-      * On upgrade:
-        1. deserialize stable store to v : ty,
-        2. return v
-    *)
     SR.Vanilla,
-    Stabilization.destabilize env ty
+    Persistence.load env ty
   | ICStableWrite ty, [e] ->
     SR.unit,
     compile_exp_vanilla env ae e ^^
-    Stabilization.stabilize env ty
+    Persistence.save env ty
 
   (* Cycles *)
   | SystemCyclesBalancePrim, [] ->
diff --git a/test/run-drun/ok/migrate-stabilization.drun.ok b/test/run-drun/ok/migrate-stabilization.drun.ok
index e69de29bb2d..16ed9383115 100644
--- a/test/run-drun/ok/migrate-stabilization.drun.ok
+++ b/test/run-drun/ok/migrate-stabilization.drun.ok
@@ -0,0 +1,118 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+debug.print: INITIALIZED: 0
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 0 0
+debug.print: 1 1
+debug.print: 2 2
+debug.print: 3 3
+debug.print: 4 4
+debug.print: 5 5
+debug.print: 6 6
+debug.print: 7 7
+debug.print: 8 8
+debug.print: 9 9
+ingress Completed: Reply: 0x4449444c0000
+debug.print: INITIALIZED: 10
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 0 0
+debug.print: 1 1
+debug.print: 2 2
+debug.print: 3 3
+debug.print: 4 4
+debug.print: 5 5
+debug.print: 6 6
+debug.print: 7 7
+debug.print: 8 8
+debug.print: 9 9
+debug.print: 10 10
+debug.print: 11 11
+debug.print: 12 12
+debug.print: 13 13
+debug.print: 14 14
+debug.print: 15 15
+debug.print: 16 16
+debug.print: 17 17
+debug.print: 18 18
+debug.print: 19 19
+ingress Completed: Reply: 0x4449444c0000
+debug.print: INITIALIZED: 20
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 0 0
+debug.print: 1 1
+debug.print: 2 2
+debug.print: 3 3
+debug.print: 4 4
+debug.print: 5 5
+debug.print: 6 6
+debug.print: 7 7
+debug.print: 8 8
+debug.print: 9 9
+debug.print: 10 10
+debug.print: 11 11
+debug.print: 12 12
+debug.print: 13 13
+debug.print: 14 14
+debug.print: 15 15
+debug.print: 16 16
+debug.print: 17 17
+debug.print: 18 18
+debug.print: 19 19
+debug.print: 20 20
+debug.print: 21 21
+debug.print: 22 22
+debug.print: 23 23
+debug.print: 24 24
+debug.print: 25 25
+debug.print: 26 26
+debug.print: 27 27
+debug.print: 28 28
+debug.print: 29 29
+ingress Completed: Reply: 0x4449444c0000
+debug.print: INITIALIZED: 30
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 0 0
+debug.print: 1 1
+debug.print: 2 2
+debug.print: 3 3
+debug.print: 4 4
+debug.print: 5 5
+debug.print: 6 6
+debug.print: 7 7
+debug.print: 8 8
+debug.print: 9 9
+debug.print: 10 10
+debug.print: 11 11
+debug.print: 12 12
+debug.print: 13 13
+debug.print: 14 14
+debug.print: 15 15
+debug.print: 16 16
+debug.print: 17 17
+debug.print: 18 18
+debug.print: 19 19
+debug.print: 20 20
+debug.print: 21 21
+debug.print: 22 22
+debug.print: 23 23
+debug.print: 24 24
+debug.print: 25 25
+debug.print: 26 26
+debug.print: 27 27
+debug.print: 28 28
+debug.print: 29 29
+debug.print: 30 30
+debug.print: 31 31
+debug.print: 32 32
+debug.print: 33 33
+debug.print: 34 34
+debug.print: 35 35
+debug.print: 36 36
+debug.print: 37 37
+debug.print: 38 38
+debug.print: 39 39
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: higher stable memory version (expected 1)

From b26ac995f03492f20c47516545006a0aa80d3d30 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 4 Sep 2023 21:55:47 +0200
Subject: [PATCH 106/260] Code refactoring

---
 src/codegen/compile.ml | 92 +++++++++++++++++++++---------------------
 1 file changed, 47 insertions(+), 45 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index e7ff6cd98dd..fbf3bbc95c8 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -7023,8 +7023,8 @@ module OldStabilization = struct
     | _ -> assert false
 end
 
-(* New stable memory layout.
-   Invalidates old versions operating on the new persistent layout.
+(* New stable memory layout with new version.
+   Prevents forward compatibility of old compiled programs that rely on deserialization.
   If size == 0: empty
   If logical size N > 0:
     [0..N]          <stable memory>
@@ -7040,44 +7040,57 @@ module NewStableMemory = struct
     IC.system_call env "stable64_size" ^^
     compile_shl64_const (Int64.of_int page_size_bits)
 
+  let store_at_end env offset typ get_value =
+    physical_size env ^^
+    compile_sub64_const offset ^^
+    get_value ^^
+    match typ with
+    | I32Type -> StableMem.write_word32 env
+    | I64Type -> StableMem.write_word64 env
+    | _ -> assert false
+
+  let read_from_end env offset typ =
+    physical_size env ^^
+    compile_sub64_const offset ^^
+    match typ with
+    | I32Type -> StableMem.read_word32 env
+    | I64Type -> StableMem.read_word64 env
+    | _ -> assert false
+
+  let clear_at_end env offset typ =
+    store_at_end env offset typ 
+    (match typ with
+    | I32Type -> compile_unboxed_const 0l
+    | I64Type -> compile_const_64 0L
+    | _ -> assert false
+    )
+
+  let logical_size_offset = 12L
+  let version_offset = 4L
+
+  let grow_size env amount =
+    StableMem.get_mem_size env ^^
+    compile_shl64_const (Int64.of_int page_size_bits) ^^
+    compile_const_64 amount ^^
+    StableMem.ensure env
+
   let backup env =
-    let (set_total_size, get_total_size) = new_local64 env "total_size" in
     physical_size env ^^
-    set_total_size ^^
-    get_total_size ^^
     G.i (Test (Wasm.Values.I64 I64Op.Eqz)) ^^
     G.if0
       G.nop
       begin
-        (* grow logical memory by 12 bytes: 
-           logical size (8 bytes) + new version (4 bytes) *)
-        StableMem.get_mem_size env ^^
-        compile_shl64_const (Int64.of_int page_size_bits) ^^
-        compile_const_64 12L ^^
-        StableMem.ensure env ^^
-
-        (* get the potentially extended physical size *)
-        physical_size env ^^
-        set_total_size ^^
-
-        (* store logical memory size *)
-        get_total_size ^^
-        compile_sub64_const 12L ^^
-        StableMem.get_mem_size env ^^
-        StableMem.write_word64 env ^^
-
-        (* save version *)
-        get_total_size ^^ 
-        compile_sub64_const 4L ^^
-        compile_unboxed_const new_stable_memory_version ^^
-        StableMem.write_word32 env
+        grow_size env logical_size_offset ^^
+
+        (* backup logical size *)
+        store_at_end env logical_size_offset I64Type (StableMem.get_mem_size env) ^^
+
+        (* store the version *)
+        store_at_end env version_offset I32Type (compile_unboxed_const new_stable_memory_version)
       end
 
   let restore env =
-    let (set_total_size, get_total_size) = new_local64 env "total_size" in
     physical_size env ^^
-    set_total_size ^^
-    get_total_size ^^
     G.i (Test (Wasm.Values.I64 I64Op.Eqz)) ^^
     G.if0
       begin
@@ -7085,30 +7098,19 @@ module NewStableMemory = struct
       end
       begin
         (* check the version *)
-        get_total_size ^^
-        compile_sub64_const 4L ^^
-        StableMem.read_word32 env ^^
+        read_from_end env version_offset I32Type ^^
         compile_eq_const new_stable_memory_version ^^
         E.else_trap_with env (Printf.sprintf
           "unsupported stable memory version (expected %s)"
            (Int32.to_string new_stable_memory_version)) ^^
         
         (* restore logical size *)
-        get_total_size ^^
-        compile_sub64_const 12L ^^
-        StableMem.read_word64 env ^^
+        read_from_end env logical_size_offset I64Type ^^
         StableMem.set_mem_size env ^^
 
         (* clear size and version *)
-        get_total_size ^^
-        compile_sub64_const 12L ^^
-        compile_const_64 0L ^^
-        StableMem.write_word64 env ^^
-
-        get_total_size ^^
-        compile_sub64_const 4L ^^
-        compile_unboxed_const 0l ^^
-        StableMem.write_word32 env 
+        clear_at_end env logical_size_offset I64Type ^^
+        clear_at_end env version_offset I32Type
       end
 end
 

From 12fda0774099f6aa1bf413a988ba1940f5b34684 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Tue, 5 Sep 2023 15:33:12 +0200
Subject: [PATCH 107/260] Collect unused old stable variables

---
 rts/motoko-rts/src/persistence.rs                  | 10 ++++++++++
 src/codegen/compile.ml                             |  7 ++++++-
 test/run-drun/ok/any-upgrades.drun.ok              |  2 +-
 test/run-drun/ok/array-upgrades.drun.ok            |  4 ++--
 test/run-drun/ok/function-upgrades.drun.ok         |  6 +++---
 test/run-drun/ok/tuple-upgrades.drun.ok            |  8 ++++----
 test/run-drun/ok/upgrade-generics.drun.ok          |  2 +-
 test/run-drun/ok/upgrade-nat-to-int.drun.ok        |  2 +-
 test/run-drun/ok/upgrade-remove-add-fields.drun.ok |  4 ++--
 test/run-drun/ok/variant-upgrades.drun.ok          |  2 +-
 10 files changed, 31 insertions(+), 16 deletions(-)

diff --git a/rts/motoko-rts/src/persistence.rs b/rts/motoko-rts/src/persistence.rs
index 8ed646959dc..8c8fc83b600 100644
--- a/rts/motoko-rts/src/persistence.rs
+++ b/rts/motoko-rts/src/persistence.rs
@@ -142,6 +142,16 @@ pub unsafe fn save_stable_actor<M: Memory>(mem: &mut M, actor: Value) {
     write_with_barrier(mem, location, actor);
 }
 
+/// Free the stable actor sub-record after a completed upgrade.
+/// Allow garbage collection for unused stable variables that are no longer declared
+/// in the new program version.
+#[ic_mem_fn]
+pub unsafe fn free_stable_actor<M: Memory>(mem: &mut M) {
+    let metadata: *mut PersistentMetadata = PersistentMetadata::get();
+    let location = &mut (*metadata).stable_actor as *mut Value;
+    write_with_barrier(mem, location, DEFAULT_VALUE);
+}
+
 #[cfg(feature = "ic")]
 /// GC root pointer required for GC marking and updating.
 pub(crate) unsafe fn stable_actor_location() -> *mut Value {
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index fbf3bbc95c8..f452b15a39c 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -872,6 +872,7 @@ module RTS = struct
     E.add_func_import env "rts" "register_stable_type" [I32Type] [];
     E.add_func_import env "rts" "load_stable_actor" [] [I32Type];
     E.add_func_import env "rts" "save_stable_actor" [I32Type] [];
+    E.add_func_import env "rts" "free_stable_actor" [] [];
     E.add_func_import env "rts" "contains_field" [I32Type; I32Type] [I32Type];
     E.add_func_import env "rts" "set_static_root" [I32Type] [];
     E.add_func_import env "rts" "get_static_root" [] [I32Type];
@@ -7119,6 +7120,8 @@ module Persistence = struct
     
   let save_stable_actor env = E.call_import env "rts" "save_stable_actor"
 
+  let free_stable_actor env = E.call_import env "rts" "free_stable_actor"
+
   let register_stable_type env actor_type =
     let type_descriptor = Persistence.encode_stable_type actor_type in
     Blob.lit env type_descriptor ^^
@@ -7140,7 +7143,9 @@ module Persistence = struct
         (load_stable_actor env ^^ Object.load_idx_raw env field)
         (Opt.null_lit env)
       ) in
-    create_actor env actor_type recover_field
+    create_actor env actor_type recover_field ^^
+    free_stable_actor env
+
 
   let save env actor_type =
     save_stable_actor env ^^
diff --git a/test/run-drun/ok/any-upgrades.drun.ok b/test/run-drun/ok/any-upgrades.drun.ok
index fd15d4dfc3c..b343e97a038 100644
--- a/test/run-drun/ok/any-upgrades.drun.ok
+++ b/test/run-drun/ok/any-upgrades.drun.ok
@@ -4,5 +4,5 @@ ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
 debug.print: Memory-incompatible program upgrade
-debug.print: panic occurred in file 'src/persistence.rs' at line 193
+debug.print: panic occurred in file 'src/persistence.rs' at line 203
 ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
diff --git a/test/run-drun/ok/array-upgrades.drun.ok b/test/run-drun/ok/array-upgrades.drun.ok
index ed6459af71f..269f64e0702 100644
--- a/test/run-drun/ok/array-upgrades.drun.ok
+++ b/test/run-drun/ok/array-upgrades.drun.ok
@@ -20,10 +20,10 @@ debug.print: [[1, 2, 3], [4, 5, 6]]
 debug.print: ?[null, ?[], ?[?[null, null], null]]
 ingress Completed: Reply: 0x4449444c0000
 debug.print: Memory-incompatible program upgrade
-debug.print: panic occurred in file 'src/persistence.rs' at line 193
+debug.print: panic occurred in file 'src/persistence.rs' at line 203
 ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
 debug.print: Memory-incompatible program upgrade
-debug.print: panic occurred in file 'src/persistence.rs' at line 193
+debug.print: panic occurred in file 'src/persistence.rs' at line 203
 ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
 ingress Completed: Reply: 0x4449444c0000
 debug.print: [var 1.000000, 2.000000, 3.000000, 4.000000]
diff --git a/test/run-drun/ok/function-upgrades.drun.ok b/test/run-drun/ok/function-upgrades.drun.ok
index 7ac57d684ec..c4b2228d3e9 100644
--- a/test/run-drun/ok/function-upgrades.drun.ok
+++ b/test/run-drun/ok/function-upgrades.drun.ok
@@ -4,12 +4,12 @@ ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
 debug.print: Memory-incompatible program upgrade
-debug.print: panic occurred in file 'src/persistence.rs' at line 193
+debug.print: panic occurred in file 'src/persistence.rs' at line 203
 ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
 debug.print: Memory-incompatible program upgrade
-debug.print: panic occurred in file 'src/persistence.rs' at line 193
+debug.print: panic occurred in file 'src/persistence.rs' at line 203
 ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
 debug.print: Memory-incompatible program upgrade
-debug.print: panic occurred in file 'src/persistence.rs' at line 193
+debug.print: panic occurred in file 'src/persistence.rs' at line 203
 ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/tuple-upgrades.drun.ok b/test/run-drun/ok/tuple-upgrades.drun.ok
index 5a988916e8f..5b2ef66a0d4 100644
--- a/test/run-drun/ok/tuple-upgrades.drun.ok
+++ b/test/run-drun/ok/tuple-upgrades.drun.ok
@@ -22,16 +22,16 @@ debug.print: (0, "Test", 1.230000, {key = 5; value = '_'}, [-1, +2, -3])
 debug.print: ?(2, ?(1, null, null), ?(4, ?(3, null, null), ?(5, null, null)))
 ingress Completed: Reply: 0x4449444c0000
 debug.print: Memory-incompatible program upgrade
-debug.print: panic occurred in file 'src/persistence.rs' at line 193
+debug.print: panic occurred in file 'src/persistence.rs' at line 203
 ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
 debug.print: Memory-incompatible program upgrade
-debug.print: panic occurred in file 'src/persistence.rs' at line 193
+debug.print: panic occurred in file 'src/persistence.rs' at line 203
 ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
 debug.print: Memory-incompatible program upgrade
-debug.print: panic occurred in file 'src/persistence.rs' at line 193
+debug.print: panic occurred in file 'src/persistence.rs' at line 203
 ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
 debug.print: Memory-incompatible program upgrade
-debug.print: panic occurred in file 'src/persistence.rs' at line 193
+debug.print: panic occurred in file 'src/persistence.rs' at line 203
 ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
 ingress Completed: Reply: 0x4449444c0000
 debug.print: (1, 2)
diff --git a/test/run-drun/ok/upgrade-generics.drun.ok b/test/run-drun/ok/upgrade-generics.drun.ok
index 9ba941e842c..3db739de0b3 100644
--- a/test/run-drun/ok/upgrade-generics.drun.ok
+++ b/test/run-drun/ok/upgrade-generics.drun.ok
@@ -12,7 +12,7 @@ ingress Completed: Reply: 0x4449444c0000
 debug.print: (([0], [+1]), true)
 ingress Completed: Reply: 0x4449444c0000
 debug.print: Memory-incompatible program upgrade
-debug.print: panic occurred in file 'src/persistence.rs' at line 193
+debug.print: panic occurred in file 'src/persistence.rs' at line 203
 ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
 ingress Completed: Reply: 0x4449444c0000
 debug.print: (([0], [+1]), true)
diff --git a/test/run-drun/ok/upgrade-nat-to-int.drun.ok b/test/run-drun/ok/upgrade-nat-to-int.drun.ok
index ceac73f50b1..b961c8ec4a6 100644
--- a/test/run-drun/ok/upgrade-nat-to-int.drun.ok
+++ b/test/run-drun/ok/upgrade-nat-to-int.drun.ok
@@ -16,5 +16,5 @@ ingress Completed: Reply: 0x4449444c0000
 debug.print: -2
 ingress Completed: Reply: 0x4449444c0000
 debug.print: Memory-incompatible program upgrade
-debug.print: panic occurred in file 'src/persistence.rs' at line 193
+debug.print: panic occurred in file 'src/persistence.rs' at line 203
 ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
diff --git a/test/run-drun/ok/upgrade-remove-add-fields.drun.ok b/test/run-drun/ok/upgrade-remove-add-fields.drun.ok
index 61be9d4a059..d72f5fb89d6 100644
--- a/test/run-drun/ok/upgrade-remove-add-fields.drun.ok
+++ b/test/run-drun/ok/upgrade-remove-add-fields.drun.ok
@@ -20,13 +20,13 @@ ingress Completed: Reply: 0x4449444c0000
 debug.print: secondField=4
 ingress Completed: Reply: 0x4449444c0000
 debug.print: Memory-incompatible program upgrade
-debug.print: panic occurred in file 'src/persistence.rs' at line 193
+debug.print: panic occurred in file 'src/persistence.rs' at line 203
 ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
 ingress Completed: Reply: 0x4449444c0000
 debug.print: secondField=5
 ingress Completed: Reply: 0x4449444c0000
 debug.print: Memory-incompatible program upgrade
-debug.print: panic occurred in file 'src/persistence.rs' at line 193
+debug.print: panic occurred in file 'src/persistence.rs' at line 203
 ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
 ingress Completed: Reply: 0x4449444c0000
 debug.print: secondField=6
diff --git a/test/run-drun/ok/variant-upgrades.drun.ok b/test/run-drun/ok/variant-upgrades.drun.ok
index d1eae564e05..f2f1686663d 100644
--- a/test/run-drun/ok/variant-upgrades.drun.ok
+++ b/test/run-drun/ok/variant-upgrades.drun.ok
@@ -16,5 +16,5 @@ ingress Completed: Reply: 0x4449444c0000
 debug.print: #two({key = 1; name = "TEST TEST TEST TEST TEST"})
 ingress Completed: Reply: 0x4449444c0000
 debug.print: Memory-incompatible program upgrade
-debug.print: panic occurred in file 'src/persistence.rs' at line 193
+debug.print: panic occurred in file 'src/persistence.rs' at line 203
 ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked

From a80e610689977c5b02094464244ebe72a9b463a0 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Tue, 5 Sep 2023 19:55:33 +0200
Subject: [PATCH 108/260] Require mutable invariance

---
 .../src/persistence/compatibility.rs          | 28 +++++++++++++++++++
 .../src/persistence/compatibility.rs          |  7 ++++-
 test/run-drun/ok/upgrade-mutable.drun.ok      | 14 ++++++++++
 .../ok/upgrade-recursive-type.drun.ok         |  8 ++++--
 test/run-drun/upgrade-mutable.drun            |  8 ++++++
 test/run-drun/upgrade-mutable/version0.mo     | 18 ++++++++++++
 test/run-drun/upgrade-mutable/version1.mo     | 20 +++++++++++++
 .../upgrade-recursive-type/version1.mo        |  1 +
 8 files changed, 101 insertions(+), 3 deletions(-)
 create mode 100644 test/run-drun/ok/upgrade-mutable.drun.ok
 create mode 100644 test/run-drun/upgrade-mutable.drun
 create mode 100644 test/run-drun/upgrade-mutable/version0.mo
 create mode 100644 test/run-drun/upgrade-mutable/version1.mo

diff --git a/rts/motoko-rts-tests/src/persistence/compatibility.rs b/rts/motoko-rts-tests/src/persistence/compatibility.rs
index a2de16501c9..f255f782ce0 100644
--- a/rts/motoko-rts-tests/src/persistence/compatibility.rs
+++ b/rts/motoko-rts-tests/src/persistence/compatibility.rs
@@ -1109,6 +1109,7 @@ unsafe fn test_failing_cases(heap: &mut TestMemory) {
     test_actor_to_object(heap);
     test_object_to_actor(heap);
     test_mutable_mismatch(heap);
+    test_mutable_invariance(heap);
     test_immutable_mismatch(heap);
     test_recursion_mismatch(heap);
     test_option_mismatch(heap);
@@ -1271,6 +1272,33 @@ unsafe fn test_mutable_mismatch(heap: &mut TestMemory) {
     assert!(!are_compatible(heap, old_types, new_types));
 }
 
+unsafe fn test_mutable_invariance(heap: &mut TestMemory) {
+    let main_actor = Type::Object(FieldList {
+        fields: vec![Field {
+            name: String::from("ActorField"),
+            field_type: TypeReference { index: 1 },
+        }],
+    });
+    let mutable_type = Type::Mutable(TypeReference { index: 2 });
+    let field1 = Field {
+        name: String::from("Field1"),
+        field_type: TypeReference::nat(),
+    };
+    let field2 = Field {
+        name: String::from("Field2"),
+        field_type: TypeReference::text(),
+    };
+    let old_object = Type::Object(FieldList {
+        fields: vec![field1.clone(), field2],
+    });
+    let new_object = Type::Object(FieldList {
+        fields: vec![field1.clone()],
+    });
+    let old_types = vec![main_actor.clone(), mutable_type.clone(), old_object];
+    let new_types = vec![main_actor.clone(), mutable_type.clone(), new_object];
+    assert!(!are_compatible(heap, old_types, new_types));
+}
+
 unsafe fn test_immutable_mismatch(heap: &mut TestMemory) {
     let old_actor = Type::Object(FieldList {
         fields: vec![Field {
diff --git a/rts/motoko-rts/src/persistence/compatibility.rs b/rts/motoko-rts/src/persistence/compatibility.rs
index 3601d8ce66a..6e93bc86c64 100644
--- a/rts/motoko-rts/src/persistence/compatibility.rs
+++ b/rts/motoko-rts/src/persistence/compatibility.rs
@@ -602,6 +602,11 @@ impl CompatibilityChecker {
         false
     }
 
+    unsafe fn identical_types(&mut self, target_type_index: i32, source_type_index: i32) -> bool {
+        self.type_compatible(target_type_index, source_type_index)
+            && self.reverse_compatible(source_type_index, target_type_index)
+    }
+
     unsafe fn type_compatible(&mut self, target_type_index: i32, source_type_index: i32) -> bool {
         if target_type_index < 0 || source_type_index < 0 {
             return self.compatible_primitives(target_type_index, source_type_index);
@@ -631,7 +636,7 @@ impl CompatibilityChecker {
             }
             (Type::Function(_), _) => false,
             (Type::Mutable(new_variable), Type::Mutable(old_variable)) => {
-                self.compatible_type_indices(new_variable, old_variable)
+                self.identical_types(new_variable.type_index, old_variable.type_index)
             }
             (Type::Mutable(_), _) => false,
             (Type::Option(new_option), Type::Option(old_option)) => {
diff --git a/test/run-drun/ok/upgrade-mutable.drun.ok b/test/run-drun/ok/upgrade-mutable.drun.ok
new file mode 100644
index 00000000000..62cfb8bc1b5
--- /dev/null
+++ b/test/run-drun/ok/upgrade-mutable.drun.ok
@@ -0,0 +1,14 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: [var {key = 2; value = "2"}]
+debug.print: [var {key = 2; value = "2"}]
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: [var {key = 2; value = "2"}]
+debug.print: [var {key = 2; value = "2"}]
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Memory-incompatible program upgrade
+debug.print: panic occurred in file 'src/persistence.rs' at line 203
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
diff --git a/test/run-drun/ok/upgrade-recursive-type.drun.ok b/test/run-drun/ok/upgrade-recursive-type.drun.ok
index e9e921de8a5..2becc24484b 100644
--- a/test/run-drun/ok/upgrade-recursive-type.drun.ok
+++ b/test/run-drun/ok/upgrade-recursive-type.drun.ok
@@ -7,11 +7,15 @@ ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
 debug.print: CHECK 2
 ingress Completed: Reply: 0x4449444c0000
-ingress Completed: Reply: 0x4449444c0000
+debug.print: Memory-incompatible program upgrade
+debug.print: panic occurred in file 'src/persistence.rs' at line 203
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
 ingress Completed: Reply: 0x4449444c0000
 debug.print: CHECK 3
 ingress Completed: Reply: 0x4449444c0000
-ingress Completed: Reply: 0x4449444c0000
+debug.print: Memory-incompatible program upgrade
+debug.print: panic occurred in file 'src/persistence.rs' at line 203
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
 ingress Completed: Reply: 0x4449444c0000
 debug.print: CHECK 4
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/upgrade-mutable.drun b/test/run-drun/upgrade-mutable.drun
new file mode 100644
index 00000000000..f66bffb052d
--- /dev/null
+++ b/test/run-drun/upgrade-mutable.drun
@@ -0,0 +1,8 @@
+# SKIP ic-ref-run
+install $ID upgrade-mutable/version0.mo ""
+ingress $ID modify "DIDL\x00\x00"
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID upgrade-mutable/version0.mo ""
+ingress $ID modify "DIDL\x00\x00"
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID upgrade-mutable/version1.mo ""
diff --git a/test/run-drun/upgrade-mutable/version0.mo b/test/run-drun/upgrade-mutable/version0.mo
new file mode 100644
index 00000000000..058768fbd04
--- /dev/null
+++ b/test/run-drun/upgrade-mutable/version0.mo
@@ -0,0 +1,18 @@
+import Prim "mo:prim";
+
+actor {
+   type Entry = { key: Nat; value: Text; };
+   stable var array1: [var Entry] = [ var { key = 1; value = "1" }];
+   stable var array2: [var Entry] = array1;
+   
+   public func modify() : async () {
+      array1[0] := { key = 2; value = "2" };
+      assert(array2[0].key == 2);
+      assert(array2[0].value == "2");
+   };
+
+   public func print() : async () {
+      Prim.debugPrint(debug_show(array1));
+      Prim.debugPrint(debug_show(array2));
+   };
+};
diff --git a/test/run-drun/upgrade-mutable/version1.mo b/test/run-drun/upgrade-mutable/version1.mo
new file mode 100644
index 00000000000..be9424f3d7e
--- /dev/null
+++ b/test/run-drun/upgrade-mutable/version1.mo
@@ -0,0 +1,20 @@
+import Prim "mo:prim";
+
+actor {
+   type Entry = { key : Nat; value : Text };
+   type SubEntry = { key : Nat; };
+   
+   stable var array1 : [var Entry] = [var { key = 1; value = "1" }];
+   stable var array2 : [var SubEntry] = [var];
+
+   public func modify() : async () {
+      array2[0] := { key = 3; };
+      assert (array1[0].key == 3);
+      Prim.debugPrint(array1[0].value);
+   };
+
+   public func print() : async () {
+      Prim.debugPrint(debug_show (array1));
+      Prim.debugPrint(debug_show (array2));
+   };
+};
diff --git a/test/run-drun/upgrade-recursive-type/version1.mo b/test/run-drun/upgrade-recursive-type/version1.mo
index f6e0b4b36c4..a840ea723d8 100644
--- a/test/run-drun/upgrade-recursive-type/version1.mo
+++ b/test/run-drun/upgrade-recursive-type/version1.mo
@@ -1,5 +1,6 @@
 import Prim "mo:prim";
 
+// Incompatible change (mutable invariance).
 actor {
     type Node = {
         var value : Nat;

From 5cc4588264714496f9c9f0912075ca2eeeb66987 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Tue, 5 Sep 2023 20:06:54 +0200
Subject: [PATCH 109/260] Update documentation

---
 .../{StableMemory.md => OldStableMemory.md}   |   6 +-
 design/OrthogonalPersistence.md               | 130 ++++++++++++++++++
 design/Stable.md                              |  11 +-
 3 files changed, 136 insertions(+), 11 deletions(-)
 rename design/{StableMemory.md => OldStableMemory.md} (98%)
 create mode 100644 design/OrthogonalPersistence.md

diff --git a/design/StableMemory.md b/design/OldStableMemory.md
similarity index 98%
rename from design/StableMemory.md
rename to design/OldStableMemory.md
index d9ddfdeccb6..9c98b66f709 100644
--- a/design/StableMemory.md
+++ b/design/OldStableMemory.md
@@ -1,4 +1,8 @@
-# Stable Memory API
+# Old Stable Memory API
+
+This describes the legacy stable memory mechanism intended to be replaced by 
+true orthogonal persistence where the main memory is retained across upgrades.
+See `OrthogonalPersistence.md`.
 
 The current implementation of stable variables is based on
 serialization and deserialization of all stable data on upgrade. This
diff --git a/design/OrthogonalPersistence.md b/design/OrthogonalPersistence.md
new file mode 100644
index 00000000000..5094a986a3f
--- /dev/null
+++ b/design/OrthogonalPersistence.md
@@ -0,0 +1,130 @@
+# Orthogonal Persistence (Stable Heap)
+
+This realizes the vision of keeping the canister main memory persistent even across upgrades and thus allows scalable upgrades.
+Canister upgrades do no longer involve serialization and deserialization to and from secondary stable memory.
+
+## Purpose
+* **Instantenous upgrades**: New program versions simply resume on the existing main memory and have access to the memory-compatible data.
+* **Scalable upgrades**: The upgrade mechanism scales with larger heaps and in contrast to serialization, does not hit IC instruction limits.
+
+## Broader Vision
+In the longer term, this approach aims to enable **true orthogonal persistence** that is simple, flexible, efficient, and scalable.
+While this version implements the runtime support for 32-bit memory, this could be leveraged to 64-bit persistent main memory in future.
+As a result, the use of secondary storage (explicit stable memory, dedicated stable data structures, DB-like storage abstractions) will no longer be necessary: 
+Motoko developers could directly work on their normal object-oriented program structures that are automatically persisted and retained across program version changes.
+With 64-bit main memory, large-scaled orthogonal persistence would be enabled, supported by the incremental GC that is designed to also scale in 64-bit.
+
+## Design
+The stable heap is based on the following main properties:
+* Extension of the IC to retain main memory on upgrades.
+* A long-term memory layout that is invariant to new compiled program versions.
+* A fast memory compatibility check performed on each canister upgrade.
+* Incremental garbage collection using a partitioned heap.
+
+### IC Extension
+As a prerequisite for the stable heap support, the IC runtime support has to be extended in order not to erase the main memory on upgrades.
+This is realized in a specific IC branch (https://github.com/luc-blaeser/ic/tree/luc/stable-heap-on-release) that retains the main memory even on upgrades, similar to normal canister message execution. 
+The only data that needs to be updated on an upgrade is the Wasm data segments specified in the Wasm binary, e.g. text literals. 
+For this purpose, a special memory section is reserved for data segments.
+
+### Memory Layout
+In a co-design between the compiler and the runtime system, the main memory is arranged in the following structure, invariant of the compiled program version:
+* Lower 2MB: Rust call stack.
+* Space between 2MB and 6MB: Reserved space Wasm data segments.
+* Between 6MB and 6.125MB: Persistent metadata.
+* Thereafter: Dynamic heap space. Fix start address at 6.125MB.
+
+### Persistent Metadata
+The persistent metadata describes all anchor information for the program to resume after an upgrade. 
+More specifically, it comprises:
+* A stable heap version that allows evolving the persistent memory layout in the future.
+* The stable subset of the main actor, containing all stable variables declared in the main actor.
+* A descriptor of the stable static types to check memory compatibility on upgrades.
+* The reference to the null singleton object.
+* The runtime state of the garbage collector, including the dynamic heap metadata and memory statistics.
+* A reserve for future metadata extensions.
+
+### Compatibility Check
+NOTE: This will be simplified by using the existing IDL sub-type test in the runtime system.
+
+Upgrades are only permitted if the new program version is compatible to the old version, such that the runtime system guarantees a compatible memory structure.
+Compatible changes are equivalent to the allowed Motoko subtype relation, e.g.
+* Adding or removing actor fields
+* Removing object fields
+* Adding variant fields
+* `Nat` to `Int`
+* Shared function parameter contravariance and return type covariance
+
+The compiler generates a static type table that describes all static variable types.
+The table is registered in the persistent metadata and compared against the type table of a new program version. The upgrade is rejected on incompatible type tables.
+
+This compatibility check serves as an additional safety measure on top of the DFX Candid subtype check that can be bypassed by users (when ignoring a warning). Moreoever, the memory compatibility rules may be stricter than in Candid (e.g. not allowing introducing optional types).
+
+### Garbage Collection
+The implementation focuses on the incremental GC and abandons the other GCs because the GCs use different memory layouts. For example, the incremental GC uses a partitioned heap with objects carrying a forwarding pointer.
+
+The incremental GC is chosen because it is designed to scale on large heaps and the stable heap design also aims to increase scalability. Moreover, it is suited to scale on 64-bit memory in future.
+
+The garbage collection state needs to be persisted and retained across upgrades. 
+This is because the GC may not yet be completed at the time of an upgrade, such that object forwarding is still in use. The partition table is stored as part of the GC state.
+
+The garbage collector uses two kinds of roots:
+* Persistent roots: These refer to root objects that need to survive canister upgrades.
+* Transient roots: These cover additional roots that are only valid in a specific version of a program and are discarded on an upgrade.
+
+The persistent roots are registered in the persistent metadata and comprise:
+* All stable variables of the main actor, only stored during an upgrade.
+* The null singleton object.
+* The stable type table.
+
+The transient roots are referenced by the Wasm data segments and comprise:
+* All canister variables of the current version, including flexible variables.
+
+### Main Actor
+On an upgrade, the main actor is recreated and existing stable variables are recovered from the persistent root.
+The remaining actor variables, the flexible fields as well as new stable variables, are (re)initialized.
+As a result, the GC can collect unreachable flexible objects of previous canister versions. 
+Unused stable variables of former versions can also be reclaimed by the GC.
+
+### Wasm Data Segments
+Wasm data segments are reinitialized on upgrade. 
+This is necessary because data segments may contain text literals or transient GC roots that are bound to a specific new Wasm binary.
+The system reserves dedicated space for data segments, namely between 2MB and 6MB. 
+Therefore, the data segments are limited to 4MB per canister Wasm in this design. 
+Both the linker and the IC runtime system check that the data segments fit inside this reserved space.
+
+There exist alternative design possibilities to handle data segments, see below.
+
+### No Static Heap
+The static heap is abandoned and former static objects need to be allocated in the dynamic heap.
+This is because these objects may also need to survive upgrades and must not be not overwritten by new data segments. 
+
+The incremental GC also operates on these objects, meaning that forwarding pointer resolution is also necessary for these objects.
+
+The runtime systems avoids any global Wasm variables for state that needs to be preserved on upgrades.
+Instead, such global runtime state is stored in the persistent metadata.
+
+Sharing optimization (pooling) is possible for compile-time-known objects, see below.
+
+### Null Singleton
+As an optimization, the top-level `null`` singleton is allocated once in the dynamic heap and remembered in the persistent metadata across upgrades. 
+This is necessary to implement null checks by pointer comparison (however, by first resolving pointer forwarding before the comparison).
+The null singleton needs to be part of the persistent root set.
+
+### Migration Path
+When migrating from the old serialization-based stabilization to the new stable heap, the old data is deserialized one last time from stable memory and then placed in the new stable heap layout.
+Once operating on the stable heap, the system prevents downgrade attempts to the old serialization-based persistence.
+
+### Old Stable Memory
+The old stable memory remains equally accessible as secondary memory with the new support.
+
+## Possible Extensions
+The following extensions or optimization could be applied in the future:
+* Unlimited data segments: Using passive Wasm data segments and loading them at runtime to dynamically computed addresses in the heap. The IC would however need to be extended to support passive Wasm data segments.
+* 64-bit memory: Extend the main memory to 64-bit by using Wasm64, see https://github.com/dfinity/motoko/pull/4136. The memory layout would need to be extended. Moreover, it would be beneficial to introduce a dynamic partition table for the GC. Ideally, stable heap support is directly rolled out for 64-bit to avoid complicated memory layout upgrades from 32-bit to 64-bit.
+* Object pooling: Compile-time-known objects can be shared in the dynamic heap by remembering them in an additional pool table. The pool table needs to be registered as a transient GC root and is recreated on canister upgrades.
+
+## Related PRs
+
+* IC with stable main memory support: https://github.com/luc-blaeser/ic/tree/luc/stable-heap-on-release
+* Wasm64 Support for Motoko: https://github.com/dfinity/motoko/pull/4136
diff --git a/design/Stable.md b/design/Stable.md
index 6fd40a09174..2dfd34975f6 100644
--- a/design/Stable.md
+++ b/design/Stable.md
@@ -180,13 +180,4 @@ Note: The post-upgrade method differs from expression declarations in the body o
 
 ## Implementation
 
-Until Wasm provides multiple memories, the values of stable variables need to be written to the _stable memory_ provided by the System API.
-There are multiple possible implementation strategies for this:
-
-1. Lazy de/serialisation: the compiler generates a pre_upgrade hook that serialises a map of all stable variables to the stable memory, and a post_upgrade hook that deserialises.
-
-2. Eager de/serialisation: reading/writing a stable variable de/serialises their value directly into a key/value store living in the stable memory.
-Dealing with in-place update on mutable components requires indirections in the store via some extensible table.
-It also necessitates some form of garbage collection of the stable heap.
-
-3. Possibly other, like more smarter incremental approaches...
+See `OrthogonalPersistence.md`.

From 0be976912a95ad753a8b22ececf9bd2d5bc6ebdc Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Tue, 5 Sep 2023 20:14:43 +0200
Subject: [PATCH 110/260] Update benchmark results (incremental GC)

---
 test/bench/ok/alloc.drun-run-opt.ok      |  6 +++---
 test/bench/ok/alloc.drun-run.ok          |  6 +++---
 test/bench/ok/bignum.drun-run-opt.ok     |  4 ++--
 test/bench/ok/bignum.drun-run.ok         |  4 ++--
 test/bench/ok/heap-32.drun-run-opt.ok    |  4 ++--
 test/bench/ok/heap-32.drun-run.ok        |  4 ++--
 test/bench/ok/nat16.drun-run-opt.ok      |  2 +-
 test/bench/ok/nat16.drun-run.ok          |  2 +-
 test/bench/ok/palindrome.drun-run-opt.ok | 12 ++++++------
 test/bench/ok/palindrome.drun-run.ok     | 12 ++++++------
 10 files changed, 28 insertions(+), 28 deletions(-)

diff --git a/test/bench/ok/alloc.drun-run-opt.ok b/test/bench/ok/alloc.drun-run-opt.ok
index f946678807a..7b203d6b8c4 100644
--- a/test/bench/ok/alloc.drun-run-opt.ok
+++ b/test/bench/ok/alloc.drun-run-opt.ok
@@ -1,8 +1,8 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+268_435_456, 2_432_885_039)
+debug.print: (+335_544_320, 4_714_400_059)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+268_435_456, 2_432_749_871)
+debug.print: (+335_544_320, 4_714_399_876)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+268_435_456, 2_432_749_871)
+debug.print: (+335_544_320, 4_714_399_888)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/alloc.drun-run.ok b/test/bench/ok/alloc.drun-run.ok
index 4e599232919..94440925784 100644
--- a/test/bench/ok/alloc.drun-run.ok
+++ b/test/bench/ok/alloc.drun-run.ok
@@ -1,8 +1,8 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+268_435_456, 2_500_059_458)
+debug.print: (+335_544_320, 4_865_395_178)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+268_435_456, 2_499_907_906)
+debug.print: (+335_544_320, 4_865_394_985)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+268_435_456, 2_499_907_906)
+debug.print: (+335_544_320, 4_865_394_998)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/bignum.drun-run-opt.ok b/test/bench/ok/bignum.drun-run-opt.ok
index 5b40a565944..e0acc143ad0 100644
--- a/test/bench/ok/bignum.drun-run-opt.ok
+++ b/test/bench/ok/bignum.drun-run-opt.ok
@@ -1,6 +1,6 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 2_389_389; size = +59_652}
+debug.print: {cycles = 2_413_519; size = +60_608}
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 102_989_116; size = +1_817_872}
+debug.print: {cycles = 103_307_648; size = +1_827_460}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/bignum.drun-run.ok b/test/bench/ok/bignum.drun-run.ok
index 7e490e3f3a2..19714633700 100644
--- a/test/bench/ok/bignum.drun-run.ok
+++ b/test/bench/ok/bignum.drun-run.ok
@@ -1,6 +1,6 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 2_493_575; size = +59_652}
+debug.print: {cycles = 2_518_300; size = +60_608}
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 103_046_061; size = +1_817_872}
+debug.print: {cycles = 103_362_157; size = +1_827_460}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/heap-32.drun-run-opt.ok b/test/bench/ok/heap-32.drun-run-opt.ok
index 95d5dd1aa92..ea7f19893d7 100644
--- a/test/bench/ok/heap-32.drun-run-opt.ok
+++ b/test/bench/ok/heap-32.drun-run-opt.ok
@@ -1,5 +1,5 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (50_227, +30_261_252, 620_394_365)
-debug.print: (50_070, +32_992_212, 671_304_553)
+debug.print: (50_227, +37_021_304, 762_444_205)
+debug.print: (50_070, +40_056_236, 824_441_398)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/heap-32.drun-run.ok b/test/bench/ok/heap-32.drun-run.ok
index 96f23a8b836..3b78e390d32 100644
--- a/test/bench/ok/heap-32.drun-run.ok
+++ b/test/bench/ok/heap-32.drun-run.ok
@@ -1,5 +1,5 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (50_227, +30_261_252, 667_797_613)
-debug.print: (50_070, +32_992_212, 720_521_485)
+debug.print: (50_227, +37_021_304, 810_355_108)
+debug.print: (50_070, +40_056_236, 874_090_143)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/nat16.drun-run-opt.ok b/test/bench/ok/nat16.drun-run-opt.ok
index 78e980acd52..7d812c5e5c1 100644
--- a/test/bench/ok/nat16.drun-run-opt.ok
+++ b/test/bench/ok/nat16.drun-run-opt.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (0, 18_875_143)
+debug.print: (0, 18_875_156)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/nat16.drun-run.ok b/test/bench/ok/nat16.drun-run.ok
index 41d7356a203..c40412fab2a 100644
--- a/test/bench/ok/nat16.drun-run.ok
+++ b/test/bench/ok/nat16.drun-run.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (0, 42_992_136)
+debug.print: (0, 42_992_140)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/palindrome.drun-run-opt.ok b/test/bench/ok/palindrome.drun-run-opt.ok
index f3305eaf66f..6e958fe0610 100644
--- a/test/bench/ok/palindrome.drun-run-opt.ok
+++ b/test/bench/ok/palindrome.drun-run-opt.ok
@@ -1,9 +1,9 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (true, +1_188, 10_852)
-debug.print: (false, +1_188, 10_198)
-debug.print: (false, +1_188, 10_843)
-debug.print: (true, +868, 11_135)
-debug.print: (false, +868, 9_989)
-debug.print: (false, +868, 11_099)
+debug.print: (true, +1_548, 28_429)
+debug.print: (false, +1_548, 27_119)
+debug.print: (false, +1_548, 28_394)
+debug.print: (true, +1_160, 27_441)
+debug.print: (false, +1_148, 25_379)
+debug.print: (false, +1_148, 27_239)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/palindrome.drun-run.ok b/test/bench/ok/palindrome.drun-run.ok
index 6f3a5873847..eb2213c59ff 100644
--- a/test/bench/ok/palindrome.drun-run.ok
+++ b/test/bench/ok/palindrome.drun-run.ok
@@ -1,9 +1,9 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (true, +1_188, 11_854)
-debug.print: (false, +1_188, 11_139)
-debug.print: (false, +1_188, 11_844)
-debug.print: (true, +868, 11_834)
-debug.print: (false, +868, 10_653)
-debug.print: (false, +868, 11_793)
+debug.print: (true, +1_548, 29_899)
+debug.print: (false, +1_548, 28_513)
+debug.print: (false, +1_548, 29_863)
+debug.print: (true, +1_160, 28_397)
+debug.print: (false, +1_148, 26_296)
+debug.print: (false, +1_148, 28_186)
 ingress Completed: Reply: 0x4449444c0000

From e9e91ce89c016382fe7f2e7ef08c7a724b688397 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Wed, 6 Sep 2023 09:51:58 +0200
Subject: [PATCH 111/260] Merge branch 'master' into luc/stable-heap

---
 .github/dependabot.yml                        |   9 +
 .github/workflows/release.yml                 |  10 +-
 .github/workflows/test.yml                    |  14 +-
 .github/workflows/update-hash.yml             |   4 +-
 Changelog.md                                  |   8 +
 default.nix                                   |   6 +-
 nix/sources.json                              |  18 +-
 .../src/gc/incremental/partitioned_heap.rs    |  14 +
 .../phases/evacuation_increment.rs            |   2 +-
 src/codegen/compile.ml                        | 101 ++++-
 src/codegen/persistence.ml                    |   4 +-
 src/idllib/arrange_idl.ml                     | 380 ++++++++++--------
 src/idllib/parser.mly                         |   6 +-
 src/idllib/pipeline.ml                        |   2 +-
 src/idllib/syntax.ml                          |   3 +-
 src/ir_def/check_ir.ml                        |   6 +-
 src/ir_def/construct.ml                       |   2 +-
 src/ir_passes/async.ml                        |   4 +-
 src/ir_passes/erase_typ_field.ml              |   4 +-
 src/js/common.ml                              |   4 +-
 src/{mo_def => lang_utils}/trivia.ml          |  50 ++-
 src/{mo_def => lang_utils}/trivia.mli         |   6 +
 src/lowering/desugar.ml                       |  18 +-
 src/mo_frontend/lexer.ml                      |   2 +-
 src/mo_frontend/lexer.mli                     |   2 +-
 src/mo_frontend/parser_lib.ml                 |   2 +-
 src/mo_frontend/source_lexer.mll              |   2 +-
 src/mo_frontend/source_token.ml               |   2 +-
 src/mo_frontend/typing.ml                     |  87 ++--
 src/mo_idl/idl_to_mo.ml                       |   8 +-
 src/mo_idl/mo_to_idl.ml                       |  29 +-
 src/mo_types/type.ml                          |  79 ++--
 src/mo_types/type.mli                         |   4 +-
 src/mo_values/prim.ml                         |  15 +-
 src/prelude/prim.mo                           | 211 +++++-----
 test/fail/ok/no-timer-canc.tc.ok              |  12 +
 test/fail/ok/no-timer-set.tc.ok               |  12 +
 test/repl/ok/outrange-int-nat.stderr.ok       |   9 +
 test/repl/ok/outrange-int-nat.stdout.ok       |   9 +
 test/repl/outrange-int-nat.sh                 |  24 ++
 test/run.sh                                   |   4 +-
 test/run/conversions.mo                       | 172 +++++---
 test/run/ok/conversions.run-ir.ok             |   6 +
 test/run/ok/conversions.run-low.ok            |   6 +
 test/run/ok/conversions.run.ok                |   6 +
 test/run/ok/conversions.wasm-run.ok           |   6 +
 test/test-moc.js                              | 294 +++++++-------
 .../ok/outrange-int16-int8-lower.run-ir.ok    |   1 +
 .../ok/outrange-int16-int8-lower.run-low.ok   |   1 +
 test/trap/ok/outrange-int16-int8-lower.run.ok |   1 +
 .../ok/outrange-int16-int8-lower.run.ret.ok   |   1 +
 .../ok/outrange-int16-int8-lower.wasm-run.ok  |   9 +
 .../outrange-int16-int8-lower.wasm-run.ret.ok |   1 +
 .../ok/outrange-int16-int8-negation.run-ir.ok |   1 +
 .../outrange-int16-int8-negation.run-low.ok   |   1 +
 .../ok/outrange-int16-int8-negation.run.ok    |   1 +
 .../outrange-int16-int8-negation.run.ret.ok   |   1 +
 .../outrange-int16-int8-negation.wasm-run.ok  |  10 +
 ...trange-int16-int8-negation.wasm-run.ret.ok |   1 +
 .../ok/outrange-int16-int8-upper.run-ir.ok    |   1 +
 .../ok/outrange-int16-int8-upper.run-low.ok   |   1 +
 test/trap/ok/outrange-int16-int8-upper.run.ok |   1 +
 .../ok/outrange-int16-int8-upper.run.ret.ok   |   1 +
 .../ok/outrange-int16-int8-upper.wasm-run.ok  |   9 +
 .../outrange-int16-int8-upper.wasm-run.ret.ok |   1 +
 .../ok/outrange-int32-int16-lower.run-ir.ok   |   1 +
 .../ok/outrange-int32-int16-lower.run-low.ok  |   1 +
 .../trap/ok/outrange-int32-int16-lower.run.ok |   1 +
 .../ok/outrange-int32-int16-lower.run.ret.ok  |   1 +
 .../ok/outrange-int32-int16-lower.wasm-run.ok |   9 +
 ...outrange-int32-int16-lower.wasm-run.ret.ok |   1 +
 .../outrange-int32-int16-negation.run-ir.ok   |   1 +
 .../outrange-int32-int16-negation.run-low.ok  |   1 +
 .../ok/outrange-int32-int16-negation.run.ok   |   1 +
 .../outrange-int32-int16-negation.run.ret.ok  |   1 +
 .../outrange-int32-int16-negation.wasm-run.ok |  10 +
 ...range-int32-int16-negation.wasm-run.ret.ok |   1 +
 .../ok/outrange-int32-int16-upper.run-ir.ok   |   1 +
 .../ok/outrange-int32-int16-upper.run-low.ok  |   1 +
 .../trap/ok/outrange-int32-int16-upper.run.ok |   1 +
 .../ok/outrange-int32-int16-upper.run.ret.ok  |   1 +
 .../ok/outrange-int32-int16-upper.wasm-run.ok |   9 +
 ...outrange-int32-int16-upper.wasm-run.ret.ok |   1 +
 .../ok/outrange-int64-int32-lower.run-ir.ok   |   1 +
 .../ok/outrange-int64-int32-lower.run-low.ok  |   1 +
 .../trap/ok/outrange-int64-int32-lower.run.ok |   1 +
 .../ok/outrange-int64-int32-lower.run.ret.ok  |   1 +
 .../ok/outrange-int64-int32-lower.wasm-run.ok |   9 +
 ...outrange-int64-int32-lower.wasm-run.ret.ok |   1 +
 .../outrange-int64-int32-negation.run-ir.ok   |   1 +
 .../outrange-int64-int32-negation.run-low.ok  |   1 +
 .../ok/outrange-int64-int32-negation.run.ok   |   1 +
 .../outrange-int64-int32-negation.run.ret.ok  |   1 +
 .../outrange-int64-int32-negation.wasm-run.ok |  10 +
 ...range-int64-int32-negation.wasm-run.ret.ok |   1 +
 .../ok/outrange-int64-int32-upper.run-ir.ok   |   1 +
 .../ok/outrange-int64-int32-upper.run-low.ok  |   1 +
 .../trap/ok/outrange-int64-int32-upper.run.ok |   1 +
 .../ok/outrange-int64-int32-upper.run.ret.ok  |   1 +
 .../ok/outrange-int64-int32-upper.wasm-run.ok |   9 +
 ...outrange-int64-int32-upper.wasm-run.ret.ok |   1 +
 test/trap/ok/outrange-nat16-nat8.run-ir.ok    |   1 +
 test/trap/ok/outrange-nat16-nat8.run-low.ok   |   1 +
 test/trap/ok/outrange-nat16-nat8.run.ok       |   1 +
 test/trap/ok/outrange-nat16-nat8.run.ret.ok   |   1 +
 test/trap/ok/outrange-nat16-nat8.wasm-run.ok  |   9 +
 .../ok/outrange-nat16-nat8.wasm-run.ret.ok    |   1 +
 test/trap/ok/outrange-nat32-nat16.run-ir.ok   |   1 +
 test/trap/ok/outrange-nat32-nat16.run-low.ok  |   1 +
 test/trap/ok/outrange-nat32-nat16.run.ok      |   1 +
 test/trap/ok/outrange-nat32-nat16.run.ret.ok  |   1 +
 test/trap/ok/outrange-nat32-nat16.wasm-run.ok |   9 +
 .../ok/outrange-nat32-nat16.wasm-run.ret.ok   |   1 +
 test/trap/ok/outrange-nat64-nat32.run-ir.ok   |   1 +
 test/trap/ok/outrange-nat64-nat32.run-low.ok  |   1 +
 test/trap/ok/outrange-nat64-nat32.run.ok      |   1 +
 test/trap/ok/outrange-nat64-nat32.run.ret.ok  |   1 +
 test/trap/ok/outrange-nat64-nat32.wasm-run.ok |   9 +
 .../ok/outrange-nat64-nat32.wasm-run.ret.ok   |   1 +
 test/trap/outrange-int16-int8-lower.mo        |   2 +
 test/trap/outrange-int16-int8-negation.mo     |   2 +
 test/trap/outrange-int16-int8-upper.mo        |   2 +
 test/trap/outrange-int32-int16-lower.mo       |   2 +
 test/trap/outrange-int32-int16-negation.mo    |   2 +
 test/trap/outrange-int32-int16-upper.mo       |   2 +
 test/trap/outrange-int64-int32-lower.mo       |   2 +
 test/trap/outrange-int64-int32-negation.mo    |   2 +
 test/trap/outrange-int64-int32-upper.mo       |   2 +
 test/trap/outrange-nat16-nat8.mo              |   2 +
 test/trap/outrange-nat32-nat16.mo             |   2 +
 test/trap/outrange-nat64-nat32.mo             |   2 +
 131 files changed, 1219 insertions(+), 654 deletions(-)
 create mode 100644 .github/dependabot.yml
 rename src/{mo_def => lang_utils}/trivia.ml (62%)
 rename src/{mo_def => lang_utils}/trivia.mli (84%)
 create mode 100644 test/run/ok/conversions.run-ir.ok
 create mode 100644 test/run/ok/conversions.run-low.ok
 create mode 100644 test/run/ok/conversions.run.ok
 create mode 100644 test/run/ok/conversions.wasm-run.ok
 create mode 100644 test/trap/ok/outrange-int16-int8-lower.run-ir.ok
 create mode 100644 test/trap/ok/outrange-int16-int8-lower.run-low.ok
 create mode 100644 test/trap/ok/outrange-int16-int8-lower.run.ok
 create mode 100644 test/trap/ok/outrange-int16-int8-lower.run.ret.ok
 create mode 100644 test/trap/ok/outrange-int16-int8-lower.wasm-run.ok
 create mode 100644 test/trap/ok/outrange-int16-int8-lower.wasm-run.ret.ok
 create mode 100644 test/trap/ok/outrange-int16-int8-negation.run-ir.ok
 create mode 100644 test/trap/ok/outrange-int16-int8-negation.run-low.ok
 create mode 100644 test/trap/ok/outrange-int16-int8-negation.run.ok
 create mode 100644 test/trap/ok/outrange-int16-int8-negation.run.ret.ok
 create mode 100644 test/trap/ok/outrange-int16-int8-negation.wasm-run.ok
 create mode 100644 test/trap/ok/outrange-int16-int8-negation.wasm-run.ret.ok
 create mode 100644 test/trap/ok/outrange-int16-int8-upper.run-ir.ok
 create mode 100644 test/trap/ok/outrange-int16-int8-upper.run-low.ok
 create mode 100644 test/trap/ok/outrange-int16-int8-upper.run.ok
 create mode 100644 test/trap/ok/outrange-int16-int8-upper.run.ret.ok
 create mode 100644 test/trap/ok/outrange-int16-int8-upper.wasm-run.ok
 create mode 100644 test/trap/ok/outrange-int16-int8-upper.wasm-run.ret.ok
 create mode 100644 test/trap/ok/outrange-int32-int16-lower.run-ir.ok
 create mode 100644 test/trap/ok/outrange-int32-int16-lower.run-low.ok
 create mode 100644 test/trap/ok/outrange-int32-int16-lower.run.ok
 create mode 100644 test/trap/ok/outrange-int32-int16-lower.run.ret.ok
 create mode 100644 test/trap/ok/outrange-int32-int16-lower.wasm-run.ok
 create mode 100644 test/trap/ok/outrange-int32-int16-lower.wasm-run.ret.ok
 create mode 100644 test/trap/ok/outrange-int32-int16-negation.run-ir.ok
 create mode 100644 test/trap/ok/outrange-int32-int16-negation.run-low.ok
 create mode 100644 test/trap/ok/outrange-int32-int16-negation.run.ok
 create mode 100644 test/trap/ok/outrange-int32-int16-negation.run.ret.ok
 create mode 100644 test/trap/ok/outrange-int32-int16-negation.wasm-run.ok
 create mode 100644 test/trap/ok/outrange-int32-int16-negation.wasm-run.ret.ok
 create mode 100644 test/trap/ok/outrange-int32-int16-upper.run-ir.ok
 create mode 100644 test/trap/ok/outrange-int32-int16-upper.run-low.ok
 create mode 100644 test/trap/ok/outrange-int32-int16-upper.run.ok
 create mode 100644 test/trap/ok/outrange-int32-int16-upper.run.ret.ok
 create mode 100644 test/trap/ok/outrange-int32-int16-upper.wasm-run.ok
 create mode 100644 test/trap/ok/outrange-int32-int16-upper.wasm-run.ret.ok
 create mode 100644 test/trap/ok/outrange-int64-int32-lower.run-ir.ok
 create mode 100644 test/trap/ok/outrange-int64-int32-lower.run-low.ok
 create mode 100644 test/trap/ok/outrange-int64-int32-lower.run.ok
 create mode 100644 test/trap/ok/outrange-int64-int32-lower.run.ret.ok
 create mode 100644 test/trap/ok/outrange-int64-int32-lower.wasm-run.ok
 create mode 100644 test/trap/ok/outrange-int64-int32-lower.wasm-run.ret.ok
 create mode 100644 test/trap/ok/outrange-int64-int32-negation.run-ir.ok
 create mode 100644 test/trap/ok/outrange-int64-int32-negation.run-low.ok
 create mode 100644 test/trap/ok/outrange-int64-int32-negation.run.ok
 create mode 100644 test/trap/ok/outrange-int64-int32-negation.run.ret.ok
 create mode 100644 test/trap/ok/outrange-int64-int32-negation.wasm-run.ok
 create mode 100644 test/trap/ok/outrange-int64-int32-negation.wasm-run.ret.ok
 create mode 100644 test/trap/ok/outrange-int64-int32-upper.run-ir.ok
 create mode 100644 test/trap/ok/outrange-int64-int32-upper.run-low.ok
 create mode 100644 test/trap/ok/outrange-int64-int32-upper.run.ok
 create mode 100644 test/trap/ok/outrange-int64-int32-upper.run.ret.ok
 create mode 100644 test/trap/ok/outrange-int64-int32-upper.wasm-run.ok
 create mode 100644 test/trap/ok/outrange-int64-int32-upper.wasm-run.ret.ok
 create mode 100644 test/trap/ok/outrange-nat16-nat8.run-ir.ok
 create mode 100644 test/trap/ok/outrange-nat16-nat8.run-low.ok
 create mode 100644 test/trap/ok/outrange-nat16-nat8.run.ok
 create mode 100644 test/trap/ok/outrange-nat16-nat8.run.ret.ok
 create mode 100644 test/trap/ok/outrange-nat16-nat8.wasm-run.ok
 create mode 100644 test/trap/ok/outrange-nat16-nat8.wasm-run.ret.ok
 create mode 100644 test/trap/ok/outrange-nat32-nat16.run-ir.ok
 create mode 100644 test/trap/ok/outrange-nat32-nat16.run-low.ok
 create mode 100644 test/trap/ok/outrange-nat32-nat16.run.ok
 create mode 100644 test/trap/ok/outrange-nat32-nat16.run.ret.ok
 create mode 100644 test/trap/ok/outrange-nat32-nat16.wasm-run.ok
 create mode 100644 test/trap/ok/outrange-nat32-nat16.wasm-run.ret.ok
 create mode 100644 test/trap/ok/outrange-nat64-nat32.run-ir.ok
 create mode 100644 test/trap/ok/outrange-nat64-nat32.run-low.ok
 create mode 100644 test/trap/ok/outrange-nat64-nat32.run.ok
 create mode 100644 test/trap/ok/outrange-nat64-nat32.run.ret.ok
 create mode 100644 test/trap/ok/outrange-nat64-nat32.wasm-run.ok
 create mode 100644 test/trap/ok/outrange-nat64-nat32.wasm-run.ret.ok
 create mode 100644 test/trap/outrange-int16-int8-lower.mo
 create mode 100644 test/trap/outrange-int16-int8-negation.mo
 create mode 100644 test/trap/outrange-int16-int8-upper.mo
 create mode 100644 test/trap/outrange-int32-int16-lower.mo
 create mode 100644 test/trap/outrange-int32-int16-negation.mo
 create mode 100644 test/trap/outrange-int32-int16-upper.mo
 create mode 100644 test/trap/outrange-int64-int32-lower.mo
 create mode 100644 test/trap/outrange-int64-int32-negation.mo
 create mode 100644 test/trap/outrange-int64-int32-upper.mo
 create mode 100644 test/trap/outrange-nat16-nat8.mo
 create mode 100644 test/trap/outrange-nat32-nat16.mo
 create mode 100644 test/trap/outrange-nat64-nat32.mo

diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 00000000000..24fb13978cf
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,9 @@
+version: 2
+updates:
+  - package-ecosystem: github-actions
+    directory: "/"
+    schedule:
+      interval: daily
+      time: '00:00'
+      timezone: UTC
+    open-pull-requests-limit: 10
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 585967702d3..8a2b7ffec69 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -18,7 +18,7 @@ jobs:
   changelog:
     runs-on: 'ubuntu-latest'
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
 
     - name: Get the version
       id: get_version
@@ -47,8 +47,8 @@ jobs:
     needs: changelog
     runs-on: ${{ matrix.os }}
     steps:
-    - uses: actions/checkout@v3
-    - uses: cachix/install-nix-action@v22
+    - uses: actions/checkout@v4
+    - uses: cachix/install-nix-action@v23
     - uses: cachix/cachix-action@v12
       if: startsWith(github.ref, 'refs/heads/')
       with:
@@ -73,8 +73,8 @@ jobs:
     runs-on: 'ubuntu-latest'
     needs: [ changelog, build ]
     steps:
-    - uses: actions/checkout@v3
-    - uses: cachix/install-nix-action@v22
+    - uses: actions/checkout@v4
+    - uses: cachix/install-nix-action@v23
     - uses: cachix/cachix-action@v12
       with:
         name: ic-hs-test
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 22daf7cdb94..0e74c6c3c72 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -11,13 +11,13 @@ jobs:
       fail-fast: false
     runs-on: ${{ matrix.os }}
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
       with:
         # fetch full history so that git merge-base works
         fetch-depth: 0
         # fetch PR commit, not predicted merge commit
         ref: ${{ github.event.pull_request.head.sha }}
-    - uses: cachix/install-nix-action@v22
+    - uses: cachix/install-nix-action@v23
 
     # We are using the ic-hs-test cachix cache that is also used by
     # dfinity/ic-hs. This is partly laziness (on need to set up a separate
@@ -72,7 +72,7 @@ jobs:
     # motoko#2864.
     - name: Create or update performance comment
       if: github.actor != 'dependabot[bot]' && runner.os == 'Linux' && github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name == github.repository
-      uses: peter-evans/create-or-update-comment@v2
+      uses: peter-evans/create-or-update-comment@v3
       with:
         comment-id: ${{ steps.fc.outputs.comment-id }}
         issue-number: ${{ github.event.pull_request.number }}
@@ -87,8 +87,8 @@ jobs:
     concurrency: ci-${{ github.ref }}
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
-    - uses: cachix/install-nix-action@v22
+    - uses: actions/checkout@v4
+    - uses: cachix/install-nix-action@v23
     - uses: cachix/cachix-action@v12
       with:
         name: ic-hs-test
@@ -109,8 +109,8 @@ jobs:
     concurrency: ci-${{ github.ref }}
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
-    - uses: cachix/install-nix-action@v22
+    - uses: actions/checkout@v4
+    - uses: cachix/install-nix-action@v23
     - uses: cachix/cachix-action@v12
       with:
         name: ic-hs-test
diff --git a/.github/workflows/update-hash.yml b/.github/workflows/update-hash.yml
index dbc9726ea03..618a4f71636 100644
--- a/.github/workflows/update-hash.yml
+++ b/.github/workflows/update-hash.yml
@@ -12,11 +12,11 @@ jobs:
     if: github.actor != 'dependabot[bot]'
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
       with:
         # This is needed to be able to push and trigger CI with that push
         token: ${{ secrets.NIV_UPDATER_TOKEN }}
-    - uses: cachix/install-nix-action@v22
+    - uses: cachix/install-nix-action@v23
       with:
         nix_path: nixpkgs=channel:nixos-22.11
     - uses: cachix/cachix-action@v12
diff --git a/Changelog.md b/Changelog.md
index f049088d8e8..6d521c33c7e 100644
--- a/Changelog.md
+++ b/Changelog.md
@@ -1,5 +1,13 @@
 # Motoko compiler changelog
 
+## 0.9.8 (2023-08-11)
+
+* motoko (`moc`)
+
+  * Added numerical type conversions between adjacent fixed-width types (#4139).
+
+  * Administrative: legacy-named release artefacts are no longer created (#4111).
+
 ## 0.9.7 (2023-07-18)
 
 * motoko (`moc`)
diff --git a/default.nix b/default.nix
index 8a88072fdcf..cb1596ccc2d 100644
--- a/default.nix
+++ b/default.nix
@@ -467,7 +467,7 @@ rec {
   in fix_names ({
       run        = test_subdir "run"        [ moc ] ;
       run-dbg    = snty_subdir "run"        [ moc ] ;
-      ic-ref-run = test_subdir "run-drun"   [ moc ic-ref-run ];
+      # ic-ref-run = test_subdir "run-drun"   [ moc ic-ref-run ];
       drun       = test_subdir "run-drun"   [ moc nixpkgs.drun ];
       drun-dbg   = snty_subdir "run-drun"   [ moc nixpkgs.drun ];
       fail       = test_subdir "fail"       [ moc ];
@@ -546,7 +546,7 @@ rec {
     nixpkgs.rustPlatform.buildRustPackage {
       name = "ic-wasm";
       src = nixpkgs.sources.ic-wasm;
-      cargoSha256 = "sha256-iGCju0JG+jkysmDAeTfjNCYaSfg7N3Qqq8HpPlRHMgU=";
+      cargoSha256 = "sha256-qw1MwjlhGftN9k2sOjlAYo9rDRvHnf0qYQFPHMu2v74=";
       doCheck = false;
     };
 
@@ -731,7 +731,7 @@ rec {
       base-doc
       docs
       report-site
-      ic-ref-run
+      # ic-ref-run
       shell
       check-formatting
       check-rts-formatting
diff --git a/nix/sources.json b/nix/sources.json
index 5a5af2f0704..be583b7ea4f 100644
--- a/nix/sources.json
+++ b/nix/sources.json
@@ -51,10 +51,10 @@
         "homepage": null,
         "owner": "dfinity",
         "repo": "ic-wasm",
-        "rev": "42d911dd249ffb01c04ca429ae09006c2b047a3a",
-        "sha256": "11pf3b7650dpbkyg36b18yd91i3v5h8iksxsgz3y3lb45pyivx1j",
+        "rev": "0cc218f2c6d25a143371766f21243b3af0465ea7",
+        "sha256": "0y38kqjm5wddv93h0y1azyxknj8apff9pi6cs5x76s9h6pb9ys6g",
         "type": "tarball",
-        "url": "https://github.com/dfinity/ic-wasm/archive/42d911dd249ffb01c04ca429ae09006c2b047a3a.tar.gz",
+        "url": "https://github.com/dfinity/ic-wasm/archive/0cc218f2c6d25a143371766f21243b3af0465ea7.tar.gz",
         "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
     },
     "libtommath": {
@@ -75,10 +75,10 @@
         "homepage": null,
         "owner": "dfinity",
         "repo": "motoko-base",
-        "rev": "fbf51ef4e2d7aa215fac7f54406b28d0bc376321",
-        "sha256": "1y03xlmadgqmksqqh5h1cqr5zjy39l4p4mdcdc2kff8hhjsinsms",
+        "rev": "1f52c6b8fe64b15ae6ea68fc0fc2130b2112f6ce",
+        "sha256": "1vam0mbyia55a1ik8jylv1amvq8sm5ibshjcy8wkhzwmwqsjx35n",
         "type": "tarball",
-        "url": "https://github.com/dfinity/motoko-base/archive/fbf51ef4e2d7aa215fac7f54406b28d0bc376321.tar.gz",
+        "url": "https://github.com/dfinity/motoko-base/archive/1f52c6b8fe64b15ae6ea68fc0fc2130b2112f6ce.tar.gz",
         "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
     },
     "motoko-matchers": {
@@ -101,10 +101,10 @@
         "homepage": "https://wasi.dev",
         "owner": "WebAssembly",
         "repo": "wasi-libc",
-        "rev": "9f51a7102085ec6a6ced5778f0864c9af9f50000",
-        "sha256": "0j1ah34fmdsa1srsl49c8xly8bdg1cs7k2ji1avkv9d4dhmp2ls1",
+        "rev": "ec4566beae84e54952637f0bf61bee4b4cacc087",
+        "sha256": "0f739yhi5phs2g0p0bl2nx87qmcc4amq2c2nykdycr1lglvqq5yy",
         "type": "tarball",
-        "url": "https://github.com/WebAssembly/wasi-libc/archive/9f51a7102085ec6a6ced5778f0864c9af9f50000.tar.gz",
+        "url": "https://github.com/WebAssembly/wasi-libc/archive/ec4566beae84e54952637f0bf61bee4b4cacc087.tar.gz",
         "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
     },
     "nixpkgs": {
diff --git a/rts/motoko-rts/src/gc/incremental/partitioned_heap.rs b/rts/motoko-rts/src/gc/incremental/partitioned_heap.rs
index cffba859a10..e5005c46940 100644
--- a/rts/motoko-rts/src/gc/incremental/partitioned_heap.rs
+++ b/rts/motoko-rts/src/gc/incremental/partitioned_heap.rs
@@ -346,6 +346,7 @@ pub struct PartitionedHeap {
     bitmap_allocation_pointer: usize, // Free pointer for allocating the next mark bitmap.
     gc_running: bool, // Create bitmaps for partitions when allocated during active GC.
     precomputed_heap_size: usize, // Occupied heap size, excluding the dynamic heap in the allocation partition.
+    evacuated_size: usize, // Size of all evacuated objects during a GC run. Serves for accurate total allocation statistics.
 }
 
 impl PartitionedHeap {
@@ -382,6 +383,7 @@ impl PartitionedHeap {
             bitmap_allocation_pointer: 0,
             gc_running: false,
             precomputed_heap_size: heap_base,
+            evacuated_size: 0,
         }
     }
 
@@ -505,6 +507,7 @@ impl PartitionedHeap {
                 evacuation_space -= partition.marked_size();
                 partition.evacuate = true;
                 self.evacuating = true;
+                debug_assert_eq!(self.evacuated_size, 0);
             }
         }
     }
@@ -545,6 +548,7 @@ impl PartitionedHeap {
             }
         }
         self.evacuating = false;
+        self.evacuated_size = 0;
         self.bitmap_allocation_pointer = 0;
         debug_assert!(self.gc_running);
         self.gc_running = false;
@@ -610,6 +614,16 @@ impl PartitionedHeap {
         Bytes(self.reclaimed)
     }
 
+    pub fn increase_evacuated_size(&mut self, size: Words<u32>) {
+        self.evacuated_size += size.to_bytes().as_usize();
+    }
+
+    pub fn total_allocated_size(&self) -> Bytes<u64> {
+        debug_assert!(self.evacuated_size <= self.occupied_size().as_usize());
+        let heap_size_without_evacuations = self.occupied_size().as_usize() - self.evacuated_size;
+        Bytes(heap_size_without_evacuations as u64) + self.reclaimed_size()
+    }
+
     pub unsafe fn allocate<M: Memory>(&mut self, mem: &mut M, words: Words<u32>) -> Value {
         let size = words.to_bytes().as_usize();
         if size <= PARTITION_SIZE {
diff --git a/rts/motoko-rts/src/gc/incremental/phases/evacuation_increment.rs b/rts/motoko-rts/src/gc/incremental/phases/evacuation_increment.rs
index e59dc64ece5..730bc33e04f 100644
--- a/rts/motoko-rts/src/gc/incremental/phases/evacuation_increment.rs
+++ b/rts/motoko-rts/src/gc/incremental/phases/evacuation_increment.rs
@@ -79,6 +79,7 @@ impl<'a, M: Memory + 'a> EvacuationIncrement<'a, M> {
         debug_assert!(!original.is_forwarded());
         let size = block_size(original as usize);
         let new_address = self.mem.alloc_words(size);
+        self.heap.increase_evacuated_size(size);
         let copy = new_address.get_ptr() as *mut Obj;
         memcpy_words(copy as usize, original as usize, size);
         (*copy).forward = new_address;
@@ -88,7 +89,6 @@ impl<'a, M: Memory + 'a> EvacuationIncrement<'a, M> {
         // Marking is necessary to ensure field updates in the copy.
         let unmarked_before = self.heap.mark_object(copy);
         debug_assert!(unmarked_before);
-
         // Determined by measurements in comparison to the mark and update phases.
         const TIME_FRACTION_PER_WORD: f64 = 2.7;
         self.time
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index f452b15a39c..157e5f0625e 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -9311,7 +9311,106 @@ and compile_prim_invocation (env : E.t) ae p es at =
       SR.UnboxedFloat64,
       compile_exp_as env ae SR.UnboxedWord64 e ^^
       G.i (Convert (Wasm.Values.F64 F64Op.ConvertSI64))
-
+    | Nat8, Nat16 ->
+      SR.Vanilla,
+      compile_exp_vanilla env ae e ^^
+      compile_shrU_const 8l
+    | Nat16, Nat32 ->
+      SR.Vanilla,
+      compile_exp_vanilla env ae e ^^
+      compile_shrU_const 15l (* resulting Nat32 will always be unboxed *)
+    | Nat32, Nat64 ->
+      SR.UnboxedWord64,
+      compile_exp_as env ae SR.UnboxedWord32 e ^^
+      G.i (Convert (Wasm.Values.I64 I64Op.ExtendUI32))
+    | Nat16, (Nat8 as pty) ->
+      SR.Vanilla,
+      let num_bits = (TaggedSmallWord.bits_of_type pty) in
+      let set_val, get_val = new_local env "convertee" in
+      compile_exp_vanilla env ae e ^^
+      set_val ^^
+      get_val ^^
+      compile_shrU_const (Int32.of_int (32 - num_bits)) ^^
+      E.then_trap_with env "losing precision" ^^
+      get_val ^^
+      compile_shl_const (Int32.of_int num_bits)
+    | Nat32, (Nat16 as pty) ->
+      SR.Vanilla,
+      let num_bits = Int32.of_int (TaggedSmallWord.bits_of_type pty) in
+      let set_val, get_val = new_local env "convertee" in
+      compile_exp_as env ae SR.UnboxedWord32 e ^^
+      set_val ^^
+      get_val ^^
+      compile_shrU_const num_bits ^^
+      E.then_trap_with env "losing precision" ^^
+      get_val ^^
+      compile_shl_const num_bits
+    | Nat64, (Nat32 as pty) ->
+      SR.UnboxedWord32,
+      let num_bits = Int64.of_int (TaggedSmallWord.bits_of_type pty) in
+      let set_val, get_val = new_local64 env "convertee" in
+      compile_exp_as env ae SR.UnboxedWord64 e ^^
+      set_val ^^
+      get_val ^^
+      compile_shrU64_const num_bits ^^
+      G.i (Convert (Wasm.Values.I32 I32Op.WrapI64)) ^^
+      E.then_trap_with env "losing precision" ^^
+      get_val ^^
+      G.i (Convert (Wasm.Values.I32 I32Op.WrapI64))
+    | Int8, Int16 ->
+      SR.Vanilla,
+      compile_exp_vanilla env ae e ^^
+      compile_shrS_const 8l
+    | Int16, Int32 ->
+      SR.Vanilla,
+      compile_exp_vanilla env ae e ^^
+      compile_shrS_const 15l (* resulting Int32 will always be unboxed *)
+    | Int32, Int64 ->
+      SR.UnboxedWord64,
+      compile_exp_as env ae SR.UnboxedWord32 e ^^
+      G.i (Convert (Wasm.Values.I64 I64Op.ExtendSI32))
+    | Int16, (Int8 as pty) ->
+      SR.Vanilla,
+      let num_bits = (TaggedSmallWord.bits_of_type pty) in
+      let set_val, get_val = new_local env "convertee" in
+      compile_exp_vanilla env ae e ^^
+      set_val ^^
+      get_val ^^
+      compile_shl_const (Int32.of_int num_bits) ^^
+      compile_shrS_const (Int32.of_int num_bits) ^^
+      get_val ^^
+      compile_eq env Type.(Prim Nat16) ^^
+      E.else_trap_with env "losing precision" ^^
+      get_val ^^
+      compile_shl_const (Int32.of_int num_bits)
+    | Int32, (Int16 as pty) ->
+      SR.Vanilla,
+      let num_bits = (TaggedSmallWord.bits_of_type pty) in
+      let set_val, get_val = new_local env "convertee" in
+      compile_exp_as env ae SR.UnboxedWord32 e ^^
+      set_val ^^
+      get_val ^^
+      compile_shl_const (Int32.of_int num_bits) ^^
+      compile_shrS_const (Int32.of_int num_bits) ^^
+      get_val ^^
+      compile_eq env Type.(Prim Nat32) ^^
+      E.else_trap_with env "losing precision" ^^
+      get_val ^^
+      compile_shl_const (Int32.of_int num_bits)
+    | Int64, (Int32 as pty) ->
+      SR.UnboxedWord32,
+      let num_bits = (TaggedSmallWord.bits_of_type pty) in
+      let set_val, get_val = new_local64 env "convertee" in
+      compile_exp_as env ae SR.UnboxedWord64 e ^^
+      set_val ^^
+      get_val ^^
+      compile_shl64_const (Int64.of_int num_bits) ^^
+      compile_shrS64_const (Int64.of_int num_bits) ^^
+      get_val ^^
+      compile_eq env Type.(Prim Nat64) ^^
+      E.else_trap_with env "losing precision" ^^
+      get_val ^^
+      G.i (Convert (Wasm.Values.I32 I32Op.WrapI64))
     | _ -> SR.Unreachable, todo_trap env "compile_prim_invocation" (Arrange_ir.prim p)
     end
 
diff --git a/src/codegen/persistence.ml b/src/codegen/persistence.ml
index ebcc0fa82f3..549519159ba 100644
--- a/src/codegen/persistence.ml
+++ b/src/codegen/persistence.ml
@@ -119,7 +119,7 @@ and resolve_field_list field_list type_arguments =
   let open Type in
   let resolve_field field = 
     let resolved_field_type = resolve_generics field.typ type_arguments in
-    { lab = field.lab; typ = resolved_field_type; depr = field.depr } in
+    { lab = field.lab; typ = resolved_field_type; src = field.src } in
   List.map resolve_field field_list
 
 and resolve_type_list type_list type_arguments =
@@ -273,7 +273,7 @@ let encode_stable_type (stable_type: Type.typ) : string =
   let open Type in 
   match stable_type with
   | Obj (Memory, field_list) -> 
-      let unwrap_field field = {lab = field.lab; typ = unwrap_optional field.typ; depr = field.depr} in
+      let unwrap_field field = {lab = field.lab; typ = unwrap_optional field.typ; src = field.src} in
       let stable_fields = List.map unwrap_field field_list in
       let stable_actor = Obj (Object, stable_fields) in
       let table = collect_type TypeTable.empty stable_actor in
diff --git a/src/idllib/arrange_idl.ml b/src/idllib/arrange_idl.ml
index 69e0a853a10..6f7567dbd32 100644
--- a/src/idllib/arrange_idl.ml
+++ b/src/idllib/arrange_idl.ml
@@ -77,174 +77,216 @@ and prog prog = "Decs" $$ List.map dec prog.it.decs @ [actor prog.it.actor]
 
 
 (* Pretty printing  *)
-open Format
-let str ppf s = pp_print_string ppf s
-let space = pp_print_space
-let kwd ppf s = str ppf s; space ppf ()
-let quote ppf s =
-  pp_open_hbox ppf ();
-  str ppf "\""; str ppf (Lib.String.lightweight_escaped s); str ppf "\"";
-  pp_close_box ppf ()
-let text ppf s =
-  if Escape.needs_candid_quote s then quote ppf s else str ppf s
-
-let rec pp_typ ppf t =
-  pp_open_hovbox ppf 1;
-  (match t.it with
-  | VarT id -> str ppf id.it
-  | PrimT p -> str ppf (string_of_prim p)
-  | OptT t -> kwd ppf "opt"; pp_typ ppf t
-  | VecT t -> kwd ppf "vec"; pp_typ ppf t
-  | BlobT -> str ppf "blob"
-  | RecordT fs -> pp_fields ppf "record" fs
-  | VariantT fs -> pp_fields ppf "variant" fs
-  | FuncT (ms,s,t) ->
-     kwd ppf "func";
-     pp_func ppf (ms,s,t)
-  | ServT ms ->
-     pp_open_vbox ppf 2;
-     str ppf "service {";
-     List.iter (fun m -> pp_print_cut ppf (); pp_meth ppf m; str ppf ";") ms;
-     pp_print_break ppf 0 (-2);
-     str ppf "}";
-     pp_close_box ppf ()
-  | PrincipalT -> str ppf "principal"
-  | ClassT _ -> assert false
-  | PreT -> assert false);
-  pp_close_box ppf ()
-and pp_fields ppf name fs =
-  let is_variant = name = "variant" in
-  if List.length fs > 1 then
-    pp_open_vbox ppf 2
-  else
-    pp_open_hovbox ppf 2;
-  str ppf (name ^ " {");
-  List.iter (fun f -> pp_print_cut ppf (); pp_field ppf is_variant f; str ppf ";") fs;
-  pp_print_break ppf 0 (-2);
-  str ppf "}";
-  pp_close_box ppf ()
-and pp_field ppf is_variant f =
-  let hide_type = is_variant && f.it.typ.it = PrimT Null in
-  pp_open_hovbox ppf 1;
-  (match f.it.label.it with
-  | Named name ->
-     text ppf name;
-     if not hide_type then
-       (kwd ppf ":"; pp_typ ppf f.it.typ)
-  | Id n ->
-     str ppf (Lib.Uint32.to_string n);
-     if not hide_type then
-       (kwd ppf ":"; pp_typ ppf f.it.typ)
-  | Unnamed _ -> pp_typ ppf f.it.typ);
-  pp_close_box ppf ()
-
-and pp_func ppf (ms,s,t) =
-  pp_args ppf s;
-  kwd ppf " ->";
-  pp_args ppf t;
-  List.iter (fun m -> str ppf (string_of_mode m)) ms
-
-and pp_args ppf fs =
-  let n = List.length fs in
-  str ppf "(";
-  List.iteri (fun i f ->
-      pp_typ ppf f;
-      if i < n-1 then
-        kwd ppf ",";
-    ) fs;
-  str ppf ")"
-
-and pp_meth ppf m =
-  pp_open_hovbox ppf 1;
-  text ppf m.it.var.it;
-  kwd ppf ":";
-  (match m.it.meth.it with
-   | FuncT (ms,s,t) -> pp_func ppf (ms,s,t)
-   | _ -> pp_typ ppf m.it.meth);
-  pp_close_box ppf ()
-
-let rec is_linebreak_type t =
-  match t.it with
-  | ServT _ -> true
-  | RecordT fs | VariantT fs -> List.length fs > 1
-  | VecT t | OptT t -> is_linebreak_type t
-  | _ -> false
-
-let pp_dec ppf d =
-  pp_open_vbox ppf 1;
-  (match d.it with
-   | TypD (id, typ) ->
+module type Config = sig
+  val trivia : Trivia.trivia_info Trivia.PosHashtbl.t option
+end
+
+module Default = struct
+  let trivia = None
+end
+
+module Make (Cfg : Config) = struct
+  open Format
+  let str ppf s = pp_print_string ppf s
+  let space = pp_print_space
+  let kwd ppf s = str ppf s; space ppf ()
+  let quote ppf s =
+    pp_open_hbox ppf ();
+    str ppf "\""; str ppf (Lib.String.lightweight_escaped s); str ppf "\"";
+    pp_close_box ppf ()
+  let text ppf s =
+    if Escape.needs_candid_quote s then quote ppf s else str ppf s
+
+  let rec pp_typ ppf t =
+    pp_open_hovbox ppf 1;
+    (match t.it with
+    | VarT id -> str ppf id.it
+    | PrimT p -> str ppf (string_of_prim p)
+    | OptT t -> kwd ppf "opt"; pp_typ ppf t
+    | VecT t -> kwd ppf "vec"; pp_typ ppf t
+    | BlobT -> str ppf "blob"
+    | RecordT fs -> pp_fields ppf "record" fs
+    | VariantT fs -> pp_fields ppf "variant" fs
+    | FuncT (ms,s,t) ->
+      kwd ppf "func";
+      pp_func ppf (ms,s,t)
+    | ServT ms ->
+      pp_open_vbox ppf 2;
+      str ppf "service {";
+      List.iter (fun m -> pp_print_cut ppf (); pp_meth ppf m; str ppf ";") ms;
+      pp_print_break ppf 0 (-2);
+      str ppf "}";
+      pp_close_box ppf ()
+    | PrincipalT -> str ppf "principal"
+    | ClassT _ -> assert false
+    | PreT -> assert false);
+    pp_close_box ppf ()
+  and pp_fields ppf name fs =
+    let is_variant = name = "variant" in
+    if List.length fs > 1 then
+      pp_open_vbox ppf 2
+    else
+      pp_open_hovbox ppf 2;
+    str ppf (name ^ " {");
+    List.iter (fun f -> pp_print_cut ppf (); pp_field ppf is_variant f; str ppf ";") fs;
+    pp_print_break ppf 0 (-2);
+    str ppf "}";
+    pp_close_box ppf ()
+  and pp_field ppf is_variant f =
+    pp_doc ppf f.at;
+    let hide_type = is_variant && f.it.typ.it = PrimT Null in
+    pp_open_hovbox ppf 1;
+    (match f.it.label.it with
+    | Named name ->
+      text ppf name;
+      if not hide_type then
+        (kwd ppf ":"; pp_typ ppf f.it.typ)
+    | Id n ->
+      str ppf (Lib.Uint32.to_string n);
+      if not hide_type then
+        (kwd ppf ":"; pp_typ ppf f.it.typ)
+    | Unnamed _ -> pp_typ ppf f.it.typ);
+    pp_close_box ppf ()
+
+  and pp_func ppf (ms,s,t) =
+    pp_args ppf s;
+    kwd ppf " ->";
+    pp_args ppf t;
+    List.iter (fun m -> str ppf (string_of_mode m)) ms
+
+  and pp_args ppf fs =
+    let n = List.length fs in
+    str ppf "(";
+    List.iteri (fun i f ->
+        pp_typ ppf f;
+        if i < n-1 then
+          kwd ppf ",";
+      ) fs;
+    str ppf ")"
+
+  and pp_meth ppf m =
+    pp_doc ppf m.at;
+    pp_open_hovbox ppf 1;
+    text ppf m.it.var.it;
+    kwd ppf ":";
+    (match m.it.meth.it with
+    | FuncT (ms,s,t) -> pp_func ppf (ms,s,t)
+    | _ -> pp_typ ppf m.it.meth);
+    pp_close_box ppf ()
+
+  and pp_doc ppf at =
+    let open Trivia in
+    match Cfg.trivia with
+    | Some t ->
+      let pos = { line = at.left.line; column = at.left.column } in
+      let trivia = PosHashtbl.find_opt t pos in
+      (match trivia with
+      | Some t ->
+        List.iter (function
+        | LineComment s ->
+          str ppf "/// ";
+          str ppf s;
+          pp_force_newline ppf ()
+        | BlockComment s ->
+          List.iter (fun line ->
+            if String.length line > 0 then (
+              str ppf "/// ";
+              str ppf line;
+              pp_force_newline ppf ()))
+          (String.split_on_char '\n' s))
+        (docs_of_trivia_info t)
+      | None -> ())
+    | None -> ()
+
+  let rec is_linebreak_type t =
+    match t.it with
+    | ServT _ -> true
+    | RecordT fs | VariantT fs -> List.length fs > 1
+    | VecT t | OptT t -> is_linebreak_type t
+    | _ -> false
+
+  let pp_dec ppf d =
+    pp_doc ppf d.at;
+    pp_open_vbox ppf 1;
+    (match d.it with
+    | TypD (id, typ) ->
+        pp_open_hbox ppf ();
+        kwd ppf "type";
+        kwd ppf id.it;
+        kwd ppf "=";
+        pp_close_box ppf ();
+        if is_linebreak_type typ then
+          pp_print_cut ppf ();
+        pp_typ ppf typ
+    | ImportD (f, fp) ->
+        str ppf "import \"";
+        str ppf f;
+        str ppf "\""
+    );
+    pp_close_box ppf ()
+
+  let pp_actor ppf actor =
+    Option.iter (fun a -> pp_doc ppf a.at) actor;
+    (match actor with
+    | None -> ()
+    | Some {it=ServT ms; _} ->
+      pp_open_vbox ppf 2;
       pp_open_hbox ppf ();
-      kwd ppf "type";
-      kwd ppf id.it;
-      kwd ppf "=";
+      str ppf "service : {";
       pp_close_box ppf ();
-      if is_linebreak_type typ then
-        pp_print_cut ppf ();
-      pp_typ ppf typ
-   | ImportD (f, fp) ->
-      str ppf "import \"";
-      str ppf f;
-      str ppf "\""
-  );
-  pp_close_box ppf ()
-
-let pp_actor ppf actor =
-  (match actor with
-  | None -> ()
-  | Some {it=ServT ms; _} ->
-     pp_open_vbox ppf 2;
-     pp_open_hbox ppf ();
-     str ppf "service : {";
-     pp_close_box ppf ();
-     List.iter (fun m -> pp_print_cut ppf (); pp_meth ppf m; str ppf ";") ms;
-     pp_print_break ppf 0 (-2);
-     str ppf "}";
-     pp_close_box ppf ()
-  | Some {it=VarT x; _} ->
-     pp_open_hbox ppf ();
-     kwd ppf "service";
-     kwd ppf ":";
-     str ppf x.it;
-     pp_close_box ppf ()
-  | Some {it=ClassT(args, t); _} ->
-     pp_open_hbox ppf ();
-     kwd ppf "service";
-     kwd ppf ":";
-     pp_args ppf args;
-     str ppf " -> ";
-     pp_typ ppf t;
-     pp_close_box ppf ()
-  | _ -> assert false);
-  pp_print_cut ppf ()
-
-let pp_prog ppf prog =
-  pp_open_vbox ppf 0;
-  List.iter (fun d ->
-      pp_dec ppf d;
-      str ppf ";";
-      pp_print_cut ppf ()
-    ) prog.it.decs;
-  pp_actor ppf prog.it.actor;
-  pp_close_box ppf ()
-
-let string_of_typ t =
-  let buf = Buffer.create 100 in
-  let ppf = formatter_of_buffer buf in
-  pp_typ ppf t;
-  pp_print_flush ppf ();
-  Buffer.contents buf
-
-let string_of_prog prog =
-  let buf = Buffer.create 100 in
-  let ppf = formatter_of_buffer buf in
-  pp_prog ppf prog;
-  pp_print_flush ppf ();
-  Buffer.contents buf
-
-let string_of_args ts =
-  let buf = Buffer.create 100 in
-  let ppf = formatter_of_buffer buf in
-  pp_args ppf ts;
-  pp_print_flush ppf ();
-  Buffer.contents buf
+      List.iter (fun m -> pp_print_cut ppf (); pp_meth ppf m; str ppf ";") ms;
+      pp_print_break ppf 0 (-2);
+      str ppf "}";
+      pp_close_box ppf ()
+    | Some {it=VarT x; _} ->
+      pp_open_hbox ppf ();
+      kwd ppf "service";
+      kwd ppf ":";
+      str ppf x.it;
+      pp_close_box ppf ()
+    | Some {it=ClassT(args, t); _} ->
+      pp_open_hbox ppf ();
+      kwd ppf "service";
+      kwd ppf ":";
+      pp_args ppf args;
+      str ppf " -> ";
+      pp_typ ppf t;
+      pp_close_box ppf ()
+    | _ -> assert false);
+    pp_print_cut ppf ()
+
+  let pp_prog ppf prog =
+    pp_open_vbox ppf 0;
+    List.iter (fun d ->
+        pp_dec ppf d;
+        str ppf ";";
+        pp_print_cut ppf ()
+      ) prog.it.decs;
+    pp_doc ppf prog.at;
+    pp_actor ppf prog.it.actor;
+    pp_close_box ppf ()
+
+  let string_of_typ t =
+    let buf = Buffer.create 100 in
+    let ppf = formatter_of_buffer buf in
+    pp_typ ppf t;
+    pp_print_flush ppf ();
+    Buffer.contents buf
+
+  let string_of_prog prog =
+    let buf = Buffer.create 100 in
+    let ppf = formatter_of_buffer buf in
+    pp_prog ppf prog;
+    pp_print_flush ppf ();
+    Buffer.contents buf
+
+  let string_of_args ts =
+    let buf = Buffer.create 100 in
+    let ppf = formatter_of_buffer buf in
+    pp_args ppf ts;
+    pp_print_flush ppf ();
+    Buffer.contents buf
+end
+
+(* Defaults *)
+include Make (Default)
diff --git a/src/idllib/parser.mly b/src/idllib/parser.mly
index b42f5f0607d..bf5e9451e2d 100644
--- a/src/idllib/parser.mly
+++ b/src/idllib/parser.mly
@@ -204,7 +204,9 @@ actor :
 
 parse_prog :
   | ds=seplist(def, SEMICOLON) actor=actor EOF
-    { fun filename -> { it = {decs=ds; actor=actor}; at = at $sloc; note = filename} }
+    {
+      let trivia = Trivia.PosHashtbl.create 0 in
+      fun filename -> {it = {decs=ds; actor=actor}; at = at $sloc; note = {filename; trivia}} }
 
 (* Values *)
 
@@ -285,6 +287,6 @@ test :
 
 parse_tests :
   | tdecs=endlist(def, SEMICOLON) tests=seplist(test, SEMICOLON) EOF
-    { fun filename -> { it = {tdecs; tests}; at = at $sloc; note = filename} }
+    { fun filename -> {it = {tdecs; tests}; at = at $sloc; note = filename} }
 
 %%
diff --git a/src/idllib/pipeline.ml b/src/idllib/pipeline.ml
index 309084379c6..bf2524af406 100644
--- a/src/idllib/pipeline.ml
+++ b/src/idllib/pipeline.ml
@@ -67,7 +67,7 @@ let parse_file filename : parse_result =
 
 let check_prog senv prog
   : (Typing.scope * Syntax.typ option) Diag.result =
-  phase "Checking" prog.Source.note;
+  phase "Checking" prog.Source.note.Syntax.filename;
   let r = Typing.check_prog senv prog in
   (match r with
    | Ok ((scope, _), _) ->
diff --git a/src/idllib/syntax.ml b/src/idllib/syntax.ml
index 47001fa4c82..e91395b1f36 100644
--- a/src/idllib/syntax.ml
+++ b/src/idllib/syntax.ml
@@ -62,7 +62,8 @@ and dec' =
 
 (* Program *)
 
-type prog = (prog', string) Source.annotated_phrase
+type prog_note = { filename : string; trivia : Trivia.triv_table }
+type prog = (prog', prog_note) Source.annotated_phrase
 and prog' = { decs : dec list; actor : typ option }
 
 (* Values *)
diff --git a/src/ir_def/check_ir.ml b/src/ir_def/check_ir.ml
index 331b311011d..222d70368e1 100644
--- a/src/ir_def/check_ir.ml
+++ b/src/ir_def/check_ir.ml
@@ -451,7 +451,7 @@ let rec check_exp env (exp:Ir.exp) : unit =
     | OptPrim, [exp1] ->
       T.Opt (typ exp1) <: t
     | TagPrim i, [exp1] ->
-      T.Variant [{T.lab = i; typ = typ exp1; depr = None}] <: t
+      T.Variant [{T.lab = i; typ = typ exp1; src = T.empty_src}] <: t
     | ActorDotPrim n, [exp1]
     | DotPrim n, [exp1] ->
       begin
@@ -1037,7 +1037,7 @@ and check_pat_fields env t = List.iter (check_pat_field env t)
 
 and check_pat_field env t (pf : pat_field) =
   let lab = pf.it.name in
-  let tf = T.{lab; typ = pf.it.pat.note; depr = None} in
+  let tf = T.{lab; typ = pf.it.pat.note; src = empty_src} in
   let s, tfs = T.as_obj_sub [lab] t in
   let (<:) = check_sub env pf.it.pat.at in
   t <: T.Obj (s, [tf]);
@@ -1072,7 +1072,7 @@ and type_exp_field env s f : T.field =
     check env f.at ((s = T.Actor) ==> T.is_shared_func t)
       "public actor field must have shared function type";
   end;
-  T.{lab = name; typ = t; depr = None}
+  T.{lab = name; typ = t; src = empty_src}
 
 (* Declarations *)
 
diff --git a/src/ir_def/construct.ml b/src/ir_def/construct.ml
index 597fa7a81f3..2a10026ee81 100644
--- a/src/ir_def/construct.ml
+++ b/src/ir_def/construct.ml
@@ -220,7 +220,7 @@ let optE e =
 
 let tagE i e =
  { it = PrimE (TagPrim i, [e]);
-   note = Note.{ def with typ = T.Variant [{T.lab = i; typ = typ e; depr = None}]; eff = eff e };
+   note = Note.{ def with typ = T.Variant [{T.lab = i; typ = typ e; src = T.empty_src}]; eff = eff e };
    at = no_region;
  }
 
diff --git a/src/ir_passes/async.ml b/src/ir_passes/async.ml
index 2145747cbea..5d4a000cabf 100644
--- a/src/ir_passes/async.ml
+++ b/src/ir_passes/async.ml
@@ -229,8 +229,8 @@ let transform prog =
 
   and t_prim p = Ir.map_prim t_typ (fun id -> id) p
 
-  and t_field {lab; typ; depr} =
-    { lab; typ = t_typ typ; depr }
+  and t_field {lab; typ; src} =
+    { lab; typ = t_typ typ; src }
   in
 
   let rec t_exp (exp: exp) =
diff --git a/src/ir_passes/erase_typ_field.ml b/src/ir_passes/erase_typ_field.ml
index 57db7be0994..3a999ebe0a9 100644
--- a/src/ir_passes/erase_typ_field.ml
+++ b/src/ir_passes/erase_typ_field.ml
@@ -85,8 +85,8 @@ let transform prog =
 
   and t_prim p = Ir.map_prim t_typ (fun id -> id) p
 
-  and t_field {lab; typ; depr} =
-    { lab; typ = t_typ typ; depr }
+  and t_field {lab; typ; src} =
+    { lab; typ = t_typ typ; src }
   in
 
   let rec t_exp (exp : exp) =
diff --git a/src/js/common.ml b/src/js/common.ml
index 3e3f623ad03..e4ecab8d43e 100644
--- a/src/js/common.ml
+++ b/src/js/common.ml
@@ -104,7 +104,9 @@ let js_candid source =
   Mo_types.Cons.session (fun _ -> 
     js_result (Pipeline.generate_idl [Js.to_string source])
       (fun prog ->
-        let code = Idllib.Arrange_idl.string_of_prog prog in
+        let open Idllib in
+        let module WithComments = Arrange_idl.Make(struct let trivia = Some prog.note.Syntax.trivia end) in
+        let code = WithComments.string_of_prog prog in
         Js.some (Js.string code)))
 
 let js_stable_compatible pre post =
diff --git a/src/mo_def/trivia.ml b/src/lang_utils/trivia.ml
similarity index 62%
rename from src/mo_def/trivia.ml
rename to src/lang_utils/trivia.ml
index 0444c5ce2fb..646469cbe8d 100644
--- a/src/mo_def/trivia.ml
+++ b/src/lang_utils/trivia.ml
@@ -33,6 +33,11 @@ type trivia_info = {
   trailing_trivia : void trivia list;
 }
 
+let string_of_trivia_info (info : trivia_info) : string =
+    let leading = List.map (string_of_trivia string_of_line_feed) info.leading_trivia |> String.concat ", " in
+    let trailing = List.map (string_of_trivia (fun _ -> "")) info.trailing_trivia |> String.concat ", " in
+    Printf.sprintf "Leading: [%s]; Trailing: [%s]" leading trailing
+
 type pos = { line : int; column : int }
 
 let pos_of_lexpos : Lexing.position -> pos =
@@ -76,24 +81,29 @@ let deprecated_of_trivia_info : trivia_info -> string option =
   in
   if lines = [] then None else Some (String.concat "\n" lines)
 
-let doc_comment_of_trivia_info : trivia_info -> string option =
- fun info ->
-  let lines =
-    List.filter_map
-      (function
-        | Comment s -> (
-            match Lib.String.chop_prefix "///" s with
-            | Some "" -> Some ""
-            | Some line_comment ->
-                (* We expect a documentation line comment to start with a space
-                 *  (which we remove here) *)
-                Lib.String.chop_prefix " " line_comment
-            | None ->
-                Option.bind
-                  (Lib.String.chop_prefix "/**" s)
-                  (Lib.String.chop_suffix "*/")
-                |> Option.map String.trim )
-        | _ -> None)
-      info.leading_trivia
-  in
+type doc = LineComment of string | BlockComment of string
+
+let docs_of_trivia_info (info : trivia_info) : doc list =
+  List.filter_map
+    (function
+      | Comment s -> (
+          match Lib.String.chop_prefix "///" s with
+          | Some "" -> Some (LineComment "")
+          | Some line_comment ->
+              (* We expect a documentation line comment to start with a space
+              *  (which we remove here) *)
+              Lib.String.chop_prefix " " line_comment
+              |> Option.map (fun c -> LineComment c)
+          | None ->
+              Option.bind
+                (Lib.String.chop_prefix "/**" s)
+                (Lib.String.chop_suffix "*/")
+              |> Option.map String.trim
+              |> Option.map (fun c -> BlockComment c))
+      | _ -> None)
+    info.leading_trivia
+ 
+let doc_comment_of_trivia_info (info : trivia_info) : string option =
+  let docs = docs_of_trivia_info info in
+  let lines = List.map (function BlockComment s | LineComment s -> s) docs in
   if lines = [] then None else Some (String.concat "\n" lines)
diff --git a/src/mo_def/trivia.mli b/src/lang_utils/trivia.mli
similarity index 84%
rename from src/mo_def/trivia.mli
rename to src/lang_utils/trivia.mli
index 78b28f16348..71b99fdf2b8 100644
--- a/src/mo_def/trivia.mli
+++ b/src/lang_utils/trivia.mli
@@ -19,8 +19,14 @@ type trivia_info = {
   trailing_trivia : void trivia list;
 }
 
+val string_of_trivia_info : trivia_info -> string
+
 val deprecated_of_trivia_info : trivia_info -> string option
 
+type doc = LineComment of string | BlockComment of string
+
+val docs_of_trivia_info : trivia_info -> doc list
+
 val doc_comment_of_trivia_info : trivia_info -> string option
 
 type pos = { line : int; column : int }
diff --git a/src/lowering/desugar.ml b/src/lowering/desugar.ml
index d2006b61651..502ea6e5484 100644
--- a/src/lowering/desugar.ml
+++ b/src/lowering/desugar.ml
@@ -357,9 +357,9 @@ and call_system_func_opt name es obj_typ =
           let msg = fresh_var "msg" msg_typ in
           let record_typ =
             T.Obj (T.Object, List.sort T.compare_field
-             [{T.lab = "caller"; T.typ = typ_of_var caller; T.depr = None};
-               {T.lab = "arg"; T.typ = typ_of_var arg; T.depr = None};
-               {T.lab = "msg"; T.typ = typ_of_var msg; T.depr = None}])
+             [{T.lab = "caller"; T.typ = typ_of_var caller; T.src = T.empty_src};
+               {T.lab = "arg"; T.typ = typ_of_var arg; T.src = T.empty_src};
+               {T.lab = "msg"; T.typ = typ_of_var msg; T.src = T.empty_src}])
           in
           let record = fresh_var "record" record_typ in
           let msg_variant =
@@ -403,10 +403,12 @@ and call_system_func_opt name es obj_typ =
           callE (varE (var id.it note)) [] (tupE []))
     | _ -> None) es
 and build_candid ts obj_typ =
+  let open Idllib in
   let (args, prog) = Mo_idl.Mo_to_idl.of_service_type ts obj_typ in
+  let module WithComments = Arrange_idl.Make(struct let trivia = Some prog.note.Syntax.trivia end) in
   I.{
-   args = Idllib.Arrange_idl.string_of_args args;
-   service = Idllib.Arrange_idl.string_of_prog prog;
+   args = WithComments.string_of_args args;
+   service = WithComments.string_of_prog prog;
   }
 
 and export_interface txt =
@@ -434,7 +436,7 @@ and export_footprint self_id expr =
   let scope_con2 = Cons.fresh "T2" (Abs ([], Any)) in
   let bind1  = typ_arg scope_con1 Scope scope_bound in
   let bind2 = typ_arg scope_con2 Scope scope_bound in
-  let ret_typ = T.Obj(Object,[{lab = "size"; typ = T.nat64; depr = None}]) in
+  let ret_typ = T.Obj(Object,[{lab = "size"; typ = T.nat64; src = empty_src}]) in
   let caller = fresh_var "caller" caller in
   ([ letD (var v typ) (
        funcE v (Shared Query) Promises [bind1] [] [ret_typ] (
@@ -465,9 +467,9 @@ and build_actor at ts self_id es obj_typ =
   let idss = List.map fst pairs in
   let ids = List.concat idss in
   let sig_ = List.sort T.compare_field
-    (List.map (fun (i,t) -> T.{lab = i; typ = t; depr = None}) ids)
+    (List.map (fun (i,t) -> T.{lab = i; typ = t; src = empty_src}) ids)
   in
-  let fields = List.map (fun (i,t) -> T.{lab = i; typ = T.Opt (T.as_immut t); depr = None}) ids in
+  let fields = List.map (fun (i,t) -> T.{lab = i; typ = T.Opt (T.as_immut t); src = T.empty_src}) ids in
   let mk_ds = List.map snd pairs in
   let ty = T.Obj (T.Memory, List.sort T.compare_field fields) in
   let state = fresh_var "state" (T.Mut (T.Opt ty)) in
diff --git a/src/mo_frontend/lexer.ml b/src/mo_frontend/lexer.ml
index f7355ef19ae..c4bfb2a15ae 100644
--- a/src/mo_frontend/lexer.ml
+++ b/src/mo_frontend/lexer.ml
@@ -1,5 +1,5 @@
 module ST = Source_token
-open Mo_def.Trivia
+open Trivia
 include Lexer_lib
 
 type source_token = ST.token * Lexing.position * Lexing.position
diff --git a/src/mo_frontend/lexer.mli b/src/mo_frontend/lexer.mli
index 90cda6f34ea..99da41c4b39 100644
--- a/src/mo_frontend/lexer.mli
+++ b/src/mo_frontend/lexer.mli
@@ -11,7 +11,7 @@
 *)
 
 module ST = Source_token
-open Mo_def.Trivia
+open Trivia
 
 include module type of Lexer_lib
 
diff --git a/src/mo_frontend/parser_lib.ml b/src/mo_frontend/parser_lib.ml
index 3c22db4836b..90196bb0e2b 100644
--- a/src/mo_frontend/parser_lib.ml
+++ b/src/mo_frontend/parser_lib.ml
@@ -4,4 +4,4 @@ exception Imports of Mo_def.Syntax.dec list
 let msg_store : Diag.msg_store option ref = ref None
 let mode : Lexer_lib.mode option ref = ref None
 
-let triv_table : Mo_def.Trivia.triv_table ref = ref Mo_def.Trivia.empty_triv_table
+let triv_table : Trivia.triv_table ref = ref Trivia.empty_triv_table
diff --git a/src/mo_frontend/source_lexer.mll b/src/mo_frontend/source_lexer.mll
index 67f05c6d6de..ad9de260ff0 100644
--- a/src/mo_frontend/source_lexer.mll
+++ b/src/mo_frontend/source_lexer.mll
@@ -1,5 +1,5 @@
 {
-open Mo_def.Trivia
+open Trivia
 open Source_token
 open Lexer_lib
 module Utf8 = Lib.Utf8
diff --git a/src/mo_frontend/source_token.ml b/src/mo_frontend/source_token.ml
index 01568a63e07..1d385c23288 100644
--- a/src/mo_frontend/source_token.ml
+++ b/src/mo_frontend/source_token.ml
@@ -1,4 +1,4 @@
-open Mo_def.Trivia
+open Trivia
 
 type token =
   | EOF
diff --git a/src/mo_frontend/typing.ml b/src/mo_frontend/typing.ml
index 3707390b9ed..de5322f6d39 100644
--- a/src/mo_frontend/typing.ml
+++ b/src/mo_frontend/typing.ml
@@ -22,7 +22,8 @@ type ret_env = T.typ option
 type val_env  = (T.typ * avl) T.Env.t
 
 (* separate maps for values and types; entries only for _public_ elements *)
-type visibility_env = (region * string option) T.Env.t * (region * string option) T.Env.t
+type visibility_src = {depr : string option; id_region : Source.region; field_region : Source.region}
+type visibility_env = visibility_src T.Env.t * visibility_src T.Env.t
 
 let available env = T.Env.map (fun ty -> (ty, Available)) env
 
@@ -233,9 +234,9 @@ let system_funcs tfs =
      (let msg_typ = T.decode_msg_typ tfs in
       let record_typ =
         T.Obj (T.Object, List.sort T.compare_field
-          [{T.lab = "caller"; T.typ = T.principal; T.depr = None};
-           {T.lab = "arg"; T.typ = T.blob; T.depr = None};
-           {T.lab = "msg"; T.typ = msg_typ; T.depr = None}])
+          [{T.lab = "caller"; T.typ = T.principal; T.src = T.empty_src};
+           {T.lab = "arg"; T.typ = T.blob; T.src = T.empty_src};
+           {T.lab = "msg"; T.typ = msg_typ; T.src = T.empty_src}])
       in
         T.Func (T.Local, T.Returns, [],  [record_typ], [T.bool])))
   ]
@@ -604,16 +605,16 @@ and check_typ_field env s typ_field : T.field = match typ_field.it with
         error env typ.at "M0042" "actor field %s must have shared function type, but has type\n  %s"
           id.it (T.string_of_typ_expand t)
     end;
-    T.{lab = id.it; typ = t; depr = None}
+    T.{lab = id.it; typ = t; src = empty_src}
   | TypF (id, typ_binds, typ) ->
     let k = check_typ_def env typ_field.at (id, typ_binds, typ) in
     let c = Cons.fresh id.it k in
-    T.{lab = id.it; typ = Typ c; depr = None}
+    T.{lab = id.it; typ = Typ c; src = empty_src}
 
 and check_typ_tag env typ_tag =
   let {tag; typ} = typ_tag.it in
   let t = check_typ env typ in
-  T.{lab = tag.it; typ = t; depr = None}
+  T.{lab = tag.it; typ = t; src = empty_src}
 
 and check_typ_binds_acyclic env typ_binds cs ts  =
   let n = List.length cs in
@@ -933,28 +934,28 @@ let check_lit env t lit at =
 let array_obj t =
   let open T in
   let immut t =
-    [ {lab = "get";  typ = Func (Local, Returns, [], [Prim Nat], [t]); depr = None};
-      {lab = "size";  typ = Func (Local, Returns, [], [], [Prim Nat]); depr = None};
-      {lab = "keys"; typ = Func (Local, Returns, [], [], [iter_obj (Prim Nat)]); depr = None};
-      {lab = "vals"; typ = Func (Local, Returns, [], [], [iter_obj t]); depr = None};
+    [ {lab = "get";  typ = Func (Local, Returns, [], [Prim Nat], [t]); src = empty_src};
+      {lab = "size";  typ = Func (Local, Returns, [], [], [Prim Nat]); src = empty_src};
+      {lab = "keys"; typ = Func (Local, Returns, [], [], [iter_obj (Prim Nat)]); src = empty_src};
+      {lab = "vals"; typ = Func (Local, Returns, [], [], [iter_obj t]); src = empty_src};
     ] in
   let mut t = immut t @
-    [ {lab = "put"; typ = Func (Local, Returns, [], [Prim Nat; t], []); depr = None} ] in
+    [ {lab = "put"; typ = Func (Local, Returns, [], [Prim Nat; t], []); src = empty_src} ] in
   Object,
   List.sort compare_field (match t with Mut t' -> mut t' | t -> immut t)
 
 let blob_obj () =
   let open T in
   Object,
-  [ {lab = "vals"; typ = Func (Local, Returns, [], [], [iter_obj (Prim Nat8)]); depr = None};
-    {lab = "size";  typ = Func (Local, Returns, [], [], [Prim Nat]); depr = None};
+  [ {lab = "vals"; typ = Func (Local, Returns, [], [], [iter_obj (Prim Nat8)]); src = empty_src};
+    {lab = "size";  typ = Func (Local, Returns, [], [], [Prim Nat]); src = empty_src};
   ]
 
 let text_obj () =
   let open T in
   Object,
-  [ {lab = "chars"; typ = Func (Local, Returns, [], [], [iter_obj (Prim Char)]); depr = None};
-    {lab = "size";  typ = Func (Local, Returns, [], [], [Prim Nat]); depr = None};
+  [ {lab = "chars"; typ = Func (Local, Returns, [], [], [iter_obj (Prim Char)]); src = empty_src};
+    {lab = "size";  typ = Func (Local, Returns, [], [], [Prim Nat]); src = empty_src};
   ]
 
 
@@ -1110,7 +1111,7 @@ and infer_exp'' env exp : T.typ =
     end
   | TagE (id, exp1) ->
     let t1 = infer_exp env exp1 in
-    T.Variant [T.{lab = id.it; typ = t1; depr = None}]
+    T.Variant [T.{lab = id.it; typ = t1; src = empty_src}]
   | ProjE (exp1, n) ->
     let t1 = infer_exp_promote env exp1 in
     (try
@@ -1536,7 +1537,7 @@ and infer_exp_field env rf =
   let { mut; id; exp } = rf.it in
   let t = infer_exp env exp in
   let t1 = if mut.it = Syntax.Var then T.Mut t else t in
-  T.{ lab = id.it; typ = t1; depr = None }
+  T.{ lab = id.it; typ = t1; src = empty_src }
 
 and check_exp_strong env t exp =
   check_exp {env with weak = false} t exp
@@ -1900,7 +1901,7 @@ and infer_pat' env pat : T.typ * Scope.val_env =
     T.Opt t1, ve
   | TagP (id, pat1) ->
     let t1, ve = infer_pat env pat1 in
-    T.Variant [T.{lab = id.it; typ = t1; depr = None}], ve
+    T.Variant [T.{lab = id.it; typ = t1; src = empty_src}], ve
   | AltP (pat1, pat2) ->
     error env pat.at "M0184"
         "cannot infer the type of this or-pattern, please add a type annotation";
@@ -1936,7 +1937,7 @@ and infer_pat_fields at env pfs ts ve : (T.obj_sort * T.field list) * Scope.val_
   | pf::pfs' ->
     let typ, ve1 = infer_pat env pf.it.pat in
     let ve' = disjoint_union env at "M0017" "duplicate binding for %s in pattern" ve ve1 in
-    infer_pat_fields at env pfs' (T.{ lab = pf.it.id.it; typ; depr = None }::ts) ve'
+    infer_pat_fields at env pfs' (T.{ lab = pf.it.id.it; typ; src = empty_src }::ts) ve'
 
 and check_shared_pat env shared_pat : T.func_sort * Scope.val_env =
   match shared_pat.it with
@@ -2115,14 +2116,14 @@ and check_pat_fields env t tfs pfs ve at : Scope.val_env =
       display_typ_expand t
   | T.{lab; typ = Typ _; _}::tfs', _ ->  (* TODO: remove the namespace hack *)
     check_pat_fields env t tfs' pfs ve at
-  | T.{lab; typ; depr}::tfs', pf::pfs' ->
+  | T.{lab; typ; src}::tfs', pf::pfs' ->
     match compare pf.it.id.it lab with
     | -1 -> check_pat_fields env t [] pfs ve at
     | +1 -> check_pat_fields env t tfs' pfs ve at
     | _ ->
       if T.is_mut typ then
         error env pf.at "M0120" "cannot pattern match mutable field %s" lab;
-      Option.iter (warn env pf.at "M0154" "type field %s is deprecated:\n%s" lab) depr;
+      Option.iter (warn env pf.at "M0154" "type field %s is deprecated:\n%s" lab) src.T.depr;
       let ve1 = check_pat env typ pf.it.pat in
       let ve' =
         disjoint_union env at "M0017" "duplicate binding for %s in pattern" ve ve1 in
@@ -2141,38 +2142,38 @@ and pub_fields dec_fields : visibility_env =
 
 and pub_field dec_field xs : visibility_env =
   match dec_field.it with
-  | {vis = { it = Public depr; _}; dec; _} -> pub_dec depr dec xs
+  | {vis = { it = Public depr; _}; dec; _} -> pub_dec T.{depr = depr; region = dec_field.at} dec xs
   | _ -> xs
 
-and pub_dec depr dec xs : visibility_env =
+and pub_dec src dec xs : visibility_env =
   match dec.it with
   | ExpD _ -> xs
-  | LetD (pat, _, _) -> pub_pat depr pat xs
-  | VarD (id, _) -> pub_val_id depr id xs
+  | LetD (pat, _, _) -> pub_pat src pat xs
+  | VarD (id, _) -> pub_val_id src id xs
   | ClassD (_, id, _, _, _, _, _, _) ->
-    pub_val_id depr {id with note = ()} (pub_typ_id depr id xs)
-  | TypD (id, _, _) -> pub_typ_id depr id xs
+    pub_val_id src {id with note = ()} (pub_typ_id src id xs)
+  | TypD (id, _, _) -> pub_typ_id src id xs
 
-and pub_pat depr pat xs : visibility_env =
+and pub_pat src pat xs : visibility_env =
   match pat.it with
   | WildP | LitP _ | SignP _ -> xs
-  | VarP id -> pub_val_id depr id xs
-  | TupP pats -> List.fold_right (pub_pat depr) pats xs
-  | ObjP pfs -> List.fold_right (pub_pat_field depr) pfs xs
+  | VarP id -> pub_val_id src id xs
+  | TupP pats -> List.fold_right (pub_pat src) pats xs
+  | ObjP pfs -> List.fold_right (pub_pat_field src) pfs xs
   | AltP (pat1, _)
   | OptP pat1
   | TagP (_, pat1)
   | AnnotP (pat1, _)
-  | ParP pat1 -> pub_pat depr pat1 xs
+  | ParP pat1 -> pub_pat src pat1 xs
 
-and pub_pat_field depr pf xs =
-  pub_pat depr pf.it.pat xs
+and pub_pat_field src pf xs =
+  pub_pat src pf.it.pat xs
 
-and pub_typ_id depr id (xs, ys) : visibility_env =
-  (T.Env.add id.it (id.at, depr) xs, ys)
+and pub_typ_id src id (xs, ys) : visibility_env =
+  (T.Env.add id.it T.{depr = src.depr; id_region = id.at; field_region = src.region} xs, ys)
 
-and pub_val_id depr id (xs, ys) : visibility_env =
-  (xs, T.Env.add id.it (id.at, depr) ys)
+and pub_val_id src id (xs, ys) : visibility_env =
+  (xs, T.Env.add id.it T.{depr = src.depr; id_region = id.at; field_region = src.region} ys)
 
 
 (* Object/Scope transformations *)
@@ -2185,8 +2186,7 @@ and object_of_scope env sort dec_fields scope at =
     T.Env.fold
       (fun id c tfs ->
         match T.Env.find_opt id pub_typ with
-        | Some (_r, Some depr) -> T.{lab = id; typ = T.Typ c; depr = Some depr}::tfs
-        | Some (_r, None) -> T.{lab = id; typ = T.Typ c; depr = None}::tfs
+        | Some src -> T.{lab = id; typ = T.Typ c; src = {depr = src.depr; region = src.field_region}}::tfs
         | _ -> tfs
       ) scope.Scope.typ_env  []
   in
@@ -2194,8 +2194,7 @@ and object_of_scope env sort dec_fields scope at =
     T.Env.fold
       (fun id t tfs ->
         match T.Env.find_opt id pub_val with
-        | Some (_r, Some depr) -> T.{lab = id; typ = t; depr = Some depr}::tfs
-        | Some (_r, None) -> T.{lab = id; typ = t; depr = None}::tfs
+        | Some src -> T.{lab = id; typ = t; src = {depr = src.depr; region = src.field_region}}::tfs
         | _ -> tfs
       ) scope.Scope.val_env tfs
   in
@@ -2240,7 +2239,7 @@ and infer_obj env s dec_fields at : T.typ =
       List.iter (fun T.{lab; typ; _} ->
         if not (T.is_typ typ) && not (T.is_shared_func typ) then
           let _, pub_val = pub_fields dec_fields in
-          error env (fst (T.Env.find lab pub_val)) "M0124"
+          error env ((T.Env.find lab pub_val).id_region) "M0124"
             "public actor field %s has non-shared function type%a"
             lab
             display_typ_expand typ
diff --git a/src/mo_idl/idl_to_mo.ml b/src/mo_idl/idl_to_mo.ml
index c23b784ef54..aaa16a3c0fd 100644
--- a/src/mo_idl/idl_to_mo.ml
+++ b/src/mo_idl/idl_to_mo.ml
@@ -88,13 +88,13 @@ let rec check_typ' env occs t =
   | PreT -> assert false
 and check_typs' env occs ts = List.map (check_typ' env occs) ts
 and check_field env occs f =
-  M.{lab = check_label f.it.label; typ = check_typ' env occs f.it.typ; depr = None}
+  M.{lab = check_label f.it.label; typ = check_typ' env occs f.it.typ; src = empty_src}
 and check_variant_field env occs f =
   match f.it.typ.it with
-  | PrimT Null -> M.{lab = check_label f.it.label; typ = M.Tup []; depr = None}
+  | PrimT Null -> M.{lab = check_label f.it.label; typ = M.Tup []; src = empty_src}
   | _ -> check_field env occs f
 and check_meth env occs (m: typ_meth) =
-  M.{lab = Idllib.Escape.escape_method m.it.var.at m.it.var.it; typ = check_typ' env occs m.it.meth; depr = None}
+  M.{lab = Idllib.Escape.escape_method m.it.var.at m.it.var.it; typ = check_typ' env occs m.it.meth; src = empty_src}
 
 let check_prog (env: typ I.Env.t) actor : M.typ =
   let occs = ref M.Env.empty in
@@ -123,7 +123,7 @@ let check_prog (env: typ I.Env.t) actor : M.typ =
        | M.Con (c, _) ->
           (* TODO: consider adding deprecation as types can disappear even
              across compatible .dids *)
-          M.{lab = id; typ = M.Typ c; depr = None}::fs
+          M.{lab = id; typ = M.Typ c; src = empty_src}::fs
        | _ -> assert false) !occs fs in
   M.Obj (M.Actor, List.sort M.compare_field fs1)
 
diff --git a/src/mo_idl/mo_to_idl.ml b/src/mo_idl/mo_to_idl.ml
index 4833184da6d..040d6c25e19 100644
--- a/src/mo_idl/mo_to_idl.ml
+++ b/src/mo_idl/mo_to_idl.ml
@@ -2,6 +2,7 @@ open Mo_def
 open Mo_types
 
 open Source
+open Trivia
 open Type
 module E = Syntax
 module I = Idllib.Syntax
@@ -134,13 +135,13 @@ module MakeState() = struct
     | Mut _
     | Pre -> assert false
     ) @@ no_region
-  and field {lab; typ=t; _} =
+  and field {lab; typ = t; src = {region; _}} =
     let open Idllib.Escape in
     match unescape lab with
     | Nat nat ->
-       I.{label = I.Id nat @@ no_region; typ = typ t} @@ no_region
+       I.{label = I.Id nat @@ no_region; typ = typ t} @@ region
     | Id id ->
-       I.{label = I.Named id @@ no_region; typ = typ t} @@ no_region
+       I.{label = I.Named id @@ no_region; typ = typ t} @@ region
   and fields fs =
     List.map field
       (List.filter (fun f -> not (is_typ f.typ)) fs)
@@ -159,7 +160,7 @@ module MakeState() = struct
         | _ ->
            let meth =
              I.{var = Idllib.Escape.unescape_method f.lab @@ no_region;
-                meth = typ f.typ} @@ no_region in
+                meth = typ f.typ} @@ f.src.region in
            meth :: list
       ) fs []
 
@@ -175,14 +176,14 @@ module MakeState() = struct
 
   let gather_decs () =
     Env.fold (fun id t list ->
+        (* TODO: pass corresponding Motoko source region? *)
         let dec = I.TypD (id @@ no_region, t) @@ no_region in
         dec::list
       ) !env []
 
 
-  let actor progs =
+  let actor prog =
     let open E in
-    let prog = CompUnit.combine_progs progs in
     let { body = cub; _ } = (CompUnit.comp_unit_of_prog false prog).it in
     match cub.it with
     | ProgU _ | ModuleU _ -> None
@@ -200,25 +201,27 @@ module MakeState() = struct
 end
 
 let prog (progs, senv) : I.prog =
+  let prog = CompUnit.combine_progs progs in
+  let trivia = prog.note.E.trivia in
   let open MakeState() in
-  let actor = actor progs in
+  let actor = actor prog in
   if actor = None then chase_decs senv;
   let decs = gather_decs () in
-  let prog = I.{decs = decs; actor = actor} in
-  {it = prog; at = no_region; note = ""}
+  let it = I.{decs; actor} in
+  {it; at = prog.at; note = I.{filename = ""; trivia}}
 
 let of_actor_type t : I.prog =
   let open MakeState() in
   let actor = Some (typ t) in
   let decs = gather_decs () in
-  let prog = I.{decs = decs; actor = actor} in
-  {it = prog; at = no_region; note = ""}
+  let prog = I.{decs; actor} in
+  {it = prog; at = no_region; note = I.{filename = ""; trivia = empty_triv_table}}
 
 let of_service_type ts t : I.typ list * I.prog =
   let open MakeState() in
   let args = List.map typ ts  in
   let actor = Some (typ t) in
   let decs = gather_decs () in
-  let prog = I.{decs = decs; actor = actor} in
+  let prog = I.{decs; actor} in
   args,
-  {it = prog; at = no_region; note = ""}
+  {it = prog; at = no_region; note = I.{filename = ""; trivia = empty_triv_table}}
diff --git a/src/mo_types/type.ml b/src/mo_types/type.ml
index 74db125c7ea..13e316cc353 100644
--- a/src/mo_types/type.ml
+++ b/src/mo_types/type.ml
@@ -61,13 +61,16 @@ and scope = typ
 and bind_sort = Scope | Type
 
 and bind = {var : var; sort: bind_sort; bound : typ}
-and field = {lab : lab; typ : typ; depr : string option}
+and src = {depr : string option; region : Source.region}
+and field = {lab : lab; typ : typ; src : src}
 
 and con = kind Cons.t
 and kind =
   | Def of bind list * typ
   | Abs of bind list * typ
 
+let empty_src = {depr = None; region = Source.no_region}
+
 (* Efficient comparison *)
 let tag_prim = function
   | Null -> 0
@@ -153,10 +156,10 @@ let compare_bind_sort s1 s2 =
   | Type, Scope -> -1
   | Scope, Type -> 1
 
-let compare_depr d1 d2 =
-  match (d1, d2) with
+let compare_src s1 s2 =
+  match (s1.depr, s2.depr) with
   | None, None -> 0
-  | Some s1, Some s2 -> String.compare s1 s2
+  | Some d1, Some d2 -> String.compare d1 d2
   | None, Some _ -> -1
   | _ -> 1
 
@@ -234,7 +237,7 @@ and compare_fld fld1 fld2 =
   match String.compare fld1.lab fld2.lab with
   | 0 ->
     (match compare_typ fld1.typ fld2.typ with
-     | 0 -> compare_depr fld1.depr fld2.depr
+     | 0 -> compare_src fld1.src fld2.src
      | ord -> ord)
   | ord -> ord
 
@@ -317,7 +320,7 @@ let principal = Prim Principal
 
 let fields flds =
   List.sort compare_field
-    (List.map (fun (lab, typ) -> {lab; typ; depr = None}) flds)
+    (List.map (fun (lab, typ) -> {lab; typ; src = empty_src}) flds)
 
 let obj sort flds =
   Obj (sort, fields flds)
@@ -326,19 +329,19 @@ let sum flds =
   Variant (fields flds)
 
 let throwErrorCodes = List.sort compare_field [
-  { lab = "canister_reject"; typ = unit; depr = None}
+  { lab = "canister_reject"; typ = unit; src = empty_src}
 ]
 
-let call_error = Obj(Object,[{ lab = "err_code"; typ = Prim Nat32; depr = None }])
+let call_error = Obj(Object,[{ lab = "err_code"; typ = Prim Nat32; src = empty_src}])
 
 let catchErrorCodes = List.sort compare_field (
   throwErrorCodes @ [
-    { lab = "system_fatal"; typ = unit; depr = None};
-    { lab = "system_transient"; typ = unit; depr = None};
-    { lab = "destination_invalid"; typ = unit; depr = None};
-    { lab = "canister_error"; typ = unit; depr = None};
-    { lab = "future"; typ = Prim Nat32; depr = None};
-    { lab = "call_error"; typ = call_error; depr = None};
+    { lab = "system_fatal"; typ = unit; src = empty_src};
+    { lab = "system_transient"; typ = unit; src = empty_src};
+    { lab = "destination_invalid"; typ = unit; src = empty_src};
+    { lab = "canister_error"; typ = unit; src = empty_src};
+    { lab = "future"; typ = Prim Nat32; src = empty_src};
+    { lab = "call_error"; typ = call_error; src = empty_src};
   ])
 
 let throw = Prim Error
@@ -347,7 +350,7 @@ let catch = Prim Error
 (* Shared call context *)
 
 let caller = principal
-let ctxt = Obj (Object,[{ lab = "caller"; typ = caller; depr = None}])
+let ctxt = Obj (Object,[{ lab = "caller"; typ = caller; src = empty_src}])
 
 let prim = function
   | "Null" -> Null
@@ -381,7 +384,7 @@ let codom c to_scope ts2 =  match c with
 
 let iter_obj t =
   Obj (Object,
-    [{lab = "next"; typ = Func (Local, Returns, [], [], [Opt t]); depr = None}])
+    [{lab = "next"; typ = Func (Local, Returns, [], [], [Opt t]); src = empty_src}])
 
 
 (* Shifting *)
@@ -409,8 +412,8 @@ let rec shift i n t =
 and shift_bind i n tb =
   {tb with bound = shift i n tb.bound}
 
-and shift_field i n {lab; typ; depr} =
-  {lab; typ = shift i n typ; depr}
+and shift_field i n {lab; typ; src} =
+  {lab; typ = shift i n typ; src}
 
 (*
 and shift_kind i n k =
@@ -460,8 +463,8 @@ let rec subst sigma t =
 and subst_bind sigma tb =
   { tb with bound = subst sigma tb.bound}
 
-and subst_field sigma {lab; typ; depr} =
-  {lab; typ = subst sigma typ; depr}
+and subst_field sigma {lab; typ; src} =
+  {lab; typ = subst sigma typ; src}
 
 (*
 and subst_kind sigma k =
@@ -510,8 +513,8 @@ let rec open' i ts t =
 and open_bind i ts tb  =
   {tb with bound = open' i ts tb.bound}
 
-and open_field i ts {lab; typ; depr} =
-  {lab; typ = open' i ts typ; depr}
+and open_field i ts {lab; typ; src} =
+  {lab; typ = open' i ts typ; src}
 
 (*
 and open_kind i ts k =
@@ -615,11 +618,11 @@ let as_prim_sub p t = match promote t with
   | _ -> invalid "as_prim_sub"
 let as_obj_sub ls t = match promote t with
   | Obj (s, tfs) -> s, tfs
-  | Non -> Object, List.map (fun l -> {lab = l; typ = Non; depr = None}) ls
+  | Non -> Object, List.map (fun l -> {lab = l; typ = Non; src = empty_src}) ls
   | _ -> invalid "as_obj_sub"
 let as_variant_sub l t = match promote t with
   | Variant tfs -> tfs
-  | Non -> [{lab = l; typ = Non; depr = None}]
+  | Non -> [{lab = l; typ = Non; src = empty_src}]
   | _ -> invalid "as_variant_sub"
 let as_array_sub t = match promote t with
   | Array t -> t
@@ -687,13 +690,13 @@ let lookup_typ_field l tfs =
 let lookup_val_deprecation l tfs =
   let is_lab = function {typ = Typ _; _} -> false | {lab; _} -> lab = l in
   match List.find_opt is_lab tfs with
-  | Some tf -> tf.depr
+  | Some {src = {depr; _}; _} -> depr
   | None -> invalid "lookup_val_deprecation"
 
 let lookup_typ_deprecation l tfs =
   let is_lab = function {typ = Typ _; lab; _} -> lab = l | _ -> false in
   match List.find_opt is_lab tfs with
-  | Some tf -> tf.depr
+  | Some {src = {depr; _}; _} -> depr
   | _ -> invalid "lookup_typ_deprecation"
 
 
@@ -755,7 +758,7 @@ and cons_con inTyp c cs =
 and cons_bind inTyp tb cs =
   cons' inTyp tb.bound cs
 
-and cons_field inTyp {lab; typ; depr} cs =
+and cons_field inTyp {lab; typ; src} cs =
   cons' inTyp typ cs
 
 and cons_kind' inTyp k cs =
@@ -1297,7 +1300,7 @@ and combine_fields rel lubs glbs fs1 fs2 =
     | _ ->
       match combine rel lubs glbs f1.typ f2.typ with
       | typ ->
-       {lab = f1.lab; typ; depr = None} :: combine_fields rel lubs glbs fs1' fs2'
+       {lab = f1.lab; typ; src = empty_src} :: combine_fields rel lubs glbs fs1' fs2'
       | exception Mismatch when rel == lubs ->
         combine_fields rel lubs glbs fs1' fs2'
 
@@ -1311,7 +1314,7 @@ and combine_tags rel lubs glbs fs1 fs2 =
     | +1 -> cons_if (rel == lubs) f2 (combine_tags rel lubs glbs fs1 fs2')
     | _ ->
       let typ = combine rel lubs glbs f1.typ f2.typ in
-      {lab = f1.lab; typ; depr = None} :: combine_tags rel lubs glbs fs1' fs2'
+      {lab = f1.lab; typ; src = empty_src} :: combine_tags rel lubs glbs fs1' fs2'
 
 let lub t1 t2 = let lubs = ref M.empty in combine lubs lubs (ref M.empty) t1 t2
 let glb t1 t2 = let glbs = ref M.empty in combine glbs (ref M.empty) glbs t1 t2
@@ -1333,21 +1336,21 @@ let scope_bind = { var = default_scope_var; sort = Scope; bound = scope_bound }
 let motoko_async_helper_fld =
   { lab = "__motoko_async_helper";
     typ = Func(Shared Write, Promises, [scope_bind], [Prim Nat32], []);
-    depr = None;
+    src = empty_src;
   }
 
 let motoko_stable_var_info_fld =
   { lab = "__motoko_stable_var_info";
     typ =
       Func(Shared Query, Promises, [scope_bind], [],
-        [ Obj(Object, [{lab = "size"; typ = nat64; depr = None}]) ]);
-    depr = None;
+        [ Obj(Object, [{lab = "size"; typ = nat64; src = empty_src}]) ]);
+    src = empty_src;
   }
 
 let get_candid_interface_fld =
   { lab = "__get_candid_interface_tmp_hack";
     typ = Func(Shared Query, Promises, [scope_bind], [], [text]);
-    depr = None;
+    src = empty_src;
   }
 
 let well_known_actor_fields = [
@@ -1365,7 +1368,7 @@ let decode_msg_typ tfs =
            typ =
              Func(Local, Returns, [], [],
                List.map (open_ (List.map (fun _ -> Non) tbs)) ts1);
-           depr = None }
+           src = empty_src }
        | _ -> None)
      tfs))
 
@@ -1626,7 +1629,7 @@ and pp_typ' vs ppf t =
   (* No cases for syntactic _ And _ & _ Or _ (already desugared) *)
   | t -> pp_typ_nobin vs ppf t
 
-and pp_field vs ppf {lab; typ; depr} =
+and pp_field vs ppf {lab; typ; src} =
   match typ with
   | Typ c ->
     let op, sbs, st = pps_of_kind' vs (Cons.kind c) in
@@ -1636,14 +1639,14 @@ and pp_field vs ppf {lab; typ; depr} =
   | _ ->
     fprintf ppf "@[<2>%s :@ %a@]" lab (pp_typ' vs) typ
 
-and pp_stab_field vs ppf {lab; typ; depr} =
+and pp_stab_field vs ppf {lab; typ; src} =
   match typ with
   | Mut t' ->
     fprintf ppf "@[<2>stable var %s :@ %a@]" lab (pp_typ' vs) t'
   | _ ->
     fprintf ppf "@[<2>stable %s :@ %a@]" lab (pp_typ' vs) typ
 
-and pp_tag vs ppf {lab; typ; depr} =
+and pp_tag vs ppf {lab; typ; src} =
   match typ with
   | Tup [] -> fprintf ppf "#%s" lab
   | _ ->
@@ -1719,7 +1722,7 @@ and pp_stab_sig ppf sig_ =
       (List.map (fun c ->
         { lab = string_of_con c;
           typ = Typ c;
-          depr = None }) ds)
+          src = empty_src }) ds)
   in
   let pp_stab_fields ppf sig_ =
     fprintf ppf "@[<v 2>%s{@;<0 0>%a@;<0 -2>}@]"
diff --git a/src/mo_types/type.mli b/src/mo_types/type.mli
index 710d6da0570..605873ae586 100644
--- a/src/mo_types/type.mli
+++ b/src/mo_types/type.mli
@@ -55,13 +55,15 @@ and scope = typ
 and bind_sort = Scope | Type
 and bind = {var : var; sort: bind_sort; bound : typ}
 
-and field = {lab : lab; typ : typ; depr : string option}
+and src = {depr : string option; region : Source.region}
+and field = {lab : lab; typ : typ; src : src}
 
 and con = kind Cons.t
 and kind =
   | Def of bind list * typ
   | Abs of bind list * typ
 
+val empty_src : src
 
 (* Syntactic orderings *)
 
diff --git a/src/mo_values/prim.ml b/src/mo_values/prim.ml
index 85844679d1d..8ad82dc8f6b 100644
--- a/src/mo_values/prim.ml
+++ b/src/mo_values/prim.ml
@@ -65,10 +65,21 @@ let num_conv_trap_prim trap t1 t2 =
   | T.Int, T.(Int8|Int16|Int32|Int64)
   | T.(Nat8|Nat16|Nat32|Nat64), T.Nat
   | T.(Int8|Int16|Int32|Int64), T.Int
+  | T.Nat8, T.Nat16
+  | T.Nat16, T.Nat32
+  | T.Nat32, T.Nat64
+  | T.Nat64, T.Nat32
+  | T.Nat32, T.Nat16
+  | T.Nat16, T.Nat8
+  | T.Int8, T.Int16
+  | T.Int16, T.Int32
+  | T.Int32, T.Int64
+  | T.Int64, T.Int32
+  | T.Int32, T.Int16
+  | T.Int16, T.Int8
   | T.Nat32, T.Char
   -> fun v -> (try of_big_int_trap t2 (as_big_int t1 v)
                with Invalid_argument msg -> trap.trap msg)
-
   | T.Float, T.Int64 -> fun v -> Int64 (Int_64.of_big_int (bigint_of_double (as_float v)))
   | T.Int64, T.Float -> fun v -> Float (Wasm.F64_convert.convert_i64_s (Big_int.int64_of_big_int (Int_64.to_big_int (as_int64 v))))
 
@@ -92,7 +103,7 @@ let prim trap =
   let float_formatter prec : int -> float -> string =
     let open Printf in
     function
-    | 0 -> sprintf "%.*f" prec 
+    | 0 -> sprintf "%.*f" prec
     | 1 -> sprintf "%.*e" prec
     | 2 -> sprintf "%.*g" prec
     | 3 -> sprintf "%.*h" prec
diff --git a/src/prelude/prim.mo b/src/prelude/prim.mo
index d57072ec89f..f8161852ea7 100644
--- a/src/prelude/prim.mo
+++ b/src/prelude/prim.mo
@@ -39,8 +39,12 @@ module Types = {
 };
 
 func abs(x : Int) : Nat { (prim "abs" : Int -> Nat) x };
-func shiftLeft(x : Nat, shift : Nat32) : Nat { (prim "lsh_Nat" : (Nat, Nat32) -> Nat) (x, shift) };
-func shiftRight(x : Nat, shift : Nat32) : Nat { (prim "rsh_Nat" : (Nat, Nat32) -> Nat) (x, shift) };
+func shiftLeft(x : Nat, shift : Nat32) : Nat {
+  (prim "lsh_Nat" : (Nat, Nat32) -> Nat)(x, shift);
+};
+func shiftRight(x : Nat, shift : Nat32) : Nat {
+  (prim "rsh_Nat" : (Nat, Nat32) -> Nat)(x, shift);
+};
 
 // for testing
 func idlHash(x : Text) : Nat32 { (prim "idlHash" : Text -> Nat32) x };
@@ -48,9 +52,9 @@ func idlHash(x : Text) : Nat32 { (prim "idlHash" : Text -> Nat32) x };
 // Printing
 
 func debugPrint(x : Text) { (prim "print" : Text -> ()) x };
-func debugPrintNat(x : Nat) { debugPrint (@text_of_Nat x) };
-func debugPrintInt(x : Int) { debugPrint (@text_of_Int x) };
-func debugPrintChar(x : Char) { debugPrint (charToText x) };
+func debugPrintNat(x : Nat) { debugPrint(@text_of_Nat x) };
+func debugPrintInt(x : Int) { debugPrint(@text_of_Int x) };
+func debugPrintChar(x : Char) { debugPrint(charToText x) };
 
 // Trapping
 
@@ -58,17 +62,27 @@ func trap(x : Text) : None { (prim "trap" : Text -> None) x };
 
 // RTS stats
 
-func rts_version() : Text { (prim "rts_version" : () -> Text) () };
-func rts_memory_size() : Nat { (prim "rts_memory_size" : () -> Nat) () };
-func rts_heap_size() : Nat { (prim "rts_heap_size" : () -> Nat) () };
-func rts_total_allocation() : Nat { (prim "rts_total_allocation" : () -> Nat) () };
-func rts_reclaimed() : Nat { (prim "rts_reclaimed" : () -> Nat) () };
-func rts_max_live_size() : Nat { (prim "rts_max_live_size" : () -> Nat) () };
-func rts_max_stack_size() : Nat { (prim "rts_max_stack_size" : () -> Nat) () };
-func rts_callback_table_count() : Nat { (prim "rts_callback_table_count" : () -> Nat) () };
-func rts_callback_table_size() : Nat { (prim "rts_callback_table_size" : () -> Nat) () };
-func rts_mutator_instructions() : Nat { (prim "rts_mutator_instructions" : () -> Nat) () };
-func rts_collector_instructions() : Nat { (prim "rts_collector_instructions" : () -> Nat) () };
+func rts_version() : Text { (prim "rts_version" : () -> Text)() };
+func rts_memory_size() : Nat { (prim "rts_memory_size" : () -> Nat)() };
+func rts_heap_size() : Nat { (prim "rts_heap_size" : () -> Nat)() };
+func rts_total_allocation() : Nat {
+  (prim "rts_total_allocation" : () -> Nat)();
+};
+func rts_reclaimed() : Nat { (prim "rts_reclaimed" : () -> Nat)() };
+func rts_max_live_size() : Nat { (prim "rts_max_live_size" : () -> Nat)() };
+func rts_max_stack_size() : Nat { (prim "rts_max_stack_size" : () -> Nat)() };
+func rts_callback_table_count() : Nat {
+  (prim "rts_callback_table_count" : () -> Nat)();
+};
+func rts_callback_table_size() : Nat {
+  (prim "rts_callback_table_size" : () -> Nat)();
+};
+func rts_mutator_instructions() : Nat {
+  (prim "rts_mutator_instructions" : () -> Nat)();
+};
+func rts_collector_instructions() : Nat {
+  (prim "rts_collector_instructions" : () -> Nat)();
+};
 
 // Total conversions (fixed to big)
 
@@ -105,6 +119,7 @@ func intToNat32Wrap(n : Int) : Nat32 = (prim "num_wrap_Int_Nat32" : Int -> Nat32
 func intToNat16Wrap(n : Int) : Nat16 = (prim "num_wrap_Int_Nat16" : Int -> Nat16) n;
 func intToNat8Wrap(n : Int) : Nat8 = (prim "num_wrap_Int_Nat8" : Int -> Nat8) n;
 
+// Across same width
 func int64ToNat64(n : Int64) : Nat64 = (prim "num_wrap_Int64_Nat64" : Int64 -> Nat64) n;
 func nat64ToInt64(n : Nat64) : Int64 = (prim "num_wrap_Nat64_Int64" : Nat64 -> Int64) n;
 func int32ToNat32(n : Int32) : Nat32 = (prim "num_wrap_Int32_Nat32" : Int32 -> Nat32) n;
@@ -114,6 +129,23 @@ func nat16ToInt16(n : Nat16) : Int16 = (prim "num_wrap_Nat16_Int16" : Nat16 -> I
 func int8ToNat8(n : Int8) : Nat8 = (prim "num_wrap_Int8_Nat8" : Int8 -> Nat8) n;
 func nat8ToInt8(n : Nat8) : Int8 = (prim "num_wrap_Nat8_Int8" : Nat8 -> Int8) n;
 
+// Between adjacent widths
+func nat8ToNat16(n : Nat8) : Nat16 = (prim "num_conv_Nat8_Nat16" : Nat8 -> Nat16) n;
+func nat16ToNat32(n : Nat16) : Nat32 = (prim "num_conv_Nat16_Nat32" : Nat16 -> Nat32) n;
+func nat32ToNat64(n : Nat32) : Nat64 = (prim "num_conv_Nat32_Nat64" : Nat32 -> Nat64) n;
+
+func nat64ToNat32(n : Nat64) : Nat32 = (prim "num_conv_Nat64_Nat32" : Nat64 -> Nat32) n;
+func nat32ToNat16(n : Nat32) : Nat16 = (prim "num_conv_Nat32_Nat16" : Nat32 -> Nat16) n;
+func nat16ToNat8(n : Nat16) : Nat8 = (prim "num_conv_Nat16_Nat8" : Nat16 -> Nat8) n;
+
+func int8ToInt16(n : Int8) : Int16 = (prim "num_conv_Int8_Int16" : Int8 -> Int16) n;
+func int16ToInt32(n : Int16) : Int32 = (prim "num_conv_Int16_Int32" : Int16 -> Int32) n;
+func int32ToInt64(n : Int32) : Int64 = (prim "num_conv_Int32_Int64" : Int32 -> Int64) n;
+
+func int64ToInt32(n : Int64) : Int32 = (prim "num_conv_Int64_Int32" : Int64 -> Int32) n;
+func int32ToInt16(n : Int32) : Int16 = (prim "num_conv_Int32_Int16" : Int32 -> Int16) n;
+func int16ToInt8(n : Int16) : Int8 = (prim "num_conv_Int16_Int8" : Int16 -> Int8) n;
+
 // Char conversion and properties
 
 func charToNat32(c : Char) : Nat32 = (prim "num_wrap_Char_Nat32" : Char -> Nat32) c;
@@ -130,57 +162,56 @@ func charIsAlphabetic(c : Char) : Bool = (prim "char_is_alphabetic" : Char -> Bo
 
 // Blob functions
 
-func blobCompare(b1 : Blob, b2 : Blob) : Int8 = (prim "blob_compare" : (Blob, Blob) -> Int8) (b1, b2);
+func blobCompare(b1 : Blob, b2 : Blob) : Int8 = (prim "blob_compare" : (Blob, Blob) -> Int8)(b1, b2);
 func hashBlob(b : Blob) : Nat32 { (prim "crc32Hash" : Blob -> Nat32) b };
 
-
 // Text conversion
 func decodeUtf8(b : Blob) : ?Text = (prim "decodeUtf8" : Blob -> ?Text) b;
 func encodeUtf8(t : Text) : Blob = (prim "encodeUtf8" : Text -> Blob) t;
 
 // Text comparison
-func textCompare(t1 : Text, t2 : Text) : Int8 = (prim "text_compare" : (Text, Text) -> Int8) (t1, t2);
+func textCompare(t1 : Text, t2 : Text) : Int8 = (prim "text_compare" : (Text, Text) -> Int8)(t1, t2);
 
 // Exotic bitwise operations
 func popcntNat8(w : Nat8) : Nat8 = (prim "popcnt8" : Nat8 -> Nat8) w;
 func clzNat8(w : Nat8) : Nat8 = (prim "clz8" : Nat8 -> Nat8) w;
 func ctzNat8(w : Nat8) : Nat8 = (prim "ctz8" : Nat8 -> Nat8) w;
-func btstNat8(w : Nat8, amount : Nat8) : Bool = (prim "btst8" : (Nat8, Nat8) -> Nat8) (w, amount) != (0 : Nat8);
+func btstNat8(w : Nat8, amount : Nat8) : Bool = (prim "btst8" : (Nat8, Nat8) -> Nat8)(w, amount) != (0 : Nat8);
 
 func popcntNat16(w : Nat16) : Nat16 = (prim "popcnt16" : Nat16 -> Nat16) w;
 func clzNat16(w : Nat16) : Nat16 = (prim "clz16" : Nat16 -> Nat16) w;
 func ctzNat16(w : Nat16) : Nat16 = (prim "ctz16" : Nat16 -> Nat16) w;
-func btstNat16(w : Nat16, amount : Nat16) : Bool = (prim "btst16" : (Nat16, Nat16) -> Nat16) (w, amount) != (0 : Nat16);
+func btstNat16(w : Nat16, amount : Nat16) : Bool = (prim "btst16" : (Nat16, Nat16) -> Nat16)(w, amount) != (0 : Nat16);
 
 func popcntNat32(w : Nat32) : Nat32 = (prim "popcnt32" : Nat32 -> Nat32) w;
 func clzNat32(w : Nat32) : Nat32 = (prim "clz32" : Nat32 -> Nat32) w;
 func ctzNat32(w : Nat32) : Nat32 = (prim "ctz32" : Nat32 -> Nat32) w;
-func btstNat32(w : Nat32, amount : Nat32) : Bool = (prim "btst32" : (Nat32, Nat32) -> Nat32) (w, amount) != (0 : Nat32);
+func btstNat32(w : Nat32, amount : Nat32) : Bool = (prim "btst32" : (Nat32, Nat32) -> Nat32)(w, amount) != (0 : Nat32);
 
 func popcntNat64(w : Nat64) : Nat64 = (prim "popcnt64" : Nat64 -> Nat64) w;
 func clzNat64(w : Nat64) : Nat64 = (prim "clz64" : Nat64 -> Nat64) w;
 func ctzNat64(w : Nat64) : Nat64 = (prim "ctz64" : Nat64 -> Nat64) w;
-func btstNat64(w : Nat64, amount : Nat64) : Bool = (prim "btst64" : (Nat64, Nat64) -> Nat64) (w, amount) != (0 : Nat64);
+func btstNat64(w : Nat64, amount : Nat64) : Bool = (prim "btst64" : (Nat64, Nat64) -> Nat64)(w, amount) != (0 : Nat64);
 
 func popcntInt8(w : Int8) : Int8 = (prim "popcnt8" : Int8 -> Int8) w;
 func clzInt8(w : Int8) : Int8 = (prim "clz8" : Int8 -> Int8) w;
 func ctzInt8(w : Int8) : Int8 = (prim "ctz8" : Int8 -> Int8) w;
-func btstInt8(w : Int8, amount : Int8) : Bool = (prim "btst8" : (Int8, Int8) -> Int8) (w, amount) != (0 : Int8);
+func btstInt8(w : Int8, amount : Int8) : Bool = (prim "btst8" : (Int8, Int8) -> Int8)(w, amount) != (0 : Int8);
 
 func popcntInt16(w : Int16) : Int16 = (prim "popcnt16" : Int16 -> Int16) w;
 func clzInt16(w : Int16) : Int16 = (prim "clz16" : Int16 -> Int16) w;
 func ctzInt16(w : Int16) : Int16 = (prim "ctz16" : Int16 -> Int16) w;
-func btstInt16(w : Int16, amount : Int16) : Bool = (prim "btst16" : (Int16, Int16) -> Int16) (w, amount) != (0 : Int16);
+func btstInt16(w : Int16, amount : Int16) : Bool = (prim "btst16" : (Int16, Int16) -> Int16)(w, amount) != (0 : Int16);
 
 func popcntInt32(w : Int32) : Int32 = (prim "popcnt32" : Int32 -> Int32) w;
 func clzInt32(w : Int32) : Int32 = (prim "clz32" : Int32 -> Int32) w;
 func ctzInt32(w : Int32) : Int32 = (prim "ctz32" : Int32 -> Int32) w;
-func btstInt32(w : Int32, amount : Int32) : Bool = (prim "btst32" : (Int32, Int32) -> Int32) (w, amount) != (0 : Int32);
+func btstInt32(w : Int32, amount : Int32) : Bool = (prim "btst32" : (Int32, Int32) -> Int32)(w, amount) != (0 : Int32);
 
 func popcntInt64(w : Int64) : Int64 = (prim "popcnt64" : Int64 -> Int64) w;
 func clzInt64(w : Int64) : Int64 = (prim "clz64" : Int64 -> Int64) w;
 func ctzInt64(w : Int64) : Int64 = (prim "ctz64" : Int64 -> Int64) w;
-func btstInt64(w : Int64, amount : Int64) : Bool = (prim "btst64" : (Int64, Int64) -> Int64) (w, amount) != (0 : Int64);
+func btstInt64(w : Int64, amount : Int64) : Bool = (prim "btst64" : (Int64, Int64) -> Int64)(w, amount) != (0 : Int64);
 
 // Float operations
 
@@ -190,13 +221,13 @@ func floatCeil(f : Float) : Float = (prim "fceil" : Float -> Float) f;
 func floatFloor(f : Float) : Float = (prim "ffloor" : Float -> Float) f;
 func floatTrunc(f : Float) : Float = (prim "ftrunc" : Float -> Float) f;
 func floatNearest(f : Float) : Float = (prim "fnearest" : Float -> Float) f;
-func floatMin(f : Float, g : Float) : Float = (prim "fmin" : (Float, Float) -> Float) (f, g);
-func floatMax(f : Float, g : Float) : Float = (prim "fmax" : (Float, Float) -> Float) (f, g);
-func floatCopySign(f : Float, g : Float) : Float = (prim "fcopysign" : (Float, Float) -> Float) (f, g);
-func floatToInt(f : Float) : Int = (prim "num_conv_Float_Int" : Float -> Int) (f);
-func intToFloat(n : Int) : Float = (prim "num_conv_Int_Float" : Int -> Float) (n);
-func floatToInt64(f : Float) : Int64 = (prim "num_conv_Float_Int64" : Float -> Int64) (f);
-func int64ToFloat(n : Int64) : Float = (prim "num_conv_Int64_Float" : Int64 -> Float) (n);
+func floatMin(f : Float, g : Float) : Float = (prim "fmin" : (Float, Float) -> Float)(f, g);
+func floatMax(f : Float, g : Float) : Float = (prim "fmax" : (Float, Float) -> Float)(f, g);
+func floatCopySign(f : Float, g : Float) : Float = (prim "fcopysign" : (Float, Float) -> Float)(f, g);
+func floatToInt(f : Float) : Int = (prim "num_conv_Float_Int" : Float -> Int)(f);
+func intToFloat(n : Int) : Float = (prim "num_conv_Int_Float" : Int -> Float)(n);
+func floatToInt64(f : Float) : Int64 = (prim "num_conv_Float_Int64" : Float -> Int64)(f);
+func int64ToFloat(n : Int64) : Float = (prim "num_conv_Int64_Float" : Int64 -> Float)(n);
 
 let floatToText = @text_of_Float;
 
@@ -207,7 +238,7 @@ let floatToText = @text_of_Float;
 //  2) generic format "%.*g"
 //  3) hexadecimal format "%.*h"
 //  _) invalid (traps)
-func floatToFormattedText(f : Float, prec : Nat8, mode : Nat8) : Text = (prim "fmtFloat->Text" : (Float, Nat8, Nat8) -> Text) (f, prec, mode);
+func floatToFormattedText(f : Float, prec : Nat8, mode : Nat8) : Text = (prim "fmtFloat->Text" : (Float, Nat8, Nat8) -> Text)(f, prec, mode);
 
 // Trigonometric and transcendental functions
 
@@ -217,19 +248,19 @@ func tan(f : Float) : Float = (prim "ftan" : Float -> Float) f;
 func arcsin(f : Float) : Float = (prim "fasin" : Float -> Float) f;
 func arccos(f : Float) : Float = (prim "facos" : Float -> Float) f;
 func arctan(f : Float) : Float = (prim "fatan" : Float -> Float) f;
-func arctan2(y : Float, x : Float) : Float = (prim "fatan2" : (Float, Float) -> Float) (y, x);
+func arctan2(y : Float, x : Float) : Float = (prim "fatan2" : (Float, Float) -> Float)(y, x);
 
 func exp(f : Float) : Float = (prim "fexp" : Float -> Float) f;
 func log(f : Float) : Float = (prim "flog" : Float -> Float) f;
 
 // Array utilities
 
-func Array_init<T>(len : Nat,  x : T) : [var T] {
-  (prim "Array.init" : <T>(Nat, T) -> [var T])<T>(len, x)
+func Array_init<T>(len : Nat, x : T) : [var T] {
+  (prim "Array.init" : <T>(Nat, T) -> [var T]) <T>(len, x);
 };
 
-func Array_tabulate<T>(len : Nat,  gen : Nat -> T) : [T] {
-  (prim "Array.tabulate" : <T>(Nat, Nat -> T) -> [T])<T>(len, gen)
+func Array_tabulate<T>(len : Nat, gen : Nat -> T) : [T] {
+  (prim "Array.tabulate" : <T>(Nat, Nat -> T) -> [T]) <T>(len, gen);
 };
 
 func blobToArray(b : Blob) : [Nat8] = (prim "blobToArray" : (Blob) -> [Nat8]) b;
@@ -237,7 +268,6 @@ func blobToArrayMut(b : Blob) : [var Nat8] = (prim "blobToArrayMut" : (Blob) ->
 func arrayToBlob(a : [Nat8]) : Blob = (prim "arrayToBlob" : [Nat8] -> Blob) a;
 func arrayMutToBlob(a : [var Nat8]) : Blob = (prim "arrayMutToBlob" : [var Nat8] -> Blob) a;
 
-
 // Error codes
 type ErrorCode = {
   #system_fatal;
@@ -246,22 +276,20 @@ type ErrorCode = {
   #canister_reject;
   #canister_error;
   #future : Nat32;
-  #call_error : { err_code :  Nat32 }
+  #call_error : { err_code : Nat32 };
 };
 
 // creation and inspection of abstract error
 func error(message : Text) : Error {
   let e = (#canister_reject, message);
-  (prim "cast" : (ErrorCode, Text) -> Error) e
+  (prim "cast" : (ErrorCode, Text) -> Error) e;
 };
-func errorCode(e : Error) : ErrorCode =
-  ((prim "cast" : Error -> (ErrorCode, Text)) e).0;
-func errorMessage(e : Error) : Text =
-  ((prim "cast" : Error -> (ErrorCode, Text)) e).1;
+func errorCode(e : Error) : ErrorCode = ((prim "cast" : Error -> (ErrorCode, Text)) e).0;
+func errorMessage(e : Error) : Text = ((prim "cast" : Error -> (ErrorCode, Text)) e).1;
 
 // Time
 
-func time() : Nat64 = (prim "time" : () -> Nat64) ();
+func time() : Nat64 = (prim "time" : () -> Nat64)();
 
 // Principal
 
@@ -270,25 +298,25 @@ func principalOfBlob(act : Blob) : Principal = (prim "cast" : Blob -> Principal)
 
 func principalOfActor(act : actor {}) : Principal = (prim "cast" : (actor {}) -> Principal) act;
 func isController(p : Principal) : Bool = (prim "is_controller" : Principal -> Bool) p;
-func canisterVersion() : Nat64 = (prim "canister_version" : () -> Nat64) ();
+func canisterVersion() : Nat64 = (prim "canister_version" : () -> Nat64)();
 
 // Untyped dynamic actor creation from blobs
 let createActor : (wasm : Blob, argument : Blob) -> async Principal = @create_actor_helper;
 
 func cyclesBalance() : Nat {
-  (prim "cyclesBalance" : () -> Nat) ();
+  (prim "cyclesBalance" : () -> Nat)();
 };
 
 func cyclesAvailable() : Nat {
-  (prim "cyclesAvailable" : () -> Nat) ();
+  (prim "cyclesAvailable" : () -> Nat)();
 };
 
 func cyclesRefunded() : Nat {
-    @refund
+  @refund;
 };
 
 func cyclesAccept(amount : Nat) : Nat {
-  (prim "cyclesAccept" : Nat -> Nat) (amount);
+  (prim "cyclesAccept" : Nat -> Nat)(amount);
 };
 
 func cyclesAdd(amount : Nat) : () {
@@ -296,88 +324,63 @@ func cyclesAdd(amount : Nat) : () {
   @cycles += amount;
   // trap if @cycles would exceed 2^128
   if (@cycles > 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) {
-    trap("cannot add more than 2^128 cycles")
+    trap("cannot add more than 2^128 cycles");
   };
 };
 
 // certified data
 func setCertifiedData(data : Blob) = (prim "setCertifiedData" : Blob -> ()) data;
-func getCertificate() : ?Blob = (prim "getCertificate" : () -> ?Blob) ();
+func getCertificate() : ?Blob = (prim "getCertificate" : () -> ?Blob)();
 
 // stable memory
 
-func stableMemorySize() : Nat64 =
-  (prim "stableMemorySize" : () -> Nat64) ();
+func stableMemorySize() : Nat64 = (prim "stableMemorySize" : () -> Nat64)();
 
-func stableMemoryGrow(pages : Nat64) : Nat64 =
-  (prim "stableMemoryGrow" : Nat64 -> Nat64) pages;
+func stableMemoryGrow(pages : Nat64) : Nat64 = (prim "stableMemoryGrow" : Nat64 -> Nat64) pages;
 
-func stableMemoryLoadNat32(offset : Nat64) : Nat32 =
-  (prim "stableMemoryLoadNat32" : Nat64 -> Nat32) offset;
+func stableMemoryLoadNat32(offset : Nat64) : Nat32 = (prim "stableMemoryLoadNat32" : Nat64 -> Nat32) offset;
 
-func stableMemoryStoreNat32(offset : Nat64, val : Nat32) : () =
-  (prim "stableMemoryStoreNat32" : (Nat64, Nat32) -> ()) (offset, val);
+func stableMemoryStoreNat32(offset : Nat64, val : Nat32) : () = (prim "stableMemoryStoreNat32" : (Nat64, Nat32) -> ())(offset, val);
 
-func stableMemoryLoadNat8(offset : Nat64) : Nat8 =
-  (prim "stableMemoryLoadNat8" : Nat64 -> Nat8) offset;
+func stableMemoryLoadNat8(offset : Nat64) : Nat8 = (prim "stableMemoryLoadNat8" : Nat64 -> Nat8) offset;
 
-func stableMemoryStoreNat8(offset : Nat64, val : Nat8) : () =
-  (prim "stableMemoryStoreNat8" : (Nat64, Nat8) -> ()) (offset, val);
+func stableMemoryStoreNat8(offset : Nat64, val : Nat8) : () = (prim "stableMemoryStoreNat8" : (Nat64, Nat8) -> ())(offset, val);
 
-func stableMemoryLoadNat16(offset : Nat64) : Nat16 =
-  (prim "stableMemoryLoadNat16" : Nat64 -> Nat16) offset;
+func stableMemoryLoadNat16(offset : Nat64) : Nat16 = (prim "stableMemoryLoadNat16" : Nat64 -> Nat16) offset;
 
-func stableMemoryStoreNat16(offset : Nat64, val : Nat16) : () =
-  (prim "stableMemoryStoreNat16" : (Nat64, Nat16) -> ()) (offset, val);
+func stableMemoryStoreNat16(offset : Nat64, val : Nat16) : () = (prim "stableMemoryStoreNat16" : (Nat64, Nat16) -> ())(offset, val);
 
-func stableMemoryLoadNat64(offset : Nat64) : Nat64 =
-  (prim "stableMemoryLoadNat64" : Nat64 -> Nat64) offset;
+func stableMemoryLoadNat64(offset : Nat64) : Nat64 = (prim "stableMemoryLoadNat64" : Nat64 -> Nat64) offset;
 
-func stableMemoryStoreNat64(offset : Nat64, val : Nat64) : () =
-  (prim "stableMemoryStoreNat64" : (Nat64, Nat64) -> ()) (offset, val);
+func stableMemoryStoreNat64(offset : Nat64, val : Nat64) : () = (prim "stableMemoryStoreNat64" : (Nat64, Nat64) -> ())(offset, val);
 
-func stableMemoryLoadInt32(offset : Nat64) : Int32 =
-  (prim "stableMemoryLoadInt32" : Nat64 -> Int32) offset;
+func stableMemoryLoadInt32(offset : Nat64) : Int32 = (prim "stableMemoryLoadInt32" : Nat64 -> Int32) offset;
 
-func stableMemoryStoreInt32(offset : Nat64, val : Int32) : () =
-  (prim "stableMemoryStoreInt32" : (Nat64, Int32) -> ()) (offset, val);
+func stableMemoryStoreInt32(offset : Nat64, val : Int32) : () = (prim "stableMemoryStoreInt32" : (Nat64, Int32) -> ())(offset, val);
 
-func stableMemoryLoadInt8(offset : Nat64) : Int8 =
-  (prim "stableMemoryLoadInt8" : Nat64 -> Int8) offset;
+func stableMemoryLoadInt8(offset : Nat64) : Int8 = (prim "stableMemoryLoadInt8" : Nat64 -> Int8) offset;
 
-func stableMemoryStoreInt8(offset : Nat64, val : Int8) : () =
-  (prim "stableMemoryStoreInt8" : (Nat64, Int8) -> ()) (offset, val);
+func stableMemoryStoreInt8(offset : Nat64, val : Int8) : () = (prim "stableMemoryStoreInt8" : (Nat64, Int8) -> ())(offset, val);
 
-func stableMemoryLoadInt16(offset : Nat64) : Int16 =
-  (prim "stableMemoryLoadInt16" : Nat64 -> Int16) offset;
+func stableMemoryLoadInt16(offset : Nat64) : Int16 = (prim "stableMemoryLoadInt16" : Nat64 -> Int16) offset;
 
-func stableMemoryStoreInt16(offset : Nat64, val : Int16) : () =
-  (prim "stableMemoryStoreInt16" : (Nat64, Int16) -> ()) (offset, val);
+func stableMemoryStoreInt16(offset : Nat64, val : Int16) : () = (prim "stableMemoryStoreInt16" : (Nat64, Int16) -> ())(offset, val);
 
-func stableMemoryLoadInt64(offset : Nat64) : Int64 =
-  (prim "stableMemoryLoadInt64" : Nat64 -> Int64) offset;
+func stableMemoryLoadInt64(offset : Nat64) : Int64 = (prim "stableMemoryLoadInt64" : Nat64 -> Int64) offset;
 
-func stableMemoryStoreInt64(offset : Nat64, val : Int64) : () =
-  (prim "stableMemoryStoreInt64" : (Nat64, Int64) -> ()) (offset, val);
+func stableMemoryStoreInt64(offset : Nat64, val : Int64) : () = (prim "stableMemoryStoreInt64" : (Nat64, Int64) -> ())(offset, val);
 
-func stableMemoryLoadFloat(offset : Nat64) : Float =
-  (prim "stableMemoryLoadFloat" : Nat64 -> Float) offset;
+func stableMemoryLoadFloat(offset : Nat64) : Float = (prim "stableMemoryLoadFloat" : Nat64 -> Float) offset;
 
-func stableMemoryStoreFloat(offset : Nat64, val :  Float) : () =
-  (prim "stableMemoryStoreFloat" : (Nat64, Float) -> ()) (offset, val);
+func stableMemoryStoreFloat(offset : Nat64, val : Float) : () = (prim "stableMemoryStoreFloat" : (Nat64, Float) -> ())(offset, val);
 
-func stableMemoryLoadBlob(offset : Nat64, size : Nat) : Blob =
-  (prim "stableMemoryLoadBlob" : (Nat64, Nat) -> Blob) (offset, size);
+func stableMemoryLoadBlob(offset : Nat64, size : Nat) : Blob = (prim "stableMemoryLoadBlob" : (Nat64, Nat) -> Blob)(offset, size);
 
-func stableMemoryStoreBlob(offset : Nat64, val :  Blob) : () =
-  (prim "stableMemoryStoreBlob" : (Nat64, Blob) -> ()) (offset, val);
+func stableMemoryStoreBlob(offset : Nat64, val : Blob) : () = (prim "stableMemoryStoreBlob" : (Nat64, Blob) -> ())(offset, val);
 
 // Returns a query that computes the current actor's stable variable statistics (for now, the current size, in bytes, of serialized stable variable data).
-func stableVarQuery() : shared query () -> async {size : Nat64} =
-  (prim "stableVarQuery" : () -> (shared query () -> async {size : Nat64})) () ;
-
+func stableVarQuery() : shared query () -> async { size : Nat64 } = (prim "stableVarQuery" : () -> (shared query () -> async { size : Nat64 }))();
 
 let call_raw = @call_raw;
 
-func performanceCounter(counter : Nat32) : Nat64 =
-  (prim "performanceCounter" : (Nat32) -> Nat64) counter;
+func performanceCounter(counter : Nat32) : Nat64 = (prim "performanceCounter" : (Nat32) -> Nat64) counter;
diff --git a/test/fail/ok/no-timer-canc.tc.ok b/test/fail/ok/no-timer-canc.tc.ok
index ce9c53ef653..cc272e6b02e 100644
--- a/test/fail/ok/no-timer-canc.tc.ok
+++ b/test/fail/ok/no-timer-canc.tc.ok
@@ -114,13 +114,19 @@ no-timer-canc.mo:3.10-3.21: type error [M0119], object field cancelTimer is not
     hashBlob : Blob -> Nat32;
     idlHash : Text -> Nat32;
     int16ToInt : Int16 -> Int;
+    int16ToInt32 : Int16 -> Int32;
+    int16ToInt8 : Int16 -> Int8;
     int16ToNat16 : Int16 -> Nat16;
     int32ToInt : Int32 -> Int;
+    int32ToInt16 : Int32 -> Int16;
+    int32ToInt64 : Int32 -> Int64;
     int32ToNat32 : Int32 -> Nat32;
     int64ToFloat : Int64 -> Float;
     int64ToInt : Int64 -> Int;
+    int64ToInt32 : Int64 -> Int32;
     int64ToNat64 : Int64 -> Nat64;
     int8ToInt : Int8 -> Int;
+    int8ToInt16 : Int8 -> Int16;
     int8ToNat8 : Int8 -> Nat8;
     intToFloat : Int -> Float;
     intToInt16 : Int -> Int16;
@@ -139,13 +145,19 @@ no-timer-canc.mo:3.10-3.21: type error [M0119], object field cancelTimer is not
     log : Float -> Float;
     nat16ToInt16 : Nat16 -> Int16;
     nat16ToNat : Nat16 -> Nat;
+    nat16ToNat32 : Nat16 -> Nat32;
+    nat16ToNat8 : Nat16 -> Nat8;
     nat32ToChar : Nat32 -> Char;
     nat32ToInt32 : Nat32 -> Int32;
     nat32ToNat : Nat32 -> Nat;
+    nat32ToNat16 : Nat32 -> Nat16;
+    nat32ToNat64 : Nat32 -> Nat64;
     nat64ToInt64 : Nat64 -> Int64;
     nat64ToNat : Nat64 -> Nat;
+    nat64ToNat32 : Nat64 -> Nat32;
     nat8ToInt8 : Nat8 -> Int8;
     nat8ToNat : Nat8 -> Nat;
+    nat8ToNat16 : Nat8 -> Nat16;
     natToNat16 : Nat -> Nat16;
     natToNat32 : Nat -> Nat32;
     natToNat64 : Nat -> Nat64;
diff --git a/test/fail/ok/no-timer-set.tc.ok b/test/fail/ok/no-timer-set.tc.ok
index 75b505fc318..94ba0f5a325 100644
--- a/test/fail/ok/no-timer-set.tc.ok
+++ b/test/fail/ok/no-timer-set.tc.ok
@@ -114,13 +114,19 @@ no-timer-set.mo:3.10-3.18: type error [M0119], object field setTimer is not cont
     hashBlob : Blob -> Nat32;
     idlHash : Text -> Nat32;
     int16ToInt : Int16 -> Int;
+    int16ToInt32 : Int16 -> Int32;
+    int16ToInt8 : Int16 -> Int8;
     int16ToNat16 : Int16 -> Nat16;
     int32ToInt : Int32 -> Int;
+    int32ToInt16 : Int32 -> Int16;
+    int32ToInt64 : Int32 -> Int64;
     int32ToNat32 : Int32 -> Nat32;
     int64ToFloat : Int64 -> Float;
     int64ToInt : Int64 -> Int;
+    int64ToInt32 : Int64 -> Int32;
     int64ToNat64 : Int64 -> Nat64;
     int8ToInt : Int8 -> Int;
+    int8ToInt16 : Int8 -> Int16;
     int8ToNat8 : Int8 -> Nat8;
     intToFloat : Int -> Float;
     intToInt16 : Int -> Int16;
@@ -139,13 +145,19 @@ no-timer-set.mo:3.10-3.18: type error [M0119], object field setTimer is not cont
     log : Float -> Float;
     nat16ToInt16 : Nat16 -> Int16;
     nat16ToNat : Nat16 -> Nat;
+    nat16ToNat32 : Nat16 -> Nat32;
+    nat16ToNat8 : Nat16 -> Nat8;
     nat32ToChar : Nat32 -> Char;
     nat32ToInt32 : Nat32 -> Int32;
     nat32ToNat : Nat32 -> Nat;
+    nat32ToNat16 : Nat32 -> Nat16;
+    nat32ToNat64 : Nat32 -> Nat64;
     nat64ToInt64 : Nat64 -> Int64;
     nat64ToNat : Nat64 -> Nat;
+    nat64ToNat32 : Nat64 -> Nat32;
     nat8ToInt8 : Nat8 -> Int8;
     nat8ToNat : Nat8 -> Nat;
+    nat8ToNat16 : Nat8 -> Nat16;
     natToNat16 : Nat -> Nat16;
     natToNat32 : Nat -> Nat32;
     natToNat64 : Nat -> Nat64;
diff --git a/test/repl/ok/outrange-int-nat.stderr.ok b/test/repl/ok/outrange-int-nat.stderr.ok
index 89e69ec6b84..969965dfc44 100644
--- a/test/repl/ok/outrange-int-nat.stderr.ok
+++ b/test/repl/ok/outrange-int-nat.stderr.ok
@@ -10,3 +10,12 @@ prim:___: execution error, value out of bounds
 prim:___: execution error, value out of bounds
 prim:___: execution error, value out of bounds
 prim:___: execution error, value out of bounds
+prim:___: execution error, value out of bounds
+prim:___: execution error, value out of bounds
+prim:___: execution error, value out of bounds
+prim:___: execution error, value out of bounds
+prim:___: execution error, value out of bounds
+prim:___: execution error, value out of bounds
+prim:___: execution error, value out of bounds
+prim:___: execution error, value out of bounds
+prim:___: execution error, value out of bounds
diff --git a/test/repl/ok/outrange-int-nat.stdout.ok b/test/repl/ok/outrange-int-nat.stdout.ok
index cfd468abf26..05777f1c0e4 100644
--- a/test/repl/ok/outrange-int-nat.stdout.ok
+++ b/test/repl/ok/outrange-int-nat.stdout.ok
@@ -2,15 +2,24 @@ Motoko compiler (source XXX)
 > let Prim : module {...}
 > +127 : Int8
 > > -128 : Int8
+> >   +127 : Int8
+> > -128 : Int8
+> >   +32_767 : Int16
+> > -32_768 : Int16
 > >   +32_767 : Int16
 > > -32_768 : Int16
 > >   +2_147_483_647 : Int32
 > > -2_147_483_648 : Int32
+> >   +2_147_483_647 : Int32
+> > -2_147_483_648 : Int32
 > >   +9_223_372_036_854_775_807 : Int64
 > > -9_223_372_036_854_775_808 : Int64
 > >     255 : Nat8
+> >   255 : Nat8
+> >   65_535 : Nat16
 > >   65_535 : Nat16
 > >   4_294_967_295 : Nat32
+> >   4_294_967_295 : Nat32
 > >   18_446_744_073_709_551_615 : Nat64
 > >     -127 : Int8
 > -127 : Int8
diff --git a/test/repl/outrange-int-nat.sh b/test/repl/outrange-int-nat.sh
index cbbaf2ee8e8..04607b05f3c 100755
--- a/test/repl/outrange-int-nat.sh
+++ b/test/repl/outrange-int-nat.sh
@@ -7,16 +7,31 @@ Prim.intToInt8 0x80;
 Prim.intToInt8 (-0x80);
 Prim.intToInt8 (-0x81);
 
+Prim.int16ToInt8 0x7F;
+Prim.int16ToInt8 0x80;
+Prim.int16ToInt8 (-0x80);
+Prim.int16ToInt8 (-0x81);
+
 Prim.intToInt16 0x7FFF;
 Prim.intToInt16 0x8000;
 Prim.intToInt16 (-0x8000);
 Prim.intToInt16 (-0x8001);
 
+Prim.int32ToInt16 0x7FFF;
+Prim.int32ToInt16 0x8000;
+Prim.int32ToInt16 (-0x8000);
+Prim.int32ToInt16 (-0x8001);
+
 Prim.intToInt32 0x7FFFFFFF;
 Prim.intToInt32 0x80000000;
 Prim.intToInt32 (-0x80000000);
 Prim.intToInt32 (-0x80000001);
 
+Prim.int64ToInt32 0x7FFFFFFF;
+Prim.int64ToInt32 0x80000000;
+Prim.int64ToInt32 (-0x80000000);
+Prim.int64ToInt32 (-0x80000001);
+
 Prim.intToInt64 0x7FFFFFFFFFFFFFFF;
 Prim.intToInt64 0x8000000000000000;
 Prim.intToInt64 (-0x8000000000000000);
@@ -26,12 +41,21 @@ Prim.intToInt64 (-0x8000000000000001);
 Prim.natToNat8 0xFF;
 Prim.natToNat8 0x100;
 
+Prim.nat16ToNat8 0xFF;
+Prim.nat16ToNat8 0x100;
+
 Prim.natToNat16 0xFFFF;
 Prim.natToNat16 0x10000;
 
+Prim.nat32ToNat16 0xFFFF;
+Prim.nat32ToNat16 0x10000;
+
 Prim.natToNat32 0xFFFFFFFF;
 Prim.natToNat32 0x100000000;
 
+Prim.nat64ToNat32 0xFFFFFFFF;
+Prim.nat64ToNat32 0x100000000;
+
 Prim.natToNat64 0xFFFFFFFFFFFFFFFF;
 Prim.natToNat64 0x10000000000000000;
 
diff --git a/test/run.sh b/test/run.sh
index 9035830ac33..7ef28a30bcb 100755
--- a/test/run.sh
+++ b/test/run.sh
@@ -26,7 +26,7 @@ DTESTS=no
 IDL=no
 PERF=no
 VIPER=no
-WASMTIME_OPTIONS="--disable-cache"
+WASMTIME_OPTIONS="--disable-cache --enable-cranelift-nan-canonicalization"
 WRAP_drun=$(realpath $(dirname $0)/drun-wrapper.sh)
 WRAP_ic_ref_run=$(realpath $(dirname $0)/ic-ref-run-wrapper.sh)
 SKIP_RUNNING=${SKIP_RUNNING:-no}
@@ -351,7 +351,7 @@ do
         then
           run comp $moc_with_flags --hide-warnings --map -c $mangled -o $out/$base.wasm
           if [ $HAVE_ic_wasm = yes ]; then
-            run opt ic-wasm -o $out/$base.opt.wasm $out/$base.wasm shrink --optimize O3 --keep-name-section
+            run opt ic-wasm -o $out/$base.opt.wasm $out/$base.wasm optimize O3 --keep-name-section
           fi
         else
           run comp $moc_with_flags -g -wasi-system-api --hide-warnings --map -c $mangled -o $out/$base.wasm
diff --git a/test/run/conversions.mo b/test/run/conversions.mo
index 83f9e5e500f..4e5f133dbc0 100644
--- a/test/run/conversions.mo
+++ b/test/run/conversions.mo
@@ -3,14 +3,14 @@ import Prim "mo:⛔";
 // Nat <--> Nat8
 
 func test_Nat_Nat8(n1 : Nat, n2 : Nat8) {
-  assert(Prim.natToNat8 n1 == n2);
-  assert(Prim.intToNat8Wrap n1 == n2);
-  assert(n1 == Prim.nat8ToNat n2);
+  assert Prim.natToNat8 n1 == n2;
+  assert Prim.intToNat8Wrap n1 == n2;
+  assert n1 == Prim.nat8ToNat n2;
 };
 func wrap_Nat_Nat8(n1 : Nat, n2 : Nat8) {
-  assert(Prim.natToNat8 (n1 % 2**8) == n2);
-  assert(Prim.intToNat8Wrap n1 == n2);
-  assert(n1 % 2**8 == Prim.nat8ToNat n2);
+  assert Prim.natToNat8(n1 % 2 ** 8) == n2;
+  assert Prim.intToNat8Wrap n1 == n2;
+  assert n1 % 2 ** 8 == Prim.nat8ToNat n2;
 };
 
 test_Nat_Nat8(0, 0);
@@ -22,14 +22,14 @@ wrap_Nat_Nat8(0x101, 1);
 // Nat <--> Nat16
 
 func test_Nat_Nat16(n1 : Nat, n2 : Nat16) {
-  assert(Prim.natToNat16 n1 == n2);
-  assert(Prim.intToNat16Wrap n1 == n2);
-  assert(n1 == Prim.nat16ToNat n2);
+  assert Prim.natToNat16 n1 == n2;
+  assert Prim.intToNat16Wrap n1 == n2;
+  assert n1 == Prim.nat16ToNat n2;
 };
 func wrap_Nat_Nat16(n1 : Nat, n2 : Nat16) {
-  assert(Prim.natToNat16 (n1 % 2**16) == n2);
-  assert(Prim.intToNat16Wrap n1 == n2);
-  assert(n1 % 2**16 == Prim.nat16ToNat n2);
+  assert Prim.natToNat16(n1 % 2 ** 16) == n2;
+  assert Prim.intToNat16Wrap n1 == n2;
+  assert n1 % 2 ** 16 == Prim.nat16ToNat n2;
 };
 
 test_Nat_Nat16(0, 0);
@@ -41,14 +41,14 @@ wrap_Nat_Nat16(0x10001, 1);
 // Nat <--> Nat32
 
 func test_Nat_Nat32(n1 : Nat, n2 : Nat32) {
-  assert(Prim.natToNat32 n1 == n2);
-  assert(Prim.intToNat32Wrap n1 == n2);
-  assert(n1 == Prim.nat32ToNat n2);
+  assert Prim.natToNat32 n1 == n2;
+  assert Prim.intToNat32Wrap n1 == n2;
+  assert n1 == Prim.nat32ToNat n2;
 };
 func wrap_Nat_Nat32(n1 : Nat, n2 : Nat32) {
-  assert(Prim.natToNat32 (n1 % 2**32) == n2);
-  assert(Prim.intToNat32Wrap n1 == n2);
-  assert(n1 % 2**32 == Prim.nat32ToNat n2);
+  assert Prim.natToNat32(n1 % 2 ** 32) == n2;
+  assert Prim.intToNat32Wrap n1 == n2;
+  assert n1 % 2 ** 32 == Prim.nat32ToNat n2;
 };
 
 test_Nat_Nat32(0, 0);
@@ -60,14 +60,14 @@ wrap_Nat_Nat32(0x100000001, 1);
 // Nat <--> Nat64
 
 func test_Nat_Nat64(n1 : Nat, n2 : Nat64) {
-  assert(Prim.natToNat64 n1 == n2);
-  assert(Prim.intToNat64Wrap n1 == n2);
-  assert(n1 == Prim.nat64ToNat n2);
+  assert Prim.natToNat64 n1 == n2;
+  assert Prim.intToNat64Wrap n1 == n2;
+  assert n1 == Prim.nat64ToNat n2;
 };
 func wrap_Nat_Nat64(n1 : Nat, n2 : Nat64) {
-  assert(Prim.natToNat64 (n1 % 2**64) == n2);
-  assert(Prim.intToNat64Wrap n1 == n2);
-  assert(n1 % 2**64 == Prim.nat64ToNat n2);
+  assert Prim.natToNat64(n1 % 2 ** 64) == n2;
+  assert Prim.intToNat64Wrap n1 == n2;
+  assert n1 % 2 ** 64 == Prim.nat64ToNat n2;
 };
 
 test_Nat_Nat64(0, 0);
@@ -79,16 +79,16 @@ wrap_Nat_Nat64(0x10000000000000001, 1);
 // Int <--> Int8
 
 func test_Int_Int8(n1 : Int, n2 : Int8) {
-  assert(Prim.intToInt8 n1 == n2);
-  assert(Prim.intToInt8Wrap n1 == n2);
-  assert(n1 == Prim.int8ToInt n2);
+  assert Prim.intToInt8 n1 == n2;
+  assert Prim.intToInt8Wrap n1 == n2;
+  assert n1 == Prim.int8ToInt n2;
 };
 func wrap_Int_Int8(n1 : Int, n2 : Int8) {
-  var n1_wrapped = n1 % 2**8;
-  if (n1_wrapped >= 2**7) n1_wrapped -= 2**8;
-  assert(Prim.intToInt8 n1_wrapped == n2);
-  assert(Prim.intToInt8Wrap n1 == n2);
-  assert(n1_wrapped == Prim.int8ToInt n2);
+  var n1_wrapped = n1 % 2 ** 8;
+  if (n1_wrapped >= 2 ** 7) n1_wrapped -= 2 ** 8;
+  assert Prim.intToInt8 n1_wrapped == n2;
+  assert Prim.intToInt8Wrap n1 == n2;
+  assert n1_wrapped == Prim.int8ToInt n2;
 };
 
 test_Int_Int8(0, 0);
@@ -103,16 +103,16 @@ wrap_Int_Int8(0x81, -0x7f);
 // Int <--> Int16
 
 func test_Int_Int16(n1 : Int, n2 : Int16) {
-  assert(Prim.intToInt16 n1 == n2);
-  assert(Prim.intToInt16Wrap n1 == n2);
-  assert(n1 == Prim.int16ToInt n2);
+  assert Prim.intToInt16 n1 == n2;
+  assert Prim.intToInt16Wrap n1 == n2;
+  assert n1 == Prim.int16ToInt n2;
 };
 func wrap_Int_Int16(n1 : Int, n2 : Int16) {
-  var n1_wrapped = n1 % 2**16;
-  if (n1_wrapped >= 2**15) n1_wrapped -= 2**16;
-  assert(Prim.intToInt16 n1_wrapped == n2);
-  assert(Prim.intToInt16Wrap n1 == n2);
-  assert(n1_wrapped == Prim.int16ToInt n2);
+  var n1_wrapped = n1 % 2 ** 16;
+  if (n1_wrapped >= 2 ** 15) n1_wrapped -= 2 ** 16;
+  assert Prim.intToInt16 n1_wrapped == n2;
+  assert Prim.intToInt16Wrap n1 == n2;
+  assert n1_wrapped == Prim.int16ToInt n2;
 };
 
 test_Int_Int16(0, 0);
@@ -127,16 +127,16 @@ wrap_Int_Int16(0x8001, -0x7fff);
 // Int <--> Int32
 
 func test_Int_Int32(n1 : Int, n2 : Int32) {
-  assert(Prim.intToInt32 n1 == n2);
-  assert(Prim.intToInt32Wrap n1 == n2);
-  assert(n1 == Prim.int32ToInt n2);
+  assert Prim.intToInt32 n1 == n2;
+  assert Prim.intToInt32Wrap n1 == n2;
+  assert n1 == Prim.int32ToInt n2;
 };
 func wrap_Int_Int32(n1 : Int, n2 : Int32) {
-  var n1_wrapped = n1 % 2**32;
-  if (n1_wrapped >= 2**31) n1_wrapped -= 2**32;
-  assert(Prim.intToInt32 n1_wrapped == n2);
-  assert(Prim.intToInt32Wrap n1 == n2);
-  assert(n1_wrapped == Prim.int32ToInt n2);
+  var n1_wrapped = n1 % 2 ** 32;
+  if (n1_wrapped >= 2 ** 31) n1_wrapped -= 2 ** 32;
+  assert Prim.intToInt32 n1_wrapped == n2;
+  assert Prim.intToInt32Wrap n1 == n2;
+  assert n1_wrapped == Prim.int32ToInt n2;
 };
 
 test_Int_Int32(0, 0);
@@ -151,16 +151,16 @@ wrap_Int_Int32(0x80000001, -0x7fffffff);
 // Int <--> Int64
 
 func test_Int_Int64(n1 : Int, n2 : Int64) {
-  assert(Prim.intToInt64 n1 == n2);
-  assert(Prim.intToInt64Wrap n1 == n2);
-  assert(n1 == Prim.int64ToInt n2);
+  assert Prim.intToInt64 n1 == n2;
+  assert Prim.intToInt64Wrap n1 == n2;
+  assert n1 == Prim.int64ToInt n2;
 };
 func wrap_Int_Int64(n1 : Int, n2 : Int64) {
-  var n1_wrapped = n1 % 2**64;
-  if (n1_wrapped >= 2**63) n1_wrapped -= 2**64;
-  assert(Prim.intToInt64 n1_wrapped == n2);
-  assert(Prim.intToInt64Wrap n1 == n2);
-  assert(n1_wrapped == Prim.int64ToInt n2);
+  var n1_wrapped = n1 % 2 ** 64;
+  if (n1_wrapped >= 2 ** 63) n1_wrapped -= 2 ** 64;
+  assert Prim.intToInt64 n1_wrapped == n2;
+  assert Prim.intToInt64Wrap n1 == n2;
+  assert n1_wrapped == Prim.int64ToInt n2;
 };
 
 test_Int_Int64(0, 0);
@@ -171,3 +171,63 @@ test_Int_Int64(-0x7fffffffffffffff, -0x7fffffffffffffff);
 test_Int_Int64(-0x8000000000000000, -0x8000000000000000);
 wrap_Int_Int64(0x8000000000000000, -0x8000000000000000);
 wrap_Int_Int64(0x8000000000000001, -0x7fffffffffffffff);
+
+// NatN <--> Nat2N
+func test_Nat8_Nat16(n1 : Nat8, n2 : Nat16) {
+  assert Prim.nat8ToNat16 n1 == n2;
+  assert Prim.nat16ToNat8 n2 == n1;
+};
+func test_Nat16_Nat32(n1 : Nat16, n2 : Nat32) {
+  assert Prim.nat16ToNat32 n1 == n2;
+  assert Prim.nat32ToNat16 n2 == n1;
+};
+func test_Nat32_Nat64(n1 : Nat32, n2 : Nat64) {
+  assert Prim.nat32ToNat64 n1 == n2;
+  assert Prim.nat64ToNat32 n2 == n1;
+};
+
+test_Nat8_Nat16(0, 0);
+test_Nat8_Nat16(1, 1);
+test_Nat8_Nat16(0xff, 0xff);
+test_Nat16_Nat32(0, 0);
+test_Nat16_Nat32(1, 1);
+test_Nat16_Nat32(0xffff, 0xffff);
+test_Nat32_Nat64(0, 0);
+test_Nat32_Nat64(1, 1);
+test_Nat32_Nat64(0xffffffff, 0xffffffff);
+
+// IntN <--> Int2N
+func test_Int8_Int16(n1 : Int8, n2 : Int16) {
+  assert Prim.int8ToInt16 n1 == n2;
+  assert Prim.int16ToInt8 n2 == n1;
+};
+
+func test_Int16_Int32(n1 : Int16, n2 : Int32) {
+  assert Prim.int16ToInt32 n1 == n2;
+  // "side effect" should only be printed once
+  assert Prim.int32ToInt16((Prim.debugPrint "side effect", n2).1) == n1;
+};
+
+func test_Int32_Int64(n1 : Int32, n2 : Int64) {
+  assert Prim.int32ToInt64 n1 == n2;
+  assert Prim.int64ToInt32 n2 == n1;
+};
+
+test_Int8_Int16(0, 0);
+test_Int8_Int16(1, 1);
+test_Int8_Int16(-1, -1);
+test_Int8_Int16(0x7f, 0x7f);
+test_Int8_Int16(-0x7f, -0x7f);
+test_Int8_Int16(-0x80, -0x80);
+test_Int16_Int32(0, 0);
+test_Int16_Int32(1, 1);
+test_Int16_Int32(-1, -1);
+test_Int16_Int32(0x7fff, 0x7fff);
+test_Int16_Int32(-0x7fff, -0x7fff);
+test_Int16_Int32(-0x8000, -0x8000);
+test_Int32_Int64(0, 0);
+test_Int32_Int64(1, 1);
+test_Int32_Int64(-1, -1);
+test_Int32_Int64(0x7fffffff, 0x7fffffff);
+test_Int32_Int64(-0x7fffffff, -0x7fffffff);
+test_Int32_Int64(-0x80000000, -0x80000000);
diff --git a/test/run/ok/conversions.run-ir.ok b/test/run/ok/conversions.run-ir.ok
new file mode 100644
index 00000000000..79849a27e19
--- /dev/null
+++ b/test/run/ok/conversions.run-ir.ok
@@ -0,0 +1,6 @@
+side effect
+side effect
+side effect
+side effect
+side effect
+side effect
diff --git a/test/run/ok/conversions.run-low.ok b/test/run/ok/conversions.run-low.ok
new file mode 100644
index 00000000000..79849a27e19
--- /dev/null
+++ b/test/run/ok/conversions.run-low.ok
@@ -0,0 +1,6 @@
+side effect
+side effect
+side effect
+side effect
+side effect
+side effect
diff --git a/test/run/ok/conversions.run.ok b/test/run/ok/conversions.run.ok
new file mode 100644
index 00000000000..79849a27e19
--- /dev/null
+++ b/test/run/ok/conversions.run.ok
@@ -0,0 +1,6 @@
+side effect
+side effect
+side effect
+side effect
+side effect
+side effect
diff --git a/test/run/ok/conversions.wasm-run.ok b/test/run/ok/conversions.wasm-run.ok
new file mode 100644
index 00000000000..79849a27e19
--- /dev/null
+++ b/test/run/ok/conversions.wasm-run.ok
@@ -0,0 +1,6 @@
+side effect
+side effect
+side effect
+side effect
+side effect
+side effect
diff --git a/test/test-moc.js b/test/test-moc.js
index c2059d9668b..be9f1e36159 100644
--- a/test/test-moc.js
+++ b/test/test-moc.js
@@ -5,165 +5,169 @@ process.on("unhandledRejection", (error) => {
 const assert = require("assert").strict;
 
 // Load moc.js
-const moc = require("moc.js");
+const { Motoko } = require("moc.js");
 
 // Store files
-moc.Motoko.saveFile("empty.mo", "");
-moc.Motoko.saveFile("ok.mo", "1");
-moc.Motoko.saveFile("bad.mo", "1+");
-moc.Motoko.saveFile(
+Motoko.saveFile("empty.mo", "");
+Motoko.saveFile("ok.mo", "1");
+Motoko.saveFile("bad.mo", "1+");
+Motoko.saveFile(
   "actor.mo",
   'actor { type A<B> = B; public query func main() : async A<Text> { "abc" } }'
 );
-moc.Motoko.saveFile(
+Motoko.saveFile(
   "ast.mo",
   `
-  /// Module
-  module {
-    /// Variable
-    let x = 0;
-    /// Type
-    public type A<B> = B;
-    /** Function */
-    public query func main() {};
-    /// Sub-module
+  /** Program comment
+      multi-line */
+  import Prim "mo:prim";
+
+  actor {
+    /// Type comment
+    type T = Nat;
+    /// Variable comment
+    stable var x : T = 0;
+    /** Function comment */
+    public query func main() : async T { x };
+    /// Sub-module comment
     module M {
-      /// Class
+      /// Class comment
       public class C() {};
     };
   }`
 );
-moc.Motoko.saveFile("text.mo", `let s = "${"⛔|".repeat(10000)}"; s.size()`); // #3822
-
-try {
-  assert.equal(moc.Motoko.readFile("empty.mo"), "");
-  assert.equal(moc.Motoko.readFile("ok.mo"), "1");
-
-  // Compile the empty module in wasi and ic mode
-  const empty_wasm_plain = moc.Motoko.compileWasm("wasi", "empty.mo");
-  const empty_wasm_ic = moc.Motoko.compileWasm("ic", "empty.mo");
-
-  // For the plain module...
-  // Check that the code looks like a WebAssembly binary
-  assert.equal(typeof empty_wasm_plain, "object");
-  assert.deepEqual(
-    empty_wasm_plain.code.wasm.subarray(0, 4),
-    new Uint8Array([0, 97, 115, 109])
-  );
-  assert.deepEqual(
-    empty_wasm_plain.code.wasm.subarray(4, 8),
-    new Uint8Array([1, 0, 0, 0])
-  );
-  assert.equal(typeof empty_wasm_plain.diagnostics, "object");
-  assert.equal(empty_wasm_plain.diagnostics.length, 0);
-
-  // Check that the WebAssembly binary can be loaded
-  WebAssembly.compile(empty_wasm_plain.code.wasm);
-
-  // Now again for the ic module
-  assert.equal(typeof empty_wasm_ic, "object");
-  assert.deepEqual(
-    empty_wasm_plain.code.wasm.subarray(0, 4),
-    new Uint8Array([0, 97, 115, 109])
-  );
-  assert.deepEqual(
-    empty_wasm_plain.code.wasm.subarray(4, 8),
-    new Uint8Array([1, 0, 0, 0])
-  );
-  assert.equal(typeof empty_wasm_ic.diagnostics, "object");
-  assert.equal(empty_wasm_ic.diagnostics.length, 0);
-
-  WebAssembly.compile(empty_wasm_ic.code.wasm);
-
-  // The plain and the ic module should not be the same
-  assert.notEqual(empty_wasm_plain.code.wasm, empty_wasm_ic.code.wasm);
-
-  moc.Motoko.removeFile("empty.mo");
-  assert.throws(() => {
-    moc.Motoko.compileWasm("ic", "empty.mo");
-  }, /No such file or directory/);
-
-  // Check if error messages are correctly returned
-  const bad_result = moc.Motoko.compileWasm("ic", "bad.mo");
-  // Uncomment to see what to paste below
-  // console.log(JSON.stringify(bad_result, null, 2));
-  assert.deepStrictEqual(bad_result, {
-    diagnostics: [
-      {
-        range: {
-          start: {
-            line: 0,
-            character: 2,
-          },
-          end: {
-            line: 0,
-            character: 2,
-          },
+Motoko.saveFile("text.mo", `let s = "${"⛔|".repeat(10000)}"; s.size()`); // #3822
+
+assert.equal(Motoko.readFile("empty.mo"), "");
+assert.equal(Motoko.readFile("ok.mo"), "1");
+
+// Compile the empty module in wasi and ic mode
+const empty_wasm_plain = Motoko.compileWasm("wasi", "empty.mo");
+const empty_wasm_ic = Motoko.compileWasm("ic", "empty.mo");
+
+// For the plain module...
+// Check that the code looks like a WebAssembly binary
+assert.equal(typeof empty_wasm_plain, "object");
+assert.deepEqual(
+  empty_wasm_plain.code.wasm.subarray(0, 4),
+  new Uint8Array([0, 97, 115, 109])
+);
+assert.deepEqual(
+  empty_wasm_plain.code.wasm.subarray(4, 8),
+  new Uint8Array([1, 0, 0, 0])
+);
+assert.equal(typeof empty_wasm_plain.diagnostics, "object");
+assert.equal(empty_wasm_plain.diagnostics.length, 0);
+
+// Check that the WebAssembly binary can be loaded
+WebAssembly.compile(empty_wasm_plain.code.wasm);
+
+// Now again for the ic module
+assert.equal(typeof empty_wasm_ic, "object");
+assert.deepEqual(
+  empty_wasm_plain.code.wasm.subarray(0, 4),
+  new Uint8Array([0, 97, 115, 109])
+);
+assert.deepEqual(
+  empty_wasm_plain.code.wasm.subarray(4, 8),
+  new Uint8Array([1, 0, 0, 0])
+);
+assert.equal(typeof empty_wasm_ic.diagnostics, "object");
+assert.equal(empty_wasm_ic.diagnostics.length, 0);
+
+WebAssembly.compile(empty_wasm_ic.code.wasm);
+
+// The plain and the ic module should not be the same
+assert.notEqual(empty_wasm_plain.code.wasm, empty_wasm_ic.code.wasm);
+
+Motoko.removeFile("empty.mo");
+assert.throws(() => {
+  Motoko.compileWasm("ic", "empty.mo");
+}, /No such file or directory/);
+
+// Check if error messages are correctly returned
+const bad_result = Motoko.compileWasm("ic", "bad.mo");
+// Uncomment to see what to paste below
+// console.log(JSON.stringify(bad_result, null, 2));
+assert.deepStrictEqual(bad_result, {
+  diagnostics: [
+    {
+      range: {
+        start: {
+          line: 0,
+          character: 2,
+        },
+        end: {
+          line: 0,
+          character: 2,
         },
-        severity: 1,
-        source: "bad.mo",
-        code: "M0001",
-        category: "syntax",
-        message:
-          "unexpected end of input, expected one of token or <phrase> sequence:\n  <exp_bin(ob)>",
       },
-    ],
-    code: null,
-  });
-
-  // Check the check command (should print errors, but have no code)
-  assert.deepStrictEqual(moc.Motoko.check("ok.mo"), {
-    diagnostics: [],
-    code: null,
-  });
-
-  assert.deepStrictEqual(moc.Motoko.check("bad.mo"), {
-    diagnostics: [
-      {
-        range: {
-          start: {
-            line: 0,
-            character: 2,
-          },
-          end: {
-            line: 0,
-            character: 2,
-          },
+      severity: 1,
+      source: "bad.mo",
+      code: "M0001",
+      category: "syntax",
+      message:
+        "unexpected end of input, expected one of token or <phrase> sequence:\n  <exp_bin(ob)>",
+    },
+  ],
+  code: null,
+});
+
+// Check the check command (should print errors, but have no code)
+assert.deepStrictEqual(Motoko.check("ok.mo"), {
+  diagnostics: [],
+  code: null,
+});
+
+assert.deepStrictEqual(Motoko.check("bad.mo"), {
+  diagnostics: [
+    {
+      range: {
+        start: {
+          line: 0,
+          character: 2,
+        },
+        end: {
+          line: 0,
+          character: 2,
         },
-        severity: 1,
-        source: "bad.mo",
-        category: "syntax",
-        code: "M0001",
-        message:
-          "unexpected end of input, expected one of token or <phrase> sequence:\n  <exp_bin(ob)>",
       },
-    ],
-    code: null,
-  });
-
-  const astString = JSON.stringify(
-    moc.Motoko.parseMotoko(moc.Motoko.readFile("ast.mo"))
-  );
-
-  // Check doc comments
-  assert.match(astString, /"name":"\*","args":\["Module"/);
-  assert.match(astString, /"name":"\*","args":\["Variable"/);
-  assert.match(astString, /"name":"\*","args":\["Type"/);
-  assert.match(astString, /"name":"\*","args":\["Function"/);
-  assert.match(astString, /"name":"\*","args":\["Sub-module"/);
-  assert.match(astString, /"name":"\*","args":\["Class"/);
-
-  // // Check Wasm reproducibility
-  // assert.deepStrictEqual(
-  //   moc.Motoko.compileWasm("ic", "actor.mo").code.wasm,
-  //   moc.Motoko.compileWasm("ic", "actor.mo").code.wasm
-  // );
-
-  // Check that long text literals type-check without error
-  assert.deepStrictEqual(moc.Motoko.check("text.mo"), {
-    code: null,
-    diagnostics: [],
-  });
-} catch (err) {
-  assert.fail(err);
+      severity: 1,
+      source: "bad.mo",
+      category: "syntax",
+      code: "M0001",
+      message:
+        "unexpected end of input, expected one of token or <phrase> sequence:\n  <exp_bin(ob)>",
+    },
+  ],
+  code: null,
+});
+
+const astString = JSON.stringify(
+  Motoko.parseMotoko(Motoko.readFile("ast.mo"))
+);
+
+// Check doc comments
+assert.match(astString, /"name":"\*","args":\["Program comment\\n      multi-line"/);
+assert.match(astString, /"name":"\*","args":\["Type comment"/);
+assert.match(astString, /"name":"\*","args":\["Variable comment"/);
+assert.match(astString, /"name":"\*","args":\["Function comment"/);
+assert.match(astString, /"name":"\*","args":\["Sub-module comment"/);
+assert.match(astString, /"name":"\*","args":\["Class comment"/);
+
+// Check that long text literals type-check without error
+assert.deepStrictEqual(Motoko.check("text.mo"), {
+  code: null,
+  diagnostics: [],
+});
+
+const candid = `
+type T = nat;
+/// Program comment
+///       multi-line
+service : {
+  /// Function comment
+  main: () -> (T) query;
 }
+`.trim() + '\n';
+assert.deepStrictEqual(Motoko.candid('ast.mo'), {diagnostics: [], code: candid});
diff --git a/test/trap/ok/outrange-int16-int8-lower.run-ir.ok b/test/trap/ok/outrange-int16-int8-lower.run-ir.ok
new file mode 100644
index 00000000000..785d7427085
--- /dev/null
+++ b/test/trap/ok/outrange-int16-int8-lower.run-ir.ok
@@ -0,0 +1 @@
+prim:___: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-int16-int8-lower.run-low.ok b/test/trap/ok/outrange-int16-int8-lower.run-low.ok
new file mode 100644
index 00000000000..785d7427085
--- /dev/null
+++ b/test/trap/ok/outrange-int16-int8-lower.run-low.ok
@@ -0,0 +1 @@
+prim:___: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-int16-int8-lower.run.ok b/test/trap/ok/outrange-int16-int8-lower.run.ok
new file mode 100644
index 00000000000..785d7427085
--- /dev/null
+++ b/test/trap/ok/outrange-int16-int8-lower.run.ok
@@ -0,0 +1 @@
+prim:___: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-int16-int8-lower.run.ret.ok b/test/trap/ok/outrange-int16-int8-lower.run.ret.ok
new file mode 100644
index 00000000000..69becfa16f9
--- /dev/null
+++ b/test/trap/ok/outrange-int16-int8-lower.run.ret.ok
@@ -0,0 +1 @@
+Return code 1
diff --git a/test/trap/ok/outrange-int16-int8-lower.wasm-run.ok b/test/trap/ok/outrange-int16-int8-lower.wasm-run.ok
new file mode 100644
index 00000000000..4617624b446
--- /dev/null
+++ b/test/trap/ok/outrange-int16-int8-lower.wasm-run.ok
@@ -0,0 +1,9 @@
+losing precision
+Error: failed to run main module `_out/outrange-int16-int8-lower.wasm`
+
+Caused by:
+    0: failed to invoke command default
+    1: error while executing at wasm backtrace:
+         0: init
+         1: _start
+    2: wasm trap: unreachable
diff --git a/test/trap/ok/outrange-int16-int8-lower.wasm-run.ret.ok b/test/trap/ok/outrange-int16-int8-lower.wasm-run.ret.ok
new file mode 100644
index 00000000000..8209aecf795
--- /dev/null
+++ b/test/trap/ok/outrange-int16-int8-lower.wasm-run.ret.ok
@@ -0,0 +1 @@
+Return code 134
diff --git a/test/trap/ok/outrange-int16-int8-negation.run-ir.ok b/test/trap/ok/outrange-int16-int8-negation.run-ir.ok
new file mode 100644
index 00000000000..f8423dbee1d
--- /dev/null
+++ b/test/trap/ok/outrange-int16-int8-negation.run-ir.ok
@@ -0,0 +1 @@
+outrange-int16-int8-negation.mo:2.9-2.36: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-int16-int8-negation.run-low.ok b/test/trap/ok/outrange-int16-int8-negation.run-low.ok
new file mode 100644
index 00000000000..f8423dbee1d
--- /dev/null
+++ b/test/trap/ok/outrange-int16-int8-negation.run-low.ok
@@ -0,0 +1 @@
+outrange-int16-int8-negation.mo:2.9-2.36: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-int16-int8-negation.run.ok b/test/trap/ok/outrange-int16-int8-negation.run.ok
new file mode 100644
index 00000000000..f8423dbee1d
--- /dev/null
+++ b/test/trap/ok/outrange-int16-int8-negation.run.ok
@@ -0,0 +1 @@
+outrange-int16-int8-negation.mo:2.9-2.36: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-int16-int8-negation.run.ret.ok b/test/trap/ok/outrange-int16-int8-negation.run.ret.ok
new file mode 100644
index 00000000000..69becfa16f9
--- /dev/null
+++ b/test/trap/ok/outrange-int16-int8-negation.run.ret.ok
@@ -0,0 +1 @@
+Return code 1
diff --git a/test/trap/ok/outrange-int16-int8-negation.wasm-run.ok b/test/trap/ok/outrange-int16-int8-negation.wasm-run.ok
new file mode 100644
index 00000000000..e33a43e68e7
--- /dev/null
+++ b/test/trap/ok/outrange-int16-int8-negation.wasm-run.ok
@@ -0,0 +1,10 @@
+arithmetic overflow
+Error: failed to run main module `_out/outrange-int16-int8-negation.wasm`
+
+Caused by:
+    0: failed to invoke command default
+    1: error while executing at wasm backtrace:
+         0: neg32_trap
+         1: init
+         2: _start
+    2: wasm trap: unreachable
diff --git a/test/trap/ok/outrange-int16-int8-negation.wasm-run.ret.ok b/test/trap/ok/outrange-int16-int8-negation.wasm-run.ret.ok
new file mode 100644
index 00000000000..8209aecf795
--- /dev/null
+++ b/test/trap/ok/outrange-int16-int8-negation.wasm-run.ret.ok
@@ -0,0 +1 @@
+Return code 134
diff --git a/test/trap/ok/outrange-int16-int8-upper.run-ir.ok b/test/trap/ok/outrange-int16-int8-upper.run-ir.ok
new file mode 100644
index 00000000000..785d7427085
--- /dev/null
+++ b/test/trap/ok/outrange-int16-int8-upper.run-ir.ok
@@ -0,0 +1 @@
+prim:___: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-int16-int8-upper.run-low.ok b/test/trap/ok/outrange-int16-int8-upper.run-low.ok
new file mode 100644
index 00000000000..785d7427085
--- /dev/null
+++ b/test/trap/ok/outrange-int16-int8-upper.run-low.ok
@@ -0,0 +1 @@
+prim:___: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-int16-int8-upper.run.ok b/test/trap/ok/outrange-int16-int8-upper.run.ok
new file mode 100644
index 00000000000..785d7427085
--- /dev/null
+++ b/test/trap/ok/outrange-int16-int8-upper.run.ok
@@ -0,0 +1 @@
+prim:___: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-int16-int8-upper.run.ret.ok b/test/trap/ok/outrange-int16-int8-upper.run.ret.ok
new file mode 100644
index 00000000000..69becfa16f9
--- /dev/null
+++ b/test/trap/ok/outrange-int16-int8-upper.run.ret.ok
@@ -0,0 +1 @@
+Return code 1
diff --git a/test/trap/ok/outrange-int16-int8-upper.wasm-run.ok b/test/trap/ok/outrange-int16-int8-upper.wasm-run.ok
new file mode 100644
index 00000000000..b9b3412ac13
--- /dev/null
+++ b/test/trap/ok/outrange-int16-int8-upper.wasm-run.ok
@@ -0,0 +1,9 @@
+losing precision
+Error: failed to run main module `_out/outrange-int16-int8-upper.wasm`
+
+Caused by:
+    0: failed to invoke command default
+    1: error while executing at wasm backtrace:
+         0: init
+         1: _start
+    2: wasm trap: unreachable
diff --git a/test/trap/ok/outrange-int16-int8-upper.wasm-run.ret.ok b/test/trap/ok/outrange-int16-int8-upper.wasm-run.ret.ok
new file mode 100644
index 00000000000..8209aecf795
--- /dev/null
+++ b/test/trap/ok/outrange-int16-int8-upper.wasm-run.ret.ok
@@ -0,0 +1 @@
+Return code 134
diff --git a/test/trap/ok/outrange-int32-int16-lower.run-ir.ok b/test/trap/ok/outrange-int32-int16-lower.run-ir.ok
new file mode 100644
index 00000000000..785d7427085
--- /dev/null
+++ b/test/trap/ok/outrange-int32-int16-lower.run-ir.ok
@@ -0,0 +1 @@
+prim:___: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-int32-int16-lower.run-low.ok b/test/trap/ok/outrange-int32-int16-lower.run-low.ok
new file mode 100644
index 00000000000..785d7427085
--- /dev/null
+++ b/test/trap/ok/outrange-int32-int16-lower.run-low.ok
@@ -0,0 +1 @@
+prim:___: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-int32-int16-lower.run.ok b/test/trap/ok/outrange-int32-int16-lower.run.ok
new file mode 100644
index 00000000000..785d7427085
--- /dev/null
+++ b/test/trap/ok/outrange-int32-int16-lower.run.ok
@@ -0,0 +1 @@
+prim:___: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-int32-int16-lower.run.ret.ok b/test/trap/ok/outrange-int32-int16-lower.run.ret.ok
new file mode 100644
index 00000000000..69becfa16f9
--- /dev/null
+++ b/test/trap/ok/outrange-int32-int16-lower.run.ret.ok
@@ -0,0 +1 @@
+Return code 1
diff --git a/test/trap/ok/outrange-int32-int16-lower.wasm-run.ok b/test/trap/ok/outrange-int32-int16-lower.wasm-run.ok
new file mode 100644
index 00000000000..0d0e638e361
--- /dev/null
+++ b/test/trap/ok/outrange-int32-int16-lower.wasm-run.ok
@@ -0,0 +1,9 @@
+losing precision
+Error: failed to run main module `_out/outrange-int32-int16-lower.wasm`
+
+Caused by:
+    0: failed to invoke command default
+    1: error while executing at wasm backtrace:
+         0: init
+         1: _start
+    2: wasm trap: unreachable
diff --git a/test/trap/ok/outrange-int32-int16-lower.wasm-run.ret.ok b/test/trap/ok/outrange-int32-int16-lower.wasm-run.ret.ok
new file mode 100644
index 00000000000..8209aecf795
--- /dev/null
+++ b/test/trap/ok/outrange-int32-int16-lower.wasm-run.ret.ok
@@ -0,0 +1 @@
+Return code 134
diff --git a/test/trap/ok/outrange-int32-int16-negation.run-ir.ok b/test/trap/ok/outrange-int32-int16-negation.run-ir.ok
new file mode 100644
index 00000000000..be3e2b80fba
--- /dev/null
+++ b/test/trap/ok/outrange-int32-int16-negation.run-ir.ok
@@ -0,0 +1 @@
+outrange-int32-int16-negation.mo:2.9-2.38: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-int32-int16-negation.run-low.ok b/test/trap/ok/outrange-int32-int16-negation.run-low.ok
new file mode 100644
index 00000000000..be3e2b80fba
--- /dev/null
+++ b/test/trap/ok/outrange-int32-int16-negation.run-low.ok
@@ -0,0 +1 @@
+outrange-int32-int16-negation.mo:2.9-2.38: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-int32-int16-negation.run.ok b/test/trap/ok/outrange-int32-int16-negation.run.ok
new file mode 100644
index 00000000000..be3e2b80fba
--- /dev/null
+++ b/test/trap/ok/outrange-int32-int16-negation.run.ok
@@ -0,0 +1 @@
+outrange-int32-int16-negation.mo:2.9-2.38: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-int32-int16-negation.run.ret.ok b/test/trap/ok/outrange-int32-int16-negation.run.ret.ok
new file mode 100644
index 00000000000..69becfa16f9
--- /dev/null
+++ b/test/trap/ok/outrange-int32-int16-negation.run.ret.ok
@@ -0,0 +1 @@
+Return code 1
diff --git a/test/trap/ok/outrange-int32-int16-negation.wasm-run.ok b/test/trap/ok/outrange-int32-int16-negation.wasm-run.ok
new file mode 100644
index 00000000000..6ddff7b3c94
--- /dev/null
+++ b/test/trap/ok/outrange-int32-int16-negation.wasm-run.ok
@@ -0,0 +1,10 @@
+arithmetic overflow
+Error: failed to run main module `_out/outrange-int32-int16-negation.wasm`
+
+Caused by:
+    0: failed to invoke command default
+    1: error while executing at wasm backtrace:
+         0: neg32_trap
+         1: init
+         2: _start
+    2: wasm trap: unreachable
diff --git a/test/trap/ok/outrange-int32-int16-negation.wasm-run.ret.ok b/test/trap/ok/outrange-int32-int16-negation.wasm-run.ret.ok
new file mode 100644
index 00000000000..8209aecf795
--- /dev/null
+++ b/test/trap/ok/outrange-int32-int16-negation.wasm-run.ret.ok
@@ -0,0 +1 @@
+Return code 134
diff --git a/test/trap/ok/outrange-int32-int16-upper.run-ir.ok b/test/trap/ok/outrange-int32-int16-upper.run-ir.ok
new file mode 100644
index 00000000000..785d7427085
--- /dev/null
+++ b/test/trap/ok/outrange-int32-int16-upper.run-ir.ok
@@ -0,0 +1 @@
+prim:___: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-int32-int16-upper.run-low.ok b/test/trap/ok/outrange-int32-int16-upper.run-low.ok
new file mode 100644
index 00000000000..785d7427085
--- /dev/null
+++ b/test/trap/ok/outrange-int32-int16-upper.run-low.ok
@@ -0,0 +1 @@
+prim:___: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-int32-int16-upper.run.ok b/test/trap/ok/outrange-int32-int16-upper.run.ok
new file mode 100644
index 00000000000..785d7427085
--- /dev/null
+++ b/test/trap/ok/outrange-int32-int16-upper.run.ok
@@ -0,0 +1 @@
+prim:___: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-int32-int16-upper.run.ret.ok b/test/trap/ok/outrange-int32-int16-upper.run.ret.ok
new file mode 100644
index 00000000000..69becfa16f9
--- /dev/null
+++ b/test/trap/ok/outrange-int32-int16-upper.run.ret.ok
@@ -0,0 +1 @@
+Return code 1
diff --git a/test/trap/ok/outrange-int32-int16-upper.wasm-run.ok b/test/trap/ok/outrange-int32-int16-upper.wasm-run.ok
new file mode 100644
index 00000000000..fd09ebd4bf7
--- /dev/null
+++ b/test/trap/ok/outrange-int32-int16-upper.wasm-run.ok
@@ -0,0 +1,9 @@
+losing precision
+Error: failed to run main module `_out/outrange-int32-int16-upper.wasm`
+
+Caused by:
+    0: failed to invoke command default
+    1: error while executing at wasm backtrace:
+         0: init
+         1: _start
+    2: wasm trap: unreachable
diff --git a/test/trap/ok/outrange-int32-int16-upper.wasm-run.ret.ok b/test/trap/ok/outrange-int32-int16-upper.wasm-run.ret.ok
new file mode 100644
index 00000000000..8209aecf795
--- /dev/null
+++ b/test/trap/ok/outrange-int32-int16-upper.wasm-run.ret.ok
@@ -0,0 +1 @@
+Return code 134
diff --git a/test/trap/ok/outrange-int64-int32-lower.run-ir.ok b/test/trap/ok/outrange-int64-int32-lower.run-ir.ok
new file mode 100644
index 00000000000..785d7427085
--- /dev/null
+++ b/test/trap/ok/outrange-int64-int32-lower.run-ir.ok
@@ -0,0 +1 @@
+prim:___: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-int64-int32-lower.run-low.ok b/test/trap/ok/outrange-int64-int32-lower.run-low.ok
new file mode 100644
index 00000000000..785d7427085
--- /dev/null
+++ b/test/trap/ok/outrange-int64-int32-lower.run-low.ok
@@ -0,0 +1 @@
+prim:___: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-int64-int32-lower.run.ok b/test/trap/ok/outrange-int64-int32-lower.run.ok
new file mode 100644
index 00000000000..785d7427085
--- /dev/null
+++ b/test/trap/ok/outrange-int64-int32-lower.run.ok
@@ -0,0 +1 @@
+prim:___: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-int64-int32-lower.run.ret.ok b/test/trap/ok/outrange-int64-int32-lower.run.ret.ok
new file mode 100644
index 00000000000..69becfa16f9
--- /dev/null
+++ b/test/trap/ok/outrange-int64-int32-lower.run.ret.ok
@@ -0,0 +1 @@
+Return code 1
diff --git a/test/trap/ok/outrange-int64-int32-lower.wasm-run.ok b/test/trap/ok/outrange-int64-int32-lower.wasm-run.ok
new file mode 100644
index 00000000000..e7ff22d6fad
--- /dev/null
+++ b/test/trap/ok/outrange-int64-int32-lower.wasm-run.ok
@@ -0,0 +1,9 @@
+losing precision
+Error: failed to run main module `_out/outrange-int64-int32-lower.wasm`
+
+Caused by:
+    0: failed to invoke command default
+    1: error while executing at wasm backtrace:
+         0: init
+         1: _start
+    2: wasm trap: unreachable
diff --git a/test/trap/ok/outrange-int64-int32-lower.wasm-run.ret.ok b/test/trap/ok/outrange-int64-int32-lower.wasm-run.ret.ok
new file mode 100644
index 00000000000..8209aecf795
--- /dev/null
+++ b/test/trap/ok/outrange-int64-int32-lower.wasm-run.ret.ok
@@ -0,0 +1 @@
+Return code 134
diff --git a/test/trap/ok/outrange-int64-int32-negation.run-ir.ok b/test/trap/ok/outrange-int64-int32-negation.run-ir.ok
new file mode 100644
index 00000000000..872ac445e2f
--- /dev/null
+++ b/test/trap/ok/outrange-int64-int32-negation.run-ir.ok
@@ -0,0 +1 @@
+outrange-int64-int32-negation.mo:2.9-2.39: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-int64-int32-negation.run-low.ok b/test/trap/ok/outrange-int64-int32-negation.run-low.ok
new file mode 100644
index 00000000000..872ac445e2f
--- /dev/null
+++ b/test/trap/ok/outrange-int64-int32-negation.run-low.ok
@@ -0,0 +1 @@
+outrange-int64-int32-negation.mo:2.9-2.39: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-int64-int32-negation.run.ok b/test/trap/ok/outrange-int64-int32-negation.run.ok
new file mode 100644
index 00000000000..872ac445e2f
--- /dev/null
+++ b/test/trap/ok/outrange-int64-int32-negation.run.ok
@@ -0,0 +1 @@
+outrange-int64-int32-negation.mo:2.9-2.39: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-int64-int32-negation.run.ret.ok b/test/trap/ok/outrange-int64-int32-negation.run.ret.ok
new file mode 100644
index 00000000000..69becfa16f9
--- /dev/null
+++ b/test/trap/ok/outrange-int64-int32-negation.run.ret.ok
@@ -0,0 +1 @@
+Return code 1
diff --git a/test/trap/ok/outrange-int64-int32-negation.wasm-run.ok b/test/trap/ok/outrange-int64-int32-negation.wasm-run.ok
new file mode 100644
index 00000000000..441f676820b
--- /dev/null
+++ b/test/trap/ok/outrange-int64-int32-negation.wasm-run.ok
@@ -0,0 +1,10 @@
+arithmetic overflow
+Error: failed to run main module `_out/outrange-int64-int32-negation.wasm`
+
+Caused by:
+    0: failed to invoke command default
+    1: error while executing at wasm backtrace:
+         0: neg32_trap
+         1: init
+         2: _start
+    2: wasm trap: unreachable
diff --git a/test/trap/ok/outrange-int64-int32-negation.wasm-run.ret.ok b/test/trap/ok/outrange-int64-int32-negation.wasm-run.ret.ok
new file mode 100644
index 00000000000..8209aecf795
--- /dev/null
+++ b/test/trap/ok/outrange-int64-int32-negation.wasm-run.ret.ok
@@ -0,0 +1 @@
+Return code 134
diff --git a/test/trap/ok/outrange-int64-int32-upper.run-ir.ok b/test/trap/ok/outrange-int64-int32-upper.run-ir.ok
new file mode 100644
index 00000000000..785d7427085
--- /dev/null
+++ b/test/trap/ok/outrange-int64-int32-upper.run-ir.ok
@@ -0,0 +1 @@
+prim:___: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-int64-int32-upper.run-low.ok b/test/trap/ok/outrange-int64-int32-upper.run-low.ok
new file mode 100644
index 00000000000..785d7427085
--- /dev/null
+++ b/test/trap/ok/outrange-int64-int32-upper.run-low.ok
@@ -0,0 +1 @@
+prim:___: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-int64-int32-upper.run.ok b/test/trap/ok/outrange-int64-int32-upper.run.ok
new file mode 100644
index 00000000000..785d7427085
--- /dev/null
+++ b/test/trap/ok/outrange-int64-int32-upper.run.ok
@@ -0,0 +1 @@
+prim:___: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-int64-int32-upper.run.ret.ok b/test/trap/ok/outrange-int64-int32-upper.run.ret.ok
new file mode 100644
index 00000000000..69becfa16f9
--- /dev/null
+++ b/test/trap/ok/outrange-int64-int32-upper.run.ret.ok
@@ -0,0 +1 @@
+Return code 1
diff --git a/test/trap/ok/outrange-int64-int32-upper.wasm-run.ok b/test/trap/ok/outrange-int64-int32-upper.wasm-run.ok
new file mode 100644
index 00000000000..5e9c2025011
--- /dev/null
+++ b/test/trap/ok/outrange-int64-int32-upper.wasm-run.ok
@@ -0,0 +1,9 @@
+losing precision
+Error: failed to run main module `_out/outrange-int64-int32-upper.wasm`
+
+Caused by:
+    0: failed to invoke command default
+    1: error while executing at wasm backtrace:
+         0: init
+         1: _start
+    2: wasm trap: unreachable
diff --git a/test/trap/ok/outrange-int64-int32-upper.wasm-run.ret.ok b/test/trap/ok/outrange-int64-int32-upper.wasm-run.ret.ok
new file mode 100644
index 00000000000..8209aecf795
--- /dev/null
+++ b/test/trap/ok/outrange-int64-int32-upper.wasm-run.ret.ok
@@ -0,0 +1 @@
+Return code 134
diff --git a/test/trap/ok/outrange-nat16-nat8.run-ir.ok b/test/trap/ok/outrange-nat16-nat8.run-ir.ok
new file mode 100644
index 00000000000..785d7427085
--- /dev/null
+++ b/test/trap/ok/outrange-nat16-nat8.run-ir.ok
@@ -0,0 +1 @@
+prim:___: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-nat16-nat8.run-low.ok b/test/trap/ok/outrange-nat16-nat8.run-low.ok
new file mode 100644
index 00000000000..785d7427085
--- /dev/null
+++ b/test/trap/ok/outrange-nat16-nat8.run-low.ok
@@ -0,0 +1 @@
+prim:___: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-nat16-nat8.run.ok b/test/trap/ok/outrange-nat16-nat8.run.ok
new file mode 100644
index 00000000000..785d7427085
--- /dev/null
+++ b/test/trap/ok/outrange-nat16-nat8.run.ok
@@ -0,0 +1 @@
+prim:___: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-nat16-nat8.run.ret.ok b/test/trap/ok/outrange-nat16-nat8.run.ret.ok
new file mode 100644
index 00000000000..69becfa16f9
--- /dev/null
+++ b/test/trap/ok/outrange-nat16-nat8.run.ret.ok
@@ -0,0 +1 @@
+Return code 1
diff --git a/test/trap/ok/outrange-nat16-nat8.wasm-run.ok b/test/trap/ok/outrange-nat16-nat8.wasm-run.ok
new file mode 100644
index 00000000000..4f40794b023
--- /dev/null
+++ b/test/trap/ok/outrange-nat16-nat8.wasm-run.ok
@@ -0,0 +1,9 @@
+losing precision
+Error: failed to run main module `_out/outrange-nat16-nat8.wasm`
+
+Caused by:
+    0: failed to invoke command default
+    1: error while executing at wasm backtrace:
+         0: init
+         1: _start
+    2: wasm trap: unreachable
diff --git a/test/trap/ok/outrange-nat16-nat8.wasm-run.ret.ok b/test/trap/ok/outrange-nat16-nat8.wasm-run.ret.ok
new file mode 100644
index 00000000000..8209aecf795
--- /dev/null
+++ b/test/trap/ok/outrange-nat16-nat8.wasm-run.ret.ok
@@ -0,0 +1 @@
+Return code 134
diff --git a/test/trap/ok/outrange-nat32-nat16.run-ir.ok b/test/trap/ok/outrange-nat32-nat16.run-ir.ok
new file mode 100644
index 00000000000..785d7427085
--- /dev/null
+++ b/test/trap/ok/outrange-nat32-nat16.run-ir.ok
@@ -0,0 +1 @@
+prim:___: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-nat32-nat16.run-low.ok b/test/trap/ok/outrange-nat32-nat16.run-low.ok
new file mode 100644
index 00000000000..785d7427085
--- /dev/null
+++ b/test/trap/ok/outrange-nat32-nat16.run-low.ok
@@ -0,0 +1 @@
+prim:___: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-nat32-nat16.run.ok b/test/trap/ok/outrange-nat32-nat16.run.ok
new file mode 100644
index 00000000000..785d7427085
--- /dev/null
+++ b/test/trap/ok/outrange-nat32-nat16.run.ok
@@ -0,0 +1 @@
+prim:___: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-nat32-nat16.run.ret.ok b/test/trap/ok/outrange-nat32-nat16.run.ret.ok
new file mode 100644
index 00000000000..69becfa16f9
--- /dev/null
+++ b/test/trap/ok/outrange-nat32-nat16.run.ret.ok
@@ -0,0 +1 @@
+Return code 1
diff --git a/test/trap/ok/outrange-nat32-nat16.wasm-run.ok b/test/trap/ok/outrange-nat32-nat16.wasm-run.ok
new file mode 100644
index 00000000000..a5d6248b4ec
--- /dev/null
+++ b/test/trap/ok/outrange-nat32-nat16.wasm-run.ok
@@ -0,0 +1,9 @@
+losing precision
+Error: failed to run main module `_out/outrange-nat32-nat16.wasm`
+
+Caused by:
+    0: failed to invoke command default
+    1: error while executing at wasm backtrace:
+         0: init
+         1: _start
+    2: wasm trap: unreachable
diff --git a/test/trap/ok/outrange-nat32-nat16.wasm-run.ret.ok b/test/trap/ok/outrange-nat32-nat16.wasm-run.ret.ok
new file mode 100644
index 00000000000..8209aecf795
--- /dev/null
+++ b/test/trap/ok/outrange-nat32-nat16.wasm-run.ret.ok
@@ -0,0 +1 @@
+Return code 134
diff --git a/test/trap/ok/outrange-nat64-nat32.run-ir.ok b/test/trap/ok/outrange-nat64-nat32.run-ir.ok
new file mode 100644
index 00000000000..785d7427085
--- /dev/null
+++ b/test/trap/ok/outrange-nat64-nat32.run-ir.ok
@@ -0,0 +1 @@
+prim:___: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-nat64-nat32.run-low.ok b/test/trap/ok/outrange-nat64-nat32.run-low.ok
new file mode 100644
index 00000000000..785d7427085
--- /dev/null
+++ b/test/trap/ok/outrange-nat64-nat32.run-low.ok
@@ -0,0 +1 @@
+prim:___: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-nat64-nat32.run.ok b/test/trap/ok/outrange-nat64-nat32.run.ok
new file mode 100644
index 00000000000..785d7427085
--- /dev/null
+++ b/test/trap/ok/outrange-nat64-nat32.run.ok
@@ -0,0 +1 @@
+prim:___: execution error, value out of bounds
diff --git a/test/trap/ok/outrange-nat64-nat32.run.ret.ok b/test/trap/ok/outrange-nat64-nat32.run.ret.ok
new file mode 100644
index 00000000000..69becfa16f9
--- /dev/null
+++ b/test/trap/ok/outrange-nat64-nat32.run.ret.ok
@@ -0,0 +1 @@
+Return code 1
diff --git a/test/trap/ok/outrange-nat64-nat32.wasm-run.ok b/test/trap/ok/outrange-nat64-nat32.wasm-run.ok
new file mode 100644
index 00000000000..f9e5ee4cfe7
--- /dev/null
+++ b/test/trap/ok/outrange-nat64-nat32.wasm-run.ok
@@ -0,0 +1,9 @@
+losing precision
+Error: failed to run main module `_out/outrange-nat64-nat32.wasm`
+
+Caused by:
+    0: failed to invoke command default
+    1: error while executing at wasm backtrace:
+         0: init
+         1: _start
+    2: wasm trap: unreachable
diff --git a/test/trap/ok/outrange-nat64-nat32.wasm-run.ret.ok b/test/trap/ok/outrange-nat64-nat32.wasm-run.ret.ok
new file mode 100644
index 00000000000..8209aecf795
--- /dev/null
+++ b/test/trap/ok/outrange-nat64-nat32.wasm-run.ret.ok
@@ -0,0 +1 @@
+Return code 134
diff --git a/test/trap/outrange-int16-int8-lower.mo b/test/trap/outrange-int16-int8-lower.mo
new file mode 100644
index 00000000000..3d458353aeb
--- /dev/null
+++ b/test/trap/outrange-int16-int8-lower.mo
@@ -0,0 +1,2 @@
+import Prim "mo:⛔";
+let _ = Prim.int16ToInt8(-129); // this should trap
diff --git a/test/trap/outrange-int16-int8-negation.mo b/test/trap/outrange-int16-int8-negation.mo
new file mode 100644
index 00000000000..1a91a728b0d
--- /dev/null
+++ b/test/trap/outrange-int16-int8-negation.mo
@@ -0,0 +1,2 @@
+import Prim "mo:⛔";
+let _ = - Prim.int16ToInt8(-2 ** 7); // this should trap
diff --git a/test/trap/outrange-int16-int8-upper.mo b/test/trap/outrange-int16-int8-upper.mo
new file mode 100644
index 00000000000..fe984e7ee43
--- /dev/null
+++ b/test/trap/outrange-int16-int8-upper.mo
@@ -0,0 +1,2 @@
+import Prim "mo:⛔";
+let _ = Prim.int16ToInt8 128; // this should trap
diff --git a/test/trap/outrange-int32-int16-lower.mo b/test/trap/outrange-int32-int16-lower.mo
new file mode 100644
index 00000000000..5c0252b37b5
--- /dev/null
+++ b/test/trap/outrange-int32-int16-lower.mo
@@ -0,0 +1,2 @@
+import Prim "mo:⛔";
+let _ = Prim.int32ToInt16(-32769); // this should trap
diff --git a/test/trap/outrange-int32-int16-negation.mo b/test/trap/outrange-int32-int16-negation.mo
new file mode 100644
index 00000000000..6bf33aeb06a
--- /dev/null
+++ b/test/trap/outrange-int32-int16-negation.mo
@@ -0,0 +1,2 @@
+import Prim "mo:⛔";
+let _ = - Prim.int32ToInt16(-2 ** 15); // this should trap
diff --git a/test/trap/outrange-int32-int16-upper.mo b/test/trap/outrange-int32-int16-upper.mo
new file mode 100644
index 00000000000..c749da6666d
--- /dev/null
+++ b/test/trap/outrange-int32-int16-upper.mo
@@ -0,0 +1,2 @@
+import Prim "mo:⛔";
+let _ = Prim.int32ToInt16(2 ** 15); // this should trap
diff --git a/test/trap/outrange-int64-int32-lower.mo b/test/trap/outrange-int64-int32-lower.mo
new file mode 100644
index 00000000000..26e6b358b25
--- /dev/null
+++ b/test/trap/outrange-int64-int32-lower.mo
@@ -0,0 +1,2 @@
+import Prim "mo:⛔";
+let _ = Prim.int64ToInt32(-2147483649); // this should trap
diff --git a/test/trap/outrange-int64-int32-negation.mo b/test/trap/outrange-int64-int32-negation.mo
new file mode 100644
index 00000000000..44b0ab87c72
--- /dev/null
+++ b/test/trap/outrange-int64-int32-negation.mo
@@ -0,0 +1,2 @@
+import Prim "mo:⛔";
+let _ = - Prim.int64ToInt32(- 2 ** 31); // this should trap
diff --git a/test/trap/outrange-int64-int32-upper.mo b/test/trap/outrange-int64-int32-upper.mo
new file mode 100644
index 00000000000..972a86c3dc7
--- /dev/null
+++ b/test/trap/outrange-int64-int32-upper.mo
@@ -0,0 +1,2 @@
+import Prim "mo:⛔";
+let _ = Prim.int64ToInt32(2 ** 31); // this should trap
diff --git a/test/trap/outrange-nat16-nat8.mo b/test/trap/outrange-nat16-nat8.mo
new file mode 100644
index 00000000000..c8245a653ca
--- /dev/null
+++ b/test/trap/outrange-nat16-nat8.mo
@@ -0,0 +1,2 @@
+import Prim "mo:⛔";
+let _ = Prim.nat16ToNat8 256; // this should trap
diff --git a/test/trap/outrange-nat32-nat16.mo b/test/trap/outrange-nat32-nat16.mo
new file mode 100644
index 00000000000..fa9daef3eb3
--- /dev/null
+++ b/test/trap/outrange-nat32-nat16.mo
@@ -0,0 +1,2 @@
+import Prim "mo:⛔";
+let _ = Prim.nat32ToNat16(2 ** 16); // this should trap
diff --git a/test/trap/outrange-nat64-nat32.mo b/test/trap/outrange-nat64-nat32.mo
new file mode 100644
index 00000000000..3e5360f4229
--- /dev/null
+++ b/test/trap/outrange-nat64-nat32.mo
@@ -0,0 +1,2 @@
+import Prim "mo:⛔";
+let _ = Prim.nat64ToNat32(2 ** 32); // this should trap

From c58823958543c7cf55b06d09528a682ad084be55 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Wed, 6 Sep 2023 10:07:15 +0200
Subject: [PATCH 112/260] Manual merge from master

---
 nix/drun.nix     | 2 +-
 nix/sources.json | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/nix/drun.nix b/nix/drun.nix
index 055f5ff31d3..ed6ff536d53 100644
--- a/nix/drun.nix
+++ b/nix/drun.nix
@@ -19,7 +19,7 @@ pkgs:
         lockFile = "${pkgs.sources.ic}/Cargo.lock";
         outputHashes = {
           "derive_more-0.99.8-alpha.0" = "sha256-tEsfYC9oCAsDjinCsUDgRg3q6ruvayuA1lRmsEP9cys=";
-          "ic-btc-interface-0.1.0" = "sha256-VecEMFjoeiRi0VgJ9CeDoOzdyJbJNiZ5MBmiV1+b7As=";
+          "ic-btc-interface-0.1.0" = "sha256-H1lTXZSX1yRQ+2zvGmp+b52o5RL8KBUkE2/8dHZB+4Q=";
           "jsonrpc-0.12.1" = "sha256-3FtdZlt2PqVDkE5iKWYIp1eiIELsaYlUPRSP2Xp8ejM=";
           "libssh2-sys-0.2.23" = "sha256-9Hb7CnPF+lxrVO1NAhS7EXcPVWZutJXr6UWxpptzk4U=";
           "lmdb-rkv-0.14.99" = "sha256-dqxWgtNZ/qRukQLiDawjHRwdPgfzm/sVcWwudwX9rD8=";
diff --git a/nix/sources.json b/nix/sources.json
index bd59e422115..be583b7ea4f 100644
--- a/nix/sources.json
+++ b/nix/sources.json
@@ -39,10 +39,10 @@
         "homepage": "",
         "owner": "dfinity",
         "repo": "ic-hs",
-        "rev": "a5f89cf508b0c80b633e3f0c152e3406fb750189",
-        "sha256": "0sjj272ch14309h3n3cxq6g7jkdhhqmdjrjdg67w1xxk4k1s1sfn",
+        "rev": "e727fecab6bad1401a65a50773637e46b8a14e0e",
+        "sha256": "183xcavjkfsa2hgx9s67qxg7hfykykmw0wbzd4458rkiqb164wmc",
         "type": "tarball",
-        "url": "https://github.com/dfinity/ic-hs/archive/a5f89cf508b0c80b633e3f0c152e3406fb750189.tar.gz",
+        "url": "https://github.com/dfinity/ic-hs/archive/e727fecab6bad1401a65a50773637e46b8a14e0e.tar.gz",
         "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
     },
     "ic-wasm": {

From b10aeddb594868c3eeaf66f773ffcfe9dbda7237 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 7 Sep 2023 11:28:12 +0200
Subject: [PATCH 113/260] Adjust test

---
 test/perf/sha256.mo | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/perf/sha256.mo b/test/perf/sha256.mo
index 0b77f7b3c94..f5dea4cfecc 100644
--- a/test/perf/sha256.mo
+++ b/test/perf/sha256.mo
@@ -4,7 +4,7 @@ import Nat8 "./sha256/Nat8";
 actor {
   public func go() : async () {
     // 256kb already exceed the instruction limit
-    ignore SHA256.sha256(Array.tabulate(128*1024, Nat8.fromIntWrap));
+    ignore SHA256.sha256(Array.tabulate(64*1024, Nat8.fromIntWrap));
   }
 }
 //CALL ingress go 0x4449444C0000

From 2c31217f084e52c57ab408e4799257ac8b62375b Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 7 Sep 2023 14:03:31 +0200
Subject: [PATCH 114/260] Manual merge of region PR

---
 rts/motoko-rts-tests/src/gc.rs                |  4 +-
 rts/motoko-rts-tests/src/gc/heap.rs           | 29 ++++--
 .../src/gc/incremental/roots.rs               |  3 +-
 .../src/persistence/compatibility.rs          |  8 +-
 rts/motoko-rts/src/gc/incremental/roots.rs    | 13 +--
 rts/motoko-rts/src/lib.rs                     |  3 +-
 .../src/persistence/compatibility.rs          |  1 +
 rts/motoko-rts/src/region.rs                  | 62 ++++++------
 rts/motoko-rts/src/types.rs                   |  2 +-
 rts/motoko-rts/src/visitor.rs                 |  2 +-
 src/codegen/compile.ml                        | 96 ++++++++++---------
 src/codegen/persistence.ml                    |  2 +
 test/bench/ok/alloc.drun-run-opt.ok           |  6 +-
 test/bench/ok/alloc.drun-run.ok               |  6 +-
 test/bench/ok/bignum.drun-run-opt.ok          |  4 +-
 test/bench/ok/bignum.drun-run.ok              |  4 +-
 test/bench/ok/heap-32.drun-run-opt.ok         |  4 +-
 test/bench/ok/heap-32.drun-run.ok             |  4 +-
 test/bench/ok/palindrome.drun-run-opt.ok      | 12 +--
 test/bench/ok/palindrome.drun-run.ok          | 12 +--
 test/bench/ok/region-mem.drun-run-opt.ok      |  2 +-
 test/bench/ok/region-mem.drun-run.ok          |  2 +-
 test/bench/ok/region0-mem.drun-run-opt.ok     |  2 +-
 test/bench/ok/region0-mem.drun-run.ok         |  2 +-
 test/bench/ok/stable-mem.drun-run-opt.ok      |  2 +-
 test/bench/ok/stable-mem.drun-run.ok          |  2 +-
 .../run-drun/ok/region0-rts-stats.drun-run.ok |  6 +-
 .../ok/stable-mem-rts-stats.drun-run.ok       |  6 +-
 test/run-drun/region0-big-blob.mo             |  4 +-
 test/run-drun/stable-mem-big-blob.mo          |  4 +-
 30 files changed, 164 insertions(+), 145 deletions(-)

diff --git a/rts/motoko-rts-tests/src/gc.rs b/rts/motoko-rts-tests/src/gc.rs
index d68a594971a..7183b412db5 100644
--- a/rts/motoko-rts-tests/src/gc.rs
+++ b/rts/motoko-rts-tests/src/gc.rs
@@ -463,6 +463,7 @@ fn read_object_id(object_address: u32, heap: &[u8]) -> ObjectIdx {
 fn run(heap: &mut MotokoHeap) -> bool {
     let static_root = heap.static_root_array_variable_address() as *mut Value;
     let continuation_table_location = heap.continuation_table_variable_address() as *mut Value;
+    let region0_pointer_location = heap.region0_pointer_variable_address() as *mut Value;
     let unused_root = &mut Value::from_scalar(0) as *mut Value;
 
     unsafe {
@@ -472,7 +473,8 @@ fn run(heap: &mut MotokoHeap) -> bool {
             let roots = [
                 static_root,
                 continuation_table_location,
-                &mut region_0,,
+                region0_pointer_location,
+                unused_root,
                 unused_root,
                 unused_root,
             ];
diff --git a/rts/motoko-rts-tests/src/gc/heap.rs b/rts/motoko-rts-tests/src/gc/heap.rs
index c421785d037..1fb0ddc98af 100644
--- a/rts/motoko-rts-tests/src/gc/heap.rs
+++ b/rts/motoko-rts-tests/src/gc/heap.rs
@@ -39,7 +39,7 @@ impl MotokoHeap {
         map: &[(ObjectIdx, Vec<ObjectIdx>)],
         roots: &[ObjectIdx],
         continuation_table: &[ObjectIdx],
-        region0_ptr_loc: &[ObjectIdx],
+        _region0_ptr_loc: &[ObjectIdx],
     ) -> MotokoHeap {
         MotokoHeap {
             inner: Rc::new(RefCell::new(MotokoHeapInner::new(
@@ -92,7 +92,7 @@ impl MotokoHeap {
     }
 
     /// Get the address of the continuation table pointer
-    pub fn region0_ptr_location(&self) -> usize {
+    pub fn region0_pointer_variable_address(&self) -> usize {
         self.inner.borrow().region0_ptr_address()
     }
 
@@ -138,9 +138,13 @@ struct MotokoHeapInner {
     ///
     /// Reminder: this location is in static heap and will have pointer to an array in dynamic
     /// heap.
-    continuation_table_ptr_offset: usize,
+    continuation_table_variable_offset: usize,
 
-    region0_ptr_location_offset: usize,
+    /// Offset of the region 0 pointer.
+    ///
+    /// Reminder: this location is in static heap and will have pointer to an array in dynamic
+    /// heap.
+    region0_pointer_variable_offset: usize,
 }
 
 impl MotokoHeapInner {
@@ -178,7 +182,7 @@ impl MotokoHeapInner {
     }
 
     fn region0_ptr_address(&self) -> usize {
-        self.offset_to_address(self.region0_ptr_location_offset)
+        self.offset_to_address(self.region0_pointer_variable_offset)
     }
 
     fn new(
@@ -243,11 +247,11 @@ impl MotokoHeapInner {
         // Root pointers in static memory space.
         let static_root_array_variable_offset = root_pointers_size_bytes - 3 * WORD_SIZE;
         let continuation_table_variable_offset = root_pointers_size_bytes - 2 * WORD_SIZE;
-        let region0_ptr_location_offset = static_heap_size_bytes - WORD_SIZE;
+        let region0_pointer_variable_offset = root_pointers_size_bytes - WORD_SIZE;
         create_static_memory(
             static_root_array_variable_offset,
             continuation_table_variable_offset,
-            region0_ptr_location_offset,
+            region0_pointer_variable_offset,
             static_root_array_address,
             continuation_table_address,
             &mut heap[realign..root_pointers_size_bytes + realign],
@@ -260,7 +264,7 @@ impl MotokoHeapInner {
             heap_ptr_offset: total_heap_size_bytes + realign,
             static_root_array_variable_offset: static_root_array_variable_offset + realign,
             continuation_table_variable_offset: continuation_table_variable_offset + realign,
-            region0_ptr_location_offset: region0_ptr_location_offset + realign,
+            region0_pointer_variable_offset: region0_pointer_variable_offset + realign,
         }
     }
 
@@ -449,21 +453,26 @@ fn create_dynamic_heap(
 fn create_static_memory(
     static_root_array_variable_offset: usize,
     continuation_table_variable_offset: usize,
+    region0_pointer_variable_offset: usize,
     static_root_array_address: u32,
     continuation_table_address: u32,
     heap: &mut [u8],
 ) {
-    // Write static array pointer as the second last word in static memory
+    // Write static array pointer as the third last word in static memory
     write_word(
         heap,
         static_root_array_variable_offset,
         make_pointer(static_root_array_address),
     );
 
-    // Write continuation table pointer as the last word in static memory
+    // Write continuation table pointer as the second last word in static memory
     write_word(
         heap,
         continuation_table_variable_offset,
         make_pointer(continuation_table_address),
     );
+
+    let no_region_0 = make_scalar(0);
+    // Write region 0 pointer as the last word in static memory
+    write_word(heap, region0_pointer_variable_offset, no_region_0);
 }
diff --git a/rts/motoko-rts-tests/src/gc/incremental/roots.rs b/rts/motoko-rts-tests/src/gc/incremental/roots.rs
index ec6fa3a4399..9b9e2eacaaf 100644
--- a/rts/motoko-rts-tests/src/gc/incremental/roots.rs
+++ b/rts/motoko-rts-tests/src/gc/incremental/roots.rs
@@ -63,7 +63,7 @@ unsafe fn check_visit_continuation_table(heap: &MotokoHeap, continuation_ids: &[
 unsafe fn get_roots(heap: &MotokoHeap) -> Roots {
     let static_root = heap.static_root_array_variable_address() as *mut Value;
     let continuation_table_location = heap.continuation_table_variable_address() as *mut Value;
-    let region0_ptr_location = heap.region0_ptr_location() as *mut Value;
+    let region0_ptr_location = heap.region0_pointer_variable_address() as *mut Value;
     let unused_root = &mut Value::from_scalar(0) as *mut Value;
     assert_ne!(continuation_table_location, null_mut());
     [
@@ -72,6 +72,7 @@ unsafe fn get_roots(heap: &MotokoHeap) -> Roots {
         region0_ptr_location,
         unused_root,
         unused_root,
+        unused_root,
     ]
 }
 
diff --git a/rts/motoko-rts-tests/src/persistence/compatibility.rs b/rts/motoko-rts-tests/src/persistence/compatibility.rs
index f255f782ce0..48bc0f05e33 100644
--- a/rts/motoko-rts-tests/src/persistence/compatibility.rs
+++ b/rts/motoko-rts-tests/src/persistence/compatibility.rs
@@ -160,7 +160,8 @@ const FLOAT_ENCODING_TAG: i32 = -13;
 const CHAR_ENCODING_TAG: i32 = -14;
 const TEXT_ENCODING_TAG: i32 = -15;
 const BLOB_ENCODING_TAG: i32 = -16;
-const PRINCIPAL_ENCODING_TAG: i32 = -16;
+const PRINCIPAL_ENCODING_TAG: i32 = -17;
+const REGION_ENCODING_TAG: i32 = -18;
 
 impl TypeReference {
     fn primitive(index: i32) -> Self {
@@ -235,6 +236,10 @@ impl TypeReference {
     fn principal() -> Self {
         Self::primitive(PRINCIPAL_ENCODING_TAG)
     }
+
+    fn region() -> Self {
+        Self::primitive(REGION_ENCODING_TAG)
+    }
 }
 
 #[derive(Clone)]
@@ -358,6 +363,7 @@ unsafe fn test_primitive_types(heap: &mut TestMemory) {
         TypeReference::text(),
         TypeReference::blob(),
         TypeReference::principal(),
+        TypeReference::region(),
     ];
     for first in &all_types {
         for second in &all_types {
diff --git a/rts/motoko-rts/src/gc/incremental/roots.rs b/rts/motoko-rts/src/gc/incremental/roots.rs
index b9d3ebb1b7d..f2bd7ba4e47 100644
--- a/rts/motoko-rts/src/gc/incremental/roots.rs
+++ b/rts/motoko-rts/src/gc/incremental/roots.rs
@@ -24,7 +24,7 @@ pub unsafe fn root_set() -> Roots {
         stable_actor_location(),
         stable_type_location(),
         null_singleton_location(),
-        region0_get_ptr_loc()
+        region0_get_ptr_loc(),
     ]
 }
 
@@ -59,14 +59,3 @@ pub unsafe extern "C" fn get_static_root() -> Value {
     assert!(STATIC_ROOT.is_ptr());
     STATIC_ROOT
 }
-
-unsafe fn visit_region0_ptr<C, V: Fn(&mut C, *mut Value)>(
-    region0_ptr_location: *mut Value,
-    heap_base: usize,
-    context: &mut C,
-    visit_field: &V,
-) {
-    if pointer_to_dynamic_heap(region0_ptr_location, heap_base) {
-        visit_field(context, region0_ptr_location);
-    }
-}
diff --git a/rts/motoko-rts/src/lib.rs b/rts/motoko-rts/src/lib.rs
index 487245cfd86..13460d9c30e 100644
--- a/rts/motoko-rts/src/lib.rs
+++ b/rts/motoko-rts/src/lib.rs
@@ -33,8 +33,9 @@ mod mem_utils;
 pub mod memory;
 pub mod persistence;
 pub mod principal_id;
+#[cfg(feature = "ic")]
 pub mod region;
-//#[cfg(feature = "ic")]
+#[cfg(feature = "ic")]
 mod stable_mem;
 mod static_checks;
 pub mod stream;
diff --git a/rts/motoko-rts/src/persistence/compatibility.rs b/rts/motoko-rts/src/persistence/compatibility.rs
index 6e93bc86c64..8f03def62aa 100644
--- a/rts/motoko-rts/src/persistence/compatibility.rs
+++ b/rts/motoko-rts/src/persistence/compatibility.rs
@@ -69,6 +69,7 @@
 //! Text      | -15l
 //! Blob      | -16l
 //! Principal | -17l
+//! Region    | -18l
 //!
 //! Function sort
 //! Sort      | Encoding
diff --git a/rts/motoko-rts/src/region.rs b/rts/motoko-rts/src/region.rs
index c79d0d69547..c58299dffa8 100644
--- a/rts/motoko-rts/src/region.rs
+++ b/rts/motoko-rts/src/region.rs
@@ -4,10 +4,10 @@ use crate::trap_with_prefix;
 use crate::types::{size_of, Blob, Bytes, Region, Value, TAG_REGION};
 
 // Versions
-// Should agree with constants StableMem.version_no_stable_memory etc. in compile.ml
-const VERSION_NO_STABLE_MEMORY: u32 = 0; // never manifest in serialized form
-const VERSION_SOME_STABLE_MEMORY: u32 = 1;
-const VERSION_REGIONS: u32 = 2;
+// Should agree with constants in StableMem in compile.ml
+// Version 0 to 2 are legacy.
+const VERSION_STABLE_HEAP_NO_REGIONS: u32 = 3;
+const VERSION_STABLE_HEAP_REGIONS: u32 = 4;
 
 const _: () = assert!(meta_data::size::PAGES_IN_BLOCK <= u8::MAX as u32);
 const _: () = assert!(meta_data::max::BLOCKS <= u16::MAX);
@@ -46,6 +46,9 @@ const NIL_REGION_ID: u64 = 0;
 
 const LAST_RESERVED_REGION_ID: u64 = 15;
 
+/// All this global state gets reinitialized after an upgrade.
+/// Therefore, it is not included in the persistent metadata.
+
 // Mirrored field from stable memory, for handling upgrade logic.
 pub(crate) static mut REGION_TOTAL_ALLOCATED_BLOCKS: u32 = 0;
 
@@ -57,6 +60,9 @@ pub(crate) static mut BLOCK_BASE: u64 = 0;
 pub(crate) const NO_REGION: Value = Value::from_scalar(0);
 
 // Region 0 -- classic API for stable memory, as a dedicated region.
+// NOTE: Multiple instances of region 0 objects can exist,
+// because an upgrade initializes a new instance and old regions can be recovered
+// This was already considered before stable heap design.
 pub(crate) static mut REGION_0: Value = NO_REGION;
 
 // This impl encapsulates encoding of optional region IDs within a u64.
@@ -469,14 +475,14 @@ pub(crate) unsafe fn region0_get_ptr_loc() -> *mut Value {
 #[ic_mem_fn]
 pub unsafe fn region_new<M: Memory>(mem: &mut M) -> Value {
     match crate::stable_mem::get_version() {
-        VERSION_NO_STABLE_MEMORY => {
-            assert_eq!(crate::stable_mem::size(), 0);
-            region_migration_from_no_stable_memory(mem);
-        }
-        VERSION_SOME_STABLE_MEMORY => {
-            region_migration_from_some_stable_memory(mem);
+        VERSION_STABLE_HEAP_REGIONS => {}
+        VERSION_STABLE_HEAP_NO_REGIONS => {
+            if crate::stable_mem::size() == 0 {
+                region_migration_from_no_stable_memory(mem);
+            } else {
+                region_migration_from_some_stable_memory(mem);
+            }
         }
-        VERSION_REGIONS => {}
         _ => {
             assert!(false);
         }
@@ -552,7 +558,7 @@ pub(crate) unsafe fn region_migration_from_no_stable_memory<M: Memory>(mem: &mut
     use crate::stable_mem::{get_version, grow, size, write};
     use meta_data::size::{PAGES_IN_BLOCK, PAGE_IN_BYTES};
 
-    assert!(get_version() == VERSION_NO_STABLE_MEMORY);
+    assert!(get_version() == VERSION_STABLE_HEAP_NO_REGIONS);
     assert_eq!(size(), 0);
 
     // pages required for meta_data (9/ 960KiB), much less than PAGES_IN_BLOCK (128/ 8MB) for a full block
@@ -582,7 +588,7 @@ pub(crate) unsafe fn region_migration_from_no_stable_memory<M: Memory>(mem: &mut
     // Write magic header
     write_magic();
 
-    crate::stable_mem::set_version(VERSION_REGIONS);
+    crate::stable_mem::set_version(VERSION_STABLE_HEAP_REGIONS);
 
     // Region 0 -- classic API for stable memory, as a dedicated region.
     REGION_0 = region_new(mem);
@@ -706,7 +712,7 @@ pub(crate) unsafe fn region_migration_from_some_stable_memory<M: Memory>(mem: &m
         meta_data::block_region_table::set(BlockId(i), Some((RegionId(0), rank, page_count)))
     }
 
-    crate::stable_mem::set_version(VERSION_REGIONS);
+    crate::stable_mem::set_version(VERSION_STABLE_HEAP_REGIONS);
 
     /* "Recover" the region data into a heap object. */
     REGION_0 = region_recover(mem, &RegionId(0));
@@ -760,23 +766,20 @@ pub(crate) unsafe fn region_migration_from_regions_plus<M: Memory>(mem: &mut M)
 #[ic_mem_fn]
 pub(crate) unsafe fn region_init<M: Memory>(mem: &mut M, use_stable_regions: u32) {
     match crate::stable_mem::get_version() {
-        VERSION_NO_STABLE_MEMORY => {
-            assert!(crate::stable_mem::size() == 0);
+        VERSION_STABLE_HEAP_NO_REGIONS => {
             if use_stable_regions != 0 {
-                region_migration_from_no_stable_memory(mem);
-                debug_assert!(meta_data::offset::FREE < BLOCK_BASE);
-                debug_assert!(BLOCK_BASE == meta_data::offset::BASE_LOW);
-            };
-        }
-        VERSION_SOME_STABLE_MEMORY => {
-            assert!(crate::stable_mem::size() > 0);
-            if use_stable_regions != 0 {
-                region_migration_from_some_stable_memory(mem);
-                debug_assert!(meta_data::offset::FREE < BLOCK_BASE);
-                debug_assert!(BLOCK_BASE == meta_data::offset::BASE_HIGH);
-            };
+                if crate::stable_mem::size() == 0 {
+                    region_migration_from_no_stable_memory(mem);
+                    debug_assert!(meta_data::offset::FREE < BLOCK_BASE);
+                    debug_assert!(BLOCK_BASE == meta_data::offset::BASE_LOW);
+                } else {
+                    region_migration_from_some_stable_memory(mem);
+                    debug_assert!(meta_data::offset::FREE < BLOCK_BASE);
+                    debug_assert!(BLOCK_BASE == meta_data::offset::BASE_HIGH);
+                }
+            }
         }
-        _ => {
+        VERSION_STABLE_HEAP_REGIONS => {
             region_migration_from_regions_plus(mem); //check format & recover region0
             debug_assert!(meta_data::offset::FREE < BLOCK_BASE);
             debug_assert!(
@@ -784,6 +787,7 @@ pub(crate) unsafe fn region_init<M: Memory>(mem: &mut M, use_stable_regions: u32
                     || BLOCK_BASE == meta_data::offset::BASE_HIGH
             );
         }
+        _ => assert!(false),
     }
 }
 
diff --git a/rts/motoko-rts/src/types.rs b/rts/motoko-rts/src/types.rs
index ec9d162b6d1..6ff8b30d30a 100644
--- a/rts/motoko-rts/src/types.rs
+++ b/rts/motoko-rts/src/types.rs
@@ -339,7 +339,7 @@ impl Value {
         self.check_forwarding_pointer();
         self.forward().get_ptr() as *mut Object
     }
-    
+
     /// Get the pointer as `Region` using forwarding.
     pub unsafe fn as_region(self) -> *mut Region {
         debug_assert!(self.tag() == TAG_REGION);
diff --git a/rts/motoko-rts/src/visitor.rs b/rts/motoko-rts/src/visitor.rs
index c4996b9c9fe..d3048e9e11d 100644
--- a/rts/motoko-rts/src/visitor.rs
+++ b/rts/motoko-rts/src/visitor.rs
@@ -95,7 +95,7 @@ pub unsafe fn visit_pointer_fields<C, F, G>(
         TAG_REGION => {
             let region = obj as *mut Region;
             let field_addr = &mut (*region).vec_pages;
-            if pointer_to_dynamic_heap(field_addr, heap_base) {
+            if is_pointer_field(field_addr) {
                 visit_ptr_field(ctx, field_addr);
             }
         }
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 5413473eee4..ae5ef3e9a7a 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -4817,15 +4817,17 @@ module StableMem = struct
 
   (* Versioning (c.f. Region.rs) *)
   (* NB: these constants must agree with VERSION_NO_STABLE_MEMORY etc. in Region.rs *)
-  let version_no_stable_memory = Int32.of_int 0 (* never manifest in serialized form *)
-  let version_some_stable_memory = Int32.of_int 1
-  let version_regions = Int32.of_int 2
-  let version_max = version_regions
+  let legacy_version_no_stable_memory = Int32.of_int 0 (* never manifest in serialized form *)
+  let legacy_version_some_stable_memory = Int32.of_int 1
+  let legacy_version_regions = Int32.of_int 2
+  let version_stable_heap_no_regions = Int32.of_int 3
+  let version_stable_heap_regions = Int32.of_int 4
+  let version_max = version_stable_heap_regions
 
   let register_globals env =
     (* size (in pages) *)
     E.add_global64 env "__stablemem_size" Mutable 0L;
-    E.add_global32 env "__stablemem_version" Mutable version_no_stable_memory
+    E.add_global32 env "__stablemem_version" Mutable version_stable_heap_no_regions
 
   let get_mem_size env =
     G.i (GlobalGet (nr (E.get_global env "__stablemem_size")))
@@ -4839,6 +4841,10 @@ module StableMem = struct
   let set_version env =
     G.i (GlobalSet (nr (E.get_global env "__stablemem_version")))
 
+  let region_init env =
+    compile_unboxed_const (if !Flags.use_stable_regions then 1l else 0l) ^^
+    E.call_import env "rts" "region_init"
+
   (* stable memory bounds check *)
   let guard env =
     match E.mode env with
@@ -5118,10 +5124,9 @@ end (* StableMem *)
 (* Core, legacy interface to IC stable memory, used to implement prims `stableMemoryXXX` of
    library `ExperimentalStableMemory.mo`.
    Each operation dispatches on the state of `StableMem.get_version()`.
-   * StableMem.version_no_stable_memory/StableMem.version_some_stable_memory:
-     * use StableMem directly
-     * switch to version_some_stable_memory on non-trivial grow.
-   * StableMem.version_regions: use Region.mo
+   * StableMem.version_stable_heap_no_regions
+     * use StableMem directly.
+   * StableMem.version_stable_heap_regions: use Region.mo
 *)
 module StableMemoryInterface = struct
 
@@ -5130,7 +5135,7 @@ module StableMemoryInterface = struct
 
   let if_regions env args tys is1 is2 =
     StableMem.get_version env ^^
-    compile_unboxed_const StableMem.version_regions ^^
+    compile_unboxed_const StableMem.version_stable_heap_regions ^^
     G.i (Compare (Wasm.Values.I32 I32Op.Eq)) ^^
     E.if_ env tys
       (get_region0 env ^^ args ^^ is1 env)
@@ -5154,27 +5159,8 @@ module StableMemoryInterface = struct
           [I64Type]
           Region.grow
           (fun env ->
-            (* do StableMem.grow, but detect and record change in version as well *)
-            let (set_res, get_res) = new_local64 env "size" in
             (* logical grow *)
-            StableMem.grow env ^^
-            set_res ^^
-            (* if version = version_no_stable_memory and new mem_size > 0
-               then version := version_some_stable_memory *)
-            StableMem.get_version env ^^
-            compile_eq_const StableMem.version_no_stable_memory ^^
-            StableMem.get_mem_size env ^^
-            compile_const_64 0L ^^
-            G.i (Compare (Wasm.Values.I64 I32Op.GtU)) ^^
-            G.i (Binary (Wasm.Values.I32 I32Op.And)) ^^
-            (G.if0
-               begin
-                 compile_unboxed_const StableMem.version_some_stable_memory ^^
-                 StableMem.set_version env
-               end
-               G.nop) ^^
-            (* return res *)
-            get_res))
+            StableMem.grow env))
 
   let load_blob env =
     Func.share_code2 env "__stablememory_load_blob"
@@ -7280,8 +7266,6 @@ module Serialization = MakeSerialization(BumpStream)
    * ../../design/StableMemory.md
 *)
 module OldStabilization = struct
-  let old_stable_memory_version = Int32.of_int 1
-
   let extend64 code = code ^^ G.i (Convert (Wasm.Values.I64 I64Op.ExtendUI32))
   
   let _read_word32 env =
@@ -7340,7 +7324,7 @@ module OldStabilization = struct
         compile_add_const Heap.word_size ^^
         set_ptr))
 
-  let old_destabilize env ty =
+  let old_destabilize env ty save_version =
     match E.mode env with
     | Flags.ICMode | Flags.RefMode ->
       let (set_pages, get_pages) = new_local64 env "pages" in
@@ -7361,7 +7345,7 @@ module OldStabilization = struct
           StableMem.get_mem_size env ^^
           G.i (Test (Wasm.Values.I64 I64Op.Eqz)) ^^
           E.else_trap_with env "StableMem.mem_size non-zero" ^^
-          compile_unboxed_const 0l ^^
+          compile_unboxed_const StableMem.version_stable_heap_no_regions ^^
           StableMem.set_version env ^^
           Object.lit_raw env fs'
         end
@@ -7494,8 +7478,6 @@ end
   ending at page boundary
 *)
 module NewStableMemory = struct
-  let new_stable_memory_version = 3l
-
   let physical_size env =
     IC.system_call env "stable64_size" ^^
     compile_shl64_const (Int64.of_int page_size_bits)
@@ -7528,6 +7510,24 @@ module NewStableMemory = struct
   let logical_size_offset = 12L
   let version_offset = 4L
 
+  let upgrade_version env =
+    StableMem.set_version env ^^
+    StableMem.get_version env ^^
+    compile_eq_const StableMem.legacy_version_no_stable_memory ^^
+    StableMem.get_version env ^^
+    compile_eq_const StableMem.legacy_version_some_stable_memory ^^
+    G.i (Binary (Wasm.Values.I32 I32Op.Or)) ^^
+    (G.if0
+      (compile_unboxed_const StableMem.version_stable_heap_no_regions ^^
+      StableMem.set_version env)
+      G.nop) ^^
+    StableMem.get_version env ^^
+    compile_eq_const StableMem.legacy_version_regions ^^
+    (G.if0
+      (compile_unboxed_const StableMem.version_stable_heap_regions ^^
+      StableMem.set_version env)
+      G.nop)
+      
   let grow_size env amount =
     StableMem.get_mem_size env ^^
     compile_shl64_const (Int64.of_int page_size_bits) ^^
@@ -7546,7 +7546,7 @@ module NewStableMemory = struct
         store_at_end env logical_size_offset I64Type (StableMem.get_mem_size env) ^^
 
         (* store the version *)
-        store_at_end env version_offset I32Type (compile_unboxed_const new_stable_memory_version)
+        store_at_end env version_offset I32Type (StableMem.get_version env)
       end
 
   let restore env =
@@ -7559,10 +7559,16 @@ module NewStableMemory = struct
       begin
         (* check the version *)
         read_from_end env version_offset I32Type ^^
-        compile_eq_const new_stable_memory_version ^^
+        StableMem.set_version env ^^
+        StableMem.get_version env ^^
+        compile_eq_const StableMem.version_stable_heap_no_regions ^^
+        StableMem.get_version env ^^
+        compile_eq_const StableMem.version_stable_heap_regions ^^
+        G.i (Binary (Wasm.Values.I32 I32Op.Or)) ^^
         E.else_trap_with env (Printf.sprintf
-          "unsupported stable memory version (expected %s)"
-           (Int32.to_string new_stable_memory_version)) ^^
+          "unsupported stable memory version (expected %s or %s)"
+           (Int32.to_string StableMem.version_stable_heap_no_regions)
+           (Int32.to_string StableMem.version_stable_heap_regions)) ^^
         
         (* restore logical size *)
         read_from_end env logical_size_offset I64Type ^^
@@ -7605,7 +7611,6 @@ module Persistence = struct
     create_actor env actor_type recover_field ^^
     free_stable_actor env
 
-
   let save env actor_type =
     save_stable_actor env ^^
     NewStableMemory.backup env
@@ -7614,14 +7619,15 @@ module Persistence = struct
     register_stable_type env actor_type ^^
     load_stable_actor env ^^
     G.i (Test (Wasm.Values.I32 I32Op.Eqz)) ^^
-    G.if1 I32Type
+    (G.if1 I32Type
       begin
-        OldStabilization.old_destabilize env actor_type
+        OldStabilization.old_destabilize env actor_type (NewStableMemory.upgrade_version env)
       end
       begin
         recover_actor env actor_type ^^
         NewStableMemory.restore env
-      end
+      end) ^^
+    StableMem.region_init env
 end
 
 module GCRoots = struct
@@ -10590,8 +10596,6 @@ and compile_prim_invocation (env : E.t) ae p es at =
   | ICStableRead ty, [] ->
     SR.Vanilla,
     Persistence.load env ty
-    compile_unboxed_const (if !Flags.use_stable_regions then 1l else 0l) ^^
-    E.call_import env "rts" "region_init"
   | ICStableWrite ty, [e] ->
     SR.unit,
     compile_exp_vanilla env ae e ^^
diff --git a/src/codegen/persistence.ml b/src/codegen/persistence.ml
index 549519159ba..6898ff40de7 100644
--- a/src/codegen/persistence.ml
+++ b/src/codegen/persistence.ml
@@ -42,6 +42,7 @@
   Text      | -15l
   Blob      | -16l
   Principal | -17l
+  Region    | -18l
 
 
   // Function sort
@@ -194,6 +195,7 @@ let primitive_type_index primitive_type =
   | Text -> -15l
   | Blob -> -16l
   | Principal -> -17l
+  | Region -> -18l
   | Error -> assert false (* non-stable type *)
 
 let type_index table typ =
diff --git a/test/bench/ok/alloc.drun-run-opt.ok b/test/bench/ok/alloc.drun-run-opt.ok
index 7b203d6b8c4..f9e95b161d1 100644
--- a/test/bench/ok/alloc.drun-run-opt.ok
+++ b/test/bench/ok/alloc.drun-run-opt.ok
@@ -1,8 +1,8 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_714_400_059)
+debug.print: (+335_544_320, 4_815_063_355)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_714_399_876)
+debug.print: (+335_544_320, 4_815_063_172)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_714_399_888)
+debug.print: (+335_544_320, 4_815_063_184)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/alloc.drun-run.ok b/test/bench/ok/alloc.drun-run.ok
index 94440925784..4575154646c 100644
--- a/test/bench/ok/alloc.drun-run.ok
+++ b/test/bench/ok/alloc.drun-run.ok
@@ -1,8 +1,8 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_865_395_178)
+debug.print: (+335_544_320, 4_966_058_474)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_865_394_985)
+debug.print: (+335_544_320, 4_966_058_281)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_865_394_998)
+debug.print: (+335_544_320, 4_966_058_294)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/bignum.drun-run-opt.ok b/test/bench/ok/bignum.drun-run-opt.ok
index e0acc143ad0..44b5dc64276 100644
--- a/test/bench/ok/bignum.drun-run-opt.ok
+++ b/test/bench/ok/bignum.drun-run-opt.ok
@@ -1,6 +1,6 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 2_413_519; size = +60_608}
+debug.print: {cycles = 2_414_305; size = +60_608}
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 103_307_648; size = +1_827_460}
+debug.print: {cycles = 103_321_340; size = +1_827_460}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/bignum.drun-run.ok b/test/bench/ok/bignum.drun-run.ok
index 19714633700..d06c8e2bdd6 100644
--- a/test/bench/ok/bignum.drun-run.ok
+++ b/test/bench/ok/bignum.drun-run.ok
@@ -1,6 +1,6 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 2_518_300; size = +60_608}
+debug.print: {cycles = 2_519_086; size = +60_608}
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 103_362_157; size = +1_827_460}
+debug.print: {cycles = 103_375_825; size = +1_827_460}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/heap-32.drun-run-opt.ok b/test/bench/ok/heap-32.drun-run-opt.ok
index ea7f19893d7..fa0a97064f8 100644
--- a/test/bench/ok/heap-32.drun-run-opt.ok
+++ b/test/bench/ok/heap-32.drun-run-opt.ok
@@ -1,5 +1,5 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (50_227, +37_021_304, 762_444_205)
-debug.print: (50_070, +40_056_236, 824_441_398)
+debug.print: (50_227, +37_021_304, 768_384_283)
+debug.print: (50_070, +40_056_236, 830_837_434)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/heap-32.drun-run.ok b/test/bench/ok/heap-32.drun-run.ok
index 3b78e390d32..124de2bae61 100644
--- a/test/bench/ok/heap-32.drun-run.ok
+++ b/test/bench/ok/heap-32.drun-run.ok
@@ -1,5 +1,5 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (50_227, +37_021_304, 810_355_108)
-debug.print: (50_070, +40_056_236, 874_090_143)
+debug.print: (50_227, +37_021_304, 816_295_186)
+debug.print: (50_070, +40_056_236, 880_486_179)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/palindrome.drun-run-opt.ok b/test/bench/ok/palindrome.drun-run-opt.ok
index 6e958fe0610..8d86d8095e4 100644
--- a/test/bench/ok/palindrome.drun-run-opt.ok
+++ b/test/bench/ok/palindrome.drun-run-opt.ok
@@ -1,9 +1,9 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (true, +1_548, 28_429)
-debug.print: (false, +1_548, 27_119)
-debug.print: (false, +1_548, 28_394)
-debug.print: (true, +1_160, 27_441)
-debug.print: (false, +1_148, 25_379)
-debug.print: (false, +1_148, 27_239)
+debug.print: (true, +1_548, 28_867)
+debug.print: (false, +1_548, 27_557)
+debug.print: (false, +1_548, 28_832)
+debug.print: (true, +1_160, 27_783)
+debug.print: (false, +1_148, 25_715)
+debug.print: (false, +1_148, 27_575)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/palindrome.drun-run.ok b/test/bench/ok/palindrome.drun-run.ok
index eb2213c59ff..bee16b4c9b5 100644
--- a/test/bench/ok/palindrome.drun-run.ok
+++ b/test/bench/ok/palindrome.drun-run.ok
@@ -1,9 +1,9 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (true, +1_548, 29_899)
-debug.print: (false, +1_548, 28_513)
-debug.print: (false, +1_548, 29_863)
-debug.print: (true, +1_160, 28_397)
-debug.print: (false, +1_148, 26_296)
-debug.print: (false, +1_148, 28_186)
+debug.print: (true, +1_548, 30_337)
+debug.print: (false, +1_548, 28_951)
+debug.print: (false, +1_548, 30_301)
+debug.print: (true, +1_160, 28_739)
+debug.print: (false, +1_148, 26_632)
+debug.print: (false, +1_148, 28_522)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/region-mem.drun-run-opt.ok b/test/bench/ok/region-mem.drun-run-opt.ok
index 347dc52dd1c..b32d3d9d55c 100644
--- a/test/bench/ok/region-mem.drun-run-opt.ok
+++ b/test/bench/ok/region-mem.drun-run-opt.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 5_096_079_644}
+debug.print: {heap_diff = 0; instr_diff = 8_090_812_785}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/region-mem.drun-run.ok b/test/bench/ok/region-mem.drun-run.ok
index d163a240d75..7159bb97a74 100644
--- a/test/bench/ok/region-mem.drun-run.ok
+++ b/test/bench/ok/region-mem.drun-run.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 5_398_069_554}
+debug.print: {heap_diff = 0; instr_diff = 8_719_958_412}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/region0-mem.drun-run-opt.ok b/test/bench/ok/region0-mem.drun-run-opt.ok
index d3ebcd3f433..96fca6ed896 100644
--- a/test/bench/ok/region0-mem.drun-run-opt.ok
+++ b/test/bench/ok/region0-mem.drun-run-opt.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 5_221_908_764}
+debug.print: {heap_diff = 0; instr_diff = 7_310_672_241}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/region0-mem.drun-run.ok b/test/bench/ok/region0-mem.drun-run.ok
index e40430fa5af..91c2b8a8374 100644
--- a/test/bench/ok/region0-mem.drun-run.ok
+++ b/test/bench/ok/region0-mem.drun-run.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 5_637_144_882}
+debug.print: {heap_diff = 0; instr_diff = 7_876_903_308}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/stable-mem.drun-run-opt.ok b/test/bench/ok/stable-mem.drun-run-opt.ok
index 07ceff68c2d..e734aab7d6b 100644
--- a/test/bench/ok/stable-mem.drun-run-opt.ok
+++ b/test/bench/ok/stable-mem.drun-run-opt.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 2_642_411_804}
+debug.print: {heap_diff = 0; instr_diff = 3_548_381_553}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/stable-mem.drun-run.ok b/test/bench/ok/stable-mem.drun-run.ok
index 2419c21d635..d9d2e4a1ed9 100644
--- a/test/bench/ok/stable-mem.drun-run.ok
+++ b/test/bench/ok/stable-mem.drun-run.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 3_007_316_274}
+debug.print: {heap_diff = 0; instr_diff = 4_089_446_796}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/region0-rts-stats.drun-run.ok b/test/run-drun/ok/region0-rts-stats.drun-run.ok
index 566c3bbefc0..9f22d7475b0 100644
--- a/test/run-drun/ok/region0-rts-stats.drun-run.ok
+++ b/test/run-drun/ok/region0-rts-stats.drun-run.ok
@@ -2,9 +2,9 @@ ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a000000000000000001
 debug.print: {l1 = 6; s1 = 6}
 debug.print: {l2 = 144; s2 = 144}
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {l1 = 144; s1 = 146}
+debug.print: {l1 = 144; s1 = 145}
 ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: pattern failed
-debug.print: {l1 = 144; s1 = 146}
+debug.print: {l1 = 144; s1 = 145}
 ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: pattern failed
-debug.print: {l1 = 144; s1 = 146}
+debug.print: {l1 = 144; s1 = 145}
 ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: pattern failed
diff --git a/test/run-drun/ok/stable-mem-rts-stats.drun-run.ok b/test/run-drun/ok/stable-mem-rts-stats.drun-run.ok
index b58413c7edb..79bb9d774dd 100644
--- a/test/run-drun/ok/stable-mem-rts-stats.drun-run.ok
+++ b/test/run-drun/ok/stable-mem-rts-stats.drun-run.ok
@@ -2,9 +2,9 @@ ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a000000000000000001
 debug.print: {l1 = 0; s1 = 0}
 debug.print: {l2 = 16; s2 = 16}
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {l1 = 16; s1 = 18}
+debug.print: {l1 = 16; s1 = 17}
 ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: pattern failed
-debug.print: {l1 = 16; s1 = 18}
+debug.print: {l1 = 16; s1 = 17}
 ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: pattern failed
-debug.print: {l1 = 16; s1 = 18}
+debug.print: {l1 = 16; s1 = 17}
 ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: pattern failed
diff --git a/test/run-drun/region0-big-blob.mo b/test/run-drun/region0-big-blob.mo
index a6972af5107..0f674e779d0 100644
--- a/test/run-drun/region0-big-blob.mo
+++ b/test/run-drun/region0-big-blob.mo
@@ -4,8 +4,8 @@ import StableMemory "stable-mem/StableMemory";
 actor {
 
   let 0 = StableMemory.grow(65535-128);
-  let n = 2**31+16384;
-  let o:Nat64 = 2**31+16384 - 1;
+  let n = 2**15+16384;
+  let o:Nat64 = 2**15+16384 - 1;
   StableMemory.storeNat8(o, 255);
   let b = StableMemory.loadBlob(0, n);
   StableMemory.storeNat8(o, 0);
diff --git a/test/run-drun/stable-mem-big-blob.mo b/test/run-drun/stable-mem-big-blob.mo
index 9db89c50620..20f9f724793 100644
--- a/test/run-drun/stable-mem-big-blob.mo
+++ b/test/run-drun/stable-mem-big-blob.mo
@@ -4,8 +4,8 @@ import StableMemory "stable-mem/StableMemory";
 actor {
 
   let 0 = StableMemory.grow(65535-128);
-  let n = 2**31+16384;
-  let o:Nat64 = 2**31+16384 - 1;
+  let n = 2**15+16384;
+  let o:Nat64 = 2**15+16384 - 1;
   StableMemory.storeNat8(o, 255);
   let b = StableMemory.loadBlob(0, n);
   StableMemory.storeNat8(o, 0);

From b119d8082de27b70ec9531435ab09f37ee67e23a Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 7 Sep 2023 17:03:27 +0200
Subject: [PATCH 115/260] Adjust profile report script

---
 test/profile-report.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/profile-report.sh b/test/profile-report.sh
index 51971c11934..4a0e7d6f32d 100755
--- a/test/profile-report.sh
+++ b/test/profile-report.sh
@@ -51,7 +51,7 @@ __END__
 for file in perf/*.mo; do
   base="$(basename "$file" .mo)"
   echo "Profiling $base..."
-  moc --compacting-gc --force-gc -g "$file" -o "_profile_build/$base.wasm"
+  moc --force-gc -g "$file" -o "_profile_build/$base.wasm"
   wasm-profiler-instrument --ic-system-api -i "_profile_build/$base.wasm" -o "_profile_build/$base.instrumented.wasm"
 
   # qr.mo takes far too long with profiling instrumentation, so limit runtime

From 568b3cc8e4370f9cc8f2647cef2c1d9fc4f924f1 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 8 Sep 2023 15:52:05 +0200
Subject: [PATCH 116/260] Check compatibility with Candid subtype

Update benchmark results

Adjust order of sub-type test

Support mutable types for Candid subtype checks
---
 rts/motoko-rts-tests/src/gc.rs                |    1 +
 .../src/gc/incremental/roots.rs               |    1 +
 rts/motoko-rts-tests/src/main.rs              |    3 -
 rts/motoko-rts-tests/src/persistence.rs       |   21 -
 .../src/persistence/compatibility.rs          | 1712 -----------------
 rts/motoko-rts/src/gc/incremental/roots.rs    |    7 +-
 rts/motoko-rts/src/idl.rs                     |   67 +-
 rts/motoko-rts/src/lib.rs                     |    1 +
 rts/motoko-rts/src/mem_utils.rs               |    1 +
 rts/motoko-rts/src/persistence.rs             |   42 +-
 .../src/persistence/compatibility.rs          |  768 ++------
 src/codegen/compile.ml                        |   10 +-
 test/bench/ok/bignum.drun-run-opt.ok          |    2 +-
 test/bench/ok/bignum.drun-run.ok              |    2 +-
 test/run-drun/ok/any-upgrades.drun.ok         |    4 +-
 test/run-drun/ok/array-upgrades.drun.ok       |    8 +-
 test/run-drun/ok/function-upgrades.drun.ok    |   12 +-
 test/run-drun/ok/tuple-upgrades.drun.ok       |   16 +-
 test/run-drun/ok/upgrade-generics.drun.ok     |    4 +-
 test/run-drun/ok/upgrade-mutable.drun.ok      |    4 +-
 test/run-drun/ok/upgrade-nat-to-int.drun.ok   |    4 +-
 .../ok/upgrade-recursive-type.drun.ok         |    8 +-
 .../ok/upgrade-remove-add-fields.drun.ok      |    8 +-
 test/run-drun/ok/variant-upgrades.drun.ok     |    4 +-
 24 files changed, 233 insertions(+), 2477 deletions(-)
 delete mode 100644 rts/motoko-rts-tests/src/persistence.rs
 delete mode 100644 rts/motoko-rts-tests/src/persistence/compatibility.rs

diff --git a/rts/motoko-rts-tests/src/gc.rs b/rts/motoko-rts-tests/src/gc.rs
index 7183b412db5..6567ec4bc61 100644
--- a/rts/motoko-rts-tests/src/gc.rs
+++ b/rts/motoko-rts-tests/src/gc.rs
@@ -477,6 +477,7 @@ fn run(heap: &mut MotokoHeap) -> bool {
                 unused_root,
                 unused_root,
                 unused_root,
+                unused_root,
             ];
             IncrementalGC::instance(heap, get_incremental_gc_state())
                 .empty_call_stack_increment(roots);
diff --git a/rts/motoko-rts-tests/src/gc/incremental/roots.rs b/rts/motoko-rts-tests/src/gc/incremental/roots.rs
index 9b9e2eacaaf..5f953d529ab 100644
--- a/rts/motoko-rts-tests/src/gc/incremental/roots.rs
+++ b/rts/motoko-rts-tests/src/gc/incremental/roots.rs
@@ -73,6 +73,7 @@ unsafe fn get_roots(heap: &MotokoHeap) -> Roots {
         unused_root,
         unused_root,
         unused_root,
+        unused_root,
     ]
 }
 
diff --git a/rts/motoko-rts-tests/src/main.rs b/rts/motoko-rts-tests/src/main.rs
index ec4ea2ae139..3b2e92fadbc 100644
--- a/rts/motoko-rts-tests/src/main.rs
+++ b/rts/motoko-rts-tests/src/main.rs
@@ -7,7 +7,6 @@ mod crc32;
 mod gc;
 mod leb128;
 mod memory;
-mod persistence;
 mod principal_id;
 mod stream;
 mod text;
@@ -22,8 +21,6 @@ fn main() {
     }
 
     unsafe {
-        persistence::test();
-
         test_read_write_64_bit();
         bigint::test();
         bitrel::test();
diff --git a/rts/motoko-rts-tests/src/persistence.rs b/rts/motoko-rts-tests/src/persistence.rs
deleted file mode 100644
index 19c64c672d9..00000000000
--- a/rts/motoko-rts-tests/src/persistence.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-mod compatibility;
-
-use motoko_rts::persistence::allocate_null;
-use motoko_rts::types::TAG_NULL;
-
-use crate::memory::{initialize_test_memory, reset_test_memory};
-
-pub fn test() {
-    println!("Testing orthogonal persistence ...");
-    unsafe {
-        compatibility::test();
-        test_null_allocation();
-    }
-}
-
-unsafe fn test_null_allocation() {
-    let mut heap = initialize_test_memory();
-    let value = allocate_null(&mut heap);
-    assert_eq!(value.tag(), TAG_NULL);
-    reset_test_memory();
-}
diff --git a/rts/motoko-rts-tests/src/persistence/compatibility.rs b/rts/motoko-rts-tests/src/persistence/compatibility.rs
deleted file mode 100644
index 48bc0f05e33..00000000000
--- a/rts/motoko-rts-tests/src/persistence/compatibility.rs
+++ /dev/null
@@ -1,1712 +0,0 @@
-use motoko_rts::memory::{alloc_blob, Memory};
-use motoko_rts::persistence::compatibility::{
-    memory_compatible, ACTOR_ENCODING_TAG, ANY_ENCODING_TAG, ARRAY_ENCODING_TAG,
-    COMPOSITE_FUNCTION_SORT, FUNCTION_ENCODING_TAG, MUTABLE_ENCODING_TAG, NONE_ENCODING_TAG,
-    OBJECT_ENCODING_TAG, OPTION_ENCODING_TAG, QUERY_FUNCTION_SORT, TUPLE_ENCODING_TAG,
-    VARIANT_ENCODING_TAG, WRITE_FUNCTION_SORT,
-};
-use motoko_rts::types::{Bytes, Value};
-use std::hash::Hasher;
-use std::{collections::hash_map::DefaultHasher, hash::Hash};
-
-use crate::memory::{initialize_test_memory, reset_test_memory, TestMemory};
-
-struct BinaryData {
-    byte_sequence: Vec<u8>,
-}
-
-impl BinaryData {
-    fn new() -> BinaryData {
-        BinaryData {
-            byte_sequence: vec![],
-        }
-    }
-
-    fn write_i32(&mut self, value: i32) {
-        for byte in value.to_le_bytes() {
-            self.byte_sequence.push(byte);
-        }
-    }
-
-    fn write_hash(&mut self, value: &str) {
-        let mut hasher = DefaultHasher::new();
-        value.hash(&mut hasher);
-        self.write_i32(hasher.finish() as i32);
-    }
-
-    unsafe fn make_blob<M: Memory>(&self, mem: &mut M) -> Value {
-        let length = Bytes(self.byte_sequence.len() as u32);
-        let value = alloc_blob(mem, length);
-        let target = value.as_blob_mut();
-
-        for index in 0..length.as_usize() {
-            let byte = target.payload_addr().add(index);
-            *byte = *self.byte_sequence.get(index).unwrap();
-        }
-        value
-    }
-}
-
-#[derive(Clone)]
-enum Type {
-    Object(FieldList),
-    Actor(FieldList),
-    Function(FunctionSignature),
-    Mutable(TypeReference),
-    Option(TypeReference),
-    Array(TypeReference),
-    Tuple(TypeList),
-    Variant(FieldList),
-    None,
-    Any,
-}
-
-impl Type {
-    fn serialize(&self, output: &mut BinaryData) {
-        match &self {
-            Self::Object(field_list) => {
-                output.write_i32(OBJECT_ENCODING_TAG);
-                field_list.serialize(output);
-            }
-            Self::Function(function_signature) => {
-                output.write_i32(FUNCTION_ENCODING_TAG);
-                function_signature.serialize(output);
-            }
-            Self::Mutable(type_reference) => {
-                output.write_i32(MUTABLE_ENCODING_TAG);
-                output.write_i32(type_reference.index);
-            }
-            Self::Option(type_reference) => {
-                output.write_i32(OPTION_ENCODING_TAG);
-                output.write_i32(type_reference.index);
-            }
-            Self::Array(type_reference) => {
-                output.write_i32(ARRAY_ENCODING_TAG);
-                output.write_i32(type_reference.index);
-            }
-            Self::Tuple(type_list) => {
-                output.write_i32(TUPLE_ENCODING_TAG);
-                type_list.serialize(output);
-            }
-            Self::Variant(field_list) => {
-                output.write_i32(VARIANT_ENCODING_TAG);
-                field_list.serialize(output);
-            }
-            Self::None => {
-                output.write_i32(NONE_ENCODING_TAG);
-            }
-            Self::Any => {
-                output.write_i32(ANY_ENCODING_TAG);
-            }
-            Self::Actor(field_list) => {
-                output.write_i32(ACTOR_ENCODING_TAG);
-                field_list.serialize(output);
-            }
-        }
-    }
-}
-
-#[derive(Clone)]
-enum FunctionSort {
-    Query,
-    Write,
-    Composite,
-}
-
-impl FunctionSort {
-    fn serialize(&self, output: &mut BinaryData) {
-        match self {
-            Self::Query => output.write_i32(QUERY_FUNCTION_SORT),
-            Self::Write => output.write_i32(WRITE_FUNCTION_SORT),
-            Self::Composite => output.write_i32(COMPOSITE_FUNCTION_SORT),
-        }
-    }
-}
-
-#[derive(Clone)]
-struct FunctionSignature {
-    sort: FunctionSort,
-    parameter_types: TypeList,
-    return_types: TypeList,
-}
-
-impl FunctionSignature {
-    fn serialize(&self, output: &mut BinaryData) {
-        self.sort.serialize(output);
-        self.parameter_types.serialize(output);
-        self.return_types.serialize(output);
-    }
-}
-
-#[derive(PartialEq, Clone)]
-struct TypeReference {
-    index: i32,
-}
-
-// Keep identical to `compatibility.rs` and `persistence.ml`.
-const NULL_ENCODING_TAG: i32 = -1;
-const BOOL_ENCODING_TAG: i32 = -2;
-const NAT_ENCODING_TAG: i32 = -3;
-const NAT8_ENCODING_TAG: i32 = -4;
-const NAT16_ENCODING_TAG: i32 = -5;
-const NAT32_ENCODING_TAG: i32 = -6;
-const NAT64_ENCODING_TAG: i32 = -7;
-const INT_ENCODING_TAG: i32 = -8;
-const INT8_ENCODING_TAG: i32 = -9;
-const INT16_ENCODING_TAG: i32 = -10;
-const INT32_ENCODING_TAG: i32 = -11;
-const INT64_ENCODING_TAG: i32 = -12;
-const FLOAT_ENCODING_TAG: i32 = -13;
-const CHAR_ENCODING_TAG: i32 = -14;
-const TEXT_ENCODING_TAG: i32 = -15;
-const BLOB_ENCODING_TAG: i32 = -16;
-const PRINCIPAL_ENCODING_TAG: i32 = -17;
-const REGION_ENCODING_TAG: i32 = -18;
-
-impl TypeReference {
-    fn primitive(index: i32) -> Self {
-        assert!(index < 0);
-        TypeReference { index }
-    }
-
-    fn null() -> Self {
-        Self::primitive(NULL_ENCODING_TAG)
-    }
-
-    fn bool() -> Self {
-        Self::primitive(BOOL_ENCODING_TAG)
-    }
-
-    fn nat() -> Self {
-        Self::primitive(NAT_ENCODING_TAG)
-    }
-
-    fn nat8() -> Self {
-        Self::primitive(NAT8_ENCODING_TAG)
-    }
-
-    fn nat16() -> Self {
-        Self::primitive(NAT16_ENCODING_TAG)
-    }
-
-    fn nat32() -> Self {
-        Self::primitive(NAT32_ENCODING_TAG)
-    }
-
-    fn nat64() -> Self {
-        Self::primitive(NAT64_ENCODING_TAG)
-    }
-
-    fn int() -> Self {
-        Self::primitive(INT_ENCODING_TAG)
-    }
-
-    fn int8() -> Self {
-        Self::primitive(INT8_ENCODING_TAG)
-    }
-
-    fn int16() -> Self {
-        Self::primitive(INT16_ENCODING_TAG)
-    }
-
-    fn int32() -> Self {
-        Self::primitive(INT32_ENCODING_TAG)
-    }
-
-    fn int64() -> Self {
-        Self::primitive(INT64_ENCODING_TAG)
-    }
-
-    fn float() -> Self {
-        Self::primitive(FLOAT_ENCODING_TAG)
-    }
-
-    fn char() -> Self {
-        Self::primitive(CHAR_ENCODING_TAG)
-    }
-
-    fn text() -> Self {
-        Self::primitive(TEXT_ENCODING_TAG)
-    }
-
-    fn blob() -> Self {
-        Self::primitive(BLOB_ENCODING_TAG)
-    }
-
-    fn principal() -> Self {
-        Self::primitive(PRINCIPAL_ENCODING_TAG)
-    }
-
-    fn region() -> Self {
-        Self::primitive(REGION_ENCODING_TAG)
-    }
-}
-
-#[derive(Clone)]
-struct Field {
-    name: String,
-    field_type: TypeReference,
-}
-
-impl Field {
-    fn serialize(&self, output: &mut BinaryData) {
-        output.write_hash(&self.name);
-        output.write_i32(self.field_type.index);
-    }
-}
-
-#[derive(Clone)]
-struct FieldList {
-    fields: Vec<Field>,
-}
-
-impl FieldList {
-    fn serialize(&self, output: &mut BinaryData) {
-        output.write_i32(self.fields.len() as i32);
-        for field in &self.fields {
-            field.serialize(output);
-        }
-    }
-}
-
-#[derive(Clone)]
-struct TypeList {
-    items: Vec<TypeReference>,
-}
-
-impl TypeList {
-    fn serialize(&self, output: &mut BinaryData) {
-        output.write_i32(self.items.len() as i32);
-        for item in &self.items {
-            output.write_i32(item.index);
-        }
-    }
-}
-
-struct TypeTable {
-    types: Vec<Type>,
-}
-
-impl TypeTable {
-    fn new(types: Vec<Type>) -> TypeTable {
-        TypeTable { types }
-    }
-
-    fn serialize(&self) -> BinaryData {
-        let mut output = BinaryData::new();
-        output.write_i32(self.types.len() as i32);
-        for current_type in &self.types {
-            current_type.serialize(&mut output);
-        }
-        output
-    }
-}
-
-unsafe fn build<M: Memory>(mem: &mut M, types: Vec<Type>) -> Value {
-    TypeTable::new(types).serialize().make_blob(mem)
-}
-
-unsafe fn are_compatible<M: Memory>(
-    mem: &mut M,
-    old_types: Vec<Type>,
-    new_types: Vec<Type>,
-) -> bool {
-    let old_type_blob = build(mem, old_types);
-    let new_type_blob = build(mem, new_types);
-    memory_compatible(mem, old_type_blob, new_type_blob)
-}
-
-unsafe fn is_compatible<M: Memory>(mem: &mut M, old_type: Type, new_type: Type) -> bool {
-    are_compatible(mem, vec![old_type], vec![new_type])
-}
-
-pub unsafe fn test() {
-    println!("  Testing memory compatibility...");
-    let mut heap = initialize_test_memory();
-    test_primitive_types(&mut heap);
-    test_sucessful_cases(&mut heap);
-    test_failing_cases(&mut heap);
-    reset_test_memory();
-}
-
-unsafe fn test_primitive_types(heap: &mut TestMemory) {
-    let mut is_compatible = |first: &TypeReference, second: &TypeReference| {
-        let old_types = Type::Object(FieldList {
-            fields: vec![Field {
-                name: String::from("Field"),
-                field_type: first.clone(),
-            }],
-        });
-        let new_types = Type::Object(FieldList {
-            fields: vec![Field {
-                name: String::from("Field"),
-                field_type: second.clone(),
-            }],
-        });
-        is_compatible(heap, old_types, new_types)
-    };
-    let all_types = [
-        TypeReference::null(),
-        TypeReference::bool(),
-        TypeReference::nat(),
-        TypeReference::nat8(),
-        TypeReference::nat16(),
-        TypeReference::nat32(),
-        TypeReference::nat64(),
-        TypeReference::int(),
-        TypeReference::int8(),
-        TypeReference::int16(),
-        TypeReference::int32(),
-        TypeReference::int64(),
-        TypeReference::float(),
-        TypeReference::char(),
-        TypeReference::text(),
-        TypeReference::blob(),
-        TypeReference::principal(),
-        TypeReference::region(),
-    ];
-    for first in &all_types {
-        for second in &all_types {
-            assert_eq!(
-                is_compatible(first, second),
-                first == second
-                    || first == &TypeReference::nat() && second == &TypeReference::int()
-            );
-        }
-    }
-}
-
-unsafe fn test_sucessful_cases(heap: &mut TestMemory) {
-    test_empty_actor(heap);
-    test_multiple_primitive_fields(heap);
-    test_reordered_main_actor_fields(heap);
-    test_removed_main_actor_fields(heap);
-    test_mutable_fields(heap);
-    test_added_main_actor_fields(heap);
-    test_removed_object_fields(heap);
-    test_removed_actor_fields(heap);
-    test_direct_recursive_type(heap);
-    test_indirect_recursive_type(heap);
-    test_option_types(heap);
-    test_flat_array_types(heap);
-    test_nested_array_types(heap);
-    test_recursive_array_types(heap);
-    test_empty_tuple_types(heap);
-    test_simple_tuple_types(heap);
-    test_nested_tuple_types(heap);
-    test_recursive_tuple_types(heap);
-    test_reordered_variant_fields(heap);
-    test_added_variant_fields(heap);
-    test_any_to_any(heap);
-    test_some_to_any(heap);
-    test_none_to_none(heap);
-    test_identical_functions(heap);
-    test_no_return_functions(heap);
-    test_no_parameter_functions(heap);
-    test_covariant_function_results(heap);
-    test_contravariant_parameters(heap);
-    test_different_type_counts(heap);
-}
-
-unsafe fn test_empty_actor(heap: &mut TestMemory) {
-    let old_type = Type::Object(FieldList { fields: vec![] });
-    let new_type = Type::Object(FieldList { fields: vec![] });
-    assert!(is_compatible(heap, old_type, new_type));
-}
-
-unsafe fn test_multiple_primitive_fields(heap: &mut TestMemory) {
-    let fields = vec![
-        Field {
-            name: String::from("NullField"),
-            field_type: TypeReference::null(),
-        },
-        Field {
-            name: String::from("BoolField"),
-            field_type: TypeReference::bool(),
-        },
-        Field {
-            name: String::from("NatField"),
-            field_type: TypeReference::nat(),
-        },
-        Field {
-            name: String::from("Nat8Field"),
-            field_type: TypeReference::nat8(),
-        },
-        Field {
-            name: String::from("Nat16Field"),
-            field_type: TypeReference::nat16(),
-        },
-        Field {
-            name: String::from("Nat32Field"),
-            field_type: TypeReference::nat32(),
-        },
-        Field {
-            name: String::from("Nat64Field"),
-            field_type: TypeReference::nat64(),
-        },
-        Field {
-            name: String::from("IntField"),
-            field_type: TypeReference::int(),
-        },
-        Field {
-            name: String::from("Int8Field"),
-            field_type: TypeReference::int8(),
-        },
-        Field {
-            name: String::from("Int16Field"),
-            field_type: TypeReference::int16(),
-        },
-        Field {
-            name: String::from("Int32Field"),
-            field_type: TypeReference::int32(),
-        },
-        Field {
-            name: String::from("Int64Field"),
-            field_type: TypeReference::int64(),
-        },
-        Field {
-            name: String::from("FloatField"),
-            field_type: TypeReference::float(),
-        },
-        Field {
-            name: String::from("CharField"),
-            field_type: TypeReference::char(),
-        },
-        Field {
-            name: String::from("TextField"),
-            field_type: TypeReference::text(),
-        },
-        Field {
-            name: String::from("BlobField"),
-            field_type: TypeReference::blob(),
-        },
-        Field {
-            name: String::from("PrincipalField"),
-            field_type: TypeReference::principal(),
-        },
-    ];
-
-    let types = Type::Object(FieldList { fields });
-
-    assert!(is_compatible(heap, types.clone(), types));
-}
-
-unsafe fn test_reordered_main_actor_fields(heap: &mut TestMemory) {
-    let field1 = Field {
-        name: String::from("Field1"),
-        field_type: TypeReference::int(),
-    };
-    let field2 = Field {
-        name: String::from("Field2"),
-        field_type: TypeReference::nat(),
-    };
-
-    let old_type = Type::Object(FieldList {
-        fields: vec![field1.clone(), field2.clone()],
-    });
-    let new_type = Type::Object(FieldList {
-        fields: vec![field2.clone(), field1.clone()],
-    });
-
-    assert!(is_compatible(heap, old_type, new_type));
-}
-
-unsafe fn test_removed_main_actor_fields(heap: &mut TestMemory) {
-    let field1 = Field {
-        name: String::from("Field1"),
-        field_type: TypeReference::nat8(),
-    };
-    let field2 = Field {
-        name: String::from("Field2"),
-        field_type: TypeReference::nat16(),
-    };
-    let field3 = Field {
-        name: String::from("Field3"),
-        field_type: TypeReference::nat32(),
-    };
-
-    let old_type = Type::Object(FieldList {
-        fields: vec![field1.clone(), field2.clone(), field3.clone()],
-    });
-    let new_type = Type::Object(FieldList {
-        fields: vec![field2.clone()],
-    });
-
-    assert!(is_compatible(heap, old_type, new_type));
-}
-
-unsafe fn test_added_main_actor_fields(heap: &mut TestMemory) {
-    let field1 = Field {
-        name: String::from("Field1"),
-        field_type: TypeReference::bool(),
-    };
-    let field2 = Field {
-        name: String::from("Field2"),
-        field_type: TypeReference::char(),
-    };
-    let field3 = Field {
-        name: String::from("Field3"),
-        field_type: TypeReference::text(),
-    };
-
-    let old_type = Type::Object(FieldList {
-        fields: vec![field2.clone()],
-    });
-    let new_type = Type::Object(FieldList {
-        fields: vec![field1.clone(), field2.clone(), field3.clone()],
-    });
-
-    assert!(is_compatible(heap, old_type, new_type));
-}
-
-unsafe fn test_mutable_fields(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("MainActorField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let mutable_type = Type::Mutable(TypeReference::nat());
-    let old_types = vec![main_actor.clone(), mutable_type.clone()];
-    let new_types = vec![main_actor.clone(), mutable_type.clone()];
-    assert!(are_compatible(heap, old_types, new_types));
-}
-
-unsafe fn test_removed_object_fields(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("ActorField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-
-    let field1 = Field {
-        name: String::from("Field1"),
-        field_type: TypeReference::int8(),
-    };
-    let field2 = Field {
-        name: String::from("Field2"),
-        field_type: TypeReference::int16(),
-    };
-    let field3 = Field {
-        name: String::from("Field3"),
-        field_type: TypeReference::int32(),
-    };
-
-    let old_type = Type::Object(FieldList {
-        fields: vec![field1.clone(), field2.clone(), field3.clone()],
-    });
-    let new_type = Type::Object(FieldList {
-        fields: vec![field2.clone()],
-    });
-
-    let old_types = vec![main_actor.clone(), old_type];
-    let new_types = vec![main_actor.clone(), new_type];
-    assert!(are_compatible(heap, old_types, new_types));
-}
-
-unsafe fn test_removed_actor_fields(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("ActorField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-
-    let field1 = Field {
-        name: String::from("Field1"),
-        field_type: TypeReference::int8(),
-    };
-    let field2 = Field {
-        name: String::from("Field2"),
-        field_type: TypeReference::int16(),
-    };
-    let field3 = Field {
-        name: String::from("Field3"),
-        field_type: TypeReference::int32(),
-    };
-
-    let old_type = Type::Actor(FieldList {
-        fields: vec![field1.clone(), field2.clone(), field3.clone()],
-    });
-    let new_type = Type::Actor(FieldList {
-        fields: vec![field2.clone()],
-    });
-
-    let old_types = vec![main_actor.clone(), old_type];
-    let new_types = vec![main_actor.clone(), new_type];
-    assert!(are_compatible(heap, old_types, new_types));
-}
-
-unsafe fn test_direct_recursive_type(heap: &mut TestMemory) {
-    let actor_field = Field {
-        name: String::from("ActorField"),
-        field_type: TypeReference { index: 1 },
-    };
-    let main_actor = Type::Object(FieldList {
-        fields: vec![actor_field],
-    });
-    let recursive_field = Field {
-        name: String::from("RecursiveField"),
-        field_type: TypeReference { index: 1 },
-    };
-    let recursive_type = Type::Object(FieldList {
-        fields: vec![recursive_field],
-    });
-    let types = vec![main_actor, recursive_type];
-    assert!(are_compatible(heap, types.clone(), types.clone()));
-}
-
-unsafe fn test_indirect_recursive_type(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("ActorField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let first_type = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("Field1"),
-            field_type: TypeReference { index: 2 },
-        }],
-    });
-    let second_type = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("Field2"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let types = vec![main_actor, first_type, second_type];
-    assert!(are_compatible(heap, types.clone(), types.clone()));
-}
-
-unsafe fn test_option_types(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("OptionalField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let option_type = Type::Option(TypeReference::blob());
-    let types = vec![main_actor, option_type];
-    assert!(are_compatible(heap, types.clone(), types.clone()));
-}
-
-unsafe fn test_flat_array_types(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("ArrayField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let array_type = Type::Array(TypeReference::nat());
-    let types = vec![main_actor, array_type];
-    assert!(are_compatible(heap, types.clone(), types.clone()));
-}
-
-unsafe fn test_nested_array_types(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("ArrayField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let outer_array_type = Type::Array(TypeReference { index: 2 });
-    let inner_array_type = Type::Array(TypeReference::nat());
-    let types = vec![main_actor, outer_array_type, inner_array_type];
-    assert!(are_compatible(heap, types.clone(), types.clone()));
-}
-
-unsafe fn test_recursive_array_types(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("ArrayField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let recursive_array_type = Type::Array(TypeReference { index: 1 });
-    let types = vec![main_actor, recursive_array_type];
-    assert!(are_compatible(heap, types.clone(), types.clone()));
-}
-
-unsafe fn test_empty_tuple_types(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("TupleField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let unit_type = Type::Tuple(TypeList { items: vec![] });
-    let types = vec![main_actor, unit_type];
-    assert!(are_compatible(heap, types.clone(), types.clone()));
-}
-
-unsafe fn test_simple_tuple_types(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("TupleField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let tuple_type = Type::Tuple(TypeList {
-        items: vec![
-            TypeReference::nat(),
-            TypeReference::text(),
-            TypeReference::int32(),
-        ],
-    });
-    let types = vec![main_actor, tuple_type];
-    assert!(are_compatible(heap, types.clone(), types.clone()));
-}
-
-unsafe fn test_nested_tuple_types(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("TupleField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let outer_tuple_type = Type::Tuple(TypeList {
-        items: vec![TypeReference { index: 2 }],
-    });
-    let inner_tuple_type = Type::Tuple(TypeList {
-        items: vec![TypeReference::nat()],
-    });
-    let types = vec![main_actor, outer_tuple_type, inner_tuple_type];
-    assert!(are_compatible(heap, types.clone(), types.clone()));
-}
-
-unsafe fn test_recursive_tuple_types(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("TupleField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let first_tuple_type = Type::Tuple(TypeList {
-        items: vec![TypeReference { index: 2 }],
-    });
-    let second_tuple_type = Type::Tuple(TypeList {
-        items: vec![TypeReference { index: 1 }],
-    });
-    let types = vec![main_actor, first_tuple_type, second_tuple_type];
-    assert!(are_compatible(heap, types.clone(), types.clone()));
-}
-
-unsafe fn test_reordered_variant_fields(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("VariantField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-
-    let field1 = Field {
-        name: String::from("Field1"),
-        field_type: TypeReference::int8(),
-    };
-    let field2 = Field {
-        name: String::from("Field2"),
-        field_type: TypeReference::int16(),
-    };
-    let field3 = Field {
-        name: String::from("Field3"),
-        field_type: TypeReference::int32(),
-    };
-
-    let old_variant = Type::Variant(FieldList {
-        fields: vec![field3.clone(), field2.clone(), field1.clone()],
-    });
-    let new_variant = Type::Variant(FieldList {
-        fields: vec![field1.clone(), field2.clone(), field3.clone()],
-    });
-
-    let old_types = vec![main_actor.clone(), old_variant];
-    let new_types = vec![main_actor.clone(), new_variant];
-    assert!(are_compatible(heap, old_types, new_types));
-}
-
-unsafe fn test_added_variant_fields(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("VariantField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-
-    let field1 = Field {
-        name: String::from("Field1"),
-        field_type: TypeReference::int8(),
-    };
-    let field2 = Field {
-        name: String::from("Field2"),
-        field_type: TypeReference::int16(),
-    };
-    let field3 = Field {
-        name: String::from("Field3"),
-        field_type: TypeReference::int32(),
-    };
-
-    let old_variant = Type::Variant(FieldList {
-        fields: vec![field2.clone()],
-    });
-    let new_variant = Type::Variant(FieldList {
-        fields: vec![field1.clone(), field2.clone(), field3.clone()],
-    });
-
-    let old_types = vec![main_actor.clone(), old_variant];
-    let new_types = vec![main_actor.clone(), new_variant];
-    assert!(are_compatible(heap, old_types, new_types));
-}
-
-unsafe fn test_any_to_any(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("Field"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let any_type = Type::Any;
-    let types = vec![main_actor, any_type];
-    assert!(are_compatible(heap, types.clone(), types.clone()));
-}
-
-unsafe fn test_some_to_any(heap: &mut TestMemory) {
-    let old_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("Field"),
-            field_type: TypeReference::text(),
-        }],
-    });
-    let new_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("Field"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let any_type = Type::Any;
-    let old_types = vec![old_actor];
-    let new_types = vec![new_actor, any_type];
-    assert!(are_compatible(heap, old_types, new_types));
-}
-
-unsafe fn test_none_to_none(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("Field"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let none_type = Type::None;
-    let types = vec![main_actor, none_type];
-    assert!(are_compatible(heap, types.clone(), types.clone()));
-}
-
-unsafe fn test_identical_functions(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("FunctionField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let parameter_types = TypeList {
-        items: vec![TypeReference::nat(), TypeReference::bool()],
-    };
-    let return_types = TypeList {
-        items: vec![TypeReference::int(), TypeReference::text()],
-    };
-    let sort = FunctionSort::Query;
-    let function = Type::Function(FunctionSignature {
-        sort,
-        parameter_types,
-        return_types,
-    });
-    let types = vec![main_actor, function];
-    assert!(are_compatible(heap, types.clone(), types.clone()));
-}
-
-unsafe fn test_no_return_functions(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("FunctionField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let parameter_types = TypeList {
-        items: vec![TypeReference::nat(), TypeReference::bool()],
-    };
-    let return_types = TypeList { items: vec![] };
-    let sort = FunctionSort::Composite;
-    let function = Type::Function(FunctionSignature {
-        sort,
-        parameter_types,
-        return_types,
-    });
-    let types = vec![main_actor, function];
-    assert!(are_compatible(heap, types.clone(), types.clone()));
-}
-
-unsafe fn test_no_parameter_functions(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("FunctionField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let parameter_types = TypeList { items: vec![] };
-    let return_types = TypeList {
-        items: vec![TypeReference::float()],
-    };
-    let sort = FunctionSort::Write;
-    let function = Type::Function(FunctionSignature {
-        sort,
-        parameter_types,
-        return_types,
-    });
-    let types = vec![main_actor, function];
-    assert!(are_compatible(heap, types.clone(), types.clone()));
-}
-
-unsafe fn test_covariant_function_results(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("FunctionField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let parameter_types = TypeList {
-        items: vec![TypeReference::nat(), TypeReference::bool()],
-    };
-    let return_types = TypeList {
-        items: vec![TypeReference { index: 2 }],
-    };
-    let sort = FunctionSort::Composite;
-    let function = Type::Function(FunctionSignature {
-        sort,
-        parameter_types,
-        return_types,
-    });
-
-    let field1 = Field {
-        name: String::from("Field1"),
-        field_type: TypeReference::int8(),
-    };
-    let field2 = Field {
-        name: String::from("Field2"),
-        field_type: TypeReference::int16(),
-    };
-    let field3 = Field {
-        name: String::from("Field3"),
-        field_type: TypeReference::int32(),
-    };
-
-    let old_object = Type::Actor(FieldList {
-        fields: vec![field1.clone(), field2.clone(), field3.clone()],
-    });
-    let new_object = Type::Actor(FieldList {
-        fields: vec![field2.clone()],
-    });
-
-    let old_types = vec![main_actor.clone(), function.clone(), old_object];
-    let new_types = vec![main_actor.clone(), function.clone(), new_object];
-    assert!(are_compatible(heap, old_types, new_types));
-}
-
-unsafe fn test_contravariant_parameters(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("FunctionField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let parameter_types = TypeList {
-        items: vec![TypeReference { index: 2 }],
-    };
-    let return_types = TypeList { items: vec![] };
-    let sort = FunctionSort::Composite;
-    let function = Type::Function(FunctionSignature {
-        sort,
-        parameter_types,
-        return_types,
-    });
-
-    let field1 = Field {
-        name: String::from("Field1"),
-        field_type: TypeReference::int8(),
-    };
-    let field2 = Field {
-        name: String::from("Field2"),
-        field_type: TypeReference::int16(),
-    };
-    let field3 = Field {
-        name: String::from("Field3"),
-        field_type: TypeReference::int32(),
-    };
-
-    let old_object = Type::Actor(FieldList {
-        fields: vec![field2.clone()],
-    });
-    let new_object = Type::Actor(FieldList {
-        fields: vec![field1.clone(), field2.clone(), field3.clone()],
-    });
-
-    let old_types = vec![main_actor.clone(), function.clone(), old_object];
-    let new_types = vec![main_actor.clone(), function.clone(), new_object];
-    assert!(are_compatible(heap, old_types, new_types));
-}
-
-unsafe fn test_different_type_counts(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("FunctionField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let sort = FunctionSort::Composite;
-    let old_function = Type::Function(FunctionSignature {
-        sort: sort.clone(),
-        parameter_types: TypeList {
-            items: vec![TypeReference { index: 2 }],
-        },
-        return_types: TypeList { items: vec![] },
-    });
-    let new_function = Type::Function(FunctionSignature {
-        sort: sort.clone(),
-        parameter_types: TypeList {
-            items: vec![TypeReference { index: 4 }],
-        },
-        return_types: TypeList { items: vec![] },
-    });
-    let field1 = Field {
-        name: String::from("Field1"),
-        field_type: TypeReference::int8(),
-    };
-    let field2 = Field {
-        name: String::from("Field2"),
-        field_type: TypeReference::int16(),
-    };
-    let field3 = Field {
-        name: String::from("Field3"),
-        field_type: TypeReference::int32(),
-    };
-
-    let old_object = Type::Actor(FieldList {
-        fields: vec![field2.clone()],
-    });
-    let new_object = Type::Actor(FieldList {
-        fields: vec![field1.clone(), field2.clone(), field3.clone()],
-    });
-    let unused_type = Type::None;
-
-    let old_types = vec![main_actor.clone(), old_function, old_object];
-    let new_types = vec![
-        main_actor.clone(),
-        new_function,
-        unused_type.clone(),
-        unused_type.clone(),
-        new_object,
-    ];
-    assert!(are_compatible(heap, old_types, new_types));
-}
-
-unsafe fn test_failing_cases(heap: &mut TestMemory) {
-    test_added_object_fields(heap);
-    test_added_actor_fields(heap);
-    test_actor_to_object(heap);
-    test_object_to_actor(heap);
-    test_mutable_mismatch(heap);
-    test_mutable_invariance(heap);
-    test_immutable_mismatch(heap);
-    test_recursion_mismatch(heap);
-    test_option_mismatch(heap);
-    test_array_mismatch(heap);
-    test_array_mutability_mismatch(heap);
-    test_reordered_tuple_types(heap);
-    test_removed_variant_fields(heap);
-    test_any_to_some(heap);
-    test_any_to_none(heap);
-    test_mismatching_function_sort(heap);
-    test_mismatching_parameters(heap);
-    test_mismatching_parameter_count(heap);
-    test_mismatching_return_types(heap);
-    test_mismatching_return_count(heap);
-    test_invalid_result_variance(heap);
-    test_invalid_parameter_variance(heap);
-}
-
-unsafe fn test_recursion_mismatch(heap: &mut TestMemory) {
-    let old_actor_field = Field {
-        name: String::from("ActorField"),
-        field_type: TypeReference { index: 1 },
-    };
-    let old_actor = Type::Object(FieldList {
-        fields: vec![old_actor_field],
-    });
-    let recursive_field = Field {
-        name: String::from("Field"),
-        field_type: TypeReference { index: 1 },
-    };
-    let recursive_type = Type::Object(FieldList {
-        fields: vec![recursive_field],
-    });
-    let new_actor_field = Field {
-        name: String::from("ActorField"),
-        field_type: TypeReference { index: 1 },
-    };
-    let new_actor = Type::Object(FieldList {
-        fields: vec![new_actor_field],
-    });
-    let non_recursive_field = Field {
-        name: String::from("Field"),
-        field_type: TypeReference::principal(),
-    };
-    let non_recursive_type = Type::Object(FieldList {
-        fields: vec![non_recursive_field],
-    });
-    let old_types = vec![old_actor, recursive_type];
-    let new_types = vec![new_actor, non_recursive_type];
-    assert!(!are_compatible(heap, old_types, new_types));
-}
-
-unsafe fn test_added_object_fields(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("ActorField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let field1 = Field {
-        name: String::from("Field1"),
-        field_type: TypeReference::nat64(),
-    };
-    let field2 = Field {
-        name: String::from("Field2"),
-        field_type: TypeReference::float(),
-    };
-    let field3 = Field {
-        name: String::from("Field3"),
-        field_type: TypeReference::int64(),
-    };
-
-    let old_type = Type::Object(FieldList {
-        fields: vec![field2.clone()],
-    });
-    let new_type = Type::Object(FieldList {
-        fields: vec![field1.clone(), field2.clone(), field3.clone()],
-    });
-    let old_types = vec![main_actor.clone(), old_type];
-    let new_types = vec![main_actor.clone(), new_type];
-    assert!(!are_compatible(heap, old_types, new_types));
-}
-
-unsafe fn test_added_actor_fields(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("ActorField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-
-    let field1 = Field {
-        name: String::from("Field1"),
-        field_type: TypeReference::nat64(),
-    };
-    let field2 = Field {
-        name: String::from("Field2"),
-        field_type: TypeReference::float(),
-    };
-    let field3 = Field {
-        name: String::from("Field3"),
-        field_type: TypeReference::int64(),
-    };
-
-    let old_type = Type::Actor(FieldList {
-        fields: vec![field2.clone()],
-    });
-    let new_type = Type::Actor(FieldList {
-        fields: vec![field1.clone(), field2.clone(), field3.clone()],
-    });
-    let old_types = vec![main_actor.clone(), old_type];
-    let new_types = vec![main_actor.clone(), new_type];
-    assert!(!are_compatible(heap, old_types, new_types));
-}
-
-unsafe fn test_actor_to_object(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("ActorField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let old_type = Type::Actor(FieldList { fields: vec![] });
-    let new_type = Type::Object(FieldList { fields: vec![] });
-    let old_types = vec![main_actor.clone(), old_type];
-    let new_types = vec![main_actor.clone(), new_type];
-    assert!(!are_compatible(heap, old_types, new_types));
-}
-
-unsafe fn test_object_to_actor(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("ActorField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let old_type = Type::Actor(FieldList { fields: vec![] });
-    let new_type = Type::Object(FieldList { fields: vec![] });
-    let old_types = vec![main_actor.clone(), old_type];
-    let new_types = vec![main_actor.clone(), new_type];
-    assert!(!are_compatible(heap, old_types, new_types));
-}
-
-unsafe fn test_mutable_mismatch(heap: &mut TestMemory) {
-    let old_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("ActorField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let mutable_type = Type::Mutable(TypeReference::nat());
-    let new_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("ActorField"),
-            field_type: TypeReference::nat(),
-        }],
-    });
-    let old_types = vec![old_actor, mutable_type];
-    let new_types = vec![new_actor];
-    assert!(!are_compatible(heap, old_types, new_types));
-}
-
-unsafe fn test_mutable_invariance(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("ActorField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let mutable_type = Type::Mutable(TypeReference { index: 2 });
-    let field1 = Field {
-        name: String::from("Field1"),
-        field_type: TypeReference::nat(),
-    };
-    let field2 = Field {
-        name: String::from("Field2"),
-        field_type: TypeReference::text(),
-    };
-    let old_object = Type::Object(FieldList {
-        fields: vec![field1.clone(), field2],
-    });
-    let new_object = Type::Object(FieldList {
-        fields: vec![field1.clone()],
-    });
-    let old_types = vec![main_actor.clone(), mutable_type.clone(), old_object];
-    let new_types = vec![main_actor.clone(), mutable_type.clone(), new_object];
-    assert!(!are_compatible(heap, old_types, new_types));
-}
-
-unsafe fn test_immutable_mismatch(heap: &mut TestMemory) {
-    let old_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("ActorField"),
-            field_type: TypeReference::bool(),
-        }],
-    });
-    let new_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("ActorField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let mutable_type = Type::Mutable(TypeReference::nat());
-    let old_types = vec![old_actor];
-    let new_types = vec![new_actor, mutable_type];
-    assert!(!are_compatible(heap, old_types, new_types));
-}
-
-unsafe fn test_option_mismatch(heap: &mut TestMemory) {
-    let old_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("OptionalField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let option_type = Type::Option(TypeReference::nat());
-    let new_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("OptionalField"),
-            field_type: TypeReference::float(),
-        }],
-    });
-    let old_types = vec![old_actor, option_type];
-    let new_types = vec![new_actor];
-    assert!(!are_compatible(heap, old_types, new_types));
-}
-
-unsafe fn test_array_mismatch(heap: &mut TestMemory) {
-    let old_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("ArrayField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let array_type = Type::Array(TypeReference::nat());
-    let new_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("ArrayField"),
-            field_type: TypeReference::text(),
-        }],
-    });
-    let old_types = vec![old_actor, array_type];
-    let new_types = vec![new_actor];
-    assert!(!are_compatible(heap, old_types, new_types));
-}
-
-unsafe fn test_array_mutability_mismatch(heap: &mut TestMemory) {
-    let old_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("ArrayField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let immutable_array_type = Type::Array(TypeReference::nat());
-    let new_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("ArrayField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let mutable_array_type = Type::Array(TypeReference { index: 2 });
-    let mutable_variable = Type::Mutable(TypeReference::nat());
-    let old_types = vec![old_actor, immutable_array_type];
-    let new_types = vec![new_actor, mutable_array_type, mutable_variable];
-    assert!(!are_compatible(heap, old_types, new_types));
-}
-
-unsafe fn test_reordered_tuple_types(heap: &mut TestMemory) {
-    let old_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("TupleField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let old_tuple = Type::Tuple(TypeList {
-        items: vec![TypeReference::nat(), TypeReference::text()],
-    });
-    let new_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("TupleField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let new_tuple = Type::Tuple(TypeList {
-        items: vec![TypeReference::text(), TypeReference::nat()],
-    });
-    let old_types = vec![old_actor, old_tuple];
-    let new_types = vec![new_actor, new_tuple];
-    assert!(!are_compatible(heap, old_types, new_types));
-}
-
-unsafe fn test_removed_variant_fields(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("VariantField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-
-    let field1 = Field {
-        name: String::from("Field1"),
-        field_type: TypeReference::int8(),
-    };
-    let field2 = Field {
-        name: String::from("Field2"),
-        field_type: TypeReference::int16(),
-    };
-    let field3 = Field {
-        name: String::from("Field3"),
-        field_type: TypeReference::int32(),
-    };
-
-    let old_variant = Type::Variant(FieldList {
-        fields: vec![field1.clone(), field2.clone(), field3.clone()],
-    });
-    let new_variant = Type::Variant(FieldList {
-        fields: vec![field2.clone()],
-    });
-
-    let old_types = vec![main_actor.clone(), old_variant];
-    let new_types = vec![main_actor.clone(), new_variant];
-    assert!(!are_compatible(heap, old_types, new_types));
-}
-
-unsafe fn test_any_to_some(heap: &mut TestMemory) {
-    let old_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("Field"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let any_type = Type::Any;
-    let new_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("Field"),
-            field_type: TypeReference::text(),
-        }],
-    });
-    let old_types = vec![old_actor, any_type];
-    let new_types = vec![new_actor];
-    assert!(!are_compatible(heap, old_types, new_types));
-}
-
-unsafe fn test_any_to_none(heap: &mut TestMemory) {
-    let old_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("Field"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let any_type = Type::Any;
-    let new_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("Field"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let none_type = Type::None;
-    let old_types = vec![old_actor, any_type];
-    let new_types = vec![new_actor, none_type];
-    assert!(!are_compatible(heap, old_types, new_types));
-}
-
-unsafe fn test_mismatching_function_sort(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("FunctionField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let parameter_types = TypeList {
-        items: vec![TypeReference::nat()],
-    };
-    let return_types = TypeList {
-        items: vec![TypeReference::int()],
-    };
-    let old_function = Type::Function(FunctionSignature {
-        sort: FunctionSort::Query,
-        parameter_types: parameter_types.clone(),
-        return_types: return_types.clone(),
-    });
-    let new_function = Type::Function(FunctionSignature {
-        sort: FunctionSort::Write,
-        parameter_types: parameter_types.clone(),
-        return_types: return_types.clone(),
-    });
-    let old_types = vec![main_actor.clone(), old_function];
-    let new_types = vec![main_actor.clone(), new_function];
-    assert!(!are_compatible(heap, old_types, new_types));
-}
-
-unsafe fn test_mismatching_parameters(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("FunctionField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let old_parameter_types = TypeList {
-        items: vec![TypeReference::nat()],
-    };
-    let new_parameter_types = TypeList {
-        items: vec![TypeReference::text()],
-    };
-    let return_types = TypeList {
-        items: vec![TypeReference::int()],
-    };
-    let sort = FunctionSort::Query;
-    let old_function = Type::Function(FunctionSignature {
-        sort: sort.clone(),
-        parameter_types: old_parameter_types,
-        return_types: return_types.clone(),
-    });
-    let new_function = Type::Function(FunctionSignature {
-        sort: sort.clone(),
-        parameter_types: new_parameter_types,
-        return_types: return_types.clone(),
-    });
-    let old_types = vec![main_actor.clone(), old_function];
-    let new_types = vec![main_actor.clone(), new_function];
-    assert!(!are_compatible(heap, old_types, new_types));
-}
-
-unsafe fn test_mismatching_parameter_count(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("FunctionField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let old_parameter_types = TypeList {
-        items: vec![TypeReference::nat()],
-    };
-    let new_parameter_types = TypeList { items: vec![] };
-    let return_types = TypeList {
-        items: vec![TypeReference::int()],
-    };
-    let sort = FunctionSort::Query;
-    let old_function = Type::Function(FunctionSignature {
-        sort: sort.clone(),
-        parameter_types: old_parameter_types,
-        return_types: return_types.clone(),
-    });
-    let new_function = Type::Function(FunctionSignature {
-        sort: sort.clone(),
-        parameter_types: new_parameter_types,
-        return_types: return_types.clone(),
-    });
-    let old_types = vec![main_actor.clone(), old_function];
-    let new_types = vec![main_actor.clone(), new_function];
-    assert!(!are_compatible(heap, old_types, new_types));
-}
-
-unsafe fn test_mismatching_return_types(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("FunctionField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let parameter_types = TypeList {
-        items: vec![TypeReference::nat()],
-    };
-    let old_return_types = TypeList {
-        items: vec![TypeReference::int()],
-    };
-    let new_return_types = TypeList {
-        items: vec![TypeReference::text()],
-    };
-    let sort = FunctionSort::Query;
-    let old_function = Type::Function(FunctionSignature {
-        sort: sort.clone(),
-        parameter_types: parameter_types.clone(),
-        return_types: old_return_types,
-    });
-    let new_function = Type::Function(FunctionSignature {
-        sort: sort.clone(),
-        parameter_types: parameter_types.clone(),
-        return_types: new_return_types,
-    });
-    let old_types = vec![main_actor.clone(), old_function];
-    let new_types = vec![main_actor.clone(), new_function];
-    assert!(!are_compatible(heap, old_types, new_types));
-}
-
-unsafe fn test_mismatching_return_count(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("FunctionField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let parameter_types = TypeList {
-        items: vec![TypeReference::nat()],
-    };
-    let old_return_types = TypeList {
-        items: vec![TypeReference::int()],
-    };
-    let new_return_types = TypeList { items: vec![] };
-    let sort = FunctionSort::Query;
-    let old_function = Type::Function(FunctionSignature {
-        sort: sort.clone(),
-        parameter_types: parameter_types.clone(),
-        return_types: old_return_types,
-    });
-    let new_function = Type::Function(FunctionSignature {
-        sort: sort.clone(),
-        parameter_types: parameter_types.clone(),
-        return_types: new_return_types,
-    });
-    let old_types = vec![main_actor.clone(), old_function];
-    let new_types = vec![main_actor.clone(), new_function];
-    assert!(!are_compatible(heap, old_types, new_types));
-}
-
-unsafe fn test_invalid_result_variance(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("FunctionField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let parameter_types = TypeList {
-        items: vec![TypeReference::nat(), TypeReference::bool()],
-    };
-    let return_types = TypeList {
-        items: vec![TypeReference { index: 2 }],
-    };
-    let sort = FunctionSort::Composite;
-    let function = Type::Function(FunctionSignature {
-        sort,
-        parameter_types,
-        return_types,
-    });
-
-    let field1 = Field {
-        name: String::from("Field1"),
-        field_type: TypeReference::int8(),
-    };
-    let field2 = Field {
-        name: String::from("Field2"),
-        field_type: TypeReference::int16(),
-    };
-
-    let old_object = Type::Actor(FieldList {
-        fields: vec![field1.clone()],
-    });
-    let new_object = Type::Actor(FieldList {
-        fields: vec![field1.clone(), field2.clone()],
-    });
-
-    let old_types = vec![main_actor.clone(), function.clone(), old_object];
-    let new_types = vec![main_actor.clone(), function.clone(), new_object];
-    assert!(!are_compatible(heap, old_types, new_types));
-}
-
-unsafe fn test_invalid_parameter_variance(heap: &mut TestMemory) {
-    let main_actor = Type::Object(FieldList {
-        fields: vec![Field {
-            name: String::from("FunctionField"),
-            field_type: TypeReference { index: 1 },
-        }],
-    });
-    let parameter_types = TypeList {
-        items: vec![TypeReference { index: 2 }],
-    };
-    let return_types = TypeList { items: vec![] };
-    let sort = FunctionSort::Composite;
-    let function = Type::Function(FunctionSignature {
-        sort,
-        parameter_types,
-        return_types,
-    });
-
-    let field1 = Field {
-        name: String::from("Field1"),
-        field_type: TypeReference::int8(),
-    };
-    let field2 = Field {
-        name: String::from("Field2"),
-        field_type: TypeReference::int16(),
-    };
-
-    let old_object = Type::Actor(FieldList {
-        fields: vec![field1.clone(), field2.clone()],
-    });
-    let new_object = Type::Actor(FieldList {
-        fields: vec![field2.clone()],
-    });
-
-    let old_types = vec![main_actor.clone(), function.clone(), old_object];
-    let new_types = vec![main_actor.clone(), function.clone(), new_object];
-    assert!(!are_compatible(heap, old_types, new_types));
-}
diff --git a/rts/motoko-rts/src/gc/incremental/roots.rs b/rts/motoko-rts/src/gc/incremental/roots.rs
index f2bd7ba4e47..5d2731b41a7 100644
--- a/rts/motoko-rts/src/gc/incremental/roots.rs
+++ b/rts/motoko-rts/src/gc/incremental/roots.rs
@@ -9,20 +9,21 @@ use crate::{types::Value, visitor::is_pointer_field};
 static mut STATIC_ROOT: Value = Value::from_scalar(0);
 
 /// GC root set.
-pub type Roots = [*mut Value; 6];
+pub type Roots = [*mut Value; 7];
 
 #[cfg(feature = "ic")]
 pub unsafe fn root_set() -> Roots {
     use crate::{
         continuation_table::continuation_table_loc,
-        persistence::{null_singleton_location, stable_actor_location, stable_type_location},
+        persistence::{null_singleton_location, stable_actor_location, stable_type_descriptor},
         region::region0_get_ptr_loc,
     };
     [
         static_root_location(),
         continuation_table_loc(),
         stable_actor_location(),
-        stable_type_location(),
+        stable_type_descriptor().candid_data_location(),
+        stable_type_descriptor().type_offsets_location(),
         null_singleton_location(),
         region0_get_ptr_loc(),
     ]
diff --git a/rts/motoko-rts/src/idl.rs b/rts/motoko-rts/src/idl.rs
index fa291835b7f..4fb356e74dc 100644
--- a/rts/motoko-rts/src/idl.rs
+++ b/rts/motoko-rts/src/idl.rs
@@ -539,8 +539,16 @@ unsafe fn is_opt_reserved(typtbl: *mut *mut u8, end: *mut u8, t: i32) -> bool {
     return t == IDL_CON_opt;
 }
 
+#[derive(Clone, Copy)]
+pub enum CompatibilityMode {
+    // Conventional Candid deserialization compatibility.
+    Candid,
+    // Memory compatibility for orthogonal persistence.
+    Persistence,
+}
+
 // TODO: consider storing fixed args typtbl1...end2 in `rel` to use less stack.
-unsafe fn sub(
+pub(crate) unsafe fn sub(
     rel: &BitRel,
     p: bool,
     typtbl1: *mut *mut u8,
@@ -549,6 +557,7 @@ unsafe fn sub(
     end2: *mut u8,
     t1: i32,
     t2: i32,
+    mode: CompatibilityMode,
 ) -> bool {
     if t1 >= 0 && t2 >= 0 {
         let t1 = t1 as u32;
@@ -604,15 +613,48 @@ unsafe fn sub(
     // exit either via 'return true' or 'break 'return_false' to memoize the negative result
     'return_false: loop {
         match (u1, u2) {
-            (_, IDL_CON_alias) | (IDL_CON_alias, _) => idl_trap_with("sub: unexpected alias"),
-            (_, IDL_PRIM_reserved)
-            | (IDL_PRIM_empty, _)
-            | (IDL_PRIM_nat, IDL_PRIM_int)
-            | (_, IDL_CON_opt) => return true, // apparently, this is admissable
+            (IDL_CON_alias, IDL_CON_alias) => match mode {
+                CompatibilityMode::Candid => idl_trap_with("sub: unexpected alias"),
+                CompatibilityMode::Persistence => {
+                    let t11 = sleb128_decode(&mut tb1);
+                    let t21 = sleb128_decode(&mut tb2);
+                    // invariance
+                    if sub(rel, p, typtbl1, typtbl2, end1, end2, t11, t21, mode)
+                        && sub(rel, !p, typtbl2, typtbl1, end2, end1, t21, t11, mode)
+                    {
+                        return true;
+                    } else {
+                        break 'return_false;
+                    }
+                }
+            },
+            (_, IDL_PRIM_reserved) | (IDL_PRIM_empty, _) | (IDL_PRIM_nat, IDL_PRIM_int) => {
+                return true
+            }
+            (_, IDL_CON_alias) | (IDL_CON_alias, _) => match mode {
+                CompatibilityMode::Candid => idl_trap_with("sub: unexpected alias"),
+                CompatibilityMode::Persistence => return false,
+            },
+            (IDL_CON_opt, IDL_CON_opt) => match mode {
+                CompatibilityMode::Candid => return true,
+                CompatibilityMode::Persistence => {
+                    let t11 = sleb128_decode(&mut tb1);
+                    let t21 = sleb128_decode(&mut tb2);
+                    if sub(rel, p, typtbl1, typtbl2, end1, end2, t11, t21, mode) {
+                        return true;
+                    } else {
+                        break 'return_false;
+                    }
+                }
+            },
+            (_, IDL_CON_opt) => match mode {
+                CompatibilityMode::Candid => return true,
+                CompatibilityMode::Persistence => return false,
+            },
             (IDL_CON_vec, IDL_CON_vec) => {
                 let t11 = sleb128_decode(&mut tb1);
                 let t21 = sleb128_decode(&mut tb2);
-                if sub(rel, p, typtbl1, typtbl2, end1, end2, t11, t21) {
+                if sub(rel, p, typtbl1, typtbl2, end1, end2, t11, t21, mode) {
                     return true;
                 } else {
                     break 'return_false;
@@ -632,7 +674,7 @@ unsafe fn sub(
                         let t21 = sleb128_decode(&mut tb2);
                         in2 -= 1;
                         // NB: invert p and args!
-                        if !sub(rel, !p, typtbl2, typtbl1, end2, end1, t21, t11) {
+                        if !sub(rel, !p, typtbl2, typtbl1, end2, end1, t21, t11, mode) {
                             break 'return_false;
                         }
                     }
@@ -653,7 +695,7 @@ unsafe fn sub(
                     } else {
                         let t11 = sleb128_decode(&mut tb1);
                         out1 -= 1;
-                        if !sub(rel, p, typtbl1, typtbl2, end1, end2, t11, t21) {
+                        if !sub(rel, p, typtbl1, typtbl2, end1, end2, t11, t21, mode) {
                             break 'return_false;
                         }
                     }
@@ -728,7 +770,7 @@ unsafe fn sub(
                         advance = false; // reconsider this field in next round
                         continue;
                     };
-                    if !sub(rel, p, typtbl1, typtbl2, end1, end2, t11, t21) {
+                    if !sub(rel, p, typtbl1, typtbl2, end1, end2, t11, t21, mode) {
                         break 'return_false;
                     }
                     advance = true;
@@ -757,7 +799,7 @@ unsafe fn sub(
                     if tag1 != tag2 {
                         break 'return_false;
                     };
-                    if !sub(rel, p, typtbl1, typtbl2, end1, end2, t11, t21) {
+                    if !sub(rel, p, typtbl1, typtbl2, end1, end2, t11, t21, mode) {
                         break 'return_false;
                     }
                 }
@@ -791,7 +833,7 @@ unsafe fn sub(
                     if cmp != 0 {
                         break 'return_false;
                     };
-                    if !sub(rel, p, typtbl1, typtbl2, end1, end2, t11, t21) {
+                    if !sub(rel, p, typtbl1, typtbl2, end1, end2, t11, t21, mode) {
                         break 'return_false;
                     }
                 }
@@ -859,5 +901,6 @@ unsafe extern "C" fn idl_sub(
         typtbl_end2,
         t1,
         t2,
+        CompatibilityMode::Candid,
     );
 }
diff --git a/rts/motoko-rts/src/lib.rs b/rts/motoko-rts/src/lib.rs
index 13460d9c30e..f03862f1b1b 100644
--- a/rts/motoko-rts/src/lib.rs
+++ b/rts/motoko-rts/src/lib.rs
@@ -31,6 +31,7 @@ mod idl;
 pub mod leb128;
 mod mem_utils;
 pub mod memory;
+#[cfg(feature = "ic")]
 pub mod persistence;
 pub mod principal_id;
 #[cfg(feature = "ic")]
diff --git a/rts/motoko-rts/src/mem_utils.rs b/rts/motoko-rts/src/mem_utils.rs
index b71d1b8d253..37b1d07e1ce 100644
--- a/rts/motoko-rts/src/mem_utils.rs
+++ b/rts/motoko-rts/src/mem_utils.rs
@@ -12,6 +12,7 @@ pub(crate) unsafe fn memzero(to: usize, n: Words<u32>) {
     libc::memset(to as *mut _, 0, n.to_bytes().as_usize());
 }
 
+#[cfg(feature = "ic")]
 pub(crate) unsafe fn memzero_bytes(to: usize, n: Bytes<u32>) {
     libc::memset(to as *mut _, 0, n.as_usize());
 }
diff --git a/rts/motoko-rts/src/persistence.rs b/rts/motoko-rts/src/persistence.rs
index 8c8fc83b600..0cf79e1f937 100644
--- a/rts/motoko-rts/src/persistence.rs
+++ b/rts/motoko-rts/src/persistence.rs
@@ -11,9 +11,12 @@ use crate::{
     gc::incremental::State,
     memory::Memory,
     persistence::compatibility::memory_compatible,
+    rts_trap_with,
     types::{size_of, Null, Value, TAG_BLOB, TAG_NULL},
 };
 
+use self::compatibility::TypeDescriptor;
+
 #[cfg(feature = "ic")]
 const FINGERPRINT: [char; 32] = [
     'M', 'O', 'T', 'O', 'K', 'O', ' ', 'O', 'R', 'T', 'H', 'O', 'G', 'O', 'N', 'A', 'L', ' ', 'P',
@@ -37,9 +40,9 @@ struct PersistentMetadata {
     /// Reference to the stable sub-record of the actor, comprising all stable actor fields. Set before upgrade.
     /// Constitutes a GC root and requires pointer forwarding.
     stable_actor: Value,
-    /// Reference to the stable type descriptor blob, serving for heap compatibility checks on upgrades.
-    /// Constitutes a GC root and requires pointer forwarding.
-    stable_type: Value,
+    /// Reference to the stable type descriptor, serving for heap compatibility checks on upgrades.
+    /// The blob in the descriptor serves as a GC root and requires pointer forwarding.
+    stable_type: TypeDescriptor,
     /// The state of the incremental GC including the partitioned heap description.
     /// The GC continues work after upgrades.
     incremental_gc_state: State,
@@ -71,7 +74,7 @@ impl PersistentMetadata {
             initialized
                 || (*self).fingerprint == ['\0'; 32]
                     && (*self).stable_actor == DEFAULT_VALUE
-                    && (*self).stable_type == DEFAULT_VALUE
+                    && (*self).stable_type.is_default()
                     && (*self).null_singleton == DEFAULT_VALUE
         );
         initialized
@@ -95,7 +98,7 @@ impl PersistentMetadata {
         (*self).fingerprint = FINGERPRINT;
         (*self).version = VERSION;
         (*self).stable_actor = DEFAULT_VALUE;
-        (*self).stable_type = DEFAULT_VALUE;
+        (*self).stable_type = TypeDescriptor::default();
         (*self).incremental_gc_state = IncrementalGC::initial_gc_state(mem, HEAP_START);
         (*self).null_singleton = DEFAULT_VALUE;
     }
@@ -128,7 +131,7 @@ unsafe fn allocate_initial_objects<M: Memory>(mem: &mut M) {
 #[no_mangle]
 pub unsafe extern "C" fn load_stable_actor() -> Value {
     let metadata = PersistentMetadata::get();
-    assert!((*metadata).stable_type.forward_if_possible() != DEFAULT_VALUE);
+    (*metadata).stable_type.assert_initialized();
     (*metadata).stable_actor.forward_if_possible()
 }
 
@@ -137,7 +140,7 @@ pub unsafe extern "C" fn load_stable_actor() -> Value {
 pub unsafe fn save_stable_actor<M: Memory>(mem: &mut M, actor: Value) {
     assert!(actor != DEFAULT_VALUE);
     let metadata: *mut PersistentMetadata = PersistentMetadata::get();
-    assert!((*metadata).stable_type.forward_if_possible() != DEFAULT_VALUE);
+    (*metadata).stable_type.assert_initialized();
     let location = &mut (*metadata).stable_actor as *mut Value;
     write_with_barrier(mem, location, actor);
 }
@@ -195,22 +198,26 @@ pub unsafe fn allocate_null<M: Memory>(mem: &mut M) -> Value {
 /// On an upgrade, the memory compatibility between the new and existing stable type is checked.
 /// The `new_type` value points to a blob encoding the new stable actor type.
 #[ic_mem_fn]
-pub unsafe fn register_stable_type<M: Memory>(mem: &mut M, new_type: Value) {
-    assert_eq!(new_type.tag(), TAG_BLOB);
+pub unsafe fn register_stable_type<M: Memory>(
+    mem: &mut M,
+    new_candid_data: Value,
+    new_type_offsets: Value,
+    new_actor_index: i32,
+) {
+    assert_eq!(new_candid_data.tag(), TAG_BLOB);
+    let mut new_type = TypeDescriptor::new(new_candid_data, new_type_offsets, new_actor_index);
     let metadata = PersistentMetadata::get();
-    let old_type = (*metadata).stable_type.forward_if_possible();
-    if old_type != DEFAULT_VALUE && !memory_compatible(mem, old_type, new_type) {
-        panic!("Memory-incompatible program upgrade");
+    let old_type = &mut (*metadata).stable_type;
+    if !old_type.is_default() && !memory_compatible(mem, old_type, &mut new_type) {
+        rts_trap_with("Memory-incompatible program upgrade");
     }
-    let location = &mut (*metadata).stable_type as *mut Value;
-    write_with_barrier(mem, location, new_type);
+    (*metadata).stable_type.assign(mem, &new_type);
 }
 
-/// GC root pointer required for GC marking and updating.
 #[cfg(feature = "ic")]
-pub(crate) unsafe fn stable_type_location() -> *mut Value {
+pub(crate) unsafe fn stable_type_descriptor() -> &'static mut TypeDescriptor {
     let metadata = PersistentMetadata::get();
-    &mut (*metadata).stable_type as *mut Value
+    &mut (*metadata).stable_type
 }
 
 /// Get the null singleton used for top-level optional types.
@@ -233,7 +240,6 @@ pub(crate) unsafe fn null_singleton_location() -> *mut Value {
     &mut (*metadata).null_singleton as *mut Value
 }
 
-// GC root pointer required for GC marking and updating.
 #[cfg(feature = "ic")]
 pub(crate) unsafe fn get_incremental_gc_state() -> &'static mut State {
     let metadata = PersistentMetadata::get();
diff --git a/rts/motoko-rts/src/persistence/compatibility.rs b/rts/motoko-rts/src/persistence/compatibility.rs
index 8f03def62aa..fbcf826cb95 100644
--- a/rts/motoko-rts/src/persistence/compatibility.rs
+++ b/rts/motoko-rts/src/persistence/compatibility.rs
@@ -1,689 +1,159 @@
 //! Persistent type compatibility check.
 //! Determines whether the a new actor type is compatible with the existing persistent state.
-//!
-//! This is determined by focusing on the stable actor fields (comprised in `stable_actor`).
-//!
-//! To be compatible, all the fields of an actor must be compatible to the previous state.
-//! A field is compatible if at least one of the condition holds:
-//! * The field is declared flexible, i.e. not stable, in the previous or new actor version.
-//! * The previous actor does not contain a field with that same name.
-//! * The field type is compatible to the type of the equally named field in the previous version.
-//!
-//! A new type is compatible to a previous type if
-//! * the types are identical
-//! * The new type is sub-type of the previous field.
-//!
-//! The existing sub-type relations are also memory-compatible at the runtime system level:
-//! * Nat can be interpreted as Int.
-//! * If record fields are dropped in a declaration, old records with more fields can still
-//!   be accessed.
-//!   -> However, redundant old fields should be removed in the future, e.g. by the GC.
-//! * Variant options can be added, without invalidating the existing variant tags.
-//!
-//! Binary format of the stable type encoding, generated by the Motoko compiler backend, `persistence.ml`.
-//!
-//! All composed non-primitive types are encoded in a table without defined order, except for the
-//! first entry.
-//! The first type in the table denotes the stable sub-type of the actor, ie. all its stable field
-//! declarations, without option wrapping.
-//!
-//! Non-primitive types are referred to by a positive index according to the type table.
-//! Primitive types are encoded by predefined negative indices.
-//! All numbers (type indices etc.) are encoded as little endian i32.
-//!
-//! ```
-//! <type_table> ::= length:i32 (<type>)^length
-//! <type> ::= <object> | <actor> | <function> | <mutable> | <option> | <array> | <tuple> | <variant> | <none> | <any>
-//! <object> ::= 1l <field_list>
-//! <actor> ::= 2l <field_list>
-//! <function> ::= 3l function_sort:i32 <type_list> <type_list>
-//! <mutable> ::= 4l type_index:i32
-//! <option> ::= 5l type_index:i32
-//! <array> ::= 6l type_index:i32
-//! <tuple> ::= 7l length:i32 (type_index:i32)^length
-//! <variant> ::= 8l <field_list>
-//! <none> ::= 9l
-//! <any> ::= 10l
-//! <field_list> ::= length:i32 (<field>)^length
-//! <field> ::= label_hash:i32 type_index:i32
-//! <type_list> ::= length:i32 <type_index:i32>^length
-//! ```
-//!
-//! Predefined primitive type indices
-//! Type      | Index
-//! --------- | --------
-//! Null      | -1l
-//! Bool      | -2l
-//! Nat       | -3l
-//! Nat8      | -4l
-//! Nat16     | -5l
-//! Nat32     | -6l
-//! Nat64     | -7l
-//! Int       | -8l
-//! Int8      | -9l
-//! Int16     | -10l
-//! Int32     | -11l
-//! Int64     | -12l
-//! Float     | -13l
-//! Char      | -14l
-//! Text      | -15l
-//! Blob      | -16l
-//! Principal | -17l
-//! Region    | -18l
-//!
-//! Function sort
-//! Sort      | Encoding
-//! --------- | ---------
-//! Query     | 1l
-//! Write     | 2l
-//! Composite | 3l
-
-use core::mem::swap;
+//! Engages the existing IDL subtype check functionality.
 
 use crate::{
-    mem_utils::memzero_bytes,
+    barriers::write_with_barrier,
+    bitrel::BitRel,
+    constants::WORD_SIZE,
     memory::{alloc_blob, Memory},
-    types::{size_of, Bytes, Value},
+    types::{Value, Words},
 };
 
-pub const OBJECT_ENCODING_TAG: i32 = 1;
-pub const ACTOR_ENCODING_TAG: i32 = 2;
-pub const FUNCTION_ENCODING_TAG: i32 = 3;
-pub const MUTABLE_ENCODING_TAG: i32 = 4;
-pub const OPTION_ENCODING_TAG: i32 = 5;
-pub const ARRAY_ENCODING_TAG: i32 = 6;
-pub const TUPLE_ENCODING_TAG: i32 = 7;
-pub const VARIANT_ENCODING_TAG: i32 = 8;
-pub const NONE_ENCODING_TAG: i32 = 9;
-pub const ANY_ENCODING_TAG: i32 = 10;
-
-const ACTOR_TYPE_INDEX: i32 = 0;
-
-const TYPE_TAG_LENGTH: usize = 1;
-const FUNCTION_SORT_LENGTH: usize = 1;
-const LENGTH_HEADER: usize = 1;
-const TYPE_INDEX_LENGTH: usize = 1;
-const FIELD_ENCODING_LENGTH: usize = 2; // label_hash type_index
-
-const NAT_TYPE_INDEX: i32 = -3;
-const INT_TYPE_INDEX: i32 = -8;
+const DEFAULT_VALUE: Value = Value::from_scalar(0);
 
-struct EncodedData {
-    words: *const i32,
-    size: usize,
+pub struct TypeDescriptor {
+    // Blob with candid-encoded type defintions.
+    candid_data: Value,
+    // Blob with a list of `u32` offsets referring to the `candid_data`.
+    type_offsets: Value,
+    // Type index of the main actor to the compared for memory compatibility.
+    main_actor_index: i32,
 }
 
-impl EncodedData {
-    pub fn new(words: *const i32, size: usize) -> EncodedData {
-        EncodedData { words, size }
-    }
-
-    unsafe fn read(&self, offset: usize) -> i32 {
-        assert!(offset < self.size);
-        let location = self.words.add(offset);
-        *location
-    }
-
-    unsafe fn sub_view(&self, offset: usize) -> EncodedData {
-        assert!(offset <= self.size);
-        EncodedData {
-            words: self.words.add(offset),
-            size: self.size - offset,
+impl TypeDescriptor {
+    pub fn default() -> Self {
+        Self {
+            candid_data: DEFAULT_VALUE,
+            type_offsets: DEFAULT_VALUE,
+            main_actor_index: 0,
         }
     }
-}
-
-struct TypeTable {
-    data: EncodedData,
-}
-
-impl TypeTable {
-    unsafe fn new(value: Value) -> TypeTable {
-        let blob = value.as_blob();
-        assert_eq!(blob.len().as_usize() % size_of::<i32>().as_usize(), 0);
-        let words = blob.payload_const() as *const i32;
-        let size = blob.len().as_usize() / size_of::<i32>().to_bytes().as_usize();
-        let data = EncodedData::new(words, size);
-        TypeTable { data }
-    }
-
-    unsafe fn count_types(&self) -> usize {
-        let count = self.data.read(0);
-        assert!(count >= 0);
-        count as usize
-    }
 
-    unsafe fn get_type(&self, type_index: i32) -> Type {
-        assert!(type_index >= 0);
-        assert!(type_index <= self.count_types() as i32);
-        let mut start = 1;
-        for _ in 0..type_index {
-            let type_view = self.data.sub_view(start);
-            start += Type::size(type_view);
+    pub unsafe fn new(
+        candid_data: Value,
+        type_offsets: Value,
+        main_actor_index: i32,
+    ) -> TypeDescriptor {
+        Self {
+            candid_data: candid_data.forward_if_possible(),
+            type_offsets: type_offsets.forward_if_possible(),
+            main_actor_index,
         }
-        let type_view = self.data.sub_view(start);
-        Type::get_type(type_view)
-    }
-
-    unsafe fn get_actor_fields(&self) -> FieldList {
-        match self.get_type(ACTOR_TYPE_INDEX) {
-            Type::Object(field_list) => field_list,
-            _ => panic!("Invalid stable type encoding"),
-        }
-    }
-}
-
-enum Type {
-    Object(FieldList),
-    Actor(FieldList),
-    Function(FunctionSignature),
-    Mutable(TypeIndex),
-    Option(TypeIndex),
-    Array(TypeIndex),
-    Tuple(TypeList),
-    Variant(FieldList),
-    None,
-    Any,
-}
-
-impl Type {
-    unsafe fn size(data: EncodedData) -> usize {
-        TYPE_TAG_LENGTH
-            + match Self::get_type(data) {
-                Self::Object(field_list) => field_list.size(),
-                Self::Actor(field_list) => field_list.size(),
-                Self::Function(signature) => signature.size(),
-                Self::Mutable(type_index) => type_index.size(),
-                Self::Option(type_index) => type_index.size(),
-                Self::Array(type_index) => type_index.size(),
-                Self::Tuple(tuple_list) => tuple_list.size(),
-                Self::Variant(field_list) => field_list.size(),
-                Self::None | Self::Any => 0,
-            }
-    }
-
-    unsafe fn get_type(data: EncodedData) -> Type {
-        let tag = data.read(0);
-        let data = data.sub_view(TYPE_TAG_LENGTH);
-        match tag {
-            OBJECT_ENCODING_TAG => Self::Object(FieldList::new(data)),
-            ACTOR_ENCODING_TAG => Self::Actor(FieldList::new(data)),
-            FUNCTION_ENCODING_TAG => Self::Function(FunctionSignature::new(data)),
-            MUTABLE_ENCODING_TAG => Self::Mutable(TypeIndex::new(data)),
-            OPTION_ENCODING_TAG => Self::Option(TypeIndex::new(data)),
-            ARRAY_ENCODING_TAG => Self::Array(TypeIndex::new(data)),
-            TUPLE_ENCODING_TAG => Self::Tuple(TypeList::new(data)),
-            VARIANT_ENCODING_TAG => Self::Variant(FieldList::new(data)),
-            NONE_ENCODING_TAG => Self::None,
-            ANY_ENCODING_TAG => Self::Any,
-            _ => unreachable!(),
-        }
-    }
-}
-
-struct FieldList {
-    data: EncodedData,
-}
-
-impl FieldList {
-    unsafe fn new(data: EncodedData) -> FieldList {
-        FieldList { data }
-    }
-
-    unsafe fn size(&self) -> usize {
-        LENGTH_HEADER + self.count_fields() * FIELD_ENCODING_LENGTH
-    }
-
-    unsafe fn count_fields(&self) -> usize {
-        let count = self.data.read(0);
-        assert!(count >= 0);
-        count as usize
-    }
-
-    unsafe fn get_field(&self, field_index: usize) -> Field {
-        let field_offset = LENGTH_HEADER + field_index * FIELD_ENCODING_LENGTH;
-        let label_hash = self.data.read(field_offset);
-        let type_index = self.data.read(field_offset + 1);
-        Field {
-            label_hash,
-            type_index,
-        }
-    }
-
-    unsafe fn find_field(&self, label_hash: i32) -> Option<Field> {
-        for field_index in 0..self.count_fields() {
-            let field = self.get_field(field_index);
-            if field.label_hash == label_hash {
-                return Some(field);
-            }
-        }
-        None
-    }
-}
-
-struct Field {
-    label_hash: i32,
-    type_index: i32,
-}
-
-struct TypeList {
-    data: EncodedData,
-}
-
-impl TypeList {
-    unsafe fn new(data: EncodedData) -> TypeList {
-        TypeList { data }
-    }
-
-    unsafe fn size(&self) -> usize {
-        LENGTH_HEADER + self.count_items() * TYPE_INDEX_LENGTH
-    }
-
-    unsafe fn count_items(&self) -> usize {
-        let count = self.data.read(0);
-        assert!(count >= 0);
-        count as usize
-    }
-
-    unsafe fn get_item(&self, item_index: usize) -> TypeIndex {
-        let item_offset = LENGTH_HEADER + item_index * TYPE_INDEX_LENGTH;
-        let type_index = self.data.read(item_offset);
-        TypeIndex { type_index }
-    }
-}
-
-struct TypeIndex {
-    type_index: i32,
-}
-
-impl TypeIndex {
-    unsafe fn new(data: EncodedData) -> TypeIndex {
-        let type_index = data.read(0);
-        TypeIndex { type_index }
-    }
-
-    unsafe fn size(&self) -> usize {
-        TYPE_INDEX_LENGTH
-    }
-}
-
-#[derive(PartialEq)]
-enum FunctionSort {
-    Query,
-    Write,
-    Composite,
-}
-
-pub const QUERY_FUNCTION_SORT: i32 = 1;
-pub const WRITE_FUNCTION_SORT: i32 = 2;
-pub const COMPOSITE_FUNCTION_SORT: i32 = 3;
-
-struct FunctionSignature {
-    data: EncodedData,
-}
-
-impl FunctionSignature {
-    unsafe fn new(data: EncodedData) -> FunctionSignature {
-        FunctionSignature { data }
     }
 
-    unsafe fn size(&self) -> usize {
-        self.return_types_offset() + LENGTH_HEADER + self.count_return_types() * TYPE_INDEX_LENGTH
+    // GC root if part of the persistent stable type
+    pub fn candid_data_location(&mut self) -> *mut Value {
+        &mut self.candid_data as *mut Value
     }
 
-    unsafe fn sort(&self) -> FunctionSort {
-        match self.data.read(0) {
-            QUERY_FUNCTION_SORT => FunctionSort::Query,
-            WRITE_FUNCTION_SORT => FunctionSort::Write,
-            COMPOSITE_FUNCTION_SORT => FunctionSort::Composite,
-            _ => unreachable!(),
-        }
-    }
-
-    unsafe fn count_parameters(&self) -> usize {
-        let count = self.data.read(FUNCTION_SORT_LENGTH);
-        assert!(count >= 0);
-        count as usize
+    // GC root when part of the persistent stable type
+    pub fn type_offsets_location(&mut self) -> *mut Value {
+        &mut self.type_offsets as *mut Value
     }
 
-    unsafe fn get_parameter(&self, index: usize) -> TypeIndex {
-        let offset = FUNCTION_SORT_LENGTH + LENGTH_HEADER + index * TYPE_INDEX_LENGTH;
-        let type_index = self.data.read(offset);
-        TypeIndex { type_index }
+    pub fn is_default(&self) -> bool {
+        self.candid_data == DEFAULT_VALUE
+            && self.type_offsets == DEFAULT_VALUE
+            && self.main_actor_index == 0
     }
 
-    unsafe fn return_types_offset(&self) -> usize {
-        FUNCTION_SORT_LENGTH + LENGTH_HEADER + self.count_parameters() * TYPE_INDEX_LENGTH
+    pub fn assert_initialized(&self) {
+        assert!(self.candid_data != DEFAULT_VALUE && self.type_offsets != DEFAULT_VALUE);
     }
 
-    unsafe fn count_return_types(&self) -> usize {
-        let offset = self.return_types_offset();
-        let count = self.data.read(offset);
-        assert!(count >= 0);
-        count as usize
+    pub unsafe fn assign<M: Memory>(&mut self, mem: &mut M, other: &TypeDescriptor) {
+        let candid_data_location = &mut self.candid_data as *mut Value;
+        write_with_barrier(mem, candid_data_location, other.candid_data);
+        let type_offsets_location = &mut self.type_offsets as *mut Value;
+        write_with_barrier(mem, type_offsets_location, other.type_offsets);
+        self.main_actor_index = other.main_actor_index;
     }
 
-    unsafe fn get_return_type(&self, index: usize) -> TypeIndex {
-        let offset = self.return_types_offset() + LENGTH_HEADER + index * TYPE_INDEX_LENGTH;
-        let type_index = self.data.read(offset);
-        TypeIndex { type_index }
+    pub unsafe fn type_count(&self) -> usize {
+        let blob_size = self.type_offsets.as_blob().len();
+        assert_eq!(blob_size.as_u32() % WORD_SIZE, 0);
+        blob_size.to_words().as_usize()
     }
-}
 
-/// Cache for remembering previous type compatibility checks.
-/// Necessary to avoid infinite loops on type recursion.
-/// Helpful to optimize repeated checks.
-struct TypeCheckCache {
-    bitmap: *mut u8,
-    count_new_types: usize,
-    count_old_types: usize,
-}
-
-impl TypeCheckCache {
-    pub unsafe fn new<M: Memory>(
-        mem: &mut M,
-        new_types: &TypeTable,
-        old_types: &TypeTable,
-    ) -> TypeCheckCache {
-        let count_new_types = new_types.count_types();
-        let count_old_types = old_types.count_types();
-        let bit_size = count_new_types * count_old_types;
-        let byte_size = Bytes((bit_size as u32 + u8::BITS - 1) / u8::BITS);
-        let blob = alloc_blob(mem, byte_size);
-        let bitmap = blob.as_blob_mut().payload_addr();
-        memzero_bytes(bitmap as usize, byte_size);
-        TypeCheckCache {
-            bitmap,
-            count_new_types,
-            count_old_types,
+    // NOTE: The resulting type table holds absolute pointers to `candid_data` and can only
+    // be used during a single IC message when no GC increment is running in between.
+    pub unsafe fn build_type_table<M: Memory>(&mut self, mem: &mut M) -> *mut *mut u8 {
+        let type_count = self.type_count();
+        let temporary_blob = alloc_blob(mem, Words(type_count as u32).to_bytes());
+        let offset_table = self.type_offsets.as_blob().payload_const() as *const u32;
+        let type_table = temporary_blob.as_blob_mut().payload_addr() as *mut *mut u8;
+        let candid_data = self.candid_data.as_blob_mut().payload_addr();
+        for index in 0..type_count {
+            let offset = *offset_table.add(index);
+            debug_assert!((offset as usize) < self.candid_length());
+            let entry = type_table.add(index);
+            *entry = candid_data.add(offset as usize);
         }
+        type_table
     }
 
-    pub unsafe fn visited(&self, new_type_index: i32, old_type_index: i32) -> bool {
-        let (byte, bit_index) = self.position(new_type_index, old_type_index);
-        (*byte >> bit_index) & 0b1 != 0
-    }
-
-    pub unsafe fn visit(&mut self, new_type_index: i32, old_type_index: i32) {
-        let (byte, bit_index) = self.position(new_type_index, old_type_index);
-        *byte |= 0b1 << bit_index;
+    pub unsafe fn candid_length(&self) -> usize {
+        self.candid_data.as_blob().len().as_usize()
     }
 
-    unsafe fn position(&self, new_type_index: i32, old_type_index: i32) -> (*mut u8, usize) {
-        assert!(new_type_index >= 0);
-        assert!(old_type_index >= 0);
-        assert!((new_type_index as usize) < self.count_new_types);
-        assert!((old_type_index as usize) < self.count_old_types);
-        let index = new_type_index as usize * self.count_old_types + old_type_index as usize;
-        let byte_index = index / u8::BITS as usize;
-        let bit_index = index % u8::BITS as usize;
-        let byte = self.bitmap.add(byte_index);
-        (byte, bit_index)
+    pub unsafe fn type_table_end(&mut self) -> *mut u8 {
+        self.candid_data
+            .as_blob_mut()
+            .payload_addr()
+            .add(self.candid_length())
     }
 }
 
-struct CompatibilityChecker {
-    covariance_cache: TypeCheckCache,
-    contravariance_cache: TypeCheckCache,
-    target_type_table: TypeTable,
-    source_type_table: TypeTable,
-}
-
-impl CompatibilityChecker {
-    unsafe fn new<M: Memory>(
-        mem: &mut M,
-        target_type_table: TypeTable,
-        source_type_table: TypeTable,
-    ) -> CompatibilityChecker {
-        let covariance_cache = TypeCheckCache::new(mem, &target_type_table, &source_type_table);
-        let contravariance_cache = TypeCheckCache::new(mem, &source_type_table, &target_type_table);
-        CompatibilityChecker {
-            covariance_cache,
-            contravariance_cache,
-            target_type_table,
-            source_type_table,
-        }
-    }
-
-    fn flip_variance(&mut self) {
-        swap(&mut self.covariance_cache, &mut self.contravariance_cache);
-        swap(&mut self.target_type_table, &mut self.source_type_table);
-    }
-
-    unsafe fn compatible_object_fields(
-        &mut self,
-        target_field_list: &FieldList,
-        source_field_list: &FieldList,
-    ) -> bool {
-        for field_index in 0..target_field_list.count_fields() {
-            let target_field = target_field_list.get_field(field_index);
-            match source_field_list.find_field(target_field.label_hash) {
-                None => {
-                    return false;
-                }
-                Some(source_field) => {
-                    if !self.type_compatible(target_field.type_index, source_field.type_index) {
-                        return false;
-                    }
-                }
-            }
-        }
-        true
-    }
-
-    unsafe fn compatible_variant_fields(
-        &mut self,
-        target_field_list: &FieldList,
-        source_field_list: &FieldList,
-    ) -> bool {
-        for field_index in 0..source_field_list.count_fields() {
-            let source_field = source_field_list.get_field(field_index);
-            match target_field_list.find_field(source_field.label_hash) {
-                None => {
-                    return false;
-                }
-                Some(target_field) => {
-                    if !self.type_compatible(target_field.type_index, source_field.type_index) {
-                        return false;
-                    }
-                }
-            }
-        }
-        true
-    }
-
-    unsafe fn compatible_type_indices(
-        &mut self,
-        target_type: &TypeIndex,
-        source_type: &TypeIndex,
-    ) -> bool {
-        self.type_compatible(target_type.type_index, source_type.type_index)
-    }
-
-    unsafe fn compatible_type_list(
-        &mut self,
-        target_tuple: &TypeList,
-        source_tuple: &TypeList,
-    ) -> bool {
-        let target_count = target_tuple.count_items();
-        let source_count = source_tuple.count_items();
-        if target_count != source_count {
-            return false;
-        }
-        for item_index in 0..target_count {
-            let new_item = target_tuple.get_item(item_index);
-            let old_item = source_tuple.get_item(item_index);
-            if !self.compatible_type_indices(&new_item, &old_item) {
-                return false;
-            }
-        }
-        true
-    }
-
-    unsafe fn compatible_functions(
-        &mut self,
-        target_signature: &FunctionSignature,
-        source_signature: &FunctionSignature,
-    ) -> bool {
-        target_signature.sort() == source_signature.sort()
-            && self.compatible_parameters(target_signature, source_signature)
-            && self.compatible_return_types(target_signature, source_signature)
-    }
-
-    unsafe fn compatible_parameters(
-        &mut self,
-        target_signature: &FunctionSignature,
-        source_signature: &FunctionSignature,
-    ) -> bool {
-        let target_count = target_signature.count_parameters();
-        let source_count = source_signature.count_parameters();
-        if target_count != source_count {
-            return false;
-        }
-        for index in 0..target_count {
-            let target_parameter = target_signature.get_parameter(index);
-            let source_parameter = source_signature.get_parameter(index);
-            // Contravariance
-            if !self.reverse_compatible(source_parameter.type_index, target_parameter.type_index) {
-                return false;
-            }
-        }
-        true
-    }
-
-    unsafe fn reverse_compatible(
-        &mut self,
-        source_type_index: i32,
-        target_type_index: i32,
-    ) -> bool {
-        self.flip_variance();
-        let result = self.type_compatible(source_type_index, target_type_index);
-        self.flip_variance();
-        result
-    }
-
-    unsafe fn compatible_return_types(
-        &mut self,
-        target_signature: &FunctionSignature,
-        source_signature: &FunctionSignature,
-    ) -> bool {
-        let target_count = target_signature.count_return_types();
-        let source_count = source_signature.count_return_types();
-        if target_count != source_count {
-            return false;
-        }
-        for index in 0..target_count {
-            let target_return_type = target_signature.get_return_type(index);
-            let source_return_type = source_signature.get_return_type(index);
-            // Covariance
-            if !self.type_compatible(target_return_type.type_index, source_return_type.type_index) {
-                return false;
-            }
-        }
-        true
-    }
-
-    unsafe fn compatible_primitives(
-        &mut self,
-        target_type_index: i32,
-        source_type_index: i32,
-    ) -> bool {
-        debug_assert!(target_type_index < 0 || source_type_index < 0);
-        if target_type_index == source_type_index {
-            return true;
-        }
-        if target_type_index == INT_TYPE_INDEX && source_type_index == NAT_TYPE_INDEX {
-            return true;
-        }
-        if target_type_index >= 0 {
-            if let Type::Any = self.target_type_table.get_type(target_type_index) {
-                return true;
-            }
-        }
-        false
-    }
-
-    unsafe fn identical_types(&mut self, target_type_index: i32, source_type_index: i32) -> bool {
-        self.type_compatible(target_type_index, source_type_index)
-            && self.reverse_compatible(source_type_index, target_type_index)
-    }
-
-    unsafe fn type_compatible(&mut self, target_type_index: i32, source_type_index: i32) -> bool {
-        if target_type_index < 0 || source_type_index < 0 {
-            return self.compatible_primitives(target_type_index, source_type_index);
-        }
-        if self
-            .covariance_cache
-            .visited(target_type_index, source_type_index)
-        {
-            return true;
-        }
-        self.covariance_cache
-            .visit(target_type_index, source_type_index);
-        let target_type = self.target_type_table.get_type(target_type_index);
-        let source_type = self.source_type_table.get_type(source_type_index);
-        match (&target_type, &source_type) {
-            (Type::Any, _) => true,
-            (Type::Object(new_fields), Type::Object(old_fields)) => {
-                self.compatible_object_fields(new_fields, old_fields)
-            }
-            (Type::Object(_), _) => false,
-            (Type::Actor(new_fields), Type::Actor(old_fields)) => {
-                self.compatible_object_fields(new_fields, old_fields)
-            }
-            (Type::Actor(_), _) => false,
-            (Type::Function(new_signature), Type::Function(old_signature)) => {
-                self.compatible_functions(new_signature, old_signature)
-            }
-            (Type::Function(_), _) => false,
-            (Type::Mutable(new_variable), Type::Mutable(old_variable)) => {
-                self.identical_types(new_variable.type_index, old_variable.type_index)
-            }
-            (Type::Mutable(_), _) => false,
-            (Type::Option(new_option), Type::Option(old_option)) => {
-                self.compatible_type_indices(new_option, old_option)
-            }
-            (Type::Option(_), _) => false,
-            (Type::Array(new_element), Type::Array(old_element)) => {
-                self.compatible_type_indices(new_element, old_element)
-            }
-            (Type::Array(_), _) => false,
-            (Type::Tuple(new_type_list), Type::Tuple(old_type_list)) => {
-                self.compatible_type_list(new_type_list, old_type_list)
-            }
-            (Type::Tuple(_), _) => false,
-            (Type::Variant(new_fields), Type::Variant(old_fields)) => {
-                self.compatible_variant_fields(new_fields, old_fields)
-            }
-            (Type::Variant(_), _) => false,
-            (Type::None, Type::None) => true,
-            (Type::None, _) => false,
-        }
-    }
-
-    unsafe fn compatible_main_actors(&mut self) -> bool {
-        let target_field_list = self.target_type_table.get_actor_fields();
-        let source_field_list = self.source_type_table.get_actor_fields();
-        for target_field_index in 0..target_field_list.count_fields() {
-            let target_field = target_field_list.get_field(target_field_index);
-            match source_field_list.find_field(target_field.label_hash) {
-                Some(source_field) => {
-                    if !self.type_compatible(target_field.type_index, source_field.type_index) {
-                        return false;
-                    }
-                }
-                None => {}
-            }
-        }
-        true
-    }
+unsafe fn create_type_check_cache<M: Memory>(
+    mem: &mut M,
+    old_type: &TypeDescriptor,
+    new_type: &TypeDescriptor,
+) -> BitRel {
+    let old_type_count = old_type.type_count() as u32;
+    let new_type_count = new_type.type_count() as u32;
+    let words = Words(BitRel::words(old_type_count, new_type_count));
+    let byte_length = words.to_bytes();
+    let blob_value = alloc_blob(mem, byte_length);
+    let ptr = blob_value.as_blob_mut().payload_addr() as *mut u32;
+    let end = blob_value
+        .as_blob()
+        .payload_const()
+        .add(byte_length.as_usize()) as *mut u32;
+    let cache = BitRel {
+        ptr,
+        end,
+        size1: old_type_count,
+        size2: new_type_count,
+    };
+    cache.init();
+    cache
 }
 
 /// Test whether the new stable type complies with the existing old stable type.
-/// Both arguments point to blobs encoding a stable actor type.
-pub unsafe fn memory_compatible<M: Memory>(mem: &mut M, old_type: Value, new_type: Value) -> bool {
-    let new_type_table = TypeTable::new(new_type);
-    let old_type_table = TypeTable::new(old_type);
-    let mut checker = CompatibilityChecker::new(mem, new_type_table, old_type_table);
-    checker.compatible_main_actors()
+/// This uses the existing IDL subtype test.
+pub unsafe fn memory_compatible<M: Memory>(
+    mem: &mut M,
+    old_type: &mut TypeDescriptor,
+    new_type: &mut TypeDescriptor,
+) -> bool {
+    let cache = create_type_check_cache(mem, old_type, new_type);
+
+    let old_type_table = old_type.build_type_table(mem);
+    let old_table_end = old_type.type_table_end();
+
+    let new_type_table = new_type.build_type_table(mem);
+    let new_table_end = new_type.type_table_end();
+
+    crate::idl::sub(
+        &cache,
+        true,
+        old_type_table,
+        new_type_table,
+        old_table_end,
+        new_table_end,
+        old_type.main_actor_index,
+        new_type.main_actor_index,
+        crate::idl::CompatibilityMode::Persistence,
+    )
 }
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index ae5ef3e9a7a..9e6998c2ed1 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -878,7 +878,7 @@ module RTS = struct
     E.add_func_import env "rts" "write_with_barrier" [I32Type; I32Type] [];
     E.add_func_import env "rts" "allocation_barrier" [I32Type] [I32Type];
     E.add_func_import env "rts" "running_gc" [] [I32Type];
-    E.add_func_import env "rts" "register_stable_type" [I32Type] [];
+    E.add_func_import env "rts" "register_stable_type" [I32Type; I32Type; I32Type] [];
     E.add_func_import env "rts" "load_stable_actor" [] [I32Type];
     E.add_func_import env "rts" "save_stable_actor" [I32Type] [];
     E.add_func_import env "rts" "free_stable_actor" [] [];
@@ -7588,8 +7588,12 @@ module Persistence = struct
   let free_stable_actor env = E.call_import env "rts" "free_stable_actor"
 
   let register_stable_type env actor_type =
-    let type_descriptor = Persistence.encode_stable_type actor_type in
-    Blob.lit env type_descriptor ^^
+    let (candid_type_desc, type_offsets, type_indices) = Serialization.type_desc env [actor_type] in
+    let serialized_offsets = StaticBytes.(as_bytes [i32s (List.map Int32.of_int type_offsets)]) in
+    assert ((List.length type_indices) = 1);
+    Blob.lit env candid_type_desc ^^
+    Blob.lit env serialized_offsets ^^
+    compile_unboxed_const (List.nth type_indices 0) ^^
     E.call_import env "rts" "register_stable_type"
 
   let create_actor env actor_type get_field_value =
diff --git a/test/bench/ok/bignum.drun-run-opt.ok b/test/bench/ok/bignum.drun-run-opt.ok
index 44b5dc64276..ecce60add17 100644
--- a/test/bench/ok/bignum.drun-run-opt.ok
+++ b/test/bench/ok/bignum.drun-run-opt.ok
@@ -2,5 +2,5 @@ ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a000000000000000001
 ingress Completed: Reply: 0x4449444c0000
 debug.print: {cycles = 2_414_305; size = +60_608}
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 103_321_340; size = +1_827_460}
+debug.print: {cycles = 103_321_396; size = +1_827_460}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/bignum.drun-run.ok b/test/bench/ok/bignum.drun-run.ok
index d06c8e2bdd6..ac06af40aba 100644
--- a/test/bench/ok/bignum.drun-run.ok
+++ b/test/bench/ok/bignum.drun-run.ok
@@ -2,5 +2,5 @@ ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a000000000000000001
 ingress Completed: Reply: 0x4449444c0000
 debug.print: {cycles = 2_519_086; size = +60_608}
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 103_375_825; size = +1_827_460}
+debug.print: {cycles = 103_375_885; size = +1_827_460}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/any-upgrades.drun.ok b/test/run-drun/ok/any-upgrades.drun.ok
index b343e97a038..74612ec48fa 100644
--- a/test/run-drun/ok/any-upgrades.drun.ok
+++ b/test/run-drun/ok/any-upgrades.drun.ok
@@ -3,6 +3,4 @@ ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
-debug.print: Memory-incompatible program upgrade
-debug.print: panic occurred in file 'src/persistence.rs' at line 203
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
diff --git a/test/run-drun/ok/array-upgrades.drun.ok b/test/run-drun/ok/array-upgrades.drun.ok
index 269f64e0702..05e09719101 100644
--- a/test/run-drun/ok/array-upgrades.drun.ok
+++ b/test/run-drun/ok/array-upgrades.drun.ok
@@ -19,12 +19,8 @@ debug.print: [var 1.000000, 2.000000, 3.000000, 4.000000]
 debug.print: [[1, 2, 3], [4, 5, 6]]
 debug.print: ?[null, ?[], ?[?[null, null], null]]
 ingress Completed: Reply: 0x4449444c0000
-debug.print: Memory-incompatible program upgrade
-debug.print: panic occurred in file 'src/persistence.rs' at line 203
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
-debug.print: Memory-incompatible program upgrade
-debug.print: panic occurred in file 'src/persistence.rs' at line 203
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
 ingress Completed: Reply: 0x4449444c0000
 debug.print: [var 1.000000, 2.000000, 3.000000, 4.000000]
 debug.print: ?[null, ?[], ?[?[null, null], null]]
diff --git a/test/run-drun/ok/function-upgrades.drun.ok b/test/run-drun/ok/function-upgrades.drun.ok
index c4b2228d3e9..60b4b27b770 100644
--- a/test/run-drun/ok/function-upgrades.drun.ok
+++ b/test/run-drun/ok/function-upgrades.drun.ok
@@ -3,13 +3,7 @@ ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
-debug.print: Memory-incompatible program upgrade
-debug.print: panic occurred in file 'src/persistence.rs' at line 203
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
-debug.print: Memory-incompatible program upgrade
-debug.print: panic occurred in file 'src/persistence.rs' at line 203
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
-debug.print: Memory-incompatible program upgrade
-debug.print: panic occurred in file 'src/persistence.rs' at line 203
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/tuple-upgrades.drun.ok b/test/run-drun/ok/tuple-upgrades.drun.ok
index 5b2ef66a0d4..b154425ced1 100644
--- a/test/run-drun/ok/tuple-upgrades.drun.ok
+++ b/test/run-drun/ok/tuple-upgrades.drun.ok
@@ -21,18 +21,10 @@ debug.print: (1, 2)
 debug.print: (0, "Test", 1.230000, {key = 5; value = '_'}, [-1, +2, -3])
 debug.print: ?(2, ?(1, null, null), ?(4, ?(3, null, null), ?(5, null, null)))
 ingress Completed: Reply: 0x4449444c0000
-debug.print: Memory-incompatible program upgrade
-debug.print: panic occurred in file 'src/persistence.rs' at line 203
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
-debug.print: Memory-incompatible program upgrade
-debug.print: panic occurred in file 'src/persistence.rs' at line 203
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
-debug.print: Memory-incompatible program upgrade
-debug.print: panic occurred in file 'src/persistence.rs' at line 203
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
-debug.print: Memory-incompatible program upgrade
-debug.print: panic occurred in file 'src/persistence.rs' at line 203
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
 ingress Completed: Reply: 0x4449444c0000
 debug.print: (1, 2)
 debug.print: (0, "Test", 1.230000, {key = 5; value = '_'}, [-1, +2, -3])
diff --git a/test/run-drun/ok/upgrade-generics.drun.ok b/test/run-drun/ok/upgrade-generics.drun.ok
index 3db739de0b3..136ec2202df 100644
--- a/test/run-drun/ok/upgrade-generics.drun.ok
+++ b/test/run-drun/ok/upgrade-generics.drun.ok
@@ -11,9 +11,7 @@ ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
 debug.print: (([0], [+1]), true)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: Memory-incompatible program upgrade
-debug.print: panic occurred in file 'src/persistence.rs' at line 203
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
 ingress Completed: Reply: 0x4449444c0000
 debug.print: (([0], [+1]), true)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/upgrade-mutable.drun.ok b/test/run-drun/ok/upgrade-mutable.drun.ok
index 62cfb8bc1b5..160a60b06d0 100644
--- a/test/run-drun/ok/upgrade-mutable.drun.ok
+++ b/test/run-drun/ok/upgrade-mutable.drun.ok
@@ -9,6 +9,4 @@ ingress Completed: Reply: 0x4449444c0000
 debug.print: [var {key = 2; value = "2"}]
 debug.print: [var {key = 2; value = "2"}]
 ingress Completed: Reply: 0x4449444c0000
-debug.print: Memory-incompatible program upgrade
-debug.print: panic occurred in file 'src/persistence.rs' at line 203
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
diff --git a/test/run-drun/ok/upgrade-nat-to-int.drun.ok b/test/run-drun/ok/upgrade-nat-to-int.drun.ok
index b961c8ec4a6..481c689f56d 100644
--- a/test/run-drun/ok/upgrade-nat-to-int.drun.ok
+++ b/test/run-drun/ok/upgrade-nat-to-int.drun.ok
@@ -15,6 +15,4 @@ ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
 debug.print: -2
 ingress Completed: Reply: 0x4449444c0000
-debug.print: Memory-incompatible program upgrade
-debug.print: panic occurred in file 'src/persistence.rs' at line 203
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
diff --git a/test/run-drun/ok/upgrade-recursive-type.drun.ok b/test/run-drun/ok/upgrade-recursive-type.drun.ok
index 2becc24484b..c1bfca7bfc9 100644
--- a/test/run-drun/ok/upgrade-recursive-type.drun.ok
+++ b/test/run-drun/ok/upgrade-recursive-type.drun.ok
@@ -7,15 +7,11 @@ ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
 debug.print: CHECK 2
 ingress Completed: Reply: 0x4449444c0000
-debug.print: Memory-incompatible program upgrade
-debug.print: panic occurred in file 'src/persistence.rs' at line 203
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
 ingress Completed: Reply: 0x4449444c0000
 debug.print: CHECK 3
 ingress Completed: Reply: 0x4449444c0000
-debug.print: Memory-incompatible program upgrade
-debug.print: panic occurred in file 'src/persistence.rs' at line 203
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
 ingress Completed: Reply: 0x4449444c0000
 debug.print: CHECK 4
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/upgrade-remove-add-fields.drun.ok b/test/run-drun/ok/upgrade-remove-add-fields.drun.ok
index d72f5fb89d6..e95999ccf86 100644
--- a/test/run-drun/ok/upgrade-remove-add-fields.drun.ok
+++ b/test/run-drun/ok/upgrade-remove-add-fields.drun.ok
@@ -19,15 +19,11 @@ ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
 debug.print: secondField=4
 ingress Completed: Reply: 0x4449444c0000
-debug.print: Memory-incompatible program upgrade
-debug.print: panic occurred in file 'src/persistence.rs' at line 203
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
 ingress Completed: Reply: 0x4449444c0000
 debug.print: secondField=5
 ingress Completed: Reply: 0x4449444c0000
-debug.print: Memory-incompatible program upgrade
-debug.print: panic occurred in file 'src/persistence.rs' at line 203
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
 ingress Completed: Reply: 0x4449444c0000
 debug.print: secondField=6
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/variant-upgrades.drun.ok b/test/run-drun/ok/variant-upgrades.drun.ok
index f2f1686663d..9372abbd22e 100644
--- a/test/run-drun/ok/variant-upgrades.drun.ok
+++ b/test/run-drun/ok/variant-upgrades.drun.ok
@@ -15,6 +15,4 @@ ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
 debug.print: #two({key = 1; name = "TEST TEST TEST TEST TEST"})
 ingress Completed: Reply: 0x4449444c0000
-debug.print: Memory-incompatible program upgrade
-debug.print: panic occurred in file 'src/persistence.rs' at line 203
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: RTS panicked
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade

From 9e0c490ba35e203104b9cd55b3390a1a42d1ea53 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Tue, 12 Sep 2023 14:52:46 +0200
Subject: [PATCH 117/260] Update documentation

---
 design/OrthogonalPersistence.md | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/design/OrthogonalPersistence.md b/design/OrthogonalPersistence.md
index 5094a986a3f..5c3eac11d85 100644
--- a/design/OrthogonalPersistence.md
+++ b/design/OrthogonalPersistence.md
@@ -45,20 +45,20 @@ More specifically, it comprises:
 * A reserve for future metadata extensions.
 
 ### Compatibility Check
-NOTE: This will be simplified by using the existing IDL sub-type test in the runtime system.
-
 Upgrades are only permitted if the new program version is compatible to the old version, such that the runtime system guarantees a compatible memory structure.
-Compatible changes are equivalent to the allowed Motoko subtype relation, e.g.
-* Adding or removing actor fields
-* Removing object fields
-* Adding variant fields
-* `Nat` to `Int`
-* Shared function parameter contravariance and return type covariance
 
-The compiler generates a static type table that describes all static variable types.
-The table is registered in the persistent metadata and compared against the type table of a new program version. The upgrade is rejected on incompatible type tables.
+Compatible changes for immutable types are equivalent to the allowed Motoko subtype relation, e.g.
+* Adding or removing actor fields.
+* Removing object fields.
+* Adding variant fields.
+* `Nat` to `Int`.
+* Shared function parameter contravariance and return type covariance.
+
+The existing IDL-subtype functionality is reused with some adjustments to check memory compatibility: The compiler generates the type descriptor, a type table, that is recorded in the persistent metadata. Upon an upgrade, the new type descriptor is compared against the existing type descriptor, and the upgrade only succeeds for compatible changes.
 
-This compatibility check serves as an additional safety measure on top of the DFX Candid subtype check that can be bypassed by users (when ignoring a warning). Moreoever, the memory compatibility rules may be stricter than in Candid (e.g. not allowing introducing optional types).
+This compatibility check serves as an additional safety measure on top of the DFX Candid subtype check that can be bypassed by users (when ignoring a warning). Moreoever, the memory compatibility rules is in some aspects different to the Candid sub-type check:
+* Types cannot be made optional.
+* Mutable types (aliases) are supported with type invariance.
 
 ### Garbage Collection
 The implementation focuses on the incremental GC and abandons the other GCs because the GCs use different memory layouts. For example, the incremental GC uses a partitioned heap with objects carrying a forwarding pointer.

From fdf601cad8bec23de90d7a0f180c6cadaa587b80 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Wed, 13 Sep 2023 11:04:18 +0200
Subject: [PATCH 118/260] Downscale test for CI

---
 test/run-drun/stable-region-migration/actor0.mo | 4 ++--
 test/run-drun/stable-region-migration/actor1.mo | 5 +++--
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/test/run-drun/stable-region-migration/actor0.mo b/test/run-drun/stable-region-migration/actor0.mo
index 663b992d8eb..48e220159c8 100644
--- a/test/run-drun/stable-region-migration/actor0.mo
+++ b/test/run-drun/stable-region-migration/actor0.mo
@@ -18,10 +18,10 @@ actor {
     assert M.grow(reqPages) == 0;
     assert M.size() == reqPages;
 
-    // write byte pattern, one byte at a time.
+    // write byte pattern, in a defined interval.
     while (i < size) {
         M.storeNat8(i, b);
-        i := i + 1;
+        i := i + 10;
         b := b +% 1;
     };
 
diff --git a/test/run-drun/stable-region-migration/actor1.mo b/test/run-drun/stable-region-migration/actor1.mo
index ab5d67443dd..7877e654a6d 100644
--- a/test/run-drun/stable-region-migration/actor1.mo
+++ b/test/run-drun/stable-region-migration/actor1.mo
@@ -21,14 +21,15 @@ actor {
 
     assert M.size() == reqPages;
 
-    // Load out previously-stored byte pattern, one byte at a time.
+    // Load out previously-stored byte pattern in a defined interval.
+    // The interval serves for faster test runs on the CI, to avoid `drun` batch limit. 
     // Check each byte is what we would have written, if we were repeating the same logic again.
     while (i < size) {
         let expected = b;
         let loaded = M.loadNat8(i);
         //P.debugPrint(" - " # (debug_show {i; expected; loaded}));
         assert loaded == expected;
-        i := i + 1;
+        i := i + 10;
         b := b +% 1;
     };
 

From f5ca1322cb1a77452aa470b635ebc44586180dc3 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 14 Sep 2023 09:43:50 +0200
Subject: [PATCH 119/260] Change IC dependency to pull request

---
 nix/sources.json | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/nix/sources.json b/nix/sources.json
index 620ac0f4946..24059c004a9 100644
--- a/nix/sources.json
+++ b/nix/sources.json
@@ -21,15 +21,15 @@
         "version": "3.2.25"
     },
     "ic": {
-        "branch": "luc/stable-heap-on-release",
+        "branch": "pull/135/head",
         "description": "Internet Computer blockchain source: the client/replica software run by nodes",
         "homepage": "",
-        "owner": "luc-blaeser",
+        "owner": "dfinity",
         "repo": "ic",
         "rev": "18de74c14491c06499f59404fa5434a18bb9ca50",
         "sha256": "1zlq1d4zb594nb3hld50cp7kmzfzwmhka01xsbazxagszs61p2sk",
         "type": "tarball",
-        "url": "https://github.com/luc-blaeser/ic/archive/18de74c14491c06499f59404fa5434a18bb9ca50.tar.gz",
+        "url": "https://github.com/dfinity/ic/archive/18de74c14491c06499f59404fa5434a18bb9ca50.tar.gz",
         "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
     },
     "ic-hs": {

From 0e7dcb749a6d62a6df01c0497746edcb4a8ad91b Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 14 Sep 2023 11:22:26 +0200
Subject: [PATCH 120/260] Test CI build option

---
 .github/workflows/test.yml | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index dc7b2c2ebbc..41a40e16913 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -32,11 +32,11 @@ jobs:
 
     - run: nix-env -iA nix-build-uncached -f nix/
 
-    - name: "pre-build `drun`"
-      if: startsWith(github.head_ref, 'update/ic-')
-      run: |
-        nix-build --max-jobs 1 -A drun
-        nix-store --gc --print-roots | grep /motoko/
+    # - name: "pre-build `drun`"
+    #   if: startsWith(github.head_ref, 'update/ic-')
+    #   run: |
+    #     nix-build --max-jobs 1 -A drun
+    #     nix-store --gc --print-roots | grep /motoko/
 
     - name: "nix-build"
       run: nix-build-uncached --max-jobs 4 -A all-systems-go -build-flags -L

From 0e73ccf0fcb20737abadd01b5e45830f48451d2b Mon Sep 17 00:00:00 2001
From: Gabor Greif <gabor@dfinity.org>
Date: Thu, 14 Sep 2023 12:11:28 +0200
Subject: [PATCH 121/260] Update test.yml

---
 .github/workflows/test.yml | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 41a40e16913..5a74077b714 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -32,11 +32,11 @@ jobs:
 
     - run: nix-env -iA nix-build-uncached -f nix/
 
-    # - name: "pre-build `drun`"
+    - name: "pre-build `drun`"
     #   if: startsWith(github.head_ref, 'update/ic-')
-    #   run: |
-    #     nix-build --max-jobs 1 -A drun
-    #     nix-store --gc --print-roots | grep /motoko/
+      run: |
+        nix-build --max-jobs 1 -A drun
+        nix-store --gc --print-roots | grep /motoko/
 
     - name: "nix-build"
       run: nix-build-uncached --max-jobs 4 -A all-systems-go -build-flags -L

From 0a8baf081efcd111d65af00500b80899bb520c3d Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 22 Sep 2023 10:19:53 +0200
Subject: [PATCH 122/260] Remove memory reserve

---
 rts/motoko-rts/src/gc/incremental.rs          |  3 +-
 rts/motoko-rts/src/memory.rs                  |  5 ---
 rts/motoko-rts/src/memory/ic.rs               |  1 -
 src/codegen/compile.ml                        | 32 +++------------
 .../memory-reserve-composite.drun             |  6 ---
 .../memory-reserve-composite.mo               | 39 -------------------
 .../run-drun-non-ci/memory-reserve-query.drun |  6 ---
 .../memory-reserve-query.mo                   | 31 ---------------
 .../memory-reserve-update.drun                |  6 ---
 .../memory-reserve-update.mo                  | 30 --------------
 .../memory-reserve-upgrade.drun               |  6 ---
 .../memory-reserve-upgrade.mo                 | 25 ------------
 .../ok/memory-reserve-composite.drun.ok       | 11 ------
 test/run-drun/ok/memory-reserve-query.drun.ok |  9 -----
 .../run-drun/ok/memory-reserve-update.drun.ok |  9 -----
 .../ok/memory-reserve-upgrade.drun.ok         |  9 -----
 test/run.sh                                   |  8 ----
 17 files changed, 7 insertions(+), 229 deletions(-)
 delete mode 100644 test/run-drun-non-ci/memory-reserve-composite.drun
 delete mode 100644 test/run-drun-non-ci/memory-reserve-composite/memory-reserve-composite.mo
 delete mode 100644 test/run-drun-non-ci/memory-reserve-query.drun
 delete mode 100644 test/run-drun-non-ci/memory-reserve-query/memory-reserve-query.mo
 delete mode 100644 test/run-drun-non-ci/memory-reserve-update.drun
 delete mode 100644 test/run-drun-non-ci/memory-reserve-update/memory-reserve-update.mo
 delete mode 100644 test/run-drun-non-ci/memory-reserve-upgrade.drun
 delete mode 100644 test/run-drun-non-ci/memory-reserve-upgrade/memory-reserve-upgrade.mo
 delete mode 100644 test/run-drun/ok/memory-reserve-composite.drun.ok
 delete mode 100644 test/run-drun/ok/memory-reserve-query.drun.ok
 delete mode 100644 test/run-drun/ok/memory-reserve-update.drun.ok
 delete mode 100644 test/run-drun/ok/memory-reserve-upgrade.drun.ok

diff --git a/rts/motoko-rts/src/gc/incremental.rs b/rts/motoko-rts/src/gc/incremental.rs
index 035608a7f89..d159d9e5766 100644
--- a/rts/motoko-rts/src/gc/incremental.rs
+++ b/rts/motoko-rts/src/gc/incremental.rs
@@ -72,8 +72,7 @@ unsafe fn should_start() -> bool {
     use self::partitioned_heap::PARTITION_SIZE;
     use crate::memory::ic;
 
-    const CRITICAL_HEAP_LIMIT: Bytes<u32> =
-        Bytes(u32::MAX - 768 * 1024 * 1024 - MEMORY_RESERVE as u32);
+    const CRITICAL_HEAP_LIMIT: Bytes<u32> = Bytes(u32::MAX - 768 * 1024 * 1024);
     const CRITICAL_GROWTH_THRESHOLD: f64 = 0.01;
     const NORMAL_GROWTH_THRESHOLD: f64 = 0.65;
 
diff --git a/rts/motoko-rts/src/memory.rs b/rts/motoko-rts/src/memory.rs
index ce2d601fd34..540b9669a16 100644
--- a/rts/motoko-rts/src/memory.rs
+++ b/rts/motoko-rts/src/memory.rs
@@ -7,11 +7,6 @@ use crate::types::*;
 
 use motoko_rts_macros::ic_mem_fn;
 
-// Memory reserve in bytes ensured during update and initialization calls.
-// For use by queries and upgrade calls.
-#[cfg(feature = "ic")]
-pub(crate) const MEMORY_RESERVE: usize = 256 * 1024 * 1024;
-
 /// A trait for heap allocation. RTS functions allocate in heap via this trait.
 ///
 /// To be able to link the RTS with moc-generated code, we implement wrappers around allocating
diff --git a/rts/motoko-rts/src/memory/ic.rs b/rts/motoko-rts/src/memory/ic.rs
index 59e4ab5128b..97b05269b5c 100644
--- a/rts/motoko-rts/src/memory/ic.rs
+++ b/rts/motoko-rts/src/memory/ic.rs
@@ -2,7 +2,6 @@
 
 use super::Memory;
 use crate::constants::WASM_PAGE_SIZE;
-use crate::memory::MEMORY_RESERVE;
 use crate::rts_trap_with;
 use crate::types::{Bytes, Value, Words};
 use core::arch::wasm32;
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 8a234120dab..9d4e294f5c6 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -4195,7 +4195,7 @@ module Lifecycle = struct
     | InPreUpgrade -> [Idle]
     | PostPreUpgrade -> [InPreUpgrade]
     | InPostUpgrade -> [InInit]
-    | InComposite -> [Idle; InComposite]
+    | InComposite -> [Idle]
 
   let get env =
     compile_unboxed_const (ptr ()) ^^
@@ -4222,10 +4222,6 @@ module Lifecycle = struct
       set env new_state
     )
 
-  let is_in env state =
-    get env ^^
-    compile_eq_const (int_of_state state)
-
 end (* Lifecycle *)
 
 
@@ -8150,25 +8146,9 @@ module FuncDec = struct
       | Type.Shared Type.Query ->
         Lifecycle.trans env Lifecycle.PostQuery
       | Type.Shared Type.Composite ->
-        (* Stay in composite query state such that callbacks of 
-        composite queries can also use the memory reserve. 
-        The state is isolated since memory changes of queries 
-        are rolled back by the IC runtime system. *)
-        Lifecycle.trans env Lifecycle.InComposite
+        Lifecycle.trans env Lifecycle.Idle
       | _ -> assert false
 
-  let callback_start env =
-    Lifecycle.is_in env Lifecycle.InComposite ^^
-    G.if0
-      (G.nop)
-      (message_start env (Type.Shared Type.Write))
-
-  let callback_cleanup env =
-    Lifecycle.is_in env Lifecycle.InComposite ^^
-    G.if0
-      (G.nop)
-      (message_cleanup env (Type.Shared Type.Write))
-  
   let compile_const_message outer_env outer_ae sort control args mk_body ret_tys at : E.func_with_names =
     let ae0 = VarEnv.mk_fun_ae outer_ae in
     Func.of_body outer_env [] [] (fun env -> G.with_region at (
@@ -8325,7 +8305,7 @@ module FuncDec = struct
            (fun env -> compile_unboxed_const 0l)))
     in
     Func.define_built_in env reply_name ["env", I32Type] [] (fun env ->
-        callback_start env ^^
+        message_start env (Type.Shared Type.Write) ^^
         (* Look up continuation *)
         let (set_closure, get_closure) = new_local env "closure" in
         G.i (LocalGet (nr 0l)) ^^
@@ -8341,12 +8321,12 @@ module FuncDec = struct
         get_closure ^^
         Closure.call_closure env arity 0 ^^
 
-        callback_cleanup env
+        message_cleanup env (Type.Shared Type.Write)
       );
 
     let reject_name = "@reject_callback" in
     Func.define_built_in env reject_name ["env", I32Type] [] (fun env ->
-        callback_start env ^^
+        message_start env (Type.Shared Type.Write) ^^
         (* Look up continuation *)
         let (set_closure, get_closure) = new_local env "closure" in
         G.i (LocalGet (nr 0l)) ^^
@@ -8363,7 +8343,7 @@ module FuncDec = struct
         get_closure ^^
         Closure.call_closure env 1 0 ^^
 
-        callback_cleanup env
+        message_cleanup env (Type.Shared Type.Write)
       );
 
     (* result is a function that accepts a list of closure getters, from which
diff --git a/test/run-drun-non-ci/memory-reserve-composite.drun b/test/run-drun-non-ci/memory-reserve-composite.drun
deleted file mode 100644
index 5bbc2a24e56..00000000000
--- a/test/run-drun-non-ci/memory-reserve-composite.drun
+++ /dev/null
@@ -1,6 +0,0 @@
-# INCREMENTAL-GC-ONLY
-# SKIP ic-ref-run
-install $ID memory-reserve-composite/memory-reserve-composite.mo ""
-ingress $ID prepare1 "DIDL\x00\x00"
-ingress $ID prepare2 "DIDL\x00\x00"
-query $ID allocateInCompositeQuery "DIDL\x00\x00"
diff --git a/test/run-drun-non-ci/memory-reserve-composite/memory-reserve-composite.mo b/test/run-drun-non-ci/memory-reserve-composite/memory-reserve-composite.mo
deleted file mode 100644
index d1238e382f8..00000000000
--- a/test/run-drun-non-ci/memory-reserve-composite/memory-reserve-composite.mo
+++ /dev/null
@@ -1,39 +0,0 @@
-import Prim "mo:⛔";
-actor {
-    stable var stableData = Prim.Array_tabulate<Nat>(1024 * 1024, func(index) { index });
-    var array0 : [var Nat] = [var];
-    var array1 : [var Nat] = [var];
-    var array2 : [var Nat] = [var];
-    var array3 : [var Nat] = [var];
-    Prim.debugPrint("Initialized " # debug_show (Prim.rts_memory_size()));
-
-    public func prepare1() : async () {
-        array0 := Prim.Array_init<Nat>(256 * 1024 * 1024, 0); // 1GB
-        array1 := Prim.Array_init<Nat>(256 * 1024 * 1024, 1); // 2GB
-        Prim.debugPrint("Prepared1 " # debug_show (Prim.rts_memory_size()));
-    };
-
-    public func prepare2() : async () {
-        array2 := Prim.Array_init<Nat>(256 * 1024 * 1024, 2); // 3GB
-        array3 := Prim.Array_init<Nat>(150 * 1024 * 1024, 3); // around 3.75GB
-        Prim.debugPrint("Prepared2 " # debug_show (Prim.rts_memory_size()));
-    };
-
-    public composite query func allocateInCompositeQuery() : async () {
-        ignore Prim.Array_init<Nat>(50 * 1024 * 1024, 4);
-        Prim.debugPrint("Composite query call " # debug_show (Prim.rts_memory_size()));
-        assert (Prim.rts_memory_size() > 3840 * 1024 * 1024);
-        await nestedQuery();
-        ignore Prim.Array_init<Nat>(5 * 1024 * 1024, 4);
-        Prim.debugPrint("Composite query callback " # debug_show (Prim.rts_memory_size()));
-        assert (Prim.rts_memory_size() > 3840 * 1024 * 1024);
-    };
-
-    public query func nestedQuery() : async () {
-        Prim.debugPrint("Nested query " # debug_show (Prim.rts_memory_size()));
-    };
-};
-
-//SKIP run
-//SKIP run-ir
-//SKIP run-low
diff --git a/test/run-drun-non-ci/memory-reserve-query.drun b/test/run-drun-non-ci/memory-reserve-query.drun
deleted file mode 100644
index d076edb417a..00000000000
--- a/test/run-drun-non-ci/memory-reserve-query.drun
+++ /dev/null
@@ -1,6 +0,0 @@
-# INCREMENTAL-GC-ONLY
-# SKIP ic-ref-run
-install $ID memory-reserve-query/memory-reserve-query.mo ""
-ingress $ID prepare1 "DIDL\x00\x00"
-ingress $ID prepare2 "DIDL\x00\x00"
-query $ID allocateInQuery "DIDL\x00\x00"
diff --git a/test/run-drun-non-ci/memory-reserve-query/memory-reserve-query.mo b/test/run-drun-non-ci/memory-reserve-query/memory-reserve-query.mo
deleted file mode 100644
index b50b802cb6c..00000000000
--- a/test/run-drun-non-ci/memory-reserve-query/memory-reserve-query.mo
+++ /dev/null
@@ -1,31 +0,0 @@
-import Prim "mo:⛔";
-actor {
-    stable var stableData = Prim.Array_tabulate<Nat>(1024 * 1024, func(index) { index });
-    var array0 : [var Nat] = [var];
-    var array1 : [var Nat] = [var];
-    var array2 : [var Nat] = [var];
-    var array3 : [var Nat] = [var];
-    Prim.debugPrint("Initialized " # debug_show (Prim.rts_memory_size()));
-
-    public func prepare1() : async () {
-        array0 := Prim.Array_init<Nat>(256 * 1024 * 1024, 0); // 1GB
-        array1 := Prim.Array_init<Nat>(256 * 1024 * 1024, 1); // 2GB
-        Prim.debugPrint("Prepared1 " # debug_show (Prim.rts_memory_size()));
-    };
-
-    public func prepare2() : async () {
-        array2 := Prim.Array_init<Nat>(256 * 1024 * 1024, 2); // 3GB
-        array3 := Prim.Array_init<Nat>(150 * 1024 * 1024, 3); // around 3.75GB
-        Prim.debugPrint("Prepared2 " # debug_show (Prim.rts_memory_size()));
-    };
-
-    public query func allocateInQuery() : async () {
-        ignore Prim.Array_init<Nat>(50 * 1024 * 1024, 4);
-        Prim.debugPrint("Query call " # debug_show (Prim.rts_memory_size()));
-        assert (Prim.rts_memory_size() > 3840 * 1024 * 1024);
-    };
-};
-
-//SKIP run
-//SKIP run-ir
-//SKIP run-low
diff --git a/test/run-drun-non-ci/memory-reserve-update.drun b/test/run-drun-non-ci/memory-reserve-update.drun
deleted file mode 100644
index 6d53c637928..00000000000
--- a/test/run-drun-non-ci/memory-reserve-update.drun
+++ /dev/null
@@ -1,6 +0,0 @@
-# INCREMENTAL-GC-ONLY
-# SKIP ic-ref-run
-install $ID memory-reserve-update/memory-reserve-update.mo ""
-ingress $ID prepare1 "DIDL\x00\x00"
-ingress $ID prepare2 "DIDL\x00\x00"
-ingress $ID allocateInUpdate "DIDL\x00\x00"
diff --git a/test/run-drun-non-ci/memory-reserve-update/memory-reserve-update.mo b/test/run-drun-non-ci/memory-reserve-update/memory-reserve-update.mo
deleted file mode 100644
index cc8f3aaeb38..00000000000
--- a/test/run-drun-non-ci/memory-reserve-update/memory-reserve-update.mo
+++ /dev/null
@@ -1,30 +0,0 @@
-import Prim "mo:⛔";
-actor {
-    stable var stableData = Prim.Array_tabulate<Nat>(1024 * 1024, func(index) { index });
-    var array0 : [var Nat] = [var];
-    var array1 : [var Nat] = [var];
-    var array2 : [var Nat] = [var];
-    var array3 : [var Nat] = [var];
-    Prim.debugPrint("Initialized " # debug_show (Prim.rts_memory_size()));
-
-    public func prepare1() : async () {
-        array0 := Prim.Array_init<Nat>(256 * 1024 * 1024, 0); // 1GB
-        array1 := Prim.Array_init<Nat>(256 * 1024 * 1024, 1); // 2GB
-        Prim.debugPrint("Prepared1 " # debug_show (Prim.rts_memory_size()));
-    };
-
-    public func prepare2() : async () {
-        array2 := Prim.Array_init<Nat>(256 * 1024 * 1024, 2); // 3GB
-        array3 := Prim.Array_init<Nat>(150 * 1024 * 1024, 3); // around 3.75GB
-        Prim.debugPrint("Prepared2 " # debug_show (Prim.rts_memory_size()));
-    };
-
-    public func allocateInUpdate() : async () {
-        Prim.debugPrint("Update call " # debug_show (Prim.rts_memory_size()));
-        ignore Prim.Array_init<Nat>(50 * 1024 * 1024, 4);
-    };
-};
-
-//SKIP run
-//SKIP run-ir
-//SKIP run-low
diff --git a/test/run-drun-non-ci/memory-reserve-upgrade.drun b/test/run-drun-non-ci/memory-reserve-upgrade.drun
deleted file mode 100644
index f791e8fd882..00000000000
--- a/test/run-drun-non-ci/memory-reserve-upgrade.drun
+++ /dev/null
@@ -1,6 +0,0 @@
-# INCREMENTAL-GC-ONLY
-# SKIP ic-ref-run
-install $ID memory-reserve-upgrade/memory-reserve-upgrade.mo ""
-ingress $ID prepare1 "DIDL\x00\x00"
-ingress $ID prepare2 "DIDL\x00\x00"
-upgrade $ID memory-reserve-upgrade/memory-reserve-upgrade.mo ""
diff --git a/test/run-drun-non-ci/memory-reserve-upgrade/memory-reserve-upgrade.mo b/test/run-drun-non-ci/memory-reserve-upgrade/memory-reserve-upgrade.mo
deleted file mode 100644
index 85cef10b07c..00000000000
--- a/test/run-drun-non-ci/memory-reserve-upgrade/memory-reserve-upgrade.mo
+++ /dev/null
@@ -1,25 +0,0 @@
-import Prim "mo:⛔";
-actor {
-    stable var stableData = Prim.Array_tabulate<Nat>(1024 * 1024, func(index) { index });
-    var array0 : [var Nat] = [var];
-    var array1 : [var Nat] = [var];
-    var array2 : [var Nat] = [var];
-    var array3 : [var Nat] = [var];
-    Prim.debugPrint("Initialized " # debug_show (Prim.rts_memory_size()));
-
-    public func prepare1() : async () {
-        array0 := Prim.Array_init<Nat>(256 * 1024 * 1024, 0); // 1GB
-        array1 := Prim.Array_init<Nat>(256 * 1024 * 1024, 1); // 2GB
-        Prim.debugPrint("Prepared1 " # debug_show (Prim.rts_memory_size()));
-    };
-
-    public func prepare2() : async () {
-        array2 := Prim.Array_init<Nat>(256 * 1024 * 1024, 2); // 3GB
-        array3 := Prim.Array_init<Nat>(150 * 1024 * 1024, 3); // around 3.75GB
-        Prim.debugPrint("Prepared2 " # debug_show (Prim.rts_memory_size()));
-    };
-};
-
-//SKIP run
-//SKIP run-ir
-//SKIP run-low
diff --git a/test/run-drun/ok/memory-reserve-composite.drun.ok b/test/run-drun/ok/memory-reserve-composite.drun.ok
deleted file mode 100644
index 7873f0eac9c..00000000000
--- a/test/run-drun/ok/memory-reserve-composite.drun.ok
+++ /dev/null
@@ -1,11 +0,0 @@
-ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
-debug.print: Initialized 33_554_432
-ingress Completed: Reply: 0x4449444c0000
-debug.print: Prepared1 2_248_146_944
-ingress Completed: Reply: 0x4449444c0000
-debug.print: Prepared2 4_026_531_840
-ingress Completed: Reply: 0x4449444c0000
-debug.print: Composite query call 4_261_412_864
-debug.print: Nested query 4_026_531_840
-debug.print: Composite query callback 4_261_412_864
-Ok: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/memory-reserve-query.drun.ok b/test/run-drun/ok/memory-reserve-query.drun.ok
deleted file mode 100644
index 37886cacc22..00000000000
--- a/test/run-drun/ok/memory-reserve-query.drun.ok
+++ /dev/null
@@ -1,9 +0,0 @@
-ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
-debug.print: Initialized 33_554_432
-ingress Completed: Reply: 0x4449444c0000
-debug.print: Prepared1 2_248_146_944
-ingress Completed: Reply: 0x4449444c0000
-debug.print: Prepared2 4_026_531_840
-ingress Completed: Reply: 0x4449444c0000
-debug.print: Query call 4_261_412_864
-Ok: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/memory-reserve-update.drun.ok b/test/run-drun/ok/memory-reserve-update.drun.ok
deleted file mode 100644
index 5f259ac651a..00000000000
--- a/test/run-drun/ok/memory-reserve-update.drun.ok
+++ /dev/null
@@ -1,9 +0,0 @@
-ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
-debug.print: Initialized 33_554_432
-ingress Completed: Reply: 0x4449444c0000
-debug.print: Prepared1 2_248_146_944
-ingress Completed: Reply: 0x4449444c0000
-debug.print: Prepared2 4_026_531_840
-ingress Completed: Reply: 0x4449444c0000
-debug.print: Update call 4_026_531_840
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Cannot grow memory
diff --git a/test/run-drun/ok/memory-reserve-upgrade.drun.ok b/test/run-drun/ok/memory-reserve-upgrade.drun.ok
deleted file mode 100644
index 85706920d90..00000000000
--- a/test/run-drun/ok/memory-reserve-upgrade.drun.ok
+++ /dev/null
@@ -1,9 +0,0 @@
-ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
-debug.print: Initialized 33_554_432
-ingress Completed: Reply: 0x4449444c0000
-debug.print: Prepared1 2_248_146_944
-ingress Completed: Reply: 0x4449444c0000
-debug.print: Prepared2 4_026_531_840
-ingress Completed: Reply: 0x4449444c0000
-debug.print: Initialized 33_554_432
-ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run.sh b/test/run.sh
index 34fd3d36be4..fe377512ebe 100755
--- a/test/run.sh
+++ b/test/run.sh
@@ -435,14 +435,6 @@ do
         continue
       fi
 
-      if grep -q "# *INCREMENTAL-GC-ONLY" $(basename $file)
-      then
-        if [[ $EXTRA_MOC_ARGS != *"--incremental-gc"* ]]
-        then 
-          continue
-        fi
-      fi
-
       have_var_name="HAVE_${runner//-/_}"
       if [ ${!have_var_name} != yes ]
       then

From e984eeb9a3fca47d37b3e912c9a3a3a8a1a53f17 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 22 Sep 2023 11:10:29 +0200
Subject: [PATCH 123/260] Manual merge RTS

---
 rts/motoko-rts-tests/src/gc.rs                |  4 +-
 rts/motoko-rts-tests/src/gc/heap.rs           | 74 ++++++++++++++-----
 .../src/gc/incremental/roots.rs               | 53 +++++++------
 3 files changed, 83 insertions(+), 48 deletions(-)

diff --git a/rts/motoko-rts-tests/src/gc.rs b/rts/motoko-rts-tests/src/gc.rs
index 690b23a82c3..4b343e4379d 100644
--- a/rts/motoko-rts-tests/src/gc.rs
+++ b/rts/motoko-rts-tests/src/gc.rs
@@ -122,7 +122,7 @@ fn test_gc(
         heap.heap_ptr_offset(),
         heap.static_root_array_variable_offset(),
         heap.continuation_table_variable_offset(),
-        heap.region0_ptr_offset(),
+        heap.region0_pointer_variable_offset(),
     );
 
     for _ in 0..3 {
@@ -132,7 +132,7 @@ fn test_gc(
         let heap_ptr_offset = heap.heap_ptr_offset();
         let static_array_variable_offset = heap.static_root_array_variable_offset();
         let continuation_table_variable_offset = heap.continuation_table_variable_offset();
-        let region0_ptr_offset = heap.region0_ptr_offset();
+        let region0_ptr_offset = heap.region0_pointer_variable_offset();
         check_dynamic_heap(
             check_all_reclaimed, // check for unreachable objects
             refs,
diff --git a/rts/motoko-rts-tests/src/gc/heap.rs b/rts/motoko-rts-tests/src/gc/heap.rs
index a234f33c51d..b7b09224563 100644
--- a/rts/motoko-rts-tests/src/gc/heap.rs
+++ b/rts/motoko-rts-tests/src/gc/heap.rs
@@ -90,9 +90,14 @@ impl MotokoHeap {
         self.inner.borrow().continuation_table_variable_address()
     }
 
-    /// Get the address of the continuation table pointer
+    /// Get the offset of the variable pointing to region0.
+    pub fn region0_pointer_variable_offset(&self) -> usize {
+        self.inner.borrow().region0_pointer_variable_offset
+    }
+
+    /// Get the address of the variable pointing to region0
     pub fn region0_pointer_variable_address(&self) -> usize {
-        self.inner.borrow().region0_ptr_address()
+        self.inner.borrow().region0_pointer_address()
     }
 
     /// Get the heap as an array. Use `offset` values returned by the methods above to read.
@@ -181,8 +186,7 @@ impl MotokoHeapInner {
     }
 
     /// Get the address of the region0 pointer
-    #[incremental_gc]
-    fn region0_ptr_address(&self) -> usize {
+    fn region0_pointer_address(&self) -> usize {
         self.offset_to_address(self.region0_pointer_variable_offset)
     }
 
@@ -223,8 +227,10 @@ impl MotokoHeapInner {
 
         let region0_size = size_of::<Region>().to_bytes().as_usize();
 
-        let dynamic_heap_size_bytes =
-            dynamic_heap_size_without_roots + continuation_table_size + region0_size;
+        let dynamic_heap_size_bytes = dynamic_heap_size_without_roots
+            + static_root_set_size_bytes
+            + continuation_table_size
+            + region0_size;
 
         let total_heap_size_bytes = root_pointers_size_bytes + dynamic_heap_size_bytes;
 
@@ -239,12 +245,13 @@ impl MotokoHeapInner {
         assert_eq!(realign % 4, 0);
 
         // Maps `ObjectIdx`s into their offsets in the heap.
-        let object_addrs: FxHashMap<ObjectIdx, usize> = create_dynamic_heap(
-            map,
-            roots,
-            continuation_table,
-            &mut heap[root_pointers_size_bytes + realign..heap_size + realign],
-        );
+        let (static_root_array_address, continuation_table_address, region0_address) =
+            create_dynamic_heap(
+                map,
+                roots,
+                continuation_table,
+                &mut heap[root_pointers_size_bytes + realign..heap_size + realign],
+            );
 
         // Root pointers in static memory space.
         let static_root_array_variable_offset = root_pointers_size_bytes - 3 * WORD_SIZE;
@@ -256,6 +263,7 @@ impl MotokoHeapInner {
             region0_pointer_variable_offset,
             static_root_array_address,
             continuation_table_address,
+            region0_address,
             &mut heap[realign..root_pointers_size_bytes + realign],
         );
 
@@ -326,7 +334,7 @@ fn create_dynamic_heap(
     static_roots: &[ObjectIdx],
     continuation_table: &[ObjectIdx],
     dynamic_heap: &mut [u8],
-) -> (u32, u32) {
+) -> (u32, u32, u32) {
     let heap_start = dynamic_heap.as_ptr() as usize;
 
     // Maps objects to their addresses
@@ -386,8 +394,6 @@ fn create_dynamic_heap(
         .to_bytes()
         .as_usize()
         + n_fields * WORD_SIZE;
-    let continuation_table_size =
-        size_of::<Array>().to_bytes().as_usize() + continuation_table.len() * WORD_SIZE;
 
     let mut heap_offset = root_section_offset;
     let mut root_mutboxes = vec![];
@@ -450,7 +456,33 @@ fn create_dynamic_heap(
         }
     }
 
-    (static_root_array_address, continuation_table_address)
+    // Add region0
+    let region0_address = u32::try_from(heap_start + heap_offset).unwrap();
+    {
+        write_word(dynamic_heap, heap_offset, TAG_REGION);
+        heap_offset += WORD_SIZE;
+
+        write_word(dynamic_heap, heap_offset, make_pointer(region0_address));
+        heap_offset += WORD_SIZE;
+
+        // lower part of region id
+        write_word(dynamic_heap, heap_offset, 0);
+        heap_offset += WORD_SIZE;
+        // upper part of region id
+        write_word(dynamic_heap, heap_offset, 0);
+        heap_offset += WORD_SIZE;
+        // zero pages
+        write_word(dynamic_heap, heap_offset, 0);
+        heap_offset += WORD_SIZE;
+        // Simplification: Skip the vector pages blob
+        write_word(dynamic_heap, heap_offset, make_scalar(0));
+    }
+
+    (
+        static_root_array_address,
+        continuation_table_address,
+        region0_address,
+    )
 }
 
 /// Static memory part containing the root pointers.
@@ -460,6 +492,7 @@ fn create_static_memory(
     region0_pointer_variable_offset: usize,
     static_root_array_address: u32,
     continuation_table_address: u32,
+    region0_address: u32,
     heap: &mut [u8],
 ) {
     // Write static array pointer as the third last word in static memory
@@ -476,7 +509,10 @@ fn create_static_memory(
         make_pointer(continuation_table_address),
     );
 
-    let region0_ptr = region0_offset as u32 + heap.as_ptr() as u32;
-    // Write region 0 pointer as the last word in static memory
-    write_word(heap, region0_pointer_variable_offset, make_pointer(region0_ptr));
+    // Write region 0 pointer as the very last word in static memory
+    write_word(
+        heap,
+        region0_pointer_variable_offset,
+        make_pointer(region0_address),
+    );
 }
diff --git a/rts/motoko-rts-tests/src/gc/incremental/roots.rs b/rts/motoko-rts-tests/src/gc/incremental/roots.rs
index 97f1c5ffa7c..4d413f3b457 100644
--- a/rts/motoko-rts-tests/src/gc/incremental/roots.rs
+++ b/rts/motoko-rts-tests/src/gc/incremental/roots.rs
@@ -28,14 +28,16 @@ unsafe fn check_visit_static_roots(heap: &MotokoHeap, root_ids: &[ObjectIdx]) {
     let mut visited_static_roots = vec![];
     visit_roots(roots, &mut visited_static_roots, |context, field| {
         let object = *field;
-        let array = object.as_array();
-        if array.len() == root_ids.len() as u32 {
-            for index in 0..array.len() {
-                let mutbox_value = array.get(index);
-                let mutbox = mutbox_value.as_mutbox();
-                let root_address = (*mutbox).field.get_ptr();
-                let root_id = object_id(heap, root_address);
-                context.push(root_id);
+        if object.tag() != TAG_REGION {
+            let array = object.as_array();
+            if array.len() == root_ids.len() as u32 {
+                for index in 0..array.len() {
+                    let mutbox_value = array.get(index);
+                    let mutbox = mutbox_value.as_mutbox();
+                    let root_address = (*mutbox).field.get_ptr();
+                    let root_id = object_id(heap, root_address);
+                    context.push(root_id);
+                }
             }
         }
     });
@@ -47,13 +49,15 @@ unsafe fn check_visit_continuation_table(heap: &MotokoHeap, continuation_ids: &[
     let mut visited_continuations = vec![];
     visit_roots(roots, &mut visited_continuations, |context, field| {
         let object = *field;
-        let array = object.as_array();
-        if array.len() == continuation_ids.len() as u32 {
-            assert_eq!(context.len(), 0);
-            for index in 0..array.len() {
-                let element = array.get(index);
-                let id = object_id(&heap, element.get_ptr());
-                context.push(id);
+        if object.tag() != TAG_REGION {
+            let array = object.as_array();
+            if array.len() == continuation_ids.len() as u32 {
+                assert_eq!(context.len(), 0);
+                for index in 0..array.len() {
+                    let element = array.get(index);
+                    let id = object_id(&heap, element.get_ptr());
+                    context.push(id);
+                }
             }
         }
     });
@@ -63,18 +67,13 @@ unsafe fn check_visit_continuation_table(heap: &MotokoHeap, continuation_ids: &[
 unsafe fn check_visit_region0(heap: &MotokoHeap) {
     let roots = get_roots(heap);
     let mut visited_region0 = false;
-    visit_roots(
-        roots,
-        heap.heap_base_address(),
-        &mut visited_region0,
-        |visited, field| {
-            let object = *field;
-            if object.tag() == TAG_REGION {
-                assert!(!*visited);
-                *visited = true;
-            }
-        },
-    );
+    visit_roots(roots, &mut visited_region0, |visited, field| {
+        let object = *field;
+        if object.tag() == TAG_REGION {
+            assert!(!*visited);
+            *visited = true;
+        }
+    });
     assert!(visited_region0);
 }
 

From ad587dc540134e658990b066643ab6b3fab0370c Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 22 Sep 2023 11:18:37 +0200
Subject: [PATCH 124/260] Manual merge compiler

---
 src/codegen/compile.ml | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 9d4e294f5c6..7e452ee6271 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -1854,7 +1854,7 @@ module Opt = struct
     E.call_import env "rts" "null_singleton" (* forwarding pointer already resolved *)
 
   let is_some env =
-    Func.share_code1 env "is_some" ("x", I32Type) [I32Type] (fun env get_x ->
+    Func.share_code1 Func.Never env "is_some" ("x", I32Type) [I32Type] (fun env get_x ->
       get_x ^^ BitTagged.if_tagged_scalar env [I32Type]
         ( Bool.lit true ) (* scalar *)
         ( get_x ^^ BitTagged.is_true_literal env ^^ (* exclude true literal since `branch_default` follows the forwarding pointer *)
@@ -3639,7 +3639,7 @@ module Object = struct
   (* Returns a pointer to the object field (without following the field indirection) *)
   let idx_hash_raw env low_bound =
     let name = Printf.sprintf "obj_idx<%d>" low_bound  in
-    Func.share_code2 env name (("x", I32Type), ("hash", I32Type)) [I32Type] (fun env get_x get_hash ->
+    Func.share_code2 Func.Always env name (("x", I32Type), ("hash", I32Type)) [I32Type] (fun env get_x get_hash ->
       let set_x = G.setter_for get_x in
       let set_h_ptr, get_h_ptr = new_local env "h_ptr" in
 
@@ -3672,7 +3672,7 @@ module Object = struct
     if indirect
     then
       let name = Printf.sprintf "obj_idx_ind<%d>" low_bound in
-      Func.share_code2 env name (("x", I32Type), ("hash", I32Type)) [I32Type] (fun env get_x get_hash ->
+      Func.share_code2 Func.Never env name (("x", I32Type), ("hash", I32Type)) [I32Type] (fun env get_x get_hash ->
       get_x ^^ get_hash ^^
       idx_hash_raw env low_bound ^^
       load_ptr ^^ Tagged.load_forwarding_pointer env ^^
@@ -7307,7 +7307,7 @@ module OldStabilization = struct
   let read_and_clear_word32 env =
     match E.mode env with
     | Flags.ICMode | Flags.RefMode ->
-      Func.share_code1 env "__stablemem_read_and_clear_word32"
+      Func.share_code1 Func.Always env "__stablemem_read_and_clear_word32"
         ("offset", I64Type) [I32Type]
         (fun env get_offset ->
           Stack.with_words env "temp_ptr" 1l (fun get_temp_ptr ->
@@ -7332,7 +7332,7 @@ module OldStabilization = struct
 
   (* TODO: rewrite using MemoryFill *)
   let blob_clear env =
-    Func.share_code1 env "blob_clear" ("x", I32Type) [] (fun env get_x ->
+    Func.share_code1 Func.Always env "blob_clear" ("x", I32Type) [] (fun env get_x ->
       let (set_ptr, get_ptr) = new_local env "ptr" in
       let (set_len, get_len) = new_local env "len" in
       get_x ^^
@@ -7665,7 +7665,7 @@ module Persistence = struct
 end
 
 module GCRoots = struct
-  let create_root_array env = Func.share_code0 env "create_root_array" [I32Type] (fun env ->
+  let create_root_array env = Func.share_code0 Func.Always env "create_root_array" [I32Type] (fun env ->
     let length = Int32.to_int (E.count_static_variables env) in
     let variables = Lib.List.table length (fun _ -> MutBox.alloc env) in
     Arr.lit env variables

From 63e28a8c30288b77a5ef22f4fb9bf2176b022ff7 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 22 Sep 2023 11:23:46 +0200
Subject: [PATCH 125/260] Update benchmark results

---
 test/bench/ok/alloc.drun-run-opt.ok       |  6 +++---
 test/bench/ok/alloc.drun-run.ok           |  6 +++---
 test/bench/ok/bignum.drun-run-opt.ok      |  4 ++--
 test/bench/ok/bignum.drun-run.ok          |  4 ++--
 test/bench/ok/heap-32.drun-run-opt.ok     |  4 ++--
 test/bench/ok/heap-32.drun-run.ok         |  4 ++--
 test/bench/ok/nat16.drun-run-opt.ok       |  2 +-
 test/bench/ok/nat16.drun-run.ok           |  2 +-
 test/bench/ok/palindrome.drun-run-opt.ok  | 12 ++++++------
 test/bench/ok/palindrome.drun-run.ok      | 12 ++++++------
 test/bench/ok/region-mem.drun-run-opt.ok  |  2 +-
 test/bench/ok/region-mem.drun-run.ok      |  2 +-
 test/bench/ok/region0-mem.drun-run-opt.ok |  2 +-
 test/bench/ok/region0-mem.drun-run.ok     |  2 +-
 test/bench/ok/stable-mem.drun-run-opt.ok  |  2 +-
 test/bench/ok/stable-mem.drun-run.ok      |  2 +-
 16 files changed, 34 insertions(+), 34 deletions(-)

diff --git a/test/bench/ok/alloc.drun-run-opt.ok b/test/bench/ok/alloc.drun-run-opt.ok
index f9e95b161d1..c619a21b48c 100644
--- a/test/bench/ok/alloc.drun-run-opt.ok
+++ b/test/bench/ok/alloc.drun-run-opt.ok
@@ -1,8 +1,8 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_815_063_355)
+debug.print: (+335_544_320, 4_764_731_706)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_815_063_172)
+debug.print: (+335_544_320, 4_764_731_523)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_815_063_184)
+debug.print: (+335_544_320, 4_764_731_535)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/alloc.drun-run.ok b/test/bench/ok/alloc.drun-run.ok
index 4575154646c..3fd04ca037b 100644
--- a/test/bench/ok/alloc.drun-run.ok
+++ b/test/bench/ok/alloc.drun-run.ok
@@ -1,8 +1,8 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_966_058_474)
+debug.print: (+335_544_320, 4_898_949_603)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_966_058_281)
+debug.print: (+335_544_320, 4_898_949_410)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_966_058_294)
+debug.print: (+335_544_320, 4_898_949_423)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/bignum.drun-run-opt.ok b/test/bench/ok/bignum.drun-run-opt.ok
index ecce60add17..4074ccf86df 100644
--- a/test/bench/ok/bignum.drun-run-opt.ok
+++ b/test/bench/ok/bignum.drun-run-opt.ok
@@ -1,6 +1,6 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 2_414_305; size = +60_608}
+debug.print: {cycles = 2_413_690; size = +60_608}
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 103_321_396; size = +1_827_460}
+debug.print: {cycles = 103_321_242; size = +1_827_460}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/bignum.drun-run.ok b/test/bench/ok/bignum.drun-run.ok
index ac06af40aba..8804a130c9f 100644
--- a/test/bench/ok/bignum.drun-run.ok
+++ b/test/bench/ok/bignum.drun-run.ok
@@ -1,6 +1,6 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 2_519_086; size = +60_608}
+debug.print: {cycles = 2_519_183; size = +60_608}
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 103_375_885; size = +1_827_460}
+debug.print: {cycles = 103_375_902; size = +1_827_460}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/heap-32.drun-run-opt.ok b/test/bench/ok/heap-32.drun-run-opt.ok
index fa0a97064f8..9365a1e190a 100644
--- a/test/bench/ok/heap-32.drun-run-opt.ok
+++ b/test/bench/ok/heap-32.drun-run-opt.ok
@@ -1,5 +1,5 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (50_227, +37_021_304, 768_384_283)
-debug.print: (50_070, +40_056_236, 830_837_434)
+debug.print: (50_227, +37_021_304, 767_984_255)
+debug.print: (50_070, +40_056_236, 830_437_406)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/heap-32.drun-run.ok b/test/bench/ok/heap-32.drun-run.ok
index 124de2bae61..458ca29ce8e 100644
--- a/test/bench/ok/heap-32.drun-run.ok
+++ b/test/bench/ok/heap-32.drun-run.ok
@@ -1,5 +1,5 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (50_227, +37_021_304, 816_295_186)
-debug.print: (50_070, +40_056_236, 880_486_179)
+debug.print: (50_227, +37_021_304, 815_894_722)
+debug.print: (50_070, +40_056_236, 880_136_109)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/nat16.drun-run-opt.ok b/test/bench/ok/nat16.drun-run-opt.ok
index 7d812c5e5c1..892c7d73148 100644
--- a/test/bench/ok/nat16.drun-run-opt.ok
+++ b/test/bench/ok/nat16.drun-run-opt.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (0, 18_875_156)
+debug.print: (0, 18_875_155)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/nat16.drun-run.ok b/test/bench/ok/nat16.drun-run.ok
index c40412fab2a..38425f9a5b4 100644
--- a/test/bench/ok/nat16.drun-run.ok
+++ b/test/bench/ok/nat16.drun-run.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (0, 42_992_140)
+debug.print: (0, 42_992_119)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/palindrome.drun-run-opt.ok b/test/bench/ok/palindrome.drun-run-opt.ok
index 8d86d8095e4..39fa88310fd 100644
--- a/test/bench/ok/palindrome.drun-run-opt.ok
+++ b/test/bench/ok/palindrome.drun-run-opt.ok
@@ -1,9 +1,9 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (true, +1_548, 28_867)
-debug.print: (false, +1_548, 27_557)
-debug.print: (false, +1_548, 28_832)
-debug.print: (true, +1_160, 27_783)
-debug.print: (false, +1_148, 25_715)
-debug.print: (false, +1_148, 27_575)
+debug.print: (true, +1_548, 28_338)
+debug.print: (false, +1_548, 27_043)
+debug.print: (false, +1_548, 28_303)
+debug.print: (true, +1_160, 27_215)
+debug.print: (false, +1_148, 25_336)
+debug.print: (false, +1_148, 27_016)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/palindrome.drun-run.ok b/test/bench/ok/palindrome.drun-run.ok
index bee16b4c9b5..5f48686ac5d 100644
--- a/test/bench/ok/palindrome.drun-run.ok
+++ b/test/bench/ok/palindrome.drun-run.ok
@@ -1,9 +1,9 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (true, +1_548, 30_337)
-debug.print: (false, +1_548, 28_951)
-debug.print: (false, +1_548, 30_301)
-debug.print: (true, +1_160, 28_739)
-debug.print: (false, +1_148, 26_632)
-debug.print: (false, +1_148, 28_522)
+debug.print: (true, +1_548, 29_984)
+debug.print: (false, +1_548, 28_628)
+debug.print: (false, +1_548, 29_948)
+debug.print: (true, +1_160, 28_351)
+debug.print: (false, +1_148, 26_385)
+debug.print: (false, +1_148, 28_140)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/region-mem.drun-run-opt.ok b/test/bench/ok/region-mem.drun-run-opt.ok
index b32d3d9d55c..5007d210bcd 100644
--- a/test/bench/ok/region-mem.drun-run-opt.ok
+++ b/test/bench/ok/region-mem.drun-run-opt.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 8_090_812_785}
+debug.print: {heap_diff = 0; instr_diff = 7_788_823_069}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/region-mem.drun-run.ok b/test/bench/ok/region-mem.drun-run.ok
index 7159bb97a74..952fb0b0355 100644
--- a/test/bench/ok/region-mem.drun-run.ok
+++ b/test/bench/ok/region-mem.drun-run.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 8_719_958_412}
+debug.print: {heap_diff = 0; instr_diff = 8_745_124_231}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/region0-mem.drun-run-opt.ok b/test/bench/ok/region0-mem.drun-run-opt.ok
index 96fca6ed896..2c70cdb4026 100644
--- a/test/bench/ok/region0-mem.drun-run-opt.ok
+++ b/test/bench/ok/region0-mem.drun-run-opt.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 7_310_672_241}
+debug.print: {heap_diff = 0; instr_diff = 7_159_677_284}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/region0-mem.drun-run.ok b/test/bench/ok/region0-mem.drun-run.ok
index 91c2b8a8374..0765df65ce5 100644
--- a/test/bench/ok/region0-mem.drun-run.ok
+++ b/test/bench/ok/region0-mem.drun-run.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 7_876_903_308}
+debug.print: {heap_diff = 0; instr_diff = 7_889_486_215}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/stable-mem.drun-run-opt.ok b/test/bench/ok/stable-mem.drun-run-opt.ok
index e734aab7d6b..02f1b9e3785 100644
--- a/test/bench/ok/stable-mem.drun-run-opt.ok
+++ b/test/bench/ok/stable-mem.drun-run-opt.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 3_548_381_553}
+debug.print: {heap_diff = 0; instr_diff = 3_397_386_596}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/stable-mem.drun-run.ok b/test/bench/ok/stable-mem.drun-run.ok
index d9d2e4a1ed9..95e61450410 100644
--- a/test/bench/ok/stable-mem.drun-run.ok
+++ b/test/bench/ok/stable-mem.drun-run.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 4_089_446_796}
+debug.print: {heap_diff = 0; instr_diff = 4_089_446_791}
 ingress Completed: Reply: 0x4449444c0000

From 69cf3d86f1eb7e27b19cd52001506a3c1b2fe5d2 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Wed, 27 Sep 2023 11:15:43 +0200
Subject: [PATCH 126/260] Fix typos and unwanted documentation deletion

---
 doc/md/compiler-ref.md                          |  2 ++
 rts/motoko-rts/src/persistence.rs               | 12 ++++++------
 rts/motoko-rts/src/persistence/compatibility.rs |  4 ++--
 3 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/doc/md/compiler-ref.md b/doc/md/compiler-ref.md
index 096f1a96537..354b7a64fc4 100644
--- a/doc/md/compiler-ref.md
+++ b/doc/md/compiler-ref.md
@@ -28,6 +28,8 @@ You can use the following options with the `moc` command.
 | `--check`                                 | Performs type checking only.                                                                                                                          |
 | `--debug`                                 | Respects debug expressions in the source (the default).                                                                                               |
 | `--error-detail <n>`                      | Set level of error message detail for syntax errors, n in \[0..3\] (default 2).                                                                       |
+| `-fno-shared-code`                        | Do *not* share low-level utility code: larger code size but decreased cycle consumption (default).                                                    |
+| `-fshared-code`                           | Do share low-level utility code: smaller code size but increased cycle consumption.                                                                   |
 | `-help`,`--help`                          | Displays usage information.                                                                                                                           |
 | `--hide-warnings`                         | Hides compiler warnings.                                                                                                                              |
 | `-Werror`                                 | Treat warnings as errors.                                                                                                                             |
diff --git a/rts/motoko-rts/src/persistence.rs b/rts/motoko-rts/src/persistence.rs
index 0cf79e1f937..bb72d9b6f03 100644
--- a/rts/motoko-rts/src/persistence.rs
+++ b/rts/motoko-rts/src/persistence.rs
@@ -28,7 +28,7 @@ const VERSION: usize = 1;
 /// The GC ignores this value since it is a scalar representation.
 const DEFAULT_VALUE: Value = Value::from_scalar(0);
 
-/// The persistent metadata stored at the defined location `METADTA_ADDRESS` in memory.
+/// The persistent metadata stored at the defined location `METADATA_ADDRESS` in memory.
 /// Use a long-term representation by relying on C layout.
 /// The `Value` references belong to the GC root set and require forwarding pointer resolution.
 #[repr(C)]
@@ -51,19 +51,19 @@ struct PersistentMetadata {
     null_singleton: Value,
 }
 
-/// Location of the persistent metadata. Prereseved and fixed forever.
-const METATDATA_ADDRESS: usize = 6 * 1024 * 1024;
+/// Location of the persistent metadata. Prereserved and fixed forever.
+const METADATA_ADDRESS: usize = 6 * 1024 * 1024;
 /// The reserved maximum size of the metadata, contains a reserve for future extension of the metadata.
 const METADATA_RESERVE: usize = 128 * 1024;
 
 // TODO: Include partition table in reserved space.
-pub const HEAP_START: usize = METATDATA_ADDRESS + METADATA_RESERVE;
+pub const HEAP_START: usize = METADATA_ADDRESS + METADATA_RESERVE;
 
 const _: () = assert!(core::mem::size_of::<PersistentMetadata>() <= METADATA_RESERVE);
 
 impl PersistentMetadata {
     fn get() -> *mut Self {
-        METATDATA_ADDRESS as *mut Self
+        METADATA_ADDRESS as *mut Self
     }
 
     #[cfg(feature = "ic")]
@@ -104,7 +104,7 @@ impl PersistentMetadata {
     }
 }
 
-/// Initialize fresh peristent memory after the canister installation or
+/// Initialize fresh persistent memory after the canister installation or
 /// reuse the persistent memory on a canister upgrade.
 #[cfg(feature = "ic")]
 pub unsafe fn initialize_memory<M: Memory>(mem: &mut M) {
diff --git a/rts/motoko-rts/src/persistence/compatibility.rs b/rts/motoko-rts/src/persistence/compatibility.rs
index fbcf826cb95..54b9c98962d 100644
--- a/rts/motoko-rts/src/persistence/compatibility.rs
+++ b/rts/motoko-rts/src/persistence/compatibility.rs
@@ -1,5 +1,5 @@
 //! Persistent type compatibility check.
-//! Determines whether the a new actor type is compatible with the existing persistent state.
+//! Determines whether a new actor type is compatible with the existing persistent state.
 //! Engages the existing IDL subtype check functionality.
 
 use crate::{
@@ -13,7 +13,7 @@ use crate::{
 const DEFAULT_VALUE: Value = Value::from_scalar(0);
 
 pub struct TypeDescriptor {
-    // Blob with candid-encoded type defintions.
+    // Blob with candid-encoded type definitions.
     candid_data: Value,
     // Blob with a list of `u32` offsets referring to the `candid_data`.
     type_offsets: Value,

From c4c98d7c9db97e953171fe6d38b6a55a0a49984a Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Wed, 27 Sep 2023 11:32:37 +0200
Subject: [PATCH 127/260] Re-Insert Memory Reserve for Queries and Upgrades
 (#4158)

With the incremental GC, programs can scale to the full 4GB memory space. As a consequence, update calls can allocate the full memory space, such that even a simple query, a simple composite query, or a simple upgrade logic can no longer succeed. This could also happen with classical non-copying GCs if deterministic time slicing is sufficiently extended.

This PR prevents update calls (including canister initialization, heartbeats, and timers) from allocating the full memory by leaving a reserve for queries, composite queries, and canister upgrades. During queries, composite queries, and canister upgrades, garbage collection is suspended, such that the reserve is available to the mutator code. Callbacks of composite queries can also use the memory reserve.

The current allocation limit for upgrade calls is 3.75 GB and applies to all GCs. This gives a reserve of 224 MB for the incremental GC as the last 32MB partition is unallocated in the current design. The scheduling heuristics of the incremental and generational GC needs to consider the reduced capacity for determining memory shortage.

This PR can be viewed as a temporary measure until a memory reserve is implemented in the IC runtime system.

The memory reserve may **not** be sufficient for a complex canister upgrade logic or large amount of stable heap data. Moreover, the upgrade logic may exceed the instruction limit. Thorough upgrade testing is required for canisters in any case.
---
 rts/motoko-rts/src/gc/incremental.rs          |  5 +-
 rts/motoko-rts/src/memory.rs                  |  5 ++
 rts/motoko-rts/src/memory/ic.rs               | 18 +++++--
 src/codegen/compile.ml                        | 50 ++++++++++++++++---
 test/bench/ok/alloc.drun-run-opt.ok           |  6 +--
 test/bench/ok/alloc.drun-run.ok               |  6 +--
 test/bench/ok/heap-32.drun-run-opt.ok         |  4 +-
 test/bench/ok/heap-32.drun-run.ok             |  4 +-
 .../memory-reserve-composite.drun             |  6 +++
 .../memory-reserve-composite.mo               | 39 +++++++++++++++
 .../run-drun-non-ci/memory-reserve-query.drun |  6 +++
 .../memory-reserve-query.mo                   | 31 ++++++++++++
 .../memory-reserve-update.drun                |  6 +++
 .../memory-reserve-update.mo                  | 30 +++++++++++
 .../memory-reserve-upgrade.drun               |  6 +++
 .../memory-reserve-upgrade.mo                 | 25 ++++++++++
 test/run.sh                                   |  8 +++
 17 files changed, 233 insertions(+), 22 deletions(-)
 create mode 100644 test/run-drun-non-ci/memory-reserve-composite.drun
 create mode 100644 test/run-drun-non-ci/memory-reserve-composite/memory-reserve-composite.mo
 create mode 100644 test/run-drun-non-ci/memory-reserve-query.drun
 create mode 100644 test/run-drun-non-ci/memory-reserve-query/memory-reserve-query.mo
 create mode 100644 test/run-drun-non-ci/memory-reserve-update.drun
 create mode 100644 test/run-drun-non-ci/memory-reserve-update/memory-reserve-update.mo
 create mode 100644 test/run-drun-non-ci/memory-reserve-upgrade.drun
 create mode 100644 test/run-drun-non-ci/memory-reserve-upgrade/memory-reserve-upgrade.mo

diff --git a/rts/motoko-rts/src/gc/incremental.rs b/rts/motoko-rts/src/gc/incremental.rs
index d159d9e5766..c300919ff94 100644
--- a/rts/motoko-rts/src/gc/incremental.rs
+++ b/rts/motoko-rts/src/gc/incremental.rs
@@ -70,9 +70,10 @@ unsafe fn incremental_gc<M: Memory>(mem: &mut M) {
 #[cfg(feature = "ic")]
 unsafe fn should_start() -> bool {
     use self::partitioned_heap::PARTITION_SIZE;
-    use crate::memory::ic;
+    use crate::memory::{ic, MEMORY_RESERVE};
 
-    const CRITICAL_HEAP_LIMIT: Bytes<u32> = Bytes(u32::MAX - 768 * 1024 * 1024);
+    const CRITICAL_HEAP_LIMIT: Bytes<u32> =
+        Bytes(u32::MAX - 768 * 1024 * 1024 - MEMORY_RESERVE as u32);
     const CRITICAL_GROWTH_THRESHOLD: f64 = 0.01;
     const NORMAL_GROWTH_THRESHOLD: f64 = 0.65;
 
diff --git a/rts/motoko-rts/src/memory.rs b/rts/motoko-rts/src/memory.rs
index 540b9669a16..ce2d601fd34 100644
--- a/rts/motoko-rts/src/memory.rs
+++ b/rts/motoko-rts/src/memory.rs
@@ -7,6 +7,11 @@ use crate::types::*;
 
 use motoko_rts_macros::ic_mem_fn;
 
+// Memory reserve in bytes ensured during update and initialization calls.
+// For use by queries and upgrade calls.
+#[cfg(feature = "ic")]
+pub(crate) const MEMORY_RESERVE: usize = 256 * 1024 * 1024;
+
 /// A trait for heap allocation. RTS functions allocate in heap via this trait.
 ///
 /// To be able to link the RTS with moc-generated code, we implement wrappers around allocating
diff --git a/rts/motoko-rts/src/memory/ic.rs b/rts/motoko-rts/src/memory/ic.rs
index 97b05269b5c..2a861cc9019 100644
--- a/rts/motoko-rts/src/memory/ic.rs
+++ b/rts/motoko-rts/src/memory/ic.rs
@@ -2,10 +2,15 @@
 
 use super::Memory;
 use crate::constants::WASM_PAGE_SIZE;
+use crate::memory::MEMORY_RESERVE;
 use crate::rts_trap_with;
 use crate::types::{Bytes, Value, Words};
 use core::arch::wasm32;
 
+extern "C" {
+    fn keep_memory_reserve() -> bool;
+}
+
 /// Provides a `Memory` implementation, to be used in functions compiled for IC or WASI. The
 /// `Memory` implementation allocates in Wasm heap with Wasm `memory.grow` instruction.
 pub struct IcMemory;
@@ -20,9 +25,16 @@ impl Memory for IcMemory {
     /// with the slight exception of not allocating the extra page for address 0xFFFF_0000.
     #[inline(never)]
     unsafe fn grow_memory(&mut self, ptr: u64) {
-        debug_assert_eq!(0xFFFF_0000, usize::MAX - WASM_PAGE_SIZE.as_usize() + 1);
-        if ptr > 0xFFFF_0000 {
-            // spare the last wasm memory page
+        const LAST_PAGE_LIMIT: usize = 0xFFFF_0000;
+        debug_assert_eq!(LAST_PAGE_LIMIT, usize::MAX - WASM_PAGE_SIZE.as_usize() + 1);
+        let limit = if keep_memory_reserve() {
+            // Spare a memory reserve during update and initialization calls for use by queries and upgrades.
+            usize::MAX - MEMORY_RESERVE + 1
+        } else {
+            // Spare the last Wasm memory page on queries and upgrades to support the Rust call stack boundary checks.
+            LAST_PAGE_LIMIT
+        };
+        if ptr > limit as u64 {
             rts_trap_with("Cannot grow memory")
         };
         let page_size = u64::from(WASM_PAGE_SIZE.as_u32());
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 6ca499a73b2..ca4deaa5e9e 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -4199,7 +4199,7 @@ module Lifecycle = struct
     | InPreUpgrade -> [Idle]
     | PostPreUpgrade -> [InPreUpgrade]
     | InPostUpgrade -> [InInit]
-    | InComposite -> [Idle]
+    | InComposite -> [Idle; InComposite]
 
   let get env =
     compile_unboxed_const (ptr ()) ^^
@@ -4226,6 +4226,10 @@ module Lifecycle = struct
       set env new_state
     )
 
+  let is_in env state =
+    get env ^^
+    compile_eq_const (int_of_state state)
+
 end (* Lifecycle *)
 
 
@@ -5335,7 +5339,23 @@ module RTS_Exports = struct
       edesc = nr (FuncExport (nr rts_trap_fi))
     });
 
-  let ic0_stable64_write_fi =
+    (* Keep a memory reserve when in update or init state. 
+       This reserve can be used by queries, composite queries, and upgrades. *)
+    let keep_memory_reserve_fi = E.add_fun env "keep_memory_reserve" (
+      Func.of_body env [] [I32Type] (fun env ->
+        Lifecycle.get env ^^
+        compile_eq_const Lifecycle.(int_of_state InUpdate) ^^
+        Lifecycle.get env ^^
+        compile_eq_const Lifecycle.(int_of_state InInit) ^^
+        G.i (Binary (Wasm.Values.I32 I32Op.Or))
+      )
+    ) in
+    E.add_export env (nr {
+      name = Lib.Utf8.decode "keep_memory_reserve";
+      edesc = nr (FuncExport (nr keep_memory_reserve_fi))
+    });
+
+    let ic0_stable64_write_fi =
       if E.mode env = Flags.WASIMode then
         E.add_fun env "ic0_stable64_write" (
             Func.of_body env ["to", I64Type; "from", I64Type; "len", I64Type] []
@@ -8150,9 +8170,25 @@ module FuncDec = struct
       | Type.Shared Type.Query ->
         Lifecycle.trans env Lifecycle.PostQuery
       | Type.Shared Type.Composite ->
-        Lifecycle.trans env Lifecycle.Idle
+        (* Stay in composite query state such that callbacks of 
+        composite queries can also use the memory reserve. 
+        The state is isolated since memory changes of queries 
+        are rolled back by the IC runtime system. *)
+        Lifecycle.trans env Lifecycle.InComposite
       | _ -> assert false
 
+  let callback_start env =
+    Lifecycle.is_in env Lifecycle.InComposite ^^
+    G.if0
+      (G.nop)
+      (message_start env (Type.Shared Type.Write))
+
+  let callback_cleanup env =
+    Lifecycle.is_in env Lifecycle.InComposite ^^
+    G.if0
+      (G.nop)
+      (message_cleanup env (Type.Shared Type.Write))
+  
   let compile_const_message outer_env outer_ae sort control args mk_body ret_tys at : E.func_with_names =
     let ae0 = VarEnv.mk_fun_ae outer_ae in
     Func.of_body outer_env [] [] (fun env -> G.with_region at (
@@ -8309,7 +8345,7 @@ module FuncDec = struct
            (fun env -> compile_unboxed_const 0l)))
     in
     Func.define_built_in env reply_name ["env", I32Type] [] (fun env ->
-        message_start env (Type.Shared Type.Write) ^^
+        callback_start env ^^
         (* Look up continuation *)
         let (set_closure, get_closure) = new_local env "closure" in
         G.i (LocalGet (nr 0l)) ^^
@@ -8325,12 +8361,12 @@ module FuncDec = struct
         get_closure ^^
         Closure.call_closure env arity 0 ^^
 
-        message_cleanup env (Type.Shared Type.Write)
+        callback_cleanup env
       );
 
     let reject_name = "@reject_callback" in
     Func.define_built_in env reject_name ["env", I32Type] [] (fun env ->
-        message_start env (Type.Shared Type.Write) ^^
+        callback_start env ^^
         (* Look up continuation *)
         let (set_closure, get_closure) = new_local env "closure" in
         G.i (LocalGet (nr 0l)) ^^
@@ -8347,7 +8383,7 @@ module FuncDec = struct
         get_closure ^^
         Closure.call_closure env 1 0 ^^
 
-        message_cleanup env (Type.Shared Type.Write)
+        callback_cleanup env
       );
 
     (* result is a function that accepts a list of closure getters, from which
diff --git a/test/bench/ok/alloc.drun-run-opt.ok b/test/bench/ok/alloc.drun-run-opt.ok
index c619a21b48c..ebe1ca9a37b 100644
--- a/test/bench/ok/alloc.drun-run-opt.ok
+++ b/test/bench/ok/alloc.drun-run-opt.ok
@@ -1,8 +1,8 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_764_731_706)
+debug.print: (+335_544_320, 4_764_731_816)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_764_731_523)
+debug.print: (+335_544_320, 4_764_731_633)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_764_731_535)
+debug.print: (+335_544_320, 4_764_731_645)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/alloc.drun-run.ok b/test/bench/ok/alloc.drun-run.ok
index 3fd04ca037b..1285909900e 100644
--- a/test/bench/ok/alloc.drun-run.ok
+++ b/test/bench/ok/alloc.drun-run.ok
@@ -1,8 +1,8 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_898_949_603)
+debug.print: (+335_544_320, 4_898_949_723)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_898_949_410)
+debug.print: (+335_544_320, 4_898_949_530)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_898_949_423)
+debug.print: (+335_544_320, 4_898_949_543)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/heap-32.drun-run-opt.ok b/test/bench/ok/heap-32.drun-run-opt.ok
index 9365a1e190a..77b3a4e8e0b 100644
--- a/test/bench/ok/heap-32.drun-run-opt.ok
+++ b/test/bench/ok/heap-32.drun-run-opt.ok
@@ -1,5 +1,5 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (50_227, +37_021_304, 767_984_255)
-debug.print: (50_070, +40_056_236, 830_437_406)
+debug.print: (50_227, +37_021_304, 767_984_266)
+debug.print: (50_070, +40_056_236, 830_437_417)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/heap-32.drun-run.ok b/test/bench/ok/heap-32.drun-run.ok
index 458ca29ce8e..402c131c5c5 100644
--- a/test/bench/ok/heap-32.drun-run.ok
+++ b/test/bench/ok/heap-32.drun-run.ok
@@ -1,5 +1,5 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (50_227, +37_021_304, 815_894_722)
-debug.print: (50_070, +40_056_236, 880_136_109)
+debug.print: (50_227, +37_021_304, 815_894_734)
+debug.print: (50_070, +40_056_236, 880_136_121)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun-non-ci/memory-reserve-composite.drun b/test/run-drun-non-ci/memory-reserve-composite.drun
new file mode 100644
index 00000000000..5bbc2a24e56
--- /dev/null
+++ b/test/run-drun-non-ci/memory-reserve-composite.drun
@@ -0,0 +1,6 @@
+# INCREMENTAL-GC-ONLY
+# SKIP ic-ref-run
+install $ID memory-reserve-composite/memory-reserve-composite.mo ""
+ingress $ID prepare1 "DIDL\x00\x00"
+ingress $ID prepare2 "DIDL\x00\x00"
+query $ID allocateInCompositeQuery "DIDL\x00\x00"
diff --git a/test/run-drun-non-ci/memory-reserve-composite/memory-reserve-composite.mo b/test/run-drun-non-ci/memory-reserve-composite/memory-reserve-composite.mo
new file mode 100644
index 00000000000..d1238e382f8
--- /dev/null
+++ b/test/run-drun-non-ci/memory-reserve-composite/memory-reserve-composite.mo
@@ -0,0 +1,39 @@
+import Prim "mo:⛔";
+actor {
+    stable var stableData = Prim.Array_tabulate<Nat>(1024 * 1024, func(index) { index });
+    var array0 : [var Nat] = [var];
+    var array1 : [var Nat] = [var];
+    var array2 : [var Nat] = [var];
+    var array3 : [var Nat] = [var];
+    Prim.debugPrint("Initialized " # debug_show (Prim.rts_memory_size()));
+
+    public func prepare1() : async () {
+        array0 := Prim.Array_init<Nat>(256 * 1024 * 1024, 0); // 1GB
+        array1 := Prim.Array_init<Nat>(256 * 1024 * 1024, 1); // 2GB
+        Prim.debugPrint("Prepared1 " # debug_show (Prim.rts_memory_size()));
+    };
+
+    public func prepare2() : async () {
+        array2 := Prim.Array_init<Nat>(256 * 1024 * 1024, 2); // 3GB
+        array3 := Prim.Array_init<Nat>(150 * 1024 * 1024, 3); // around 3.75GB
+        Prim.debugPrint("Prepared2 " # debug_show (Prim.rts_memory_size()));
+    };
+
+    public composite query func allocateInCompositeQuery() : async () {
+        ignore Prim.Array_init<Nat>(50 * 1024 * 1024, 4);
+        Prim.debugPrint("Composite query call " # debug_show (Prim.rts_memory_size()));
+        assert (Prim.rts_memory_size() > 3840 * 1024 * 1024);
+        await nestedQuery();
+        ignore Prim.Array_init<Nat>(5 * 1024 * 1024, 4);
+        Prim.debugPrint("Composite query callback " # debug_show (Prim.rts_memory_size()));
+        assert (Prim.rts_memory_size() > 3840 * 1024 * 1024);
+    };
+
+    public query func nestedQuery() : async () {
+        Prim.debugPrint("Nested query " # debug_show (Prim.rts_memory_size()));
+    };
+};
+
+//SKIP run
+//SKIP run-ir
+//SKIP run-low
diff --git a/test/run-drun-non-ci/memory-reserve-query.drun b/test/run-drun-non-ci/memory-reserve-query.drun
new file mode 100644
index 00000000000..d076edb417a
--- /dev/null
+++ b/test/run-drun-non-ci/memory-reserve-query.drun
@@ -0,0 +1,6 @@
+# INCREMENTAL-GC-ONLY
+# SKIP ic-ref-run
+install $ID memory-reserve-query/memory-reserve-query.mo ""
+ingress $ID prepare1 "DIDL\x00\x00"
+ingress $ID prepare2 "DIDL\x00\x00"
+query $ID allocateInQuery "DIDL\x00\x00"
diff --git a/test/run-drun-non-ci/memory-reserve-query/memory-reserve-query.mo b/test/run-drun-non-ci/memory-reserve-query/memory-reserve-query.mo
new file mode 100644
index 00000000000..b50b802cb6c
--- /dev/null
+++ b/test/run-drun-non-ci/memory-reserve-query/memory-reserve-query.mo
@@ -0,0 +1,31 @@
+import Prim "mo:⛔";
+actor {
+    stable var stableData = Prim.Array_tabulate<Nat>(1024 * 1024, func(index) { index });
+    var array0 : [var Nat] = [var];
+    var array1 : [var Nat] = [var];
+    var array2 : [var Nat] = [var];
+    var array3 : [var Nat] = [var];
+    Prim.debugPrint("Initialized " # debug_show (Prim.rts_memory_size()));
+
+    public func prepare1() : async () {
+        array0 := Prim.Array_init<Nat>(256 * 1024 * 1024, 0); // 1GB
+        array1 := Prim.Array_init<Nat>(256 * 1024 * 1024, 1); // 2GB
+        Prim.debugPrint("Prepared1 " # debug_show (Prim.rts_memory_size()));
+    };
+
+    public func prepare2() : async () {
+        array2 := Prim.Array_init<Nat>(256 * 1024 * 1024, 2); // 3GB
+        array3 := Prim.Array_init<Nat>(150 * 1024 * 1024, 3); // around 3.75GB
+        Prim.debugPrint("Prepared2 " # debug_show (Prim.rts_memory_size()));
+    };
+
+    public query func allocateInQuery() : async () {
+        ignore Prim.Array_init<Nat>(50 * 1024 * 1024, 4);
+        Prim.debugPrint("Query call " # debug_show (Prim.rts_memory_size()));
+        assert (Prim.rts_memory_size() > 3840 * 1024 * 1024);
+    };
+};
+
+//SKIP run
+//SKIP run-ir
+//SKIP run-low
diff --git a/test/run-drun-non-ci/memory-reserve-update.drun b/test/run-drun-non-ci/memory-reserve-update.drun
new file mode 100644
index 00000000000..6d53c637928
--- /dev/null
+++ b/test/run-drun-non-ci/memory-reserve-update.drun
@@ -0,0 +1,6 @@
+# INCREMENTAL-GC-ONLY
+# SKIP ic-ref-run
+install $ID memory-reserve-update/memory-reserve-update.mo ""
+ingress $ID prepare1 "DIDL\x00\x00"
+ingress $ID prepare2 "DIDL\x00\x00"
+ingress $ID allocateInUpdate "DIDL\x00\x00"
diff --git a/test/run-drun-non-ci/memory-reserve-update/memory-reserve-update.mo b/test/run-drun-non-ci/memory-reserve-update/memory-reserve-update.mo
new file mode 100644
index 00000000000..cc8f3aaeb38
--- /dev/null
+++ b/test/run-drun-non-ci/memory-reserve-update/memory-reserve-update.mo
@@ -0,0 +1,30 @@
+import Prim "mo:⛔";
+actor {
+    stable var stableData = Prim.Array_tabulate<Nat>(1024 * 1024, func(index) { index });
+    var array0 : [var Nat] = [var];
+    var array1 : [var Nat] = [var];
+    var array2 : [var Nat] = [var];
+    var array3 : [var Nat] = [var];
+    Prim.debugPrint("Initialized " # debug_show (Prim.rts_memory_size()));
+
+    public func prepare1() : async () {
+        array0 := Prim.Array_init<Nat>(256 * 1024 * 1024, 0); // 1GB
+        array1 := Prim.Array_init<Nat>(256 * 1024 * 1024, 1); // 2GB
+        Prim.debugPrint("Prepared1 " # debug_show (Prim.rts_memory_size()));
+    };
+
+    public func prepare2() : async () {
+        array2 := Prim.Array_init<Nat>(256 * 1024 * 1024, 2); // 3GB
+        array3 := Prim.Array_init<Nat>(150 * 1024 * 1024, 3); // around 3.75GB
+        Prim.debugPrint("Prepared2 " # debug_show (Prim.rts_memory_size()));
+    };
+
+    public func allocateInUpdate() : async () {
+        Prim.debugPrint("Update call " # debug_show (Prim.rts_memory_size()));
+        ignore Prim.Array_init<Nat>(50 * 1024 * 1024, 4);
+    };
+};
+
+//SKIP run
+//SKIP run-ir
+//SKIP run-low
diff --git a/test/run-drun-non-ci/memory-reserve-upgrade.drun b/test/run-drun-non-ci/memory-reserve-upgrade.drun
new file mode 100644
index 00000000000..f791e8fd882
--- /dev/null
+++ b/test/run-drun-non-ci/memory-reserve-upgrade.drun
@@ -0,0 +1,6 @@
+# INCREMENTAL-GC-ONLY
+# SKIP ic-ref-run
+install $ID memory-reserve-upgrade/memory-reserve-upgrade.mo ""
+ingress $ID prepare1 "DIDL\x00\x00"
+ingress $ID prepare2 "DIDL\x00\x00"
+upgrade $ID memory-reserve-upgrade/memory-reserve-upgrade.mo ""
diff --git a/test/run-drun-non-ci/memory-reserve-upgrade/memory-reserve-upgrade.mo b/test/run-drun-non-ci/memory-reserve-upgrade/memory-reserve-upgrade.mo
new file mode 100644
index 00000000000..85cef10b07c
--- /dev/null
+++ b/test/run-drun-non-ci/memory-reserve-upgrade/memory-reserve-upgrade.mo
@@ -0,0 +1,25 @@
+import Prim "mo:⛔";
+actor {
+    stable var stableData = Prim.Array_tabulate<Nat>(1024 * 1024, func(index) { index });
+    var array0 : [var Nat] = [var];
+    var array1 : [var Nat] = [var];
+    var array2 : [var Nat] = [var];
+    var array3 : [var Nat] = [var];
+    Prim.debugPrint("Initialized " # debug_show (Prim.rts_memory_size()));
+
+    public func prepare1() : async () {
+        array0 := Prim.Array_init<Nat>(256 * 1024 * 1024, 0); // 1GB
+        array1 := Prim.Array_init<Nat>(256 * 1024 * 1024, 1); // 2GB
+        Prim.debugPrint("Prepared1 " # debug_show (Prim.rts_memory_size()));
+    };
+
+    public func prepare2() : async () {
+        array2 := Prim.Array_init<Nat>(256 * 1024 * 1024, 2); // 3GB
+        array3 := Prim.Array_init<Nat>(150 * 1024 * 1024, 3); // around 3.75GB
+        Prim.debugPrint("Prepared2 " # debug_show (Prim.rts_memory_size()));
+    };
+};
+
+//SKIP run
+//SKIP run-ir
+//SKIP run-low
diff --git a/test/run.sh b/test/run.sh
index fe377512ebe..34fd3d36be4 100755
--- a/test/run.sh
+++ b/test/run.sh
@@ -435,6 +435,14 @@ do
         continue
       fi
 
+      if grep -q "# *INCREMENTAL-GC-ONLY" $(basename $file)
+      then
+        if [[ $EXTRA_MOC_ARGS != *"--incremental-gc"* ]]
+        then 
+          continue
+        fi
+      fi
+
       have_var_name="HAVE_${runner//-/_}"
       if [ ${!have_var_name} != yes ]
       then

From cf9a37d96dc89ed05da3d15c678a8c4d6e5f5934 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Wed, 27 Sep 2023 11:59:22 +0200
Subject: [PATCH 128/260] Optimize field search

---
 rts/motoko-rts/src/persistence.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/rts/motoko-rts/src/persistence.rs b/rts/motoko-rts/src/persistence.rs
index bb72d9b6f03..0d8393b4407 100644
--- a/rts/motoko-rts/src/persistence.rs
+++ b/rts/motoko-rts/src/persistence.rs
@@ -176,8 +176,10 @@ pub unsafe extern "C" fn contains_field(actor: Value, field_hash: u32) -> bool {
     let mut current_address = hash_blob.payload_const() as u32;
     for _ in 0..number_of_fields {
         let hash_address = current_address as *mut u32;
-        if *hash_address == field_hash {
-            return true;
+        let hash_value = *hash_address;
+        // The hash sequence is sorted: Stop when the hash matches or cannot exist.
+        if hash_value >= field_hash {
+            return hash_value == field_hash;
         }
         current_address += WORD_SIZE;
     }

From 43bde5d449471060c847e92634a3ebf85c8dea86 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Wed, 27 Sep 2023 16:01:15 +0200
Subject: [PATCH 129/260] Improve memory compatibility check

---
 rts/motoko-rts/src/idl.rs                     | 380 +++++++++++++++---
 .../src/persistence/compatibility.rs          |   7 +-
 src/codegen/compile.ml                        |  37 +-
 test/bench/ok/bignum.drun-run-opt.ok          |   2 +-
 test/bench/ok/bignum.drun-run.ok              |   2 +-
 test/run-drun/blob-array-mismatch.drun        |   6 +
 test/run-drun/blob-array-mismatch/version0.mo |   3 +
 test/run-drun/blob-array-mismatch/version1.mo |   3 +
 test/run-drun/more-function-upgrades.drun     |   4 +
 .../more-function-upgrades/version0.mo        |   4 +
 .../more-function-upgrades/version1.mo        |   4 +
 .../more-function-upgrades/version2.mo        |   4 +
 test/run-drun/ok/blob-array-mismatch.drun.ok  |   7 +
 .../ok/more-function-upgrades.drun.ok         |   5 +
 14 files changed, 397 insertions(+), 71 deletions(-)
 create mode 100644 test/run-drun/blob-array-mismatch.drun
 create mode 100644 test/run-drun/blob-array-mismatch/version0.mo
 create mode 100644 test/run-drun/blob-array-mismatch/version1.mo
 create mode 100644 test/run-drun/more-function-upgrades.drun
 create mode 100644 test/run-drun/more-function-upgrades/version0.mo
 create mode 100644 test/run-drun/more-function-upgrades/version1.mo
 create mode 100644 test/run-drun/more-function-upgrades/version2.mo
 create mode 100644 test/run-drun/ok/blob-array-mismatch.drun.ok
 create mode 100644 test/run-drun/ok/more-function-upgrades.drun.ok

diff --git a/rts/motoko-rts/src/idl.rs b/rts/motoko-rts/src/idl.rs
index 4fb356e74dc..2f601ba810f 100644
--- a/rts/motoko-rts/src/idl.rs
+++ b/rts/motoko-rts/src/idl.rs
@@ -42,6 +42,7 @@ const IDL_CON_service: i32 = -23;
 
 const IDL_REF_principal: i32 = -24;
 const IDL_EXT_region: i32 = -128;
+const IDL_EXT_blob: i32 = -129;
 
 const IDL_CON_alias: i32 = 1;
 
@@ -52,7 +53,11 @@ pub unsafe fn leb128_decode_ptr(buf: *mut Buf) -> (u32, *mut u8) {
 }
 
 unsafe fn is_primitive_type(ty: i32) -> bool {
-    ty < 0 && (ty >= IDL_PRIM_lowest || ty == IDL_REF_principal || ty == IDL_EXT_region)
+    ty < 0
+        && (ty >= IDL_PRIM_lowest
+            || ty == IDL_REF_principal
+            || ty == IDL_EXT_region
+            || ty == IDL_EXT_blob)
 }
 
 // TBR; based on Text.text_compare
@@ -539,12 +544,316 @@ unsafe fn is_opt_reserved(typtbl: *mut *mut u8, end: *mut u8, t: i32) -> bool {
     return t == IDL_CON_opt;
 }
 
-#[derive(Clone, Copy)]
-pub enum CompatibilityMode {
-    // Conventional Candid deserialization compatibility.
-    Candid,
-    // Memory compatibility for orthogonal persistence.
-    Persistence,
+#[derive(PartialEq, Clone, Copy, Debug)]
+pub(crate) enum TypeVariance {
+    Covariance,
+    Contravariance,
+    Invariance,
+}
+
+impl TypeVariance {
+    fn invert(self) -> TypeVariance {
+        match self {
+            TypeVariance::Covariance => TypeVariance::Contravariance,
+            TypeVariance::Contravariance => TypeVariance::Covariance,
+            TypeVariance::Invariance => TypeVariance::Invariance,
+        }
+    }
+}
+
+unsafe fn recurring_memory_check(cache: &BitRel, variance: TypeVariance, t1: u32, t2: u32) -> bool {
+    match variance {
+        TypeVariance::Covariance => cache.visited(true, t1, t2),
+        TypeVariance::Contravariance => cache.visited(false, t1, t2),
+        TypeVariance::Invariance => cache.visited(true, t1, t2) && cache.visited(false, t2, t1),
+    }
+}
+
+unsafe fn remember_memory_check(cache: &BitRel, variance: TypeVariance, t1: u32, t2: u32) {
+    match variance {
+        TypeVariance::Covariance => cache.visit(true, t1, t2),
+        TypeVariance::Contravariance => cache.visit(false, t1, t2),
+        TypeVariance::Invariance => {
+            cache.visit(true, t1, t2);
+            cache.visit(false, t2, t1);
+        }
+    }
+}
+
+/// Memory compatibility check for orthogonal persistence.
+/// Checks whether the new type (`typetbl2`) is compatible to the old type (`typetbl1`).
+/// The implementation is similar to the Candid sub-type test `sub()` below, however,
+/// with some relevant differences w.r.t. the permitted type relations:
+/// * Support of variable (MutBox) with type invariance.
+/// * Types cannot be made optional (no insertion of Option).
+/// * Same arity for function parameters and function return types.
+/// * Records cannot introduce additional optional fields.
+pub(crate) unsafe fn memory_compatible(
+    rel: &BitRel,
+    variance: TypeVariance,
+    typtbl1: *mut *mut u8,
+    typtbl2: *mut *mut u8,
+    end1: *mut u8,
+    end2: *mut u8,
+    t1: i32,
+    t2: i32,
+    main_actor: bool,
+) -> bool {
+    if t1 >= 0 && t2 >= 0 {
+        let t1 = t1 as u32;
+        let t2 = t2 as u32;
+        if recurring_memory_check(rel, variance, t1, t2) {
+            return true;
+        };
+        remember_memory_check(rel, variance, t1, t2);
+    };
+
+    /* primitives reflexive */
+    if is_primitive_type(t1) && is_primitive_type(t2) && t1 == t2 {
+        return true;
+    }
+
+    // unfold t1, if necessary
+    let mut tb1 = Buf {
+        ptr: if t1 < 0 {
+            end1
+        } else {
+            *typtbl1.add(t1 as usize)
+        },
+        end: end1,
+    };
+
+    let u1 = if t1 >= 0 {
+        sleb128_decode(&mut tb1)
+    } else {
+        t1
+    };
+
+    // unfold t2, if necessary
+    let mut tb2 = Buf {
+        ptr: if t2 < 0 {
+            end2
+        } else {
+            *typtbl2.add(t2 as usize)
+        },
+        end: end2,
+    };
+
+    let u2 = if t2 >= 0 {
+        sleb128_decode(&mut tb2)
+    } else {
+        t2
+    };
+
+    match (u1, u2) {
+        (IDL_CON_alias, IDL_CON_alias) => {
+            let t11 = sleb128_decode(&mut tb1);
+            let t21 = sleb128_decode(&mut tb2);
+            // invariance
+            memory_compatible(
+                rel,
+                TypeVariance::Invariance,
+                typtbl1,
+                typtbl2,
+                end1,
+                end2,
+                t11,
+                t21,
+                false,
+            )
+        }
+        (IDL_PRIM_reserved, IDL_PRIM_reserved) | (IDL_PRIM_empty, IDL_PRIM_empty) => true,
+        (_, IDL_PRIM_reserved) | (IDL_PRIM_empty, _) | (IDL_PRIM_nat, IDL_PRIM_int) => {
+            variance != TypeVariance::Invariance
+        }
+        (_, IDL_CON_alias) | (IDL_CON_alias, _) => false,
+        (IDL_CON_opt, IDL_CON_opt) => {
+            let t11 = sleb128_decode(&mut tb1);
+            let t21 = sleb128_decode(&mut tb2);
+            memory_compatible(rel, variance, typtbl1, typtbl2, end1, end2, t11, t21, false)
+        }
+        (_, IDL_CON_opt) => false,
+        (IDL_CON_vec, IDL_CON_vec) => {
+            let t11 = sleb128_decode(&mut tb1);
+            let t21 = sleb128_decode(&mut tb2);
+            memory_compatible(rel, variance, typtbl1, typtbl2, end1, end2, t11, t21, false)
+        }
+        (IDL_CON_func, IDL_CON_func) => {
+            // contra in domain
+            let in1 = leb128_decode(&mut tb1);
+            let in2 = leb128_decode(&mut tb2);
+            if in1 != in2 {
+                return false;
+            }
+            for _ in 0..in1 {
+                let t11 = sleb128_decode(&mut tb1);
+                let t21 = sleb128_decode(&mut tb2);
+                // NB: invert p and args!
+                if !memory_compatible(
+                    rel,
+                    variance.invert(),
+                    typtbl2,
+                    typtbl1,
+                    end2,
+                    end1,
+                    t21,
+                    t11,
+                    false,
+                ) {
+                    return false;
+                }
+            }
+            // co in range
+            let out1 = leb128_decode(&mut tb1);
+            let out2 = leb128_decode(&mut tb2);
+            if out1 != out2 {
+                return false;
+            }
+            for _ in 0..out2 {
+                let t21 = sleb128_decode(&mut tb2);
+                let t11 = sleb128_decode(&mut tb1);
+                if !memory_compatible(rel, variance, typtbl1, typtbl2, end1, end2, t11, t21, false)
+                {
+                    return false;
+                }
+            }
+            // check annotations (that we care about)
+            // TODO: more generally, we would check equality of 256-bit bit-vectors,
+            // but validity ensures each entry is 1, 2 or 3 (for now)
+            // c.f. https://github.com/dfinity/candid/issues/318
+            let mut a11 = false;
+            let mut a12 = false;
+            let mut a13 = false;
+            for _ in 0..leb128_decode(&mut tb1) {
+                match read_byte(&mut tb1) {
+                    1 => a11 = true,
+                    2 => a12 = true,
+                    3 => a13 = true,
+                    _ => {}
+                }
+            }
+            let mut a21 = false;
+            let mut a22 = false;
+            let mut a23 = false;
+            for _ in 0..leb128_decode(&mut tb2) {
+                match read_byte(&mut tb2) {
+                    1 => a21 = true,
+                    2 => a22 = true,
+                    3 => a23 = true,
+                    _ => {}
+                }
+            }
+            a11 == a21 && a12 == a22 && a13 == a23
+        }
+        (IDL_CON_record, IDL_CON_record) => {
+            let mut n1 = leb128_decode(&mut tb1);
+            let n2 = leb128_decode(&mut tb2);
+            let mut tag1 = 0;
+            let mut t11 = 0;
+            let mut advance = true;
+            for _ in 0..n2 {
+                let tag2 = leb128_decode(&mut tb2);
+                let t21 = sleb128_decode(&mut tb2);
+                if n1 == 0 {
+                    // Optional additional fields are only supported in the main actor type.
+                    if !main_actor || !is_opt_reserved(typtbl2, end2, t21) {
+                        return false;
+                    }
+                    continue;
+                };
+                if advance {
+                    loop {
+                        tag1 = leb128_decode(&mut tb1);
+                        t11 = sleb128_decode(&mut tb1);
+                        n1 -= 1;
+                        if !(tag1 < tag2 && n1 > 0) {
+                            break;
+                        }
+                    }
+                };
+                if tag1 > tag2 {
+                    // Optional additional fields are only supported in the main actor type.
+                    if !main_actor || !is_opt_reserved(typtbl2, end2, t21) {
+                        return false;
+                    }
+                    advance = false; // reconsider this field in next round
+                    continue;
+                };
+                if !memory_compatible(rel, variance, typtbl1, typtbl2, end1, end2, t11, t21, false)
+                {
+                    return false;
+                }
+                advance = true;
+            }
+            variance != TypeVariance::Invariance || n1 == 0
+        }
+        (IDL_CON_variant, IDL_CON_variant) => {
+            let n1 = leb128_decode(&mut tb1);
+            let mut n2 = leb128_decode(&mut tb2);
+            for _ in 0..n1 {
+                if n2 == 0 {
+                    return false;
+                };
+                let tag1 = leb128_decode(&mut tb1);
+                let t11 = sleb128_decode(&mut tb1);
+                let mut tag2: u32;
+                let mut t21: i32;
+                loop {
+                    tag2 = leb128_decode(&mut tb2);
+                    t21 = sleb128_decode(&mut tb2);
+                    n2 -= 1;
+                    if !(tag2 < tag1 && n2 > 0) {
+                        break;
+                    }
+                }
+                if tag1 != tag2 {
+                    return false;
+                }
+                if !memory_compatible(rel, variance, typtbl1, typtbl2, end1, end2, t11, t21, false)
+                {
+                    return false;
+                }
+            }
+            variance != TypeVariance::Invariance || n2 == 0
+        }
+        (IDL_CON_service, IDL_CON_service) => {
+            let mut n1 = leb128_decode(&mut tb1);
+            let n2 = leb128_decode(&mut tb2);
+            for _ in 0..n2 {
+                if n1 == 0 {
+                    return false;
+                };
+                let (len2, p2) = leb128_decode_ptr(&mut tb2);
+                Buf::advance(&mut tb2, len2);
+                let t21 = sleb128_decode(&mut tb2);
+                let mut len1: u32;
+                let mut p1: *mut u8;
+                let mut t11: i32;
+                let mut cmp: i32;
+                loop {
+                    (len1, p1) = leb128_decode_ptr(&mut tb1);
+                    Buf::advance(&mut tb1, len1);
+                    t11 = sleb128_decode(&mut tb1);
+                    n1 -= 1;
+                    cmp = utf8_cmp(len1, p1, len2, p2);
+                    if cmp < 0 && n1 > 0 {
+                        continue;
+                    };
+                    break;
+                }
+                if cmp != 0 {
+                    return false;
+                };
+                if !memory_compatible(rel, variance, typtbl1, typtbl2, end1, end2, t11, t21, false)
+                {
+                    return false;
+                }
+            }
+            variance != TypeVariance::Invariance || n1 == 0
+        }
+        // default
+        (_, _) => false,
+    }
 }
 
 // TODO: consider storing fixed args typtbl1...end2 in `rel` to use less stack.
@@ -557,7 +866,6 @@ pub(crate) unsafe fn sub(
     end2: *mut u8,
     t1: i32,
     t2: i32,
-    mode: CompatibilityMode,
 ) -> bool {
     if t1 >= 0 && t2 >= 0 {
         let t1 = t1 as u32;
@@ -613,48 +921,15 @@ pub(crate) unsafe fn sub(
     // exit either via 'return true' or 'break 'return_false' to memoize the negative result
     'return_false: loop {
         match (u1, u2) {
-            (IDL_CON_alias, IDL_CON_alias) => match mode {
-                CompatibilityMode::Candid => idl_trap_with("sub: unexpected alias"),
-                CompatibilityMode::Persistence => {
-                    let t11 = sleb128_decode(&mut tb1);
-                    let t21 = sleb128_decode(&mut tb2);
-                    // invariance
-                    if sub(rel, p, typtbl1, typtbl2, end1, end2, t11, t21, mode)
-                        && sub(rel, !p, typtbl2, typtbl1, end2, end1, t21, t11, mode)
-                    {
-                        return true;
-                    } else {
-                        break 'return_false;
-                    }
-                }
-            },
-            (_, IDL_PRIM_reserved) | (IDL_PRIM_empty, _) | (IDL_PRIM_nat, IDL_PRIM_int) => {
-                return true
-            }
-            (_, IDL_CON_alias) | (IDL_CON_alias, _) => match mode {
-                CompatibilityMode::Candid => idl_trap_with("sub: unexpected alias"),
-                CompatibilityMode::Persistence => return false,
-            },
-            (IDL_CON_opt, IDL_CON_opt) => match mode {
-                CompatibilityMode::Candid => return true,
-                CompatibilityMode::Persistence => {
-                    let t11 = sleb128_decode(&mut tb1);
-                    let t21 = sleb128_decode(&mut tb2);
-                    if sub(rel, p, typtbl1, typtbl2, end1, end2, t11, t21, mode) {
-                        return true;
-                    } else {
-                        break 'return_false;
-                    }
-                }
-            },
-            (_, IDL_CON_opt) => match mode {
-                CompatibilityMode::Candid => return true,
-                CompatibilityMode::Persistence => return false,
-            },
+            (_, IDL_CON_alias) | (IDL_CON_alias, _) => idl_trap_with("sub: unexpected alias"),
+            (_, IDL_PRIM_reserved)
+            | (IDL_PRIM_empty, _)
+            | (IDL_PRIM_nat, IDL_PRIM_int)
+            | (_, IDL_CON_opt) => return true, // apparently, this is admissable
             (IDL_CON_vec, IDL_CON_vec) => {
                 let t11 = sleb128_decode(&mut tb1);
                 let t21 = sleb128_decode(&mut tb2);
-                if sub(rel, p, typtbl1, typtbl2, end1, end2, t11, t21, mode) {
+                if sub(rel, p, typtbl1, typtbl2, end1, end2, t11, t21) {
                     return true;
                 } else {
                     break 'return_false;
@@ -674,7 +949,7 @@ pub(crate) unsafe fn sub(
                         let t21 = sleb128_decode(&mut tb2);
                         in2 -= 1;
                         // NB: invert p and args!
-                        if !sub(rel, !p, typtbl2, typtbl1, end2, end1, t21, t11, mode) {
+                        if !sub(rel, !p, typtbl2, typtbl1, end2, end1, t21, t11) {
                             break 'return_false;
                         }
                     }
@@ -695,7 +970,7 @@ pub(crate) unsafe fn sub(
                     } else {
                         let t11 = sleb128_decode(&mut tb1);
                         out1 -= 1;
-                        if !sub(rel, p, typtbl1, typtbl2, end1, end2, t11, t21, mode) {
+                        if !sub(rel, p, typtbl1, typtbl2, end1, end2, t11, t21) {
                             break 'return_false;
                         }
                     }
@@ -770,7 +1045,7 @@ pub(crate) unsafe fn sub(
                         advance = false; // reconsider this field in next round
                         continue;
                     };
-                    if !sub(rel, p, typtbl1, typtbl2, end1, end2, t11, t21, mode) {
+                    if !sub(rel, p, typtbl1, typtbl2, end1, end2, t11, t21) {
                         break 'return_false;
                     }
                     advance = true;
@@ -799,7 +1074,7 @@ pub(crate) unsafe fn sub(
                     if tag1 != tag2 {
                         break 'return_false;
                     };
-                    if !sub(rel, p, typtbl1, typtbl2, end1, end2, t11, t21, mode) {
+                    if !sub(rel, p, typtbl1, typtbl2, end1, end2, t11, t21) {
                         break 'return_false;
                     }
                 }
@@ -833,7 +1108,7 @@ pub(crate) unsafe fn sub(
                     if cmp != 0 {
                         break 'return_false;
                     };
-                    if !sub(rel, p, typtbl1, typtbl2, end1, end2, t11, t21, mode) {
+                    if !sub(rel, p, typtbl1, typtbl2, end1, end2, t11, t21) {
                         break 'return_false;
                     }
                 }
@@ -901,6 +1176,5 @@ unsafe extern "C" fn idl_sub(
         typtbl_end2,
         t1,
         t2,
-        CompatibilityMode::Candid,
     );
 }
diff --git a/rts/motoko-rts/src/persistence/compatibility.rs b/rts/motoko-rts/src/persistence/compatibility.rs
index 54b9c98962d..67ba50688df 100644
--- a/rts/motoko-rts/src/persistence/compatibility.rs
+++ b/rts/motoko-rts/src/persistence/compatibility.rs
@@ -6,6 +6,7 @@ use crate::{
     barriers::write_with_barrier,
     bitrel::BitRel,
     constants::WORD_SIZE,
+    idl::TypeVariance,
     memory::{alloc_blob, Memory},
     types::{Value, Words},
 };
@@ -145,15 +146,15 @@ pub unsafe fn memory_compatible<M: Memory>(
     let new_type_table = new_type.build_type_table(mem);
     let new_table_end = new_type.type_table_end();
 
-    crate::idl::sub(
+    crate::idl::memory_compatible(
         &cache,
-        true,
+        TypeVariance::Covariance,
         old_type_table,
         new_type_table,
         old_table_end,
         new_table_end,
         old_type.main_actor_index,
         new_type.main_actor_index,
-        crate::idl::CompatibilityMode::Persistence,
+        true,
     )
 }
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index ca4deaa5e9e..2c79fe8e1e3 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -5696,7 +5696,12 @@ module MakeSerialization (Strm : Stream) = struct
   *)
 
   module TM = Map.Make (Type.Ord)
-  let to_idl_prim = let open Type in function
+
+  type mode =
+    | Candid
+    | Persistence
+
+  let to_idl_prim mode = let open Type in function
     | Prim Null | Tup [] -> Some 1l
     | Prim Bool -> Some 2l
     | Prim Nat -> Some 3l
@@ -5716,6 +5721,11 @@ module MakeSerialization (Strm : Stream) = struct
     | Non -> Some 17l
     | Prim Principal -> Some 24l
     | Prim Region -> Some 128l
+    (* only used for memory compatibility checks *)
+    | Prim Blob -> 
+      (match mode with
+      | Candid -> None
+      | Persistence -> Some 129l)
     | _ -> None
 
   (* some constants, also see rts/idl.c *)
@@ -5728,7 +5738,7 @@ module MakeSerialization (Strm : Stream) = struct
   let idl_alias     = 1l (* see Note [mutable stable values] *)
 
   (* TODO: use record *)
-  let type_desc env ts :
+  let type_desc env mode ts :
      string * int list * int32 list  (* type_desc, (relative offsets), indices of ts *)
     =
     let open Type in
@@ -5740,7 +5750,7 @@ module MakeSerialization (Strm : Stream) = struct
       let idx = ref TM.empty in
       let rec go t =
         let t = Type.normalize t in
-        if to_idl_prim t <> None then () else
+        if to_idl_prim mode t <> None then () else
         if TM.mem t !idx then () else begin
           idx := TM.add t (Lib.List32.length !typs) !idx;
           typs := !typs @ [ t ];
@@ -5799,20 +5809,21 @@ module MakeSerialization (Strm : Stream) = struct
 
     let add_idx t =
       let t = Type.normalize t in
-      match to_idl_prim t with
+      match to_idl_prim mode t with
       | Some i -> add_sleb128 (Int32.neg i)
       | None -> add_sleb128 (TM.find (normalize t) idx) in
 
     let idx t =
       let t = Type.normalize t in
-      match to_idl_prim t with
+      match to_idl_prim mode t with
       | Some i -> Int32.neg i
       | None -> TM.find (normalize t) idx in
 
     let rec add_typ t =
       match t with
       | Non -> assert false
-      | Prim Blob ->
+      | Prim Blob -> 
+        assert (mode = Candid);
         add_typ Type.(Array (Prim Nat8))
       | Prim Region ->
         add_sleb128 idl_alias; add_idx t
@@ -5890,7 +5901,7 @@ module MakeSerialization (Strm : Stream) = struct
 
   (* See Note [Candid subtype checks] *)
   let set_delayed_globals (env : E.t) (set_typtbl, set_typtbl_end, set_typtbl_size, set_typtbl_idltyps) =
-    let typdesc, offsets, idltyps = type_desc env (E.get_typtbl_typs env) in
+    let typdesc, offsets, idltyps = type_desc env Candid (E.get_typtbl_typs env) in
     let static_typedesc = E.add_static_unskewed env [StaticBytes.Bytes typdesc] in
     let static_typtbl =
       let bytes = StaticBytes.i32s
@@ -6405,7 +6416,7 @@ module MakeSerialization (Strm : Stream) = struct
       (* returns true if we are looking at primitive type with this id *)
       let check_prim_typ t =
         get_idltyp ^^
-        compile_eq_const (Int32.neg (Option.get (to_idl_prim t)))
+        compile_eq_const (Int32.neg (Option.get (to_idl_prim Candid t)))
       in
 
       let with_prim_typ t f =
@@ -6554,7 +6565,7 @@ module MakeSerialization (Strm : Stream) = struct
         begin
           (* sanity check *)
           get_arg_typ ^^
-          compile_eq_const (Int32.neg (Option.get (to_idl_prim (Prim Region)))) ^^
+          compile_eq_const (Int32.neg (Option.get (to_idl_prim Candid (Prim Region)))) ^^
           E.else_trap_with env "IDL error: unexpecting primitive alias type" ^^
           get_arg_typ
         end
@@ -6815,7 +6826,7 @@ module MakeSerialization (Strm : Stream) = struct
           let (set_region, get_region) = new_local env "region" in
           (* sanity check *)
           get_region_typ ^^
-          compile_eq_const (Int32.neg (Option.get (to_idl_prim (Prim Region)))) ^^
+          compile_eq_const (Int32.neg (Option.get (to_idl_prim Candid (Prim Region)))) ^^
           E.else_trap_with env "deserialize_go (Region): unexpected idl_typ" ^^
           (* pre-allocate a region object, with dummy fields *)
           compile_const_64 0L ^^ (* id *)
@@ -6996,7 +7007,7 @@ module MakeSerialization (Strm : Stream) = struct
       let (set_data_size, get_data_size) = new_local env "data_size" in
       let (set_refs_size, get_refs_size) = new_local env "refs_size" in
 
-      let (tydesc, _offsets, _idltyps) = type_desc env ts in
+      let (tydesc, _offsets, _idltyps) = type_desc env Candid ts in
       let tydesc_len = Int32.of_int (String.length tydesc) in
 
       (* Get object sizes *)
@@ -7642,7 +7653,7 @@ module Persistence = struct
   let free_stable_actor env = E.call_import env "rts" "free_stable_actor"
 
   let register_stable_type env actor_type =
-    let (candid_type_desc, type_offsets, type_indices) = Serialization.type_desc env [actor_type] in
+    let (candid_type_desc, type_offsets, type_indices) = Serialization.(type_desc env Persistence [actor_type]) in
     let serialized_offsets = StaticBytes.(as_bytes [i32s (List.map Int32.of_int type_offsets)]) in
     assert ((List.length type_indices) = 1);
     Blob.lit env candid_type_desc ^^
@@ -10011,7 +10022,7 @@ and compile_prim_invocation (env : E.t) ae p es at =
 
   | ICStableSize t, [e] ->
     SR.UnboxedWord64,
-    let (tydesc, _, _) = Serialization.type_desc env [t] in
+    let (tydesc, _, _) = Serialization.(type_desc env Candid [t]) in
     let tydesc_len = Int32.of_int (String.length tydesc) in
     compile_exp_vanilla env ae e ^^
     Serialization.buffer_size env t ^^
diff --git a/test/bench/ok/bignum.drun-run-opt.ok b/test/bench/ok/bignum.drun-run-opt.ok
index 4074ccf86df..ef39fa426e0 100644
--- a/test/bench/ok/bignum.drun-run-opt.ok
+++ b/test/bench/ok/bignum.drun-run-opt.ok
@@ -2,5 +2,5 @@ ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a000000000000000001
 ingress Completed: Reply: 0x4449444c0000
 debug.print: {cycles = 2_413_690; size = +60_608}
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 103_321_242; size = +1_827_460}
+debug.print: {cycles = 103_321_244; size = +1_827_460}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/bignum.drun-run.ok b/test/bench/ok/bignum.drun-run.ok
index 8804a130c9f..6a8519e430d 100644
--- a/test/bench/ok/bignum.drun-run.ok
+++ b/test/bench/ok/bignum.drun-run.ok
@@ -2,5 +2,5 @@ ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a000000000000000001
 ingress Completed: Reply: 0x4449444c0000
 debug.print: {cycles = 2_519_183; size = +60_608}
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 103_375_902; size = +1_827_460}
+debug.print: {cycles = 103_375_904; size = +1_827_460}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/blob-array-mismatch.drun b/test/run-drun/blob-array-mismatch.drun
new file mode 100644
index 00000000000..140a273175a
--- /dev/null
+++ b/test/run-drun/blob-array-mismatch.drun
@@ -0,0 +1,6 @@
+install $ID blob-array-mismatch/version0.mo ""
+upgrade $ID blob-array-mismatch/version0.mo ""
+upgrade $ID blob-array-mismatch/version1.mo ""
+reinstall $ID blob-array-mismatch/version1.mo ""
+upgrade $ID blob-array-mismatch/version1.mo ""
+upgrade $ID blob-array-mismatch/version0.mo ""
diff --git a/test/run-drun/blob-array-mismatch/version0.mo b/test/run-drun/blob-array-mismatch/version0.mo
new file mode 100644
index 00000000000..d046ca830a3
--- /dev/null
+++ b/test/run-drun/blob-array-mismatch/version0.mo
@@ -0,0 +1,3 @@
+actor {
+   stable let test = "\01\02\03\03" : Blob;
+};
diff --git a/test/run-drun/blob-array-mismatch/version1.mo b/test/run-drun/blob-array-mismatch/version1.mo
new file mode 100644
index 00000000000..29e9905f906
--- /dev/null
+++ b/test/run-drun/blob-array-mismatch/version1.mo
@@ -0,0 +1,3 @@
+actor {
+   stable let test: [Nat8] = [ 0, 1, 2, 3 ];
+};
diff --git a/test/run-drun/more-function-upgrades.drun b/test/run-drun/more-function-upgrades.drun
new file mode 100644
index 00000000000..4e4e1c30411
--- /dev/null
+++ b/test/run-drun/more-function-upgrades.drun
@@ -0,0 +1,4 @@
+install $ID more-function-upgrades/version0.mo ""
+upgrade $ID more-function-upgrades/version0.mo ""
+upgrade $ID more-function-upgrades/version1.mo ""
+upgrade $ID more-function-upgrades/version2.mo ""
diff --git a/test/run-drun/more-function-upgrades/version0.mo b/test/run-drun/more-function-upgrades/version0.mo
new file mode 100644
index 00000000000..3111aae3f70
--- /dev/null
+++ b/test/run-drun/more-function-upgrades/version0.mo
@@ -0,0 +1,4 @@
+actor {
+   public shared query func test(x: ?Nat) : async () { loop {} };
+   stable let shared_function = test;
+};
diff --git a/test/run-drun/more-function-upgrades/version1.mo b/test/run-drun/more-function-upgrades/version1.mo
new file mode 100644
index 00000000000..49cef225a0e
--- /dev/null
+++ b/test/run-drun/more-function-upgrades/version1.mo
@@ -0,0 +1,4 @@
+actor {
+   public shared query func test() : async () { loop {} };
+   stable let shared_function = test;
+};
diff --git a/test/run-drun/more-function-upgrades/version2.mo b/test/run-drun/more-function-upgrades/version2.mo
new file mode 100644
index 00000000000..bc44cee409d
--- /dev/null
+++ b/test/run-drun/more-function-upgrades/version2.mo
@@ -0,0 +1,4 @@
+actor {
+   public shared query func test(x: ?Nat) : async ?Int { loop {} };
+   stable let shared_function = test;
+};
diff --git a/test/run-drun/ok/blob-array-mismatch.drun.ok b/test/run-drun/ok/blob-array-mismatch.drun.ok
new file mode 100644
index 00000000000..f5f49f31f1f
--- /dev/null
+++ b/test/run-drun/ok/blob-array-mismatch.drun.ok
@@ -0,0 +1,7 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
diff --git a/test/run-drun/ok/more-function-upgrades.drun.ok b/test/run-drun/ok/more-function-upgrades.drun.ok
new file mode 100644
index 00000000000..c46182ff707
--- /dev/null
+++ b/test/run-drun/ok/more-function-upgrades.drun.ok
@@ -0,0 +1,5 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade

From cce91a883e0d2316d5f204fc383da4c95607cf3c Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 28 Sep 2023 10:16:06 +0200
Subject: [PATCH 130/260] Delete unused source file

---
 src/codegen/persistence.ml | 283 -------------------------------------
 1 file changed, 283 deletions(-)
 delete mode 100644 src/codegen/persistence.ml

diff --git a/src/codegen/persistence.ml b/src/codegen/persistence.ml
deleted file mode 100644
index 6898ff40de7..00000000000
--- a/src/codegen/persistence.ml
+++ /dev/null
@@ -1,283 +0,0 @@
-(* Support for orthogonal persistence using stable heap and in-place memory upgrades 
-   without serialization or deserialization to secondary stable memory. *)
-
-(*
-  // The first type denotes the stable actor object.
-  // Non-primitive types are referred to by a positive index according to the type table.
-  // Primitive types are encoded by negative indices.
-  // All numbers (type indices etc.) are encoded as little endian i32.
-  <type_table> ::= length:i32 (<type>)^length
-  <type> ::= <object> | <actor> | <function> | <mutable> | <option> | <array> | <tuple> | <variant> | <none> | <any>
-  <object> ::= 1l <field_list>
-  <actor> ::= 2l <field_list>
-  <function> ::= 3l function_sort:i32 <type_list> <type_list>
-  <mutable> ::= 4l type_index:i32
-  <option> ::= 5l type_index:i32
-  <array> ::= 6l type_index:i32
-  <tuple> ::= 7l length:i32 (type_index:i32)^length
-  <variant> ::= 8l <field_list>
-  <none> ::= 9l
-  <any> ::= 10l
-  <field_list> ::= length:i32 (<field>)^length
-  <field> ::= label_hash:i32 type_index:i32
-  <type_list> ::= length:i32 <type_index:i32>^length
-  
-  // Predefined primitive type indices
-  Type      | Index
-  --------- | --------
-  Null      | -1l
-  Bool      | -2l
-  Nat       | -3l
-  Nat8      | -4l
-  Nat16     | -5l
-  Nat32     | -6l
-  Nat64     | -7l
-  Int       | -8l
-  Int8      | -9l
-  Int16     | -10l
-  Int32     | -11l
-  Int64     | -12l
-  Float     | -13l
-  Char      | -14l
-  Text      | -15l
-  Blob      | -16l
-  Principal | -17l
-  Region    | -18l
-
-
-  // Function sort
-  Sort      | Encoding
-  --------- | ---------
-  Query     | 1l
-  Write     | 2l
-  Composite | 3l
-*)
-
-open Mo_types
-
-let encode_i32 number =
-  let buffer = Buffer.create 4 in
-  Buffer.add_int32_le buffer number;
-  Buffer.contents buffer
-
-let list_to_string list = List.fold_left (^) "" list
-
-module TypeTable = struct
-  let empty = []
-
-  let length table = List.length table
-
-  let index_of table typ =
-    let rec get_index table index =
-      match table with
-      | [] -> assert false
-      | current::remainder ->
-          if Type.eq current typ then index
-          else get_index remainder (Int.add index 1) in
-    get_index table 0
-
-  let contains_type table typ =
-    match List.find_opt (fun entry -> Type.eq entry typ) table with
-    | Some _ -> true
-    | None -> false
-
-  let add_type table typ =
-    let open Type in
-    match typ with
-    | Prim _ -> table
-    | Con _ -> assert false
-    | _ -> List.append table [typ]
-end
-
-let rec resolve_generics typ type_arguments =
-  let open Type in
-  match typ with
-  | Var (_, index) -> 
-      List.nth type_arguments index
-  | Obj (sort, field_list) ->
-      Obj (sort, (resolve_field_list field_list type_arguments))
-  | Func (sort, control, bindings, parameter_list, return_list) ->
-      let resolved_parameters = resolve_type_list parameter_list type_arguments in
-      let resolved_returns = resolve_type_list return_list type_arguments in
-      Func (sort, control, bindings, resolved_parameters, resolved_returns)
-  | Variant field_list ->
-      Variant (resolve_field_list field_list type_arguments)
-  | Array element_type ->
-      Array (resolve_generics element_type type_arguments)
-  | Opt optional_type ->
-      Opt (resolve_generics optional_type type_arguments)
-  | Tup type_list ->
-      Tup (resolve_type_list type_list type_arguments)
-  | Mut mutable_type ->
-      Mut (resolve_generics mutable_type type_arguments)
-  | Con _ ->
-      promote typ
-  | Prim _ | Any | Non -> typ
-  | _ ->
-    assert false
-
-and resolve_field_list field_list type_arguments =
-  let open Type in
-  let resolve_field field = 
-    let resolved_field_type = resolve_generics field.typ type_arguments in
-    { lab = field.lab; typ = resolved_field_type; src = field.src } in
-  List.map resolve_field field_list
-
-and resolve_type_list type_list type_arguments =
-  List.map (fun typ -> resolve_generics typ type_arguments) type_list
-
-let promote_type typ =
-  let open Type in
-  match typ with
-  | Con (constructor, type_arguments) ->
-    resolve_generics (promote typ) type_arguments
-  | _ -> typ
-
-let rec collect_type table old_typ =
-  let typ = promote_type old_typ in
-  if TypeTable.contains_type table typ then
-    table
-  else
-    (let table = TypeTable.add_type table typ in
-    let open Type in
-    match typ with
-    | Prim _ | Non | Any -> table
-    | Obj (sort, field_list) when sort = Actor || sort = Object ->
-      collect_fields table field_list
-    | Func (Shared _, _, _, parameter_list, return_list) ->
-      collect_types table (List.append parameter_list return_list)
-    | Mut variable_type ->
-      collect_type table variable_type
-    | Opt optional_type ->
-      collect_type table optional_type
-    | Array element_type ->
-      collect_type table element_type
-    | Tup type_list ->
-      collect_types table type_list
-    | Variant field_list ->
-      collect_fields table field_list
-    | _ ->
-      Printf.eprintf "Unsupported persistent type %s\n" (Type.string_of_typ typ);
-      assert false)
-
-and collect_fields table field_list =
-  let open Type in
-  let field_types = List.map (fun field -> field.typ) field_list in
-  collect_types table field_types
-
-and collect_types table type_list =
-  match type_list with
-  | [] -> table
-  | first::remainder -> collect_types (collect_type table first) remainder
-  
-let encode_list encode_element list = 
-  let length = Int32.of_int (List.length list) in
-  let elements = List.map encode_element list in
-  encode_i32 length ^ list_to_string elements
-
-let primitive_type_index primitive_type =
-  let open Type in
-  match primitive_type with
-  | Null -> -1l
-  | Bool -> -2l
-  | Nat -> -3l
-  | Nat8 -> -4l
-  | Nat16 -> -5l
-  | Nat32 -> -6l
-  | Nat64 -> -7l
-  | Int -> -8l
-  | Int8 -> -9l
-  | Int16 -> -10l
-  | Int32 -> -11l
-  | Int64 -> -12l
-  | Float -> -13l
-  | Char -> -14l
-  | Text -> -15l
-  | Blob -> -16l
-  | Principal -> -17l
-  | Region -> -18l
-  | Error -> assert false (* non-stable type *)
-
-let type_index table typ =
-  let open Type in
-  let typ = promote_type typ in
-  match typ with
-  | Prim primitive_type -> primitive_type_index primitive_type
-  | _ -> Int32.of_int (TypeTable.index_of table typ)
-
-let encode_field table field =
-  let open Type in
-  let field_hash = Hash.hash field.lab in
-  encode_i32 field_hash ^ 
-  encode_i32 (type_index table field.typ)
-
-let encode_type_reference table typ =
-  encode_i32 (type_index table typ)
-
-let encode_type_list table type_list =
-  encode_list (encode_type_reference table) type_list
-
-let function_sort_code sort =
-  let open Type in
-  match sort with
-  | Query -> 1l
-  | Write -> 2l
-  | Composite -> 3l
-  
-let encode_complex_type table typ =
-  let open Type in
-  match typ with
-  | Prim _ -> assert false
-  | Obj (Object, field_list) -> 
-    encode_i32 1l ^ 
-    encode_list (encode_field table) field_list
-  | Obj (Actor, field_list) -> 
-    encode_i32 2l ^ 
-    encode_list (encode_field table) field_list
-  | Func (Shared sort, _, _, parameter_list, return_list) ->
-    encode_i32 3l ^ 
-    encode_i32 (function_sort_code sort) ^
-    encode_type_list table parameter_list ^
-    encode_type_list table return_list
-  | Mut variable_type ->
-    encode_i32 4l ^
-    encode_i32 (type_index table variable_type)
-  | Opt optional_type ->
-    encode_i32 5l ^
-    encode_i32 (type_index table optional_type)
-  | Array element_type ->
-    encode_i32 6l ^
-    encode_i32 (type_index table element_type)
-  | Tup type_list ->
-    encode_i32 7l ^
-    encode_type_list table type_list
-  | Variant field_list ->
-    encode_i32 8l ^
-    encode_list (encode_field table) field_list
-  | Non ->
-    encode_i32 9l
-  | Any ->
-    encode_i32 10l
-  | _ -> assert false
-
-let encode_type_table table =
-  encode_list (encode_complex_type table) table
-
-let unwrap_optional typ =
-  let open Type in
-  match typ with
-  | Opt inner_type -> inner_type
-  | _ -> assert false
-
-(* Encode the stable type to enable a memory compatibility check on upgrade. *)
-(* See `persistence::compatibility` in the runtime system for the encoding format. *)
-let encode_stable_type (stable_type: Type.typ) : string =
-  let open Type in 
-  match stable_type with
-  | Obj (Memory, field_list) -> 
-      let unwrap_field field = {lab = field.lab; typ = unwrap_optional field.typ; src = field.src} in
-      let stable_fields = List.map unwrap_field field_list in
-      let stable_actor = Obj (Object, stable_fields) in
-      let table = collect_type TypeTable.empty stable_actor in
-      encode_type_table table
-  | _ -> assert false

From a9756db24f02f39f4c5c4a868237a446c7990d97 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 28 Sep 2023 12:08:32 +0200
Subject: [PATCH 131/260] Downsize test

---
 test/perf/sha256.mo | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/perf/sha256.mo b/test/perf/sha256.mo
index f5dea4cfecc..d78b671d3e9 100644
--- a/test/perf/sha256.mo
+++ b/test/perf/sha256.mo
@@ -4,7 +4,7 @@ import Nat8 "./sha256/Nat8";
 actor {
   public func go() : async () {
     // 256kb already exceed the instruction limit
-    ignore SHA256.sha256(Array.tabulate(64*1024, Nat8.fromIntWrap));
+    ignore SHA256.sha256(Array.tabulate(48*1024, Nat8.fromIntWrap));
   }
 }
 //CALL ingress go 0x4449444C0000

From cd85353e055ae43e67a3600c7044e3da0bf98ad6 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 29 Sep 2023 13:19:38 +0200
Subject: [PATCH 132/260] Exempt blob tag from Candid parsing

---
 rts/motoko-rts/src/idl.rs            | 13 +++++++------
 test/bench/ok/bignum.drun-run-opt.ok |  2 +-
 test/bench/ok/bignum.drun-run.ok     |  2 +-
 3 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/rts/motoko-rts/src/idl.rs b/rts/motoko-rts/src/idl.rs
index 2f601ba810f..c9bdb924bb8 100644
--- a/rts/motoko-rts/src/idl.rs
+++ b/rts/motoko-rts/src/idl.rs
@@ -53,11 +53,12 @@ pub unsafe fn leb128_decode_ptr(buf: *mut Buf) -> (u32, *mut u8) {
 }
 
 unsafe fn is_primitive_type(ty: i32) -> bool {
-    ty < 0
-        && (ty >= IDL_PRIM_lowest
-            || ty == IDL_REF_principal
-            || ty == IDL_EXT_region
-            || ty == IDL_EXT_blob)
+    ty < 0 && (ty >= IDL_PRIM_lowest || ty == IDL_REF_principal || ty == IDL_EXT_region)
+}
+
+// Only used for memory-compatibility checks for orthogonal persistence.
+unsafe fn is_extended_primitive_type(ty: i32) -> bool {
+    is_primitive_type(ty) || ty < 0 && ty == IDL_EXT_blob
 }
 
 // TBR; based on Text.text_compare
@@ -609,7 +610,7 @@ pub(crate) unsafe fn memory_compatible(
     };
 
     /* primitives reflexive */
-    if is_primitive_type(t1) && is_primitive_type(t2) && t1 == t2 {
+    if is_extended_primitive_type(t1) && is_extended_primitive_type(t2) && t1 == t2 {
         return true;
     }
 
diff --git a/test/bench/ok/bignum.drun-run-opt.ok b/test/bench/ok/bignum.drun-run-opt.ok
index ef39fa426e0..4074ccf86df 100644
--- a/test/bench/ok/bignum.drun-run-opt.ok
+++ b/test/bench/ok/bignum.drun-run-opt.ok
@@ -2,5 +2,5 @@ ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a000000000000000001
 ingress Completed: Reply: 0x4449444c0000
 debug.print: {cycles = 2_413_690; size = +60_608}
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 103_321_244; size = +1_827_460}
+debug.print: {cycles = 103_321_242; size = +1_827_460}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/bignum.drun-run.ok b/test/bench/ok/bignum.drun-run.ok
index 6a8519e430d..8804a130c9f 100644
--- a/test/bench/ok/bignum.drun-run.ok
+++ b/test/bench/ok/bignum.drun-run.ok
@@ -2,5 +2,5 @@ ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a000000000000000001
 ingress Completed: Reply: 0x4449444c0000
 debug.print: {cycles = 2_519_183; size = +60_608}
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 103_375_904; size = +1_827_460}
+debug.print: {cycles = 103_375_902; size = +1_827_460}
 ingress Completed: Reply: 0x4449444c0000

From 4d7980172843a51c45f77b2761020b5e0a4a9ff5 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Wed, 4 Oct 2023 09:21:32 +0200
Subject: [PATCH 133/260] Resolve merge conflict

---
 rts/motoko-rts/src/idl.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rts/motoko-rts/src/idl.rs b/rts/motoko-rts/src/idl.rs
index 27414642447..027fe9e6fd1 100644
--- a/rts/motoko-rts/src/idl.rs
+++ b/rts/motoko-rts/src/idl.rs
@@ -62,7 +62,7 @@ unsafe fn is_primitive_type(extended: bool, ty: i32) -> bool {
 
 // Only used for memory-compatibility checks for orthogonal persistence.
 unsafe fn is_extended_primitive_type(ty: i32) -> bool {
-    is_primitive_type(ty) || ty < 0 && ty == IDL_EXT_blob
+    is_primitive_type(true, ty) || ty < 0 && ty == IDL_EXT_blob
 }
 
 // TBR; based on Text.text_compare

From 338ff5ef58957c128ca12d85a1ccfaabc4b56231 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 6 Oct 2023 16:52:14 +0200
Subject: [PATCH 134/260] Support memory sanity checks

---
 .../src/gc/incremental/sanity_checks.rs       |   8 +-
 .../sanity_checks/remembered_set.rs           | 275 ++++++++++++++++++
 2 files changed, 279 insertions(+), 4 deletions(-)
 create mode 100644 rts/motoko-rts/src/gc/incremental/sanity_checks/remembered_set.rs

diff --git a/rts/motoko-rts/src/gc/incremental/sanity_checks.rs b/rts/motoko-rts/src/gc/incremental/sanity_checks.rs
index 8bb620958d7..ed39fecde16 100644
--- a/rts/motoko-rts/src/gc/incremental/sanity_checks.rs
+++ b/rts/motoko-rts/src/gc/incremental/sanity_checks.rs
@@ -1,14 +1,15 @@
 //! Incremental GC sanity checker
 #![allow(dead_code)]
 
-use core::ptr::null;
+mod remembered_set;
 
 use crate::gc::incremental::partitioned_heap::PARTITION_SIZE;
-use crate::gc::remembered_set::RememberedSet;
 use crate::memory::Memory;
 use crate::types::*;
 use crate::visitor::visit_pointer_fields;
 
+use self::remembered_set::RememberedSet;
+
 use super::mark_stack::{MarkStack, STACK_EMPTY};
 use super::partitioned_heap::PartitionedHeap;
 use super::roots::{visit_roots, Roots};
@@ -64,7 +65,7 @@ impl<'a, M: Memory> MemoryChecker<'a, M> {
     }
 
     unsafe fn check_roots(&mut self) {
-        visit_roots(self.roots, self.heap.base_address(), self, |gc, field| {
+        visit_roots(self.roots, self, |gc, field| {
             gc.check_object(*field);
         });
     }
@@ -99,7 +100,6 @@ impl<'a, M: Memory> MemoryChecker<'a, M> {
             self,
             object,
             object.tag(),
-            0,
             |gc, field_address| {
                 let value = *field_address;
                 if value.is_ptr() {
diff --git a/rts/motoko-rts/src/gc/incremental/sanity_checks/remembered_set.rs b/rts/motoko-rts/src/gc/incremental/sanity_checks/remembered_set.rs
new file mode 100644
index 00000000000..03c1cdc13a0
--- /dev/null
+++ b/rts/motoko-rts/src/gc/incremental/sanity_checks/remembered_set.rs
@@ -0,0 +1,275 @@
+//! Remembered set.
+//! Serves for recording pointer locations trapped by the write barrier.
+//!
+//! Hash-set implementation. Linked-list collision handling.
+//!
+//! Hash function = (ptr / WORD_SIZE) % TABLE_SIZE
+//!
+//! Hash-table (length N):
+//! ----------------------------------
+//! | entry[0]   | collision_ptr[0]   |
+//! ----------------------------------
+//! | entry[1]   | collision_ptr[1]   |
+//! ----------------------------------
+//! |  ...                           |
+//! ----------------------------------
+//! | entry[N-1] | collision_ptr[N-1] |
+//! ----------------------------------
+//!
+//! Per collision a new linked list node is appended:
+//!
+//!                               Collision node
+//!                        ------------------------------
+//! prev_collision_ptr --> | entry | next_collision_ptr |
+//!                        ------------------------------
+//!
+//! Amortized hash-table growth when exceeding a defined threshold.
+//!
+//! Growth factor 2 for faster bitwise modulo calculation.
+//!
+//! NOTE: Remembered set structure is not recorded by write barriers
+//! as it is discarded by each GC run.
+//!
+//! NOTE: The table must be blobs, as their entries must not be
+//! analyzed by the GC.
+
+use core::mem::size_of;
+use core::ptr::null_mut;
+
+use crate::constants::WORD_SIZE;
+use crate::memory::{alloc_blob, Memory};
+use crate::types::{block_size, Blob, Bytes, Value};
+
+pub struct RememberedSet {
+    hash_table: *mut Blob,
+    count: u32, // contained entries
+}
+
+#[repr(C)]
+struct HashEntry {
+    pub value: Value,
+    pub next_collision_ptr: *mut CollisionNode,
+}
+
+#[repr(C)]
+struct CollisionNode {
+    pub header: Blob,
+    pub entry: HashEntry,
+}
+
+pub struct RememberedSetIterator {
+    hash_table: *mut Blob,
+    hash_index: u32,
+    current_entry: *mut HashEntry,
+}
+
+pub const INITIAL_TABLE_LENGTH: u32 = 1024;
+const GROWTH_FACTOR: u32 = 2;
+pub const OCCUPATION_THRESHOLD_PERCENT: u32 = 65;
+
+impl RememberedSet {
+    pub unsafe fn new<M: Memory>(mem: &mut M) -> RememberedSet {
+        let hash_table = new_table(mem, INITIAL_TABLE_LENGTH);
+        RememberedSet {
+            hash_table,
+            count: 0,
+        }
+    }
+
+    pub unsafe fn insert<M: Memory>(&mut self, mem: &mut M, value: Value) {
+        debug_assert!(!is_null_ptr_value(value));
+        let index = self.hash_index(value);
+        let entry = table_get(self.hash_table, index);
+        if is_null_ptr_value((*entry).value) {
+            debug_assert_eq!((*entry).next_collision_ptr, null_mut());
+            table_set(self.hash_table, index, value);
+        } else {
+            let mut current = entry;
+            while (*current).value.get_raw() != value.get_raw()
+                && (*current).next_collision_ptr != null_mut()
+            {
+                let next_node = (*current).next_collision_ptr;
+                current = &mut (*next_node).entry;
+                debug_assert!(!is_null_ptr_value((*current).value));
+            }
+            if (*current).value.get_raw() == value.get_raw() {
+                // duplicate
+                return;
+            }
+            debug_assert!(!is_null_ptr_value((*current).value));
+            (*current).next_collision_ptr = new_collision_node(mem, value);
+        }
+        self.count += 1;
+        if self.count > table_length(self.hash_table) * OCCUPATION_THRESHOLD_PERCENT / 100 {
+            self.grow(mem);
+        }
+    }
+
+    // Only used for debug assertions (barrier coverage check).
+    pub unsafe fn contains(&self, value: Value) -> bool {
+        debug_assert!(!is_null_ptr_value(value));
+        let index = self.hash_index(value);
+        let entry = table_get(self.hash_table, index);
+        if !is_null_ptr_value((*entry).value) {
+            let mut current = entry;
+            while (*current).value.get_raw() != value.get_raw()
+                && (*current).next_collision_ptr != null_mut()
+            {
+                let next_node = (*current).next_collision_ptr;
+                current = &mut (*next_node).entry;
+                debug_assert!(!is_null_ptr_value((*current).value));
+            }
+            if (*current).value.get_raw() == value.get_raw() {
+                return true;
+            }
+        }
+        false
+    }
+
+    pub unsafe fn hash_index(&self, value: Value) -> u32 {
+        // Future optimization: Use bitwise modulo, check for power of 2
+        let raw = value.get_raw();
+        let length = table_length(self.hash_table);
+        debug_assert_eq!((raw / WORD_SIZE) % length, (raw / WORD_SIZE) & (length - 1));
+        (raw / WORD_SIZE) & (length - 1)
+    }
+
+    pub unsafe fn iterate(&self) -> RememberedSetIterator {
+        RememberedSetIterator::init(self)
+    }
+
+    pub fn count(&self) -> u32 {
+        self.count
+    }
+
+    unsafe fn grow<M: Memory>(&mut self, mem: &mut M) {
+        let old_count = self.count;
+        let mut iterator = self.iterate();
+        let new_length = table_length(self.hash_table) * GROWTH_FACTOR;
+        self.hash_table = new_table(mem, new_length);
+        self.count = 0;
+        while iterator.has_next() {
+            let value = iterator.current();
+            debug_assert!(!is_null_ptr_value(value));
+            self.insert(mem, value);
+            iterator.next();
+        }
+        assert_eq!(self.count, old_count);
+    }
+}
+
+impl RememberedSetIterator {
+    pub unsafe fn init(remembered_set: &RememberedSet) -> RememberedSetIterator {
+        let mut first_entry = table_get(remembered_set.hash_table, 0);
+        if is_null_ptr_value((*first_entry).value) {
+            first_entry = null_mut()
+        }
+        let mut iterator = RememberedSetIterator {
+            hash_table: remembered_set.hash_table,
+            hash_index: 0,
+            current_entry: first_entry,
+        };
+        iterator.skip_free();
+        iterator
+    }
+
+    unsafe fn skip_free(&mut self) {
+        let length = table_length(self.hash_table);
+        if self.hash_index == length {
+            return;
+        }
+        if self.current_entry != null_mut() {
+            debug_assert!(!is_null_ptr_value((*self.current_entry).value));
+            return;
+        }
+        self.hash_index += 1;
+        while self.hash_index < length
+            && is_null_ptr_value((*table_get(self.hash_table, self.hash_index)).value)
+        {
+            debug_assert_eq!(
+                (*table_get(self.hash_table, self.hash_index)).next_collision_ptr,
+                null_mut()
+            );
+            self.hash_index += 1
+        }
+        if self.hash_index < length {
+            self.current_entry = table_get(self.hash_table, self.hash_index);
+            debug_assert!(!is_null_ptr_value((*self.current_entry).value));
+        } else {
+            self.current_entry = null_mut();
+        }
+    }
+
+    pub unsafe fn has_next(&self) -> bool {
+        self.current_entry != null_mut()
+    }
+
+    pub unsafe fn current(&self) -> Value {
+        debug_assert!(self.has_next());
+        debug_assert!(!is_null_ptr_value((*self.current_entry).value));
+        (*self.current_entry).value
+    }
+
+    pub unsafe fn next(&mut self) {
+        debug_assert!(self.has_next());
+        let next_node = (*self.current_entry).next_collision_ptr;
+        if next_node == null_mut() {
+            self.current_entry = null_mut()
+        } else {
+            self.current_entry = &mut (*next_node).entry as *mut HashEntry;
+        }
+        self.skip_free()
+    }
+}
+
+unsafe fn new_table<M: Memory>(mem: &mut M, size: u32) -> *mut Blob {
+    // No post allocation barrier as this RTS-internal blob will be collected by the GC.
+    let table = alloc_blob(mem, Bytes(size * size_of::<HashEntry>() as u32)).as_blob_mut();
+    for index in 0..size {
+        table_set(table, index, null_ptr_value());
+    }
+    table
+}
+
+unsafe fn new_collision_node<M: Memory>(mem: &mut M, value: Value) -> *mut CollisionNode {
+    debug_assert!(!is_null_ptr_value(value));
+    // No post allocation barrier as this RTS-internal blob will be collected by the GC.
+    let node =
+        alloc_blob(mem, Bytes(size_of::<HashEntry>() as u32)).as_blob_mut() as *mut CollisionNode;
+    (*node).entry = HashEntry {
+        value,
+        next_collision_ptr: null_mut(),
+    };
+    node
+}
+
+unsafe fn table_get(table: *mut Blob, index: u32) -> *mut HashEntry {
+    debug_assert!(table != null_mut());
+    let entry =
+        (table.payload_addr() as u32 + index * size_of::<HashEntry>() as u32) as *mut HashEntry;
+    debug_assert!(
+        entry as u32 + size_of::<HashEntry>() as u32
+            <= table as u32 + block_size(table as usize).to_bytes().as_u32()
+    );
+    entry
+}
+
+unsafe fn table_set(table: *mut Blob, index: u32, value: Value) {
+    let entry = table_get(table, index);
+    (*entry).value = value;
+    (*entry).next_collision_ptr = null_mut();
+}
+
+unsafe fn table_length(table: *mut Blob) -> u32 {
+    debug_assert!(table != null_mut());
+    debug_assert!(table.len().as_u32() % size_of::<HashEntry>() as u32 == 0);
+    table.len().as_u32() / size_of::<HashEntry>() as u32
+}
+
+unsafe fn null_ptr_value() -> Value {
+    Value::from_raw((null_mut() as *mut usize) as u32)
+}
+
+unsafe fn is_null_ptr_value(value: Value) -> bool {
+    value.get_raw() as *mut usize == null_mut()
+}

From 76f2bde96bec462bd93fd1f0a69bc2ba72b4c0e8 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Wed, 18 Oct 2023 11:43:32 +0200
Subject: [PATCH 135/260] Bug fix: Null comparison in pattern matching

---
 src/codegen/compile.ml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 2c79fe8e1e3..59426e9d51b 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -10996,8 +10996,8 @@ enabled mutual recursion.
 and compile_lit_pat env l =
   match l with
   | NullLit ->
-    compile_lit_as env SR.Vanilla l ^^
-    G.i (Compare (Wasm.Values.I32 I32Op.Eq))
+    Opt.is_some env ^^
+    Bool.neg
   | BoolLit true ->
     G.nop
   | BoolLit false ->

From dde1d7e3c10c5e63d3d4c64894ddf472757fd20f Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Wed, 18 Oct 2023 11:48:05 +0200
Subject: [PATCH 136/260] Update benchmark results

---
 test/bench/ok/palindrome.drun-run-opt.ok | 12 ++++++------
 test/bench/ok/palindrome.drun-run.ok     | 12 ++++++------
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/test/bench/ok/palindrome.drun-run-opt.ok b/test/bench/ok/palindrome.drun-run-opt.ok
index 39fa88310fd..d91e86fc3cf 100644
--- a/test/bench/ok/palindrome.drun-run-opt.ok
+++ b/test/bench/ok/palindrome.drun-run-opt.ok
@@ -1,9 +1,9 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (true, +1_548, 28_338)
-debug.print: (false, +1_548, 27_043)
-debug.print: (false, +1_548, 28_303)
-debug.print: (true, +1_160, 27_215)
-debug.print: (false, +1_148, 25_336)
-debug.print: (false, +1_148, 27_016)
+debug.print: (true, +1_548, 27_833)
+debug.print: (false, +1_548, 26_530)
+debug.print: (false, +1_548, 27_790)
+debug.print: (true, +1_160, 26_862)
+debug.print: (false, +1_148, 24_975)
+debug.print: (false, +1_148, 26_655)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/palindrome.drun-run.ok b/test/bench/ok/palindrome.drun-run.ok
index 5f48686ac5d..c9cbf22f959 100644
--- a/test/bench/ok/palindrome.drun-run.ok
+++ b/test/bench/ok/palindrome.drun-run.ok
@@ -1,9 +1,9 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (true, +1_548, 29_984)
-debug.print: (false, +1_548, 28_628)
-debug.print: (false, +1_548, 29_948)
-debug.print: (true, +1_160, 28_351)
-debug.print: (false, +1_148, 26_385)
-debug.print: (false, +1_148, 28_140)
+debug.print: (true, +1_548, 29_582)
+debug.print: (false, +1_548, 28_217)
+debug.print: (false, +1_548, 29_537)
+debug.print: (true, +1_160, 28_102)
+debug.print: (false, +1_148, 26_128)
+debug.print: (false, +1_148, 27_883)
 ingress Completed: Reply: 0x4449444c0000

From bcb7f73eff8fd547dd8f9b6b5bb8270fb19dd367 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 20 Oct 2023 13:56:53 +0200
Subject: [PATCH 137/260] Upgrade IC dependency, use persistence flag

---
 nix/drun.nix             | 2 +-
 nix/sources.json         | 8 ++++----
 src/prelude/internals.mo | 9 ++++++---
 3 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/nix/drun.nix b/nix/drun.nix
index ed6ff536d53..055f5ff31d3 100644
--- a/nix/drun.nix
+++ b/nix/drun.nix
@@ -19,7 +19,7 @@ pkgs:
         lockFile = "${pkgs.sources.ic}/Cargo.lock";
         outputHashes = {
           "derive_more-0.99.8-alpha.0" = "sha256-tEsfYC9oCAsDjinCsUDgRg3q6ruvayuA1lRmsEP9cys=";
-          "ic-btc-interface-0.1.0" = "sha256-H1lTXZSX1yRQ+2zvGmp+b52o5RL8KBUkE2/8dHZB+4Q=";
+          "ic-btc-interface-0.1.0" = "sha256-VecEMFjoeiRi0VgJ9CeDoOzdyJbJNiZ5MBmiV1+b7As=";
           "jsonrpc-0.12.1" = "sha256-3FtdZlt2PqVDkE5iKWYIp1eiIELsaYlUPRSP2Xp8ejM=";
           "libssh2-sys-0.2.23" = "sha256-9Hb7CnPF+lxrVO1NAhS7EXcPVWZutJXr6UWxpptzk4U=";
           "lmdb-rkv-0.14.99" = "sha256-dqxWgtNZ/qRukQLiDawjHRwdPgfzm/sVcWwudwX9rD8=";
diff --git a/nix/sources.json b/nix/sources.json
index a530f5f524d..4e4feae659a 100644
--- a/nix/sources.json
+++ b/nix/sources.json
@@ -21,15 +21,15 @@
         "version": "3.2.25"
     },
     "ic": {
-        "branch": "pull/135/head",
+        "branch": "pull/139/head",
         "description": "Internet Computer blockchain source: the client/replica software run by nodes",
         "homepage": "",
         "owner": "dfinity",
         "repo": "ic",
-        "rev": "18de74c14491c06499f59404fa5434a18bb9ca50",
-        "sha256": "1zlq1d4zb594nb3hld50cp7kmzfzwmhka01xsbazxagszs61p2sk",
+        "rev": "1fa4ad1d5d86c25da7091d5cec38940ef63c7f5f",
+        "sha256": "1yd0mgh8m08avqwl7pj2y7n39y4w3l6haymlm316a5z25d5vs3vh",
         "type": "tarball",
-        "url": "https://github.com/dfinity/ic/archive/18de74c14491c06499f59404fa5434a18bb9ca50.tar.gz",
+        "url": "https://github.com/dfinity/ic/archive/1fa4ad1d5d86c25da7091d5cec38940ef63c7f5f.tar.gz",
         "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
     },
     "ic-hs": {
diff --git a/src/prelude/internals.mo b/src/prelude/internals.mo
index e74977d5ca8..041c6178436 100644
--- a/src/prelude/internals.mo
+++ b/src/prelude/internals.mo
@@ -398,7 +398,8 @@ let @ic00 = actor "aaaaa-aa" :
       canister_id : Principal;
       wasm_module : @ManagementCanister.wasm_module;
       arg : Blob;
-      sender_canister_version : ?Nat64
+      sender_canister_version : ?Nat64;
+      keep_main_memory: ?Bool;
     } -> async ()
  };
 
@@ -438,7 +439,8 @@ func @install_actor_helper(
     canister_id;
     wasm_module;
     arg;
-    sender_canister_version = ?(prim "canister_version" : () -> Nat64)()
+    sender_canister_version = ?(prim "canister_version" : () -> Nat64)();
+    keep_main_memory = ?true;
   };
   return canister_id;
 };
@@ -459,7 +461,8 @@ func @create_actor_helper(wasm_module : Blob, arg : Blob) : async Principal = as
     canister_id;
     wasm_module;
     arg;
-    sender_canister_version = ?(prim "canister_version" : () -> Nat64)()
+    sender_canister_version = ?(prim "canister_version" : () -> Nat64)();
+    keep_main_memory = ?true;
   };
   return canister_id;
 };

From 539e4b331dfd55da4190864bf886ef0d68d7aa69 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 20 Oct 2023 16:58:44 +0200
Subject: [PATCH 138/260] Update IC dependency

---
 nix/sources.json | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/nix/sources.json b/nix/sources.json
index 4e4feae659a..e391ed86924 100644
--- a/nix/sources.json
+++ b/nix/sources.json
@@ -26,10 +26,10 @@
         "homepage": "",
         "owner": "dfinity",
         "repo": "ic",
-        "rev": "1fa4ad1d5d86c25da7091d5cec38940ef63c7f5f",
-        "sha256": "1yd0mgh8m08avqwl7pj2y7n39y4w3l6haymlm316a5z25d5vs3vh",
+        "rev": "f65a8c0a439f000c4754ca17bd41d47fbe95a26c",
+        "sha256": "0y9g3xhc1jc2afw2f06saap5304f4lqi5imy0f5s0sp0glh8gx94",
         "type": "tarball",
-        "url": "https://github.com/dfinity/ic/archive/1fa4ad1d5d86c25da7091d5cec38940ef63c7f5f.tar.gz",
+        "url": "https://github.com/dfinity/ic/archive/f65a8c0a439f000c4754ca17bd41d47fbe95a26c.tar.gz",
         "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
     },
     "ic-hs": {

From 29bc1fdbf52597e8db2d509e07c0c5a9a5905fef Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 27 Oct 2023 10:23:29 +0200
Subject: [PATCH 139/260] Update IC dependency

---
 nix/sources.json | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/nix/sources.json b/nix/sources.json
index e391ed86924..ad372b580e6 100644
--- a/nix/sources.json
+++ b/nix/sources.json
@@ -26,10 +26,10 @@
         "homepage": "",
         "owner": "dfinity",
         "repo": "ic",
-        "rev": "f65a8c0a439f000c4754ca17bd41d47fbe95a26c",
-        "sha256": "0y9g3xhc1jc2afw2f06saap5304f4lqi5imy0f5s0sp0glh8gx94",
+        "rev": "0307ea77ccce2f3ee2a3e78e7d5a8c89c4aeaff3",
+        "sha256": "0q6i5g7cq92nyaiczjshn2bdpn7ny1zawdspzisdz9jfffldwz0f",
         "type": "tarball",
-        "url": "https://github.com/dfinity/ic/archive/f65a8c0a439f000c4754ca17bd41d47fbe95a26c.tar.gz",
+        "url": "https://github.com/dfinity/ic/archive/0307ea77ccce2f3ee2a3e78e7d5a8c89c4aeaff3.tar.gz",
         "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
     },
     "ic-hs": {

From ad1264bef1677fa71f651c9467949bc4a3c6c96c Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 27 Oct 2023 14:43:01 +0200
Subject: [PATCH 140/260] Adjust test

---
 test/run-drun/max-stack-variant.mo | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/run-drun/max-stack-variant.mo b/test/run-drun/max-stack-variant.mo
index 7c51aeae6de..752a0d0ea0f 100644
--- a/test/run-drun/max-stack-variant.mo
+++ b/test/run-drun/max-stack-variant.mo
@@ -2,7 +2,7 @@
 import { errorMessage; performanceCounter; rts_heap_size; rts_max_stack_size; debugPrint; } = "mo:⛔";
 
 actor stack {
-    let expectedMinimumSize = 31_000;
+    let expectedMinimumSize = 29_000;
 
     public func ser() : async () { await go(false) };
     public func deser() : async () { await go(true) };

From d27d9eeea36745733ddc791c7ea6f45dc872400a Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 3 Nov 2023 12:33:17 +0100
Subject: [PATCH 141/260] Use new upgrade option

---
 src/prelude/internals.mo | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/src/prelude/internals.mo b/src/prelude/internals.mo
index 041c6178436..d9d6de61609 100644
--- a/src/prelude/internals.mo
+++ b/src/prelude/internals.mo
@@ -387,6 +387,10 @@ module @ManagementCanister = {
   };
 };
 
+type UpgradeOptions = { 
+  keep_main_memory: ?Bool;
+};
+
 let @ic00 = actor "aaaaa-aa" :
   actor {
     create_canister : {
@@ -394,12 +398,15 @@ let @ic00 = actor "aaaaa-aa" :
       sender_canister_version : ?Nat64
     } -> async { canister_id : Principal };
     install_code : {
-      mode : { #install; #reinstall; #upgrade };
+      mode : { 
+        #install; 
+        #reinstall; 
+        #upgrade : ?UpgradeOptions;
+      };
       canister_id : Principal;
       wasm_module : @ManagementCanister.wasm_module;
       arg : Blob;
       sender_canister_version : ?Nat64;
-      keep_main_memory: ?Bool;
     } -> async ()
  };
 
@@ -431,7 +438,10 @@ func @install_actor_helper(
         (#reinstall, (prim "cast" : (actor {}) -> Principal) actor1)
       };
       case (#upgrade actor2) {
-        (#upgrade, (prim "cast" : (actor {}) -> Principal) actor2)
+        let upgradeOptions = {
+          keep_main_memory = ?true;
+        };
+        ((#upgrade (?upgradeOptions)), (prim "cast" : (actor {}) -> Principal) actor2)
       }
     };
   await @ic00.install_code {
@@ -440,7 +450,6 @@ func @install_actor_helper(
     wasm_module;
     arg;
     sender_canister_version = ?(prim "canister_version" : () -> Nat64)();
-    keep_main_memory = ?true;
   };
   return canister_id;
 };
@@ -462,7 +471,6 @@ func @create_actor_helper(wasm_module : Blob, arg : Blob) : async Principal = as
     wasm_module;
     arg;
     sender_canister_version = ?(prim "canister_version" : () -> Nat64)();
-    keep_main_memory = ?true;
   };
   return canister_id;
 };

From 149206de4dd8361b38e2e8055b6aa08dec22bc1c Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 6 Nov 2023 16:14:39 +0100
Subject: [PATCH 142/260] Update IC dependency

---
 nix/sources.json | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/nix/sources.json b/nix/sources.json
index ad372b580e6..8b61fa23f66 100644
--- a/nix/sources.json
+++ b/nix/sources.json
@@ -21,15 +21,15 @@
         "version": "3.2.25"
     },
     "ic": {
-        "branch": "pull/139/head",
+        "branch": "pull/143/head",
         "description": "Internet Computer blockchain source: the client/replica software run by nodes",
         "homepage": "",
         "owner": "dfinity",
         "repo": "ic",
-        "rev": "0307ea77ccce2f3ee2a3e78e7d5a8c89c4aeaff3",
-        "sha256": "0q6i5g7cq92nyaiczjshn2bdpn7ny1zawdspzisdz9jfffldwz0f",
+        "rev": "0f51bd67a6d9e5141e761000ddef77c20ca3d0a5",
+        "sha256": "14lrlj6qq96wg4197ngb9495p5a8bc5lvxc0w123ybijrg266pcn",
         "type": "tarball",
-        "url": "https://github.com/dfinity/ic/archive/0307ea77ccce2f3ee2a3e78e7d5a8c89c4aeaff3.tar.gz",
+        "url": "https://github.com/dfinity/ic/archive/0f51bd67a6d9e5141e761000ddef77c20ca3d0a5.tar.gz",
         "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
     },
     "ic-hs": {

From bd46954833d245a43d6638ab7b2851050cc7f72f Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 6 Nov 2023 19:03:39 +0100
Subject: [PATCH 143/260] Adjust test

---
 test/run-drun/max-stack-variant.mo | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/run-drun/max-stack-variant.mo b/test/run-drun/max-stack-variant.mo
index 752a0d0ea0f..e0b8b5401ac 100644
--- a/test/run-drun/max-stack-variant.mo
+++ b/test/run-drun/max-stack-variant.mo
@@ -2,7 +2,7 @@
 import { errorMessage; performanceCounter; rts_heap_size; rts_max_stack_size; debugPrint; } = "mo:⛔";
 
 actor stack {
-    let expectedMinimumSize = 29_000;
+    let expectedMinimumSize = 26_000;
 
     public func ser() : async () { await go(false) };
     public func deser() : async () { await go(true) };

From c19aabd77be460452d88cf553efdb35b87fb2aab Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Wed, 8 Nov 2023 08:22:30 +0100
Subject: [PATCH 144/260] Update IC dependency

---
 nix/sources.json | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/nix/sources.json b/nix/sources.json
index e41714dd111..c5786c7c75d 100644
--- a/nix/sources.json
+++ b/nix/sources.json
@@ -26,10 +26,10 @@
         "homepage": "",
         "owner": "dfinity",
         "repo": "ic",
-        "rev": "0f51bd67a6d9e5141e761000ddef77c20ca3d0a5",
-        "sha256": "14lrlj6qq96wg4197ngb9495p5a8bc5lvxc0w123ybijrg266pcn",
+        "rev": "a39d4e2b4c0ba2f298efee9566c172d48b486982",
+        "sha256": "1qfliwm0pyqrddsg6425fi94drzxrcmzzypv1jz19n7idr4im0g2",
         "type": "tarball",
-        "url": "https://github.com/dfinity/ic/archive/0f51bd67a6d9e5141e761000ddef77c20ca3d0a5.tar.gz",
+        "url": "https://github.com/dfinity/ic/archive/a39d4e2b4c0ba2f298efee9566c172d48b486982.tar.gz",
         "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
     },
     "ic-hs": {

From c6071a0361f13535c8decd0e866e398f57009e15 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Wed, 15 Nov 2023 12:58:38 +0100
Subject: [PATCH 145/260] Manual merge conflict resolution

---
 src/codegen/compile.ml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 424ad9595c3..176d72fb2ab 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -7491,7 +7491,7 @@ module OldStabilization = struct
             get_temp_ptr ^^ G.i (Convert (Wasm.Values.I64 I64Op.ExtendUI32)) ^^
             get_offset ^^
             compile_const_64 4L ^^
-            stable64_read env ^^
+            StableMem.stable64_read env ^^
             get_temp_ptr ^^ load_unskewed_ptr ^^
             set_word ^^
             (* write 0 *)
@@ -7499,7 +7499,7 @@ module OldStabilization = struct
             get_offset ^^
             get_temp_ptr ^^ G.i (Convert (Wasm.Values.I64 I64Op.ExtendUI32)) ^^
             compile_const_64 4L ^^
-            stable64_write env ^^
+            StableMem.stable64_write env ^^
             (* return word *)
             get_word
         ))

From a0bae8835bace7722423b7f10d88c21ef78cf2cb Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Wed, 15 Nov 2023 14:22:51 +0100
Subject: [PATCH 146/260] Remove code redundancies

---
 rts/motoko-rts-tests/src/main.rs   |   2 -
 rts/motoko-rts-tests/src/stream.rs |  92 -------------
 rts/motoko-rts/src/bigint.rs       |  29 +---
 rts/motoko-rts/src/lib.rs          |   1 -
 rts/motoko-rts/src/stream.rs       | 211 -----------------------------
 rts/motoko-rts/src/text.rs         |  18 +--
 rts/motoko-rts/src/types.rs        |  73 +---------
 src/codegen/compile.ml             |  68 +---------
 8 files changed, 6 insertions(+), 488 deletions(-)
 delete mode 100644 rts/motoko-rts-tests/src/stream.rs
 delete mode 100644 rts/motoko-rts/src/stream.rs

diff --git a/rts/motoko-rts-tests/src/main.rs b/rts/motoko-rts-tests/src/main.rs
index 3b2e92fadbc..c1dd4f4e505 100644
--- a/rts/motoko-rts-tests/src/main.rs
+++ b/rts/motoko-rts-tests/src/main.rs
@@ -8,7 +8,6 @@ mod gc;
 mod leb128;
 mod memory;
 mod principal_id;
-mod stream;
 mod text;
 mod utf8;
 
@@ -29,7 +28,6 @@ fn main() {
         gc::test();
         leb128::test();
         principal_id::test();
-        stream::test();
         text::test();
         utf8::test();
     }
diff --git a/rts/motoko-rts-tests/src/stream.rs b/rts/motoko-rts-tests/src/stream.rs
deleted file mode 100644
index fcff8036779..00000000000
--- a/rts/motoko-rts-tests/src/stream.rs
+++ /dev/null
@@ -1,92 +0,0 @@
-//! Stream tests
-
-use crate::memory::{initialize_test_memory, reset_test_memory};
-
-use motoko_rts::stream::alloc_stream;
-use motoko_rts::types::{size_of, Blob, Bytes, Stream, Value};
-
-pub unsafe fn test() {
-    println!("Testing streaming ...");
-
-    let mut mem = initialize_test_memory();
-
-    const STREAM_SMALL_SIZE: u32 = 60;
-
-    println!("  Testing stream creation");
-    let stream = Value::from_ptr(alloc_stream(&mut mem, Bytes(STREAM_SMALL_SIZE)) as usize);
-
-    let initial_stream_filled = (size_of::<Stream>() - size_of::<Blob>())
-        .to_bytes()
-        .as_u32();
-
-    println!("  Testing stream filling (single bytes)");
-    for b in initial_stream_filled..(initial_stream_filled + STREAM_SMALL_SIZE) {
-        stream.as_stream().cache_byte(b as u8);
-    }
-    assert_eq!(
-        stream.as_blob().get(initial_stream_filled) as u32,
-        initial_stream_filled
-    );
-    let last = initial_stream_filled + STREAM_SMALL_SIZE - 1;
-    assert_eq!(stream.as_blob().get(last) as u32, last);
-
-    println!("  Testing stream decay");
-    let blob = stream.as_stream().split();
-    assert_eq!(blob.as_blob().len(), Bytes(STREAM_SMALL_SIZE));
-    const REMAINDER: u32 = 20;
-    assert_eq!(stream.as_blob().len(), Bytes(REMAINDER));
-
-    println!("  Testing stream filling (blocks)");
-    const STREAM_LARGE_SIZE: u32 = 6000;
-    let stream = Value::from_ptr(alloc_stream(&mut mem, Bytes(STREAM_LARGE_SIZE)) as usize);
-    let chunk: [u8; 10] = [10, 1, 2, 3, 4, 5, 6, 7, 8, 9];
-    for _ in 0..STREAM_LARGE_SIZE / chunk.len() as u32 {
-        stream
-            .as_stream()
-            .cache_bytes(&chunk[0], Bytes(chunk.len() as u32));
-    }
-    assert_eq!(stream.as_blob().get(initial_stream_filled), 10);
-    assert_eq!(stream.as_blob().get(initial_stream_filled + 1), 1);
-    assert_eq!(stream.as_blob().get(initial_stream_filled + 9), 9);
-    assert_eq!(stream.as_blob().get(initial_stream_filled + 10), 10);
-    assert_eq!(
-        stream
-            .as_blob()
-            .get(initial_stream_filled + STREAM_LARGE_SIZE - 1),
-        9
-    );
-    let blob = stream.as_stream().split();
-    assert_eq!(blob.as_blob().len(), Bytes(STREAM_LARGE_SIZE));
-
-    // TODO: cache_bytes more than STREAM_CHUNK_SIZE
-
-    println!("  Testing stream flushing");
-    static mut WRITTEN: Bytes<u32> = Bytes(0);
-    fn just_count(_stream: *mut Stream, ptr: *const u8, n: Bytes<u32>) {
-        unsafe {
-            assert_eq!(*ptr, 'a' as u8);
-            WRITTEN += n
-        }
-    }
-    let stream = alloc_stream(&mut mem, Bytes(STREAM_LARGE_SIZE));
-    (*stream).outputter = just_count;
-    const STREAM_RESERVE_SIZE1: u32 = 20;
-    let place = stream.reserve(Bytes(STREAM_RESERVE_SIZE1));
-    *place = 'a' as u8;
-    *place.add(1) = 'b' as u8;
-    assert_eq!(WRITTEN, Bytes(0)); // nothing written yet
-    stream.shutdown();
-    assert_eq!(WRITTEN, Bytes(STREAM_RESERVE_SIZE1)); // now!
-    const STREAM_RESERVE_SIZE2: u32 = 200;
-    let place = stream.reserve(Bytes(STREAM_RESERVE_SIZE2));
-    *place = 'a' as u8;
-    assert_eq!(WRITTEN, Bytes(STREAM_RESERVE_SIZE1)); // nothing written yet
-    stream.reserve(Bytes(STREAM_LARGE_SIZE - STREAM_RESERVE_SIZE2));
-    assert_eq!(WRITTEN, Bytes(STREAM_RESERVE_SIZE1)); // nothing written yet
-    stream.cache_byte(97);
-    assert_eq!(WRITTEN, Bytes(STREAM_LARGE_SIZE + STREAM_RESERVE_SIZE1)); // all at once
-    stream.shutdown();
-    assert_eq!(WRITTEN, Bytes(STREAM_LARGE_SIZE + STREAM_RESERVE_SIZE1 + 1)); // u8 too
-
-    reset_test_memory();
-}
diff --git a/rts/motoko-rts/src/bigint.rs b/rts/motoko-rts/src/bigint.rs
index bae1084d557..ab17b0f155f 100644
--- a/rts/motoko-rts/src/bigint.rs
+++ b/rts/motoko-rts/src/bigint.rs
@@ -36,7 +36,7 @@ use crate::buf::{read_byte, Buf};
 use crate::mem_utils::memcpy_bytes;
 use crate::memory::Memory;
 use crate::tommath_bindings::*;
-use crate::types::{size_of, BigInt, Bytes, Stream, Value, TAG_BIGINT};
+use crate::types::{size_of, BigInt, Bytes, Value, TAG_BIGINT};
 
 use motoko_rts_macros::ic_mem_fn;
 
@@ -457,14 +457,6 @@ pub unsafe extern "C" fn bigint_leb128_encode(n: Value, buf: *mut u8) {
     bigint_leb128_encode_go(&mut tmp, buf, false)
 }
 
-#[no_mangle]
-pub unsafe extern "C" fn bigint_leb128_stream_encode(stream: *mut Stream, n: Value) {
-    debug_assert!(!stream.is_forwarded());
-    let mut tmp: mp_int = core::mem::zeroed(); // or core::mem::uninitialized?
-    check(mp_init_copy(&mut tmp, n.as_bigint().mp_int_ptr()));
-    stream.write_leb128(&mut tmp, false)
-}
-
 #[no_mangle]
 unsafe extern "C" fn bigint_2complement_bits(n: Value) -> u32 {
     let mp_int = n.as_bigint().mp_int_ptr();
@@ -501,25 +493,6 @@ pub unsafe extern "C" fn bigint_sleb128_encode(n: Value, buf: *mut u8) {
     }
 }
 
-#[no_mangle]
-pub unsafe extern "C" fn bigint_sleb128_stream_encode(stream: *mut Stream, n: Value) {
-    debug_assert!(!stream.is_forwarded());
-    let mut tmp: mp_int = core::mem::zeroed(); // or core::mem::uninitialized?
-    check(mp_init_copy(&mut tmp, n.as_bigint().mp_int_ptr()));
-
-    if mp_isneg(&tmp) {
-        // Turn negative numbers into the two's complement of the right size
-        let mut big: mp_int = core::mem::zeroed();
-        check(mp_init(&mut big));
-        let bytes = bigint_sleb128_size(n);
-        check(mp_2expt(&mut big, 7 * bytes as i32));
-        check(mp_add(&mut tmp, &big, &mut tmp));
-        stream.write_leb128(&mut tmp, false)
-    } else {
-        stream.write_leb128(&mut tmp, true)
-    }
-}
-
 #[no_mangle]
 pub unsafe extern "C" fn bigint_leb128_decode(buf: *mut Buf) -> Value {
     let mut i = tmp_bigint();
diff --git a/rts/motoko-rts/src/lib.rs b/rts/motoko-rts/src/lib.rs
index 1054e5ddee1..8700941789a 100644
--- a/rts/motoko-rts/src/lib.rs
+++ b/rts/motoko-rts/src/lib.rs
@@ -44,7 +44,6 @@ pub mod region;
 #[cfg(feature = "ic")]
 mod stable_mem;
 mod static_checks;
-pub mod stream;
 pub mod text;
 pub mod text_iter;
 mod tommath_bindings;
diff --git a/rts/motoko-rts/src/stream.rs b/rts/motoko-rts/src/stream.rs
deleted file mode 100644
index 4a9299ae3ed..00000000000
--- a/rts/motoko-rts/src/stream.rs
+++ /dev/null
@@ -1,211 +0,0 @@
-//! The implementation of streaming serialisation
-//!
-//! When serialising Motoko stable variables to stable memory we used to first completely
-//! fill up an in-heap buffer and then copy that wholesale into stable memory. This can be
-//! disadvantageous for two reasons:
-//!  - double copying
-//!  - heap congestion (especially for the compacting collector)
-//!
-//! Instead now we'll only allocate a small(ish) blob that will serve as a temporary storage
-//! for bytes in transit, while bigger chunks will flush this staging area before being written
-//! directly to destination.
-//!
-//!
-
-// Layout of a stream node:
-//
-// ┌────────────┬─────┬─────────┬───────┬─────────┬─────────┬───────────┬────────┬──────────┐
-// │ obj header │ len │ padding | ptr64 │ start64 │ limit64 │ outputter │ filled │ cache... │
-// └────────────┴─────┴─────────┴───────┴─────────┴─────────┴───────────┴────────┴──────────┘
-//
-// We reuse the opaque nature of blobs (to Motoko) and stick Rust-related information
-// into the leading bytes:
-// - `obj header` contains tag (BLOB) and forwarding pointer
-// - `len` is in blob metadata
-// - `ptr64`, `start64`, and `limit64` are each represented as two 32-bit components
-//    in little endian encoding.
-// - `ptr64` and `limit64` are the next and past-end pointers into stable memory
-// - `filled` and `cache` are the number of bytes consumed from the blob, and the
-//   staging area of the stream, respectively
-// - `outputter` is the function to be called when `len - filled` approaches zero.
-// - INVARIANT: keep `BlobStream.{ptr64_field, start64_field, filled_field}`,
-//              (from `compile.ml`) in sync with the layout!
-// - Note: `len` and `filled` are relative to the encompassing blob.
-
-use crate::barriers::allocation_barrier;
-use crate::bigint::{check, mp_get_u32, mp_isneg, mp_iszero};
-use crate::mem_utils::memcpy_bytes;
-use crate::memory::{alloc_blob, Memory};
-use crate::rts_trap_with;
-use crate::tommath_bindings::{mp_div_2d, mp_int};
-use crate::types::{size_of, Blob, Bytes, Stream, Value, TAG_BLOB};
-
-use motoko_rts_macros::ic_mem_fn;
-
-const MAX_STREAM_SIZE: Bytes<u32> = Bytes((1 << 30) - 1);
-const INITIAL_STREAM_FILLED: Bytes<u32> = Bytes(32);
-const STREAM_CHUNK_SIZE: Bytes<u32> = Bytes(128);
-
-#[ic_mem_fn]
-pub unsafe fn alloc_stream<M: Memory>(mem: &mut M, size: Bytes<u32>) -> *mut Stream {
-    debug_assert_eq!(
-        INITIAL_STREAM_FILLED,
-        (size_of::<Stream>() - size_of::<Blob>()).to_bytes()
-    );
-    if size > MAX_STREAM_SIZE {
-        rts_trap_with("alloc_stream: Cache too large");
-    }
-    let ptr = alloc_blob(mem, size + INITIAL_STREAM_FILLED);
-    let stream = ptr.as_stream();
-    stream.write_ptr64(0);
-    stream.write_start64(0);
-    stream.write_limit64(0);
-    (*stream).outputter = Stream::no_backing_store;
-    (*stream).filled = INITIAL_STREAM_FILLED;
-    allocation_barrier(ptr);
-    stream
-}
-
-#[allow(dead_code)]
-extern "C" {
-    // generated by `moc`
-    fn ic0_stable64_write(to: u64, ptr: u64, n: u64);
-}
-
-impl Stream {
-    #[inline]
-    pub unsafe fn cache_addr(self: *const Self) -> *const u8 {
-        self.add(1) as *const u8 // skip closure header
-    }
-
-    /// make sure that the cache is empty
-    fn flush(self: *mut Self) {
-        unsafe {
-            if (*self).filled > INITIAL_STREAM_FILLED {
-                ((*self).outputter)(
-                    self,
-                    self.cache_addr(),
-                    (*self).filled - INITIAL_STREAM_FILLED,
-                );
-                (*self).filled = INITIAL_STREAM_FILLED
-            }
-        }
-    }
-
-    fn no_backing_store(self: *mut Self, _ptr: *const u8, _n: Bytes<u32>) {
-        assert!(false)
-    }
-
-    #[cfg(feature = "ic")]
-    fn send_to_stable(self: *mut Self, ptr: *const u8, n: Bytes<u32>) {
-        unsafe {
-            let next_ptr64 = self.read_ptr64() + n.as_u32() as u64;
-            ic0_stable64_write(self.read_ptr64(), ptr as u64, n.as_u32() as u64);
-            self.write_ptr64(next_ptr64);
-        }
-    }
-
-    #[cfg(feature = "ic")]
-    /// Sets up the bottleneck routine to output towards a range of stable memory
-    /// Note: assumes that the entire byte range is writable
-    #[export_name = "stream_stable_dest"]
-    pub fn setup_stable_dest(self: *mut Self, start: u64, limit: u64) {
-        unsafe {
-            self.write_ptr64(start);
-            self.write_start64(start);
-            self.write_limit64(limit);
-            (*self).outputter = Self::send_to_stable;
-        }
-    }
-
-    /// Ingest a number of bytes into the stream.
-    #[export_name = "stream_write"]
-    pub fn cache_bytes(self: *mut Self, ptr: *const u8, n: Bytes<u32>) {
-        unsafe {
-            if self.read_limit64() != 0 && n > STREAM_CHUNK_SIZE
-                || (*self).filled + n > (*self).header.len
-            {
-                self.flush();
-                ((*self).outputter)(self, ptr, n);
-            } else {
-                let dest = self
-                    .as_blob_mut()
-                    .payload_addr()
-                    .add((*self).filled.as_usize());
-                (*self).filled += n;
-                assert!((*self).filled <= (*self).header.len);
-                memcpy_bytes(dest as usize, ptr as usize, n);
-            }
-        }
-    }
-
-    /// Ingest a single byte into the stream.
-    #[inline]
-    #[export_name = "stream_write_byte"]
-    pub fn cache_byte(self: *mut Self, byte: u8) {
-        unsafe {
-            if (*self).filled >= (*self).header.len {
-                self.flush()
-            }
-            self.as_blob_mut().set((*self).filled.as_u32(), byte);
-            (*self).filled += Bytes(1)
-        }
-    }
-
-    /// Return a pointer to a reserved area of the cache and advance the
-    /// fill indicator beyond it.
-    #[export_name = "stream_reserve"]
-    pub fn reserve(self: *mut Self, bytes: Bytes<u32>) -> *mut u8 {
-        unsafe {
-            if (*self).filled + bytes > (*self).header.len {
-                self.flush()
-            }
-            let ptr = self
-                .as_blob_mut()
-                .payload_addr()
-                .add((*self).filled.as_usize());
-            (*self).filled += bytes;
-            ptr
-        }
-    }
-
-    /// like `bigint_leb128_encode_go`, but to a stream
-    pub(crate) unsafe fn write_leb128(self: *mut Stream, tmp: *mut mp_int, add_bit: bool) {
-        debug_assert!(!mp_isneg(tmp));
-
-        loop {
-            let byte = mp_get_u32(tmp) as u8;
-            check(mp_div_2d(tmp, 7, tmp, core::ptr::null_mut()));
-            if !mp_iszero(tmp) || (add_bit && byte & (1 << 6) != 0) {
-                self.cache_byte(byte | (1 << 7));
-            } else {
-                return self.cache_byte(byte);
-            }
-        }
-    }
-
-    /// Split the stream object into two `Blob`s, a front-runner (small) one
-    /// and a latter one that comprises the current amount of the cached bytes.
-    /// Lengths are adjusted correspondingly.
-    #[export_name = "stream_split"]
-    pub unsafe fn split(self: *mut Self) -> Value {
-        if (*self).header.len > (*self).filled {
-            self.as_blob_mut().shrink((*self).filled);
-        }
-        (*self).header.len = INITIAL_STREAM_FILLED - size_of::<Blob>().to_bytes();
-        (*self).filled -= INITIAL_STREAM_FILLED;
-        let blob = (self.cache_addr() as *mut Blob).sub(1);
-        (*blob).header.tag = TAG_BLOB;
-        let ptr = Value::from_ptr(blob as usize);
-        (*blob).header.init_forward(ptr);
-        debug_assert_eq!(blob.len(), (*self).filled);
-        allocation_barrier(ptr)
-    }
-
-    /// Shut down the stream by outputting all data. Lengths are
-    /// adjusted correspondingly, and the stream remains intact.
-    #[export_name = "stream_shutdown"]
-    pub unsafe fn shutdown(self: *mut Self) {
-        self.flush()
-    }
-}
diff --git a/rts/motoko-rts/src/text.rs b/rts/motoko-rts/src/text.rs
index 47c5dd3b945..752d4739b51 100644
--- a/rts/motoko-rts/src/text.rs
+++ b/rts/motoko-rts/src/text.rs
@@ -30,7 +30,7 @@ use crate::barriers::allocation_barrier;
 use crate::mem_utils::memcpy_bytes;
 use crate::memory::{alloc_blob, Memory};
 use crate::rts_trap_with;
-use crate::types::{size_of, Blob, Bytes, Concat, Stream, Value, TAG_BLOB, TAG_CONCAT};
+use crate::types::{size_of, Blob, Bytes, Concat, Value, TAG_BLOB, TAG_CONCAT};
 
 use alloc::string::String;
 use core::cmp::{min, Ordering};
@@ -168,22 +168,6 @@ unsafe extern "C" fn text_to_buf(mut s: Value, mut buf: *mut u8) {
     }
 }
 
-#[no_mangle]
-unsafe extern "C" fn stream_write_text(stream: *mut Stream, mut s: Value) {
-    loop {
-        let s_ptr = s.as_obj();
-        if s_ptr.tag() == TAG_BLOB {
-            let blob = s_ptr.as_blob();
-            stream.cache_bytes(blob.payload_addr(), blob.len());
-            break;
-        } else {
-            let concat = s_ptr.as_concat();
-            stream_write_text(stream, concat.text1());
-            s = concat.text2()
-        }
-    }
-}
-
 // Straighten into contiguous memory, if needed (e.g. for system calls)
 #[ic_mem_fn]
 pub unsafe fn blob_of_text<M: Memory>(mem: &mut M, s: Value) -> Value {
diff --git a/rts/motoko-rts/src/types.rs b/rts/motoko-rts/src/types.rs
index 6ff8b30d30a..39ae8840740 100644
--- a/rts/motoko-rts/src/types.rs
+++ b/rts/motoko-rts/src/types.rs
@@ -377,15 +377,6 @@ impl Value {
         self.forward().get_ptr() as *mut Blob
     }
 
-    /// Get the pointer as `Stream` using forwarding, which is a glorified `Blob`.
-    /// In debug mode panics if the value is not a pointer or the
-    /// pointed object is not a `Blob`.
-    pub unsafe fn as_stream(self) -> *mut Stream {
-        debug_assert_eq!(self.tag(), TAG_BLOB);
-        self.check_forwarding_pointer();
-        self.forward().get_ptr() as *mut Stream
-    }
-
     /// Get the pointer as `BigInt` using forwarding. In debug mode panics if the value is not a pointer or the
     /// pointed object is not a `BigInt`.
     pub unsafe fn as_bigint(self) -> *mut BigInt {
@@ -686,67 +677,9 @@ impl Blob {
     }
 }
 
-/// Note: Do not declare 64-bit fields, as otherwise, the objects are expected to be 64-bit aligned.
-/// This is not the case in the current heap design.
-/// Moreover, fields would also get 64-bit aligned causing implicit paddding.
-
-#[repr(C)] // See the note at the beginning of this module
-pub struct Stream {
-    pub header: Blob,
-
-    /// Components of the 64-bit `ptr` value. Little-endian encoding.
-    /// Use `read_ptr64()` and `write_ptr64()` to access.
-    pub ptr_lower: u32,
-    pub ptr_upper: u32,
-
-    /// Components of the 64-bit `start` value. Little-endian encoding.
-    /// Use `read_start64()` and `write_start64()` to access.
-    pub start_lower: u32,
-    pub start_upper: u32,
-
-    /// Components of the 64-bit `limit` value. Little-endian encoding.
-    /// Use `read_limit64()` and `write_limit64()` to access.
-    pub limit_lower: u32,
-    pub limit_upper: u32,
-
-    pub outputter: fn(*mut Self, *const u8, Bytes<u32>) -> (),
-    pub filled: Bytes<u32>, // cache data follows ..
-}
-
-impl Stream {
-    pub unsafe fn is_forwarded(self: *const Self) -> bool {
-        (self as *const Obj).is_forwarded()
-    }
-
-    pub unsafe fn as_blob_mut(self: *mut Self) -> *mut Blob {
-        debug_assert!(!self.is_forwarded());
-        self as *mut Blob
-    }
-
-    pub unsafe fn write_ptr64(self: *mut Self, value: u64) {
-        write64(&mut (*self).ptr_lower, &mut (*self).ptr_upper, value);
-    }
-
-    pub unsafe fn read_ptr64(self: *const Self) -> u64 {
-        read64((*self).ptr_lower, (*self).ptr_upper)
-    }
-
-    pub unsafe fn write_start64(self: *mut Self, value: u64) {
-        write64(&mut (*self).start_lower, &mut (*self).start_upper, value);
-    }
-
-    pub unsafe fn read_start64(self: *const Self) -> u64 {
-        read64((*self).start_lower, (*self).start_upper)
-    }
-
-    pub unsafe fn write_limit64(self: *mut Self, value: u64) {
-        write64(&mut (*self).limit_lower, &mut (*self).limit_upper, value);
-    }
-
-    pub unsafe fn read_limit64(self: *const Self) -> u64 {
-        read64((*self).limit_lower, (*self).limit_upper)
-    }
-}
+// Note: Do not declare 64-bit fields, as otherwise, the objects are expected to be 64-bit aligned.
+// This is not the case in the current heap design.
+// Moreover, fields would also get 64-bit aligned causing implicit paddding.
 
 pub fn read64(lower: u32, upper: u32) -> u64 {
     ((upper as u64) << u32::BITS) | lower as u64
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 176d72fb2ab..b7d72cce2f8 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -991,12 +991,10 @@ module RTS = struct
     E.add_func_import env "rts" "bigint_abs" [I32Type] [I32Type];
     E.add_func_import env "rts" "bigint_leb128_size" [I32Type] [I32Type];
     E.add_func_import env "rts" "bigint_leb128_encode" [I32Type; I32Type] [];
-    E.add_func_import env "rts" "bigint_leb128_stream_encode" [I32Type; I32Type] [];
     E.add_func_import env "rts" "bigint_leb128_decode" [I32Type] [I32Type];
     E.add_func_import env "rts" "bigint_leb128_decode_word64" [I64Type; I64Type; I32Type] [I32Type];
     E.add_func_import env "rts" "bigint_sleb128_size" [I32Type] [I32Type];
     E.add_func_import env "rts" "bigint_sleb128_encode" [I32Type; I32Type] [];
-    E.add_func_import env "rts" "bigint_sleb128_stream_encode" [I32Type; I32Type] [];
     E.add_func_import env "rts" "bigint_sleb128_decode" [I32Type] [I32Type];
     E.add_func_import env "rts" "bigint_sleb128_decode_word64" [I64Type; I64Type; I32Type] [I32Type];
     E.add_func_import env "rts" "leb128_encode" [I32Type; I32Type] [];
@@ -1078,14 +1076,6 @@ module RTS = struct
     E.add_func_import env "rts" "get_heap_size" [] [I32Type];
     E.add_func_import env "rts" "alloc_blob" [I32Type] [I32Type];
     E.add_func_import env "rts" "alloc_array" [I32Type] [I32Type];
-    E.add_func_import env "rts" "alloc_stream" [I32Type] [I32Type];
-    E.add_func_import env "rts" "stream_write" [I32Type; I32Type; I32Type] [];
-    E.add_func_import env "rts" "stream_write_byte" [I32Type; I32Type] [];
-    E.add_func_import env "rts" "stream_write_text" [I32Type; I32Type] [];
-    E.add_func_import env "rts" "stream_split" [I32Type] [I32Type];
-    E.add_func_import env "rts" "stream_shutdown" [I32Type] [];
-    E.add_func_import env "rts" "stream_reserve" [I32Type; I32Type] [I32Type];
-    E.add_func_import env "rts" "stream_stable_dest" [I32Type; I64Type; I64Type] [];
     ()
 
 end (* RTS *)
@@ -1180,7 +1170,7 @@ module Heap = struct
   (* Although we occasionally want to treat two consecutive
      32 bit fields as one 64 bit number *)
 
-  (* Requires little-endian encoding, see also `Stream` in `types.rs` *)
+  (* Requires little-endian encoding *)
   let load_field64 (i : int32) : G.t =
     let offset = Int32.(add (mul word_size i) ptr_unskew) in
     G.i (Load {ty = I64Type; align = 2; offset; sz = None})
@@ -1573,7 +1563,6 @@ module Tagged = struct
      Attention: This mapping is duplicated in these places
        * here
        * motoko-rts/src/types.rs
-       * motoko-rts/src/stream.rs
        * motoko-rts/src/text.rs
        * motoko-rts/src/memory.rs
        * motoko-rts/src/bigint.rs
@@ -2591,13 +2580,6 @@ sig
    *)
   val compile_store_to_data_buf_signed : E.t -> G.t
   val compile_store_to_data_buf_unsigned : E.t -> G.t
-  (* given on stack
-     - numeric object (vanilla, TOS)
-     - (unskewed) stream
-    store the binary representation of the numeric object into the stream
-   *)
-  val compile_store_to_stream_signed : E.t -> G.t
-  val compile_store_to_stream_unsigned : E.t -> G.t
   (* given a ReadBuf on stack, consume bytes from it,
      deserializing to a numeric object
      and leave it on the stack (vanilla).
@@ -3097,48 +3079,6 @@ module MakeCompact (Num : BigNumType) : BigNumType = struct
         get_buf ^^ get_x ^^ Num.compile_store_to_data_buf_signed env)
       env
 
-  let compile_store_to_stream_unsigned env =
-    let set_x, get_x = new_local env "x" in
-    let set_stream, get_stream = new_local env "stream" in
-    set_x ^^ set_stream ^^
-    get_x ^^
-    try_unbox I32Type
-      (fun env ->
-        BitTagged.untag_i32 ^^ set_x ^^
-        (* get size & reserve & encode *)
-        let dest =
-          get_stream ^^
-          I32Leb.compile_leb128_size get_x ^^
-          E.call_import env "rts" "stream_reserve" in
-        I32Leb.compile_store_to_data_buf_unsigned env get_x dest)
-      (fun env ->
-        G.i Drop ^^
-        get_stream ^^ get_x ^^ Num.compile_store_to_stream_unsigned env ^^
-        compile_unboxed_zero)
-      env ^^
-      G.i Drop
-
-  let compile_store_to_stream_signed env =
-    let set_x, get_x = new_local env "x" in
-    let set_stream, get_stream = new_local env "stream" in
-    set_x ^^ set_stream ^^
-    get_x ^^
-    try_unbox I32Type
-      (fun env ->
-        BitTagged.untag_i32 ^^ set_x ^^
-        (* get size & reserve & encode *)
-        let dest =
-          get_stream ^^
-          I32Leb.compile_sleb128_size get_x ^^
-          E.call_import env "rts" "stream_reserve" in
-        I32Leb.compile_store_to_data_buf_signed env get_x dest)
-      (fun env ->
-        G.i Drop ^^
-        get_stream ^^ get_x ^^ Num.compile_store_to_stream_signed env ^^
-        compile_unboxed_zero)
-      env ^^
-      G.i Drop
-
   let compile_data_size_unsigned env =
     try_unbox I32Type
       (fun _ ->
@@ -3253,9 +3193,6 @@ module BigNumLibtommath : BigNumType = struct
     get_n ^^ get_buf ^^ E.call_import env "rts" "bigint_leb128_encode" ^^
     get_n ^^ E.call_import env "rts" "bigint_leb128_size"
 
-  let compile_store_to_stream_unsigned env =
-    E.call_import env "rts" "bigint_leb128_stream_encode"
-
   let compile_store_to_data_buf_signed env =
     let (set_buf, get_buf) = new_local env "buf" in
     let (set_n, get_n) = new_local env "n" in
@@ -3263,9 +3200,6 @@ module BigNumLibtommath : BigNumType = struct
     get_n ^^ get_buf ^^ E.call_import env "rts" "bigint_sleb128_encode" ^^
     get_n ^^ E.call_import env "rts" "bigint_sleb128_size"
 
-  let compile_store_to_stream_signed env =
-    E.call_import env "rts" "bigint_sleb128_stream_encode"
-
   let compile_load_from_data_buf env get_data_buf = function
     | false -> get_data_buf ^^ E.call_import env "rts" "bigint_leb128_decode"
     | true -> get_data_buf ^^ E.call_import env "rts" "bigint_sleb128_decode"

From 7d3d0174fbe56caf900cadbe34d03f7bfd3ebde3 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Wed, 15 Nov 2023 14:53:51 +0100
Subject: [PATCH 147/260] Adjust version upgrade

---
 src/codegen/compile.ml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index b7d72cce2f8..8520a6e8152 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -7485,7 +7485,7 @@ module OldStabilization = struct
           G.i (Test (Wasm.Values.I64 I64Op.Eqz)) ^^
           E.else_trap_with env "StableMem.mem_size non-zero" ^^
           compile_unboxed_const StableMem.version_stable_heap_no_regions ^^
-          StableMem.set_version env ^^
+          save_version ^^
           Object.lit_raw env fs'
         end
         begin

From 8f42dc06bb0587ce4dcb35c993e195757b8e1b85 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Wed, 22 Nov 2023 13:30:57 +0100
Subject: [PATCH 148/260] Add test cases

---
 .../run-drun/ok/upgrade-bignat-bigint.drun.ok | 18 ++++++++++++++++++
 .../ok/upgrade-boxed-numbers.drun-run.ok      | 13 +++++++++++++
 test/run-drun/ok/upgrade-non-stable.drun.ok   | 14 ++++++++++++++
 test/run-drun/ok/upgrade-optional.drun.ok     | 17 +++++++++++++++++
 test/run-drun/upgrade-bignat-bigint.drun      | 14 ++++++++++++++
 .../upgrade-bignat-bigint/version0.mo         | 13 +++++++++++++
 .../upgrade-bignat-bigint/version1.mo         | 13 +++++++++++++
 test/run-drun/upgrade-boxed-numbers.mo        | 19 +++++++++++++++++++
 test/run-drun/upgrade-non-stable.drun         | 10 ++++++++++
 test/run-drun/upgrade-non-stable/version0.mo  | 19 +++++++++++++++++++
 test/run-drun/upgrade-non-stable/version1.mo  | 12 ++++++++++++
 test/run-drun/upgrade-optional.drun           | 12 ++++++++++++
 test/run-drun/upgrade-optional/version0.mo    |  9 +++++++++
 test/run-drun/upgrade-optional/version1.mo    |  9 +++++++++
 test/run-drun/upgrade-optional/version2.mo    |  9 +++++++++
 15 files changed, 201 insertions(+)
 create mode 100644 test/run-drun/ok/upgrade-bignat-bigint.drun.ok
 create mode 100644 test/run-drun/ok/upgrade-boxed-numbers.drun-run.ok
 create mode 100644 test/run-drun/ok/upgrade-non-stable.drun.ok
 create mode 100644 test/run-drun/ok/upgrade-optional.drun.ok
 create mode 100644 test/run-drun/upgrade-bignat-bigint.drun
 create mode 100644 test/run-drun/upgrade-bignat-bigint/version0.mo
 create mode 100644 test/run-drun/upgrade-bignat-bigint/version1.mo
 create mode 100644 test/run-drun/upgrade-boxed-numbers.mo
 create mode 100644 test/run-drun/upgrade-non-stable.drun
 create mode 100644 test/run-drun/upgrade-non-stable/version0.mo
 create mode 100644 test/run-drun/upgrade-non-stable/version1.mo
 create mode 100644 test/run-drun/upgrade-optional.drun
 create mode 100644 test/run-drun/upgrade-optional/version0.mo
 create mode 100644 test/run-drun/upgrade-optional/version1.mo
 create mode 100644 test/run-drun/upgrade-optional/version2.mo

diff --git a/test/run-drun/ok/upgrade-bignat-bigint.drun.ok b/test/run-drun/ok/upgrade-bignat-bigint.drun.ok
new file mode 100644
index 00000000000..be20fcc0751
--- /dev/null
+++ b/test/run-drun/ok/upgrade-bignat-bigint.drun.ok
@@ -0,0 +1,18 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 12_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_891
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 12_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_892
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: +12_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: +12_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_888
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
diff --git a/test/run-drun/ok/upgrade-boxed-numbers.drun-run.ok b/test/run-drun/ok/upgrade-boxed-numbers.drun-run.ok
new file mode 100644
index 00000000000..0f5f89b2845
--- /dev/null
+++ b/test/run-drun/ok/upgrade-boxed-numbers.drun-run.ok
@@ -0,0 +1,13 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 4_294_967_295
+debug.print: -2_147_483_648
+debug.print: 18_446_744_073_709_551_614
+debug.print: -9_223_372_036_854_775_808
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 4_294_967_295
+debug.print: -2_147_483_648
+debug.print: 18_446_744_073_709_551_614
+debug.print: -9_223_372_036_854_775_808
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/upgrade-non-stable.drun.ok b/test/run-drun/ok/upgrade-non-stable.drun.ok
new file mode 100644
index 00000000000..ce9825f8ad1
--- /dev/null
+++ b/test/run-drun/ok/upgrade-non-stable.drun.ok
@@ -0,0 +1,14 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {stableField = "Version 0"}
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {stableField = "Version 0"}
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {}
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {}
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
diff --git a/test/run-drun/ok/upgrade-optional.drun.ok b/test/run-drun/ok/upgrade-optional.drun.ok
new file mode 100644
index 00000000000..96be10b9c53
--- /dev/null
+++ b/test/run-drun/ok/upgrade-optional.drun.ok
@@ -0,0 +1,17 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+debug.print: ?(?null)
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: ?(?null)
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: ?(?null)
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: ?(?null)
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: ?(?null)
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/upgrade-bignat-bigint.drun b/test/run-drun/upgrade-bignat-bigint.drun
new file mode 100644
index 00000000000..941ef0cf16c
--- /dev/null
+++ b/test/run-drun/upgrade-bignat-bigint.drun
@@ -0,0 +1,14 @@
+# SKIP ic-ref-run
+install $ID upgrade-bignat-bigint/version0.mo ""
+ingress $ID modify "DIDL\x00\x00"
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID upgrade-bignat-bigint/version0.mo ""
+ingress $ID modify "DIDL\x00\x00"
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID upgrade-bignat-bigint/version1.mo ""
+ingress $ID modify "DIDL\x00\x00"
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID upgrade-bignat-bigint/version1.mo ""
+ingress $ID modify "DIDL\x00\x00"
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID upgrade-bignat-bigint/version0.mo ""
diff --git a/test/run-drun/upgrade-bignat-bigint/version0.mo b/test/run-drun/upgrade-bignat-bigint/version0.mo
new file mode 100644
index 00000000000..a8ad79fdf36
--- /dev/null
+++ b/test/run-drun/upgrade-bignat-bigint/version0.mo
@@ -0,0 +1,13 @@
+import Prim "mo:prim";
+
+actor {
+   stable var number : Nat = 12345678901234567890123456789012345678901234567890123456789012345678901234567890;
+
+   public func modify() : async () {
+      number += 1;
+   };
+
+   public func print() : async () {
+      Prim.debugPrint(debug_show (number));
+   };
+};
diff --git a/test/run-drun/upgrade-bignat-bigint/version1.mo b/test/run-drun/upgrade-bignat-bigint/version1.mo
new file mode 100644
index 00000000000..c7afbe089ff
--- /dev/null
+++ b/test/run-drun/upgrade-bignat-bigint/version1.mo
@@ -0,0 +1,13 @@
+import Prim "mo:prim";
+
+actor {
+   stable var number : Int = -1;
+
+   public func modify() : async () {
+      number -= 2;
+   };
+
+   public func print() : async () {
+      Prim.debugPrint(debug_show (number));
+   };
+};
diff --git a/test/run-drun/upgrade-boxed-numbers.mo b/test/run-drun/upgrade-boxed-numbers.mo
new file mode 100644
index 00000000000..c47426afb85
--- /dev/null
+++ b/test/run-drun/upgrade-boxed-numbers.mo
@@ -0,0 +1,19 @@
+import Prim "mo:prim";
+
+actor {
+  stable let boxedNat32 : Nat32 = 4294967295;
+  stable let boxedInt32 : Int32 = -2147483648;
+  stable let boxedNat64 : Nat64 = 18446744073709551614;
+  stable let boxedInt64 : Int64 = -9223372036854775808;
+
+  public func print() : async () {
+    Prim.debugPrint(debug_show (boxedNat32));
+    Prim.debugPrint(debug_show (boxedInt32));
+    Prim.debugPrint(debug_show (boxedNat64));
+    Prim.debugPrint(debug_show (boxedInt64));
+  };
+};
+
+//CALL ingress print "DIDL\x00\x00"
+//CALL upgrade ""
+//CALL ingress print "DIDL\x00\x00"
diff --git a/test/run-drun/upgrade-non-stable.drun b/test/run-drun/upgrade-non-stable.drun
new file mode 100644
index 00000000000..cd320e88413
--- /dev/null
+++ b/test/run-drun/upgrade-non-stable.drun
@@ -0,0 +1,10 @@
+# SKIP ic-ref-run
+install $ID upgrade-non-stable/version0.mo ""
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID upgrade-non-stable/version0.mo ""
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID upgrade-non-stable/version1.mo ""
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID upgrade-non-stable/version1.mo ""
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID upgrade-non-stable/version0.mo ""
diff --git a/test/run-drun/upgrade-non-stable/version0.mo b/test/run-drun/upgrade-non-stable/version0.mo
new file mode 100644
index 00000000000..7dd6de3c5e3
--- /dev/null
+++ b/test/run-drun/upgrade-non-stable/version0.mo
@@ -0,0 +1,19 @@
+import Prim "mo:prim";
+
+actor {
+  let temporary = 1;
+
+  stable let value : {
+    stableField : Text;
+  } = {
+    stableField = "Version 0";
+    nonStableField = func() {
+      Prim.debugPrint(debug_show (temporary));
+    };
+    unreachableField = -123;
+  };
+
+  public func print() : async () {
+    Prim.debugPrint(debug_show (value));
+  };
+};
diff --git a/test/run-drun/upgrade-non-stable/version1.mo b/test/run-drun/upgrade-non-stable/version1.mo
new file mode 100644
index 00000000000..93f6116c0a1
--- /dev/null
+++ b/test/run-drun/upgrade-non-stable/version1.mo
@@ -0,0 +1,12 @@
+import Prim "mo:prim";
+
+actor {
+  stable let value : {
+  } = {
+    stableField = "Version 1";
+  };
+
+  public func print() : async () {
+    Prim.debugPrint(debug_show (value));
+  };
+};
diff --git a/test/run-drun/upgrade-optional.drun b/test/run-drun/upgrade-optional.drun
new file mode 100644
index 00000000000..085283e5d28
--- /dev/null
+++ b/test/run-drun/upgrade-optional.drun
@@ -0,0 +1,12 @@
+# SKIP ic-ref-run
+install $ID upgrade-optional/version0.mo ""
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID upgrade-optional/version0.mo ""
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID upgrade-optional/version1.mo ""
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID upgrade-optional/version1.mo ""
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID upgrade-optional/version2.mo ""
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID upgrade-optional/version2.mo ""
diff --git a/test/run-drun/upgrade-optional/version0.mo b/test/run-drun/upgrade-optional/version0.mo
new file mode 100644
index 00000000000..51958e571ab
--- /dev/null
+++ b/test/run-drun/upgrade-optional/version0.mo
@@ -0,0 +1,9 @@
+import Prim "mo:prim";
+
+actor {
+  stable let value: ???{} = ??null;
+
+  public func print() : async () {
+    Prim.debugPrint(debug_show (value));
+  };
+};
diff --git a/test/run-drun/upgrade-optional/version1.mo b/test/run-drun/upgrade-optional/version1.mo
new file mode 100644
index 00000000000..880646e7ede
--- /dev/null
+++ b/test/run-drun/upgrade-optional/version1.mo
@@ -0,0 +1,9 @@
+import Prim "mo:prim";
+
+actor {
+  stable let value: ???{} = ?null;
+
+  public func print() : async () {
+    Prim.debugPrint(debug_show (value));
+  };
+};
diff --git a/test/run-drun/upgrade-optional/version2.mo b/test/run-drun/upgrade-optional/version2.mo
new file mode 100644
index 00000000000..d0437c6ad8b
--- /dev/null
+++ b/test/run-drun/upgrade-optional/version2.mo
@@ -0,0 +1,9 @@
+import Prim "mo:prim";
+
+actor {
+  stable let value: ???{} = null;
+
+  public func print() : async () {
+    Prim.debugPrint(debug_show (value));
+  };
+};

From cad375a182190f70370d246ef3b1464c70431da2 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 15 Dec 2023 13:23:38 +0100
Subject: [PATCH 149/260] Manually resolve merge conflicts

---
 rts/motoko-rts/src/gc/incremental.rs  | 4 ++--
 rts/motoko-rts/src/memory/ic.rs       | 7 +++----
 test/bench/ok/alloc.drun-run-opt.ok   | 6 +++---
 test/bench/ok/alloc.drun-run.ok       | 6 +++---
 test/bench/ok/heap-32.drun-run-opt.ok | 4 ++--
 test/bench/ok/heap-32.drun-run.ok     | 4 ++--
 6 files changed, 15 insertions(+), 16 deletions(-)

diff --git a/rts/motoko-rts/src/gc/incremental.rs b/rts/motoko-rts/src/gc/incremental.rs
index dc5d1e9b02f..b97f247b638 100644
--- a/rts/motoko-rts/src/gc/incremental.rs
+++ b/rts/motoko-rts/src/gc/incremental.rs
@@ -70,7 +70,7 @@ unsafe fn incremental_gc<M: Memory>(mem: &mut M) {
 #[cfg(feature = "ic")]
 unsafe fn should_start() -> bool {
     use self::partitioned_heap::PARTITION_SIZE;
-    use crate::constants::{GB, MB};
+    use crate::constants::GB;
     use crate::memory::ic;
 
     const CRITICAL_HEAP_LIMIT: Bytes<u32> = Bytes((2 * GB + 256 * MB) as u32);
@@ -456,7 +456,7 @@ const GC_MEMORY_RESERVE: usize = (128 + 512) * MB;
 pub unsafe fn memory_reserve() -> usize {
     use crate::memory::GENERAL_MEMORY_RESERVE;
 
-    let additional_reserve = if STATE.borrow().running_increment {
+    let additional_reserve = if get_incremental_gc_state().running_increment {
         0
     } else {
         GC_MEMORY_RESERVE
diff --git a/rts/motoko-rts/src/memory/ic.rs b/rts/motoko-rts/src/memory/ic.rs
index 32d531663f0..3b95b93d80c 100644
--- a/rts/motoko-rts/src/memory/ic.rs
+++ b/rts/motoko-rts/src/memory/ic.rs
@@ -21,14 +21,13 @@ impl Memory for IcMemory {
     }
 
     /// Page allocation. Ensures that the memory up to, but excluding, the given pointer is allocated.
-    /// Ensure a memory reserve of at least one Wasm page depending on the canister state.
-    /// `memory_reserve`: A memory reserve in bytes ensured during update and initialization calls.
-    //  For use by queries and upgrade calls. The reserve may vary depending on the GC and the phase of the GC.
+    /// Ensure a memory reserve for the incremental GC and an additional reserve for upgrades and queries.
     #[inline(never)]
-    unsafe fn grow_memory(&mut self, ptr: u64, memory_reserve: usize) {
+    unsafe fn grow_memory(&mut self, ptr: u64) {
         const LAST_PAGE_LIMIT: usize = 0xFFFF_0000;
         debug_assert_eq!(LAST_PAGE_LIMIT, usize::MAX - WASM_PAGE_SIZE.as_usize() + 1);
         let limit = if keep_memory_reserve() {
+            let memory_reserve = crate::gc::incremental::memory_reserve();
             // Spare a memory reserve during update and initialization calls for use by queries and upgrades.
             usize::MAX - memory_reserve + 1
         } else {
diff --git a/test/bench/ok/alloc.drun-run-opt.ok b/test/bench/ok/alloc.drun-run-opt.ok
index ebe1ca9a37b..21537c46a9e 100644
--- a/test/bench/ok/alloc.drun-run-opt.ok
+++ b/test/bench/ok/alloc.drun-run-opt.ok
@@ -1,8 +1,8 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_764_731_816)
+debug.print: (+335_544_320, 4_764_731_846)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_764_731_633)
+debug.print: (+335_544_320, 4_764_731_663)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_764_731_645)
+debug.print: (+335_544_320, 4_764_731_675)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/alloc.drun-run.ok b/test/bench/ok/alloc.drun-run.ok
index 1285909900e..381d19356e2 100644
--- a/test/bench/ok/alloc.drun-run.ok
+++ b/test/bench/ok/alloc.drun-run.ok
@@ -1,8 +1,8 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_898_949_723)
+debug.print: (+335_544_320, 4_898_949_803)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_898_949_530)
+debug.print: (+335_544_320, 4_898_949_610)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_898_949_543)
+debug.print: (+335_544_320, 4_898_949_623)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/heap-32.drun-run-opt.ok b/test/bench/ok/heap-32.drun-run-opt.ok
index 77b3a4e8e0b..71b0980bc35 100644
--- a/test/bench/ok/heap-32.drun-run-opt.ok
+++ b/test/bench/ok/heap-32.drun-run-opt.ok
@@ -1,5 +1,5 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (50_227, +37_021_304, 767_984_266)
-debug.print: (50_070, +40_056_236, 830_437_417)
+debug.print: (50_227, +37_021_304, 767_984_269)
+debug.print: (50_070, +40_056_236, 830_437_420)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/heap-32.drun-run.ok b/test/bench/ok/heap-32.drun-run.ok
index 402c131c5c5..6329d1b0ffb 100644
--- a/test/bench/ok/heap-32.drun-run.ok
+++ b/test/bench/ok/heap-32.drun-run.ok
@@ -1,5 +1,5 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (50_227, +37_021_304, 815_894_734)
-debug.print: (50_070, +40_056_236, 880_136_121)
+debug.print: (50_227, +37_021_304, 815_894_742)
+debug.print: (50_070, +40_056_236, 880_136_129)
 ingress Completed: Reply: 0x4449444c0000

From bc7a51fba23e33d156750abdf240ac01a2782cdc Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 15 Dec 2023 13:39:05 +0100
Subject: [PATCH 150/260] Update IC dependency

---
 nix/sources.json | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/nix/sources.json b/nix/sources.json
index 1e3321148a9..b98f77c3727 100644
--- a/nix/sources.json
+++ b/nix/sources.json
@@ -26,10 +26,10 @@
         "homepage": "",
         "owner": "dfinity",
         "repo": "ic",
-        "rev": "a39d4e2b4c0ba2f298efee9566c172d48b486982",
-        "sha256": "1qfliwm0pyqrddsg6425fi94drzxrcmzzypv1jz19n7idr4im0g2",
+        "rev": "418b964468d7706836c7b4e3b166a58526a4ac16",
+        "sha256": "1gbrmfnmn8245isj865dd48xcnpfdyi1aqgk79avi6xgzzc3nwk7",
         "type": "tarball",
-        "url": "https://github.com/dfinity/ic/archive/a39d4e2b4c0ba2f298efee9566c172d48b486982.tar.gz",
+        "url": "https://github.com/dfinity/ic/archive/418b964468d7706836c7b4e3b166a58526a4ac16.tar.gz",
         "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
     },
     "ic-hs": {

From 9d6cd0f05765782a7d4e2af5fbe162ec74c833b0 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 15 Dec 2023 15:19:13 +0100
Subject: [PATCH 151/260] Manual merge conflict resolution

---
 rts/Makefile                          |  2 +-
 rts/motoko-rts/src/gc/incremental.rs  | 13 +++++++------
 test/bench/ok/alloc.drun-run-opt.ok   |  6 +++---
 test/bench/ok/alloc.drun-run.ok       |  6 +++---
 test/bench/ok/heap-32.drun-run-opt.ok |  4 ++--
 test/bench/ok/heap-32.drun-run.ok     |  4 ++--
 6 files changed, 18 insertions(+), 17 deletions(-)

diff --git a/rts/Makefile b/rts/Makefile
index e4fc8b0cbd0..70132dde886 100644
--- a/rts/Makefile
+++ b/rts/Makefile
@@ -243,7 +243,7 @@ $(RTS_RUST_DEBUG_WASM_A): $(RTS_DEPENDENCIES)
 
 TEST_DEPENDENCIES=$(TOMMATH_WASM_A) $(TOMMATH_BINDINGS_RS)
 TEST_BUILD=cd motoko-rts-tests && cargo build --target=wasm32-wasi
-TEST_RUN=wasmtime --disable-cache motoko-rts-tests/target/wasm32-wasi/debug/motoko-rts-tests.wasm
+TEST_RUN=wasmtime -C cache=n -W nan-canonicalization=y motoko-rts-tests/target/wasm32-wasi/debug/motoko-rts-tests.wasm
 
 .PHONY: test
 
diff --git a/rts/motoko-rts/src/gc/incremental.rs b/rts/motoko-rts/src/gc/incremental.rs
index b97f247b638..aa4be315254 100644
--- a/rts/motoko-rts/src/gc/incremental.rs
+++ b/rts/motoko-rts/src/gc/incremental.rs
@@ -164,10 +164,12 @@ pub struct State {
     allocation_count: usize, // Number of allocations during an active GC run.
     mark_state: Option<MarkState>,
     iterator_state: Option<PartitionedHeapIterator>,
-    running_increment: bool, // GC increment is active.
     statistics: Statistics,
 }
 
+/// Temporary state during message execution, not part of the persistent metadata.
+static mut RUNNING_GC_INCREMENT: bool = false;
+
 /// Incremental GC.
 /// Each GC call has its new GC instance that shares the common GC state `STATE`.
 pub struct IncrementalGC<'a, M: Memory> {
@@ -191,7 +193,6 @@ impl<'a, M: Memory + 'a> IncrementalGC<'a, M> {
             allocation_count: 0,
             mark_state: None,
             iterator_state: None,
-            running_increment: false,
             statistics,
         }
     }
@@ -214,8 +215,8 @@ impl<'a, M: Memory + 'a> IncrementalGC<'a, M> {
     /// * The mark phase can only be started on an empty call stack.
     /// * The update phase can only be completed on an empty call stack.
     pub unsafe fn empty_call_stack_increment(&mut self, roots: Roots) {
-        debug_assert!(!self.state.running_increment);
-        self.state.running_increment = true;
+        debug_assert!(!RUNNING_GC_INCREMENT);
+        RUNNING_GC_INCREMENT = true;
         if self.pausing() {
             self.start_marking(roots);
         }
@@ -237,7 +238,7 @@ impl<'a, M: Memory + 'a> IncrementalGC<'a, M> {
         if self.updating_completed() {
             self.complete_run(roots);
         }
-        self.state.running_increment = false;
+        RUNNING_GC_INCREMENT = false;
     }
 
     unsafe fn pausing(&mut self) -> bool {
@@ -456,7 +457,7 @@ const GC_MEMORY_RESERVE: usize = (128 + 512) * MB;
 pub unsafe fn memory_reserve() -> usize {
     use crate::memory::GENERAL_MEMORY_RESERVE;
 
-    let additional_reserve = if get_incremental_gc_state().running_increment {
+    let additional_reserve = if RUNNING_GC_INCREMENT {
         0
     } else {
         GC_MEMORY_RESERVE
diff --git a/test/bench/ok/alloc.drun-run-opt.ok b/test/bench/ok/alloc.drun-run-opt.ok
index 21537c46a9e..16540a7a4f9 100644
--- a/test/bench/ok/alloc.drun-run-opt.ok
+++ b/test/bench/ok/alloc.drun-run-opt.ok
@@ -1,8 +1,8 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_764_731_846)
+debug.print: (+335_544_320, 4_764_731_856)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_764_731_663)
+debug.print: (+335_544_320, 4_764_731_673)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_764_731_675)
+debug.print: (+335_544_320, 4_764_731_685)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/alloc.drun-run.ok b/test/bench/ok/alloc.drun-run.ok
index 381d19356e2..4cc2441198a 100644
--- a/test/bench/ok/alloc.drun-run.ok
+++ b/test/bench/ok/alloc.drun-run.ok
@@ -1,8 +1,8 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_898_949_803)
+debug.print: (+335_544_320, 4_898_949_823)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_898_949_610)
+debug.print: (+335_544_320, 4_898_949_630)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_898_949_623)
+debug.print: (+335_544_320, 4_898_949_643)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/heap-32.drun-run-opt.ok b/test/bench/ok/heap-32.drun-run-opt.ok
index 71b0980bc35..ab02ec775f2 100644
--- a/test/bench/ok/heap-32.drun-run-opt.ok
+++ b/test/bench/ok/heap-32.drun-run-opt.ok
@@ -1,5 +1,5 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (50_227, +37_021_304, 767_984_269)
-debug.print: (50_070, +40_056_236, 830_437_420)
+debug.print: (50_227, +37_021_304, 767_984_270)
+debug.print: (50_070, +40_056_236, 830_437_421)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/heap-32.drun-run.ok b/test/bench/ok/heap-32.drun-run.ok
index 6329d1b0ffb..61139fd47df 100644
--- a/test/bench/ok/heap-32.drun-run.ok
+++ b/test/bench/ok/heap-32.drun-run.ok
@@ -1,5 +1,5 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (50_227, +37_021_304, 815_894_742)
-debug.print: (50_070, +40_056_236, 880_136_129)
+debug.print: (50_227, +37_021_304, 815_894_744)
+debug.print: (50_070, +40_056_236, 880_136_131)
 ingress Completed: Reply: 0x4449444c0000

From f36196a3ea97b5ed2f2895322a1299bb2de28be6 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 15 Dec 2023 15:52:25 +0100
Subject: [PATCH 152/260] Remove non-incremental GC test options

---
 .../memory-reserve-composite.drun               |  1 -
 test/run-drun-non-ci/memory-reserve-query.drun  |  1 -
 test/run-drun-non-ci/memory-reserve-update.drun |  1 -
 .../run-drun-non-ci/memory-reserve-upgrade.drun |  1 -
 test/run-drun/gc-trigger.mo                     |  4 +---
 test/run.sh                                     | 17 -----------------
 6 files changed, 1 insertion(+), 24 deletions(-)

diff --git a/test/run-drun-non-ci/memory-reserve-composite.drun b/test/run-drun-non-ci/memory-reserve-composite.drun
index 5bbc2a24e56..1da30f6357b 100644
--- a/test/run-drun-non-ci/memory-reserve-composite.drun
+++ b/test/run-drun-non-ci/memory-reserve-composite.drun
@@ -1,4 +1,3 @@
-# INCREMENTAL-GC-ONLY
 # SKIP ic-ref-run
 install $ID memory-reserve-composite/memory-reserve-composite.mo ""
 ingress $ID prepare1 "DIDL\x00\x00"
diff --git a/test/run-drun-non-ci/memory-reserve-query.drun b/test/run-drun-non-ci/memory-reserve-query.drun
index d076edb417a..f7956e7ab96 100644
--- a/test/run-drun-non-ci/memory-reserve-query.drun
+++ b/test/run-drun-non-ci/memory-reserve-query.drun
@@ -1,4 +1,3 @@
-# INCREMENTAL-GC-ONLY
 # SKIP ic-ref-run
 install $ID memory-reserve-query/memory-reserve-query.mo ""
 ingress $ID prepare1 "DIDL\x00\x00"
diff --git a/test/run-drun-non-ci/memory-reserve-update.drun b/test/run-drun-non-ci/memory-reserve-update.drun
index 6d53c637928..00296d68dab 100644
--- a/test/run-drun-non-ci/memory-reserve-update.drun
+++ b/test/run-drun-non-ci/memory-reserve-update.drun
@@ -1,4 +1,3 @@
-# INCREMENTAL-GC-ONLY
 # SKIP ic-ref-run
 install $ID memory-reserve-update/memory-reserve-update.mo ""
 ingress $ID prepare1 "DIDL\x00\x00"
diff --git a/test/run-drun-non-ci/memory-reserve-upgrade.drun b/test/run-drun-non-ci/memory-reserve-upgrade.drun
index f791e8fd882..77c3762f6d5 100644
--- a/test/run-drun-non-ci/memory-reserve-upgrade.drun
+++ b/test/run-drun-non-ci/memory-reserve-upgrade.drun
@@ -1,4 +1,3 @@
-# INCREMENTAL-GC-ONLY
 # SKIP ic-ref-run
 install $ID memory-reserve-upgrade/memory-reserve-upgrade.mo ""
 ingress $ID prepare1 "DIDL\x00\x00"
diff --git a/test/run-drun/gc-trigger.mo b/test/run-drun/gc-trigger.mo
index 04ddf7ac455..8ffe61788c8 100644
--- a/test/run-drun/gc-trigger.mo
+++ b/test/run-drun/gc-trigger.mo
@@ -1,9 +1,8 @@
 //MOC-NO-FORCE-GC
-//INCREMENTAL-GC-ONLY
 import Prim "mo:prim";
 
 actor {
-    let retained = Prim.Array_init<Nat>(6 * 1024 * 1024, 0);
+    let retained = Prim.Array_init<Nat>(5 * 1024 * 1024, 0);
     // GC is triggered during initialization
 
     var heapSizeWithGarbage = 0;
@@ -13,7 +12,6 @@ actor {
         ignore Prim.Array_init<Nat>(1024 * 1024, 0);
         heapSizeWithGarbage := Prim.rts_heap_size();
         // Growth is too little to trigger the incremental GC.
-        // Note: The generational GC would still run the GC.
     };
 
     public query func checkBeforeGC(): async() {
diff --git a/test/run.sh b/test/run.sh
index f9cf1945f6d..825a36e1487 100755
--- a/test/run.sh
+++ b/test/run.sh
@@ -254,15 +254,6 @@ do
 
   case $ext in
   "mo")
-    if grep -q "//INCREMENTAL-GC-ONLY" $base.mo
-    then
-      if [[ $EXTRA_MOC_ARGS != *"--incremental-gc"* ]]
-      then
-        $ECHO " Skipped (non-incremental GC)"
-        continue
-      fi
-    fi
-
     # extra flags (allow shell variables there)
     moc_extra_flags="$(eval echo $(grep '//MOC-FLAG' $base.mo | cut -c11- | paste -sd' '))"
     moc_extra_env="$(eval echo $(grep '//MOC-ENV' $base.mo | cut -c10- | paste -sd' '))"
@@ -447,14 +438,6 @@ do
         continue
       fi
 
-      if grep -q "# *INCREMENTAL-GC-ONLY" $(basename $file)
-      then
-        if [[ $EXTRA_MOC_ARGS != *"--incremental-gc"* ]]
-        then 
-          continue
-        fi
-      fi
-
       have_var_name="HAVE_${runner//-/_}"
       if [ ${!have_var_name} != yes ]
       then

From 51d52429ed2a0d04e64e0cb9a6717e7660c02072 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Tue, 19 Dec 2023 11:49:13 +0100
Subject: [PATCH 153/260] Drop content of destabilized `Any`-typed actor field

---
 src/codegen/compile.ml                   | 12 +++++++++---
 test/run-drun/ok/upgrade-to-any.drun.ok  | 17 +++++++++++++++++
 test/run-drun/upgrade-to-any.drun        | 11 +++++++++++
 test/run-drun/upgrade-to-any/version0.mo | 22 ++++++++++++++++++++++
 test/run-drun/upgrade-to-any/version1.mo | 24 ++++++++++++++++++++++++
 test/run-drun/upgrade-to-any/version2.mo | 22 ++++++++++++++++++++++
 6 files changed, 105 insertions(+), 3 deletions(-)
 create mode 100644 test/run-drun/ok/upgrade-to-any.drun.ok
 create mode 100644 test/run-drun/upgrade-to-any.drun
 create mode 100644 test/run-drun/upgrade-to-any/version0.mo
 create mode 100644 test/run-drun/upgrade-to-any/version1.mo
 create mode 100644 test/run-drun/upgrade-to-any/version2.mo

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 27f2a5bf2d5..bb38a87106d 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -7753,17 +7753,23 @@ module Persistence = struct
   let create_actor env actor_type get_field_value =
     let (_, field_declarations) = Type.as_obj actor_type in
     let field_initializers = List.map
-      (fun field -> (field.Type.lab, fun () -> (get_field_value field.Type.lab)))
+      (fun field -> (field.Type.lab, fun () -> (get_field_value field)))
       field_declarations
     in
     Object.lit_raw env field_initializers
 
   let recover_actor env actor_type =
+    let load_old_field env field =
+      if field.Type.typ = Type.(Opt Any) then
+        (* A stable variable may have been promoted to type `Any`: Therefore, drop its former content. *)
+        Opt.inject env Tuple.compile_unit
+      else
+        (load_stable_actor env ^^ Object.load_idx_raw env field.Type.lab) in
     let recover_field field = 
       load_stable_actor env ^^
-      Object.contains_field env field ^^
+      Object.contains_field env field.Type.lab ^^
       (G.if1 I32Type
-        (load_stable_actor env ^^ Object.load_idx_raw env field)
+        (load_old_field env field)
         (Opt.null_lit env)
       ) in
     create_actor env actor_type recover_field ^^
diff --git a/test/run-drun/ok/upgrade-to-any.drun.ok b/test/run-drun/ok/upgrade-to-any.drun.ok
new file mode 100644
index 00000000000..fab4050878a
--- /dev/null
+++ b/test/run-drun/ok/upgrade-to-any.drun.ok
@@ -0,0 +1,17 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+debug.print: Version 0
+debug.print: Initialize first variable
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Version 1
+debug.print: Initialize second variable
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Version 2
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Version 2
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/upgrade-to-any.drun b/test/run-drun/upgrade-to-any.drun
new file mode 100644
index 00000000000..ea5756edae1
--- /dev/null
+++ b/test/run-drun/upgrade-to-any.drun
@@ -0,0 +1,11 @@
+# SKIP ic-ref-run
+install $ID upgrade-to-any/version0.mo ""
+ingress $ID check "DIDL\x00\x00"
+upgrade $ID upgrade-to-any/version1.mo ""
+ingress $ID __motoko_gc_trigger "DIDL\x00\x00"
+ingress $ID check "DIDL\x00\x00"
+upgrade $ID upgrade-to-any/version2.mo ""
+ingress $ID __motoko_gc_trigger "DIDL\x00\x00"
+ingress $ID check "DIDL\x00\x00"
+upgrade $ID upgrade-to-any/version2.mo ""
+ingress $ID check "DIDL\x00\x00"
diff --git a/test/run-drun/upgrade-to-any/version0.mo b/test/run-drun/upgrade-to-any/version0.mo
new file mode 100644
index 00000000000..2d2d80d943a
--- /dev/null
+++ b/test/run-drun/upgrade-to-any/version0.mo
@@ -0,0 +1,22 @@
+import Prim "mo:prim";
+
+actor {
+   Prim.debugPrint("Version 0");
+
+   let allocationSize = 40_000_000;
+
+   func largeAllocation(name: Text): [var Nat] {
+      Prim.debugPrint("Initialize " # name);
+      Prim.Array_init<Nat>(allocationSize / 4, 0);
+   };
+
+   stable var firstVariable : [var Nat] = largeAllocation("first variable");
+
+   public func check(): async() {
+      // Extra GC increments.
+      await async {};
+      await async {};
+      // Check that first variable has been cleared and the first array has been reclaimed.
+      assert(Prim.rts_heap_size() >= allocationSize);
+   };
+};
diff --git a/test/run-drun/upgrade-to-any/version1.mo b/test/run-drun/upgrade-to-any/version1.mo
new file mode 100644
index 00000000000..76f8107b1be
--- /dev/null
+++ b/test/run-drun/upgrade-to-any/version1.mo
@@ -0,0 +1,24 @@
+import Prim "mo:prim";
+
+actor {
+   Prim.debugPrint("Version 1");
+
+   let allocationSize = 40_000_000;
+
+   func largeAllocation(name: Text): [var Nat] {
+      Prim.debugPrint("Initialize " # name);
+      Prim.Array_init<Nat>(allocationSize / 4, 0);
+   };
+
+   stable var firstVariable : Any = largeAllocation("first variable");
+   stable var secondVariable : Any = largeAllocation("second variable");
+   
+   public func check(): async() {
+      // Extra GC increments.
+      await async {};
+      await async {};
+      // Check that first variable has been cleared and the first array has been reclaimed.
+      assert(Prim.rts_heap_size() >= allocationSize);
+      assert(Prim.rts_heap_size() < 2 * allocationSize);
+   };
+};
diff --git a/test/run-drun/upgrade-to-any/version2.mo b/test/run-drun/upgrade-to-any/version2.mo
new file mode 100644
index 00000000000..9051e2fd5cf
--- /dev/null
+++ b/test/run-drun/upgrade-to-any/version2.mo
@@ -0,0 +1,22 @@
+import Prim "mo:prim";
+
+actor {
+   Prim.debugPrint("Version 2");
+
+   let allocationSize = 40_000_000;
+
+   func largeAllocation(name: Text): [var Nat] {
+      Prim.trap("Should not be called");
+   };
+
+   stable var firstVariable : Any = largeAllocation("first variable");
+   stable var secondVariable : Any = largeAllocation("second variable");
+
+   public func check(): async() {
+      // Extra GC increments.
+      await async {};
+      await async {};
+      // Check that both variables have been cleared and both arrays have been reclaimed.
+      assert(Prim.rts_heap_size() < allocationSize);
+   }
+};

From 911e3d73a3d940fcee816d4de89ebb42ab0bad4f Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Tue, 19 Dec 2023 10:22:59 +0100
Subject: [PATCH 154/260] Refactor `is_primitive_type` in Candid parser and
 subtype check

---
 rts/motoko-rts/src/idl.rs | 74 +++++++++++++++++++++++++++------------
 1 file changed, 51 insertions(+), 23 deletions(-)

diff --git a/rts/motoko-rts/src/idl.rs b/rts/motoko-rts/src/idl.rs
index 027fe9e6fd1..52a4effa69a 100644
--- a/rts/motoko-rts/src/idl.rs
+++ b/rts/motoko-rts/src/idl.rs
@@ -55,14 +55,28 @@ pub unsafe fn leb128_decode_ptr(buf: *mut Buf) -> (u32, *mut u8) {
     (leb128_decode(buf), (*buf).ptr)
 }
 
-unsafe fn is_primitive_type(extended: bool, ty: i32) -> bool {
-    ty < 0
-        && (ty >= IDL_PRIM_lowest || ty == IDL_REF_principal || (extended && ty == IDL_EXT_region))
+#[derive(Copy, Clone, PartialEq)]
+enum CompatibilityMode {
+    /// Pure Candid used for IC message payloads.
+    PureCandid,
+    /// Candidish stabilization (old stabilization format).
+    CandidishStabilization,
+    /// Memory compatibility used by graph-copy-based stabilization.
+    MemoryCompatibility,
 }
 
-// Only used for memory-compatibility checks for orthogonal persistence.
-unsafe fn is_extended_primitive_type(ty: i32) -> bool {
-    is_primitive_type(true, ty) || ty < 0 && ty == IDL_EXT_blob
+unsafe fn is_primitive_type(mode: CompatibilityMode, ty: i32) -> bool {
+    if ty >= 0 {
+        return false;
+    }
+    if ty >= IDL_PRIM_lowest || ty == IDL_REF_principal {
+        return true;
+    }
+    match mode {
+        CompatibilityMode::PureCandid => false,
+        CompatibilityMode::CandidishStabilization => ty == IDL_EXT_region,
+        CompatibilityMode::MemoryCompatibility => ty == IDL_EXT_region || ty == IDL_EXT_blob,
+    }
 }
 
 // TBR; based on Text.text_compare
@@ -84,14 +98,14 @@ unsafe fn utf8_cmp(len1: u32, p1: *mut u8, len2: u32, p2: *mut u8) -> i32 {
     }
 }
 
-unsafe fn check_typearg(extended: bool, ty: i32, n_types: u32) {
+unsafe fn check_typearg(mode: CompatibilityMode, ty: i32, n_types: u32) {
     // Arguments to type constructors can be primitive types or type indices
-    if !(is_primitive_type(extended, ty) || (ty >= 0 && (ty as u32) < n_types)) {
+    if !(is_primitive_type(mode, ty) || (ty >= 0 && (ty as u32) < n_types)) {
         idl_trap_with("invalid type argument");
     }
 }
 
-unsafe fn parse_fields(extended: bool, buf: *mut Buf, n_types: u32) {
+unsafe fn parse_fields(mode: CompatibilityMode, buf: *mut Buf, n_types: u32) {
     let mut next_valid = 0;
     for n in (1..=leb128_decode(buf)).rev() {
         let tag = leb128_decode(buf);
@@ -100,7 +114,7 @@ unsafe fn parse_fields(extended: bool, buf: *mut Buf, n_types: u32) {
         }
         next_valid = tag + 1;
         let t = sleb128_decode(buf);
-        check_typearg(extended, t, n_types);
+        check_typearg(mode, t, n_types);
     }
 }
 
@@ -127,6 +141,8 @@ unsafe fn alloc<M: Memory>(mem: &mut M, size: Words<u32>) -> *mut u8 {
 ///
 /// * returns a pointer to the beginning of the list of main types
 ///   (again via pointer argument, for lack of multi-value returns in C ABI)
+///
+/// `extended` denotes Candidish stabilization format, otherwise it assumes the pure Candid format.
 #[ic_mem_fn]
 unsafe fn parse_idl_header<M: Memory>(
     mem: &mut M,
@@ -136,6 +152,12 @@ unsafe fn parse_idl_header<M: Memory>(
     typtbl_size_out: *mut u32,
     main_types_out: *mut *mut u8,
 ) {
+    let mode = if extended {
+        CompatibilityMode::CandidishStabilization
+    } else {
+        CompatibilityMode::PureCandid
+    };
+
     if (*buf).ptr == (*buf).end {
         idl_trap_with(
             "empty input. Expected Candid-encoded argument, but received a zero-length argument",
@@ -171,32 +193,32 @@ unsafe fn parse_idl_header<M: Memory>(
             // internal
             // See Note [mutable stable values] in codegen/compile.ml
             let t = sleb128_decode(buf);
-            check_typearg(extended, t, n_types);
+            check_typearg(mode, t, n_types);
         } else if ty >= 0 {
             idl_trap_with("illegal type table"); // illegal
-        } else if is_primitive_type(extended, ty) {
+        } else if is_primitive_type(mode, ty) {
             // illegal
             idl_trap_with("primitive type in type table");
         } else if ty == IDL_CON_opt {
             let t = sleb128_decode(buf);
-            check_typearg(extended, t, n_types);
+            check_typearg(mode, t, n_types);
         } else if ty == IDL_CON_vec {
             let t = sleb128_decode(buf);
-            check_typearg(extended, t, n_types);
+            check_typearg(mode, t, n_types);
         } else if ty == IDL_CON_record {
-            parse_fields(extended, buf, n_types);
+            parse_fields(mode, buf, n_types);
         } else if ty == IDL_CON_variant {
-            parse_fields(extended, buf, n_types);
+            parse_fields(mode, buf, n_types);
         } else if ty == IDL_CON_func {
             // Arg types
             for _ in 0..leb128_decode(buf) {
                 let t = sleb128_decode(buf);
-                check_typearg(extended, t, n_types);
+                check_typearg(mode, t, n_types);
             }
             // Ret types
             for _ in 0..leb128_decode(buf) {
                 let t = sleb128_decode(buf);
-                check_typearg(extended, t, n_types);
+                check_typearg(mode, t, n_types);
             }
             // Annotations
             for _ in 0..leb128_decode(buf) {
@@ -235,7 +257,7 @@ unsafe fn parse_idl_header<M: Memory>(
 
                 // Type
                 let t = sleb128_decode(buf);
-                check_typearg(extended, t, n_types);
+                check_typearg(mode, t, n_types);
             }
         } else {
             // Future type
@@ -282,7 +304,7 @@ unsafe fn parse_idl_header<M: Memory>(
     *main_types_out = (*buf).ptr;
     for _ in 0..leb128_decode(buf) {
         let t = sleb128_decode(buf);
-        check_typearg(extended, t, n_types);
+        check_typearg(mode, t, n_types);
     }
 
     *typtbl_out = typtbl;
@@ -532,7 +554,7 @@ unsafe extern "C" fn skip_fields(tb: *mut Buf, buf: *mut Buf, typtbl: *mut *mut
 }
 
 unsafe fn is_opt_reserved(typtbl: *mut *mut u8, end: *mut u8, t: i32) -> bool {
-    if is_primitive_type(false, t) {
+    if is_primitive_type(CompatibilityMode::PureCandid, t) {
         return t == IDL_PRIM_reserved;
     }
 
@@ -614,7 +636,10 @@ pub(crate) unsafe fn memory_compatible(
     };
 
     /* primitives reflexive */
-    if is_extended_primitive_type(t1) && is_extended_primitive_type(t2) && t1 == t2 {
+    if is_primitive_type(CompatibilityMode::MemoryCompatibility, t1)
+        && is_primitive_type(CompatibilityMode::MemoryCompatibility, t2)
+        && t1 == t2
+    {
         return true;
     }
 
@@ -886,7 +911,10 @@ pub(crate) unsafe fn sub(
     };
 
     /* primitives reflexive */
-    if is_primitive_type(false, t1) && is_primitive_type(false, t2) && t1 == t2 {
+    if is_primitive_type(CompatibilityMode::PureCandid, t1)
+        && is_primitive_type(CompatibilityMode::PureCandid, t2)
+        && t1 == t2
+    {
         return true;
     }
 

From 3981a91f5b8ff89d34a8e7b496792c3429bb245d Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Tue, 19 Dec 2023 10:55:20 +0100
Subject: [PATCH 155/260] Do not use the cache for the main actor type
 compatibility check

---
 rts/motoko-rts/src/idl.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/rts/motoko-rts/src/idl.rs b/rts/motoko-rts/src/idl.rs
index 52a4effa69a..448adddb7bc 100644
--- a/rts/motoko-rts/src/idl.rs
+++ b/rts/motoko-rts/src/idl.rs
@@ -626,7 +626,10 @@ pub(crate) unsafe fn memory_compatible(
     t2: i32,
     main_actor: bool,
 ) -> bool {
-    if t1 >= 0 && t2 >= 0 {
+    // Do not use the cache for the main actor sub-type relation, as it does not follow the ordinary sub-type rules,
+    // i.e. new actor fields can be inserted in new program versions.
+    // The `main_actor` flag only occurs non-recursively at the top level of the memory compatibility check.
+    if !main_actor && t1 >= 0 && t2 >= 0 {
         let t1 = t1 as u32;
         let t2 = t2 as u32;
         if recurring_memory_check(rel, variance, t1, t2) {

From 0ca9ce372f03369f7be3573ab4b5d487c6eb9f1c Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Tue, 19 Dec 2023 12:03:22 +0100
Subject: [PATCH 156/260] Update benchmark results

---
 test/bench/ok/bignum.drun-run-opt.ok | 2 +-
 test/bench/ok/bignum.drun-run.ok     | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/bench/ok/bignum.drun-run-opt.ok b/test/bench/ok/bignum.drun-run-opt.ok
index 8db19b6ec90..88b82900d33 100644
--- a/test/bench/ok/bignum.drun-run-opt.ok
+++ b/test/bench/ok/bignum.drun-run-opt.ok
@@ -2,5 +2,5 @@ ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a000000000000000001
 ingress Completed: Reply: 0x4449444c0000
 debug.print: {cycles = 2_413_690; size = +60_608}
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 103_321_260; size = +1_827_460}
+debug.print: {cycles = 103_321_259; size = +1_827_460}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/bignum.drun-run.ok b/test/bench/ok/bignum.drun-run.ok
index 24b3c22f5eb..57b43412f1f 100644
--- a/test/bench/ok/bignum.drun-run.ok
+++ b/test/bench/ok/bignum.drun-run.ok
@@ -2,5 +2,5 @@ ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a000000000000000001
 ingress Completed: Reply: 0x4449444c0000
 debug.print: {cycles = 2_519_183; size = +60_608}
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 103_375_917; size = +1_827_460}
+debug.print: {cycles = 103_375_920; size = +1_827_460}
 ingress Completed: Reply: 0x4449444c0000

From e8986b32beb1c2ddecc8e84cc718c4fca4d080b0 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Tue, 19 Dec 2023 12:10:24 +0100
Subject: [PATCH 157/260] Adjust comment

---
 rts/motoko-rts/src/idl.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rts/motoko-rts/src/idl.rs b/rts/motoko-rts/src/idl.rs
index 448adddb7bc..b2936d7e470 100644
--- a/rts/motoko-rts/src/idl.rs
+++ b/rts/motoko-rts/src/idl.rs
@@ -61,7 +61,7 @@ enum CompatibilityMode {
     PureCandid,
     /// Candidish stabilization (old stabilization format).
     CandidishStabilization,
-    /// Memory compatibility used by graph-copy-based stabilization.
+    /// Memory compatibility of orthogonal persistence.
     MemoryCompatibility,
 }
 

From d6daf394dbf17d7c8ac9d713e32d1b0b9fc05da9 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Wed, 20 Dec 2023 17:24:22 +0100
Subject: [PATCH 158/260] Eliminate redundant size field in `Object` header

---
 rts/motoko-rts/src/debug.rs              |  4 ++--
 rts/motoko-rts/src/types.rs              |  6 ++++--
 src/codegen/compile.ml                   | 24 +++++++++---------------
 test/bench/ok/bignum.drun-run-opt.ok     |  2 +-
 test/bench/ok/bignum.drun-run.ok         |  2 +-
 test/bench/ok/palindrome.drun-run-opt.ok | 12 ++++++------
 test/bench/ok/palindrome.drun-run.ok     | 12 ++++++------
 test/bench/ok/region-mem.drun-run-opt.ok |  2 +-
 8 files changed, 30 insertions(+), 34 deletions(-)

diff --git a/rts/motoko-rts/src/debug.rs b/rts/motoko-rts/src/debug.rs
index 07426c387a8..e7015060eb2 100644
--- a/rts/motoko-rts/src/debug.rs
+++ b/rts/motoko-rts/src/debug.rs
@@ -142,7 +142,7 @@ pub(crate) unsafe fn print_boxed_object(buf: &mut WriteBuf, p: usize) {
             let _ = write!(
                 buf,
                 "<Object size={:#x} hash_ptr={:#x} field=[",
-                (*object).size,
+                object.size(),
                 (*object).hash_blob.get_raw()
             );
             for i in 0..object.size() {
@@ -155,7 +155,7 @@ pub(crate) unsafe fn print_boxed_object(buf: &mut WriteBuf, p: usize) {
                     let _ = write!(buf, ")");
                 }
 
-                if i != (*object).size - 1 {
+                if i != object.size() - 1 {
                     let _ = write!(buf, ",");
                 }
             }
diff --git a/rts/motoko-rts/src/types.rs b/rts/motoko-rts/src/types.rs
index 39ae8840740..73f7e9d1175 100644
--- a/rts/motoko-rts/src/types.rs
+++ b/rts/motoko-rts/src/types.rs
@@ -561,7 +561,6 @@ impl Region {
 #[repr(C)] // See the note at the beginning of this module
 pub struct Object {
     pub header: Obj,
-    pub size: u32,        // Number of elements
     pub hash_blob: Value, // Pointer to a blob containing the hashes of the object field labels.
 }
 
@@ -574,8 +573,11 @@ impl Object {
         self.add(1) as *mut Value // skip object header
     }
 
+    /// Number of fields in the object.
     pub(crate) unsafe fn size(self: *mut Self) -> u32 {
-        (*self).size
+        let hash_blob_length = (*self).hash_blob.as_blob().len().as_u32();
+        debug_assert_eq!(hash_blob_length % WORD_SIZE, 0);
+        hash_blob_length / WORD_SIZE
     }
 
     #[cfg(debug_assertions)]
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index bb38a87106d..354bd42e685 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -3511,11 +3511,11 @@ module Object = struct
   (* An object with a mutable field1 and immutable field 2 has the following
      heap layout:
  
-     ┌──────┬─────┬──────────┬──────────┬─────────┬─────────────┬───┐
-     │ obj header │ n_fields │ hash_ptr │ ind_ptr │ field2_data │ … │
-     └──────┴─────┴──────────┴┬─────────┴┬────────┴─────────────┴───┘
-          ┌───────────────────┘          │
-          │   ┌──────────────────────────┘
+     ┌──────┬─────┬──────────┬─────────┬─────────────┬───┐
+     │ obj header │ hash_ptr │ ind_ptr │ field2_data │ … │
+     └──────┴─────┴┬─────────┴┬────────┴─────────────┴───┘
+          ┌────────┘          │
+          │   ┌───────────────┘
           │   ↓
           │  ╶─┬────────┬─────────────┐
           │    │ ObjInd │ field1_data │
@@ -3525,7 +3525,8 @@ module Object = struct
           └─────────────┴─────────────┴─────────────┴───┘        
  
      The object header includes the object tag (Object) and the forwarding pointer.
- 
+     The size of the object (number of fields) can be derived from the hash blob via `hash_ptr`.
+
      The field hashes reside in a blob inside the dynamic heap.
      The hash blob needs to be tracked by the GC, but not the content of the hash blob.
      This is because the hash values are plain numbers that would look like skewed pointers.ters.
@@ -3544,11 +3545,9 @@ module Object = struct
      not for the implementing of sharing of mutable stable values.
    *)
  
-  let header_size = Int32.add Tagged.header_size 2l
+  let header_size = Int32.add Tagged.header_size 1l
  
-  (* Number of object fields *)
-  let size_field = Int32.add Tagged.header_size 0l
-  let hash_ptr_field = Int32.add Tagged.header_size 1l
+  let hash_ptr_field = Int32.add Tagged.header_size 0l
  
   module FieldEnv = Env.Make(String)
  
@@ -3581,11 +3580,6 @@ module Object = struct
       Tagged.alloc env (Int32.add header_size sz) Tagged.Object ^^
       set_ri ^^
 
-      (* Set size *)
-      get_ri ^^
-      compile_unboxed_const sz ^^
-      Tagged.store_field env size_field ^^
-
       (* Set hash_ptr *)
       get_ri ^^
       hash_blob env ^^
diff --git a/test/bench/ok/bignum.drun-run-opt.ok b/test/bench/ok/bignum.drun-run-opt.ok
index 88b82900d33..2a0331c0ead 100644
--- a/test/bench/ok/bignum.drun-run-opt.ok
+++ b/test/bench/ok/bignum.drun-run-opt.ok
@@ -1,6 +1,6 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 2_413_690; size = +60_608}
+debug.print: {cycles = 2_413_600; size = +60_608}
 ingress Completed: Reply: 0x4449444c0000
 debug.print: {cycles = 103_321_259; size = +1_827_460}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/bignum.drun-run.ok b/test/bench/ok/bignum.drun-run.ok
index 57b43412f1f..51714172ca6 100644
--- a/test/bench/ok/bignum.drun-run.ok
+++ b/test/bench/ok/bignum.drun-run.ok
@@ -1,6 +1,6 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 2_519_183; size = +60_608}
+debug.print: {cycles = 2_519_096; size = +60_608}
 ingress Completed: Reply: 0x4449444c0000
 debug.print: {cycles = 103_375_920; size = +1_827_460}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/palindrome.drun-run-opt.ok b/test/bench/ok/palindrome.drun-run-opt.ok
index d91e86fc3cf..7a1010ae0e2 100644
--- a/test/bench/ok/palindrome.drun-run-opt.ok
+++ b/test/bench/ok/palindrome.drun-run-opt.ok
@@ -1,9 +1,9 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (true, +1_548, 27_833)
-debug.print: (false, +1_548, 26_530)
-debug.print: (false, +1_548, 27_790)
-debug.print: (true, +1_160, 26_862)
-debug.print: (false, +1_148, 24_975)
-debug.print: (false, +1_148, 26_655)
+debug.print: (true, +1_544, 27_830)
+debug.print: (false, +1_544, 26_527)
+debug.print: (false, +1_544, 27_787)
+debug.print: (true, +1_156, 26_859)
+debug.print: (false, +1_144, 24_972)
+debug.print: (false, +1_144, 26_652)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/palindrome.drun-run.ok b/test/bench/ok/palindrome.drun-run.ok
index c9cbf22f959..ce3a6134c03 100644
--- a/test/bench/ok/palindrome.drun-run.ok
+++ b/test/bench/ok/palindrome.drun-run.ok
@@ -1,9 +1,9 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (true, +1_548, 29_582)
-debug.print: (false, +1_548, 28_217)
-debug.print: (false, +1_548, 29_537)
-debug.print: (true, +1_160, 28_102)
-debug.print: (false, +1_148, 26_128)
-debug.print: (false, +1_148, 27_883)
+debug.print: (true, +1_544, 29_579)
+debug.print: (false, +1_544, 28_214)
+debug.print: (false, +1_544, 29_534)
+debug.print: (true, +1_156, 28_099)
+debug.print: (false, +1_144, 26_125)
+debug.print: (false, +1_144, 27_880)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/region-mem.drun-run-opt.ok b/test/bench/ok/region-mem.drun-run-opt.ok
index 5007d210bcd..6df45bd93c7 100644
--- a/test/bench/ok/region-mem.drun-run-opt.ok
+++ b/test/bench/ok/region-mem.drun-run-opt.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 7_788_823_069}
+debug.print: {heap_diff = 0; instr_diff = 7_788_823_066}
 ingress Completed: Reply: 0x4449444c0000

From a613365935566811f21939af7d3aa6f6c059b954 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 21 Dec 2023 18:15:10 +0100
Subject: [PATCH 159/260] Record the upgrade instruction costs

---
 rts/motoko-rts/src/persistence.rs             | 17 ++++++++
 src/codegen/compile.ml                        | 29 +++++++++++++-
 src/mo_values/prim.ml                         |  3 +-
 src/prelude/prim.mo                           |  3 ++
 test/fail/ok/no-timer-canc.tc.ok              |  1 +
 test/fail/ok/no-timer-set.tc.ok               |  1 +
 .../ok/upgrade-instructions.drun-run.ok       | 12 ++++++
 test/run-drun/upgrade-instructions.mo         | 40 +++++++++++++++++++
 8 files changed, 103 insertions(+), 3 deletions(-)
 create mode 100644 test/run-drun/ok/upgrade-instructions.drun-run.ok
 create mode 100644 test/run-drun/upgrade-instructions.mo

diff --git a/rts/motoko-rts/src/persistence.rs b/rts/motoko-rts/src/persistence.rs
index 0d8393b4407..9f740341e03 100644
--- a/rts/motoko-rts/src/persistence.rs
+++ b/rts/motoko-rts/src/persistence.rs
@@ -49,6 +49,8 @@ struct PersistentMetadata {
     /// Singleton of the top-level null value. To be retained across upgrades.
     /// Constitutes a GC root and requires pointer forwarding.
     null_singleton: Value,
+    /// Upgrade performance statistics: Total number of instructions consumed by the last upgrade.
+    upgrade_instructions: u64,
 }
 
 /// Location of the persistent metadata. Prereserved and fixed forever.
@@ -101,6 +103,7 @@ impl PersistentMetadata {
         (*self).stable_type = TypeDescriptor::default();
         (*self).incremental_gc_state = IncrementalGC::initial_gc_state(mem, HEAP_START);
         (*self).null_singleton = DEFAULT_VALUE;
+        (*self).upgrade_instructions = 0;
     }
 }
 
@@ -247,3 +250,17 @@ pub(crate) unsafe fn get_incremental_gc_state() -> &'static mut State {
     let metadata = PersistentMetadata::get();
     &mut (*metadata).incremental_gc_state
 }
+
+#[no_mangle]
+#[cfg(feature = "ic")]
+pub unsafe extern "C" fn get_upgrade_instructions() -> u64 {
+    let metadata = PersistentMetadata::get();
+    (*metadata).upgrade_instructions
+}
+
+#[no_mangle]
+#[cfg(feature = "ic")]
+pub unsafe extern "C" fn set_upgrade_instructions(instructions: u64) {
+    let metadata = PersistentMetadata::get();
+    (*metadata).upgrade_instructions = instructions;
+}
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index db4bfa0fd6d..566370ffc5b 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -950,6 +950,8 @@ module RTS = struct
     E.add_func_import env "rts" "set_static_root" [I32Type] [];
     E.add_func_import env "rts" "get_static_root" [] [I32Type];
     E.add_func_import env "rts" "null_singleton" [] [I32Type];
+    E.add_func_import env "rts" "set_upgrade_instructions" [I64Type] [];
+    E.add_func_import env "rts" "get_upgrade_instructions" [] [I64Type];
     E.add_func_import env "rts" "memcpy" [I32Type; I32Type; I32Type] [I32Type]; (* standard libc memcpy *)
     E.add_func_import env "rts" "memcmp" [I32Type; I32Type; I32Type] [I32Type];
     E.add_func_import env "rts" "version" [] [I32Type];
@@ -5382,6 +5384,23 @@ module StableMemoryInterface = struct
 
 end
 
+module UpgradeStatistics = struct
+  let get_upgrade_instructions env =
+    E.call_import env "rts" "get_upgrade_instructions"
+  let set_upgrade_instructions env =
+    E.call_import env "rts" "set_upgrade_instructions"
+
+  let add_instructions env =
+    get_upgrade_instructions env ^^
+    GC.instruction_counter env ^^
+    G.i (Binary (Wasm.Values.I64 I64Op.Add)) ^^
+    set_upgrade_instructions env
+
+  let set_instructions env =
+    GC.instruction_counter env ^^
+    set_upgrade_instructions env
+end
+
 module RTS_Exports = struct
   (* Must be called late, after main codegen, to ensure correct generation of
      of functioning or unused-but-trapping stable memory exports (as required)
@@ -7771,7 +7790,8 @@ module Persistence = struct
 
   let save env actor_type =
     save_stable_actor env ^^
-    NewStableMemory.backup env
+    NewStableMemory.backup env ^^
+    UpgradeStatistics.set_instructions env
 
   let load env actor_type =
     register_stable_type env actor_type ^^
@@ -7785,7 +7805,8 @@ module Persistence = struct
         recover_actor env actor_type ^^
         NewStableMemory.restore env
       end) ^^
-    StableMem.region_init env
+    StableMem.region_init env ^^
+    UpgradeStatistics.add_instructions env
 end
 
 module GCRoots = struct
@@ -10374,6 +10395,10 @@ and compile_prim_invocation (env : E.t) ae p es at =
     SR.Vanilla,
     GC.get_collector_instructions env ^^ BigNum.from_word64 env
 
+  | OtherPrim "rts_upgrade_instructions", [] ->
+    SR.Vanilla,
+    UpgradeStatistics.get_upgrade_instructions env ^^ BigNum.from_word64 env
+
   | OtherPrim "rts_stable_memory_size", [] ->
     SR.Vanilla,
     StableMem.stable64_size env ^^ BigNum.from_word64 env
diff --git a/src/mo_values/prim.ml b/src/mo_values/prim.ml
index efe34b5d359..84049f7c2c9 100644
--- a/src/mo_values/prim.ml
+++ b/src/mo_values/prim.ml
@@ -224,7 +224,8 @@ let prim trap =
      | "rts_callback_table_count"
      | "rts_callback_table_size"
      | "rts_mutator_instructions"
-     | "rts_collector_instructions") ->
+     | "rts_collector_instructions"
+     | "rts_upgrade_instructions") ->
         fun _ v k -> as_unit v; k (Int (Int.of_int 0))
   | "time" -> fun _ v k -> as_unit v; k (Value.Nat64 (Numerics.Nat64.of_int 42))
   | "idlHash" -> fun _ v k ->
diff --git a/src/prelude/prim.mo b/src/prelude/prim.mo
index 75652073272..e95c96d38e9 100644
--- a/src/prelude/prim.mo
+++ b/src/prelude/prim.mo
@@ -84,6 +84,9 @@ func rts_mutator_instructions() : Nat {
 func rts_collector_instructions() : Nat {
   (prim "rts_collector_instructions" : () -> Nat)();
 };
+func rts_upgrade_instructions() : Nat {
+  (prim "rts_upgrade_instructions" : () -> Nat)();
+};
 
 func rts_stable_memory_size() : Nat {
   (prim "rts_stable_memory_size" : () -> Nat) ()
diff --git a/test/fail/ok/no-timer-canc.tc.ok b/test/fail/ok/no-timer-canc.tc.ok
index 2cf6ec61c3e..a7fa91fa8d4 100644
--- a/test/fail/ok/no-timer-canc.tc.ok
+++ b/test/fail/ok/no-timer-canc.tc.ok
@@ -210,6 +210,7 @@ no-timer-canc.mo:3.10-3.21: type error [M0119], object field cancelTimer is not
     rts_reclaimed : () -> Nat;
     rts_stable_memory_size : () -> Nat;
     rts_total_allocation : () -> Nat;
+    rts_upgrade_instructions : () -> Nat;
     rts_version : () -> Text;
     setCertifiedData : Blob -> ();
     shiftLeft : (Nat, Nat32) -> Nat;
diff --git a/test/fail/ok/no-timer-set.tc.ok b/test/fail/ok/no-timer-set.tc.ok
index 7c46ff57e95..72ba3ab6b8d 100644
--- a/test/fail/ok/no-timer-set.tc.ok
+++ b/test/fail/ok/no-timer-set.tc.ok
@@ -210,6 +210,7 @@ no-timer-set.mo:3.10-3.18: type error [M0119], object field setTimer is not cont
     rts_reclaimed : () -> Nat;
     rts_stable_memory_size : () -> Nat;
     rts_total_allocation : () -> Nat;
+    rts_upgrade_instructions : () -> Nat;
     rts_version : () -> Text;
     setCertifiedData : Blob -> ();
     shiftLeft : (Nat, Nat32) -> Nat;
diff --git a/test/run-drun/ok/upgrade-instructions.drun-run.ok b/test/run-drun/ok/upgrade-instructions.drun-run.ok
new file mode 100644
index 00000000000..ca037b0974d
--- /dev/null
+++ b/test/run-drun/ok/upgrade-instructions.drun-run.ok
@@ -0,0 +1,12 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+debug.print: Ignore Diff: (ignored)
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Ignore Diff: (ignored)
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Ignore Diff: (ignored)
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Ignore Diff: (ignored)
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/upgrade-instructions.mo b/test/run-drun/upgrade-instructions.mo
new file mode 100644
index 00000000000..38489a31a36
--- /dev/null
+++ b/test/run-drun/upgrade-instructions.mo
@@ -0,0 +1,40 @@
+import Prim "mo:prim";
+
+actor {
+  stable var lastInstructions = 0;
+  stable var length = 0;
+  stable var stableArray : [Nat] = [];
+
+  if (length > 0) {
+    assert (Prim.rts_upgrade_instructions() >= lastInstructions);
+    lastInstructions := Prim.rts_upgrade_instructions();
+    assert(lastInstructions > 0);
+  };
+  Prim.debugPrint("Ignore Diff: Upgrade instructions: " # debug_show (Prim.rts_upgrade_instructions()));
+
+  public func increase() : async () {
+    if (length == 0) {
+      length := 1_000;
+    } else {
+      length *= 10;
+    };
+    let newArray = Prim.Array_tabulate<Nat>(
+      length,
+      func(index) {
+        index * index;
+      },
+    );
+    stableArray := newArray;
+  };
+};
+
+//SKIP run
+//SKIP run-ir
+//SKIP run-low
+
+//CALL ingress increase "DIDL\x00\x00"
+//CALL upgrade ""
+//CALL ingress increase "DIDL\x00\x00"
+//CALL upgrade ""
+//CALL ingress increase "DIDL\x00\x00"
+//CALL upgrade ""

From 193a6846ea19723a8cbb7a4b1dca813774763b59 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 4 Jan 2024 18:14:32 +0100
Subject: [PATCH 160/260] Update IC dependency

---
 nix/drun.nix                              | 29 ++++++++++++-----------
 nix/sources.json                          |  6 ++---
 test/bench/ok/alloc.drun-run-opt.ok       |  6 ++---
 test/bench/ok/alloc.drun-run.ok           |  6 ++---
 test/bench/ok/bignum.drun-run-opt.ok      |  4 ++--
 test/bench/ok/bignum.drun-run.ok          |  4 ++--
 test/bench/ok/heap-32.drun-run-opt.ok     |  4 ++--
 test/bench/ok/heap-32.drun-run.ok         |  4 ++--
 test/bench/ok/nat16.drun-run-opt.ok       |  2 +-
 test/bench/ok/nat16.drun-run.ok           |  2 +-
 test/bench/ok/palindrome.drun-run-opt.ok  | 12 +++++-----
 test/bench/ok/palindrome.drun-run.ok      | 12 +++++-----
 test/bench/ok/region-mem.drun-run-opt.ok  |  2 +-
 test/bench/ok/region-mem.drun-run.ok      |  2 +-
 test/bench/ok/region0-mem.drun-run-opt.ok |  2 +-
 test/bench/ok/region0-mem.drun-run.ok     |  2 +-
 test/bench/ok/stable-mem.drun-run-opt.ok  |  2 +-
 test/bench/ok/stable-mem.drun-run.ok      |  2 +-
 test/run-drun/ok/perf.drun-run.ok         |  2 +-
 19 files changed, 53 insertions(+), 52 deletions(-)

diff --git a/nix/drun.nix b/nix/drun.nix
index deeb992fbba..d59d8103647 100644
--- a/nix/drun.nix
+++ b/nix/drun.nix
@@ -18,29 +18,30 @@ pkgs:
       cargoLock = {
         lockFile = "${pkgs.sources.ic}/Cargo.lock";
         outputHashes = {
+          "build-info-0.0.27" = "sha256-SkwWwDNrTsntkNiCv6rsyTFGazhpRDnKtVzPpYLKF9U=";
           "derive_more-0.99.8-alpha.0" = "sha256-tEsfYC9oCAsDjinCsUDgRg3q6ruvayuA1lRmsEP9cys=";
-          "ic-btc-interface-0.1.0" = "sha256-VecEMFjoeiRi0VgJ9CeDoOzdyJbJNiZ5MBmiV1+b7As=";
+          "icrc1-test-env-0.1.1" = "sha256-yWJF+KM8l65Nr0pwR9QeltkqbHDzOLNPVnLhf1mRukQ=";
+          "ic-btc-interface-0.1.0" = "sha256-JoVg1t62C2FIe0la1oQzidybLj1CyAQy80gkRh/MTn0=";
+          "ic-btc-test-utils-0.1.0" = "sha256-VecEMFjoeiRi0VgJ9CeDoOzdyJbJNiZ5MBmiV1+b7As=";
           "jsonrpc-0.12.1" = "sha256-3FtdZlt2PqVDkE5iKWYIp1eiIELsaYlUPRSP2Xp8ejM=";
           "libssh2-sys-0.2.23" = "sha256-9Hb7CnPF+lxrVO1NAhS7EXcPVWZutJXr6UWxpptzk4U=";
-          "lmdb-rkv-0.14.99" = "sha256-dqxWgtNZ/qRukQLiDawjHRwdPgfzm/sVcWwudwX9rD8=";
-          "pprof-0.10.1" = "sha256-ioZ8AyFTUUev8MDZapto0yXC6G+dZzg+7ZNtTR87Rg4=";
+          "lmdb-rkv-0.14.99" = "sha256-5WcUzapkrc/s3wCBNCuUDhtbp17n67rTbm2rx0qtITg=";
         };
       };
 
       patchPhase = ''
         cd ../cargo-vendor-dir
         patch librocksdb-sys*/build.rs << EOF
-@@ -118,6 +118,10 @@
-         config.define("OS_MACOSX", Some("1"));
-         config.define("ROCKSDB_PLATFORM_POSIX", Some("1"));
-         config.define("ROCKSDB_LIB_IO_POSIX", Some("1"));
-+        if target.contains("aarch64") {
-+            config.define("isSSE42()", Some("0"));
-+            config.define("isPCLMULQDQ()", Some("0"));
-+        }
-     } else if target.contains("android") {
-         config.define("OS_ANDROID", Some("1"));
-         config.define("ROCKSDB_PLATFORM_POSIX", Some("1"));
+@@ -249,6 +249,9 @@ fn build_rocksdb() {
+         config.flag("-Wno-missing-field-initializers");
+         config.flag("-Wno-strict-aliasing");
+         config.flag("-Wno-invalid-offsetof");
++        if target.contains("darwin") {
++            config.flag("-faligned-allocation");
++        }    
+     }
+
+     for file in lib_sources {
 EOF
 
         cd -
diff --git a/nix/sources.json b/nix/sources.json
index 890dcbfe25c..3969bf4c816 100644
--- a/nix/sources.json
+++ b/nix/sources.json
@@ -26,10 +26,10 @@
         "homepage": "",
         "owner": "dfinity",
         "repo": "ic",
-        "rev": "418b964468d7706836c7b4e3b166a58526a4ac16",
-        "sha256": "1gbrmfnmn8245isj865dd48xcnpfdyi1aqgk79avi6xgzzc3nwk7",
+        "rev": "d3225d44df101150b96aa86be8e5e82255333f9f",
+        "sha256": "1kv83i33vav1h62ymmiw72c6npa19hb4mr4m6rhv7qwhv1n3x7py",
         "type": "tarball",
-        "url": "https://github.com/dfinity/ic/archive/418b964468d7706836c7b4e3b166a58526a4ac16.tar.gz",
+        "url": "https://github.com/dfinity/ic/archive/d3225d44df101150b96aa86be8e5e82255333f9f.tar.gz",
         "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
     },
     "ic-hs": {
diff --git a/test/bench/ok/alloc.drun-run-opt.ok b/test/bench/ok/alloc.drun-run-opt.ok
index 16540a7a4f9..b7e79a12027 100644
--- a/test/bench/ok/alloc.drun-run-opt.ok
+++ b/test/bench/ok/alloc.drun-run-opt.ok
@@ -1,8 +1,8 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_764_731_856)
+debug.print: (+335_544_320, 4_076_868_902)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_764_731_673)
+debug.print: (+335_544_320, 4_076_865_999)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_764_731_685)
+debug.print: (+335_544_320, 4_076_866_013)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/alloc.drun-run.ok b/test/bench/ok/alloc.drun-run.ok
index 4cc2441198a..a3168dac965 100644
--- a/test/bench/ok/alloc.drun-run.ok
+++ b/test/bench/ok/alloc.drun-run.ok
@@ -1,8 +1,8 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_898_949_823)
+debug.print: (+335_544_320, 4_244_641_333)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_898_949_630)
+debug.print: (+335_544_320, 4_244_638_420)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_898_949_643)
+debug.print: (+335_544_320, 4_244_638_435)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/bignum.drun-run-opt.ok b/test/bench/ok/bignum.drun-run-opt.ok
index 2a0331c0ead..0878f6d750b 100644
--- a/test/bench/ok/bignum.drun-run-opt.ok
+++ b/test/bench/ok/bignum.drun-run-opt.ok
@@ -1,6 +1,6 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 2_413_600; size = +60_608}
+debug.print: {cycles = 2_524_687; size = +60_608}
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 103_321_259; size = +1_827_460}
+debug.print: {cycles = 107_802_010; size = +1_827_460}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/bignum.drun-run.ok b/test/bench/ok/bignum.drun-run.ok
index 51714172ca6..a3d53d71247 100644
--- a/test/bench/ok/bignum.drun-run.ok
+++ b/test/bench/ok/bignum.drun-run.ok
@@ -1,6 +1,6 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 2_519_096; size = +60_608}
+debug.print: {cycles = 2_631_309; size = +60_608}
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 103_375_920; size = +1_827_460}
+debug.print: {cycles = 107_962_919; size = +1_827_460}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/heap-32.drun-run-opt.ok b/test/bench/ok/heap-32.drun-run-opt.ok
index ab02ec775f2..f3799847935 100644
--- a/test/bench/ok/heap-32.drun-run-opt.ok
+++ b/test/bench/ok/heap-32.drun-run-opt.ok
@@ -1,5 +1,5 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (50_227, +37_021_304, 767_984_270)
-debug.print: (50_070, +40_056_236, 830_437_421)
+debug.print: (50_227, +37_021_304, 766_107_734)
+debug.print: (50_070, +40_056_236, 827_511_356)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/heap-32.drun-run.ok b/test/bench/ok/heap-32.drun-run.ok
index 61139fd47df..98c7140a2b5 100644
--- a/test/bench/ok/heap-32.drun-run.ok
+++ b/test/bench/ok/heap-32.drun-run.ok
@@ -1,5 +1,5 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (50_227, +37_021_304, 815_894_744)
-debug.print: (50_070, +40_056_236, 880_136_131)
+debug.print: (50_227, +37_021_304, 816_577_323)
+debug.print: (50_070, +40_056_236, 879_831_106)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/nat16.drun-run-opt.ok b/test/bench/ok/nat16.drun-run-opt.ok
index 892c7d73148..d93ecabef72 100644
--- a/test/bench/ok/nat16.drun-run-opt.ok
+++ b/test/bench/ok/nat16.drun-run-opt.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (0, 18_875_155)
+debug.print: (0, 22_021_129)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/nat16.drun-run.ok b/test/bench/ok/nat16.drun-run.ok
index 38425f9a5b4..93bdc7e9135 100644
--- a/test/bench/ok/nat16.drun-run.ok
+++ b/test/bench/ok/nat16.drun-run.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (0, 42_992_119)
+debug.print: (0, 51_380_877)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/palindrome.drun-run-opt.ok b/test/bench/ok/palindrome.drun-run-opt.ok
index 7a1010ae0e2..683cfb1d396 100644
--- a/test/bench/ok/palindrome.drun-run-opt.ok
+++ b/test/bench/ok/palindrome.drun-run-opt.ok
@@ -1,9 +1,9 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (true, +1_544, 27_830)
-debug.print: (false, +1_544, 26_527)
-debug.print: (false, +1_544, 27_787)
-debug.print: (true, +1_156, 26_859)
-debug.print: (false, +1_144, 24_972)
-debug.print: (false, +1_144, 26_652)
+debug.print: (true, +1_544, 25_032)
+debug.print: (false, +1_544, 23_318)
+debug.print: (false, +1_544, 24_968)
+debug.print: (true, +1_156, 25_486)
+debug.print: (false, +1_144, 23_109)
+debug.print: (false, +1_144, 25_329)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/palindrome.drun-run.ok b/test/bench/ok/palindrome.drun-run.ok
index ce3a6134c03..b696471867d 100644
--- a/test/bench/ok/palindrome.drun-run.ok
+++ b/test/bench/ok/palindrome.drun-run.ok
@@ -1,9 +1,9 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (true, +1_544, 29_579)
-debug.print: (false, +1_544, 28_214)
-debug.print: (false, +1_544, 29_534)
-debug.print: (true, +1_156, 28_099)
-debug.print: (false, +1_144, 26_125)
-debug.print: (false, +1_144, 27_880)
+debug.print: (true, +1_544, 26_857)
+debug.print: (false, +1_544, 25_081)
+debug.print: (false, +1_544, 26_791)
+debug.print: (true, +1_156, 27_161)
+debug.print: (false, +1_144, 24_624)
+debug.print: (false, +1_144, 26_994)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/region-mem.drun-run-opt.ok b/test/bench/ok/region-mem.drun-run-opt.ok
index 6df45bd93c7..c64e4a821cf 100644
--- a/test/bench/ok/region-mem.drun-run-opt.ok
+++ b/test/bench/ok/region-mem.drun-run-opt.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 7_788_823_066}
+debug.print: {heap_diff = 0; instr_diff = 8_657_043_872}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/region-mem.drun-run.ok b/test/bench/ok/region-mem.drun-run.ok
index 952fb0b0355..7e5ebd3f0b6 100644
--- a/test/bench/ok/region-mem.drun-run.ok
+++ b/test/bench/ok/region-mem.drun-run.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 8_745_124_231}
+debug.print: {heap_diff = 0; instr_diff = 9_386_852_794}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/region0-mem.drun-run-opt.ok b/test/bench/ok/region0-mem.drun-run-opt.ok
index 2c70cdb4026..c9399b5142d 100644
--- a/test/bench/ok/region0-mem.drun-run-opt.ok
+++ b/test/bench/ok/region0-mem.drun-run-opt.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 7_159_677_284}
+debug.print: {heap_diff = 0; instr_diff = 8_002_732_446}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/region0-mem.drun-run.ok b/test/bench/ok/region0-mem.drun-run.ok
index 0765df65ce5..1ddc9e6da71 100644
--- a/test/bench/ok/region0-mem.drun-run.ok
+++ b/test/bench/ok/region0-mem.drun-run.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 7_889_486_215}
+debug.print: {heap_diff = 0; instr_diff = 8_757_707_194}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/stable-mem.drun-run-opt.ok b/test/bench/ok/stable-mem.drun-run-opt.ok
index 02f1b9e3785..5bd807fdc12 100644
--- a/test/bench/ok/stable-mem.drun-run-opt.ok
+++ b/test/bench/ok/stable-mem.drun-run-opt.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 3_397_386_596}
+debug.print: {heap_diff = 0; instr_diff = 4_341_105_054}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/stable-mem.drun-run.ok b/test/bench/ok/stable-mem.drun-run.ok
index 95e61450410..2dd9a6cf0e4 100644
--- a/test/bench/ok/stable-mem.drun-run.ok
+++ b/test/bench/ok/stable-mem.drun-run.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 4_089_446_791}
+debug.print: {heap_diff = 0; instr_diff = 4_932_501_946}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/perf.drun-run.ok b/test/run-drun/ok/perf.drun-run.ok
index f49c90e6572..d8daae9f670 100644
--- a/test/run-drun/ok/perf.drun-run.ok
+++ b/test/run-drun/ok/perf.drun-run.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: 50_218
+debug.print: 66_251
 ingress Completed: Reply: 0x4449444c0000

From e8fe7d80e4dac652075c69b8c239891ad10dda74 Mon Sep 17 00:00:00 2001
From: Nix hash updater <41898282+github-actions[bot]@users.noreply.github.com>
Date: Thu, 4 Jan 2024 17:16:22 +0000
Subject: [PATCH 161/260] Updating nix hashes

---
 nix/drun.nix | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nix/drun.nix b/nix/drun.nix
index d59d8103647..267e4810cca 100644
--- a/nix/drun.nix
+++ b/nix/drun.nix
@@ -20,9 +20,9 @@ pkgs:
         outputHashes = {
           "build-info-0.0.27" = "sha256-SkwWwDNrTsntkNiCv6rsyTFGazhpRDnKtVzPpYLKF9U=";
           "derive_more-0.99.8-alpha.0" = "sha256-tEsfYC9oCAsDjinCsUDgRg3q6ruvayuA1lRmsEP9cys=";
-          "icrc1-test-env-0.1.1" = "sha256-yWJF+KM8l65Nr0pwR9QeltkqbHDzOLNPVnLhf1mRukQ=";
           "ic-btc-interface-0.1.0" = "sha256-JoVg1t62C2FIe0la1oQzidybLj1CyAQy80gkRh/MTn0=";
           "ic-btc-test-utils-0.1.0" = "sha256-VecEMFjoeiRi0VgJ9CeDoOzdyJbJNiZ5MBmiV1+b7As=";
+          "icrc1-test-env-0.1.1" = "sha256-yWJF+KM8l65Nr0pwR9QeltkqbHDzOLNPVnLhf1mRukQ=";
           "jsonrpc-0.12.1" = "sha256-3FtdZlt2PqVDkE5iKWYIp1eiIELsaYlUPRSP2Xp8ejM=";
           "libssh2-sys-0.2.23" = "sha256-9Hb7CnPF+lxrVO1NAhS7EXcPVWZutJXr6UWxpptzk4U=";
           "lmdb-rkv-0.14.99" = "sha256-5WcUzapkrc/s3wCBNCuUDhtbp17n67rTbm2rx0qtITg=";

From 1e2e35df56e690a34ca56fc4eaa918eab7aa867d Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Tue, 9 Jan 2024 11:36:25 +0100
Subject: [PATCH 162/260] Update IC dependency

---
 nix/sources.json | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/nix/sources.json b/nix/sources.json
index 3969bf4c816..3a0acbf1429 100644
--- a/nix/sources.json
+++ b/nix/sources.json
@@ -26,10 +26,10 @@
         "homepage": "",
         "owner": "dfinity",
         "repo": "ic",
-        "rev": "d3225d44df101150b96aa86be8e5e82255333f9f",
-        "sha256": "1kv83i33vav1h62ymmiw72c6npa19hb4mr4m6rhv7qwhv1n3x7py",
+        "rev": "7e5d8c4d5c50bdef548bb963d39598ea99cacc6e",
+        "sha256": "11ddqq2ca9igshvvnzlx9x6g0mm2n69fzagd0zcdipiwmfzb0mpl",
         "type": "tarball",
-        "url": "https://github.com/dfinity/ic/archive/d3225d44df101150b96aa86be8e5e82255333f9f.tar.gz",
+        "url": "https://github.com/dfinity/ic/archive/7e5d8c4d5c50bdef548bb963d39598ea99cacc6e.tar.gz",
         "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
     },
     "ic-hs": {

From 1e83095a4c4d69f610046dd65cf082ed6047dd4b Mon Sep 17 00:00:00 2001
From: Luc Blaeser <112870813+luc-blaeser@users.noreply.github.com>
Date: Thu, 22 Feb 2024 17:31:23 +0100
Subject: [PATCH 163/260] Enhanced Orthogonal Persistence: Use Passive Data
 Segments (32-Bit) (#4410)

Only passive Wasm data segments are used by the compiler and runtime system. In contrast to ordinary active data segments, passive segments can be explicitly loaded to a dynamic address.

This simplifies two aspects:
* The generated Motoko code can contain arbitrarily large data segments which can loaded to dynamic heap when needed.
* The IC can simply retain the main memory on an upgrade without needing to patch the active data segments of the new program version to the persistent memory.

However, more specific handling is required for the Rust-implemented runtime system:
The Rust-generated active data segments of the runtime system is changed to passive and loaded to the expected static address at the program start (canister initialization and upgrade).
The location and size of the RTS data segments is therefore limited to a defined reserve, see above.
This is acceptable because the RTS only uses small size for data segments (e.g. 54KB) that is independent of the compiled Motoko program.
---
 default.nix                                   |  42 +--
 design/OrthogonalPersistence.md               |  34 +--
 nix/sources.json                              |  10 +-
 rts/motoko-rts/src/idl.rs                     |  18 +-
 rts/motoko-rts/src/persistence.rs             |   8 +-
 .../src/persistence/compatibility.rs          |  48 +--
 src/codegen/compile.ml                        | 276 ++++++++++--------
 src/linking/linkModule.ml                     | 117 +++++++-
 src/wasm-exts/ast.ml                          |  23 +-
 src/wasm-exts/customModule.ml                 |   4 +
 src/wasm-exts/customModuleDecode.ml           |  69 ++++-
 src/wasm-exts/customModuleEncode.ml           |  37 ++-
 src/wasm-exts/operators.ml                    |   5 +-
 test/bench/ok/alloc.drun-run-opt.ok           |   8 -
 test/bench/ok/bignum.drun-run-opt.ok          |   6 -
 test/bench/ok/bignum.drun-run.ok              |   4 +-
 test/bench/ok/heap-32.drun-run-opt.ok         |   5 -
 test/bench/ok/nat16.drun-run-opt.ok           |   4 -
 test/bench/ok/palindrome.drun-run-opt.ok      |   9 -
 test/bench/ok/palindrome.drun-run.ok          |  12 +-
 test/bench/ok/region-mem.drun-run-opt.ok      |   4 -
 test/bench/ok/region0-mem.drun-run-opt.ok     |   4 -
 test/bench/ok/stable-mem.drun-run-opt.ok      |   4 -
 test/run-drun/max-stack.mo                    |   2 +-
 .../run-drun/ok/migrate-stabilization.drun.ok |   2 +-
 test/run.sh                                   |   9 +-
 test/run/refuted-const-float.mo               |   2 +-
 test/run/refuted-const-option-null.mo         |   2 +-
 test/run/refuted-const-option.mo              |   2 +-
 test/run/refuted-const-variant.mo             |   2 +-
 30 files changed, 491 insertions(+), 281 deletions(-)
 delete mode 100644 test/bench/ok/alloc.drun-run-opt.ok
 delete mode 100644 test/bench/ok/bignum.drun-run-opt.ok
 delete mode 100644 test/bench/ok/heap-32.drun-run-opt.ok
 delete mode 100644 test/bench/ok/nat16.drun-run-opt.ok
 delete mode 100644 test/bench/ok/palindrome.drun-run-opt.ok
 delete mode 100644 test/bench/ok/region-mem.drun-run-opt.ok
 delete mode 100644 test/bench/ok/region0-mem.drun-run-opt.ok
 delete mode 100644 test/bench/ok/stable-mem.drun-run-opt.ok

diff --git a/default.nix b/default.nix
index 0c15c7a4e90..f2a0f0ca3dc 100644
--- a/default.nix
+++ b/default.nix
@@ -415,23 +415,24 @@ rec {
       '';
     };
 
-    profiling-graphs = testDerivation {
-      src = test_src "perf";
-      buildInputs =
-        (with nixpkgs; [ perl wabt wasm-profiler-instrument wasm-profiler-postproc flamegraph-bin ]) ++
-        [ moc nixpkgs.drun ];
-      checkPhase = ''
-        patchShebangs .
-        type -p moc && moc --version
-        type -p drun && drun --help
-        ./profile-report.sh
-      '';
-      installPhase = ''
-        mv _profile $out;
-        mkdir -p $out/nix-support
-        echo "report flamegraphs $out index.html" >> $out/nix-support/hydra-build-products
-      '';
-    };
+    # wasm-profiler is not compatible with passive data segments
+    # profiling-graphs = testDerivation {
+    #  src = test_src "perf";
+    #  buildInputs =
+    #    (with nixpkgs; [ perl wabt wasm-profiler-instrument wasm-profiler-postproc flamegraph-bin ]) ++
+    #    [ moc nixpkgs.drun ];
+    #  checkPhase = ''
+    #    patchShebangs .
+    #    type -p moc && moc --version
+    #    type -p drun && drun --help
+    #    ./profile-report.sh
+    #  '';
+    #  installPhase = ''
+    #    mv _profile $out;
+    #    mkdir -p $out/nix-support
+    #    echo "report flamegraphs $out index.html" >> $out/nix-support/hydra-build-products
+    #  '';
+    #};
 
 
     fix_names = builtins.mapAttrs (name: deriv:
@@ -480,7 +481,8 @@ rec {
       perf       = perf_subdir "perf"       [ moc nixpkgs.drun ];
       bench      = perf_subdir "bench"      [ moc nixpkgs.drun ic-wasm ];
       # viper      = test_subdir "viper"      [ moc nixpkgs.which nixpkgs.openjdk nixpkgs.z3 ];
-      inherit qc lsp unit candid profiling-graphs coverage;
+      # TODO: profiling-graph is excluded because the underlying partity_wasm is deprecated and does not support passive data segments.
+      inherit qc lsp unit candid coverage;
     }) // { recurseForDerivations = true; };
 
   samples = stdenv.mkDerivation {
@@ -672,15 +674,13 @@ EOF
     mkdir -p $out
     ln -s ${base-doc} $out/base-doc
     ln -s ${docs} $out/docs
-    ln -s ${tests.profiling-graphs} $out/flamegraphs
     ln -s ${tests.coverage} $out/coverage
     cd $out;
     # generate a simple index.html, listing the entry points
     ( echo docs/overview-slides.html;
       echo docs/html/motoko.html;
       echo base-doc/
-      echo coverage/
-      echo flamegraphs/ ) | \
+      echo coverage/ ) | \
       tree -H . -l --fromfile -T "Motoko build reports" > index.html
   '';
 
diff --git a/design/OrthogonalPersistence.md b/design/OrthogonalPersistence.md
index 5c3eac11d85..c891f55ddc9 100644
--- a/design/OrthogonalPersistence.md
+++ b/design/OrthogonalPersistence.md
@@ -23,16 +23,14 @@ The stable heap is based on the following main properties:
 
 ### IC Extension
 As a prerequisite for the stable heap support, the IC runtime support has to be extended in order not to erase the main memory on upgrades.
-This is realized in a specific IC branch (https://github.com/luc-blaeser/ic/tree/luc/stable-heap-on-release) that retains the main memory even on upgrades, similar to normal canister message execution. 
-The only data that needs to be updated on an upgrade is the Wasm data segments specified in the Wasm binary, e.g. text literals. 
-For this purpose, a special memory section is reserved for data segments.
+This is realized in a specific IC PR (https://github.com/luc-blaeser/ic/tree/luc/stable-heap-on-release) that retains the main memory even on upgrades, similar to normal canister message execution. 
 
 ### Memory Layout
 In a co-design between the compiler and the runtime system, the main memory is arranged in the following structure, invariant of the compiled program version:
-* Lower 2MB: Rust call stack.
-* Space between 2MB and 6MB: Reserved space Wasm data segments.
-* Between 6MB and 6.125MB: Persistent metadata.
-* Thereafter: Dynamic heap space. Fix start address at 6.125MB.
+* Lower 4MB: Rust call stack.
+* Space between 4MB and 4.5MB: Limited reserved space Wasm data segments, only used for the Motoko runtime system.
+* Between 4.5MB and 5MB: Persistent metadata.
+* Thereafter: Dynamic heap space. Fix start address at 5MB.
 
 ### Persistent Metadata
 The persistent metadata describes all anchor information for the program to resume after an upgrade. 
@@ -86,15 +84,6 @@ The remaining actor variables, the flexible fields as well as new stable variabl
 As a result, the GC can collect unreachable flexible objects of previous canister versions. 
 Unused stable variables of former versions can also be reclaimed by the GC.
 
-### Wasm Data Segments
-Wasm data segments are reinitialized on upgrade. 
-This is necessary because data segments may contain text literals or transient GC roots that are bound to a specific new Wasm binary.
-The system reserves dedicated space for data segments, namely between 2MB and 6MB. 
-Therefore, the data segments are limited to 4MB per canister Wasm in this design. 
-Both the linker and the IC runtime system check that the data segments fit inside this reserved space.
-
-There exist alternative design possibilities to handle data segments, see below.
-
 ### No Static Heap
 The static heap is abandoned and former static objects need to be allocated in the dynamic heap.
 This is because these objects may also need to survive upgrades and must not be not overwritten by new data segments. 
@@ -106,6 +95,18 @@ Instead, such global runtime state is stored in the persistent metadata.
 
 Sharing optimization (pooling) is possible for compile-time-known objects, see below.
 
+### Wasm Data Segments
+Only passive Wasm data segments are used by the compiler and runtime system. In contrast to ordinary active data segments, passive segments can be explicitly loaded to a dynamic address.
+
+This simplifies two aspects: 
+* The generated Motoko code can contain arbitrarily large data segments which can loaded to dynamic heap when needed.
+* The IC can simply retain the main memory on an upgrade without needing to patch the active data segments of the new program version to the persistent memory.
+
+However, more specific handling is required for the Rust-implemented runtime system:
+The Rust-generated active data segments of the runtime system is changed to passive and loaded to the expected static address at the program start (canister initialization and upgrade).
+The location and size of the RTS data segments is therefore limited to a defined reserve, see above. 
+This is acceptable because the RTS only uses small size for data segments (e.g. 54KB) that is independent of the compiled Motoko program.
+
 ### Null Singleton
 As an optimization, the top-level `null`` singleton is allocated once in the dynamic heap and remembered in the persistent metadata across upgrades. 
 This is necessary to implement null checks by pointer comparison (however, by first resolving pointer forwarding before the comparison).
@@ -120,7 +121,6 @@ The old stable memory remains equally accessible as secondary memory with the ne
 
 ## Possible Extensions
 The following extensions or optimization could be applied in the future:
-* Unlimited data segments: Using passive Wasm data segments and loading them at runtime to dynamically computed addresses in the heap. The IC would however need to be extended to support passive Wasm data segments.
 * 64-bit memory: Extend the main memory to 64-bit by using Wasm64, see https://github.com/dfinity/motoko/pull/4136. The memory layout would need to be extended. Moreover, it would be beneficial to introduce a dynamic partition table for the GC. Ideally, stable heap support is directly rolled out for 64-bit to avoid complicated memory layout upgrades from 32-bit to 64-bit.
 * Object pooling: Compile-time-known objects can be shared in the dynamic heap by remembering them in an additional pool table. The pool table needs to be registered as a transient GC root and is recreated on canister upgrades.
 
diff --git a/nix/sources.json b/nix/sources.json
index 5f538e8286b..8451274cee7 100644
--- a/nix/sources.json
+++ b/nix/sources.json
@@ -21,15 +21,15 @@
         "version": "3.2.25"
     },
     "ic": {
-        "branch": "pull/143/head",
+        "branch": "luc/passive-data-segment",
         "description": "Internet Computer blockchain source: the client/replica software run by nodes",
         "homepage": "",
-        "owner": "dfinity",
+        "owner": "luc-blaeser",
         "repo": "ic",
-        "rev": "7e5d8c4d5c50bdef548bb963d39598ea99cacc6e",
-        "sha256": "11ddqq2ca9igshvvnzlx9x6g0mm2n69fzagd0zcdipiwmfzb0mpl",
+        "rev": "411f0cf022140e048d7a46cbfea69a4a358f2d54",
+        "sha256": "0i27f2lvmlgxmwzr1s4ig2cdivd74am93bwybdlgr2gs7pvf7ydm",
         "type": "tarball",
-        "url": "https://github.com/dfinity/ic/archive/7e5d8c4d5c50bdef548bb963d39598ea99cacc6e.tar.gz",
+        "url": "https://github.com/luc-blaeser/ic/archive/411f0cf022140e048d7a46cbfea69a4a358f2d54.tar.gz",
         "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
     },
     "ic-hs": {
diff --git a/rts/motoko-rts/src/idl.rs b/rts/motoko-rts/src/idl.rs
index b2936d7e470..18ddce2db40 100644
--- a/rts/motoko-rts/src/idl.rs
+++ b/rts/motoko-rts/src/idl.rs
@@ -4,7 +4,8 @@ use crate::buf::{read_byte, read_word, skip_leb128, Buf};
 use crate::idl_trap_with;
 use crate::leb128::{leb128_decode, sleb128_decode};
 use crate::memory::{alloc_blob, Memory};
-use crate::types::Words;
+use crate::persistence::compatibility::TypeDescriptor;
+use crate::types::{Value, Words};
 use crate::utf8::utf8_validate;
 
 use core::cmp::min;
@@ -1180,20 +1181,25 @@ unsafe extern "C" fn idl_sub_buf_init(rel_buf: *mut u32, typtbl_size1: u32, typt
     rel.init();
 }
 
-#[no_mangle]
-unsafe extern "C" fn idl_sub(
+#[ic_mem_fn]
+unsafe fn idl_sub<M: Memory>(
+    mem: &mut M,
     rel_buf: *mut u32, // a buffer with at least 2 * typtbl_size1 * typtbl_size2 bits
     typtbl1: *mut *mut u8,
-    typtbl2: *mut *mut u8,
     typtbl_end1: *mut u8,
-    typtbl_end2: *mut u8,
     typtbl_size1: u32,
-    typtbl_size2: u32,
+    candid_data2: Value,
+    type_offsets2: Value,
     t1: i32,
     t2: i32,
 ) -> bool {
     debug_assert!(rel_buf != (0 as *mut u32));
 
+    let mut type_descriptor2 = TypeDescriptor::new(candid_data2, type_offsets2);
+    let typtbl2 = type_descriptor2.build_type_table(mem);
+    let typtbl_end2 = type_descriptor2.type_table_end();
+    let typtbl_size2 = type_descriptor2.type_count() as u32;
+
     let rel = BitRel {
         ptr: rel_buf,
         end: rel_buf.add(idl_sub_buf_words(typtbl_size1, typtbl_size2) as usize),
diff --git a/rts/motoko-rts/src/persistence.rs b/rts/motoko-rts/src/persistence.rs
index 9f740341e03..5de70882c8a 100644
--- a/rts/motoko-rts/src/persistence.rs
+++ b/rts/motoko-rts/src/persistence.rs
@@ -8,6 +8,7 @@ use motoko_rts_macros::ic_mem_fn;
 
 use crate::{
     barriers::{allocation_barrier, write_with_barrier},
+    constants::{KB, MB},
     gc::incremental::State,
     memory::Memory,
     persistence::compatibility::memory_compatible,
@@ -54,9 +55,9 @@ struct PersistentMetadata {
 }
 
 /// Location of the persistent metadata. Prereserved and fixed forever.
-const METADATA_ADDRESS: usize = 6 * 1024 * 1024;
+const METADATA_ADDRESS: usize = 4 * MB + 512 * KB;
 /// The reserved maximum size of the metadata, contains a reserve for future extension of the metadata.
-const METADATA_RESERVE: usize = 128 * 1024;
+const METADATA_RESERVE: usize = 512 * KB;
 
 // TODO: Include partition table in reserved space.
 pub const HEAP_START: usize = METADATA_ADDRESS + METADATA_RESERVE;
@@ -207,10 +208,9 @@ pub unsafe fn register_stable_type<M: Memory>(
     mem: &mut M,
     new_candid_data: Value,
     new_type_offsets: Value,
-    new_actor_index: i32,
 ) {
     assert_eq!(new_candid_data.tag(), TAG_BLOB);
-    let mut new_type = TypeDescriptor::new(new_candid_data, new_type_offsets, new_actor_index);
+    let mut new_type = TypeDescriptor::new(new_candid_data, new_type_offsets);
     let metadata = PersistentMetadata::get();
     let old_type = &mut (*metadata).stable_type;
     if !old_type.is_default() && !memory_compatible(mem, old_type, &mut new_type) {
diff --git a/rts/motoko-rts/src/persistence/compatibility.rs b/rts/motoko-rts/src/persistence/compatibility.rs
index 67ba50688df..028933c68ee 100644
--- a/rts/motoko-rts/src/persistence/compatibility.rs
+++ b/rts/motoko-rts/src/persistence/compatibility.rs
@@ -13,13 +13,21 @@ use crate::{
 
 const DEFAULT_VALUE: Value = Value::from_scalar(0);
 
+/// Relocatable static type descriptor used for Candid subtypes and program upgrade compatibility checks.
+/// The descriptor consists of two blobs, one for the Candid type data and one denoting a vector of types.
+/// The vector only stores relative offsets in the Candid data and does not hold any absolute addresses.
+/// A type descriptor is used for two cases:
+/// * To store the types of the previous program version in the persistent dynamic heap, with the GC
+///   potentially moving the blobs.
+/// * To load the types of the current program version from passive data segments, without that absolute
+///   addresses are known at compile-time.
+/// The static type table is only created when calling the Candid subtype or memory compatibility check.
+/// As the static table contains absolute addresses, it can only temporarily used until the next GC increment.
 pub struct TypeDescriptor {
     // Blob with candid-encoded type definitions.
     candid_data: Value,
     // Blob with a list of `u32` offsets referring to the `candid_data`.
     type_offsets: Value,
-    // Type index of the main actor to the compared for memory compatibility.
-    main_actor_index: i32,
 }
 
 impl TypeDescriptor {
@@ -27,22 +35,24 @@ impl TypeDescriptor {
         Self {
             candid_data: DEFAULT_VALUE,
             type_offsets: DEFAULT_VALUE,
-            main_actor_index: 0,
         }
     }
 
-    pub unsafe fn new(
-        candid_data: Value,
-        type_offsets: Value,
-        main_actor_index: i32,
-    ) -> TypeDescriptor {
+    pub unsafe fn new(candid_data: Value, type_offsets: Value) -> Self {
         Self {
             candid_data: candid_data.forward_if_possible(),
             type_offsets: type_offsets.forward_if_possible(),
-            main_actor_index,
         }
     }
 
+    pub fn is_default(&self) -> bool {
+        self.candid_data == DEFAULT_VALUE && self.type_offsets == DEFAULT_VALUE
+    }
+
+    pub fn assert_initialized(&self) {
+        assert!(self.candid_data != DEFAULT_VALUE && self.type_offsets != DEFAULT_VALUE);
+    }
+
     // GC root if part of the persistent stable type
     pub fn candid_data_location(&mut self) -> *mut Value {
         &mut self.candid_data as *mut Value
@@ -53,22 +63,11 @@ impl TypeDescriptor {
         &mut self.type_offsets as *mut Value
     }
 
-    pub fn is_default(&self) -> bool {
-        self.candid_data == DEFAULT_VALUE
-            && self.type_offsets == DEFAULT_VALUE
-            && self.main_actor_index == 0
-    }
-
-    pub fn assert_initialized(&self) {
-        assert!(self.candid_data != DEFAULT_VALUE && self.type_offsets != DEFAULT_VALUE);
-    }
-
-    pub unsafe fn assign<M: Memory>(&mut self, mem: &mut M, other: &TypeDescriptor) {
+    pub unsafe fn assign<M: Memory>(&mut self, mem: &mut M, other: &Self) {
         let candid_data_location = &mut self.candid_data as *mut Value;
         write_with_barrier(mem, candid_data_location, other.candid_data);
         let type_offsets_location = &mut self.type_offsets as *mut Value;
         write_with_barrier(mem, type_offsets_location, other.type_offsets);
-        self.main_actor_index = other.main_actor_index;
     }
 
     pub unsafe fn type_count(&self) -> usize {
@@ -131,6 +130,9 @@ unsafe fn create_type_check_cache<M: Memory>(
     cache
 }
 
+// Fix main actor type index, see `compile.ml`.
+const MAIN_ACTOR_TYPE_INDEX: i32 = 0;
+
 /// Test whether the new stable type complies with the existing old stable type.
 /// This uses the existing IDL subtype test.
 pub unsafe fn memory_compatible<M: Memory>(
@@ -153,8 +155,8 @@ pub unsafe fn memory_compatible<M: Memory>(
         new_type_table,
         old_table_end,
         new_table_end,
-        old_type.main_actor_index,
-        new_type.main_actor_index,
+        MAIN_ACTOR_TYPE_INDEX,
+        MAIN_ACTOR_TYPE_INDEX,
         true,
     )
 }
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 566370ffc5b..48affb4f0f4 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -18,6 +18,7 @@ open Mo_config
 open Wasm_exts.Ast
 open Wasm.Types
 open Source
+
 (* Re-shadow Source.(@@), to get Stdlib.(@@) *)
 let (@@) = Stdlib.(@@)
 
@@ -257,6 +258,11 @@ module E = struct
   type local_names = (int32 * string) list (* For the debug section: Names of locals *)
   type func_with_names = func * local_names
   type lazy_function = (int32, func_with_names) Lib.AllocOnUse.t
+  type type_descriptor = {
+    candid_data_segment : int32;
+    type_offsets_segment : int32;
+    idl_types_segment : int32;
+  }
   type t = {
     (* Global fields *)
     (* Static *)
@@ -281,10 +287,7 @@ module E = struct
     named_imports : int32 NameEnv.t ref;
     built_in_funcs : lazy_function NameEnv.t ref;
     static_strings : int32 StringEnv.t ref;
-    end_of_static_memory : int32 ref; (* End of statically allocated memory *)
-    static_memory : (int32 * string) list ref; (* Content of static memory *)
-    static_memory_frozen : bool ref;
-      (* Sanity check: Nothing should bump end_of_static_memory once it has been read *)
+    data_segments : string list ref; (* Passive data segments *)
     static_variables : int32 ref;
       (* Number of static variables (MutBox), accessed by index via the runtime system,
          and belonging to the GC root set. *)
@@ -314,11 +317,14 @@ module E = struct
 
     (* requires stable memory (and emulation on wasm targets) *)
     requires_stable_memory : bool ref;
+
+    (* Type descriptor of current program version, created on `conclude_module`. *)
+    global_type_descriptor : type_descriptor option ref;
   }
 
 
   (* The initial global environment *)
-  let mk_global mode rts trap_with dyn_mem : t = {
+  let mk_global mode rts trap_with : t = {
     mode;
     rts;
     trap_with;
@@ -334,9 +340,7 @@ module E = struct
     named_imports = ref NameEnv.empty;
     built_in_funcs = ref NameEnv.empty;
     static_strings = ref StringEnv.empty;
-    end_of_static_memory = ref dyn_mem;
-    static_memory = ref [];
-    static_memory_frozen = ref false;
+    data_segments = ref [];
     static_variables = ref 0l;
     typtbl_typs = ref [];
     (* Metadata *)
@@ -351,6 +355,7 @@ module E = struct
     local_names = ref [];
     features = ref FeatureSet.empty;
     requires_stable_memory = ref false;
+    global_type_descriptor = ref None;
   }
 
   (* This wraps Mo_types.Hash.hash to also record which labels we have seen,
@@ -538,17 +543,10 @@ module E = struct
   let then_trap_with env msg = G.if0 (trap_with env msg) G.nop
   let else_trap_with env msg = G.if0 G.nop (trap_with env msg)
 
-  let reserve_static_memory (env : t) size : int32 =
-    if !(env.static_memory_frozen) then raise (Invalid_argument "Static memory frozen");
-    let ptr = !(env.end_of_static_memory) in
-    let aligned = Int32.logand (Int32.add size 3l) (Int32.lognot 3l) in
-    env.end_of_static_memory := Int32.add ptr aligned;
-    ptr
-
-  let add_mutable_static_bytes (env : t) data : int32 =
-    let ptr = reserve_static_memory env (Int32.of_int (String.length data)) in
-    env.static_memory := !(env.static_memory) @ [ (ptr, data) ];
-    Int32.(add ptr ptr_skew) (* Return a skewed pointer *)
+  let add_data_segment (env : t) data : int32 =
+    let index = List.length !(env.data_segments) in
+    env.data_segments := !(env.data_segments) @ [ data ];
+    Int32.of_int index
 
   let add_fun_ptr (env : t) fi : int32 =
     match FunEnv.find_opt fi !(env.func_ptrs) with
@@ -568,33 +566,36 @@ module E = struct
   let add_static (env : t) (data : StaticBytes.t) : int32 =
     let b = StaticBytes.as_bytes data in
     match StringEnv.find_opt b !(env.static_strings)  with
-    | Some ptr -> ptr
+    | Some segment_index -> segment_index
     | None ->
-      let ptr = add_mutable_static_bytes env b  in
-      env.static_strings := StringEnv.add b ptr !(env.static_strings);
-      ptr
-  
-  let add_static_unskewed (env : t) (data : StaticBytes.t) : int32 =
-    Int32.add (add_static env data) ptr_unskew
-
-  let get_end_of_static_memory env : int32 =
-    env.static_memory_frozen := true;
-    !(env.end_of_static_memory)
+      let segment_index = add_data_segment env b  in
+      env.static_strings := StringEnv.add b segment_index !(env.static_strings);
+      segment_index
+
+  let replace_data_segment (env : t) (segment_index : int32) (data : StaticBytes.t) : int32 =
+    let new_value = StaticBytes.as_bytes data in
+    let segment_index = Int32.to_int segment_index in
+    assert (segment_index < List.length !(env.data_segments));
+    env.data_segments := List.mapi (fun index old_value -> 
+      if index = segment_index then
+        (assert (old_value = "");
+        new_value)
+      else 
+        old_value
+      ) !(env.data_segments);
+    Int32.of_int (String.length new_value)
+
+  let get_data_segments (env : t) =
+    !(env.data_segments)
 
   let add_static_variable (env : t) : int32 =
-    let index = !(env.static_variables) in
-    env.static_variables := Int32.add index 1l;
-    index
+    let variable_index = !(env.static_variables) in
+    env.static_variables := Int32.add variable_index 1l;
+    variable_index
 
   let count_static_variables (env : t) =
     !(env.static_variables)
 
-  let get_static_memory env =
-    !(env.static_memory)
-
-  let mem_size env =
-    Int32.(add (div (get_end_of_static_memory env) page_size) 1l)
-
   let collect_garbage env force =
     let name = "incremental_gc" in
     let gc_fn = if force || !Flags.force_gc then name else "schedule_" ^ name in
@@ -628,8 +629,8 @@ module E = struct
   let requires_stable_memory (env : t) =
     !(env.requires_stable_memory)
 
-  let get_memories (env : t) =
-    nr {mtype = MemoryType {min = mem_size env; max = None}}
+  let get_memories (env : t) initial_memory_pages =
+    nr {mtype = MemoryType {min = initial_memory_pages; max = None}}
     ::
     match mode env with
     | Flags.WASIMode | Flags.WasmMode when !(env.requires_stable_memory) ->
@@ -942,7 +943,7 @@ module RTS = struct
     E.add_func_import env "rts" "write_with_barrier" [I32Type; I32Type] [];
     E.add_func_import env "rts" "allocation_barrier" [I32Type] [I32Type];
     E.add_func_import env "rts" "running_gc" [] [I32Type];
-    E.add_func_import env "rts" "register_stable_type" [I32Type; I32Type; I32Type] [];
+    E.add_func_import env "rts" "register_stable_type" [I32Type; I32Type] [];
     E.add_func_import env "rts" "load_stable_actor" [] [I32Type];
     E.add_func_import env "rts" "save_stable_actor" [I32Type] [];
     E.add_func_import env "rts" "free_stable_actor" [] [];
@@ -959,7 +960,7 @@ module RTS = struct
     E.add_func_import env "rts" "idl_sub_buf_words" [I32Type; I32Type] [I32Type];
     E.add_func_import env "rts" "idl_sub_buf_init" [I32Type; I32Type; I32Type] [];
     E.add_func_import env "rts" "idl_sub"
-      [I32Type; I32Type; I32Type; I32Type; I32Type; I32Type; I32Type; I32Type; I32Type] [I32Type];
+      [I32Type; I32Type; I32Type; I32Type; I32Type; I32Type; I32Type; I32Type] [I32Type];
     E.add_func_import env "rts" "leb128_decode" [I32Type] [I32Type];
     E.add_func_import env "rts" "sleb128_decode" [I32Type] [I32Type];
     E.add_func_import env "rts" "bigint_of_word32" [I32Type] [I32Type];
@@ -1226,8 +1227,8 @@ module Stack = struct
      grows downwards.)
   *)
 
-  (* Predefined constant stack size of 2MB, according to the persistent memory layout. *)
-  let stack_size = 2 * 1024 * 1024
+  (* Predefined constant stack size of 4MB, according to the persistent memory layout. *)
+  let stack_size = 4 * 1024 * 1024
 
   let end_ () = Int32.of_int stack_size 
 
@@ -3338,12 +3339,10 @@ module Blob = struct
       BigNum.from_word32 env
     )
 
-  let static_data env s =
-    compile_unboxed_const (Int32.add ptr_unskew (E.add_static env StaticBytes.[Bytes s]))
-
-  let lit_ptr_len env s =
-    static_data env s ^^
-    compile_unboxed_const (Int32.of_int (String.length s))
+  (* unskewed target address, data offset, and length on stack *)
+  let load_static_data env s =
+    let segment_index = E.add_static env StaticBytes.[Bytes s] in
+    G.i (MemoryInit (nr segment_index))
 
   let alloc env =
     E.call_import env "rts" "alloc_blob" ^^
@@ -3361,9 +3360,9 @@ module Blob = struct
     let (set_new_blob, get_new_blob) = new_local env "new_blob" in
     compile_unboxed_const blob_length ^^ alloc env ^^ set_new_blob ^^
     get_new_blob ^^ payload_ptr_unskewed env ^^ (* target address *)
-    static_data env s ^^ (* source address *)
-    compile_unboxed_const blob_length ^^ (* copy length *)
-    Heap.memcpy env ^^
+    compile_unboxed_const 0l ^^ (* data offset *)
+    compile_unboxed_const blob_length ^^ (* data length *)
+    load_static_data env s ^^
     get_new_blob
 
   let as_ptr_len env = Func.share_code1 Func.Never env "as_ptr_size" ("x", I32Type) [I32Type; I32Type] (
@@ -3372,6 +3371,20 @@ module Blob = struct
       get_x ^^ len env
     )
 
+  let lit_ptr_len env s =
+    lit env s ^^
+    as_ptr_len env
+
+  let load_data_segment env segment_index data_length =
+    let (set_blob, get_blob) = new_local env "data_segment_blob" in
+    data_length ^^
+    alloc env ^^ set_blob ^^
+    get_blob ^^ payload_ptr_unskewed env ^^ (* target address *)
+    compile_unboxed_const 0l ^^ (* data offset *)
+    data_length ^^
+    G.i (MemoryInit (nr segment_index)) ^^
+    get_blob
+  
   let of_ptr_size env = Func.share_code2 Func.Always env "blob_of_ptr_size" (("ptr", I32Type), ("size" , I32Type)) [I32Type] (
     fun env get_ptr get_size ->
       let (set_x, get_x) = new_local env "x" in
@@ -5715,26 +5728,44 @@ module MakeSerialization (Strm : Stream) = struct
   *)
 
   module Strm = Strm
-
-  (* Globals recording known Candid types
-     See Note [Candid subtype checks]
-   *)
-
-  let register_delayed_globals env =
-    (E.add_global32_delayed env "__typtbl" Immutable,
-     E.add_global32_delayed env "__typtbl_end" Immutable,
-     E.add_global32_delayed env "__typtbl_size" Immutable,
-     E.add_global32_delayed env "__typtbl_idltyps" Immutable)
-
-  let get_typtbl env =
-    G.i (GlobalGet (nr (E.get_global env "__typtbl")))
-  let get_typtbl_size env =
-    G.i (GlobalGet (nr (E.get_global env "__typtbl_size")))
-  let get_typtbl_end env =
-    G.i (GlobalGet (nr (E.get_global env "__typtbl_end")))
-  let get_typtbl_idltyps env =
-    G.i (GlobalGet (nr (E.get_global env "__typtbl_idltyps")))
-
+    (* Globals recording known Candid types
+      See Note [Candid subtype checks]
+    *)
+    let register_delayed_globals env =
+      (E.add_global32_delayed env "__candid_data_length" Immutable,
+      E.add_global32_delayed env "__type_offsets_length" Immutable,
+      E.add_global32_delayed env "__idl_types_length" Immutable)
+
+    let get_candid_data_length env =
+      G.i (GlobalGet (nr (E.get_global env "__candid_data_length")))
+    let get_type_offsets_length env =
+      G.i (GlobalGet (nr (E.get_global env "__type_offsets_length")))
+    let get_idl_types_length env =
+      G.i (GlobalGet (nr (E.get_global env "__idl_types_length")))
+
+    let candid_type_offset_size = 4l
+
+    let get_global_type_descriptor env =
+      match !(E.(env.global_type_descriptor)) with
+      | Some descriptor -> descriptor
+      | None -> assert false
+
+    let load_candid_data env =
+      let descriptor = get_global_type_descriptor env in
+      Blob.load_data_segment env E.(descriptor.candid_data_segment) (get_candid_data_length env)
+
+    let load_type_offsets env =
+      let descriptor = get_global_type_descriptor env in
+      Blob.load_data_segment env E.(descriptor.type_offsets_segment) (get_type_offsets_length env)
+
+    let count_type_offsets env =
+      get_type_offsets_length env ^^
+      compile_divU_const candid_type_offset_size
+
+    let load_idl_types env =
+      let descriptor = get_global_type_descriptor env in
+      Blob.load_data_segment env E.(descriptor.idl_types_segment) (get_idl_types_length env)
+      
   module Registers = struct
     let register_globals env =
       E.add_global32 env "@@rel_buf_opt" Mutable 0l;
@@ -5996,22 +6027,29 @@ module MakeSerialization (Strm : Stream) = struct
      List.map idx ts)
 
   (* See Note [Candid subtype checks] *)
-  let set_delayed_globals (env : E.t) (set_typtbl, set_typtbl_end, set_typtbl_size, set_typtbl_idltyps) =
-    let typdesc, offsets, idltyps = type_desc env Candid (E.get_typtbl_typs env) in
-    let static_typedesc = E.add_static_unskewed env [StaticBytes.Bytes typdesc] in
-    let static_typtbl =
-      let bytes = StaticBytes.i32s
-        (List.map (fun offset ->
-          Int32.(add static_typedesc (of_int(offset))))
-        offsets)
-      in
-      E.add_static_unskewed env [bytes]
-    in
-    let static_idltyps = E.add_static_unskewed env [StaticBytes.i32s idltyps] in
-    set_typtbl static_typtbl;
-    set_typtbl_end Int32.(add static_typedesc (of_int (String.length typdesc)));
-    set_typtbl_size (Int32.of_int (List.length offsets));
-    set_typtbl_idltyps static_idltyps
+  let reserve_global_type_descriptor (env : E.t) =
+    let candid_data_segment = E.add_data_segment env "" in
+    let type_offsets_segment = E.add_data_segment env "" in
+    let idl_types_segment = E.add_data_segment env "" in
+    E.(env.global_type_descriptor := Some {
+      candid_data_segment;
+      type_offsets_segment;
+      idl_types_segment;
+    })
+
+  let create_global_type_descriptor (env : E.t) (set_candid_data_length, set_type_offsets_length, set_idl_types_length) =
+    let descriptor = get_global_type_descriptor env in
+    let candid_data, type_offsets, idl_types = type_desc env Candid (E.get_typtbl_typs env) in
+    let candid_data_binary = [StaticBytes.Bytes candid_data] in
+    let candid_data_length = E.replace_data_segment env E.(descriptor.candid_data_segment) candid_data_binary in
+    set_candid_data_length candid_data_length;
+    let type_offsets_binary = [StaticBytes.i32s (List.map Int32.of_int type_offsets)] in
+    let type_offsets_length = E.replace_data_segment env E.(descriptor.type_offsets_segment) type_offsets_binary in
+    set_type_offsets_length type_offsets_length;
+    let idl_types_binary = [StaticBytes.i32s idl_types] in
+    let idl_types_length = E.replace_data_segment env E.(descriptor.idl_types_segment) idl_types_binary in
+    set_idl_types_length idl_types_length
+
 
   (* Returns data (in bytes) and reference buffer size (in entries) needed *)
   let rec buffer_size env t =
@@ -6360,18 +6398,19 @@ module MakeSerialization (Strm : Stream) = struct
     if extended then
       f (compile_unboxed_const 0l)
     else
-      get_typtbl_size1 ^^ get_typtbl_size env ^^
+      get_typtbl_size1 ^^ count_type_offsets env ^^
       E.call_import env "rts" "idl_sub_buf_words" ^^
       Stack.dynamic_with_words env "rel_buf" (fun get_ptr ->
-        get_ptr ^^ get_typtbl_size1 ^^ get_typtbl_size env ^^
+        get_ptr ^^ get_typtbl_size1 ^^ count_type_offsets env ^^
         E.call_import env "rts" "idl_sub_buf_init" ^^
         f get_ptr)
 
   (* See Note [Candid subtype checks] *)
   let idl_sub env t2 =
     let idx = E.add_typtbl_typ env t2 in
-    get_typtbl_idltyps env ^^
-    G.i (Load {ty = I32Type; align = 0; offset = Int32.mul idx 4l (*!*); sz = None}) ^^
+    load_idl_types env ^^
+    Blob.payload_ptr_unskewed env ^^
+    G.i (Load {ty = I32Type; align = 0; offset = Int32.mul idx candid_type_offset_size (*!*); sz = None}) ^^
     Func.share_code6 Func.Always env ("idl_sub")
       (("rel_buf", I32Type),
        ("typtbl1", I32Type),
@@ -6386,11 +6425,10 @@ module MakeSerialization (Strm : Stream) = struct
         E.else_trap_with env "null rel_buf" ^^
         get_rel_buf ^^
         get_typtbl1 ^^
-        get_typtbl env ^^
         get_typtbl_end1 ^^
-        get_typtbl_end env ^^
         get_typtbl_size1 ^^
-        get_typtbl_size env ^^
+        load_candid_data env ^^
+        load_type_offsets env ^^
         get_idltyp1 ^^
         get_idltyp2 ^^
         E.call_import env "rts" "idl_sub")
@@ -7388,12 +7426,18 @@ encountered during code generation, the other is determined
 dynamically by, e.g. message payload. The latter will vary with
 each payload to decode.
 
+The static type table and a type descriptor are stored in passive 
+data segments. Instead of absolute memory addresses, the static type 
+table in the data segment only contains relative offsets into type 
+descriptor. When loaded, these offsets are patched by static addresses 
+that point into the type descriptor.
+
 The known Motoko types are accumulated in a global list as required
 and then, in a final compilation step, encoded to global type table
-and sequence of type indices. The encoding is stored as static
-data referenced by dedicated wasm globals so that we can generate
-code that references the globals before their final definitions are
-known.
+and the type descriptor (sequence of type indices). The encoding is 
+stored in passive data segments referenced (by way of segment indices) 
+from dedicated wasm globals so that we can generate code that 
+references the globals before their final definitions are known.
 
 Deserializing a proper (not extended) Candid value stack allocates a
 mutable word buffer, of size determined by `idl_sub_buf_words`.
@@ -7757,10 +7801,9 @@ module Persistence = struct
   let register_stable_type env actor_type =
     let (candid_type_desc, type_offsets, type_indices) = Serialization.(type_desc env Persistence [actor_type]) in
     let serialized_offsets = StaticBytes.(as_bytes [i32s (List.map Int32.of_int type_offsets)]) in
-    assert ((List.length type_indices) = 1);
+    assert (type_indices = [0l]);
     Blob.lit env candid_type_desc ^^
     Blob.lit env serialized_offsets ^^
-    compile_unboxed_const (List.nth type_indices 0) ^^
     E.call_import env "rts" "register_stable_type"
 
   let create_actor env actor_type get_field_value =
@@ -11705,7 +11748,7 @@ and conclude_module env set_serialization_globals start_fi_o =
   FuncDec.export_gc_trigger_method env;
 
   (* See Note [Candid subtype checks] *)
-  Serialization.set_delayed_globals env set_serialization_globals;
+  Serialization.create_global_type_descriptor env set_serialization_globals;
 
   (* declare before building GC *)
 
@@ -11717,7 +11760,8 @@ and conclude_module env set_serialization_globals start_fi_o =
   Heap.register env;
   IC.register env;
 
-  set_heap_base (E.get_end_of_static_memory env);
+  let dynamic_heap_start = Lifecycle.end_ () in
+  set_heap_base dynamic_heap_start;
 
   (* Wrap the start function with the RTS initialization *)
   let rts_start_fi = E.add_fun env "rts_start" (Func.of_body env [] [] (fun env1 ->
@@ -11738,15 +11782,15 @@ and conclude_module env set_serialization_globals start_fi_o =
 
   let other_imports = E.get_other_imports env in
 
-  let memories = E.get_memories env in
+  let initial_memory_pages = Int32.(add (div dynamic_heap_start page_size) 1l) in
+  let memories = E.get_memories env initial_memory_pages in
 
   let funcs = E.get_funcs env in
 
-  let data = List.map (fun (offset, init) -> nr {
-    index = nr 0l;
-    offset = nr (G.to_instr_list (compile_unboxed_const offset));
-    init;
-    }) (E.get_static_memory env) in
+  let datas = List.map (fun (dinit) -> nr {
+    dinit;
+    dmode = (nr Wasm_exts.Ast.Passive);
+    }) (E.get_data_segments env) in
 
   let elems = List.map (fun (fi, fp) -> nr {
     index = nr 0l;
@@ -11766,7 +11810,7 @@ and conclude_module env set_serialization_globals start_fi_o =
       memories;
       imports = func_imports @ other_imports;
       exports = E.get_exports env;
-      data
+      datas
     } in
 
   let emodule =
@@ -11780,8 +11824,9 @@ and conclude_module env set_serialization_globals start_fi_o =
       motoko = {
         labels = E.get_labs env;
         stable_types = !(env.E.stable_types);
-        compiler = metadata "motoko:compiler" (Lib.Option.get Source_id.release Source_id.id)
+        compiler = metadata "motoko:compiler" (Lib.Option.get Source_id.release Source_id.id);
       };
+      enhanced_orthogonal_persistence = Some (false, "32-bit, layout version 1");
       candid = {
         args = !(env.E.args);
         service = !(env.E.service);
@@ -11795,7 +11840,7 @@ and conclude_module env set_serialization_globals start_fi_o =
   | Some rts -> Linking.LinkModule.link emodule "rts" rts
 
 let compile mode rts (prog : Ir.prog) : Wasm_exts.CustomModule.extended_module =
-  let env = E.mk_global mode rts IC.trap_with (Lifecycle.end_ ()) in
+  let env = E.mk_global mode rts IC.trap_with in
 
   IC.register_globals env;
   Stack.register_globals env;
@@ -11805,7 +11850,8 @@ let compile mode rts (prog : Ir.prog) : Wasm_exts.CustomModule.extended_module =
 
   (* See Note [Candid subtype checks] *)
   let set_serialization_globals = Serialization.register_delayed_globals env in
-
+  Serialization.reserve_global_type_descriptor env;
+  
   IC.system_imports env;
   RTS.system_imports env;
 
diff --git a/src/linking/linkModule.ml b/src/linking/linkModule.ml
index 7092c9382d7..403e9aa14a3 100644
--- a/src/linking/linkModule.ml
+++ b/src/linking/linkModule.ml
@@ -382,16 +382,23 @@ let rename_globals rn : module_' -> module_' = fun m ->
   let table_segment = phrase (table_segment') in
   let table_segments = List.map table_segment in
 
-  let memory_segment' (s : string segment') = { s with offset = const s.offset; } in
-  let memory_segment = phrase (memory_segment') in
-  let memory_segments = List.map memory_segment in
+  let segment_mode' (dmode : segment_mode') = 
+    match dmode with 
+      | Passive -> Passive
+      | Active { index; offset } -> Active { index; offset = const offset }
+      | Declarative -> Declarative
+    in
+  let segment_mode = phrase (segment_mode') in
+  let data_segment' (s : data_segment') = { s with dmode = segment_mode s.dmode; } in
+  let data_segment = phrase (data_segment') in
+  let data_segments = List.map data_segment in
 
 
   { m with
     funcs = funcs m.funcs;
     globals = globals m.globals;
     elems = table_segments m.elems;
-    data = memory_segments m.data;
+    datas = data_segments m.datas;
   }
 
 let set_global global value = fun m ->
@@ -433,16 +440,23 @@ let fill_global (global : int32) (value : int32) : module_' -> module_' = fun m
   let table_segment = phrase (table_segment') in
   let table_segments = List.map table_segment in
 
-  let memory_segment' (s : string segment') = { s with offset = const s.offset; } in
-  let memory_segment = phrase (memory_segment') in
-  let memory_segments = List.map memory_segment in
+  let segment_mode' (dmode : segment_mode') = 
+    match dmode with 
+      | Passive -> Passive
+      | Active { index; offset } -> Active { index; offset = const offset }
+      | Declarative -> Declarative
+    in
+  let segment_mode = phrase (segment_mode') in
+  let data_segment' (s : data_segment') = { s with dmode = segment_mode s.dmode; } in
+  let data_segment = phrase (data_segment') in
+  let data_segments = List.map data_segment in
 
 
   { m with
     funcs = funcs m.funcs;
     globals = globals m.globals;
     elems = table_segments m.elems;
-    data = memory_segments m.data;
+    datas = data_segments m.datas;
   }
 
 let rename_funcs_name_section rn (ns : name_section) =
@@ -599,7 +613,7 @@ let join_modules
         funcs = m1.funcs @ m2.funcs;
         start = m1.start;
         elems = m1.elems @ m2.elems;
-        data = m1.data @ m2.data;
+        datas = m1.datas @ m2.datas;
         imports = m1.imports @ m2.imports;
         exports = m1.exports @ m2.exports;
       };
@@ -773,10 +787,12 @@ let link (em1 : extended_module) libname (em2 : extended_module) =
   let lib_heap_start = align dylink.memory_alignment old_heap_start in
   let new_heap_start = align 4l (Int32.add lib_heap_start dylink.memory_size) in
 
-  (* Data segments must fit below 6MB according to the persistent heap layout. 
-     The first 2MB are reserved for the Rust call stacks such that data segments are limited to 4MB. *)
-  (if (Int32.to_int new_heap_start) > 6 * 1024 * 1024 then
-    (raise (TooLargeDataSegments "The Wasm data segment size exceeds the supported maxmimum of 4MB."))
+  (* The RTs data segments must fit below 4.5MB according to the persistent heap layout. 
+     The first 4MB are reserved for the Rust call stack such that RTS data segments are limited to 512KB. *)
+  let max_rts_stack_size = 4 * 1024 * 1024 in
+  let max_rts_data_segment_size = 512 * 1024 in
+  (if (Int32.to_int new_heap_start) > max_rts_stack_size + max_rts_data_segment_size then
+    (raise (TooLargeDataSegments (Printf.sprintf "The Wasm data segment size exceeds the supported maxmimum of %nMB." max_rts_data_segment_size)))
   else
     ()
   );
@@ -852,6 +868,22 @@ let link (em1 : extended_module) libname (em2 : extended_module) =
     add_or_get_ty fun_ty.it
   in
 
+  (* Check that the first module generated by the compiler backend does not use 
+     active data segments. *)
+  let is_active data_segment = match data_segment.it.dmode.it with
+  | Active _ -> true
+  | _ -> false
+  in
+  let em1_active_data_segments = List.filter is_active em1.module_.datas in
+  assert ((List.length em1_active_data_segments) = 0);
+  
+  let is_passive data_segment = match data_segment.it.dmode.it with 
+  | Passive -> true
+  | _ -> false
+  in
+  let em1_passive_data_segments = List.filter is_passive em1.module_.datas in
+  let dm2_data_segment_offset = List.length em1_passive_data_segments in
+
   (* Rename types in first module *)
   let em1_tys =
     map_module (fun m -> { (rename_types (ty_renamer m.types) m) with types = [] }) em1
@@ -881,6 +913,63 @@ let link (em1 : extended_module) libname (em2 : extended_module) =
     Int32.add (Int32.add lib_table_start dylink.table_size) (Int32.of_int (List.length got_func_imports))
   in
 
+  (* Rust generates active data segments for the runtime system code that are not supported with orthogonal persistence.
+     Therefore, make the data segments passive and load them on initialization to their reserved static space. 
+     Note: If Rust would also use passive data segments in future, the segment load indices need to be renumbered. *)
+  let make_rts_data_segments_passive : module_' -> module_' = fun m ->
+    let segment_mode' (dmode : segment_mode') = 
+      match dmode with 
+        | Active _ -> Passive
+        | _ -> raise (LinkError "Passive data segments are not yet supported in the RTS module")
+    in
+    let segment_mode = phrase (segment_mode') in
+    let data_segment' (s : data_segment') = { s with dmode = segment_mode s.dmode; } in
+    let data_segment = phrase (data_segment') in
+    let data_segments = List.map data_segment in
+    { m with datas = data_segments m.datas; }
+  in
+
+  let load_rts_data_segments numbering_offset data_segments : module_' -> module_' = fun m ->
+      let imported_functions = Int32.to_int (count_imports is_fun_import m) in
+      let start_index = Int32.to_int (match m.start with
+      | Some index -> index.it
+      | None -> raise (LinkError "The module has no start function to inject"))
+      in
+      let local_start_function = Int.sub start_index imported_functions in
+      if local_start_function < 0 then
+        raise (LinkError "The module start refers to an imported function that cannot be injected");
+      assert (local_start_function < (List.length m.funcs));
+  
+      let load_passive_segment index data_segment =
+        let segment_index = Int32.of_int (Int.add index numbering_offset) in
+        let compile_const_i32 value = Const (Wasm.Values.I32 value @@ no_region) @@ no_region in
+        let data_target = match data_segment.it.dmode.it with
+          | Active { offset; _ } -> offset.it
+          | _ -> raise (LinkError "Passive data segments are not yet supported in the RTS module")
+        in
+        let data_length = Int32.of_int (String.length data_segment.it.dinit) in
+        let memory_init = MemoryInit (segment_index @@ no_region) @@ no_region in
+        data_target @
+        [ 
+          compile_const_i32 0l; (* data offset *)
+          compile_const_i32 data_length; 
+          memory_init 
+        ]
+      in
+      let load_passive_segments = List.concat (List.mapi load_passive_segment data_segments) in
+  
+      let inject_in_func' code f = { f with body = code @ f.body } in
+      let inject_in_func code = phrase (inject_in_func' code) in
+      let patch_functions functions = 
+        List.mapi (fun index func -> 
+          if index = local_start_function then 
+            inject_in_func load_passive_segments func
+          else func
+        ) functions
+      in
+      { m with funcs = patch_functions m.funcs; }
+    in
+
   let merged = join_modules
     ( em1_tys
     |> map_module (fun m -> { m with types = type_indices_sorted })
@@ -894,6 +983,7 @@ let link (em1 : extended_module) libname (em2 : extended_module) =
     |> map_module (set_table_size new_table_size)
     )
     ( dm2
+    |> make_rts_data_segments_passive
     |> remove_imports is_fun_import fun_resolved21
     |> remove_imports is_global_import global_resolved21
     |> remove_imports is_memory_import [0l, 0l]
@@ -909,6 +999,7 @@ let link (em1 : extended_module) libname (em2 : extended_module) =
     type_indices
   |> add_call_ctors
   |> remove_non_ic_exports (* only sane if no additional files get linked in *)
+  |> map_module (load_rts_data_segments dm2_data_segment_offset dm2.datas)
   in
 
   (* Rename global and function indices in GOT.func stuff *)
diff --git a/src/wasm-exts/ast.ml b/src/wasm-exts/ast.ml
index d13c26f7a27..60b4d161d3f 100644
--- a/src/wasm-exts/ast.ml
+++ b/src/wasm-exts/ast.ml
@@ -7,6 +7,7 @@ Base revision: WebAssembly/spec@a7a1856.
 The changes are:
  * Pseudo-instruction Meta for debug information
  * StableMemory, StableGrow, StableRead, StableWrite instructions.
+ * Support for passive data segments (incl. `MemoryInit`).
 
 The code is otherwise as untouched as possible, so that we can relatively
 easily apply diffs from the original code (possibly manually).
@@ -111,6 +112,7 @@ and instr' =
   | Store of storeop                  (* write memory at address *)
   | MemorySize                        (* size of linear memory *)
   | MemoryGrow                        (* grow linear memory *)
+  | MemoryInit of var                 (* initialize memory range from segment *)
   | Const of literal                  (* constant *)
   | Test of testop                    (* numeric test *)
   | Compare of relop                  (* numeric comparison *)
@@ -173,8 +175,21 @@ and 'data segment' =
 }
 
 type table_segment = var list segment
-type memory_segment = string segment
 
+(* Manual extension to support passive data segements *)
+type segment_mode = segment_mode' phrase
+and segment_mode' =
+  | Passive
+  | Active of {index : var; offset : const}
+  | Declarative
+
+type data_segment = data_segment' phrase
+and data_segment' =
+{
+  dinit : string;
+  dmode : segment_mode;
+}
+(* End of manual extension *)
 
 (* Modules *)
 
@@ -219,7 +234,9 @@ and module_' =
   funcs : func list;
   start : var option;
   elems : var list segment list;
-  data : string segment list;
+  (* Manual adjustment for passive data segment support *)
+  datas : data_segment list;
+  (* End of manual adjustment *)
   imports : import list;
   exports : export list;
 }
@@ -236,7 +253,7 @@ let empty_module =
   funcs = [];
   start = None;
   elems  = [];
-  data = [];
+  datas = [];
   imports = [];
   exports = [];
 }
diff --git a/src/wasm-exts/customModule.ml b/src/wasm-exts/customModule.ml
index f92e04566ac..484ccdbd74f 100644
--- a/src/wasm-exts/customModule.ml
+++ b/src/wasm-exts/customModule.ml
@@ -60,6 +60,8 @@ let empty_candid_sections = {
   service = None;
 }
 
+type persistence_section = (bool * string) option
+
 type extended_module = {
   (* The non-custom sections *)
   module_ : module_';
@@ -71,6 +73,8 @@ type extended_module = {
   candid : candid_sections;
   (* motoko sections *)
   motoko : motoko_sections;
+  (* enhanced orthogonal persistence section *)
+  enhanced_orthogonal_persistence : persistence_section;
   (* source map section *)
   source_mapping_url : string option;
   wasm_features : string list;
diff --git a/src/wasm-exts/customModuleDecode.ml b/src/wasm-exts/customModuleDecode.ml
index 5993362c757..39db6267709 100644
--- a/src/wasm-exts/customModuleDecode.ml
+++ b/src/wasm-exts/customModuleDecode.ml
@@ -4,6 +4,7 @@ reference implementation.
 
 The changes are:
  * Support for additional custom sections
+ * Support for passive data segments (incl. `MemoryInit`).
 
 The code is otherwise as untouched as possible, so that we can relatively
 easily apply diffs from the original code (possibly manually).
@@ -220,6 +221,7 @@ let var s = vu32 s
 
 let op s = u8 s
 let end_ s = expect 0x0b s "END opcode expected"
+let zero s = expect 0x00 s "zero byte expected"
 
 let memop s =
   let align = vu32 s in
@@ -244,6 +246,11 @@ let math_prefix s =
   | 0x05 -> i64_trunc_sat_f32_u
   | 0x06 -> i64_trunc_sat_f64_s
   | 0x07 -> i64_trunc_sat_f64_u
+  (* Manual extension for passive data segments *)
+  | 0x08 ->
+    let x = at var s in
+    zero s; memory_init x
+  (* End of manual extension *)
   | b -> illegal s pos b
 
 let rec instr s =
@@ -521,6 +528,7 @@ let id s =
     | 9 -> `ElemSection
     | 10 -> `CodeSection
     | 11 -> `DataSection
+    | 12 -> `DataCountSection
     | _ -> error s (pos s) "malformed section id"
     ) bo
 
@@ -647,6 +655,21 @@ let code_section s =
 
 (* Element section *)
 
+(* Manual extension for passive data segments *)
+let passive s =
+  Passive
+
+let active s =
+  let index = at var s in
+  let offset = const s in
+  Active {index; offset}
+
+let active_zero s =
+  let index = Source.(0l @@ no_region) in
+  let offset = const s in
+  Active {index; offset}
+(* End of manual extension *)
+
 let segment dat s =
   let index = at var s in
   let offset = const s in
@@ -660,15 +683,38 @@ let elem_section s =
   section `ElemSection (vec (at table_segment)) [] s
 
 
+(* Manual extension for passive data segments *)
 (* Data section *)
 
-let memory_segment s =
-  segment string s
+let data s =
+  match vu32 s with
+  | 0x00l ->
+    let dmode = at active_zero s in
+    let dinit = string s in
+    {dinit; dmode}
+  | 0x01l ->
+    let dmode = at passive s in
+    let dinit = string s in
+    {dinit; dmode}
+  | 0x02l ->
+    let dmode = at active s in
+    let dinit = string s in
+    {dinit; dmode}
+  | _ -> error s (pos s - 1) "malformed data segment kind"
 
 let data_section s =
-  section `DataSection (vec (at memory_segment)) [] s
+  section `DataSection (vec (at data)) [] s
 
 
+(* DataCount section *)
+
+let data_count s =
+  Some (vu32 s)
+
+let data_count_section s =
+  section `DataCountSection data_count None s
+(* End of manual extension *)
+
 (* Custom sections *)
 
 let custom_section (name_pred : int list -> bool) (f : int -> stream -> 'a) (default : 'a) (s : stream) =
@@ -829,7 +875,11 @@ let utf8 sec_end s =
 let motoko_sections s =
   let stable_types = icp_custom_section "motoko:stable-types" utf8 None s in
   let compiler = icp_custom_section "motoko:compiler" utf8 None s in
-  custom_section is_motoko motoko_section_content { empty_motoko_sections with stable_types; compiler} s
+  custom_section is_motoko motoko_section_content { empty_motoko_sections with stable_types; compiler; } s
+
+(* Enhanced orthogonal persistence section *)
+let enhanced_orthogonal_persistence_section s =
+  icp_custom_section "enhanced-orthogonal-persistence" utf8 None s
 
 (* Candid sections *)
 
@@ -896,9 +946,11 @@ let module_ s =
   iterate skip_custom_section s;
   let elems = elem_section s in
   iterate skip_custom_section s;
+  let data_count = data_count_section s in
+  iterate skip_custom_section s;
   let func_bodies = code_section s in
   iterate skip_custom_section s;
-  let data = data_section s in
+  let datas = data_section s in
   iterate skip_custom_section s;
   let name = name_section s in
   iterate skip_custom_section s;
@@ -907,20 +959,25 @@ let module_ s =
   iterate skip_custom_section s;
   let motoko = motoko_sections s in
   iterate skip_custom_section s;
+  let enhanced_orthogonal_persistence = enhanced_orthogonal_persistence_section s in
+  iterate skip_custom_section s;
   let wasm_features = wasm_features_section s in
   iterate skip_custom_section s;
   require (pos s = len s) s (len s) "junk after last section";
   require (List.length func_types = List.length func_bodies)
     s (len s) "function and code section have inconsistent lengths";
+  require (data_count = None || data_count = Some (Lib.List32.length datas))
+  s (len s) "data count and data section have inconsistent lengths";
   let funcs =
     List.map2 Source.(fun t f -> {f.it with ftype = t} @@ f.at)
       func_types func_bodies
   in
   { module_ =
-     {types; tables; memories; globals; funcs; imports; exports; elems; data; start};
+     {types; tables; memories; globals; funcs; imports; exports; elems; datas; start};
     dylink;
     name;
     motoko;
+    enhanced_orthogonal_persistence;
     candid;
     source_mapping_url = None;
     wasm_features = wasm_features;
diff --git a/src/wasm-exts/customModuleEncode.ml b/src/wasm-exts/customModuleEncode.ml
index 5e2c5feacdd..3bbed7a7c3e 100644
--- a/src/wasm-exts/customModuleEncode.ml
+++ b/src/wasm-exts/customModuleEncode.ml
@@ -5,6 +5,7 @@ reference implementation.
 The changes are:
  * Support for writing out a source map for the Code parts
  * Support for additional custom sections
+ * Support for passive data segments (incl. `MemoryInit`).
 
 The code is otherwise as untouched as possible, so that we can relatively
 easily apply diffs from the original code (possibly manually).
@@ -471,6 +472,10 @@ let encode (em : extended_module) =
       | MemorySize -> op 0x3f; u8 0x00
       | MemoryGrow -> op 0x40; u8 0x00
 
+      (* Manual extension for passive data segments *)
+      | MemoryInit x -> op 0xfc; vu32 0x08l; var x; u8 0x00
+      (* End of manual extension *)
+
       | Const {it = I32 c; _} -> op 0x41; vs32 c
       | Const {it = I64 c; _} -> op 0x42; vs64 c
       | Const {it = F32 c; _} -> op 0x43; f32 c
@@ -804,12 +809,29 @@ let encode (em : extended_module) =
     let elem_section elems =
       section 9 (vec table_segment) elems (elems <> [])
 
+    (* Manual extension for passive data segments *)
     (* Data section *)
-    let memory_segment seg =
-      segment string seg
 
-    let data_section data =
-      section 11 (vec memory_segment) data (data <> [])
+    let data seg =
+      let {dinit; dmode} = seg.it in
+      match dmode.it with
+      | Passive ->
+        vu32 0x01l; string dinit
+      | Active {index; offset} when index.it = 0l ->
+        vu32 0x00l; const offset; string dinit
+      | Active {index; offset} ->
+        vu32 0x02l; var index; const offset; string dinit
+      | Declarative ->
+        failwith "illegal declarative data segment"
+
+    let data_section datas =
+      section 11 (vec data) datas (datas <> [])
+
+    (* Data count section *)
+
+    let data_count_section datas m =
+      section 12 len (List.length datas) (datas <> [])
+    (* End of manual extension *)
 
     (* sourceMappingURL section *)
 
@@ -859,6 +881,9 @@ let encode (em : extended_module) =
       icp_custom_section "motoko:compiler" utf8 motoko.compiler;
       custom_section "motoko" motoko_section_body motoko.labels (motoko.labels <> []) (* TODO: make an icp_section *)
 
+    let enhanced_orthogonal_persistence_section version =
+      icp_custom_section "enhanced-orthogonal-persistence" utf8 version
+
     let candid_sections candid =
       icp_custom_section "candid:service" utf8 candid.service;
       icp_custom_section "candid:args" utf8 candid.args
@@ -1229,12 +1254,14 @@ let encode (em : extended_module) =
       export_section m.exports;
       start_section m.start;
       elem_section m.elems;
+      data_count_section m.datas m;
       code_section m.funcs;
-      data_section m.data;
+      data_section m.datas;
       (* other optional sections *)
       name_section em.name;
       candid_sections em.candid;
       motoko_sections em.motoko;
+      enhanced_orthogonal_persistence_section em.enhanced_orthogonal_persistence;
       wasm_features_section em.wasm_features;
       source_mapping_url_section em.source_mapping_url;
       if !Mo_config.Flags.debug_info then
diff --git a/src/wasm-exts/operators.ml b/src/wasm-exts/operators.ml
index 2c35fe6aa20..7e000e1ae91 100644
--- a/src/wasm-exts/operators.ml
+++ b/src/wasm-exts/operators.ml
@@ -7,7 +7,7 @@ that it got basically replicated into the customModuleDecode.ml file.
 Base revision: WebAssembly/spec@a7a1856.
 
 The changes are:
- * None for now
+  * Support for passive data segments (incl. `MemoryInit`).
 
 The code is otherwise as untouched as possible, so that we can relatively
 easily apply diffs from the original code (possibly manually).
@@ -230,3 +230,6 @@ let f64_reinterpret_i64 = Convert (F64 F64Op.ReinterpretInt)
 let memory_size = MemorySize
 let memory_grow = MemoryGrow
 
+(* Manual extension for passive data segments *)
+let memory_init x = MemoryInit x
+(* End of manual extension *)
diff --git a/test/bench/ok/alloc.drun-run-opt.ok b/test/bench/ok/alloc.drun-run-opt.ok
deleted file mode 100644
index b7e79a12027..00000000000
--- a/test/bench/ok/alloc.drun-run-opt.ok
+++ /dev/null
@@ -1,8 +0,0 @@
-ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
-ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_076_868_902)
-ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_076_865_999)
-ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_076_866_013)
-ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/bignum.drun-run-opt.ok b/test/bench/ok/bignum.drun-run-opt.ok
deleted file mode 100644
index 0878f6d750b..00000000000
--- a/test/bench/ok/bignum.drun-run-opt.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
-ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 2_524_687; size = +60_608}
-ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 107_802_010; size = +1_827_460}
-ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/bignum.drun-run.ok b/test/bench/ok/bignum.drun-run.ok
index a3d53d71247..5ce8915c9a4 100644
--- a/test/bench/ok/bignum.drun-run.ok
+++ b/test/bench/ok/bignum.drun-run.ok
@@ -1,6 +1,6 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 2_631_309; size = +60_608}
+debug.print: {cycles = 2_631_657; size = +60_608}
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 107_962_919; size = +1_827_460}
+debug.print: {cycles = 107_963_330; size = +1_827_460}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/heap-32.drun-run-opt.ok b/test/bench/ok/heap-32.drun-run-opt.ok
deleted file mode 100644
index f3799847935..00000000000
--- a/test/bench/ok/heap-32.drun-run-opt.ok
+++ /dev/null
@@ -1,5 +0,0 @@
-ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
-ingress Completed: Reply: 0x4449444c0000
-debug.print: (50_227, +37_021_304, 766_107_734)
-debug.print: (50_070, +40_056_236, 827_511_356)
-ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/nat16.drun-run-opt.ok b/test/bench/ok/nat16.drun-run-opt.ok
deleted file mode 100644
index d93ecabef72..00000000000
--- a/test/bench/ok/nat16.drun-run-opt.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
-ingress Completed: Reply: 0x4449444c0000
-debug.print: (0, 22_021_129)
-ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/palindrome.drun-run-opt.ok b/test/bench/ok/palindrome.drun-run-opt.ok
deleted file mode 100644
index 683cfb1d396..00000000000
--- a/test/bench/ok/palindrome.drun-run-opt.ok
+++ /dev/null
@@ -1,9 +0,0 @@
-ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
-ingress Completed: Reply: 0x4449444c0000
-debug.print: (true, +1_544, 25_032)
-debug.print: (false, +1_544, 23_318)
-debug.print: (false, +1_544, 24_968)
-debug.print: (true, +1_156, 25_486)
-debug.print: (false, +1_144, 23_109)
-debug.print: (false, +1_144, 25_329)
-ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/palindrome.drun-run.ok b/test/bench/ok/palindrome.drun-run.ok
index b696471867d..4a6505f0c28 100644
--- a/test/bench/ok/palindrome.drun-run.ok
+++ b/test/bench/ok/palindrome.drun-run.ok
@@ -1,9 +1,9 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (true, +1_544, 26_857)
-debug.print: (false, +1_544, 25_081)
-debug.print: (false, +1_544, 26_791)
-debug.print: (true, +1_156, 27_161)
-debug.print: (false, +1_144, 24_624)
-debug.print: (false, +1_144, 26_994)
+debug.print: (true, +1_544, 26_916)
+debug.print: (false, +1_544, 25_140)
+debug.print: (false, +1_544, 26_850)
+debug.print: (true, +1_156, 27_220)
+debug.print: (false, +1_144, 24_683)
+debug.print: (false, +1_144, 27_053)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/region-mem.drun-run-opt.ok b/test/bench/ok/region-mem.drun-run-opt.ok
deleted file mode 100644
index c64e4a821cf..00000000000
--- a/test/bench/ok/region-mem.drun-run-opt.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
-ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 8_657_043_872}
-ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/region0-mem.drun-run-opt.ok b/test/bench/ok/region0-mem.drun-run-opt.ok
deleted file mode 100644
index c9399b5142d..00000000000
--- a/test/bench/ok/region0-mem.drun-run-opt.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
-ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 8_002_732_446}
-ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/stable-mem.drun-run-opt.ok b/test/bench/ok/stable-mem.drun-run-opt.ok
deleted file mode 100644
index 5bd807fdc12..00000000000
--- a/test/bench/ok/stable-mem.drun-run-opt.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
-ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 4_341_105_054}
-ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/max-stack.mo b/test/run-drun/max-stack.mo
index 573e49ed15c..f3375ecce4f 100644
--- a/test/run-drun/max-stack.mo
+++ b/test/run-drun/max-stack.mo
@@ -2,7 +2,7 @@
 import { errorMessage; performanceCounter; rts_heap_size; rts_max_stack_size; debugPrint; } = "mo:⛔";
 
 actor stack {
-    let expectedMinimumSize = 35_000;
+    let expectedMinimumSize = 31_000;
 
     public func ser() : async () { await go(false) };
     public func deser() : async () { await go(true) };
diff --git a/test/run-drun/ok/migrate-stabilization.drun.ok b/test/run-drun/ok/migrate-stabilization.drun.ok
index 16ed9383115..69c77832199 100644
--- a/test/run-drun/ok/migrate-stabilization.drun.ok
+++ b/test/run-drun/ok/migrate-stabilization.drun.ok
@@ -115,4 +115,4 @@ debug.print: 37 37
 debug.print: 38 38
 debug.print: 39 39
 ingress Completed: Reply: 0x4449444c0000
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: higher stable memory version (expected 1)
+ingress Err: IC0504: Missing upgrade option: Enhanced orthogonal persistence requires the `keep_main_memory` upgrade option.
diff --git a/test/run.sh b/test/run.sh
index 825a36e1487..19ac635b72a 100755
--- a/test/run.sh
+++ b/test/run.sh
@@ -185,10 +185,11 @@ then
       HAVE_drun=no
     fi
   fi
-  if ic-wasm --help >& /dev/null
-  then
-    HAVE_ic_wasm=yes
-  fi
+  # ic-wasm does not yet support passive data segments
+  # if ic-wasm --help >& /dev/null
+  # then
+  #   HAVE_ic_wasm=yes
+  # fi
 fi
 
 if [ $DTESTS = yes ]
diff --git a/test/run/refuted-const-float.mo b/test/run/refuted-const-float.mo
index 97cf66b6499..aed68a0adac 100644
--- a/test/run/refuted-const-float.mo
+++ b/test/run/refuted-const-float.mo
@@ -4,7 +4,7 @@ let 0.67 = 3.14;
 // CHECK: (func $init (type
 // CHECK: call $blob_of_principal
 // CHECK: i32.const 14
-// CHECK-NEXT: call $print_ptr
+// CHECK: call $print_ptr
 // CHECK-NEXT: unreachable)
 
 //SKIP run-low
diff --git a/test/run/refuted-const-option-null.mo b/test/run/refuted-const-option-null.mo
index 7bfbf6b8e5e..68f285a6fc8 100644
--- a/test/run/refuted-const-option-null.mo
+++ b/test/run/refuted-const-option-null.mo
@@ -4,7 +4,7 @@ let ?b = null;
 // CHECK: (func $init (type
 // CHECK: call $blob_of_principal
 // CHECK: i32.const 14
-// CHECK-NEXT: call $print_ptr
+// CHECK: call $print_ptr
 // CHECK-NEXT: unreachable)
 
 //SKIP run-low
diff --git a/test/run/refuted-const-option.mo b/test/run/refuted-const-option.mo
index 5adb4ae2be7..e47f347854f 100644
--- a/test/run/refuted-const-option.mo
+++ b/test/run/refuted-const-option.mo
@@ -4,7 +4,7 @@ let null = ?42;
 // CHECK: (func $init (type
 // CHECK: call $blob_of_principal
 // CHECK: i32.const 14
-// CHECK-NEXT: call $print_ptr
+// CHECK: call $print_ptr
 // CHECK-NEXT: unreachable)
 
 //SKIP run-low
diff --git a/test/run/refuted-const-variant.mo b/test/run/refuted-const-variant.mo
index f949c6bab20..90fc698290f 100644
--- a/test/run/refuted-const-variant.mo
+++ b/test/run/refuted-const-variant.mo
@@ -4,7 +4,7 @@ let (#const b) = #bummer;
 // CHECK: (func $init (type
 // CHECK: call $blob_of_principal
 // CHECK: i32.const 14
-// CHECK-NEXT: call $print_ptr
+// CHECK: call $print_ptr
 // CHECK-NEXT: unreachable)
 
 //SKIP run-low

From ef2e8a50fad0b713c103cda604a29d7a1998852c Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 22 Feb 2024 17:35:38 +0100
Subject: [PATCH 164/260] Update IC dependency

---
 nix/sources.json | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/nix/sources.json b/nix/sources.json
index 8451274cee7..e5aeacbc7d1 100644
--- a/nix/sources.json
+++ b/nix/sources.json
@@ -21,15 +21,15 @@
         "version": "3.2.25"
     },
     "ic": {
-        "branch": "luc/passive-data-segment",
+        "branch": "pull/143/head",
         "description": "Internet Computer blockchain source: the client/replica software run by nodes",
         "homepage": "",
-        "owner": "luc-blaeser",
+        "owner": "dfinity",
         "repo": "ic",
-        "rev": "411f0cf022140e048d7a46cbfea69a4a358f2d54",
+        "rev": "b91114192c326a719d6d9a1fbc3e5d481d6fa4b3",
         "sha256": "0i27f2lvmlgxmwzr1s4ig2cdivd74am93bwybdlgr2gs7pvf7ydm",
         "type": "tarball",
-        "url": "https://github.com/luc-blaeser/ic/archive/411f0cf022140e048d7a46cbfea69a4a358f2d54.tar.gz",
+        "url": "https://github.com/dfinity/ic/archive/b91114192c326a719d6d9a1fbc3e5d481d6fa4b3.tar.gz",
         "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
     },
     "ic-hs": {

From d8f7f048c5d9198ed093374161881f1dbdd7e025 Mon Sep 17 00:00:00 2001
From: Luc Blaeser <112870813+luc-blaeser@users.noreply.github.com>
Date: Thu, 29 Feb 2024 13:11:40 +0100
Subject: [PATCH 165/260] Merge Preparation: Precise Tagging + Enhanced
 Orthogonal Persistence (32-Bit) (#4383)

Preparing merging https://github.com/dfinity/motoko/pull/4369 in https://github.com/dfinity/motoko/pull/4193
---
 Changelog.md                                  |   12 +-
 doc/md/language-manual.md                     |    4 +-
 doc/md/upgrades.md                            |    4 +-
 nix/sources.json                              |    6 +-
 rts/cargo-vendor-tools/Cargo.toml             |    2 +-
 rts/motoko-rts-macros/Cargo.toml              |    2 +-
 rts/motoko-rts-tests/Cargo.toml               |    2 +-
 rts/motoko-rts/Cargo.toml                     |    2 +-
 rts/motoko-rts/native/Cargo.toml              |    2 +-
 rts/motoko-rts/src/bigint.rs                  |   27 +-
 rts/motoko-rts/src/constants.rs               |    4 +
 rts/motoko-rts/src/memory.rs                  |    4 +-
 src/codegen/compile.ml                        | 1444 ++++++++++++-----
 src/exes/candid_tests.ml                      |    2 +-
 src/ir_def/arrange_ir.ml                      |    6 +-
 src/ir_def/check_ir.ml                        |   12 +-
 src/ir_def/construct.ml                       |   12 +-
 src/ir_def/construct.mli                      |    1 +
 src/ir_def/ir.ml                              |   16 +-
 src/ir_interpreter/interpret_ir.ml            |   10 +-
 src/lang_utils/error_codes.ml                 |    1 +
 src/lang_utils/error_codes/M0194.md           |   31 +
 src/languageServer/declaration_index.ml       |    9 +-
 src/lowering/desugar.ml                       |   53 +-
 src/mo_config/flags.ml                        |    1 +
 src/mo_def/syntax.ml                          |    8 +-
 src/mo_frontend/typing.ml                     |  193 ++-
 src/mo_frontend/typing.mli                    |    5 +-
 src/mo_idl/idl_to_mo_value.ml                 |    2 +-
 src/mo_interpreter/interpret.ml               |    4 +-
 src/mo_types/scope.ml                         |    2 +-
 src/mo_types/scope.mli                        |    2 +-
 src/mo_values/prim.ml                         |    9 +-
 src/pipeline/pipeline.ml                      |   33 +-
 src/pipeline/resolve_import.ml                |   16 +-
 src/prelude/prim.mo                           |   38 +-
 test/bench/alloc.mo                           |    3 +-
 test/bench/nat16.mo                           |    1 -
 test/bench/ok/alloc.drun-run.ok               |    6 +-
 test/bench/ok/bignum.drun-run.ok              |    4 +-
 test/bench/ok/bignum.tc.ok                    |    1 +
 test/bench/ok/heap-32.drun-run.ok             |    4 +-
 test/bench/ok/heap-32.tc.ok                   |    1 +
 test/bench/ok/nat16.drun-run.ok               |    2 +-
 test/bench/ok/nat16.tc.ok                     |    2 +
 test/bench/ok/palindrome.drun-run.ok          |   12 +-
 test/bench/ok/palindrome.tc.ok                |    1 +
 test/bench/ok/region-mem.drun-run.ok          |    2 +-
 test/bench/ok/region-mem.tc.ok                |    1 +
 test/bench/ok/region0-mem.drun-run.ok         |    2 +-
 test/bench/ok/region0-mem.tc.ok               |    1 +
 test/bench/ok/stable-mem.drun-run.ok          |    2 +-
 test/bench/ok/stable-mem.tc.ok                |    1 +
 test/fail/lib/unused1.mo                      |    6 +
 test/fail/lib/unused2.mo                      |    9 +
 test/fail/lib/unused3.mo                      |    6 +
 test/fail/lib/unused4.mo                      |    6 +
 test/fail/ok/M0127.tc.ok                      |    1 +
 test/fail/ok/M0128.tc.ok                      |    2 +
 test/fail/ok/abstract-msgs.tc.ok              |    5 +
 test/fail/ok/actor-cap.tc.ok                  |    2 +
 test/fail/ok/actor-class-generic.tc.ok        |    1 +
 test/fail/ok/actor-class-star.tc.ok           |    1 +
 test/fail/ok/argument-subtyping.tc.ok         |    4 +
 test/fail/ok/asyncret2.tc.ok                  |    1 +
 test/fail/ok/bad-actor.tc.ok                  |    6 +
 test/fail/ok/bad-async-sort.tc.ok             |    4 +
 test/fail/ok/bad-async.tc.ok                  |   10 +-
 test/fail/ok/bad-import-decs.tc.ok            |    1 +
 test/fail/ok/bad-unops.tc.ok                  |    4 +
 test/fail/ok/bang-fail.tc.ok                  |    5 +
 test/fail/ok/bounds-mismatch.tc.ok            |   16 +
 test/fail/ok/branch-before-define.tc.ok       |    1 +
 test/fail/ok/check-record.tc.ok               |    2 +
 test/fail/ok/const-var-array.tc.ok            |    1 +
 test/fail/ok/const-var-field.tc.ok            |    1 +
 test/fail/ok/f-bounds-fail.tc.ok              |   27 +
 test/fail/ok/ho-variant.tc.ok                 |    5 +
 test/fail/ok/illegal-await.tc.ok              |   50 +-
 test/fail/ok/inference.tc.ok                  |   16 +
 test/fail/ok/issue-1411.tc.ok                 |    2 +
 test/fail/ok/issue-3318.tc.ok                 |   13 +
 test/fail/ok/issue2062.tc.ok                  |    1 +
 test/fail/ok/missing-semi.tc.ok               |    1 +
 test/fail/ok/modexp3.tc.ok                    |    1 +
 test/fail/ok/modexp4.tc.ok                    |    1 +
 test/fail/ok/modexp6.tc.ok                    |    1 +
 test/fail/ok/non_static_module.tc.ok          |   11 +
 test/fail/ok/obj-with.tc.ok                   |    5 +
 test/fail/ok/object-ext-poly.tc.ok            |    1 +
 test/fail/ok/objpat-infer.tc.ok               |    1 +
 test/fail/ok/one-tuple-ambiguity.tc.ok        |    2 +
 test/fail/ok/pat-inconsistent.tc.ok           |    1 +
 test/fail/ok/pat-subtyping-fail.tc.ok         |    8 +
 test/fail/ok/pretty-inference.tc.ok           |    4 +
 test/fail/ok/pretty.tc.ok                     |    5 +
 test/fail/ok/prim-in-source.tc.ok             |    1 +
 test/fail/ok/queries.tc.ok                    |    1 +
 test/fail/ok/redundant-ignore.tc.ok           |    1 +
 test/fail/ok/return-before-define.tc.ok       |    1 +
 test/fail/ok/shared-nonexhaustive.tc.ok       |    4 +
 test/fail/ok/structural_equality.tc.ok        |    2 +
 test/fail/ok/typed-labels.tc.ok               |   20 +
 test/fail/ok/unused.tc.ok                     |    9 +
 test/fail/ok/use-before-define.tc.ok          |    1 +
 test/fail/ok/use-before-define5.tc.ok         |    1 +
 test/fail/ok/use-before-define6.tc.ok         |    1 +
 test/fail/ok/usedefbug.tc.ok                  |    3 +
 test/fail/ok/var-const-array.tc.ok            |    1 +
 test/fail/ok/variance.tc.ok                   |    8 +
 test/fail/ok/variant-check.tc.ok              |    2 +
 test/fail/unused.mo                           |   32 +
 test/lsp-int/lsp-int.cabal                    |    2 +-
 test/mo-idl/ok/class.idl.ok                   |    1 +
 test/mo-idl/ok/class.tc.ok                    |    1 +
 test/mo-idl/ok/counter.did.ok                 |    4 +-
 test/mo-idl/ok/counter.idl.ok                 |    2 +
 test/mo-idl/ok/counter.tc.ok                  |    2 +
 test/mo-idl/ok/dup_fields.idl.ok              |    3 +
 test/mo-idl/ok/dup_fields.tc.ok               |    3 +
 test/mo-idl/ok/empty_class.did.ok             |    4 +-
 test/mo-idl/ok/fields.idl.ok                  |    3 +
 test/mo-idl/ok/fields.tc.ok                   |    3 +
 test/mo-idl/ok/func_mode.idl.ok               |    1 +
 test/mo-idl/ok/func_mode.tc.ok                |    1 +
 test/mo-idl/ok/inline_result.idl.ok           |    1 +
 test/mo-idl/ok/inline_result.tc.ok            |    1 +
 test/mo-idl/ok/keyword.idl.ok                 |    1 +
 test/mo-idl/ok/keyword.tc.ok                  |    1 +
 test/mo-idl/ok/pa_cars.idl.ok                 |    6 +
 test/mo-idl/ok/pa_cars.tc.ok                  |    6 +
 test/mo-idl/ok/prelude.idl.ok                 |    3 +
 test/mo-idl/ok/prelude.tc.ok                  |    3 +
 test/mo-idl/result.mo                         |    2 +-
 test/perf/assetstorage/Text.mo                |    2 +-
 test/perf/ok/assetstorage.tc.ok               |    5 +
 test/perf/ok/dao.tc.ok                        |    7 +
 test/perf/ok/qr.tc.ok                         |   10 +
 test/perf/ok/sha256.tc.ok                     |    1 +
 test/perf/sha256/Nat32.mo                     |    2 +-
 test/perf/sha256/Nat64.mo                     |    2 +-
 test/perf/sha256/Nat8.mo                      |    2 +-
 test/random/qc-motoko.cabal                   |    2 +-
 test/repl/ok/file-and-repl.stderr.ok          |    1 +
 test/repl/ok/type-lub-repl.stderr.ok          |   36 +
 test/run-drun/actor-class-mgmt-interp.mo      |    1 -
 test/run-drun/actor-import.mo                 |    2 +-
 test/run-drun/actor-reference.mo              |    4 +-
 test/run-drun/async-loop.mo                   |    2 +-
 test/run-drun/certified-data.mo               |    2 +-
 test/run-drun/composite-import.mo             |    2 +-
 test/run-drun/distributor/node.mo             |    2 +-
 test/run-drun/gc-random-test-force-gc.mo      |    2 +
 test/run-drun/gc-random-test-no-force-gc.mo   |    3 +
 test/run-drun/gc-random-test/buffer.mo        |    3 +-
 .../run-drun/gc-random-test/gc-random-test.mo |   21 +-
 test/run-drun/gc-random-test/types.mo         |  100 +-
 test/run-drun/gc-random-test/values.mo        |    8 +
 test/run-drun/idl-buf-size-bug.mo             |    1 -
 test/run-drun/idl-composite.mo                |    4 +-
 test/run-drun/inline.mo                       |    3 -
 test/run-drun/issue-3140-d.mo                 |    1 -
 test/run-drun/max-stack-variant.mo            |    6 +-
 test/run-drun/max-stack.mo                    |    6 +-
 test/run-drun/ok/AST-64.tc.ok                 |    2 +
 test/run-drun/ok/AST-66.ic-ref-run.ok         |    6 -
 test/run-drun/ok/GIT-843.ic-ref-run.ok        |    7 -
 test/run-drun/ok/actor-arg.ic-ref-run.ok      |    8 -
 test/run-drun/ok/actor-capture.ic-ref-run.ok  |    4 -
 .../run-drun/ok/actor-class-arg.ic-ref-run.ok |   44 -
 .../ok/actor-class-cycles.ic-ref-run.ok       |   24 -
 .../ok/actor-class-mgmt.ic-ref-run.ok         |    7 -
 .../ok/actor-creator-shadow-too.ic-ref-run.ok |    6 -
 .../ok/actor-creator-shadow-too.tc.ok         |    1 +
 .../ok/actor-creator-shadow.ic-ref-run.ok     |    6 -
 test/run-drun/ok/actor-creator-shadow.tc.ok   |    1 +
 test/run-drun/ok/actor-creator.ic-ref-run.ok  |    8 -
 test/run-drun/ok/actor-creator.tc.ok          |    2 +
 test/run-drun/ok/actor-import.ic-ref-run.ok   |   10 -
 .../ok/actor-reference-bad.ic-ref-run.ok      |   17 -
 .../ok/actor-reference-return.ic-ref-run.ok   |    8 -
 .../run-drun/ok/actor-reference.ic-ref-run.ok |    4 -
 .../ok/array-out-of-bounds.ic-ref-run.ok      |    8 -
 test/run-drun/ok/assert.ic-ref-run.ok         |    6 -
 test/run-drun/ok/async-any.ic-ref-run.ok      |    6 -
 test/run-drun/ok/async-bang.ic-ref-run.ok     |   13 -
 test/run-drun/ok/async-calls1.ic-ref-run.ok   |    6 -
 test/run-drun/ok/async-calls2.ic-ref-run.ok   |    6 -
 test/run-drun/ok/async-calls3.ic-ref-run.ok   |    6 -
 test/run-drun/ok/async-calls3.tc.ok           |    1 +
 test/run-drun/ok/async-free-var.ic-ref-run.ok |   13 -
 .../ok/async-loop-while.ic-ref-run.ok         |   18 -
 test/run-drun/ok/async-loop.ic-ref-run.ok     |    4 -
 test/run-drun/ok/async-new-obj.ic-ref-run.ok  |   11 -
 test/run-drun/ok/async-obj-mut.ic-ref-run.ok  |   14 -
 test/run-drun/ok/async-obj-mut.tc.ok          |    5 +
 test/run-drun/ok/async-while.ic-ref-run.ok    |   18 -
 test/run-drun/ok/await-sugar.ic-ref-run.ok    |    6 -
 .../ok/await-without-yield.ic-ref-run.ok      |    7 -
 test/run-drun/ok/await.ic-ref-run.ok          |   33 -
 test/run-drun/ok/await.tc.ok                  |    3 +
 test/run-drun/ok/basic-cycles.ic-ref-run.ok   |   34 -
 test/run-drun/ok/basic-cycles.tc.ok           |    1 +
 test/run-drun/ok/bignum1.ic-ref-run.ok        |    4 -
 test/run-drun/ok/bignum1.tc.ok                |    2 +
 test/run-drun/ok/block.ic-ref-run.ok          |   16 -
 test/run-drun/ok/calc.ic-ref-run.ok           |   19 -
 .../ok/call-async-method.ic-ref-run.ok        |    6 -
 test/run-drun/ok/call-async-method.tc.ok      |    1 +
 .../run-drun/ok/call-raw-candid.ic-ref-run.ok |   13 -
 test/run-drun/ok/call-raw-candid.tc.ok        |    3 +
 test/run-drun/ok/call-raw.ic-ref-run.ok       |   21 -
 test/run-drun/ok/call-raw.tc.ok               |    2 +
 .../ok/callback-trap-upgrade.ic-ref-run.ok    |   22 -
 test/run-drun/ok/caller.ic-ref-run.ok         |   24 -
 test/run-drun/ok/caller.tc.ok                 |    4 +
 test/run-drun/ok/certified-data.ic-ref-run.ok |   14 -
 test/run-drun/ok/class-import.ic-ref-run.ok   |   13 -
 test/run-drun/ok/class-import.tc.ok           |    2 +
 test/run-drun/ok/clone.ic-ref-run.ok          |   16 -
 test/run-drun/ok/closure-params.ic-ref-run.ok |   16 -
 .../run-drun/ok/commit-on-await.ic-ref-run.ok |   10 -
 .../composite-inspect-message.ic-ref-run.ok   |    4 -
 .../ok/composite-inspect-message.tc.ok        |    1 +
 test/run-drun/ok/composite-query.tc.ok        |    1 +
 test/run-drun/ok/composite-semantics.tc.ok    |    1 +
 test/run-drun/ok/control.tc.ok                |    6 +
 .../run-drun/ok/count-callbacks.ic-ref-run.ok |   19 -
 test/run-drun/ok/counter.ic-ref-run.ok        |   18 -
 test/run-drun/ok/counter2.ic-ref-run.ok       |   20 -
 test/run-drun/ok/data-params.ic-ref-run.ok    |   42 -
 test/run-drun/ok/distributor.ic-ref-run.ok    |   78 -
 test/run-drun/ok/divide-by-zero.ic-ref-run.ok |    4 -
 test/run-drun/ok/do-async-nary.ic-ref-run.ok  |    6 -
 test/run-drun/ok/do-async-nary.tc.ok          |    2 +
 .../run-drun/ok/do-async-nested.ic-ref-run.ok |    6 -
 test/run-drun/ok/do-async-poly.tc.ok          |    1 +
 test/run-drun/ok/do-async-rec.ic-ref-run.ok   |    6 -
 test/run-drun/ok/do-async-rec.tc.ok           |    1 +
 test/run-drun/ok/do-async-unary.ic-ref-run.ok |    6 -
 test/run-drun/ok/do-async-unary.tc.ok         |    2 +
 test/run-drun/ok/do-async-unit.ic-ref-run.ok  |    6 -
 test/run-drun/ok/do-async-unit.tc.ok          |    2 +
 test/run-drun/ok/do-async.ic-ref-run.ok       |    6 -
 test/run-drun/ok/do-option-bug.ic-ref-run.ok  |    6 -
 test/run-drun/ok/do-option-bug.tc.ok          |    2 +
 test/run-drun/ok/empty-actor.ic-ref-run.ok    |    4 -
 test/run-drun/ok/empty-call.ic-ref-run.ok     |    6 -
 test/run-drun/ok/error-codes.ic-ref-run.ok    |    8 -
 test/run-drun/ok/error-codes.tc.ok            |    1 +
 test/run-drun/ok/eval.ic-ref-run.ok           |    4 -
 test/run-drun/ok/explicit-actor-import.tc.ok  |    1 +
 test/run-drun/ok/explicit-trap.ic-ref-run.ok  |    6 -
 .../ok/flatten-awaitables.ic-ref-run.ok       |   40 -
 test/run-drun/ok/for-await.ic-ref-run.ok      |   17 -
 test/run-drun/ok/free-callbacks.ic-ref-run.ok |    7 -
 .../ok/from_candid_trap.ic-ref-run.ok         |    6 -
 test/run-drun/ok/gc.ic-ref-run.ok             |   49 -
 test/run-drun/ok/general_await.ic-ref-run.ok  |   50 -
 .../ok/general_await_implicit.ic-ref-run.ok   |   50 -
 .../ok/generic-tail-rec.ic-ref-run.ok         |    8 -
 .../ok/hello-world-async.ic-ref-run.ok        |    8 -
 .../ok/hello-world-await.ic-ref-run.ok        |    7 -
 .../ok/hello-world-message.ic-ref-run.ok      |    4 -
 .../ok/hello-world-return.ic-ref-run.ok       |    8 -
 test/run-drun/ok/hello-world.ic-ref-run.ok    |    5 -
 test/run-drun/ok/ic-calls.ic-ref-run.ok       |    6 -
 test/run-drun/ok/id-sub-ho.ic-ref-run.ok      |   15 -
 test/run-drun/ok/idl-any-stable.ic-ref-run.ok |    6 -
 test/run-drun/ok/idl-any.ic-ref-run.ok        |   94 --
 test/run-drun/ok/idl-bad.ic-ref-run.ok        |    6 -
 test/run-drun/ok/idl-bool.ic-ref-run.ok       |   10 -
 .../ok/idl-buf-size-bug.ic-ref-run.ok         |    6 -
 .../ok/idl-field-escape.ic-ref-run.ok         |   12 -
 test/run-drun/ok/idl-field-escape.tc.ok       |    1 +
 test/run-drun/ok/idl-float.ic-ref-run.ok      |    6 -
 test/run-drun/ok/idl-func.ic-ref-run.ok       |   12 -
 test/run-drun/ok/idl-func.tc.ok               |    1 +
 .../ok/idl-large-principal.ic-ref-run.ok      |   16 -
 test/run-drun/ok/idl-mo.ic-ref-run.ok         |    4 -
 test/run-drun/ok/idl-nary.ic-ref-run.ok       |   26 -
 test/run-drun/ok/idl-nat-int.ic-ref-run.ok    |   12 -
 test/run-drun/ok/idl-option.ic-ref-run.ok     |   13 -
 test/run-drun/ok/idl-pair.ic-ref-run.ok       |    6 -
 test/run-drun/ok/idl-principal.ic-ref-run.ok  |    8 -
 test/run-drun/ok/idl-record.ic-ref-run.ok     |   18 -
 test/run-drun/ok/idl-shorthand.ic-ref-run.ok  |    6 -
 test/run-drun/ok/idl-sub-ho-neg.ic-ref-run.ok |   25 -
 test/run-drun/ok/idl-sub-ho-neg.tc.ok         |   50 +
 test/run-drun/ok/idl-sub-ho.ic-ref-run.ok     |   17 -
 test/run-drun/ok/idl-sub-ho.tc.ok             |   28 +
 .../ok/idl-sub-opt-any-record.ic-ref-run.ok   |   11 -
 test/run-drun/ok/idl-sub-opt-any-record.tc.ok |    7 +
 .../run-drun/ok/idl-sub-opt-any.ic-ref-run.ok |   13 -
 test/run-drun/ok/idl-sub-opt-any.tc.ok        |   11 +
 test/run-drun/ok/idl-sub-rec.ic-ref-run.ok    |   25 -
 test/run-drun/ok/idl-sub-rec.tc.ok            |    9 +
 .../run-drun/ok/idl-sub-variant.ic-ref-run.ok |    9 -
 test/run-drun/ok/idl-sub.ic-ref-run.ok        |   22 -
 test/run-drun/ok/idl-sub.tc.ok                |   21 +
 test/run-drun/ok/idl-tuple.ic-ref-run.ok      |   18 -
 test/run-drun/ok/idl-tuple.tc.ok              |    1 +
 test/run-drun/ok/idl-unit.ic-ref-run.ok       |    6 -
 test/run-drun/ok/idl-variant.ic-ref-run.ok    |    6 -
 test/run-drun/ok/idl-vector.ic-ref-run.ok     |    6 -
 test/run-drun/ok/import-pat.ic-ref-run.ok     |    7 -
 test/run-drun/ok/inline.ic-ref-run.ok         |    4 -
 test/run-drun/ok/inline.tc.ok                 |    2 +
 .../run-drun/ok/inspect_message.ic-ref-run.ok |    4 -
 test/run-drun/ok/inspect_message.tc.ok        |    1 +
 .../ok/inspect_message_blob.ic-ref-run.ok     |    4 -
 .../ok/install-empty-actor.ic-ref-run.ok      |    8 -
 test/run-drun/ok/interleave.ic-ref-run.ok     |   25 -
 test/run-drun/ok/interleave.tc.ok             |    1 +
 test/run-drun/ok/issue-1174.ic-ref-run.ok     |    4 -
 test/run-drun/ok/issue-1174.tc.ok             |    1 +
 test/run-drun/ok/issue-1847.ic-ref-run.ok     |    4 -
 test/run-drun/ok/issue-1938-c.tc.ok           |    1 +
 test/run-drun/ok/issue-1938-d.tc.ok           |    1 +
 test/run-drun/ok/issue-1938.tc.ok             |    2 +
 test/run-drun/ok/issue-2047.ic-ref-run.ok     |    4 -
 test/run-drun/ok/issue-2047.tc.ok             |    1 +
 test/run-drun/ok/issue-2158.tc.ok             |    3 +
 test/run-drun/ok/issue-2464.ic-ref-run.ok     |    4 -
 test/run-drun/ok/issue-2464.tc.ok             |    1 +
 test/run-drun/ok/issue-3103.tc.ok             |    1 +
 test/run-drun/ok/issue-3128-b.ic-ref-run.ok   |    4 -
 test/run-drun/ok/issue-3128-b.tc.ok           |    1 +
 test/run-drun/ok/issue-3128.ic-ref-run.ok     |    4 -
 test/run-drun/ok/issue-3128.tc.ok             |    1 +
 test/run-drun/ok/issue-3140-b.ic-ref-run.ok   |    4 -
 test/run-drun/ok/issue-3140-b.tc.ok           |    1 +
 test/run-drun/ok/issue-3140-c.ic-ref-run.ok   |    4 -
 test/run-drun/ok/issue-3140-c.tc.ok           |    1 +
 test/run-drun/ok/issue-3140-d.ic-ref-run.ok   |    4 -
 test/run-drun/ok/issue-3140-d.tc.ok           |    1 +
 test/run-drun/ok/issue-3140.ic-ref-run.ok     |    4 -
 test/run-drun/ok/issue-3140.tc.ok             |    1 +
 test/run-drun/ok/issue-3449.ic-ref-run.ok     |    4 -
 test/run-drun/ok/issue-3449.tc.ok             |    1 +
 test/run-drun/ok/issue-3732.ic-ref-run.ok     |    4 -
 test/run-drun/ok/issue-3732.tc.ok             |    6 +
 test/run-drun/ok/issue-3740.ic-ref-run.ok     |    4 -
 test/run-drun/ok/issue-3740b.ic-ref-run.ok    |    4 -
 test/run-drun/ok/issue-3910.ic-ref-run.ok     |   14 -
 test/run-drun/ok/issue-3910.tc.ok             |    4 +
 test/run-drun/ok/issue-4236.tc.ok             |    1 +
 test/run-drun/ok/issue-894.ic-ref-run.ok      |   15 -
 test/run-drun/ok/issue2317.ic-ref-run.ok      |    4 -
 test/run-drun/ok/let-else-actor.ic-ref-run.ok |    4 -
 test/run-drun/ok/let-else-actor.tc.ok         |    1 +
 test/run-drun/ok/let-else-await.ic-ref-run.ok |    6 -
 .../ok/let-else-return-async.ic-ref-run.ok    |    6 -
 test/run-drun/ok/let-else-throw.ic-ref-run.ok |    6 -
 test/run-drun/ok/live-upgrade.ic-ref-run.ok   |   30 -
 test/run-drun/ok/local-throw.ic-ref-run.ok    |    8 -
 test/run-drun/ok/map-upgrades.ic-ref-run.ok   |  116 --
 test/run-drun/ok/mod-rebind.ic-ref-run.ok     |    4 -
 test/run-drun/ok/multi-value.ic-ref-run.ok    |    4 -
 test/run-drun/ok/nary-async.ic-ref-run.ok     |   16 -
 test/run-drun/ok/neg-powers.ic-ref-run.ok     |   42 -
 test/run-drun/ok/obj-ext-await.ic-ref-run.ok  |    6 -
 test/run-drun/ok/obj-ext-await.tc.ok          |    1 +
 .../ok/oneshot-callbacks.ic-ref-run.ok        |   70 -
 test/run-drun/ok/oneway-throw.ic-ref-run.ok   |   10 -
 test/run-drun/ok/oneway.ic-ref-run.ok         |   17 -
 test/run-drun/ok/oom.ic-ref-run.ok            |    8 -
 .../ok/optimise-for-array-eff.ic-ref-run.ok   |   18 -
 test/run-drun/ok/overflow.ic-ref-run.ok       |   16 -
 test/run-drun/ok/perf.drun-run.ok             |    1 -
 .../run-drun/ok/print-from-init.ic-ref-run.ok |    5 -
 .../ok/query-footprint-overflow.ic-ref-run.ok |    6 -
 .../ok/query-footprint-overflow.tc.ok         |    2 +
 .../run-drun/ok/query-footprint.ic-ref-run.ok |   12 -
 test/run-drun/ok/query-footprint.tc.ok        |    4 +
 .../ok/query-size-overflow.ic-ref-run.ok      |    8 -
 test/run-drun/ok/query.ic-ref-run.ok          |   30 -
 test/run-drun/ok/query2.ic-ref-run.ok         |   17 -
 test/run-drun/ok/rand.ic-ref-run.ok           |    6 -
 test/run-drun/ok/rand.tc.ok                   |    2 +
 test/run-drun/ok/region0-rts-stats.tc.ok      |    1 +
 .../run-drun/ok/region0-stable-mem-grow.tc.ok |    2 +
 test/run-drun/ok/reinstall.ic-ref-run.ok      |   10 -
 test/run-drun/ok/reject-bug.ic-ref-run.ok     |    8 -
 test/run-drun/ok/reject.ic-ref-run.ok         |   15 -
 test/run-drun/ok/rts-stack-pages.tc.ok        |    2 +
 test/run-drun/ok/rts-stats.ic-ref-run.ok      |    4 -
 test/run-drun/ok/rts-stats2.ic-ref-run.ok     |   24 -
 test/run-drun/ok/rts-stats2.tc.ok             |    1 +
 test/run-drun/ok/scope-example-func.tc.ok     |    8 +-
 test/run-drun/ok/scope-example-implicit.tc.ok |    2 +-
 test/run-drun/ok/scope-example.tc.ok          |    4 +-
 test/run-drun/ok/self-describe.tc.ok          |    1 +
 test/run-drun/ok/self-shadow.tc.ok            |    3 +
 test/run-drun/ok/self-upgrade.ic-ref-run.ok   |   29 -
 test/run-drun/ok/selftail.ic-ref-run.ok       |    6 -
 test/run-drun/ok/service-import.ic-ref-run.ok |   13 -
 test/run-drun/ok/shared-object.ic-ref-run.ok  |    6 -
 test/run-drun/ok/sharingbug.ic-ref-run.ok     |    4 -
 test/run-drun/ok/show.ic-ref-run.ok           |   38 -
 test/run-drun/ok/show.tc.ok                   |    1 +
 test/run-drun/ok/stable-mem-grow.tc.ok        |    2 +
 test/run-drun/ok/stable-mem-rts-stats.tc.ok   |    1 +
 test/run-drun/ok/stable-mutable.ic-ref-run.ok |   27 -
 .../run-drun/ok/stable-sig-more.ic-ref-run.ok |    4 -
 test/run-drun/ok/stable-sig-more.tc.ok        |   49 +
 test/run-drun/ok/stable-sig.ic-ref-run.ok     |    4 -
 test/run-drun/ok/stable-sig.tc.ok             |    7 +
 test/run-drun/ok/stable-size-overflow.tc.ok   |    1 +
 test/run-drun/ok/stable.ic-ref-run.ok         |   24 -
 test/run-drun/ok/stable.tc.ok                 |    1 +
 .../ok/static-call-from-pub.ic-ref-run.ok     |    4 -
 test/run-drun/ok/static-gc.ic-ref-run.ok      |    8 -
 test/run-drun/ok/switch-await.ic-ref-run.ok   |   12 -
 .../ok/tailpositions-actor.ic-ref-run.ok      |   13 -
 .../ok/test-cycles-state.ic-ref-run.ok        |   15 -
 test/run-drun/ok/test-cycles-state.tc.ok      |    1 +
 test/run-drun/ok/test-cycles.ic-ref-run.ok    |   35 -
 test/run-drun/ok/test-cycles.tc.ok            |    1 +
 test/run-drun/ok/text-iter-gc.ic-ref-run.ok   |    6 -
 test/run-drun/ok/text-iter-gc.tc.ok           |    1 +
 test/run-drun/ok/text-iter.ic-ref-run.ok      |  233 ---
 test/run-drun/ok/text-lowercase.ic-ref-run.ok |   16 -
 test/run-drun/ok/throw.ic-ref-run.ok          |    8 -
 test/run-drun/ok/throw.tc.ok                  |    1 +
 test/run-drun/ok/time.ic-ref-run.ok           |    6 -
 test/run-drun/ok/timer-cancel.ic-ref-run.ok   |    8 -
 test/run-drun/ok/timer-default.ic-ref-run.ok  |    8 -
 test/run-drun/ok/timer-initial.ic-ref-run.ok  |    7 -
 test/run-drun/ok/timer-initial.tc.ok          |    1 +
 test/run-drun/ok/timer-trap.ic-ref-run.ok     |   11 -
 .../ok/timer-zero-recur.ic-ref-run.ok         |    8 -
 test/run-drun/ok/timer.ic-ref-run.ok          |   12 -
 test/run-drun/ok/timer.tc.ok                  |    4 +
 test/run-drun/ok/transpose.ic-ref-run.ok      |    7 -
 test/run-drun/ok/tuple-message.ic-ref-run.ok  |   22 -
 .../run-drun/ok/type-components.ic-ref-run.ok |    8 -
 test/run-drun/ok/type-components.tc.ok        |    4 +
 test/run-drun/ok/type-lub.ic-ref-run.ok       |    6 -
 test/run-drun/ok/type-lub.tc.ok               |   36 +
 .../run-drun/ok/unavailable-constructor.tc.ok |    2 +
 test/run-drun/ok/unsupported-more.tc.ok       |    2 +
 test/run-drun/ok/unsupported.tc.ok            |   13 +
 .../ok/unused-actor-class.drun-run.ok         |    2 +
 test/run-drun/ok/unused-actor-class.tc.ok     |    5 +
 .../ok/unused-actor-fields.drun-run.ok        |    2 +
 test/run-drun/ok/unused-actor-fields.tc.ok    |   18 +
 test/run-drun/ok/unused-import.drun-run.ok    |    3 +
 test/run-drun/ok/unused-import.run-ir.ok      |    1 +
 test/run-drun/ok/unused-import.run-low.ok     |    1 +
 test/run-drun/ok/unused-import.run.ok         |    1 +
 test/run-drun/ok/unused-import.tc.ok          |   11 +
 test/run-drun/ok/unused-module.drun-run.ok    |    2 +
 test/run-drun/ok/unused-module.tc.ok          |    3 +
 test/run-drun/ok/upgrade-hooks.ic-ref-run.ok  |   45 -
 test/run-drun/ok/upgrades.ic-ref-run.ok       |   61 -
 test/run-drun/ok/utf8.ic-ref-run.ok           |   10 -
 test/run-drun/perf.mo                         |    2 +-
 test/run-drun/rand-JIRA-EXC-1318.mo           |    4 +-
 test/run-drun/region0-stable-mem-blob.mo      |    2 -
 .../run-drun/region0-stable-mem-custom-max.mo |    1 -
 test/run-drun/region0-stable-mem-max.mo       |    1 -
 test/run-drun/region0-stable-mem-nat8.mo      |    2 -
 test/run-drun/stable-mem-blob.mo              |    2 -
 test/run-drun/stable-mem-custom-max.mo        |    1 -
 test/run-drun/stable-mem-max.mo               |    1 -
 test/run-drun/stable-mem-nat8.mo              |    2 -
 test/run-drun/stable-region-blob.mo           |    2 -
 test/run-drun/stable-regions-are-isolated.mo  |    6 +-
 .../stable-regions-new-each-upgrade.mo        |    1 -
 test/run-drun/stable-regions-one.mo           |    1 -
 test/run-drun/stable-size-no-overflow.mo      |    2 +-
 test/run-drun/static-gc.mo                    |    2 +-
 test/run-drun/throw-on-async-failure.mo       |    4 +-
 test/run-drun/throw-on-await-failure.mo       |    7 +-
 test/run-drun/throw-on-call-raw-failure.mo    |    3 +-
 test/run-drun/throw-on-local-failure.mo       |    4 +-
 test/run-drun/throw-on-oneway-failure.mo      |    4 +-
 test/run-drun/throw-on-send-failure.mo        |    4 +-
 test/run-drun/timer-cancel.mo                 |    2 +-
 test/run-drun/trap-on-async-failure.mo        |    5 +-
 test/run-drun/trap-on-await-failure.mo        |    5 +-
 test/run-drun/trap-on-call-raw-failure.mo     |    3 +-
 test/run-drun/trap-on-local-failure.mo        |    4 +-
 test/run-drun/trap-on-oneway-failure.mo       |    4 +-
 test/run-drun/trap-on-send-failure.mo         |    5 +-
 test/run-drun/unused-actor-class.mo           |    7 +
 .../unused-actor-class/test-actor-class.mo    |   11 +
 test/run-drun/unused-actor-fields.mo          |   40 +
 test/run-drun/unused-import.mo                |    7 +
 test/run-drun/unused-module.mo                |    5 +
 test/run-drun/unused-module/test-module.mo    |   18 +
 test/run.sh                                   |    8 +-
 test/run/array-iter-max.mo                    |   23 +
 test/run/idl-ops.mo                           |    2 +-
 test/run/idl.mo                               |    3 +-
 test/run/if-swap.mo                           |   12 +-
 test/run/issue1356.mo                         |   36 +-
 test/run/mut-array-iter-max.mo                |   23 +
 test/run/numeric-ops.mo                       |    1 +
 test/run/ok/3121-imp.tc.ok                    |    1 +
 test/run/ok/3121.tc.ok                        |    1 +
 test/run/ok/AST-56.tc.ok                      |    1 +
 test/run/ok/M0106.tc.ok                       |    2 +
 test/run/ok/aardvark.tc.ok                    |    4 +
 test/run/ok/arity_bug.tc.ok                   |    1 +
 test/run/ok/array-iter-max.wasm-run.ok        |    2 +
 test/run/ok/array-store.tc.ok                 |    1 +
 test/run/ok/array.tc.ok                       |    3 +
 test/run/ok/bad-actor-class.tc.ok             |    1 +
 test/run/ok/bad-actor.tc.ok                   |    1 +
 test/run/ok/bad-async-func.tc.ok              |    1 +
 test/run/ok/bad-do-async.tc.ok                |    1 +
 test/run/ok/bad-shared-func.tc.ok             |    1 +
 test/run/ok/big-array-access.wasm-run.ok      |   13 -
 test/run/ok/big-array-access.wasm-run.ret.ok  |    1 -
 test/run/ok/bit-ops.tc.ok                     |  136 ++
 test/run/ok/concat.tc.ok                      |    3 +
 test/run/ok/const-func-unused.tc.ok           |    2 +
 test/run/ok/counter-class.tc.ok               |    1 +
 test/run/ok/coverage.tc.ok                    |   11 +
 test/run/ok/deprecated.tc.ok                  |    2 +
 test/run/ok/eager-and-lazy.tc.ok              |    1 +
 test/run/ok/empty-tup-args.tc.ok              |   25 +
 test/run/ok/f-bounds.tc.ok                    |   27 +
 test/run/ok/idx.tc.ok                         |    1 +
 test/run/ok/import-module-explicit.tc.ok      |    2 +
 test/run/ok/import-module.tc.ok               |    1 +
 test/run/ok/import-named-module.tc.ok         |    1 +
 test/run/ok/inc-oom.tc.ok                     |    1 +
 test/run/ok/ir-litpat-subtype.tc.ok           |    1 +
 test/run/ok/issue-4054.tc.ok                  |    4 +
 test/run/ok/issue129.tc.ok                    |    1 +
 test/run/ok/issue1304.tc.ok                   |    1 +
 test/run/ok/issue150.tc.ok                    |    1 +
 test/run/ok/issue2975.tc.ok                   |    1 +
 test/run/ok/issue3265.tc.ok                   |    3 +
 test/run/ok/issue36.tc.ok                     |    5 +
 test/run/ok/issue442.tc.ok                    |    2 +
 test/run/ok/let-else-if.tc.ok                 |    1 +
 test/run/ok/let-else.tc.ok                    |    3 +
 test/run/ok/literals.tc.ok                    |   12 +
 test/run/ok/modexp1.tc.ok                     |    1 +
 test/run/ok/modexp2.tc.ok                     |    1 +
 test/run/ok/modexp3.tc.ok                     |    1 +
 test/run/ok/modexp4.tc.ok                     |    1 +
 test/run/ok/module1.tc.ok                     |    4 +
 test/run/ok/module2.tc.ok                     |    1 +
 test/run/ok/modules-bwd.tc.ok                 |    2 +
 test/run/ok/mut-array-iter-max.wasm-run.ok    |    2 +
 test/run/ok/n-ary.tc.ok                       |    3 +
 test/run/ok/nat-shift.tc.ok                   |    1 +
 test/run/ok/neg-boundary.tc.ok                |    6 +
 test/run/ok/nested-class-rec.tc.ok            |    3 +
 test/run/ok/object-extend-type.tc.ok          |    7 +
 test/run/ok/object-extend.tc.ok               |    5 +
 test/run/ok/objects-order.tc.ok               |    1 +
 test/run/ok/objects1.tc.ok                    |    5 +
 test/run/ok/optimise-for-array.tc.ok          |    1 +
 test/run/ok/or-pattern-mismatch.tc.ok         |    5 +
 test/run/ok/prim.tc.ok                        |    1 +
 test/run/ok/principal.tc.ok                   |    1 +
 test/run/ok/quicksort.tc.ok                   |    1 +
 test/run/ok/refuted-const-option-null.tc.ok   |    1 +
 test/run/ok/refuted-const-variant.tc.ok       |    1 +
 test/run/ok/relational-ops.tc.ok              |  122 ++
 test/run/ok/show.tc.ok                        |    1 +
 test/run/ok/sort-record-fields.tc.ok          |    8 +
 test/run/ok/static-call-rec.tc.ok             |    1 +
 test/run/ok/struct-eq.tc.ok                   |    1 +
 test/run/ok/switch.tc.ok                      |    3 +
 test/run/ok/tuples.tc.ok                      |    2 +
 test/run/ok/typ-field-lub-glb.tc.ok           |    4 +
 test/run/ok/type-bin.tc.ok                    |   16 +
 test/run/ok/type-combine.tc.ok                |   11 +
 test/run/ok/type-definition.tc.ok             |    4 +
 test/run/ok/type-equivalence.tc.ok            |   44 +
 test/run/ok/type-inclusion.tc.ok              |   49 +
 test/run/ok/type-inference.tc.ok              |   10 +
 test/run/ok/unused-class.tc.ok                |   10 +
 test/run/ok/unused-module-identifier.tc.ok    |    2 +
 test/run/ok/unused-object.tc.ok               |    8 +
 test/run/ok/unused-shadowing.tc.ok            |    6 +
 test/run/ok/unused-switch-case.tc.ok          |    2 +
 test/run/ok/variants.tc.ok                    |    1 +
 test/run/ok/vec-any-bomb.tc.ok                |    1 +
 test/run/optimise-for-array.mo                |  146 +-
 test/run/static-func-call.mo                  |    2 +-
 test/run/unboxed-let.mo                       |   72 +-
 test/run/unused-class.mo                      |   18 +
 test/run/unused-module-identifier.mo          |   11 +
 test/run/unused-object.mo                     |   17 +
 test/run/unused-object2.mo                    |    5 +
 test/run/unused-shadowing.mo                  |   16 +
 test/run/unused-switch-case.mo                |    4 +
 test/run/unused-underscore.mo                 |   16 +
 test/run/variant-specials.mo                  |    2 +-
 test/run/words.mo                             |  136 +-
 test/test-moc.js                              |   39 +-
 599 files changed, 3515 insertions(+), 3897 deletions(-)
 create mode 100644 src/lang_utils/error_codes/M0194.md
 create mode 100644 test/bench/ok/bignum.tc.ok
 create mode 100644 test/bench/ok/heap-32.tc.ok
 create mode 100644 test/bench/ok/nat16.tc.ok
 create mode 100644 test/bench/ok/region-mem.tc.ok
 create mode 100644 test/bench/ok/region0-mem.tc.ok
 create mode 100644 test/bench/ok/stable-mem.tc.ok
 create mode 100644 test/fail/lib/unused1.mo
 create mode 100644 test/fail/lib/unused2.mo
 create mode 100644 test/fail/lib/unused3.mo
 create mode 100644 test/fail/lib/unused4.mo
 create mode 100644 test/fail/ok/ho-variant.tc.ok
 create mode 100644 test/fail/ok/issue-1411.tc.ok
 create mode 100644 test/fail/ok/modexp3.tc.ok
 create mode 100644 test/fail/ok/modexp4.tc.ok
 create mode 100644 test/fail/ok/obj-with.tc.ok
 create mode 100644 test/fail/ok/unused.tc.ok
 create mode 100644 test/fail/ok/use-before-define5.tc.ok
 create mode 100644 test/fail/unused.mo
 create mode 100644 test/mo-idl/ok/class.idl.ok
 create mode 100644 test/mo-idl/ok/class.tc.ok
 create mode 100644 test/mo-idl/ok/counter.idl.ok
 create mode 100644 test/mo-idl/ok/counter.tc.ok
 create mode 100644 test/mo-idl/ok/dup_fields.idl.ok
 create mode 100644 test/mo-idl/ok/dup_fields.tc.ok
 create mode 100644 test/mo-idl/ok/fields.idl.ok
 create mode 100644 test/mo-idl/ok/fields.tc.ok
 create mode 100644 test/mo-idl/ok/func_mode.idl.ok
 create mode 100644 test/mo-idl/ok/func_mode.tc.ok
 create mode 100644 test/mo-idl/ok/inline_result.idl.ok
 create mode 100644 test/mo-idl/ok/inline_result.tc.ok
 create mode 100644 test/mo-idl/ok/keyword.idl.ok
 create mode 100644 test/mo-idl/ok/keyword.tc.ok
 create mode 100644 test/mo-idl/ok/pa_cars.idl.ok
 create mode 100644 test/mo-idl/ok/pa_cars.tc.ok
 create mode 100644 test/mo-idl/ok/prelude.idl.ok
 create mode 100644 test/mo-idl/ok/prelude.tc.ok
 create mode 100644 test/perf/ok/assetstorage.tc.ok
 create mode 100644 test/perf/ok/qr.tc.ok
 create mode 100644 test/perf/ok/sha256.tc.ok
 create mode 100644 test/run-drun/ok/AST-64.tc.ok
 delete mode 100644 test/run-drun/ok/AST-66.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/GIT-843.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/actor-arg.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/actor-capture.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/actor-class-arg.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/actor-class-cycles.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/actor-class-mgmt.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/actor-creator-shadow-too.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/actor-creator-shadow-too.tc.ok
 delete mode 100644 test/run-drun/ok/actor-creator-shadow.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/actor-creator-shadow.tc.ok
 delete mode 100644 test/run-drun/ok/actor-creator.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/actor-creator.tc.ok
 delete mode 100644 test/run-drun/ok/actor-import.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/actor-reference-bad.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/actor-reference-return.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/actor-reference.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/array-out-of-bounds.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/assert.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/async-any.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/async-bang.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/async-calls1.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/async-calls2.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/async-calls3.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/async-calls3.tc.ok
 delete mode 100644 test/run-drun/ok/async-free-var.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/async-loop-while.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/async-loop.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/async-new-obj.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/async-obj-mut.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/async-obj-mut.tc.ok
 delete mode 100644 test/run-drun/ok/async-while.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/await-sugar.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/await-without-yield.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/await.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/await.tc.ok
 delete mode 100644 test/run-drun/ok/basic-cycles.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/basic-cycles.tc.ok
 delete mode 100644 test/run-drun/ok/bignum1.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/bignum1.tc.ok
 delete mode 100644 test/run-drun/ok/block.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/calc.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/call-async-method.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/call-async-method.tc.ok
 delete mode 100644 test/run-drun/ok/call-raw-candid.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/call-raw-candid.tc.ok
 delete mode 100644 test/run-drun/ok/call-raw.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/call-raw.tc.ok
 delete mode 100644 test/run-drun/ok/callback-trap-upgrade.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/caller.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/caller.tc.ok
 delete mode 100644 test/run-drun/ok/certified-data.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/class-import.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/class-import.tc.ok
 delete mode 100644 test/run-drun/ok/clone.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/closure-params.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/commit-on-await.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/composite-inspect-message.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/composite-inspect-message.tc.ok
 create mode 100644 test/run-drun/ok/composite-semantics.tc.ok
 create mode 100644 test/run-drun/ok/control.tc.ok
 delete mode 100644 test/run-drun/ok/count-callbacks.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/counter.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/counter2.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/data-params.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/distributor.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/divide-by-zero.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/do-async-nary.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/do-async-nary.tc.ok
 delete mode 100644 test/run-drun/ok/do-async-nested.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/do-async-rec.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/do-async-rec.tc.ok
 delete mode 100644 test/run-drun/ok/do-async-unary.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/do-async-unary.tc.ok
 delete mode 100644 test/run-drun/ok/do-async-unit.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/do-async-unit.tc.ok
 delete mode 100644 test/run-drun/ok/do-async.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/do-option-bug.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/do-option-bug.tc.ok
 delete mode 100644 test/run-drun/ok/empty-actor.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/empty-call.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/error-codes.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/error-codes.tc.ok
 delete mode 100644 test/run-drun/ok/eval.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/explicit-trap.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/flatten-awaitables.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/for-await.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/free-callbacks.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/from_candid_trap.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/gc.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/general_await.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/general_await_implicit.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/generic-tail-rec.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/hello-world-async.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/hello-world-await.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/hello-world-message.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/hello-world-return.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/hello-world.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/ic-calls.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/id-sub-ho.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/idl-any-stable.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/idl-any.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/idl-bad.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/idl-bool.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/idl-buf-size-bug.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/idl-field-escape.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/idl-field-escape.tc.ok
 delete mode 100644 test/run-drun/ok/idl-float.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/idl-func.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/idl-func.tc.ok
 delete mode 100644 test/run-drun/ok/idl-large-principal.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/idl-mo.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/idl-nary.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/idl-nat-int.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/idl-option.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/idl-pair.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/idl-principal.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/idl-record.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/idl-shorthand.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/idl-sub-ho-neg.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/idl-sub-ho-neg.tc.ok
 delete mode 100644 test/run-drun/ok/idl-sub-ho.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/idl-sub-ho.tc.ok
 delete mode 100644 test/run-drun/ok/idl-sub-opt-any-record.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/idl-sub-opt-any-record.tc.ok
 delete mode 100644 test/run-drun/ok/idl-sub-opt-any.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/idl-sub-opt-any.tc.ok
 delete mode 100644 test/run-drun/ok/idl-sub-rec.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/idl-sub-rec.tc.ok
 delete mode 100644 test/run-drun/ok/idl-sub-variant.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/idl-sub.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/idl-sub.tc.ok
 delete mode 100644 test/run-drun/ok/idl-tuple.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/idl-tuple.tc.ok
 delete mode 100644 test/run-drun/ok/idl-unit.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/idl-variant.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/idl-vector.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/import-pat.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/inline.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/inline.tc.ok
 delete mode 100644 test/run-drun/ok/inspect_message.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/inspect_message.tc.ok
 delete mode 100644 test/run-drun/ok/inspect_message_blob.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/install-empty-actor.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/interleave.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/interleave.tc.ok
 delete mode 100644 test/run-drun/ok/issue-1174.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/issue-1174.tc.ok
 delete mode 100644 test/run-drun/ok/issue-1847.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/issue-1938-c.tc.ok
 create mode 100644 test/run-drun/ok/issue-1938-d.tc.ok
 create mode 100644 test/run-drun/ok/issue-1938.tc.ok
 delete mode 100644 test/run-drun/ok/issue-2047.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/issue-2047.tc.ok
 create mode 100644 test/run-drun/ok/issue-2158.tc.ok
 delete mode 100644 test/run-drun/ok/issue-2464.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/issue-2464.tc.ok
 create mode 100644 test/run-drun/ok/issue-3103.tc.ok
 delete mode 100644 test/run-drun/ok/issue-3128-b.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/issue-3128-b.tc.ok
 delete mode 100644 test/run-drun/ok/issue-3128.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/issue-3128.tc.ok
 delete mode 100644 test/run-drun/ok/issue-3140-b.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/issue-3140-b.tc.ok
 delete mode 100644 test/run-drun/ok/issue-3140-c.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/issue-3140-c.tc.ok
 delete mode 100644 test/run-drun/ok/issue-3140-d.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/issue-3140-d.tc.ok
 delete mode 100644 test/run-drun/ok/issue-3140.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/issue-3140.tc.ok
 delete mode 100644 test/run-drun/ok/issue-3449.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/issue-3449.tc.ok
 delete mode 100644 test/run-drun/ok/issue-3732.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/issue-3732.tc.ok
 delete mode 100644 test/run-drun/ok/issue-3740.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/issue-3740b.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/issue-3910.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/issue-4236.tc.ok
 delete mode 100644 test/run-drun/ok/issue-894.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/issue2317.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/let-else-actor.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/let-else-actor.tc.ok
 delete mode 100644 test/run-drun/ok/let-else-await.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/let-else-return-async.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/let-else-throw.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/live-upgrade.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/local-throw.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/map-upgrades.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/mod-rebind.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/multi-value.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/nary-async.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/neg-powers.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/obj-ext-await.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/obj-ext-await.tc.ok
 delete mode 100644 test/run-drun/ok/oneshot-callbacks.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/oneway-throw.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/oneway.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/oom.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/optimise-for-array-eff.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/overflow.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/print-from-init.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/query-footprint-overflow.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/query-footprint-overflow.tc.ok
 delete mode 100644 test/run-drun/ok/query-footprint.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/query-footprint.tc.ok
 delete mode 100644 test/run-drun/ok/query-size-overflow.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/query.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/query2.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/rand.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/rand.tc.ok
 create mode 100644 test/run-drun/ok/region0-stable-mem-grow.tc.ok
 delete mode 100644 test/run-drun/ok/reinstall.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/reject-bug.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/reject.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/rts-stack-pages.tc.ok
 delete mode 100644 test/run-drun/ok/rts-stats.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/rts-stats2.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/rts-stats2.tc.ok
 create mode 100644 test/run-drun/ok/self-describe.tc.ok
 create mode 100644 test/run-drun/ok/self-shadow.tc.ok
 delete mode 100644 test/run-drun/ok/self-upgrade.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/selftail.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/service-import.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/shared-object.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/sharingbug.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/show.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/show.tc.ok
 create mode 100644 test/run-drun/ok/stable-mem-grow.tc.ok
 delete mode 100644 test/run-drun/ok/stable-mutable.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/stable-sig-more.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/stable-sig-more.tc.ok
 delete mode 100644 test/run-drun/ok/stable-sig.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/stable-sig.tc.ok
 create mode 100644 test/run-drun/ok/stable-size-overflow.tc.ok
 delete mode 100644 test/run-drun/ok/stable.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/stable.tc.ok
 delete mode 100644 test/run-drun/ok/static-call-from-pub.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/static-gc.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/switch-await.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/tailpositions-actor.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/test-cycles-state.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/test-cycles-state.tc.ok
 delete mode 100644 test/run-drun/ok/test-cycles.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/test-cycles.tc.ok
 delete mode 100644 test/run-drun/ok/text-iter-gc.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/text-iter-gc.tc.ok
 delete mode 100644 test/run-drun/ok/text-iter.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/text-lowercase.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/throw.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/throw.tc.ok
 delete mode 100644 test/run-drun/ok/time.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/timer-cancel.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/timer-default.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/timer-initial.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/timer-initial.tc.ok
 delete mode 100644 test/run-drun/ok/timer-trap.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/timer-zero-recur.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/timer.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/timer.tc.ok
 delete mode 100644 test/run-drun/ok/transpose.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/tuple-message.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/type-components.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/type-components.tc.ok
 delete mode 100644 test/run-drun/ok/type-lub.ic-ref-run.ok
 create mode 100644 test/run-drun/ok/type-lub.tc.ok
 create mode 100644 test/run-drun/ok/unavailable-constructor.tc.ok
 create mode 100644 test/run-drun/ok/unsupported-more.tc.ok
 create mode 100644 test/run-drun/ok/unsupported.tc.ok
 create mode 100644 test/run-drun/ok/unused-actor-class.drun-run.ok
 create mode 100644 test/run-drun/ok/unused-actor-class.tc.ok
 create mode 100644 test/run-drun/ok/unused-actor-fields.drun-run.ok
 create mode 100644 test/run-drun/ok/unused-actor-fields.tc.ok
 create mode 100644 test/run-drun/ok/unused-import.drun-run.ok
 create mode 100644 test/run-drun/ok/unused-import.run-ir.ok
 create mode 100644 test/run-drun/ok/unused-import.run-low.ok
 create mode 100644 test/run-drun/ok/unused-import.run.ok
 create mode 100644 test/run-drun/ok/unused-import.tc.ok
 create mode 100644 test/run-drun/ok/unused-module.drun-run.ok
 create mode 100644 test/run-drun/ok/unused-module.tc.ok
 delete mode 100644 test/run-drun/ok/upgrade-hooks.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/upgrades.ic-ref-run.ok
 delete mode 100644 test/run-drun/ok/utf8.ic-ref-run.ok
 create mode 100644 test/run-drun/unused-actor-class.mo
 create mode 100644 test/run-drun/unused-actor-class/test-actor-class.mo
 create mode 100644 test/run-drun/unused-actor-fields.mo
 create mode 100644 test/run-drun/unused-import.mo
 create mode 100644 test/run-drun/unused-module.mo
 create mode 100644 test/run-drun/unused-module/test-module.mo
 create mode 100644 test/run/array-iter-max.mo
 create mode 100644 test/run/mut-array-iter-max.mo
 create mode 100644 test/run/ok/3121-imp.tc.ok
 create mode 100644 test/run/ok/3121.tc.ok
 create mode 100644 test/run/ok/AST-56.tc.ok
 create mode 100644 test/run/ok/M0106.tc.ok
 create mode 100644 test/run/ok/aardvark.tc.ok
 create mode 100644 test/run/ok/arity_bug.tc.ok
 create mode 100644 test/run/ok/array-iter-max.wasm-run.ok
 create mode 100644 test/run/ok/array-store.tc.ok
 create mode 100644 test/run/ok/bad-actor-class.tc.ok
 create mode 100644 test/run/ok/bad-actor.tc.ok
 create mode 100644 test/run/ok/bad-async-func.tc.ok
 create mode 100644 test/run/ok/bad-do-async.tc.ok
 create mode 100644 test/run/ok/bad-shared-func.tc.ok
 delete mode 100644 test/run/ok/big-array-access.wasm-run.ok
 delete mode 100644 test/run/ok/big-array-access.wasm-run.ret.ok
 create mode 100644 test/run/ok/bit-ops.tc.ok
 create mode 100644 test/run/ok/concat.tc.ok
 create mode 100644 test/run/ok/const-func-unused.tc.ok
 create mode 100644 test/run/ok/counter-class.tc.ok
 create mode 100644 test/run/ok/eager-and-lazy.tc.ok
 create mode 100644 test/run/ok/empty-tup-args.tc.ok
 create mode 100644 test/run/ok/f-bounds.tc.ok
 create mode 100644 test/run/ok/idx.tc.ok
 create mode 100644 test/run/ok/import-module-explicit.tc.ok
 create mode 100644 test/run/ok/import-module.tc.ok
 create mode 100644 test/run/ok/import-named-module.tc.ok
 create mode 100644 test/run/ok/inc-oom.tc.ok
 create mode 100644 test/run/ok/ir-litpat-subtype.tc.ok
 create mode 100644 test/run/ok/issue-4054.tc.ok
 create mode 100644 test/run/ok/issue129.tc.ok
 create mode 100644 test/run/ok/issue1304.tc.ok
 create mode 100644 test/run/ok/issue150.tc.ok
 create mode 100644 test/run/ok/issue2975.tc.ok
 create mode 100644 test/run/ok/issue3265.tc.ok
 create mode 100644 test/run/ok/issue36.tc.ok
 create mode 100644 test/run/ok/let-else-if.tc.ok
 create mode 100644 test/run/ok/let-else.tc.ok
 create mode 100644 test/run/ok/literals.tc.ok
 create mode 100644 test/run/ok/modexp1.tc.ok
 create mode 100644 test/run/ok/modexp2.tc.ok
 create mode 100644 test/run/ok/modexp3.tc.ok
 create mode 100644 test/run/ok/modexp4.tc.ok
 create mode 100644 test/run/ok/module1.tc.ok
 create mode 100644 test/run/ok/module2.tc.ok
 create mode 100644 test/run/ok/modules-bwd.tc.ok
 create mode 100644 test/run/ok/mut-array-iter-max.wasm-run.ok
 create mode 100644 test/run/ok/n-ary.tc.ok
 create mode 100644 test/run/ok/neg-boundary.tc.ok
 create mode 100644 test/run/ok/nested-class-rec.tc.ok
 create mode 100644 test/run/ok/object-extend-type.tc.ok
 create mode 100644 test/run/ok/object-extend.tc.ok
 create mode 100644 test/run/ok/objects-order.tc.ok
 create mode 100644 test/run/ok/optimise-for-array.tc.ok
 create mode 100644 test/run/ok/prim.tc.ok
 create mode 100644 test/run/ok/principal.tc.ok
 create mode 100644 test/run/ok/quicksort.tc.ok
 create mode 100644 test/run/ok/relational-ops.tc.ok
 create mode 100644 test/run/ok/show.tc.ok
 create mode 100644 test/run/ok/sort-record-fields.tc.ok
 create mode 100644 test/run/ok/static-call-rec.tc.ok
 create mode 100644 test/run/ok/struct-eq.tc.ok
 create mode 100644 test/run/ok/tuples.tc.ok
 create mode 100644 test/run/ok/typ-field-lub-glb.tc.ok
 create mode 100644 test/run/ok/type-bin.tc.ok
 create mode 100644 test/run/ok/type-definition.tc.ok
 create mode 100644 test/run/ok/type-equivalence.tc.ok
 create mode 100644 test/run/ok/type-inclusion.tc.ok
 create mode 100644 test/run/ok/unused-class.tc.ok
 create mode 100644 test/run/ok/unused-module-identifier.tc.ok
 create mode 100644 test/run/ok/unused-object.tc.ok
 create mode 100644 test/run/ok/unused-shadowing.tc.ok
 create mode 100644 test/run/ok/unused-switch-case.tc.ok
 create mode 100644 test/run/ok/variants.tc.ok
 create mode 100644 test/run/ok/vec-any-bomb.tc.ok
 create mode 100644 test/run/unused-class.mo
 create mode 100644 test/run/unused-module-identifier.mo
 create mode 100644 test/run/unused-object.mo
 create mode 100644 test/run/unused-object2.mo
 create mode 100644 test/run/unused-shadowing.mo
 create mode 100644 test/run/unused-switch-case.mo
 create mode 100644 test/run/unused-underscore.mo

diff --git a/Changelog.md b/Changelog.md
index 70ba78b9d2f..ee14329bb33 100644
--- a/Changelog.md
+++ b/Changelog.md
@@ -1,9 +1,19 @@
 # Motoko compiler changelog
 
+
 ## Unreleased
 
 * motoko (`moc`)
 
+  * Warn on detection of unused identifiers (code `M0194`) (#4377).
+
+    - By design, warnings are not emitted for code imported from a package.
+    - A warning can be suppressed by replacing the identifier entirely by a wildcard `_`,
+      or by prefixing it with an `_`, e.g. replace `x` by `_x`.
+
+    **Limitations**: recursive and mutually recursive definitions are considered used,
+    even if never referenced outside the recursive definition.
+    
   * Remove `__get_candid_interface_tmp_hack` endpoint. Candid interface is already stored as canister metadata, this temporary endpoint is redundant, thus removed. (#4386)
 
 ## 0.10.4 (2024-01-10)
@@ -12,7 +22,7 @@
 
   * Officializing the new **incremental garbage collector** after a successful beta testing phase.
     The incremental GC can be enabled by the `moc` flag `--incremental-gc` (#3837) and is designed to scale for large program heap sizes.
-    
+
     **Note**: While resolving scalability issues with regard to the instruction limit of the GC work, it is now possible to hit other scalability limits:
     - _Out of memory_: A program can run out of memory if it fills the entire memory space with live objects.
     - _Upgrade limits_: When using stable variables, the current mechanism of serialization and deserialization to and from stable memory can exceed the instruction limit or run out of memory.
diff --git a/doc/md/language-manual.md b/doc/md/language-manual.md
index 3a47fc0772f..a0ec1014614 100644
--- a/doc/md/language-manual.md
+++ b/doc/md/language-manual.md
@@ -2305,7 +2305,7 @@ If `<exp>` in `label <id> (: <typ>)? <exp>` is a looping construct:
 
 the body, `<exp1>`, of the loop is implicitly enclosed in `label <id_continue> (…​)` allowing early continuation of the loop by the evaluation of expression `continue <id>`.
 
-`<id_continue>` is fresh identifier that can only be referenced by `continue <id>` (through its implicit expansion to `break <id_continue>`).
+`<id_continue>` is a fresh identifier that can only be referenced by `continue <id>` (through its implicit expansion to `break <id_continue>`).
 
 ### Break
 
@@ -2317,7 +2317,7 @@ The expression `break <id> <exp>` has type `None` provided:
 
 -   `<exp>` has type `T`.
 
-The evaluation of `break <id> <exp>` evaluates exp to some result `r`. If `r` is `trap`, the result is `trap`. If `r` is a value `v`, the evaluation abandons the current computation up to dynamically enclosing declaration `label <id> …​` using the value `v` as the result of that labelled expression.
+The evaluation of `break <id> <exp>` evaluates `<exp>` to some result `r`. If `r` is `trap`, the result is `trap`. If `r` is a value `v`, the evaluation abandons the current computation up to the dynamically enclosing declaration `label <id> …​` using the value `v` as the result of that labelled expression.
 
 ### Continue
 
diff --git a/doc/md/upgrades.md b/doc/md/upgrades.md
index e063f0ec9d3..35766398e84 100644
--- a/doc/md/upgrades.md
+++ b/doc/md/upgrades.md
@@ -2,7 +2,7 @@
 
 One key feature of the Internet Computer is its ability to persist canister smart contract state using WebAssembly memory and globals rather than a traditional database. This means that that the entire state of a canister is magically restored before, and saved after, each message, without explicit user instruction. This automatic and user-transparent preservation of state is called *orthogonal persistence*.
 
-Though convenient, orthogonal persistence poses a challenge when it comes to upgrading the code of a canister. Without an explicit representation of the canister’s state, how does one tranfer any application data from the retired canister to its replacement?
+Though convenient, orthogonal persistence poses a challenge when it comes to upgrading the code of a canister. Without an explicit representation of the canister’s state, how does one transfer any application data from the retired canister to its replacement?
 
 Accommodating upgrades without data loss requires some new facility to *migrate* a canister’s crucial data to the upgraded canister. For example, if you want to deploy a new version of a user-registration canister to fix an issue or add functionality, you need to ensure that existing registrations survive the upgrade process.
 
@@ -164,6 +164,6 @@ This metadata can be selectively exposed by the IC and used by tools such as `df
 
 ## Upgrading a deployed actor or canister smart contract
 
-After you have deployed a Motoko actor with the appropriate `stable` variables or `preupgrade` and `postupgrade` system methods, you can use the `dfx canister install` command with the `--mode=upgrade` option to upgrade an already deployed version. For information about upgrading a deployed canister, see [Upgrade a canister smart contract](../../developer-docs/setup/manage-canisters.md#upgrade-a-canister).
+After you have deployed a Motoko actor with the appropriate `stable` variables or `preupgrade` and `postupgrade` system methods, you can use the `dfx canister install` command with the `--mode=upgrade` option to upgrade an already deployed version. For information about upgrading a deployed canister, see [Upgrade a canister smart contract](/docs/current/developer-docs/smart-contracts/maintain/upgrade).
 
 An upcoming version of `dfx` will, if appropriate, check the safety of an upgrade by comparing the Candid and (for Motoko canisters only) the stable signatures embedded in the deployed binary and upgrade binary, and abort the upgrade request when unsafe.
diff --git a/nix/sources.json b/nix/sources.json
index e5aeacbc7d1..4336f2a398a 100644
--- a/nix/sources.json
+++ b/nix/sources.json
@@ -75,10 +75,10 @@
         "homepage": null,
         "owner": "dfinity",
         "repo": "motoko-base",
-        "rev": "b772c9e49d94e725fcca64fc1c891ec1fb1baab3",
-        "sha256": "1ci0nink9sqrx4317svaz0y22cargfvlqqsnzi9vylafh0a76yg5",
+        "rev": "712d0587b0c8d2958adf450bd2e1554f2b0ff258",
+        "sha256": "17ghrfgzwlz7hbapy4sq9wbckxqy4xmcj8jpqv68bng9s83zvvvn",
         "type": "tarball",
-        "url": "https://github.com/dfinity/motoko-base/archive/b772c9e49d94e725fcca64fc1c891ec1fb1baab3.tar.gz",
+        "url": "https://github.com/dfinity/motoko-base/archive/712d0587b0c8d2958adf450bd2e1554f2b0ff258.tar.gz",
         "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
     },
     "motoko-matchers": {
diff --git a/rts/cargo-vendor-tools/Cargo.toml b/rts/cargo-vendor-tools/Cargo.toml
index 7b63e2002cc..42163cd6d69 100644
--- a/rts/cargo-vendor-tools/Cargo.toml
+++ b/rts/cargo-vendor-tools/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "cargo-vendor-tools"
 version = "0.1.0"
-authors = ["dfinity <sdk@dfinity.org>"]
+authors = ["dfinity <team-motoko@dfinity.org>"]
 edition = "2018"
 
 [[bin]]
diff --git a/rts/motoko-rts-macros/Cargo.toml b/rts/motoko-rts-macros/Cargo.toml
index 6176f9a3a37..08e37be9cf5 100644
--- a/rts/motoko-rts-macros/Cargo.toml
+++ b/rts/motoko-rts-macros/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "motoko-rts-macros"
 version = "0.1.0"
-authors = ["dfinity <sdk@dfinity.org>"]
+authors = ["dfinity <team-motoko@dfinity.org>"]
 edition = "2018"
 
 [lib]
diff --git a/rts/motoko-rts-tests/Cargo.toml b/rts/motoko-rts-tests/Cargo.toml
index 3e28860e452..82558e9caf6 100644
--- a/rts/motoko-rts-tests/Cargo.toml
+++ b/rts/motoko-rts-tests/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "motoko-rts-tests"
 version = "0.1.0"
-authors = ["dfinity <sdk@dfinity.org"]
+authors = ["dfinity <team-motoko@dfinity.org"]
 edition = "2018"
 
 [dependencies]
diff --git a/rts/motoko-rts/Cargo.toml b/rts/motoko-rts/Cargo.toml
index d29a7d4c6ae..59350673ba4 100644
--- a/rts/motoko-rts/Cargo.toml
+++ b/rts/motoko-rts/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "motoko-rts"
 version = "0.1.0"
-authors = ["dfinity <sdk@dfinity.org>"]
+authors = ["dfinity <team-motoko@dfinity.org>"]
 edition = "2018"
 
 # For rlib use native/Cargo.toml
diff --git a/rts/motoko-rts/native/Cargo.toml b/rts/motoko-rts/native/Cargo.toml
index 5a31d3798f4..b78322947c7 100644
--- a/rts/motoko-rts/native/Cargo.toml
+++ b/rts/motoko-rts/native/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "motoko-rts"
 version = "0.1.0"
-authors = ["dfinity <sdk@dfinity.org>"]
+authors = ["dfinity <team-motoko@dfinity.org>"]
 edition = "2018"
 
 [lib]
diff --git a/rts/motoko-rts/src/bigint.rs b/rts/motoko-rts/src/bigint.rs
index ab17b0f155f..fcbb4e6a06b 100644
--- a/rts/motoko-rts/src/bigint.rs
+++ b/rts/motoko-rts/src/bigint.rs
@@ -40,6 +40,11 @@ use crate::types::{size_of, BigInt, Bytes, Value, TAG_BIGINT};
 
 use motoko_rts_macros::ic_mem_fn;
 
+// Provided by generated code
+extern "C" {
+    fn int_from_i32(value: i32) -> Value;
+}
+
 unsafe fn mp_alloc<M: Memory>(mem: &mut M, size: Bytes<u32>) -> *mut u8 {
     let ptr = mem.alloc_words(size_of::<BigInt>() + size.to_words());
     // NB. Cannot use as_bigint() here as header is not written yet
@@ -258,10 +263,11 @@ unsafe extern "C" fn bigint_of_int64(j: i64) -> Value {
 #[no_mangle]
 unsafe extern "C" fn bigint_of_float64(j: f64) -> Value {
     // handle fast path: some numbers (when rounded towards zero by `j as i32`)
-    // can be represented as `Int` without resorting to heap allocation, i.e.
+    // may be represented as `Int` without resorting to heap allocation, i.e.
     // in the range `-1073741824 == 0xc0000000 <= j as i32 <= 0x3fffffff == 1073741823`
     if j < 1073741824.0 && j > -1073741825.0 {
-        return Value::from_signed_scalar(j as i32);
+        // defer to generated code to create compact or boxed Int value
+        return int_from_i32(j as i32);
     }
     let mut i = tmp_bigint();
     check(mp_set_double(&mut i, j));
@@ -271,12 +277,9 @@ unsafe extern "C" fn bigint_of_float64(j: f64) -> Value {
 #[cfg(feature = "ic")]
 #[no_mangle]
 unsafe extern "C" fn bigint_to_float64(p: Value) -> f64 {
-    if p.is_scalar() {
-        p.get_signed_scalar() as f64
-    } else {
-        let mp_int = p.as_bigint().mp_int_ptr();
-        mp_get_double(mp_int)
-    }
+    debug_assert!(!p.is_scalar());
+    let mp_int = p.as_bigint().mp_int_ptr();
+    mp_get_double(mp_int)
 }
 
 #[no_mangle]
@@ -536,7 +539,7 @@ pub unsafe extern "C" fn bigint_leb128_decode_word64(
             if continuations == 4 {
                 break;
             }
-            return Value::from_signed_scalar(acc as i32);
+            return int_from_i32(acc as i32);
         }
         bits -= 8;
         mask <<= 7;
@@ -546,7 +549,7 @@ pub unsafe extern "C" fn bigint_leb128_decode_word64(
     let tentative = (acc as i32) << 1 >> 1; // top two bits must match
     if tentative as u64 == acc {
         // roundtrip is valid
-        return Value::from_signed_scalar(tentative);
+        return int_from_i32(tentative);
     }
 
     bigint_of_word64(acc)
@@ -605,7 +608,7 @@ pub unsafe extern "C" fn bigint_sleb128_decode_word64(
                 break;
             }
             let sext = 25 - 7 * continuations; // this many top bits will get a copy of the sign
-            return Value::from_signed_scalar((acc as i32) << sext >> sext);
+            return int_from_i32((acc as i32) << sext >> sext);
         }
         bits -= 8;
         mask <<= 7;
@@ -616,7 +619,7 @@ pub unsafe extern "C" fn bigint_sleb128_decode_word64(
     let tentative = (signed as i32) << 1 >> 1; // top two bits must match
     if tentative as i64 == signed {
         // roundtrip is valid
-        return Value::from_signed_scalar(tentative);
+        return int_from_i32(tentative);
     }
 
     bigint_of_int64(signed)
diff --git a/rts/motoko-rts/src/constants.rs b/rts/motoko-rts/src/constants.rs
index 9cdb1e428e5..327fe3f251c 100644
--- a/rts/motoko-rts/src/constants.rs
+++ b/rts/motoko-rts/src/constants.rs
@@ -3,6 +3,10 @@ use crate::types::{Bytes, Words};
 /// Wasm word size. RTS only works correctly on platforms with this word size.
 pub const WORD_SIZE: u32 = 4;
 
+/// Maximum Motoko array size 2^29 (inclusive)
+/// NB: Must agree with Arr.max_array_size in compile.ml.
+pub const MAX_ARRAY_SIZE: u32 = 1 << 29;
+
 /// Wasm page size (64 KiB) in bytes
 pub const WASM_PAGE_SIZE: Bytes<u32> = Bytes(64 * 1024);
 
diff --git a/rts/motoko-rts/src/memory.rs b/rts/motoko-rts/src/memory.rs
index 8f7929f362a..65ff5255b94 100644
--- a/rts/motoko-rts/src/memory.rs
+++ b/rts/motoko-rts/src/memory.rs
@@ -1,7 +1,7 @@
 #[cfg(feature = "ic")]
 pub mod ic;
 
-use crate::constants::WASM_HEAP_SIZE;
+use crate::constants::MAX_ARRAY_SIZE;
 use crate::rts_trap_with;
 use crate::types::*;
 
@@ -61,7 +61,7 @@ pub unsafe fn alloc_blob<M: Memory>(mem: &mut M, size: Bytes<u32>) -> Value {
 #[ic_mem_fn]
 pub unsafe fn alloc_array<M: Memory>(mem: &mut M, len: u32) -> Value {
     // Array payload should not be larger than half of the memory
-    if len > (WASM_HEAP_SIZE / 2).0 {
+    if len > MAX_ARRAY_SIZE {
         rts_trap_with("Array allocation too large");
     }
 
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 48affb4f0f4..976a909c6ad 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -30,6 +30,132 @@ let page_size = Int32.of_int (64*1024)
 let page_size64 = Int64.of_int32 page_size
 let page_size_bits = 16
 
+(* Our code depends on OCaml int having at least 32 bits *)
+let _ = assert (Sys.int_size >= 32)
+
+(* Scalar Tagging Scheme *)
+
+(* Rationale:
+   Scalar tags are variable length LSBs.
+   A tag (in binary) is either
+   * 10 for Int (leaving 30 bits payload)
+   * 01(0+)0 for unsigned, e.g 0100 for Nat64
+   * 11(0+)0 for signed,   e.g.1100 for Int64
+   Types must be distinguished by tag.
+   LSB must always be 0.
+   Decoding the type of scalar is easy using `ctz` to count the trailing zeros, then
+   switching on the MSB of the tag for sign (if any).
+   We use the *longest* tag that accommodates the required payload bits, to allow room
+   for any future tags that may require more payload bits,
+   e.g. 01(0^14) for Nat8, 11(0^14) for Int8
+   01(0^30) is used for the unit tag (the payload is a trivial zero-length bit string).
+*)
+
+module TaggingScheme = struct
+
+  (*
+     Enable for development only to sanity check value tags and
+     locate unexpected tag errors to compile.ml source lines.
+     Flags.sanity_check will check tags, but not further locate them.
+  *)
+
+  let debug = false (* should never be true in master! *)
+
+  type bit = I | O
+  let _ = (I,O) (* silence warning on unused constructors *)
+
+  type tag =
+    TBool
+  | TRef
+  | TNum
+  | TNat64 | TInt64
+  | TNat32 | TInt32
+  | TChar
+  | TNat8 | TInt8
+  | TNat16 | TInt16
+  | TUnit
+  | TUnused
+
+  (* Leverage OCaml pattern match compilation to check tagging scheme is injective *)
+  let _decode u32 =
+    match u32 with
+    | ((O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O)) -> TBool (* false *)
+    | ((O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,I)) -> TBool (* true *)
+    | ((_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,_,I,I)) -> TRef  (* 30 bit *)
+    | ((_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,_,I,O)) -> TNum   (* 30 bit *)
+    | ((_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,O,I,O,O)) -> TNat64 (* 28 bit *)
+    | ((_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,I,I,O,O)) -> TInt64
+    | ((_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,O,I,O,O,O)) -> TNat32 (* 27 bit *)
+    | ((_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,I,I,O,O,O)) -> TInt32
+    | ((_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,O,I,O), (O,O,O,O,O,O,O,O)) -> TChar
+    | ((_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (O,I,O,O,O,O,O,O), (O,O,O,O,O,O,O,O)) -> TNat16
+    | ((_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (I,I,O,O,O,O,O,O), (O,O,O,O,O,O,O,O)) -> TInt16
+    | ((_,_,_,_,_,_,_,_), (O,I,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O)) -> TNat8
+    | ((_,_,_,_,_,_,_,_), (I,I,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O)) -> TInt8
+    | ((O,I,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O)) -> TUnit
+    | _                                                                            -> TUnused
+
+  let tag_of_typ pty = Type.(
+    if !Flags.rtti then
+      match pty with
+      | Nat
+      | Int ->                                    0b10l
+      | Nat64 ->                                0b0100l
+      | Int64 ->                                0b1100l
+      | Nat32 ->                               0b01000l
+      | Int32 ->                               0b11000l
+      | Char  ->                        0b010_00000000l
+      | Nat16 ->                   0b01000000_00000000l
+      | Int16 ->                   0b11000000_00000000l
+      | Nat8  ->          0b01000000_00000000_00000000l
+      | Int8  ->          0b11000000_00000000_00000000l
+      | _  -> assert false
+    else
+      (* no tag *)
+      match pty with
+      | Nat
+      | Int
+      | Nat64
+      | Int64
+      | Nat32
+      | Int32
+      | Char
+      | Nat16
+      | Int16
+      | Nat8
+      | Int8 -> 0l
+      | _  -> assert false)
+
+  let unit_tag () =
+    if !Flags.rtti then
+      (* all tag, no payload (none needed) *)
+      0b01000000_00000000_00000000_00000000l
+    else
+      (* no tag *)
+      0l
+
+  (* Number of payload bits in compact representation, including any sign *)
+  let ubits_of pty = Type.(
+    if !Flags.rtti then
+      match pty with
+      | Nat   | Int   -> 30
+      | Nat64 | Int64 -> 28
+      | Nat32 | Int32 -> 27
+      | Char          -> 21 (* suffices for 21-bit UTF8 codepoints *)
+      | Nat16 | Int16 -> 16
+      | Nat8  | Int8  ->  8
+      | _ -> assert false
+   else
+      match pty with
+      | Nat   | Int   -> 31
+      | Nat64 | Int64 -> 31
+      | Nat32 | Int32 -> 31
+      | Char          -> 21 (* suffices for 21-bit UTF8 codepoints *)
+      | Nat16 | Int16 -> 16
+      | Nat8  | Int8  ->  8
+      | _ -> assert false)
+end
+
 (*
 Pointers are skewed (translated) -1 relative to the actual offset.
 See documentation of module BitTagged for more detail.
@@ -97,8 +223,8 @@ module Const = struct
     | Vanilla of int32 (* small words, no static data, already in vanilla format *)
     | BigInt of Big_int.big_int
     | Bool of bool
-    | Word32 of int32
-    | Word64 of int64
+    | Word32 of Type.prim * int32
+    | Word64 of Type.prim * int64
     | Float64 of Numerics.Float.t
     | Blob of string
     | Null
@@ -106,8 +232,8 @@ module Const = struct
   let lit_eq l1 l2 = match l1, l2 with
     | Vanilla i, Vanilla j -> i = j
     | BigInt i, BigInt j -> Big_int.eq_big_int i j
-    | Word32 i, Word32 j -> i = j
-    | Word64 i, Word64 j -> i = j
+    | Word32 (tyi, i), Word32 (tyj, j) -> tyi = tyj && i = j
+    | Word64 (tyi, i), Word64 (tyj, j) -> tyi = tyj && i = j
     | Float64 i, Float64 j -> i = j
     | Bool i, Bool j -> i = j
     | Blob s, Blob t -> s = t
@@ -173,8 +299,8 @@ module SR = struct
   type t =
     | Vanilla
     | UnboxedTuple of int
-    | UnboxedWord64
-    | UnboxedWord32
+    | UnboxedWord64 of Type.prim
+    | UnboxedWord32 of Type.prim
     | UnboxedFloat64
     | Unreachable
     | Const of Const.v
@@ -193,8 +319,8 @@ module SR = struct
 
   let to_var_type : t -> value_type = function
     | Vanilla -> I32Type
-    | UnboxedWord64 -> I64Type
-    | UnboxedWord32 -> I32Type
+    | UnboxedWord64 _ -> I64Type
+    | UnboxedWord32 _ -> I32Type
     | UnboxedFloat64 -> F64Type
     | UnboxedTuple n -> fatal "to_var_type: UnboxedTuple"
     | Const _ -> fatal "to_var_type: Const"
@@ -1455,11 +1581,24 @@ module BitTagged = struct
      tell it apart from a pointer by looking at the last bits: if set, it is a
      pointer.
 
-     Small here means -2^30 ≤ x < 2^30, and untagging needs to happen with an
-     _arithmetic_ right shift. This is the right thing to do for signed
-     numbers, and because we want to apply a consistent logic for all types,
-     especially as there is only one wasm type, we use the same range for
-     signed numbers as well.
+     Small here means:
+
+     * 0 ≤ x < 2^(ubits ty) for an unsigned type ty with (ubits ty) payload bits
+     * -2^sbits ≤ x < 2^sbits, for a signed type ty with (sbits ty) (= (ubits ty) - 1) payload bits
+       (i.e. excluding sign bit),
+     with the exception that compact Nat is regarded as signed to support subtyping.
+
+     Tagging needs to happen with a
+     * shift left by (32-ubits ty) for a signed or unsigned type ty; then
+     * a logical or of the (variable length) tag bits for ty.
+
+     Untagging needs to happen with an
+     * logical right shift (for unsigned type ty in Nat{8,16,32,64}, Char).
+     * _arithmetic_ right shift (for signed type ty Int{8,16,32,64}, Int but also Nat).
+       This is the right thing to do for signed numbers.
+       Nat is treated as signed to allow coercion-free subtyping.
+
+     The low bits 32 - (ubits ty) store the tag bits of the value.
 
      Boolean false is a non-pointer by construction.
      Boolean true (1) needs not be shifted as GC will not consider it.
@@ -1471,11 +1610,30 @@ module BitTagged = struct
        0b000: `false`
        0b001: `true`
 
-     Note that {Nat,Int}{8,16} do not need to be explicitly bit-tagged:
-     The bytes are stored in the _most_ significant byte(s) of the `i32`,
-     thus lowest two bits are always 0.
-     All arithmetic is implemented directly on that representation, see
-     module TaggedSmallWord.
+     Note that {Nat,Int}{8,16} and compact {Int,Nat}{32,64} and compact Int, Nat are explicitly tagged.
+     The bits are stored in the _most_ significant bits of the `i32`,
+     with the lower bits storing the variable length tag.
+
+     {Int,Nat}{32,64} are stored in signed and unsigned forms.
+
+     Compact {Int,Nat} are (both) stored in signed form to support coercion free subtyping of Nat < Int.
+     That means that one bit, the highest bit, of the compact Nat representation is unused and the
+     representable range for both compact Int and Nat values is -2^(sbits Int) ≤ x < 2^(sbits Int).
+
+     This describes the vanilla representation of small and compact scalars,
+     used as the uniform representation of values and when stored in heap structures.
+
+     See module TaggedSmallWord.
+
+     The stack representation of a small scalars, UnboxedWord32 {Int,Nat}{8,16},
+     on the other hand, always has all tag bits cleared, with the payload in the high bits of the word.
+
+     The stack representation of compact or unboxed scalars, UnboxedWord32 {Int,Nat}32 or
+     UnboxedWord64 {Int,Nat}64, on the other hand, is the natural (unpadded) machine representation.
+
+     All arithmetic is implemented directly on the stack (not vanilla) representation of scalars.
+     Proper tags bits are removed/added when loading from vanilla or storing to vanilla representation.
+
   *)
   let is_true_literal env =
     compile_eq_const 1l
@@ -1495,58 +1653,234 @@ module BitTagged = struct
     compile_bitand_const 0x1l ^^
     E.if_ env retty is2 is1
 
-  (* 64 bit numbers *)
+  let ubits_of pty = TaggingScheme.ubits_of pty
 
-  (* static *)
-  let can_tag_const (n : int64) =
-    let lower_bound = Int64.(neg (shift_left 1L 30)) in
-    let upper_bound = Int64.shift_left 1L 30 in
-    lower_bound <= n && n < upper_bound
+  let sbits_of pty = (ubits_of pty) - 1
 
-  let tag_const i = Int32.shift_left (Int64.to_int32 i) 1
+  (* 64 bit numbers *)
 
+  (* static *)
+  let can_tag_const pty (n : int64) = Type.(
+    match pty with
+    | Nat | Int | Int64 | Int32 ->
+      let sbits = sbits_of pty in
+      let lower_bound = Int64.(neg (shift_left 1L sbits)) in
+      let upper_bound = Int64.shift_left 1L sbits in
+      lower_bound <= n && n < upper_bound
+    | Nat64 | Nat32 ->
+      let ubits = ubits_of pty in
+      let upper_bound = Int64.shift_left 1L ubits in
+      0L <= n && n < upper_bound
+    | _ -> assert false)
+
+  let tag_const pty i = Type.(
+    match pty with
+    |  Nat | Int | Int64 | Int32
+    |  Nat64 | Nat32 ->
+      Int32.shift_left (Int64.to_int32 i) (32 - ubits_of pty)
+      (* tag *)
+      |> Int32.logor (TaggingScheme.tag_of_typ pty)
+    | _ -> assert false)
 
   (* dynamic *)
-  let if_can_tag_i64 env retty is1 is2 =
-    Func.share_code1 Func.Never env "can_tag_i64" ("x", I64Type) [I32Type] (fun env get_x ->
-      (* checks that all but the low 30 bits are either all 0 or all 1 *)
-      get_x ^^ compile_shl64_const 1L ^^
-      get_x ^^ G.i (Binary (Wasm.Values.I64 I32Op.Xor)) ^^
-      compile_shrU64_const 31L ^^
-      G.i (Test (Wasm.Values.I64 I64Op.Eqz))
-    ) ^^
-    E.if_ env retty is1 is2
-
-  let if_can_tag_u64 env retty is1 is2 =
-    compile_shrU64_const 30L ^^
-    G.i (Test (Wasm.Values.I64 I64Op.Eqz)) ^^
-    E.if_ env retty is1 is2
+  let sanity_check_can_tag_i64 env pty get_x =
+    if TaggingScheme.debug || !Flags.sanity then
+      get_x ^^
+      Func.share_code2 Func.Always env (prim_fun_name pty "check_can_tag_i64") (("res", I32Type), ("x", I64Type)) [I32Type]
+        (fun env get_res get_x -> Type.(
+          match pty with
+          | Nat | Int | Int64 | Int32 ->
+            let sbits = sbits_of pty in
+            let lower_bound = Int64.(neg (shift_left 1L sbits)) in
+            let upper_bound = Int64.shift_left 1L sbits in
+            (* lower_bound <= x < upper_bound *)
+            compile_const_64 lower_bound ^^
+            get_x ^^
+            G.i (Compare (Wasm.Values.I64 I32Op.LeS)) ^^
+            get_x ^^ compile_const_64 upper_bound ^^
+            G.i (Compare (Wasm.Values.I64 I32Op.LtS)) ^^
+            G.i (Binary (Wasm.Values.I32 I32Op.And))
+         | Nat64 | Nat32 ->
+            let ubits = ubits_of pty in
+            let upper_bound = Int64.shift_left 1L ubits in
+            (* 0 <= x < upper_bound *)
+            get_x ^^ compile_const_64 upper_bound ^^
+            G.i (Compare (Wasm.Values.I64 I32Op.LtU))
+         | _ ->
+            assert false) ^^
+         get_res ^^
+         G.i (Compare (Wasm.Values.I32 I32Op.Eq)) ^^
+         E.else_trap_with env (prim_fun_name pty "check_can_tag_i64") ^^
+         get_res)
+    else
+      G.nop
 
-  let tag =
+  let if_can_tag_i64 env pty retty is1 is2 = Type.(
+    match pty with
+    | Nat | Int | Int64 | Int32 ->
+      Func.share_code1 Func.Never env
+        (prim_fun_name pty "if_can_tag_i64") ("x", I64Type) [I32Type] (fun env get_x ->
+        (* checks that all but the low sbits are either all 0 or all 1 *)
+        get_x ^^
+        get_x ^^ compile_shrS64_const (Int64.of_int (64 - sbits_of pty)) ^^
+        G.i (Binary (Wasm.Values.I64 I32Op.Xor)) ^^
+        compile_shrU64_const (Int64.of_int (sbits_of pty)) ^^
+        G.i (Test (Wasm.Values.I64 I64Op.Eqz)) ^^
+        sanity_check_can_tag_i64 env pty get_x) ^^
+      E.if_ env retty is1 is2
+    | Nat64 | Nat32 ->
+      Func.share_code1 Func.Never env
+         (prim_fun_name pty "if_can_tag_i64") ("x", I64Type) [I32Type] (fun env get_x ->
+          (* checks that all but the low ubits are 0 *)
+          get_x ^^ compile_shrU64_const (Int64.of_int (ubits_of pty)) ^^
+          G.i (Test (Wasm.Values.I64 I32Op.Eqz)) ^^
+          sanity_check_can_tag_i64 env pty get_x) ^^
+      E.if_ env retty is1 is2
+     | _ -> assert false)
+
+  let if_can_tag_u64 env pty retty is1 is2 = Type.(
+    match pty with
+    |  Nat | Int | Int64 | Int32 ->
+      let sbitsL = Int64.of_int (sbits_of pty) in
+      compile_shrU64_const sbitsL ^^
+      G.i (Test (Wasm.Values.I64 I64Op.Eqz)) ^^
+      E.if_ env retty is1 is2
+    | Nat64 | Nat32 ->
+      let ubitsL = Int64.of_int (ubits_of pty) in
+      compile_shrU64_const ubitsL ^^
+      E.if_ env retty is2 is1 (* NB: swapped branches *)
+    | _ -> assert false)
+
+  let tag env pty = (* TBR *)
+    let ubitsl = Int32.of_int (ubits_of pty) in
     G.i (Convert (Wasm.Values.I32 I32Op.WrapI64)) ^^
-    compile_shl_const 1l
+    compile_shl_const (Int32.sub 32l ubitsl) ^^
+    (* tag *)
+    compile_bitor_const (TaggingScheme.tag_of_typ pty)
+
+  let sanity_check_tag line env ty =
+    if TaggingScheme.debug || !(Flags.sanity) then
+      let name =
+        (prim_fun_name ty "sanity_check_tag") ^
+          (if TaggingScheme.debug then Int.to_string line else "")
+      in
+      let tag_mask = Int32.(sub (shift_left 1l (32 - TaggingScheme.ubits_of ty)) one) in
+      (Func.share_code1 Func.Always env name ("v", I32Type) [I32Type] (fun env get_n ->
+         get_n ^^
+         compile_bitand_const tag_mask ^^
+         compile_eq_const (TaggingScheme.tag_of_typ ty) ^^
+         E.else_trap_with env "unexpected tag" ^^
+         get_n))
+    else G.nop
 
-  let untag env =
-    compile_shrS_const 1l ^^
-    G.i (Convert (Wasm.Values.I64 I64Op.ExtendSI32))
+  let untag line env pty = Type.(match pty with
+    | Nat | Int | Int64 | Int32 ->
+      let ubitsl = Int32.of_int (ubits_of pty) in
+      sanity_check_tag line env pty ^^
+      compile_shrS_const (Int32.sub 32l ubitsl) ^^
+      G.i (Convert (Wasm.Values.I64 I64Op.ExtendSI32))
+    | Nat64 | Nat32 ->
+      let ubitsl = Int32.of_int (ubits_of pty) in
+      sanity_check_tag line env pty ^^
+      compile_shrU_const (Int32.sub 32l ubitsl) ^^
+      G.i (Convert (Wasm.Values.I64 I64Op.ExtendUI32))
+    | _ -> assert false)
 
   (* 32 bit numbers, dynamic, w.r.t `Int` *)
 
-  let if_can_tag_i32 env retty is1 is2 =
-    Func.share_code1 Func.Never env "cannot_tag_i32" ("x", I32Type) [I32Type] (fun env get_x ->
-      (* checks that all but the low 30 bits are both either 0 or 1 *)
-      get_x ^^ compile_shrU_const 30l ^^
-      G.i (Unary (Wasm.Values.I32 I32Op.Popcnt)) ^^
-      G.i (Unary (Wasm.Values.I32 I32Op.Ctz))
-    ) ^^
-    E.if_ env retty is1 is2
-
-  let if_can_tag_u32 env retty is1 is2 =
-    compile_shrU_const 30l ^^
-    E.if_ env retty is2 is1 (* NB: swapped branches *)
+  let sanity_check_can_tag_i32 env pty get_x =
+    if TaggingScheme.debug || !Flags.sanity then
+      get_x ^^
+      Func.share_code2 Func.Always env (prim_fun_name pty "check_can_tag_i32") (("res", I32Type), ("x", I32Type)) [I32Type]
+        (fun env get_res get_x -> Type.(
+          match pty with
+          | Nat | Int | Int64 | Int32 ->
+            let sbits = sbits_of pty in
+            let lower_bound = Int32.(neg (shift_left 1l sbits)) in
+            let upper_bound = Int32.shift_left 1l sbits in
+            (* lower_bound <= x < upper_bound *)
+            compile_unboxed_const lower_bound ^^
+            get_x ^^
+            G.i (Compare (Wasm.Values.I32 I32Op.LeS)) ^^
+            get_x ^^ compile_unboxed_const upper_bound ^^
+            G.i (Compare (Wasm.Values.I32 I32Op.LtS)) ^^
+            G.i (Binary (Wasm.Values.I32 I32Op.And))
+         | Nat64 | Nat32 ->
+            let ubits = ubits_of pty in
+            let upper_bound = Int32.shift_left 1l ubits in
+            (* 0 <= x < upper_bound *)
+            get_x ^^ compile_unboxed_const upper_bound ^^
+            G.i (Compare (Wasm.Values.I32 I32Op.LtU))
+         | _ ->
+            assert false) ^^
+         get_res ^^
+         G.i (Compare (Wasm.Values.I32 I32Op.Eq)) ^^
+         E.else_trap_with env (prim_fun_name pty "check_can_tag_i32") ^^
+         get_res)
+    else
+      G.nop
 
-  let tag_i32 = compile_shl_const 1l
-  let untag_i32 = compile_shrS_const 1l
+  let if_can_tag_i32 env pty retty is1 is2 = Type.(match pty with
+    | Nat | Int | Int64 | Int32 ->
+      Func.share_code1 Func.Never env
+        (prim_fun_name pty "if_can_tag_i32") ("x", I32Type) [I32Type] (fun env get_x ->
+          (* checks that all but the low sbits are both either 0 or 1 *)
+          get_x ^^
+          get_x ^^ compile_shrS_const (Int32.of_int (32 - sbits_of pty)) ^^
+          G.i (Binary (Wasm.Values.I32 I32Op.Xor)) ^^
+          compile_shrU_const (Int32.of_int (sbits_of pty)) ^^
+          G.i (Test (Wasm.Values.I32 I32Op.Eqz)) ^^
+          sanity_check_can_tag_i32 env pty get_x)
+      ^^
+      E.if_ env retty is1 is2
+    | Nat64 | Nat32 ->
+       Func.share_code1 Func.Never env
+         (prim_fun_name pty "if_can_tag_i32") ("x", I32Type) [I32Type] (fun env get_x ->
+          (* checks that all but the low ubits are 0 *)
+          get_x ^^ compile_shrU_const (Int32.of_int (ubits_of pty)) ^^
+          G.i (Test (Wasm.Values.I32 I32Op.Eqz)) ^^
+          sanity_check_can_tag_i32 env pty get_x)
+      ^^
+      E.if_ env retty is1 is2
+    | _ -> assert false)
+
+  let if_can_tag_u32 env pty retty is1 is2 = Type.(
+    match pty with
+    | Nat | Int | Int64 | Int32 ->
+      let sbits = sbits_of pty in
+      compile_shrU_const (Int32.of_int sbits) ^^
+      E.if_ env retty is2 is1 (* NB: swapped branches *)
+    | Nat64 | Nat32 ->
+      let ubits = ubits_of pty in
+      compile_shrU_const (Int32.of_int ubits) ^^
+      E.if_ env retty is2 is1 (* NB: swapped branches *)
+    | _ -> assert false)
+
+  let tag_i32 env pty =
+    let ubits = ubits_of pty in
+    compile_shl_const (Int32.sub 32l (Int32.of_int ubits)) ^^
+    (* tag *)
+    compile_bitor_const (TaggingScheme.tag_of_typ pty)
+
+  let untag_i32 line env pty = Type.(match pty with
+    | Nat | Int | Int64 | Int32 ->
+      let ubits = ubits_of pty in
+      (* check tag *)
+      sanity_check_tag line env pty ^^
+      compile_shrS_const (Int32.sub 32l (Int32.of_int ubits))
+    | Nat64 | Nat32 ->
+      let ubits = ubits_of pty in
+      (* check tag *)
+      sanity_check_tag line env pty ^^
+      compile_shrU_const (Int32.sub 32l (Int32.of_int ubits))
+    | _ -> assert false)
+
+  let clear_tag env pty =
+    if TaggingScheme.tag_of_typ pty <> 0l then
+      let shift_amount = 32 - ubits_of pty in
+      let mask = Int32.(lognot (sub (shift_left one shift_amount) one)) in
+      compile_bitand_const mask
+    else G.nop
 
 end (* BitTagged *)
 
@@ -2061,35 +2395,41 @@ module BoxedWord64 = struct
      The object header includes the object tag (Bits64) and the forwarding pointer.
   *)
 
+  let heap_tag env pty = Tagged.Bits64
+
   let payload_field = Tagged.header_size
 
-  let compile_box env compile_elem : G.t =
+  let compile_box env pty compile_elem : G.t =
     let (set_i, get_i) = new_local env "boxed_i64" in
     let size = 4l in
-    Tagged.alloc env size Tagged.Bits64 ^^
+    Tagged.alloc env size (heap_tag env pty) ^^
     set_i ^^
     get_i ^^ compile_elem ^^ Tagged.store_field64 env payload_field ^^
     get_i ^^
     Tagged.allocation_barrier env
 
-  let lit env i =
-    if BitTagged.can_tag_const i
+  let lit env pty i =
+    if BitTagged.can_tag_const pty i
     then 
-      compile_unboxed_const (BitTagged.tag_const i)
+      compile_unboxed_const (BitTagged.tag_const pty i)
     else
-      compile_box env (compile_const_64 i)
-
-  let box env = Func.share_code1 Func.Never env "box_i64" ("n", I64Type) [I32Type] (fun env get_n ->
-      get_n ^^ BitTagged.if_can_tag_i64 env [I32Type]
-        (get_n ^^ BitTagged.tag)
-        (compile_box env get_n)
+      compile_box env pty (compile_const_64 i)
+
+  let box env pty = 
+    Func.share_code1 Func.Never env 
+      (prim_fun_name pty "box64") ("n", I64Type) [I32Type] (fun env get_n ->
+      get_n ^^ BitTagged.if_can_tag_i64 env pty [I32Type]
+        (get_n ^^ BitTagged.tag env pty)
+        (compile_box env pty get_n)
     )
 
-  let unbox env = Func.share_code1 Func.Never env "unbox_i64" ("n", I32Type) [I64Type] (fun env get_n ->
+  let unbox env pty =
+    Func.share_code1 Func.Never env
+      (prim_fun_name pty "unbox64") ("n", I32Type) [I64Type] (fun env get_n ->
       get_n ^^
       BitTagged.if_tagged_scalar env [I64Type]
-        ( get_n ^^ BitTagged.untag env)
-        ( get_n ^^ Tagged.load_forwarding_pointer env ^^ Tagged.load_field64 env payload_field)
+        (get_n ^^ BitTagged.untag __LINE__ env pty)
+        (get_n ^^ Tagged.load_forwarding_pointer env ^^ Tagged.load_field64 env payload_field)
     )
 end (* BoxedWord64 *)
 
@@ -2162,6 +2502,11 @@ module Word64 = struct
   let _compile_eq env = G.i (Compare (Wasm.Values.I64 I64Op.Eq))
   let compile_relop env i64op = G.i (Compare (Wasm.Values.I64 i64op))
 
+  let btst_kernel env =
+    let (set_b, get_b) = new_local64 env "b" in
+    set_b ^^ compile_const_64 1L ^^ get_b ^^ G.i (Binary (Wasm.Values.I64 I64Op.Shl)) ^^
+    G.i (Binary (Wasm.Values.I64 I64Op.And))
+
 end (* BoxedWord64 *)
 
 
@@ -2181,43 +2526,46 @@ module BoxedSmallWord = struct
 
   *)
 
+  let heap_tag env pty = Tagged.Bits32 (* TODO *)
+
   let payload_field = Tagged.header_size
 
-  let lit env i =
-    if BitTagged.can_tag_const (Int64.of_int (Int32.to_int i))
+  let lit env pty i =
+    if BitTagged.can_tag_const pty (Int64.of_int (Int32.to_int i))
     then
-      compile_unboxed_const (BitTagged.tag_const (Int64.of_int (Int32.to_int i)))
+      compile_unboxed_const (BitTagged.tag_const pty (Int64.of_int (Int32.to_int i)))
     else
-      Tagged.obj env Tagged.Bits32 [
+      Tagged.obj env (heap_tag env pty) [
         compile_unboxed_const i
       ]
 
-  let compile_box env compile_elem : G.t =
+  let compile_box env pty compile_elem : G.t =
     let (set_i, get_i) = new_local env "boxed_i32" in
     let size = 3l in
-    Tagged.alloc env size Tagged.Bits32 ^^
+    Tagged.alloc env size (heap_tag env pty) ^^
     set_i ^^
     get_i ^^ compile_elem ^^ Tagged.store_field env payload_field ^^
     get_i ^^
     Tagged.allocation_barrier env
 
-  let box env = Func.share_code1 Func.Never env "box_i32" ("n", I32Type) [I32Type] (fun env get_n ->
-      get_n ^^ compile_shrU_const 30l ^^
-      G.i (Unary (Wasm.Values.I32 I32Op.Popcnt)) ^^
-      G.i (Unary (Wasm.Values.I32 I32Op.Ctz)) ^^
-      G.if1 I32Type
-        (get_n ^^ BitTagged.tag_i32)
-        (compile_box env get_n)
+  let box env pty =
+    Func.share_code1 Func.Never env
+      (prim_fun_name pty "box") ("n", I32Type) [I32Type] (fun env get_n ->
+      get_n ^^ BitTagged.if_can_tag_i32 env pty [I32Type]
+        (get_n ^^ BitTagged.tag_i32 env pty)
+        (compile_box env pty get_n)
     )
 
-  let unbox env = Func.share_code1 Func.Never env "unbox_i32" ("n", I32Type) [I32Type] (fun env get_n ->
+  let unbox env pty =
+    Func.share_code1 Func.Never env
+      (prim_fun_name pty "unbox") ("n", I32Type) [I32Type] (fun env get_n ->
       get_n ^^
       BitTagged.if_tagged_scalar env [I32Type]
-        (get_n ^^ BitTagged.untag_i32)
+        (get_n ^^ BitTagged.untag_i32 __LINE__ env pty)
         (get_n ^^ Tagged.load_forwarding_pointer env ^^ Tagged.load_field env payload_field)
     )
 
-  let _lit env n = compile_unboxed_const n ^^ box env
+  let _lit env pty n = compile_unboxed_const n ^^ box env pty
 
 end (* BoxedSmallWord *)
 
@@ -2226,14 +2574,32 @@ module TaggedSmallWord = struct
      perspective, there are certain differences that are type based. This module
      provides helpers to abstract over those.
 
-     Caution: Some functions here are also used for Nat32/Int32, while others
+     Caution: Some functions here are also used for unboxed Nat32/Int32, while others
      are _only_ used for the small ones. Check call-sites!
   *)
 
-  let bits_of_type = function
-    | Type.(Int8|Nat8) -> 8
-    | Type.(Int16|Nat16) -> 16
-    | _ -> 32
+  let toNat = Type.(function
+    | Int8 | Nat8 -> Nat8
+    | Int16 | Nat16 -> Nat16
+    | Int32 | Nat32 -> Nat32
+    | _ -> assert false)
+
+  let bits_of_type = Type.(function
+    | Int8 | Nat8 -> 8
+    | Int16 | Nat16 -> 16
+    | Char -> 21
+    (* unboxed on stack *)
+    | Nat32 | Int32 -> 32
+    | _  -> assert false)
+
+  let tag_of_type pty = Type.(match pty with
+    | Int8 | Nat8
+    | Int16 | Nat16
+    | Char ->
+      TaggingScheme.tag_of_typ pty
+    (* unboxed on stack *)
+    | Int32 | Nat32 -> 0l
+    | _ -> assert false)
 
   let shift_of_type ty = Int32.of_int (32 - bits_of_type ty)
 
@@ -2260,13 +2626,13 @@ module TaggedSmallWord = struct
     | Type.(Int32|Nat32) -> G.nop
     | Type.(Nat8|Nat16) as ty -> compile_shrU_const (shift_of_type ty)
     | Type.(Int8|Int16) as ty -> compile_shrS_const (shift_of_type ty)
+    | Type.Char as ty -> compile_shrU_const (shift_of_type ty)
     | _ -> assert false
 
   (* Makes sure that the word payload (e.g. operation result) is in the MSB bits of the word. *)
   let msb_adjust = function
     | Type.(Int32|Nat32) -> G.nop
     | ty -> shift_leftWordNtoI32 (shift_of_type ty)
-
   (* Makes sure that the word representation invariant is restored. *)
   let sanitize_word_result = function
     | Type.(Nat32|Int32) -> G.nop
@@ -2296,15 +2662,16 @@ module TaggedSmallWord = struct
     in lsb_adjust ty ^^ set_b ^^ lsb_adjust ty ^^
        compile_unboxed_one ^^ get_b ^^ clamp_shift_amount ty ^^
        G.i (Binary (Wasm.Values.I32 I32Op.Shl)) ^^
-       G.i (Binary (Wasm.Values.I32 I32Op.And))
+       G.i (Binary (Wasm.Values.I32 I32Op.And)) ^^
+       msb_adjust ty
 
   (* Code points occupy 21 bits, so can always be tagged scalars *)
-  let untag_codepoint = compile_shrU_const 8l
-  let tag_codepoint = compile_shl_const 8l
+  let lsb_adjust_codepoint env = lsb_adjust Type.Char
+  let msb_adjust_codepoint = msb_adjust Type.Char
 
   (* Checks (n < 0xD800 || 0xE000 ≤ n ≤ 0x10FFFF),
      ensuring the codepoint range and the absence of surrogates. *)
-  let check_and_tag_codepoint env =
+  let check_and_msb_adjust_codepoint env =
     Func.share_code1 Func.Always env "Nat32->Char" ("n", I32Type) [I32Type] (fun env get_n ->
       get_n ^^ compile_unboxed_const 0xD800l ^^
       G.i (Compare (Wasm.Values.I32 I32Op.GeU)) ^^
@@ -2315,11 +2682,12 @@ module TaggedSmallWord = struct
       G.i (Compare (Wasm.Values.I32 I32Op.GtU)) ^^
       G.i (Binary (Wasm.Values.I32 I32Op.Or)) ^^
       E.then_trap_with env "codepoint out of range" ^^
-      get_n ^^ tag_codepoint
+      get_n ^^ msb_adjust_codepoint
     )
 
   let vanilla_lit ty v =
     Int32.(shift_left (of_int v) (to_int (shift_of_type ty)))
+    |> Int32.logor (tag_of_type ty)
 
   (* Wrapping implementation for multiplication and exponentiation. *)
 
@@ -2380,9 +2748,7 @@ module TaggedSmallWord = struct
         compile_unboxed_const 0l ^^
         G.i (Compare (Wasm.Values.I32 I32Op.GeS)) ^^
         E.else_trap_with env "negative power" ^^
-        get_n ^^ get_exp ^^ compile_nat_power env ty
-      )
-
+        get_n ^^ get_exp ^^ compile_nat_power env (toNat ty))
 
   (* To rotate, first rotate a copy by bits_of_type into the other direction *)
   let rotl env ty =
@@ -2405,6 +2771,23 @@ module TaggedSmallWord = struct
         sanitize_word_result ty
        )
 
+  let tag env pty =
+    match pty with
+    | Type.(Nat8 | Int8 | Nat16 | Int16 | Char) ->
+      (* TODO:  could sanity check low bits clear *)
+      (* add tag *)
+      compile_bitor_const (tag_of_type pty)
+    | _ -> assert false
+
+  let untag env pty =
+    match pty with
+    | Type.(Nat8 | Int8 | Nat16 | Int16 | Char) ->
+       (* check tag *)
+       BitTagged.sanity_check_tag __LINE__ env pty ^^
+       (* clear tag *)
+       BitTagged.clear_tag env pty
+    | _ -> assert false
+
 end (* TaggedSmallWord *)
 
 
@@ -2567,11 +2950,11 @@ sig
   val truncate_to_word64 : E.t -> G.t
 
   (* unsigned word to SR.Vanilla *)
-  val from_word30 : E.t -> G.t
   val from_word32 : E.t -> G.t
   val from_word64 : E.t -> G.t
 
   (* signed word to SR.Vanilla *)
+  val from_signed_word_compact : E.t -> G.t
   val from_signed_word32 : E.t -> G.t
   val from_signed_word64 : E.t -> G.t
 
@@ -2683,7 +3066,7 @@ end
 
 module MakeCompact (Num : BigNumType) : BigNumType = struct
 
-  (* Compact BigNums are a representation of signed 31-bit bignums (of the
+  (* Compact BigNums are a representation of signed BitTagged.ubit-bignums (of the
      underlying boxed representation `Num`), that fit into an i32 as per the
      BitTagged representation.
 
@@ -2715,24 +3098,36 @@ module MakeCompact (Num : BigNumType) : BigNumType = struct
 
   (* TODO: Does the result of the rem/mod fast path ever needs boxing? *)
 
-  (* examine the skewed pointer and determine if number fits into 31 bits *)
-  let fits_in_vanilla env = Num.fits_signed_bits env 31
+  (* examine the skewed pointer and determine if number fits into ubits *)
+  let fits_in_vanilla env = Num.fits_signed_bits env (BitTagged.ubits_of Type.Int)
+
+  let clear_tag env = BitTagged.clear_tag env Type.Int
 
   (* Tagged scalar to right-0-padded signed i64 *)
-  let extend64 = G.i (Convert (Wasm.Values.I64 I64Op.ExtendSI32))
+  let extend64 env =
+    BitTagged.sanity_check_tag __LINE__ env Type.Int ^^
+    (* clear tag *)
+    clear_tag env ^^
+    G.i (Convert (Wasm.Values.I64 I64Op.ExtendSI32))
 
   (* A variant of BitTagged.can_tag that works on right-0-tagged 64 bit numbers *)
   let if_can_tag_padded env retty is1 is2 =
-    compile_shrS64_const 1L ^^ BitTagged.if_can_tag_i64 env retty is1 is2
+    let ubitsL = Int64.of_int(BitTagged.ubits_of Type.Int) in
+    compile_shrS64_const (Int64.sub 32L ubitsL) ^^ BitTagged.if_can_tag_i64 env Type.Int retty is1 is2
 
   (* right-0-padded signed i64 to tagged scalar *)
-  let tag_padded = G.i (Convert (Wasm.Values.I32 I32Op.WrapI64))
+  let tag_padded =
+    G.i (Convert (Wasm.Values.I32 I32Op.WrapI64)) ^^
+    compile_bitor_const (TaggingScheme.tag_of_typ Type.Int)
+
 
   (* creates a boxed bignum from a right-0-padded signed i64 *)
-  let box64 env = compile_shrS64_const 1L ^^ Num.from_signed_word64 env
+  let box64 env =
+    let ubitsL = Int64.of_int(BitTagged.ubits_of Type.Int) in
+    compile_shrS64_const (Int64.sub 32L ubitsL) ^^ Num.from_signed_word64 env
 
   (* creates a boxed bignum from an right-0-padded signed i32 *)
-  let extend_and_box64 env = extend64 ^^ box64 env
+  let extend_and_box64 env = extend64 env ^^ box64 env
 
   (* check if both arguments are tagged scalars,
      if so, promote to right-0-padded, signed i64 and perform the fast path.
@@ -2748,8 +3143,8 @@ module MakeCompact (Num : BigNumType) : BigNumType = struct
         get_a ^^ get_b ^^
         BitTagged.if_both_tagged_scalar env [I32Type]
           begin
-            get_a ^^ extend64 ^^
-            get_b ^^ extend64 ^^
+            get_a ^^ extend64 env ^^
+            get_b ^^ extend64 env ^^
             fast env ^^ set_res64 ^^
             get_res64 ^^
             if_can_tag_padded env [I32Type]
@@ -2766,14 +3161,19 @@ module MakeCompact (Num : BigNumType) : BigNumType = struct
             slow env ^^ set_res ^^ get_res ^^
             fits_in_vanilla env ^^
             G.if1 I32Type
-              (get_res ^^ Num.truncate_to_word32 env ^^ BitTagged.tag_i32)
+              (get_res ^^ Num.truncate_to_word32 env ^^ BitTagged.tag_i32 env Type.Int)
               get_res
-          end)
+          end
+      )
 
   let compile_add = try_unbox2 "B_add" Word64.compile_add Num.compile_add
 
-  let adjust_arg2 code env = compile_shrS64_const 1L ^^ code env
-  let adjust_result code env = code env ^^ compile_shl64_const 1L
+  let adjust_arg2 code env =
+    compile_shrS64_const (Int64.of_int (32 - BitTagged.ubits_of Type.Int)) ^^
+    code env (* TBR *)
+  let adjust_result code env =
+    code env ^^
+    compile_shl64_const (Int64.of_int (32 - BitTagged.ubits_of Type.Int))
 
   let compile_mul = try_unbox2 "B_mul" (adjust_arg2 Word64.compile_mul) Num.compile_mul
   let compile_signed_sub = try_unbox2 "B+sub" Word64.compile_signed_sub Num.compile_signed_sub
@@ -2794,8 +3194,8 @@ module MakeCompact (Num : BigNumType) : BigNumType = struct
         let set_a64, get_a64 = new_local64 env "a64" in
         let set_b64, get_b64 = new_local64 env "b64" in
         (* Convert to plain Word64 *)
-        get_a ^^ extend64 ^^ compile_shrS64_const 1L ^^ set_a64 ^^
-        get_b ^^ extend64 ^^ compile_shrS64_const 1L ^^ set_b64 ^^
+        get_a ^^ extend64 env ^^ compile_shrS64_const (Int64.of_int (32 - BitTagged.ubits_of Type.Int)) ^^ set_a64 ^^
+        get_b ^^ extend64 env ^^ compile_shrS64_const (Int64.of_int (32 - BitTagged.ubits_of Type.Int)) ^^ set_b64 ^^
 
         (* estimate bitcount of result: `bits(a) * b <= 64` guarantees
            the absence of overflow in 64-bit arithmetic *)
@@ -2806,8 +3206,8 @@ module MakeCompact (Num : BigNumType) : BigNumType = struct
         G.if1 I32Type
           begin
             get_a64 ^^ get_b64 ^^ Word64.compile_unsigned_pow env ^^ set_res64 ^^
-            get_res64 ^^ BitTagged.if_can_tag_i64 env [I32Type]
-              (get_res64 ^^ BitTagged.tag)
+            get_res64 ^^ BitTagged.if_can_tag_i64 env Type.Int [I32Type]
+              (get_res64 ^^ BitTagged.tag env Type.Int)
               (get_res64 ^^ Num.from_word64 env)
           end
           begin
@@ -2816,7 +3216,7 @@ module MakeCompact (Num : BigNumType) : BigNumType = struct
             Num.compile_unsigned_pow env ^^ set_res ^^
             get_res ^^ fits_in_vanilla env ^^
             G.if1 I32Type
-              (get_res ^^ Num.truncate_to_word32 env ^^ BitTagged.tag_i32)
+              (get_res ^^ Num.truncate_to_word32 env ^^ BitTagged.tag_i32 env Type.Int)
               get_res
           end
       end
@@ -2830,7 +3230,7 @@ module MakeCompact (Num : BigNumType) : BigNumType = struct
         Num.compile_unsigned_pow env ^^ set_res ^^
         get_res ^^ fits_in_vanilla env ^^
         G.if1 I32Type
-          (get_res ^^ Num.truncate_to_word32 env ^^ BitTagged.tag_i32)
+          (get_res ^^ Num.truncate_to_word32 env ^^ BitTagged.tag_i32 env Type.Int)
           get_res
       end)
 
@@ -2856,7 +3256,7 @@ module MakeCompact (Num : BigNumType) : BigNumType = struct
       get_n ^^
       BitTagged.if_tagged_scalar env [I32Type]
         ( (* see Note [left shifting compact Nat] *)
-          get_n ^^
+          get_n ^^ clear_tag env ^^
           G.i (Convert (Wasm.Values.I64 I64Op.ExtendSI32)) ^^
           get_amount ^^
           G.i (Convert (Wasm.Values.I64 I64Op.ExtendUI32)) ^^
@@ -2872,8 +3272,9 @@ module MakeCompact (Num : BigNumType) : BigNumType = struct
           get_amount ^^ compile_rel_const I32Op.LeU 42l ^^
           G.i (Binary (Wasm.Values.I32 I32Op.And)) ^^
           G.if1 I32Type
-            get_res
-            (get_n ^^ compile_shrS_const 1l ^^ Num.from_word30 env ^^ get_amount ^^ Num.compile_lsh env)
+            (get_res ^^ compile_bitor_const (TaggingScheme.tag_of_typ Type.Int))
+            (get_n ^^ compile_shrS_const (Int32.of_int (32 - BitTagged.ubits_of Type.Int)) ^^
+             Num.from_signed_word_compact env ^^ get_amount ^^ Num.compile_lsh env)
         )
         (get_n ^^ get_amount ^^ Num.compile_lsh env))
 
@@ -2883,12 +3284,14 @@ module MakeCompact (Num : BigNumType) : BigNumType = struct
       get_n ^^
       BitTagged.if_tagged_scalar env [I32Type]
         begin
-          get_n ^^
+          get_n ^^ clear_tag env ^^
           get_amount ^^
           G.i (Binary (Wasm.Values.I32 I32Op.ShrU)) ^^
-          compile_bitand_const 0xFFFFFFFEl ^^
-          get_amount ^^ compile_rel_const I32Op.LeU 31l ^^
-          G.i (Binary (Wasm.Values.I32 I32Op.Mul)) (* branch-free `if` *)
+          compile_bitand_const Int32.(shift_left minus_one (32 - BitTagged.ubits_of Type.Int)) ^^
+          get_amount ^^ compile_rel_const I32Op.LeU (Int32.of_int (BitTagged.ubits_of Type.Int))^^
+          G.i (Binary (Wasm.Values.I32 I32Op.Mul)) (* branch-free `if` *) ^^
+          (* tag *)
+          compile_bitor_const (TaggingScheme.tag_of_typ Type.Int)
         end
         begin
           get_n ^^ get_amount ^^ Num.compile_rsh env ^^
@@ -2896,7 +3299,7 @@ module MakeCompact (Num : BigNumType) : BigNumType = struct
           set_res ^^ get_res ^^
           fits_in_vanilla env ^^
           G.if1 I32Type
-            (get_res ^^ Num.truncate_to_word32 env ^^ BitTagged.tag_i32)
+            (get_res ^^ Num.truncate_to_word32 env ^^ BitTagged.tag_i32 env Type.Int)
             get_res
         end)
 
@@ -2904,25 +3307,30 @@ module MakeCompact (Num : BigNumType) : BigNumType = struct
     let set_n, get_n = new_local env "n" in
     set_n ^^ get_n ^^
     BitTagged.if_tagged_scalar env [I32Type]
-      (get_n ^^ compile_unboxed_const 0l ^^ G.i (Compare (Wasm.Values.I32 I32Op.LtS)))
+      (get_n ^^ clear_tag env ^^ compile_unboxed_const 0l ^^ G.i (Compare (Wasm.Values.I32 I32Op.LtS)))
       (get_n ^^ Num.compile_is_negative env)
 
   let lit env = function
-    | n when Big_int.is_int_big_int n && BitTagged.can_tag_const (Big_int.int64_of_big_int n) ->
-      compile_unboxed_const (BitTagged.tag_const (Big_int.int64_of_big_int n))
+    | n when Big_int.is_int_big_int n && BitTagged.can_tag_const Type.Int (Big_int.int64_of_big_int n) ->
+      compile_unboxed_const (BitTagged.tag_const Type.Int (Big_int.int64_of_big_int n))
     | n -> Num.lit env n
 
   let compile_neg env =
+    let sminl = Int32.shift_left 1l (BitTagged.sbits_of Type.Int) in
+    let sminl_shifted = Int32.shift_left sminl (32 - BitTagged.ubits_of Type.Int) in
     Func.share_code1 Func.Always env "B_neg" ("n", I32Type) [I32Type] (fun env get_n ->
       get_n ^^ BitTagged.if_tagged_scalar env [I32Type]
         begin
-          get_n ^^ compile_eq_const 0x80000000l ^^ (* -2^30 shifted *)
+          get_n ^^ clear_tag env ^^ compile_eq_const sminl_shifted ^^ (* -2^sbits, shifted ubits *)
           G.if1 I32Type
-            (compile_unboxed_const 0x40000000l ^^ Num.from_word32 env)
+            (compile_unboxed_const sminl ^^ Num.from_word32 env)
             begin
               compile_unboxed_const 0l ^^
-              get_n ^^
-              G.i (Binary (Wasm.Values.I32 I32Op.Sub))
+              get_n ^^ clear_tag env ^^
+              G.i (Binary (Wasm.Values.I32 I32Op.Sub)) ^^
+              (* tag the result *)
+              clear_tag env ^^
+              compile_bitor_const (TaggingScheme.tag_of_typ Type.Int)
             end
         end
         (get_n ^^ Num.compile_neg env)
@@ -2934,8 +3342,8 @@ module MakeCompact (Num : BigNumType) : BigNumType = struct
         get_a ^^ get_b ^^
         BitTagged.if_both_tagged_scalar env [I32Type]
           begin
-            get_a ^^ extend64 ^^
-            get_b ^^ extend64 ^^
+            get_a ^^ extend64 env ^^
+            get_b ^^ extend64 env ^^
             fast env
           end
           begin
@@ -2985,51 +3393,85 @@ module MakeCompact (Num : BigNumType) : BigNumType = struct
     try_unbox I32Type (fun _ -> match n with
         | 32 | 64 -> G.i Drop ^^ Bool.lit true
         | 8 | 16 ->
-          compile_bitand_const Int32.(logor 1l (shift_left minus_one (n + 1))) ^^
+          (* use shifting to test that the payload including the tag fits the desired bit width. 
+              E.g. this is now n + 2 for Type.Int. *)
+          compile_bitand_const Int32.(shift_left minus_one (n + (32 - BitTagged.ubits_of Type.Int))) ^^
           G.i (Test (Wasm.Values.I32 I32Op.Eqz))
         | _ -> assert false
       )
       (fun env -> Num.fits_unsigned_bits env n)
       env
 
+  let sanity_check_fits_signed_bits env n get_a =
+     if TaggingScheme.debug || !Flags.sanity then
+     get_a ^^
+     Func.share_code2 Func.Always env ("check_fits_signed_bits_"^Int.to_string n) (("res", I32Type), ("a", I32Type)) [I32Type]
+      (fun env get_res get_a ->
+         let lower_bound = Int32.(neg (shift_left 1l (n-1))) in
+         let upper_bound = Int32.shift_left 1l (n-1) in
+         let set_a = G.setter_for get_a in
+         get_a ^^
+         compile_shrS_const (Int32.of_int (32 - BitTagged.ubits_of Type.Int)) ^^
+         set_a ^^
+         compile_unboxed_const lower_bound ^^
+         get_a ^^
+         G.i (Compare (Wasm.Values.I32 I32Op.LeS)) ^^
+         get_a ^^ compile_unboxed_const upper_bound ^^
+         G.i (Compare (Wasm.Values.I32 I32Op.LtS)) ^^
+         G.i (Binary (Wasm.Values.I32 I32Op.And)) ^^
+         get_res ^^
+         G.i (Compare (Wasm.Values.I32 I32Op.Eq)) ^^
+         E.else_trap_with env ("fit_signed_bits failure_"^Int.to_string n) ^^
+         get_res)
+     else G.nop
+
   let fits_signed_bits env n =
     let set_a, get_a = new_local env "a" in
     try_unbox I32Type (fun _ -> match n with
         | 32 | 64 -> G.i Drop ^^ Bool.lit true
         | 8 | 16 ->
+           (* check all bits beyond signed payload are all 0 or all 1 *)
            set_a ^^
            get_a ^^ get_a ^^ compile_shrS_const 1l ^^
            G.i (Binary (Wasm.Values.I32 I32Op.Xor)) ^^
            compile_bitand_const
-             Int32.(shift_left minus_one n) ^^
-           G.i (Test (Wasm.Values.I32 I32Op.Eqz))
+             Int32.(shift_left minus_one ((n-1) + (32 - BitTagged.ubits_of Type.Int))) ^^
+           G.i (Test (Wasm.Values.I32 I32Op.Eqz)) ^^
+           sanity_check_fits_signed_bits env n get_a
         | _ -> assert false
       )
       (fun env -> Num.fits_signed_bits env n)
       env
 
   let compile_abs env =
+    let sminl = Int32.shift_left 1l (BitTagged.sbits_of Type.Int) in
+    let sminl_shifted = Int32.shift_left sminl (32 - BitTagged.ubits_of Type.Int) in
     try_unbox I32Type
       begin
         fun _ ->
         let set_a, get_a = new_local env "a" in
+        clear_tag env ^^
         set_a ^^
         get_a ^^ compile_unboxed_const 0l ^^ G.i (Compare (Wasm.Values.I32 I32Op.LtS)) ^^
         G.if1 I32Type
           begin
             get_a ^^
-            (* -2^30 is small enough for compact representation, but 2^30 isn't *)
-            compile_eq_const 0x80000000l ^^ (* i.e. -2^30 shifted *)
+            (* -2^sbits is small enough for compact representation, but 2^sbits isn't *)
+            compile_eq_const sminl_shifted ^^ (* i.e. -2^sbits shifted *)
             G.if1 I32Type
-              (compile_unboxed_const 0x40000000l ^^ Num.from_word32 env)
+              (compile_unboxed_const sminl ^^ Num.from_word32 env)
               begin
                 (* absolute value works directly on shifted representation *)
                 compile_unboxed_const 0l ^^
                 get_a ^^
-                G.i (Binary (Wasm.Values.I32 I32Op.Sub))
+                G.i (Binary (Wasm.Values.I32 I32Op.Sub)) ^^
+                compile_bitor_const (TaggingScheme.tag_of_typ Type.Int)
               end
           end
-          get_a
+          begin
+            get_a ^^
+            compile_bitor_const (TaggingScheme.tag_of_typ Type.Int)
+          end
       end
       Num.compile_abs
       env
@@ -3065,7 +3507,7 @@ module MakeCompact (Num : BigNumType) : BigNumType = struct
     get_x ^^
     try_unbox I32Type
       (fun env ->
-        BitTagged.untag_i32 ^^ set_x ^^
+        BitTagged.untag_i32 __LINE__ env Type.Int ^^ set_x ^^
         I32Leb.compile_store_to_data_buf_unsigned env get_x get_buf
       )
       (fun env ->
@@ -3080,7 +3522,7 @@ module MakeCompact (Num : BigNumType) : BigNumType = struct
     get_x ^^
     try_unbox I32Type
       (fun env ->
-        BitTagged.untag_i32 ^^ set_x ^^
+        BitTagged.untag_i32 __LINE__ env Type.Int ^^ set_x ^^
         I32Leb.compile_store_to_data_buf_signed env get_x get_buf
       )
       (fun env ->
@@ -3092,7 +3534,7 @@ module MakeCompact (Num : BigNumType) : BigNumType = struct
     try_unbox I32Type
       (fun _ ->
         let set_x, get_x = new_local env "x" in
-        BitTagged.untag_i32 ^^ set_x ^^
+        BitTagged.untag_i32 __LINE__ env Type.Int ^^ set_x ^^
         I32Leb.compile_leb128_size get_x
       )
       (fun env -> Num.compile_data_size_unsigned env)
@@ -3102,7 +3544,7 @@ module MakeCompact (Num : BigNumType) : BigNumType = struct
     try_unbox I32Type
       (fun _ ->
         let set_x, get_x = new_local env "x" in
-        BitTagged.untag_i32 ^^ set_x ^^
+        BitTagged.untag_i32 __LINE__ env Type.Int ^^ set_x ^^
         I32Leb.compile_sleb128_size get_x
       )
       (fun env -> Num.compile_data_size_signed env)
@@ -3111,60 +3553,70 @@ module MakeCompact (Num : BigNumType) : BigNumType = struct
   let from_signed_word32 env =
     let set_a, get_a = new_local env "a" in
     set_a ^^
-    get_a ^^ BitTagged.if_can_tag_i32 env  [I32Type]
-      (get_a ^^ BitTagged.tag_i32)
+    get_a ^^ BitTagged.if_can_tag_i32 env Type.Int [I32Type]
+      (get_a ^^ BitTagged.tag_i32 env Type.Int)
       (get_a ^^ Num.from_signed_word32 env)
 
   let from_signed_word64 env =
     let set_a, get_a = new_local64 env "a" in
     set_a ^^
-    get_a ^^ BitTagged.if_can_tag_i64 env [I32Type]
-      (get_a ^^ BitTagged.tag)
+    get_a ^^ BitTagged.if_can_tag_i64 env Type.Int [I32Type]
+      (get_a ^^ BitTagged.tag env Type.Int)
       (get_a ^^ Num.from_signed_word64 env)
 
-  let from_word30 env =
-    compile_shl_const 1l
+  let from_signed_word_compact env =
+    begin
+      if TaggingScheme.debug || !(Flags.sanity)
+     then
+      let set_a, get_a = new_local env "a" in
+      set_a ^^
+      get_a ^^ BitTagged.if_can_tag_i32 env Type.Int [I32Type]
+        get_a
+        (E.trap_with env "from_signed_word_compact")
+      else G.nop
+    end ^^
+    BitTagged.tag_i32 env Type.Int
 
   let from_word32 env =
     let set_a, get_a = new_local env "a" in
     set_a ^^
-    get_a ^^ BitTagged.if_can_tag_u32 env [I32Type]
-      (get_a ^^ BitTagged.tag_i32)
+    get_a ^^ BitTagged.if_can_tag_u32 env Type.Int [I32Type]
+      (get_a ^^ BitTagged.tag_i32 env Type.Int)
       (get_a ^^ G.i (Convert (Wasm.Values.I64 I64Op.ExtendUI32)) ^^ Num.from_word64 env)
 
   let from_word64 env =
     let set_a, get_a = new_local64 env "a" in
     set_a ^^
-    get_a ^^ BitTagged.if_can_tag_u64 env [I32Type]
-      (get_a ^^ BitTagged.tag)
+    get_a ^^ BitTagged.if_can_tag_u64 env Type.Int [I32Type]
+      (get_a ^^ BitTagged.tag env Type.Int)
       (get_a ^^ Num.from_word64 env)
 
   let truncate_to_word64 env =
     let set_a, get_a = new_local env "a" in
     set_a ^^ get_a ^^
     BitTagged.if_tagged_scalar env [I64Type]
-      (get_a ^^ BitTagged.untag env)
+      (get_a ^^ BitTagged.untag __LINE__ env Type.Int)
       (get_a ^^ Num.truncate_to_word64 env)
 
   let truncate_to_word32 env =
     let set_a, get_a = new_local env "a" in
     set_a ^^ get_a ^^
     BitTagged.if_tagged_scalar env [I32Type]
-      (get_a ^^ BitTagged.untag_i32)
+      (get_a ^^ BitTagged.untag_i32 __LINE__ env Type.Int)
       (get_a ^^ Num.truncate_to_word32 env)
 
   let to_word64 env =
     let set_a, get_a = new_local env "a" in
     set_a ^^ get_a ^^
     BitTagged.if_tagged_scalar env [I64Type]
-      (get_a ^^ BitTagged.untag env)
+      (get_a ^^ BitTagged.untag __LINE__ env Type.Int)
       (get_a ^^ Num.to_word64 env)
 
   let to_word32 env =
     let set_a, get_a = new_local env "a" in
     set_a ^^ get_a ^^
     BitTagged.if_tagged_scalar env [I32Type]
-      (get_a ^^ BitTagged.untag_i32)
+      (get_a ^^ BitTagged.untag_i32 __LINE__ env Type.Int) (*TBR*)
       (get_a ^^ Num.to_word32 env)
 
   let to_word32_with env =
@@ -3173,7 +3625,7 @@ module MakeCompact (Num : BigNumType) : BigNumType = struct
     set_err_msg ^^ set_a ^^
     get_a ^^
     BitTagged.if_tagged_scalar env [I32Type]
-      (get_a ^^ BitTagged.untag_i32)
+      (get_a ^^ BitTagged.untag_i32 __LINE__ env Type.Int) (* TBR *)
       (get_a ^^ get_err_msg ^^ Num.to_word32_with env)
 end
 
@@ -3186,7 +3638,7 @@ module BigNumLibtommath : BigNumType = struct
   let truncate_to_word32 env = E.call_import env "rts" "bigint_to_word32_wrap"
   let truncate_to_word64 env = E.call_import env "rts" "bigint_to_word64_wrap"
 
-  let from_word30 env = E.call_import env "rts" "bigint_of_word32"
+  let from_signed_word_compact env = E.call_import env "rts" "bigint_of_int32"
   let from_word32 env = E.call_import env "rts" "bigint_of_word32"
   let from_word64 env = E.call_import env "rts" "bigint_of_word64"
   let from_signed_word32 env = E.call_import env "rts" "bigint_of_int32"
@@ -3828,7 +4280,7 @@ module Text = struct
       BigNum.from_word32 env
     )
   let prim_showChar env =
-    TaggedSmallWord.untag_codepoint ^^
+    TaggedSmallWord.lsb_adjust_codepoint env ^^
     E.call_import env "rts" "text_singleton"
   let to_blob env = E.call_import env "rts" "blob_of_text"
 
@@ -3848,7 +4300,7 @@ module Text = struct
     E.call_import env "rts" "text_iter_done"
   let iter_next env =
     E.call_import env "rts" "text_iter_next" ^^
-    TaggedSmallWord.tag_codepoint
+    TaggedSmallWord.msb_adjust_codepoint
 
   let compare env op =
     let open Operator in
@@ -3888,6 +4340,9 @@ module Arr = struct
      No difference between mutable and immutable arrays.
   *)
 
+  (* NB max_array_size must agree with limit 2^29 imposed by RTS constants.MAX_ARRAY_SIZE *)
+  let max_array_size = Int32.shift_left 1l 29 (* inclusive *)
+
   let header_size = Int32.add Tagged.header_size 1l
   let element_size = 4l
   let len_field = Int32.add Tagged.header_size 0l
@@ -4068,6 +4523,7 @@ module Arr = struct
         get_i ^^ G.i (Binary (Wasm.Values.I32 I32Op.Add)) ^^
         G.i (Load {ty = I32Type; align = 0; offset = 0l; sz = Some Wasm.Types.(Pack8, ZX)}) ^^
         TaggedSmallWord.msb_adjust Type.Nat8 ^^
+        TaggedSmallWord.tag env Type.Nat8 ^^
         store_ptr
       ) ^^
       get_r ^^
@@ -4107,8 +4563,8 @@ module Tuple = struct
 
   (* We represent the boxed empty tuple as the unboxed scalar 0, i.e. simply as
      number (but really anything is fine, we never look at this) *)
-  let unit_vanilla_lit = 0l
-  let compile_unit = compile_unboxed_const unit_vanilla_lit
+  let unit_vanilla_lit env = TaggingScheme.unit_tag ()  (* all tag, trivial payload *)
+  let compile_unit env = compile_unboxed_const (unit_vanilla_lit ())
 
   (* Expects on the stack the pointer to the array. *)
   let load_n env n =
@@ -4117,7 +4573,7 @@ module Tuple = struct
 
   (* Takes n elements of the stack and produces an argument tuple *)
   let from_stack env n =
-    if n = 0 then compile_unit
+    if n = 0 then compile_unit env
     else
       let name = Printf.sprintf "to_%i_tuple" n in
       let args = Lib.List.table n (fun i -> Printf.sprintf "arg%i" i, I32Type) in
@@ -4608,14 +5064,14 @@ module IC = struct
         get_code ^^ compile_unboxed_const const ^^
         G.i (Compare (Wasm.Values.I32 I32Op.Eq)) ^^
         G.if1 I32Type
-          (Variant.inject env tag Tuple.compile_unit)
+          (Variant.inject env tag (Tuple.compile_unit env))
           code)
         ["system_fatal", 1l;
          "system_transient", 2l;
          "destination_invalid", 3l;
          "canister_reject", 4l;
          "canister_error", 5l]
-        (Variant.inject env "future" (get_code ^^ BoxedSmallWord.box env)))
+        (Variant.inject env "future" (get_code ^^ BoxedSmallWord.box env Type.Nat32)))
 
   let error_message env =
     Func.share_code0 Func.Never env "error_message" [I32Type] (fun env ->
@@ -5419,6 +5875,22 @@ module RTS_Exports = struct
      of functioning or unused-but-trapping stable memory exports (as required)
    *)
   let system_exports env =
+
+    (* Value constructors *)
+
+    let int_from_i32_fi = E.add_fun env "int_from_i32" (
+      Func.of_body env ["v", I32Type] [I32Type] (fun env ->
+        let get_v = G.i (LocalGet (nr 0l)) in
+        get_v ^^ BigNum.from_signed_word32 env
+      )
+    ) in
+    E.add_export env (nr {
+      name = Lib.Utf8.decode "int_from_i32";
+      edesc = nr (FuncExport (nr int_from_i32_fi))
+    });
+
+    (* Traps *)
+
     let bigint_trap_fi = E.add_fun env "bigint_trap" (
       Func.of_body env [] [] (fun env ->
         E.trap_with env "bigint function error"
@@ -5441,7 +5913,7 @@ module RTS_Exports = struct
       edesc = nr (FuncExport (nr rts_trap_fi))
     });
 
-    (* Keep a memory reserve when in update or init state. 
+    (* Keep a memory reserve when in update or init state.
        This reserve can be used by queries, composite queries, and upgrades. *)
     let keep_memory_reserve_fi = E.add_fun env "keep_memory_reserve" (
       Func.of_body env [] [I32Type] (fun env ->
@@ -6298,20 +6770,20 @@ module MakeSerialization (Strm : Stream) = struct
         reserve env get_data_buf 8l ^^
         get_x ^^ Float.unbox env ^^
         G.i (Store {ty = F64Type; align = 0; offset = 0l; sz = None})
-      | Prim (Int64|Nat64) ->
+      | Prim ((Int64|Nat64) as pty) ->
         reserve env get_data_buf 8l ^^
-        get_x ^^ BoxedWord64.unbox env ^^
+        get_x ^^ BoxedWord64.unbox env pty ^^
         G.i (Store {ty = I64Type; align = 0; offset = 0l; sz = None})
-      | Prim (Int32|Nat32) ->
-        write_word_32 env get_data_buf (get_x ^^ BoxedSmallWord.unbox env)
+      | Prim ((Int32|Nat32) as ty) ->
+        write_word_32 env get_data_buf (get_x ^^ BoxedSmallWord.unbox env ty)
       | Prim Char ->
-        write_word_32 env get_data_buf (get_x ^^ TaggedSmallWord.untag_codepoint)
-      | Prim (Int16|Nat16) ->
+        write_word_32 env get_data_buf (get_x ^^ TaggedSmallWord.lsb_adjust_codepoint env)
+      | Prim ((Int16|Nat16) as ty) ->
         reserve env get_data_buf 2l ^^
-        get_x ^^ TaggedSmallWord.lsb_adjust Nat16 ^^
+        get_x ^^ TaggedSmallWord.lsb_adjust ty ^^
         G.i (Store {ty = I32Type; align = 0; offset = 0l; sz = Some Wasm.Types.Pack16})
-      | Prim (Int8|Nat8) ->
-        write_byte env get_data_buf (get_x ^^ TaggedSmallWord.lsb_adjust Nat8)
+      | Prim ((Int8|Nat8) as ty) ->
+        write_byte env get_data_buf (get_x ^^ TaggedSmallWord.lsb_adjust ty)
       | Prim Bool ->
         write_byte env get_data_buf get_x
       | Tup [] -> (* e(()) = null *)
@@ -6821,35 +7293,38 @@ module MakeSerialization (Strm : Stream) = struct
           ReadBuf.read_float64 env get_data_buf ^^
           Float.box env
         end
-      | Prim (Int64|Nat64) ->
+      | Prim ((Int64|Nat64) as pty) ->
         with_prim_typ t
         begin
           ReadBuf.read_word64 env get_data_buf ^^
-          BoxedWord64.box env
+          BoxedWord64.box env pty
         end
-      | Prim (Int32|Nat32) ->
+      | Prim ((Int32|Nat32) as pty) ->
         with_prim_typ t
         begin
           ReadBuf.read_word32 env get_data_buf ^^
-          BoxedSmallWord.box env
+          BoxedSmallWord.box env pty
         end
       | Prim Char ->
         with_prim_typ t
         begin
           ReadBuf.read_word32 env get_data_buf ^^
-          TaggedSmallWord.check_and_tag_codepoint env
+          TaggedSmallWord.check_and_msb_adjust_codepoint env ^^
+          TaggedSmallWord.tag env Char
         end
-      | Prim (Int16|Nat16) ->
+      | Prim ((Int16|Nat16) as ty) ->
         with_prim_typ t
         begin
           ReadBuf.read_word16 env get_data_buf ^^
-          TaggedSmallWord.msb_adjust Nat16
+          TaggedSmallWord.msb_adjust ty ^^
+          TaggedSmallWord.tag env ty
         end
-      | Prim (Int8|Nat8) ->
+      | Prim ((Int8|Nat8) as ty) ->
         with_prim_typ t
         begin
           ReadBuf.read_byte env get_data_buf ^^
-          TaggedSmallWord.msb_adjust Nat8
+          TaggedSmallWord.msb_adjust ty ^^
+          TaggedSmallWord.tag env ty
         end
       | Prim Bool ->
         with_prim_typ t
@@ -7818,7 +8293,7 @@ module Persistence = struct
     let load_old_field env field =
       if field.Type.typ = Type.(Opt Any) then
         (* A stable variable may have been promoted to type `Any`: Therefore, drop its former content. *)
-        Opt.inject env Tuple.compile_unit
+        Opt.inject env (Tuple.compile_unit env)
       else
         (load_stable_actor env ^^ Object.load_idx_raw env field.Type.lab) in
     let recover_field field = 
@@ -7892,9 +8367,9 @@ module StackRep = struct
     match normalize t with
     | Prim Bool -> SR.bool
     | Prim (Nat | Int) -> Vanilla
-    | Prim (Nat64 | Int64) -> UnboxedWord64
-    | Prim (Nat32 | Int32) -> UnboxedWord32
-    | Prim (Nat8 | Nat16 | Int8 | Int16 | Char) -> Vanilla
+    | Prim ((Nat64 | Int64) as pty) -> UnboxedWord64 pty
+    | Prim ((Nat32 | Int32) as pty) -> UnboxedWord32 pty
+    | Prim ((Nat8 | Nat16 | Int8 | Int16 | Char) as pty) -> UnboxedWord32 pty
     | Prim (Text | Blob | Principal) -> Vanilla
     | Prim Float -> UnboxedFloat64
     | Obj (Actor, _) -> Vanilla
@@ -7906,8 +8381,8 @@ module StackRep = struct
      For now, multi-value block returns are handled via FakeMultiVal. *)
   let to_block_type env = function
     | Vanilla -> [I32Type]
-    | UnboxedWord64 -> [I64Type]
-    | UnboxedWord32 -> [I32Type]
+    | UnboxedWord64 _ -> [I64Type]
+    | UnboxedWord32 _ -> [I32Type]
     | UnboxedFloat64 -> [F64Type]
     | UnboxedTuple n -> Lib.List.make n I32Type
     | Const _ -> []
@@ -7915,8 +8390,8 @@ module StackRep = struct
 
   let to_string = function
     | Vanilla -> "Vanilla"
-    | UnboxedWord64 -> "UnboxedWord64"
-    | UnboxedWord32 -> "UnboxedWord32"
+    | UnboxedWord64 pty -> prim_fun_name pty "UnboxedWord64"
+    | UnboxedWord32 pty -> prim_fun_name pty "UnboxedWord32"
     | UnboxedFloat64 -> "UnboxedFloat64"
     | UnboxedTuple n -> Printf.sprintf "UnboxedTuple %d" n
     | Unreachable -> "Unreachable"
@@ -7944,7 +8419,7 @@ module StackRep = struct
 
   let drop env (sr_in : t) =
     match sr_in with
-    | Vanilla | UnboxedWord64 | UnboxedWord32 | UnboxedFloat64 -> G.i Drop
+    | Vanilla | UnboxedWord64 _ | UnboxedWord32 _ | UnboxedFloat64 -> G.i Drop
     | UnboxedTuple n -> G.table n (fun _ -> G.i Drop)
     | Const _ | Unreachable -> G.nop
 
@@ -7954,13 +8429,13 @@ module StackRep = struct
     | Const.Lit (Const.Blob payload) -> Blob.lit env payload
     | Const.Lit (Const.Null) -> Opt.null_lit env
     | Const.Lit (Const.BigInt number) -> BigNum.lit env number
-    | Const.Lit (Const.Word32 number) -> BoxedSmallWord.lit env number
-    | Const.Lit (Const.Word64 number) -> BoxedWord64.lit env number
+    | Const.Lit (Const.Word32 (pty, number)) -> BoxedSmallWord.lit env pty number
+    | Const.Lit (Const.Word64 (pty, number)) -> BoxedWord64.lit env pty number
     | Const.Lit (Const.Float64 number) -> Float.lit env number
     | Const.Opt value -> Opt.inject env (materialize_constant env value)
     | Const.Fun (get_fi, _) -> Closure.alloc env (get_fi ())
     | Const.Message _ -> assert false
-    | Const.Unit -> Tuple.compile_unit
+    | Const.Unit -> Tuple.compile_unit env
     | Const.Tag (tag, value) -> Variant.inject env tag (materialize_constant env value)
     | Const.Array elements -> 
         let materialized_elements = List.map (materialize_constant env) elements in
@@ -7979,18 +8454,40 @@ module StackRep = struct
     | UnboxedTuple n, Vanilla -> Tuple.from_stack env n
     | Vanilla, UnboxedTuple n -> Tuple.to_stack env n
 
-    | UnboxedWord64, Vanilla -> BoxedWord64.box env
-    | Vanilla, UnboxedWord64 -> BoxedWord64.unbox env
-
-    | UnboxedWord32, Vanilla -> BoxedSmallWord.box env
-    | Vanilla, UnboxedWord32 -> BoxedSmallWord.unbox env
+    (* BoxedWord64 types *)
+    | UnboxedWord64 pty, Vanilla ->
+       assert Type.(pty = Nat64 || pty = Int64);
+       BoxedWord64.box env pty
+    | Vanilla, UnboxedWord64 pty ->
+       assert Type.(pty = Nat64 || pty = Int64);
+       BoxedWord64.unbox env pty
+
+    (* TaggedSmallWord types *)
+    | UnboxedWord32 (Type.(Int8 | Nat8 | Int16 | Nat16 | Char) as pty), Vanilla ->
+       TaggedSmallWord.tag env pty
+    | Vanilla, UnboxedWord32 (Type.(Nat8 | Int8 | Nat16 | Int16 | Char) as pty) ->
+       TaggedSmallWord.untag env pty
+
+    (* BoxedSmallWord types *)
+    | UnboxedWord32 pty, Vanilla ->
+       assert Type.(pty = Nat32 || pty = Int32);
+       BoxedSmallWord.box env pty
+    | Vanilla, UnboxedWord32 ((Type.Nat32 | Type.Int32) as pty) ->
+       assert Type.(pty = Nat32 || pty = Int32);
+       BoxedSmallWord.unbox env pty
 
     | UnboxedFloat64, Vanilla -> Float.box env
     | Vanilla, UnboxedFloat64 -> Float.unbox env
 
-    | Const value, Vanilla -> materialize_constant env value
-    | Const Const.Lit (Const.Word32 n), UnboxedWord32 -> compile_unboxed_const n
-    | Const Const.Lit (Const.Word64 n), UnboxedWord64 -> compile_const_64 n
+    | Const value, Vanilla -> 
+        materialize_constant env value
+    | Const Const.Lit (Const.Vanilla n), UnboxedWord32 ty ->
+        compile_unboxed_const n ^^
+        TaggedSmallWord.untag env ty
+    | Const Const.Lit (Const.Word32 (ty1, n)), UnboxedWord32 ty2 when ty1 = ty2 -> 
+        compile_unboxed_const n
+    | Const Const.Lit (Const.Word64 (ty1, n)), UnboxedWord64 ty2 when ty1 = ty2 -> 
+        compile_const_64 n
     | Const Const.Lit (Const.Float64 f), UnboxedFloat64 -> Float.compile_unboxed_const f
     | Const c, UnboxedTuple 0 -> G.nop
     | Const Const.Array cs, UnboxedTuple n ->
@@ -7999,7 +8496,7 @@ module StackRep = struct
     | _, _ ->
       Printf.eprintf "Unknown stack_rep conversion %s -> %s\n"
         (to_string sr_in) (to_string sr_out);
-      G.nop
+      assert false
 
 end (* StackRep *)
 
@@ -8363,7 +8860,7 @@ module FuncDec = struct
       (* reply early for a oneway *)
       (if control = Type.Returns
        then
-         Tuple.compile_unit ^^
+         Tuple.compile_unit env ^^
          Serialization.serialize env [] ^^
          IC.reply_with_data env
        else G.nop) ^^
@@ -8655,7 +9152,7 @@ module FuncDec = struct
       (closures_to_reply_reject_callbacks env ts [get_k; get_r; get_future])
       (fun get_cb_index ->
         get_cb_index ^^
-        BoxedSmallWord.box env ^^
+        BoxedSmallWord.box env Type.Nat32 ^^
         Serialization.serialize env Type.[Prim Nat32])
 
   let ic_call_one_shot env ts get_meth_pair get_arg add_cycles =
@@ -8725,7 +9222,7 @@ module FuncDec = struct
 
         (* Deserialize and look up continuation argument *)
         Serialization.deserialize env Type.[Prim Nat32] ^^
-        BoxedSmallWord.unbox env ^^
+        BoxedSmallWord.unbox env Type.Nat32 ^^
         ContinuationTable.peek_future env ^^
         set_closure ^^
         get_closure ^^
@@ -8754,7 +9251,7 @@ module FuncDec = struct
         (* To avoid more failing allocation, don't deserialize args nor serialize reply,
            i.e. don't even try to do this:
         Serialization.deserialize env [] ^^
-        Tuple.compile_unit ^^
+        Tuple.compile_unit env ^^
         Serialization.serialize env [] ^^
         *)
         (* Instead, just ignore the argument and
@@ -8941,8 +9438,9 @@ module AllocHow = struct
   let stackrep_of_type t =
     let open Type in
     match normalize t with
-    | Prim (Nat32 | Int32) -> SR.UnboxedWord32
-    | Prim (Nat64 | Int64) -> SR.UnboxedWord64
+    | Prim ((Nat32 | Int32 | Nat16 | Int16 | Nat8 | Int8 | Char) as pty) ->
+       SR.UnboxedWord32 pty
+    | Prim ((Nat64 | Int64) as pty) -> SR.UnboxedWord64 pty
     | Prim Float -> SR.UnboxedFloat64
     | _ -> SR.Vanilla
 
@@ -9053,11 +9551,12 @@ let const_lit_of_lit : Ir.lit -> Const.lit = function
   | Nat8Lit n     -> Const.Vanilla (TaggedSmallWord.vanilla_lit Type.Nat8 (Numerics.Nat8.to_int n))
   | Int16Lit n    -> Const.Vanilla (TaggedSmallWord.vanilla_lit Type.Int16 (Numerics.Int_16.to_int n))
   | Nat16Lit n    -> Const.Vanilla (TaggedSmallWord.vanilla_lit Type.Nat16 (Numerics.Nat16.to_int n))
-  | Int32Lit n    -> Const.Word32 (Big_int.int32_of_big_int (Numerics.Int_32.to_big_int n))
-  | Nat32Lit n    -> Const.Word32 (Big_int.int32_of_big_int (nat32_to_int32 (Numerics.Nat32.to_big_int n)))
-  | Int64Lit n    -> Const.Word64 (Big_int.int64_of_big_int (Numerics.Int_64.to_big_int n))
-  | Nat64Lit n    -> Const.Word64 (Big_int.int64_of_big_int (nat64_to_int64 (Numerics.Nat64.to_big_int n)))
-  | CharLit c     -> Const.Vanilla Int32.(shift_left (of_int c) 8)
+  | Int32Lit n    -> Const.Word32 (Type.Int32, (Big_int.int32_of_big_int (Numerics.Int_32.to_big_int n)))
+  | Nat32Lit n    -> Const.Word32 (Type.Nat32, (Big_int.int32_of_big_int (nat32_to_int32 (Numerics.Nat32.to_big_int n))))
+  | Int64Lit n    -> Const.Word64 (Type.Int64, (Big_int.int64_of_big_int (Numerics.Int_64.to_big_int n)))
+  | Nat64Lit n    -> Const.Word64 (Type.Nat64, (Big_int.int64_of_big_int (nat64_to_int64 (Numerics.Nat64.to_big_int n))))
+  | CharLit c     -> Const.Vanilla (TaggedSmallWord.vanilla_lit Type.Char c)
+
   | NullLit       -> Const.Null
   | TextLit t
   | BlobLit t     -> Const.Blob t
@@ -9087,7 +9586,7 @@ let compile_unop env t op =
     SR.Vanilla, SR.Vanilla,
     BigNum.compile_neg env
   | NegOp, Type.(Prim Int64) ->
-      SR.UnboxedWord64, SR.UnboxedWord64,
+      SR.UnboxedWord64 Type.Int64, SR.UnboxedWord64 Type.Int64,
       Func.share_code1 Func.Never env "neg_trap" ("n", I64Type) [I64Type] (fun env get_n ->
         get_n ^^
         compile_eq64_const 0x8000000000000000L ^^
@@ -9096,9 +9595,9 @@ let compile_unop env t op =
         get_n ^^
         G.i (Binary (Wasm.Values.I64 I64Op.Sub))
       )
-  | NegOp, Type.(Prim (Int8 | Int16 | Int32)) ->
+  | NegOp, Type.(Prim ((Int8 | Int16 | Int32) as p)) ->
     StackRep.of_type t, StackRep.of_type t,
-    Func.share_code1 Func.Never env "neg32_trap" ("n", I32Type) [I32Type] (fun env get_n ->
+    Func.share_code1 Func.Never env (prim_fun_name p "neg32_trap") ("n", I32Type) [I32Type] (fun env get_n ->
       get_n ^^
       compile_eq_const 0x80000000l ^^
       then_arithmetic_overflow env ^^
@@ -9109,8 +9608,8 @@ let compile_unop env t op =
   | NegOp, Type.(Prim Float) ->
     SR.UnboxedFloat64, SR.UnboxedFloat64,
     G.i (Unary (Wasm.Values.F64 F64Op.Neg))
-  | NotOp, Type.(Prim (Nat64|Int64)) ->
-     SR.UnboxedWord64, SR.UnboxedWord64,
+  | NotOp, Type.(Prim (Nat64|Int64 as p)) ->
+     SR.UnboxedWord64 p, SR.UnboxedWord64 p,
      compile_xor64_const (-1L)
   | NotOp, Type.(Prim (Nat8|Nat16|Nat32|Int8|Int16|Int32 as ty)) ->
      StackRep.of_type t, StackRep.of_type t,
@@ -9427,10 +9926,10 @@ let compile_binop env t op : SR.t * SR.t * G.t =
         get_a ^^ get_b ^^ G.i (Binary (Wasm.Values.I32 I32Op.DivS)) ^^
         TaggedSmallWord.msb_adjust ty ^^ set_res ^^
         get_a ^^ compile_eq_const 0x80000000l ^^
-        E.if_ env (StackRep.to_block_type env SR.UnboxedWord32)
+        E.if_ env (StackRep.to_block_type env (SR.UnboxedWord32 Type.Int32))
           begin
             get_b ^^ TaggedSmallWord.lsb_adjust ty ^^ compile_eq_const (-1l) ^^
-            E.if_ env (StackRep.to_block_type env SR.UnboxedWord32)
+            E.if_ env (StackRep.to_block_type env (SR.UnboxedWord32 ty))
               (G.i Unreachable)
               get_res
           end
@@ -9518,8 +10017,7 @@ let compile_binop env t op : SR.t * SR.t * G.t =
               end
               get_n (* n@{0,1} ** (1+exp) == n *)
           end
-          (compile_unboxed_const
-             Int32.(shift_left one (to_int (TaggedSmallWord.shift_of_type ty))))) (* x ** 0 == 1 *)
+          (compile_unboxed_one ^^ TaggedSmallWord.msb_adjust ty)) (* x ** 0 == 1 *)
   | Type.(Prim Int32),                        PowOp ->
     Func.share_code2 Func.Always env (prim_fun_name Type.Int32 "pow")
       (("n", I32Type), ("exp", I32Type)) [I32Type]
@@ -9866,24 +10364,28 @@ and compile_prim_invocation (env : E.t) ae p es at =
     SR.Vanilla,
     compile_array_index env ae e1 e2 ^^
     load_ptr
-  | NextArrayOffset spacing, [e] ->
-    let advance_by =
-      match spacing with
-      | ElementSize -> Arr.element_size
-      | One -> 2l (* 1 : Nat *) in
+  (* NB: all these operations assume a valid array offset fits in a compact bignum *)
+  | NextArrayOffset, [e] ->
+    let one_untagged = Int32.shift_left 1l (32 - BitTagged.ubits_of Type.Int) in
     SR.Vanilla,
     compile_exp_vanilla env ae e ^^ (* previous byte offset to array *)
-    compile_add_const advance_by
-  | ValidArrayOffset, [e1; e2] ->
+    compile_add_const one_untagged (* preserving the tag in low bits *)
+  | EqArrayOffset, [e1; e2] ->
     SR.bool,
     compile_exp_vanilla env ae e1 ^^
+    BitTagged.sanity_check_tag __LINE__ env Type.Int ^^
     compile_exp_vanilla env ae e2 ^^
-    G.i (Compare (Wasm.Values.I32 I32Op.LtU))
+    BitTagged.sanity_check_tag __LINE__ env Type.Int ^^
+    (* equate (without untagging) *)
+    G.i (Compare (Wasm.Values.I32 I32Op.Eq))
   | DerefArrayOffset, [e1; e2] ->
     SR.Vanilla,
+    (* NB: no bounds check on index *)
     compile_exp_vanilla env ae e1 ^^ (* skewed pointer to array *)
     Tagged.load_forwarding_pointer env ^^
     compile_exp_vanilla env ae e2 ^^ (* byte offset *)
+    BitTagged.untag_i32 __LINE__ env Type.Int ^^
+    compile_shl_const 2l ^^ (* effectively a multiplication by word_size *)
     (* Note: the below two lines compile to `i32.add; i32.load offset=OFFSET`
        with OFFSET = 13 with forwarding pointers and OFFSET = 9 without forwarding pointers,
        thus together also unskewing the pointer and skipping administrative
@@ -9891,15 +10393,13 @@ and compile_prim_invocation (env : E.t) ae p es at =
     G.i (Binary (Wasm.Values.I32 I32Op.Add)) ^^
     (* Not using Tagged.load_field since it is not a proper pointer to the array start *)
     Heap.load_field Arr.header_size (* loads the element at the byte offset *)
-  | GetPastArrayOffset spacing, [e] ->
-    let shift =
-      match spacing with
-      | ElementSize -> compile_shl_const 2l (* effectively a multiplication by word_size *)
-      | One -> BigNum.from_word30 env in    (* make it a compact bignum *)
+  | GetLastArrayOffset, [e] ->
+    assert (BitTagged.can_tag_const Type.Int (Int64.of_int32 (Int32.sub Arr.max_array_size 1l)));
     SR.Vanilla,
     compile_exp_vanilla env ae e ^^ (* array *)
     Arr.len env ^^
-    shift
+    compile_sub_const 1l ^^
+    BigNum.from_signed_word_compact env
 
   | BreakPrim name, [e] ->
     let d = VarEnv.get_label_depth ae name in
@@ -9921,30 +10421,33 @@ and compile_prim_invocation (env : E.t) ae p es at =
     let open Type in
     match t1, t2 with
     | (Nat|Int), (Nat8|Nat16|Int8|Int16) ->
-      SR.Vanilla,
+      SR.UnboxedWord32 t2, (* ! *)
       compile_exp_vanilla env ae e ^^
       Prim.prim_intToWordNShifted env (TaggedSmallWord.shift_of_type t2)
-
-    | (Nat|Int), (Nat32|Int32) ->
-      SR.UnboxedWord32,
+    | (Nat|Int), ((Nat32|Int32 as p)) ->
+      SR.UnboxedWord32 p,
       compile_exp_vanilla env ae e ^^
       Prim.prim_intToWord32 env
 
-    | (Nat|Int), (Nat64|Int64) ->
-      SR.UnboxedWord64,
+    | (Nat|Int), (Nat64|Int64 as p) ->
+      SR.UnboxedWord64 p,
       compile_exp_vanilla env ae e ^^
       BigNum.truncate_to_word64 env
 
-    | Nat64, Int64 | Int64, Nat64
-    | Nat32, Int32 | Int32, Nat32
+    | Nat64, Int64 | Int64, Nat64 ->
+      SR.UnboxedWord64 t2,
+      compile_exp_as env ae (SR.UnboxedWord64 t1) e
+    | Nat32, Int32 | Int32, Nat32 ->
+      SR.UnboxedWord32 t2,
+      compile_exp_as env ae (SR.UnboxedWord32 t1) e
     | Nat16, Int16 | Int16, Nat16
     | Nat8, Int8 | Int8, Nat8 ->
-      compile_exp env ae e
-
+      SR.UnboxedWord32 t2,
+      compile_exp_as env ae (SR.UnboxedWord32 t1) e
     | Char, Nat32 ->
-      SR.UnboxedWord32,
-      compile_exp_vanilla env ae e ^^
-      TaggedSmallWord.untag_codepoint
+      SR.UnboxedWord32 Nat32,
+      compile_exp_as env ae (SR.UnboxedWord32 t1) e ^^
+      TaggedSmallWord.lsb_adjust_codepoint env
 
     | _ -> SR.Unreachable, todo_trap env "compile_prim_invocation" (Arrange_ir.prim p)
     end
@@ -9954,7 +10457,7 @@ and compile_prim_invocation (env : E.t) ae p es at =
     match t1, t2 with
 
     | Int, Int64 ->
-      SR.UnboxedWord64,
+      SR.UnboxedWord64 Int64,
       compile_exp_vanilla env ae e ^^
       Func.share_code1 Func.Never env "Int->Int64" ("n", I32Type) [I64Type] (fun env get_n ->
         get_n ^^
@@ -9975,7 +10478,7 @@ and compile_prim_invocation (env : E.t) ae p es at =
         TaggedSmallWord.msb_adjust pty)
 
     | Nat, Nat64 ->
-      SR.UnboxedWord64,
+      SR.UnboxedWord64 Nat64,
       compile_exp_vanilla env ae e ^^
       Func.share_code1 Func.Never env "Nat->Nat64" ("n", I32Type) [I64Type] (fun env get_n ->
         get_n ^^
@@ -9997,38 +10500,38 @@ and compile_prim_invocation (env : E.t) ae p es at =
 
     | (Nat8|Nat16), Nat ->
       SR.Vanilla,
-      compile_exp_vanilla env ae e ^^
+      compile_exp_as env ae (SR.UnboxedWord32 t1) e ^^
       Prim.prim_shiftWordNtoUnsigned env (TaggedSmallWord.shift_of_type t1)
 
     | (Int8|Int16), Int ->
       SR.Vanilla,
-      compile_exp_vanilla env ae e ^^
+      compile_exp_as env ae (SR.UnboxedWord32 t1) e ^^
       Prim.prim_shiftWordNtoSigned env (TaggedSmallWord.shift_of_type t1)
 
     | Nat32, Nat ->
       SR.Vanilla,
-      compile_exp_as env ae SR.UnboxedWord32 e ^^
+      compile_exp_as env ae (SR.UnboxedWord32 Nat32) e ^^
       Prim.prim_word32toNat env
 
     | Int32, Int ->
       SR.Vanilla,
-      compile_exp_as env ae SR.UnboxedWord32 e ^^
+      compile_exp_as env ae (SR.UnboxedWord32 Int32) e ^^
       Prim.prim_word32toInt env
 
     | Nat64, Nat ->
       SR.Vanilla,
-      compile_exp_as env ae SR.UnboxedWord64 e ^^
+      compile_exp_as env ae (SR.UnboxedWord64 Nat64) e ^^
       BigNum.from_word64 env
 
     | Int64, Int ->
       SR.Vanilla,
-      compile_exp_as env ae SR.UnboxedWord64 e ^^
+      compile_exp_as env ae (SR.UnboxedWord64 Int64) e ^^
       BigNum.from_signed_word64 env
 
     | Nat32, Char ->
-      SR.Vanilla,
-      compile_exp_as env ae SR.UnboxedWord32 e ^^
-      TaggedSmallWord.check_and_tag_codepoint env
+      SR.UnboxedWord32 Type.Char, (* ! *)
+      compile_exp_as env ae (SR.UnboxedWord32 Nat32) e ^^
+      TaggedSmallWord.check_and_msb_adjust_codepoint env (* TBR *)
 
     | Float, Int ->
       SR.Vanilla,
@@ -10038,34 +10541,45 @@ and compile_prim_invocation (env : E.t) ae p es at =
     | Int, Float ->
       SR.UnboxedFloat64,
       compile_exp_vanilla env ae e ^^
-      E.call_import env "rts" "bigint_to_float64"
+      let set_b, get_b = new_local env "b" in
+      set_b ^^
+      get_b ^^
+      BitTagged.if_tagged_scalar env [F64Type]
+        (get_b ^^
+         BitTagged.untag_i32 __LINE__ env Type.Int ^^
+         G.i (Convert (Wasm.Values.I64 I64Op.ExtendSI32)) ^^
+         G.i (Convert (Wasm.Values.F64 F64Op.ConvertSI64)))
+        (get_b ^^
+         E.call_import env "rts" "bigint_to_float64")
 
     | Float, Int64 ->
-      SR.UnboxedWord64,
+      SR.UnboxedWord64 Int64,
       compile_exp_as env ae SR.UnboxedFloat64 e ^^
       G.i (Convert (Wasm.Values.I64 I64Op.TruncSF64))
 
     | Int64, Float ->
       SR.UnboxedFloat64,
-      compile_exp_as env ae SR.UnboxedWord64 e ^^
+      compile_exp_as env ae (SR.UnboxedWord64 Int64) e ^^
       G.i (Convert (Wasm.Values.F64 F64Op.ConvertSI64))
     | Nat8, Nat16 ->
-      SR.Vanilla,
-      compile_exp_vanilla env ae e ^^
-      compile_shrU_const 8l
+      SR.UnboxedWord32 Nat16,
+      compile_exp_as env ae (SR.UnboxedWord32 Nat8) e ^^
+      TaggedSmallWord.lsb_adjust Nat8 ^^
+      TaggedSmallWord.msb_adjust Nat16
     | Nat16, Nat32 ->
-      SR.Vanilla,
-      compile_exp_vanilla env ae e ^^
-      compile_shrU_const 15l (* resulting Nat32 will always be unboxed *)
+      SR.UnboxedWord32 Nat32,
+      compile_exp_as env ae (SR.UnboxedWord32 Nat16) e ^^
+      TaggedSmallWord.lsb_adjust Type.Nat16 ^^
+      TaggedSmallWord.msb_adjust Nat32 (* NB: a nop for 32-bit present, but not for 64-bit future *)
     | Nat32, Nat64 ->
-      SR.UnboxedWord64,
-      compile_exp_as env ae SR.UnboxedWord32 e ^^
+      SR.UnboxedWord64 Nat64,
+      compile_exp_as env ae (SR.UnboxedWord32 Nat32) e ^^
       G.i (Convert (Wasm.Values.I64 I64Op.ExtendUI32))
     | Nat16, (Nat8 as pty) ->
-      SR.Vanilla,
+      SR.UnboxedWord32 Nat8,
       let num_bits = (TaggedSmallWord.bits_of_type pty) in
       let set_val, get_val = new_local env "convertee" in
-      compile_exp_vanilla env ae e ^^
+      compile_exp_as env ae (SR.UnboxedWord32 Nat16) e ^^
       set_val ^^
       get_val ^^
       compile_shrU_const (Int32.of_int (32 - num_bits)) ^^
@@ -10073,10 +10587,10 @@ and compile_prim_invocation (env : E.t) ae p es at =
       get_val ^^
       compile_shl_const (Int32.of_int num_bits)
     | Nat32, (Nat16 as pty) ->
-      SR.Vanilla,
+      SR.UnboxedWord32 pty, (* ! *)
       let num_bits = Int32.of_int (TaggedSmallWord.bits_of_type pty) in
       let set_val, get_val = new_local env "convertee" in
-      compile_exp_as env ae SR.UnboxedWord32 e ^^
+      compile_exp_as env ae (SR.UnboxedWord32 Nat32) e ^^
       set_val ^^
       get_val ^^
       compile_shrU_const num_bits ^^
@@ -10084,10 +10598,10 @@ and compile_prim_invocation (env : E.t) ae p es at =
       get_val ^^
       compile_shl_const num_bits
     | Nat64, (Nat32 as pty) ->
-      SR.UnboxedWord32,
+      SR.UnboxedWord32 pty,
       let num_bits = Int64.of_int (TaggedSmallWord.bits_of_type pty) in
       let set_val, get_val = new_local64 env "convertee" in
-      compile_exp_as env ae SR.UnboxedWord64 e ^^
+      compile_exp_as env ae (SR.UnboxedWord64 Nat64) e ^^
       set_val ^^
       get_val ^^
       compile_shrU64_const num_bits ^^
@@ -10096,36 +10610,39 @@ and compile_prim_invocation (env : E.t) ae p es at =
       get_val ^^
       G.i (Convert (Wasm.Values.I32 I32Op.WrapI64))
     | Int8, Int16 ->
-      SR.Vanilla,
-      compile_exp_vanilla env ae e ^^
+      SR.UnboxedWord32 Int16,
+      compile_exp_as env ae (SR.UnboxedWord32 Int8) e ^^
+      (* Optimization of TaggedSmallWord.lsb_adjust Int8 ^^ TabbedSmallWord.msb_adjust Int16 *)
       compile_shrS_const 8l
+
     | Int16, Int32 ->
-      SR.Vanilla,
-      compile_exp_vanilla env ae e ^^
-      compile_shrS_const 15l (* resulting Int32 will always be unboxed *)
+      SR.UnboxedWord32 Int32,
+      compile_exp_as env ae (SR.UnboxedWord32 Int16) e ^^
+      (* Optimization of TaggedSmallWord.lsb_adjust Int16 ^^ TabbedSmallWord.msb_adjust Int32 *)
+      compile_shrS_const 16l
     | Int32, Int64 ->
-      SR.UnboxedWord64,
-      compile_exp_as env ae SR.UnboxedWord32 e ^^
+      SR.UnboxedWord64 Int64,
+      compile_exp_as env ae (SR.UnboxedWord32 Int32) e ^^
       G.i (Convert (Wasm.Values.I64 I64Op.ExtendSI32))
     | Int16, (Int8 as pty) ->
-      SR.Vanilla,
+      SR.UnboxedWord32 Int8,
       let num_bits = (TaggedSmallWord.bits_of_type pty) in
       let set_val, get_val = new_local env "convertee" in
-      compile_exp_vanilla env ae e ^^
+      compile_exp_as env ae (SR.UnboxedWord32 Int16)  e ^^
       set_val ^^
       get_val ^^
       compile_shl_const (Int32.of_int num_bits) ^^
       compile_shrS_const (Int32.of_int num_bits) ^^
       get_val ^^
-      compile_eq env Type.(Prim Nat16) ^^
+      compile_eq env Type.(Prim Int16) ^^
       E.else_trap_with env "losing precision" ^^
       get_val ^^
       compile_shl_const (Int32.of_int num_bits)
     | Int32, (Int16 as pty) ->
-      SR.Vanilla,
+      SR.UnboxedWord32 Int16, (*!*)
       let num_bits = (TaggedSmallWord.bits_of_type pty) in
       let set_val, get_val = new_local env "convertee" in
-      compile_exp_as env ae SR.UnboxedWord32 e ^^
+      compile_exp_as env ae (SR.UnboxedWord32 Int32) e ^^
       set_val ^^
       get_val ^^
       compile_shl_const (Int32.of_int num_bits) ^^
@@ -10136,10 +10653,10 @@ and compile_prim_invocation (env : E.t) ae p es at =
       get_val ^^
       compile_shl_const (Int32.of_int num_bits)
     | Int64, (Int32 as pty) ->
-      SR.UnboxedWord32,
+      SR.UnboxedWord32 pty,
       let num_bits = (TaggedSmallWord.bits_of_type pty) in
       let set_val, get_val = new_local64 env "convertee" in
-      compile_exp_as env ae SR.UnboxedWord64 e ^^
+      compile_exp_as env ae (SR.UnboxedWord64 Int64) e ^^
       set_val ^^
       get_val ^^
       compile_shl64_const (Int64.of_int num_bits) ^^
@@ -10172,7 +10689,7 @@ and compile_prim_invocation (env : E.t) ae p es at =
     begin match ts with
     | [] ->
       (* return some () *)
-      Opt.inject env Tuple.compile_unit
+      Opt.inject env (Tuple.compile_unit env)
     | [t] ->
       (* save to local, propagate error as null or return some value *)
       let (set_val, get_val) = new_local env "val" in
@@ -10209,7 +10726,7 @@ and compile_prim_invocation (env : E.t) ae p es at =
     GC.collect_garbage env
 
   | ICStableSize t, [e] ->
-    SR.UnboxedWord64,
+    SR.UnboxedWord64 Type.Nat64,
     let (tydesc, _, _) = Serialization.(type_desc env Candid [t]) in
     let tydesc_len = Int32.of_int (String.length tydesc) in
     compile_exp_vanilla env ae e ^^
@@ -10224,7 +10741,7 @@ and compile_prim_invocation (env : E.t) ae p es at =
     SR.Vanilla,
     compile_exp_vanilla env ae e ^^
     Arr.len env ^^
-    BigNum.from_word30 env
+    BigNum.from_word32 env
 
   | OtherPrim "text_len", [e] ->
     SR.Vanilla, compile_exp_vanilla env ae e ^^ Text.len_nat env
@@ -10233,9 +10750,9 @@ and compile_prim_invocation (env : E.t) ae p es at =
   | OtherPrim "text_iter_done", [e] ->
     SR.bool, compile_exp_vanilla env ae e ^^ Text.iter_done env
   | OtherPrim "text_iter_next", [e] ->
-    SR.Vanilla, compile_exp_vanilla env ae e ^^ Text.iter_next env
+    SR.UnboxedWord32 Type.Char, compile_exp_vanilla env ae e ^^ Text.iter_next env
   | OtherPrim "text_compare", [e1; e2] ->
-    SR.Vanilla,
+    SR.UnboxedWord32 Type.Int8,
     compile_exp_vanilla env ae e1 ^^
     compile_exp_vanilla env ae e2 ^^
     E.call_import env "rts" "text_compare" ^^
@@ -10253,18 +10770,19 @@ and compile_prim_invocation (env : E.t) ae p es at =
   | OtherPrim "blob_iter_done", [e] ->
     SR.bool, compile_exp_vanilla env ae e ^^ Blob.iter_done env
   | OtherPrim "blob_iter_next", [e] ->
-    SR.Vanilla, compile_exp_vanilla env ae e ^^ Blob.iter_next env
+    SR.UnboxedWord32 Type.Nat8, (* ! *)
+    compile_exp_vanilla env ae e ^^ Blob.iter_next env
 
   | OtherPrim "lsh_Nat", [e1; e2] ->
     SR.Vanilla,
     compile_exp_vanilla env ae e1 ^^
-    compile_exp_as env ae SR.UnboxedWord32 e2 ^^
+    compile_exp_as env ae (SR.UnboxedWord32 Type.Nat32) e2 ^^
     BigNum.compile_lsh env
 
   | OtherPrim "rsh_Nat", [e1; e2] ->
     SR.Vanilla,
     compile_exp_vanilla env ae e1 ^^
-    compile_exp_as env ae SR.UnboxedWord32 e2 ^^
+    compile_exp_as env ae (SR.UnboxedWord32 Type.Nat32) e2 ^^
     BigNum.compile_rsh env
 
   | OtherPrim "abs", [e] ->
@@ -10383,11 +10901,11 @@ and compile_prim_invocation (env : E.t) ae p es at =
   (* Other prims, nullary *)
 
   | SystemTimePrim, [] ->
-    SR.UnboxedWord64,
+    SR.UnboxedWord64 Type.Nat64,
     IC.get_system_time env
 
   | OtherPrim "call_perform_status", [] ->
-    SR.UnboxedWord32,
+    SR.UnboxedWord32 Type.Nat32,
     IC.get_call_perform_status env
 
   | OtherPrim "call_perform_message", [] ->
@@ -10463,20 +10981,20 @@ and compile_prim_invocation (env : E.t) ae p es at =
      BigNum.from_word64 env
 
   | OtherPrim ("regionGrow"), [e0; e1] ->
-    SR.UnboxedWord64,
+    SR.UnboxedWord64 Type.Nat64,
     compile_exp_as env ae SR.Vanilla e0 ^^
-    compile_exp_as env ae SR.UnboxedWord64 e1 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
     Region.grow env
 
   | OtherPrim "regionSize", [e0] ->
-    SR.UnboxedWord64,
+    SR.UnboxedWord64 Type.Nat64,
     compile_exp_as env ae SR.Vanilla e0 ^^
     Region.size env
 
   | OtherPrim ("regionLoadBlob"), [e0; e1; e2] ->
     SR.Vanilla,
     compile_exp_as env ae SR.Vanilla e0 ^^
-    compile_exp_as env ae SR.UnboxedWord64 e1 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
     compile_exp_as env ae SR.Vanilla e2 ^^
     Blob.lit env "Blob size out of bounds" ^^
     BigNum.to_word32_with env ^^
@@ -10485,84 +11003,91 @@ and compile_prim_invocation (env : E.t) ae p es at =
   | OtherPrim ("regionStoreBlob"), [e0; e1; e2] ->
     SR.unit,
     compile_exp_as env ae SR.Vanilla e0 ^^
-    compile_exp_as env ae SR.UnboxedWord64 e1 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
     compile_exp_as env ae SR.Vanilla e2 ^^
     Region.store_blob env
 
   | OtherPrim (("regionLoadNat8" | "regionLoadInt8" as p)), [e0; e1] ->
-    SR.Vanilla,
+    let ty = Type.(if p = "regionLoadNat8" then Nat8 else Int8) in
+    SR.UnboxedWord32 ty,
     compile_exp_as env ae SR.Vanilla e0 ^^
-    compile_exp_as env ae SR.UnboxedWord64 e1 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
     Region.load_word8 env ^^
-    TaggedSmallWord.msb_adjust Type.(if p = "regionLoadNat8" then Nat8 else Int8)
+    TaggedSmallWord.msb_adjust ty
 
   | OtherPrim (("regionStoreNat8" | "regionStoreInt8") as p), [e0; e1; e2] ->
+    let ty = Type.(if p = "regionStoreNat8" then Nat8 else Int8) in
     SR.unit,
     compile_exp_as env ae SR.Vanilla e0 ^^
-    compile_exp_as env ae SR.UnboxedWord64 e1 ^^
-    compile_exp_as env ae SR.Vanilla e2 ^^
-    TaggedSmallWord.lsb_adjust Type.(if p = "regionStoreNat8" then Nat8 else Int8) ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
+    compile_exp_as env ae (SR.UnboxedWord32 ty) e2 ^^
+    TaggedSmallWord.lsb_adjust ty ^^
     Region.store_word8 env
 
   | OtherPrim (("regionLoadNat16" | "regionLoadInt16") as p), [e0; e1] ->
-    SR.Vanilla,
+    let ty = Type.(if p = "regionLoadNat16" then Nat16 else Int16) in
+    SR.UnboxedWord32 ty,
     compile_exp_as env ae SR.Vanilla e0 ^^
-    compile_exp_as env ae SR.UnboxedWord64 e1 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
     Region.load_word16 env ^^
-    TaggedSmallWord.msb_adjust Type.(if p = "regionLoadNat16" then Nat16 else Int16)
+    TaggedSmallWord.msb_adjust ty
 
   | OtherPrim (("regionStoreNat16" | "regionStoreInt16") as p), [e0; e1; e2] ->
     SR.unit,
+    let ty = Type.(if p = "regionStoreNat16" then Nat16 else Int16) in
     compile_exp_as env ae SR.Vanilla e0 ^^
-    compile_exp_as env ae SR.UnboxedWord64 e1 ^^
-    compile_exp_as env ae SR.Vanilla e2 ^^
-    TaggedSmallWord.lsb_adjust Type.(if p = "regionStoreNat16" then Nat16 else Int16) ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
+    compile_exp_as env ae (SR.UnboxedWord32 ty) e2 ^^
+    TaggedSmallWord.lsb_adjust ty ^^
     Region.store_word16 env
 
-  | OtherPrim ("regionLoadNat32" | "regionLoadInt32"), [e0; e1] ->
-    SR.UnboxedWord32,
+  | OtherPrim (("regionLoadNat32" | "regionLoadInt32") as p), [e0; e1] ->
+    SR.UnboxedWord32 Type.(if p = "regionLoadNat32" then Nat32 else Int32),
     compile_exp_as env ae SR.Vanilla e0 ^^
-    compile_exp_as env ae SR.UnboxedWord64 e1 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
     Region.load_word32 env
 
-  | OtherPrim ("regionStoreNat32" | "regionStoreInt32"), [e0; e1; e2] ->
+  | OtherPrim (("regionStoreNat32" | "regionStoreInt32") as p), [e0; e1; e2] ->
     SR.unit,
     compile_exp_as env ae SR.Vanilla e0 ^^
-    compile_exp_as env ae SR.UnboxedWord64 e1 ^^
-    compile_exp_as env ae SR.UnboxedWord32 e2 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
+    compile_exp_as env ae
+      (SR.UnboxedWord32 Type.(if p = "regionStoreNat32" then Nat32 else Int32)) e2 ^^
     Region.store_word32 env
 
-  | OtherPrim ("regionLoadNat64" | "regionLoadInt64"), [e0; e1] ->
-    SR.UnboxedWord64,
+  | OtherPrim (("regionLoadNat64" | "regionLoadInt64") as p), [e0; e1] ->
+    (SR.UnboxedWord64 Type.(if p = "regionLoadNat64" then Nat64 else Int64)),
     compile_exp_as env ae SR.Vanilla e0 ^^
-    compile_exp_as env ae SR.UnboxedWord64 e1 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
     Region.load_word64 env
 
-  | OtherPrim ("regionStoreNat64" | "regionStoreInt64"), [e0; e1; e2] ->
+  | OtherPrim (("regionStoreNat64" | "regionStoreInt64") as p), [e0; e1; e2] ->
     SR.unit,
     compile_exp_as env ae SR.Vanilla e0 ^^
-    compile_exp_as env ae SR.UnboxedWord64 e1 ^^
-    compile_exp_as env ae SR.UnboxedWord64 e2 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
+    compile_exp_as env ae
+      (SR.UnboxedWord64 Type.(if p = "regionStoreNat64" then Nat64 else Int64))
+      e2 ^^
     Region.store_word64 env
 
   | OtherPrim ("regionLoadFloat"), [e0; e1] ->
     SR.UnboxedFloat64,
     compile_exp_as env ae SR.Vanilla e0 ^^
-    compile_exp_as env ae SR.UnboxedWord64 e1 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
     Region.load_float64 env
 
   | OtherPrim ("regionStoreFloat"), [e0; e1; e2] ->
     SR.unit,
     compile_exp_as env ae SR.Vanilla e0 ^^
-    compile_exp_as env ae SR.UnboxedWord64 e1 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
     compile_exp_as env ae SR.UnboxedFloat64 e2 ^^
     Region.store_float64 env
 
   (* Other prims, unary *)
 
   | OtherPrim "global_timer_set", [e] ->
-    SR.UnboxedWord64,
-    compile_exp_as env ae SR.UnboxedWord64 e ^^
+    SR.UnboxedWord64 Type.Nat64,
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e ^^
     IC.system_call env "global_timer_set"
 
   | OtherPrim "is_controller", [e] ->
@@ -10576,11 +11101,11 @@ and compile_prim_invocation (env : E.t) ae p es at =
     IC.is_controller env
 
   | OtherPrim "canister_version", [] ->
-    SR.UnboxedWord64,
+    SR.UnboxedWord64 Type.Nat64,
     IC.canister_version env
 
   | OtherPrim "crc32Hash", [e] ->
-    SR.UnboxedWord32,
+    SR.UnboxedWord32 Type.Nat32,
     compile_exp_vanilla env ae e ^^
     E.call_import env "rts" "compute_crc32"
 
@@ -10590,31 +11115,97 @@ and compile_prim_invocation (env : E.t) ae p es at =
 
 
   | OtherPrim "popcnt8", [e] ->
-    SR.Vanilla,
-    compile_exp_vanilla env ae e ^^
+    SR.UnboxedWord32 Type.Nat8,
+    compile_exp_as env ae (SR.UnboxedWord32 Type.Nat8) e ^^
     G.i (Unary (Wasm.Values.I32 I32Op.Popcnt)) ^^
     TaggedSmallWord.msb_adjust Type.Nat8
   | OtherPrim "popcnt16", [e] ->
-    SR.Vanilla,
-    compile_exp_vanilla env ae e ^^
+    SR.UnboxedWord32 Type.Nat16,
+    compile_exp_as env ae (SR.UnboxedWord32 Type.Nat16) e ^^
     G.i (Unary (Wasm.Values.I32 I32Op.Popcnt)) ^^
     TaggedSmallWord.msb_adjust Type.Nat16
+  | OtherPrim "popcntInt8", [e] ->
+    SR.UnboxedWord32 Type.Int8,
+    compile_exp_as env ae (SR.UnboxedWord32 Type.Int8) e ^^
+    G.i (Unary (Wasm.Values.I32 I32Op.Popcnt)) ^^
+    TaggedSmallWord.msb_adjust Type.Int8
+  | OtherPrim "popcntInt16", [e] ->
+    SR.UnboxedWord32 Type.Int16,
+    compile_exp_as env ae (SR.UnboxedWord32 Type.Int16) e ^^
+    G.i (Unary (Wasm.Values.I32 I32Op.Popcnt)) ^^
+    TaggedSmallWord.msb_adjust Type.Int16
   | OtherPrim "popcnt32", [e] ->
-    SR.UnboxedWord32,
-    compile_exp_as env ae SR.UnboxedWord32 e ^^
+    SR.UnboxedWord32 Type.Nat32,
+    compile_exp_as env ae (SR.UnboxedWord32 Type.Nat32) e ^^
+    G.i (Unary (Wasm.Values.I32 I32Op.Popcnt))
+  | OtherPrim "popcntInt32", [e] ->
+    SR.UnboxedWord32 Type.Int32,
+    compile_exp_as env ae (SR.UnboxedWord32 Type.Int32) e ^^
     G.i (Unary (Wasm.Values.I32 I32Op.Popcnt))
   | OtherPrim "popcnt64", [e] ->
-    SR.UnboxedWord64,
-    compile_exp_as env ae SR.UnboxedWord64 e ^^
+    SR.UnboxedWord64 Type.Nat64,
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e ^^
     G.i (Unary (Wasm.Values.I64 I64Op.Popcnt))
-  | OtherPrim "clz8", [e] -> SR.Vanilla, compile_exp_vanilla env ae e ^^ TaggedSmallWord.clz_kernel Type.Nat8
-  | OtherPrim "clz16", [e] -> SR.Vanilla, compile_exp_vanilla env ae e ^^ TaggedSmallWord.clz_kernel Type.Nat16
-  | OtherPrim "clz32", [e] -> SR.UnboxedWord32, compile_exp_as env ae SR.UnboxedWord32 e ^^ G.i (Unary (Wasm.Values.I32 I32Op.Clz))
-  | OtherPrim "clz64", [e] -> SR.UnboxedWord64, compile_exp_as env ae SR.UnboxedWord64 e ^^ G.i (Unary (Wasm.Values.I64 I64Op.Clz))
-  | OtherPrim "ctz8", [e] -> SR.Vanilla, compile_exp_vanilla env ae e ^^ TaggedSmallWord.ctz_kernel Type.Nat8
-  | OtherPrim "ctz16", [e] -> SR.Vanilla, compile_exp_vanilla env ae e ^^ TaggedSmallWord.ctz_kernel Type.Nat16
-  | OtherPrim "ctz32", [e] -> SR.UnboxedWord32, compile_exp_as env ae SR.UnboxedWord32 e ^^ G.i (Unary (Wasm.Values.I32 I32Op.Ctz))
-  | OtherPrim "ctz64", [e] -> SR.UnboxedWord64, compile_exp_as env ae SR.UnboxedWord64 e ^^ G.i (Unary (Wasm.Values.I64 I64Op.Ctz))
+  | OtherPrim "popcntInt64", [e] ->
+    SR.UnboxedWord64 Type.Int64,
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Int64) e ^^
+    G.i (Unary (Wasm.Values.I64 I64Op.Popcnt))
+  | OtherPrim "clz8", [e] ->
+     SR.UnboxedWord32 Type.Nat8,
+     compile_exp_as env ae (SR.UnboxedWord32 Type.Nat8) e ^^
+     TaggedSmallWord.clz_kernel Type.Nat8
+  | OtherPrim "clz16", [e] ->
+     SR.UnboxedWord32 Type.Nat16,
+     compile_exp_as env ae (SR.UnboxedWord32 Type.Nat16) e ^^
+     TaggedSmallWord.clz_kernel Type.Nat16
+  | OtherPrim "clzInt8", [e] ->
+     SR.UnboxedWord32 Type.Int8,
+     compile_exp_as env ae (SR.UnboxedWord32 Type.Int8) e ^^
+     TaggedSmallWord.clz_kernel Type.Int8
+  | OtherPrim "clzInt16", [e] ->
+     SR.UnboxedWord32 Type.Int16,
+     compile_exp_as env ae (SR.UnboxedWord32 Type.Int16) e ^^
+     TaggedSmallWord.clz_kernel Type.Int16
+  | OtherPrim "clz32", [e] ->
+     SR.UnboxedWord32 Type.Nat32,
+     compile_exp_as env ae (SR.UnboxedWord32 Type.Nat32) e ^^ G.i (Unary (Wasm.Values.I32 I32Op.Clz))
+  | OtherPrim "clzInt32", [e] ->
+     SR.UnboxedWord32 Type.Int32,
+     compile_exp_as env ae (SR.UnboxedWord32 Type.Int32) e ^^ G.i (Unary (Wasm.Values.I32 I32Op.Clz))
+  | OtherPrim "clz64", [e] ->
+     SR.UnboxedWord64 Type.Nat64,
+     compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e ^^ G.i (Unary (Wasm.Values.I64 I64Op.Clz))
+  | OtherPrim "clzInt64", [e] ->
+     SR.UnboxedWord64 Type.Int64,
+     compile_exp_as env ae (SR.UnboxedWord64 Type.Int64) e ^^ G.i (Unary (Wasm.Values.I64 I64Op.Clz))
+  | OtherPrim "ctz8", [e] ->
+     SR.UnboxedWord32 Type.Nat8,
+     compile_exp_as env ae (SR.UnboxedWord32 Type.Nat8) e ^^
+     TaggedSmallWord.ctz_kernel Type.Nat8
+  | OtherPrim "ctz16", [e] ->
+     SR.UnboxedWord32 Type.Nat16,
+     compile_exp_as env ae (SR.UnboxedWord32 Type.Nat16) e ^^
+     TaggedSmallWord.ctz_kernel Type.Nat16
+  | OtherPrim "ctzInt8", [e] ->
+     SR.UnboxedWord32 Type.Int8,
+     compile_exp_as env ae (SR.UnboxedWord32 Type.Int8) e ^^
+     TaggedSmallWord.ctz_kernel Type.Int8
+  | OtherPrim "ctzInt16", [e] ->
+     SR.UnboxedWord32 Type.Int16,
+     compile_exp_as env ae (SR.UnboxedWord32 Type.Int16) e ^^
+     TaggedSmallWord.ctz_kernel Type.Int16
+  | OtherPrim "ctz32", [e] ->
+    SR.UnboxedWord32 Type.Nat32,
+    compile_exp_as env ae (SR.UnboxedWord32 Type.Nat32) e ^^ G.i (Unary (Wasm.Values.I32 I32Op.Ctz))
+  | OtherPrim "ctzInt32", [e] ->
+    SR.UnboxedWord32 Type.Int32,
+    compile_exp_as env ae (SR.UnboxedWord32 Type.Int32) e ^^ G.i (Unary (Wasm.Values.I32 I32Op.Ctz))
+  | OtherPrim "ctz64", [e] ->
+    SR.UnboxedWord64 Type.Nat64,
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e ^^ G.i (Unary (Wasm.Values.I64 I64Op.Ctz))
+  | OtherPrim "ctzInt64", [e] ->
+    SR.UnboxedWord64 Type.Int64,
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Int64) e ^^ G.i (Unary (Wasm.Values.I64 I64Op.Ctz))
 
   | OtherPrim "conv_Char_Text", [e] ->
     SR.Vanilla,
@@ -10655,8 +11246,8 @@ and compile_prim_invocation (env : E.t) ae p es at =
     Text.uppercase env
 
   | OtherPrim "performanceCounter", [e] ->
-    SR.UnboxedWord64,
-    compile_exp_as env ae SR.UnboxedWord32 e ^^
+    (SR.UnboxedWord64 Type.Nat64),
+    compile_exp_as env ae (SR.UnboxedWord32 Type.Nat32) e ^^
     IC.performance_counter env
 
   | OtherPrim "trap", [e] ->
@@ -10669,70 +11260,78 @@ and compile_prim_invocation (env : E.t) ae p es at =
   | OtherPrim ("arrayToBlob" | "arrayMutToBlob"), e ->
     const_sr SR.Vanilla (Arr.toBlob env)
 
-  | OtherPrim ("stableMemoryLoadNat32" | "stableMemoryLoadInt32"), [e] ->
-    SR.UnboxedWord32,
-    compile_exp_as env ae SR.UnboxedWord64 e ^^
+  | OtherPrim (("stableMemoryLoadNat32" | "stableMemoryLoadInt32") as p), [e] ->
+    (SR.UnboxedWord32 Type.(if p = "stableMemoryLoadNat32" then Nat32 else Int32)),
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e ^^
     StableMemoryInterface.load_word32 env
 
-  | OtherPrim ("stableMemoryStoreNat32" | "stableMemoryStoreInt32"), [e1; e2] ->
+  | OtherPrim (("stableMemoryStoreNat32" | "stableMemoryStoreInt32") as p), [e1; e2] ->
     SR.unit,
-    compile_exp_as env ae SR.UnboxedWord64 e1 ^^
-    compile_exp_as env ae SR.UnboxedWord32 e2 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
+    compile_exp_as env ae
+      (SR.UnboxedWord32 Type.(if p = "stableMemoryStoreNat32" then Nat32 else Int32))
+      e2 ^^
     StableMemoryInterface.store_word32 env
 
   | OtherPrim (("stableMemoryLoadNat8" | "stableMemoryLoadInt8") as p), [e] ->
-    SR.Vanilla,
-    compile_exp_as env ae SR.UnboxedWord64 e ^^
+    let ty = Type.(if p = "stableMemoryLoadNat8" then Nat8 else Int8) in
+    SR.UnboxedWord32 ty,
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e ^^
     StableMemoryInterface.load_word8 env ^^
-    TaggedSmallWord.msb_adjust Type.(if p = "stableMemoryLoadNat8" then Nat8 else Int8)
+    TaggedSmallWord.msb_adjust ty
 
   (* Other prims, binary *)
 
   | OtherPrim (("stableMemoryStoreNat8" | "stableMemoryStoreInt8") as p), [e1; e2] ->
+    let ty = Type.(if p = "stableMemoryStoreNat8" then Nat8 else Int8) in
     SR.unit,
-    compile_exp_as env ae SR.UnboxedWord64 e1 ^^
-    compile_exp_as env ae SR.Vanilla e2 ^^
-    TaggedSmallWord.lsb_adjust Type.(if p = "stableMemoryStoreNat8" then Nat8 else Int8) ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
+    compile_exp_as env ae (SR.UnboxedWord32 ty) e2 ^^
+    TaggedSmallWord.lsb_adjust ty ^^
     StableMemoryInterface.store_word8 env
 
   | OtherPrim (("stableMemoryLoadNat16" | "stableMemoryLoadInt16") as p), [e] ->
-    SR.Vanilla,
-    compile_exp_as env ae SR.UnboxedWord64 e ^^
+    let ty = Type.(if p = "stableMemoryLoadNat16" then Nat16 else Int16) in
+    SR.UnboxedWord32 ty,
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e ^^
     StableMemoryInterface.load_word16 env ^^
-    TaggedSmallWord.msb_adjust Type.(if p = "stableMemoryLoadNat16" then Nat16 else Int16)
+    TaggedSmallWord.msb_adjust ty
 
   | OtherPrim (("stableMemoryStoreNat16" | "stableMemoryStoreInt16") as p), [e1; e2] ->
+    let ty = Type.(if p = "stableMemoryStoreNat16" then Nat16 else Int16) in
     SR.unit,
-    compile_exp_as env ae SR.UnboxedWord64 e1 ^^
-    compile_exp_as env ae SR.Vanilla e2 ^^
-    TaggedSmallWord.lsb_adjust Type.(if p = "stableMemoryStoreNat16" then Nat16 else Int16) ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
+    compile_exp_as env ae (SR.UnboxedWord32 ty) e2 ^^
+    TaggedSmallWord.lsb_adjust ty ^^
     StableMemoryInterface.store_word16 env
 
-  | OtherPrim ("stableMemoryLoadNat64" | "stableMemoryLoadInt64"), [e] ->
-    SR.UnboxedWord64,
-    compile_exp_as env ae SR.UnboxedWord64 e ^^
+  | OtherPrim (("stableMemoryLoadNat64" | "stableMemoryLoadInt64") as p), [e] ->
+    (SR.UnboxedWord64 Type.(if p = "stableMemoryLoadNat64" then Nat64 else Int64)),
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e ^^
     StableMemoryInterface.load_word64 env
 
-  | OtherPrim ("stableMemoryStoreNat64" | "stableMemoryStoreInt64"), [e1; e2] ->
+  | OtherPrim (("stableMemoryStoreNat64" | "stableMemoryStoreInt64") as p), [e1; e2] ->
     SR.unit,
-    compile_exp_as env ae SR.UnboxedWord64 e1 ^^
-    compile_exp_as env ae SR.UnboxedWord64 e2 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
+    compile_exp_as env ae
+      (SR.UnboxedWord64 Type.(if p = "stableMemoryStoreNat64" then Nat64 else Int64))
+      e2 ^^
     StableMemoryInterface.store_word64 env
 
   | OtherPrim "stableMemoryLoadFloat", [e] ->
     SR.UnboxedFloat64,
-    compile_exp_as env ae SR.UnboxedWord64 e ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e ^^
     StableMemoryInterface.load_float64 env
 
   | OtherPrim "stableMemoryStoreFloat", [e1; e2] ->
     SR.unit,
-    compile_exp_as env ae SR.UnboxedWord64 e1 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
     compile_exp_as env ae SR.UnboxedFloat64 e2 ^^
     StableMemoryInterface.store_float64 env
 
   | OtherPrim "stableMemoryLoadBlob", [e1; e2] ->
     SR.Vanilla,
-    compile_exp_as env ae SR.UnboxedWord64 e1 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
     compile_exp_as env ae SR.Vanilla e2 ^^
     Blob.lit env "Blob size out of bounds" ^^
     BigNum.to_word32_with env ^^
@@ -10740,17 +11339,17 @@ and compile_prim_invocation (env : E.t) ae p es at =
 
   | OtherPrim "stableMemoryStoreBlob", [e1; e2] ->
     SR.unit,
-    compile_exp_as env ae SR.UnboxedWord64 e1 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
     compile_exp_as env ae SR.Vanilla e2 ^^
     StableMemoryInterface.store_blob env
 
   | OtherPrim "stableMemorySize", [] ->
-    SR.UnboxedWord64,
+    SR.UnboxedWord64 Type.Nat64,
     StableMemoryInterface.size env
 
   | OtherPrim "stableMemoryGrow", [e] ->
-    SR.UnboxedWord64,
-    compile_exp_as env ae SR.UnboxedWord64 e ^^
+    SR.UnboxedWord64 Type.Nat64,
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e ^^
     StableMemoryInterface.grow env
 
   | OtherPrim "stableVarQuery", [] ->
@@ -10765,17 +11364,21 @@ and compile_prim_invocation (env : E.t) ae p es at =
     const_sr SR.Vanilla (Arr.tabulate env)
   | OtherPrim "btst8", [_;_] ->
     (* TODO: btstN returns Bool, not a small value *)
-    const_sr SR.Vanilla (TaggedSmallWord.btst_kernel env Type.Nat8)
+    const_sr (SR.UnboxedWord32 Type.Nat8) (TaggedSmallWord.btst_kernel env Type.Nat8)
   | OtherPrim "btst16", [_;_] ->
-    const_sr SR.Vanilla (TaggedSmallWord.btst_kernel env Type.Nat16)
+    const_sr (SR.UnboxedWord32 Type.Nat16) (TaggedSmallWord.btst_kernel env Type.Nat16)
+  | OtherPrim "btstInt8", [_;_] ->
+    const_sr (SR.UnboxedWord32 Type.Int8) (TaggedSmallWord.btst_kernel env Type.Int8)
+  | OtherPrim "btstInt16", [_;_] ->
+    const_sr (SR.UnboxedWord32 Type.Int16) (TaggedSmallWord.btst_kernel env Type.Int16)
   | OtherPrim "btst32", [_;_] ->
-    const_sr SR.UnboxedWord32 (TaggedSmallWord.btst_kernel env Type.Nat32)
+     const_sr (SR.UnboxedWord32 Type.Nat32) (TaggedSmallWord.btst_kernel env Type.Nat32)
+  | OtherPrim "btstInt32", [_;_] ->
+     const_sr (SR.UnboxedWord32 Type.Int32) (TaggedSmallWord.btst_kernel env Type.Int32) (* ! *)
   | OtherPrim "btst64", [_;_] ->
-    const_sr SR.UnboxedWord64 (
-      let (set_b, get_b) = new_local64 env "b" in
-      set_b ^^ compile_const_64 1L ^^ get_b ^^ G.i (Binary (Wasm.Values.I64 I64Op.Shl)) ^^
-      G.i (Binary (Wasm.Values.I64 I64Op.And))
-    )
+    const_sr (SR.UnboxedWord64 Type.Nat64) (Word64.btst_kernel env)
+  | OtherPrim "btstInt64", [_;_] ->
+    const_sr (SR.UnboxedWord64 Type.Int64) (Word64.btst_kernel env)
 
   (* Coercions for abstract types *)
   | CastPrim (_,_), [e] ->
@@ -11126,19 +11729,19 @@ and compile_exp_as_test env ae e =
 
 (* Compile a prim of type Char -> Char to a RTS call. *)
 and compile_char_to_char_rts env ae exp rts_fn =
-  SR.Vanilla,
-  compile_exp_vanilla env ae exp ^^
-  TaggedSmallWord.untag_codepoint ^^
+  SR.UnboxedWord32 Type.Char,
+  compile_exp_as env ae (SR.UnboxedWord32 Type.Char) exp ^^
+  TaggedSmallWord.lsb_adjust_codepoint env ^^
   E.call_import env "rts" rts_fn ^^
-  TaggedSmallWord.tag_codepoint
+  TaggedSmallWord.msb_adjust_codepoint
 
 (* Compile a prim of type Char -> Bool to a RTS call. The RTS function should
    have type int32_t -> int32_t where the return value is 0 for 'false' and 1
    for 'true'. *)
 and compile_char_to_bool_rts (env : E.t) (ae : VarEnv.t) exp rts_fn =
   SR.bool,
-  compile_exp_vanilla env ae exp ^^
-  TaggedSmallWord.untag_codepoint ^^
+  compile_exp_as env ae (SR.UnboxedWord32 Type.Char) exp ^^
+  TaggedSmallWord.lsb_adjust_codepoint env ^^
   (* The RTS function returns Motoko True/False values (which are represented as
      1 and 0, respectively) so we don't need any marshalling *)
   E.call_import env "rts" rts_fn
@@ -11190,12 +11793,12 @@ and compile_lit_pat env l =
     compile_lit_as env SR.Vanilla l ^^
     compile_eq env Type.(Prim Nat16)
   | Nat32Lit _ ->
-    BoxedSmallWord.unbox env ^^
-    compile_lit_as env SR.UnboxedWord32 l ^^
+    BoxedSmallWord.unbox env Type.Nat32 ^^
+    compile_lit_as env (SR.UnboxedWord32 Type.Nat32) l ^^
     compile_eq env Type.(Prim Nat32)
   | Nat64Lit _ ->
-    BoxedWord64.unbox env ^^
-    compile_lit_as env SR.UnboxedWord64 l ^^
+    BoxedWord64.unbox env Type.Nat64 ^^
+    compile_lit_as env (SR.UnboxedWord64 Type.Nat64) l ^^
     compile_eq env Type.(Prim Nat64)
   | Int8Lit _ ->
     compile_lit_as env SR.Vanilla l ^^
@@ -11204,12 +11807,12 @@ and compile_lit_pat env l =
     compile_lit_as env SR.Vanilla l ^^
     compile_eq env Type.(Prim Int16)
   | Int32Lit _ ->
-    BoxedSmallWord.unbox env ^^
-    compile_lit_as env SR.UnboxedWord32 l ^^
+    BoxedSmallWord.unbox env Type.Int32 ^^
+    compile_lit_as env (SR.UnboxedWord32 Type.Int32) l ^^
     compile_eq env Type.(Prim Int32)
   | Int64Lit _ ->
-    BoxedWord64.unbox env ^^
-    compile_lit_as env SR.UnboxedWord64 l ^^
+    BoxedWord64.unbox env Type.Int64 ^^
+    compile_lit_as env (SR.UnboxedWord64 Type.Int64) l ^^
     compile_eq env Type.(Prim Int64)
   | CharLit _ ->
     compile_lit_as env SR.Vanilla l ^^
@@ -11840,6 +12443,7 @@ and conclude_module env set_serialization_globals start_fi_o =
   | Some rts -> Linking.LinkModule.link emodule "rts" rts
 
 let compile mode rts (prog : Ir.prog) : Wasm_exts.CustomModule.extended_module =
+  assert !Flags.rtti; (* orthogonal persistence requires a fixed layout. *)
   let env = E.mk_global mode rts IC.trap_with in
 
   IC.register_globals env;
diff --git a/src/exes/candid_tests.ml b/src/exes/candid_tests.ml
index 3d56766b002..bddd6aae3dd 100644
--- a/src/exes/candid_tests.ml
+++ b/src/exes/candid_tests.ml
@@ -76,7 +76,7 @@ let mo_of_test tenv test : (string * expected_behaviour, string) result =
 
   try
     let defs =
-      "import Prim \"mo:⛔\";" ^
+      "import _Prim \"mo:⛔\";" ^
       String.concat "" (List.map (fun (n,candid_typ) ->
         let mo_typ = Idl_to_mo.check_typ tenv candid_typ in
         "type " ^ n ^ " = " ^ Pretty.string_of_typ mo_typ ^ ";\n"
diff --git a/src/ir_def/arrange_ir.ml b/src/ir_def/arrange_ir.ml
index b5a2d8e8f88..7b68f595f6d 100644
--- a/src/ir_def/arrange_ir.ml
+++ b/src/ir_def/arrange_ir.ml
@@ -69,10 +69,10 @@ and prim = function
   | ActorDotPrim n    -> "ActorDotPrim" $$ [Atom n]
   | ArrayPrim (m, t)  -> "ArrayPrim"  $$ [mut m; typ t]
   | IdxPrim           -> Atom "IdxPrim"
-  | NextArrayOffset _ -> Atom "NextArrayOffset"
-  | ValidArrayOffset  -> Atom "ValidArrayOffset"
+  | NextArrayOffset   -> Atom "NextArrayOffset"
+  | EqArrayOffset     -> Atom "EqArrayOffset"
   | DerefArrayOffset  -> Atom "DerefArrayOffset"
-  | GetPastArrayOffset _ -> Atom "GetPastArrayOffset"
+  | GetLastArrayOffset -> Atom "GetLastArrayOffset"
   | BreakPrim i       -> "BreakPrim"  $$ [id i]
   | RetPrim           -> Atom "RetPrim"
   | AwaitPrim Type.Fut -> Atom "AwaitPrim"
diff --git a/src/ir_def/check_ir.ml b/src/ir_def/check_ir.ml
index 222d70368e1..6f92399002b 100644
--- a/src/ir_def/check_ir.ml
+++ b/src/ir_def/check_ir.ml
@@ -482,20 +482,20 @@ let rec check_exp env (exp:Ir.exp) : unit =
       in
       typ exp2 <: T.nat;
       T.as_immut t2 <: t
-    | GetPastArrayOffset _, [exp1] ->
+    | GetLastArrayOffset, [exp1] ->
       let t1 = T.promote (typ exp1) in
       ignore
         (try T.as_array_sub t1 with
          | Invalid_argument _ ->
            error env exp1.at "expected array type, but expression produces type\n  %s"
              (T.string_of_typ_expand t1));
-      T.nat <: t
-    | NextArrayOffset _, [exp1] ->
+      T.int <: t
+    | NextArrayOffset, [exp1] ->
       typ exp1 <: T.nat;
       T.nat <: t
-    | ValidArrayOffset, [exp1; exp2] ->
-      typ exp1 <: T.nat;
-      typ exp2 <: T.nat;
+    | EqArrayOffset, [exp1; exp2] ->
+      typ exp1 <: T.int;
+      typ exp2 <: T.int;
       T.bool <: t
     | BreakPrim id, [exp1] ->
       begin
diff --git a/src/ir_def/construct.ml b/src/ir_def/construct.ml
index 2a10026ee81..8c0a52a2bb9 100644
--- a/src/ir_def/construct.ml
+++ b/src/ir_def/construct.ml
@@ -95,9 +95,9 @@ let primE prim es =
     | ICStableSize _ -> T.nat64
     | IdxPrim
     | DerefArrayOffset -> T.(as_immut (as_array_sub (List.hd es).note.Note.typ))
-    | ValidArrayOffset -> T.bool
-    | NextArrayOffset _
-    | GetPastArrayOffset _ -> T.nat
+    | EqArrayOffset -> T.bool
+    | NextArrayOffset -> T.nat
+    | GetLastArrayOffset -> T.int
     | IcUrlOfBlob -> T.text
     | ActorOfIdBlob t -> t
     | BinPrim (t, _) -> t
@@ -265,6 +265,12 @@ let natE n =
     note = Note.{ def with typ = T.nat }
   }
 
+let intE n =
+  { it = LitE (IntLit n);
+    at = no_region;
+    note = Note.{ def with typ = T.int }
+  }
+
 let textE s =
   { it = LitE (TextLit s);
     at = no_region;
diff --git a/src/ir_def/construct.mli b/src/ir_def/construct.mli
index c2ddadc4074..731568f94a2 100644
--- a/src/ir_def/construct.mli
+++ b/src/ir_def/construct.mli
@@ -64,6 +64,7 @@ val thenE : exp -> exp -> exp
 val blockE : dec list -> exp -> exp
 val let_else_switch : pat -> exp -> exp -> exp
 val natE : Mo_values.Numerics.Nat.t -> exp
+val intE : Mo_values.Numerics.Int.t -> exp
 val nat32E : Mo_values.Numerics.Nat32.t -> exp
 val textE : string -> exp
 val blobE : string -> exp
diff --git a/src/ir_def/ir.ml b/src/ir_def/ir.ml
index 77c87fe69c2..f58bdb9567a 100644
--- a/src/ir_def/ir.ml
+++ b/src/ir_def/ir.ml
@@ -146,10 +146,10 @@ and prim =
   | SelfRef of Type.typ               (* returns the self actor ref *)
   | SystemTimePrim
   (* Array field iteration/access *)
-  | NextArrayOffset of spacing        (* advance array offset *)
-  | ValidArrayOffset                  (* verify array offset *)
-  | DerefArrayOffset                  (* array offset indexing *)
-  | GetPastArrayOffset of spacing     (* array offset past the last element *)
+  | NextArrayOffset                   (* advance compact array offset, as Nat *)
+  | EqArrayOffset                     (* equate compact array offset at type Int *)
+  | DerefArrayOffset                  (* compact array offset indexing (unchecked) *)
+  | GetLastArrayOffset                (* compact array offset of the last element, or -1, as Int *)
   (* Funds *)
   | SystemCyclesAddPrim
   | SystemCyclesAcceptPrim
@@ -176,8 +176,6 @@ and prim =
   | ICStableRead of Type.typ           (* deserialize value of stable type from stable memory *)
   | ICStableSize of Type.typ
 
-and spacing = One | ElementSize        (* increment units when iterating over arrays *)
-
 (* Declarations *)
 
 and dec = dec' Source.phrase
@@ -271,10 +269,10 @@ let map_prim t_typ t_id p =
   | ActorDotPrim _ -> p
   | ArrayPrim (m, t) -> ArrayPrim (m, t_typ t)
   | IdxPrim
-  | NextArrayOffset _
-  | ValidArrayOffset
+  | NextArrayOffset
+  | EqArrayOffset
   | DerefArrayOffset
-  | GetPastArrayOffset _ -> p
+  | GetLastArrayOffset -> p
   | BreakPrim id -> BreakPrim (t_id id)
   | RetPrim
   | AwaitPrim _
diff --git a/src/ir_interpreter/interpret_ir.ml b/src/ir_interpreter/interpret_ir.ml
index e184acbd768..8f0a4f9a9b7 100644
--- a/src/ir_interpreter/interpret_ir.ml
+++ b/src/ir_interpreter/interpret_ir.ml
@@ -354,12 +354,12 @@ and interpret_exp_mut env exp (k : V.value V.cont) =
       | (IdxPrim | DerefArrayOffset), [v1; v2] ->
         k (try (V.as_array v1).(Numerics.Int.to_int (V.as_int v2))
            with Invalid_argument s -> trap exp.at "%s" s)
-      | NextArrayOffset _, [v1] ->
+      | NextArrayOffset , [v1] ->
         k (V.Int Numerics.Nat.(of_int ((to_int (V.as_int v1)) + 1)))
-      | ValidArrayOffset, [v1; v2] ->
-        k (V.Bool Numerics.Nat.(to_int (V.as_int v1) < to_int (V.as_int v2)))
-      | GetPastArrayOffset _, [v1] ->
-        k (V.Int Numerics.Nat.(of_int (Array.length (V.as_array v1))))
+      | EqArrayOffset, [v1; v2] ->
+        k (V.Bool Numerics.Int.(to_int (V.as_int v1) = to_int (V.as_int v2)))
+      | GetLastArrayOffset,  [v1] ->
+        k (V.Int Numerics.Int.(of_int (Array.length (V.as_array v1) - 1)))
       | BreakPrim id, [v1] -> find id env.labs v1
       | RetPrim, [v1] -> Option.get env.rets v1
       | ThrowPrim, [v1] -> Option.get env.throws v1
diff --git a/src/lang_utils/error_codes.ml b/src/lang_utils/error_codes.ml
index 892261d9043..c2a680afcfa 100644
--- a/src/lang_utils/error_codes.ml
+++ b/src/lang_utils/error_codes.ml
@@ -197,4 +197,5 @@ let error_codes : (string * string option) list =
     "M0191", None; (* Code requires Wasm features ... to execute *)
     "M0192", None; (* Object/Actor/Module body type mismatch *)
     "M0193", None; (* Can't declare actor class to have `async*` result *)
+    "M0194", Some([%blob "lang_utils/error_codes/M0194.md"]); (* Unused identifier warning *)
   ]
diff --git a/src/lang_utils/error_codes/M0194.md b/src/lang_utils/error_codes/M0194.md
new file mode 100644
index 00000000000..42c55eff18c
--- /dev/null
+++ b/src/lang_utils/error_codes/M0194.md
@@ -0,0 +1,31 @@
+# M0194
+
+This warning means that you defined an identifier without
+referencing it later, a good indicator of dead code.
+
+Dubious code example:
+
+```motoko
+let nickname = "klutz";
+// code that never uses `nickname`
+```
+
+If you encounter this warning, you can either delete the definition (if the code has no other side-effect),
+
+```motoko
+// code that never uses `nickname`
+```
+
+replace it by a wildcard pattern:
+
+```motoko
+let _ = "klutz";
+// code that never uses `nickname`
+```
+
+or just prefix the identifier with an underscore:
+
+```motoko
+let _nickname = "klutz";
+// code that never uses `nickname`
+```
diff --git a/src/languageServer/declaration_index.ml b/src/languageServer/declaration_index.ml
index 8ce3ea58562..6bd5ff43221 100644
--- a/src/languageServer/declaration_index.ml
+++ b/src/languageServer/declaration_index.ml
@@ -313,13 +313,14 @@ let list_files_recursively dir =
   in
   loop [] [ dir ]
 
-let scan_packages : unit -> string list =
+let scan_packages : unit -> lib_path list =
  fun _ ->
-  let scan_package path =
+  let scan_package p path =
     list_files_recursively path
     |> List.filter (fun f -> Filename.extension f = ".mo")
+    |> List.map (fun f -> { package = Some p; path = f })
   in
-  Flags.M.fold (fun _ v acc -> scan_package v @ acc) !Flags.package_urls []
+  Flags.M.fold (fun p v acc -> scan_package p v @ acc) !Flags.package_urls []
 
 let scan_actors : unit -> string list =
  fun _ ->
@@ -347,7 +348,7 @@ let index_from_scope : string -> t -> Syntax.lib list -> Scope.t -> t =
 
 let make_index_inner project_root vfs entry_points : t Diag.result =
   let package_paths =
-    List.map (fun f -> LibPath f @@ Source.no_region) (scan_packages ())
+    List.map (fun lp -> LibPath lp @@ Source.no_region) (scan_packages ())
   in
   let package_env =
     Pipeline.chase_imports
diff --git a/src/lowering/desugar.ml b/src/lowering/desugar.ml
index 821f40b22f1..9eadd3839b2 100644
--- a/src/lowering/desugar.ml
+++ b/src/lowering/desugar.ml
@@ -269,33 +269,46 @@ and transform_for_to_while p arr_exp proj e1 e2 =
   (* for (p in (arr_exp : [_]).proj(e1)) e2 when proj in {"keys", "vals"}
      ~~>
      let arr = arr_exp ;
-     let size = arr.size(e1) ;
-     var indx = 0 ;
-     label l loop {
-       if indx < size
-       then { let p = arr[indx]; e2; indx += 1 }
-       else { break l }
-     } *)
+     let last = arr.size(e1) : Int - 1 ;
+     var indx = 0;
+     if (last == -1) { }
+     else {
+       label l loop {
+         let p = arr[indx]; /* sans bound check */
+         e2;
+         if (indx == last)
+         else { break l }
+         then { indx += 1 }
+       }
+     }
+  *)
   let arr_typ = arr_exp.note.note_typ in
   let arrv = fresh_var "arr" arr_typ in
   let indx = fresh_var "indx" T.(Mut nat) in
-  let spacing, indexing_exp = match proj.it with
-    | "vals" -> I.ElementSize, primE I.DerefArrayOffset [varE arrv; varE indx]
-    | "keys" -> I.One, varE indx
+  let indexing_exp = match proj.it with
+    | "vals" -> primE I.DerefArrayOffset [varE arrv; varE indx]
+    | "keys" -> varE indx
     | _ -> assert false in
-  let size_exp = primE I.(GetPastArrayOffset spacing) [varE arrv] in
-  let size = fresh_var "size" T.nat in
+  let last = fresh_var "last" T.int in
+  let lab = fresh_id "done" () in
   blockE
     [ letD arrv (exp arr_exp)
     ; expD (exp e1)
-    ; letD size size_exp
+    ; letD last (primE I.GetLastArrayOffset [varE arrv]) (* -1 for empty array *)
     ; varD indx (natE Numerics.Nat.zero)]
-    (whileE (primE I.ValidArrayOffset
-               [varE indx; varE size])
-       (blockE [ letP (pat p) indexing_exp
-               ; expD (exp e2)]
-          (assignE indx
-             (primE I.(NextArrayOffset spacing) [varE indx]))))
+    (ifE (primE I.EqArrayOffset [varE last; intE (Numerics.Int.of_int (-1))])
+      (* empty array, do nothing *)
+      (unitE())
+      (labelE lab T.unit (
+        loopE (
+          (blockE
+            [ letP (pat p) indexing_exp
+            ; expD (exp e2)]
+           (ifE (primE I.EqArrayOffset [varE indx; varE last])
+             (* last, exit loop *)
+             (breakE lab (tupE []))
+             (* else increment and continue *)
+             (assignE indx (primE I.NextArrayOffset [varE indx]))))))))
 
 and mut m = match m.it with
   | S.Const -> Ir.Const
@@ -1006,7 +1019,7 @@ let transform_import (i : S.import) : import_declaration =
   assert (t <> T.Pre);
   let rhs = match !ir with
     | S.Unresolved -> raise (Invalid_argument ("Unresolved import " ^ f))
-    | S.LibPath fp ->
+    | S.LibPath {path = fp; _} ->
       varE (var (id_of_full_path fp) t)
     | S.PrimPath ->
       varE (var (id_of_full_path "@prim") t)
diff --git a/src/mo_config/flags.ml b/src/mo_config/flags.ml
index 70099d67141..a519dab8e1d 100644
--- a/src/mo_config/flags.ml
+++ b/src/mo_config/flags.ml
@@ -41,6 +41,7 @@ let force_gc = ref false
 let global_timer = ref true
 let experimental_field_aliasing = ref false
 let ocaml_js = ref false
+let rtti = ref true
 let trap_on_call_error = ref false
 let use_stable_regions = ref false
 let share_code = ref false
diff --git a/src/mo_def/syntax.ml b/src/mo_def/syntax.ml
index 17e7e7d7f40..8060759b4b9 100644
--- a/src/mo_def/syntax.ml
+++ b/src/mo_def/syntax.ml
@@ -12,9 +12,10 @@ let empty_typ_note = {note_typ = Type.Pre; note_eff = Type.Triv}
 
 (* Resolved imports (filled in separately after parsing) *)
 
+type lib_path = {package : string option; path : string}
 type resolved_import =
   | Unresolved
-  | LibPath of string
+  | LibPath of lib_path
   | IDLPath of (string * string) (* filepath * bytes *)
   | PrimPath (* the built-in prim module *)
 
@@ -125,6 +126,7 @@ and vis' =
   | System
 
 let is_public vis = match vis.Source.it with Public _ -> true | _ -> false
+let is_private vis = match vis.Source.it with Private -> true | _ -> false
 
 type stab = stab' Source.phrase
 and stab' = Stable | Flexible
@@ -296,8 +298,8 @@ open Source
 
 (* Identifiers *)
 
-let anon_id sort at = "anon-" ^ sort ^ "-" ^ string_of_pos at.left
-let is_anon_id id = Lib.String.chop_prefix "anon-" id.it <> None
+let anon_id sort at = "@anon-" ^ sort ^ "-" ^ string_of_pos at.left
+let is_anon_id id = Lib.String.chop_prefix "@anon-" id.it <> None
 
 (* Types & Scopes *)
 
diff --git a/src/mo_frontend/typing.ml b/src/mo_frontend/typing.ml
index cad88dbcc7f..20659d13c07 100644
--- a/src/mo_frontend/typing.ml
+++ b/src/mo_frontend/typing.ml
@@ -10,6 +10,7 @@ module T = Type
 module A = Effect
 module C = Async_cap
 
+module S = Set.Make(String)
 
 (* Contexts  *)
 
@@ -19,13 +20,13 @@ type avl = Available | Unavailable
 
 type lab_env = T.typ T.Env.t
 type ret_env = T.typ option
-type val_env  = (T.typ * avl) T.Env.t
+type val_env  = (T.typ * Source.region * avl) T.Env.t
 
 (* separate maps for values and types; entries only for _public_ elements *)
 type visibility_src = {depr : string option; id_region : Source.region; field_region : Source.region}
 type visibility_env = visibility_src T.Env.t * visibility_src T.Env.t
 
-let available env = T.Env.map (fun ty -> (ty, Available)) env
+let available env = T.Env.map (fun (ty, at) -> (ty, at, Available)) env
 
 let initial_scope =
   { Scope.empty with
@@ -33,6 +34,7 @@ let initial_scope =
     Scope.con_env = T.ConSet.singleton C.top_cap;
   }
 
+type unused_warnings = (string * Source.region) List.t
 
 type env =
   { vals : val_env;
@@ -50,6 +52,9 @@ type env =
     weak : bool;
     msgs : Diag.msg_store;
     scopes : Source.region T.ConEnv.t;
+    check_unused : bool;
+    used_identifiers : S.t ref;
+    unused_warnings : unused_warnings ref;
   }
 
 let env_of_scope msgs scope =
@@ -68,8 +73,38 @@ let env_of_scope msgs scope =
     weak = false;
     msgs;
     scopes = T.ConEnv.empty;
+    check_unused = true;
+    used_identifiers = ref S.empty;
+    unused_warnings = ref [];
   }
 
+let use_identifier env id =
+  env.used_identifiers := S.add id !(env.used_identifiers)
+
+let is_unused_identifier env id =
+  not (S.mem id !(env.used_identifiers))
+
+let get_identifiers identifiers =
+  T.Env.fold (fun id _ set -> S.add id set) identifiers S.empty
+
+let equal_unused_warning first second = first = second
+
+let add_unused_warning env warning =
+  if List.find_opt (equal_unused_warning warning) !(env.unused_warnings) = None then
+    env.unused_warnings := warning::!(env.unused_warnings)
+  else ()
+
+let compare_unused_warning first second =
+  let (first_id, {left = first_left; right = first_right}) = first in
+  let (second_id, {left = second_left; right = second_right}) = second in
+  match compare first_left second_left with
+  | 0 ->
+    (match compare first_right second_right with
+     | 0 -> compare first_id second_id
+     | other -> other)
+  | other -> other
+
+let sorted_unused_warnings list = List.sort compare_unused_warning list
 
 (* Error bookkeeping *)
 
@@ -148,10 +183,41 @@ let warn_lossy_bind_type env at bind t1 t2 =
 let _warn_in modes env at code fmt =
   ignore (diag_in type_warning modes env at code fmt)
 
+(* Unused identifier detection *)
+
+let emit_unused_warnings env =
+  let emit (id, region) = warn env region "M0194" "unused identifier %s (delete or rename to wildcard `_` or `_%s`)" id id in
+  let list = sorted_unused_warnings !(env.unused_warnings) in
+  List.iter emit list
+
+let ignore_warning_for_id id =
+  if String.length id > 0 then
+    let prefix = String.get id 0 in
+    prefix = '_' || prefix = '@'
+  else
+    false
+
+let detect_unused env inner_identifiers =
+  if env.check_unused then
+    T.Env.iter (fun id (_, at) ->
+      if (not (ignore_warning_for_id id)) && (is_unused_identifier env id) then
+        add_unused_warning env (id, at)
+    ) inner_identifiers
+
+let enter_scope env : S.t =
+  !(env.used_identifiers)
+
+let leave_scope env inner_identifiers initial_usage =
+  detect_unused env inner_identifiers;
+  let inner_identifiers = get_identifiers inner_identifiers in
+  let unshadowed_usage = S.diff !(env.used_identifiers) inner_identifiers in
+  let final_usage = S.union initial_usage unshadowed_usage in
+  env.used_identifiers := final_usage
+
 (* Context extension *)
 
 let add_lab env x t = {env with labs = T.Env.add x t env.labs}
-let add_val env x t = {env with vals = T.Env.add x (t, Available) env.vals}
+let add_val env x t at = {env with vals = T.Env.add x (t, at, Available) env.vals}
 
 let add_typs env xs cs =
   { env with
@@ -265,7 +331,7 @@ let check_import env at f ri =
   let full_path =
     match !ri with
     | Unresolved -> error env at "M0020" "unresolved import %s" f
-    | LibPath fp -> fp
+    | LibPath {path=fp; _} -> fp
     | IDLPath (fp, _) -> fp
     | PrimPath -> "@prim"
   in
@@ -291,11 +357,12 @@ let rec check_obj_path env path : T.obj_sort * (T.field list) =
 and check_obj_path' env path : T.typ =
   match path.it with
   | IdH id ->
+    use_identifier env id.it;
     (match T.Env.find_opt id.it env.vals with
-     | Some (T.Pre, _) ->
+     | Some (T.Pre, _, _) ->
        error env id.at "M0024" "cannot infer type of forward variable reference %s" id.it
-     | Some (t, Available) -> t
-     | Some (t, Unavailable) ->
+     | Some (t, _, Available) -> t
+     | Some (t, _, Unavailable) ->
          error env id.at "M0025" "unavailable variable %s" id.it
      | None -> error env id.at "M0026" "unbound variable %s" id.it
     )
@@ -317,6 +384,7 @@ let rec check_typ_path env path : T.con =
 and check_typ_path' env path : T.con =
   match path.it with
   | IdH id ->
+    use_identifier env id.it;
     (match T.Env.find_opt id.it env.typs with
     | Some c -> c
     | None -> error env id.at "M0029" "unbound type %s" id.it
@@ -1014,14 +1082,15 @@ and infer_exp'' env exp : T.typ =
   | PrimE _ ->
     error env exp.at "M0054" "cannot infer type of primitive"
   | VarE id ->
+    use_identifier env id.it;
     (match T.Env.find_opt id.it env.vals with
-    | Some (T.Pre, _) ->
+    | Some (T.Pre, _, _) ->
       error env id.at "M0055" "cannot infer type of forward variable %s" id.it;
-    | Some (t, Unavailable) ->
+    | Some (t, _, Unavailable) ->
       if !Flags.compiled then
         error env id.at "M0056" "variable %s is in scope but not available in compiled code" id.it
       else t
-    | Some (t, Available) -> t
+    | Some (t, _, Available) -> t
     | None ->
       error env id.at "M0057" "unbound variable %s" id.it
     )
@@ -1320,7 +1389,9 @@ and infer_exp'' env exp : T.typ =
           rets = Some codom;
           (* async = None; *) }
       in
+      let initial_usage = enter_scope env'' in
       check_exp_strong (adjoin_vals env'' ve2) codom exp1;
+      leave_scope env ve2 initial_usage;
       if Type.is_shared_sort sort then begin
         check_shared_binds env exp.at tbs;
         if not (T.shared t1) then
@@ -1352,7 +1423,7 @@ and infer_exp'' env exp : T.typ =
   | CallE (exp1, inst, exp2) ->
     infer_call env exp1 inst exp2 exp.at None
   | BlockE decs ->
-    let t, _ = infer_block env decs exp.at in
+    let t, _ = infer_block env decs exp.at false in
     t
   | NotE exp1 ->
     if not env.pre then check_exp_strong env T.bool exp1;
@@ -1857,7 +1928,9 @@ and infer_cases env t_pat t cases : T.typ =
 and infer_case env t_pat t case =
   let {pat; exp} = case.it in
   let ve = check_pat env t_pat pat in
+  let initial_usage = enter_scope env in
   let t' = recover_with T.Non (infer_exp (adjoin_vals env ve)) exp in
+  leave_scope env ve initial_usage;
   let t'' = T.lub t t' in
   if not env.pre && inconsistent t'' [t; t'] then
     warn env case.at "M0101"
@@ -2002,7 +2075,7 @@ and check_pat' env t pat : Scope.val_env =
   | WildP ->
     T.Env.empty
   | VarP id ->
-    T.Env.singleton id.it t
+    T.Env.singleton id.it (t, id.at)
   | LitP lit ->
     if not env.pre then begin
       let t' = if T.eq t T.nat then T.int else t in  (* account for Nat <: Int *)
@@ -2062,8 +2135,12 @@ and check_pat' env t pat : Scope.val_env =
     let ve2 = check_pat env t pat2 in
     if T.Env.keys ve1 <> T.Env.keys ve2 then
       error env pat.at "M0189" "different set of bindings in pattern alternatives";
-    T.Env.(iter (fun k t1 -> warn_lossy_bind_type env pat.at k t1 (find k ve2))) ve1;
-    T.Env.merge (fun _ -> Lib.Option.map2 T.lub) ve1 ve2
+    T.Env.(iter (fun k (t1, _) -> 
+      let (t2, _) = find k ve2 in
+      warn_lossy_bind_type env pat.at k t1 t2)
+    ) ve1;
+    let merge_entries (t1, at1) (t2, at2) = (T.lub t1 t2, at1) in
+    T.Env.merge (fun _ -> Lib.Option.map2 merge_entries) ve1 ve2
   | AnnotP (pat1, typ) ->
     let t' = check_typ env typ in
     if not (T.sub t t') then
@@ -2211,7 +2288,7 @@ and object_of_scope env sort dec_fields scope at =
   in
   let tfs' =
     T.Env.fold
-      (fun id t tfs ->
+      (fun id (t, _) tfs ->
         match T.Env.find_opt id pub_val with
         | Some src -> T.{lab = id; typ = t; src = {depr = src.depr; region = src.field_region}}::tfs
         | _ -> tfs
@@ -2237,8 +2314,16 @@ and is_typ_dec dec : bool = match dec.it with
   | TypD _ -> true
   | _ -> false
 
-
 and infer_obj env s dec_fields at : T.typ =
+  let private_fields =
+    let scope = List.filter (fun field -> is_private field.it.vis) dec_fields
+    |> List.map (fun field -> field.it.dec)
+    |> gather_block_decs env in
+    get_identifiers scope.Scope.val_env
+  in
+  let private_identifiers identifiers =
+    T.Env.filter (fun id _ -> S.mem id private_fields) identifiers
+  in
   let env =
     if s <> T.Actor then
       { env with in_actor = false }
@@ -2250,8 +2335,10 @@ and infer_obj env s dec_fields at : T.typ =
         async = C.NullCap; }
   in
   let decs = List.map (fun (df : dec_field) -> df.it.dec) dec_fields in
-  let _, scope = infer_block env decs at in
+  let initial_usage = enter_scope env in
+  let _, scope = infer_block env decs at false in
   let t = object_of_scope env s dec_fields scope at in
+  leave_scope env (private_identifiers scope.Scope.val_env) initial_usage;
   let (_, tfs) = T.as_obj t in
   if not env.pre then begin
     if s = T.Actor then begin
@@ -2293,7 +2380,7 @@ and check_system_fields env sort scope tfs dec_fields =
           (* TBR why does Stable.md require this to be a manifest function, not just any expression of appropriate type?  *)
           if vis = System then
             begin
-              let t1 = T.Env.find id.it scope.Scope.val_env in
+              let (t1, _) = T.Env.find id.it scope.Scope.val_env in
               if not (T.sub t1 t) then
                 local_error env df.at "M0127" "system function %s is declared with type%a\ninstead of expected type%a" id.it
                    display_typ t1
@@ -2324,7 +2411,7 @@ and check_stab env sort scope dec_fields =
   let check_stable id at =
     match T.Env.find_opt id scope.Scope.val_env with
     | None -> assert false
-    | Some t ->
+    | Some (t, _) ->
       let t1 = T.as_immut t in
       if not (T.stable t1) then
         local_error env at "M0131"
@@ -2357,7 +2444,8 @@ and check_stab env sort scope dec_fields =
 
 (* Blocks and Declarations *)
 
-and infer_block env decs at : T.typ * Scope.scope =
+and infer_block env decs at check_unused : T.typ * Scope.scope =
+  let initial_usage = enter_scope env in
   let scope = infer_block_decs env decs at in
   let env' = adjoin env scope in
   (* HACK: when compiling to IC, mark class constructors as unavailable *)
@@ -2366,12 +2454,15 @@ and infer_block env decs at : T.typ * Scope.scope =
       List.fold_left (fun ve' dec ->
         match dec.it with
         | ClassD(_, id, _, _, _, { it = T.Actor; _}, _, _) ->
-          T.Env.mapi (fun id' (typ, avl) ->
-            (typ, if id' = id.it then Unavailable else avl)) ve'
+          T.Env.mapi (fun id' (typ, at, avl) ->
+            (typ, at, if id' = id.it then Unavailable else avl)) ve'
         | _ -> ve') env'.vals decs
     | _ -> env'.vals
   in
   let t = infer_block_exps { env' with vals = ve } decs in
+  if check_unused then
+    leave_scope env scope.Scope.val_env initial_usage
+  else ();
   t, scope
 
 and infer_block_decs env decs at : Scope.t =
@@ -2406,7 +2497,7 @@ and infer_dec env dec : T.typ =
     if not env.pre then ignore (infer_exp env exp);
     T.unit
   | ClassD (shared_pat, id, typ_binds, pat, typ_opt, obj_sort, self_id, dec_fields) ->
-    let (t, _) = T.Env.find id.it env.vals in
+    let (t, _, _) = T.Env.find id.it env.vals in
     if not env.pre then begin
       let c = T.Env.find id.it env.typs in
       let ve0 = check_class_shared_pat env shared_pat obj_sort in
@@ -2423,14 +2514,16 @@ and infer_dec env dec : T.typ =
       let cs' = if obj_sort.it = T.Actor then List.tl cs else cs in
       let self_typ = T.Con (c, List.map (fun c -> T.Con (c, [])) cs') in
       let env''' =
-        { (add_val env'' self_id.it self_typ) with
+        { (add_val env'' self_id.it self_typ self_id.at) with
           labs = T.Env.empty;
           rets = None;
           async = C.NullCap;
           in_actor = obj_sort.it = T.Actor;
         }
       in
-      let t' = infer_obj env''' obj_sort.it dec_fields dec.at in
+      let initial_usage = enter_scope env''' in
+      let t' = infer_obj { env''' with check_unused = true } obj_sort.it dec_fields dec.at in
+      leave_scope env ve initial_usage;
       match typ_opt, obj_sort.it with
       | None, _ -> ()
       | Some { it = AsyncT (T.Fut, _, typ); at; _ }, T.Actor
@@ -2458,8 +2551,10 @@ and infer_dec env dec : T.typ =
 
 
 and check_block env t decs at : Scope.t =
+  let initial_usage = enter_scope env in
   let scope = infer_block_decs env decs at in
   check_block_exps (adjoin env scope) t decs at;
+  leave_scope env scope.Scope.val_env initial_usage;
   scope
 
 and check_block_exps env t decs at =
@@ -2493,7 +2588,7 @@ and infer_val_path env exp : T.typ option =
     Some (check_import env exp.at f ri)
   | VarE id ->
     (match T.Env.find_opt id.it env.vals with (* TBR: return None for Unavailable? *)
-     | Some (t, _) -> Some t
+     | Some (t, _, _) -> Some t
      | _ -> None)
   | DotE (path, id) ->
     (match infer_val_path env path with
@@ -2533,7 +2628,7 @@ and gather_dec env scope dec : Scope.t =
     if T.Env.mem id.it scope.val_env then
       error_duplicate env "" id;
     let scope' = gather_block_decs env decs in
-    let ve' = T.Env.add id.it (object_of_scope env obj_sort.it dec_fields scope' at) scope.val_env in
+    let ve' = T.Env.add id.it ((object_of_scope env obj_sort.it dec_fields scope' at), id.at) scope.val_env in
     let obj_env = T.Env.add id.it scope' scope.obj_env in
     { val_env = ve';
       typ_env = scope.typ_env;
@@ -2566,7 +2661,7 @@ and gather_dec env scope dec : Scope.t =
       | ClassD _ ->
         if T.Env.mem id.it scope.val_env then
           error_duplicate env "" id;
-        T.Env.add id.it T.Pre scope.val_env
+        T.Env.add id.it (T.Pre, id.at) scope.val_env
       | _ -> scope.val_env
     in
     { val_env;
@@ -2591,7 +2686,7 @@ and gather_pat_field env ve pf : Scope.val_env =
 and gather_id env ve id : Scope.val_env =
   if T.Env.mem id.it ve then
     error_duplicate env "" id;
-  T.Env.add id.it T.Pre ve
+  T.Env.add id.it (T.Pre, id.at) ve
 
 (* Pass 2 and 3: infer type definitions *)
 and infer_block_typdecs env decs : Scope.t =
@@ -2618,7 +2713,7 @@ and infer_dec_typdecs env dec : Scope.t =
     let obj_scope = Scope.adjoin scope obj_scope_typs in
     Scope.{ empty with
       con_env = obj_scope.con_env;
-      val_env = T.Env.singleton id.it (object_of_scope env obj_sort.it dec_fields obj_scope at);
+      val_env = T.Env.singleton id.it ((object_of_scope env obj_sort.it dec_fields obj_scope at), id.at);
       obj_env = T.Env.singleton id.it obj_scope
     }
   (* TODO: generalize beyond let <id> = <valpath> *)
@@ -2628,8 +2723,8 @@ and infer_dec_typdecs env dec : Scope.t =
      | Some t ->
        let open Scope in
        match T.promote t with
-       | T.Obj (_, _) as t' -> { Scope.empty with val_env = T.Env.singleton id.it t' }
-       | _ -> { Scope.empty with val_env = T.Env.singleton id.it T.Pre }
+       | T.Obj (_, _) as t' -> { Scope.empty with val_env = T.Env.singleton id.it (t', id.at) }
+       | _ -> { Scope.empty with val_env = T.Env.singleton id.it (T.Pre, id.at) }
     )
   | LetD _ | ExpD _ | VarD _ ->
     Scope.empty
@@ -2651,8 +2746,8 @@ and infer_dec_typdecs env dec : Scope.t =
         List.tl tbs, List.tl cs
       else tbs, cs in
     let self_typ = T.Con (c, List.map (fun c -> T.Con (c, [])) cs') in
-    let env'' = add_val (adjoin_vals env' ve) self_id.it self_typ in
-    let t = infer_obj env'' obj_sort.it dec_fields dec.at in
+    let env'' = add_val (adjoin_vals env' ve) self_id.it self_typ self_id.at in
+    let t = infer_obj { env'' with check_unused = false } obj_sort.it dec_fields dec.at in
     let k = T.Def (T.close_binds cs' tbs', T.close cs' t) in
     check_closed env id k dec.at;
     Scope.{ empty with
@@ -2702,9 +2797,9 @@ and infer_dec_valdecs env dec : Scope.t =
     in
     let obj_typ = object_of_scope env obj_sort.it dec_fields obj_scope' at in
     let _ve = check_pat env obj_typ pat in
-    Scope.{empty with val_env = T.Env.singleton id.it obj_typ}
+    Scope.{empty with val_env = T.Env.singleton id.it (obj_typ, id.at)}
   | LetD (pat, exp, fail) ->
-    let t = infer_exp {env with pre = true} exp in
+    let t = infer_exp {env with pre = true; check_unused = false} exp in
     let ve' = match fail with
       | None -> check_pat_exhaustive (if is_import dec then local_error else warn) env t pat
       | Some _ -> check_pat env t pat
@@ -2712,7 +2807,7 @@ and infer_dec_valdecs env dec : Scope.t =
     Scope.{empty with val_env = ve'}
   | VarD (id, exp) ->
     let t = infer_exp {env with pre = true} exp in
-    Scope.{empty with val_env = T.Env.singleton id.it (T.Mut t)}
+    Scope.{empty with val_env = T.Env.singleton id.it ((T.Mut t), id.at)}
   | TypD (id, _, _) ->
     let c = Option.get id.note in
     Scope.{ empty with
@@ -2746,7 +2841,7 @@ and infer_dec_valdecs env dec : Scope.t =
       [T.close cs t2])
     in
     Scope.{ empty with
-      val_env = T.Env.singleton id.it t;
+      val_env = T.Env.singleton id.it (t, id.at);
       typ_env = T.Env.singleton id.it c;
       con_env = T.ConSet.singleton c;
     }
@@ -2754,14 +2849,19 @@ and infer_dec_valdecs env dec : Scope.t =
 
 (* Programs *)
 
-let infer_prog scope async_cap prog : (T.typ * Scope.t) Diag.result =
+let infer_prog scope pkg_opt async_cap prog : (T.typ * Scope.t) Diag.result =
   Diag.with_message_store
     (fun msgs ->
       recover_opt
         (fun prog ->
           let env0 = env_of_scope msgs scope in
-          let env = { env0 with async = async_cap } in
-          let res = infer_block env prog.it prog.at in
+          let env = {
+             env0 with async = async_cap;
+            (* suppress usage warning in package code *)
+            check_unused = pkg_opt = None
+          } in
+          let res = infer_block env prog.it prog.at true in
+          emit_unused_warnings env;
           res
         ) prog
     )
@@ -2793,15 +2893,19 @@ let check_actors scope progs : unit Diag.result =
         ) progs
     )
 
-let check_lib scope lib : Scope.t Diag.result =
+let check_lib scope pkg_opt lib : Scope.t Diag.result =
   Diag.with_message_store
     (fun msgs ->
       recover_opt
         (fun lib ->
-          let env = env_of_scope msgs scope in
+          let env = {
+            (env_of_scope msgs scope) with
+            (* suppress usage warning in package code *)
+            check_unused = pkg_opt = None
+          } in
           let { imports; body = cub; _ } = lib.it in
           let (imp_ds, ds) = CompUnit.decs_of_lib lib in
-          let typ, _ = infer_block env (imp_ds @ ds) lib.at in
+          let typ, _ = infer_block env (imp_ds @ ds) lib.at false in
           List.iter2 (fun import imp_d -> import.note <- imp_d.note.note_typ) imports imp_ds;
           cub.note <- {note_typ = typ; note_eff = T.Triv};
           let imp_typ = match cub.it with
@@ -2841,6 +2945,7 @@ let check_lib scope lib : Scope.t Diag.result =
               (* this shouldn't really happen, as an imported program should be rewritten to a module *)
               error env cub.at "M0000" "compiler bug: expected a module or actor class but found a program, i.e. a sequence of declarations"
           in
+          emit_unused_warnings env;
           Scope.lib lib.note.filename imp_typ
         ) lib
     )
diff --git a/src/mo_frontend/typing.mli b/src/mo_frontend/typing.mli
index a34a460a056..264a5ce5c82 100644
--- a/src/mo_frontend/typing.mli
+++ b/src/mo_frontend/typing.mli
@@ -5,9 +5,10 @@ open Type
 open Scope
 
 val initial_scope : scope
-val infer_prog : scope -> Async_cap.async_cap -> Syntax.prog -> (typ * scope) Diag.result
 
-val check_lib : scope -> Syntax.lib -> scope Diag.result
+val infer_prog : scope -> string option -> Async_cap.async_cap -> Syntax.prog -> (typ * scope) Diag.result
+
+val check_lib : scope -> string option -> Syntax.lib -> scope Diag.result
 val check_actors : scope -> Syntax.prog list -> unit Diag.result
 val check_stab_sig : scope -> Syntax.stab_sig -> (field list) Diag.result
 
diff --git a/src/mo_idl/idl_to_mo_value.ml b/src/mo_idl/idl_to_mo_value.ml
index 2d603194724..7d3ee94753d 100644
--- a/src/mo_idl/idl_to_mo_value.ml
+++ b/src/mo_idl/idl_to_mo_value.ml
@@ -75,7 +75,7 @@ let rec value v t =
       (Pretty.string_of_typ t)
       (Idllib.Escape.escape_method Source.no_region m)
   | PrincipalV s, _ ->
-    "Prim.principalOfActor" ^ parens ("actor " ^ text_lit s ^ " : actor {}")
+    "_Prim.principalOfActor" ^ parens ("actor " ^ text_lit s ^ " : actor {}")
   | _ -> raise (UnsupportedCandidFeature
     (Diag.error_message v.at "M0165" "import" "odd expected type"))
 
diff --git a/src/mo_interpreter/interpret.ml b/src/mo_interpreter/interpret.ml
index 88dc8f4819f..6c0674dfb4a 100644
--- a/src/mo_interpreter/interpret.ml
+++ b/src/mo_interpreter/interpret.ml
@@ -424,8 +424,8 @@ and interpret_exp_mut env exp (k : V.value V.cont) =
   | ImportE (f, ri) ->
     (match !ri with
     | Unresolved -> assert false
-    | LibPath fp ->
-      k (find fp env.libs)
+    | LibPath {path; _} ->
+      k (find path env.libs)
     | IDLPath _ -> trap exp.at "actor import"
     | PrimPath -> k (find "@prim" env.libs)
     )
diff --git a/src/mo_types/scope.ml b/src/mo_types/scope.ml
index 1a7df717e73..1705ab55b9a 100644
--- a/src/mo_types/scope.ml
+++ b/src/mo_types/scope.ml
@@ -2,7 +2,7 @@ module T = Type
 
 (* Scopes *)
 
-type val_env = T.typ T.Env.t
+type val_env = (T.typ * Source.region) T.Env.t
 type lib_env = T.typ T.Env.t
 type typ_env = T.con T.Env.t
 type con_env = T.ConSet.t
diff --git a/src/mo_types/scope.mli b/src/mo_types/scope.mli
index 9e8101b4044..fecf2e33e2d 100644
--- a/src/mo_types/scope.mli
+++ b/src/mo_types/scope.mli
@@ -1,6 +1,6 @@
 open Type
 
-type val_env = typ Env.t
+type val_env = (typ * Source.region) Env.t
 type lib_env = typ Env.t
 type typ_env = con Env.t
 type con_env = ConSet.t
diff --git a/src/mo_values/prim.ml b/src/mo_values/prim.ml
index 84049f7c2c9..64ea0bad606 100644
--- a/src/mo_values/prim.ml
+++ b/src/mo_values/prim.ml
@@ -146,7 +146,8 @@ let prim trap =
      | _ -> assert false)
   | "fexp" -> fun _ v k -> k (via_float Stdlib.exp v)
   | "flog" -> fun _ v k -> k (via_float Stdlib.log v)
-
+  (* TODO: refine exotic cases below to catch more errors *)
+  | "popcntInt8" | "popcntInt16" | "popcntInt32" | "popcntInt64"
   | "popcnt8" | "popcnt16" | "popcnt32" | "popcnt64" ->
      fun _ v k ->
      k (match v with
@@ -159,7 +160,7 @@ let prim trap =
         | Int32 w -> Int32 (Int_32.popcnt w)
         | Int64 w -> Int64 (Int_64.popcnt w)
         | _ -> failwith "popcnt")
-
+  | "clzInt8" | "clzInt16" | "clzInt32" | "clzInt64"
   | "clz8" | "clz16" | "clz32" | "clz64" ->
      fun _ v k ->
      k (match v with
@@ -172,7 +173,7 @@ let prim trap =
         | Int32 w -> Int32 (Int_32.clz w)
         | Int64 w -> Int64 (Int_64.clz w)
         | _ -> failwith "clz")
-
+  | "ctzInt8" | "ctzInt16" | "ctzInt32" | "ctzInt64"
   | "ctz8" | "ctz16" | "ctz32" | "ctz64" ->
      fun _ v k ->
      k (match v with
@@ -185,7 +186,7 @@ let prim trap =
         | Int32 w -> Int32 (Int_32.ctz w)
         | Int64 w -> Int64 (Int_64.ctz w)
         | _ -> failwith "ctz")
-
+  | "btstInt8" | "btstInt16" | "btstInt32" | "btstInt64"
   | "btst8" | "btst16" | "btst32" | "btst64" ->
      fun _ v k ->
      let w, a = as_pair v
diff --git a/src/pipeline/pipeline.ml b/src/pipeline/pipeline.ml
index 1d145be2da2..cac4a96aecc 100644
--- a/src/pipeline/pipeline.ml
+++ b/src/pipeline/pipeline.ml
@@ -33,7 +33,7 @@ let print_ce =
   )
 
 let print_stat_ve =
-  Type.Env.iter (fun x t ->
+  Type.Env.iter (fun x (t, _) ->
     let t' = Type.as_immut t in
     Format.printf "@[<hv 2>%s %s :@ %a@]@."
       (if t == t' then "let" else "var") x
@@ -43,7 +43,7 @@ let print_stat_ve =
 let print_dyn_ve scope =
   Value.Env.iter (fun x d ->
     let open Type in
-    let t = Env.find x scope.Scope.val_env in
+    let (t, _) = Env.find x scope.Scope.val_env in
     let t' = as_immut t in
     match normalize t' with
     | Obj (Module, fs) ->
@@ -180,10 +180,10 @@ let async_cap_of_prog prog =
      else
        Async_cap.initial_cap()
 
-let infer_prog senv async_cap prog : (Type.typ * Scope.scope) Diag.result =
+let infer_prog pkg_opt senv async_cap prog : (Type.typ * Scope.scope) Diag.result =
   let filename = prog.Source.note.Syntax.filename in
   phase "Checking" filename;
-  let r = Typing.infer_prog senv async_cap prog in
+  let r = Typing.infer_prog pkg_opt senv async_cap prog in
   if !Flags.trace && !Flags.verbose then begin
     match r with
     | Ok ((_, scope), _) ->
@@ -204,15 +204,15 @@ let rec check_progs senv progs : Scope.scope Diag.result =
   | prog::progs' ->
     let open Diag.Syntax in
     let async_cap = async_cap_of_prog prog in
-    let* _t, sscope = infer_prog senv async_cap prog in
+    let* _t, sscope = infer_prog senv None async_cap prog in
     let senv' = Scope.adjoin senv sscope in
     check_progs senv' progs'
 
-let check_lib senv lib : Scope.scope Diag.result =
+let check_lib senv pkg_opt lib : Scope.scope Diag.result =
   let filename = lib.Source.note.Syntax.filename in
   phase "Checking" (Filename.basename filename);
   let open Diag.Syntax in
-  let* sscope = Typing.check_lib senv lib in
+  let* sscope = Typing.check_lib senv pkg_opt lib in
   phase "Definedness" (Filename.basename filename);
   let* () = Definedness.check_lib lib in
   Diag.return sscope
@@ -235,7 +235,7 @@ let check_builtin what src senv0 : Syntax.prog * stat_env =
   match parse_with Lexer.mode_priv lexer parse what with
   | Error es -> builtin_error "parsing" what es
   | Ok (prog, _ws) ->
-    match infer_prog senv0 Async_cap.NullCap prog with
+    match infer_prog senv0 None Async_cap.NullCap prog with
     | Error es -> builtin_error "checking" what es
     | Ok ((_t, sscope), _ws) ->
       let senv1 = Scope.adjoin senv0 sscope in
@@ -311,7 +311,7 @@ let check_prim () : Syntax.lib * stat_env =
       at = no_region;
       note = { filename = "@prim"; trivia = Trivia.empty_triv_table }
     } in
-    match check_lib senv0 lib with
+    match check_lib senv0 None lib with
     | Error es -> prim_error "checking" es
     | Ok (sscope, _ws) ->
       let senv1 = Scope.adjoin senv0 sscope in
@@ -355,7 +355,7 @@ let chase_imports parsefn senv0 imports : (Syntax.lib list * Scope.scope) Diag.r
   let senv = ref senv0 in
   let libs = ref [] in
 
-  let rec go ri = match ri.Source.it with
+  let rec go pkg_opt ri = match ri.Source.it with
     | Syntax.PrimPath ->
       (* a bit of a hack, lib_env should key on resolved_import *)
       if Type.Env.mem "@prim" !senv.Scope.lib_env then
@@ -366,7 +366,7 @@ let chase_imports parsefn senv0 imports : (Syntax.lib list * Scope.scope) Diag.r
         senv := Scope.adjoin !senv sscope;
         Diag.return ()
     | Syntax.Unresolved -> assert false
-    | Syntax.LibPath f ->
+    | Syntax.(LibPath {path = f; package = lib_pkg_opt}) ->
       if Type.Env.mem f !senv.Scope.lib_env then
         Diag.return ()
       else if mem ri.Source.it !pending then
@@ -381,9 +381,10 @@ let chase_imports parsefn senv0 imports : (Syntax.lib list * Scope.scope) Diag.r
         let* prog, base = parsefn ri.Source.at f in
         let* () = Static.prog prog in
         let* more_imports = ResolveImport.resolve (resolve_flags ()) prog base in
-        let* () = go_set more_imports in
+        let pkg_opt' = if lib_pkg_opt <> None then lib_pkg_opt else pkg_opt in
+        let* () = go_set pkg_opt more_imports in
         let lib = lib_of_prog f prog in
-        let* sscope = check_lib !senv lib in
+        let* sscope = check_lib !senv pkg_opt' lib in
         libs := lib :: !libs; (* NB: Conceptually an append *)
         senv := Scope.adjoin !senv sscope;
         pending := remove ri.Source.it !pending;
@@ -412,9 +413,9 @@ let chase_imports parsefn senv0 imports : (Syntax.lib list * Scope.scope) Diag.r
           let sscope = Scope.lib f actor in
           senv := Scope.adjoin !senv sscope;
           Diag.return ()
-  and go_set todo = Diag.traverse_ go todo
+  and go_set pkg_opt todo = Diag.traverse_ (go pkg_opt) todo
   in
-  Diag.map (fun () -> (List.rev !libs, !senv)) (go_set imports)
+  Diag.map (fun () -> (List.rev !libs, !senv)) (go_set None imports)
 
 let load_progs parsefn files senv : load_result =
   let open Diag.Syntax in
@@ -431,7 +432,7 @@ let load_decl parse_one senv : load_decl_result =
   let* parsed = parse_one in
   let* prog, libs = resolve_prog parsed in
   let* libs, senv' = chase_imports parse_file senv libs in
-  let* t, sscope = infer_prog senv' (Async_cap.(AwaitCap top_cap)) prog in
+  let* t, sscope = infer_prog senv' (Some "<toplevel>") (Async_cap.(AwaitCap top_cap)) prog in
   let senv'' = Scope.adjoin senv' sscope in
   Diag.return (libs, prog, senv'', t, sscope)
 
diff --git a/src/pipeline/resolve_import.ml b/src/pipeline/resolve_import.ml
index 9b9a4df9f11..7a6290d69ce 100644
--- a/src/pipeline/resolve_import.ml
+++ b/src/pipeline/resolve_import.ml
@@ -138,11 +138,12 @@ let resolve_lib_import at full_path : (string, Diag.message) result =
   then Ok full_path
   else Error (err_file_does_not_exist' at full_path)
 
-let add_lib_import msgs imported ri_ref at full_path =
-  match resolve_lib_import at full_path with
+let add_lib_import msgs imported ri_ref at lib_path =
+  match resolve_lib_import at lib_path.path with
   | Ok full_path -> begin
-      ri_ref := LibPath full_path;
-      imported := RIM.add (LibPath full_path) at !imported
+      let ri = LibPath {lib_path with path = full_path} in
+      ri_ref := ri;
+      imported := RIM.add ri at !imported
     end
   | Error err ->
      Diag.add_msg msgs err
@@ -174,10 +175,13 @@ let resolve_import_string msgs base actor_idl_path aliases packages imported (f,
   match Url.parse f with
   | Ok (Url.Relative path) ->
     (* TODO support importing local .did file *)
-    add_lib_import msgs imported ri_ref at (in_base base path)
+    add_lib_import msgs imported ri_ref at
+      { path = in_base base path; package = None }
   | Ok (Url.Package (pkg,path)) ->
     begin match M.find_opt pkg packages with
-    | Some pkg_path -> add_lib_import msgs imported ri_ref at (in_base pkg_path path)
+    | Some pkg_path ->
+      add_lib_import msgs imported ri_ref at
+        { path = in_base pkg_path path; package = Some pkg }
     | None -> err_package_not_defined msgs at pkg
     end
   | Ok (Url.Ic bytes) ->
diff --git a/src/prelude/prim.mo b/src/prelude/prim.mo
index e95c96d38e9..98e1eb93b23 100644
--- a/src/prelude/prim.mo
+++ b/src/prelude/prim.mo
@@ -210,25 +210,25 @@ func clzNat64(w : Nat64) : Nat64 = (prim "clz64" : Nat64 -> Nat64) w;
 func ctzNat64(w : Nat64) : Nat64 = (prim "ctz64" : Nat64 -> Nat64) w;
 func btstNat64(w : Nat64, amount : Nat64) : Bool = (prim "btst64" : (Nat64, Nat64) -> Nat64)(w, amount) != (0 : Nat64);
 
-func popcntInt8(w : Int8) : Int8 = (prim "popcnt8" : Int8 -> Int8) w;
-func clzInt8(w : Int8) : Int8 = (prim "clz8" : Int8 -> Int8) w;
-func ctzInt8(w : Int8) : Int8 = (prim "ctz8" : Int8 -> Int8) w;
-func btstInt8(w : Int8, amount : Int8) : Bool = (prim "btst8" : (Int8, Int8) -> Int8)(w, amount) != (0 : Int8);
-
-func popcntInt16(w : Int16) : Int16 = (prim "popcnt16" : Int16 -> Int16) w;
-func clzInt16(w : Int16) : Int16 = (prim "clz16" : Int16 -> Int16) w;
-func ctzInt16(w : Int16) : Int16 = (prim "ctz16" : Int16 -> Int16) w;
-func btstInt16(w : Int16, amount : Int16) : Bool = (prim "btst16" : (Int16, Int16) -> Int16)(w, amount) != (0 : Int16);
-
-func popcntInt32(w : Int32) : Int32 = (prim "popcnt32" : Int32 -> Int32) w;
-func clzInt32(w : Int32) : Int32 = (prim "clz32" : Int32 -> Int32) w;
-func ctzInt32(w : Int32) : Int32 = (prim "ctz32" : Int32 -> Int32) w;
-func btstInt32(w : Int32, amount : Int32) : Bool = (prim "btst32" : (Int32, Int32) -> Int32)(w, amount) != (0 : Int32);
-
-func popcntInt64(w : Int64) : Int64 = (prim "popcnt64" : Int64 -> Int64) w;
-func clzInt64(w : Int64) : Int64 = (prim "clz64" : Int64 -> Int64) w;
-func ctzInt64(w : Int64) : Int64 = (prim "ctz64" : Int64 -> Int64) w;
-func btstInt64(w : Int64, amount : Int64) : Bool = (prim "btst64" : (Int64, Int64) -> Int64)(w, amount) != (0 : Int64);
+func popcntInt8(w : Int8) : Int8 = (prim "popcntInt8" : Int8 -> Int8) w;
+func clzInt8(w : Int8) : Int8 = (prim "clzInt8" : Int8 -> Int8) w;
+func ctzInt8(w : Int8) : Int8 = (prim "ctzInt8" : Int8 -> Int8) w;
+func btstInt8(w : Int8, amount : Int8) : Bool = (prim "btstInt8" : (Int8, Int8) -> Int8) (w, amount) != (0 : Int8);
+
+func popcntInt16(w : Int16) : Int16 = (prim "popcntInt16" : Int16 -> Int16) w;
+func clzInt16(w : Int16) : Int16 = (prim "clzInt16" : Int16 -> Int16) w;
+func ctzInt16(w : Int16) : Int16 = (prim "ctzInt16" : Int16 -> Int16) w;
+func btstInt16(w : Int16, amount : Int16) : Bool = (prim "btstInt16" : (Int16, Int16) -> Int16) (w, amount) != (0 : Int16);
+
+func popcntInt32(w : Int32) : Int32 = (prim "popcntInt32" : Int32 -> Int32) w;
+func clzInt32(w : Int32) : Int32 = (prim "clzInt32" : Int32 -> Int32) w;
+func ctzInt32(w : Int32) : Int32 = (prim "ctzInt32" : Int32 -> Int32) w;
+func btstInt32(w : Int32, amount : Int32) : Bool = (prim "btstInt32" : (Int32, Int32) -> Int32)(w, amount) != (0 : Int32);
+
+func popcntInt64(w : Int64) : Int64 = (prim "popcntInt64" : Int64 -> Int64) w;
+func clzInt64(w : Int64) : Int64 = (prim "clzInt64" : Int64 -> Int64) w;
+func ctzInt64(w : Int64) : Int64 = (prim "ctzInt64" : Int64 -> Int64) w;
+func btstInt64(w : Int64, amount : Int64) : Bool = (prim "btstInt64" : (Int64, Int64) -> Int64)(w, amount) != (0 : Int64);
 
 // Float operations
 
diff --git a/test/bench/alloc.mo b/test/bench/alloc.mo
index 8b37969148d..5aeb0fa9242 100644
--- a/test/bench/alloc.mo
+++ b/test/bench/alloc.mo
@@ -1,7 +1,7 @@
 //MOC-FLAG --force-gc
 import { performanceCounter; rts_heap_size; debugPrint } = "mo:⛔";
 
-actor alloc {
+actor _alloc {
 
     func counters() : (Int, Nat64) = (rts_heap_size(), performanceCounter(0));
 
@@ -16,7 +16,6 @@ actor alloc {
         };
         let (m1, n1) = counters();
         debugPrint(debug_show (m1 - m0, n1 - n0));
-
     }
 }
 //SKIP run-low
diff --git a/test/bench/nat16.mo b/test/bench/nat16.mo
index 5719d226894..1679868461b 100644
--- a/test/bench/nat16.mo
+++ b/test/bench/nat16.mo
@@ -19,7 +19,6 @@ actor Tagged {
         temp := n *% n;
         n += 1;
       };
-
       i += 1;
     };
     let (m1, n1) = counters();
diff --git a/test/bench/ok/alloc.drun-run.ok b/test/bench/ok/alloc.drun-run.ok
index a3168dac965..84bd19db7a5 100644
--- a/test/bench/ok/alloc.drun-run.ok
+++ b/test/bench/ok/alloc.drun-run.ok
@@ -1,8 +1,8 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_244_641_333)
+debug.print: (+335_544_320, 4_613_740_101)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_244_638_420)
+debug.print: (+335_544_320, 4_613_737_188)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_244_638_435)
+debug.print: (+335_544_320, 4_613_737_203)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/bignum.drun-run.ok b/test/bench/ok/bignum.drun-run.ok
index 5ce8915c9a4..2eecb7e0257 100644
--- a/test/bench/ok/bignum.drun-run.ok
+++ b/test/bench/ok/bignum.drun-run.ok
@@ -1,6 +1,6 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 2_631_657; size = +60_608}
+debug.print: {cycles = 2_631_839; size = +60_608}
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 107_963_330; size = +1_827_460}
+debug.print: {cycles = 107_963_422; size = +1_827_460}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/bignum.tc.ok b/test/bench/ok/bignum.tc.ok
new file mode 100644
index 00000000000..90a561535aa
--- /dev/null
+++ b/test/bench/ok/bignum.tc.ok
@@ -0,0 +1 @@
+bignum.mo:4.7-4.13: warning [M0194], unused identifier Bignum (delete or rename to wildcard `_` or `_Bignum`)
diff --git a/test/bench/ok/heap-32.drun-run.ok b/test/bench/ok/heap-32.drun-run.ok
index 98c7140a2b5..377af51b5fd 100644
--- a/test/bench/ok/heap-32.drun-run.ok
+++ b/test/bench/ok/heap-32.drun-run.ok
@@ -1,5 +1,5 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (50_227, +37_021_304, 816_577_323)
-debug.print: (50_070, +40_056_236, 879_831_106)
+debug.print: (50_227, +40_579_412, 879_264_651)
+debug.print: (50_070, +42_103_788, 913_585_900)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/heap-32.tc.ok b/test/bench/ok/heap-32.tc.ok
new file mode 100644
index 00000000000..58e19b51323
--- /dev/null
+++ b/test/bench/ok/heap-32.tc.ok
@@ -0,0 +1 @@
+heap-32.mo:5.7-5.13: warning [M0194], unused identifier Tagged (delete or rename to wildcard `_` or `_Tagged`)
diff --git a/test/bench/ok/nat16.drun-run.ok b/test/bench/ok/nat16.drun-run.ok
index 93bdc7e9135..9bb141f2499 100644
--- a/test/bench/ok/nat16.drun-run.ok
+++ b/test/bench/ok/nat16.drun-run.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (0, 51_380_877)
+debug.print: (0, 55_575_377)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/nat16.tc.ok b/test/bench/ok/nat16.tc.ok
new file mode 100644
index 00000000000..0951a613f78
--- /dev/null
+++ b/test/bench/ok/nat16.tc.ok
@@ -0,0 +1,2 @@
+nat16.mo:2.10-2.24: warning [M0194], unused identifier Array_tabulate (delete or rename to wildcard `_` or `_Array_tabulate`)
+nat16.mo:4.7-4.13: warning [M0194], unused identifier Tagged (delete or rename to wildcard `_` or `_Tagged`)
diff --git a/test/bench/ok/palindrome.drun-run.ok b/test/bench/ok/palindrome.drun-run.ok
index 4a6505f0c28..d9cdd47a4a4 100644
--- a/test/bench/ok/palindrome.drun-run.ok
+++ b/test/bench/ok/palindrome.drun-run.ok
@@ -1,9 +1,9 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (true, +1_544, 26_916)
-debug.print: (false, +1_544, 25_140)
-debug.print: (false, +1_544, 26_850)
-debug.print: (true, +1_156, 27_220)
-debug.print: (false, +1_144, 24_683)
-debug.print: (false, +1_144, 27_053)
+debug.print: (true, +1_544, 27_046)
+debug.print: (false, +1_544, 25_210)
+debug.print: (false, +1_544, 26_980)
+debug.print: (true, +1_156, 27_350)
+debug.print: (false, +1_144, 24_753)
+debug.print: (false, +1_144, 27_183)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/palindrome.tc.ok b/test/bench/ok/palindrome.tc.ok
index 03b8491c4a7..c63bb0adeaa 100644
--- a/test/bench/ok/palindrome.tc.ok
+++ b/test/bench/ok/palindrome.tc.ok
@@ -22,3 +22,4 @@ palindrome.mo:36.17-36.21: warning [M0145], this pattern of type
   List<Char> = ?(Char, List<Char>)
 does not cover value
   ?(_)
+palindrome.mo:6.7-6.17: warning [M0194], unused identifier Palindrome (delete or rename to wildcard `_` or `_Palindrome`)
diff --git a/test/bench/ok/region-mem.drun-run.ok b/test/bench/ok/region-mem.drun-run.ok
index 7e5ebd3f0b6..57d066465f4 100644
--- a/test/bench/ok/region-mem.drun-run.ok
+++ b/test/bench/ok/region-mem.drun-run.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 9_386_852_794}
+debug.print: {heap_diff = 0; instr_diff = 9_437_184_446}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/region-mem.tc.ok b/test/bench/ok/region-mem.tc.ok
new file mode 100644
index 00000000000..0880cff51c4
--- /dev/null
+++ b/test/bench/ok/region-mem.tc.ok
@@ -0,0 +1 @@
+region-mem.mo:13.7-13.16: warning [M0194], unused identifier stablemem (delete or rename to wildcard `_` or `_stablemem`)
diff --git a/test/bench/ok/region0-mem.drun-run.ok b/test/bench/ok/region0-mem.drun-run.ok
index 1ddc9e6da71..b33378a41c4 100644
--- a/test/bench/ok/region0-mem.drun-run.ok
+++ b/test/bench/ok/region0-mem.drun-run.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 8_757_707_194}
+debug.print: {heap_diff = 0; instr_diff = 8_808_038_846}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/region0-mem.tc.ok b/test/bench/ok/region0-mem.tc.ok
new file mode 100644
index 00000000000..4e744ef79eb
--- /dev/null
+++ b/test/bench/ok/region0-mem.tc.ok
@@ -0,0 +1 @@
+region0-mem.mo:12.7-12.16: warning [M0194], unused identifier stablemem (delete or rename to wildcard `_` or `_stablemem`)
diff --git a/test/bench/ok/stable-mem.drun-run.ok b/test/bench/ok/stable-mem.drun-run.ok
index 2dd9a6cf0e4..759ac4e36bb 100644
--- a/test/bench/ok/stable-mem.drun-run.ok
+++ b/test/bench/ok/stable-mem.drun-run.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 4_932_501_946}
+debug.print: {heap_diff = 0; instr_diff = 4_982_833_598}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/stable-mem.tc.ok b/test/bench/ok/stable-mem.tc.ok
new file mode 100644
index 00000000000..f6a3ee2d3ff
--- /dev/null
+++ b/test/bench/ok/stable-mem.tc.ok
@@ -0,0 +1 @@
+stable-mem.mo:13.7-13.16: warning [M0194], unused identifier stablemem (delete or rename to wildcard `_` or `_stablemem`)
diff --git a/test/fail/lib/unused1.mo b/test/fail/lib/unused1.mo
new file mode 100644
index 00000000000..7ccf3e5c6ea
--- /dev/null
+++ b/test/fail/lib/unused1.mo
@@ -0,0 +1,6 @@
+module {
+
+  // a private, unused definition
+  let unused = 1;
+
+}
diff --git a/test/fail/lib/unused2.mo b/test/fail/lib/unused2.mo
new file mode 100644
index 00000000000..76b55a11c14
--- /dev/null
+++ b/test/fail/lib/unused2.mo
@@ -0,0 +1,9 @@
+import _Unused1 "mo:lib/unused3"; // don't report package imports usage warning
+import _Unused2 "unused4"; // do report relative imports usage warning
+
+module {
+
+  // a private, unused definition
+  let unused2 = 1;
+
+}
diff --git a/test/fail/lib/unused3.mo b/test/fail/lib/unused3.mo
new file mode 100644
index 00000000000..332ba25c5eb
--- /dev/null
+++ b/test/fail/lib/unused3.mo
@@ -0,0 +1,6 @@
+module {
+
+  // a private, unused definition
+  let unused3 = 1;
+
+}
diff --git a/test/fail/lib/unused4.mo b/test/fail/lib/unused4.mo
new file mode 100644
index 00000000000..b81234e55aa
--- /dev/null
+++ b/test/fail/lib/unused4.mo
@@ -0,0 +1,6 @@
+module {
+
+  // a private, unused definition
+  let unused4 = 1;
+
+}
diff --git a/test/fail/ok/M0127.tc.ok b/test/fail/ok/M0127.tc.ok
index 47d66226dab..0e1f6740d69 100644
--- a/test/fail/ok/M0127.tc.ok
+++ b/test/fail/ok/M0127.tc.ok
@@ -2,3 +2,4 @@ M0127.mo:2.3-2.40: type error [M0127], system function preupgrade is declared wi
   Bool -> ()
 instead of expected type
   () -> ()
+M0127.mo:2.26-2.29: warning [M0194], unused identifier foo (delete or rename to wildcard `_` or `_foo`)
diff --git a/test/fail/ok/M0128.tc.ok b/test/fail/ok/M0128.tc.ok
index 780e7ca8b15..d97927f8a94 100644
--- a/test/fail/ok/M0128.tc.ok
+++ b/test/fail/ok/M0128.tc.ok
@@ -1 +1,3 @@
 M0128.mo:2.8-2.18: warning [M0128], this function has the name of a system method, but is declared without system visibility and will not be called by the system
+M0128.mo:2.8-2.18: warning [M0194], unused identifier preupgrade (delete or rename to wildcard `_` or `_preupgrade`)
+M0128.mo:2.19-2.22: warning [M0194], unused identifier foo (delete or rename to wildcard `_` or `_foo`)
diff --git a/test/fail/ok/abstract-msgs.tc.ok b/test/fail/ok/abstract-msgs.tc.ok
index b42a3764525..f3a1d965212 100644
--- a/test/fail/ok/abstract-msgs.tc.ok
+++ b/test/fail/ok/abstract-msgs.tc.ok
@@ -14,3 +14,8 @@ abstract-msgs.mo:16.34-16.35: type error [M0031], shared function has non-shared
   A__16
 abstract-msgs.mo:17.27-17.47: type error [M0032], shared function has non-shared return type
   A__17
+abstract-msgs.mo:2.33-2.34: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+abstract-msgs.mo:4.11-4.14: warning [M0194], unused identifier foo (delete or rename to wildcard `_` or `_foo`)
+abstract-msgs.mo:5.25-5.26: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+abstract-msgs.mo:23.38-23.41: warning [M0194], unused identifier bar (delete or rename to wildcard `_` or `_bar`)
+abstract-msgs.mo:23.42-23.43: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
diff --git a/test/fail/ok/actor-cap.tc.ok b/test/fail/ok/actor-cap.tc.ok
index d624089b85a..5849d301540 100644
--- a/test/fail/ok/actor-cap.tc.ok
+++ b/test/fail/ok/actor-cap.tc.ok
@@ -2,3 +2,5 @@ actor-cap.mo:4.3-4.14: type error [M0085], misplaced return
 actor-cap.mo:5.3-5.30: type error [M0039], misplaced throw
 actor-cap.mo:9.4-9.15: type error [M0085], misplaced return
 actor-cap.mo:10.4-10.31: type error [M0039], misplaced throw
+actor-cap.mo:3.13-3.14: warning [M0194], unused identifier C (delete or rename to wildcard `_` or `_C`)
+actor-cap.mo:8.7-8.11: warning [M0194], unused identifier self (delete or rename to wildcard `_` or `_self`)
diff --git a/test/fail/ok/actor-class-generic.tc.ok b/test/fail/ok/actor-class-generic.tc.ok
index a07f7e68520..774a44ea185 100644
--- a/test/fail/ok/actor-class-generic.tc.ok
+++ b/test/fail/ok/actor-class-generic.tc.ok
@@ -1 +1,2 @@
 actor-class-generic.mo:1.1-1.21: type error [M0140], actor classes with type parameters are not supported yet
+actor-class-generic.mo:1.13-1.14: warning [M0194], unused identifier C (delete or rename to wildcard `_` or `_C`)
diff --git a/test/fail/ok/actor-class-star.tc.ok b/test/fail/ok/actor-class-star.tc.ok
index bed24a3b8a5..7ddd1d88ccc 100644
--- a/test/fail/ok/actor-class-star.tc.ok
+++ b/test/fail/ok/actor-class-star.tc.ok
@@ -1 +1,2 @@
 actor-class-star.mo:1.1-1.39: type error [M0193], actor class has non-async return type
+actor-class-star.mo:1.13-1.14: warning [M0194], unused identifier C (delete or rename to wildcard `_` or `_C`)
diff --git a/test/fail/ok/argument-subtyping.tc.ok b/test/fail/ok/argument-subtyping.tc.ok
index 45b976b6617..33265369905 100644
--- a/test/fail/ok/argument-subtyping.tc.ok
+++ b/test/fail/ok/argument-subtyping.tc.ok
@@ -2,3 +2,7 @@ argument-subtyping.mo:12.61-12.62: type error [M0096], expression of type
   shared Nat -> ()
 cannot produce expected type
   shared Text -> ()
+argument-subtyping.mo:2.11-2.14: warning [M0194], unused identifier foo (delete or rename to wildcard `_` or `_foo`)
+argument-subtyping.mo:5.11-5.14: warning [M0194], unused identifier foo (delete or rename to wildcard `_` or `_foo`)
+argument-subtyping.mo:8.11-8.14: warning [M0194], unused identifier foo (delete or rename to wildcard `_` or `_foo`)
+argument-subtyping.mo:9.11-9.14: warning [M0194], unused identifier foo (delete or rename to wildcard `_` or `_foo`)
diff --git a/test/fail/ok/asyncret2.tc.ok b/test/fail/ok/asyncret2.tc.ok
index dda875dd99e..a1ccca0cacd 100644
--- a/test/fail/ok/asyncret2.tc.ok
+++ b/test/fail/ok/asyncret2.tc.ok
@@ -2,3 +2,4 @@ asyncret2.mo:1.54-1.57: type error [M0096], expression of type
   async<$call3> Int
 cannot produce expected type
   Int
+asyncret2.mo:1.6-1.11: warning [M0194], unused identifier call3 (delete or rename to wildcard `_` or `_call3`)
diff --git a/test/fail/ok/bad-actor.tc.ok b/test/fail/ok/bad-actor.tc.ok
index 60d5d628269..1092d50039b 100644
--- a/test/fail/ok/bad-actor.tc.ok
+++ b/test/fail/ok/bad-actor.tc.ok
@@ -11,3 +11,9 @@ bad-actor.mo:8.1-8.38: type error [M0134], class body of type
 does not match expected type
   {}
 bad-actor.mo:9.1-9.31: warning [M0135], actor classes with non non-async return types are deprecated; please declare the return type as 'async ...'
+bad-actor.mo:1.13-1.14: warning [M0194], unused identifier A (delete or rename to wildcard `_` or `_A`)
+bad-actor.mo:3.13-3.15: warning [M0194], unused identifier A1 (delete or rename to wildcard `_` or `_A1`)
+bad-actor.mo:4.13-4.15: warning [M0194], unused identifier A2 (delete or rename to wildcard `_` or `_A2`)
+bad-actor.mo:6.13-6.15: warning [M0194], unused identifier A3 (delete or rename to wildcard `_` or `_A3`)
+bad-actor.mo:8.13-8.15: warning [M0194], unused identifier A4 (delete or rename to wildcard `_` or `_A4`)
+bad-actor.mo:9.13-9.15: warning [M0194], unused identifier A5 (delete or rename to wildcard `_` or `_A5`)
diff --git a/test/fail/ok/bad-async-sort.tc.ok b/test/fail/ok/bad-async-sort.tc.ok
index 7012cfa0cce..aac413f2e41 100644
--- a/test/fail/ok/bad-async-sort.tc.ok
+++ b/test/fail/ok/bad-async-sort.tc.ok
@@ -16,3 +16,7 @@ Use keyword 'async*' (not 'async') to produce the expected type.
 bad-async-sort.mo:23.14-23.23: type error [M0183], async expression cannot produce expected async type 
   async<$anon4> ().
 Use keyword 'async' (not 'async*') to produce the expected type.
+bad-async-sort.mo:10.8-10.13: warning [M0194], unused identifier anon1 (delete or rename to wildcard `_` or `_anon1`)
+bad-async-sort.mo:14.8-14.13: warning [M0194], unused identifier anon2 (delete or rename to wildcard `_` or `_anon2`)
+bad-async-sort.mo:18.8-18.13: warning [M0194], unused identifier anon3 (delete or rename to wildcard `_` or `_anon3`)
+bad-async-sort.mo:22.8-22.13: warning [M0194], unused identifier anon4 (delete or rename to wildcard `_` or `_anon4`)
diff --git a/test/fail/ok/bad-async.tc.ok b/test/fail/ok/bad-async.tc.ok
index 9475c359d75..e18e0502ff8 100644
--- a/test/fail/ok/bad-async.tc.ok
+++ b/test/fail/ok/bad-async.tc.ok
@@ -1,11 +1,11 @@
 bad-async.mo:4.32-4.42: type error [M0096], expression of type
   async<$foo1> Nat
 cannot produce expected type
-  async<$anon-async-1.1> Nat
-bad-async.mo:7.17-7.21: type error [M0087], ill-scoped await: expected async type from current scope $foo2, found async type from other scope $anon-async-1.1
+  async<$@anon-async-1.1> Nat
+bad-async.mo:7.17-7.21: type error [M0087], ill-scoped await: expected async type from current scope $foo2, found async type from other scope $@anon-async-1.1
   scope $foo2 is bad-async.mo:5.36-8.6
-  scope $anon-async-1.1 is bad-async.mo:1.1-9.2
+  scope $@anon-async-1.1 is bad-async.mo:1.1-9.2
 bad-async.mo:5.36: info, start of scope $foo2 mentioned in error at bad-async.mo:7.11-7.21
 bad-async.mo:8.5: info, end of scope $foo2 mentioned in error at bad-async.mo:7.11-7.21
-bad-async.mo:1.1: info, start of scope $anon-async-1.1 mentioned in error at bad-async.mo:7.11-7.21
-bad-async.mo:9.1: info, end of scope $anon-async-1.1 mentioned in error at bad-async.mo:7.11-7.21
+bad-async.mo:1.1: info, start of scope $@anon-async-1.1 mentioned in error at bad-async.mo:7.11-7.21
+bad-async.mo:9.1: info, end of scope $@anon-async-1.1 mentioned in error at bad-async.mo:7.11-7.21
diff --git a/test/fail/ok/bad-import-decs.tc.ok b/test/fail/ok/bad-import-decs.tc.ok
index 10c8f63cc0e..5d2d80d4bbc 100644
--- a/test/fail/ok/bad-import-decs.tc.ok
+++ b/test/fail/ok/bad-import-decs.tc.ok
@@ -1 +1,2 @@
 lib/decs.mo:0.1: warning [M0142], deprecated syntax: an imported library should be a module or named actor class
+bad-import-decs.mo:1.8-1.9: warning [M0194], unused identifier C (delete or rename to wildcard `_` or `_C`)
diff --git a/test/fail/ok/bad-unops.tc.ok b/test/fail/ok/bad-unops.tc.ok
index 7535da1e76f..d3a8be72de7 100644
--- a/test/fail/ok/bad-unops.tc.ok
+++ b/test/fail/ok/bad-unops.tc.ok
@@ -15,3 +15,7 @@ bad-unops.mo:6.20-6.22: type error [M0111], operator pattern cannot consume expe
 bad-unops.mo:8.20-8.22: warning [M0146], this pattern is never matched
 bad-unops.mo:10.21-10.23: type error [M0111], operator pattern cannot consume expected type
   Int
+bad-unops.mo:1.5-1.6: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+bad-unops.mo:2.5-2.6: warning [M0194], unused identifier b (delete or rename to wildcard `_` or `_b`)
+bad-unops.mo:3.5-3.6: warning [M0194], unused identifier c (delete or rename to wildcard `_` or `_c`)
+bad-unops.mo:4.5-4.6: warning [M0194], unused identifier d (delete or rename to wildcard `_` or `_d`)
diff --git a/test/fail/ok/bang-fail.tc.ok b/test/fail/ok/bang-fail.tc.ok
index 2f6525e532e..de6ff28d89c 100644
--- a/test/fail/ok/bang-fail.tc.ok
+++ b/test/fail/ok/bang-fail.tc.ok
@@ -12,3 +12,8 @@ bang-fail.mo:18.17-18.19: type error [M0096], expression of type
   ()
 cannot produce expected type
   Nat
+bang-fail.mo:1.6-1.12: warning [M0194], unused identifier wrong1 (delete or rename to wildcard `_` or `_wrong1`)
+bang-fail.mo:5.6-5.12: warning [M0194], unused identifier wrong2 (delete or rename to wildcard `_` or `_wrong2`)
+bang-fail.mo:9.6-9.12: warning [M0194], unused identifier wrong3 (delete or rename to wildcard `_` or `_wrong3`)
+bang-fail.mo:13.6-13.12: warning [M0194], unused identifier wrong4 (delete or rename to wildcard `_` or `_wrong4`)
+bang-fail.mo:17.6-17.12: warning [M0194], unused identifier wrong5 (delete or rename to wildcard `_` or `_wrong5`)
diff --git a/test/fail/ok/bounds-mismatch.tc.ok b/test/fail/ok/bounds-mismatch.tc.ok
index ee5f86b2b19..d4c2e647e44 100644
--- a/test/fail/ok/bounds-mismatch.tc.ok
+++ b/test/fail/ok/bounds-mismatch.tc.ok
@@ -66,3 +66,19 @@ cannot produce expected type
 bounds-mismatch.mo:125.21-128.4: warning [M0074], this array has type
   [Any]
 because elements have inconsistent types
+bounds-mismatch.mo:2.10-2.11: warning [M0194], unused identifier g (delete or rename to wildcard `_` or `_g`)
+bounds-mismatch.mo:7.10-7.11: warning [M0194], unused identifier g (delete or rename to wildcard `_` or `_g`)
+bounds-mismatch.mo:12.10-12.11: warning [M0194], unused identifier g (delete or rename to wildcard `_` or `_g`)
+bounds-mismatch.mo:17.10-17.11: warning [M0194], unused identifier g (delete or rename to wildcard `_` or `_g`)
+bounds-mismatch.mo:22.10-22.11: warning [M0194], unused identifier g (delete or rename to wildcard `_` or `_g`)
+bounds-mismatch.mo:27.10-27.11: warning [M0194], unused identifier g (delete or rename to wildcard `_` or `_g`)
+bounds-mismatch.mo:32.10-32.11: warning [M0194], unused identifier g (delete or rename to wildcard `_` or `_g`)
+bounds-mismatch.mo:37.10-37.11: warning [M0194], unused identifier g (delete or rename to wildcard `_` or `_g`)
+bounds-mismatch.mo:75.6-75.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+bounds-mismatch.mo:81.6-81.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+bounds-mismatch.mo:87.6-87.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+bounds-mismatch.mo:93.6-93.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+bounds-mismatch.mo:99.6-99.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+bounds-mismatch.mo:106.6-106.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+bounds-mismatch.mo:126.41-126.42: warning [M0194], unused identifier b (delete or rename to wildcard `_` or `_b`)
+bounds-mismatch.mo:127.41-127.42: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
diff --git a/test/fail/ok/branch-before-define.tc.ok b/test/fail/ok/branch-before-define.tc.ok
index 287eaf9df7a..8b2dce919a6 100644
--- a/test/fail/ok/branch-before-define.tc.ok
+++ b/test/fail/ok/branch-before-define.tc.ok
@@ -1 +1,2 @@
+branch-before-define.mo:18.5-18.10: warning [M0194], unused identifier wrong (delete or rename to wildcard `_` or `_wrong`)
 branch-before-define.mo:7.7-7.40: definedness error [M0016], cannot use g before x has been defined
diff --git a/test/fail/ok/check-record.tc.ok b/test/fail/ok/check-record.tc.ok
index 073732b8790..30be9fa2423 100644
--- a/test/fail/ok/check-record.tc.ok
+++ b/test/fail/ok/check-record.tc.ok
@@ -14,3 +14,5 @@ check-record.mo:24.9-24.27: type error [M0096], expression of type
   {a : Nat}
 cannot produce expected type
   {b : Nat}
+check-record.mo:6.5-6.6: warning [M0194], unused identifier r (delete or rename to wildcard `_` or `_r`)
+check-record.mo:20.7-20.8: warning [M0194], unused identifier b (delete or rename to wildcard `_` or `_b`)
diff --git a/test/fail/ok/const-var-array.tc.ok b/test/fail/ok/const-var-array.tc.ok
index ef87c4c77c5..4a4022823f6 100644
--- a/test/fail/ok/const-var-array.tc.ok
+++ b/test/fail/ok/const-var-array.tc.ok
@@ -1,2 +1,3 @@
 const-var-array.mo:1.17-1.22: type error [M0091], mutable array expression cannot produce expected type
   [Nat]
+const-var-array.mo:1.5-1.6: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
diff --git a/test/fail/ok/const-var-field.tc.ok b/test/fail/ok/const-var-field.tc.ok
index 0e1d0a88dca..d34989196c8 100644
--- a/test/fail/ok/const-var-field.tc.ok
+++ b/test/fail/ok/const-var-field.tc.ok
@@ -2,3 +2,4 @@ const-var-field.mo:1.21-1.48: type error [M0096], expression of type
   {var x : Nat}
 cannot produce expected type
   {x : Nat}
+const-var-field.mo:1.5-1.6: warning [M0194], unused identifier o (delete or rename to wildcard `_` or `_o`)
diff --git a/test/fail/ok/f-bounds-fail.tc.ok b/test/fail/ok/f-bounds-fail.tc.ok
index ef6436ba0fe..13cad21c683 100644
--- a/test/fail/ok/f-bounds-fail.tc.ok
+++ b/test/fail/ok/f-bounds-fail.tc.ok
@@ -174,3 +174,30 @@ f-bounds-fail.mo:82.26-82.27: type error [M0096], expression of type
   B__13
 cannot produce expected type
   C__9
+f-bounds-fail.mo:3.5-3.6: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+f-bounds-fail.mo:5.6-5.9: warning [M0194], unused identifier f2a (delete or rename to wildcard `_` or `_f2a`)
+f-bounds-fail.mo:7.6-7.9: warning [M0194], unused identifier f2b (delete or rename to wildcard `_` or `_f2b`)
+f-bounds-fail.mo:9.6-9.9: warning [M0194], unused identifier f3a (delete or rename to wildcard `_` or `_f3a`)
+f-bounds-fail.mo:10.6-10.9: warning [M0194], unused identifier f3b (delete or rename to wildcard `_` or `_f3b`)
+f-bounds-fail.mo:11.6-11.9: warning [M0194], unused identifier f3c (delete or rename to wildcard `_` or `_f3c`)
+f-bounds-fail.mo:45.6-45.8: warning [M0194], unused identifier u0 (delete or rename to wildcard `_` or `_u0`)
+f-bounds-fail.mo:46.6-46.8: warning [M0194], unused identifier u1 (delete or rename to wildcard `_` or `_u1`)
+f-bounds-fail.mo:47.6-47.8: warning [M0194], unused identifier u2 (delete or rename to wildcard `_` or `_u2`)
+f-bounds-fail.mo:48.6-48.8: warning [M0194], unused identifier u3 (delete or rename to wildcard `_` or `_u3`)
+f-bounds-fail.mo:49.6-49.8: warning [M0194], unused identifier u4 (delete or rename to wildcard `_` or `_u4`)
+f-bounds-fail.mo:50.6-50.8: warning [M0194], unused identifier u5 (delete or rename to wildcard `_` or `_u5`)
+f-bounds-fail.mo:51.6-51.8: warning [M0194], unused identifier u6 (delete or rename to wildcard `_` or `_u6`)
+f-bounds-fail.mo:53.6-53.8: warning [M0194], unused identifier v0 (delete or rename to wildcard `_` or `_v0`)
+f-bounds-fail.mo:54.6-54.8: warning [M0194], unused identifier v1 (delete or rename to wildcard `_` or `_v1`)
+f-bounds-fail.mo:55.6-55.8: warning [M0194], unused identifier v2 (delete or rename to wildcard `_` or `_v2`)
+f-bounds-fail.mo:56.6-56.8: warning [M0194], unused identifier v3 (delete or rename to wildcard `_` or `_v3`)
+f-bounds-fail.mo:57.6-57.8: warning [M0194], unused identifier v4 (delete or rename to wildcard `_` or `_v4`)
+f-bounds-fail.mo:58.6-58.8: warning [M0194], unused identifier v5 (delete or rename to wildcard `_` or `_v5`)
+f-bounds-fail.mo:59.6-59.8: warning [M0194], unused identifier v6 (delete or rename to wildcard `_` or `_v6`)
+f-bounds-fail.mo:61.6-61.8: warning [M0194], unused identifier w0 (delete or rename to wildcard `_` or `_w0`)
+f-bounds-fail.mo:62.6-62.8: warning [M0194], unused identifier w1 (delete or rename to wildcard `_` or `_w1`)
+f-bounds-fail.mo:63.6-63.8: warning [M0194], unused identifier w2 (delete or rename to wildcard `_` or `_w2`)
+f-bounds-fail.mo:64.6-64.8: warning [M0194], unused identifier w3 (delete or rename to wildcard `_` or `_w3`)
+f-bounds-fail.mo:65.6-65.8: warning [M0194], unused identifier w4 (delete or rename to wildcard `_` or `_w4`)
+f-bounds-fail.mo:66.6-66.8: warning [M0194], unused identifier w5 (delete or rename to wildcard `_` or `_w5`)
+f-bounds-fail.mo:67.6-67.8: warning [M0194], unused identifier w6 (delete or rename to wildcard `_` or `_w6`)
diff --git a/test/fail/ok/ho-variant.tc.ok b/test/fail/ok/ho-variant.tc.ok
new file mode 100644
index 00000000000..905729d4cae
--- /dev/null
+++ b/test/fail/ok/ho-variant.tc.ok
@@ -0,0 +1,5 @@
+ho-variant.mo:19.5-19.6: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+ho-variant.mo:21.5-21.7: warning [M0194], unused identifier x0 (delete or rename to wildcard `_` or `_x0`)
+ho-variant.mo:22.5-22.7: warning [M0194], unused identifier x1 (delete or rename to wildcard `_` or `_x1`)
+ho-variant.mo:23.5-23.7: warning [M0194], unused identifier x2 (delete or rename to wildcard `_` or `_x2`)
+ho-variant.mo:26.5-26.6: warning [M0194], unused identifier z (delete or rename to wildcard `_` or `_z`)
diff --git a/test/fail/ok/illegal-await.tc.ok b/test/fail/ok/illegal-await.tc.ok
index 70d77316b5d..6c1ca3d8d23 100644
--- a/test/fail/ok/illegal-await.tc.ok
+++ b/test/fail/ok/illegal-await.tc.ok
@@ -1,29 +1,29 @@
-illegal-await.mo:3.36-3.37: type error [M0087], ill-scoped await: expected async type from current scope $anon-async-3.22, found async type from other scope $top-level
-  scope $anon-async-3.22 is illegal-await.mo:3.22-3.40
+illegal-await.mo:3.36-3.37: type error [M0087], ill-scoped await: expected async type from current scope $@anon-async-3.22, found async type from other scope $top-level
+  scope $@anon-async-3.22 is illegal-await.mo:3.22-3.40
   scope $top-level is the global scope
-illegal-await.mo:3.22: info, start of scope $anon-async-3.22 mentioned in error at illegal-await.mo:3.30-3.37
-illegal-await.mo:3.39: info, end of scope $anon-async-3.22 mentioned in error at illegal-await.mo:3.30-3.37
-illegal-await.mo:12.39-12.41: type error [M0087], ill-scoped await: expected async type from current scope $anon-async-12.25, found async type from other scope $anon-async-11.10
-  scope $anon-async-12.25 is illegal-await.mo:12.25-12.44
-  scope $anon-async-11.10 is illegal-await.mo:11.10-15.4
-illegal-await.mo:12.25: info, start of scope $anon-async-12.25 mentioned in error at illegal-await.mo:12.33-12.41
-illegal-await.mo:12.43: info, end of scope $anon-async-12.25 mentioned in error at illegal-await.mo:12.33-12.41
-illegal-await.mo:11.10: info, start of scope $anon-async-11.10 mentioned in error at illegal-await.mo:12.33-12.41
-illegal-await.mo:15.3: info, end of scope $anon-async-11.10 mentioned in error at illegal-await.mo:12.33-12.41
-illegal-await.mo:13.39-13.41: type error [M0087], ill-scoped await: expected async type from current scope $anon-async-13.25, found async type from other scope $anon-async-11.10
-  scope $anon-async-13.25 is illegal-await.mo:13.25-13.44
-  scope $anon-async-11.10 is illegal-await.mo:11.10-15.4
-illegal-await.mo:13.25: info, start of scope $anon-async-13.25 mentioned in error at illegal-await.mo:13.33-13.41
-illegal-await.mo:13.43: info, end of scope $anon-async-13.25 mentioned in error at illegal-await.mo:13.33-13.41
-illegal-await.mo:11.10: info, start of scope $anon-async-11.10 mentioned in error at illegal-await.mo:13.33-13.41
-illegal-await.mo:15.3: info, end of scope $anon-async-11.10 mentioned in error at illegal-await.mo:13.33-13.41
-illegal-await.mo:25.13-25.14: type error [M0087], ill-scoped await: expected async type from current scope $anon-async-24.11, found async type from other scope $anon-async-22.10
-  scope $anon-async-24.11 is illegal-await.mo:24.11-26.6
-  scope $anon-async-22.10 is illegal-await.mo:22.10-27.4
-illegal-await.mo:24.11: info, start of scope $anon-async-24.11 mentioned in error at illegal-await.mo:25.7-25.14
-illegal-await.mo:26.5: info, end of scope $anon-async-24.11 mentioned in error at illegal-await.mo:25.7-25.14
-illegal-await.mo:22.10: info, start of scope $anon-async-22.10 mentioned in error at illegal-await.mo:25.7-25.14
-illegal-await.mo:27.3: info, end of scope $anon-async-22.10 mentioned in error at illegal-await.mo:25.7-25.14
+illegal-await.mo:3.22: info, start of scope $@anon-async-3.22 mentioned in error at illegal-await.mo:3.30-3.37
+illegal-await.mo:3.39: info, end of scope $@anon-async-3.22 mentioned in error at illegal-await.mo:3.30-3.37
+illegal-await.mo:12.39-12.41: type error [M0087], ill-scoped await: expected async type from current scope $@anon-async-12.25, found async type from other scope $@anon-async-11.10
+  scope $@anon-async-12.25 is illegal-await.mo:12.25-12.44
+  scope $@anon-async-11.10 is illegal-await.mo:11.10-15.4
+illegal-await.mo:12.25: info, start of scope $@anon-async-12.25 mentioned in error at illegal-await.mo:12.33-12.41
+illegal-await.mo:12.43: info, end of scope $@anon-async-12.25 mentioned in error at illegal-await.mo:12.33-12.41
+illegal-await.mo:11.10: info, start of scope $@anon-async-11.10 mentioned in error at illegal-await.mo:12.33-12.41
+illegal-await.mo:15.3: info, end of scope $@anon-async-11.10 mentioned in error at illegal-await.mo:12.33-12.41
+illegal-await.mo:13.39-13.41: type error [M0087], ill-scoped await: expected async type from current scope $@anon-async-13.25, found async type from other scope $@anon-async-11.10
+  scope $@anon-async-13.25 is illegal-await.mo:13.25-13.44
+  scope $@anon-async-11.10 is illegal-await.mo:11.10-15.4
+illegal-await.mo:13.25: info, start of scope $@anon-async-13.25 mentioned in error at illegal-await.mo:13.33-13.41
+illegal-await.mo:13.43: info, end of scope $@anon-async-13.25 mentioned in error at illegal-await.mo:13.33-13.41
+illegal-await.mo:11.10: info, start of scope $@anon-async-11.10 mentioned in error at illegal-await.mo:13.33-13.41
+illegal-await.mo:15.3: info, end of scope $@anon-async-11.10 mentioned in error at illegal-await.mo:13.33-13.41
+illegal-await.mo:25.13-25.14: type error [M0087], ill-scoped await: expected async type from current scope $@anon-async-24.11, found async type from other scope $@anon-async-22.10
+  scope $@anon-async-24.11 is illegal-await.mo:24.11-26.6
+  scope $@anon-async-22.10 is illegal-await.mo:22.10-27.4
+illegal-await.mo:24.11: info, start of scope $@anon-async-24.11 mentioned in error at illegal-await.mo:25.7-25.14
+illegal-await.mo:26.5: info, end of scope $@anon-async-24.11 mentioned in error at illegal-await.mo:25.7-25.14
+illegal-await.mo:22.10: info, start of scope $@anon-async-22.10 mentioned in error at illegal-await.mo:25.7-25.14
+illegal-await.mo:27.3: info, end of scope $@anon-async-22.10 mentioned in error at illegal-await.mo:25.7-25.14
 illegal-await.mo:35.11-35.12: type error [M0087], ill-scoped await: expected async type from current scope $Rec, found async type from other scope $__13
   scope $Rec is illegal-await.mo:33.44-40.2
   scope $__13 is illegal-await.mo:33.1-40.2
diff --git a/test/fail/ok/inference.tc.ok b/test/fail/ok/inference.tc.ok
index 93545774329..07deb617b2d 100644
--- a/test/fail/ok/inference.tc.ok
+++ b/test/fail/ok/inference.tc.ok
@@ -155,3 +155,19 @@ because no instantiation of T__117 makes
   {type x = Nat}  <:  {x : T__117}
 inference.mo:183.8-183.21: type error [M0045], wrong number of type arguments: expected 2 but got 0
 inference.mo:186.8-186.15: type error [M0045], wrong number of type arguments: expected 1 but got 0
+inference.mo:11.14-11.15: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+inference.mo:51.6-51.11: warning [M0194], unused identifier mult1 (delete or rename to wildcard `_` or `_mult1`)
+inference.mo:53.6-53.11: warning [M0194], unused identifier mult2 (delete or rename to wildcard `_` or `_mult2`)
+inference.mo:56.16-56.17: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+inference.mo:75.19-75.20: warning [M0194], unused identifier y (delete or rename to wildcard `_` or `_y`)
+inference.mo:88.23-88.24: warning [M0194], unused identifier y (delete or rename to wildcard `_` or `_y`)
+inference.mo:89.23-89.24: warning [M0194], unused identifier y (delete or rename to wildcard `_` or `_y`)
+inference.mo:90.23-90.24: warning [M0194], unused identifier y (delete or rename to wildcard `_` or `_y`)
+inference.mo:135.6-135.7: warning [M0194], unused identifier g (delete or rename to wildcard `_` or `_g`)
+inference.mo:136.20-136.21: warning [M0194], unused identifier y (delete or rename to wildcard `_` or `_y`)
+inference.mo:140.6-140.7: warning [M0194], unused identifier h (delete or rename to wildcard `_` or `_h`)
+inference.mo:141.20-141.21: warning [M0194], unused identifier y (delete or rename to wildcard `_` or `_y`)
+inference.mo:145.6-145.7: warning [M0194], unused identifier i (delete or rename to wildcard `_` or `_i`)
+inference.mo:150.6-150.7: warning [M0194], unused identifier j (delete or rename to wildcard `_` or `_j`)
+inference.mo:155.6-155.7: warning [M0194], unused identifier k (delete or rename to wildcard `_` or `_k`)
+inference.mo:180.19-180.20: warning [M0194], unused identifier u (delete or rename to wildcard `_` or `_u`)
diff --git a/test/fail/ok/issue-1411.tc.ok b/test/fail/ok/issue-1411.tc.ok
new file mode 100644
index 00000000000..2a149629151
--- /dev/null
+++ b/test/fail/ok/issue-1411.tc.ok
@@ -0,0 +1,2 @@
+issue-1411.mo:6.5-6.7: warning [M0194], unused identifier x1 (delete or rename to wildcard `_` or `_x1`)
+issue-1411.mo:11.5-11.7: warning [M0194], unused identifier x2 (delete or rename to wildcard `_` or `_x2`)
diff --git a/test/fail/ok/issue-3318.tc.ok b/test/fail/ok/issue-3318.tc.ok
index 3e7d42ba5e1..736f0399615 100644
--- a/test/fail/ok/issue-3318.tc.ok
+++ b/test/fail/ok/issue-3318.tc.ok
@@ -22,3 +22,16 @@ issue-3318.mo:33.43-33.44: type error [M0096], expression of type
   (Nat, Nat) -> ((Nat, Nat))
 cannot produce expected type
   ((Nat, Nat)) -> ((Nat, Nat))
+issue-3318.mo:2.13-2.14: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+issue-3318.mo:11.6-11.8: warning [M0194], unused identifier t0 (delete or rename to wildcard `_` or `_t0`)
+issue-3318.mo:14.6-14.8: warning [M0194], unused identifier t1 (delete or rename to wildcard `_` or `_t1`)
+issue-3318.mo:17.6-17.8: warning [M0194], unused identifier t2 (delete or rename to wildcard `_` or `_t2`)
+issue-3318.mo:20.6-20.8: warning [M0194], unused identifier t3 (delete or rename to wildcard `_` or `_t3`)
+issue-3318.mo:23.6-23.8: warning [M0194], unused identifier t4 (delete or rename to wildcard `_` or `_t4`)
+issue-3318.mo:26.6-26.8: warning [M0194], unused identifier t5 (delete or rename to wildcard `_` or `_t5`)
+issue-3318.mo:29.6-29.8: warning [M0194], unused identifier t6 (delete or rename to wildcard `_` or `_t6`)
+issue-3318.mo:32.6-32.8: warning [M0194], unused identifier t7 (delete or rename to wildcard `_` or `_t7`)
+issue-3318.mo:35.6-35.8: warning [M0194], unused identifier t8 (delete or rename to wildcard `_` or `_t8`)
+issue-3318.mo:40.6-40.8: warning [M0194], unused identifier u0 (delete or rename to wildcard `_` or `_u0`)
+issue-3318.mo:42.6-42.8: warning [M0194], unused identifier u1 (delete or rename to wildcard `_` or `_u1`)
+issue-3318.mo:44.6-44.8: warning [M0194], unused identifier u2 (delete or rename to wildcard `_` or `_u2`)
diff --git a/test/fail/ok/issue2062.tc.ok b/test/fail/ok/issue2062.tc.ok
index 74e39a2d498..76e71a03f53 100644
--- a/test/fail/ok/issue2062.tc.ok
+++ b/test/fail/ok/issue2062.tc.ok
@@ -2,3 +2,4 @@ issue2062.mo:2.3-3.11: type error [M0096], expression of type
   ()
 cannot produce expected type
   Nat
+issue2062.mo:1.6-1.9: warning [M0194], unused identifier fac (delete or rename to wildcard `_` or `_fac`)
diff --git a/test/fail/ok/missing-semi.tc.ok b/test/fail/ok/missing-semi.tc.ok
index a529ed7468d..cff52fc4c5d 100644
--- a/test/fail/ok/missing-semi.tc.ok
+++ b/test/fail/ok/missing-semi.tc.ok
@@ -4,3 +4,4 @@ missing-semi.mo:3.5-4.1: info, this looks like an unintended function call, perh
 missing-semi.mo:9.3-9.7: type error [M0097], expected function type, but expression produces type
   ()
 missing-semi.mo:9.7-10.3: info, this looks like an unintended function call, perhaps a missing ';'?
+missing-semi.mo:7.6-7.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
diff --git a/test/fail/ok/modexp3.tc.ok b/test/fail/ok/modexp3.tc.ok
new file mode 100644
index 00000000000..4c51b8295e2
--- /dev/null
+++ b/test/fail/ok/modexp3.tc.ok
@@ -0,0 +1 @@
+modexp3.mo:1.8-1.9: warning [M0194], unused identifier X (delete or rename to wildcard `_` or `_X`)
diff --git a/test/fail/ok/modexp4.tc.ok b/test/fail/ok/modexp4.tc.ok
new file mode 100644
index 00000000000..fa1f130eba4
--- /dev/null
+++ b/test/fail/ok/modexp4.tc.ok
@@ -0,0 +1 @@
+modexp4.mo:2.8-2.9: warning [M0194], unused identifier X (delete or rename to wildcard `_` or `_X`)
diff --git a/test/fail/ok/modexp6.tc.ok b/test/fail/ok/modexp6.tc.ok
index 6cf0e376fef..cea4965ac22 100644
--- a/test/fail/ok/modexp6.tc.ok
+++ b/test/fail/ok/modexp6.tc.ok
@@ -1 +1,2 @@
 modexp6.mo:2.7-2.11: type error [M0015], only trivial patterns allowed in static expressions
+modexp6.mo:1.8-1.9: warning [M0194], unused identifier A (delete or rename to wildcard `_` or `_A`)
diff --git a/test/fail/ok/non_static_module.tc.ok b/test/fail/ok/non_static_module.tc.ok
index 48ff8b1d088..6d445e38710 100644
--- a/test/fail/ok/non_static_module.tc.ok
+++ b/test/fail/ok/non_static_module.tc.ok
@@ -10,3 +10,14 @@ non_static_module.mo:11.4-11.13: type error [M0014], non-static expression in li
 non_static_module.mo:20.12-20.15: type error [M0014], non-static expression in library or module
 non_static_module.mo:21.12-21.19: type error [M0014], non-static expression in library or module
 non_static_module.mo:22.4-22.13: type error [M0014], non-static expression in library or module
+non_static_module.mo:1.8-1.13: warning [M0194], unused identifier Wrong (delete or rename to wildcard `_` or `_Wrong`)
+non_static_module.mo:5.7-5.8: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+non_static_module.mo:6.7-6.8: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+non_static_module.mo:8.10-8.16: warning [M0194], unused identifier WrongO (delete or rename to wildcard `_` or `_WrongO`)
+non_static_module.mo:11.8-11.9: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+non_static_module.mo:14.10-14.13: warning [M0194], unused identifier OkO (delete or rename to wildcard `_` or `_OkO`)
+non_static_module.mo:16.9-16.10: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+non_static_module.mo:19.10-19.16: warning [M0194], unused identifier WrongM (delete or rename to wildcard `_` or `_WrongM`)
+non_static_module.mo:22.8-22.9: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+non_static_module.mo:25.10-25.13: warning [M0194], unused identifier OkM (delete or rename to wildcard `_` or `_OkM`)
+non_static_module.mo:27.9-27.10: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
diff --git a/test/fail/ok/obj-with.tc.ok b/test/fail/ok/obj-with.tc.ok
new file mode 100644
index 00000000000..df8784ea39f
--- /dev/null
+++ b/test/fail/ok/obj-with.tc.ok
@@ -0,0 +1,5 @@
+obj-with.mo:1.8-1.12: warning [M0194], unused identifier Prim (delete or rename to wildcard `_` or `_Prim`)
+obj-with.mo:6.5-6.7: warning [M0194], unused identifier ba (delete or rename to wildcard `_` or `_ba`)
+obj-with.mo:7.5-7.12: warning [M0194], unused identifier ba_semi (delete or rename to wildcard `_` or `_ba_semi`)
+obj-with.mo:9.5-9.8: warning [M0194], unused identifier bac (delete or rename to wildcard `_` or `_bac`)
+obj-with.mo:10.5-10.13: warning [M0194], unused identifier bac_semi (delete or rename to wildcard `_` or `_bac_semi`)
diff --git a/test/fail/ok/object-ext-poly.tc.ok b/test/fail/ok/object-ext-poly.tc.ok
index cf5bee5afec..4597ad176c1 100644
--- a/test/fail/ok/object-ext-poly.tc.ok
+++ b/test/fail/ok/object-ext-poly.tc.ok
@@ -2,3 +2,4 @@ object-ext-poly.mo:2.5-2.32: type error [M0096], expression of type
   {a : Int; b : Char; c : Text}
 cannot produce expected type
   A__9
+object-ext-poly.mo:1.6-1.9: warning [M0194], unused identifier mix (delete or rename to wildcard `_` or `_mix`)
diff --git a/test/fail/ok/objpat-infer.tc.ok b/test/fail/ok/objpat-infer.tc.ok
index 1fd72842ae3..87c84e02530 100644
--- a/test/fail/ok/objpat-infer.tc.ok
+++ b/test/fail/ok/objpat-infer.tc.ok
@@ -20,3 +20,4 @@ objpat-infer.mo:35.15-35.23: type error [M0096], expression of type
   actor {}
 cannot produce expected type
   {}
+objpat-infer.mo:17.17-17.18: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
diff --git a/test/fail/ok/one-tuple-ambiguity.tc.ok b/test/fail/ok/one-tuple-ambiguity.tc.ok
index f0810e0998e..8cad8fb30cc 100644
--- a/test/fail/ok/one-tuple-ambiguity.tc.ok
+++ b/test/fail/ok/one-tuple-ambiguity.tc.ok
@@ -2,3 +2,5 @@ one-tuple-ambiguity.mo:16.3-16.5: type error [M0050], literal of type
   Nat
 does not have expected type
   (Nat, Bool)
+one-tuple-ambiguity.mo:13.9-13.10: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+one-tuple-ambiguity.mo:13.18-13.19: warning [M0194], unused identifier b (delete or rename to wildcard `_` or `_b`)
diff --git a/test/fail/ok/pat-inconsistent.tc.ok b/test/fail/ok/pat-inconsistent.tc.ok
index 3de534f9340..883bad81183 100644
--- a/test/fail/ok/pat-inconsistent.tc.ok
+++ b/test/fail/ok/pat-inconsistent.tc.ok
@@ -12,3 +12,4 @@ pat-inconsistent.mo:58.1-60.2: warning [M0145], this switch of type
 does not cover value
   #sparrows
 pat-inconsistent.mo:64.10-64.18: warning [M0146], this pattern is never matched
+pat-inconsistent.mo:62.6-62.12: warning [M0194], unused identifier absurd (delete or rename to wildcard `_` or `_absurd`)
diff --git a/test/fail/ok/pat-subtyping-fail.tc.ok b/test/fail/ok/pat-subtyping-fail.tc.ok
index 6a8aec8da30..734b4d391dc 100644
--- a/test/fail/ok/pat-subtyping-fail.tc.ok
+++ b/test/fail/ok/pat-subtyping-fail.tc.ok
@@ -114,3 +114,11 @@ pat-subtyping-fail.mo:162.11-162.35: type error [M0096], expression of type
   Nat -> ()
 cannot produce expected type
   Int -> ()
+pat-subtyping-fail.mo:129.8-129.9: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+pat-subtyping-fail.mo:129.10-129.11: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+pat-subtyping-fail.mo:153.16-153.17: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+pat-subtyping-fail.mo:153.18-153.19: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+pat-subtyping-fail.mo:156.16-156.17: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+pat-subtyping-fail.mo:156.18-156.19: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+pat-subtyping-fail.mo:162.16-162.17: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+pat-subtyping-fail.mo:162.18-162.19: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
diff --git a/test/fail/ok/pretty-inference.tc.ok b/test/fail/ok/pretty-inference.tc.ok
index e7dddc07fc2..f8443f1fbf4 100644
--- a/test/fail/ok/pretty-inference.tc.ok
+++ b/test/fail/ok/pretty-inference.tc.ok
@@ -250,3 +250,7 @@ because no instantiation of T__47, U__17 makes
     (T__47, U__17)
 and
   Nat  <:  ()
+pretty-inference.mo:11.17-11.18: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+pretty-inference.mo:26.30-26.31: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+pretty-inference.mo:40.14-40.15: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+pretty-inference.mo:40.20-40.21: warning [M0194], unused identifier u (delete or rename to wildcard `_` or `_u`)
diff --git a/test/fail/ok/pretty.tc.ok b/test/fail/ok/pretty.tc.ok
index d17d5ce522e..24778d1af00 100644
--- a/test/fail/ok/pretty.tc.ok
+++ b/test/fail/ok/pretty.tc.ok
@@ -467,3 +467,8 @@ pretty.mo:145.4-145.6: type error [M0096], expression of type
   }
 cannot produce expected type
   ()
+pretty.mo:22.6-22.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+pretty.mo:24.6-24.7: warning [M0194], unused identifier g (delete or rename to wildcard `_` or `_g`)
+pretty.mo:26.6-26.7: warning [M0194], unused identifier h (delete or rename to wildcard `_` or `_h`)
+pretty.mo:28.6-28.7: warning [M0194], unused identifier i (delete or rename to wildcard `_` or `_i`)
+pretty.mo:135.21-135.22: warning [M0194], unused identifier y (delete or rename to wildcard `_` or `_y`)
diff --git a/test/fail/ok/prim-in-source.tc.ok b/test/fail/ok/prim-in-source.tc.ok
index 58521aa2c57..805215a6ebd 100644
--- a/test/fail/ok/prim-in-source.tc.ok
+++ b/test/fail/ok/prim-in-source.tc.ok
@@ -1 +1,2 @@
 prim-in-source.mo:1.22-1.26: type error [M0057], unbound variable prim
+prim-in-source.mo:1.5-1.6: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
diff --git a/test/fail/ok/queries.tc.ok b/test/fail/ok/queries.tc.ok
index e6cff6d94c9..c89f310fd11 100644
--- a/test/fail/ok/queries.tc.ok
+++ b/test/fail/ok/queries.tc.ok
@@ -11,3 +11,4 @@ queries.mo:26.5-26.14: type error [M0096], expression of type
   async<$bogus> ()
 cannot produce expected type
   ()
+queries.mo:3.7-3.8: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
diff --git a/test/fail/ok/redundant-ignore.tc.ok b/test/fail/ok/redundant-ignore.tc.ok
index cb1143c89e1..cd0f4d9b93e 100644
--- a/test/fail/ok/redundant-ignore.tc.ok
+++ b/test/fail/ok/redundant-ignore.tc.ok
@@ -4,3 +4,4 @@ redundant-ignore.mo:6.1-6.9: warning [M0089], redundant ignore, operand already
 redundant-ignore.mo:11.3-11.12: warning [M0089], redundant ignore, operand already has type ()
 redundant-ignore.mo:12.3-12.13: warning [M0089], redundant ignore, operand already has type ()
 redundant-ignore.mo:13.3-13.11: warning [M0089], redundant ignore, operand already has type ()
+redundant-ignore.mo:10.6-10.7: warning [M0194], unused identifier g (delete or rename to wildcard `_` or `_g`)
diff --git a/test/fail/ok/return-before-define.tc.ok b/test/fail/ok/return-before-define.tc.ok
index d73130a1062..35dfa78edaf 100644
--- a/test/fail/ok/return-before-define.tc.ok
+++ b/test/fail/ok/return-before-define.tc.ok
@@ -1 +1,2 @@
+return-before-define.mo:16.5-16.10: warning [M0194], unused identifier wrong (delete or rename to wildcard `_` or `_wrong`)
 return-before-define.mo:6.5-6.34: definedness error [M0016], cannot use g before x has been defined
diff --git a/test/fail/ok/shared-nonexhaustive.tc.ok b/test/fail/ok/shared-nonexhaustive.tc.ok
index fbaf894d463..302b569f843 100644
--- a/test/fail/ok/shared-nonexhaustive.tc.ok
+++ b/test/fail/ok/shared-nonexhaustive.tc.ok
@@ -18,3 +18,7 @@ shared-nonexhaustive.mo:9.21-9.34: type error [M0145], this pattern of type
   Bool
 does not cover value
   false
+shared-nonexhaustive.mo:3.13-3.19: warning [M0194], unused identifier wrong1 (delete or rename to wildcard `_` or `_wrong1`)
+shared-nonexhaustive.mo:5.15-5.21: warning [M0194], unused identifier wrong2 (delete or rename to wildcard `_` or `_wrong2`)
+shared-nonexhaustive.mo:7.13-7.19: warning [M0194], unused identifier wrong2 (delete or rename to wildcard `_` or `_wrong2`)
+shared-nonexhaustive.mo:9.15-9.21: warning [M0194], unused identifier wrong2 (delete or rename to wildcard `_` or `_wrong2`)
diff --git a/test/fail/ok/structural_equality.tc.ok b/test/fail/ok/structural_equality.tc.ok
index 9106e69fdfd..577d75947ba 100644
--- a/test/fail/ok/structural_equality.tc.ok
+++ b/test/fail/ok/structural_equality.tc.ok
@@ -32,3 +32,5 @@ and
   B
 at common supertype
   Any
+structural_equality.mo:12.6-12.10: warning [M0194], unused identifier myEq (delete or rename to wildcard `_` or `_myEq`)
+structural_equality.mo:13.6-13.11: warning [M0194], unused identifier myEq2 (delete or rename to wildcard `_` or `_myEq2`)
diff --git a/test/fail/ok/typed-labels.tc.ok b/test/fail/ok/typed-labels.tc.ok
index 97bab818a60..c7343bc5f51 100644
--- a/test/fail/ok/typed-labels.tc.ok
+++ b/test/fail/ok/typed-labels.tc.ok
@@ -28,3 +28,23 @@ typed-labels.mo:24.24-24.64: type error [M0096], expression of type
 cannot produce expected type
   Nat
 typed-labels.mo:25.33-25.34: type error [M0083], unbound label c
+typed-labels.mo:3.5-3.7: warning [M0194], unused identifier a0 (delete or rename to wildcard `_` or `_a0`)
+typed-labels.mo:4.5-4.7: warning [M0194], unused identifier b0 (delete or rename to wildcard `_` or `_b0`)
+typed-labels.mo:5.5-5.7: warning [M0194], unused identifier c0 (delete or rename to wildcard `_` or `_c0`)
+typed-labels.mo:6.5-6.7: warning [M0194], unused identifier d0 (delete or rename to wildcard `_` or `_d0`)
+typed-labels.mo:7.5-7.7: warning [M0194], unused identifier e0 (delete or rename to wildcard `_` or `_e0`)
+typed-labels.mo:9.5-9.7: warning [M0194], unused identifier a1 (delete or rename to wildcard `_` or `_a1`)
+typed-labels.mo:10.5-10.7: warning [M0194], unused identifier b1 (delete or rename to wildcard `_` or `_b1`)
+typed-labels.mo:11.5-11.7: warning [M0194], unused identifier c1 (delete or rename to wildcard `_` or `_c1`)
+typed-labels.mo:12.5-12.7: warning [M0194], unused identifier d1 (delete or rename to wildcard `_` or `_d1`)
+typed-labels.mo:13.5-13.7: warning [M0194], unused identifier e1 (delete or rename to wildcard `_` or `_e1`)
+typed-labels.mo:15.5-15.7: warning [M0194], unused identifier a2 (delete or rename to wildcard `_` or `_a2`)
+typed-labels.mo:16.5-16.7: warning [M0194], unused identifier b2 (delete or rename to wildcard `_` or `_b2`)
+typed-labels.mo:17.5-17.7: warning [M0194], unused identifier c2 (delete or rename to wildcard `_` or `_c2`)
+typed-labels.mo:18.5-18.7: warning [M0194], unused identifier d2 (delete or rename to wildcard `_` or `_d2`)
+typed-labels.mo:19.5-19.7: warning [M0194], unused identifier e2 (delete or rename to wildcard `_` or `_e2`)
+typed-labels.mo:21.5-21.7: warning [M0194], unused identifier a3 (delete or rename to wildcard `_` or `_a3`)
+typed-labels.mo:22.5-22.7: warning [M0194], unused identifier b3 (delete or rename to wildcard `_` or `_b3`)
+typed-labels.mo:23.5-23.7: warning [M0194], unused identifier c3 (delete or rename to wildcard `_` or `_c3`)
+typed-labels.mo:24.5-24.7: warning [M0194], unused identifier d3 (delete or rename to wildcard `_` or `_d3`)
+typed-labels.mo:25.5-25.7: warning [M0194], unused identifier e3 (delete or rename to wildcard `_` or `_e3`)
diff --git a/test/fail/ok/unused.tc.ok b/test/fail/ok/unused.tc.ok
new file mode 100644
index 00000000000..183c85edb82
--- /dev/null
+++ b/test/fail/ok/unused.tc.ok
@@ -0,0 +1,9 @@
+lib/unused4.mo:4.7-4.14: warning [M0194], unused identifier unused4 (delete or rename to wildcard `_` or `_unused4`)
+lib/unused2.mo:7.7-7.14: warning [M0194], unused identifier unused2 (delete or rename to wildcard `_` or `_unused2`)
+unused.mo:7.6-7.9: warning [M0194], unused identifier rec (delete or rename to wildcard `_` or `_rec`)
+unused.mo:9.9-9.15: warning [M0194], unused identifier unused (delete or rename to wildcard `_` or `_unused`)
+unused.mo:11.6-11.7: warning [M0194], unused identifier g (delete or rename to wildcard `_` or `_g`)
+unused.mo:11.8-11.9: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+unused.mo:15.5-15.8: warning [M0194], unused identifier hmm (delete or rename to wildcard `_` or `_hmm`)
+unused.mo:32.5-32.6: warning [M0194], unused identifier r (delete or rename to wildcard `_` or `_r`)
+unused.mo:32.29-32.30: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
diff --git a/test/fail/ok/use-before-define.tc.ok b/test/fail/ok/use-before-define.tc.ok
index 3596b1a07f3..709161ec86c 100644
--- a/test/fail/ok/use-before-define.tc.ok
+++ b/test/fail/ok/use-before-define.tc.ok
@@ -1 +1,2 @@
+use-before-define.mo:4.5-4.6: warning [M0194], unused identifier y (delete or rename to wildcard `_` or `_y`)
 use-before-define.mo:4.1-4.12: definedness error [M0016], cannot use f before x has been defined
diff --git a/test/fail/ok/use-before-define5.tc.ok b/test/fail/ok/use-before-define5.tc.ok
new file mode 100644
index 00000000000..260e92e11d2
--- /dev/null
+++ b/test/fail/ok/use-before-define5.tc.ok
@@ -0,0 +1 @@
+use-before-define5.mo:2.5-2.6: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
diff --git a/test/fail/ok/use-before-define6.tc.ok b/test/fail/ok/use-before-define6.tc.ok
index d0ba1a0c5aa..b94ae6c710e 100644
--- a/test/fail/ok/use-before-define6.tc.ok
+++ b/test/fail/ok/use-before-define6.tc.ok
@@ -1 +1,2 @@
+use-before-define6.mo:3.9-3.13: warning [M0194], unused identifier bomb (delete or rename to wildcard `_` or `_bomb`)
 use-before-define6.mo:6.3-6.20: definedness error [M0016], cannot use g before g has been defined
diff --git a/test/fail/ok/usedefbug.tc.ok b/test/fail/ok/usedefbug.tc.ok
index f268df19b55..d695b869d89 100644
--- a/test/fail/ok/usedefbug.tc.ok
+++ b/test/fail/ok/usedefbug.tc.ok
@@ -1 +1,4 @@
+usedefbug.mo:1.7-1.10: warning [M0194], unused identifier Bar (delete or rename to wildcard `_` or `_Bar`)
+usedefbug.mo:4.9-4.13: warning [M0194], unused identifier bomb (delete or rename to wildcard `_` or `_bomb`)
+usedefbug.mo:7.7-7.10: warning [M0194], unused identifier Bar (delete or rename to wildcard `_` or `_Bar`)
 usedefbug.mo:7.3-7.22: definedness error [M0016], cannot use g before g has been defined
diff --git a/test/fail/ok/var-const-array.tc.ok b/test/fail/ok/var-const-array.tc.ok
index ff75be50a38..cfa9db68708 100644
--- a/test/fail/ok/var-const-array.tc.ok
+++ b/test/fail/ok/var-const-array.tc.ok
@@ -1,2 +1,3 @@
 var-const-array.mo:1.21-1.23: type error [M0091], immutable array expression cannot produce expected type
   [var Nat]
+var-const-array.mo:1.5-1.6: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
diff --git a/test/fail/ok/variance.tc.ok b/test/fail/ok/variance.tc.ok
index 935fc0f7258..09d938fa18a 100644
--- a/test/fail/ok/variance.tc.ok
+++ b/test/fail/ok/variance.tc.ok
@@ -43,3 +43,11 @@ because implicit instantiation of type parameter A is under-constrained with
 where
   None  =/=  Any
 so that explicit type instantiation is required
+variance.mo:16.7-16.8: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+variance.mo:89.29-89.30: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+variance.mo:90.27-90.28: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+variance.mo:94.25-94.26: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+variance.mo:99.26-99.27: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+variance.mo:100.24-100.25: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+variance.mo:104.26-104.27: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+variance.mo:105.24-105.25: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
diff --git a/test/fail/ok/variant-check.tc.ok b/test/fail/ok/variant-check.tc.ok
index 8e0a9fd357a..b4bd4290b9e 100644
--- a/test/fail/ok/variant-check.tc.ok
+++ b/test/fail/ok/variant-check.tc.ok
@@ -2,3 +2,5 @@ variant-check.mo:6.23-6.26: type error [M0096], expression of type
   Nat
 cannot produce expected type
   Nat8
+variant-check.mo:3.6-3.9: warning [M0194], unused identifier foo (delete or rename to wildcard `_` or `_foo`)
+variant-check.mo:6.6-6.9: warning [M0194], unused identifier bar (delete or rename to wildcard `_` or `_bar`)
diff --git a/test/fail/unused.mo b/test/fail/unused.mo
new file mode 100644
index 00000000000..fe9b34d4c0a
--- /dev/null
+++ b/test/fail/unused.mo
@@ -0,0 +1,32 @@
+//MOC-FLAG --package lib lib
+import _Unused1 "mo:lib/unused1"; // don't report package imports usage warning
+import _Unused2 "./lib/unused2"; // do report relative imports usage warning
+
+func rec1() { rec1() }; // accepted, but reject as unused?
+
+func rec() { }; //reject ok
+
+do {let unused = 1 };
+
+func g(x : ()) {};
+
+//let unused = 1;
+let _ok = 1;
+let hmm = _ok; // should we warn about the use of a silenced identifier? OCaml doens't actually, so perhaps not
+
+do { func f() { g() ; }; //both f and g are only used recursively accept or reject?
+     func g() { f() };
+};
+
+// switches
+switch (?1) {
+  case (?u) {}; //unused u
+  case o {}; //unused 0
+};
+
+// types
+
+do { type Unused = Int; }; // do we want to warn?
+
+
+let r = object {private let f = 0; public let x = 0};
diff --git a/test/lsp-int/lsp-int.cabal b/test/lsp-int/lsp-int.cabal
index 9218ec0763e..6f615d91a1c 100644
--- a/test/lsp-int/lsp-int.cabal
+++ b/test/lsp-int/lsp-int.cabal
@@ -5,7 +5,7 @@ version:             0
 synopsis:            Integration tests for the language server
 -- description:
 author:              dfinity
-maintainer:          sdk@dfinity.org
+maintainer:          team-motoko@dfinity.org
 -- copyright:
 category:            Testing
 extra-source-files:  CHANGELOG.md
diff --git a/test/mo-idl/ok/class.idl.ok b/test/mo-idl/ok/class.idl.ok
new file mode 100644
index 00000000000..e51be0cfb32
--- /dev/null
+++ b/test/mo-idl/ok/class.idl.ok
@@ -0,0 +1 @@
+class.mo:2.13-2.14: warning [M0194], unused identifier A (delete or rename to wildcard `_` or `_A`)
diff --git a/test/mo-idl/ok/class.tc.ok b/test/mo-idl/ok/class.tc.ok
new file mode 100644
index 00000000000..e51be0cfb32
--- /dev/null
+++ b/test/mo-idl/ok/class.tc.ok
@@ -0,0 +1 @@
+class.mo:2.13-2.14: warning [M0194], unused identifier A (delete or rename to wildcard `_` or `_A`)
diff --git a/test/mo-idl/ok/counter.did.ok b/test/mo-idl/ok/counter.did.ok
index 491d72d8acf..b3989048bf0 100644
--- a/test/mo-idl/ok/counter.did.ok
+++ b/test/mo-idl/ok/counter.did.ok
@@ -1,6 +1,6 @@
-type anon_class_2_1 = 
+type _anon_class_2_1 = 
  service {
    dec: () -> () oneway;
    read: () -> (int);
  };
-service : (int, nat) -> anon_class_2_1
+service : (int, nat) -> _anon_class_2_1
diff --git a/test/mo-idl/ok/counter.idl.ok b/test/mo-idl/ok/counter.idl.ok
new file mode 100644
index 00000000000..1cf38a4658f
--- /dev/null
+++ b/test/mo-idl/ok/counter.idl.ok
@@ -0,0 +1,2 @@
+counter.mo:4.13-4.17: warning [M0194], unused identifier note (delete or rename to wildcard `_` or `_note`)
+counter.mo:4.26-4.27: warning [M0194], unused identifier c (delete or rename to wildcard `_` or `_c`)
diff --git a/test/mo-idl/ok/counter.tc.ok b/test/mo-idl/ok/counter.tc.ok
new file mode 100644
index 00000000000..1cf38a4658f
--- /dev/null
+++ b/test/mo-idl/ok/counter.tc.ok
@@ -0,0 +1,2 @@
+counter.mo:4.13-4.17: warning [M0194], unused identifier note (delete or rename to wildcard `_` or `_note`)
+counter.mo:4.26-4.27: warning [M0194], unused identifier c (delete or rename to wildcard `_` or `_c`)
diff --git a/test/mo-idl/ok/dup_fields.idl.ok b/test/mo-idl/ok/dup_fields.idl.ok
new file mode 100644
index 00000000000..456b78212d4
--- /dev/null
+++ b/test/mo-idl/ok/dup_fields.idl.ok
@@ -0,0 +1,3 @@
+dup_fields.mo:1.7-1.13: warning [M0194], unused identifier Server (delete or rename to wildcard `_` or `_Server`)
+dup_fields.mo:9.26-9.30: warning [M0194], unused identifier user (delete or rename to wildcard `_` or `_user`)
+dup_fields.mo:11.21-11.25: warning [M0194], unused identifier user (delete or rename to wildcard `_` or `_user`)
diff --git a/test/mo-idl/ok/dup_fields.tc.ok b/test/mo-idl/ok/dup_fields.tc.ok
new file mode 100644
index 00000000000..456b78212d4
--- /dev/null
+++ b/test/mo-idl/ok/dup_fields.tc.ok
@@ -0,0 +1,3 @@
+dup_fields.mo:1.7-1.13: warning [M0194], unused identifier Server (delete or rename to wildcard `_` or `_Server`)
+dup_fields.mo:9.26-9.30: warning [M0194], unused identifier user (delete or rename to wildcard `_` or `_user`)
+dup_fields.mo:11.21-11.25: warning [M0194], unused identifier user (delete or rename to wildcard `_` or `_user`)
diff --git a/test/mo-idl/ok/empty_class.did.ok b/test/mo-idl/ok/empty_class.did.ok
index 863a11e1ed9..59dc4d998d9 100644
--- a/test/mo-idl/ok/empty_class.did.ok
+++ b/test/mo-idl/ok/empty_class.did.ok
@@ -1,5 +1,5 @@
-type anon_class_1_1 = 
+type _anon_class_1_1 = 
  service {
    dec: () -> () oneway;
  };
-service : () -> anon_class_1_1
+service : () -> _anon_class_1_1
diff --git a/test/mo-idl/ok/fields.idl.ok b/test/mo-idl/ok/fields.idl.ok
new file mode 100644
index 00000000000..8de3205ba32
--- /dev/null
+++ b/test/mo-idl/ok/fields.idl.ok
@@ -0,0 +1,3 @@
+fields.mo:1.7-1.13: warning [M0194], unused identifier Server (delete or rename to wildcard `_` or `_Server`)
+fields.mo:11.20-11.24: warning [M0194], unused identifier user (delete or rename to wildcard `_` or `_user`)
+fields.mo:13.21-13.25: warning [M0194], unused identifier user (delete or rename to wildcard `_` or `_user`)
diff --git a/test/mo-idl/ok/fields.tc.ok b/test/mo-idl/ok/fields.tc.ok
new file mode 100644
index 00000000000..8de3205ba32
--- /dev/null
+++ b/test/mo-idl/ok/fields.tc.ok
@@ -0,0 +1,3 @@
+fields.mo:1.7-1.13: warning [M0194], unused identifier Server (delete or rename to wildcard `_` or `_Server`)
+fields.mo:11.20-11.24: warning [M0194], unused identifier user (delete or rename to wildcard `_` or `_user`)
+fields.mo:13.21-13.25: warning [M0194], unused identifier user (delete or rename to wildcard `_` or `_user`)
diff --git a/test/mo-idl/ok/func_mode.idl.ok b/test/mo-idl/ok/func_mode.idl.ok
new file mode 100644
index 00000000000..0409ea5d02d
--- /dev/null
+++ b/test/mo-idl/ok/func_mode.idl.ok
@@ -0,0 +1 @@
+func_mode.mo:1.7-1.8: warning [M0194], unused identifier s (delete or rename to wildcard `_` or `_s`)
diff --git a/test/mo-idl/ok/func_mode.tc.ok b/test/mo-idl/ok/func_mode.tc.ok
new file mode 100644
index 00000000000..0409ea5d02d
--- /dev/null
+++ b/test/mo-idl/ok/func_mode.tc.ok
@@ -0,0 +1 @@
+func_mode.mo:1.7-1.8: warning [M0194], unused identifier s (delete or rename to wildcard `_` or `_s`)
diff --git a/test/mo-idl/ok/inline_result.idl.ok b/test/mo-idl/ok/inline_result.idl.ok
new file mode 100644
index 00000000000..30a7f7ae06a
--- /dev/null
+++ b/test/mo-idl/ok/inline_result.idl.ok
@@ -0,0 +1 @@
+inline_result.mo:12.16-12.17: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
diff --git a/test/mo-idl/ok/inline_result.tc.ok b/test/mo-idl/ok/inline_result.tc.ok
new file mode 100644
index 00000000000..30a7f7ae06a
--- /dev/null
+++ b/test/mo-idl/ok/inline_result.tc.ok
@@ -0,0 +1 @@
+inline_result.mo:12.16-12.17: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
diff --git a/test/mo-idl/ok/keyword.idl.ok b/test/mo-idl/ok/keyword.idl.ok
new file mode 100644
index 00000000000..9e8344e7db6
--- /dev/null
+++ b/test/mo-idl/ok/keyword.idl.ok
@@ -0,0 +1 @@
+keyword.mo:3.22-3.28: warning [M0194], unused identifier record (delete or rename to wildcard `_` or `_record`)
diff --git a/test/mo-idl/ok/keyword.tc.ok b/test/mo-idl/ok/keyword.tc.ok
new file mode 100644
index 00000000000..9e8344e7db6
--- /dev/null
+++ b/test/mo-idl/ok/keyword.tc.ok
@@ -0,0 +1 @@
+keyword.mo:3.22-3.28: warning [M0194], unused identifier record (delete or rename to wildcard `_` or `_record`)
diff --git a/test/mo-idl/ok/pa_cars.idl.ok b/test/mo-idl/ok/pa_cars.idl.ok
new file mode 100644
index 00000000000..d7f541e7f5b
--- /dev/null
+++ b/test/mo-idl/ok/pa_cars.idl.ok
@@ -0,0 +1,6 @@
+pa_cars.mo:3.13-3.16: warning [M0194], unused identifier Car (delete or rename to wildcard `_` or `_Car`)
+pa_cars.mo:3.17-3.20: warning [M0194], unused identifier dmv (delete or rename to wildcard `_` or `_dmv`)
+pa_cars.mo:16.27-16.31: warning [M0194], unused identifier user (delete or rename to wildcard `_` or `_user`)
+pa_cars.mo:16.40-16.47: warning [M0194], unused identifier carInfo (delete or rename to wildcard `_` or `_carInfo`)
+pa_cars.mo:16.61-16.69: warning [M0194], unused identifier location (delete or rename to wildcard `_` or `_location`)
+pa_cars.mo:16.82-16.90: warning [M0194], unused identifier timeSpan (delete or rename to wildcard `_` or `_timeSpan`)
diff --git a/test/mo-idl/ok/pa_cars.tc.ok b/test/mo-idl/ok/pa_cars.tc.ok
new file mode 100644
index 00000000000..d7f541e7f5b
--- /dev/null
+++ b/test/mo-idl/ok/pa_cars.tc.ok
@@ -0,0 +1,6 @@
+pa_cars.mo:3.13-3.16: warning [M0194], unused identifier Car (delete or rename to wildcard `_` or `_Car`)
+pa_cars.mo:3.17-3.20: warning [M0194], unused identifier dmv (delete or rename to wildcard `_` or `_dmv`)
+pa_cars.mo:16.27-16.31: warning [M0194], unused identifier user (delete or rename to wildcard `_` or `_user`)
+pa_cars.mo:16.40-16.47: warning [M0194], unused identifier carInfo (delete or rename to wildcard `_` or `_carInfo`)
+pa_cars.mo:16.61-16.69: warning [M0194], unused identifier location (delete or rename to wildcard `_` or `_location`)
+pa_cars.mo:16.82-16.90: warning [M0194], unused identifier timeSpan (delete or rename to wildcard `_` or `_timeSpan`)
diff --git a/test/mo-idl/ok/prelude.idl.ok b/test/mo-idl/ok/prelude.idl.ok
new file mode 100644
index 00000000000..d7dac1c5f2c
--- /dev/null
+++ b/test/mo-idl/ok/prelude.idl.ok
@@ -0,0 +1,3 @@
+prelude.mo:1.7-1.8: warning [M0194], unused identifier A (delete or rename to wildcard `_` or `_A`)
+prelude.mo:5.20-5.21: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+prelude.mo:5.27-5.28: warning [M0194], unused identifier y (delete or rename to wildcard `_` or `_y`)
diff --git a/test/mo-idl/ok/prelude.tc.ok b/test/mo-idl/ok/prelude.tc.ok
new file mode 100644
index 00000000000..d7dac1c5f2c
--- /dev/null
+++ b/test/mo-idl/ok/prelude.tc.ok
@@ -0,0 +1,3 @@
+prelude.mo:1.7-1.8: warning [M0194], unused identifier A (delete or rename to wildcard `_` or `_A`)
+prelude.mo:5.20-5.21: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+prelude.mo:5.27-5.28: warning [M0194], unused identifier y (delete or rename to wildcard `_` or `_y`)
diff --git a/test/mo-idl/result.mo b/test/mo-idl/result.mo
index 06084b5d900..d72e0b961a8 100644
--- a/test/mo-idl/result.mo
+++ b/test/mo-idl/result.mo
@@ -17,7 +17,7 @@ actor {
         case null {#err "error"};
         }
     };
-    public func g(x:Result3<()>):async Result2<Nat> {
+    public func g(_x:Result3<()>):async Result2<Nat> {
         #ok(1);
     };
 }
diff --git a/test/perf/assetstorage/Text.mo b/test/perf/assetstorage/Text.mo
index eda1c0dde45..d6100ffee41 100644
--- a/test/perf/assetstorage/Text.mo
+++ b/test/perf/assetstorage/Text.mo
@@ -578,7 +578,7 @@ module {
         case (null, ?_) { return #less };
         case (?_, null) { return #greater };
         case (?c1, ?c2) {
-          switch (Char.compare(c1, c2)) {
+          switch (cmp(c1, c2)) {
             case (#equal) { }; // continue
             case other { return other; }
           }
diff --git a/test/perf/ok/assetstorage.tc.ok b/test/perf/ok/assetstorage.tc.ok
new file mode 100644
index 00000000000..64a6076d547
--- /dev/null
+++ b/test/perf/ok/assetstorage.tc.ok
@@ -0,0 +1,5 @@
+assetstorage/Iter.mo:165.29-165.31: warning [M0194], unused identifier ix (delete or rename to wildcard `_` or `_ix`)
+assetstorage/RBTree.mo:45.10-45.13: warning [M0194], unused identifier res (delete or rename to wildcard `_` or `_res`)
+assetstorage/RBTree.mo:50.10-50.13: warning [M0194], unused identifier res (delete or rename to wildcard `_` or `_res`)
+assetstorage/Char.mo:8.15-8.22: warning [M0194], unused identifier toUpper (delete or rename to wildcard `_` or `_toUpper`)
+assetstorage/Char.mo:11.15-11.22: warning [M0194], unused identifier toLower (delete or rename to wildcard `_` or `_toLower`)
diff --git a/test/perf/ok/dao.tc.ok b/test/perf/ok/dao.tc.ok
index 21ef450e6ec..4c3a82d4696 100644
--- a/test/perf/ok/dao.tc.ok
+++ b/test/perf/ok/dao.tc.ok
@@ -1,2 +1,9 @@
+assetstorage/Iter.mo:165.29-165.31: warning [M0194], unused identifier ix (delete or rename to wildcard `_` or `_ix`)
+assetstorage/Trie.mo:206.31-206.32: warning [M0194], unused identifier v (delete or rename to wildcard `_` or `_v`)
+assetstorage/Trie.mo:486.25-486.26: warning [M0194], unused identifier v (delete or rename to wildcard `_` or `_v`)
+assetstorage/Trie.mo:588.9-588.15: warning [M0194], unused identifier key_eq (delete or rename to wildcard `_` or `_key_eq`)
+assetstorage/Trie.mo:967.7-967.12: warning [M0194], unused identifier k3_eq (delete or rename to wildcard `_` or `_k3_eq`)
+assetstorage/Trie.mo:1568.5-1568.10: warning [M0194], unused identifier k1_eq (delete or rename to wildcard `_` or `_k1_eq`)
 dao/dao-types.mo:67.72-67.80: warning [M0154], field hash is deprecated:
 For large `Int` values consider using a bespoke hash function that considers all of the argument's bits.
+dao.mo:13.40-13.43: warning [M0194], unused identifier DAO (delete or rename to wildcard `_` or `_DAO`)
diff --git a/test/perf/ok/qr.tc.ok b/test/perf/ok/qr.tc.ok
new file mode 100644
index 00000000000..bd2bd86a236
--- /dev/null
+++ b/test/perf/ok/qr.tc.ok
@@ -0,0 +1,10 @@
+qr/option.mo:52.8-52.11: warning [M0194], unused identifier map (delete or rename to wildcard `_` or `_map`)
+qr/iter.mo:36.8-36.14: warning [M0194], unused identifier length (delete or rename to wildcard `_` or `_length`)
+qr/trie.mo:515.9-515.15: warning [M0194], unused identifier key_eq (delete or rename to wildcard `_` or `_key_eq`)
+qr/trie.mo:893.7-893.12: warning [M0194], unused identifier k3_eq (delete or rename to wildcard `_` or `_k3_eq`)
+qr/trie.mo:1447.61-1447.66: warning [M0194], unused identifier k1_eq (delete or rename to wildcard `_` or `_k1_eq`)
+qr/eight-bit.mo:17.22-17.29: warning [M0194], unused identifier version (delete or rename to wildcard `_` or `_version`)
+qr/eight-bit.mo:17.41-17.45: warning [M0194], unused identifier text (delete or rename to wildcard `_` or `_text`)
+qr/kanji.mo:17.22-17.29: warning [M0194], unused identifier version (delete or rename to wildcard `_` or `_version`)
+qr/kanji.mo:17.41-17.45: warning [M0194], unused identifier text (delete or rename to wildcard `_` or `_text`)
+qr/mask.mo:23.5-23.10: warning [M0194], unused identifier level (delete or rename to wildcard `_` or `_level`)
diff --git a/test/perf/ok/sha256.tc.ok b/test/perf/ok/sha256.tc.ok
new file mode 100644
index 00000000000..d1c7d20a1ed
--- /dev/null
+++ b/test/perf/ok/sha256.tc.ok
@@ -0,0 +1 @@
+sha256/Iter.mo:194.29-194.31: warning [M0194], unused identifier ix (delete or rename to wildcard `_` or `_ix`)
diff --git a/test/perf/sha256/Nat32.mo b/test/perf/sha256/Nat32.mo
index 40d64b279eb..159a64e0a5b 100644
--- a/test/perf/sha256/Nat32.mo
+++ b/test/perf/sha256/Nat32.mo
@@ -79,7 +79,7 @@ module {
   public func pow(x : Nat32, y : Nat32) : Nat32 { x ** y };
 
   /// Returns the bitwise negation of `x`, `^x`.
-  public func bitnot(x : Nat32, y : Nat32) : Nat32 { ^x };
+  public func bitnot(x : Nat32) : Nat32 { ^x };
 
   /// Returns the bitwise and of `x` and `y`, `x & y`.
   public func bitand(x : Nat32, y : Nat32) : Nat32 { x & y };
diff --git a/test/perf/sha256/Nat64.mo b/test/perf/sha256/Nat64.mo
index 4f3f58d1a2b..851a25b7ff9 100644
--- a/test/perf/sha256/Nat64.mo
+++ b/test/perf/sha256/Nat64.mo
@@ -79,7 +79,7 @@ module {
   public func pow(x : Nat64, y : Nat64) : Nat64 { x ** y };
 
   /// Returns the bitwise negation of `x`, `^x`.
-  public func bitnot(x : Nat64, y : Nat64) : Nat64 { ^x };
+  public func bitnot(x : Nat64) : Nat64 { ^x };
 
   /// Returns the bitwise and of `x` and `y`, `x & y`.
   public func bitand(x : Nat64, y : Nat64) : Nat64 { x & y };
diff --git a/test/perf/sha256/Nat8.mo b/test/perf/sha256/Nat8.mo
index 5283a459b37..89725423063 100644
--- a/test/perf/sha256/Nat8.mo
+++ b/test/perf/sha256/Nat8.mo
@@ -79,7 +79,7 @@ module {
   public func pow(x : Nat8, y : Nat8) : Nat8 { x ** y };
 
   /// Returns the bitwise negation of `x`, `^x`.
-  public func bitnot(x : Nat8, y : Nat8) : Nat8 { ^x };
+  public func bitnot(x : Nat8) : Nat8 { ^x };
 
   /// Returns the bitwise and of `x` and `y`, `x & y`.
   public func bitand(x : Nat8, y : Nat8) : Nat8 { x & y };
diff --git a/test/random/qc-motoko.cabal b/test/random/qc-motoko.cabal
index a521f63e5db..4a3cb7fae60 100644
--- a/test/random/qc-motoko.cabal
+++ b/test/random/qc-motoko.cabal
@@ -5,7 +5,7 @@ version:             1
 synopsis:            generate randomised tests for Motoko
 -- description:
 author:              dfinity
-maintainer:          sdk@dfinity.org
+maintainer:          team-motoko@dfinity.org
 -- copyright:
 category:            Testing
 extra-source-files:  CHANGELOG.md
diff --git a/test/repl/ok/file-and-repl.stderr.ok b/test/repl/ok/file-and-repl.stderr.ok
index cf50cbaa97f..b86be3164f4 100644
--- a/test/repl/ok/file-and-repl.stderr.ok
+++ b/test/repl/ok/file-and-repl.stderr.ok
@@ -2,3 +2,4 @@
   Bool
 does not cover value
   false
+/dev/fd/63:1.5-1.6: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
diff --git a/test/repl/ok/type-lub-repl.stderr.ok b/test/repl/ok/type-lub-repl.stderr.ok
index c1a3a9852d2..c4f24b8c2ac 100644
--- a/test/repl/ok/type-lub-repl.stderr.ok
+++ b/test/repl/ok/type-lub-repl.stderr.ok
@@ -1,3 +1,39 @@
 lib/type-lub.mo:37.16-37.42: warning [M0074], this array has type
   [Any]
 because elements have inconsistent types
+lib/type-lub.mo:1.5-1.9: warning [M0194], unused identifier opts (delete or rename to wildcard `_` or `_opts`)
+lib/type-lub.mo:2.5-2.10: warning [M0194], unused identifier nulls (delete or rename to wildcard `_` or `_nulls`)
+lib/type-lub.mo:4.5-4.22: warning [M0194], unused identifier incompatible_objs (delete or rename to wildcard `_` or `_incompatible_objs`)
+lib/type-lub.mo:5.5-5.9: warning [M0194], unused identifier objs (delete or rename to wildcard `_` or `_objs`)
+lib/type-lub.mo:7.5-7.9: warning [M0194], unused identifier tups (delete or rename to wildcard `_` or `_tups`)
+lib/type-lub.mo:8.5-8.10: warning [M0194], unused identifier tup1s (delete or rename to wildcard `_` or `_tup1s`)
+lib/type-lub.mo:10.5-10.9: warning [M0194], unused identifier arrs (delete or rename to wildcard `_` or `_arrs`)
+lib/type-lub.mo:12.5-12.23: warning [M0194], unused identifier incompatible_funcs (delete or rename to wildcard `_` or `_incompatible_funcs`)
+lib/type-lub.mo:13.34-13.35: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+lib/type-lub.mo:16.5-16.15: warning [M0194], unused identifier poly_funcs (delete or rename to wildcard `_` or `_poly_funcs`)
+lib/type-lub.mo:17.29-17.30: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+lib/type-lub.mo:20.5-20.16: warning [M0194], unused identifier poly_funcs2 (delete or rename to wildcard `_` or `_poly_funcs2`)
+lib/type-lub.mo:21.30-21.31: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+lib/type-lub.mo:24.5-24.16: warning [M0194], unused identifier poly_funcs3 (delete or rename to wildcard `_` or `_poly_funcs3`)
+lib/type-lub.mo:24.43-24.44: warning [M0194], unused identifier b (delete or rename to wildcard `_` or `_b`)
+lib/type-lub.mo:25.43-25.44: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+lib/type-lub.mo:28.5-28.10: warning [M0194], unused identifier funcs (delete or rename to wildcard `_` or `_funcs`)
+lib/type-lub.mo:29.21-29.22: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+lib/type-lub.mo:32.5-32.18: warning [M0194], unused identifier variant_funcs (delete or rename to wildcard `_` or `_variant_funcs`)
+lib/type-lub.mo:37.5-37.13: warning [M0194], unused identifier mut_arrs (delete or rename to wildcard `_` or `_mut_arrs`)
+lib/type-lub.mo:42.5-42.12: warning [M0194], unused identifier shareds (delete or rename to wildcard `_` or `_shareds`)
+lib/type-lub.mo:43.5-43.13: warning [M0194], unused identifier shared2s (delete or rename to wildcard `_` or `_shared2s`)
+lib/type-lub.mo:45.5-45.17: warning [M0194], unused identifier shared_funcs (delete or rename to wildcard `_` or `_shared_funcs`)
+lib/type-lub.mo:46.28-46.29: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+lib/type-lub.mo:52.6-52.8: warning [M0194], unused identifier c0 (delete or rename to wildcard `_` or `_c0`)
+lib/type-lub.mo:54.5-54.8: warning [M0194], unused identifier c1s (delete or rename to wildcard `_` or `_c1s`)
+lib/type-lub.mo:63.6-63.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+lib/type-lub.mo:70.6-70.8: warning [M0194], unused identifier f1 (delete or rename to wildcard `_` or `_f1`)
+lib/type-lub.mo:80.6-80.7: warning [M0194], unused identifier g (delete or rename to wildcard `_` or `_g`)
+lib/type-lub.mo:91.6-91.8: warning [M0194], unused identifier v0 (delete or rename to wildcard `_` or `_v0`)
+lib/type-lub.mo:97.6-97.8: warning [M0194], unused identifier g0 (delete or rename to wildcard `_` or `_g0`)
+lib/type-lub.mo:103.6-103.8: warning [M0194], unused identifier k0 (delete or rename to wildcard `_` or `_k0`)
+lib/type-lub.mo:109.6-109.8: warning [M0194], unused identifier k1 (delete or rename to wildcard `_` or `_k1`)
+lib/type-lub.mo:122.6-122.8: warning [M0194], unused identifier f0 (delete or rename to wildcard `_` or `_f0`)
+lib/type-lub.mo:127.6-127.9: warning [M0194], unused identifier f12 (delete or rename to wildcard `_` or `_f12`)
+lib/type-lub.mo:132.6-132.8: warning [M0194], unused identifier f2 (delete or rename to wildcard `_` or `_f2`)
diff --git a/test/run-drun/actor-class-mgmt-interp.mo b/test/run-drun/actor-class-mgmt-interp.mo
index 3f2ef614c26..e0c16d4dadc 100644
--- a/test/run-drun/actor-class-mgmt-interp.mo
+++ b/test/run-drun/actor-class-mgmt-interp.mo
@@ -1,5 +1,4 @@
 import Prim "mo:⛔";
-import Cycles = "cycles/cycles";
 import Cs "actor-class-mgmt/C";
 
 // test graceful failure of actor class system calls in interpreters
diff --git a/test/run-drun/actor-import.mo b/test/run-drun/actor-import.mo
index 7493ab9164a..6606099703e 100644
--- a/test/run-drun/actor-import.mo
+++ b/test/run-drun/actor-import.mo
@@ -8,7 +8,7 @@
 
 import imported1 "ic:lg264-qjkae";
 import imported2 "canister:self";
-actor a {
+actor {
   public func go() : async (actor {}) = async imported1;
   public func go2() : async (actor {}) = async await (imported1.go());
   public func go3() : async (actor {}) = async await (imported2.go());
diff --git a/test/run-drun/actor-reference.mo b/test/run-drun/actor-reference.mo
index 8df23452873..cb12a46d1a7 100644
--- a/test/run-drun/actor-reference.mo
+++ b/test/run-drun/actor-reference.mo
@@ -3,8 +3,8 @@
 actor {
   public func quux() : async Nat {
     let orange = actor "bfozs-kwa73-7nadi" : actor { fubar(n : Nat) : async Nat };
-    let n = await orange.fubar(45);
+    let _n = await orange.fubar(45);
     let tangerine = actor ("bfozs-kw" # "a73-7nadi") : actor { fubar(n : Nat) : async Nat };
-    let m = await tangerine.fubar(45)
+    let _m = await tangerine.fubar(45)
   }
 }
diff --git a/test/run-drun/async-loop.mo b/test/run-drun/async-loop.mo
index f886b4fec29..41d5842dbda 100644
--- a/test/run-drun/async-loop.mo
+++ b/test/run-drun/async-loop.mo
@@ -1,5 +1,5 @@
 import Prim "mo:⛔";
-actor a {
+actor {
   public func go() {
     do {
       var i = 0;
diff --git a/test/run-drun/certified-data.mo b/test/run-drun/certified-data.mo
index 0e6d3447259..148dc8796a8 100644
--- a/test/run-drun/certified-data.mo
+++ b/test/run-drun/certified-data.mo
@@ -1,5 +1,5 @@
 import Prim "mo:⛔";
-actor a {
+actor {
 
   public shared func set() : async () {
     Prim.setCertifiedData("Hello");
diff --git a/test/run-drun/composite-import.mo b/test/run-drun/composite-import.mo
index d52ae08911c..ca0de7d19cd 100644
--- a/test/run-drun/composite-import.mo
+++ b/test/run-drun/composite-import.mo
@@ -8,7 +8,7 @@
 import Prim = "mo:⛔";
 import imported1 "ic:rwlgt-iiaaa-aaaaa-aaaaa-cai";
 import imported2 "canister:self";
-actor a {
+actor {
   public func go1() : async (actor { cq : composite query () -> async () }) = async {
      imported1;
   };
diff --git a/test/run-drun/distributor/node.mo b/test/run-drun/distributor/node.mo
index 21379a9fe74..fbdc71d5f5b 100644
--- a/test/run-drun/distributor/node.mo
+++ b/test/run-drun/distributor/node.mo
@@ -5,7 +5,7 @@ actor class Node(i : Nat) {
   type Value = Text;
 
   Prim.debugPrint("installing node" # debug_show i);
-  var map = func (k: Nat) : ?Value { return null };
+  var map = func (_k: Nat) : ?Value { return null };
 
   public func lookup(k : Key) : async ? Value {
     Prim.debugPrint(debug_show i # ": lookup " # debug_show k);
diff --git a/test/run-drun/gc-random-test-force-gc.mo b/test/run-drun/gc-random-test-force-gc.mo
index 69a62063fd8..7e344feb4ce 100644
--- a/test/run-drun/gc-random-test-force-gc.mo
+++ b/test/run-drun/gc-random-test-force-gc.mo
@@ -1,3 +1,5 @@
+//MOC-FLAG --stable-regions
+
 import GCRandomTest "gc-random-test/gc-random-test";
 
 actor {
diff --git a/test/run-drun/gc-random-test-no-force-gc.mo b/test/run-drun/gc-random-test-no-force-gc.mo
index 8e8e4216ba9..d3225f245a4 100644
--- a/test/run-drun/gc-random-test-no-force-gc.mo
+++ b/test/run-drun/gc-random-test-no-force-gc.mo
@@ -1,4 +1,7 @@
 //MOC-NO-FORCE-GC
+//MOC-FLAG --stable-regions
+//MOC-FLAG --max-stable-pages=1000000
+
 import GCRandomTest "gc-random-test/gc-random-test";
 
 actor {
diff --git a/test/run-drun/gc-random-test/buffer.mo b/test/run-drun/gc-random-test/buffer.mo
index a35ea9ffeb0..a29c1d2641d 100644
--- a/test/run-drun/gc-random-test/buffer.mo
+++ b/test/run-drun/gc-random-test/buffer.mo
@@ -15,8 +15,7 @@ module {
     private let INCREASE_FACTOR_DENOM = 2;
     private let DECREASE_THRESHOLD = 4; // Don't decrease capacity too early to avoid thrashing
     private let DECREASE_FACTOR = 2;
-    private let DEFAULT_CAPACITY = 8;
-
+    
     private func newCapacity(oldCapacity : Nat) : Nat {
         if (oldCapacity == 0) {
             1;
diff --git a/test/run-drun/gc-random-test/gc-random-test.mo b/test/run-drun/gc-random-test/gc-random-test.mo
index ab9a379c2f1..d9c7171c27a 100644
--- a/test/run-drun/gc-random-test/gc-random-test.mo
+++ b/test/run-drun/gc-random-test/gc-random-test.mo
@@ -9,24 +9,33 @@ module {
     public class GCRandomTest() {
         let seed = 4711;
         let random = Random.Random(seed);
+        let types = Types.allocationTypes();
 
         var root : Values.RandomValue = #none;
 
         var allocationCount = 0;
+        let allocationPerType = Prim.Array_init<Nat>(types.size(), 0);
 
         func maxAlive() : Nat {
-            assert(allocationCount > 0);
+            assert (allocationCount > 0);
             let averageObjectSize = Prim.rts_total_allocation() / allocationCount;
             (Prim.rts_heap_size() + averageObjectSize - 1) / averageObjectSize;
         };
 
         func randomAllocate() {
             Prim.debugPrint("Random allocation");
-            let types = Types.allocationTypes();
-            let factory = types[random.next() % types.size()];
-            let randomValue = factory.instantiate(random);
-            allocationCount += 1;
-            append(randomValue);
+            let index = random.next() % types.size();
+            let factory = types[index];
+            let canAllocate = switch (factory.allocationLimit) {
+                case null true;
+                case (?limit) { allocationPerType[index] < limit };
+            };
+            if (canAllocate) {
+                let randomValue = factory.instantiate(random);
+                allocationCount += 1;
+                allocationPerType[index] += 1;
+                append(randomValue);
+            };
         };
 
         func append(value : Values.RandomValue) {
diff --git a/test/run-drun/gc-random-test/types.mo b/test/run-drun/gc-random-test/types.mo
index 169347b664f..19e0e00c961 100644
--- a/test/run-drun/gc-random-test/types.mo
+++ b/test/run-drun/gc-random-test/types.mo
@@ -2,10 +2,12 @@ import Prim "mo:prim";
 import Array "array";
 import Random "random";
 import Values "values";
+import Region "../stable-region/Region";
 
 module {
     public type RandomType = {
         name : Text;
+        allocationLimit : ?Nat;
         instantiate(random : Random.Random) : Values.RandomValue;
         readReferences(source : Values.RandomValue) : [Values.RandomValue];
         append(target : Values.RandomValue, value : Values.RandomValue) : Bool;
@@ -18,7 +20,7 @@ module {
     };
 
     public func allocationTypes() : [RandomType] {
-        [RandomObjectType, RandomArrayType, RandomBlobType, RandomBoxType, RandomTextType, RandomOptionType];
+        [RandomObjectType, RandomArrayType, RandomBlobType, RandomBoxType, RandomTextType, RandomOptionType, RandomRegionType];
     };
 
     public func getType(value : Values.RandomValue) : RandomType {
@@ -30,6 +32,7 @@ module {
             case (#box _) RandomBoxType;
             case (#text _) RandomTextType;
             case (#option _) RandomOptionType;
+            case (#region _) RandomRegionType;
         };
     };
 
@@ -57,6 +60,7 @@ module {
 
     public object NoneType {
         public let name = "none";
+        public let allocationLimit : ?Nat = null;
 
         public func instantiate(_random : Random.Random) : Values.RandomValue {
             Prim.trap("unsupported");
@@ -98,6 +102,7 @@ module {
 
     public object RandomObjectType {
         public let name = "object";
+        public let allocationLimit : ?Nat = null;
 
         public func instantiate(random : Random.Random) : Values.RandomValue {
             let number = random.next();
@@ -182,6 +187,7 @@ module {
 
     public object RandomArrayType {
         public let name = "array";
+        public let allocationLimit : ?Nat = null;
 
         public func instantiate(random : Random.Random) : Values.RandomValue {
             let maxLength = 100_000;
@@ -287,6 +293,7 @@ module {
 
     public object RandomBlobType {
         public let name = "blob";
+        public let allocationLimit : ?Nat = null;
 
         public func instantiate(random : Random.Random) : Values.RandomValue {
             let maxLength = 128 * 1024 * 1024;
@@ -341,6 +348,7 @@ module {
 
     public object RandomBoxType {
         public let name = "box";
+        public let allocationLimit : ?Nat = null;
 
         public func instantiate(random : Random.Random) : Values.RandomValue {
             let randomBigInt : Int = (random.next() * 2 ** 64 + random.next() * 2 ** 32 + random.next()) * -1 * random.next() % 2;
@@ -357,15 +365,15 @@ module {
             #box randomBox;
         };
 
-        public func readReferences(source : Values.RandomValue) : [Values.RandomValue] {
+        public func readReferences(_source : Values.RandomValue) : [Values.RandomValue] {
             [];
         };
 
-        public func append(target : Values.RandomValue, value : Values.RandomValue) : Bool {
+        public func append(_target : Values.RandomValue, _value : Values.RandomValue) : Bool {
             false;
         };
 
-        public func randomWrite(random : Random.Random, target : Values.RandomValue, value : Values.RandomValue) {};
+        public func randomWrite(_random : Random.Random, _target : Values.RandomValue, _value : Values.RandomValue) {};
 
         public func randomCheck(_random : Random.Random, value : Values.RandomValue) {
             let box = cast(value);
@@ -404,6 +412,7 @@ module {
 
     public object RandomTextType {
         public let name = "text";
+        public let allocationLimit : ?Nat = null;
 
         public func instantiate(random : Random.Random) : Values.RandomValue {
             var text = "";
@@ -414,8 +423,6 @@ module {
                 text #= "CONCATENATE-" # Prim.charToText(Prim.nat32ToChar(Prim.natToNat32(random.next() % 0xD800)));
                 count += 1;
             };
-            let randomFloat = Prim.intToFloat(random.next() * -1 * random.next() % 2) / Prim.intToFloat(random.next());
-            let randomInt64 = Prim.intToInt64Wrap((random.next() * 2 ** 32 + random.next() * -1 * random.next() % 2));
             let randomText = {
                 var randomText = text;
                 checkText = text;
@@ -423,15 +430,15 @@ module {
             #text randomText;
         };
 
-        public func readReferences(source : Values.RandomValue) : [Values.RandomValue] {
+        public func readReferences(_source : Values.RandomValue) : [Values.RandomValue] {
             [];
         };
 
-        public func append(target : Values.RandomValue, value : Values.RandomValue) : Bool {
+        public func append(_target : Values.RandomValue, _value : Values.RandomValue) : Bool {
             false;
         };
 
-        public func randomWrite(random : Random.Random, target : Values.RandomValue, value : Values.RandomValue) {};
+        public func randomWrite(_random : Random.Random, _target : Values.RandomValue, _value : Values.RandomValue) {};
 
         public func randomCheck(_random : Random.Random, value : Values.RandomValue) {
             let text = cast(value);
@@ -477,6 +484,7 @@ module {
 
     public object RandomOptionType {
         public let name = "option";
+        public let allocationLimit : ?Nat = null;
 
         public func instantiate(random : Random.Random) : Values.RandomValue {
             let types = allocationTypes();
@@ -495,11 +503,11 @@ module {
             };
         };
 
-        public func append(target : Values.RandomValue, value : Values.RandomValue) : Bool {
+        public func append(_target : Values.RandomValue, _value : Values.RandomValue) : Bool {
             false;
         };
 
-        public func randomWrite(random : Random.Random, target : Values.RandomValue, value : Values.RandomValue) {};
+        public func randomWrite(_random : Random.Random, _target : Values.RandomValue, _value : Values.RandomValue) {};
 
         public func randomCheck(random : Random.Random, value : Values.RandomValue) {
             let option = cast(value);
@@ -550,4 +558,74 @@ module {
             };
         };
     };
+
+    public object RandomRegionType {
+        public let name = "region";
+        public let allocationLimit = ?32752; // 32 * 1024 minus 16 reserved ids
+
+        public func instantiate(random : Random.Random) : Values.RandomValue {
+            let PageSize = Prim.natToNat64(64 * 1024);
+            let maxPages = 128;
+            let pageCount = Prim.natToNat64(1 + random.next() % maxPages);
+            let region = Region.new();
+            let checkValue = Prim.natToNat8(random.next() % 2 ** 8);
+            let result = Region.grow(region, pageCount);
+            assert (result != 0xFFFF_FFFF_FFFF_FFFF);
+            Region.storeNat8(region, 0, checkValue);
+            Region.storeNat8(region, pageCount * PageSize - 2, checkValue);
+            #region {
+                region;
+                checkSize = pageCount;
+                checkValue;
+            };
+        };
+
+        public func readReferences(_source : Values.RandomValue) : [Values.RandomValue] {
+            [];
+        };
+
+        public func append(_target : Values.RandomValue, _value : Values.RandomValue) : Bool {
+            false;
+        };
+
+        public func randomWrite(_random : Random.Random, _target : Values.RandomValue, _value : Values.RandomValue) {};
+
+        public func randomCheck(_random : Random.Random, value : Values.RandomValue) {
+            let PageSize = Prim.natToNat64(64 * 1024);
+            let regionValue = cast(value);
+            let region = regionValue.region;
+            assert (Region.size(region) == regionValue.checkSize);
+            assert (Region.loadNat8(region, 0) == regionValue.checkValue);
+            assert (Region.loadNat8(region, regionValue.checkSize * PageSize - 2) == regionValue.checkValue);
+        };
+
+        public func identical(left : Values.RandomValue, right : Values.RandomValue) : Bool {
+            let leftRegion = cast(left).region;
+            let rightRegion = cast(right).region;
+            Region.id(leftRegion) == Region.id(rightRegion);
+        };
+
+        public func hash(value : Values.RandomValue) : Nat {
+            let regionValue = cast(value);
+            let region = regionValue.region;
+            Prim.nat64ToNat(Region.size(region)) * 2 ** 8 + Prim.nat8ToNat(regionValue.checkValue);
+        };
+
+        public func text(value : Values.RandomValue) : Text {
+            shortText(value);
+        };
+
+        public func shortText(value : Values.RandomValue) : Text {
+            let regionValue = cast(value);
+            let region = regionValue.region;
+            "region(size = " # debug_show (Region.size(region)) # ")";
+        };
+
+        func cast(value : Values.RandomValue) : Values.RandomRegion {
+            switch value {
+                case (#region randomRegion) randomRegion;
+                case _ Prim.trap("invalid cast");
+            };
+        };
+    };
 };
diff --git a/test/run-drun/gc-random-test/values.mo b/test/run-drun/gc-random-test/values.mo
index 531f0dcb49d..740a390e657 100644
--- a/test/run-drun/gc-random-test/values.mo
+++ b/test/run-drun/gc-random-test/values.mo
@@ -1,4 +1,5 @@
 import Array "array";
+import Region "../stable-region/Region";
 
 module {
     public type RandomValue = {
@@ -9,6 +10,7 @@ module {
         #box : RandomBox;
         #text : RandomText;
         #option : RandomOption;
+        #region : RandomRegion;
     };
 
     public type RandomObject = {
@@ -38,6 +40,12 @@ module {
 
     public type RandomOption = ?RandomValue;
 
+    public type RandomRegion = {
+        region : Region;
+        checkSize : Nat64;
+        checkValue : Nat8;
+    };
+
     public func isNone(value : RandomValue) : Bool {
         switch value {
             case (#none) true;
diff --git a/test/run-drun/idl-buf-size-bug.mo b/test/run-drun/idl-buf-size-bug.mo
index 6947a241a59..a5e8c5582a3 100644
--- a/test/run-drun/idl-buf-size-bug.mo
+++ b/test/run-drun/idl-buf-size-bug.mo
@@ -1,4 +1,3 @@
-import Prim "mo:⛔";
 actor {
   public func match (b : Int) : async () {
     assert (switch b {
diff --git a/test/run-drun/idl-composite.mo b/test/run-drun/idl-composite.mo
index 9e9e5428e61..543f006dd8a 100644
--- a/test/run-drun/idl-composite.mo
+++ b/test/run-drun/idl-composite.mo
@@ -18,11 +18,11 @@ actor This {
 
        // can't deserialize as update
        let o3 = from_candid blob : ? (actor { f : /* composite  query */ () -> async (); });
-       assert o2 == null;
+       assert o3 == null;
 
        // can't deserialize as oneway
        let o4 = from_candid blob : ? (actor { f : /* composite  query */ () -> (); });
-       assert o2 == null;
+       assert o4 == null;
 
     };
 
diff --git a/test/run-drun/inline.mo b/test/run-drun/inline.mo
index fba37058cf4..eb3422f0787 100644
--- a/test/run-drun/inline.mo
+++ b/test/run-drun/inline.mo
@@ -1,6 +1,3 @@
-//MOC-ENV MOC_UNLOCK_PRIM=yesplease
-import Prim "mo:⛔";
-
 actor {
   func inline(t1: Text, t2 : Text) : Text = t1 # t2;
   func makecalls() : () {
diff --git a/test/run-drun/issue-3140-d.mo b/test/run-drun/issue-3140-d.mo
index 1a3a974ed6c..d749f9d7537 100644
--- a/test/run-drun/issue-3140-d.mo
+++ b/test/run-drun/issue-3140-d.mo
@@ -1,4 +1,3 @@
-import Prim = "mo:⛔";
 actor {
 
   type Fresh = ?Fresh;
diff --git a/test/run-drun/max-stack-variant.mo b/test/run-drun/max-stack-variant.mo
index e0b8b5401ac..fad29cf2893 100644
--- a/test/run-drun/max-stack-variant.mo
+++ b/test/run-drun/max-stack-variant.mo
@@ -1,7 +1,7 @@
 //MOC-FLAG -measure-rts-stack
-import { errorMessage; performanceCounter; rts_heap_size; rts_max_stack_size; debugPrint; } = "mo:⛔";
+import { errorMessage; debugPrint; } = "mo:⛔";
 
-actor stack {
+actor {
     let expectedMinimumSize = 26_000;
 
     public func ser() : async () { await go(false) };
@@ -43,7 +43,7 @@ actor stack {
         let b = to_candid(l);
         debugPrint("serialized");
 
-        let o : ?(List) =
+        let _o : ?(List) =
           if deserialize
             from_candid(b)
           else null;
diff --git a/test/run-drun/max-stack.mo b/test/run-drun/max-stack.mo
index f3375ecce4f..0edbfc6b5bb 100644
--- a/test/run-drun/max-stack.mo
+++ b/test/run-drun/max-stack.mo
@@ -1,7 +1,7 @@
 //MOC-FLAG -measure-rts-stack
-import { errorMessage; performanceCounter; rts_heap_size; rts_max_stack_size; debugPrint; } = "mo:⛔";
+import { errorMessage; debugPrint; } = "mo:⛔";
 
-actor stack {
+actor {
     let expectedMinimumSize = 31_000;
 
     public func ser() : async () { await go(false) };
@@ -41,7 +41,7 @@ actor stack {
         let b = to_candid(l);
         debugPrint("serialized");
 
-        let o : ?(List) =
+        let _o : ?(List) =
           if deserialize
             from_candid(b)
           else null;
diff --git a/test/run-drun/ok/AST-64.tc.ok b/test/run-drun/ok/AST-64.tc.ok
new file mode 100644
index 00000000000..8c40c798ad2
--- /dev/null
+++ b/test/run-drun/ok/AST-64.tc.ok
@@ -0,0 +1,2 @@
+AST-64.mo:1.16-1.20: warning [M0194], unused identifier this (delete or rename to wildcard `_` or `_this`)
+AST-64.mo:5.17-5.21: warning [M0194], unused identifier this (delete or rename to wildcard `_` or `_this`)
diff --git a/test/run-drun/ok/AST-66.ic-ref-run.ok b/test/run-drun/ok/AST-66.ic-ref-run.ok
deleted file mode 100644
index 9cb02531277..00000000000
--- a/test/run-drun/ok/AST-66.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-<= replied: ()
diff --git a/test/run-drun/ok/GIT-843.ic-ref-run.ok b/test/run-drun/ok/GIT-843.ic-ref-run.ok
deleted file mode 100644
index fe17f3cd629..00000000000
--- a/test/run-drun/ok/GIT-843.ic-ref-run.ok
+++ /dev/null
@@ -1,7 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update Bad()
-debug.print: ok
-<= replied: ()
diff --git a/test/run-drun/ok/actor-arg.ic-ref-run.ok b/test/run-drun/ok/actor-arg.ic-ref-run.ok
deleted file mode 100644
index 9f505f9193f..00000000000
--- a/test/run-drun/ok/actor-arg.ic-ref-run.ok
+++ /dev/null
@@ -1,8 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob "DIDL\00\00"; kca_xin = blob "\00asm\01\...
-<= replied: ()
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update install_code(record {arg = blob "NOTDIDL"; kca_xin = blob "\00asm\01\00\...
-<= rejected (RC_CANISTER_ERROR): Initialization trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: IDL error: missing magic bytes"
diff --git a/test/run-drun/ok/actor-capture.ic-ref-run.ok b/test/run-drun/ok/actor-capture.ic-ref-run.ok
deleted file mode 100644
index 9acd6341cc1..00000000000
--- a/test/run-drun/ok/actor-capture.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob "DIDL\00\01q\05Hello"; kca_xin = blob "\...
-<= replied: ()
diff --git a/test/run-drun/ok/actor-class-arg.ic-ref-run.ok b/test/run-drun/ok/actor-class-arg.ic-ref-run.ok
deleted file mode 100644
index 0782b1c14e5..00000000000
--- a/test/run-drun/ok/actor-class-arg.ic-ref-run.ok
+++ /dev/null
@@ -1,44 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob "DIDL\00\00"; kca_xin = blob "\00asm\01\...
-debug.print: hello
-<= replied: ()
-=> query check(1)
-<= replied: ()
-=> update echo()
-debug.print: hello
-<= replied: ()
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-debug.print: hello
-<= replied: ()
-=> query check(1)
-<= replied: ()
-=> update echo()
-debug.print: hello
-<= replied: ()
-=> update install_code(record {arg = blob "DIDL\00\01q\05Hello"; kca_xin = blob "\...
-debug.print: Hello
-<= replied: ()
-=> query check(1)
-<= replied: ()
-=> update echo()
-debug.print: Hello
-<= replied: ()
-=> update install_code(record {arg = blob "DIDL\00\02qq\05Hello\05World"; kca_xin ...
-debug.print: Hello
-<= replied: ()
-=> query check(1)
-<= replied: ()
-=> update echo()
-debug.print: Hello
-debug.print: World
-<= replied: ()
-=> update install_code(record {arg = blob "DIDL\00\02qq\05Hello\05World"; kca_xin ...
-debug.print: Hello
-<= replied: ()
-=> query check(1)
-<= replied: ()
-=> update echo()
-debug.print: Hello
-debug.print: World
-<= replied: ()
diff --git a/test/run-drun/ok/actor-class-cycles.ic-ref-run.ok b/test/run-drun/ok/actor-class-cycles.ic-ref-run.ok
deleted file mode 100644
index 99b3d08ae1d..00000000000
--- a/test/run-drun/ok/actor-class-cycles.ic-ref-run.ok
+++ /dev/null
@@ -1,24 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: {Principal = rwlgt-iiaaa-aaaaa-aaaaa-cai}
-debug.print: {balance = "100T"}
-debug.print: {balance = "100T"}
-debug.print: {iteration = 1}
-debug.print: {balance = "100T"}
-debug.print: {initial_C = 20_000_000_000_000}
-debug.print: {Principal = rrkah-fqaaa-aaaaa-aaaaq-cai}
-debug.print: {current = "20T"; initial = 20_000_000_000_000}
-debug.print: {iteration = 2}
-debug.print: {balance = "80T"}
-debug.print: {initial_C = 30_000_000_000_000}
-debug.print: {Principal = ryjl3-tyaaa-aaaaa-aaaba-cai}
-debug.print: {current = "30T"; initial = 30_000_000_000_000}
-debug.print: {iteration = 3}
-debug.print: {balance = "50T"}
-debug.print: {initial_C = 40_000_000_000_000}
-debug.print: {Principal = r7inp-6aaaa-aaaaa-aaabq-cai}
-debug.print: {current = "40T"; initial = 40_000_000_000_000}
-<= replied: ()
diff --git a/test/run-drun/ok/actor-class-mgmt.ic-ref-run.ok b/test/run-drun/ok/actor-class-mgmt.ic-ref-run.ok
deleted file mode 100644
index c73a53598f0..00000000000
--- a/test/run-drun/ok/actor-class-mgmt.ic-ref-run.ok
+++ /dev/null
@@ -1,7 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: {controllers = [rwlgt-iiaaa-aaaaa-aaaaa-cai]; recent_changes = [{canister_version = 0; details = #creation({controllers = [rwlgt-iiaaa-aaaaa-aaaaa-cai]}); origin = #from_canister({canister_id = rwlgt-iiaaa-aaaaa-aaaaa-cai; canister_version = null})}, {canister_version = 1; details = #code_deployment({mode = #install}); origin = #from_canister({canister_id = rwlgt-iiaaa-aaaaa-aaaaa-cai; canister_version = ?18})}, {canister_version = 3; details = #code_deployment({mode = #upgrade}); origin = #from_canister({canister_id = rwlgt-iiaaa-aaaaa-aaaaa-cai; canister_version = ?22})}, {canister_version = 5; details = #code_deployment({mode = #reinstall}); origin = #from_canister({canister_id = rwlgt-iiaaa-aaaaa-aaaaa-cai; canister_version = ?26})}]; total_num_changes = 4}
-<= replied: ()
diff --git a/test/run-drun/ok/actor-creator-shadow-too.ic-ref-run.ok b/test/run-drun/ok/actor-creator-shadow-too.ic-ref-run.ok
deleted file mode 100644
index 2441159422b..00000000000
--- a/test/run-drun/ok/actor-creator-shadow-too.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update c1()
-<= replied: (service "rwlgt-iiaaa-aaaaa-aaaaa-cai")
diff --git a/test/run-drun/ok/actor-creator-shadow-too.tc.ok b/test/run-drun/ok/actor-creator-shadow-too.tc.ok
new file mode 100644
index 00000000000..e58c6354d82
--- /dev/null
+++ b/test/run-drun/ok/actor-creator-shadow-too.tc.ok
@@ -0,0 +1 @@
+actor-creator-shadow-too.mo:3.17-3.21: warning [M0194], unused identifier ctxt (delete or rename to wildcard `_` or `_ctxt`)
diff --git a/test/run-drun/ok/actor-creator-shadow.ic-ref-run.ok b/test/run-drun/ok/actor-creator-shadow.ic-ref-run.ok
deleted file mode 100644
index f3d45a5b948..00000000000
--- a/test/run-drun/ok/actor-creator-shadow.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update c1()
-<= replied: (1)
diff --git a/test/run-drun/ok/actor-creator-shadow.tc.ok b/test/run-drun/ok/actor-creator-shadow.tc.ok
new file mode 100644
index 00000000000..672d807e4b2
--- /dev/null
+++ b/test/run-drun/ok/actor-creator-shadow.tc.ok
@@ -0,0 +1 @@
+actor-creator-shadow.mo:4.17-4.21: warning [M0194], unused identifier ctxt (delete or rename to wildcard `_` or `_ctxt`)
diff --git a/test/run-drun/ok/actor-creator.ic-ref-run.ok b/test/run-drun/ok/actor-creator.ic-ref-run.ok
deleted file mode 100644
index 4b96b3d2355..00000000000
--- a/test/run-drun/ok/actor-creator.ic-ref-run.ok
+++ /dev/null
@@ -1,8 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update c1()
-<= replied: (principal "w7x7r-cok77-xa")
-=> update c2()
-<= replied: (principal "w7x7r-cok77-xa")
diff --git a/test/run-drun/ok/actor-creator.tc.ok b/test/run-drun/ok/actor-creator.tc.ok
new file mode 100644
index 00000000000..d2171947e62
--- /dev/null
+++ b/test/run-drun/ok/actor-creator.tc.ok
@@ -0,0 +1,2 @@
+actor-creator.mo:6.17-6.21: warning [M0194], unused identifier ctxt (delete or rename to wildcard `_` or `_ctxt`)
+actor-creator.mo:10.17-10.21: warning [M0194], unused identifier ctxt (delete or rename to wildcard `_` or `_ctxt`)
diff --git a/test/run-drun/ok/actor-import.ic-ref-run.ok b/test/run-drun/ok/actor-import.ic-ref-run.ok
deleted file mode 100644
index 14f1db565d6..00000000000
--- a/test/run-drun/ok/actor-import.ic-ref-run.ok
+++ /dev/null
@@ -1,10 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-<= replied: (service "lg264-qjkae")
-=> update go2()
-<= rejected (RC_CANISTER_REJECT): canister does not exist: lg264-qjkae
-=> update go3()
-<= rejected (RC_CANISTER_REJECT): canister does not exist: lg264-qjkae
diff --git a/test/run-drun/ok/actor-reference-bad.ic-ref-run.ok b/test/run-drun/ok/actor-reference-bad.ic-ref-run.ok
deleted file mode 100644
index 4e2dbd584a0..00000000000
--- a/test/run-drun/ok/actor-reference-bad.ic-ref-run.ok
+++ /dev/null
@@ -1,17 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: "bfozs-kwa73-7nadi":
-debug.print: "":
-debug.print: canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: RTS error: blob_of_principal: principal too short"
-debug.print: "BFOZS-KWA73-7NADI":
-debug.print: canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: RTS error: blob_of_principal: invalid principal"
-debug.print: "bfozskwa737nadi":
-debug.print: canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: RTS error: blob_of_principal: invalid principal"
-debug.print: "vpgq":
-debug.print: canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: RTS error: blob_of_principal: principal too short"
-debug.print: "5h74t-uga73-7nadi":
-debug.print: canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: RTS error: blob_of_principal: invalid principal"
-<= replied: ()
diff --git a/test/run-drun/ok/actor-reference-return.ic-ref-run.ok b/test/run-drun/ok/actor-reference-return.ic-ref-run.ok
deleted file mode 100644
index 72a494539ae..00000000000
--- a/test/run-drun/ok/actor-reference-return.ic-ref-run.ok
+++ /dev/null
@@ -1,8 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> query foo()
-<= replied: (service "bfozs-kwa73-7nadi")
-=> query bar()
-<= replied: (service "lsoqw-g6a73-7nado-k725l-5xvnx-3xq")
diff --git a/test/run-drun/ok/actor-reference.ic-ref-run.ok b/test/run-drun/ok/actor-reference.ic-ref-run.ok
deleted file mode 100644
index 7e967e1a062..00000000000
--- a/test/run-drun/ok/actor-reference.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
diff --git a/test/run-drun/ok/array-out-of-bounds.ic-ref-run.ok b/test/run-drun/ok/array-out-of-bounds.ic-ref-run.ok
deleted file mode 100644
index 7fdbd226329..00000000000
--- a/test/run-drun/ok/array-out-of-bounds.ic-ref-run.ok
+++ /dev/null
@@ -1,8 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update foo1()
-<= rejected (RC_CANISTER_ERROR): canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: Array index out of bounds"
-=> update foo2()
-<= rejected (RC_CANISTER_ERROR): canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: Array index out of bounds"
diff --git a/test/run-drun/ok/assert.ic-ref-run.ok b/test/run-drun/ok/assert.ic-ref-run.ok
deleted file mode 100644
index 94beb6671d1..00000000000
--- a/test/run-drun/ok/assert.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-<= rejected (RC_CANISTER_ERROR): canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: assertion failed at Lib.mo:3.27-5.4"
diff --git a/test/run-drun/ok/async-any.ic-ref-run.ok b/test/run-drun/ok/async-any.ic-ref-run.ok
deleted file mode 100644
index 9cb02531277..00000000000
--- a/test/run-drun/ok/async-any.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-<= replied: ()
diff --git a/test/run-drun/ok/async-bang.ic-ref-run.ok b/test/run-drun/ok/async-bang.ic-ref-run.ok
deleted file mode 100644
index e8a8dfa27e0..00000000000
--- a/test/run-drun/ok/async-bang.ic-ref-run.ok
+++ /dev/null
@@ -1,13 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: ?3
-debug.print: null
-debug.print: ?6
-debug.print: null
-debug.print: ?0
-debug.print: null
-debug.print: null
-<= replied: ()
diff --git a/test/run-drun/ok/async-calls1.ic-ref-run.ok b/test/run-drun/ok/async-calls1.ic-ref-run.ok
deleted file mode 100644
index 9cb02531277..00000000000
--- a/test/run-drun/ok/async-calls1.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-<= replied: ()
diff --git a/test/run-drun/ok/async-calls2.ic-ref-run.ok b/test/run-drun/ok/async-calls2.ic-ref-run.ok
deleted file mode 100644
index 9cb02531277..00000000000
--- a/test/run-drun/ok/async-calls2.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-<= replied: ()
diff --git a/test/run-drun/ok/async-calls3.ic-ref-run.ok b/test/run-drun/ok/async-calls3.ic-ref-run.ok
deleted file mode 100644
index 9cb02531277..00000000000
--- a/test/run-drun/ok/async-calls3.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-<= replied: ()
diff --git a/test/run-drun/ok/async-calls3.tc.ok b/test/run-drun/ok/async-calls3.tc.ok
new file mode 100644
index 00000000000..499b58dc3cd
--- /dev/null
+++ b/test/run-drun/ok/async-calls3.tc.ok
@@ -0,0 +1 @@
+async-calls3.mo:5.7-5.8: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
diff --git a/test/run-drun/ok/async-free-var.ic-ref-run.ok b/test/run-drun/ok/async-free-var.ic-ref-run.ok
deleted file mode 100644
index ab88ac89283..00000000000
--- a/test/run-drun/ok/async-free-var.ic-ref-run.ok
+++ /dev/null
@@ -1,13 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: A
-debug.print: A
-debug.print: C
-debug.print: Now in async
-debug.print: C
-debug.print: B
-debug.print: B
-<= replied: ()
diff --git a/test/run-drun/ok/async-loop-while.ic-ref-run.ok b/test/run-drun/ok/async-loop-while.ic-ref-run.ok
deleted file mode 100644
index 79010a297c0..00000000000
--- a/test/run-drun/ok/async-loop-while.ic-ref-run.ok
+++ /dev/null
@@ -1,18 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: 0
-debug.print: 1
-debug.print: 2
-debug.print: 0
-debug.print: 1
-debug.print: 2
-debug.print: 0
-debug.print: 1
-debug.print: 2
-debug.print: 0
-debug.print: 1
-debug.print: 2
-<= replied: ()
diff --git a/test/run-drun/ok/async-loop.ic-ref-run.ok b/test/run-drun/ok/async-loop.ic-ref-run.ok
deleted file mode 100644
index 7e967e1a062..00000000000
--- a/test/run-drun/ok/async-loop.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
diff --git a/test/run-drun/ok/async-new-obj.ic-ref-run.ok b/test/run-drun/ok/async-new-obj.ic-ref-run.ok
deleted file mode 100644
index d40144a7724..00000000000
--- a/test/run-drun/ok/async-new-obj.ic-ref-run.ok
+++ /dev/null
@@ -1,11 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: aaab
-debug.print: babb
-debug.print: dadb
-debug.print: eaeb
-debug.print: cacb
-<= replied: ()
diff --git a/test/run-drun/ok/async-obj-mut.ic-ref-run.ok b/test/run-drun/ok/async-obj-mut.ic-ref-run.ok
deleted file mode 100644
index 5517614369d..00000000000
--- a/test/run-drun/ok/async-obj-mut.ic-ref-run.ok
+++ /dev/null
@@ -1,14 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: 1
-debug.print: 2
-debug.print: 3
-debug.print: done creating
-
-debug.print: 3
-debug.print: 4
-debug.print: 5
-<= replied: ()
diff --git a/test/run-drun/ok/async-obj-mut.tc.ok b/test/run-drun/ok/async-obj-mut.tc.ok
new file mode 100644
index 00000000000..2c392640ac3
--- /dev/null
+++ b/test/run-drun/ok/async-obj-mut.tc.ok
@@ -0,0 +1,5 @@
+async-obj-mut.mo:6.11-6.12: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+async-obj-mut.mo:8.11-8.12: warning [M0194], unused identifier b (delete or rename to wildcard `_` or `_b`)
+async-obj-mut.mo:9.11-9.12: warning [M0194], unused identifier c (delete or rename to wildcard `_` or `_c`)
+async-obj-mut.mo:11.11-11.12: warning [M0194], unused identifier e (delete or rename to wildcard `_` or `_e`)
+async-obj-mut.mo:12.11-12.12: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
diff --git a/test/run-drun/ok/async-while.ic-ref-run.ok b/test/run-drun/ok/async-while.ic-ref-run.ok
deleted file mode 100644
index 79010a297c0..00000000000
--- a/test/run-drun/ok/async-while.ic-ref-run.ok
+++ /dev/null
@@ -1,18 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: 0
-debug.print: 1
-debug.print: 2
-debug.print: 0
-debug.print: 1
-debug.print: 2
-debug.print: 0
-debug.print: 1
-debug.print: 2
-debug.print: 0
-debug.print: 1
-debug.print: 2
-<= replied: ()
diff --git a/test/run-drun/ok/await-sugar.ic-ref-run.ok b/test/run-drun/ok/await-sugar.ic-ref-run.ok
deleted file mode 100644
index 0a074dfe40b..00000000000
--- a/test/run-drun/ok/await-sugar.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update test()
-<= replied: ()
diff --git a/test/run-drun/ok/await-without-yield.ic-ref-run.ok b/test/run-drun/ok/await-without-yield.ic-ref-run.ok
deleted file mode 100644
index 586b2b42884..00000000000
--- a/test/run-drun/ok/await-without-yield.ic-ref-run.ok
+++ /dev/null
@@ -1,7 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: 3
-<= replied: ()
diff --git a/test/run-drun/ok/await.ic-ref-run.ok b/test/run-drun/ok/await.ic-ref-run.ok
deleted file mode 100644
index bf05e0ef8a0..00000000000
--- a/test/run-drun/ok/await.ic-ref-run.ok
+++ /dev/null
@@ -1,33 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: a
-debug.print: b
-debug.print: c
-debug.print: d
-debug.print: e
-debug.print: g
-debug.print: holy
-debug.print: e-while
-debug.print: g-label
-debug.print: .
-debug.print: a
-debug.print: b
-debug.print: cnt: 0 i: 0
-debug.print: cnt: 1 i: 1
-debug.print: cnt: 2 i: 2
-debug.print: cnt: 3 i: 4
-debug.print: cnt: 4 i: 5
-debug.print: cnt: 5 i: 10
-debug.print: .
-debug.print: cnt: 6 i: 3
-debug.print: cnt: 7 i: 6
-debug.print: cnt: 8 i: 11
-debug.print: .
-debug.print: cnt: 9 i: 7
-debug.print: cnt: 10 i: 12
-debug.print: e-exit
-debug.print: g-exit
-<= replied: ()
diff --git a/test/run-drun/ok/await.tc.ok b/test/run-drun/ok/await.tc.ok
new file mode 100644
index 00000000000..ae698746651
--- /dev/null
+++ b/test/run-drun/ok/await.tc.ok
@@ -0,0 +1,3 @@
+await.mo:45.9-45.10: warning [M0194], unused identifier g (delete or rename to wildcard `_` or `_g`)
+await.mo:63.10-63.11: warning [M0194], unused identifier p (delete or rename to wildcard `_` or `_p`)
+await.mo:64.9-64.10: warning [M0194], unused identifier h (delete or rename to wildcard `_` or `_h`)
diff --git a/test/run-drun/ok/basic-cycles.ic-ref-run.ok b/test/run-drun/ok/basic-cycles.ic-ref-run.ok
deleted file mode 100644
index 24ce80cd043..00000000000
--- a/test/run-drun/ok/basic-cycles.ic-ref-run.ok
+++ /dev/null
@@ -1,34 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: cannot add more than 2^128 cycles"
-debug.print: ok
-debug.print: canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: cannot add more than 2^128 cycles"
-debug.print: canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: cycles out of bounds"
-debug.print: {balance = 100_000_000_000_000}
-debug.print: {topped_up_balance = 100_000_000_000_000}
-debug.print: {added = 0}
-debug.print: {amount = 0; available = 0}
-debug.print: {balance = 100_000_000_000_000}
-debug.print: {topped_up_balance = 100_000_000_000_000}
-debug.print: {added = 4_294_967_295}
-debug.print: {amount = 4_294_967_295; available = 4_294_967_295}
-debug.print: {balance = 100_000_000_000_000}
-debug.print: {topped_up_balance = 18_446_744_073_709_551_615}
-debug.print: {added = 18_446_744_073_709_551_615}
-debug.print: {amount = 18_446_744_073_709_551_615; available = 18_446_744_073_709_551_615}
-debug.print: {balance = 18_446_744_073_709_551_615}
-debug.print: {topped_up_balance = 18_446_744_073_709_551_616}
-debug.print: {added = 18_446_744_073_709_551_616}
-debug.print: {amount = 18_446_744_073_709_551_616; available = 18_446_744_073_709_551_616}
-debug.print: {balance = 18_446_744_073_709_551_616}
-debug.print: {topped_up_balance = 79_228_162_514_264_337_593_543_950_335}
-debug.print: {added = 79_228_162_514_264_337_593_543_950_335}
-debug.print: {amount = 79_228_162_514_264_337_593_543_950_335; available = 79_228_162_514_264_337_593_543_950_335}
-debug.print: {balance = 79_228_162_514_264_337_593_543_950_335}
-debug.print: {topped_up_balance = 340_282_366_920_938_463_463_374_607_431_768_211_455}
-debug.print: {added = 340_282_366_920_938_463_463_374_607_431_768_211_455}
-debug.print: {amount = 340_282_366_920_938_463_463_374_607_431_768_211_455; available = 340_282_366_920_938_463_463_374_607_431_768_211_455}
-<= replied: ()
diff --git a/test/run-drun/ok/basic-cycles.tc.ok b/test/run-drun/ok/basic-cycles.tc.ok
new file mode 100644
index 00000000000..6b3df344d9d
--- /dev/null
+++ b/test/run-drun/ok/basic-cycles.tc.ok
@@ -0,0 +1 @@
+basic-cycles.mo:12.7-12.15: warning [M0194], unused identifier refunded (delete or rename to wildcard `_` or `_refunded`)
diff --git a/test/run-drun/ok/bignum1.ic-ref-run.ok b/test/run-drun/ok/bignum1.ic-ref-run.ok
deleted file mode 100644
index 7e967e1a062..00000000000
--- a/test/run-drun/ok/bignum1.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
diff --git a/test/run-drun/ok/bignum1.tc.ok b/test/run-drun/ok/bignum1.tc.ok
new file mode 100644
index 00000000000..b33804dcac0
--- /dev/null
+++ b/test/run-drun/ok/bignum1.tc.ok
@@ -0,0 +1,2 @@
+bignum1.mo:1.7-1.8: warning [M0194], unused identifier B (delete or rename to wildcard `_` or `_B`)
+bignum1.mo:4.8-4.9: warning [M0194], unused identifier b (delete or rename to wildcard `_` or `_b`)
diff --git a/test/run-drun/ok/block.ic-ref-run.ok b/test/run-drun/ok/block.ic-ref-run.ok
deleted file mode 100644
index 2b0fb1f70c2..00000000000
--- a/test/run-drun/ok/block.ic-ref-run.ok
+++ /dev/null
@@ -1,16 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: a1
-debug.print: b1
-debug.print: 1
-debug.print: a2
-debug.print: b2
-debug.print: a3
-debug.print: b3
-debug.print: 3
-debug.print: 5
-debug.print: 6
-<= replied: ()
diff --git a/test/run-drun/ok/calc.ic-ref-run.ok b/test/run-drun/ok/calc.ic-ref-run.ok
deleted file mode 100644
index d2250ad4c26..00000000000
--- a/test/run-drun/ok/calc.ic-ref-run.ok
+++ /dev/null
@@ -1,19 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update evaluate()
-debug.print: Sync
-debug.print: +528
-debug.print: +2_048
-<= replied: ()
-=> update evaluateAsync()
-debug.print: Async
-debug.print: +528
-debug.print: +2_048
-<= replied: ()
-=> update evaluateAsyncStar()
-debug.print: AsyncStar
-debug.print: +528
-debug.print: +2_048
-<= replied: ()
diff --git a/test/run-drun/ok/call-async-method.ic-ref-run.ok b/test/run-drun/ok/call-async-method.ic-ref-run.ok
deleted file mode 100644
index a4f418b064b..00000000000
--- a/test/run-drun/ok/call-async-method.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update __motoko_async_helper()
-<= rejected (RC_CANISTER_ERROR): canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: not a self-call"
diff --git a/test/run-drun/ok/call-async-method.tc.ok b/test/run-drun/ok/call-async-method.tc.ok
new file mode 100644
index 00000000000..26c149bd0d0
--- /dev/null
+++ b/test/run-drun/ok/call-async-method.tc.ok
@@ -0,0 +1 @@
+call-async-method.mo:1.7-1.8: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
diff --git a/test/run-drun/ok/call-raw-candid.ic-ref-run.ok b/test/run-drun/ok/call-raw-candid.ic-ref-run.ok
deleted file mode 100644
index 8dcc1016533..00000000000
--- a/test/run-drun/ok/call-raw-candid.ic-ref-run.ok
+++ /dev/null
@@ -1,13 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: unit!
-debug.print: ("int", +1)
-debug.print: ("text", "hello")
-debug.print: ("text", (1, true, 'a'))
-debug.print: canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: IDL error: unexpected IDL type when parsing Nat"
-debug.print: canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: ohoh"
-debug.print: supercalifragilisticexpialidocious
-<= replied: ()
diff --git a/test/run-drun/ok/call-raw-candid.tc.ok b/test/run-drun/ok/call-raw-candid.tc.ok
new file mode 100644
index 00000000000..6b9dd4f87a8
--- /dev/null
+++ b/test/run-drun/ok/call-raw-candid.tc.ok
@@ -0,0 +1,3 @@
+call-raw-candid.mo:24.30-24.31: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+call-raw-candid.mo:67.13-67.16: warning [M0194], unused identifier res (delete or rename to wildcard `_` or `_res`)
+call-raw-candid.mo:80.13-80.16: warning [M0194], unused identifier res (delete or rename to wildcard `_` or `_res`)
diff --git a/test/run-drun/ok/call-raw.ic-ref-run.ok b/test/run-drun/ok/call-raw.ic-ref-run.ok
deleted file mode 100644
index e23f00ab45c..00000000000
--- a/test/run-drun/ok/call-raw.ic-ref-run.ok
+++ /dev/null
@@ -1,21 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update sint()
-<= replied: (+2)
-=> update snat()
-<= replied: (2)
-=> update stext()
-<= replied: ("hello")
-=> update stuple()
-<= replied: (1, true, (97 : nat32))
-=> update go()
-debug.print: unit!
-debug.print: ("int", +1)
-debug.print: ("int", +2)
-debug.print: ("text", "hello")
-debug.print: ("text", (1, true, 'a'))
-debug.print: canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: ohoh"
-debug.print: supercalifragilisticexpialidocious
-<= replied: ()
diff --git a/test/run-drun/ok/call-raw.tc.ok b/test/run-drun/ok/call-raw.tc.ok
new file mode 100644
index 00000000000..aaa6053f34c
--- /dev/null
+++ b/test/run-drun/ok/call-raw.tc.ok
@@ -0,0 +1,2 @@
+call-raw.mo:40.30-40.31: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+call-raw.mo:84.13-84.16: warning [M0194], unused identifier res (delete or rename to wildcard `_` or `_res`)
diff --git a/test/run-drun/ok/callback-trap-upgrade.ic-ref-run.ok b/test/run-drun/ok/callback-trap-upgrade.ic-ref-run.ok
deleted file mode 100644
index 11e6e2ca2f2..00000000000
--- a/test/run-drun/ok/callback-trap-upgrade.ic-ref-run.ok
+++ /dev/null
@@ -1,22 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-debug.print: init'ed
-<= replied: ()
-=> update stats()
-debug.print: In stats(), outstanding callbacks: 0
-<= replied: ()
-=> update go()
-debug.print: In go(), outstanding callbacks: 0
-debug.print: In ping(), outstanding callbacks: 1
-debug.print: In go() again, outstanding callbacks: 0
-<= rejected (RC_CANISTER_ERROR): canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: assertion failed at callback-trap-upgrade.mo:13.5-13.18"
-=> update stats()
-debug.print: In stats(), outstanding callbacks: 0
-<= replied: ()
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-debug.print: init'ed
-<= replied: ()
-=> update stats()
-debug.print: In stats(), outstanding callbacks: 0
-<= replied: ()
diff --git a/test/run-drun/ok/caller.ic-ref-run.ok b/test/run-drun/ok/caller.ic-ref-run.ok
deleted file mode 100644
index 93526a1e8f0..00000000000
--- a/test/run-drun/ok/caller.ic-ref-run.ok
+++ /dev/null
@@ -1,24 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update c1()
-<= replied: ()
-=> update c2()
-<= replied: ()
-=> update c3()
-<= replied: ()
-=> update c4()
-<= replied: ()
-=> query c6()
-<= replied: ()
-=> update c7()
-<= replied: (principal "w7x7r-cok77-xa")
-=> query c8()
-<= replied: (principal "rwlgt-iiaaa-aaaaa-aaaaa-cai")
-=> query c9()
-<= replied: ((3085957257 : nat32))
-=> query c10()
-<= replied: (3)
-=> query c11()
-<= replied: (opt (202 : nat8))
diff --git a/test/run-drun/ok/caller.tc.ok b/test/run-drun/ok/caller.tc.ok
new file mode 100644
index 00000000000..7f4e2787638
--- /dev/null
+++ b/test/run-drun/ok/caller.tc.ok
@@ -0,0 +1,4 @@
+caller.mo:5.9-5.10: warning [M0194], unused identifier c (delete or rename to wildcard `_` or `_c`)
+caller.mo:10.9-10.11: warning [M0194], unused identifier c1 (delete or rename to wildcard `_` or `_c1`)
+caller.mo:22.9-22.11: warning [M0194], unused identifier c1 (delete or rename to wildcard `_` or `_c1`)
+caller.mo:27.9-27.11: warning [M0194], unused identifier c1 (delete or rename to wildcard `_` or `_c1`)
diff --git a/test/run-drun/ok/certified-data.ic-ref-run.ok b/test/run-drun/ok/certified-data.ic-ref-run.ok
deleted file mode 100644
index ea7891bd429..00000000000
--- a/test/run-drun/ok/certified-data.ic-ref-run.ok
+++ /dev/null
@@ -1,14 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> query get()
-<= replied: (true)
-=> update get()
-<= replied: (false)
-=> update set()
-<= replied: ()
-=> query get()
-<= replied: (true)
-=> update get()
-<= replied: (false)
diff --git a/test/run-drun/ok/class-import.ic-ref-run.ok b/test/run-drun/ok/class-import.ic-ref-run.ok
deleted file mode 100644
index 96aaf64f1b2..00000000000
--- a/test/run-drun/ok/class-import.ic-ref-run.ok
+++ /dev/null
@@ -1,13 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: empty
-debug.print: () tested
-debug.print: one
-debug.print: "one" tested
-debug.print: ("one", "two")
-debug.print: ("one", "two")tested
-debug.print: caught trap
-<= replied: ()
diff --git a/test/run-drun/ok/class-import.tc.ok b/test/run-drun/ok/class-import.tc.ok
new file mode 100644
index 00000000000..543b6ceb683
--- /dev/null
+++ b/test/run-drun/ok/class-import.tc.ok
@@ -0,0 +1,2 @@
+class-import.mo:32.10-32.14: warning [M0194], unused identifier trap (delete or rename to wildcard `_` or `_trap`)
+class-import.mo:41.10-41.14: warning [M0194], unused identifier trap (delete or rename to wildcard `_` or `_trap`)
diff --git a/test/run-drun/ok/clone.ic-ref-run.ok b/test/run-drun/ok/clone.ic-ref-run.ok
deleted file mode 100644
index 7e099fb0c14..00000000000
--- a/test/run-drun/ok/clone.ic-ref-run.ok
+++ /dev/null
@@ -1,16 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update test()
-debug.print: 0
-debug.print: 1
-debug.print: rrkah-fqaaa-aaaaa-aaaaq-cai
-debug.print: 1
-debug.print: 2
-debug.print: ryjl3-tyaaa-aaaaa-aaaba-cai
-debug.print: 2
-debug.print: 3
-debug.print: r7inp-6aaaa-aaaaa-aaabq-cai
-debug.print: 2
-<= replied: ()
diff --git a/test/run-drun/ok/closure-params.ic-ref-run.ok b/test/run-drun/ok/closure-params.ic-ref-run.ok
deleted file mode 100644
index 1b38319016b..00000000000
--- a/test/run-drun/ok/closure-params.ic-ref-run.ok
+++ /dev/null
@@ -1,16 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: 1
-debug.print: 1
-debug.print: 3
-debug.print: 3
-debug.print: 6
-debug.print: 6
-debug.print: 10
-debug.print: 10
-debug.print: 15
-debug.print: 15
-<= replied: ()
diff --git a/test/run-drun/ok/commit-on-await.ic-ref-run.ok b/test/run-drun/ok/commit-on-await.ic-ref-run.ok
deleted file mode 100644
index 46091732589..00000000000
--- a/test/run-drun/ok/commit-on-await.ic-ref-run.ok
+++ /dev/null
@@ -1,10 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: 3
-debug.print: 3
-debug.print: 3
-debug.print: 3
-<= replied: ()
diff --git a/test/run-drun/ok/composite-inspect-message.ic-ref-run.ok b/test/run-drun/ok/composite-inspect-message.ic-ref-run.ok
deleted file mode 100644
index 7e967e1a062..00000000000
--- a/test/run-drun/ok/composite-inspect-message.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
diff --git a/test/run-drun/ok/composite-inspect-message.tc.ok b/test/run-drun/ok/composite-inspect-message.tc.ok
new file mode 100644
index 00000000000..58ee9d7bde2
--- /dev/null
+++ b/test/run-drun/ok/composite-inspect-message.tc.ok
@@ -0,0 +1 @@
+composite-inspect-message.mo:17.8-17.14: warning [M0194], unused identifier caller (delete or rename to wildcard `_` or `_caller`)
diff --git a/test/run-drun/ok/composite-query.tc.ok b/test/run-drun/ok/composite-query.tc.ok
index 771ebcfc7fb..2b5a2d87096 100644
--- a/test/run-drun/ok/composite-query.tc.ok
+++ b/test/run-drun/ok/composite-query.tc.ok
@@ -6,3 +6,4 @@ composite-query.mo:35.11-35.13: warning [M0145], this pattern of type
   ?Class__1
 does not cover value
   null
+composite-query.mo:6.7-6.17: warning [M0194], unused identifier Composites (delete or rename to wildcard `_` or `_Composites`)
diff --git a/test/run-drun/ok/composite-semantics.tc.ok b/test/run-drun/ok/composite-semantics.tc.ok
new file mode 100644
index 00000000000..d489f75d62b
--- /dev/null
+++ b/test/run-drun/ok/composite-semantics.tc.ok
@@ -0,0 +1 @@
+composite-semantics.mo:3.7-3.17: warning [M0194], unused identifier Composites (delete or rename to wildcard `_` or `_Composites`)
diff --git a/test/run-drun/ok/control.tc.ok b/test/run-drun/ok/control.tc.ok
new file mode 100644
index 00000000000..70d2a35cb94
--- /dev/null
+++ b/test/run-drun/ok/control.tc.ok
@@ -0,0 +1,6 @@
+control.mo:6.7-6.14: warning [M0194], unused identifier control (delete or rename to wildcard `_` or `_control`)
+control.mo:15.19-15.20: warning [M0194], unused identifier m (delete or rename to wildcard `_` or `_m`)
+control.mo:16.9-16.10: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+control.mo:17.10-17.11: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+control.mo:17.13-17.14: warning [M0194], unused identifier y (delete or rename to wildcard `_` or `_y`)
+control.mo:17.16-17.17: warning [M0194], unused identifier z (delete or rename to wildcard `_` or `_z`)
diff --git a/test/run-drun/ok/count-callbacks.ic-ref-run.ok b/test/run-drun/ok/count-callbacks.ic-ref-run.ok
deleted file mode 100644
index 84709083acc..00000000000
--- a/test/run-drun/ok/count-callbacks.ic-ref-run.ok
+++ /dev/null
@@ -1,19 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: go 1: 0
-debug.print: go 1: 1
-debug.print: go 1: 2
-debug.print: go 1: 3
-debug.print: go 1: 4
-debug.print: ping! 4
-debug.print: ping! 4
-debug.print: ping! 4
-debug.print: ping! 4
-debug.print: go 2: 3
-debug.print: go 3: 2
-debug.print: go 4: 1
-debug.print: go 5: 0
-<= replied: ()
diff --git a/test/run-drun/ok/counter.ic-ref-run.ok b/test/run-drun/ok/counter.ic-ref-run.ok
deleted file mode 100644
index 98241695791..00000000000
--- a/test/run-drun/ok/counter.ic-ref-run.ok
+++ /dev/null
@@ -1,18 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update inc()
-debug.print: 2
-<= replied: ()
-=> update inc()
-debug.print: 3
-<= replied: ()
-=> update inc()
-debug.print: 4
-<= replied: ()
-=> update printCounter()
-debug.print: 4
-<= replied: ()
-=> update get()
-<= replied: (4)
diff --git a/test/run-drun/ok/counter2.ic-ref-run.ok b/test/run-drun/ok/counter2.ic-ref-run.ok
deleted file mode 100644
index 396e6a3fdb6..00000000000
--- a/test/run-drun/ok/counter2.ic-ref-run.ok
+++ /dev/null
@@ -1,20 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: 2
-debug.print: 3
-debug.print: 4
-debug.print: 4
-debug.print: 5
-debug.print: 6
-debug.print: 7
-debug.print: 8
-debug.print: 9
-debug.print: 10
-debug.print: 11
-debug.print: 12
-debug.print: 13
-debug.print: 14
-<= replied: ()
diff --git a/test/run-drun/ok/data-params.ic-ref-run.ok b/test/run-drun/ok/data-params.ic-ref-run.ok
deleted file mode 100644
index da3daf8967b..00000000000
--- a/test/run-drun/ok/data-params.ic-ref-run.ok
+++ /dev/null
@@ -1,42 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: ("sendn", 0)
-debug.print: ("sendn", 1)
-debug.print: ("sendn", 2)
-debug.print: ("sendn", 3)
-debug.print: ("sendn", 4)
-debug.print: ("sendn", 1_000)
-debug.print: ("sendnn", 5, 6)
-debug.print: ("sendnn", 2_000, 3_000)
-debug.print: ("sendnested", 7, 8, 9)
-debug.print: ("sendarray", [10, 11, 12, 13])
-debug.print: ("sendopt", null)
-debug.print: ("sendopt", ?14)
-debug.print: ("sendrecord", {x = 15; y = 16})
-debug.print: ("sendrecord", {x = 17; y = 18})
-debug.print: ("sendVariant", #foo(20))
-debug.print: ("sendVariant", #bar(20))
-debug.print: ("sendLabeled", "Foo1: ")
-debug.print: ("sendLabeled", "μεταγράψτε: ")
-debug.print: ("sendLabeledOpt", ?"Foo2: ")
-debug.print: ("sendn", 10_000_000_000_000)
-debug.print: ("sendi", +10_000_000_000_000)
-debug.print: ("sendi", -20_000_000_000_000)
-debug.print: ("sendnats", 1, 2, 3, 4)
-debug.print: ("sendints", +1, +2, +3, +4)
-debug.print: ("sendints", -1, -2, -3, -4)
-debug.print: ("sendn", 1_267_650_600_228_229_401_496_703_205_376)
-debug.print: ("sendi", +1_267_650_600_228_229_401_496_703_205_376)
-debug.print: ("sendi", -2_535_301_200_456_458_802_993_406_410_752)
-debug.print: ("sendi", +1_073_741_824)
-debug.print: ("sendi", +1_073_741_823)
-debug.print: ("sendi", 0)
-debug.print: ("sendi", +1)
-debug.print: ("sendi", +42)
-debug.print: ("sendi", -42)
-debug.print: ("sendn", 2_147_483_647)
-debug.print: ("sendfloat", 42.000000)
-<= replied: ()
diff --git a/test/run-drun/ok/distributor.ic-ref-run.ok b/test/run-drun/ok/distributor.ic-ref-run.ok
deleted file mode 100644
index 77fecfea8aa..00000000000
--- a/test/run-drun/ok/distributor.ic-ref-run.ok
+++ /dev/null
@@ -1,78 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: installing node0
-debug.print: 0: insert (0, "0")
-debug.print: 0: lookup 0
-debug.print: installing node1
-debug.print: 1: insert (1, "1")
-debug.print: 1: lookup 1
-debug.print: installing node2
-debug.print: 2: insert (2, "2")
-debug.print: 2: lookup 2
-debug.print: installing node3
-debug.print: 3: insert (3, "3")
-debug.print: 3: lookup 3
-debug.print: installing node4
-debug.print: 4: insert (4, "4")
-debug.print: 4: lookup 4
-debug.print: installing node5
-debug.print: 5: insert (5, "5")
-debug.print: 5: lookup 5
-debug.print: installing node6
-debug.print: 6: insert (6, "6")
-debug.print: 6: lookup 6
-debug.print: installing node7
-debug.print: 7: insert (7, "7")
-debug.print: 7: lookup 7
-debug.print: 0: lookup 8
-debug.print: 0: insert (8, "8")
-debug.print: 0: lookup 8
-debug.print: 1: lookup 9
-debug.print: 1: insert (9, "9")
-debug.print: 1: lookup 9
-debug.print: 2: lookup 10
-debug.print: 2: insert (10, "10")
-debug.print: 2: lookup 10
-debug.print: 3: lookup 11
-debug.print: 3: insert (11, "11")
-debug.print: 3: lookup 11
-debug.print: 4: lookup 12
-debug.print: 4: insert (12, "12")
-debug.print: 4: lookup 12
-debug.print: 5: lookup 13
-debug.print: 5: insert (13, "13")
-debug.print: 5: lookup 13
-debug.print: 6: lookup 14
-debug.print: 6: insert (14, "14")
-debug.print: 6: lookup 14
-debug.print: 7: lookup 15
-debug.print: 7: insert (15, "15")
-debug.print: 7: lookup 15
-debug.print: 0: lookup 16
-debug.print: 0: insert (16, "16")
-debug.print: 0: lookup 16
-debug.print: 1: lookup 17
-debug.print: 1: insert (17, "17")
-debug.print: 1: lookup 17
-debug.print: 2: lookup 18
-debug.print: 2: insert (18, "18")
-debug.print: 2: lookup 18
-debug.print: 3: lookup 19
-debug.print: 3: insert (19, "19")
-debug.print: 3: lookup 19
-debug.print: 4: lookup 20
-debug.print: 4: insert (20, "20")
-debug.print: 4: lookup 20
-debug.print: 5: lookup 21
-debug.print: 5: insert (21, "21")
-debug.print: 5: lookup 21
-debug.print: 6: lookup 22
-debug.print: 6: insert (22, "22")
-debug.print: 6: lookup 22
-debug.print: 7: lookup 23
-debug.print: 7: insert (23, "23")
-debug.print: 7: lookup 23
-<= replied: ()
diff --git a/test/run-drun/ok/divide-by-zero.ic-ref-run.ok b/test/run-drun/ok/divide-by-zero.ic-ref-run.ok
deleted file mode 100644
index 07cdf3bdbb5..00000000000
--- a/test/run-drun/ok/divide-by-zero.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= rejected (RC_CANISTER_ERROR): Initialization trapped: EvalTrapError region:0xXXX-0xXXX "NumericIntegerDivideByZero"
diff --git a/test/run-drun/ok/do-async-nary.ic-ref-run.ok b/test/run-drun/ok/do-async-nary.ic-ref-run.ok
deleted file mode 100644
index 9cb02531277..00000000000
--- a/test/run-drun/ok/do-async-nary.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-<= replied: ()
diff --git a/test/run-drun/ok/do-async-nary.tc.ok b/test/run-drun/ok/do-async-nary.tc.ok
new file mode 100644
index 00000000000..4cb753d294e
--- /dev/null
+++ b/test/run-drun/ok/do-async-nary.tc.ok
@@ -0,0 +1,2 @@
+do-async-nary.mo:10.16-10.22: warning [M0194], unused identifier doText (delete or rename to wildcard `_` or `_doText`)
+do-async-nary.mo:11.9-11.10: warning [M0194], unused identifier t (delete or rename to wildcard `_` or `_t`)
diff --git a/test/run-drun/ok/do-async-nested.ic-ref-run.ok b/test/run-drun/ok/do-async-nested.ic-ref-run.ok
deleted file mode 100644
index 9cb02531277..00000000000
--- a/test/run-drun/ok/do-async-nested.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-<= replied: ()
diff --git a/test/run-drun/ok/do-async-poly.tc.ok b/test/run-drun/ok/do-async-poly.tc.ok
index 6933d16c735..a4d79c0226a 100644
--- a/test/run-drun/ok/do-async-poly.tc.ok
+++ b/test/run-drun/ok/do-async-poly.tc.ok
@@ -8,3 +8,4 @@ do-async-poly.mo:22.42-22.43: type error [M0033], async has non-shared content t
   T__23
 do-async-poly.mo:26.43-26.44: type error [M0033], async has non-shared content type
   T__24
+do-async-poly.mo:13.16-13.22: warning [M0194], unused identifier doText (delete or rename to wildcard `_` or `_doText`)
diff --git a/test/run-drun/ok/do-async-rec.ic-ref-run.ok b/test/run-drun/ok/do-async-rec.ic-ref-run.ok
deleted file mode 100644
index 9cb02531277..00000000000
--- a/test/run-drun/ok/do-async-rec.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-<= replied: ()
diff --git a/test/run-drun/ok/do-async-rec.tc.ok b/test/run-drun/ok/do-async-rec.tc.ok
new file mode 100644
index 00000000000..47b5efc7650
--- /dev/null
+++ b/test/run-drun/ok/do-async-rec.tc.ok
@@ -0,0 +1 @@
+do-async-rec.mo:1.8-1.9: warning [M0194], unused identifier P (delete or rename to wildcard `_` or `_P`)
diff --git a/test/run-drun/ok/do-async-unary.ic-ref-run.ok b/test/run-drun/ok/do-async-unary.ic-ref-run.ok
deleted file mode 100644
index 9cb02531277..00000000000
--- a/test/run-drun/ok/do-async-unary.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-<= replied: ()
diff --git a/test/run-drun/ok/do-async-unary.tc.ok b/test/run-drun/ok/do-async-unary.tc.ok
new file mode 100644
index 00000000000..6b23e8dd1db
--- /dev/null
+++ b/test/run-drun/ok/do-async-unary.tc.ok
@@ -0,0 +1,2 @@
+do-async-unary.mo:10.16-10.22: warning [M0194], unused identifier doText (delete or rename to wildcard `_` or `_doText`)
+do-async-unary.mo:11.9-11.10: warning [M0194], unused identifier t (delete or rename to wildcard `_` or `_t`)
diff --git a/test/run-drun/ok/do-async-unit.ic-ref-run.ok b/test/run-drun/ok/do-async-unit.ic-ref-run.ok
deleted file mode 100644
index 9cb02531277..00000000000
--- a/test/run-drun/ok/do-async-unit.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-<= replied: ()
diff --git a/test/run-drun/ok/do-async-unit.tc.ok b/test/run-drun/ok/do-async-unit.tc.ok
new file mode 100644
index 00000000000..649f65533c4
--- /dev/null
+++ b/test/run-drun/ok/do-async-unit.tc.ok
@@ -0,0 +1,2 @@
+do-async-unit.mo:10.16-10.22: warning [M0194], unused identifier doText (delete or rename to wildcard `_` or `_doText`)
+do-async-unit.mo:11.9-11.10: warning [M0194], unused identifier t (delete or rename to wildcard `_` or `_t`)
diff --git a/test/run-drun/ok/do-async.ic-ref-run.ok b/test/run-drun/ok/do-async.ic-ref-run.ok
deleted file mode 100644
index 9cb02531277..00000000000
--- a/test/run-drun/ok/do-async.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-<= replied: ()
diff --git a/test/run-drun/ok/do-option-bug.ic-ref-run.ok b/test/run-drun/ok/do-option-bug.ic-ref-run.ok
deleted file mode 100644
index 9cb02531277..00000000000
--- a/test/run-drun/ok/do-option-bug.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-<= replied: ()
diff --git a/test/run-drun/ok/do-option-bug.tc.ok b/test/run-drun/ok/do-option-bug.tc.ok
new file mode 100644
index 00000000000..1a1a860ead5
--- /dev/null
+++ b/test/run-drun/ok/do-option-bug.tc.ok
@@ -0,0 +1,2 @@
+do-option-bug.mo:1.8-1.9: warning [M0194], unused identifier P (delete or rename to wildcard `_` or `_P`)
+do-option-bug.mo:3.7-3.8: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
diff --git a/test/run-drun/ok/empty-actor.ic-ref-run.ok b/test/run-drun/ok/empty-actor.ic-ref-run.ok
deleted file mode 100644
index 7e967e1a062..00000000000
--- a/test/run-drun/ok/empty-actor.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
diff --git a/test/run-drun/ok/empty-call.ic-ref-run.ok b/test/run-drun/ok/empty-call.ic-ref-run.ok
deleted file mode 100644
index 9cb02531277..00000000000
--- a/test/run-drun/ok/empty-call.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-<= replied: ()
diff --git a/test/run-drun/ok/error-codes.ic-ref-run.ok b/test/run-drun/ok/error-codes.ic-ref-run.ok
deleted file mode 100644
index 98964b31884..00000000000
--- a/test/run-drun/ok/error-codes.ic-ref-run.ok
+++ /dev/null
@@ -1,8 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: canister_reject:ball
-debug.print: canister_error:canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: assertion failed at error-codes.mo:10.33-10.50"
-<= replied: ()
diff --git a/test/run-drun/ok/error-codes.tc.ok b/test/run-drun/ok/error-codes.tc.ok
new file mode 100644
index 00000000000..85ed2afe24b
--- /dev/null
+++ b/test/run-drun/ok/error-codes.tc.ok
@@ -0,0 +1 @@
+error-codes.mo:8.16-8.23: warning [M0194], unused identifier invalid (delete or rename to wildcard `_` or `_invalid`)
diff --git a/test/run-drun/ok/eval.ic-ref-run.ok b/test/run-drun/ok/eval.ic-ref-run.ok
deleted file mode 100644
index 7e967e1a062..00000000000
--- a/test/run-drun/ok/eval.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
diff --git a/test/run-drun/ok/explicit-actor-import.tc.ok b/test/run-drun/ok/explicit-actor-import.tc.ok
index 979a9876b22..2614c4c46b4 100644
--- a/test/run-drun/ok/explicit-actor-import.tc.ok
+++ b/test/run-drun/ok/explicit-actor-import.tc.ok
@@ -2,3 +2,4 @@ explicit-actor-import.mo:10.8-10.29: type error [M0114], object pattern cannot c
   actor {go : shared () -> async actor {}}
 explicit-actor-import.mo:11.8-11.29: type error [M0114], object pattern cannot consume actor type
   actor {go : shared () -> async actor {}}
+explicit-actor-import.mo:13.7-13.8: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
diff --git a/test/run-drun/ok/explicit-trap.ic-ref-run.ok b/test/run-drun/ok/explicit-trap.ic-ref-run.ok
deleted file mode 100644
index c880c626eaf..00000000000
--- a/test/run-drun/ok/explicit-trap.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-<= rejected (RC_CANISTER_ERROR): canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: This is an explicit trap"
diff --git a/test/run-drun/ok/flatten-awaitables.ic-ref-run.ok b/test/run-drun/ok/flatten-awaitables.ic-ref-run.ok
deleted file mode 100644
index e9ca37a049c..00000000000
--- a/test/run-drun/ok/flatten-awaitables.ic-ref-run.ok
+++ /dev/null
@@ -1,40 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: first-order
-debug.print: 0
-debug.print: 1
-debug.print: 2
-debug.print: 3
-debug.print: 4
-debug.print: 5
-debug.print: 6
-debug.print: 7
-debug.print: 8
-debug.print: 9
-debug.print: 10
-debug.print: 11
-debug.print: 12
-debug.print: 13
-debug.print: 14
-debug.print: 15
-debug.print: higher-order
-debug.print: 0
-debug.print: 1
-debug.print: 2
-debug.print: 3
-debug.print: 4
-debug.print: 5
-debug.print: 6
-debug.print: 7
-debug.print: 8
-debug.print: 9
-debug.print: 10
-debug.print: 11
-debug.print: 12
-debug.print: 13
-debug.print: 14
-debug.print: 15
-<= replied: ()
diff --git a/test/run-drun/ok/for-await.ic-ref-run.ok b/test/run-drun/ok/for-await.ic-ref-run.ok
deleted file mode 100644
index 447ad533953..00000000000
--- a/test/run-drun/ok/for-await.ic-ref-run.ok
+++ /dev/null
@@ -1,17 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: 0
-debug.print: 1
-debug.print: 2
-debug.print: 3
-debug.print: 4
-debug.print: 5
-debug.print: 6
-debug.print: 7
-debug.print: 8
-debug.print: 9
-debug.print: 10
-<= replied: ()
diff --git a/test/run-drun/ok/free-callbacks.ic-ref-run.ok b/test/run-drun/ok/free-callbacks.ic-ref-run.ok
deleted file mode 100644
index 82a0efea9c5..00000000000
--- a/test/run-drun/ok/free-callbacks.ic-ref-run.ok
+++ /dev/null
@@ -1,7 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: Ignore Diff: (ignored)
-<= replied: ()
diff --git a/test/run-drun/ok/from_candid_trap.ic-ref-run.ok b/test/run-drun/ok/from_candid_trap.ic-ref-run.ok
deleted file mode 100644
index 9cb02531277..00000000000
--- a/test/run-drun/ok/from_candid_trap.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-<= replied: ()
diff --git a/test/run-drun/ok/gc.ic-ref-run.ok b/test/run-drun/ok/gc.ic-ref-run.ok
deleted file mode 100644
index 5273b9be887..00000000000
--- a/test/run-drun/ok/gc.ic-ref-run.ok
+++ /dev/null
@@ -1,49 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update testBytes()
-debug.print: 0
-debug.print: 1
-debug.print: 2
-debug.print: 3
-<= replied: ()
-=> update testChars()
-debug.print: 'a'
-debug.print: 'b'
-debug.print: 'c'
-debug.print: 'd'
-debug.print: 'e'
-debug.print: 'f'
-debug.print: 'g'
-debug.print: 'h'
-debug.print: 'h'
-debug.print: 'i'
-debug.print: 'j'
-debug.print: 'k'
-debug.print: 'l'
-debug.print: 'm'
-debug.print: 'n'
-debug.print: 'o'
-debug.print: 'p'
-debug.print: 'q'
-debug.print: 'r'
-debug.print: 's'
-debug.print: 't'
-debug.print: 'u'
-debug.print: 'v'
-debug.print: 'w'
-debug.print: 'x'
-debug.print: 'y'
-debug.print: 'z'
-<= replied: ()
-=> update testArray()
-debug.print: "0"
-debug.print: "1"
-debug.print: "2"
-<= replied: ()
-=> update testArrayMut()
-debug.print: "0"
-debug.print: "1"
-debug.print: "2"
-<= replied: ()
diff --git a/test/run-drun/ok/general_await.ic-ref-run.ok b/test/run-drun/ok/general_await.ic-ref-run.ok
deleted file mode 100644
index f4d38a11a30..00000000000
--- a/test/run-drun/ok/general_await.ic-ref-run.ok
+++ /dev/null
@@ -1,50 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update Test()
-debug.print: Ack
-debug.print: Ack
-debug.print: +1
-debug.print: +2
-debug.print: Ack
-debug.print: Ack
-debug.print: Ack
-debug.print: Ack
-debug.print: Ack
-debug.print: Ack
-debug.print: Ack
-debug.print: Ack
-debug.print: Ack
-debug.print: Ack
-debug.print: 0
-debug.print: +1
-debug.print: +2
-debug.print: +3
-debug.print: +4
-debug.print: +5
-debug.print: +6
-debug.print: +7
-debug.print: +8
-debug.print: +9
-debug.print: Ack
-debug.print: Ack
-debug.print: Ack
-debug.print: Ack
-debug.print: Ack
-debug.print: Ack
-debug.print: Ack
-debug.print: Ack
-debug.print: Ack
-debug.print: Ack
-debug.print: +10
-debug.print: +9
-debug.print: +8
-debug.print: +7
-debug.print: +6
-debug.print: +5
-debug.print: +4
-debug.print: +3
-debug.print: +2
-debug.print: +1
-<= replied: ()
diff --git a/test/run-drun/ok/general_await_implicit.ic-ref-run.ok b/test/run-drun/ok/general_await_implicit.ic-ref-run.ok
deleted file mode 100644
index f4d38a11a30..00000000000
--- a/test/run-drun/ok/general_await_implicit.ic-ref-run.ok
+++ /dev/null
@@ -1,50 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update Test()
-debug.print: Ack
-debug.print: Ack
-debug.print: +1
-debug.print: +2
-debug.print: Ack
-debug.print: Ack
-debug.print: Ack
-debug.print: Ack
-debug.print: Ack
-debug.print: Ack
-debug.print: Ack
-debug.print: Ack
-debug.print: Ack
-debug.print: Ack
-debug.print: 0
-debug.print: +1
-debug.print: +2
-debug.print: +3
-debug.print: +4
-debug.print: +5
-debug.print: +6
-debug.print: +7
-debug.print: +8
-debug.print: +9
-debug.print: Ack
-debug.print: Ack
-debug.print: Ack
-debug.print: Ack
-debug.print: Ack
-debug.print: Ack
-debug.print: Ack
-debug.print: Ack
-debug.print: Ack
-debug.print: Ack
-debug.print: +10
-debug.print: +9
-debug.print: +8
-debug.print: +7
-debug.print: +6
-debug.print: +5
-debug.print: +4
-debug.print: +3
-debug.print: +2
-debug.print: +1
-<= replied: ()
diff --git a/test/run-drun/ok/generic-tail-rec.ic-ref-run.ok b/test/run-drun/ok/generic-tail-rec.ic-ref-run.ok
deleted file mode 100644
index 50d9d849d62..00000000000
--- a/test/run-drun/ok/generic-tail-rec.ic-ref-run.ok
+++ /dev/null
@@ -1,8 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-debug.print: done 1
-debug.print: done 2
-debug.print: done 3
-debug.print: done 4
-<= replied: ()
diff --git a/test/run-drun/ok/hello-world-async.ic-ref-run.ok b/test/run-drun/ok/hello-world-async.ic-ref-run.ok
deleted file mode 100644
index 1475d56fb89..00000000000
--- a/test/run-drun/ok/hello-world-async.ic-ref-run.ok
+++ /dev/null
@@ -1,8 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: Hello 
-debug.print: World!
-<= replied: ()
diff --git a/test/run-drun/ok/hello-world-await.ic-ref-run.ok b/test/run-drun/ok/hello-world-await.ic-ref-run.ok
deleted file mode 100644
index 1195387b10b..00000000000
--- a/test/run-drun/ok/hello-world-await.ic-ref-run.ok
+++ /dev/null
@@ -1,7 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: Hello World!
-<= replied: ()
diff --git a/test/run-drun/ok/hello-world-message.ic-ref-run.ok b/test/run-drun/ok/hello-world-message.ic-ref-run.ok
deleted file mode 100644
index 7e967e1a062..00000000000
--- a/test/run-drun/ok/hello-world-message.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
diff --git a/test/run-drun/ok/hello-world-return.ic-ref-run.ok b/test/run-drun/ok/hello-world-return.ic-ref-run.ok
deleted file mode 100644
index 687b56087e9..00000000000
--- a/test/run-drun/ok/hello-world-return.ic-ref-run.ok
+++ /dev/null
@@ -1,8 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> query hello("World")
-<= replied: ("Hello World!")
-=> query hello2("World")
-<= replied: ("Hello World!")
diff --git a/test/run-drun/ok/hello-world.ic-ref-run.ok b/test/run-drun/ok/hello-world.ic-ref-run.ok
deleted file mode 100644
index c1440ab5571..00000000000
--- a/test/run-drun/ok/hello-world.ic-ref-run.ok
+++ /dev/null
@@ -1,5 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-debug.print: Hello World!
-<= replied: ()
diff --git a/test/run-drun/ok/ic-calls.ic-ref-run.ok b/test/run-drun/ok/ic-calls.ic-ref-run.ok
deleted file mode 100644
index 9cb02531277..00000000000
--- a/test/run-drun/ok/ic-calls.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-<= replied: ()
diff --git a/test/run-drun/ok/id-sub-ho.ic-ref-run.ok b/test/run-drun/ok/id-sub-ho.ic-ref-run.ok
deleted file mode 100644
index 85e03181f69..00000000000
--- a/test/run-drun/ok/id-sub-ho.ic-ref-run.ok
+++ /dev/null
@@ -1,15 +0,0 @@
-→ update create_canister(record {settings = null})
-← replied: (record {hymijyo = principal "cvccv-qqaaq-aaaaa-aaaaa-c"})
-→ update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0…
-← replied: ()
-→ update go()
-debug.print: ok
-debug.print: ok
-debug.print: ok
-debug.print: ok
-debug.print: ok
-debug.print: ok
-debug.print: ok
-debug.print: ok
-debug.print: ok
-← replied: ()
diff --git a/test/run-drun/ok/idl-any-stable.ic-ref-run.ok b/test/run-drun/ok/idl-any-stable.ic-ref-run.ok
deleted file mode 100644
index fdcac8f361c..00000000000
--- a/test/run-drun/ok/idl-any-stable.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> query any(0x4449444c01017102007100000000000003424144)
-<= rejected (RC_CANISTER_ERROR): canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: IDL error: illegal type table"
diff --git a/test/run-drun/ok/idl-any.ic-ref-run.ok b/test/run-drun/ok/idl-any.ic-ref-run.ok
deleted file mode 100644
index 2a64e76e2b1..00000000000
--- a/test/run-drun/ok/idl-any.ic-ref-run.ok
+++ /dev/null
@@ -1,94 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> query any(null, "Foo")
-debug.print: ok: Foo
-<= replied: ()
-=> query any(true, "Foo")
-debug.print: ok: Foo
-<= replied: ()
-=> query any(16777216, "Foo")
-debug.print: ok: Foo
-<= replied: ()
-=> query any(+16777216, "Foo")
-debug.print: ok: Foo
-<= replied: ()
-=> query any((171 : nat8), "Foo")
-debug.print: ok: Foo
-<= replied: ()
-=> query any((52651 : nat16), "Foo")
-debug.print: ok: Foo
-<= replied: ()
-=> query any((4022250974 : nat32), "Foo")
-debug.print: ok: Foo
-<= replied: ()
-=> query any((7417146883396513246 : nat64), "Foo")
-debug.print: ok: Foo
-<= replied: ()
-=> query any((-85 : int8), "Foo")
-debug.print: ok: Foo
-<= replied: ()
-=> query any((-12885 : int16), "Foo")
-debug.print: ok: Foo
-<= replied: ()
-=> query any((-272716322 : int32), "Foo")
-debug.print: ok: Foo
-<= replied: ()
-=> query any((7417146883396513246 : int64), "Foo")
-debug.print: ok: Foo
-<= replied: ()
-=> query any((-1.1802469e29 : float32), "Foo")
-debug.print: ok: Foo
-<= replied: ()
-=> query any((6.7440016273455695e187 : float64), "Foo")
-debug.print: ok: Foo
-<= replied: ()
-=> query any("Foo", "Foo")
-debug.print: ok: Foo
-<= replied: ()
-=> query any((null : reserved), "Foo")
-debug.print: ok: Foo
-<= replied: ()
-=> query any(0x4449444c000268710003466f6f)
-debug.print: ok: Foo
-<= replied: ()
-=> query any(principal "psokg-ww6vw-7o6", "Foo")
-debug.print: ok: Foo
-<= replied: ()
-=> query any(null, "Foo")
-debug.print: ok: Foo
-<= replied: ()
-=> query any(opt "Foo", "Foo")
-debug.print: ok: Foo
-<= replied: ()
-=> query any(vec {}, "Foo")
-debug.print: ok: Foo
-<= replied: ()
-=> query any(vec {"Foo"}, "Foo")
-debug.print: ok: Foo
-<= replied: ()
-=> query any(vec {""; "Foo"}, "Foo")
-debug.print: ok: Foo
-<= replied: ()
-=> query any(record {}, "Foo")
-debug.print: ok: Foo
-<= replied: ()
-=> query any(record {dk_jduc = (-272716322 : int32)}, "Foo")
-debug.print: ok: Foo
-<= replied: ()
-=> query any(record {0 = "☃"; dk_jduc = (-272716322 : int32)}, "Foo")
-debug.print: ok: Foo
-<= replied: ()
-=> query any(variant {dk_jduc = (-272716322 : int32)}, "Foo")
-debug.print: ok: Foo
-<= replied: ()
-=> query any(variant {0 = "☃"}, "Foo")
-debug.print: ok: Foo
-<= replied: ()
-=> query any(variant {dk_jduc = (-272716322 : int32)}, "Foo")
-debug.print: ok: Foo
-<= replied: ()
-=> query any(future, "Foo")
-debug.print: ok: Foo
-<= replied: ()
diff --git a/test/run-drun/ok/idl-bad.ic-ref-run.ok b/test/run-drun/ok/idl-bad.ic-ref-run.ok
deleted file mode 100644
index 2b92453cc23..00000000000
--- a/test/run-drun/ok/idl-bad.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> query foo(0x4e4f544449444c)
-<= rejected (RC_CANISTER_ERROR): canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: IDL error: missing magic bytes"
diff --git a/test/run-drun/ok/idl-bool.ic-ref-run.ok b/test/run-drun/ok/idl-bool.ic-ref-run.ok
deleted file mode 100644
index 942df4be635..00000000000
--- a/test/run-drun/ok/idl-bool.ic-ref-run.ok
+++ /dev/null
@@ -1,10 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> query flip(false)
-<= replied: (true)
-=> query flip(true)
-<= replied: (false)
-=> query flip(0x4449444c00017e02)
-<= rejected (RC_CANISTER_ERROR): canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: IDL error: byte tag not 0 or 1"
diff --git a/test/run-drun/ok/idl-buf-size-bug.ic-ref-run.ok b/test/run-drun/ok/idl-buf-size-bug.ic-ref-run.ok
deleted file mode 100644
index 010613298a5..00000000000
--- a/test/run-drun/ok/idl-buf-size-bug.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update foo()
-<= replied: ()
diff --git a/test/run-drun/ok/idl-field-escape.ic-ref-run.ok b/test/run-drun/ok/idl-field-escape.ic-ref-run.ok
deleted file mode 100644
index f4ea7dc0841..00000000000
--- a/test/run-drun/ok/idl-field-escape.ic-ref-run.ok
+++ /dev/null
@@ -1,12 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> query foo1()
-<= replied: (record {foo = null})
-=> query foo2()
-<= replied: (record {foo = null})
-=> query out()
-<= replied: (record {0 = +65535; 1 = 4096; async = "XXX"})
-=> query input(record {0 = +65535; 1 = 4096; async = "XXX"})
-<= replied: ()
diff --git a/test/run-drun/ok/idl-field-escape.tc.ok b/test/run-drun/ok/idl-field-escape.tc.ok
new file mode 100644
index 00000000000..1acfb3ae1cb
--- /dev/null
+++ b/test/run-drun/ok/idl-field-escape.tc.ok
@@ -0,0 +1 @@
+idl-field-escape.mo:20.27-20.28: warning [M0194], unused identifier r (delete or rename to wildcard `_` or `_r`)
diff --git a/test/run-drun/ok/idl-float.ic-ref-run.ok b/test/run-drun/ok/idl-float.ic-ref-run.ok
deleted file mode 100644
index d26b1a5b456..00000000000
--- a/test/run-drun/ok/idl-float.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> query foon((3.0 : float64))
-<= replied: ((6.0 : float64))
diff --git a/test/run-drun/ok/idl-func.ic-ref-run.ok b/test/run-drun/ok/idl-func.ic-ref-run.ok
deleted file mode 100644
index 2e8dfc98202..00000000000
--- a/test/run-drun/ok/idl-func.ic-ref-run.ok
+++ /dev/null
@@ -1,12 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> query fun()
-<= replied: (null)
-=> query fun2(null)
-<= replied: ()
-=> query fun3()
-<= replied: (func "rwlgt-iiaaa-aaaaa-aaaaa-cai"."fun")
-=> query fun4()
-<= replied: (func "rwlgt-iiaaa-aaaaa-aaaaa-cai"."oneway")
diff --git a/test/run-drun/ok/idl-func.tc.ok b/test/run-drun/ok/idl-func.tc.ok
new file mode 100644
index 00000000000..8a343ea2190
--- /dev/null
+++ b/test/run-drun/ok/idl-func.tc.ok
@@ -0,0 +1 @@
+idl-func.mo:8.26-8.29: warning [M0194], unused identifier arg (delete or rename to wildcard `_` or `_arg`)
diff --git a/test/run-drun/ok/idl-large-principal.ic-ref-run.ok b/test/run-drun/ok/idl-large-principal.ic-ref-run.ok
deleted file mode 100644
index 3e978beef98..00000000000
--- a/test/run-drun/ok/idl-large-principal.ic-ref-run.ok
+++ /dev/null
@@ -1,16 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> query fun1(principal "vs4dm-3qace-rdgrc-vmz3y-rgiac-erdgr-cvmz3-yrgia-...
-<= replied: ()
-=> query fun1(principal "wfewn-3qace-regrc-vmz3y-rgiac-erdgr-cvmz3-yrgia-...
-<= rejected (RC_CANISTER_ERROR): canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: IDL error: principal too long"
-=> query fun2(service "vs4dm-3qace-rdgrc-vmz3y-rgiac-erdgr-cvmz3-yrgia-ce...
-<= replied: ()
-=> query fun2(service "6f3ta-baace-rdgrc-vmz3y-rgiac-erdgr-cvmz3-yrgia-ce...
-<= rejected (RC_CANISTER_ERROR): canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: IDL error: principal too long"
-=> query fun3(func "vs4dm-3qace-rdgrc-vmz3y-rgiac-erdgr-cvmz3-yrgia-cerdg...
-<= replied: ()
-=> query fun3(func "6f3ta-baace-rdgrc-vmz3y-rgiac-erdgr-cvmz3-yrgia-cerdg...
-<= rejected (RC_CANISTER_ERROR): canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: IDL error: principal too long"
diff --git a/test/run-drun/ok/idl-mo.ic-ref-run.ok b/test/run-drun/ok/idl-mo.ic-ref-run.ok
deleted file mode 100644
index 7e967e1a062..00000000000
--- a/test/run-drun/ok/idl-mo.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
diff --git a/test/run-drun/ok/idl-nary.ic-ref-run.ok b/test/run-drun/ok/idl-nary.ic-ref-run.ok
deleted file mode 100644
index d413b8f469f..00000000000
--- a/test/run-drun/ok/idl-nary.ic-ref-run.ok
+++ /dev/null
@@ -1,26 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> query two("One", "Two")
-<= replied: ("One", "Two")
-=> query three("One", "Two", "Three")
-<= replied: ("One", "Two", "Three")
-=> query four("One", "Two", "Three", "Four")
-<= replied: ("One", "Two", "Three", "Four")
-=> query mkRecord()
-<= replied: (record {"One"; "Two"; "Three"; "Four"})
-=> query unary1(record {"One"; "Two"; "Three"; "Four"})
-<= replied: (record {"One"; "Two"; "Three"; "Four"})
-=> query unary2(record {"One"; "Two"; "Three"; "Four"})
-<= replied: (record {"One"; "Two"; "Three"; "Four"})
-=> query unary3(record {"One"; "Two"; "Three"; "Four"})
-<= replied: (record {"One"; "Two"; "Three"; "Four"})
-=> query unary4(record {"One"; "Two"; "Three"; "Four"})
-<= replied: (record {"One"; "Two"; "Three"; "Four"})
-=> query three("One", "Two")
-<= rejected (RC_CANISTER_ERROR): canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: IDL error: too few arguments ttt"
-=> query three(0x4449444c0003717171034f6e650354776f05546872656545585452414...
-<= rejected (RC_CANISTER_ERROR): canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: IDL error: left-over bytes ttt"
-=> query four("One", "Two", "Three", "Four", "Five")
-<= replied: ("One", "Two", "Three", "Four")
diff --git a/test/run-drun/ok/idl-nat-int.ic-ref-run.ok b/test/run-drun/ok/idl-nat-int.ic-ref-run.ok
deleted file mode 100644
index f6722e2f21c..00000000000
--- a/test/run-drun/ok/idl-nat-int.ic-ref-run.ok
+++ /dev/null
@@ -1,12 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> query absolute(42)
-<= replied: (42)
-=> query absolute(-42)
-<= replied: (42)
-=> query absolutes(vec {42; 25})
-<= replied: (vec {42; 25})
-=> query absolutes(vec {-42; +25})
-<= replied: (vec {42; 25})
diff --git a/test/run-drun/ok/idl-option.ic-ref-run.ok b/test/run-drun/ok/idl-option.ic-ref-run.ok
deleted file mode 100644
index 96f987ba537..00000000000
--- a/test/run-drun/ok/idl-option.ic-ref-run.ok
+++ /dev/null
@@ -1,13 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> query any(null)
-debug.print: ok: null
-<= replied: ()
-=> query any(null)
-debug.print: ok: null
-<= replied: ()
-=> query any(opt "Foo")
-debug.print: ok: Foo
-<= replied: ()
diff --git a/test/run-drun/ok/idl-pair.ic-ref-run.ok b/test/run-drun/ok/idl-pair.ic-ref-run.ok
deleted file mode 100644
index 05c2ae23995..00000000000
--- a/test/run-drun/ok/idl-pair.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> query len2("Hi", "World")
-<= replied: (record {+2; +5})
diff --git a/test/run-drun/ok/idl-principal.ic-ref-run.ok b/test/run-drun/ok/idl-principal.ic-ref-run.ok
deleted file mode 100644
index 1d0722e4e1f..00000000000
--- a/test/run-drun/ok/idl-principal.ic-ref-run.ok
+++ /dev/null
@@ -1,8 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> query fun(principal "w7x7r-cok77-xa")
-<= replied: (principal "w7x7r-cok77-xa")
-=> query fun2(opt principal "w7x7r-cok77-xa")
-<= replied: (opt principal "w7x7r-cok77-xa")
diff --git a/test/run-drun/ok/idl-record.ic-ref-run.ok b/test/run-drun/ok/idl-record.ic-ref-run.ok
deleted file mode 100644
index 1a768c425a8..00000000000
--- a/test/run-drun/ok/idl-record.ic-ref-run.ok
+++ /dev/null
@@ -1,18 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> query pair(record {"Hey!"; +42})
-debug.print: ok: +42
-<= replied: ()
-=> query record(record {content = "Hey!"; value = +42})
-debug.print: ok: Hey!
-<= replied: ()
-=> query record1(record {content = "Hey!"; value = +42; byte = (25 : int8)})
-debug.print: ok: +25
-<= replied: ()
-=> query record2(record {content = "Hey!"; value = +42; byte = (24 : int8)},...
-debug.print: ok:  Hey! +25
-<= replied: ((25 : int8))
-=> query record3(record {content = "Hey!"; value = +42})
-<= rejected (RC_CANISTER_ERROR): canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: IDL error: did not find field extra in record"
diff --git a/test/run-drun/ok/idl-shorthand.ic-ref-run.ok b/test/run-drun/ok/idl-shorthand.ic-ref-run.ok
deleted file mode 100644
index 92915cbde8e..00000000000
--- a/test/run-drun/ok/idl-shorthand.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> query foo(variant {nil})
-<= replied: (variant {nil})
diff --git a/test/run-drun/ok/idl-sub-ho-neg.ic-ref-run.ok b/test/run-drun/ok/idl-sub-ho-neg.ic-ref-run.ok
deleted file mode 100644
index 205fa3316eb..00000000000
--- a/test/run-drun/ok/idl-sub-ho-neg.ic-ref-run.ok
+++ /dev/null
@@ -1,25 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: ok_0_1_a
-debug.print: ok_0_1_b
-debug.print: ok_0_2_a
-debug.print: ok_0_2_a
-debug.print: ok_0_3_a
-debug.print: ok_0_3_b
-debug.print: ok 0_4
-debug.print: ok 2_0_a
-debug.print: ok 2_0_b
-debug.print: ok 2_1_a
-debug.print: ok 2_1_b
-debug.print: ok 3_0_a
-debug.print: ok 3_0_b
-debug.print: ok 5_0_a
-debug.print: ok 5_0_b
-debug.print: ok 5_1_a
-debug.print: ok 5_1_b
-debug.print: ok 6_0_a
-debug.print: ok 6_0_b
-<= replied: ()
diff --git a/test/run-drun/ok/idl-sub-ho-neg.tc.ok b/test/run-drun/ok/idl-sub-ho-neg.tc.ok
new file mode 100644
index 00000000000..8d0b32579e8
--- /dev/null
+++ b/test/run-drun/ok/idl-sub-ho-neg.tc.ok
@@ -0,0 +1,50 @@
+idl-sub-ho-neg.mo:7.6-7.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+idl-sub-ho-neg.mo:13.6-13.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+idl-sub-ho-neg.mo:20.6-20.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+idl-sub-ho-neg.mo:27.6-27.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+idl-sub-ho-neg.mo:34.6-34.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+idl-sub-ho-neg.mo:41.19-41.20: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+idl-sub-ho-neg.mo:43.23-43.24: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+idl-sub-ho-neg.mo:44.23-44.24: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+idl-sub-ho-neg.mo:47.23-47.24: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+idl-sub-ho-neg.mo:47.32-47.33: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+idl-sub-ho-neg.mo:49.23-49.25: warning [M0194], unused identifier on (delete or rename to wildcard `_` or `_on`)
+idl-sub-ho-neg.mo:49.34-49.35: warning [M0194], unused identifier i (delete or rename to wildcard `_` or `_i`)
+idl-sub-ho-neg.mo:50.23-50.24: warning [M0194], unused identifier i (delete or rename to wildcard `_` or `_i`)
+idl-sub-ho-neg.mo:50.32-50.34: warning [M0194], unused identifier on (delete or rename to wildcard `_` or `_on`)
+idl-sub-ho-neg.mo:52.21-52.23: warning [M0194], unused identifier ob (delete or rename to wildcard `_` or `_ob`)
+idl-sub-ho-neg.mo:52.33-52.34: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+idl-sub-ho-neg.mo:54.21-54.22: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+idl-sub-ho-neg.mo:56.23-56.24: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+idl-sub-ho-neg.mo:56.32-56.33: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+idl-sub-ho-neg.mo:56.43-56.44: warning [M0194], unused identifier r (delete or rename to wildcard `_` or `_r`)
+idl-sub-ho-neg.mo:56.67-56.68: warning [M0194], unused identifier v (delete or rename to wildcard `_` or `_v`)
+idl-sub-ho-neg.mo:61.23-61.24: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+idl-sub-ho-neg.mo:61.32-61.33: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+idl-sub-ho-neg.mo:61.43-61.44: warning [M0194], unused identifier r (delete or rename to wildcard `_` or `_r`)
+idl-sub-ho-neg.mo:61.67-61.68: warning [M0194], unused identifier v (delete or rename to wildcard `_` or `_v`)
+idl-sub-ho-neg.mo:67.23-67.24: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+idl-sub-ho-neg.mo:67.32-67.33: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+idl-sub-ho-neg.mo:67.43-67.44: warning [M0194], unused identifier r (delete or rename to wildcard `_` or `_r`)
+idl-sub-ho-neg.mo:67.58-67.59: warning [M0194], unused identifier v (delete or rename to wildcard `_` or `_v`)
+idl-sub-ho-neg.mo:72.23-72.24: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+idl-sub-ho-neg.mo:72.32-72.33: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+idl-sub-ho-neg.mo:72.43-72.44: warning [M0194], unused identifier r (delete or rename to wildcard `_` or `_r`)
+idl-sub-ho-neg.mo:72.58-72.59: warning [M0194], unused identifier v (delete or rename to wildcard `_` or `_v`)
+idl-sub-ho-neg.mo:78.23-78.24: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+idl-sub-ho-neg.mo:88.28-88.29: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+idl-sub-ho-neg.mo:88.41-88.42: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+idl-sub-ho-neg.mo:88.56-88.57: warning [M0194], unused identifier r (delete or rename to wildcard `_` or `_r`)
+idl-sub-ho-neg.mo:88.84-88.85: warning [M0194], unused identifier v (delete or rename to wildcard `_` or `_v`)
+idl-sub-ho-neg.mo:93.28-93.29: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+idl-sub-ho-neg.mo:93.41-93.42: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+idl-sub-ho-neg.mo:93.56-93.57: warning [M0194], unused identifier r (delete or rename to wildcard `_` or `_r`)
+idl-sub-ho-neg.mo:93.84-93.85: warning [M0194], unused identifier v (delete or rename to wildcard `_` or `_v`)
+idl-sub-ho-neg.mo:98.28-98.29: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+idl-sub-ho-neg.mo:98.41-98.42: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+idl-sub-ho-neg.mo:98.56-98.57: warning [M0194], unused identifier r (delete or rename to wildcard `_` or `_r`)
+idl-sub-ho-neg.mo:98.75-98.76: warning [M0194], unused identifier v (delete or rename to wildcard `_` or `_v`)
+idl-sub-ho-neg.mo:103.28-103.29: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+idl-sub-ho-neg.mo:103.41-103.42: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+idl-sub-ho-neg.mo:103.56-103.57: warning [M0194], unused identifier r (delete or rename to wildcard `_` or `_r`)
+idl-sub-ho-neg.mo:103.75-103.76: warning [M0194], unused identifier v (delete or rename to wildcard `_` or `_v`)
diff --git a/test/run-drun/ok/idl-sub-ho.ic-ref-run.ok b/test/run-drun/ok/idl-sub-ho.ic-ref-run.ok
deleted file mode 100644
index cdcccfa004f..00000000000
--- a/test/run-drun/ok/idl-sub-ho.ic-ref-run.ok
+++ /dev/null
@@ -1,17 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: ok
-debug.print: ok
-debug.print: ok
-debug.print: ok
-debug.print: ok
-debug.print: ok
-debug.print: ok
-debug.print: ok
-debug.print: ok
-debug.print: ok
-debug.print: ok
-<= replied: ()
diff --git a/test/run-drun/ok/idl-sub-ho.tc.ok b/test/run-drun/ok/idl-sub-ho.tc.ok
new file mode 100644
index 00000000000..c996dff24fa
--- /dev/null
+++ b/test/run-drun/ok/idl-sub-ho.tc.ok
@@ -0,0 +1,28 @@
+idl-sub-ho.mo:7.6-7.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+idl-sub-ho.mo:13.6-13.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+idl-sub-ho.mo:19.6-19.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+idl-sub-ho.mo:26.6-26.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+idl-sub-ho.mo:33.6-33.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+idl-sub-ho.mo:40.6-40.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+idl-sub-ho.mo:46.19-46.20: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+idl-sub-ho.mo:48.21-48.22: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+idl-sub-ho.mo:52.21-52.22: warning [M0194], unused identifier i (delete or rename to wildcard `_` or `_i`)
+idl-sub-ho.mo:52.30-52.32: warning [M0194], unused identifier on (delete or rename to wildcard `_` or `_on`)
+idl-sub-ho.mo:54.21-54.23: warning [M0194], unused identifier ob (delete or rename to wildcard `_` or `_ob`)
+idl-sub-ho.mo:56.21-56.22: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+idl-sub-ho.mo:58.21-58.22: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+idl-sub-ho.mo:58.30-58.31: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+idl-sub-ho.mo:58.41-58.42: warning [M0194], unused identifier r (delete or rename to wildcard `_` or `_r`)
+idl-sub-ho.mo:58.65-58.66: warning [M0194], unused identifier v (delete or rename to wildcard `_` or `_v`)
+idl-sub-ho.mo:63.21-63.22: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+idl-sub-ho.mo:63.30-63.31: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+idl-sub-ho.mo:63.41-63.42: warning [M0194], unused identifier r (delete or rename to wildcard `_` or `_r`)
+idl-sub-ho.mo:63.56-63.57: warning [M0194], unused identifier v (delete or rename to wildcard `_` or `_v`)
+idl-sub-ho.mo:73.26-73.27: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+idl-sub-ho.mo:73.39-73.40: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+idl-sub-ho.mo:73.54-73.55: warning [M0194], unused identifier r (delete or rename to wildcard `_` or `_r`)
+idl-sub-ho.mo:73.82-73.83: warning [M0194], unused identifier v (delete or rename to wildcard `_` or `_v`)
+idl-sub-ho.mo:78.26-78.27: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+idl-sub-ho.mo:78.39-78.40: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+idl-sub-ho.mo:78.54-78.55: warning [M0194], unused identifier r (delete or rename to wildcard `_` or `_r`)
+idl-sub-ho.mo:78.73-78.74: warning [M0194], unused identifier v (delete or rename to wildcard `_` or `_v`)
diff --git a/test/run-drun/ok/idl-sub-opt-any-record.ic-ref-run.ok b/test/run-drun/ok/idl-sub-opt-any-record.ic-ref-run.ok
deleted file mode 100644
index a346cb0884a..00000000000
--- a/test/run-drun/ok/idl-sub-opt-any-record.ic-ref-run.ok
+++ /dev/null
@@ -1,11 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: ok_0_1_a
-debug.print: ok_0
-debug.print: ok_0_1_b
-debug.print: ok_0
-debug.print: ok_0_1_c
-<= replied: ()
diff --git a/test/run-drun/ok/idl-sub-opt-any-record.tc.ok b/test/run-drun/ok/idl-sub-opt-any-record.tc.ok
new file mode 100644
index 00000000000..b093e3fbd96
--- /dev/null
+++ b/test/run-drun/ok/idl-sub-opt-any-record.tc.ok
@@ -0,0 +1,7 @@
+idl-sub-opt-any-record.mo:7.6-7.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+idl-sub-opt-any-record.mo:14.24-14.25: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+idl-sub-opt-any-record.mo:14.33-14.34: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+idl-sub-opt-any-record.mo:15.24-15.25: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+idl-sub-opt-any-record.mo:15.33-15.34: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+idl-sub-opt-any-record.mo:16.24-16.25: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+idl-sub-opt-any-record.mo:16.33-16.34: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
diff --git a/test/run-drun/ok/idl-sub-opt-any.ic-ref-run.ok b/test/run-drun/ok/idl-sub-opt-any.ic-ref-run.ok
deleted file mode 100644
index f1cf0722a2e..00000000000
--- a/test/run-drun/ok/idl-sub-opt-any.ic-ref-run.ok
+++ /dev/null
@@ -1,13 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: ok_0_1_a
-debug.print: ok_0
-debug.print: ok_0_1_b
-debug.print: ok_0
-debug.print: ok_0_1_c
-debug.print: ok_0_1_d
-debug.print: ok_0_1_e
-<= replied: ()
diff --git a/test/run-drun/ok/idl-sub-opt-any.tc.ok b/test/run-drun/ok/idl-sub-opt-any.tc.ok
new file mode 100644
index 00000000000..a070db4853e
--- /dev/null
+++ b/test/run-drun/ok/idl-sub-opt-any.tc.ok
@@ -0,0 +1,11 @@
+idl-sub-opt-any.mo:7.6-7.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+idl-sub-opt-any.mo:14.23-14.24: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+idl-sub-opt-any.mo:14.32-14.33: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+idl-sub-opt-any.mo:15.23-15.24: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+idl-sub-opt-any.mo:15.32-15.33: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+idl-sub-opt-any.mo:16.23-16.24: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+idl-sub-opt-any.mo:16.32-16.33: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+idl-sub-opt-any.mo:17.23-17.24: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+idl-sub-opt-any.mo:17.34-17.35: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+idl-sub-opt-any.mo:18.23-18.24: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+idl-sub-opt-any.mo:18.32-18.33: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
diff --git a/test/run-drun/ok/idl-sub-rec.ic-ref-run.ok b/test/run-drun/ok/idl-sub-rec.ic-ref-run.ok
deleted file mode 100644
index 22587ae07b0..00000000000
--- a/test/run-drun/ok/idl-sub-rec.ic-ref-run.ok
+++ /dev/null
@@ -1,25 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: ok f0
-debug.print: ok_0
-debug.print: ok f0
-debug.print: ok_1
-debug.print: ok f0
-debug.print: ok_2
-debug.print: ok f0
-debug.print: ok_3
-debug.print: ok f0
-debug.print: ok_4
-debug.print: ok 5:canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: IDL error: incompatible function type"
-debug.print: ok f1
-debug.print: ok_6
-debug.print: ok f1
-debug.print: ok f1
-debug.print: ok_8
-debug.print: ok_9canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: IDL error: incompatible function type"
-debug.print: ok f4
-debug.print: ok_10
-<= replied: ()
diff --git a/test/run-drun/ok/idl-sub-rec.tc.ok b/test/run-drun/ok/idl-sub-rec.tc.ok
new file mode 100644
index 00000000000..6876891bf8d
--- /dev/null
+++ b/test/run-drun/ok/idl-sub-rec.tc.ok
@@ -0,0 +1,9 @@
+idl-sub-rec.mo:41.8-41.12: warning [M0194], unused identifier sub1 (delete or rename to wildcard `_` or `_sub1`)
+idl-sub-rec.mo:42.8-42.12: warning [M0194], unused identifier sub2 (delete or rename to wildcard `_` or `_sub2`)
+idl-sub-rec.mo:43.8-43.12: warning [M0194], unused identifier sub3 (delete or rename to wildcard `_` or `_sub3`)
+idl-sub-rec.mo:45.18-45.19: warning [M0194], unused identifier l (delete or rename to wildcard `_` or `_l`)
+idl-sub-rec.mo:48.5-48.6: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+idl-sub-rec.mo:54.5-54.6: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+idl-sub-rec.mo:60.5-60.6: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+idl-sub-rec.mo:66.5-66.6: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+idl-sub-rec.mo:72.5-72.6: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
diff --git a/test/run-drun/ok/idl-sub-variant.ic-ref-run.ok b/test/run-drun/ok/idl-sub-variant.ic-ref-run.ok
deleted file mode 100644
index df33d468fd9..00000000000
--- a/test/run-drun/ok/idl-sub-variant.ic-ref-run.ok
+++ /dev/null
@@ -1,9 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: pass1
-debug.print: pass1
-debug.print: pass3: canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: IDL error: unexpected variant tag"
-<= replied: ()
diff --git a/test/run-drun/ok/idl-sub.ic-ref-run.ok b/test/run-drun/ok/idl-sub.ic-ref-run.ok
deleted file mode 100644
index 911fb90e67a..00000000000
--- a/test/run-drun/ok/idl-sub.ic-ref-run.ok
+++ /dev/null
@@ -1,22 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: ok 0
-debug.print: ok 1
-debug.print: ok 2
-debug.print: ok 3
-debug.print: ok 4
-debug.print: ok 5
-debug.print: ok 6
-debug.print: ok 7
-debug.print: ok 8
-debug.print: ok 9
-debug.print: ok 10
-debug.print: ok 11
-debug.print: ok 12
-debug.print: ok 13
-debug.print: ok 14
-debug.print: ok 15
-<= replied: ()
diff --git a/test/run-drun/ok/idl-sub.tc.ok b/test/run-drun/ok/idl-sub.tc.ok
new file mode 100644
index 00000000000..dbba7caec24
--- /dev/null
+++ b/test/run-drun/ok/idl-sub.tc.ok
@@ -0,0 +1,21 @@
+idl-sub.mo:8.6-8.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+idl-sub.mo:13.19-13.20: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+idl-sub.mo:16.6-16.8: warning [M0194], unused identifier f1 (delete or rename to wildcard `_` or `_f1`)
+idl-sub.mo:21.19-21.20: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+idl-sub.mo:24.6-24.8: warning [M0194], unused identifier f2 (delete or rename to wildcard `_` or `_f2`)
+idl-sub.mo:31.19-31.20: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+idl-sub.mo:34.6-34.8: warning [M0194], unused identifier f3 (delete or rename to wildcard `_` or `_f3`)
+idl-sub.mo:41.19-41.20: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+idl-sub.mo:44.6-44.8: warning [M0194], unused identifier f4 (delete or rename to wildcard `_` or `_f4`)
+idl-sub.mo:51.19-51.20: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+idl-sub.mo:54.6-54.8: warning [M0194], unused identifier f5 (delete or rename to wildcard `_` or `_f5`)
+idl-sub.mo:63.6-63.8: warning [M0194], unused identifier f6 (delete or rename to wildcard `_` or `_f6`)
+idl-sub.mo:71.6-71.8: warning [M0194], unused identifier f7 (delete or rename to wildcard `_` or `_f7`)
+idl-sub.mo:81.6-81.8: warning [M0194], unused identifier f8 (delete or rename to wildcard `_` or `_f8`)
+idl-sub.mo:90.6-90.8: warning [M0194], unused identifier f9 (delete or rename to wildcard `_` or `_f9`)
+idl-sub.mo:99.6-99.9: warning [M0194], unused identifier f10 (delete or rename to wildcard `_` or `_f10`)
+idl-sub.mo:109.6-109.9: warning [M0194], unused identifier f11 (delete or rename to wildcard `_` or `_f11`)
+idl-sub.mo:118.6-118.9: warning [M0194], unused identifier f12 (delete or rename to wildcard `_` or `_f12`)
+idl-sub.mo:127.6-127.9: warning [M0194], unused identifier f13 (delete or rename to wildcard `_` or `_f13`)
+idl-sub.mo:143.6-143.9: warning [M0194], unused identifier f14 (delete or rename to wildcard `_` or `_f14`)
+idl-sub.mo:152.6-152.9: warning [M0194], unused identifier f15 (delete or rename to wildcard `_` or `_f15`)
diff --git a/test/run-drun/ok/idl-tuple.ic-ref-run.ok b/test/run-drun/ok/idl-tuple.ic-ref-run.ok
deleted file mode 100644
index ed38c4e03c5..00000000000
--- a/test/run-drun/ok/idl-tuple.ic-ref-run.ok
+++ /dev/null
@@ -1,18 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> query len2("Hi", "World")
-<= replied: (+2, +5)
-=> query len3(record {"Hello"; (67305985 : int32)}, "World")
-<= replied: (+5, +5, +67305985)
-=> query len3a(record {"Hello"; (67305985 : int32); null}, "World")
-<= replied: (+5, +5, +67305985)
-=> query len3(record {"Hello"; (67305985 : int32); (-21026 : int16)}, "Wo...
-<= replied: (+5, +5, +67305985)
-=> query len3a(record {"Hello"; (67305985 : int32); null}, "World")
-<= replied: (+5, +5, +67305985)
-=> query len3a(record {0 = "Hello"; 2 = null}, "World")
-<= rejected (RC_CANISTER_ERROR): canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: IDL error: did not find tuple field in record"
-=> query len3a(record {"Hello"; (67305985 : int32)}, "World")
-<= replied: (+5, +5, +67305985)
diff --git a/test/run-drun/ok/idl-tuple.tc.ok b/test/run-drun/ok/idl-tuple.tc.ok
new file mode 100644
index 00000000000..ac3cbdfb107
--- /dev/null
+++ b/test/run-drun/ok/idl-tuple.tc.ok
@@ -0,0 +1 @@
+idl-tuple.mo:12.45-12.46: warning [M0194], unused identifier z (delete or rename to wildcard `_` or `_z`)
diff --git a/test/run-drun/ok/idl-unit.ic-ref-run.ok b/test/run-drun/ok/idl-unit.ic-ref-run.ok
deleted file mode 100644
index c489c9abf0a..00000000000
--- a/test/run-drun/ok/idl-unit.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> query unit_id()
-<= replied: ()
diff --git a/test/run-drun/ok/idl-variant.ic-ref-run.ok b/test/run-drun/ok/idl-variant.ic-ref-run.ok
deleted file mode 100644
index e88d636a7de..00000000000
--- a/test/run-drun/ok/idl-variant.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> query numify(variant {fix = variant {right = (32 : nat32)}})
-<= replied: (variant {fix = variant {left = (32 : nat32)}})
diff --git a/test/run-drun/ok/idl-vector.ic-ref-run.ok b/test/run-drun/ok/idl-vector.ic-ref-run.ok
deleted file mode 100644
index c75d9777345..00000000000
--- a/test/run-drun/ok/idl-vector.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> query rose(vec {vec {}; vec {vec {}; vec {vec {}; vec {}}; vec {}; vec...
-<= replied: (opt vec {opt vec {}; opt vec {opt vec {}; opt vec {opt vec {}; opt vec {}}; opt vec {}; opt vec {}}...
diff --git a/test/run-drun/ok/import-pat.ic-ref-run.ok b/test/run-drun/ok/import-pat.ic-ref-run.ok
deleted file mode 100644
index bde1ab58378..00000000000
--- a/test/run-drun/ok/import-pat.ic-ref-run.ok
+++ /dev/null
@@ -1,7 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-debug.print: 1
-debug.print: 1
-debug.print: 1
-<= replied: ()
diff --git a/test/run-drun/ok/inline.ic-ref-run.ok b/test/run-drun/ok/inline.ic-ref-run.ok
deleted file mode 100644
index 7e967e1a062..00000000000
--- a/test/run-drun/ok/inline.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
diff --git a/test/run-drun/ok/inline.tc.ok b/test/run-drun/ok/inline.tc.ok
new file mode 100644
index 00000000000..c63f0b06ad9
--- /dev/null
+++ b/test/run-drun/ok/inline.tc.ok
@@ -0,0 +1,2 @@
+inline.mo:4.9-4.11: warning [M0194], unused identifier t1 (delete or rename to wildcard `_` or `_t1`)
+inline.mo:6.9-6.11: warning [M0194], unused identifier t2 (delete or rename to wildcard `_` or `_t2`)
diff --git a/test/run-drun/ok/inspect_message.ic-ref-run.ok b/test/run-drun/ok/inspect_message.ic-ref-run.ok
deleted file mode 100644
index 7e967e1a062..00000000000
--- a/test/run-drun/ok/inspect_message.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
diff --git a/test/run-drun/ok/inspect_message.tc.ok b/test/run-drun/ok/inspect_message.tc.ok
new file mode 100644
index 00000000000..4346feb3e7e
--- /dev/null
+++ b/test/run-drun/ok/inspect_message.tc.ok
@@ -0,0 +1 @@
+inspect_message.mo:14.8-14.14: warning [M0194], unused identifier caller (delete or rename to wildcard `_` or `_caller`)
diff --git a/test/run-drun/ok/inspect_message_blob.ic-ref-run.ok b/test/run-drun/ok/inspect_message_blob.ic-ref-run.ok
deleted file mode 100644
index 7e967e1a062..00000000000
--- a/test/run-drun/ok/inspect_message_blob.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
diff --git a/test/run-drun/ok/install-empty-actor.ic-ref-run.ok b/test/run-drun/ok/install-empty-actor.ic-ref-run.ok
deleted file mode 100644
index 8d41850d4e7..00000000000
--- a/test/run-drun/ok/install-empty-actor.ic-ref-run.ok
+++ /dev/null
@@ -1,8 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: Installing actor:
-debug.print: rrkah-fqaaa-aaaaa-aaaaq-cai
-<= replied: ()
diff --git a/test/run-drun/ok/interleave.ic-ref-run.ok b/test/run-drun/ok/interleave.ic-ref-run.ok
deleted file mode 100644
index 5d4cc054367..00000000000
--- a/test/run-drun/ok/interleave.ic-ref-run.ok
+++ /dev/null
@@ -1,25 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: g
-debug.print:   e-while
-
-debug.print: g-label
-
-debug.print:   e cnt: 0 i: 5
-debug.print: g cnt: 1 i: 10
-debug.print:   e cnt: 2 i: 6
-debug.print: g cnt: 3 i: 11
-debug.print:   e cnt: 4 i: 7
-debug.print: g cnt: 5 i: 12
-debug.print:   e cnt: 6 i: 8
-debug.print: g cnt: 7 i: 13
-debug.print:   e cnt: 8 i: 9
-debug.print: g cnt: 9 i: 14
-debug.print:   e-exit
-
-debug.print: g-exit
-
-<= replied: ()
diff --git a/test/run-drun/ok/interleave.tc.ok b/test/run-drun/ok/interleave.tc.ok
new file mode 100644
index 00000000000..b1f78598292
--- /dev/null
+++ b/test/run-drun/ok/interleave.tc.ok
@@ -0,0 +1 @@
+interleave.mo:14.9-14.10: warning [M0194], unused identifier e (delete or rename to wildcard `_` or `_e`)
diff --git a/test/run-drun/ok/issue-1174.ic-ref-run.ok b/test/run-drun/ok/issue-1174.ic-ref-run.ok
deleted file mode 100644
index 7e967e1a062..00000000000
--- a/test/run-drun/ok/issue-1174.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
diff --git a/test/run-drun/ok/issue-1174.tc.ok b/test/run-drun/ok/issue-1174.tc.ok
new file mode 100644
index 00000000000..2f37fc05ec4
--- /dev/null
+++ b/test/run-drun/ok/issue-1174.tc.ok
@@ -0,0 +1 @@
+issue-1174.mo:2.7-2.14: warning [M0194], unused identifier Example (delete or rename to wildcard `_` or `_Example`)
diff --git a/test/run-drun/ok/issue-1847.ic-ref-run.ok b/test/run-drun/ok/issue-1847.ic-ref-run.ok
deleted file mode 100644
index 4fed97c5a2a..00000000000
--- a/test/run-drun/ok/issue-1847.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= rejected (RC_CANISTER_ERROR): Initialization trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: IDL error: empty input. Expected Candid-encoded argument, but received a zero-length argument"
diff --git a/test/run-drun/ok/issue-1938-c.tc.ok b/test/run-drun/ok/issue-1938-c.tc.ok
new file mode 100644
index 00000000000..a4363e6deef
--- /dev/null
+++ b/test/run-drun/ok/issue-1938-c.tc.ok
@@ -0,0 +1 @@
+issue-1938-c.mo:2.7-2.8: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
diff --git a/test/run-drun/ok/issue-1938-d.tc.ok b/test/run-drun/ok/issue-1938-d.tc.ok
new file mode 100644
index 00000000000..b7a0882924d
--- /dev/null
+++ b/test/run-drun/ok/issue-1938-d.tc.ok
@@ -0,0 +1 @@
+issue-1938-d.mo:2.13-2.14: warning [M0194], unused identifier C (delete or rename to wildcard `_` or `_C`)
diff --git a/test/run-drun/ok/issue-1938.tc.ok b/test/run-drun/ok/issue-1938.tc.ok
new file mode 100644
index 00000000000..aa8ecdf79c1
--- /dev/null
+++ b/test/run-drun/ok/issue-1938.tc.ok
@@ -0,0 +1,2 @@
+issue-1938.mo:1.7-1.8: warning [M0194], unused identifier A (delete or rename to wildcard `_` or `_A`)
+issue-1938.mo:2.7-2.8: warning [M0194], unused identifier B (delete or rename to wildcard `_` or `_B`)
diff --git a/test/run-drun/ok/issue-2047.ic-ref-run.ok b/test/run-drun/ok/issue-2047.ic-ref-run.ok
deleted file mode 100644
index 7e967e1a062..00000000000
--- a/test/run-drun/ok/issue-2047.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
diff --git a/test/run-drun/ok/issue-2047.tc.ok b/test/run-drun/ok/issue-2047.tc.ok
new file mode 100644
index 00000000000..6af7bccfebe
--- /dev/null
+++ b/test/run-drun/ok/issue-2047.tc.ok
@@ -0,0 +1 @@
+issue-2047.mo:1.7-1.8: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
diff --git a/test/run-drun/ok/issue-2158.tc.ok b/test/run-drun/ok/issue-2158.tc.ok
new file mode 100644
index 00000000000..2e638e5c347
--- /dev/null
+++ b/test/run-drun/ok/issue-2158.tc.ok
@@ -0,0 +1,3 @@
+issue-2158/C.mo:4.23-4.24: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+issue-2158.mo:4.8-4.9: warning [M0194], unused identifier T (delete or rename to wildcard `_` or `_T`)
+issue-2158.mo:7.7-7.8: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
diff --git a/test/run-drun/ok/issue-2464.ic-ref-run.ok b/test/run-drun/ok/issue-2464.ic-ref-run.ok
deleted file mode 100644
index 7e967e1a062..00000000000
--- a/test/run-drun/ok/issue-2464.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
diff --git a/test/run-drun/ok/issue-2464.tc.ok b/test/run-drun/ok/issue-2464.tc.ok
new file mode 100644
index 00000000000..258900539d2
--- /dev/null
+++ b/test/run-drun/ok/issue-2464.tc.ok
@@ -0,0 +1 @@
+issue-2464.mo:4.13-4.18: warning [M0194], unused identifier Maker (delete or rename to wildcard `_` or `_Maker`)
diff --git a/test/run-drun/ok/issue-3103.tc.ok b/test/run-drun/ok/issue-3103.tc.ok
new file mode 100644
index 00000000000..e1cf6a7fa74
--- /dev/null
+++ b/test/run-drun/ok/issue-3103.tc.ok
@@ -0,0 +1 @@
+issue-3103.mo:7.7-7.8: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
diff --git a/test/run-drun/ok/issue-3128-b.ic-ref-run.ok b/test/run-drun/ok/issue-3128-b.ic-ref-run.ok
deleted file mode 100644
index 7e967e1a062..00000000000
--- a/test/run-drun/ok/issue-3128-b.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
diff --git a/test/run-drun/ok/issue-3128-b.tc.ok b/test/run-drun/ok/issue-3128-b.tc.ok
new file mode 100644
index 00000000000..d452f73ab1d
--- /dev/null
+++ b/test/run-drun/ok/issue-3128-b.tc.ok
@@ -0,0 +1 @@
+issue-3128-b.mo:8.14-8.15: warning [M0194], unused identifier p (delete or rename to wildcard `_` or `_p`)
diff --git a/test/run-drun/ok/issue-3128.ic-ref-run.ok b/test/run-drun/ok/issue-3128.ic-ref-run.ok
deleted file mode 100644
index 7e967e1a062..00000000000
--- a/test/run-drun/ok/issue-3128.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
diff --git a/test/run-drun/ok/issue-3128.tc.ok b/test/run-drun/ok/issue-3128.tc.ok
new file mode 100644
index 00000000000..a2f1a2c40cd
--- /dev/null
+++ b/test/run-drun/ok/issue-3128.tc.ok
@@ -0,0 +1 @@
+issue-3128.mo:8.14-8.15: warning [M0194], unused identifier p (delete or rename to wildcard `_` or `_p`)
diff --git a/test/run-drun/ok/issue-3140-b.ic-ref-run.ok b/test/run-drun/ok/issue-3140-b.ic-ref-run.ok
deleted file mode 100644
index 7e967e1a062..00000000000
--- a/test/run-drun/ok/issue-3140-b.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
diff --git a/test/run-drun/ok/issue-3140-b.tc.ok b/test/run-drun/ok/issue-3140-b.tc.ok
new file mode 100644
index 00000000000..5ef3441cb06
--- /dev/null
+++ b/test/run-drun/ok/issue-3140-b.tc.ok
@@ -0,0 +1 @@
+issue-3140-b.mo:8.14-8.15: warning [M0194], unused identifier t (delete or rename to wildcard `_` or `_t`)
diff --git a/test/run-drun/ok/issue-3140-c.ic-ref-run.ok b/test/run-drun/ok/issue-3140-c.ic-ref-run.ok
deleted file mode 100644
index 7e967e1a062..00000000000
--- a/test/run-drun/ok/issue-3140-c.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
diff --git a/test/run-drun/ok/issue-3140-c.tc.ok b/test/run-drun/ok/issue-3140-c.tc.ok
new file mode 100644
index 00000000000..d59c484cd6b
--- /dev/null
+++ b/test/run-drun/ok/issue-3140-c.tc.ok
@@ -0,0 +1 @@
+issue-3140-c.mo:49.14-49.15: warning [M0194], unused identifier t (delete or rename to wildcard `_` or `_t`)
diff --git a/test/run-drun/ok/issue-3140-d.ic-ref-run.ok b/test/run-drun/ok/issue-3140-d.ic-ref-run.ok
deleted file mode 100644
index 7e967e1a062..00000000000
--- a/test/run-drun/ok/issue-3140-d.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
diff --git a/test/run-drun/ok/issue-3140-d.tc.ok b/test/run-drun/ok/issue-3140-d.tc.ok
new file mode 100644
index 00000000000..f413eaaf027
--- /dev/null
+++ b/test/run-drun/ok/issue-3140-d.tc.ok
@@ -0,0 +1 @@
+issue-3140-d.mo:27.14-27.15: warning [M0194], unused identifier t (delete or rename to wildcard `_` or `_t`)
diff --git a/test/run-drun/ok/issue-3140.ic-ref-run.ok b/test/run-drun/ok/issue-3140.ic-ref-run.ok
deleted file mode 100644
index 7e967e1a062..00000000000
--- a/test/run-drun/ok/issue-3140.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
diff --git a/test/run-drun/ok/issue-3140.tc.ok b/test/run-drun/ok/issue-3140.tc.ok
new file mode 100644
index 00000000000..a7341754c1a
--- /dev/null
+++ b/test/run-drun/ok/issue-3140.tc.ok
@@ -0,0 +1 @@
+issue-3140.mo:8.14-8.15: warning [M0194], unused identifier t (delete or rename to wildcard `_` or `_t`)
diff --git a/test/run-drun/ok/issue-3449.ic-ref-run.ok b/test/run-drun/ok/issue-3449.ic-ref-run.ok
deleted file mode 100644
index 7e967e1a062..00000000000
--- a/test/run-drun/ok/issue-3449.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
diff --git a/test/run-drun/ok/issue-3449.tc.ok b/test/run-drun/ok/issue-3449.tc.ok
new file mode 100644
index 00000000000..085d728662b
--- /dev/null
+++ b/test/run-drun/ok/issue-3449.tc.ok
@@ -0,0 +1 @@
+issue-3449.mo:10.14-10.15: warning [M0194], unused identifier v (delete or rename to wildcard `_` or `_v`)
diff --git a/test/run-drun/ok/issue-3732.ic-ref-run.ok b/test/run-drun/ok/issue-3732.ic-ref-run.ok
deleted file mode 100644
index 7e967e1a062..00000000000
--- a/test/run-drun/ok/issue-3732.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
diff --git a/test/run-drun/ok/issue-3732.tc.ok b/test/run-drun/ok/issue-3732.tc.ok
new file mode 100644
index 00000000000..6f7e04c2154
--- /dev/null
+++ b/test/run-drun/ok/issue-3732.tc.ok
@@ -0,0 +1,6 @@
+issue-3732.mo:2.13-2.20: warning [M0194], unused identifier TestAPI (delete or rename to wildcard `_` or `_TestAPI`)
+issue-3732.mo:3.25-3.26: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+issue-3732.mo:4.25-4.26: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+issue-3732.mo:4.32-4.33: warning [M0194], unused identifier y (delete or rename to wildcard `_` or `_y`)
+issue-3732.mo:8.8-8.14: warning [M0194], unused identifier caller (delete or rename to wildcard `_` or `_caller`)
+issue-3732.mo:9.8-9.11: warning [M0194], unused identifier arg (delete or rename to wildcard `_` or `_arg`)
diff --git a/test/run-drun/ok/issue-3740.ic-ref-run.ok b/test/run-drun/ok/issue-3740.ic-ref-run.ok
deleted file mode 100644
index 7e967e1a062..00000000000
--- a/test/run-drun/ok/issue-3740.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
diff --git a/test/run-drun/ok/issue-3740b.ic-ref-run.ok b/test/run-drun/ok/issue-3740b.ic-ref-run.ok
deleted file mode 100644
index 7e967e1a062..00000000000
--- a/test/run-drun/ok/issue-3740b.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
diff --git a/test/run-drun/ok/issue-3910.ic-ref-run.ok b/test/run-drun/ok/issue-3910.ic-ref-run.ok
deleted file mode 100644
index 7ee3b2a8a7d..00000000000
--- a/test/run-drun/ok/issue-3910.ic-ref-run.ok
+++ /dev/null
@@ -1,14 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: f0
-debug.print: f1
-debug.print: f2
-debug.print: f2() trapped successfully
-debug.print: g0
-debug.print: g1
-debug.print: g2
-debug.print: g2() trapped successfully
-<= replied: ()
diff --git a/test/run-drun/ok/issue-3910.tc.ok b/test/run-drun/ok/issue-3910.tc.ok
index 61f82d94c0b..e0d3757ed0b 100644
--- a/test/run-drun/ok/issue-3910.tc.ok
+++ b/test/run-drun/ok/issue-3910.tc.ok
@@ -6,3 +6,7 @@ issue-3910.mo:34.10-34.35: warning [M0145], this pattern of type
   {trap : Bool}
 does not cover value
   {trap = true}
+issue-3910.mo:7.11-7.12: warning [M0194], unused identifier r (delete or rename to wildcard `_` or `_r`)
+issue-3910.mo:12.13-12.17: warning [M0194], unused identifier trap (delete or rename to wildcard `_` or `_trap`)
+issue-3910.mo:24.11-24.12: warning [M0194], unused identifier r (delete or rename to wildcard `_` or `_r`)
+issue-3910.mo:29.13-29.17: warning [M0194], unused identifier trap (delete or rename to wildcard `_` or `_trap`)
diff --git a/test/run-drun/ok/issue-4236.tc.ok b/test/run-drun/ok/issue-4236.tc.ok
new file mode 100644
index 00000000000..e0b8c8bcde2
--- /dev/null
+++ b/test/run-drun/ok/issue-4236.tc.ok
@@ -0,0 +1 @@
+issue-4236.mo:16.8-16.18: warning [M0194], unused identifier getAccount (delete or rename to wildcard `_` or `_getAccount`)
diff --git a/test/run-drun/ok/issue-894.ic-ref-run.ok b/test/run-drun/ok/issue-894.ic-ref-run.ok
deleted file mode 100644
index ba3fb44040e..00000000000
--- a/test/run-drun/ok/issue-894.ic-ref-run.ok
+++ /dev/null
@@ -1,15 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: 1
-debug.print: 1
-debug.print: 1
-debug.print: 1
-debug.print: 0
-debug.print: 1
-debug.print: 2
-debug.print: 3
-debug.print: 4
-<= replied: ()
diff --git a/test/run-drun/ok/issue2317.ic-ref-run.ok b/test/run-drun/ok/issue2317.ic-ref-run.ok
deleted file mode 100644
index 7e967e1a062..00000000000
--- a/test/run-drun/ok/issue2317.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
diff --git a/test/run-drun/ok/let-else-actor.ic-ref-run.ok b/test/run-drun/ok/let-else-actor.ic-ref-run.ok
deleted file mode 100644
index a85f4545927..00000000000
--- a/test/run-drun/ok/let-else-actor.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= rejected (RC_CANISTER_ERROR): Initialization trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: x was null"
diff --git a/test/run-drun/ok/let-else-actor.tc.ok b/test/run-drun/ok/let-else-actor.tc.ok
new file mode 100644
index 00000000000..39cc280a607
--- /dev/null
+++ b/test/run-drun/ok/let-else-actor.tc.ok
@@ -0,0 +1 @@
+let-else-actor.mo:4.10-4.11: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
diff --git a/test/run-drun/ok/let-else-await.ic-ref-run.ok b/test/run-drun/ok/let-else-await.ic-ref-run.ok
deleted file mode 100644
index b4a8ea09ece..00000000000
--- a/test/run-drun/ok/let-else-await.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-<= replied: (4)
diff --git a/test/run-drun/ok/let-else-return-async.ic-ref-run.ok b/test/run-drun/ok/let-else-return-async.ic-ref-run.ok
deleted file mode 100644
index b4a8ea09ece..00000000000
--- a/test/run-drun/ok/let-else-return-async.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-<= replied: (4)
diff --git a/test/run-drun/ok/let-else-throw.ic-ref-run.ok b/test/run-drun/ok/let-else-throw.ic-ref-run.ok
deleted file mode 100644
index 6de8df3dc0b..00000000000
--- a/test/run-drun/ok/let-else-throw.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-<= replied: (1)
diff --git a/test/run-drun/ok/live-upgrade.ic-ref-run.ok b/test/run-drun/ok/live-upgrade.ic-ref-run.ok
deleted file mode 100644
index dd048afa887..00000000000
--- a/test/run-drun/ok/live-upgrade.ic-ref-run.ok
+++ /dev/null
@@ -1,30 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-debug.print: {version = 0}
-<= replied: ()
-=> query check(0)
-<= replied: ()
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-debug.print: {version = 0}
-<= replied: ()
-=> query check(1)
-<= replied: ()
-=> update repeat()
-<= replied: ()
-=> update wait()
-<= replied: ()
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-debug.print: {version = 1}
-<= replied: ()
-=> query check(2)
-<= replied: ()
-=> update repeat()
-<= replied: ()
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-debug.print: {version = 2}
-<= replied: ()
-=> update wait()
-<= replied: ()
-=> query check(2)
-<= rejected (RC_CANISTER_ERROR): canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: assertion failed at live-upgrade.mo:11.49-13.4"
diff --git a/test/run-drun/ok/local-throw.ic-ref-run.ok b/test/run-drun/ok/local-throw.ic-ref-run.ok
deleted file mode 100644
index 005291cbf38..00000000000
--- a/test/run-drun/ok/local-throw.ic-ref-run.ok
+++ /dev/null
@@ -1,8 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: t2 ok
-debug.print: t3 ok
-<= replied: ()
diff --git a/test/run-drun/ok/map-upgrades.ic-ref-run.ok b/test/run-drun/ok/map-upgrades.ic-ref-run.ok
deleted file mode 100644
index 88d7620e6e8..00000000000
--- a/test/run-drun/ok/map-upgrades.ic-ref-run.ok
+++ /dev/null
@@ -1,116 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: {node = 1; state = null; upgrades = 0}
-debug.print: 1: insert (1, "1")
-debug.print: 1: lookup 1
-debug.print: {node = 2; state = null; upgrades = 0}
-debug.print: 2: insert (2, "2")
-debug.print: 2: lookup 2
-<= replied: ()
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update upgradeNodes()
-debug.print: {node = 1; state = ?(1, "1", null); upgrades = 1}
-debug.print: {node = 2; state = ?(2, "2", null); upgrades = 1}
-<= replied: ()
-=> update go()
-debug.print: {node = 3; state = null; upgrades = 0}
-debug.print: 3: insert (3, "3")
-debug.print: 3: lookup 3
-debug.print: {node = 4; state = null; upgrades = 0}
-debug.print: 4: insert (4, "4")
-debug.print: 4: lookup 4
-<= replied: ()
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update upgradeNodes()
-debug.print: {node = 1; state = ?(1, "1", null); upgrades = 2}
-debug.print: {node = 2; state = ?(2, "2", null); upgrades = 2}
-debug.print: {node = 3; state = ?(3, "3", null); upgrades = 1}
-debug.print: {node = 4; state = ?(4, "4", null); upgrades = 1}
-<= replied: ()
-=> update go()
-debug.print: {node = 5; state = null; upgrades = 0}
-debug.print: 5: insert (5, "5")
-debug.print: 5: lookup 5
-debug.print: {node = 6; state = null; upgrades = 0}
-debug.print: 6: insert (6, "6")
-debug.print: 6: lookup 6
-<= replied: ()
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update upgradeNodes()
-debug.print: {node = 1; state = ?(1, "1", null); upgrades = 3}
-debug.print: {node = 2; state = ?(2, "2", null); upgrades = 3}
-debug.print: {node = 3; state = ?(3, "3", null); upgrades = 2}
-debug.print: {node = 4; state = ?(4, "4", null); upgrades = 2}
-debug.print: {node = 5; state = ?(5, "5", null); upgrades = 1}
-debug.print: {node = 6; state = ?(6, "6", null); upgrades = 1}
-<= replied: ()
-=> update go()
-debug.print: {node = 7; state = null; upgrades = 0}
-debug.print: 7: insert (7, "7")
-debug.print: 7: lookup 7
-debug.print: {node = 0; state = null; upgrades = 0}
-debug.print: 0: insert (8, "8")
-debug.print: 0: lookup 8
-<= replied: ()
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update upgradeNodes()
-debug.print: {node = 0; state = ?(8, "8", null); upgrades = 1}
-debug.print: {node = 1; state = ?(1, "1", null); upgrades = 4}
-debug.print: {node = 2; state = ?(2, "2", null); upgrades = 4}
-debug.print: {node = 3; state = ?(3, "3", null); upgrades = 3}
-debug.print: {node = 4; state = ?(4, "4", null); upgrades = 3}
-debug.print: {node = 5; state = ?(5, "5", null); upgrades = 2}
-debug.print: {node = 6; state = ?(6, "6", null); upgrades = 2}
-debug.print: {node = 7; state = ?(7, "7", null); upgrades = 1}
-<= replied: ()
-=> update go()
-debug.print: 1: lookup 9
-debug.print: 1: insert (9, "9")
-debug.print: 1: lookup 9
-debug.print: 1: remove 9
-debug.print: 1: lookup 9
-debug.print: 1: insert (9, "9")
-debug.print: 1: lookup 9
-debug.print: 2: lookup 10
-debug.print: 2: insert (10, "10")
-debug.print: 2: lookup 10
-debug.print: 2: remove 10
-debug.print: 2: lookup 10
-debug.print: 2: insert (10, "10")
-debug.print: 2: lookup 10
-<= replied: ()
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update upgradeNodes()
-debug.print: {node = 0; state = ?(8, "8", null); upgrades = 2}
-debug.print: {node = 1; state = ?(9, "9", ?(1, "1", null)); upgrades = 5}
-debug.print: {node = 2; state = ?(10, "10", ?(2, "2", null)); upgrades = 5}
-debug.print: {node = 3; state = ?(3, "3", null); upgrades = 4}
-debug.print: {node = 4; state = ?(4, "4", null); upgrades = 4}
-debug.print: {node = 5; state = ?(5, "5", null); upgrades = 3}
-debug.print: {node = 6; state = ?(6, "6", null); upgrades = 3}
-debug.print: {node = 7; state = ?(7, "7", null); upgrades = 2}
-<= replied: ()
-=> update go()
-debug.print: 3: lookup 11
-debug.print: 3: insert (11, "11")
-debug.print: 3: lookup 11
-debug.print: 3: remove 11
-debug.print: 3: lookup 11
-debug.print: 3: insert (11, "11")
-debug.print: 3: lookup 11
-debug.print: 4: lookup 12
-debug.print: 4: insert (12, "12")
-debug.print: 4: lookup 12
-debug.print: 4: remove 12
-debug.print: 4: lookup 12
-debug.print: 4: insert (12, "12")
-debug.print: 4: lookup 12
-<= replied: ()
diff --git a/test/run-drun/ok/mod-rebind.ic-ref-run.ok b/test/run-drun/ok/mod-rebind.ic-ref-run.ok
deleted file mode 100644
index ec514e61a14..00000000000
--- a/test/run-drun/ok/mod-rebind.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-→ update create_canister()
-← replied: (record {1313628723 = service "cvccv-qqaaq-aaaaa-aaaaa-c"})
-→ update install_code(record {4849238 = blob ""; 265441191 = blob "\00asm\01\00\0…
-← replied: ()
diff --git a/test/run-drun/ok/multi-value.ic-ref-run.ok b/test/run-drun/ok/multi-value.ic-ref-run.ok
deleted file mode 100644
index 7e967e1a062..00000000000
--- a/test/run-drun/ok/multi-value.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
diff --git a/test/run-drun/ok/nary-async.ic-ref-run.ok b/test/run-drun/ok/nary-async.ic-ref-run.ok
deleted file mode 100644
index 8120a794e8a..00000000000
--- a/test/run-drun/ok/nary-async.ic-ref-run.ok
+++ /dev/null
@@ -1,16 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go1()
-debug.print: 0_0
-debug.print: 1_0
-debug.print: 2_0
-debug.print: 3_0
-<= replied: ()
-=> update go2()
-debug.print: 0_0
-debug.print: 0_1
-debug.print: 0_2
-debug.print: 0_3
-<= replied: ()
diff --git a/test/run-drun/ok/neg-powers.ic-ref-run.ok b/test/run-drun/ok/neg-powers.ic-ref-run.ok
deleted file mode 100644
index b4ecc66a23e..00000000000
--- a/test/run-drun/ok/neg-powers.ic-ref-run.ok
+++ /dev/null
@@ -1,42 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: ok 1
-debug.print: ok 2
-debug.print: ok 3
-debug.print: ok 4
-debug.print: ok 1
-debug.print: ok 2
-debug.print: ok 3
-debug.print: ok 4
-debug.print: ok 1
-debug.print: ok 2
-debug.print: ok 3
-debug.print: ok 4
-debug.print: ok 1
-debug.print: ok 2
-debug.print: ok 3
-debug.print: ok 4
-debug.print: ok 1
-debug.print: ok 2
-debug.print: ok 3
-debug.print: ok 4
-debug.print: ok 1
-debug.print: ok 2
-debug.print: ok 3
-debug.print: ok 4
-debug.print: ok 1
-debug.print: ok 2
-debug.print: ok 3
-debug.print: ok 4
-debug.print: ok 1
-debug.print: ok 2
-debug.print: ok 3
-debug.print: ok 4
-debug.print: ok 1
-debug.print: ok 2
-debug.print: ok 3
-debug.print: ok 4
-<= replied: ()
diff --git a/test/run-drun/ok/obj-ext-await.ic-ref-run.ok b/test/run-drun/ok/obj-ext-await.ic-ref-run.ok
deleted file mode 100644
index 9cb02531277..00000000000
--- a/test/run-drun/ok/obj-ext-await.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-<= replied: ()
diff --git a/test/run-drun/ok/obj-ext-await.tc.ok b/test/run-drun/ok/obj-ext-await.tc.ok
new file mode 100644
index 00000000000..2416448301b
--- /dev/null
+++ b/test/run-drun/ok/obj-ext-await.tc.ok
@@ -0,0 +1 @@
+obj-ext-await.mo:5.13-5.14: warning [M0194], unused identifier t (delete or rename to wildcard `_` or `_t`)
diff --git a/test/run-drun/ok/oneshot-callbacks.ic-ref-run.ok b/test/run-drun/ok/oneshot-callbacks.ic-ref-run.ok
deleted file mode 100644
index c00693298f7..00000000000
--- a/test/run-drun/ok/oneshot-callbacks.ic-ref-run.ok
+++ /dev/null
@@ -1,70 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update drill((42 : nat8))
-debug.print: drill! 42 0
-debug.print: drill! 41 2
-debug.print: drill! 40 4
-debug.print: drill! 39 6
-debug.print: drill! 38 8
-debug.print: drill! 37 10
-debug.print: drill! 36 12
-debug.print: drill! 35 14
-debug.print: drill! 34 16
-debug.print: drill! 33 18
-debug.print: drill! 32 20
-debug.print: drill! 31 22
-debug.print: drill! 30 24
-debug.print: drill! 29 26
-debug.print: drill! 28 28
-debug.print: drill! 27 30
-debug.print: drill! 26 32
-debug.print: drill! 25 34
-debug.print: drill! 24 36
-debug.print: drill! 23 38
-debug.print: drill! 22 40
-debug.print: drill! 21 42
-debug.print: drill! 20 44
-debug.print: drill! 19 46
-debug.print: drill! 18 48
-debug.print: drill! 17 50
-debug.print: drill! 16 52
-debug.print: drill! 15 54
-debug.print: drill! 14 56
-debug.print: drill! 13 58
-debug.print: drill! 12 60
-debug.print: drill! 11 62
-debug.print: drill! 10 64
-debug.print: drill! 9 66
-debug.print: drill! 8 68
-debug.print: drill! 7 70
-debug.print: drill! 6 72
-debug.print: drill! 5 74
-debug.print: drill! 4 76
-debug.print: drill! 3 78
-debug.print: drill! 2 80
-debug.print: drill! 1 82
-debug.print: drill! 0 84
-<= replied: ()
-=> update go(true)
-debug.print: go 0: 0
-debug.print: ping! 1
-debug.print: go 1: 1
-debug.print: ping-async! 1
-debug.print: go 2: 1
-<= rejected (RC_CANISTER_ERROR): canister trapped: EvalTrapError region:0xXXX-0xXXX "NumericIntegerDivideByZero"
-=> update go(false)
-debug.print: go 0: 0
-debug.print: ping! 1
-debug.print: go 1: 1
-debug.print: ping-async! 1
-debug.print: go 2: 1
-<= replied: ()
-=> update go(true)
-debug.print: go 0: 0
-debug.print: ping! 1
-debug.print: go 1: 1
-debug.print: ping-async! 1
-debug.print: go 2: 1
-<= rejected (RC_CANISTER_ERROR): canister trapped: EvalTrapError region:0xXXX-0xXXX "NumericIntegerDivideByZero"
diff --git a/test/run-drun/ok/oneway-throw.ic-ref-run.ok b/test/run-drun/ok/oneway-throw.ic-ref-run.ok
deleted file mode 100644
index 4dba9f4e602..00000000000
--- a/test/run-drun/ok/oneway-throw.ic-ref-run.ok
+++ /dev/null
@@ -1,10 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: go1
-debug.print: throws()
-debug.print: ping()
-debug.print: go2
-<= replied: ()
diff --git a/test/run-drun/ok/oneway.ic-ref-run.ok b/test/run-drun/ok/oneway.ic-ref-run.ok
deleted file mode 100644
index 64033498cd2..00000000000
--- a/test/run-drun/ok/oneway.ic-ref-run.ok
+++ /dev/null
@@ -1,17 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: A
-debug.print: B
-debug.print: C
-debug.print: D
-debug.print: E
-debug.print: 1
-debug.print: 2
-debug.print: 3
-debug.print: 4
-debug.print: 5
-debug.print: 6
-<= replied: ()
diff --git a/test/run-drun/ok/oom.ic-ref-run.ok b/test/run-drun/ok/oom.ic-ref-run.ok
deleted file mode 100644
index 145184946ca..00000000000
--- a/test/run-drun/ok/oom.ic-ref-run.ok
+++ /dev/null
@@ -1,8 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-<= replied: ()
-=> update go()
-<= replied: ()
diff --git a/test/run-drun/ok/optimise-for-array-eff.ic-ref-run.ok b/test/run-drun/ok/optimise-for-array-eff.ic-ref-run.ok
deleted file mode 100644
index 2ec20a79090..00000000000
--- a/test/run-drun/ok/optimise-for-array-eff.ic-ref-run.ok
+++ /dev/null
@@ -1,18 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: effect
-debug.print: hello
-debug.print: world
-debug.print: hello
-debug.print: world
-debug.print: effect
-debug.print: hello
-debug.print: bound
-debug.print: world
-debug.print: hello
-debug.print: bound
-debug.print: world
-<= replied: ()
diff --git a/test/run-drun/ok/overflow.ic-ref-run.ok b/test/run-drun/ok/overflow.ic-ref-run.ok
deleted file mode 100644
index c0a16790358..00000000000
--- a/test/run-drun/ok/overflow.ic-ref-run.ok
+++ /dev/null
@@ -1,16 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: ok 1
-debug.print: ok 2
-debug.print: ok 3
-debug.print: ok 4
-debug.print: ok 5
-debug.print: ok 6
-debug.print: ok 7
-debug.print: ok 8
-debug.print: ok 9
-debug.print: ok 10
-<= replied: ()
diff --git a/test/run-drun/ok/perf.drun-run.ok b/test/run-drun/ok/perf.drun-run.ok
index d8daae9f670..c76c471c7d5 100644
--- a/test/run-drun/ok/perf.drun-run.ok
+++ b/test/run-drun/ok/perf.drun-run.ok
@@ -1,4 +1,3 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: 66_251
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/print-from-init.ic-ref-run.ok b/test/run-drun/ok/print-from-init.ic-ref-run.ok
deleted file mode 100644
index 29150b2b10e..00000000000
--- a/test/run-drun/ok/print-from-init.ic-ref-run.ok
+++ /dev/null
@@ -1,5 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-debug.print: Debug out
-<= replied: ()
diff --git a/test/run-drun/ok/query-footprint-overflow.ic-ref-run.ok b/test/run-drun/ok/query-footprint-overflow.ic-ref-run.ok
deleted file mode 100644
index 7e60f85d9e8..00000000000
--- a/test/run-drun/ok/query-footprint-overflow.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update delegate()
-<= rejected (RC_CANISTER_REJECT): canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: buffer_size overflow"
diff --git a/test/run-drun/ok/query-footprint-overflow.tc.ok b/test/run-drun/ok/query-footprint-overflow.tc.ok
new file mode 100644
index 00000000000..fa23d3c5fec
--- /dev/null
+++ b/test/run-drun/ok/query-footprint-overflow.tc.ok
@@ -0,0 +1,2 @@
+query-footprint-overflow.mo:3.7-3.16: warning [M0194], unused identifier footprint (delete or rename to wildcard `_` or `_footprint`)
+query-footprint-overflow.mo:21.16-21.20: warning [M0194], unused identifier expl (delete or rename to wildcard `_` or `_expl`)
diff --git a/test/run-drun/ok/query-footprint.ic-ref-run.ok b/test/run-drun/ok/query-footprint.ic-ref-run.ok
deleted file mode 100644
index f70a6dea81f..00000000000
--- a/test/run-drun/ok/query-footprint.ic-ref-run.ok
+++ /dev/null
@@ -1,12 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update __motoko_stable_var_info()
-<= replied: (record {size = (6225 : nat64)})
-=> query __motoko_stable_var_info()
-<= replied: (record {size = (6225 : nat64)})
-=> update delegate()
-<= replied: ((6225 : nat64))
-=> update delegate()
-<= replied: ((6225 : nat64))
diff --git a/test/run-drun/ok/query-footprint.tc.ok b/test/run-drun/ok/query-footprint.tc.ok
new file mode 100644
index 00000000000..a6e7da9d658
--- /dev/null
+++ b/test/run-drun/ok/query-footprint.tc.ok
@@ -0,0 +1,4 @@
+query-footprint.mo:3.7-3.16: warning [M0194], unused identifier footprint (delete or rename to wildcard `_` or `_footprint`)
+query-footprint.mo:4.16-4.17: warning [M0194], unused identifier s (delete or rename to wildcard `_` or `_s`)
+query-footprint.mo:6.9-6.13: warning [M0194], unused identifier lost (delete or rename to wildcard `_` or `_lost`)
+query-footprint.mo:18.16-18.20: warning [M0194], unused identifier expl (delete or rename to wildcard `_` or `_expl`)
diff --git a/test/run-drun/ok/query-size-overflow.ic-ref-run.ok b/test/run-drun/ok/query-size-overflow.ic-ref-run.ok
deleted file mode 100644
index 5a7b256e69c..00000000000
--- a/test/run-drun/ok/query-size-overflow.ic-ref-run.ok
+++ /dev/null
@@ -1,8 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> query overflow()
-<= rejected (RC_CANISTER_ERROR): canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: buffer_size overflow"
-=> query overflowOpt()
-<= rejected (RC_CANISTER_ERROR): canister trapped: EvalTrapError region:0xXXX-0xXXX "canister trapped explicitly: buffer_size overflow"
diff --git a/test/run-drun/ok/query.ic-ref-run.ok b/test/run-drun/ok/query.ic-ref-run.ok
deleted file mode 100644
index f0e2dc58bf7..00000000000
--- a/test/run-drun/ok/query.ic-ref-run.ok
+++ /dev/null
@@ -1,30 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update inc()
-debug.print: 2
-<= replied: ()
-=> update inc()
-debug.print: 3
-<= replied: ()
-=> update inc()
-debug.print: 4
-<= replied: ()
-=> update printCounter()
-debug.print: 4
-<= replied: ()
-=> update get()
-<= replied: (4)
-=> query read()
-debug.print: 5
-<= replied: (4)
-=> update printCounter()
-debug.print: 4
-<= replied: ()
-=> query read()
-debug.print: 5
-<= replied: (4)
-=> update printCounter()
-debug.print: 4
-<= replied: ()
diff --git a/test/run-drun/ok/query2.ic-ref-run.ok b/test/run-drun/ok/query2.ic-ref-run.ok
deleted file mode 100644
index eebf1a0715e..00000000000
--- a/test/run-drun/ok/query2.ic-ref-run.ok
+++ /dev/null
@@ -1,17 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: 2
-debug.print: 3
-debug.print: 4
-debug.print: 4
-debug.print: In read:
-debug.print: 5
-debug.print: 4
-debug.print: In read:
-debug.print: 5
-debug.print: 4
-debug.print: The following fails in the interpreter, for lack of query semantics
-<= replied: ()
diff --git a/test/run-drun/ok/rand.ic-ref-run.ok b/test/run-drun/ok/rand.ic-ref-run.ok
deleted file mode 100644
index 9cb02531277..00000000000
--- a/test/run-drun/ok/rand.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-<= replied: ()
diff --git a/test/run-drun/ok/rand.tc.ok b/test/run-drun/ok/rand.tc.ok
new file mode 100644
index 00000000000..3f50c1d8077
--- /dev/null
+++ b/test/run-drun/ok/rand.tc.ok
@@ -0,0 +1,2 @@
+rand.mo:8.9-8.11: warning [M0194], unused identifier t1 (delete or rename to wildcard `_` or `_t1`)
+rand.mo:10.9-10.11: warning [M0194], unused identifier t2 (delete or rename to wildcard `_` or `_t2`)
diff --git a/test/run-drun/ok/region0-rts-stats.tc.ok b/test/run-drun/ok/region0-rts-stats.tc.ok
index a6fcc2eb750..767402f14be 100644
--- a/test/run-drun/ok/region0-rts-stats.tc.ok
+++ b/test/run-drun/ok/region0-rts-stats.tc.ok
@@ -2,3 +2,4 @@ region0-rts-stats.mo:8.7-8.8: warning [M0145], this pattern of type
   Nat64
 does not cover value
   1 or 2 or _
+region0-rts-stats.mo:9.14-9.15: warning [M0194], unused identifier v (delete or rename to wildcard `_` or `_v`)
diff --git a/test/run-drun/ok/region0-stable-mem-grow.tc.ok b/test/run-drun/ok/region0-stable-mem-grow.tc.ok
new file mode 100644
index 00000000000..72b67f75793
--- /dev/null
+++ b/test/run-drun/ok/region0-stable-mem-grow.tc.ok
@@ -0,0 +1,2 @@
+region0-stable-mem-grow.mo:11.14-11.15: warning [M0194], unused identifier c (delete or rename to wildcard `_` or `_c`)
+region0-stable-mem-grow.mo:15.9-15.10: warning [M0194], unused identifier m (delete or rename to wildcard `_` or `_m`)
diff --git a/test/run-drun/ok/reinstall.ic-ref-run.ok b/test/run-drun/ok/reinstall.ic-ref-run.ok
deleted file mode 100644
index 3d2310a18f6..00000000000
--- a/test/run-drun/ok/reinstall.ic-ref-run.ok
+++ /dev/null
@@ -1,10 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> query check()
-<= replied: (1)
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> query check()
-<= replied: (2)
diff --git a/test/run-drun/ok/reject-bug.ic-ref-run.ok b/test/run-drun/ok/reject-bug.ic-ref-run.ok
deleted file mode 100644
index 45297da01a8..00000000000
--- a/test/run-drun/ok/reject-bug.ic-ref-run.ok
+++ /dev/null
@@ -1,8 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> query ok()
-<= rejected (RC_CANISTER_REJECT): abcdefgh
-=> query crash()
-<= rejected (RC_CANISTER_REJECT): abcdefghi
diff --git a/test/run-drun/ok/reject.ic-ref-run.ok b/test/run-drun/ok/reject.ic-ref-run.ok
deleted file mode 100644
index adc65e10d7f..00000000000
--- a/test/run-drun/ok/reject.ic-ref-run.ok
+++ /dev/null
@@ -1,15 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update reject1()
-debug.print: 1
-<= rejected (RC_CANISTER_REJECT): Error
-=> update reject2()
-debug.print: 1
-debug.print: ok
-<= replied: ()
-=> update reject3()
-debug.print: 1
-debug.print: ok
-<= rejected (RC_CANISTER_REJECT): Error
diff --git a/test/run-drun/ok/rts-stack-pages.tc.ok b/test/run-drun/ok/rts-stack-pages.tc.ok
new file mode 100644
index 00000000000..ddd1d8c367a
--- /dev/null
+++ b/test/run-drun/ok/rts-stack-pages.tc.ok
@@ -0,0 +1,2 @@
+rts-stack-pages.mo:6.7-6.8: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+rts-stack-pages.mo:8.8-8.9: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
diff --git a/test/run-drun/ok/rts-stats.ic-ref-run.ok b/test/run-drun/ok/rts-stats.ic-ref-run.ok
deleted file mode 100644
index 7e967e1a062..00000000000
--- a/test/run-drun/ok/rts-stats.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
diff --git a/test/run-drun/ok/rts-stats2.ic-ref-run.ok b/test/run-drun/ok/rts-stats2.ic-ref-run.ok
deleted file mode 100644
index e23f781e659..00000000000
--- a/test/run-drun/ok/rts-stats2.ic-ref-run.ok
+++ /dev/null
@@ -1,24 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update foo()
-<= replied: ()
-=> update check_A()
-debug.print: Ignore Diff: (ignored)
-debug.print: Ignore Diff: (ignored)
-<= replied: ()
-=> update check_A()
-debug.print: Ignore Diff: (ignored)
-debug.print: Ignore Diff: (ignored)
-<= replied: ()
-=> update bar()
-<= replied: ()
-=> update check_B()
-debug.print: Ignore Diff: (ignored)
-debug.print: Ignore Diff: (ignored)
-<= replied: ()
-=> update check_B()
-debug.print: Ignore Diff: (ignored)
-debug.print: Ignore Diff: (ignored)
-<= replied: ()
diff --git a/test/run-drun/ok/rts-stats2.tc.ok b/test/run-drun/ok/rts-stats2.tc.ok
new file mode 100644
index 00000000000..06ce5b9ecea
--- /dev/null
+++ b/test/run-drun/ok/rts-stats2.tc.ok
@@ -0,0 +1 @@
+rts-stats2.mo:2.7-2.8: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
diff --git a/test/run-drun/ok/scope-example-func.tc.ok b/test/run-drun/ok/scope-example-func.tc.ok
index 1e72db69880..85bc86e0765 100644
--- a/test/run-drun/ok/scope-example-func.tc.ok
+++ b/test/run-drun/ok/scope-example-func.tc.ok
@@ -2,7 +2,7 @@ scope-example-func.mo:10.13-10.38: type error [M0037], misplaced async expressio
 scope-example-func.mo:10.13-10.38: type error [M0092], async at scope
   $bogus
 cannot produce expected scope
-  $anon-async-5.60
-  scope $anon-async-5.60 is scope-example-func.mo:5.60-21.4
-scope-example-func.mo:5.60: info, start of scope $anon-async-5.60 mentioned in error at scope-example-func.mo:10.13-10.38
-scope-example-func.mo:21.3: info, end of scope $anon-async-5.60 mentioned in error at scope-example-func.mo:10.13-10.38
+  $@anon-async-5.60
+  scope $@anon-async-5.60 is scope-example-func.mo:5.60-21.4
+scope-example-func.mo:5.60: info, start of scope $@anon-async-5.60 mentioned in error at scope-example-func.mo:10.13-10.38
+scope-example-func.mo:21.3: info, end of scope $@anon-async-5.60 mentioned in error at scope-example-func.mo:10.13-10.38
diff --git a/test/run-drun/ok/scope-example-implicit.tc.ok b/test/run-drun/ok/scope-example-implicit.tc.ok
index 73863c4e787..d8a64b87b48 100644
--- a/test/run-drun/ok/scope-example-implicit.tc.ok
+++ b/test/run-drun/ok/scope-example-implicit.tc.ok
@@ -1,4 +1,4 @@
 scope-example-implicit.mo:10.12-10.19: type error [M0096], expression of type
-  async<$anon-async-8.12> Int
+  async<$@anon-async-8.12> Int
 cannot produce expected type
   async<$f> Int
diff --git a/test/run-drun/ok/scope-example.tc.ok b/test/run-drun/ok/scope-example.tc.ok
index 1562ab07708..ee201b574d4 100644
--- a/test/run-drun/ok/scope-example.tc.ok
+++ b/test/run-drun/ok/scope-example.tc.ok
@@ -1,4 +1,4 @@
 scope-example.mo:12.13-12.27: type error [M0096], expression of type
-  async<$anon-async-10.12> Int
+  async<$@anon-async-10.12> Int
 cannot produce expected type
-  async<$anon-async-6.60> Int
+  async<$@anon-async-6.60> Int
diff --git a/test/run-drun/ok/self-describe.tc.ok b/test/run-drun/ok/self-describe.tc.ok
new file mode 100644
index 00000000000..1c8cba6b34f
--- /dev/null
+++ b/test/run-drun/ok/self-describe.tc.ok
@@ -0,0 +1 @@
+self-describe.mo:3.21-3.22: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
diff --git a/test/run-drun/ok/self-shadow.tc.ok b/test/run-drun/ok/self-shadow.tc.ok
new file mode 100644
index 00000000000..8f881c6b314
--- /dev/null
+++ b/test/run-drun/ok/self-shadow.tc.ok
@@ -0,0 +1,3 @@
+self-shadow.mo:1.7-1.10: warning [M0194], unused identifier foo (delete or rename to wildcard `_` or `_foo`)
+self-shadow.mo:4.17-4.19: warning [M0194], unused identifier go (delete or rename to wildcard `_` or `_go`)
+self-shadow.mo:5.9-5.12: warning [M0194], unused identifier bar (delete or rename to wildcard `_` or `_bar`)
diff --git a/test/run-drun/ok/self-upgrade.ic-ref-run.ok b/test/run-drun/ok/self-upgrade.ic-ref-run.ok
deleted file mode 100644
index 2ca3a1f3671..00000000000
--- a/test/run-drun/ok/self-upgrade.ic-ref-run.ok
+++ /dev/null
@@ -1,29 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-debug.print: init'ed
-<= replied: ()
-=> query check(1)
-debug.print: a
-<= replied: ()
-=> update inc()
-<= replied: ()
-=> query check(2)
-debug.print: aa
-<= replied: ()
-=> update inc()
-<= replied: ()
-=> query check(3)
-debug.print: aaa
-<= replied: ()
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-debug.print: init'ed
-<= replied: ()
-=> query check(3)
-debug.print: aaa
-<= replied: ()
-=> update inc()
-<= replied: ()
-=> query check(4)
-debug.print: aaaa
-<= replied: ()
diff --git a/test/run-drun/ok/selftail.ic-ref-run.ok b/test/run-drun/ok/selftail.ic-ref-run.ok
deleted file mode 100644
index 56f22daf620..00000000000
--- a/test/run-drun/ok/selftail.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-debug.print: ok1
-debug.print: ok2
-<= rejected (RC_CANISTER_ERROR): Initialization trapped: EvalExhaustionError region:0xXXX-0xXXX "call stack exhausted"
diff --git a/test/run-drun/ok/service-import.ic-ref-run.ok b/test/run-drun/ok/service-import.ic-ref-run.ok
deleted file mode 100644
index cfe638ed830..00000000000
--- a/test/run-drun/ok/service-import.ic-ref-run.ok
+++ /dev/null
@@ -1,13 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: rwlgt-iiaaa-aaaaa-aaaaa-cai
-<= replied: (service "rwlgt-iiaaa-aaaaa-aaaaa-cai")
-=> update go2()
-debug.print: rwlgt-iiaaa-aaaaa-aaaaa-cai
-<= replied: (service "rwlgt-iiaaa-aaaaa-aaaaa-cai")
-=> update go3()
-debug.print: rwlgt-iiaaa-aaaaa-aaaaa-cai
-<= replied: (service "rwlgt-iiaaa-aaaaa-aaaaa-cai")
diff --git a/test/run-drun/ok/shared-object.ic-ref-run.ok b/test/run-drun/ok/shared-object.ic-ref-run.ok
deleted file mode 100644
index 9cb02531277..00000000000
--- a/test/run-drun/ok/shared-object.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-<= replied: ()
diff --git a/test/run-drun/ok/sharingbug.ic-ref-run.ok b/test/run-drun/ok/sharingbug.ic-ref-run.ok
deleted file mode 100644
index 7e967e1a062..00000000000
--- a/test/run-drun/ok/sharingbug.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
diff --git a/test/run-drun/ok/show.ic-ref-run.ok b/test/run-drun/ok/show.ic-ref-run.ok
deleted file mode 100644
index b603c5337e5..00000000000
--- a/test/run-drun/ok/show.ic-ref-run.ok
+++ /dev/null
@@ -1,38 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-debug.print: true
-debug.print: false
-debug.print: -42_000_000_000_000
-debug.print: -42_000_000
-debug.print: -42_000
-debug.print: -42
-debug.print: 0
-debug.print: 0
-debug.print: +42
-debug.print: +42_000
-debug.print: +42_000_000
-debug.print: +420_000_000_000_000
-debug.print: 0
-debug.print: 42
-debug.print: 42_000
-debug.print: 42_000_000
-debug.print: 420_000_000_000_000
-debug.print: (42, -42, ())
-debug.print: ("Foobar", null, null, ?23)
-debug.print: []
-debug.print: [1, 2, 3]
-debug.print: [var]
-debug.print: [var 1, 2, 3]
-debug.print: {bar = true; foo = +42}
-debug.print: #foo
-debug.print: #bar(1, 2)
-debug.print: #bar({})
-debug.print: #bar([])
-debug.print: #bar(42)
-debug.print: #bar(-42)
-debug.print: #foo(+42)
-debug.print: 42
-debug.print: +42
-debug.print: -42
-<= replied: ()
diff --git a/test/run-drun/ok/show.tc.ok b/test/run-drun/ok/show.tc.ok
new file mode 100644
index 00000000000..b485e9ccb8b
--- /dev/null
+++ b/test/run-drun/ok/show.tc.ok
@@ -0,0 +1 @@
+show.mo:25.77-25.83: warning [M0194], unused identifier hidden (delete or rename to wildcard `_` or `_hidden`)
diff --git a/test/run-drun/ok/stable-mem-grow.tc.ok b/test/run-drun/ok/stable-mem-grow.tc.ok
new file mode 100644
index 00000000000..e0f7a104fb6
--- /dev/null
+++ b/test/run-drun/ok/stable-mem-grow.tc.ok
@@ -0,0 +1,2 @@
+stable-mem-grow.mo:10.14-10.15: warning [M0194], unused identifier c (delete or rename to wildcard `_` or `_c`)
+stable-mem-grow.mo:14.9-14.10: warning [M0194], unused identifier m (delete or rename to wildcard `_` or `_m`)
diff --git a/test/run-drun/ok/stable-mem-rts-stats.tc.ok b/test/run-drun/ok/stable-mem-rts-stats.tc.ok
index 5706232e25e..4ac54eeb875 100644
--- a/test/run-drun/ok/stable-mem-rts-stats.tc.ok
+++ b/test/run-drun/ok/stable-mem-rts-stats.tc.ok
@@ -2,3 +2,4 @@ stable-mem-rts-stats.mo:7.7-7.8: warning [M0145], this pattern of type
   Nat64
 does not cover value
   1 or 2 or _
+stable-mem-rts-stats.mo:8.14-8.15: warning [M0194], unused identifier v (delete or rename to wildcard `_` or `_v`)
diff --git a/test/run-drun/ok/stable-mutable.ic-ref-run.ok b/test/run-drun/ok/stable-mutable.ic-ref-run.ok
deleted file mode 100644
index 5fa08850815..00000000000
--- a/test/run-drun/ok/stable-mutable.ic-ref-run.ok
+++ /dev/null
@@ -1,27 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update tie(1)
-<= replied: ()
-=> query checkArray(1)
-<= replied: ()
-=> query checkRecord(1)
-<= replied: ()
-=> query checkCycle(1)
-<= replied: ()
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> query checkArray(1)
-<= replied: ()
-=> query checkRecord(1)
-<= replied: ()
-=> query checkCycle(1)
-<= replied: ()
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> query checkArray2(1)
-<= replied: ()
-=> query checkRecord2(1)
-debug.print: hello
-<= replied: ()
diff --git a/test/run-drun/ok/stable-sig-more.ic-ref-run.ok b/test/run-drun/ok/stable-sig-more.ic-ref-run.ok
deleted file mode 100644
index 7e967e1a062..00000000000
--- a/test/run-drun/ok/stable-sig-more.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
diff --git a/test/run-drun/ok/stable-sig-more.tc.ok b/test/run-drun/ok/stable-sig-more.tc.ok
new file mode 100644
index 00000000000..410fb464f7f
--- /dev/null
+++ b/test/run-drun/ok/stable-sig-more.tc.ok
@@ -0,0 +1,49 @@
+stable-sig-more.mo:2.7-2.11: warning [M0194], unused identifier this (delete or rename to wildcard `_` or `_this`)
+stable-sig-more.mo:5.13-5.15: warning [M0194], unused identifier x0 (delete or rename to wildcard `_` or `_x0`)
+stable-sig-more.mo:8.13-8.15: warning [M0194], unused identifier x1 (delete or rename to wildcard `_` or `_x1`)
+stable-sig-more.mo:11.13-11.15: warning [M0194], unused identifier x2 (delete or rename to wildcard `_` or `_x2`)
+stable-sig-more.mo:14.13-14.15: warning [M0194], unused identifier x3 (delete or rename to wildcard `_` or `_x3`)
+stable-sig-more.mo:17.13-17.15: warning [M0194], unused identifier x4 (delete or rename to wildcard `_` or `_x4`)
+stable-sig-more.mo:20.13-20.15: warning [M0194], unused identifier x5 (delete or rename to wildcard `_` or `_x5`)
+stable-sig-more.mo:23.13-23.15: warning [M0194], unused identifier x6 (delete or rename to wildcard `_` or `_x6`)
+stable-sig-more.mo:25.13-25.15: warning [M0194], unused identifier v1 (delete or rename to wildcard `_` or `_v1`)
+stable-sig-more.mo:26.13-26.15: warning [M0194], unused identifier v2 (delete or rename to wildcard `_` or `_v2`)
+stable-sig-more.mo:27.13-27.15: warning [M0194], unused identifier v3 (delete or rename to wildcard `_` or `_v3`)
+stable-sig-more.mo:28.13-28.15: warning [M0194], unused identifier v4 (delete or rename to wildcard `_` or `_v4`)
+stable-sig-more.mo:29.13-29.15: warning [M0194], unused identifier v5 (delete or rename to wildcard `_` or `_v5`)
+stable-sig-more.mo:30.13-30.15: warning [M0194], unused identifier v6 (delete or rename to wildcard `_` or `_v6`)
+stable-sig-more.mo:31.13-31.15: warning [M0194], unused identifier v7 (delete or rename to wildcard `_` or `_v7`)
+stable-sig-more.mo:32.13-32.15: warning [M0194], unused identifier v8 (delete or rename to wildcard `_` or `_v8`)
+stable-sig-more.mo:34.13-34.14: warning [M0194], unused identifier p (delete or rename to wildcard `_` or `_p`)
+stable-sig-more.mo:36.13-36.15: warning [M0194], unused identifier v9 (delete or rename to wildcard `_` or `_v9`)
+stable-sig-more.mo:37.13-37.16: warning [M0194], unused identifier v10 (delete or rename to wildcard `_` or `_v10`)
+stable-sig-more.mo:38.13-38.16: warning [M0194], unused identifier v11 (delete or rename to wildcard `_` or `_v11`)
+stable-sig-more.mo:40.13-40.14: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+stable-sig-more.mo:42.13-42.15: warning [M0194], unused identifier o1 (delete or rename to wildcard `_` or `_o1`)
+stable-sig-more.mo:43.13-43.15: warning [M0194], unused identifier o2 (delete or rename to wildcard `_` or `_o2`)
+stable-sig-more.mo:44.13-44.15: warning [M0194], unused identifier o3 (delete or rename to wildcard `_` or `_o3`)
+stable-sig-more.mo:45.13-45.15: warning [M0194], unused identifier o4 (delete or rename to wildcard `_` or `_o4`)
+stable-sig-more.mo:46.13-46.15: warning [M0194], unused identifier o5 (delete or rename to wildcard `_` or `_o5`)
+stable-sig-more.mo:47.13-47.15: warning [M0194], unused identifier o6 (delete or rename to wildcard `_` or `_o6`)
+stable-sig-more.mo:48.13-48.15: warning [M0194], unused identifier o7 (delete or rename to wildcard `_` or `_o7`)
+stable-sig-more.mo:49.13-49.15: warning [M0194], unused identifier o8 (delete or rename to wildcard `_` or `_o8`)
+stable-sig-more.mo:51.13-51.15: warning [M0194], unused identifier t1 (delete or rename to wildcard `_` or `_t1`)
+stable-sig-more.mo:52.13-52.15: warning [M0194], unused identifier t2 (delete or rename to wildcard `_` or `_t2`)
+stable-sig-more.mo:53.13-53.15: warning [M0194], unused identifier t3 (delete or rename to wildcard `_` or `_t3`)
+stable-sig-more.mo:54.13-54.15: warning [M0194], unused identifier t4 (delete or rename to wildcard `_` or `_t4`)
+stable-sig-more.mo:56.13-56.15: warning [M0194], unused identifier a0 (delete or rename to wildcard `_` or `_a0`)
+stable-sig-more.mo:57.13-57.15: warning [M0194], unused identifier a1 (delete or rename to wildcard `_` or `_a1`)
+stable-sig-more.mo:58.13-58.15: warning [M0194], unused identifier a2 (delete or rename to wildcard `_` or `_a2`)
+stable-sig-more.mo:60.13-60.15: warning [M0194], unused identifier m0 (delete or rename to wildcard `_` or `_m0`)
+stable-sig-more.mo:61.13-61.15: warning [M0194], unused identifier m1 (delete or rename to wildcard `_` or `_m1`)
+stable-sig-more.mo:62.13-62.15: warning [M0194], unused identifier m2 (delete or rename to wildcard `_` or `_m2`)
+stable-sig-more.mo:63.13-63.15: warning [M0194], unused identifier m3 (delete or rename to wildcard `_` or `_m3`)
+stable-sig-more.mo:65.13-65.15: warning [M0194], unused identifier r1 (delete or rename to wildcard `_` or `_r1`)
+stable-sig-more.mo:66.13-66.15: warning [M0194], unused identifier r2 (delete or rename to wildcard `_` or `_r2`)
+stable-sig-more.mo:67.13-67.15: warning [M0194], unused identifier r3 (delete or rename to wildcard `_` or `_r3`)
+stable-sig-more.mo:68.13-68.15: warning [M0194], unused identifier r4 (delete or rename to wildcard `_` or `_r4`)
+stable-sig-more.mo:69.13-69.15: warning [M0194], unused identifier r5 (delete or rename to wildcard `_` or `_r5`)
+stable-sig-more.mo:71.13-71.15: warning [M0194], unused identifier d1 (delete or rename to wildcard `_` or `_d1`)
+stable-sig-more.mo:72.13-72.15: warning [M0194], unused identifier d2 (delete or rename to wildcard `_` or `_d2`)
+stable-sig-more.mo:73.13-73.15: warning [M0194], unused identifier d3 (delete or rename to wildcard `_` or `_d3`)
+stable-sig-more.mo:74.13-74.15: warning [M0194], unused identifier d4 (delete or rename to wildcard `_` or `_d4`)
diff --git a/test/run-drun/ok/stable-sig.ic-ref-run.ok b/test/run-drun/ok/stable-sig.ic-ref-run.ok
deleted file mode 100644
index 7e967e1a062..00000000000
--- a/test/run-drun/ok/stable-sig.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
diff --git a/test/run-drun/ok/stable-sig.tc.ok b/test/run-drun/ok/stable-sig.tc.ok
new file mode 100644
index 00000000000..33bf7f94db9
--- /dev/null
+++ b/test/run-drun/ok/stable-sig.tc.ok
@@ -0,0 +1,7 @@
+stable-sig.mo:6.14-6.15: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+stable-sig.mo:7.14-7.16: warning [M0194], unused identifier vn (delete or rename to wildcard `_` or `_vn`)
+stable-sig.mo:9.14-9.16: warning [M0194], unused identifier ns (delete or rename to wildcard `_` or `_ns`)
+stable-sig.mo:10.14-10.16: warning [M0194], unused identifier ln (delete or rename to wildcard `_` or `_ln`)
+stable-sig.mo:11.14-11.16: warning [M0194], unused identifier lt (delete or rename to wildcard `_` or `_lt`)
+stable-sig.mo:12.14-12.18: warning [M0194], unused identifier lnon (delete or rename to wildcard `_` or `_lnon`)
+stable-sig.mo:13.14-13.18: warning [M0194], unused identifier lany (delete or rename to wildcard `_` or `_lany`)
diff --git a/test/run-drun/ok/stable-size-overflow.tc.ok b/test/run-drun/ok/stable-size-overflow.tc.ok
new file mode 100644
index 00000000000..c95acc0ecd5
--- /dev/null
+++ b/test/run-drun/ok/stable-size-overflow.tc.ok
@@ -0,0 +1 @@
+stable-size-overflow.mo:12.7-12.8: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
diff --git a/test/run-drun/ok/stable.ic-ref-run.ok b/test/run-drun/ok/stable.ic-ref-run.ok
deleted file mode 100644
index 34169211554..00000000000
--- a/test/run-drun/ok/stable.ic-ref-run.ok
+++ /dev/null
@@ -1,24 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-debug.print: init'ed
-<= replied: ()
-=> query check(1)
-<= replied: ()
-=> update inc()
-<= replied: ()
-=> query check(2)
-<= replied: ()
-=> update inc()
-<= replied: ()
-=> query check(3)
-<= replied: ()
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-debug.print: init'ed
-<= replied: ()
-=> query check(3)
-<= replied: ()
-=> update inc()
-<= replied: ()
-=> query check(4)
-<= replied: ()
diff --git a/test/run-drun/ok/stable.tc.ok b/test/run-drun/ok/stable.tc.ok
new file mode 100644
index 00000000000..42754cc68cb
--- /dev/null
+++ b/test/run-drun/ok/stable.tc.ok
@@ -0,0 +1 @@
+stable.mo:11.14-11.15: warning [M0194], unused identifier b (delete or rename to wildcard `_` or `_b`)
diff --git a/test/run-drun/ok/static-call-from-pub.ic-ref-run.ok b/test/run-drun/ok/static-call-from-pub.ic-ref-run.ok
deleted file mode 100644
index 7e967e1a062..00000000000
--- a/test/run-drun/ok/static-call-from-pub.ic-ref-run.ok
+++ /dev/null
@@ -1,4 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
diff --git a/test/run-drun/ok/static-gc.ic-ref-run.ok b/test/run-drun/ok/static-gc.ic-ref-run.ok
deleted file mode 100644
index e9c537fbbc6..00000000000
--- a/test/run-drun/ok/static-gc.ic-ref-run.ok
+++ /dev/null
@@ -1,8 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update foo1()
-<= replied: ()
-=> update foo2()
-<= replied: ()
diff --git a/test/run-drun/ok/switch-await.ic-ref-run.ok b/test/run-drun/ok/switch-await.ic-ref-run.ok
deleted file mode 100644
index b76535f8137..00000000000
--- a/test/run-drun/ok/switch-await.ic-ref-run.ok
+++ /dev/null
@@ -1,12 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go_tt()
-<= replied: ("One")
-=> update go_ta()
-<= replied: ("One")
-=> update go_at()
-<= replied: ("One")
-=> update go_aa()
-<= replied: ("One")
diff --git a/test/run-drun/ok/tailpositions-actor.ic-ref-run.ok b/test/run-drun/ok/tailpositions-actor.ic-ref-run.ok
deleted file mode 100644
index 48ccb22746e..00000000000
--- a/test/run-drun/ok/tailpositions-actor.ic-ref-run.ok
+++ /dev/null
@@ -1,13 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> query test_loop1()
-debug.print: done
-<= replied: ()
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-debug.print: preupgrade
-debug.print: preupgrade_loop done
-debug.print: postupgrade
-debug.print: postupgrade_loop done
-<= replied: ()
diff --git a/test/run-drun/ok/test-cycles-state.ic-ref-run.ok b/test/run-drun/ok/test-cycles-state.ic-ref-run.ok
deleted file mode 100644
index 080bb9dd2b3..00000000000
--- a/test/run-drun/ok/test-cycles-state.ic-ref-run.ok
+++ /dev/null
@@ -1,15 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: wallet: {cycles = "<not_shown>"}
-debug.print: setting cycles
-debug.print: wallet: {cycles = "<not_shown>"}
-debug.print: debit
-debug.print: available: 1_000_000
-debug.print: available: 0
-debug.print: available: 3_000_000
-debug.print: available: 5_000
-debug.print: available: 0
-<= replied: ()
diff --git a/test/run-drun/ok/test-cycles-state.tc.ok b/test/run-drun/ok/test-cycles-state.tc.ok
new file mode 100644
index 00000000000..a386732ef2c
--- /dev/null
+++ b/test/run-drun/ok/test-cycles-state.tc.ok
@@ -0,0 +1 @@
+test-cycles-state.mo:27.7-27.8: warning [M0194], unused identifier b (delete or rename to wildcard `_` or `_b`)
diff --git a/test/run-drun/ok/test-cycles.ic-ref-run.ok b/test/run-drun/ok/test-cycles.ic-ref-run.ok
deleted file mode 100644
index 2ba338cbe48..00000000000
--- a/test/run-drun/ok/test-cycles.ic-ref-run.ok
+++ /dev/null
@@ -1,35 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: client: available: 0
-debug.print: client: accept(0): 0
-debug.print: wallet: {cycles = "<not_shown>"}
-debug.print: client: setting cycles
-debug.print: wallet: {cycles = "<not_shown>"}
-debug.print: client: # debit
-debug.print: client: # credit-1
-debug.print: client: refunded: 0
-debug.print: client: # credit-2
-debug.print: client: refunded: 0
-debug.print: client: # refund
-debug.print: refunding: 250_000
-debug.print: client: refunded: 250_000
-debug.print: client: refund(5)
-debug.print: refunding: 5
-debug.print: client: refund(4)
-debug.print: refunding: 4
-debug.print: client: refund(3)
-debug.print: refunding: 3
-debug.print: client: refund(2)
-debug.print: refunding: 2
-debug.print: client: refund(1)
-debug.print: refunding: 1
-debug.print: client: refunded: 1
-debug.print: client: refunded: 2
-debug.print: client: refunded: 3
-debug.print: client: refunded: 4
-debug.print: client: refunded: 5
-debug.print: client: 0
-<= replied: ()
diff --git a/test/run-drun/ok/test-cycles.tc.ok b/test/run-drun/ok/test-cycles.tc.ok
new file mode 100644
index 00000000000..1c0694889e0
--- /dev/null
+++ b/test/run-drun/ok/test-cycles.tc.ok
@@ -0,0 +1 @@
+test-cycles.mo:87.8-87.9: warning [M0194], unused identifier b (delete or rename to wildcard `_` or `_b`)
diff --git a/test/run-drun/ok/text-iter-gc.ic-ref-run.ok b/test/run-drun/ok/text-iter-gc.ic-ref-run.ok
deleted file mode 100644
index 9cb02531277..00000000000
--- a/test/run-drun/ok/text-iter-gc.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-<= replied: ()
diff --git a/test/run-drun/ok/text-iter-gc.tc.ok b/test/run-drun/ok/text-iter-gc.tc.ok
new file mode 100644
index 00000000000..0dd326b9ee5
--- /dev/null
+++ b/test/run-drun/ok/text-iter-gc.tc.ok
@@ -0,0 +1 @@
+text-iter-gc.mo:6.8-6.13: warning [M0194], unused identifier array (delete or rename to wildcard `_` or `_array`)
diff --git a/test/run-drun/ok/text-iter.ic-ref-run.ok b/test/run-drun/ok/text-iter.ic-ref-run.ok
deleted file mode 100644
index 12256477af0..00000000000
--- a/test/run-drun/ok/text-iter.ic-ref-run.ok
+++ /dev/null
@@ -1,233 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-debug.print: via `debugPrint`:
-debug.print: hello world!
-debug.print: 
-debug.print: via iteration and `debugPrintChar`: #1
-debug.print: h
-debug.print: e
-debug.print: l
-debug.print: l
-debug.print: o
-debug.print:  
-debug.print: w
-debug.print: o
-debug.print: r
-debug.print: l
-debug.print: d
-debug.print: !
-debug.print: 
-debug.print: via iteration and `debugPrintChar`: #2
-debug.print: 1
-debug.print: :
-debug.print: '
-debug.print: h
-debug.print: '
-debug.print:  
-debug.print: 2
-debug.print: :
-debug.print: '
-debug.print: e
-debug.print: '
-debug.print:  
-debug.print: 3
-debug.print: :
-debug.print: '
-debug.print: l
-debug.print: '
-debug.print:  
-debug.print: 4
-debug.print: :
-debug.print: '
-debug.print: l
-debug.print: '
-debug.print:  
-debug.print: 5
-debug.print: :
-debug.print: '
-debug.print: o
-debug.print: '
-debug.print:  
-debug.print: 6
-debug.print: :
-debug.print: '
-debug.print:  
-debug.print: '
-debug.print:  
-debug.print: 7
-debug.print: :
-debug.print: '
-debug.print: w
-debug.print: '
-debug.print:  
-debug.print: 8
-debug.print: :
-debug.print: '
-debug.print: o
-debug.print: '
-debug.print:  
-debug.print: 9
-debug.print: :
-debug.print: '
-debug.print: r
-debug.print: '
-debug.print:  
-debug.print: 10
-debug.print: :
-debug.print: '
-debug.print: l
-debug.print: '
-debug.print:  
-debug.print: 11
-debug.print: :
-debug.print: '
-debug.print: d
-debug.print: '
-debug.print:  
-debug.print: 12
-debug.print: :
-debug.print: '
-debug.print: !
-debug.print: '
-debug.print:  
-debug.print: 
-debug.print: via iteration and `debugPrintChar` (Unicode): #3
-debug.print: 1
-debug.print: :
-debug.print: '
-debug.print: П
-debug.print: '
-debug.print:  
-debug.print: 2
-debug.print: :
-debug.print: '
-debug.print: р
-debug.print: '
-debug.print:  
-debug.print: 3
-debug.print: :
-debug.print: '
-debug.print: и
-debug.print: '
-debug.print:  
-debug.print: 4
-debug.print: :
-debug.print: '
-debug.print: в
-debug.print: '
-debug.print:  
-debug.print: 5
-debug.print: :
-debug.print: '
-debug.print: е
-debug.print: '
-debug.print:  
-debug.print: 6
-debug.print: :
-debug.print: '
-debug.print: т
-debug.print: '
-debug.print:  
-debug.print: 7
-debug.print: :
-debug.print: '
-debug.print: с
-debug.print: '
-debug.print:  
-debug.print: 8
-debug.print: :
-debug.print: '
-debug.print: т
-debug.print: '
-debug.print:  
-debug.print: 9
-debug.print: :
-debug.print: '
-debug.print: в
-debug.print: '
-debug.print:  
-debug.print: 10
-debug.print: :
-debug.print: '
-debug.print: у
-debug.print: '
-debug.print:  
-debug.print: 11
-debug.print: :
-debug.print: '
-debug.print: ю
-debug.print: '
-debug.print:  
-debug.print: 12
-debug.print: :
-debug.print: '
-debug.print: ,
-debug.print: '
-debug.print:  
-debug.print: 13
-debug.print: :
-debug.print: '
-debug.print:  
-debug.print: '
-debug.print:  
-debug.print: 14
-debug.print: :
-debug.print: '
-debug.print: м
-debug.print: '
-debug.print:  
-debug.print: 15
-debug.print: :
-debug.print: '
-debug.print: и
-debug.print: '
-debug.print:  
-debug.print: 16
-debug.print: :
-debug.print: '
-debug.print: р
-debug.print: '
-debug.print:  
-debug.print: 17
-debug.print: :
-debug.print: '
-debug.print: !
-debug.print: '
-debug.print:  
-debug.print: 18
-debug.print: :
-debug.print: '
-debug.print: 
-
-debug.print: '
-debug.print:  
-debug.print: 
-debug.print: via iteration and `debugPrintChar` (Unicode): #4
-debug.print: 1
-debug.print: :
-debug.print: '
-debug.print: 🙈
-debug.print: '
-debug.print:  
-debug.print: 2
-debug.print: :
-debug.print: '
-debug.print: 🎸
-debug.print: '
-debug.print:  
-debug.print: 3
-debug.print: :
-debug.print: '
-debug.print: 😋
-debug.print: '
-debug.print:  
-debug.print: 
-debug.print: Приветствую, мир!
-
-debug.print: 
-debug.print: П
-debug.print: 
-debug.print: 🙈
-debug.print: 
-<= replied: ()
diff --git a/test/run-drun/ok/text-lowercase.ic-ref-run.ok b/test/run-drun/ok/text-lowercase.ic-ref-run.ok
deleted file mode 100644
index b2ac13446ca..00000000000
--- a/test/run-drun/ok/text-lowercase.ic-ref-run.ok
+++ /dev/null
@@ -1,16 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-debug.print: ABCDCEFGHIJABCDCEFGHIJABCDCEFGHIJABCDCEFGHIJABCDCEFGHIJ 1234 X
-debug.print: abcdcefghijabcdcefghijabcdcefghijabcdcefghijabcdcefghij 1234 x
-debug.print: abcdcefghijabcdcefghijabcdcefghijabcdcefghijabcdcefghij 1234 x
-debug.print: Σ
-debug.print: σ
-debug.print: σ
-debug.print: ὈΔΥΣΣΕΎΣ
-debug.print: ὀδυσσεύς
-debug.print: ὀδυσσεύς
-debug.print: 农历新年
-debug.print: 农历新年
-debug.print: 农历新年
-<= replied: ()
diff --git a/test/run-drun/ok/throw.ic-ref-run.ok b/test/run-drun/ok/throw.ic-ref-run.ok
deleted file mode 100644
index 005291cbf38..00000000000
--- a/test/run-drun/ok/throw.ic-ref-run.ok
+++ /dev/null
@@ -1,8 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: t2 ok
-debug.print: t3 ok
-<= replied: ()
diff --git a/test/run-drun/ok/throw.tc.ok b/test/run-drun/ok/throw.tc.ok
new file mode 100644
index 00000000000..4f8e30d6174
--- /dev/null
+++ b/test/run-drun/ok/throw.tc.ok
@@ -0,0 +1 @@
+throw.mo:38.19-38.22: warning [M0194], unused identifier sys (delete or rename to wildcard `_` or `_sys`)
diff --git a/test/run-drun/ok/time.ic-ref-run.ok b/test/run-drun/ok/time.ic-ref-run.ok
deleted file mode 100644
index 9cb02531277..00000000000
--- a/test/run-drun/ok/time.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-<= replied: ()
diff --git a/test/run-drun/ok/timer-cancel.ic-ref-run.ok b/test/run-drun/ok/timer-cancel.ic-ref-run.ok
deleted file mode 100644
index 6f13f814197..00000000000
--- a/test/run-drun/ok/timer-cancel.ic-ref-run.ok
+++ /dev/null
@@ -1,8 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: CANCELLING!
-debug.print: {attempts = 200; counter = 4}
-<= replied: ()
diff --git a/test/run-drun/ok/timer-default.ic-ref-run.ok b/test/run-drun/ok/timer-default.ic-ref-run.ok
deleted file mode 100644
index ee85f5ca4c7..00000000000
--- a/test/run-drun/ok/timer-default.ic-ref-run.ok
+++ /dev/null
@@ -1,8 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: YEP!
-debug.print: {count = 1}
-<= replied: ()
diff --git a/test/run-drun/ok/timer-initial.ic-ref-run.ok b/test/run-drun/ok/timer-initial.ic-ref-run.ok
deleted file mode 100644
index d3a9131a252..00000000000
--- a/test/run-drun/ok/timer-initial.ic-ref-run.ok
+++ /dev/null
@@ -1,7 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: {count = 1}
-<= replied: ()
diff --git a/test/run-drun/ok/timer-initial.tc.ok b/test/run-drun/ok/timer-initial.tc.ok
new file mode 100644
index 00000000000..2ee81378006
--- /dev/null
+++ b/test/run-drun/ok/timer-initial.tc.ok
@@ -0,0 +1 @@
+timer-initial.mo:7.21-7.35: warning [M0194], unused identifier setGlobalTimer (delete or rename to wildcard `_` or `_setGlobalTimer`)
diff --git a/test/run-drun/ok/timer-trap.ic-ref-run.ok b/test/run-drun/ok/timer-trap.ic-ref-run.ok
deleted file mode 100644
index bc9aaed4ee6..00000000000
--- a/test/run-drun/ok/timer-trap.ic-ref-run.ok
+++ /dev/null
@@ -1,11 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: YEP!
-debug.print: EEK!
-debug.print: BEAM!
-debug.print: YEP!
-debug.print: {count = 3}
-<= replied: ()
diff --git a/test/run-drun/ok/timer-zero-recur.ic-ref-run.ok b/test/run-drun/ok/timer-zero-recur.ic-ref-run.ok
deleted file mode 100644
index 15eab363945..00000000000
--- a/test/run-drun/ok/timer-zero-recur.ic-ref-run.ok
+++ /dev/null
@@ -1,8 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: YEP!
-debug.print: {count = 2}
-<= replied: ()
diff --git a/test/run-drun/ok/timer.ic-ref-run.ok b/test/run-drun/ok/timer.ic-ref-run.ok
deleted file mode 100644
index 144ec694ca3..00000000000
--- a/test/run-drun/ok/timer.ic-ref-run.ok
+++ /dev/null
@@ -1,12 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: YEP!
-debug.print: DIM!
-debug.print: ROOK!
-debug.print: BATT!
-debug.print: BATT!
-debug.print: {count = 5}
-<= replied: ()
diff --git a/test/run-drun/ok/timer.tc.ok b/test/run-drun/ok/timer.tc.ok
new file mode 100644
index 00000000000..a45b1fa94fd
--- /dev/null
+++ b/test/run-drun/ok/timer.tc.ok
@@ -0,0 +1,4 @@
+timer.mo:18.21-18.35: warning [M0194], unused identifier setGlobalTimer (delete or rename to wildcard `_` or `_setGlobalTimer`)
+timer.mo:31.10-31.13: warning [M0194], unused identifier id1 (delete or rename to wildcard `_` or `_id1`)
+timer.mo:32.10-32.13: warning [M0194], unused identifier id2 (delete or rename to wildcard `_` or `_id2`)
+timer.mo:33.10-33.13: warning [M0194], unused identifier id3 (delete or rename to wildcard `_` or `_id3`)
diff --git a/test/run-drun/ok/transpose.ic-ref-run.ok b/test/run-drun/ok/transpose.ic-ref-run.ok
deleted file mode 100644
index ffd7e794b3f..00000000000
--- a/test/run-drun/ok/transpose.ic-ref-run.ok
+++ /dev/null
@@ -1,7 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: All good
-<= replied: ()
diff --git a/test/run-drun/ok/tuple-message.ic-ref-run.ok b/test/run-drun/ok/tuple-message.ic-ref-run.ok
deleted file mode 100644
index 31347162f29..00000000000
--- a/test/run-drun/ok/tuple-message.ic-ref-run.ok
+++ /dev/null
@@ -1,22 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; amount = null})
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-debug.print: f
-debug.print: g
-debug.print: i
-debug.print: f
-debug.print: f
-debug.print: g
-debug.print: i
-debug.print: f
-debug.print: fp
-debug.print: gp
-debug.print: i
-debug.print: fp
-debug.print: fp
-debug.print: gp
-debug.print: i
-debug.print: fp
-<= replied: ()
diff --git a/test/run-drun/ok/type-components.ic-ref-run.ok b/test/run-drun/ok/type-components.ic-ref-run.ok
deleted file mode 100644
index b0a1c8855ef..00000000000
--- a/test/run-drun/ok/type-components.ic-ref-run.ok
+++ /dev/null
@@ -1,8 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-debug.print: {f = +1}
-debug.print: {f = +1}
-<= replied: ()
-=> update go()
-<= replied: ()
diff --git a/test/run-drun/ok/type-components.tc.ok b/test/run-drun/ok/type-components.tc.ok
new file mode 100644
index 00000000000..914497f87b8
--- /dev/null
+++ b/test/run-drun/ok/type-components.tc.ok
@@ -0,0 +1,4 @@
+type-components.mo:14.7-14.10: warning [M0194], unused identifier eqC (delete or rename to wildcard `_` or `_eqC`)
+type-components.mo:15.7-15.10: warning [M0194], unused identifier eqD (delete or rename to wildcard `_` or `_eqD`)
+type-components.mo:22.17-22.18: warning [M0194], unused identifier c (delete or rename to wildcard `_` or `_c`)
+type-components.mo:24.17-24.18: warning [M0194], unused identifier d (delete or rename to wildcard `_` or `_d`)
diff --git a/test/run-drun/ok/type-lub.ic-ref-run.ok b/test/run-drun/ok/type-lub.ic-ref-run.ok
deleted file mode 100644
index 9cb02531277..00000000000
--- a/test/run-drun/ok/type-lub.ic-ref-run.ok
+++ /dev/null
@@ -1,6 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update go()
-<= replied: ()
diff --git a/test/run-drun/ok/type-lub.tc.ok b/test/run-drun/ok/type-lub.tc.ok
new file mode 100644
index 00000000000..63a34eee2ce
--- /dev/null
+++ b/test/run-drun/ok/type-lub.tc.ok
@@ -0,0 +1,36 @@
+type-lub.mo:3.9-3.13: warning [M0194], unused identifier opts (delete or rename to wildcard `_` or `_opts`)
+type-lub.mo:4.9-4.14: warning [M0194], unused identifier nulls (delete or rename to wildcard `_` or `_nulls`)
+type-lub.mo:6.9-6.26: warning [M0194], unused identifier incompatible_objs (delete or rename to wildcard `_` or `_incompatible_objs`)
+type-lub.mo:7.9-7.13: warning [M0194], unused identifier objs (delete or rename to wildcard `_` or `_objs`)
+type-lub.mo:9.9-9.13: warning [M0194], unused identifier tups (delete or rename to wildcard `_` or `_tups`)
+type-lub.mo:10.9-10.14: warning [M0194], unused identifier tup1s (delete or rename to wildcard `_` or `_tup1s`)
+type-lub.mo:12.9-12.13: warning [M0194], unused identifier arrs (delete or rename to wildcard `_` or `_arrs`)
+type-lub.mo:14.9-14.27: warning [M0194], unused identifier incompatible_funcs (delete or rename to wildcard `_` or `_incompatible_funcs`)
+type-lub.mo:15.38-15.39: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+type-lub.mo:18.9-18.19: warning [M0194], unused identifier poly_funcs (delete or rename to wildcard `_` or `_poly_funcs`)
+type-lub.mo:19.33-19.34: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+type-lub.mo:22.9-22.20: warning [M0194], unused identifier poly_funcs2 (delete or rename to wildcard `_` or `_poly_funcs2`)
+type-lub.mo:23.34-23.35: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+type-lub.mo:26.9-26.20: warning [M0194], unused identifier poly_funcs3 (delete or rename to wildcard `_` or `_poly_funcs3`)
+type-lub.mo:26.47-26.48: warning [M0194], unused identifier b (delete or rename to wildcard `_` or `_b`)
+type-lub.mo:27.47-27.48: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+type-lub.mo:30.9-30.14: warning [M0194], unused identifier funcs (delete or rename to wildcard `_` or `_funcs`)
+type-lub.mo:31.25-31.26: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+type-lub.mo:34.9-34.22: warning [M0194], unused identifier variant_funcs (delete or rename to wildcard `_` or `_variant_funcs`)
+type-lub.mo:39.9-39.17: warning [M0194], unused identifier mut_arrs (delete or rename to wildcard `_` or `_mut_arrs`)
+type-lub.mo:44.9-44.16: warning [M0194], unused identifier shareds (delete or rename to wildcard `_` or `_shareds`)
+type-lub.mo:45.9-45.17: warning [M0194], unused identifier shared2s (delete or rename to wildcard `_` or `_shared2s`)
+type-lub.mo:47.9-47.21: warning [M0194], unused identifier shared_funcs (delete or rename to wildcard `_` or `_shared_funcs`)
+type-lub.mo:48.32-48.33: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+type-lub.mo:52.10-52.12: warning [M0194], unused identifier c0 (delete or rename to wildcard `_` or `_c0`)
+type-lub.mo:53.9-53.12: warning [M0194], unused identifier c1s (delete or rename to wildcard `_` or `_c1s`)
+type-lub.mo:62.10-62.11: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-lub.mo:69.10-69.12: warning [M0194], unused identifier f1 (delete or rename to wildcard `_` or `_f1`)
+type-lub.mo:79.10-79.11: warning [M0194], unused identifier g (delete or rename to wildcard `_` or `_g`)
+type-lub.mo:90.10-90.12: warning [M0194], unused identifier v0 (delete or rename to wildcard `_` or `_v0`)
+type-lub.mo:96.10-96.12: warning [M0194], unused identifier g0 (delete or rename to wildcard `_` or `_g0`)
+type-lub.mo:102.10-102.12: warning [M0194], unused identifier k0 (delete or rename to wildcard `_` or `_k0`)
+type-lub.mo:108.10-108.12: warning [M0194], unused identifier k1 (delete or rename to wildcard `_` or `_k1`)
+type-lub.mo:121.10-121.12: warning [M0194], unused identifier f0 (delete or rename to wildcard `_` or `_f0`)
+type-lub.mo:126.10-126.13: warning [M0194], unused identifier f12 (delete or rename to wildcard `_` or `_f12`)
+type-lub.mo:131.10-131.12: warning [M0194], unused identifier f2 (delete or rename to wildcard `_` or `_f2`)
diff --git a/test/run-drun/ok/unavailable-constructor.tc.ok b/test/run-drun/ok/unavailable-constructor.tc.ok
new file mode 100644
index 00000000000..76a50669881
--- /dev/null
+++ b/test/run-drun/ok/unavailable-constructor.tc.ok
@@ -0,0 +1,2 @@
+unavailable-constructor.mo:1.6-1.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+unavailable-constructor.mo:7.17-7.21: warning [M0194], unused identifier ctxt (delete or rename to wildcard `_` or `_ctxt`)
diff --git a/test/run-drun/ok/unsupported-more.tc.ok b/test/run-drun/ok/unsupported-more.tc.ok
new file mode 100644
index 00000000000..f83560ea122
--- /dev/null
+++ b/test/run-drun/ok/unsupported-more.tc.ok
@@ -0,0 +1,2 @@
+unsupported-more.mo:2.7-2.14: warning [M0194], unused identifier Counter (delete or rename to wildcard `_` or `_Counter`)
+unsupported-more.mo:8.7-8.21: warning [M0194], unused identifier BadSecondActor (delete or rename to wildcard `_` or `_BadSecondActor`)
diff --git a/test/run-drun/ok/unsupported.tc.ok b/test/run-drun/ok/unsupported.tc.ok
new file mode 100644
index 00000000000..d74613841f0
--- /dev/null
+++ b/test/run-drun/ok/unsupported.tc.ok
@@ -0,0 +1,13 @@
+unsupported.mo:2.7-2.14: warning [M0194], unused identifier Counter (delete or rename to wildcard `_` or `_Counter`)
+unsupported.mo:4.26-4.44: warning [M0194], unused identifier bad_private_shared (delete or rename to wildcard `_` or `_bad_private_shared`)
+unsupported.mo:6.29-6.30: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+unsupported.mo:8.32-8.33: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+unsupported.mo:30.13-30.14: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+unsupported.mo:36.13-36.23: warning [M0194], unused identifier bad_shared (delete or rename to wildcard `_` or `_bad_shared`)
+unsupported.mo:50.15-50.28: warning [M0194], unused identifier BadActorClass (delete or rename to wildcard `_` or `_BadActorClass`)
+unsupported.mo:54.15-54.28: warning [M0194], unused identifier BadActorClass (delete or rename to wildcard `_` or `_BadActorClass`)
+unsupported.mo:54.30-54.31: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+unsupported.mo:58.6-58.23: warning [M0194], unused identifier bad_non_top_actor (delete or rename to wildcard `_` or `_bad_non_top_actor`)
+unsupported.mo:62.7-62.23: warning [M0194], unused identifier bad_nested_actor (delete or rename to wildcard `_` or `_bad_nested_actor`)
+unsupported.mo:66.7-66.21: warning [M0194], unused identifier BadSecondActor (delete or rename to wildcard `_` or `_BadSecondActor`)
+unsupported.mo:69.6-69.20: warning [M0194], unused identifier implicit_async (delete or rename to wildcard `_` or `_implicit_async`)
diff --git a/test/run-drun/ok/unused-actor-class.drun-run.ok b/test/run-drun/ok/unused-actor-class.drun-run.ok
new file mode 100644
index 00000000000..a6f776f43c6
--- /dev/null
+++ b/test/run-drun/ok/unused-actor-class.drun-run.ok
@@ -0,0 +1,2 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/unused-actor-class.tc.ok b/test/run-drun/ok/unused-actor-class.tc.ok
new file mode 100644
index 00000000000..c6cfb01ea0d
--- /dev/null
+++ b/test/run-drun/ok/unused-actor-class.tc.ok
@@ -0,0 +1,5 @@
+unused-actor-class/test-actor-class.mo:1.28-1.48: warning [M0194], unused identifier actorClassParameter1 (delete or rename to wildcard `_` or `_actorClassParameter1`)
+unused-actor-class/test-actor-class.mo:3.9-3.28: warning [M0194], unused identifier actorClassVariable2 (delete or rename to wildcard `_` or `_actorClassVariable2`)
+unused-actor-class/test-actor-class.mo:5.10-5.32: warning [M0194], unused identifier unusedActorClassMethod (delete or rename to wildcard `_` or `_unusedActorClassMethod`)
+unused-actor-class/test-actor-class.mo:5.33-5.43: warning [M0194], unused identifier parameter1 (delete or rename to wildcard `_` or `_parameter1`)
+unused-actor-class/test-actor-class.mo:5.51-5.61: warning [M0194], unused identifier parameter2 (delete or rename to wildcard `_` or `_parameter2`)
diff --git a/test/run-drun/ok/unused-actor-fields.drun-run.ok b/test/run-drun/ok/unused-actor-fields.drun-run.ok
new file mode 100644
index 00000000000..a6f776f43c6
--- /dev/null
+++ b/test/run-drun/ok/unused-actor-fields.drun-run.ok
@@ -0,0 +1,2 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/unused-actor-fields.tc.ok b/test/run-drun/ok/unused-actor-fields.tc.ok
new file mode 100644
index 00000000000..373ed9b3e56
--- /dev/null
+++ b/test/run-drun/ok/unused-actor-fields.tc.ok
@@ -0,0 +1,18 @@
+unused-actor-fields.mo:4.11-4.20: warning [M0194], unused identifier TestClass (delete or rename to wildcard `_` or `_TestClass`)
+unused-actor-fields.mo:4.21-4.36: warning [M0194], unused identifier classParameter1 (delete or rename to wildcard `_` or `_classParameter1`)
+unused-actor-fields.mo:4.44-4.59: warning [M0194], unused identifier classParameter2 (delete or rename to wildcard `_` or `_classParameter2`)
+unused-actor-fields.mo:5.13-5.19: warning [M0194], unused identifier field1 (delete or rename to wildcard `_` or `_field1`)
+unused-actor-fields.mo:7.13-7.19: warning [M0194], unused identifier field3 (delete or rename to wildcard `_` or `_field3`)
+unused-actor-fields.mo:9.14-9.26: warning [M0194], unused identifier unusedMethod (delete or rename to wildcard `_` or `_unusedMethod`)
+unused-actor-fields.mo:9.27-9.43: warning [M0194], unused identifier unusedParameter1 (delete or rename to wildcard `_` or `_unusedParameter1`)
+unused-actor-fields.mo:10.17-10.23: warning [M0194], unused identifier local1 (delete or rename to wildcard `_` or `_local1`)
+unused-actor-fields.mo:14.12-14.22: warning [M0194], unused identifier TestObject (delete or rename to wildcard `_` or `_TestObject`)
+unused-actor-fields.mo:17.13-17.25: warning [M0194], unused identifier objectField3 (delete or rename to wildcard `_` or `_objectField3`)
+unused-actor-fields.mo:18.13-18.25: warning [M0194], unused identifier objectField4 (delete or rename to wildcard `_` or `_objectField4`)
+unused-actor-fields.mo:22.9-22.18: warning [M0194], unused identifier variable2 (delete or rename to wildcard `_` or `_variable2`)
+unused-actor-fields.mo:24.10-24.28: warning [M0194], unused identifier testUnusedFunction (delete or rename to wildcard `_` or `_testUnusedFunction`)
+unused-actor-fields.mo:24.47-24.57: warning [M0194], unused identifier parameter2 (delete or rename to wildcard `_` or `_parameter2`)
+unused-actor-fields.mo:25.13-25.22: warning [M0194], unused identifier variable2 (delete or rename to wildcard `_` or `_variable2`)
+unused-actor-fields.mo:27.13-27.22: warning [M0194], unused identifier variable4 (delete or rename to wildcard `_` or `_variable4`)
+unused-actor-fields.mo:30.17-30.30: warning [M0194], unused identifier localFunction (delete or rename to wildcard `_` or `_localFunction`)
+unused-actor-fields.mo:38.42-38.58: warning [M0194], unused identifier unusedParameter2 (delete or rename to wildcard `_` or `_unusedParameter2`)
diff --git a/test/run-drun/ok/unused-import.drun-run.ok b/test/run-drun/ok/unused-import.drun-run.ok
new file mode 100644
index 00000000000..5bbab1e840c
--- /dev/null
+++ b/test/run-drun/ok/unused-import.drun-run.ok
@@ -0,0 +1,3 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+debug.print: Test
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/unused-import.run-ir.ok b/test/run-drun/ok/unused-import.run-ir.ok
new file mode 100644
index 00000000000..345e6aef713
--- /dev/null
+++ b/test/run-drun/ok/unused-import.run-ir.ok
@@ -0,0 +1 @@
+Test
diff --git a/test/run-drun/ok/unused-import.run-low.ok b/test/run-drun/ok/unused-import.run-low.ok
new file mode 100644
index 00000000000..345e6aef713
--- /dev/null
+++ b/test/run-drun/ok/unused-import.run-low.ok
@@ -0,0 +1 @@
+Test
diff --git a/test/run-drun/ok/unused-import.run.ok b/test/run-drun/ok/unused-import.run.ok
new file mode 100644
index 00000000000..345e6aef713
--- /dev/null
+++ b/test/run-drun/ok/unused-import.run.ok
@@ -0,0 +1 @@
+Test
diff --git a/test/run-drun/ok/unused-import.tc.ok b/test/run-drun/ok/unused-import.tc.ok
new file mode 100644
index 00000000000..3b8dcc99220
--- /dev/null
+++ b/test/run-drun/ok/unused-import.tc.ok
@@ -0,0 +1,11 @@
+unused-actor-class/test-actor-class.mo:1.28-1.48: warning [M0194], unused identifier actorClassParameter1 (delete or rename to wildcard `_` or `_actorClassParameter1`)
+unused-actor-class/test-actor-class.mo:3.9-3.28: warning [M0194], unused identifier actorClassVariable2 (delete or rename to wildcard `_` or `_actorClassVariable2`)
+unused-actor-class/test-actor-class.mo:5.10-5.32: warning [M0194], unused identifier unusedActorClassMethod (delete or rename to wildcard `_` or `_unusedActorClassMethod`)
+unused-actor-class/test-actor-class.mo:5.33-5.43: warning [M0194], unused identifier parameter1 (delete or rename to wildcard `_` or `_parameter1`)
+unused-actor-class/test-actor-class.mo:5.51-5.61: warning [M0194], unused identifier parameter2 (delete or rename to wildcard `_` or `_parameter2`)
+unused-module/test-module.mo:2.9-2.30: warning [M0194], unused identifier unusedModuleVariable1 (delete or rename to wildcard `_` or `_unusedModuleVariable1`)
+unused-module/test-module.mo:4.10-4.29: warning [M0194], unused identifier localModuleFunction (delete or rename to wildcard `_` or `_localModuleFunction`)
+unused-module/test-module.mo:16.12-16.23: warning [M0194], unused identifier localObject (delete or rename to wildcard `_` or `_localObject`)
+unused-import.mo:1.8-1.17: warning [M0194], unused identifier TestActor (delete or rename to wildcard `_` or `_TestActor`)
+unused-import.mo:2.8-2.24: warning [M0194], unused identifier UnusedTestModule (delete or rename to wildcard `_` or `_UnusedTestModule`)
+unused-import.mo:3.22-3.32: warning [M0194], unused identifier Array_init (delete or rename to wildcard `_` or `_Array_init`)
diff --git a/test/run-drun/ok/unused-module.drun-run.ok b/test/run-drun/ok/unused-module.drun-run.ok
new file mode 100644
index 00000000000..a6f776f43c6
--- /dev/null
+++ b/test/run-drun/ok/unused-module.drun-run.ok
@@ -0,0 +1,2 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/unused-module.tc.ok b/test/run-drun/ok/unused-module.tc.ok
new file mode 100644
index 00000000000..66e10fe9272
--- /dev/null
+++ b/test/run-drun/ok/unused-module.tc.ok
@@ -0,0 +1,3 @@
+unused-module/test-module.mo:2.9-2.30: warning [M0194], unused identifier unusedModuleVariable1 (delete or rename to wildcard `_` or `_unusedModuleVariable1`)
+unused-module/test-module.mo:4.10-4.29: warning [M0194], unused identifier localModuleFunction (delete or rename to wildcard `_` or `_localModuleFunction`)
+unused-module/test-module.mo:16.12-16.23: warning [M0194], unused identifier localObject (delete or rename to wildcard `_` or `_localObject`)
diff --git a/test/run-drun/ok/upgrade-hooks.ic-ref-run.ok b/test/run-drun/ok/upgrade-hooks.ic-ref-run.ok
deleted file mode 100644
index 7f381e09b72..00000000000
--- a/test/run-drun/ok/upgrade-hooks.ic-ref-run.ok
+++ /dev/null
@@ -1,45 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-debug.print: init'ed
-<= replied: ()
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-debug.print: init'ed 0
-debug.print: postupgrade 0
-<= replied: ()
-=> query check(1)
-debug.print: a
-<= replied: ()
-=> update inc()
-<= replied: ()
-=> query check(2)
-debug.print: aa
-<= replied: ()
-=> update inc()
-<= replied: ()
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-debug.print: preupgrade 0
-debug.print: init'ed 1
-debug.print: postupgrade 1
-<= replied: ()
-=> query check(3)
-debug.print: 3
-debug.print: aaa
-<= replied: ()
-=> update inc()
-<= replied: ()
-=> query check(4)
-debug.print: 4
-debug.print: aaa
-<= replied: ()
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-debug.print: preupgrade 1
-debug.print: init'ed 2
-debug.print: postupgrade 2
-<= replied: ()
-=> query check(4)
-<= replied: ()
-=> update inc()
-<= replied: ()
-=> query check(5)
-<= replied: ()
diff --git a/test/run-drun/ok/upgrades.ic-ref-run.ok b/test/run-drun/ok/upgrades.ic-ref-run.ok
deleted file mode 100644
index e8c96983fe1..00000000000
--- a/test/run-drun/ok/upgrades.ic-ref-run.ok
+++ /dev/null
@@ -1,61 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-debug.print: init'ed
-<= replied: ()
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-debug.print: init'ed 0
-debug.print: initial version: 2
-<= replied: ()
-=> query check(1)
-debug.print: a
-<= replied: ()
-=> update inc()
-<= replied: ()
-=> query check(2)
-debug.print: aa
-<= replied: ()
-=> update inc()
-<= replied: ()
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-debug.print: init'ed 1
-debug.print: current version: 5
-<= replied: ()
-=> query check(3)
-debug.print: 3
-debug.print: aaa
-<= replied: ()
-=> update inc()
-<= replied: ()
-=> query check(4)
-debug.print: 4
-debug.print: aaa
-<= replied: ()
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-debug.print: init'ed 2
-<= replied: ()
-=> query check(4)
-<= replied: ()
-=> update inc()
-<= replied: ()
-=> query check(5)
-<= replied: ()
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-debug.print: init'ed 3
-<= replied: ()
-=> query check(5)
-<= replied: ()
-=> update inc()
-<= replied: ()
-=> update check(6)
-<= replied: ()
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-debug.print: init'ed 4
-debug.print: timer endpoint in 4
-<= replied: ()
-=> query check(6)
-<= replied: ()
-=> update inc()
-<= replied: ()
-=> query check(7)
-<= replied: ()
diff --git a/test/run-drun/ok/utf8.ic-ref-run.ok b/test/run-drun/ok/utf8.ic-ref-run.ok
deleted file mode 100644
index a9edfd72e49..00000000000
--- a/test/run-drun/ok/utf8.ic-ref-run.ok
+++ /dev/null
@@ -1,10 +0,0 @@
-=> update provisional_create_canister_with_cycles(record {settings = null; qgqjpK = null; amount = null; ddww...
-<= replied: (record {hymijyo = principal "rwlgt-iiaaa-aaaaa-aaaaa-cai"})
-=> update install_code(record {arg = blob ""; kca_xin = blob "\00asm\01\00\00\00\0...
-<= replied: ()
-=> update callshow()
-debug.print: ██    ██
-
-debug.print: ██    ██
-
-<= replied: ("██    ██\n")
diff --git a/test/run-drun/perf.mo b/test/run-drun/perf.mo
index 7544f756cfc..f253f4a0612 100644
--- a/test/run-drun/perf.mo
+++ b/test/run-drun/perf.mo
@@ -9,7 +9,7 @@ actor {
         n-=1;
      };
      let c2 = Prim.performanceCounter(0);
-     Prim.debugPrint(debug_show(c2 - c1));
+     // Prim.debugPrint(debug_show(c2 - c1)); // too noisy for --sanity-checks
      assert (c2 >= c1);
   }
 }
diff --git a/test/run-drun/rand-JIRA-EXC-1318.mo b/test/run-drun/rand-JIRA-EXC-1318.mo
index 7f5313928a9..707a44c4eb5 100644
--- a/test/run-drun/rand-JIRA-EXC-1318.mo
+++ b/test/run-drun/rand-JIRA-EXC-1318.mo
@@ -1,9 +1,7 @@
 // This test exists to verify the fix for
 // https://dfinity.atlassian.net/browse/EXC-1318
 // drun didn't implement raw_rand properly, returning the same bytes each time.
-import Prim "mo:⛔";
-
-actor a {
+actor {
 
   let rand = (actor "aaaaa-aa" : actor { raw_rand : () -> async Blob }).raw_rand;
 
diff --git a/test/run-drun/region0-stable-mem-blob.mo b/test/run-drun/region0-stable-mem-blob.mo
index 9bb09d70d0b..3cc14f7a0c5 100644
--- a/test/run-drun/region0-stable-mem-blob.mo
+++ b/test/run-drun/region0-stable-mem-blob.mo
@@ -19,8 +19,6 @@ actor {
     P.arrayToBlob(a);
   };
 
-  let inc : Nat64 = 8;
-
   var i : Nat64 = 0;
   var size : Nat64 = 0;
   let max = n * 65536;
diff --git a/test/run-drun/region0-stable-mem-custom-max.mo b/test/run-drun/region0-stable-mem-custom-max.mo
index 0cb0f1ce7e2..89f6a7bf67a 100644
--- a/test/run-drun/region0-stable-mem-custom-max.mo
+++ b/test/run-drun/region0-stable-mem-custom-max.mo
@@ -1,5 +1,4 @@
 //MOC-FLAG --stable-regions --max-stable-pages 16384
-import P "mo:⛔";
 import StableMemory "stable-mem/StableMemory";
 
 actor {
diff --git a/test/run-drun/region0-stable-mem-max.mo b/test/run-drun/region0-stable-mem-max.mo
index bf812ea9202..fe34278d6da 100644
--- a/test/run-drun/region0-stable-mem-max.mo
+++ b/test/run-drun/region0-stable-mem-max.mo
@@ -1,5 +1,4 @@
 //MOC-FLAG --stable-regions
-import P "mo:⛔";
 import StableMemory "stable-mem/StableMemory";
 
 actor {
diff --git a/test/run-drun/region0-stable-mem-nat8.mo b/test/run-drun/region0-stable-mem-nat8.mo
index 80d8d7ea62a..cbba0c2baf2 100644
--- a/test/run-drun/region0-stable-mem-nat8.mo
+++ b/test/run-drun/region0-stable-mem-nat8.mo
@@ -2,8 +2,6 @@
 import P "mo:⛔";
 import StableMemory "stable-mem/StableMemory";
 
-import Region "stable-region/Region";
-
 actor {
   stable var n : Nat64 = 0;
   assert (n == StableMemory.size());
diff --git a/test/run-drun/stable-mem-blob.mo b/test/run-drun/stable-mem-blob.mo
index f13fe78fc2f..3b9b45ed70e 100644
--- a/test/run-drun/stable-mem-blob.mo
+++ b/test/run-drun/stable-mem-blob.mo
@@ -17,8 +17,6 @@ actor {
     P.arrayToBlob(a);
   };
 
-  let inc : Nat64 = 8;
-
   var i : Nat64 = 0;
   var size : Nat64 = 0;
   let max = n * 65536;
diff --git a/test/run-drun/stable-mem-custom-max.mo b/test/run-drun/stable-mem-custom-max.mo
index 31084221b95..668226994d0 100644
--- a/test/run-drun/stable-mem-custom-max.mo
+++ b/test/run-drun/stable-mem-custom-max.mo
@@ -1,5 +1,4 @@
 //MOC-FLAG --max-stable-pages 16384
-import P "mo:⛔";
 import StableMemory "stable-mem/StableMemory";
 
 actor {
diff --git a/test/run-drun/stable-mem-max.mo b/test/run-drun/stable-mem-max.mo
index 006ee44b881..cbffb780ffe 100644
--- a/test/run-drun/stable-mem-max.mo
+++ b/test/run-drun/stable-mem-max.mo
@@ -1,4 +1,3 @@
-import P "mo:⛔";
 import StableMemory "stable-mem/StableMemory";
 
 actor {
diff --git a/test/run-drun/stable-mem-nat8.mo b/test/run-drun/stable-mem-nat8.mo
index 990765483fe..9c92127305c 100644
--- a/test/run-drun/stable-mem-nat8.mo
+++ b/test/run-drun/stable-mem-nat8.mo
@@ -1,8 +1,6 @@
 import P "mo:⛔";
 import StableMemory "stable-mem/StableMemory";
 
-import Region "stable-region/Region";
-
 actor {
   stable var n : Nat64 = 0;
   assert (n == StableMemory.size());
diff --git a/test/run-drun/stable-region-blob.mo b/test/run-drun/stable-region-blob.mo
index fcb8c60f771..abc357ce2e8 100644
--- a/test/run-drun/stable-region-blob.mo
+++ b/test/run-drun/stable-region-blob.mo
@@ -22,8 +22,6 @@ actor {
     P.arrayToBlob(a);
   };
 
-  let inc : Nat64 = 8;
-
   var i : Nat64 = 0;
   var size : Nat64 = 0;
   let max = n * 65536;
diff --git a/test/run-drun/stable-regions-are-isolated.mo b/test/run-drun/stable-regions-are-isolated.mo
index 703453e7159..5e8e308d790 100644
--- a/test/run-drun/stable-regions-are-isolated.mo
+++ b/test/run-drun/stable-regions-are-isolated.mo
@@ -3,9 +3,9 @@
 
 import P "mo:⛔";
 import Region "stable-region/Region";
-import Region0 "stable-mem/StableMemory";
 
 actor {
+
   var r0 = Region.new();
   var r1 = Region.new();
   var r2 = Region.new();
@@ -33,7 +33,8 @@ actor {
 
   func blobOfNat64(n : Nat64) : Blob {
     let size = P.nat64ToNat(n);
-    let a = P.Array_tabulate<Nat8>(size, func i { P.natToNat8(i % 256) });
+    var v : Nat8 = 0;
+    let a = P.Array_tabulate<Nat8>(size, func _ { v +%= 1; v }); //<- expensive when i boxed
     P.arrayToBlob(a);
   };
 
@@ -54,6 +55,7 @@ actor {
   assert(Region.loadBlob(r2, 137, P.nat64ToNat(big_len)) == big_blob);
 
   P.debugPrint "success. done.";
+
 }
 
 //SKIP run
diff --git a/test/run-drun/stable-regions-new-each-upgrade.mo b/test/run-drun/stable-regions-new-each-upgrade.mo
index 124f16a80ac..858ec694149 100644
--- a/test/run-drun/stable-regions-new-each-upgrade.mo
+++ b/test/run-drun/stable-regions-new-each-upgrade.mo
@@ -3,7 +3,6 @@
 
 import P "mo:⛔";
 import Region "stable-region/Region";
-import Region0 "stable-mem/StableMemory";
 
 actor {
   stable var n = 0;
diff --git a/test/run-drun/stable-regions-one.mo b/test/run-drun/stable-regions-one.mo
index 9ab1b75c6ce..4e501a87354 100644
--- a/test/run-drun/stable-regions-one.mo
+++ b/test/run-drun/stable-regions-one.mo
@@ -2,7 +2,6 @@
 
 import P "mo:⛔";
 import Region "stable-region/Region";
-import Region0 "stable-mem/StableMemory";
 
 actor {
   stable var r1 = Region.new();
diff --git a/test/run-drun/stable-size-no-overflow.mo b/test/run-drun/stable-size-no-overflow.mo
index 9e29ed42757..7c697fef11d 100644
--- a/test/run-drun/stable-size-no-overflow.mo
+++ b/test/run-drun/stable-size-no-overflow.mo
@@ -9,7 +9,7 @@ actor {
   assert (page.size() == 65536);
 
   stable
-  let a : [Blob] = P.Array_tabulate<Blob>(65536,func _ { page });
+  let _a : [Blob] = P.Array_tabulate<Blob>(65536,func _ { page });
 
   system func preupgrade() {
    P.debugPrint("upgrading...");
diff --git a/test/run-drun/static-gc.mo b/test/run-drun/static-gc.mo
index 094f93a3d85..8e47f1bf523 100644
--- a/test/run-drun/static-gc.mo
+++ b/test/run-drun/static-gc.mo
@@ -1,7 +1,7 @@
 // Tests that GC properly looks through mutable things in global memory 
 // (This uses messages to trigger GC. If we don’t run GC after message, other ways need to be found.)
 
-actor a {
+actor {
   flexible var x = ("Foo", "Bar");
 
   public func foo1() {
diff --git a/test/run-drun/throw-on-async-failure.mo b/test/run-drun/throw-on-async-failure.mo
index c15600af9f2..7643d5e2fb1 100644
--- a/test/run-drun/throw-on-async-failure.mo
+++ b/test/run-drun/throw-on-async-failure.mo
@@ -2,7 +2,7 @@
 // test throw on async failure
 import Prim "mo:⛔";
 
-actor self {
+actor {
 
   func showError(e : Error) : Text = debug_show (Prim.errorCode(e), Prim.errorMessage(e));
 
@@ -68,4 +68,4 @@ actor self {
 //SKIP run-low
 //SKIP ic-ref-run
 
-//await a.go(); //OR-CALL ingress go "DIDL\x00\x00"
+//CALL ingress go "DIDL\x00\x00"
diff --git a/test/run-drun/throw-on-await-failure.mo b/test/run-drun/throw-on-await-failure.mo
index 22c974c7158..23322639f13 100644
--- a/test/run-drun/throw-on-await-failure.mo
+++ b/test/run-drun/throw-on-await-failure.mo
@@ -1,14 +1,13 @@
 //MOC-NO-FORCE-GC
 import Prim "mo:⛔";
 // test throw on await of completed future error
-actor self {
+actor {
 
   func showError(e : Error) : Text = debug_show (Prim.errorCode(e), Prim.errorMessage(e));
 
   let MAX_SELF_QUEUE_CAPACITY = 500;
   let PRED_MAX_SELF_QUEUE_CAPACITY = MAX_SELF_QUEUE_CAPACITY - 1 : Nat;
-  let DOUBLE_CAPACITY = 2 * MAX_SELF_QUEUE_CAPACITY;
-
+  
   let raw_rand = (actor "aaaaa-aa" : actor { raw_rand : () -> async Blob }).raw_rand;
 
   public func request() : async () {
@@ -78,4 +77,4 @@ actor self {
 //SKIP run-low
 //SKIP ic-ref-run
 
-//await a.go(); //OR-CALL ingress go "DIDL\x00\x00"
+//CALL ingress go "DIDL\x00\x00"
diff --git a/test/run-drun/throw-on-call-raw-failure.mo b/test/run-drun/throw-on-call-raw-failure.mo
index 3c64c71d8be..cd674cfc958 100644
--- a/test/run-drun/throw-on-call-raw-failure.mo
+++ b/test/run-drun/throw-on-call-raw-failure.mo
@@ -8,7 +8,6 @@ actor self {
   func showError(e : Error) : Text = debug_show (Prim.errorCode(e), Prim.errorMessage(e));
 
   let MAX_SELF_QUEUE_CAPACITY = 500;
-  let PRED_MAX_SELF_QUEUE_CAPACITY = MAX_SELF_QUEUE_CAPACITY - 1 : Nat;
   let DOUBLE_CAPACITY = 2 * MAX_SELF_QUEUE_CAPACITY;
 
   let raw_rand = (actor "aaaaa-aa" : actor { raw_rand : () -> async Blob }).raw_rand;
@@ -85,4 +84,4 @@ actor self {
 //SKIP run-low
 //SKIP ic-ref-run
 
-//await a.go(); //OR-CALL ingress go "DIDL\x00\x00"
+//await self.go(); //OR-CALL ingress go "DIDL\x00\x00"
diff --git a/test/run-drun/throw-on-local-failure.mo b/test/run-drun/throw-on-local-failure.mo
index dae09406f66..86432c27f32 100644
--- a/test/run-drun/throw-on-local-failure.mo
+++ b/test/run-drun/throw-on-local-failure.mo
@@ -2,7 +2,7 @@
 // test throw on local async call failure
 import Prim "mo:⛔";
 
-actor self {
+actor {
 
   func showError(e : Error) : Text = debug_show (Prim.errorCode(e), Prim.errorMessage(e));
 
@@ -72,4 +72,4 @@ actor self {
 //SKIP run-low
 //SKIP ic-ref-run
 
-//await a.go(); //OR-CALL ingress go "DIDL\x00\x00"
+//CALL ingress go "DIDL\x00\x00"
diff --git a/test/run-drun/throw-on-oneway-failure.mo b/test/run-drun/throw-on-oneway-failure.mo
index ced40c79598..321977ca1de 100644
--- a/test/run-drun/throw-on-oneway-failure.mo
+++ b/test/run-drun/throw-on-oneway-failure.mo
@@ -1,7 +1,7 @@
 //MOC-NO-FORCE-GC
 import Prim "mo:⛔";
 // test throw on oneway call failure
-actor self {
+actor {
 
   func showError(e : Error) : Text = debug_show (Prim.errorCode(e), Prim.errorMessage(e));
 
@@ -70,4 +70,4 @@ actor self {
 //SKIP run-low
 //SKIP ic-ref-run
 
-//await a.go(); //OR-CALL ingress go "DIDL\x00\x00"
+//CALL ingress go "DIDL\x00\x00"
diff --git a/test/run-drun/throw-on-send-failure.mo b/test/run-drun/throw-on-send-failure.mo
index 425aecbad2b..6707322d200 100644
--- a/test/run-drun/throw-on-send-failure.mo
+++ b/test/run-drun/throw-on-send-failure.mo
@@ -1,7 +1,7 @@
 //MOC-NO-FORCE-GC
 import Prim "mo:⛔";
 // test throw on send failure
-actor self {
+actor {
 
   func showError(e : Error) : Text = debug_show (Prim.errorCode(e), Prim.errorMessage(e));
 
@@ -69,4 +69,4 @@ actor self {
 //SKIP run-low
 //SKIP ic-ref-run
 
-//await a.go(); //OR-CALL ingress go "DIDL\x00\x00"
+//CALL ingress go "DIDL\x00\x00"
diff --git a/test/run-drun/timer-cancel.mo b/test/run-drun/timer-cancel.mo
index 64b2753ee2f..4f8c5f0ccdc 100644
--- a/test/run-drun/timer-cancel.mo
+++ b/test/run-drun/timer-cancel.mo
@@ -1,4 +1,4 @@
-import { debugPrint; error; setTimer; cancelTimer } = "mo:⛔";
+import { debugPrint; setTimer; cancelTimer } = "mo:⛔";
 
 actor {
   var counter = 0;
diff --git a/test/run-drun/trap-on-async-failure.mo b/test/run-drun/trap-on-async-failure.mo
index 8b2e303c477..f901a18057b 100644
--- a/test/run-drun/trap-on-async-failure.mo
+++ b/test/run-drun/trap-on-async-failure.mo
@@ -2,12 +2,11 @@
 // legacy: trap on async failure
 import Prim "mo:⛔";
 
-actor self {
+actor {
 
   func showError(e : Error) : Text = debug_show (Prim.errorCode(e), Prim.errorMessage(e));
 
   let MAX_SELF_QUEUE_CAPACITY = 500;
-  let PRED_MAX_SELF_QUEUE_CAPACITY = MAX_SELF_QUEUE_CAPACITY - 1 : Nat;
   let DOUBLE_CAPACITY = 2 * MAX_SELF_QUEUE_CAPACITY;
 
   let raw_rand = (actor "aaaaa-aa" : actor { raw_rand : () -> async Blob }).raw_rand;
@@ -73,4 +72,4 @@ actor self {
 //SKIP run-low
 //SKIP ic-ref-run
 
-//await a.go(); //OR-CALL ingress go "DIDL\x00\x00"
+//CALL ingress go "DIDL\x00\x00"
diff --git a/test/run-drun/trap-on-await-failure.mo b/test/run-drun/trap-on-await-failure.mo
index b58892515fe..215001f4e23 100644
--- a/test/run-drun/trap-on-await-failure.mo
+++ b/test/run-drun/trap-on-await-failure.mo
@@ -2,13 +2,12 @@
 // legacy: trap on await of completed future failure
 import Prim "mo:⛔";
 
-actor self {
+actor {
 
   func showError(e : Error) : Text = debug_show (Prim.errorCode(e), Prim.errorMessage(e));
 
   let MAX_SELF_QUEUE_CAPACITY = 500;
   let PRED_MAX_SELF_QUEUE_CAPACITY = MAX_SELF_QUEUE_CAPACITY - 1 : Nat;
-  let DOUBLE_CAPACITY = 2 * MAX_SELF_QUEUE_CAPACITY;
 
   let raw_rand = (actor "aaaaa-aa" : actor { raw_rand : () -> async Blob }).raw_rand;
 
@@ -78,4 +77,4 @@ actor self {
 //SKIP run-low
 //SKIP ic-ref-run
 
-//await a.go(); //OR-CALL ingress go "DIDL\x00\x00"
+//CALL ingress go "DIDL\x00\x00"
diff --git a/test/run-drun/trap-on-call-raw-failure.mo b/test/run-drun/trap-on-call-raw-failure.mo
index 993b5dea591..5d4f6e879b4 100644
--- a/test/run-drun/trap-on-call-raw-failure.mo
+++ b/test/run-drun/trap-on-call-raw-failure.mo
@@ -8,7 +8,6 @@ actor self {
   func showError(e : Error) : Text = debug_show (Prim.errorCode(e), Prim.errorMessage(e));
 
   let MAX_SELF_QUEUE_CAPACITY = 500;
-  let PRED_MAX_SELF_QUEUE_CAPACITY = MAX_SELF_QUEUE_CAPACITY - 1 : Nat;
   let DOUBLE_CAPACITY = 2 * MAX_SELF_QUEUE_CAPACITY;
 
   let raw_rand = (actor "aaaaa-aa" : actor { raw_rand : () -> async Blob }).raw_rand;
@@ -87,4 +86,4 @@ actor self {
 //SKIP run-low
 //SKIP ic-ref-run
 
-//await a.go(); //OR-CALL ingress go "DIDL\x00\x00"
+//await self.go(); //OR-CALL ingress go "DIDL\x00\x00"
diff --git a/test/run-drun/trap-on-local-failure.mo b/test/run-drun/trap-on-local-failure.mo
index 2fceccfd3a3..695365cd4c9 100644
--- a/test/run-drun/trap-on-local-failure.mo
+++ b/test/run-drun/trap-on-local-failure.mo
@@ -2,7 +2,7 @@
 // legacy: trap on local send failure
 import Prim "mo:⛔";
 
-actor self {
+actor {
 
   func showError(e : Error) : Text = debug_show (Prim.errorCode(e), Prim.errorMessage(e));
 
@@ -74,4 +74,4 @@ actor self {
 //SKIP run-low
 //SKIP ic-ref-run
 
-//await a.go(); //OR-CALL ingress go "DIDL\x00\x00"
+//CALL ingress go "DIDL\x00\x00"
diff --git a/test/run-drun/trap-on-oneway-failure.mo b/test/run-drun/trap-on-oneway-failure.mo
index 72243520a94..6cfa71dada2 100644
--- a/test/run-drun/trap-on-oneway-failure.mo
+++ b/test/run-drun/trap-on-oneway-failure.mo
@@ -2,7 +2,7 @@
 // legacy: test oneway sends never trap (even on ic0.perform_call error)
 import Prim "mo:⛔";
 
-actor self {
+actor {
 
   func showError(e : Error) : Text = debug_show (Prim.errorCode(e), Prim.errorMessage(e));
 
@@ -70,4 +70,4 @@ actor self {
 //SKIP run-low
 //SKIP ic-ref-run
 
-//await a.go(); //OR-CALL ingress go "DIDL\x00\x00"
+//CALL ingress go "DIDL\x00\x00"
diff --git a/test/run-drun/trap-on-send-failure.mo b/test/run-drun/trap-on-send-failure.mo
index 6d06d29df19..5abec132a95 100644
--- a/test/run-drun/trap-on-send-failure.mo
+++ b/test/run-drun/trap-on-send-failure.mo
@@ -2,12 +2,11 @@
 // legacy: test trap on send failure
 import Prim "mo:⛔";
 
-actor self {
+actor {
 
   func showError(e : Error) : Text = debug_show (Prim.errorCode(e), Prim.errorMessage(e));
 
   let MAX_SELF_QUEUE_CAPACITY = 500;
-  let PRED_MAX_SELF_QUEUE_CAPACITY = MAX_SELF_QUEUE_CAPACITY - 1 : Nat;
   let DOUBLE_CAPACITY = 2 * MAX_SELF_QUEUE_CAPACITY;
 
   let raw_rand = (actor "aaaaa-aa" : actor { raw_rand : () -> async Blob }).raw_rand;
@@ -69,4 +68,4 @@ actor self {
 //SKIP run-low
 //SKIP ic-ref-run
 
-//await a.go(); //OR-CALL ingress go "DIDL\x00\x00"
+//CALL ingress go "DIDL\x00\x00"
diff --git a/test/run-drun/unused-actor-class.mo b/test/run-drun/unused-actor-class.mo
new file mode 100644
index 00000000000..ec018f35fce
--- /dev/null
+++ b/test/run-drun/unused-actor-class.mo
@@ -0,0 +1,7 @@
+import TestActor "unused-actor-class/test-actor-class";
+
+actor {
+    public func test(): async() {
+        ignore await TestActor.TestActorClass(1);
+    };
+};
diff --git a/test/run-drun/unused-actor-class/test-actor-class.mo b/test/run-drun/unused-actor-class/test-actor-class.mo
new file mode 100644
index 00000000000..3d0ddfa9201
--- /dev/null
+++ b/test/run-drun/unused-actor-class/test-actor-class.mo
@@ -0,0 +1,11 @@
+actor class TestActorClass(actorClassParameter1 : Nat) {
+    var actorClassVariable1 = 0;
+    var actorClassVariable2 = "TEST";
+
+    func unusedActorClassMethod(parameter1 : Nat, parameter2 : Int) {
+        actorClassVariable1 := 1;
+    };
+
+    public func publicActorClassMethod() : async() {
+    };
+};
diff --git a/test/run-drun/unused-actor-fields.mo b/test/run-drun/unused-actor-fields.mo
new file mode 100644
index 00000000000..1b181c68d48
--- /dev/null
+++ b/test/run-drun/unused-actor-fields.mo
@@ -0,0 +1,40 @@
+actor {
+    let _noUnusedWarning = ();
+
+    class TestClass(classParameter1 : Nat, classParameter2 : Int) {
+        let field1 = 1;
+        var field2 = 2;
+        var field3 = field2;
+
+        func unusedMethod(unusedParameter1 : Any) {
+            let local1 = 0;
+        };
+    };
+
+    object TestObject {
+        let objectField1 = 1;
+        var objectField2 = 2;
+        let objectField3 = objectField1;
+        var objectField4 = objectField2;
+    };
+
+    var variable1 = 0;
+    var variable2 = "TEST";
+
+    func testUnusedFunction(parameter1 : Nat, parameter2 : Int) {
+        var variable2 = 2;
+        var variable3 = 3;
+        let variable4 = 4;
+        var variable5 = 5;
+        if (variable1 == 0 and variable3 == 3) {
+            let localFunction = func() {
+                let variable2 = parameter1;
+                variable5 *= variable2;
+            };
+        };
+    };
+
+    public func publicActorFunction(): async() {};
+    public func otherPublicActorFunction(unusedParameter2: Text) {
+    };
+};
diff --git a/test/run-drun/unused-import.mo b/test/run-drun/unused-import.mo
new file mode 100644
index 00000000000..803004dfd79
--- /dev/null
+++ b/test/run-drun/unused-import.mo
@@ -0,0 +1,7 @@
+import TestActor "unused-actor-class/test-actor-class";
+import UnusedTestModule "unused-module/test-module";
+import { debugPrint; Array_init } = "mo:prim";
+
+actor {
+    debugPrint("Test");
+};
diff --git a/test/run-drun/unused-module.mo b/test/run-drun/unused-module.mo
new file mode 100644
index 00000000000..5a17a34400c
--- /dev/null
+++ b/test/run-drun/unused-module.mo
@@ -0,0 +1,5 @@
+import TestModule "unused-module/test-module";
+
+actor {
+    TestModule.publicModuleFunction();
+};
diff --git a/test/run-drun/unused-module/test-module.mo b/test/run-drun/unused-module/test-module.mo
new file mode 100644
index 00000000000..f3061249ae7
--- /dev/null
+++ b/test/run-drun/unused-module/test-module.mo
@@ -0,0 +1,18 @@
+module {
+    let unusedModuleVariable1 = 1;
+
+    func localModuleFunction() {
+
+    };
+
+    public func publicModuleFunction() {
+
+    };
+
+    public object publicObject {
+        public let publicObjectField = 0;
+    };
+
+    object localObject {
+    }
+}
diff --git a/test/run.sh b/test/run.sh
index 19ac635b72a..106759308bd 100755
--- a/test/run.sh
+++ b/test/run.sh
@@ -89,9 +89,9 @@ function normalize () {
     sed -e 's/^  \(         [0-9]\+:\).*!/\1 /g' | # wasmtime backtrace locations (later version)
     sed -e 's/wasm `unreachable` instruction executed/unreachable/g' | # cross-version normalisation
     sed -e 's/Ignore Diff:.*/Ignore Diff: (ignored)/ig' \
-        -e 's/Motoko (source .*)/Motoko (source XXX)/ig' \
-        -e 's/Motoko [^ ]* (source .*)/Motoko (source XXX)/ig' \
+        -e 's/Motoko compiler (source .*)/Motoko compiler (source XXX)/ig' \
         -e 's/Motoko compiler [^ ]* (source .*)/Motoko compiler (source XXX)/ig' |
+
     # Normalize canister id prefixes and timestamps in debug prints
     sed -e 's/\[Canister [0-9a-z\-]*\]/debug.print:/g' \
         -e 's/^20.*UTC: debug.print:/debug.print:/g' |
@@ -412,8 +412,8 @@ do
         then
            if [ -n "$PERF_OUT" ]
            then
-             wasm-strip $out/$base.wasm
-             echo "size/$base;$(stat --format=%s $out/$base.wasm)" >> $PERF_OUT
+             wasm-strip $out/$base.wasm -o $out/$base.wasm.strip
+             echo "size/$base;$(stat --format=%s $out/$base.wasm.strip)" >> $PERF_OUT
            fi
         fi
 
diff --git a/test/run/array-iter-max.mo b/test/run/array-iter-max.mo
new file mode 100644
index 00000000000..23646260319
--- /dev/null
+++ b/test/run/array-iter-max.mo
@@ -0,0 +1,23 @@
+import Prim "mo:⛔";
+// test we can iterate over vals and keys of largest array
+let max_size = 2**29; // maximum array size
+let a = Prim.Array_tabulate<Nat>(max_size,func i = i+1);
+var c = 0;
+for (i in a.vals()) {
+  assert i == c+1; c += 1;
+}
+;
+assert c == max_size;
+Prim.debugPrint(debug_show c);
+var d = 0;
+for (k in a.keys()) {
+  assert k == d; d += 1;
+};
+assert d == max_size;
+Prim.debugPrint(debug_show d);
+
+// Prim.Array_tabulate<Nat>(max_size+1,func i = i+1); // should trap, but mangled stacktrace is noisy for testing
+
+//SKIP run
+//SKIP run-ir
+//SKIP run-low
diff --git a/test/run/idl-ops.mo b/test/run/idl-ops.mo
index e149508319c..ebcb10a4f0c 100644
--- a/test/run/idl-ops.mo
+++ b/test/run/idl-ops.mo
@@ -50,7 +50,7 @@ assert((?arrayNat) == deserArrayInt (serArrayInt arrayNat));
 assert(null == deserArrayNat (serArrayInt arrayInt));
 assert((?arrayInt) == deserArrayInt (serArrayInt arrayInt));
 let heapDifference = Prim.rts_heap_size() : Int - started_with;
-assert(heapDifference <= 30_000);
+assert(heapDifference <= 40_000);
 
 //SKIP run
 //SKIP run-ir
diff --git a/test/run/idl.mo b/test/run/idl.mo
index 2c906de95ba..e4ca01f179b 100644
--- a/test/run/idl.mo
+++ b/test/run/idl.mo
@@ -44,9 +44,8 @@ assert(arrayNat == deserArrayNat (serArrayNat arrayNat));
 assert(arrayNat == deserArrayInt (serArrayNat arrayNat));
 assert(arrayNat == deserArrayInt (serArrayInt arrayNat));
 assert(arrayInt == deserArrayInt (serArrayInt arrayInt));
-
 let heapDifference = Prim.rts_heap_size() : Int - started_with;
-assert(heapDifference == 19_704);
+assert(heapDifference == 20_412);  
 
 //SKIP run
 //SKIP run-ir
diff --git a/test/run/if-swap.mo b/test/run/if-swap.mo
index bb3dcff0a59..e68e76f5903 100644
--- a/test/run/if-swap.mo
+++ b/test/run/if-swap.mo
@@ -3,10 +3,10 @@ func wantSeeSwap(x : Bool) : Nat =
 
 ignore(wantSeeSwap(true));
 
-// CHECK-LABEL: (func $wantSeeSwap
-// CHECK-NEXT: local.get $x
-// CHECK-NEXT: if (result i32)
-// CHECK-NEXT: i32.const 50
-// CHECK-NEXT: else
-// CHECK-NEXT: i32.const 84
+// FHECK-LABEL: (func $wantSeeSwap
+// FHECK-NEXT: local.get $x
+// FHECK-NEXT: if (result i32)
+// FHECK-NEXT: i32.const 50
+// FHECK-NEXT: else
+// FHECK-NEXT: i32.const 84
 
diff --git a/test/run/issue1356.mo b/test/run/issue1356.mo
index 088f038eed8..1e03d16e41b 100644
--- a/test/run/issue1356.mo
+++ b/test/run/issue1356.mo
@@ -1,12 +1,12 @@
-// CHECK-LABEL: (func $init
+// FHECK-LABEL: (func $init
 
 func matchNat(n : Nat) : Bool =
          switch n { case 1073741823 true
                   ; case _ false };
-// CHECK-LABEL: (func $matchNat
-// CHECK:        local.get $switch_in
-// CHECK-NEXT:   i32.const 2147483646
-// CHECK-NEXT:   call $B_eq
+// FHECK-LABEL: (func $matchNat
+// FHECK:        local.get $switch_in
+// FHECK-NEXT:   i32.const 2147483646
+// FHECK-NEXT:   call $B_eq
 
 /*
 
@@ -26,24 +26,24 @@ func matchInt(n : Int) : Bool =
          switch n { case (-1073741824) true
                   ; case 1073741823 true
                   ; case _ false };
-// CHECK-LABEL: (func $matchInt
-// CHECK:        local.get $switch_in
-// CHECK-NEXT:   i32.const -2147483648
-// CHECK-NEXT:   $B_eq
-// CHECK:        local.get $switch_in
-// CHECK-NEXT:   i32.const 2147483646
-// CHECK-NEXT:   $B_eq
+// FHECK-LABEL: (func $matchInt
+// FHECK:        local.get $switch_in
+// FHECK-NEXT:   i32.const -2147483648
+// FHECK-NEXT:   $B_eq
+// FHECK:        local.get $switch_in
+// FHECK-NEXT:   i32.const 2147483646
+// FHECK-NEXT:   $B_eq
 
 func match8(n : Nat8) : Bool = switch n { case 42 true; case _ false };
-// CHECK-LABEL: (func $match8
-// CHECK:        i32.const 704643072
-// CHECK-NEXT:   i32.ne
+// FHECK-LABEL: (func $match8
+// FHECK:        i32.const 704643072
+// FHECK-NEXT:   i32.ne
 // N.B.: 704643072 == 0x2a000000 == 42 << 24
 
 func match16(n : Nat16) : Bool = switch n { case 42 true; case _ false };
-// CHECK-LABEL: (func $match16
-// CHECK:        i32.const 2752512
-// CHECK-NEXT:   i32.ne
+// FHECK-LABEL: (func $match16
+// FHECK:        i32.const 2752512
+// FHECK-NEXT:   i32.ne
 // N.B.: 2752512 == 0x002a0000 == 42 << 16
 
 // NB: reverse order, so that things appear in order
diff --git a/test/run/mut-array-iter-max.mo b/test/run/mut-array-iter-max.mo
new file mode 100644
index 00000000000..c3317a03d30
--- /dev/null
+++ b/test/run/mut-array-iter-max.mo
@@ -0,0 +1,23 @@
+import Prim "mo:⛔";
+// test we can iterate over vals and keys of largest mutable array
+let max_size = 2**29; // maximum array size
+let a = Prim.Array_init<Nat>(max_size, 666);
+var c = 0;
+for (v in a.vals()) {
+ assert v == 666; c += 1;
+}
+;
+assert c == max_size;
+Prim.debugPrint(debug_show c);
+var d = 0;
+for (k in a.keys()) {
+  assert k == d; d += 1;
+};
+assert d == max_size;
+Prim.debugPrint(debug_show d);
+
+// Prim.Array_init<Nat>(max_size+1,0); // should trap, but mangled stacktrace is noisy for testing
+
+//SKIP run
+//SKIP run-ir
+//SKIP run-low
diff --git a/test/run/numeric-ops.mo b/test/run/numeric-ops.mo
index d98c83feaf8..5f2c6c992dc 100644
--- a/test/run/numeric-ops.mo
+++ b/test/run/numeric-ops.mo
@@ -357,6 +357,7 @@ func testNat16(a : Nat16, b : Nat16) : [Nat16] {
   [sum1, sum2, diff1, diff2, prod1, prod2, rat1, rat2, mod1, mod2/*, pow1, pow2*/]
 };
 
+
 func nat16Compare(a : Nat16, b : Nat16) : Bool = a == b;
 
 verify<Nat16>([8, 2, 15, 1, 2/*, 243*/], testNat16(5, 3),
diff --git a/test/run/ok/3121-imp.tc.ok b/test/run/ok/3121-imp.tc.ok
new file mode 100644
index 00000000000..377c81a2ee3
--- /dev/null
+++ b/test/run/ok/3121-imp.tc.ok
@@ -0,0 +1 @@
+3121-imp.mo:1.23-1.27: warning [M0194], unused identifier init (delete or rename to wildcard `_` or `_init`)
diff --git a/test/run/ok/3121.tc.ok b/test/run/ok/3121.tc.ok
new file mode 100644
index 00000000000..46b5415f992
--- /dev/null
+++ b/test/run/ok/3121.tc.ok
@@ -0,0 +1 @@
+3121.mo:1.8-1.11: warning [M0194], unused identifier Dep (delete or rename to wildcard `_` or `_Dep`)
diff --git a/test/run/ok/AST-56.tc.ok b/test/run/ok/AST-56.tc.ok
new file mode 100644
index 00000000000..e8424d14171
--- /dev/null
+++ b/test/run/ok/AST-56.tc.ok
@@ -0,0 +1 @@
+AST-56.mo:6.5-6.7: warning [M0194], unused identifier ps (delete or rename to wildcard `_` or `_ps`)
diff --git a/test/run/ok/M0106.tc.ok b/test/run/ok/M0106.tc.ok
new file mode 100644
index 00000000000..485c7641a5e
--- /dev/null
+++ b/test/run/ok/M0106.tc.ok
@@ -0,0 +1,2 @@
+M0106.mo:1.7-1.8: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+M0106.mo:1.25-1.26: warning [M0194], unused identifier c (delete or rename to wildcard `_` or `_c`)
diff --git a/test/run/ok/aardvark.tc.ok b/test/run/ok/aardvark.tc.ok
new file mode 100644
index 00000000000..3871c0cd442
--- /dev/null
+++ b/test/run/ok/aardvark.tc.ok
@@ -0,0 +1,4 @@
+aardvark.mo:4.10-4.11: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+aardvark.mo:4.20-4.21: warning [M0194], unused identifier b (delete or rename to wildcard `_` or `_b`)
+aardvark.mo:4.29-4.30: warning [M0194], unused identifier t (delete or rename to wildcard `_` or `_t`)
+aardvark.mo:22.7-22.11: warning [M0194], unused identifier ints (delete or rename to wildcard `_` or `_ints`)
diff --git a/test/run/ok/arity_bug.tc.ok b/test/run/ok/arity_bug.tc.ok
new file mode 100644
index 00000000000..e9cdc5fce1c
--- /dev/null
+++ b/test/run/ok/arity_bug.tc.ok
@@ -0,0 +1 @@
+arity_bug.mo:2.5-2.6: warning [M0194], unused identifier g (delete or rename to wildcard `_` or `_g`)
diff --git a/test/run/ok/array-iter-max.wasm-run.ok b/test/run/ok/array-iter-max.wasm-run.ok
new file mode 100644
index 00000000000..db06e61f196
--- /dev/null
+++ b/test/run/ok/array-iter-max.wasm-run.ok
@@ -0,0 +1,2 @@
+536_870_912
+536_870_912
diff --git a/test/run/ok/array-store.tc.ok b/test/run/ok/array-store.tc.ok
new file mode 100644
index 00000000000..2cd352c6f21
--- /dev/null
+++ b/test/run/ok/array-store.tc.ok
@@ -0,0 +1 @@
+array-store.mo:1.8-1.12: warning [M0194], unused identifier Prim (delete or rename to wildcard `_` or `_Prim`)
diff --git a/test/run/ok/array.tc.ok b/test/run/ok/array.tc.ok
index 22364afc6d9..4fd41279006 100644
--- a/test/run/ok/array.tc.ok
+++ b/test/run/ok/array.tc.ok
@@ -1,3 +1,6 @@
 array.mo:89.27-89.64: warning [M0074], this array has type
   [Any]
 because elements have inconsistent types
+array.mo:2.5-2.7: warning [M0194], unused identifier aa (delete or rename to wildcard `_` or `_aa`)
+array.mo:15.5-15.7: warning [M0194], unused identifier bb (delete or rename to wildcard `_` or `_bb`)
+array.mo:89.5-89.18: warning [M0194], unused identifier heterogeneous (delete or rename to wildcard `_` or `_heterogeneous`)
diff --git a/test/run/ok/bad-actor-class.tc.ok b/test/run/ok/bad-actor-class.tc.ok
new file mode 100644
index 00000000000..9fb939a5bb1
--- /dev/null
+++ b/test/run/ok/bad-actor-class.tc.ok
@@ -0,0 +1 @@
+bad-actor-class.mo:1.13-1.14: warning [M0194], unused identifier C (delete or rename to wildcard `_` or `_C`)
diff --git a/test/run/ok/bad-actor.tc.ok b/test/run/ok/bad-actor.tc.ok
new file mode 100644
index 00000000000..d49db54a690
--- /dev/null
+++ b/test/run/ok/bad-actor.tc.ok
@@ -0,0 +1 @@
+bad-actor.mo:1.7-1.8: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
diff --git a/test/run/ok/bad-async-func.tc.ok b/test/run/ok/bad-async-func.tc.ok
new file mode 100644
index 00000000000..f3c683321aa
--- /dev/null
+++ b/test/run/ok/bad-async-func.tc.ok
@@ -0,0 +1 @@
+bad-async-func.mo:1.6-1.7: warning [M0194], unused identifier g (delete or rename to wildcard `_` or `_g`)
diff --git a/test/run/ok/bad-do-async.tc.ok b/test/run/ok/bad-do-async.tc.ok
new file mode 100644
index 00000000000..15d9ce3b53b
--- /dev/null
+++ b/test/run/ok/bad-do-async.tc.ok
@@ -0,0 +1 @@
+bad-do-async.mo:1.6-1.7: warning [M0194], unused identifier g (delete or rename to wildcard `_` or `_g`)
diff --git a/test/run/ok/bad-shared-func.tc.ok b/test/run/ok/bad-shared-func.tc.ok
new file mode 100644
index 00000000000..a169f812aee
--- /dev/null
+++ b/test/run/ok/bad-shared-func.tc.ok
@@ -0,0 +1 @@
+bad-shared-func.mo:1.13-1.14: warning [M0194], unused identifier g (delete or rename to wildcard `_` or `_g`)
diff --git a/test/run/ok/big-array-access.wasm-run.ok b/test/run/ok/big-array-access.wasm-run.ok
deleted file mode 100644
index 35031a6ac7c..00000000000
--- a/test/run/ok/big-array-access.wasm-run.ok
+++ /dev/null
@@ -1,13 +0,0 @@
-Array index out of bounds
-Error: failed to run main module `_out/big-array-access.wasm`
-
-Caused by:
-    0: failed to invoke command default
-    1: wasm trap: unreachable
-       wasm backtrace:
-         0: rts_trap
-         1: bigint_to_word32_trap_with
-         2: Array.idx_bigint
-         3: init
-         4: _start
-       
diff --git a/test/run/ok/big-array-access.wasm-run.ret.ok b/test/run/ok/big-array-access.wasm-run.ret.ok
deleted file mode 100644
index 8209aecf795..00000000000
--- a/test/run/ok/big-array-access.wasm-run.ret.ok
+++ /dev/null
@@ -1 +0,0 @@
-Return code 134
diff --git a/test/run/ok/bit-ops.tc.ok b/test/run/ok/bit-ops.tc.ok
new file mode 100644
index 00000000000..2a90c3fb271
--- /dev/null
+++ b/test/run/ok/bit-ops.tc.ok
@@ -0,0 +1,136 @@
+bit-ops.mo:3.6-3.14: warning [M0194], unused identifier testNat8 (delete or rename to wildcard `_` or `_testNat8`)
+bit-ops.mo:4.8-4.12: warning [M0194], unused identifier not1 (delete or rename to wildcard `_` or `_not1`)
+bit-ops.mo:5.8-5.12: warning [M0194], unused identifier not2 (delete or rename to wildcard `_` or `_not2`)
+bit-ops.mo:6.8-6.11: warning [M0194], unused identifier or1 (delete or rename to wildcard `_` or `_or1`)
+bit-ops.mo:7.8-7.11: warning [M0194], unused identifier or2 (delete or rename to wildcard `_` or `_or2`)
+bit-ops.mo:8.8-8.12: warning [M0194], unused identifier and1 (delete or rename to wildcard `_` or `_and1`)
+bit-ops.mo:9.8-9.12: warning [M0194], unused identifier and2 (delete or rename to wildcard `_` or `_and2`)
+bit-ops.mo:10.8-10.11: warning [M0194], unused identifier xor (delete or rename to wildcard `_` or `_xor`)
+bit-ops.mo:11.8-11.12: warning [M0194], unused identifier xor2 (delete or rename to wildcard `_` or `_xor2`)
+bit-ops.mo:12.8-12.12: warning [M0194], unused identifier shl1 (delete or rename to wildcard `_` or `_shl1`)
+bit-ops.mo:13.8-13.12: warning [M0194], unused identifier shl2 (delete or rename to wildcard `_` or `_shl2`)
+bit-ops.mo:14.8-14.12: warning [M0194], unused identifier shr1 (delete or rename to wildcard `_` or `_shr1`)
+bit-ops.mo:15.8-15.12: warning [M0194], unused identifier shr2 (delete or rename to wildcard `_` or `_shr2`)
+bit-ops.mo:16.8-16.13: warning [M0194], unused identifier rotl1 (delete or rename to wildcard `_` or `_rotl1`)
+bit-ops.mo:17.8-17.13: warning [M0194], unused identifier rotl2 (delete or rename to wildcard `_` or `_rotl2`)
+bit-ops.mo:18.8-18.13: warning [M0194], unused identifier rotr1 (delete or rename to wildcard `_` or `_rotr1`)
+bit-ops.mo:19.8-19.13: warning [M0194], unused identifier rotr2 (delete or rename to wildcard `_` or `_rotr2`)
+bit-ops.mo:23.6-23.15: warning [M0194], unused identifier testNat16 (delete or rename to wildcard `_` or `_testNat16`)
+bit-ops.mo:24.8-24.12: warning [M0194], unused identifier not1 (delete or rename to wildcard `_` or `_not1`)
+bit-ops.mo:25.8-25.12: warning [M0194], unused identifier not2 (delete or rename to wildcard `_` or `_not2`)
+bit-ops.mo:26.8-26.11: warning [M0194], unused identifier or1 (delete or rename to wildcard `_` or `_or1`)
+bit-ops.mo:27.8-27.11: warning [M0194], unused identifier or2 (delete or rename to wildcard `_` or `_or2`)
+bit-ops.mo:28.8-28.12: warning [M0194], unused identifier and1 (delete or rename to wildcard `_` or `_and1`)
+bit-ops.mo:29.8-29.12: warning [M0194], unused identifier and2 (delete or rename to wildcard `_` or `_and2`)
+bit-ops.mo:30.8-30.11: warning [M0194], unused identifier xor (delete or rename to wildcard `_` or `_xor`)
+bit-ops.mo:31.8-31.12: warning [M0194], unused identifier xor2 (delete or rename to wildcard `_` or `_xor2`)
+bit-ops.mo:32.8-32.12: warning [M0194], unused identifier shl1 (delete or rename to wildcard `_` or `_shl1`)
+bit-ops.mo:33.8-33.12: warning [M0194], unused identifier shl2 (delete or rename to wildcard `_` or `_shl2`)
+bit-ops.mo:34.8-34.12: warning [M0194], unused identifier shr1 (delete or rename to wildcard `_` or `_shr1`)
+bit-ops.mo:35.8-35.12: warning [M0194], unused identifier shr2 (delete or rename to wildcard `_` or `_shr2`)
+bit-ops.mo:36.8-36.13: warning [M0194], unused identifier rotl1 (delete or rename to wildcard `_` or `_rotl1`)
+bit-ops.mo:37.8-37.13: warning [M0194], unused identifier rotl2 (delete or rename to wildcard `_` or `_rotl2`)
+bit-ops.mo:38.8-38.13: warning [M0194], unused identifier rotr1 (delete or rename to wildcard `_` or `_rotr1`)
+bit-ops.mo:39.8-39.13: warning [M0194], unused identifier rotr2 (delete or rename to wildcard `_` or `_rotr2`)
+bit-ops.mo:42.6-42.15: warning [M0194], unused identifier testNat32 (delete or rename to wildcard `_` or `_testNat32`)
+bit-ops.mo:43.8-43.12: warning [M0194], unused identifier not1 (delete or rename to wildcard `_` or `_not1`)
+bit-ops.mo:44.8-44.12: warning [M0194], unused identifier not2 (delete or rename to wildcard `_` or `_not2`)
+bit-ops.mo:45.8-45.11: warning [M0194], unused identifier or1 (delete or rename to wildcard `_` or `_or1`)
+bit-ops.mo:46.8-46.11: warning [M0194], unused identifier or2 (delete or rename to wildcard `_` or `_or2`)
+bit-ops.mo:47.8-47.12: warning [M0194], unused identifier and1 (delete or rename to wildcard `_` or `_and1`)
+bit-ops.mo:48.8-48.12: warning [M0194], unused identifier and2 (delete or rename to wildcard `_` or `_and2`)
+bit-ops.mo:49.8-49.11: warning [M0194], unused identifier xor (delete or rename to wildcard `_` or `_xor`)
+bit-ops.mo:50.8-50.12: warning [M0194], unused identifier xor2 (delete or rename to wildcard `_` or `_xor2`)
+bit-ops.mo:51.8-51.12: warning [M0194], unused identifier shl1 (delete or rename to wildcard `_` or `_shl1`)
+bit-ops.mo:52.8-52.12: warning [M0194], unused identifier shl2 (delete or rename to wildcard `_` or `_shl2`)
+bit-ops.mo:53.8-53.12: warning [M0194], unused identifier shr1 (delete or rename to wildcard `_` or `_shr1`)
+bit-ops.mo:54.8-54.12: warning [M0194], unused identifier shr2 (delete or rename to wildcard `_` or `_shr2`)
+bit-ops.mo:55.8-55.13: warning [M0194], unused identifier rotl1 (delete or rename to wildcard `_` or `_rotl1`)
+bit-ops.mo:56.8-56.13: warning [M0194], unused identifier rotl2 (delete or rename to wildcard `_` or `_rotl2`)
+bit-ops.mo:57.8-57.13: warning [M0194], unused identifier rotr1 (delete or rename to wildcard `_` or `_rotr1`)
+bit-ops.mo:58.8-58.13: warning [M0194], unused identifier rotr2 (delete or rename to wildcard `_` or `_rotr2`)
+bit-ops.mo:61.6-61.15: warning [M0194], unused identifier testNat64 (delete or rename to wildcard `_` or `_testNat64`)
+bit-ops.mo:62.8-62.12: warning [M0194], unused identifier not1 (delete or rename to wildcard `_` or `_not1`)
+bit-ops.mo:63.8-63.12: warning [M0194], unused identifier not2 (delete or rename to wildcard `_` or `_not2`)
+bit-ops.mo:64.8-64.11: warning [M0194], unused identifier or1 (delete or rename to wildcard `_` or `_or1`)
+bit-ops.mo:65.8-65.11: warning [M0194], unused identifier or2 (delete or rename to wildcard `_` or `_or2`)
+bit-ops.mo:66.8-66.12: warning [M0194], unused identifier and1 (delete or rename to wildcard `_` or `_and1`)
+bit-ops.mo:67.8-67.12: warning [M0194], unused identifier and2 (delete or rename to wildcard `_` or `_and2`)
+bit-ops.mo:68.8-68.11: warning [M0194], unused identifier xor (delete or rename to wildcard `_` or `_xor`)
+bit-ops.mo:69.8-69.12: warning [M0194], unused identifier xor2 (delete or rename to wildcard `_` or `_xor2`)
+bit-ops.mo:70.8-70.12: warning [M0194], unused identifier shl1 (delete or rename to wildcard `_` or `_shl1`)
+bit-ops.mo:71.8-71.12: warning [M0194], unused identifier shl2 (delete or rename to wildcard `_` or `_shl2`)
+bit-ops.mo:72.8-72.12: warning [M0194], unused identifier shr1 (delete or rename to wildcard `_` or `_shr1`)
+bit-ops.mo:73.8-73.12: warning [M0194], unused identifier shr2 (delete or rename to wildcard `_` or `_shr2`)
+bit-ops.mo:74.8-74.13: warning [M0194], unused identifier rotl1 (delete or rename to wildcard `_` or `_rotl1`)
+bit-ops.mo:75.8-75.13: warning [M0194], unused identifier rotl2 (delete or rename to wildcard `_` or `_rotl2`)
+bit-ops.mo:76.8-76.13: warning [M0194], unused identifier rotr1 (delete or rename to wildcard `_` or `_rotr1`)
+bit-ops.mo:77.8-77.13: warning [M0194], unused identifier rotr2 (delete or rename to wildcard `_` or `_rotr2`)
+bit-ops.mo:80.6-80.14: warning [M0194], unused identifier testInt8 (delete or rename to wildcard `_` or `_testInt8`)
+bit-ops.mo:81.8-81.12: warning [M0194], unused identifier not1 (delete or rename to wildcard `_` or `_not1`)
+bit-ops.mo:82.8-82.12: warning [M0194], unused identifier not2 (delete or rename to wildcard `_` or `_not2`)
+bit-ops.mo:83.8-83.11: warning [M0194], unused identifier or1 (delete or rename to wildcard `_` or `_or1`)
+bit-ops.mo:84.8-84.11: warning [M0194], unused identifier or2 (delete or rename to wildcard `_` or `_or2`)
+bit-ops.mo:85.8-85.12: warning [M0194], unused identifier and1 (delete or rename to wildcard `_` or `_and1`)
+bit-ops.mo:86.8-86.12: warning [M0194], unused identifier and2 (delete or rename to wildcard `_` or `_and2`)
+bit-ops.mo:87.8-87.11: warning [M0194], unused identifier xor (delete or rename to wildcard `_` or `_xor`)
+bit-ops.mo:88.8-88.12: warning [M0194], unused identifier xor2 (delete or rename to wildcard `_` or `_xor2`)
+bit-ops.mo:89.8-89.12: warning [M0194], unused identifier shl1 (delete or rename to wildcard `_` or `_shl1`)
+bit-ops.mo:90.8-90.12: warning [M0194], unused identifier shl2 (delete or rename to wildcard `_` or `_shl2`)
+bit-ops.mo:91.8-91.12: warning [M0194], unused identifier shr1 (delete or rename to wildcard `_` or `_shr1`)
+bit-ops.mo:92.8-92.12: warning [M0194], unused identifier shr2 (delete or rename to wildcard `_` or `_shr2`)
+bit-ops.mo:93.8-93.13: warning [M0194], unused identifier rotl1 (delete or rename to wildcard `_` or `_rotl1`)
+bit-ops.mo:94.8-94.13: warning [M0194], unused identifier rotl2 (delete or rename to wildcard `_` or `_rotl2`)
+bit-ops.mo:95.8-95.13: warning [M0194], unused identifier rotr1 (delete or rename to wildcard `_` or `_rotr1`)
+bit-ops.mo:96.8-96.13: warning [M0194], unused identifier rotr2 (delete or rename to wildcard `_` or `_rotr2`)
+bit-ops.mo:100.6-100.15: warning [M0194], unused identifier testInt16 (delete or rename to wildcard `_` or `_testInt16`)
+bit-ops.mo:101.8-101.12: warning [M0194], unused identifier not1 (delete or rename to wildcard `_` or `_not1`)
+bit-ops.mo:102.8-102.12: warning [M0194], unused identifier not2 (delete or rename to wildcard `_` or `_not2`)
+bit-ops.mo:103.8-103.11: warning [M0194], unused identifier or1 (delete or rename to wildcard `_` or `_or1`)
+bit-ops.mo:104.8-104.11: warning [M0194], unused identifier or2 (delete or rename to wildcard `_` or `_or2`)
+bit-ops.mo:105.8-105.12: warning [M0194], unused identifier and1 (delete or rename to wildcard `_` or `_and1`)
+bit-ops.mo:106.8-106.12: warning [M0194], unused identifier and2 (delete or rename to wildcard `_` or `_and2`)
+bit-ops.mo:107.8-107.11: warning [M0194], unused identifier xor (delete or rename to wildcard `_` or `_xor`)
+bit-ops.mo:108.8-108.12: warning [M0194], unused identifier xor2 (delete or rename to wildcard `_` or `_xor2`)
+bit-ops.mo:109.8-109.12: warning [M0194], unused identifier shl1 (delete or rename to wildcard `_` or `_shl1`)
+bit-ops.mo:110.8-110.12: warning [M0194], unused identifier shl2 (delete or rename to wildcard `_` or `_shl2`)
+bit-ops.mo:111.8-111.12: warning [M0194], unused identifier shr1 (delete or rename to wildcard `_` or `_shr1`)
+bit-ops.mo:112.8-112.12: warning [M0194], unused identifier shr2 (delete or rename to wildcard `_` or `_shr2`)
+bit-ops.mo:113.8-113.13: warning [M0194], unused identifier rotl1 (delete or rename to wildcard `_` or `_rotl1`)
+bit-ops.mo:114.8-114.13: warning [M0194], unused identifier rotl2 (delete or rename to wildcard `_` or `_rotl2`)
+bit-ops.mo:115.8-115.13: warning [M0194], unused identifier rotr1 (delete or rename to wildcard `_` or `_rotr1`)
+bit-ops.mo:116.8-116.13: warning [M0194], unused identifier rotr2 (delete or rename to wildcard `_` or `_rotr2`)
+bit-ops.mo:119.6-119.15: warning [M0194], unused identifier testInt32 (delete or rename to wildcard `_` or `_testInt32`)
+bit-ops.mo:120.8-120.12: warning [M0194], unused identifier not1 (delete or rename to wildcard `_` or `_not1`)
+bit-ops.mo:121.8-121.12: warning [M0194], unused identifier not2 (delete or rename to wildcard `_` or `_not2`)
+bit-ops.mo:122.8-122.11: warning [M0194], unused identifier or1 (delete or rename to wildcard `_` or `_or1`)
+bit-ops.mo:123.8-123.11: warning [M0194], unused identifier or2 (delete or rename to wildcard `_` or `_or2`)
+bit-ops.mo:124.8-124.12: warning [M0194], unused identifier and1 (delete or rename to wildcard `_` or `_and1`)
+bit-ops.mo:125.8-125.12: warning [M0194], unused identifier and2 (delete or rename to wildcard `_` or `_and2`)
+bit-ops.mo:126.8-126.11: warning [M0194], unused identifier xor (delete or rename to wildcard `_` or `_xor`)
+bit-ops.mo:127.8-127.12: warning [M0194], unused identifier xor2 (delete or rename to wildcard `_` or `_xor2`)
+bit-ops.mo:128.8-128.12: warning [M0194], unused identifier shl1 (delete or rename to wildcard `_` or `_shl1`)
+bit-ops.mo:129.8-129.12: warning [M0194], unused identifier shl2 (delete or rename to wildcard `_` or `_shl2`)
+bit-ops.mo:130.8-130.12: warning [M0194], unused identifier shr1 (delete or rename to wildcard `_` or `_shr1`)
+bit-ops.mo:131.8-131.12: warning [M0194], unused identifier shr2 (delete or rename to wildcard `_` or `_shr2`)
+bit-ops.mo:132.8-132.13: warning [M0194], unused identifier rotl1 (delete or rename to wildcard `_` or `_rotl1`)
+bit-ops.mo:133.8-133.13: warning [M0194], unused identifier rotl2 (delete or rename to wildcard `_` or `_rotl2`)
+bit-ops.mo:134.8-134.13: warning [M0194], unused identifier rotr1 (delete or rename to wildcard `_` or `_rotr1`)
+bit-ops.mo:135.8-135.13: warning [M0194], unused identifier rotr2 (delete or rename to wildcard `_` or `_rotr2`)
+bit-ops.mo:138.6-138.15: warning [M0194], unused identifier testInt64 (delete or rename to wildcard `_` or `_testInt64`)
+bit-ops.mo:139.8-139.12: warning [M0194], unused identifier not1 (delete or rename to wildcard `_` or `_not1`)
+bit-ops.mo:140.8-140.12: warning [M0194], unused identifier not2 (delete or rename to wildcard `_` or `_not2`)
+bit-ops.mo:141.8-141.11: warning [M0194], unused identifier or1 (delete or rename to wildcard `_` or `_or1`)
+bit-ops.mo:142.8-142.11: warning [M0194], unused identifier or2 (delete or rename to wildcard `_` or `_or2`)
+bit-ops.mo:143.8-143.12: warning [M0194], unused identifier and1 (delete or rename to wildcard `_` or `_and1`)
+bit-ops.mo:144.8-144.12: warning [M0194], unused identifier and2 (delete or rename to wildcard `_` or `_and2`)
+bit-ops.mo:145.8-145.11: warning [M0194], unused identifier xor (delete or rename to wildcard `_` or `_xor`)
+bit-ops.mo:146.8-146.12: warning [M0194], unused identifier xor2 (delete or rename to wildcard `_` or `_xor2`)
+bit-ops.mo:147.8-147.12: warning [M0194], unused identifier shl1 (delete or rename to wildcard `_` or `_shl1`)
+bit-ops.mo:148.8-148.12: warning [M0194], unused identifier shl2 (delete or rename to wildcard `_` or `_shl2`)
+bit-ops.mo:149.8-149.12: warning [M0194], unused identifier shr1 (delete or rename to wildcard `_` or `_shr1`)
+bit-ops.mo:150.8-150.12: warning [M0194], unused identifier shr2 (delete or rename to wildcard `_` or `_shr2`)
+bit-ops.mo:151.8-151.13: warning [M0194], unused identifier rotl1 (delete or rename to wildcard `_` or `_rotl1`)
+bit-ops.mo:152.8-152.13: warning [M0194], unused identifier rotl2 (delete or rename to wildcard `_` or `_rotl2`)
+bit-ops.mo:153.8-153.13: warning [M0194], unused identifier rotr1 (delete or rename to wildcard `_` or `_rotr1`)
+bit-ops.mo:154.8-154.13: warning [M0194], unused identifier rotr2 (delete or rename to wildcard `_` or `_rotr2`)
diff --git a/test/run/ok/concat.tc.ok b/test/run/ok/concat.tc.ok
new file mode 100644
index 00000000000..066bcf543ad
--- /dev/null
+++ b/test/run/ok/concat.tc.ok
@@ -0,0 +1,3 @@
+concat.mo:1.6-1.14: warning [M0194], unused identifier testText (delete or rename to wildcard `_` or `_testText`)
+concat.mo:2.7-2.11: warning [M0194], unused identifier cat1 (delete or rename to wildcard `_` or `_cat1`)
+concat.mo:3.7-3.11: warning [M0194], unused identifier cat2 (delete or rename to wildcard `_` or `_cat2`)
diff --git a/test/run/ok/const-func-unused.tc.ok b/test/run/ok/const-func-unused.tc.ok
new file mode 100644
index 00000000000..8517d73ed05
--- /dev/null
+++ b/test/run/ok/const-func-unused.tc.ok
@@ -0,0 +1,2 @@
+const-func-unused.mo:1.6-1.9: warning [M0194], unused identifier bar (delete or rename to wildcard `_` or `_bar`)
+const-func-unused.mo:2.6-2.9: warning [M0194], unused identifier foo (delete or rename to wildcard `_` or `_foo`)
diff --git a/test/run/ok/counter-class.tc.ok b/test/run/ok/counter-class.tc.ok
new file mode 100644
index 00000000000..a58e2b1c02d
--- /dev/null
+++ b/test/run/ok/counter-class.tc.ok
@@ -0,0 +1 @@
+counter-class.mo:12.18-12.19: warning [M0194], unused identifier c (delete or rename to wildcard `_` or `_c`)
diff --git a/test/run/ok/coverage.tc.ok b/test/run/ok/coverage.tc.ok
index 62bf2cdbd50..171ba1f9a4c 100644
--- a/test/run/ok/coverage.tc.ok
+++ b/test/run/ok/coverage.tc.ok
@@ -185,3 +185,14 @@ coverage.mo:228.3-230.4: warning [M0145], this switch of type
   {#a}
 does not cover value
   #a
+coverage.mo:1.6-1.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+coverage.mo:3.7-3.8: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+coverage.mo:9.8-9.9: warning [M0194], unused identifier b (delete or rename to wildcard `_` or `_b`)
+coverage.mo:13.8-13.10: warning [M0194], unused identifier f1 (delete or rename to wildcard `_` or `_f1`)
+coverage.mo:14.8-14.10: warning [M0194], unused identifier f2 (delete or rename to wildcard `_` or `_f2`)
+coverage.mo:14.11-14.12: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+coverage.mo:15.8-15.10: warning [M0194], unused identifier f3 (delete or rename to wildcard `_` or `_f3`)
+coverage.mo:17.8-17.10: warning [M0194], unused identifier f5 (delete or rename to wildcard `_` or `_f5`)
+coverage.mo:18.8-18.10: warning [M0194], unused identifier f6 (delete or rename to wildcard `_` or `_f6`)
+coverage.mo:19.8-19.10: warning [M0194], unused identifier f7 (delete or rename to wildcard `_` or `_f7`)
+coverage.mo:178.6-178.7: warning [M0194], unused identifier h (delete or rename to wildcard `_` or `_h`)
diff --git a/test/run/ok/deprecated.tc.ok b/test/run/ok/deprecated.tc.ok
index 49ec20ef2d7..352fe46bc78 100644
--- a/test/run/ok/deprecated.tc.ok
+++ b/test/run/ok/deprecated.tc.ok
@@ -14,3 +14,5 @@ deprecated.mo:23.11-23.12: warning [M0154], type field f is deprecated:
 deprecated function
 deprecated.mo:24.11-24.16: warning [M0154], type field f is deprecated:
 deprecated function
+deprecated.mo:23.11-23.12: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+deprecated.mo:24.15-24.16: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
diff --git a/test/run/ok/eager-and-lazy.tc.ok b/test/run/ok/eager-and-lazy.tc.ok
new file mode 100644
index 00000000000..2f69e753625
--- /dev/null
+++ b/test/run/ok/eager-and-lazy.tc.ok
@@ -0,0 +1 @@
+eager-and-lazy.mo:4.6-4.7: warning [M0194], unused identifier y (delete or rename to wildcard `_` or `_y`)
diff --git a/test/run/ok/empty-tup-args.tc.ok b/test/run/ok/empty-tup-args.tc.ok
new file mode 100644
index 00000000000..90ebf3baffa
--- /dev/null
+++ b/test/run/ok/empty-tup-args.tc.ok
@@ -0,0 +1,25 @@
+empty-tup-args.mo:4.8-4.9: warning [M0194], unused identifier u (delete or rename to wildcard `_` or `_u`)
+empty-tup-args.mo:5.10-5.11: warning [M0194], unused identifier u (delete or rename to wildcard `_` or `_u`)
+empty-tup-args.mo:11.43-11.45: warning [M0194], unused identifier f1 (delete or rename to wildcard `_` or `_f1`)
+empty-tup-args.mo:12.59-12.61: warning [M0194], unused identifier g2 (delete or rename to wildcard `_` or `_g2`)
+empty-tup-args.mo:30.8-30.9: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+empty-tup-args.mo:31.8-31.9: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+empty-tup-args.mo:32.8-32.9: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+empty-tup-args.mo:34.40-34.42: warning [M0194], unused identifier l1 (delete or rename to wildcard `_` or `_l1`)
+empty-tup-args.mo:34.43-34.44: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+empty-tup-args.mo:41.9-41.10: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+empty-tup-args.mo:41.16-41.17: warning [M0194], unused identifier b (delete or rename to wildcard `_` or `_b`)
+empty-tup-args.mo:42.10-42.11: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+empty-tup-args.mo:42.17-42.18: warning [M0194], unused identifier b (delete or rename to wildcard `_` or `_b`)
+empty-tup-args.mo:43.5-43.7: warning [M0194], unused identifier ms (delete or rename to wildcard `_` or `_ms`)
+empty-tup-args.mo:45.8-45.9: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+empty-tup-args.mo:45.15-45.16: warning [M0194], unused identifier b (delete or rename to wildcard `_` or `_b`)
+empty-tup-args.mo:46.9-46.10: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+empty-tup-args.mo:46.16-46.17: warning [M0194], unused identifier b (delete or rename to wildcard `_` or `_b`)
+empty-tup-args.mo:48.5-48.7: warning [M0194], unused identifier ns (delete or rename to wildcard `_` or `_ns`)
+empty-tup-args.mo:50.9-50.10: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+empty-tup-args.mo:51.5-51.7: warning [M0194], unused identifier os (delete or rename to wildcard `_` or `_os`)
+empty-tup-args.mo:56.9-56.10: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+empty-tup-args.mo:58.11-58.12: warning [M0194], unused identifier u (delete or rename to wildcard `_` or `_u`)
+empty-tup-args.mo:74.17-74.18: warning [M0194], unused identifier b (delete or rename to wildcard `_` or `_b`)
+empty-tup-args.mo:75.17-75.18: warning [M0194], unused identifier b (delete or rename to wildcard `_` or `_b`)
diff --git a/test/run/ok/f-bounds.tc.ok b/test/run/ok/f-bounds.tc.ok
new file mode 100644
index 00000000000..f58150ece1c
--- /dev/null
+++ b/test/run/ok/f-bounds.tc.ok
@@ -0,0 +1,27 @@
+f-bounds.mo:3.5-3.6: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+f-bounds.mo:5.6-5.9: warning [M0194], unused identifier f2a (delete or rename to wildcard `_` or `_f2a`)
+f-bounds.mo:7.6-7.9: warning [M0194], unused identifier f2b (delete or rename to wildcard `_` or `_f2b`)
+f-bounds.mo:9.6-9.9: warning [M0194], unused identifier f3a (delete or rename to wildcard `_` or `_f3a`)
+f-bounds.mo:10.6-10.9: warning [M0194], unused identifier f3b (delete or rename to wildcard `_` or `_f3b`)
+f-bounds.mo:11.6-11.9: warning [M0194], unused identifier f3c (delete or rename to wildcard `_` or `_f3c`)
+f-bounds.mo:46.6-46.8: warning [M0194], unused identifier u0 (delete or rename to wildcard `_` or `_u0`)
+f-bounds.mo:47.6-47.8: warning [M0194], unused identifier u1 (delete or rename to wildcard `_` or `_u1`)
+f-bounds.mo:48.6-48.8: warning [M0194], unused identifier u2 (delete or rename to wildcard `_` or `_u2`)
+f-bounds.mo:49.6-49.8: warning [M0194], unused identifier u3 (delete or rename to wildcard `_` or `_u3`)
+f-bounds.mo:50.6-50.8: warning [M0194], unused identifier u4 (delete or rename to wildcard `_` or `_u4`)
+f-bounds.mo:51.6-51.8: warning [M0194], unused identifier u5 (delete or rename to wildcard `_` or `_u5`)
+f-bounds.mo:52.6-52.8: warning [M0194], unused identifier u6 (delete or rename to wildcard `_` or `_u6`)
+f-bounds.mo:54.6-54.8: warning [M0194], unused identifier v0 (delete or rename to wildcard `_` or `_v0`)
+f-bounds.mo:55.6-55.8: warning [M0194], unused identifier v1 (delete or rename to wildcard `_` or `_v1`)
+f-bounds.mo:56.6-56.8: warning [M0194], unused identifier v2 (delete or rename to wildcard `_` or `_v2`)
+f-bounds.mo:57.6-57.8: warning [M0194], unused identifier v3 (delete or rename to wildcard `_` or `_v3`)
+f-bounds.mo:58.6-58.8: warning [M0194], unused identifier v4 (delete or rename to wildcard `_` or `_v4`)
+f-bounds.mo:59.6-59.8: warning [M0194], unused identifier v5 (delete or rename to wildcard `_` or `_v5`)
+f-bounds.mo:60.6-60.8: warning [M0194], unused identifier v6 (delete or rename to wildcard `_` or `_v6`)
+f-bounds.mo:62.6-62.8: warning [M0194], unused identifier w0 (delete or rename to wildcard `_` or `_w0`)
+f-bounds.mo:63.6-63.8: warning [M0194], unused identifier w1 (delete or rename to wildcard `_` or `_w1`)
+f-bounds.mo:64.6-64.8: warning [M0194], unused identifier w2 (delete or rename to wildcard `_` or `_w2`)
+f-bounds.mo:65.6-65.8: warning [M0194], unused identifier w3 (delete or rename to wildcard `_` or `_w3`)
+f-bounds.mo:66.6-66.8: warning [M0194], unused identifier w4 (delete or rename to wildcard `_` or `_w4`)
+f-bounds.mo:67.6-67.8: warning [M0194], unused identifier w5 (delete or rename to wildcard `_` or `_w5`)
+f-bounds.mo:68.6-68.8: warning [M0194], unused identifier w6 (delete or rename to wildcard `_` or `_w6`)
diff --git a/test/run/ok/idx.tc.ok b/test/run/ok/idx.tc.ok
new file mode 100644
index 00000000000..ccc99470088
--- /dev/null
+++ b/test/run/ok/idx.tc.ok
@@ -0,0 +1 @@
+idx.mo:27.9-27.10: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
diff --git a/test/run/ok/import-module-explicit.tc.ok b/test/run/ok/import-module-explicit.tc.ok
new file mode 100644
index 00000000000..78d1e3e550f
--- /dev/null
+++ b/test/run/ok/import-module-explicit.tc.ok
@@ -0,0 +1,2 @@
+import-module-explicit.mo:4.5-4.6: warning [M0194], unused identifier s (delete or rename to wildcard `_` or `_s`)
+import-module-explicit.mo:5.5-5.6: warning [M0194], unused identifier u (delete or rename to wildcard `_` or `_u`)
diff --git a/test/run/ok/import-module.tc.ok b/test/run/ok/import-module.tc.ok
new file mode 100644
index 00000000000..ec3cea8b3f1
--- /dev/null
+++ b/test/run/ok/import-module.tc.ok
@@ -0,0 +1 @@
+import-module.mo:3.5-3.6: warning [M0194], unused identifier s (delete or rename to wildcard `_` or `_s`)
diff --git a/test/run/ok/import-named-module.tc.ok b/test/run/ok/import-named-module.tc.ok
new file mode 100644
index 00000000000..890d25e5b70
--- /dev/null
+++ b/test/run/ok/import-named-module.tc.ok
@@ -0,0 +1 @@
+import-named-module.mo:4.5-4.7: warning [M0194], unused identifier ts (delete or rename to wildcard `_` or `_ts`)
diff --git a/test/run/ok/inc-oom.tc.ok b/test/run/ok/inc-oom.tc.ok
new file mode 100644
index 00000000000..5849509f856
--- /dev/null
+++ b/test/run/ok/inc-oom.tc.ok
@@ -0,0 +1 @@
+inc-oom.mo:8.9-8.10: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
diff --git a/test/run/ok/ir-litpat-subtype.tc.ok b/test/run/ok/ir-litpat-subtype.tc.ok
new file mode 100644
index 00000000000..94a276e91dc
--- /dev/null
+++ b/test/run/ok/ir-litpat-subtype.tc.ok
@@ -0,0 +1 @@
+ir-litpat-subtype.mo:1.6-1.9: warning [M0194], unused identifier bar (delete or rename to wildcard `_` or `_bar`)
diff --git a/test/run/ok/issue-4054.tc.ok b/test/run/ok/issue-4054.tc.ok
new file mode 100644
index 00000000000..4c6ef10ff8a
--- /dev/null
+++ b/test/run/ok/issue-4054.tc.ok
@@ -0,0 +1,4 @@
+issue-4054.mo:1.8-1.9: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+issue-4054.mo:2.7-2.9: warning [M0194], unused identifier f1 (delete or rename to wildcard `_` or `_f1`)
+issue-4054.mo:3.7-3.9: warning [M0194], unused identifier f2 (delete or rename to wildcard `_` or `_f2`)
+issue-4054.mo:4.7-4.9: warning [M0194], unused identifier f3 (delete or rename to wildcard `_` or `_f3`)
diff --git a/test/run/ok/issue129.tc.ok b/test/run/ok/issue129.tc.ok
new file mode 100644
index 00000000000..1e537f5dc16
--- /dev/null
+++ b/test/run/ok/issue129.tc.ok
@@ -0,0 +1 @@
+issue129.mo:8.5-8.17: warning [M0194], unused identifier appendStatus (delete or rename to wildcard `_` or `_appendStatus`)
diff --git a/test/run/ok/issue1304.tc.ok b/test/run/ok/issue1304.tc.ok
new file mode 100644
index 00000000000..cffb59c7450
--- /dev/null
+++ b/test/run/ok/issue1304.tc.ok
@@ -0,0 +1 @@
+issue1304.mo:6.5-6.6: warning [M0194], unused identifier c (delete or rename to wildcard `_` or `_c`)
diff --git a/test/run/ok/issue150.tc.ok b/test/run/ok/issue150.tc.ok
new file mode 100644
index 00000000000..1861302debe
--- /dev/null
+++ b/test/run/ok/issue150.tc.ok
@@ -0,0 +1 @@
+issue150.mo:2.8-2.9: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
diff --git a/test/run/ok/issue2975.tc.ok b/test/run/ok/issue2975.tc.ok
new file mode 100644
index 00000000000..3f651ad445b
--- /dev/null
+++ b/test/run/ok/issue2975.tc.ok
@@ -0,0 +1 @@
+issue2975.mo:1.8-1.9: warning [M0194], unused identifier M (delete or rename to wildcard `_` or `_M`)
diff --git a/test/run/ok/issue3265.tc.ok b/test/run/ok/issue3265.tc.ok
new file mode 100644
index 00000000000..139771cf3fa
--- /dev/null
+++ b/test/run/ok/issue3265.tc.ok
@@ -0,0 +1,3 @@
+issue3265.mo:2.5-2.9: warning [M0194], unused identifier rec1 (delete or rename to wildcard `_` or `_rec1`)
+issue3265.mo:7.6-7.9: warning [M0194], unused identifier sub (delete or rename to wildcard `_` or `_sub`)
+issue3265.mo:8.5-8.9: warning [M0194], unused identifier rec2 (delete or rename to wildcard `_` or `_rec2`)
diff --git a/test/run/ok/issue36.tc.ok b/test/run/ok/issue36.tc.ok
new file mode 100644
index 00000000000..5abc0cee306
--- /dev/null
+++ b/test/run/ok/issue36.tc.ok
@@ -0,0 +1,5 @@
+issue36.mo:25.6-25.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+issue36.mo:25.9-25.10: warning [M0194], unused identifier g (delete or rename to wildcard `_` or `_g`)
+issue36.mo:25.12-25.13: warning [M0194], unused identifier h (delete or rename to wildcard `_` or `_h`)
+issue36.mo:29.6-29.7: warning [M0194], unused identifier k (delete or rename to wildcard `_` or `_k`)
+issue36.mo:29.9-29.10: warning [M0194], unused identifier l (delete or rename to wildcard `_` or `_l`)
diff --git a/test/run/ok/issue442.tc.ok b/test/run/ok/issue442.tc.ok
index 69a80127b2d..245f0590519 100644
--- a/test/run/ok/issue442.tc.ok
+++ b/test/run/ok/issue442.tc.ok
@@ -8,3 +8,5 @@ true produces
   Nat
 false produces
   Text
+issue442.mo:1.5-1.8: warning [M0194], unused identifier foo (delete or rename to wildcard `_` or `_foo`)
+issue442.mo:2.5-2.8: warning [M0194], unused identifier bar (delete or rename to wildcard `_` or `_bar`)
diff --git a/test/run/ok/let-else-if.tc.ok b/test/run/ok/let-else-if.tc.ok
new file mode 100644
index 00000000000..75c6b949dd2
--- /dev/null
+++ b/test/run/ok/let-else-if.tc.ok
@@ -0,0 +1 @@
+let-else-if.mo:1.5-1.6: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
diff --git a/test/run/ok/let-else.tc.ok b/test/run/ok/let-else.tc.ok
new file mode 100644
index 00000000000..130b34e2b82
--- /dev/null
+++ b/test/run/ok/let-else.tc.ok
@@ -0,0 +1,3 @@
+let-else.mo:1.5-1.6: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+let-else.mo:3.6-3.7: warning [M0194], unused identifier y (delete or rename to wildcard `_` or `_y`)
+let-else.mo:3.9-3.10: warning [M0194], unused identifier z (delete or rename to wildcard `_` or `_z`)
diff --git a/test/run/ok/literals.tc.ok b/test/run/ok/literals.tc.ok
new file mode 100644
index 00000000000..80f7b567a0f
--- /dev/null
+++ b/test/run/ok/literals.tc.ok
@@ -0,0 +1,12 @@
+literals.mo:1.5-1.6: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
+literals.mo:2.5-2.6: warning [M0194], unused identifier i (delete or rename to wildcard `_` or `_i`)
+literals.mo:3.5-3.7: warning [M0194], unused identifier i1 (delete or rename to wildcard `_` or `_i1`)
+literals.mo:4.5-4.7: warning [M0194], unused identifier i2 (delete or rename to wildcard `_` or `_i2`)
+literals.mo:5.5-5.9: warning [M0194], unused identifier byte (delete or rename to wildcard `_` or `_byte`)
+literals.mo:6.5-6.10: warning [M0194], unused identifier short (delete or rename to wildcard `_` or `_short`)
+literals.mo:7.5-7.9: warning [M0194], unused identifier word (delete or rename to wildcard `_` or `_word`)
+literals.mo:8.5-8.6: warning [M0194], unused identifier u (delete or rename to wildcard `_` or `_u`)
+literals.mo:9.5-9.7: warning [M0194], unused identifier gu (delete or rename to wildcard `_` or `_gu`)
+literals.mo:10.5-10.7: warning [M0194], unused identifier ru (delete or rename to wildcard `_` or `_ru`)
+literals.mo:11.5-11.6: warning [M0194], unused identifier s (delete or rename to wildcard `_` or `_s`)
+literals.mo:12.5-12.11: warning [M0194], unused identifier emojis (delete or rename to wildcard `_` or `_emojis`)
diff --git a/test/run/ok/modexp1.tc.ok b/test/run/ok/modexp1.tc.ok
new file mode 100644
index 00000000000..48e11b3c471
--- /dev/null
+++ b/test/run/ok/modexp1.tc.ok
@@ -0,0 +1 @@
+modexp1.mo:7.5-7.7: warning [M0194], unused identifier ok (delete or rename to wildcard `_` or `_ok`)
diff --git a/test/run/ok/modexp2.tc.ok b/test/run/ok/modexp2.tc.ok
new file mode 100644
index 00000000000..cc599a4cdbf
--- /dev/null
+++ b/test/run/ok/modexp2.tc.ok
@@ -0,0 +1 @@
+modexp2.mo:5.7-5.8: warning [M0194], unused identifier y (delete or rename to wildcard `_` or `_y`)
diff --git a/test/run/ok/modexp3.tc.ok b/test/run/ok/modexp3.tc.ok
new file mode 100644
index 00000000000..2a2973db4d5
--- /dev/null
+++ b/test/run/ok/modexp3.tc.ok
@@ -0,0 +1 @@
+modexp3.mo:11.5-11.7: warning [M0194], unused identifier ok (delete or rename to wildcard `_` or `_ok`)
diff --git a/test/run/ok/modexp4.tc.ok b/test/run/ok/modexp4.tc.ok
new file mode 100644
index 00000000000..fa1f130eba4
--- /dev/null
+++ b/test/run/ok/modexp4.tc.ok
@@ -0,0 +1 @@
+modexp4.mo:2.8-2.9: warning [M0194], unused identifier X (delete or rename to wildcard `_` or `_X`)
diff --git a/test/run/ok/module1.tc.ok b/test/run/ok/module1.tc.ok
new file mode 100644
index 00000000000..1a30dfd1be4
--- /dev/null
+++ b/test/run/ok/module1.tc.ok
@@ -0,0 +1,4 @@
+module1.mo:8.5-8.6: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+module1.mo:9.5-9.6: warning [M0194], unused identifier y (delete or rename to wildcard `_` or `_y`)
+module1.mo:21.5-21.6: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+module1.mo:38.5-38.6: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
diff --git a/test/run/ok/module2.tc.ok b/test/run/ok/module2.tc.ok
new file mode 100644
index 00000000000..745d503aa79
--- /dev/null
+++ b/test/run/ok/module2.tc.ok
@@ -0,0 +1 @@
+module2.mo:4.5-4.6: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
diff --git a/test/run/ok/modules-bwd.tc.ok b/test/run/ok/modules-bwd.tc.ok
new file mode 100644
index 00000000000..f2aea6e5e92
--- /dev/null
+++ b/test/run/ok/modules-bwd.tc.ok
@@ -0,0 +1,2 @@
+modules-bwd.mo:1.8-1.9: warning [M0194], unused identifier X (delete or rename to wildcard `_` or `_X`)
+modules-bwd.mo:14.5-14.6: warning [M0194], unused identifier u (delete or rename to wildcard `_` or `_u`)
diff --git a/test/run/ok/mut-array-iter-max.wasm-run.ok b/test/run/ok/mut-array-iter-max.wasm-run.ok
new file mode 100644
index 00000000000..db06e61f196
--- /dev/null
+++ b/test/run/ok/mut-array-iter-max.wasm-run.ok
@@ -0,0 +1,2 @@
+536_870_912
+536_870_912
diff --git a/test/run/ok/n-ary.tc.ok b/test/run/ok/n-ary.tc.ok
new file mode 100644
index 00000000000..9b3b6303681
--- /dev/null
+++ b/test/run/ok/n-ary.tc.ok
@@ -0,0 +1,3 @@
+n-ary.mo:7.6-7.19: warning [M0194], unused identifier foo_0_2_block (delete or rename to wildcard `_` or `_foo_0_2_block`)
+n-ary.mo:13.6-13.13: warning [M0194], unused identifier foo_1_1 (delete or rename to wildcard `_` or `_foo_1_1`)
+n-ary.mo:17.6-17.13: warning [M0194], unused identifier foo_2_2 (delete or rename to wildcard `_` or `_foo_2_2`)
diff --git a/test/run/ok/nat-shift.tc.ok b/test/run/ok/nat-shift.tc.ok
index 950b63bcfb5..ed84e3907ef 100644
--- a/test/run/ok/nat-shift.tc.ok
+++ b/test/run/ok/nat-shift.tc.ok
@@ -1,2 +1,3 @@
 nat-shift.mo:43.35-43.43: warning [M0155], operator may trap for inferred type
   Nat
+nat-shift.mo:1.10-1.20: warning [M0194], unused identifier debugPrint (delete or rename to wildcard `_` or `_debugPrint`)
diff --git a/test/run/ok/neg-boundary.tc.ok b/test/run/ok/neg-boundary.tc.ok
new file mode 100644
index 00000000000..aff44dba705
--- /dev/null
+++ b/test/run/ok/neg-boundary.tc.ok
@@ -0,0 +1,6 @@
+neg-boundary.mo:7.10-7.13: warning [M0194], unused identifier foo (delete or rename to wildcard `_` or `_foo`)
+neg-boundary.mo:8.10-8.13: warning [M0194], unused identifier bar (delete or rename to wildcard `_` or `_bar`)
+neg-boundary.mo:12.10-12.13: warning [M0194], unused identifier foo (delete or rename to wildcard `_` or `_foo`)
+neg-boundary.mo:13.10-13.13: warning [M0194], unused identifier bar (delete or rename to wildcard `_` or `_bar`)
+neg-boundary.mo:17.10-17.13: warning [M0194], unused identifier foo (delete or rename to wildcard `_` or `_foo`)
+neg-boundary.mo:18.10-18.13: warning [M0194], unused identifier bar (delete or rename to wildcard `_` or `_bar`)
diff --git a/test/run/ok/nested-class-rec.tc.ok b/test/run/ok/nested-class-rec.tc.ok
new file mode 100644
index 00000000000..7183d2f7e63
--- /dev/null
+++ b/test/run/ok/nested-class-rec.tc.ok
@@ -0,0 +1,3 @@
+nested-class-rec.mo:2.11-2.13: warning [M0194], unused identifier f1 (delete or rename to wildcard `_` or `_f1`)
+nested-class-rec.mo:2.26-2.28: warning [M0194], unused identifier f2 (delete or rename to wildcard `_` or `_f2`)
+nested-class-rec.mo:4.7-4.10: warning [M0194], unused identifier Bar (delete or rename to wildcard `_` or `_Bar`)
diff --git a/test/run/ok/object-extend-type.tc.ok b/test/run/ok/object-extend-type.tc.ok
new file mode 100644
index 00000000000..e5df9e1dfe9
--- /dev/null
+++ b/test/run/ok/object-extend-type.tc.ok
@@ -0,0 +1,7 @@
+object-extend-type.mo:15.5-15.8: warning [M0194], unused identifier ac1 (delete or rename to wildcard `_` or `_ac1`)
+object-extend-type.mo:18.5-18.7: warning [M0194], unused identifier ab (delete or rename to wildcard `_` or `_ab`)
+object-extend-type.mo:21.5-21.7: warning [M0194], unused identifier am (delete or rename to wildcard `_` or `_am`)
+object-extend-type.mo:22.5-22.7: warning [M0194], unused identifier bm (delete or rename to wildcard `_` or `_bm`)
+object-extend-type.mo:24.5-24.7: warning [M0194], unused identifier aM (delete or rename to wildcard `_` or `_aM`)
+object-extend-type.mo:25.5-25.7: warning [M0194], unused identifier bM (delete or rename to wildcard `_` or `_bM`)
+object-extend-type.mo:36.5-36.7: warning [M0194], unused identifier r2 (delete or rename to wildcard `_` or `_r2`)
diff --git a/test/run/ok/object-extend.tc.ok b/test/run/ok/object-extend.tc.ok
new file mode 100644
index 00000000000..254562062ed
--- /dev/null
+++ b/test/run/ok/object-extend.tc.ok
@@ -0,0 +1,5 @@
+object-extend.mo:56.6-56.9: warning [M0194], unused identifier mix (delete or rename to wildcard `_` or `_mix`)
+object-extend.mo:59.6-59.9: warning [M0194], unused identifier mox (delete or rename to wildcard `_` or `_mox`)
+object-extend.mo:62.6-62.9: warning [M0194], unused identifier mux (delete or rename to wildcard `_` or `_mux`)
+object-extend.mo:67.5-67.10: warning [M0194], unused identifier tb_ok (delete or rename to wildcard `_` or `_tb_ok`)
+object-extend.mo:68.5-68.10: warning [M0194], unused identifier ab_ok (delete or rename to wildcard `_` or `_ab_ok`)
diff --git a/test/run/ok/objects-order.tc.ok b/test/run/ok/objects-order.tc.ok
new file mode 100644
index 00000000000..1191a93725f
--- /dev/null
+++ b/test/run/ok/objects-order.tc.ok
@@ -0,0 +1 @@
+objects-order.mo:17.65-17.66: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
diff --git a/test/run/ok/objects1.tc.ok b/test/run/ok/objects1.tc.ok
index 5fb40655c89..7753ba81568 100644
--- a/test/run/ok/objects1.tc.ok
+++ b/test/run/ok/objects1.tc.ok
@@ -8,3 +8,8 @@ objects1.mo:47.21-49.2: warning [M0145], this switch of type
   (Nat, Int, {c : Char; d : Text})
 does not cover value
   (_, 0 or 1 or _, _)
+objects1.mo:7.6-7.12: warning [M0194], unused identifier nonrec (delete or rename to wildcard `_` or `_nonrec`)
+objects1.mo:11.5-11.7: warning [M0194], unused identifier oo (delete or rename to wildcard `_` or `_oo`)
+objects1.mo:18.9-18.10: warning [M0194], unused identifier C (delete or rename to wildcard `_` or `_C`)
+objects1.mo:55.6-55.9: warning [M0194], unused identifier baz (delete or rename to wildcard `_` or `_baz`)
+objects1.mo:59.6-59.15: warning [M0194], unused identifier full_name (delete or rename to wildcard `_` or `_full_name`)
diff --git a/test/run/ok/optimise-for-array.tc.ok b/test/run/ok/optimise-for-array.tc.ok
new file mode 100644
index 00000000000..837540a7c42
--- /dev/null
+++ b/test/run/ok/optimise-for-array.tc.ok
@@ -0,0 +1 @@
+optimise-for-array.mo:123.6-123.8: warning [M0194], unused identifier f9 (delete or rename to wildcard `_` or `_f9`)
diff --git a/test/run/ok/or-pattern-mismatch.tc.ok b/test/run/ok/or-pattern-mismatch.tc.ok
index 5e76630f5ee..c0ac7006050 100644
--- a/test/run/ok/or-pattern-mismatch.tc.ok
+++ b/test/run/ok/or-pattern-mismatch.tc.ok
@@ -23,3 +23,8 @@ type in right pattern is
   Int
 or-pattern-mismatch.mo:6.5-6.21: warning [M0146], this pattern is never matched
 or-pattern-mismatch.mo:6.6-6.20: warning [M0146], this pattern is never matched
+or-pattern-mismatch.mo:2.9-2.11: warning [M0194], unused identifier a1 (delete or rename to wildcard `_` or `_a1`)
+or-pattern-mismatch.mo:3.10-3.12: warning [M0194], unused identifier a2 (delete or rename to wildcard `_` or `_a2`)
+or-pattern-mismatch.mo:4.10-4.12: warning [M0194], unused identifier a3 (delete or rename to wildcard `_` or `_a3`)
+or-pattern-mismatch.mo:5.10-5.12: warning [M0194], unused identifier a4 (delete or rename to wildcard `_` or `_a4`)
+or-pattern-mismatch.mo:6.10-6.12: warning [M0194], unused identifier a5 (delete or rename to wildcard `_` or `_a5`)
diff --git a/test/run/ok/prim.tc.ok b/test/run/ok/prim.tc.ok
new file mode 100644
index 00000000000..f8de3dbc163
--- /dev/null
+++ b/test/run/ok/prim.tc.ok
@@ -0,0 +1 @@
+prim.mo:1.8-1.12: warning [M0194], unused identifier Prim (delete or rename to wildcard `_` or `_Prim`)
diff --git a/test/run/ok/principal.tc.ok b/test/run/ok/principal.tc.ok
new file mode 100644
index 00000000000..f9969bb1eb8
--- /dev/null
+++ b/test/run/ok/principal.tc.ok
@@ -0,0 +1 @@
+principal.mo:3.6-3.10: warning [M0194], unused identifier isEq (delete or rename to wildcard `_` or `_isEq`)
diff --git a/test/run/ok/quicksort.tc.ok b/test/run/ok/quicksort.tc.ok
new file mode 100644
index 00000000000..93d334aa327
--- /dev/null
+++ b/test/run/ok/quicksort.tc.ok
@@ -0,0 +1 @@
+quicksort.mo:16.17-16.18: warning [M0194], unused identifier v (delete or rename to wildcard `_` or `_v`)
diff --git a/test/run/ok/refuted-const-option-null.tc.ok b/test/run/ok/refuted-const-option-null.tc.ok
index 57612c2cfc8..d503d21a076 100644
--- a/test/run/ok/refuted-const-option-null.tc.ok
+++ b/test/run/ok/refuted-const-option-null.tc.ok
@@ -2,3 +2,4 @@ refuted-const-option-null.mo:2.5-2.7: warning [M0145], this pattern of type
   Null
 does not cover value
   null
+refuted-const-option-null.mo:2.6-2.7: warning [M0194], unused identifier b (delete or rename to wildcard `_` or `_b`)
diff --git a/test/run/ok/refuted-const-variant.tc.ok b/test/run/ok/refuted-const-variant.tc.ok
index b157cc13843..d6d991c61ff 100644
--- a/test/run/ok/refuted-const-variant.tc.ok
+++ b/test/run/ok/refuted-const-variant.tc.ok
@@ -2,3 +2,4 @@ refuted-const-variant.mo:2.6-2.14: warning [M0145], this pattern of type
   {#bummer}
 does not cover value
   #bummer
+refuted-const-variant.mo:2.13-2.14: warning [M0194], unused identifier b (delete or rename to wildcard `_` or `_b`)
diff --git a/test/run/ok/relational-ops.tc.ok b/test/run/ok/relational-ops.tc.ok
new file mode 100644
index 00000000000..205562fad19
--- /dev/null
+++ b/test/run/ok/relational-ops.tc.ok
@@ -0,0 +1,122 @@
+relational-ops.mo:3.6-3.13: warning [M0194], unused identifier testInt (delete or rename to wildcard `_` or `_testInt`)
+relational-ops.mo:4.8-4.11: warning [M0194], unused identifier eq1 (delete or rename to wildcard `_` or `_eq1`)
+relational-ops.mo:5.8-5.11: warning [M0194], unused identifier eq2 (delete or rename to wildcard `_` or `_eq2`)
+relational-ops.mo:6.8-6.12: warning [M0194], unused identifier neq1 (delete or rename to wildcard `_` or `_neq1`)
+relational-ops.mo:7.8-7.12: warning [M0194], unused identifier neq2 (delete or rename to wildcard `_` or `_neq2`)
+relational-ops.mo:8.8-8.11: warning [M0194], unused identifier lt1 (delete or rename to wildcard `_` or `_lt1`)
+relational-ops.mo:9.8-9.11: warning [M0194], unused identifier lt2 (delete or rename to wildcard `_` or `_lt2`)
+relational-ops.mo:10.8-10.11: warning [M0194], unused identifier le1 (delete or rename to wildcard `_` or `_le1`)
+relational-ops.mo:11.8-11.11: warning [M0194], unused identifier le2 (delete or rename to wildcard `_` or `_le2`)
+relational-ops.mo:12.8-12.11: warning [M0194], unused identifier gt1 (delete or rename to wildcard `_` or `_gt1`)
+relational-ops.mo:13.8-13.11: warning [M0194], unused identifier gt2 (delete or rename to wildcard `_` or `_gt2`)
+relational-ops.mo:14.8-14.11: warning [M0194], unused identifier ge1 (delete or rename to wildcard `_` or `_ge1`)
+relational-ops.mo:15.8-15.11: warning [M0194], unused identifier ge2 (delete or rename to wildcard `_` or `_ge2`)
+relational-ops.mo:19.6-19.14: warning [M0194], unused identifier testBool (delete or rename to wildcard `_` or `_testBool`)
+relational-ops.mo:20.8-20.11: warning [M0194], unused identifier eq1 (delete or rename to wildcard `_` or `_eq1`)
+relational-ops.mo:21.8-21.11: warning [M0194], unused identifier eq2 (delete or rename to wildcard `_` or `_eq2`)
+relational-ops.mo:22.8-22.12: warning [M0194], unused identifier neq1 (delete or rename to wildcard `_` or `_neq1`)
+relational-ops.mo:23.8-23.12: warning [M0194], unused identifier neq2 (delete or rename to wildcard `_` or `_neq2`)
+relational-ops.mo:27.6-27.13: warning [M0194], unused identifier testNat (delete or rename to wildcard `_` or `_testNat`)
+relational-ops.mo:28.8-28.11: warning [M0194], unused identifier eq1 (delete or rename to wildcard `_` or `_eq1`)
+relational-ops.mo:29.8-29.11: warning [M0194], unused identifier eq2 (delete or rename to wildcard `_` or `_eq2`)
+relational-ops.mo:30.8-30.12: warning [M0194], unused identifier neq1 (delete or rename to wildcard `_` or `_neq1`)
+relational-ops.mo:31.8-31.12: warning [M0194], unused identifier neq2 (delete or rename to wildcard `_` or `_neq2`)
+relational-ops.mo:32.8-32.11: warning [M0194], unused identifier lt1 (delete or rename to wildcard `_` or `_lt1`)
+relational-ops.mo:33.8-33.11: warning [M0194], unused identifier lt2 (delete or rename to wildcard `_` or `_lt2`)
+relational-ops.mo:34.8-34.11: warning [M0194], unused identifier le1 (delete or rename to wildcard `_` or `_le1`)
+relational-ops.mo:35.8-35.11: warning [M0194], unused identifier le2 (delete or rename to wildcard `_` or `_le2`)
+relational-ops.mo:36.8-36.11: warning [M0194], unused identifier gt1 (delete or rename to wildcard `_` or `_gt1`)
+relational-ops.mo:37.8-37.11: warning [M0194], unused identifier gt2 (delete or rename to wildcard `_` or `_gt2`)
+relational-ops.mo:38.8-38.11: warning [M0194], unused identifier ge1 (delete or rename to wildcard `_` or `_ge1`)
+relational-ops.mo:39.8-39.11: warning [M0194], unused identifier ge2 (delete or rename to wildcard `_` or `_ge2`)
+relational-ops.mo:43.6-43.15: warning [M0194], unused identifier testFloat (delete or rename to wildcard `_` or `_testFloat`)
+relational-ops.mo:44.8-44.11: warning [M0194], unused identifier eq1 (delete or rename to wildcard `_` or `_eq1`)
+relational-ops.mo:45.8-45.11: warning [M0194], unused identifier eq2 (delete or rename to wildcard `_` or `_eq2`)
+relational-ops.mo:46.8-46.12: warning [M0194], unused identifier neq1 (delete or rename to wildcard `_` or `_neq1`)
+relational-ops.mo:47.8-47.12: warning [M0194], unused identifier neq2 (delete or rename to wildcard `_` or `_neq2`)
+relational-ops.mo:48.8-48.11: warning [M0194], unused identifier lt1 (delete or rename to wildcard `_` or `_lt1`)
+relational-ops.mo:49.8-49.11: warning [M0194], unused identifier lt2 (delete or rename to wildcard `_` or `_lt2`)
+relational-ops.mo:50.8-50.11: warning [M0194], unused identifier le1 (delete or rename to wildcard `_` or `_le1`)
+relational-ops.mo:51.8-51.11: warning [M0194], unused identifier le2 (delete or rename to wildcard `_` or `_le2`)
+relational-ops.mo:52.8-52.11: warning [M0194], unused identifier gt1 (delete or rename to wildcard `_` or `_gt1`)
+relational-ops.mo:53.8-53.11: warning [M0194], unused identifier gt2 (delete or rename to wildcard `_` or `_gt2`)
+relational-ops.mo:54.8-54.11: warning [M0194], unused identifier ge1 (delete or rename to wildcard `_` or `_ge1`)
+relational-ops.mo:55.8-55.11: warning [M0194], unused identifier ge2 (delete or rename to wildcard `_` or `_ge2`)
+relational-ops.mo:58.6-58.14: warning [M0194], unused identifier testNat8 (delete or rename to wildcard `_` or `_testNat8`)
+relational-ops.mo:59.8-59.11: warning [M0194], unused identifier eq1 (delete or rename to wildcard `_` or `_eq1`)
+relational-ops.mo:60.8-60.11: warning [M0194], unused identifier eq2 (delete or rename to wildcard `_` or `_eq2`)
+relational-ops.mo:61.8-61.12: warning [M0194], unused identifier neq1 (delete or rename to wildcard `_` or `_neq1`)
+relational-ops.mo:62.8-62.12: warning [M0194], unused identifier neq2 (delete or rename to wildcard `_` or `_neq2`)
+relational-ops.mo:63.8-63.11: warning [M0194], unused identifier lt1 (delete or rename to wildcard `_` or `_lt1`)
+relational-ops.mo:64.8-64.11: warning [M0194], unused identifier lt2 (delete or rename to wildcard `_` or `_lt2`)
+relational-ops.mo:65.8-65.11: warning [M0194], unused identifier le1 (delete or rename to wildcard `_` or `_le1`)
+relational-ops.mo:66.8-66.11: warning [M0194], unused identifier le2 (delete or rename to wildcard `_` or `_le2`)
+relational-ops.mo:67.8-67.11: warning [M0194], unused identifier gt1 (delete or rename to wildcard `_` or `_gt1`)
+relational-ops.mo:68.8-68.11: warning [M0194], unused identifier gt2 (delete or rename to wildcard `_` or `_gt2`)
+relational-ops.mo:69.8-69.11: warning [M0194], unused identifier ge1 (delete or rename to wildcard `_` or `_ge1`)
+relational-ops.mo:70.8-70.11: warning [M0194], unused identifier ge2 (delete or rename to wildcard `_` or `_ge2`)
+relational-ops.mo:73.6-73.15: warning [M0194], unused identifier testNat16 (delete or rename to wildcard `_` or `_testNat16`)
+relational-ops.mo:74.8-74.11: warning [M0194], unused identifier eq1 (delete or rename to wildcard `_` or `_eq1`)
+relational-ops.mo:75.8-75.11: warning [M0194], unused identifier eq2 (delete or rename to wildcard `_` or `_eq2`)
+relational-ops.mo:76.8-76.12: warning [M0194], unused identifier neq1 (delete or rename to wildcard `_` or `_neq1`)
+relational-ops.mo:77.8-77.12: warning [M0194], unused identifier neq2 (delete or rename to wildcard `_` or `_neq2`)
+relational-ops.mo:78.8-78.11: warning [M0194], unused identifier lt1 (delete or rename to wildcard `_` or `_lt1`)
+relational-ops.mo:79.8-79.11: warning [M0194], unused identifier lt2 (delete or rename to wildcard `_` or `_lt2`)
+relational-ops.mo:80.8-80.11: warning [M0194], unused identifier le1 (delete or rename to wildcard `_` or `_le1`)
+relational-ops.mo:81.8-81.11: warning [M0194], unused identifier le2 (delete or rename to wildcard `_` or `_le2`)
+relational-ops.mo:82.8-82.11: warning [M0194], unused identifier gt1 (delete or rename to wildcard `_` or `_gt1`)
+relational-ops.mo:83.8-83.11: warning [M0194], unused identifier gt2 (delete or rename to wildcard `_` or `_gt2`)
+relational-ops.mo:84.8-84.11: warning [M0194], unused identifier ge1 (delete or rename to wildcard `_` or `_ge1`)
+relational-ops.mo:85.8-85.11: warning [M0194], unused identifier ge2 (delete or rename to wildcard `_` or `_ge2`)
+relational-ops.mo:88.6-88.15: warning [M0194], unused identifier testNat32 (delete or rename to wildcard `_` or `_testNat32`)
+relational-ops.mo:89.8-89.11: warning [M0194], unused identifier eq1 (delete or rename to wildcard `_` or `_eq1`)
+relational-ops.mo:90.8-90.11: warning [M0194], unused identifier eq2 (delete or rename to wildcard `_` or `_eq2`)
+relational-ops.mo:91.8-91.12: warning [M0194], unused identifier neq1 (delete or rename to wildcard `_` or `_neq1`)
+relational-ops.mo:92.8-92.12: warning [M0194], unused identifier neq2 (delete or rename to wildcard `_` or `_neq2`)
+relational-ops.mo:93.8-93.11: warning [M0194], unused identifier lt1 (delete or rename to wildcard `_` or `_lt1`)
+relational-ops.mo:94.8-94.11: warning [M0194], unused identifier lt2 (delete or rename to wildcard `_` or `_lt2`)
+relational-ops.mo:95.8-95.11: warning [M0194], unused identifier le1 (delete or rename to wildcard `_` or `_le1`)
+relational-ops.mo:96.8-96.11: warning [M0194], unused identifier le2 (delete or rename to wildcard `_` or `_le2`)
+relational-ops.mo:97.8-97.11: warning [M0194], unused identifier gt1 (delete or rename to wildcard `_` or `_gt1`)
+relational-ops.mo:98.8-98.11: warning [M0194], unused identifier gt2 (delete or rename to wildcard `_` or `_gt2`)
+relational-ops.mo:99.8-99.11: warning [M0194], unused identifier ge1 (delete or rename to wildcard `_` or `_ge1`)
+relational-ops.mo:100.8-100.11: warning [M0194], unused identifier ge2 (delete or rename to wildcard `_` or `_ge2`)
+relational-ops.mo:103.6-103.15: warning [M0194], unused identifier testNat64 (delete or rename to wildcard `_` or `_testNat64`)
+relational-ops.mo:104.8-104.11: warning [M0194], unused identifier eq1 (delete or rename to wildcard `_` or `_eq1`)
+relational-ops.mo:105.8-105.11: warning [M0194], unused identifier eq2 (delete or rename to wildcard `_` or `_eq2`)
+relational-ops.mo:106.8-106.12: warning [M0194], unused identifier neq1 (delete or rename to wildcard `_` or `_neq1`)
+relational-ops.mo:107.8-107.12: warning [M0194], unused identifier neq2 (delete or rename to wildcard `_` or `_neq2`)
+relational-ops.mo:108.8-108.11: warning [M0194], unused identifier lt1 (delete or rename to wildcard `_` or `_lt1`)
+relational-ops.mo:109.8-109.11: warning [M0194], unused identifier lt2 (delete or rename to wildcard `_` or `_lt2`)
+relational-ops.mo:110.8-110.11: warning [M0194], unused identifier le1 (delete or rename to wildcard `_` or `_le1`)
+relational-ops.mo:111.8-111.11: warning [M0194], unused identifier le2 (delete or rename to wildcard `_` or `_le2`)
+relational-ops.mo:112.8-112.11: warning [M0194], unused identifier gt1 (delete or rename to wildcard `_` or `_gt1`)
+relational-ops.mo:113.8-113.11: warning [M0194], unused identifier gt2 (delete or rename to wildcard `_` or `_gt2`)
+relational-ops.mo:114.8-114.11: warning [M0194], unused identifier ge1 (delete or rename to wildcard `_` or `_ge1`)
+relational-ops.mo:115.8-115.11: warning [M0194], unused identifier ge2 (delete or rename to wildcard `_` or `_ge2`)
+relational-ops.mo:119.6-119.14: warning [M0194], unused identifier testChar (delete or rename to wildcard `_` or `_testChar`)
+relational-ops.mo:120.8-120.11: warning [M0194], unused identifier eq1 (delete or rename to wildcard `_` or `_eq1`)
+relational-ops.mo:121.8-121.11: warning [M0194], unused identifier eq2 (delete or rename to wildcard `_` or `_eq2`)
+relational-ops.mo:122.8-122.12: warning [M0194], unused identifier neq1 (delete or rename to wildcard `_` or `_neq1`)
+relational-ops.mo:123.8-123.12: warning [M0194], unused identifier neq2 (delete or rename to wildcard `_` or `_neq2`)
+relational-ops.mo:124.8-124.11: warning [M0194], unused identifier lt1 (delete or rename to wildcard `_` or `_lt1`)
+relational-ops.mo:125.8-125.11: warning [M0194], unused identifier lt2 (delete or rename to wildcard `_` or `_lt2`)
+relational-ops.mo:126.8-126.11: warning [M0194], unused identifier le1 (delete or rename to wildcard `_` or `_le1`)
+relational-ops.mo:127.8-127.11: warning [M0194], unused identifier le2 (delete or rename to wildcard `_` or `_le2`)
+relational-ops.mo:128.8-128.11: warning [M0194], unused identifier gt1 (delete or rename to wildcard `_` or `_gt1`)
+relational-ops.mo:129.8-129.11: warning [M0194], unused identifier gt2 (delete or rename to wildcard `_` or `_gt2`)
+relational-ops.mo:130.8-130.11: warning [M0194], unused identifier ge1 (delete or rename to wildcard `_` or `_ge1`)
+relational-ops.mo:131.8-131.11: warning [M0194], unused identifier ge2 (delete or rename to wildcard `_` or `_ge2`)
+relational-ops.mo:134.6-134.14: warning [M0194], unused identifier testText (delete or rename to wildcard `_` or `_testText`)
+relational-ops.mo:135.8-135.11: warning [M0194], unused identifier eq1 (delete or rename to wildcard `_` or `_eq1`)
+relational-ops.mo:136.8-136.11: warning [M0194], unused identifier eq2 (delete or rename to wildcard `_` or `_eq2`)
+relational-ops.mo:137.8-137.12: warning [M0194], unused identifier neq1 (delete or rename to wildcard `_` or `_neq1`)
+relational-ops.mo:138.8-138.12: warning [M0194], unused identifier neq2 (delete or rename to wildcard `_` or `_neq2`)
+relational-ops.mo:139.8-139.11: warning [M0194], unused identifier lt1 (delete or rename to wildcard `_` or `_lt1`)
+relational-ops.mo:140.8-140.11: warning [M0194], unused identifier lt2 (delete or rename to wildcard `_` or `_lt2`)
+relational-ops.mo:141.8-141.11: warning [M0194], unused identifier le1 (delete or rename to wildcard `_` or `_le1`)
+relational-ops.mo:142.8-142.11: warning [M0194], unused identifier le2 (delete or rename to wildcard `_` or `_le2`)
+relational-ops.mo:143.8-143.11: warning [M0194], unused identifier gt1 (delete or rename to wildcard `_` or `_gt1`)
+relational-ops.mo:144.8-144.11: warning [M0194], unused identifier gt2 (delete or rename to wildcard `_` or `_gt2`)
+relational-ops.mo:145.8-145.11: warning [M0194], unused identifier ge1 (delete or rename to wildcard `_` or `_ge1`)
+relational-ops.mo:146.8-146.11: warning [M0194], unused identifier ge2 (delete or rename to wildcard `_` or `_ge2`)
diff --git a/test/run/ok/show.tc.ok b/test/run/ok/show.tc.ok
new file mode 100644
index 00000000000..244128bcb0f
--- /dev/null
+++ b/test/run/ok/show.tc.ok
@@ -0,0 +1 @@
+show.mo:63.77-63.83: warning [M0194], unused identifier hidden (delete or rename to wildcard `_` or `_hidden`)
diff --git a/test/run/ok/sort-record-fields.tc.ok b/test/run/ok/sort-record-fields.tc.ok
new file mode 100644
index 00000000000..2a74f9468c1
--- /dev/null
+++ b/test/run/ok/sort-record-fields.tc.ok
@@ -0,0 +1,8 @@
+sort-record-fields.mo:2.6-2.9: warning [M0194], unused identifier bad (delete or rename to wildcard `_` or `_bad`)
+sort-record-fields.mo:2.12-2.16: warning [M0194], unused identifier name (delete or rename to wildcard `_` or `_name`)
+sort-record-fields.mo:2.25-2.28: warning [M0194], unused identifier age (delete or rename to wildcard `_` or `_age`)
+sort-record-fields.mo:3.6-3.8: warning [M0194], unused identifier ok (delete or rename to wildcard `_` or `_ok`)
+sort-record-fields.mo:3.11-3.14: warning [M0194], unused identifier age (delete or rename to wildcard `_` or `_age`)
+sort-record-fields.mo:3.22-3.26: warning [M0194], unused identifier name (delete or rename to wildcard `_` or `_name`)
+sort-record-fields.mo:4.11-4.15: warning [M0194], unused identifier name (delete or rename to wildcard `_` or `_name`)
+sort-record-fields.mo:4.17-4.20: warning [M0194], unused identifier age (delete or rename to wildcard `_` or `_age`)
diff --git a/test/run/ok/static-call-rec.tc.ok b/test/run/ok/static-call-rec.tc.ok
new file mode 100644
index 00000000000..15f3ee62204
--- /dev/null
+++ b/test/run/ok/static-call-rec.tc.ok
@@ -0,0 +1 @@
+static-call-rec.mo:3.12-3.13: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
diff --git a/test/run/ok/struct-eq.tc.ok b/test/run/ok/struct-eq.tc.ok
new file mode 100644
index 00000000000..00d7e57f5d4
--- /dev/null
+++ b/test/run/ok/struct-eq.tc.ok
@@ -0,0 +1 @@
+struct-eq.mo:26.6-26.7: warning [M0194], unused identifier e (delete or rename to wildcard `_` or `_e`)
diff --git a/test/run/ok/switch.tc.ok b/test/run/ok/switch.tc.ok
index 3b3006aa0e7..2eb9546c271 100644
--- a/test/run/ok/switch.tc.ok
+++ b/test/run/ok/switch.tc.ok
@@ -17,3 +17,6 @@ switch.mo:97.11-99.2: warning [M0145], this switch of type
   ?Nat
 does not cover value
   ?(_)
+switch.mo:80.6-80.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+switch.mo:90.6-90.7: warning [M0194], unused identifier g (delete or rename to wildcard `_` or `_g`)
+switch.mo:93.10-93.11: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
diff --git a/test/run/ok/tuples.tc.ok b/test/run/ok/tuples.tc.ok
new file mode 100644
index 00000000000..baacb77c003
--- /dev/null
+++ b/test/run/ok/tuples.tc.ok
@@ -0,0 +1,2 @@
+tuples.mo:19.6-19.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+tuples.mo:19.22-19.23: warning [M0194], unused identifier n (delete or rename to wildcard `_` or `_n`)
diff --git a/test/run/ok/typ-field-lub-glb.tc.ok b/test/run/ok/typ-field-lub-glb.tc.ok
new file mode 100644
index 00000000000..70cc870b25b
--- /dev/null
+++ b/test/run/ok/typ-field-lub-glb.tc.ok
@@ -0,0 +1,4 @@
+typ-field-lub-glb.mo:50.6-50.10: warning [M0194], unused identifier oktx (delete or rename to wildcard `_` or `_oktx`)
+typ-field-lub-glb.mo:50.35-50.36: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+typ-field-lub-glb.mo:56.6-56.9: warning [M0194], unused identifier okx (delete or rename to wildcard `_` or `_okx`)
+typ-field-lub-glb.mo:56.18-56.19: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
diff --git a/test/run/ok/type-bin.tc.ok b/test/run/ok/type-bin.tc.ok
new file mode 100644
index 00000000000..74747a928d8
--- /dev/null
+++ b/test/run/ok/type-bin.tc.ok
@@ -0,0 +1,16 @@
+type-bin.mo:2.5-2.6: warning [M0194], unused identifier b (delete or rename to wildcard `_` or `_b`)
+type-bin.mo:3.5-3.6: warning [M0194], unused identifier c (delete or rename to wildcard `_` or `_c`)
+type-bin.mo:4.5-4.6: warning [M0194], unused identifier d (delete or rename to wildcard `_` or `_d`)
+type-bin.mo:5.5-5.6: warning [M0194], unused identifier e (delete or rename to wildcard `_` or `_e`)
+type-bin.mo:6.5-6.6: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-bin.mo:7.5-7.6: warning [M0194], unused identifier g (delete or rename to wildcard `_` or `_g`)
+type-bin.mo:8.5-8.6: warning [M0194], unused identifier h (delete or rename to wildcard `_` or `_h`)
+type-bin.mo:9.5-9.6: warning [M0194], unused identifier i (delete or rename to wildcard `_` or `_i`)
+type-bin.mo:10.5-10.6: warning [M0194], unused identifier j (delete or rename to wildcard `_` or `_j`)
+type-bin.mo:11.5-11.6: warning [M0194], unused identifier k (delete or rename to wildcard `_` or `_k`)
+type-bin.mo:12.5-12.6: warning [M0194], unused identifier l (delete or rename to wildcard `_` or `_l`)
+type-bin.mo:13.5-13.6: warning [M0194], unused identifier m (delete or rename to wildcard `_` or `_m`)
+type-bin.mo:14.5-14.6: warning [M0194], unused identifier o (delete or rename to wildcard `_` or `_o`)
+type-bin.mo:15.5-15.6: warning [M0194], unused identifier p (delete or rename to wildcard `_` or `_p`)
+type-bin.mo:16.5-16.6: warning [M0194], unused identifier q (delete or rename to wildcard `_` or `_q`)
+type-bin.mo:17.5-17.6: warning [M0194], unused identifier z (delete or rename to wildcard `_` or `_z`)
diff --git a/test/run/ok/type-combine.tc.ok b/test/run/ok/type-combine.tc.ok
index 6685b150b03..4d499a26fb2 100644
--- a/test/run/ok/type-combine.tc.ok
+++ b/test/run/ok/type-combine.tc.ok
@@ -75,3 +75,14 @@ left operand is
   <A <: Nat>() -> ()
 right operand is
   <A <: Int>() -> ()
+type-combine.mo:252.6-252.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-combine.mo:426.44-426.45: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+type-combine.mo:427.50-427.51: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+type-combine.mo:428.56-428.57: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+type-combine.mo:429.68-429.69: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+type-combine.mo:430.70-430.71: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+type-combine.mo:452.43-452.44: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+type-combine.mo:453.49-453.50: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+type-combine.mo:454.55-454.56: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+type-combine.mo:455.67-455.68: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+type-combine.mo:456.69-456.70: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
diff --git a/test/run/ok/type-definition.tc.ok b/test/run/ok/type-definition.tc.ok
new file mode 100644
index 00000000000..a6492cad24d
--- /dev/null
+++ b/test/run/ok/type-definition.tc.ok
@@ -0,0 +1,4 @@
+type-definition.mo:13.7-13.8: warning [M0194], unused identifier D (delete or rename to wildcard `_` or `_D`)
+type-definition.mo:13.24-13.25: warning [M0194], unused identifier r (delete or rename to wildcard `_` or `_r`)
+type-definition.mo:16.7-16.8: warning [M0194], unused identifier E (delete or rename to wildcard `_` or `_E`)
+type-definition.mo:16.27-16.28: warning [M0194], unused identifier r (delete or rename to wildcard `_` or `_r`)
diff --git a/test/run/ok/type-equivalence.tc.ok b/test/run/ok/type-equivalence.tc.ok
new file mode 100644
index 00000000000..c328addcc15
--- /dev/null
+++ b/test/run/ok/type-equivalence.tc.ok
@@ -0,0 +1,44 @@
+type-equivalence.mo:6.6-6.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-equivalence.mo:12.6-12.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-equivalence.mo:20.6-20.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-equivalence.mo:28.6-28.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-equivalence.mo:34.6-34.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-equivalence.mo:40.6-40.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-equivalence.mo:50.6-50.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-equivalence.mo:60.6-60.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-equivalence.mo:67.6-67.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-equivalence.mo:75.6-75.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-equivalence.mo:84.6-84.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-equivalence.mo:91.6-91.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-equivalence.mo:98.6-98.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-equivalence.mo:105.6-105.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-equivalence.mo:112.6-112.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-equivalence.mo:128.6-128.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-equivalence.mo:134.6-134.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-equivalence.mo:141.6-141.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-equivalence.mo:148.6-148.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-equivalence.mo:149.6-149.7: warning [M0194], unused identifier g (delete or rename to wildcard `_` or `_g`)
+type-equivalence.mo:150.6-150.7: warning [M0194], unused identifier h (delete or rename to wildcard `_` or `_h`)
+type-equivalence.mo:158.6-158.8: warning [M0194], unused identifier f1 (delete or rename to wildcard `_` or `_f1`)
+type-equivalence.mo:159.6-159.8: warning [M0194], unused identifier f2 (delete or rename to wildcard `_` or `_f2`)
+type-equivalence.mo:160.6-160.8: warning [M0194], unused identifier g1 (delete or rename to wildcard `_` or `_g1`)
+type-equivalence.mo:161.6-161.8: warning [M0194], unused identifier g2 (delete or rename to wildcard `_` or `_g2`)
+type-equivalence.mo:162.6-162.8: warning [M0194], unused identifier h1 (delete or rename to wildcard `_` or `_h1`)
+type-equivalence.mo:163.6-163.8: warning [M0194], unused identifier h2 (delete or rename to wildcard `_` or `_h2`)
+type-equivalence.mo:173.6-173.8: warning [M0194], unused identifier f1 (delete or rename to wildcard `_` or `_f1`)
+type-equivalence.mo:174.6-174.8: warning [M0194], unused identifier f2 (delete or rename to wildcard `_` or `_f2`)
+type-equivalence.mo:175.6-175.8: warning [M0194], unused identifier g1 (delete or rename to wildcard `_` or `_g1`)
+type-equivalence.mo:176.6-176.8: warning [M0194], unused identifier g2 (delete or rename to wildcard `_` or `_g2`)
+type-equivalence.mo:182.6-182.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-equivalence.mo:188.6-188.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-equivalence.mo:197.6-197.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-equivalence.mo:198.6-198.7: warning [M0194], unused identifier g (delete or rename to wildcard `_` or `_g`)
+type-equivalence.mo:199.6-199.7: warning [M0194], unused identifier h (delete or rename to wildcard `_` or `_h`)
+type-equivalence.mo:209.6-209.8: warning [M0194], unused identifier f1 (delete or rename to wildcard `_` or `_f1`)
+type-equivalence.mo:210.6-210.8: warning [M0194], unused identifier f2 (delete or rename to wildcard `_` or `_f2`)
+type-equivalence.mo:211.6-211.8: warning [M0194], unused identifier g1 (delete or rename to wildcard `_` or `_g1`)
+type-equivalence.mo:212.6-212.8: warning [M0194], unused identifier g2 (delete or rename to wildcard `_` or `_g2`)
+type-equivalence.mo:222.6-222.8: warning [M0194], unused identifier f1 (delete or rename to wildcard `_` or `_f1`)
+type-equivalence.mo:223.6-223.8: warning [M0194], unused identifier f2 (delete or rename to wildcard `_` or `_f2`)
+type-equivalence.mo:224.6-224.8: warning [M0194], unused identifier g1 (delete or rename to wildcard `_` or `_g1`)
+type-equivalence.mo:225.6-225.8: warning [M0194], unused identifier g2 (delete or rename to wildcard `_` or `_g2`)
diff --git a/test/run/ok/type-inclusion.tc.ok b/test/run/ok/type-inclusion.tc.ok
new file mode 100644
index 00000000000..5f0806f31d8
--- /dev/null
+++ b/test/run/ok/type-inclusion.tc.ok
@@ -0,0 +1,49 @@
+type-inclusion.mo:6.6-6.8: warning [M0194], unused identifier f1 (delete or rename to wildcard `_` or `_f1`)
+type-inclusion.mo:7.6-7.8: warning [M0194], unused identifier f2 (delete or rename to wildcard `_` or `_f2`)
+type-inclusion.mo:8.6-8.8: warning [M0194], unused identifier f3 (delete or rename to wildcard `_` or `_f3`)
+type-inclusion.mo:9.6-9.8: warning [M0194], unused identifier f4 (delete or rename to wildcard `_` or `_f4`)
+type-inclusion.mo:10.6-10.8: warning [M0194], unused identifier f5 (delete or rename to wildcard `_` or `_f5`)
+type-inclusion.mo:18.6-18.8: warning [M0194], unused identifier f1 (delete or rename to wildcard `_` or `_f1`)
+type-inclusion.mo:19.6-19.8: warning [M0194], unused identifier f2 (delete or rename to wildcard `_` or `_f2`)
+type-inclusion.mo:20.6-20.8: warning [M0194], unused identifier f3 (delete or rename to wildcard `_` or `_f3`)
+type-inclusion.mo:21.6-21.8: warning [M0194], unused identifier f4 (delete or rename to wildcard `_` or `_f4`)
+type-inclusion.mo:22.6-22.8: warning [M0194], unused identifier f5 (delete or rename to wildcard `_` or `_f5`)
+type-inclusion.mo:28.6-28.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-inclusion.mo:35.6-35.8: warning [M0194], unused identifier f1 (delete or rename to wildcard `_` or `_f1`)
+type-inclusion.mo:37.6-37.8: warning [M0194], unused identifier f3 (delete or rename to wildcard `_` or `_f3`)
+type-inclusion.mo:39.6-39.8: warning [M0194], unused identifier f5 (delete or rename to wildcard `_` or `_f5`)
+type-inclusion.mo:48.6-48.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-inclusion.mo:54.6-54.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-inclusion.mo:62.6-62.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-inclusion.mo:70.6-70.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-inclusion.mo:76.6-76.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-inclusion.mo:86.6-86.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-inclusion.mo:93.29-93.30: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+type-inclusion.mo:96.6-96.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-inclusion.mo:100.29-100.30: warning [M0194], unused identifier x (delete or rename to wildcard `_` or `_x`)
+type-inclusion.mo:103.6-103.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-inclusion.mo:112.6-112.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-inclusion.mo:118.6-118.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-inclusion.mo:124.6-124.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-inclusion.mo:130.6-130.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-inclusion.mo:136.6-136.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-inclusion.mo:143.6-143.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-inclusion.mo:174.6-174.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-inclusion.mo:181.6-181.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-inclusion.mo:188.6-188.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-inclusion.mo:189.6-189.7: warning [M0194], unused identifier g (delete or rename to wildcard `_` or `_g`)
+type-inclusion.mo:197.6-197.8: warning [M0194], unused identifier f1 (delete or rename to wildcard `_` or `_f1`)
+type-inclusion.mo:198.6-198.8: warning [M0194], unused identifier f2 (delete or rename to wildcard `_` or `_f2`)
+type-inclusion.mo:199.6-199.8: warning [M0194], unused identifier g1 (delete or rename to wildcard `_` or `_g1`)
+type-inclusion.mo:200.6-200.8: warning [M0194], unused identifier g2 (delete or rename to wildcard `_` or `_g2`)
+type-inclusion.mo:201.6-201.8: warning [M0194], unused identifier h1 (delete or rename to wildcard `_` or `_h1`)
+type-inclusion.mo:202.6-202.8: warning [M0194], unused identifier h2 (delete or rename to wildcard `_` or `_h2`)
+type-inclusion.mo:208.6-208.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-inclusion.mo:214.6-214.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-inclusion.mo:223.6-223.7: warning [M0194], unused identifier f (delete or rename to wildcard `_` or `_f`)
+type-inclusion.mo:224.6-224.7: warning [M0194], unused identifier g (delete or rename to wildcard `_` or `_g`)
+type-inclusion.mo:225.6-225.7: warning [M0194], unused identifier h (delete or rename to wildcard `_` or `_h`)
+type-inclusion.mo:235.6-235.8: warning [M0194], unused identifier f1 (delete or rename to wildcard `_` or `_f1`)
+type-inclusion.mo:236.6-236.8: warning [M0194], unused identifier f2 (delete or rename to wildcard `_` or `_f2`)
+type-inclusion.mo:237.6-237.8: warning [M0194], unused identifier g1 (delete or rename to wildcard `_` or `_g1`)
+type-inclusion.mo:238.6-238.8: warning [M0194], unused identifier g2 (delete or rename to wildcard `_` or `_g2`)
diff --git a/test/run/ok/type-inference.tc.ok b/test/run/ok/type-inference.tc.ok
index c724815cef3..cea5dc29dc0 100644
--- a/test/run/ok/type-inference.tc.ok
+++ b/test/run/ok/type-inference.tc.ok
@@ -75,3 +75,13 @@ type-inference.mo:175.19-175.24: warning [M0155], operator may trap for inferred
   Nat
 type-inference.mo:186.5-186.10: warning [M0155], operator may trap for inferred type
   Nat
+type-inference.mo:43.5-43.6: warning [M0194], unused identifier z (delete or rename to wildcard `_` or `_z`)
+type-inference.mo:51.5-51.6: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
+type-inference.mo:61.6-61.9: warning [M0194], unused identifier top (delete or rename to wildcard `_` or `_top`)
+type-inference.mo:74.6-74.9: warning [M0194], unused identifier bot (delete or rename to wildcard `_` or `_bot`)
+type-inference.mo:76.7-76.8: warning [M0194], unused identifier b (delete or rename to wildcard `_` or `_b`)
+type-inference.mo:77.7-77.8: warning [M0194], unused identifier c (delete or rename to wildcard `_` or `_c`)
+type-inference.mo:78.7-78.8: warning [M0194], unused identifier d (delete or rename to wildcard `_` or `_d`)
+type-inference.mo:79.7-79.8: warning [M0194], unused identifier e (delete or rename to wildcard `_` or `_e`)
+type-inference.mo:149.6-149.9: warning [M0194], unused identifier sub (delete or rename to wildcard `_` or `_sub`)
+type-inference.mo:188.8-188.9: warning [M0194], unused identifier h (delete or rename to wildcard `_` or `_h`)
diff --git a/test/run/ok/unused-class.tc.ok b/test/run/ok/unused-class.tc.ok
new file mode 100644
index 00000000000..04db485826b
--- /dev/null
+++ b/test/run/ok/unused-class.tc.ok
@@ -0,0 +1,10 @@
+unused-class.mo:1.7-1.22: warning [M0194], unused identifier UnusedTestClass (delete or rename to wildcard `_` or `_UnusedTestClass`)
+unused-class.mo:2.9-2.14: warning [M0194], unused identifier field (delete or rename to wildcard `_` or `_field`)
+unused-class.mo:5.21-5.36: warning [M0194], unused identifier classParameter1 (delete or rename to wildcard `_` or `_classParameter1`)
+unused-class.mo:5.44-5.59: warning [M0194], unused identifier classParameter2 (delete or rename to wildcard `_` or `_classParameter2`)
+unused-class.mo:8.9-8.15: warning [M0194], unused identifier field3 (delete or rename to wildcard `_` or `_field3`)
+unused-class.mo:9.9-9.15: warning [M0194], unused identifier field4 (delete or rename to wildcard `_` or `_field4`)
+unused-class.mo:11.10-11.22: warning [M0194], unused identifier unusedMethod (delete or rename to wildcard `_` or `_unusedMethod`)
+unused-class.mo:11.23-11.38: warning [M0194], unused identifier unusedParameter (delete or rename to wildcard `_` or `_unusedParameter`)
+unused-class.mo:13.13-13.19: warning [M0194], unused identifier local2 (delete or rename to wildcard `_` or `_local2`)
+unused-class.mo:18.5-18.11: warning [M0194], unused identifier result (delete or rename to wildcard `_` or `_result`)
diff --git a/test/run/ok/unused-module-identifier.tc.ok b/test/run/ok/unused-module-identifier.tc.ok
new file mode 100644
index 00000000000..d8561e5de16
--- /dev/null
+++ b/test/run/ok/unused-module-identifier.tc.ok
@@ -0,0 +1,2 @@
+unused-module-identifier.mo:7.8-7.20: warning [M0194], unused identifier UnusedModule (delete or rename to wildcard `_` or `_UnusedModule`)
+unused-module-identifier.mo:8.12-8.27: warning [M0194], unused identifier UnusedSubModule (delete or rename to wildcard `_` or `_UnusedSubModule`)
diff --git a/test/run/ok/unused-object.tc.ok b/test/run/ok/unused-object.tc.ok
new file mode 100644
index 00000000000..0a06b2337a3
--- /dev/null
+++ b/test/run/ok/unused-object.tc.ok
@@ -0,0 +1,8 @@
+unused-object.mo:1.8-1.24: warning [M0194], unused identifier UnusedTestObject (delete or rename to wildcard `_` or `_UnusedTestObject`)
+unused-object.mo:2.9-2.14: warning [M0194], unused identifier field (delete or rename to wildcard `_` or `_field`)
+unused-object.mo:8.9-8.15: warning [M0194], unused identifier field3 (delete or rename to wildcard `_` or `_field3`)
+unused-object.mo:9.9-9.15: warning [M0194], unused identifier field4 (delete or rename to wildcard `_` or `_field4`)
+unused-object.mo:11.10-11.22: warning [M0194], unused identifier unusedMethod (delete or rename to wildcard `_` or `_unusedMethod`)
+unused-object.mo:11.23-11.38: warning [M0194], unused identifier unusedParameter (delete or rename to wildcard `_` or `_unusedParameter`)
+unused-object.mo:13.13-13.19: warning [M0194], unused identifier local2 (delete or rename to wildcard `_` or `_local2`)
+unused-object.mo:17.5-17.11: warning [M0194], unused identifier result (delete or rename to wildcard `_` or `_result`)
diff --git a/test/run/ok/unused-shadowing.tc.ok b/test/run/ok/unused-shadowing.tc.ok
new file mode 100644
index 00000000000..f10b86efc58
--- /dev/null
+++ b/test/run/ok/unused-shadowing.tc.ok
@@ -0,0 +1,6 @@
+unused-shadowing.mo:2.5-2.14: warning [M0194], unused identifier variable2 (delete or rename to wildcard `_` or `_variable2`)
+unused-shadowing.mo:4.6-4.24: warning [M0194], unused identifier testUnusedFunction (delete or rename to wildcard `_` or `_testUnusedFunction`)
+unused-shadowing.mo:4.43-4.53: warning [M0194], unused identifier parameter2 (delete or rename to wildcard `_` or `_parameter2`)
+unused-shadowing.mo:5.9-5.18: warning [M0194], unused identifier variable2 (delete or rename to wildcard `_` or `_variable2`)
+unused-shadowing.mo:7.9-7.18: warning [M0194], unused identifier variable4 (delete or rename to wildcard `_` or `_variable4`)
+unused-shadowing.mo:10.13-10.26: warning [M0194], unused identifier localFunction (delete or rename to wildcard `_` or `_localFunction`)
diff --git a/test/run/ok/unused-switch-case.tc.ok b/test/run/ok/unused-switch-case.tc.ok
new file mode 100644
index 00000000000..98efb5890af
--- /dev/null
+++ b/test/run/ok/unused-switch-case.tc.ok
@@ -0,0 +1,2 @@
+unused-switch-case.mo:2.12-2.19: warning [M0194], unused identifier unused1 (delete or rename to wildcard `_` or `_unused1`)
+unused-switch-case.mo:3.10-3.17: warning [M0194], unused identifier unused2 (delete or rename to wildcard `_` or `_unused2`)
diff --git a/test/run/ok/variants.tc.ok b/test/run/ok/variants.tc.ok
new file mode 100644
index 00000000000..a9aaf74f3d1
--- /dev/null
+++ b/test/run/ok/variants.tc.ok
@@ -0,0 +1 @@
+variants.mo:27.5-27.8: warning [M0194], unused identifier ts3 (delete or rename to wildcard `_` or `_ts3`)
diff --git a/test/run/ok/vec-any-bomb.tc.ok b/test/run/ok/vec-any-bomb.tc.ok
new file mode 100644
index 00000000000..78529ff2c1f
--- /dev/null
+++ b/test/run/ok/vec-any-bomb.tc.ok
@@ -0,0 +1 @@
+vec-any-bomb.mo:2.8-2.12: warning [M0194], unused identifier Prim (delete or rename to wildcard `_` or `_Prim`)
diff --git a/test/run/optimise-for-array.mo b/test/run/optimise-for-array.mo
index 17ec6e66dd1..45f46d115fb 100644
--- a/test/run/optimise-for-array.mo
+++ b/test/run/optimise-for-array.mo
@@ -3,85 +3,87 @@ import Prim "mo:⛔";
 
 // Differences between incremental and non-incremental compilation (additional forwarding header field).
 
-// CHECK: (local $check0 i32)
+// FHECK: (local $check0 i32)
 
-// CHECK-NOT:  call $@immut_array_size
-// DON'TCHECK: i32.load offset=9
-// CHECK:      i32.load offset= 
-// CHECK:      i32.const 2
-// CHECK:      i32.shl
-// DON'TCHECK: i32.load offset=13
-// CHECK:      local.tee $check0
-// CHECK-NEXT: call $print_text
-// CHECK:      i32.const 4
-// CHECK-NEXT: i32.add
+// FHECK-NOT:  call $@immut_array_size
+// DON'TFHECK: i32.load offset=9
+// FHECK:      i32.load offset= 
+// FHECK:      i32.const 2
+// FHECK:      i32.shl
+// FHECK:      i32.lt_u
+// FHECK:      i32.add
+// DON'TFHECK: i32.load offset=13
+// FHECK:      local.tee $check0
+// FHECK-NEXT: call $print_text
+// FHECK:      i32.const 4
+// FHECK-NEXT: i32.add
 for (check0 in ["hello", "world"].vals()) { Prim.debugPrint check0 };
 
 
-// CHECK-NOT:  call $@mut_array_size
-// DON'TCHECK: i32.load offset=9
-// CHECK:      i32.load offset=
-// CHECK:      i32.const 2
-// CHECK:      i32.shl
-// DON'TCHECK: i32.load offset=13
-// CHECK:      local.tee $check1
-// CHECK-NEXT: call $print_text
-// CHECK:      i32.const 4
-// CHECK-NEXT: i32.add
+// FHECK-NOT:  call $@mut_array_size
+// DON'TFHECK: i32.load offset=9
+// FHECK:      i32.load offset=
+// FHECK:      i32.const 2
+// FHECK-NEXT: i32.shl
+// FHECK:      i32.lt_u
+// FHECK:      i32.add
+// DON'TFHECK: i32.load offset=13
+// FHECK:      i32.load offset=
+// FHECK-NEXT: local.tee $check1
+// FHECK-NEXT: call $print_text
 for (check1 in [var "hello", "mutable", "world"].vals()) { Prim.debugPrint check1 };
 
 let array = [var "hello", "remutable", "world"];
 array[1] := "mutable";
-// CHECK-NOT:   call $@immut_array_size
-// DON'TCHECK:  i32.load offset=9
-// CHECK:       i32.load offset=
-// CHECK:       i32.const 2
-// CHECK:       i32.shl
-// DON'T-CHECK: i32.lt_u
-// DON'T-CHECK: local.get $array
-// DON'T-CHECK: local.set $check2
+// FHECK-NOT:   call $@immut_array_size
+// DON'TFHECK:  i32.load offset=9
+// FHECK:       i32.load offset=
+// FHECK:       i32.const 2
+// FHECK:       i32.shl
+// DON'T-FHECK: i32.lt_u
+// DON'T-FHECK: local.get $array
+// DON'T-FHECK: local.set $check2
 // `arr` being a `VarE` already (but we rebind anyway, otherwise we open a can of worms)
 // later when we have path compression for variables in the backend, we can bring this back
 for (check2 in array.vals()) { Prim.debugPrint check2 };
 
-// CHECK-NOT:  call $@immut_array_size
-// DON'TCHECK: i32.load offset=9
-// CHECK:      i32.load offset=
-// CHECK:      i32.const 2
-// CHECK:      i32.shl
-// CHECK:      i32.lt_u
-// CHECK:      i32.add
-// DON'TCHECK: i32.load offset=13
-// CHECK:      local.tee $check3
-// CHECK:      i32.const 4
-// CHECK-NEXT: i32.add
+// FHECK-NOT:  call $@immut_array_size
+// DON'TFHECK: i32.load offset=9
+// FHECK:      i32.load offset=
+// FHECK:      i32.const 2
+// FHECK:      i32.shl
+// FHECK:      i32.lt_u
+// FHECK:      i32.add
+// DON'TFHECK: i32.load offset=13
+// FHECK:      i32.load offset=
+// FHECK-NEXT: local.tee $check3
 // interfering parentheses don't disturb us
 for (check3 in (((["hello", "immutable", "world"].vals())))) { Prim.debugPrint check3 };
 
 
-// CHECK:      i32.const 84
-// CHECK:      call $B_add
-// CHECK-NEXT: call $B_eq
-// CHECK-NEXT: if
-// CHECK-NEXT: loop
-// CHECK-NEXT: br 0
-// CHECK-NEXT: end
-// CHECK-NEXT: unreachable
-// CHECK-NEXT: else
+// FHECK:      i32.const 84
+// FHECK:      call $B_add
+// FHECK-NEXT: call $B_eq
+// FHECK-NEXT: if
+// FHECK-NEXT: loop
+// FHECK-NEXT: br 0
+// FHECK-NEXT: end
+// FHECK-NEXT: unreachable
+// FHECK-NEXT: else
 // bottom iteration expression is treated fairly
 var c = 42;
 if (c == c + 1) {
     for (check4 in (loop {}).vals()) { Prim.debugPrint check4 }
 };
 
-// CHECK:      call $B_add
-// CHECK-NEXT: call $B_eq
-// CHECK-NEXT: if
-// CHECK-NEXT: loop
-// CHECK-NEXT: br 0
-// CHECK-NEXT: end
-// CHECK-NEXT: unreachable
-// CHECK-NEXT: else
+// FHECK:      call $B_add
+// FHECK-NEXT: call $B_eq
+// FHECK-NEXT: if
+// FHECK-NEXT: loop
+// FHECK-NEXT: br 0
+// FHECK-NEXT: end
+// FHECK-NEXT: unreachable
+// FHECK-NEXT: else
 // typed bottom iteration expression is treated fairly
 if (c == c + 1) {
     for (check5 in ((loop {}) : [Text]).vals()) { Prim.debugPrint check5 }
@@ -93,24 +95,24 @@ check6[1] := "mutable";
 // this passes the IR type check, which demonstrates that no name capture happens
 for (check6 in check6.vals()) { ignore check6 };
 
-// DON'TCHECK: i32.load offset=9
-// CHECK:      i32.load offset=
-// CHECK:      i32.const 2
-// CHECK:      i32.shl
+// DON'TFHECK: i32.load offset=9
+// FHECK:      i32.load offset=
+// FHECK:      i32.const 2
+// FHECK:      i32.shl
 // argument to vals can have an effect too, expect it
 for (check7 in [].vals(Prim.debugPrint "want to see you")) { };
 
-// CHECK:      local.set $num8
-// CHECK-NOT:  call $@immut_array_size
-// DON'TCHECK: i32.load offset=9
-// CHECK:      i32.load offset=
-// CHECK:      i32.const 1
-// CHECK:      i32.shl
-// CHECK:      i32.lt_u
-// CHECK-NOT:  i32.add
-// CHECK:      local.tee $check8
-// CHECK-NEXT: local.get $num8
-// CHECK-NEXT: call $B_add
+// FHECK:      local.set $num8
+// FHECK-NOT:  call $@immut_array_size
+// DON'TFHECK: i32.load offset=9
+// FHECK:      i32.load offset=
+// FHECK:      i32.const 1
+// FHECK:      i32.shl
+// FHECK:      i32.lt_u
+// FHECK-NOT:  i32.add
+// FHECK:      local.tee $check8
+// FHECK-NEXT: local.get $num8
+// FHECK-NEXT: call $B_add
 var num8 = 42;
 num8 := 25;
 // `keys` is even easier to rewrite, as the "indexing expression" is just the
diff --git a/test/run/static-func-call.mo b/test/run/static-func-call.mo
index c5d08b663f1..f510625112c 100644
--- a/test/run/static-func-call.mo
+++ b/test/run/static-func-call.mo
@@ -2,5 +2,5 @@
 
 // CHECK: func $init
 // CHECK-NOT: call_indirect
-// CHECK: call $anon-func-
+// CHECK: call $@anon-func-
 
diff --git a/test/run/unboxed-let.mo b/test/run/unboxed-let.mo
index 026f8c7fed4..2831ad26d93 100644
--- a/test/run/unboxed-let.mo
+++ b/test/run/unboxed-let.mo
@@ -43,42 +43,42 @@ func goValidFloat(x : Float) { assert (x * x == 4); }; goValidFloat(2);
 
 // We have to do the filechecks in reverse order:
 
-// CHECK: func $goValidFloat
-// CHECK: f64.load
-// CHECK: unreachable
-
-// CHECK: func $goValidNat64
-// CHECK: unbox_i64
-// CHECK: unreachable
-
-// CHECK: func $goValidNat32
-// CHECK: unbox_i32
-// CHECK: unreachable
-
-// CHECK: func $goFloat
-// CHECK-NOT: f64.load
-// CHECK-STORE: f64.load
-// CHECK: unreachable
-
-// CHECK: func $goInt64
-// CHECK-NOT: box_i64
-// CHECK-NOT: unbox_i64
-// CHECK: unreachable
-
-// CHECK: func $goNat64
-// CHECK-NOT: box_i64
-// CHECK-NOT: unbox_i64
-// CHECK: unreachable
-
-// CHECK: func $goInt32
-// CHECK-NOT: box_i32
-// CHECK-NOT: unbox_i32
-// CHECK: unreachable
-
-// CHECK: func $goNat32
-// CHECK-NOT: box_i32
-// CHECK-NOT: unbox_i32
-// CHECK: unreachable
+// FHECK: func $goValidFloat
+// FHECK: f64.load
+// FHECK: unreachable
+
+// FHECK: func $goValidNat64
+// FHECK: unbox_i64
+// FHECK: unreachable
+
+// FHECK: func $goValidNat32
+// FHECK: unbox_i32
+// FHECK: unreachable
+
+// FHECK: func $goFloat
+// FHECK-NOT: f64.load
+// FHECK-STORE: f64.load
+// FHECK: unreachable
+
+// FHECK: func $goInt64
+// FHECK-NOT: box_i64
+// FHECK-NOT: unbox_i64
+// FHECK: unreachable
+
+// FHECK: func $goNat64
+// FHECK-NOT: box_i64
+// FHECK-NOT: unbox_i64
+// FHECK: unreachable
+
+// FHECK: func $goInt32
+// FHECK-NOT: box_i32
+// FHECK-NOT: unbox_i32
+// FHECK: unreachable
+
+// FHECK: func $goNat32
+// FHECK-NOT: box_i32
+// FHECK-NOT: unbox_i32
+// FHECK: unreachable
 
 
 
diff --git a/test/run/unused-class.mo b/test/run/unused-class.mo
new file mode 100644
index 00000000000..fdce5c6ff9d
--- /dev/null
+++ b/test/run/unused-class.mo
@@ -0,0 +1,18 @@
+class UnusedTestClass() {
+    let field = 0;
+};
+
+class UsedTestClass(classParameter1 : Nat, classParameter2 : Int) {
+    public let field1 = 1;
+    var field2 = 2;
+    let field3 = field1;
+    var field4 = field2;
+
+    func unusedMethod(unusedParameter : Any) {
+        let local1 = 0;
+        let local2 = local1;
+    };
+};
+
+let test = UsedTestClass(0, 0);
+let result = test.field1;
diff --git a/test/run/unused-module-identifier.mo b/test/run/unused-module-identifier.mo
new file mode 100644
index 00000000000..af7c4b89f4a
--- /dev/null
+++ b/test/run/unused-module-identifier.mo
@@ -0,0 +1,11 @@
+module UsedModule {
+    public module SubModule {
+        public type T1 = Nat;
+    };
+};
+
+module UnusedModule {
+    module UnusedSubModule {};
+};
+
+type T2 = UsedModule.SubModule.T1;
diff --git a/test/run/unused-object.mo b/test/run/unused-object.mo
new file mode 100644
index 00000000000..bb88b9dfe9e
--- /dev/null
+++ b/test/run/unused-object.mo
@@ -0,0 +1,17 @@
+object UnusedTestObject {
+    let field = 0;
+};
+
+object UsedTestObject {
+    public let field1 = 1;
+    var field2 = 2;
+    let field3 = field1;
+    var field4 = field2;
+
+    func unusedMethod(unusedParameter : Any) {
+        let local1 = 0;
+        let local2 = local1;
+    };
+};
+
+let result = UsedTestObject.field1;
diff --git a/test/run/unused-object2.mo b/test/run/unused-object2.mo
new file mode 100644
index 00000000000..31beaa79d5e
--- /dev/null
+++ b/test/run/unused-object2.mo
@@ -0,0 +1,5 @@
+let o = object abc {
+  let usedVariable = "ea";
+  public func usedFunction() : Text { usedVariable };
+};
+ignore o.usedFunction();
diff --git a/test/run/unused-shadowing.mo b/test/run/unused-shadowing.mo
new file mode 100644
index 00000000000..4e50a557bc8
--- /dev/null
+++ b/test/run/unused-shadowing.mo
@@ -0,0 +1,16 @@
+let variable1 = 1;
+var variable2 = 2;
+
+func testUnusedFunction(parameter1 : Nat, parameter2 : Int) {
+    var variable2 = 2;
+    let variable3 = 3;
+    var variable4 = 4;
+    var variable5 = 5;
+    if (variable1 == 0 and variable3 == 3) {
+        let localFunction = func() {
+            let variable2 = parameter1;
+            let parameter2 = 2;
+            variable5 *= variable2 + parameter2;
+        };
+    };
+};
diff --git a/test/run/unused-switch-case.mo b/test/run/unused-switch-case.mo
new file mode 100644
index 00000000000..f31a1610283
--- /dev/null
+++ b/test/run/unused-switch-case.mo
@@ -0,0 +1,4 @@
+switch (?1) {
+    case (?unused1) {};
+    case unused2 {};
+};
diff --git a/test/run/unused-underscore.mo b/test/run/unused-underscore.mo
new file mode 100644
index 00000000000..4a67803773e
--- /dev/null
+++ b/test/run/unused-underscore.mo
@@ -0,0 +1,16 @@
+let variable1 = 1;
+var _variable2 = 2;
+
+func _testUnusedFunction(parameter1 : Nat, _parameter2 : Int) {
+    var _variable2 = 2;
+    let variable3 = 3;
+    var _variable4 = 4;
+    var variable5 = 5;
+    if (variable1 == 0 and variable3 == 3) {
+        let _localFunction = func() {
+            let variable2 = parameter1;
+            let parameter2 = 2;
+            variable5 *= variable2 + parameter2;
+        };
+    };
+};
diff --git a/test/run/variant-specials.mo b/test/run/variant-specials.mo
index 56d2e661849..74d717ec9ea 100644
--- a/test/run/variant-specials.mo
+++ b/test/run/variant-specials.mo
@@ -24,4 +24,4 @@ specials(#one 42, #c1)
 //CHECK-NOT: i32.const 22126
 //CHECK: local.set $count
 
-//CHECK: i32.const 246
+//CHECK: i32.const 494
diff --git a/test/run/words.mo b/test/run/words.mo
index 1c9b709f6e2..15a68eef250 100644
--- a/test/run/words.mo
+++ b/test/run/words.mo
@@ -1,24 +1,24 @@
 //MOC-FLAG -fshared-code
 import Prim "mo:⛔";
 
-// CHECK: func $init
+// FHECK: func $init
 
 // check for `Eqz` optimisation
-// CHECK: i64.const 424242
+// FHECK: i64.const 424242
 assert not (424242 : Nat64 == 1);
-// CHECK-NOT: i64.eqz
+// FHECK-NOT: i64.eqz
 assert not (3 : Nat64 == 0);
 assert (0 : Nat64 == 0);
-// CHECK: i64.const 424342
+// FHECK: i64.const 424342
 assert not (424342 : Nat64 == 1);
 
 // check for `Eqz` optimisation
-// CHECK: i32.const 424542
+// FHECK: i32.const 424542
 assert not (424542 : Nat32 == 1);
-// CHECK-NOT: i32.eqz
+// FHECK-NOT: i32.eqz
 assert not (3 : Nat32 == 0);
 assert (0 : Nat32 == 0);
-// CHECK: i32.const 424842
+// FHECK: i32.const 424842
 assert not (424842 : Nat32 == 1);
 
 func printBit(a : Bool) { Prim.debugPrint(if a "set" else "clear") };
@@ -51,19 +51,19 @@ do {
     let e : Nat64 = 20000;
 
 // this is the value of c
-// CHECK: i32.const 17825530
-// CHECK-NOT: call $box_i64
-// CHECK: call $printN64ln
+// FHECK: i32.const 17825530
+// FHECK-NOT: call $box_i64
+// FHECK: call $printN64ln
     printN64ln(c);
     printN64ln(^c);
     printN64ln(a +% c);
     printN64ln(c -% a);
 
-// CHECK: call $checkpointAlpha
+// FHECK: call $checkpointAlpha
     checkpointAlpha();
 // This is a native Wasm i64 multiplication, there should be no shift involved!
-// CHECK-NOT: i64.shr_u
-// CHECK: call $printN64ln
+// FHECK-NOT: i64.shr_u
+// FHECK: call $printN64ln
     printN64ln(a * b);
 
     printN64ln(a / b);
@@ -111,22 +111,22 @@ do {
     let d : Int32 = -15;
     let e : Nat32 = 20000;
 
-// CHECK: call $checkpointBravo
+// FHECK: call $checkpointBravo
     checkpointBravo();
 // this is the value of c
-// CHECK: i32.const 17825530
-// CHECK-NOT: call $box_i64
-// CHECK: call $printN32ln
+// FHECK: i32.const 17825530
+// FHECK-NOT: call $box_i64
+// FHECK: call $printN32ln
     printN32ln(c);
     printN32ln(^c);
     printN32ln(a + c);
     printN32ln(c - a);
 
-// CHECK: call $checkpointCharlie
+// FHECK: call $checkpointCharlie
     checkpointCharlie();
 // This is a native Wasm i32 multiplication, there should be no shift involved!
-// CHECK-NOT: i32.shr_u
-// CHECK: call $printN32ln
+// FHECK-NOT: i32.shr_u
+// FHECK: call $printN32ln
     printN32ln(a * b);
     printN32ln(a / b);
     printN32ln(c % a);
@@ -176,17 +176,17 @@ do {
     printN16ln(a +% c);
     printN16ln(c -% a);
 
-// CHECK: call $checkpointDelta
+// FHECK: call $checkpointDelta
     checkpointDelta();
 // this is the value of a
-// CHECK: i32.const 299302912
+// FHECK: i32.const 299302912
 // this is the value of b
-// CHECK: i32.const 458752
+// FHECK: i32.const 458752
 // This is not a native Wasm i32 multiplication, we need to shift one of the args left by 16 bits!
-// CHECK-NEXT: i32.const 16
-// CHECK-NEXT: i32.shr_u
-// CHECK-NEXT: i32.mul
-// CHECK-NEXT: call $printN16ln
+// FHECK-NEXT: i32.const 16
+// FHECK-NEXT: i32.shr_u
+// FHECK-NEXT: i32.mul
+// FHECK-NEXT: call $printN16ln
     printN16ln(a *% b);
     printN16ln(a / b);
     printN16ln(c % a);
@@ -197,38 +197,38 @@ do {
     printN16ln(a ^ c);
     printN16ln(a << b);
 
-// CHECK: call $checkpointEcho
+// FHECK: call $checkpointEcho
    checkpointEcho();
 // this is the value of b
-// CHECK: i32.const 458752
+// FHECK: i32.const 458752
 // This is not a native Wasm i32 left shift, we need to shift the second arg left by 16 bits and clamp it to 4 bits!
-// CHECK-NEXT: i32.const 16
-// CHECK-NEXT: i32.shr_u
-// CHECK-NEXT: i32.const 15
-// CHECK-NEXT: i32.and
-// CHECK-NEXT: i32.shr_u
+// FHECK-NEXT: i32.const 16
+// FHECK-NEXT: i32.shr_u
+// FHECK-NEXT: i32.const 15
+// FHECK-NEXT: i32.and
+// FHECK-NEXT: i32.shr_u
 // Then the result must be sanitised.
-// CHECK-NEXT: i32.const -65536
-// CHECK-NEXT: i32.and
-// CHECK-NEXT: call $printN16ln
+// FHECK-NEXT: i32.const -65536
+// FHECK-NEXT: i32.and
+// FHECK-NEXT: call $printN16ln
     printN16ln(a >> b);
     printN16ln(Prim.int16ToNat16(d) >> 3); // -15 = 0xfff1 = 0b1111_1111_1111_0001 (shifted = 0b0001_1111_1111_1110 = 8190)
     printI16ln(d >> 3); // -15 = 0xfff1 = 0b1111_1111_1111_0001 (shifted = 0b1111_1111_1111_1110 = -2)
 
-// CHECK: call $checkpointFoxtrot
+// FHECK: call $checkpointFoxtrot
    checkpointFoxtrot();
 // this is the value of b
-// CHECK: i32.const 458752
-// CHECK-NEXT: call $rotl<Nat16>
-// CHECK-NEXT: call $printN16ln
+// FHECK: i32.const 458752
+// FHECK-NEXT: call $rotl<Nat16>
+// FHECK-NEXT: call $printN16ln
     printN16ln(c <<> b);
 
-// CHECK: call $checkpointGolf
+// FHECK: call $checkpointGolf
    checkpointGolf();
 // this is the value of b
-// CHECK: i32.const 458752
-// CHECK-NEXT: call $rotr<Nat16>
-// CHECK-NEXT: call $printN16ln
+// FHECK: i32.const 458752
+// FHECK-NEXT: call $rotr<Nat16>
+// FHECK-NEXT: call $printN16ln
     printN16ln(c <>> b);
     printI16ln(Prim.popcntInt16 d); // -15 = 0xfff1 = 0b1111_1111_1111_0001 (population = 13)
     printN16ln(Prim.clzNat16 e); // 20000 = 0x4e20 (leading zeros = 1)
@@ -264,15 +264,15 @@ do {
     printN8ln(^c);
     printN8ln(a + c);
     printN8ln(c -% a);
-// CHECK: call $checkpointHotel
+// FHECK: call $checkpointHotel
     checkpointHotel();
 // this is the value of b
-// CHECK: i32.const 117440512
+// FHECK: i32.const 117440512
 // This is not a native Wasm i32 multiplication, we need to shift one of the args left by 24 bits!
-// CHECK-NEXT: i32.const 24
-// CHECK-NEXT: i32.shr_u
-// CHECK-NEXT: i32.mul
-// CHECK-NEXT: call $printN8ln
+// FHECK-NEXT: i32.const 24
+// FHECK-NEXT: i32.shr_u
+// FHECK-NEXT: i32.mul
+// FHECK-NEXT: call $printN8ln
     printN8ln(a *% b);
     printN8ln(a / b);
     printN8ln(c % a);
@@ -283,35 +283,35 @@ do {
     printN8ln(a ^ c);
     printN8ln(a << b);
 
-// CHECK: call $checkpointIndia
+// FHECK: call $checkpointIndia
     checkpointIndia();
 // this is the value of b
-// CHECK: i32.const 117440512
+// FHECK: i32.const 117440512
 // This is not a native Wasm i32 left shift, we need to shift the second arg left by 24 bits and clamp it to 3 bits!
-// CHECK-NEXT: i32.const 24
-// CHECK-NEXT: i32.shr_u
-// CHECK-NEXT: i32.const 7
-// CHECK-NEXT: i32.and
-// CHECK-NEXT: i32.shr_u
+// FHECK-NEXT: i32.const 24
+// FHECK-NEXT: i32.shr_u
+// FHECK-NEXT: i32.const 7
+// FHECK-NEXT: i32.and
+// FHECK-NEXT: i32.shr_u
 // Then the result must be sanitised.
-// CHECK-NEXT: i32.const -16777216
-// CHECK-NEXT: i32.and
-// CHECK-NEXT: call $printN8ln
+// FHECK-NEXT: i32.const -16777216
+// FHECK-NEXT: i32.and
+// FHECK-NEXT: call $printN8ln
     printN8ln(a >> b);
     printN8ln(Prim.int8ToNat8(d) >> 3); // -15 = 0xf1 = 0b1111_0001 (shifted = 0b0001_1110 = 30)
     printI8ln(d >> 3); // -15 = 0xf1 = 0b1111_0001 (shifted = 0b1111_1110 = -2)
 
-// CHECK: call $checkpointJuliett
+// FHECK: call $checkpointJuliett
     checkpointJuliett();
 // this is the value of b
-// CHECK: i32.const 117440512
-// CHECK-NEXT: call $rotl<Nat8>
-// CHECK-NEXT: call $printN8ln
+// FHECK: i32.const 117440512
+// FHECK-NEXT: call $rotl<Nat8>
+// FHECK-NEXT: call $printN8ln
     printN8ln(c <<> b);
 // this is the value of b
-// CHECK: i32.const 117440512
-// CHECK-NEXT: call $rotr<Nat8>
-// CHECK-NEXT: call $printN8ln
+// FHECK: i32.const 117440512
+// FHECK-NEXT: call $rotr<Nat8>
+// FHECK-NEXT: call $printN8ln
     printN8ln(c <>> b);
     printI8ln(Prim.popcntInt8 d); // -15 = 0xf1 = 0b1111_0001 (population = 5)
     printN8ln(Prim.clzNat8 e); // 200 = 0xC8 (leading zeros = 0)
diff --git a/test/test-moc.js b/test/test-moc.js
index be9f1e36159..7629ebe9cd5 100644
--- a/test/test-moc.js
+++ b/test/test-moc.js
@@ -170,4 +170,41 @@ service : {
   main: () -> (T) query;
 }
 `.trim() + '\n';
-assert.deepStrictEqual(Motoko.candid('ast.mo'), {diagnostics: [], code: candid});
+assert.deepStrictEqual(Motoko.candid('ast.mo'), {
+  diagnostics: [
+    {
+      category: 'type',
+      code: 'M0194',
+      message: 'unused identifier Prim (delete or rename to wildcard `_` or `_Prim`)',
+      range: {
+        end: {
+          character: 13,
+          line: 3
+        },
+        start: {
+          character: 9,
+          line: 3
+        }
+      },
+      severity: 2,
+      source: 'ast.mo'
+    },
+    {
+      category: 'type',
+      code: 'M0194',
+      message: 'unused identifier M (delete or rename to wildcard `_` or `_M`)',
+      range: {
+        end: {
+          character: 12,
+          line: 13
+        },
+        start: {
+          character: 11,
+          line: 13
+        }
+      },
+      severity: 2,
+      source: 'ast.mo'
+    }
+  ], code: candid
+});

From ef695659c4125cf6d30dbd682f0dde3f6399ef5b Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 29 Feb 2024 13:18:17 +0100
Subject: [PATCH 166/260] Merge branch 'master' into luc/stable-heap

---
 test/run-drun/ok/unused-actor-class.drun-run.ok  | 5 -----
 test/run-drun/ok/unused-actor-fields.drun-run.ok | 5 -----
 test/run-drun/ok/unused-import.drun-run.ok       | 5 -----
 3 files changed, 15 deletions(-)

diff --git a/test/run-drun/ok/unused-actor-class.drun-run.ok b/test/run-drun/ok/unused-actor-class.drun-run.ok
index 49ba4f7d573..a6f776f43c6 100644
--- a/test/run-drun/ok/unused-actor-class.drun-run.ok
+++ b/test/run-drun/ok/unused-actor-class.drun-run.ok
@@ -1,7 +1,2 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-<<<<<<<< HEAD:test/run-drun/ok/unused-actor-class.drun-run.ok
-========
-debug.print: {heap_diff = 0; instr_diff = 5_662_310_728}
-ingress Completed: Reply: 0x4449444c0000
->>>>>>>> master:test/bench/ok/region-mem.drun-run-opt.ok
diff --git a/test/run-drun/ok/unused-actor-fields.drun-run.ok b/test/run-drun/ok/unused-actor-fields.drun-run.ok
index 5cea4d9f4ff..a6f776f43c6 100644
--- a/test/run-drun/ok/unused-actor-fields.drun-run.ok
+++ b/test/run-drun/ok/unused-actor-fields.drun-run.ok
@@ -1,7 +1,2 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-<<<<<<<< HEAD:test/run-drun/ok/unused-actor-fields.drun-run.ok
-========
-debug.print: {heap_diff = 0; instr_diff = 5_838_471_496}
-ingress Completed: Reply: 0x4449444c0000
->>>>>>>> master:test/bench/ok/region0-mem.drun-run-opt.ok
diff --git a/test/run-drun/ok/unused-import.drun-run.ok b/test/run-drun/ok/unused-import.drun-run.ok
index 7de82a7a248..5bbab1e840c 100644
--- a/test/run-drun/ok/unused-import.drun-run.ok
+++ b/test/run-drun/ok/unused-import.drun-run.ok
@@ -1,8 +1,3 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
-<<<<<<<< HEAD:test/run-drun/ok/unused-import.drun-run.ok
 debug.print: Test
-========
-ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 3_510_632_776}
->>>>>>>> master:test/bench/ok/stable-mem.drun-run-opt.ok
 ingress Completed: Reply: 0x4449444c0000

From 3e43218f0cf7aa315e62d0f3239f2eb94510edb9 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 28 Sep 2023 09:46:48 +0200
Subject: [PATCH 167/260] Distinguish tuple type in memory compatibility check

---
 rts/motoko-rts/src/idl.rs                     | 30 ++++++++++++++++++-
 src/codegen/compile.ml                        |  7 ++++-
 .../run-drun/ok/tuple-record-mismatch.drun.ok |  5 ++++
 test/run-drun/tuple-record-mismatch.drun      |  4 +++
 .../tuple-record-mismatch/version0.mo         |  3 ++
 .../tuple-record-mismatch/version1.mo         |  3 ++
 .../tuple-record-mismatch/version2.mo         |  3 ++
 7 files changed, 53 insertions(+), 2 deletions(-)
 create mode 100644 test/run-drun/ok/tuple-record-mismatch.drun.ok
 create mode 100644 test/run-drun/tuple-record-mismatch.drun
 create mode 100644 test/run-drun/tuple-record-mismatch/version0.mo
 create mode 100644 test/run-drun/tuple-record-mismatch/version1.mo
 create mode 100644 test/run-drun/tuple-record-mismatch/version2.mo

diff --git a/rts/motoko-rts/src/idl.rs b/rts/motoko-rts/src/idl.rs
index 18ddce2db40..0bd16c300a8 100644
--- a/rts/motoko-rts/src/idl.rs
+++ b/rts/motoko-rts/src/idl.rs
@@ -45,13 +45,16 @@ const IDL_REF_principal: i32 = -24;
 
 // Extended Candid only
 const IDL_EXT_region: i32 = -128;
-const IDL_EXT_blob: i32 = -129;
 
 // Extended Candid only
 const IDL_CON_alias: i32 = 1;
 
 const IDL_PRIM_lowest: i32 = -17;
 
+// Only used for memory compatiblity checks for orthogonal persistence.
+const IDL_EXT_blob: i32 = -129;
+const IDL_EXT_tuple: i32 = -130;
+
 pub unsafe fn leb128_decode_ptr(buf: *mut Buf) -> (u32, *mut u8) {
     (leb128_decode(buf), (*buf).ptr)
 }
@@ -208,6 +211,8 @@ unsafe fn parse_idl_header<M: Memory>(
             check_typearg(mode, t, n_types);
         } else if ty == IDL_CON_record {
             parse_fields(mode, buf, n_types);
+        } else if ty == IDL_EXT_tuple {
+            parse_fields(mode, buf, n_types);
         } else if ty == IDL_CON_variant {
             parse_fields(mode, buf, n_types);
         } else if ty == IDL_CON_func {
@@ -616,6 +621,8 @@ unsafe fn remember_memory_check(cache: &BitRel, variance: TypeVariance, t1: u32,
 /// * Types cannot be made optional (no insertion of Option).
 /// * Same arity for function parameters and function return types.
 /// * Records cannot introduce additional optional fields.
+/// * Same arity for tuple types.
+/// * Records and tuples are distinct.
 pub(crate) unsafe fn memory_compatible(
     rel: &BitRel,
     variance: TypeVariance,
@@ -779,6 +786,27 @@ pub(crate) unsafe fn memory_compatible(
             }
             a11 == a21 && a12 == a22 && a13 == a23
         }
+        (IDL_EXT_tuple, IDL_EXT_tuple) => {
+            let n1 = leb128_decode(&mut tb1);
+            let n2 = leb128_decode(&mut tb2);
+            if n1 != n2 {
+                return false;
+            }
+            for _ in 0..n1 {
+                let tag1 = leb128_decode(&mut tb1);
+                let t11 = sleb128_decode(&mut tb1);
+                let tag2 = leb128_decode(&mut tb2);
+                let t21 = sleb128_decode(&mut tb2);
+                if tag1 != tag2 {
+                    return false;
+                }
+                if !memory_compatible(rel, variance, typtbl1, typtbl2, end1, end2, t11, t21, false)
+                {
+                    return false;
+                }
+            }
+            true
+        }
         (IDL_CON_record, IDL_CON_record) => {
             let mut n1 = leb128_decode(&mut tb1);
             let n2 = leb128_decode(&mut tb2);
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 976a909c6ad..0dd95d25a52 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -6335,6 +6335,9 @@ module MakeSerialization (Strm : Stream) = struct
   let idl_func      = -22l
   let idl_service   = -23l
   let idl_alias     = 1l (* see Note [mutable stable values] *)
+  
+  (* only used for memory compatibility checks *)
+  let idl_tuple     = -130l
 
   (* TODO: use record *)
   let type_desc env mode ts :
@@ -6428,7 +6431,9 @@ module MakeSerialization (Strm : Stream) = struct
         add_sleb128 idl_alias; add_idx t
       | Prim _ -> assert false
       | Tup ts ->
-        add_sleb128 idl_record;
+        add_sleb128 (match mode with
+        | Candid -> idl_record
+        | Persistence -> idl_tuple);
         add_leb128 (List.length ts);
         List.iteri (fun i t ->
           add_leb128 i;
diff --git a/test/run-drun/ok/tuple-record-mismatch.drun.ok b/test/run-drun/ok/tuple-record-mismatch.drun.ok
new file mode 100644
index 00000000000..c46182ff707
--- /dev/null
+++ b/test/run-drun/ok/tuple-record-mismatch.drun.ok
@@ -0,0 +1,5 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
diff --git a/test/run-drun/tuple-record-mismatch.drun b/test/run-drun/tuple-record-mismatch.drun
new file mode 100644
index 00000000000..729eea35083
--- /dev/null
+++ b/test/run-drun/tuple-record-mismatch.drun
@@ -0,0 +1,4 @@
+install $ID tuple-record-mismatch/version0.mo ""
+upgrade $ID tuple-record-mismatch/version0.mo ""
+upgrade $ID tuple-record-mismatch/version1.mo ""
+upgrade $ID tuple-record-mismatch/version2.mo ""
diff --git a/test/run-drun/tuple-record-mismatch/version0.mo b/test/run-drun/tuple-record-mismatch/version0.mo
new file mode 100644
index 00000000000..8ed43ee698f
--- /dev/null
+++ b/test/run-drun/tuple-record-mismatch/version0.mo
@@ -0,0 +1,3 @@
+actor {
+   stable let test = (0, 1, 2);
+};
diff --git a/test/run-drun/tuple-record-mismatch/version1.mo b/test/run-drun/tuple-record-mismatch/version1.mo
new file mode 100644
index 00000000000..f250a6631ce
--- /dev/null
+++ b/test/run-drun/tuple-record-mismatch/version1.mo
@@ -0,0 +1,3 @@
+actor {
+   stable let test = (0, 1);
+};
diff --git a/test/run-drun/tuple-record-mismatch/version2.mo b/test/run-drun/tuple-record-mismatch/version2.mo
new file mode 100644
index 00000000000..f451d0b7372
--- /dev/null
+++ b/test/run-drun/tuple-record-mismatch/version2.mo
@@ -0,0 +1,3 @@
+actor {
+   stable let test = {};
+};

From affc532e5ff7f505ee3305700bab93c3cef5259c Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 11 Mar 2024 09:52:28 +0100
Subject: [PATCH 168/260] Manual merge conflict resolution

---
 test/run/rtti-bug.mo | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/run/rtti-bug.mo b/test/run/rtti-bug.mo
index 496c5a8af3c..5da98373fa4 100644
--- a/test/run/rtti-bug.mo
+++ b/test/run/rtti-bug.mo
@@ -1,4 +1,4 @@
-//MOC-FLAG --experimental-rtti --sanity-checks
+//MOC-FLAG --sanity-checks
 
 import { debugPrint } "mo:prim";
 

From fa85e2bb228f8c86552b13f6bd1d28160f289d86 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Tue, 12 Mar 2024 20:32:40 +0100
Subject: [PATCH 169/260] Adjust to new upgrade option

---
 src/prelude/internals.mo | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/src/prelude/internals.mo b/src/prelude/internals.mo
index b2a41f4c186..344a9a120f1 100644
--- a/src/prelude/internals.mo
+++ b/src/prelude/internals.mo
@@ -387,8 +387,13 @@ module @ManagementCanister = {
   };
 };
 
+type WasmMemoryPersistence = {
+  #Keep;
+  #Drop;
+};
+
 type UpgradeOptions = { 
-  keep_main_memory: ?Bool;
+  wasm_memory_persistence: ?WasmMemoryPersistence;
 };
 
 let @ic00 = actor "aaaaa-aa" :
@@ -439,7 +444,7 @@ func @install_actor_helper(
       };
       case (#upgrade actor2) {
         let upgradeOptions = {
-          keep_main_memory = ?true;
+          wasm_memory_persistence = ?(#Keep);
         };
         ((#upgrade (?upgradeOptions)), (prim "cast" : (actor {}) -> Principal) actor2)
       }

From 743b9afa66fde2a3c71982b4b6821021e084eddc Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Wed, 13 Mar 2024 09:55:02 +0100
Subject: [PATCH 170/260] Update IC dependency

---
 nix/sources.json | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/nix/sources.json b/nix/sources.json
index 104dd775527..62089f51c07 100644
--- a/nix/sources.json
+++ b/nix/sources.json
@@ -26,10 +26,10 @@
         "homepage": "",
         "owner": "dfinity",
         "repo": "ic",
-        "rev": "b91114192c326a719d6d9a1fbc3e5d481d6fa4b3",
-        "sha256": "0i27f2lvmlgxmwzr1s4ig2cdivd74am93bwybdlgr2gs7pvf7ydm",
+        "rev": "a7dc31400badb6ca7023a6613c09a18434d70ab6",
+        "sha256": "0gap0n3yx7xwhjhigad39ndhp5p49ajr4m2apybmhbbc8smlnlfx",
         "type": "tarball",
-        "url": "https://github.com/dfinity/ic/archive/b91114192c326a719d6d9a1fbc3e5d481d6fa4b3.tar.gz",
+        "url": "https://github.com/dfinity/ic/archive/a7dc31400badb6ca7023a6613c09a18434d70ab6.tar.gz",
         "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
     },
     "ic-hs": {

From 87dfbb77c1d272162d1e20db585178412150a252 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Wed, 13 Mar 2024 11:20:22 +0100
Subject: [PATCH 171/260] Adjust expected test result

---
 test/run-drun/ok/migrate-stabilization.drun.ok | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/run-drun/ok/migrate-stabilization.drun.ok b/test/run-drun/ok/migrate-stabilization.drun.ok
index 69c77832199..adfdd8830de 100644
--- a/test/run-drun/ok/migrate-stabilization.drun.ok
+++ b/test/run-drun/ok/migrate-stabilization.drun.ok
@@ -115,4 +115,4 @@ debug.print: 37 37
 debug.print: 38 38
 debug.print: 39 39
 ingress Completed: Reply: 0x4449444c0000
-ingress Err: IC0504: Missing upgrade option: Enhanced orthogonal persistence requires the `keep_main_memory` upgrade option.
+ingress Err: IC0504: Missing upgrade option: Enhanced orthogonal persistence requires the `wasm_memory_persistence` upgrade option.

From c500dd2e80af0650b0bfb5dfde750635bb9a6761 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 15 Mar 2024 09:09:02 +0100
Subject: [PATCH 172/260] Optimize null pointer

---
 design/OrthogonalPersistence.md               |  8 +-
 rts/motoko-rts-tests/src/gc.rs                |  1 -
 .../src/gc/incremental/roots.rs               |  1 -
 rts/motoko-rts/src/debug.rs                   |  2 +-
 rts/motoko-rts/src/gc/incremental.rs          |  1 +
 .../phases/evacuation_increment.rs            |  2 +-
 .../gc/incremental/phases/mark_increment.rs   |  7 +-
 .../gc/incremental/phases/update_increment.rs |  1 +
 rts/motoko-rts/src/gc/incremental/roots.rs    | 11 ++-
 rts/motoko-rts/src/persistence.rs             | 47 +-----------
 rts/motoko-rts/src/static_checks.rs           |  2 -
 rts/motoko-rts/src/types.rs                   | 40 +++++-----
 rts/motoko-rts/src/visitor.rs                 | 34 +++++----
 src/codegen/compile.ml                        | 76 ++++++++-----------
 test/bench/ok/alloc.drun-run.ok               |  6 +-
 test/bench/ok/bignum.drun-run.ok              |  4 +-
 test/bench/ok/palindrome.drun-run.ok          | 12 +--
 test/bench/ok/region-mem.drun-run.ok          |  2 +-
 test/bench/ok/region0-mem.drun-run.ok         |  2 +-
 test/bench/ok/stable-mem.drun-run.ok          |  2 +-
 20 files changed, 100 insertions(+), 161 deletions(-)

diff --git a/design/OrthogonalPersistence.md b/design/OrthogonalPersistence.md
index c891f55ddc9..deefe972d66 100644
--- a/design/OrthogonalPersistence.md
+++ b/design/OrthogonalPersistence.md
@@ -38,7 +38,6 @@ More specifically, it comprises:
 * A stable heap version that allows evolving the persistent memory layout in the future.
 * The stable subset of the main actor, containing all stable variables declared in the main actor.
 * A descriptor of the stable static types to check memory compatibility on upgrades.
-* The reference to the null singleton object.
 * The runtime state of the garbage collector, including the dynamic heap metadata and memory statistics.
 * A reserve for future metadata extensions.
 
@@ -72,7 +71,6 @@ The garbage collector uses two kinds of roots:
 
 The persistent roots are registered in the persistent metadata and comprise:
 * All stable variables of the main actor, only stored during an upgrade.
-* The null singleton object.
 * The stable type table.
 
 The transient roots are referenced by the Wasm data segments and comprise:
@@ -107,10 +105,8 @@ The Rust-generated active data segments of the runtime system is changed to pass
 The location and size of the RTS data segments is therefore limited to a defined reserve, see above. 
 This is acceptable because the RTS only uses small size for data segments (e.g. 54KB) that is independent of the compiled Motoko program.
 
-### Null Singleton
-As an optimization, the top-level `null`` singleton is allocated once in the dynamic heap and remembered in the persistent metadata across upgrades. 
-This is necessary to implement null checks by pointer comparison (however, by first resolving pointer forwarding before the comparison).
-The null singleton needs to be part of the persistent root set.
+### Null Sentinel
+As an optimization, the top-level `null` pointer is represented as a constant sentinel value pointing to the last unallocated Wasm page. This allows fast null tests without involving forwarding pointer resolution of potential non-null comparand pointers.
 
 ### Migration Path
 When migrating from the old serialization-based stabilization to the new stable heap, the old data is deserialized one last time from stable memory and then placed in the new stable heap layout.
diff --git a/rts/motoko-rts-tests/src/gc.rs b/rts/motoko-rts-tests/src/gc.rs
index 4b343e4379d..fbf7aebb766 100644
--- a/rts/motoko-rts-tests/src/gc.rs
+++ b/rts/motoko-rts-tests/src/gc.rs
@@ -484,7 +484,6 @@ fn run(heap: &mut MotokoHeap) -> bool {
                 unused_root,
                 unused_root,
                 unused_root,
-                unused_root,
             ];
             IncrementalGC::instance(heap, get_incremental_gc_state())
                 .empty_call_stack_increment(roots);
diff --git a/rts/motoko-rts-tests/src/gc/incremental/roots.rs b/rts/motoko-rts-tests/src/gc/incremental/roots.rs
index 4d413f3b457..41f6fe195a7 100644
--- a/rts/motoko-rts-tests/src/gc/incremental/roots.rs
+++ b/rts/motoko-rts-tests/src/gc/incremental/roots.rs
@@ -90,7 +90,6 @@ unsafe fn get_roots(heap: &MotokoHeap) -> Roots {
         unused_root,
         unused_root,
         unused_root,
-        unused_root,
     ]
 }
 
diff --git a/rts/motoko-rts/src/debug.rs b/rts/motoko-rts/src/debug.rs
index e7015060eb2..3a7e7268de3 100644
--- a/rts/motoko-rts/src/debug.rs
+++ b/rts/motoko-rts/src/debug.rs
@@ -52,7 +52,7 @@ pub(crate) unsafe fn print_continuation_table(continuation_tbl_loc: *mut Value)
 
     for i in 0..len {
         let elem = arr.get(i);
-        if elem.is_ptr() {
+        if elem.is_non_null_ptr() {
             let _ = write!(&mut write_buf, "{}: ", i);
             print_boxed_object(&mut write_buf, elem.get_ptr());
             print(&write_buf);
diff --git a/rts/motoko-rts/src/gc/incremental.rs b/rts/motoko-rts/src/gc/incremental.rs
index aa4be315254..79f2f2bd66b 100644
--- a/rts/motoko-rts/src/gc/incremental.rs
+++ b/rts/motoko-rts/src/gc/incremental.rs
@@ -328,6 +328,7 @@ unsafe fn pre_write_barrier<M: Memory>(mem: &mut M, state: &mut State, overwritt
         if overwritten_value.points_to_or_beyond(base_address) {
             let mut time = BoundedTime::new(0);
             let mut increment = MarkIncrement::instance(mem, state, &mut time);
+            debug_assert_ne!(overwritten_value, NULL_POINTER);
             increment.mark_object(overwritten_value);
         }
     }
diff --git a/rts/motoko-rts/src/gc/incremental/phases/evacuation_increment.rs b/rts/motoko-rts/src/gc/incremental/phases/evacuation_increment.rs
index 730bc33e04f..58f90925f31 100644
--- a/rts/motoko-rts/src/gc/incremental/phases/evacuation_increment.rs
+++ b/rts/motoko-rts/src/gc/incremental/phases/evacuation_increment.rs
@@ -75,7 +75,7 @@ impl<'a, M: Memory + 'a> EvacuationIncrement<'a, M> {
     }
 
     unsafe fn evacuate_object(&mut self, original: *mut Obj) {
-        debug_assert!(original.tag() >= TAG_OBJECT && original.tag() <= TAG_NULL);
+        debug_assert!(is_object_tag(original.tag()));
         debug_assert!(!original.is_forwarded());
         let size = block_size(original as usize);
         let new_address = self.mem.alloc_words(size);
diff --git a/rts/motoko-rts/src/gc/incremental/phases/mark_increment.rs b/rts/motoko-rts/src/gc/incremental/phases/mark_increment.rs
index d98a8af3988..92fe4836a84 100644
--- a/rts/motoko-rts/src/gc/incremental/phases/mark_increment.rs
+++ b/rts/motoko-rts/src/gc/incremental/phases/mark_increment.rs
@@ -80,7 +80,7 @@ impl<'a, M: Memory + 'a> MarkIncrement<'a, M> {
         }
         loop {
             let value = self.mark_stack.pop();
-            debug_assert!(value.is_ptr());
+            debug_assert!(value.is_non_null_ptr());
             if value == STACK_EMPTY {
                 self.complete_marking();
                 return;
@@ -97,15 +97,14 @@ impl<'a, M: Memory + 'a> MarkIncrement<'a, M> {
 
     pub unsafe fn mark_object(&mut self, value: Value) {
         self.time.tick();
+        debug_assert_ne!(value, NULL_POINTER);
         debug_assert!((value.get_ptr() >= self.heap.base_address()));
         debug_assert!(!value.is_forwarded());
         let object = value.as_obj();
         if self.heap.mark_object(object) {
             // A write barrier after a completed mark phase must see the object as already marked.
             debug_assert!(!*self.complete);
-            debug_assert!(
-                object.tag() >= crate::types::TAG_OBJECT && object.tag() <= crate::types::TAG_NULL
-            );
+            debug_assert!(is_object_tag(object.tag()));
             self.mark_stack.push(self.mem, value);
         }
     }
diff --git a/rts/motoko-rts/src/gc/incremental/phases/update_increment.rs b/rts/motoko-rts/src/gc/incremental/phases/update_increment.rs
index a759e9c8337..4403296c812 100644
--- a/rts/motoko-rts/src/gc/incremental/phases/update_increment.rs
+++ b/rts/motoko-rts/src/gc/incremental/phases/update_increment.rs
@@ -51,6 +51,7 @@ impl<'a> UpdateIncrement<'a> {
     pub unsafe fn update_roots(&mut self, roots: Roots) {
         visit_roots(roots, self, |gc, field| {
             let value = *field;
+            debug_assert_ne!(value, NULL_POINTER);
             if value.is_forwarded() {
                 *field = value.forward_if_possible();
             }
diff --git a/rts/motoko-rts/src/gc/incremental/roots.rs b/rts/motoko-rts/src/gc/incremental/roots.rs
index 5d2731b41a7..3dca8d6df38 100644
--- a/rts/motoko-rts/src/gc/incremental/roots.rs
+++ b/rts/motoko-rts/src/gc/incremental/roots.rs
@@ -1,6 +1,6 @@
 use motoko_rts_macros::ic_mem_fn;
 
-use crate::{types::Value, visitor::is_pointer_field};
+use crate::{types::Value, visitor::is_non_null_pointer_field};
 
 /// Root referring to all canister variables.
 /// This root is reinitialized on each canister upgrade.
@@ -9,13 +9,13 @@ use crate::{types::Value, visitor::is_pointer_field};
 static mut STATIC_ROOT: Value = Value::from_scalar(0);
 
 /// GC root set.
-pub type Roots = [*mut Value; 7];
+pub type Roots = [*mut Value; 6];
 
 #[cfg(feature = "ic")]
 pub unsafe fn root_set() -> Roots {
     use crate::{
         continuation_table::continuation_table_loc,
-        persistence::{null_singleton_location, stable_actor_location, stable_type_descriptor},
+        persistence::{stable_actor_location, stable_type_descriptor},
         region::region0_get_ptr_loc,
     };
     [
@@ -24,7 +24,6 @@ pub unsafe fn root_set() -> Roots {
         stable_actor_location(),
         stable_type_descriptor().candid_data_location(),
         stable_type_descriptor().type_offsets_location(),
-        null_singleton_location(),
         region0_get_ptr_loc(),
     ]
 }
@@ -35,7 +34,7 @@ pub unsafe fn visit_roots<C, V: Fn(&mut C, *mut Value)>(
     visit_field: V,
 ) {
     for location in roots {
-        if is_pointer_field(location) {
+        if is_non_null_pointer_field(location) {
             visit_field(context, location);
         }
     }
@@ -57,6 +56,6 @@ pub unsafe fn set_static_root<M: crate::memory::Memory>(mem: &mut M, value: Valu
 #[no_mangle]
 #[cfg(feature = "ic")]
 pub unsafe extern "C" fn get_static_root() -> Value {
-    assert!(STATIC_ROOT.is_ptr());
+    debug_assert!(STATIC_ROOT.is_non_null_ptr());
     STATIC_ROOT
 }
diff --git a/rts/motoko-rts/src/persistence.rs b/rts/motoko-rts/src/persistence.rs
index 5de70882c8a..cbd9d7d9371 100644
--- a/rts/motoko-rts/src/persistence.rs
+++ b/rts/motoko-rts/src/persistence.rs
@@ -7,13 +7,13 @@ pub mod compatibility;
 use motoko_rts_macros::ic_mem_fn;
 
 use crate::{
-    barriers::{allocation_barrier, write_with_barrier},
+    barriers::write_with_barrier,
     constants::{KB, MB},
     gc::incremental::State,
     memory::Memory,
     persistence::compatibility::memory_compatible,
     rts_trap_with,
-    types::{size_of, Null, Value, TAG_BLOB, TAG_NULL},
+    types::{Value, TAG_BLOB},
 };
 
 use self::compatibility::TypeDescriptor;
@@ -47,9 +47,6 @@ struct PersistentMetadata {
     /// The state of the incremental GC including the partitioned heap description.
     /// The GC continues work after upgrades.
     incremental_gc_state: State,
-    /// Singleton of the top-level null value. To be retained across upgrades.
-    /// Constitutes a GC root and requires pointer forwarding.
-    null_singleton: Value,
     /// Upgrade performance statistics: Total number of instructions consumed by the last upgrade.
     upgrade_instructions: u64,
 }
@@ -78,7 +75,6 @@ impl PersistentMetadata {
                 || (*self).fingerprint == ['\0'; 32]
                     && (*self).stable_actor == DEFAULT_VALUE
                     && (*self).stable_type.is_default()
-                    && (*self).null_singleton == DEFAULT_VALUE
         );
         initialized
     }
@@ -103,7 +99,6 @@ impl PersistentMetadata {
         (*self).stable_actor = DEFAULT_VALUE;
         (*self).stable_type = TypeDescriptor::default();
         (*self).incremental_gc_state = IncrementalGC::initial_gc_state(mem, HEAP_START);
-        (*self).null_singleton = DEFAULT_VALUE;
         (*self).upgrade_instructions = 0;
     }
 }
@@ -118,18 +113,9 @@ pub unsafe fn initialize_memory<M: Memory>(mem: &mut M) {
         metadata.check_version();
     } else {
         metadata.initialize(mem);
-        allocate_initial_objects(mem);
     }
 }
 
-/// Allocate initial objects only after the partitioned heap has been initialized.
-#[cfg(feature = "ic")]
-unsafe fn allocate_initial_objects<M: Memory>(mem: &mut M) {
-    let metadata = PersistentMetadata::get();
-    debug_assert!((*metadata).null_singleton == DEFAULT_VALUE);
-    (*metadata).null_singleton = allocate_null(mem);
-}
-
 /// Returns the stable sub-record of the actor of the upgraded canister version.
 /// Returns scalar 0 if no actor is stored after on a fresh memory.
 #[no_mangle]
@@ -190,15 +176,6 @@ pub unsafe extern "C" fn contains_field(actor: Value, field_hash: u32) -> bool {
     false
 }
 
-pub unsafe fn allocate_null<M: Memory>(mem: &mut M) -> Value {
-    let value = mem.alloc_words(size_of::<Null>());
-    let null = value.get_ptr() as *mut Null;
-    (*null).header.tag = TAG_NULL;
-    (*null).header.init_forward(value);
-    allocation_barrier(value);
-    value
-}
-
 /// Register the stable actor type on canister installation and upgrade.
 /// The type is stored in the persistent metadata memory for later retrieval on canister upgrades.
 /// On an upgrade, the memory compatibility between the new and existing stable type is checked.
@@ -225,26 +202,6 @@ pub(crate) unsafe fn stable_type_descriptor() -> &'static mut TypeDescriptor {
     &mut (*metadata).stable_type
 }
 
-/// Get the null singleton used for top-level optional types.
-/// Serves for optimized null checks by pointer comparison.
-/// The forwarding pointer of this object is already resolved.
-/// NOTE: The forwarding pointer of the other comparison argument needs
-/// to be resolved too.
-#[no_mangle]
-#[cfg(feature = "ic")]
-pub unsafe extern "C" fn null_singleton() -> Value {
-    let metadata = PersistentMetadata::get();
-    debug_assert!((*metadata).null_singleton != DEFAULT_VALUE);
-    (*metadata).null_singleton.forward_if_possible()
-}
-
-// GC root pointer required for GC marking and updating.
-#[cfg(feature = "ic")]
-pub(crate) unsafe fn null_singleton_location() -> *mut Value {
-    let metadata = PersistentMetadata::get();
-    &mut (*metadata).null_singleton as *mut Value
-}
-
 #[cfg(feature = "ic")]
 pub(crate) unsafe fn get_incremental_gc_state() -> &'static mut State {
     let metadata = PersistentMetadata::get();
diff --git a/rts/motoko-rts/src/static_checks.rs b/rts/motoko-rts/src/static_checks.rs
index ccf20b1d90d..b35a3278f28 100644
--- a/rts/motoko-rts/src/static_checks.rs
+++ b/rts/motoko-rts/src/static_checks.rs
@@ -29,7 +29,6 @@ const _: () = assert!(size_of::<MutBox>() == HEADER_SIZE + 1 * WORD_SIZE);
 const _: () = assert!(size_of::<Some>() == HEADER_SIZE + 1 * WORD_SIZE);
 const _: () = assert!(size_of::<Variant>() == HEADER_SIZE + 2 * WORD_SIZE);
 const _: () = assert!(size_of::<Concat>() == HEADER_SIZE + 3 * WORD_SIZE);
-const _: () = assert!(size_of::<Null>() == HEADER_SIZE);
 const _: () = assert!(size_of::<Bits32>() == HEADER_SIZE + 1 * WORD_SIZE);
 const _: () = assert!(size_of::<Bits64>() == HEADER_SIZE + 2 * WORD_SIZE);
 
@@ -49,7 +48,6 @@ const _: () = assert!(align_of::<MutBox>() == WORD_SIZE);
 const _: () = assert!(align_of::<Some>() == WORD_SIZE);
 const _: () = assert!(align_of::<Variant>() == WORD_SIZE);
 const _: () = assert!(align_of::<Concat>() == WORD_SIZE);
-const _: () = assert!(align_of::<Null>() == WORD_SIZE);
 const _: () = assert!(align_of::<Bits32>() == WORD_SIZE);
 const _: () = assert!(align_of::<Bits64>() == WORD_SIZE);
 const _: () = assert!(align_of::<OneWordFiller>() == WORD_SIZE);
diff --git a/rts/motoko-rts/src/types.rs b/rts/motoko-rts/src/types.rs
index 73f7e9d1175..f4dc4a0304a 100644
--- a/rts/motoko-rts/src/types.rs
+++ b/rts/motoko-rts/src/types.rs
@@ -159,6 +159,11 @@ impl From<Words<u32>> for Bytes<u32> {
 // The `true` value. The only scalar value that has the lowest bit set.
 pub const TRUE_VALUE: u32 = 0x1;
 
+/// Constant sentinel pointer value for fast null tests.
+/// Points to the last unallocated Wasm page.
+/// See also `compile.ml` for other reserved sentinel values.
+pub const NULL_POINTER: Value = Value::from_raw(0xffff_fffb);
+
 /// A value in a heap slot
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
@@ -237,9 +242,9 @@ impl Value {
         self.get().is_scalar()
     }
 
-    /// Is the value a pointer?
-    pub fn is_ptr(&self) -> bool {
-        self.get().is_ptr()
+    /// Is the value a non-null pointer?
+    pub fn is_non_null_ptr(&self) -> bool {
+        self.get().is_ptr() && *self != NULL_POINTER
     }
 
     /// Assumes that the value is a scalar and returns the scalar value. In debug mode panics if
@@ -282,6 +287,7 @@ impl Value {
     /// with a header as well as `OneWordFiller`, `FwdPtr`, and `FreeSpace`.
     /// In debug mode panics if the value is not a pointer.
     pub unsafe fn tag(self) -> Tag {
+        debug_assert_ne!(self, NULL_POINTER);
         *(self.get_ptr() as *const Tag)
     }
 
@@ -295,8 +301,8 @@ impl Value {
 
     /// Resolve forwarding if the value is a pointer. Otherwise, return the same value.
     pub unsafe fn forward_if_possible(self) -> Value {
-        if self.is_ptr() && self.get_ptr() as *const Obj != null() {
-            // Ignore null pointers used in text_iter.
+        // Second condition: Ignore raw null addresses used in `text_iter`.
+        if self.is_non_null_ptr() && self.get_ptr() as *const Obj != null() {
             self.forward()
         } else {
             self
@@ -390,13 +396,13 @@ impl Value {
         self.0 as i32 >> 1
     }
 
-    // optimized version of `value.is_ptr() && value.get_ptr() >= address`
-    // value is a pointer equal or greater than the unskewed address > 1
+    // optimized version of `value.is_non_null_ptr() && value.get_ptr() >= address`
+    // value is a non-null pointer equal or greater than the unskewed address > 1
     #[inline]
     pub fn points_to_or_beyond(&self, address: usize) -> bool {
         debug_assert!(address > TRUE_VALUE as usize);
         let raw = self.get_raw();
-        is_skewed(raw) && unskew(raw as usize) >= address
+        is_skewed(raw) && unskew(raw as usize) >= address && *self != NULL_POINTER
     }
 }
 
@@ -442,9 +448,8 @@ pub const TAG_BITS32: Tag = 21;
 pub const TAG_BIGINT: Tag = 23;
 pub const TAG_CONCAT: Tag = 25;
 pub const TAG_REGION: Tag = 27;
-pub const TAG_NULL: Tag = 29;
-pub const TAG_ONE_WORD_FILLER: Tag = 31;
-pub const TAG_FREE_SPACE: Tag = 33;
+pub const TAG_ONE_WORD_FILLER: Tag = 29;
+pub const TAG_FREE_SPACE: Tag = 31;
 
 // Special value to visit only a range of array fields.
 // This and all values above it are reserved and mean
@@ -452,7 +457,11 @@ pub const TAG_FREE_SPACE: Tag = 33;
 // purposes of `visit_pointer_fields`.
 // Invariant: the value of this (pseudo-)tag must be
 //            higher than all other tags defined above
-pub const TAG_ARRAY_SLICE_MIN: Tag = 34;
+pub const TAG_ARRAY_SLICE_MIN: Tag = 32;
+
+pub fn is_object_tag(tag: Tag) -> bool {
+    tag >= TAG_OBJECT && tag <= TAG_REGION
+}
 
 // Common parts of any object. Other object pointers can be coerced into a pointer to this.
 #[repr(C)] // See the note at the beginning of this module
@@ -782,11 +791,6 @@ impl Concat {
     }
 }
 
-#[repr(C)] // See the note at the beginning of this module
-pub struct Null {
-    pub header: Obj,
-}
-
 #[repr(C)] // See the note at the beginning of this module
 pub struct Bits64 {
     pub header: Obj,
@@ -883,8 +887,6 @@ pub(crate) unsafe fn block_size(address: usize) -> Words<u32> {
 
         TAG_CONCAT => size_of::<Concat>(),
 
-        TAG_NULL => size_of::<Null>(),
-
         TAG_ONE_WORD_FILLER => size_of::<OneWordFiller>(),
 
         TAG_FREE_SPACE => {
diff --git a/rts/motoko-rts/src/visitor.rs b/rts/motoko-rts/src/visitor.rs
index d3048e9e11d..da1cb91f8d4 100644
--- a/rts/motoko-rts/src/visitor.rs
+++ b/rts/motoko-rts/src/visitor.rs
@@ -32,12 +32,12 @@ pub unsafe fn visit_pointer_fields<C, F, G>(
     match tag {
         TAG_OBJECT => {
             let obj = obj as *mut Object;
-            debug_assert!(is_pointer_field(obj.hash_blob_addr()));
+            debug_assert!(is_non_null_pointer_field(obj.hash_blob_addr()));
             visit_ptr_field(ctx, obj.hash_blob_addr());
             let obj_payload = obj.payload_addr();
             for i in 0..obj.size() {
                 let field_addr = obj_payload.add(i as usize);
-                if is_pointer_field(field_addr) {
+                if is_non_null_pointer_field(field_addr) {
                     visit_ptr_field(ctx, obj_payload.add(i as usize));
                 }
             }
@@ -51,7 +51,7 @@ pub unsafe fn visit_pointer_fields<C, F, G>(
             debug_assert!(stop <= array.len());
             for i in slice_start..stop {
                 let field_addr = array_payload.add(i as usize);
-                if is_pointer_field(field_addr) {
+                if is_non_null_pointer_field(field_addr) {
                     visit_ptr_field(ctx, field_addr);
                 }
             }
@@ -60,7 +60,7 @@ pub unsafe fn visit_pointer_fields<C, F, G>(
         TAG_MUTBOX => {
             let mutbox = obj as *mut MutBox;
             let field_addr = &mut (*mutbox).field;
-            if is_pointer_field(field_addr) {
+            if is_non_null_pointer_field(field_addr) {
                 visit_ptr_field(ctx, field_addr);
             }
         }
@@ -70,7 +70,7 @@ pub unsafe fn visit_pointer_fields<C, F, G>(
             let closure_payload = closure.payload_addr();
             for i in 0..closure.size() {
                 let field_addr = closure_payload.add(i as usize);
-                if is_pointer_field(field_addr) {
+                if is_non_null_pointer_field(field_addr) {
                     visit_ptr_field(ctx, field_addr);
                 }
             }
@@ -79,7 +79,7 @@ pub unsafe fn visit_pointer_fields<C, F, G>(
         TAG_SOME => {
             let some = obj as *mut Some;
             let field_addr = &mut (*some).field;
-            if is_pointer_field(field_addr) {
+            if is_non_null_pointer_field(field_addr) {
                 visit_ptr_field(ctx, field_addr);
             }
         }
@@ -87,7 +87,7 @@ pub unsafe fn visit_pointer_fields<C, F, G>(
         TAG_VARIANT => {
             let variant = obj as *mut Variant;
             let field_addr = &mut (*variant).field;
-            if is_pointer_field(field_addr) {
+            if is_non_null_pointer_field(field_addr) {
                 visit_ptr_field(ctx, field_addr);
             }
         }
@@ -95,7 +95,7 @@ pub unsafe fn visit_pointer_fields<C, F, G>(
         TAG_REGION => {
             let region = obj as *mut Region;
             let field_addr = &mut (*region).vec_pages;
-            if is_pointer_field(field_addr) {
+            if is_non_null_pointer_field(field_addr) {
                 visit_ptr_field(ctx, field_addr);
             }
         }
@@ -103,11 +103,11 @@ pub unsafe fn visit_pointer_fields<C, F, G>(
         TAG_CONCAT => {
             let concat = obj as *mut Concat;
             let field1_addr = &mut (*concat).text1;
-            if is_pointer_field(field1_addr) {
+            if is_non_null_pointer_field(field1_addr) {
                 visit_ptr_field(ctx, field1_addr);
             }
             let field2_addr = &mut (*concat).text2;
-            if is_pointer_field(field2_addr) {
+            if is_non_null_pointer_field(field2_addr) {
                 visit_ptr_field(ctx, field2_addr);
             }
         }
@@ -115,12 +115,12 @@ pub unsafe fn visit_pointer_fields<C, F, G>(
         TAG_OBJ_IND => {
             let obj_ind = obj as *mut ObjInd;
             let field_addr = &mut (*obj_ind).field;
-            if is_pointer_field(field_addr) {
+            if is_non_null_pointer_field(field_addr) {
                 visit_ptr_field(ctx, field_addr);
             }
         }
 
-        TAG_BITS64 | TAG_BITS32 | TAG_BLOB | TAG_BIGINT | TAG_NULL => {
+        TAG_BITS64 | TAG_BITS32 | TAG_BLOB | TAG_BIGINT => {
             // These don't have pointers, skip
         }
 
@@ -131,16 +131,20 @@ pub unsafe fn visit_pointer_fields<C, F, G>(
 }
 
 // Temporary function can be later removed.
-pub unsafe fn is_pointer_field(field_addr: *mut Value) -> bool {
+pub unsafe fn is_non_null_pointer_field(field_addr: *mut Value) -> bool {
     let field_value = *field_addr;
     check_field_value(field_value);
-    field_value.is_ptr()
+    field_value.is_non_null_ptr()
 }
 
 // Temporary check, can be later removed.
 #[cfg(feature = "ic")]
 fn check_field_value(value: Value) {
-    debug_assert!(value.is_scalar() || value.get_ptr() >= crate::persistence::HEAP_START);
+    debug_assert!(
+        value.is_scalar()
+            || value.get_ptr() >= crate::persistence::HEAP_START
+            || value == NULL_POINTER
+    );
 }
 
 #[cfg(not(feature = "ic"))]
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index d0d995d2707..af2bb5043cd 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -1076,7 +1076,6 @@ module RTS = struct
     E.add_func_import env "rts" "contains_field" [I32Type; I32Type] [I32Type];
     E.add_func_import env "rts" "set_static_root" [I32Type] [];
     E.add_func_import env "rts" "get_static_root" [] [I32Type];
-    E.add_func_import env "rts" "null_singleton" [] [I32Type];
     E.add_func_import env "rts" "set_upgrade_instructions" [I64Type] [];
     E.add_func_import env "rts" "get_upgrade_instructions" [] [I64Type];
     E.add_func_import env "rts" "memcpy" [I32Type; I32Type; I32Type] [I32Type]; (* standard libc memcpy *)
@@ -1898,11 +1897,6 @@ module Tagged = struct
      │ tag  │ fwd ptr │ ...
      └──────┴─────────┴──
 
-     The copying GC requires that all tagged objects in the dynamic heap space have at least
-     two words in order to replace them by `Indirection`. This condition is except for `Null`
-     that only lives in static heap space and is therefore not replaced by `Indirection` during
-     copying GC.
-
      Attention: This mapping is duplicated in these places
        * here
        * motoko-rts/src/types.rs
@@ -1929,7 +1923,6 @@ module Tagged = struct
     | Bits32 (* Contains a 32 bit unsigned number *)
     | BigInt
     | Concat (* String concatenation, used by rts/text.c *)
-    | Null (* For opt. Singleton in persistent heap *)
     | OneWordFiller (* Only used by the RTS *)
     | FreeSpace (* Only used by the RTS *)
     | Region
@@ -1957,15 +1950,30 @@ module Tagged = struct
     | BigInt -> 23l
     | Concat -> 25l
     | Region -> 27l
-    | Null -> 29l
-    | OneWordFiller -> 31l
-    | FreeSpace -> 33l
+    | OneWordFiller -> 29l
+    | FreeSpace -> 31l
     | ArraySliceMinimum -> 34l
     (* Next two tags won't be seen by the GC, so no need to set the lowest bit
        for `CoercionFailure` and `StableSeen` *)
     | CoercionFailure -> 0xfffffffel
     | StableSeen -> 0xffffffffl
 
+  (*
+     The null pointer is the sentinel `0xffff_fffbl` (skewed representation).
+    
+     This serves for efficient null tests by using direct pointer comparison.
+     The null pointer must not be dereferenced.
+     Null tests are possible without resolving the forwarding pointer of a non-null comparand.
+  *)
+
+  let null_sentinel_pointer = 0xffff_fffbl (* skewed, pointing to last unallocated Wasm page *)
+  let null_pointer = compile_unboxed_const null_sentinel_pointer
+
+  let not_null env =
+    (* null test works without forwarding pointer resolution of a non-null comparand *)
+    null_pointer ^^ 
+    G.i (Compare (Wasm.Values.I32 I32Op.Ne))  
+
   let header_size = 2l
   
   (* The tag *)
@@ -2188,15 +2196,8 @@ end
 module Opt = struct
   (* The Option type. Optional values are represented as
 
-    1. ┌──────┐
-       │ null │
-       └──────┘
-
-       A special null value. This is a singleton object stored in the persistent memory
-       and retained across all objects. This serves for efficient null checks by using 
-       pointer comparison (and applying pointer forwarding resolution beforehand).
-
-
+    1. The null literal being the sentinel null pointer value, see above.
+       
     2. ┌──────┬─────────┐
        │ some │ payload │
        └──────┴─────────┘
@@ -2218,24 +2219,8 @@ module Opt = struct
 
   let some_payload_field = Tagged.header_size
 
-  let null_lit env =
-    E.call_import env "rts" "null_singleton" (* forwarding pointer already resolved *)
-
-  let is_some env =
-    Func.share_code1 Func.Never env "is_some" ("x", I32Type) [I32Type] (fun env get_x ->
-      get_x ^^ BitTagged.if_tagged_scalar env [I32Type]
-        ( Bool.lit true ) (* scalar *)
-        ( get_x ^^ BitTagged.is_true_literal env ^^ (* exclude true literal since `branch_default` follows the forwarding pointer *)
-          E.if_ env [I32Type]
-            ( Bool.lit true ) (* true literal *)
-            ( (* pointer to object, resolve forwarding pointer on null pointer equality check *)
-              get_x ^^
-              Tagged.load_forwarding_pointer env ^^
-              null_lit env ^^
-              G.i (Compare (Wasm.Values.I32 I32Op.Ne))
-            )
-        )
-    )
+  let null_lit env = Tagged.null_pointer
+  let is_some = Tagged.not_null
 
   let alloc_some env get_payload =
     Tagged.obj env Tagged.Some [ get_payload ]
@@ -2248,10 +2233,13 @@ module Opt = struct
         ( get_x ^^ BitTagged.is_true_literal env ^^ (* exclude true literal since `branch_default` follows the forwarding pointer *)
           E.if_ env [I32Type]
             ( get_x ) (* true literal, no wrapping *)
-            ( get_x ^^ Tagged.branch_default env [I32Type]
-              ( get_x ) (* default tag, no wrapping *)
-              [ Tagged.Null, alloc_some env get_x
-              ; Tagged.Some, alloc_some env get_x ]
+            ( get_x ^^ is_some env ^^
+              E.if_ env [I32Type]
+                ( get_x ^^ Tagged.branch_default env [I32Type]
+                  ( get_x ) (* default tag, no wrapping *)
+                  [ Tagged.Some, alloc_some env get_x ]
+                )
+                ( alloc_some env get_x ) (* ?ⁿnull for n > 0 *)
             )
         )
     )
@@ -2274,11 +2262,7 @@ module Opt = struct
             ( get_x ) (* true literal, no wrapping *)
             ( get_x ^^ Tagged.branch_default env [I32Type]
               ( get_x ) (* default tag, no wrapping *)
-              [ Tagged.Some,
-                get_x ^^ load_some_payload_field env
-              ; Tagged.Null,
-                E.trap_with env "Internal error: opt_project: null!"
-              ]
+              [ Tagged.Some, get_x ^^ load_some_payload_field env ]
             )
         )
     )
diff --git a/test/bench/ok/alloc.drun-run.ok b/test/bench/ok/alloc.drun-run.ok
index 84bd19db7a5..e8bb0b9613a 100644
--- a/test/bench/ok/alloc.drun-run.ok
+++ b/test/bench/ok/alloc.drun-run.ok
@@ -1,8 +1,8 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_613_740_101)
+debug.print: (+335_544_320, 4_613_740_069)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_613_737_188)
+debug.print: (+335_544_320, 4_613_737_156)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_613_737_203)
+debug.print: (+335_544_320, 4_613_737_171)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/bignum.drun-run.ok b/test/bench/ok/bignum.drun-run.ok
index 2eecb7e0257..eaa51f4ce20 100644
--- a/test/bench/ok/bignum.drun-run.ok
+++ b/test/bench/ok/bignum.drun-run.ok
@@ -1,6 +1,6 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 2_631_839; size = +60_608}
+debug.print: {cycles = 2_630_422; size = +60_608}
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 107_963_422; size = +1_827_460}
+debug.print: {cycles = 107_963_240; size = +1_827_460}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/palindrome.drun-run.ok b/test/bench/ok/palindrome.drun-run.ok
index d9cdd47a4a4..9ae9db84a1a 100644
--- a/test/bench/ok/palindrome.drun-run.ok
+++ b/test/bench/ok/palindrome.drun-run.ok
@@ -1,9 +1,9 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (true, +1_544, 27_046)
-debug.print: (false, +1_544, 25_210)
-debug.print: (false, +1_544, 26_980)
-debug.print: (true, +1_156, 27_350)
-debug.print: (false, +1_144, 24_753)
-debug.print: (false, +1_144, 27_183)
+debug.print: (true, +1_544, 20_367)
+debug.print: (false, +1_544, 19_294)
+debug.print: (false, +1_544, 20_344)
+debug.print: (true, +1_156, 19_126)
+debug.print: (false, +1_144, 17_514)
+debug.print: (false, +1_144, 18_984)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/region-mem.drun-run.ok b/test/bench/ok/region-mem.drun-run.ok
index 57d066465f4..8f451caf42d 100644
--- a/test/bench/ok/region-mem.drun-run.ok
+++ b/test/bench/ok/region-mem.drun-run.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 9_437_184_446}
+debug.print: {heap_diff = 0; instr_diff = 8_782_872_996}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/region0-mem.drun-run.ok b/test/bench/ok/region0-mem.drun-run.ok
index b33378a41c4..565f4aaa72a 100644
--- a/test/bench/ok/region0-mem.drun-run.ok
+++ b/test/bench/ok/region0-mem.drun-run.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 8_808_038_846}
+debug.print: {heap_diff = 0; instr_diff = 8_480_883_108}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/stable-mem.drun-run.ok b/test/bench/ok/stable-mem.drun-run.ok
index 759ac4e36bb..9b58bba8c7a 100644
--- a/test/bench/ok/stable-mem.drun-run.ok
+++ b/test/bench/ok/stable-mem.drun-run.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 4_982_833_598}
+debug.print: {heap_diff = 0; instr_diff = 4_655_677_860}
 ingress Completed: Reply: 0x4449444c0000

From 07c42dbbac4a02f921acc8df3b625dd1e4eb94a0 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 15 Mar 2024 09:23:29 +0100
Subject: [PATCH 173/260] Downsize test case

---
 test/run-drun/gc-random-test-no-force-gc.mo   |   2 +-
 .../ok/gc-random-test-no-force-gc.drun-run.ok | 320 ------------------
 2 files changed, 1 insertion(+), 321 deletions(-)

diff --git a/test/run-drun/gc-random-test-no-force-gc.mo b/test/run-drun/gc-random-test-no-force-gc.mo
index d3225f245a4..e171f79fc2b 100644
--- a/test/run-drun/gc-random-test-no-force-gc.mo
+++ b/test/run-drun/gc-random-test-no-force-gc.mo
@@ -8,7 +8,7 @@ actor {
     let test = GCRandomTest.GCRandomTest();
 
     public shared func run() : async () {
-        await test.run(200);
+        await test.run(120);
     };
 };
 
diff --git a/test/run-drun/ok/gc-random-test-no-force-gc.drun-run.ok b/test/run-drun/ok/gc-random-test-no-force-gc.drun-run.ok
index 95384f96d80..c00719ee0d8 100644
--- a/test/run-drun/ok/gc-random-test-no-force-gc.drun-run.ok
+++ b/test/run-drun/ok/gc-random-test-no-force-gc.drun-run.ok
@@ -481,324 +481,4 @@ debug.print: Step 120
 debug.print: Random allocation
 debug.print: Random change
 debug.print: Random check
-debug.print: Step 121
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 122
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 123
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 124
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 125
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 126
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 127
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 128
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 129
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 130
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 131
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 132
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 133
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 134
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 135
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 136
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 137
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 138
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 139
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 140
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 141
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 142
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 143
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 144
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 145
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 146
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 147
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 148
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 149
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 150
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 151
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 152
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 153
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 154
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 155
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 156
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 157
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 158
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 159
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 160
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 161
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 162
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 163
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 164
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 165
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 166
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 167
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 168
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 169
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 170
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 171
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 172
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 173
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 174
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 175
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 176
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 177
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 178
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 179
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 180
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 181
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 182
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 183
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 184
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 185
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 186
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 187
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 188
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 189
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 190
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 191
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 192
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 193
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 194
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 195
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 196
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 197
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 198
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 199
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
-debug.print: Step 200
-debug.print: Random allocation
-debug.print: Random change
-debug.print: Random check
 ingress Completed: Reply: 0x4449444c0000

From 94e52575793c13d9b6ed23a993c9ff88be312195 Mon Sep 17 00:00:00 2001
From: Luc Blaeser <112870813+luc-blaeser@users.noreply.github.com>
Date: Wed, 20 Mar 2024 10:01:04 +0100
Subject: [PATCH 174/260] Optimization: Enhanced Orthogonal Persistence with
 Object Pooling (#4463)

* Object pooling

* Update benchmark results

* Optimize further (BigNum pooling)

* Update benchmark results

* Adjust tests

* Optimize static blobs

* Adjust test and benchmark results

* Update documentation
---
 design/OrthogonalPersistence.md            |  12 +-
 rts/motoko-rts/src/gc/incremental/roots.rs |  28 ++-
 src/codegen/compile.ml                     | 242 +++++++++++++--------
 test/bench/ok/bignum.drun-run.ok           |   4 +-
 test/bench/ok/heap-32.drun-run.ok          |   4 +-
 test/bench/ok/palindrome.drun-run.ok       |  12 +-
 test/bench/ok/region-mem.drun-run.ok       |   2 +-
 test/bench/ok/region0-mem.drun-run.ok      |   2 +-
 test/bench/ok/stable-mem.drun-run.ok       |   2 +-
 test/run/const-func-static.mo              |   2 +-
 test/run/idl.mo                            |   2 +-
 test/run/ok/array-len.wasm-run.ok          |   2 +-
 12 files changed, 195 insertions(+), 119 deletions(-)

diff --git a/design/OrthogonalPersistence.md b/design/OrthogonalPersistence.md
index deefe972d66..96c8236e1c9 100644
--- a/design/OrthogonalPersistence.md
+++ b/design/OrthogonalPersistence.md
@@ -88,11 +88,11 @@ This is because these objects may also need to survive upgrades and must not be
 
 The incremental GC also operates on these objects, meaning that forwarding pointer resolution is also necessary for these objects.
 
+For memory and runtime efficiency, object pooling is implemented for compile-time-known constant objects (with side-effect-free initialization), i.e. those objects are already created on program initialization/upgrade in the dynamic heap and thereafter the reference to the corresponding prefabricated object is looked up whenever the constant value is needed at runtime.
+
 The runtime systems avoids any global Wasm variables for state that needs to be preserved on upgrades.
 Instead, such global runtime state is stored in the persistent metadata.
 
-Sharing optimization (pooling) is possible for compile-time-known objects, see below.
-
 ### Wasm Data Segments
 Only passive Wasm data segments are used by the compiler and runtime system. In contrast to ordinary active data segments, passive segments can be explicitly loaded to a dynamic address.
 
@@ -115,10 +115,10 @@ Once operating on the stable heap, the system prevents downgrade attempts to the
 ### Old Stable Memory
 The old stable memory remains equally accessible as secondary memory with the new support.
 
-## Possible Extensions
-The following extensions or optimization could be applied in the future:
-* 64-bit memory: Extend the main memory to 64-bit by using Wasm64, see https://github.com/dfinity/motoko/pull/4136. The memory layout would need to be extended. Moreover, it would be beneficial to introduce a dynamic partition table for the GC. Ideally, stable heap support is directly rolled out for 64-bit to avoid complicated memory layout upgrades from 32-bit to 64-bit.
-* Object pooling: Compile-time-known objects can be shared in the dynamic heap by remembering them in an additional pool table. The pool table needs to be registered as a transient GC root and is recreated on canister upgrades.
+## Current Limitations
+* Freeing old object fields: While new program versions can drop object fields, the runtime system should also delete the redundant fields of persistent objects of previous program versions. This could be realized during garbage collection when objects are copied. For this purpose, the runtime system may maintain a set of field hashes in use and consult this table during garbage collection.
+* Bounded Rust call stack size: The Rust call stack size needs to be bounded and can no longer be configured by the user.
+* The Wasm profiler (only used for the flamegraphs) is no longer applicable because the underlying `parity-wasm` crate lacks full support of passive data segments. A re-implementation of the profiler would be needed.
 
 ## Related PRs
 
diff --git a/rts/motoko-rts/src/gc/incremental/roots.rs b/rts/motoko-rts/src/gc/incremental/roots.rs
index 3dca8d6df38..43d8dff5638 100644
--- a/rts/motoko-rts/src/gc/incremental/roots.rs
+++ b/rts/motoko-rts/src/gc/incremental/roots.rs
@@ -2,11 +2,13 @@ use motoko_rts_macros::ic_mem_fn;
 
 use crate::{types::Value, visitor::is_non_null_pointer_field};
 
-/// Root referring to all canister variables.
-/// This root is reinitialized on each canister upgrade.
+/// An array referring to the static program variables, being
+/// - All canister variables.
+/// - Pooled shared objects.
+/// The array constitutes a GC root that is reinitialized on each canister upgrade.
 /// The scalar sentinel denotes an uninitialized root.
 #[cfg(feature = "ic")]
-static mut STATIC_ROOT: Value = Value::from_scalar(0);
+static mut STATIC_VARIABLES: Value = Value::from_scalar(0);
 
 /// GC root set.
 pub type Roots = [*mut Value; 6];
@@ -19,7 +21,7 @@ pub unsafe fn root_set() -> Roots {
         region::region0_get_ptr_loc,
     };
     [
-        static_root_location(),
+        static_variables_location(),
         continuation_table_loc(),
         stable_actor_location(),
         stable_type_descriptor().candid_data_location(),
@@ -41,21 +43,23 @@ pub unsafe fn visit_roots<C, V: Fn(&mut C, *mut Value)>(
 }
 
 #[cfg(feature = "ic")]
-unsafe fn static_root_location() -> *mut Value {
-    &mut STATIC_ROOT as *mut Value
+unsafe fn static_variables_location() -> *mut Value {
+    &mut STATIC_VARIABLES as *mut Value
 }
 
 #[ic_mem_fn(ic_only)]
-pub unsafe fn set_static_root<M: crate::memory::Memory>(mem: &mut M, value: Value) {
+pub unsafe fn set_static_variables<M: crate::memory::Memory>(mem: &mut M, array: Value) {
     use super::barriers::write_with_barrier;
+    use crate::types::TAG_ARRAY;
 
-    let location = &mut STATIC_ROOT as *mut Value;
-    write_with_barrier(mem, location, value);
+    assert_eq!(array.tag(), TAG_ARRAY);
+    let location = &mut STATIC_VARIABLES as *mut Value;
+    write_with_barrier(mem, location, array);
 }
 
 #[no_mangle]
 #[cfg(feature = "ic")]
-pub unsafe extern "C" fn get_static_root() -> Value {
-    debug_assert!(STATIC_ROOT.is_non_null_ptr());
-    STATIC_ROOT
+pub unsafe extern "C" fn get_static_variable(index: u32) -> Value {
+    debug_assert!(STATIC_VARIABLES.is_non_null_ptr());
+    STATIC_VARIABLES.as_array().get(index)
 }
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index af2bb5043cd..4915622c328 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -389,7 +389,18 @@ module E = struct
     type_offsets_segment : int32;
     idl_types_segment : int32;
   }
-  type t = {
+  (* Object allocation code. *)
+  type object_allocation = t -> G.t
+  (* Pool of shared objects.
+     Alllocated in the dynamic heap on program initialization/upgrade.
+     Identified by the index position in this list and accessed via the runtime system.
+     Registered as GC root set and replaced on program upgrade. 
+  *)
+  and object_pool = {
+    objects: object_allocation list ref;
+    frozen: bool ref;
+  }
+  and t = {
     (* Global fields *)
     (* Static *)
     mode : Flags.compile_mode;
@@ -414,10 +425,8 @@ module E = struct
     built_in_funcs : lazy_function NameEnv.t ref;
     static_strings : int32 StringEnv.t ref;
     data_segments : string list ref; (* Passive data segments *)
-    static_variables : int32 ref;
-      (* Number of static variables (MutBox), accessed by index via the runtime system,
-         and belonging to the GC root set. *)
-
+    object_pool : object_pool;
+      
     (* Types accumulated in global typtbl (for candid subtype checks)
        See Note [Candid subtype checks]
     *)
@@ -448,6 +457,10 @@ module E = struct
     global_type_descriptor : type_descriptor option ref;
   }
 
+  (* Compile-time-known value, either a plain vanilla constant or a shared object. *)
+  type shared_value = 
+  | Vanilla of int32
+  | SharedObject of object_allocation
 
   (* The initial global environment *)
   let mk_global mode rts trap_with : t = {
@@ -467,7 +480,7 @@ module E = struct
     built_in_funcs = ref NameEnv.empty;
     static_strings = ref StringEnv.empty;
     data_segments = ref [];
-    static_variables = ref 0l;
+    object_pool = { objects = ref []; frozen = ref false };
     typtbl_typs = ref [];
     (* Metadata *)
     args = ref None;
@@ -714,13 +727,17 @@ module E = struct
   let get_data_segments (env : t) =
     !(env.data_segments)
 
-  let add_static_variable (env : t) : int32 =
-    let variable_index = !(env.static_variables) in
-    env.static_variables := Int32.add variable_index 1l;
-    variable_index
+  let object_pool_add (env : t) (allocation : t -> G.t) : int32 =
+    if !(env.object_pool.frozen) then raise (Invalid_argument "Object pool frozen");
+    let index = List.length !(env.object_pool.objects) in
+    env.object_pool.objects := !(env.object_pool.objects) @ [ allocation ];
+    Int32.of_int index
+
+  let object_pool_size (env : t) : int =
+    List.length !(env.object_pool.objects)
 
-  let count_static_variables (env : t) =
-    !(env.static_variables)
+  let iterate_object_pool (env : t) f =
+    G.concat_mapi f !(env.object_pool.objects)
 
   let collect_garbage env force =
     let name = "incremental_gc" in
@@ -1074,8 +1091,8 @@ module RTS = struct
     E.add_func_import env "rts" "save_stable_actor" [I32Type] [];
     E.add_func_import env "rts" "free_stable_actor" [] [];
     E.add_func_import env "rts" "contains_field" [I32Type; I32Type] [I32Type];
-    E.add_func_import env "rts" "set_static_root" [I32Type] [];
-    E.add_func_import env "rts" "get_static_root" [] [I32Type];
+    E.add_func_import env "rts" "set_static_variables" [I32Type] [];
+    E.add_func_import env "rts" "get_static_variable" [I32Type] [I32Type];
     E.add_func_import env "rts" "set_upgrade_instructions" [I64Type] [];
     E.add_func_import env "rts" "get_upgrade_instructions" [] [I64Type];
     E.add_func_import env "rts" "memcpy" [I32Type; I32Type; I32Type] [I32Type]; (* standard libc memcpy *)
@@ -1336,6 +1353,10 @@ module Heap = struct
   let get_heap_size env =
     E.call_import env "rts" "get_heap_size"
 
+  let get_static_variable env index = 
+    compile_unboxed_const index ^^
+    E.call_import env "rts" "get_static_variable"
+
 end (* Heap *)
 
 module Stack = struct
@@ -1966,8 +1987,8 @@ module Tagged = struct
      Null tests are possible without resolving the forwarding pointer of a non-null comparand.
   *)
 
-  let null_sentinel_pointer = 0xffff_fffbl (* skewed, pointing to last unallocated Wasm page *)
-  let null_pointer = compile_unboxed_const null_sentinel_pointer
+  let null_vanilla_pointer = 0xffff_fffbl (* skewed, pointing to last unallocated Wasm page *)
+  let null_pointer = compile_unboxed_const null_vanilla_pointer
 
   let not_null env =
     (* null test works without forwarding pointer resolution of a non-null comparand *)
@@ -2162,6 +2183,14 @@ module Tagged = struct
     get_object ^^
     allocation_barrier env
 
+  let share env allocation =
+    let index = E.object_pool_add env allocation in
+    Heap.get_static_variable env index
+
+  let share_constant env = function
+  | E.Vanilla vanilla -> compile_unboxed_const vanilla
+  | E.SharedObject allocation -> share env allocation
+
 end (* Tagged *)
 
 module MutBox = struct
@@ -2190,6 +2219,9 @@ module MutBox = struct
     Tagged.load_forwarding_pointer env ^^
     get_mutbox_value ^^
     Tagged.store_field env field
+  
+  let add_global_mutbox env =
+    E.object_pool_add env alloc
 end
 
 
@@ -2219,7 +2251,9 @@ module Opt = struct
 
   let some_payload_field = Tagged.header_size
 
+  let null_vanilla_lit = Tagged.null_vanilla_pointer
   let null_lit env = Tagged.null_pointer
+
   let is_some = Tagged.not_null
 
   let alloc_some env get_payload =
@@ -2244,6 +2278,11 @@ module Opt = struct
         )
     )
 
+  let constant env = function
+  | E.Vanilla value when value = null_vanilla_lit -> E.SharedObject (fun env -> alloc_some env (null_lit env)) (* ?ⁿnull for n > 0 *)
+  | E.Vanilla value -> E.Vanilla value (* not null and no `Opt` object *)
+  | E.SharedObject allocation -> E.SharedObject (fun env -> inject env (allocation env)) (* potentially wrap in new `Opt` *)
+
   (* This function is used where conceptually, Opt.inject should be used, but
   we know for sure that it wouldn’t do anything anyways, except dereferencing the forwarding pointer *)
   let inject_simple env e =
@@ -2355,11 +2394,12 @@ module Closure = struct
     G.i (CallIndirect (nr ty)) ^^
     FakeMultiVal.load env (Lib.List.make n_res I32Type)
 
-  let alloc env fi =
-    Tagged.obj env Tagged.Closure [
-      compile_unboxed_const (E.add_fun_ptr env fi);
+  let constant env get_fi =
+    let fi = E.add_fun_ptr env (get_fi ()) in
+    E.SharedObject (fun env -> Tagged.obj env Tagged.Closure [
+      compile_unboxed_const fi;
       compile_unboxed_const 0l
-    ]
+    ])
 
 end (* Closure *)
 
@@ -2392,12 +2432,12 @@ module BoxedWord64 = struct
     get_i ^^
     Tagged.allocation_barrier env
 
-  let lit env pty i =
+  let constant env pty i =
     if BitTagged.can_tag_const pty i
     then 
-      compile_unboxed_const (BitTagged.tag_const pty i)
+      E.Vanilla (BitTagged.tag_const pty i)
     else
-      compile_box env pty (compile_const_64 i)
+      E.SharedObject (fun env -> compile_box env pty (compile_const_64 i))
 
   let box env pty = 
     Func.share_code1 Func.Never env 
@@ -2514,14 +2554,14 @@ module BoxedSmallWord = struct
 
   let payload_field = Tagged.header_size
 
-  let lit env pty i =
+  let constant env pty i =
     if BitTagged.can_tag_const pty (Int64.of_int (Int32.to_int i))
     then
-      compile_unboxed_const (BitTagged.tag_const pty (Int64.of_int (Int32.to_int i)))
+      E.Vanilla (BitTagged.tag_const pty (Int64.of_int (Int32.to_int i)))
     else
-      Tagged.obj env (heap_tag env pty) [
+      E.SharedObject (fun env -> (Tagged.obj env (heap_tag env pty) [
         compile_unboxed_const i
-      ]
+      ]))
 
   let compile_box env pty compile_elem : G.t =
     let (set_i, get_i) = new_local env "boxed_i32" in
@@ -2807,7 +2847,9 @@ module Float = struct
 
   let unbox env = Tagged.load_forwarding_pointer env ^^ Tagged.load_field_float64 env payload_field
 
-  let lit env f = compile_unboxed_const f ^^ box env
+  let constant env f = E.SharedObject (fun env -> 
+    compile_unboxed_const f ^^ 
+    box env)
 
 end (* Float *)
 
@@ -2963,8 +3005,8 @@ sig
    *)
   val compile_load_from_data_buf : E.t -> G.t -> bool -> G.t
 
-  (* literals *)
-  val lit : E.t -> Big_int.big_int -> G.t
+  (* constant *)
+  val constant : E.t -> Big_int.big_int -> E.shared_value
 
   (* arithmetic *)
   val compile_abs : E.t -> G.t
@@ -3294,10 +3336,10 @@ module MakeCompact (Num : BigNumType) : BigNumType = struct
       (get_n ^^ clear_tag env ^^ compile_unboxed_const 0l ^^ G.i (Compare (Wasm.Values.I32 I32Op.LtS)))
       (get_n ^^ Num.compile_is_negative env)
 
-  let lit env = function
+  let constant env = function
     | n when Big_int.is_int_big_int n && BitTagged.can_tag_const Type.Int (Big_int.int64_of_big_int n) ->
-      compile_unboxed_const (BitTagged.tag_const Type.Int (Big_int.int64_of_big_int n))
-    | n -> Num.lit env n
+      E.Vanilla (BitTagged.tag_const Type.Int (Big_int.int64_of_big_int n))
+    | n -> Num.constant env n
 
   let compile_neg env =
     let sminl = Int32.shift_left 1l (BitTagged.sbits_of Type.Int) in
@@ -3649,7 +3691,7 @@ module BigNumLibtommath : BigNumType = struct
     | false -> get_data_buf ^^ E.call_import env "rts" "bigint_leb128_decode"
     | true -> get_data_buf ^^ E.call_import env "rts" "bigint_sleb128_decode"
 
-  let lit env n =
+  let constant env n =
     (* See enum mp_sign *)
     let sign = if Big_int.sign_big_int n >= 0 then 0l else 1l in
 
@@ -3670,12 +3712,12 @@ module BigNumLibtommath : BigNumType = struct
     let size = Int32.of_int (List.length limbs) in
 
     (* cf. mp_int in tommath.h *)
-    Tagged.obj env Tagged.BigInt ([
+    E.SharedObject (fun env -> Tagged.obj env Tagged.BigInt ([
       compile_unboxed_const size; (* used *)
       compile_unboxed_const size; (* size; relying on Heap.word_size == size_of(mp_digit) *)
       compile_unboxed_const sign;
       compile_unboxed_const 0l; (* dp; this will be patched in BigInt::mp_int_ptr in the RTS when used *)
-    ] @ limbs)
+    ] @ limbs))
 
   let assert_nonneg env =
     Func.share_code1 Func.Never env "assert_nonneg" ("n", I32Type) [I32Type] (fun env get_n ->
@@ -3791,15 +3833,20 @@ module Blob = struct
     Tagged.load_forwarding_pointer env ^^
     compile_add_const (unskewed_payload_offset env)
 
-  let lit env s = 
-    let blob_length = Int32.of_int (String.length s) in
-    let (set_new_blob, get_new_blob) = new_local env "new_blob" in
-    compile_unboxed_const blob_length ^^ alloc env ^^ set_new_blob ^^
-    get_new_blob ^^ payload_ptr_unskewed env ^^ (* target address *)
-    compile_unboxed_const 0l ^^ (* data offset *)
-    compile_unboxed_const blob_length ^^ (* data length *)
-    load_static_data env s ^^
-    get_new_blob
+  let constant env payload =
+    E.SharedObject (fun env -> 
+      let blob_length = Int32.of_int (String.length payload) in
+      let (set_new_blob, get_new_blob) = new_local env "new_blob" in
+      compile_unboxed_const blob_length ^^ alloc env ^^ set_new_blob ^^
+      get_new_blob ^^ payload_ptr_unskewed env ^^ (* target address *)
+      compile_unboxed_const 0l ^^ (* data offset *)
+      compile_unboxed_const blob_length ^^ (* data length *)
+      load_static_data env payload ^^
+      get_new_blob
+    )
+
+  let lit env payload =
+    Tagged.share_constant env (constant env payload)
 
   let as_ptr_len env = Func.share_code1 Func.Never env "as_ptr_size" ("x", I32Type) [I32Type; I32Type] (
     fun env get_x ->
@@ -4024,7 +4071,11 @@ module Object = struct
         List.sort compare in
       let hash_blob env =
         let hash_payload = StaticBytes.[ i32s hashes ] in
-        Blob.lit env (StaticBytes.as_bytes hash_payload) in
+        let blob_constant = Blob.constant env (StaticBytes.as_bytes hash_payload) in
+        match blob_constant with
+        | E.SharedObject allocation -> allocation env
+        | E.Vanilla _ -> assert false
+      in
 
       (* Allocate memory *)
       let (set_ri, get_ri, ri) = new_local_ env I32Type "obj" in
@@ -5239,7 +5290,7 @@ module Cycles = struct
     let (set_val, get_val) = new_local env "cycles" in
     set_val ^^
     get_val ^^
-    BigNum.lit env (Big_int.power_int_positive_int 2 128) ^^
+    Tagged.share_constant env (BigNum.constant env (Big_int.power_int_positive_int 2 128)) ^^
     BigNum.compile_relop env Lt ^^
     E.else_trap_with env "cycles out of bounds" ^^
 
@@ -8318,20 +8369,25 @@ end
 
 module GCRoots = struct
   let create_root_array env = Func.share_code0 Func.Always env "create_root_array" [I32Type] (fun env ->
-    let length = Int32.to_int (E.count_static_variables env) in
-    let variables = Lib.List.table length (fun _ -> MutBox.alloc env) in
-    Arr.lit env variables
+    E.(env.object_pool.frozen) := true;
+    let (set_array, get_array) = new_local env "root_array" in
+    let length = Int32.of_int (E.object_pool_size env) in
+    compile_unboxed_const length ^^
+    Arr.alloc env ^^
+    set_array ^^
+    E.iterate_object_pool env (fun index allocation ->
+      get_array ^^
+      compile_unboxed_const (Int32.of_int index) ^^
+      Arr.unsafe_idx env ^^
+      allocation env ^^
+      store_ptr
+    ) ^^
+    get_array
   )
 
   let register_static_variables env =
     create_root_array env ^^
-    E.call_import env "rts" "set_static_root"
-
-  let get_static_variable env index = 
-    E.call_import env "rts" "get_static_root" ^^
-    compile_unboxed_const index ^^
-    Arr.idx env ^^
-    load_ptr
+    E.call_import env "rts" "set_static_variables"
 end (* GCRoots *)
 
 module StackRep = struct
@@ -8412,26 +8468,42 @@ module StackRep = struct
     | UnboxedTuple n -> G.table n (fun _ -> G.i Drop)
     | Const _ | Unreachable -> G.nop
 
-  let rec materialize_constant env = function
-    | Const.Lit (Const.Vanilla value) -> compile_unboxed_const value
-    | Const.Lit (Const.Bool number) -> Bool.lit number
-    | Const.Lit (Const.Blob payload) -> Blob.lit env payload
-    | Const.Lit (Const.Null) -> Opt.null_lit env
-    | Const.Lit (Const.BigInt number) -> BigNum.lit env number
-    | Const.Lit (Const.Word32 (pty, number)) -> BoxedSmallWord.lit env pty number
-    | Const.Lit (Const.Word64 (pty, number)) -> BoxedWord64.lit env pty number
-    | Const.Lit (Const.Float64 number) -> Float.lit env number
-    | Const.Opt value -> Opt.inject env (materialize_constant env value)
-    | Const.Fun (get_fi, _) -> Closure.alloc env (get_fi ())
-    | Const.Message _ -> assert false
-    | Const.Unit -> Tuple.compile_unit env
-    | Const.Tag (tag, value) -> Variant.inject env tag (materialize_constant env value)
-    | Const.Array elements -> 
-        let materialized_elements = List.map (materialize_constant env) elements in
-        Arr.lit env materialized_elements
-    | Const.Obj fields -> 
-        let materialized_fields = List.map (fun (name, value) -> (name, (fun () -> materialize_constant env value))) fields in
-        Object.lit_raw env materialized_fields
+  let rec materialize_constant_value env = function
+  | Const.Lit (Const.Vanilla value) -> E.Vanilla value
+  | Const.Lit (Const.Bool number) -> E.Vanilla (Bool.vanilla_lit number)
+  | Const.Lit (Const.Blob payload) -> Blob.constant env payload
+  | Const.Lit (Const.Null) -> E.Vanilla Opt.null_vanilla_lit
+  | Const.Lit (Const.BigInt number) -> BigNum.constant env number
+  | Const.Lit (Const.Word32 (pty, number)) -> BoxedSmallWord.constant env pty number
+  | Const.Lit (Const.Word64 (pty, number)) -> BoxedWord64.constant env pty number
+  | Const.Lit (Const.Float64 number) -> Float.constant env number
+  | Const.Opt value -> Opt.constant env (materialize_constant_value env value)
+  | Const.Fun (get_fi, _) -> Closure.constant env get_fi
+  | Const.Message _ -> assert false
+  | Const.Unit -> E.Vanilla (Tuple.unit_vanilla_lit env)
+  | Const.Tag (tag, value) -> 
+      let payload = materialize_constant_element env value in
+      E.SharedObject (fun env -> Variant.inject env tag (payload env))
+  | Const.Array elements -> 
+      let materialized_elements = List.map (materialize_constant_element env) elements in
+      E.SharedObject (fun env -> 
+        let compiled_elements = List.map (fun allocation -> allocation env) materialized_elements in
+        Arr.lit env compiled_elements
+      )
+  | Const.Obj fields -> 
+      let materialized_fields = List.map (fun (name, value) -> (name, materialize_constant_element env value)) fields in
+      E.SharedObject (fun env -> 
+        let compile_fields = List.map (fun (name, allocation) -> (name, fun () -> allocation env)) materialized_fields in
+        Object.lit_raw env compile_fields
+      )
+
+  and materialize_constant_element env value =
+    match materialize_constant_value env value with
+    | E.Vanilla vanilla -> fun env -> compile_unboxed_const vanilla
+    | E.SharedObject allocation -> allocation
+
+  let materialize_shared_constant env value =
+    Tagged.share_constant env (materialize_constant_value env value)
 
   let adjust env (sr_in : t) sr_out =
     if eq sr_in sr_out
@@ -8469,7 +8541,7 @@ module StackRep = struct
     | Vanilla, UnboxedFloat64 -> Float.unbox env
 
     | Const value, Vanilla -> 
-        materialize_constant env value
+        materialize_shared_constant env value
     | Const Const.Lit (Const.Vanilla n), UnboxedWord32 ty ->
         compile_unboxed_const n ^^
         TaggedSmallWord.untag env ty
@@ -8481,7 +8553,7 @@ module StackRep = struct
     | Const c, UnboxedTuple 0 -> G.nop
     | Const Const.Array cs, UnboxedTuple n ->
       assert (n = List.length cs);
-      G.concat_map (fun c -> materialize_constant env c) cs
+      G.concat_map (fun c -> materialize_shared_constant env c) cs
     | _, _ ->
       Printf.eprintf "Unknown stack_rep conversion %s -> %s\n"
         (to_string sr_in) (to_string sr_out);
@@ -8598,7 +8670,7 @@ module VarEnv = struct
         let ae' = { ae with vars = NameEnv.add name ((Local (SR.Vanilla, i)), typ) ae.vars } in
         add_arguments env ae' as_local remainder
       else
-        let index = E.add_static_variable env in
+        let index = MutBox.add_global_mutbox env in
         let ae' = add_static_variable ae name index typ in
         add_arguments env ae' as_local remainder
 
@@ -8658,14 +8730,14 @@ module Var = struct
       SR.Vanilla,
       MutBox.store_field env
     | Some ((Static index), typ) when potential_pointer typ ->
-      GCRoots.get_static_variable env index ^^
+      Heap.get_static_variable env index ^^
       Tagged.load_forwarding_pointer env ^^
       compile_add_const ptr_unskew ^^
       compile_add_const (Int32.mul MutBox.field Heap.word_size),
       SR.Vanilla,
       Tagged.write_with_barrier env
     | Some ((Static index), typ) ->
-      GCRoots.get_static_variable env index,
+      Heap.get_static_variable env index,
       SR.Vanilla,
       MutBox.store_field env
     | Some ((Const _), _) -> fatal "set_val: %s is const" var
@@ -8698,7 +8770,7 @@ module Var = struct
       SR.Vanilla, G.i (LocalGet (nr i)) ^^ MutBox.load_field env
     | Some (Static index) ->
       SR.Vanilla, 
-      GCRoots.get_static_variable env index ^^
+      Heap.get_static_variable env index ^^
       MutBox.load_field env
     | Some (Const c) ->
       SR.Const c, G.nop
@@ -8745,7 +8817,7 @@ module Var = struct
   *)
   let get_aliased_box env ae var = match VarEnv.lookup_var ae var with
     | Some (HeapInd i) -> G.i (LocalGet (nr i))
-    | Some (Static index) -> GCRoots.get_static_variable env index
+    | Some (Static index) -> Heap.get_static_variable env index
     | _ -> assert false
 
   let capture_aliased_box env ae var = match VarEnv.lookup_var ae var with
@@ -9503,7 +9575,7 @@ module AllocHow = struct
       let alloc_code = MutBox.alloc env ^^ G.i (LocalSet (nr i)) in
       (ae1, alloc_code)
     | StoreStatic ->
-      let index = E.add_static_variable env in
+      let index = MutBox.add_global_mutbox env in
       let ae1 = VarEnv.add_static_variable ae name index typ in
       (ae1, G.nop)
 
diff --git a/test/bench/ok/bignum.drun-run.ok b/test/bench/ok/bignum.drun-run.ok
index eaa51f4ce20..2dd7f220987 100644
--- a/test/bench/ok/bignum.drun-run.ok
+++ b/test/bench/ok/bignum.drun-run.ok
@@ -1,6 +1,6 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 2_630_422; size = +60_608}
+debug.print: {cycles = 2_626_994; size = +60_128}
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 107_963_240; size = +1_827_460}
+debug.print: {cycles = 107_960_332; size = +1_826_940}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/heap-32.drun-run.ok b/test/bench/ok/heap-32.drun-run.ok
index 377af51b5fd..baa9116ccca 100644
--- a/test/bench/ok/heap-32.drun-run.ok
+++ b/test/bench/ok/heap-32.drun-run.ok
@@ -1,5 +1,5 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (50_227, +40_579_412, 879_264_651)
-debug.print: (50_070, +42_103_788, 913_585_900)
+debug.print: (50_227, +37_379_412, 870_764_651)
+debug.print: (50_070, +38_903_788, 905_085_900)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/palindrome.drun-run.ok b/test/bench/ok/palindrome.drun-run.ok
index 9ae9db84a1a..f82af80bade 100644
--- a/test/bench/ok/palindrome.drun-run.ok
+++ b/test/bench/ok/palindrome.drun-run.ok
@@ -1,9 +1,9 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (true, +1_544, 20_367)
-debug.print: (false, +1_544, 19_294)
-debug.print: (false, +1_544, 20_344)
-debug.print: (true, +1_156, 19_126)
-debug.print: (false, +1_144, 17_514)
-debug.print: (false, +1_144, 18_984)
+debug.print: (true, +1_480, 20_073)
+debug.print: (false, +1_480, 19_000)
+debug.print: (false, +1_480, 20_050)
+debug.print: (true, +1_108, 18_905)
+debug.print: (false, +1_096, 17_293)
+debug.print: (false, +1_096, 18_763)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/region-mem.drun-run.ok b/test/bench/ok/region-mem.drun-run.ok
index 8f451caf42d..996b7e106eb 100644
--- a/test/bench/ok/region-mem.drun-run.ok
+++ b/test/bench/ok/region-mem.drun-run.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 8_782_872_996}
+debug.print: {heap_diff = 0; instr_diff = 8_380_219_796}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/region0-mem.drun-run.ok b/test/bench/ok/region0-mem.drun-run.ok
index 565f4aaa72a..e0f81d95884 100644
--- a/test/bench/ok/region0-mem.drun-run.ok
+++ b/test/bench/ok/region0-mem.drun-run.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 8_480_883_108}
+debug.print: {heap_diff = 0; instr_diff = 8_279_556_500}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/stable-mem.drun-run.ok b/test/bench/ok/stable-mem.drun-run.ok
index 9b58bba8c7a..b64bd840aaf 100644
--- a/test/bench/ok/stable-mem.drun-run.ok
+++ b/test/bench/ok/stable-mem.drun-run.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 4_655_677_860}
+debug.print: {heap_diff = 0; instr_diff = 4_454_351_252}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run/const-func-static.mo b/test/run/const-func-static.mo
index 3c66c93986e..a6a4eb0de69 100644
--- a/test/run/const-func-static.mo
+++ b/test/run/const-func-static.mo
@@ -5,7 +5,7 @@ func higher_order(foo: () -> ()) = foo();
 func bar() = ();
 higher_order(bar);
 let after = Prim.rts_heap_size();
-assert(+after-before == 16);
+assert(+after-before == 0);
 Prim.debugPrint("Ignore Diff: heap size increase " # debug_show (+after-before));
 
 //SKIP run
diff --git a/test/run/idl.mo b/test/run/idl.mo
index e4ca01f179b..5343e1364a6 100644
--- a/test/run/idl.mo
+++ b/test/run/idl.mo
@@ -45,7 +45,7 @@ assert(arrayNat == deserArrayInt (serArrayNat arrayNat));
 assert(arrayNat == deserArrayInt (serArrayInt arrayNat));
 assert(arrayInt == deserArrayInt (serArrayInt arrayInt));
 let heapDifference = Prim.rts_heap_size() : Int - started_with;
-assert(heapDifference == 20_412);  
+assert(heapDifference == 5_340);  
 
 //SKIP run
 //SKIP run-ir
diff --git a/test/run/ok/array-len.wasm-run.ok b/test/run/ok/array-len.wasm-run.ok
index 79d6e3a21c5..49fd311aadf 100644
--- a/test/run/ok/array-len.wasm-run.ok
+++ b/test/run/ok/array-len.wasm-run.ok
@@ -1,4 +1,4 @@
-Allocation delta:  68
+Allocation delta:  0
 a
 b
 c

From c3f1b56fd3df9b75179692b212b86f9c7b09465d Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 25 Mar 2024 14:04:28 +0100
Subject: [PATCH 175/260] Adjust stable memory metadata for enhanced orthogonal
 persistence

Distinguish enhanced orthogonal persistence from Candid legacy stabilization
---
 src/codegen/compile.ml | 29 +++++++++++++++++++++++++----
 1 file changed, 25 insertions(+), 4 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 4915622c328..f47865b8106 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -8197,11 +8197,14 @@ end
    Prevents forward compatibility of old compiled programs that rely on deserialization.
   If size == 0: empty
   If logical size N > 0:
-    [0..N]          <stable memory>
+    [0..4]          0 (first word is backed up at `end-8`)
+    [4..N]          <stable memory>
             <zero padding>
-    [end-12..end-4] <size N>
+    [end-16..end-8] <size N>
+    [end-8..end-4]  <first word>
     [end-4..end]    <new version>
   ending at page boundary
+  Note: The first word must be empty to distinguish this version from the Candid legacy version 0 (which has first word != 0).
 *)
 module NewStableMemory = struct
   let physical_size env =
@@ -8233,7 +8236,8 @@ module NewStableMemory = struct
     | _ -> assert false
     )
 
-  let logical_size_offset = 12L
+  let logical_size_offset = 16L
+  let first_word_backup_offset = 8L
   let version_offset = 4L
 
   let upgrade_version env =
@@ -8261,21 +8265,30 @@ module NewStableMemory = struct
     StableMem.ensure env
 
   let backup env =
+    let (set_first_word, get_first_word) = new_local env "first_word" in
     physical_size env ^^
     G.i (Test (Wasm.Values.I64 I64Op.Eqz)) ^^
     G.if0
       G.nop
       begin
+        (* read and clear first word *)
+        compile_const_64 0L ^^ StableMem.read_word32 env ^^ set_first_word ^^
+        compile_const_64 0L ^^ compile_unboxed_const 0l ^^ StableMem.write_word32 env ^^
+
         grow_size env logical_size_offset ^^
 
         (* backup logical size *)
         store_at_end env logical_size_offset I64Type (StableMem.get_mem_size env) ^^
 
+        (* backup first word *)
+        store_at_end env first_word_backup_offset I32Type get_first_word ^^
+
         (* store the version *)
         store_at_end env version_offset I32Type (StableMem.get_version env)
       end
 
   let restore env =
+    let (set_first_word, get_first_word) = new_local env "first_word" in
     physical_size env ^^
     G.i (Test (Wasm.Values.I64 I64Op.Eqz)) ^^
     G.if0
@@ -8295,6 +8308,10 @@ module NewStableMemory = struct
           "unsupported stable memory version (expected %s or %s)"
            (Int32.to_string StableMem.version_stable_heap_no_regions)
            (Int32.to_string StableMem.version_stable_heap_regions)) ^^
+
+        (* read first word *)
+        read_from_end env first_word_backup_offset I32Type ^^
+        set_first_word ^^
         
         (* restore logical size *)
         read_from_end env logical_size_offset I64Type ^^
@@ -8302,7 +8319,11 @@ module NewStableMemory = struct
 
         (* clear size and version *)
         clear_at_end env logical_size_offset I64Type ^^
-        clear_at_end env version_offset I32Type
+        clear_at_end env first_word_backup_offset I32Type ^^
+        clear_at_end env version_offset I32Type ^^
+
+        (* restore first word *)
+        compile_const_64 0L ^^ get_first_word ^^ StableMem.write_word32 env
       end
 end
 

From df3c8a320f14870a28658c103ce25ac77573156f Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 8 Apr 2024 16:09:13 +0200
Subject: [PATCH 176/260] Upgrade IC dependency

---
 nix/sources.json         | 6 +++---
 src/prelude/internals.mo | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/nix/sources.json b/nix/sources.json
index 48f003a2acc..dcb8b681480 100644
--- a/nix/sources.json
+++ b/nix/sources.json
@@ -26,10 +26,10 @@
         "homepage": "",
         "owner": "dfinity",
         "repo": "ic",
-        "rev": "a7dc31400badb6ca7023a6613c09a18434d70ab6",
-        "sha256": "0gap0n3yx7xwhjhigad39ndhp5p49ajr4m2apybmhbbc8smlnlfx",
+        "rev": "31f02c1b08aef1c6ee4c1b6bb9d25c21c5a4ff41",
+        "sha256": "04k278900kv082axrgv6vga0n8sw6c3lcc9298ih9gjyx8hanfb1",
         "type": "tarball",
-        "url": "https://github.com/dfinity/ic/archive/a7dc31400badb6ca7023a6613c09a18434d70ab6.tar.gz",
+        "url": "https://github.com/dfinity/ic/archive/31f02c1b08aef1c6ee4c1b6bb9d25c21c5a4ff41.tar.gz",
         "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
     },
     "ic-hs": {
diff --git a/src/prelude/internals.mo b/src/prelude/internals.mo
index 344a9a120f1..a48cfd9b9e8 100644
--- a/src/prelude/internals.mo
+++ b/src/prelude/internals.mo
@@ -389,7 +389,7 @@ module @ManagementCanister = {
 
 type WasmMemoryPersistence = {
   #Keep;
-  #Drop;
+  #Replace;
 };
 
 type UpgradeOptions = { 

From 0e0227ed80a7043cce78a1b0f69e3998e441340f Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Tue, 9 Apr 2024 13:17:00 +0200
Subject: [PATCH 177/260] Undo temporary change in GitHub workflow

---
 .github/workflows/test.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 1ea320d8144..e922d71e782 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -51,7 +51,7 @@ jobs:
     - run: nix-env -iA nix-build-uncached -f nix/
 
     - name: "pre-build `drun`"
-    #   if: startsWith(github.head_ref, 'update/ic-')
+      if: startsWith(github.head_ref, 'update/ic-')
       run: |
         nix-build --max-jobs 1 -A drun
         nix-store --gc --print-roots | grep /motoko/

From bdaa9796884f54611fa61d6b3d1649225e2b9af0 Mon Sep 17 00:00:00 2001
From: Luc Blaeser <112870813+luc-blaeser@users.noreply.github.com>
Date: Tue, 9 Apr 2024 13:47:56 +0200
Subject: [PATCH 178/260] Update design/OrthogonalPersistence.md

Co-authored-by: Claudio Russo <claudio@dfinity.org>
---
 design/OrthogonalPersistence.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/design/OrthogonalPersistence.md b/design/OrthogonalPersistence.md
index 96c8236e1c9..e66fa94cfcf 100644
--- a/design/OrthogonalPersistence.md
+++ b/design/OrthogonalPersistence.md
@@ -97,7 +97,7 @@ Instead, such global runtime state is stored in the persistent metadata.
 Only passive Wasm data segments are used by the compiler and runtime system. In contrast to ordinary active data segments, passive segments can be explicitly loaded to a dynamic address.
 
 This simplifies two aspects: 
-* The generated Motoko code can contain arbitrarily large data segments which can loaded to dynamic heap when needed.
+* The generated Motoko code can contain arbitrarily large data segments which can be loaded to dynamic heap when needed.
 * The IC can simply retain the main memory on an upgrade without needing to patch the active data segments of the new program version to the persistent memory.
 
 However, more specific handling is required for the Rust-implemented runtime system:

From 524f9963bd4b6bca6d498007488919c8b9458efb Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Tue, 9 Apr 2024 14:19:23 +0200
Subject: [PATCH 179/260] Adjust sentinel value for static roots

---
 rts/motoko-rts/src/gc/incremental/roots.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rts/motoko-rts/src/gc/incremental/roots.rs b/rts/motoko-rts/src/gc/incremental/roots.rs
index 43d8dff5638..f755f38d207 100644
--- a/rts/motoko-rts/src/gc/incremental/roots.rs
+++ b/rts/motoko-rts/src/gc/incremental/roots.rs
@@ -8,7 +8,7 @@ use crate::{types::Value, visitor::is_non_null_pointer_field};
 /// The array constitutes a GC root that is reinitialized on each canister upgrade.
 /// The scalar sentinel denotes an uninitialized root.
 #[cfg(feature = "ic")]
-static mut STATIC_VARIABLES: Value = Value::from_scalar(0);
+static mut STATIC_VARIABLES: Value = crate::types::NULL_POINTER;
 
 /// GC root set.
 pub type Roots = [*mut Value; 6];

From f81edb74a7fbda3b672bfb673f62c30b2b06992c Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Tue, 9 Apr 2024 14:26:28 +0200
Subject: [PATCH 180/260] Remove obsolete comment

---
 rts/motoko-rts/src/persistence.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/rts/motoko-rts/src/persistence.rs b/rts/motoko-rts/src/persistence.rs
index cbd9d7d9371..b1fb0e7a5e4 100644
--- a/rts/motoko-rts/src/persistence.rs
+++ b/rts/motoko-rts/src/persistence.rs
@@ -56,7 +56,6 @@ const METADATA_ADDRESS: usize = 4 * MB + 512 * KB;
 /// The reserved maximum size of the metadata, contains a reserve for future extension of the metadata.
 const METADATA_RESERVE: usize = 512 * KB;
 
-// TODO: Include partition table in reserved space.
 pub const HEAP_START: usize = METADATA_ADDRESS + METADATA_RESERVE;
 
 const _: () = assert!(core::mem::size_of::<PersistentMetadata>() <= METADATA_RESERVE);

From 7739fd6453c1fb7233773848d015a80518a90ff4 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Tue, 9 Apr 2024 14:38:06 +0200
Subject: [PATCH 181/260] Remove redundant IDL parsing case

---
 rts/motoko-rts/src/idl.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/rts/motoko-rts/src/idl.rs b/rts/motoko-rts/src/idl.rs
index 0bd16c300a8..4dd8fe76c4f 100644
--- a/rts/motoko-rts/src/idl.rs
+++ b/rts/motoko-rts/src/idl.rs
@@ -211,8 +211,6 @@ unsafe fn parse_idl_header<M: Memory>(
             check_typearg(mode, t, n_types);
         } else if ty == IDL_CON_record {
             parse_fields(mode, buf, n_types);
-        } else if ty == IDL_EXT_tuple {
-            parse_fields(mode, buf, n_types);
         } else if ty == IDL_CON_variant {
             parse_fields(mode, buf, n_types);
         } else if ty == IDL_CON_func {

From e98774b9aa7ee889b45a78a153ba752dddb206a5 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Tue, 9 Apr 2024 18:27:18 +0200
Subject: [PATCH 182/260] Optimize global type table blob loads

---
 src/codegen/compile.ml | 36 +++++++++++++++++++++---------------
 1 file changed, 21 insertions(+), 15 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index f47865b8106..5f6433fdd73 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -6257,21 +6257,27 @@ module MakeSerialization (Strm : Stream) = struct
       | Some descriptor -> descriptor
       | None -> assert false
 
-    let load_candid_data env =
-      let descriptor = get_global_type_descriptor env in
-      Blob.load_data_segment env E.(descriptor.candid_data_segment) (get_candid_data_length env)
+    let get_global_candid_data env =
+      Tagged.share env (fun env -> 
+        let descriptor = get_global_type_descriptor env in
+        Blob.load_data_segment env E.(descriptor.candid_data_segment) (get_candid_data_length env)
+      )
 
-    let load_type_offsets env =
-      let descriptor = get_global_type_descriptor env in
-      Blob.load_data_segment env E.(descriptor.type_offsets_segment) (get_type_offsets_length env)
+    let get_global_type_offsets env =
+      Tagged.share env (fun env -> 
+        let descriptor = get_global_type_descriptor env in
+        Blob.load_data_segment env E.(descriptor.type_offsets_segment) (get_type_offsets_length env)
+      )
 
-    let count_type_offsets env =
+    let count_global_type_offsets env =
       get_type_offsets_length env ^^
       compile_divU_const candid_type_offset_size
 
-    let load_idl_types env =
-      let descriptor = get_global_type_descriptor env in
-      Blob.load_data_segment env E.(descriptor.idl_types_segment) (get_idl_types_length env)
+    let get_global_idl_types env =
+      Tagged.share env (fun env -> 
+        let descriptor = get_global_type_descriptor env in
+        Blob.load_data_segment env E.(descriptor.idl_types_segment) (get_idl_types_length env)
+      )
       
   module Registers = struct
     let register_globals env =
@@ -6910,17 +6916,17 @@ module MakeSerialization (Strm : Stream) = struct
     if extended then
       f (compile_unboxed_const 0l)
     else
-      get_typtbl_size1 ^^ count_type_offsets env ^^
+      get_typtbl_size1 ^^ count_global_type_offsets env ^^
       E.call_import env "rts" "idl_sub_buf_words" ^^
       Stack.dynamic_with_words env "rel_buf" (fun get_ptr ->
-        get_ptr ^^ get_typtbl_size1 ^^ count_type_offsets env ^^
+        get_ptr ^^ get_typtbl_size1 ^^ count_global_type_offsets env ^^
         E.call_import env "rts" "idl_sub_buf_init" ^^
         f get_ptr)
 
   (* See Note [Candid subtype checks] *)
   let idl_sub env t2 =
     let idx = E.add_typtbl_typ env t2 in
-    load_idl_types env ^^
+    get_global_idl_types env ^^
     Blob.payload_ptr_unskewed env ^^
     G.i (Load {ty = I32Type; align = 0; offset = Int32.mul idx candid_type_offset_size (*!*); sz = None}) ^^
     Func.share_code6 Func.Always env ("idl_sub")
@@ -6939,8 +6945,8 @@ module MakeSerialization (Strm : Stream) = struct
         get_typtbl1 ^^
         get_typtbl_end1 ^^
         get_typtbl_size1 ^^
-        load_candid_data env ^^
-        load_type_offsets env ^^
+        get_global_candid_data env ^^
+        get_global_type_offsets env ^^
         get_idltyp1 ^^
         get_idltyp2 ^^
         E.call_import env "rts" "idl_sub")

From b34d4cecda805438b86bc4e9195108cda2152271 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Tue, 9 Apr 2024 18:47:54 +0200
Subject: [PATCH 183/260] Remove unclear comment

---
 rts/motoko-rts/src/region.rs | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/rts/motoko-rts/src/region.rs b/rts/motoko-rts/src/region.rs
index c1fe8006f67..1f7db49a0ad 100644
--- a/rts/motoko-rts/src/region.rs
+++ b/rts/motoko-rts/src/region.rs
@@ -60,9 +60,6 @@ pub(crate) static mut BLOCK_BASE: u64 = 0;
 pub(crate) const NO_REGION: Value = Value::from_scalar(0);
 
 // Region 0 -- classic API for stable memory, as a dedicated region.
-// NOTE: Multiple instances of region 0 objects can exist,
-// because an upgrade initializes a new instance and old regions can be recovered
-// This was already considered before stable heap design.
 pub(crate) static mut REGION_0: Value = NO_REGION;
 
 // This impl encapsulates encoding of optional region IDs within a u64.

From f924ec8cb07b59284bbb2670517eceb1b5c2e4a1 Mon Sep 17 00:00:00 2001
From: Luc Blaeser <112870813+luc-blaeser@users.noreply.github.com>
Date: Wed, 10 Apr 2024 09:40:58 +0200
Subject: [PATCH 184/260] Update
 rts/motoko-rts/src/persistence/compatibility.rs

Co-authored-by: Claudio Russo <claudio@dfinity.org>
---
 rts/motoko-rts/src/persistence/compatibility.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rts/motoko-rts/src/persistence/compatibility.rs b/rts/motoko-rts/src/persistence/compatibility.rs
index 028933c68ee..9649a23ba0d 100644
--- a/rts/motoko-rts/src/persistence/compatibility.rs
+++ b/rts/motoko-rts/src/persistence/compatibility.rs
@@ -22,7 +22,7 @@ const DEFAULT_VALUE: Value = Value::from_scalar(0);
 /// * To load the types of the current program version from passive data segments, without that absolute
 ///   addresses are known at compile-time.
 /// The static type table is only created when calling the Candid subtype or memory compatibility check.
-/// As the static table contains absolute addresses, it can only temporarily used until the next GC increment.
+/// As the static table contains absolute addresses, it can only be used temporarily until the next GC increment.
 pub struct TypeDescriptor {
     // Blob with candid-encoded type definitions.
     candid_data: Value,

From 0101f0dc7c6c0a304679175886c5a57a73fa1713 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Wed, 10 Apr 2024 10:07:09 +0200
Subject: [PATCH 185/260] Side-effect-free constant function equality check

---
 src/codegen/compile.ml | 26 ++++++++++++++++++--------
 1 file changed, 18 insertions(+), 8 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 5f6433fdd73..7b109b058d2 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -271,7 +271,7 @@ module Const = struct
   *)
 
   type v =
-    | Fun of (unit -> int32) * fun_rhs (* function pointer calculated upon first use *)
+    | Fun of int32 * (unit -> int32) * fun_rhs (* id is used for equality check, function pointer calculated upon first use *)
     | Message of int32 (* anonymous message, only temporary *)
     | Obj of (string * v) list
     | Unit
@@ -282,7 +282,7 @@ module Const = struct
 
   let eq v1 v2 = match v1, v2 with
     | Lit l1, Lit l2 -> lit_eq l1 l2
-    | Fun (f1_fp, _), Fun (f2_fp, _) -> f1_fp() = f2_fp()
+    | Fun (id1, _, _), Fun (id2, _, _) -> id1 = id2
     | _ -> v1 = v2
 
 end (* Const *)
@@ -455,6 +455,9 @@ module E = struct
 
     (* Type descriptor of current program version, created on `conclude_module`. *)
     global_type_descriptor : type_descriptor option ref;
+
+    (* Counter for deriving a unique id per constant function. *)
+    constant_functions : int32 ref;
   }
 
   (* Compile-time-known value, either a plain vanilla constant or a shared object. *)
@@ -495,6 +498,7 @@ module E = struct
     features = ref FeatureSet.empty;
     requires_stable_memory = ref false;
     global_type_descriptor = ref None;
+    constant_functions = ref 0l;
   }
 
   (* This wraps Mo_types.Hash.hash to also record which labels we have seen,
@@ -600,6 +604,11 @@ module E = struct
   let make_lazy_function env name : lazy_function =
     Lib.AllocOnUse.make (fun () -> reserve_fun env name)
 
+  let get_constant_function_id (env : t) : int32 =
+    let id = !(env.constant_functions) in
+    env.constant_functions := (Int32.add id 1l);
+    id
+
   let lookup_built_in (env : t) name : lazy_function =
     match NameEnv.find_opt name !(env.built_in_funcs) with
     | None ->
@@ -8505,7 +8514,7 @@ module StackRep = struct
   | Const.Lit (Const.Word64 (pty, number)) -> BoxedWord64.constant env pty number
   | Const.Lit (Const.Float64 number) -> Float.constant env number
   | Const.Opt value -> Opt.constant env (materialize_constant_value env value)
-  | Const.Fun (get_fi, _) -> Closure.constant env get_fi
+  | Const.Fun (_, get_fi, _) -> Closure.constant env get_fi
   | Const.Message _ -> assert false
   | Const.Unit -> E.Vanilla (Tuple.unit_vanilla_lit env)
   | Const.Tag (tag, value) -> 
@@ -8861,7 +8870,7 @@ end (* Var *)
 module Internals = struct
   let call_prelude_function env ae var =
     match VarEnv.lookup_var ae var with
-    | Some (VarEnv.Const Const.Fun (mk_fi, _)) ->
+    | Some (VarEnv.Const Const.Fun (_, mk_fi, _)) ->
        compile_unboxed_zero ^^ (* A dummy closure *)
        G.i (Call (nr (mk_fi ())))
     | _ -> assert false
@@ -8974,7 +8983,8 @@ module FuncDec = struct
     end else begin
       assert (control = Type.Returns);
       let lf = E.make_lazy_function pre_env name in
-      ( Const.Fun ((fun () -> Lib.AllocOnUse.use lf), fun_rhs), fun env ae ->
+      let fun_id = E.get_constant_function_id pre_env in
+      ( Const.Fun (fun_id, (fun () -> Lib.AllocOnUse.use lf), fun_rhs), fun env ae ->
         let restore_no_env _env ae _ = ae, unmodified in
         Lib.AllocOnUse.def lf (lazy (compile_local_function env ae restore_no_env args mk_body ret_tys at))
       )
@@ -10322,7 +10332,7 @@ and compile_prim_invocation (env : E.t) ae p es at =
 
     (* we duplicate this pattern match to emulate pattern guards *)
     let call_as_prim = match fun_sr, sort with
-      | SR.Const Const.Fun (mk_fi, Const.PrimWrapper prim), _ ->
+      | SR.Const Const.Fun (_, mk_fi, Const.PrimWrapper prim), _ ->
          begin match n_args, e2.it with
          | 0, _ -> true
          | 1, _ -> true
@@ -10332,7 +10342,7 @@ and compile_prim_invocation (env : E.t) ae p es at =
       | _ -> false in
 
     begin match fun_sr, sort with
-      | SR.Const Const.Fun (mk_fi, Const.PrimWrapper prim), _ when call_as_prim ->
+      | SR.Const Const.Fun (_, mk_fi, Const.PrimWrapper prim), _ when call_as_prim ->
          assert (sort = Type.Local);
          (* Handle argument tuples *)
          begin match n_args, e2.it with
@@ -10351,7 +10361,7 @@ and compile_prim_invocation (env : E.t) ae p es at =
            (* ugly case; let's just call this as a function for now *)
            raise (Invalid_argument "call_as_prim was true?")
          end
-      | SR.Const Const.Fun (mk_fi, _), _ ->
+      | SR.Const Const.Fun (_, mk_fi, _), _ ->
          assert (sort = Type.Local);
          StackRep.of_arity return_arity,
 

From a4ff2e23c6804782c2efb44200c0f53a363aaa49 Mon Sep 17 00:00:00 2001
From: Luc Blaeser <112870813+luc-blaeser@users.noreply.github.com>
Date: Thu, 11 Apr 2024 09:24:55 +0200
Subject: [PATCH 186/260] Enhanced Orthogonal Persistence: Optimize Nested
 Shared Objects (#4492)

---
 rts/motoko-rts/src/gc/incremental/roots.rs |  27 +++-
 src/codegen/compile.ml                     | 180 +++++++++++----------
 test/bench/ok/bignum.drun-run.ok           |   2 +-
 test/bench/ok/palindrome.drun-run.ok       |  12 +-
 4 files changed, 124 insertions(+), 97 deletions(-)

diff --git a/rts/motoko-rts/src/gc/incremental/roots.rs b/rts/motoko-rts/src/gc/incremental/roots.rs
index f755f38d207..e629f927c28 100644
--- a/rts/motoko-rts/src/gc/incremental/roots.rs
+++ b/rts/motoko-rts/src/gc/incremental/roots.rs
@@ -10,6 +10,11 @@ use crate::{types::Value, visitor::is_non_null_pointer_field};
 #[cfg(feature = "ic")]
 static mut STATIC_VARIABLES: Value = crate::types::NULL_POINTER;
 
+/// Sanity check for the variable initialization: The variables must be initialized
+/// in increasing order and may only read precedingly initialized variables.
+#[cfg(feature = "ic")]
+static mut INITIALIZED_VARIABLES: u32 = 0;
+
 /// GC root set.
 pub type Roots = [*mut Value; 6];
 
@@ -48,18 +53,32 @@ unsafe fn static_variables_location() -> *mut Value {
 }
 
 #[ic_mem_fn(ic_only)]
-pub unsafe fn set_static_variables<M: crate::memory::Memory>(mem: &mut M, array: Value) {
+pub unsafe fn initialize_static_variables<M: crate::memory::Memory>(mem: &mut M, amount: u32) {
     use super::barriers::write_with_barrier;
-    use crate::types::TAG_ARRAY;
+    use crate::memory::alloc_array;
+    use crate::types::NULL_POINTER;
 
-    assert_eq!(array.tag(), TAG_ARRAY);
+    let variables = alloc_array(mem, amount);
+    let array = variables.as_array();
+    for index in 0..amount {
+        array.initialize(index, NULL_POINTER, mem);
+    }
     let location = &mut STATIC_VARIABLES as *mut Value;
-    write_with_barrier(mem, location, array);
+    write_with_barrier(mem, location, variables);
 }
 
 #[no_mangle]
 #[cfg(feature = "ic")]
 pub unsafe extern "C" fn get_static_variable(index: u32) -> Value {
     debug_assert!(STATIC_VARIABLES.is_non_null_ptr());
+    debug_assert!(index < INITIALIZED_VARIABLES);
     STATIC_VARIABLES.as_array().get(index)
 }
+
+#[ic_mem_fn(ic_only)]
+pub unsafe fn set_static_variable<M: crate::memory::Memory>(mem: &mut M, index: u32, value: Value) {
+    debug_assert!(STATIC_VARIABLES.is_non_null_ptr());
+    debug_assert!(index == INITIALIZED_VARIABLES);
+    STATIC_VARIABLES.as_array().set(index, value, mem);
+    INITIALIZED_VARIABLES += 1;
+}
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 7b109b058d2..4f727c5f017 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -461,10 +461,10 @@ module E = struct
   }
 
   (* Compile-time-known value, either a plain vanilla constant or a shared object. *)
-  type shared_value = 
+  type shared_value =
   | Vanilla of int32
-  | SharedObject of object_allocation
-
+  | SharedObject of int32 (* index in object pool *)
+  
   (* The initial global environment *)
   let mk_global mode rts trap_with : t = {
     mode;
@@ -846,7 +846,7 @@ let compile_xor64_const = function
 let compile_eq64_const i =
   compile_const_64 i ^^
   G.i (Compare (Wasm.Values.I64 I64Op.Eq))
-
+  
 (* A common variant of todo *)
 
 let todo_trap env fn se = todo fn se (E.trap_with env ("TODO: " ^ fn))
@@ -1100,8 +1100,9 @@ module RTS = struct
     E.add_func_import env "rts" "save_stable_actor" [I32Type] [];
     E.add_func_import env "rts" "free_stable_actor" [] [];
     E.add_func_import env "rts" "contains_field" [I32Type; I32Type] [I32Type];
-    E.add_func_import env "rts" "set_static_variables" [I32Type] [];
+    E.add_func_import env "rts" "initialize_static_variables" [I32Type] [];
     E.add_func_import env "rts" "get_static_variable" [I32Type] [I32Type];
+    E.add_func_import env "rts" "set_static_variable" [I32Type; I32Type] [];
     E.add_func_import env "rts" "set_upgrade_instructions" [I64Type] [];
     E.add_func_import env "rts" "get_upgrade_instructions" [] [I64Type];
     E.add_func_import env "rts" "memcpy" [I32Type; I32Type; I32Type] [I32Type]; (* standard libc memcpy *)
@@ -2192,13 +2193,16 @@ module Tagged = struct
     get_object ^^
     allocation_barrier env
 
-  let share env allocation =
+  let shared_object env allocation =
     let index = E.object_pool_add env allocation in
-    Heap.get_static_variable env index
+    E.SharedObject index
 
-  let share_constant env = function
+  let materialize_shared_value env = function
   | E.Vanilla vanilla -> compile_unboxed_const vanilla
-  | E.SharedObject allocation -> share env allocation
+  | E.SharedObject index -> Heap.get_static_variable env index
+
+  let share env allocation =
+    materialize_shared_value env (shared_object env allocation)
 
 end (* Tagged *)
 
@@ -2288,9 +2292,13 @@ module Opt = struct
     )
 
   let constant env = function
-  | E.Vanilla value when value = null_vanilla_lit -> E.SharedObject (fun env -> alloc_some env (null_lit env)) (* ?ⁿnull for n > 0 *)
+  | E.Vanilla value when value = null_vanilla_lit -> Tagged.shared_object env (fun env -> alloc_some env (null_lit env)) (* ?ⁿnull for n > 0 *)
   | E.Vanilla value -> E.Vanilla value (* not null and no `Opt` object *)
-  | E.SharedObject allocation -> E.SharedObject (fun env -> inject env (allocation env)) (* potentially wrap in new `Opt` *)
+  | shared_value ->
+    Tagged.shared_object env (fun env -> 
+      let materialized_value = Tagged.materialize_shared_value env shared_value in  
+      inject env materialized_value (* potentially wrap in new `Opt` *)
+    )
 
   (* This function is used where conceptually, Opt.inject should be used, but
   we know for sure that it wouldn’t do anything anyways, except dereferencing the forwarding pointer *)
@@ -2405,7 +2413,7 @@ module Closure = struct
 
   let constant env get_fi =
     let fi = E.add_fun_ptr env (get_fi ()) in
-    E.SharedObject (fun env -> Tagged.obj env Tagged.Closure [
+    Tagged.shared_object env (fun env -> Tagged.obj env Tagged.Closure [
       compile_unboxed_const fi;
       compile_unboxed_const 0l
     ])
@@ -2446,7 +2454,7 @@ module BoxedWord64 = struct
     then 
       E.Vanilla (BitTagged.tag_const pty i)
     else
-      E.SharedObject (fun env -> compile_box env pty (compile_const_64 i))
+      Tagged.shared_object env (fun env -> compile_box env pty (compile_const_64 i))
 
   let box env pty = 
     Func.share_code1 Func.Never env 
@@ -2568,7 +2576,7 @@ module BoxedSmallWord = struct
     then
       E.Vanilla (BitTagged.tag_const pty (Int64.of_int (Int32.to_int i)))
     else
-      E.SharedObject (fun env -> (Tagged.obj env (heap_tag env pty) [
+      Tagged.shared_object env (fun env -> (Tagged.obj env (heap_tag env pty) [
         compile_unboxed_const i
       ]))
 
@@ -2856,7 +2864,7 @@ module Float = struct
 
   let unbox env = Tagged.load_forwarding_pointer env ^^ Tagged.load_field_float64 env payload_field
 
-  let constant env f = E.SharedObject (fun env -> 
+  let constant env f = Tagged.shared_object env (fun env -> 
     compile_unboxed_const f ^^ 
     box env)
 
@@ -3721,7 +3729,7 @@ module BigNumLibtommath : BigNumType = struct
     let size = Int32.of_int (List.length limbs) in
 
     (* cf. mp_int in tommath.h *)
-    E.SharedObject (fun env -> Tagged.obj env Tagged.BigInt ([
+    Tagged.shared_object env (fun env -> Tagged.obj env Tagged.BigInt ([
       compile_unboxed_const size; (* used *)
       compile_unboxed_const size; (* size; relying on Heap.word_size == size_of(mp_digit) *)
       compile_unboxed_const sign;
@@ -3843,7 +3851,7 @@ module Blob = struct
     compile_add_const (unskewed_payload_offset env)
 
   let constant env payload =
-    E.SharedObject (fun env -> 
+    Tagged.shared_object env (fun env -> 
       let blob_length = Int32.of_int (String.length payload) in
       let (set_new_blob, get_new_blob) = new_local env "new_blob" in
       compile_unboxed_const blob_length ^^ alloc env ^^ set_new_blob ^^
@@ -3855,7 +3863,7 @@ module Blob = struct
     )
 
   let lit env payload =
-    Tagged.share_constant env (constant env payload)
+    Tagged.materialize_shared_value env (constant env payload)
 
   let as_ptr_len env = Func.share_code1 Func.Never env "as_ptr_size" ("x", I32Type) [I32Type; I32Type] (
     fun env get_x ->
@@ -4057,10 +4065,10 @@ module Object = struct
   let hash_ptr_field = Int32.add Tagged.header_size 0l
  
   module FieldEnv = Env.Make(String)
- 
-  (* This is for non-recursive objects, i.e. ObjNewE *)
+
+  (* This is for non-recursive objects. *)
   (* The instructions in the field already create the indirection if needed *)
-  let lit_raw env (fs : (string * (unit -> G.t)) list ) =
+  let object_builder env (fs : (string * (E.t -> G.t)) list ) =
     let name_pos_map =
       fs |>
         (* We could store only public fields in the object, but
@@ -4078,38 +4086,49 @@ module Object = struct
       let hashes = fs |>
         List.map (fun (n,_) -> E.hash env n) |>
         List.sort compare in
-      let hash_blob env =
+      let hash_blob =
         let hash_payload = StaticBytes.[ i32s hashes ] in
-        let blob_constant = Blob.constant env (StaticBytes.as_bytes hash_payload) in
-        match blob_constant with
-        | E.SharedObject allocation -> allocation env
-        | E.Vanilla _ -> assert false
+        Blob.constant env (StaticBytes.as_bytes hash_payload)
       in
+      
+      (fun env -> 
+        (* Allocate memory *)
+        let (set_ri, get_ri, ri) = new_local_ env I32Type "obj" in
+        Tagged.alloc env (Int32.add header_size sz) Tagged.Object ^^
+        set_ri ^^
 
-      (* Allocate memory *)
-      let (set_ri, get_ri, ri) = new_local_ env I32Type "obj" in
-      Tagged.alloc env (Int32.add header_size sz) Tagged.Object ^^
-      set_ri ^^
-
-      (* Set hash_ptr *)
-      get_ri ^^
-      hash_blob env ^^
-      Tagged.store_field env hash_ptr_field ^^
+        (* Set hash_ptr *)
+        get_ri ^^
+        Tagged.materialize_shared_value env hash_blob ^^
+        Tagged.store_field env hash_ptr_field ^^
+
+        (* Write all the fields *)
+        let init_field (name, generate_value) : G.t =
+          (* Write the pointer to the indirection *)
+          get_ri ^^
+          generate_value env ^^
+          let i = FieldEnv.find name name_pos_map in
+          let offset = Int32.add header_size i in
+          Tagged.store_field env offset
+        in
+        G.concat_map init_field fs ^^
 
-      (* Write all the fields *)
-      let init_field (name, mk_is) : G.t =
-        (* Write the pointer to the indirection *)
+        (* Return the pointer to the object *)
         get_ri ^^
-        mk_is () ^^
-        let i = FieldEnv.find name name_pos_map in
-        let offset = Int32.add header_size i in
-        Tagged.store_field env offset
-      in
-      G.concat_map init_field fs ^^
+        Tagged.allocation_barrier env
+      )
 
-      (* Return the pointer to the object *)
-      get_ri ^^
-      Tagged.allocation_barrier env
+  let constant env (fs : (string * E.shared_value) list) =
+    let materialize_fields = List.map (fun (name, value) -> (name, fun env -> Tagged.materialize_shared_value env value)) fs in
+    let allocation = object_builder env materialize_fields in
+    Tagged.shared_object env allocation
+
+  (* This is for non-recursive objects, i.e. ObjNewE *)
+  (* The instructions in the field already create the indirection if needed *)
+  let lit_raw env (fs : (string * (unit -> G.t)) list ) =
+    let materialize_fields = List.map (fun (name, generate_value) -> (name, (fun env -> generate_value ()))) fs in
+    let allocation = object_builder env materialize_fields in
+    allocation env
 
   (* Reflection used by orthogonal persistence: 
      Check whether an (actor) object contains a specific field *)
@@ -4451,6 +4470,12 @@ module Arr = struct
      ([ compile_unboxed_const (Wasm.I32.of_int_u (List.length element_instructions))
       ] @ element_instructions)
 
+  let constant env elements =
+    Tagged.shared_object env (fun env ->
+      let materialized_elements = List.map (fun element -> Tagged.materialize_shared_value env element) elements in
+      lit env materialized_elements
+    )
+
   (* Does not initialize the fields! *)
   (* Note: Post allocation barrier must be applied after initialization *)
   let alloc env =
@@ -5299,7 +5324,7 @@ module Cycles = struct
     let (set_val, get_val) = new_local env "cycles" in
     set_val ^^
     get_val ^^
-    Tagged.share_constant env (BigNum.constant env (Big_int.power_int_positive_int 2 128)) ^^
+    Tagged.materialize_shared_value env (BigNum.constant env (Big_int.power_int_positive_int 2 128)) ^^
     BigNum.compile_relop env Lt ^^
     E.else_trap_with env "cycles out of bounds" ^^
 
@@ -8404,26 +8429,17 @@ module Persistence = struct
 end
 
 module GCRoots = struct
-  let create_root_array env = Func.share_code0 Func.Always env "create_root_array" [I32Type] (fun env ->
+  let register_static_variables env =Func.share_code0 Func.Always env "initalize_root_array" [] (fun env ->
     E.(env.object_pool.frozen) := true;
-    let (set_array, get_array) = new_local env "root_array" in
     let length = Int32.of_int (E.object_pool_size env) in
     compile_unboxed_const length ^^
-    Arr.alloc env ^^
-    set_array ^^
+    E.call_import env "rts" "initialize_static_variables" ^^
     E.iterate_object_pool env (fun index allocation ->
-      get_array ^^
       compile_unboxed_const (Int32.of_int index) ^^
-      Arr.unsafe_idx env ^^
       allocation env ^^
-      store_ptr
-    ) ^^
-    get_array
+      E.call_import env "rts" "set_static_variable"
+    )
   )
-
-  let register_static_variables env =
-    create_root_array env ^^
-    E.call_import env "rts" "set_static_variables"
 end (* GCRoots *)
 
 module StackRep = struct
@@ -8504,7 +8520,7 @@ module StackRep = struct
     | UnboxedTuple n -> G.table n (fun _ -> G.i Drop)
     | Const _ | Unreachable -> G.nop
 
-  let rec materialize_constant_value env = function
+  let rec build_constant env = function
   | Const.Lit (Const.Vanilla value) -> E.Vanilla value
   | Const.Lit (Const.Bool number) -> E.Vanilla (Bool.vanilla_lit number)
   | Const.Lit (Const.Blob payload) -> Blob.constant env payload
@@ -8513,33 +8529,25 @@ module StackRep = struct
   | Const.Lit (Const.Word32 (pty, number)) -> BoxedSmallWord.constant env pty number
   | Const.Lit (Const.Word64 (pty, number)) -> BoxedWord64.constant env pty number
   | Const.Lit (Const.Float64 number) -> Float.constant env number
-  | Const.Opt value -> Opt.constant env (materialize_constant_value env value)
+  | Const.Opt value -> Opt.constant env (build_constant env value)
   | Const.Fun (_, get_fi, _) -> Closure.constant env get_fi
   | Const.Message _ -> assert false
   | Const.Unit -> E.Vanilla (Tuple.unit_vanilla_lit env)
-  | Const.Tag (tag, value) -> 
-      let payload = materialize_constant_element env value in
-      E.SharedObject (fun env -> Variant.inject env tag (payload env))
-  | Const.Array elements -> 
-      let materialized_elements = List.map (materialize_constant_element env) elements in
-      E.SharedObject (fun env -> 
-        let compiled_elements = List.map (fun allocation -> allocation env) materialized_elements in
-        Arr.lit env compiled_elements
-      )
-  | Const.Obj fields -> 
-      let materialized_fields = List.map (fun (name, value) -> (name, materialize_constant_element env value)) fields in
-      E.SharedObject (fun env -> 
-        let compile_fields = List.map (fun (name, allocation) -> (name, fun () -> allocation env)) materialized_fields in
-        Object.lit_raw env compile_fields
+  | Const.Tag (tag, value) ->
+      let payload = build_constant env value in
+      Tagged.shared_object env (fun env ->
+        let materialized_payload = Tagged.materialize_shared_value env payload in
+        Variant.inject env tag materialized_payload
       )
+  | Const.Array elements -> 
+      let constant_elements = List.map (build_constant env) elements in
+      Arr.constant env constant_elements
+  | Const.Obj fields ->
+      let constant_fields = List.map (fun (name, value) -> (name, build_constant env value)) fields in
+      Object.constant env constant_fields
 
-  and materialize_constant_element env value =
-    match materialize_constant_value env value with
-    | E.Vanilla vanilla -> fun env -> compile_unboxed_const vanilla
-    | E.SharedObject allocation -> allocation
-
-  let materialize_shared_constant env value =
-    Tagged.share_constant env (materialize_constant_value env value)
+  let materialize_constant env value =
+    Tagged.materialize_shared_value env (build_constant env value)
 
   let adjust env (sr_in : t) sr_out =
     if eq sr_in sr_out
@@ -8577,7 +8585,7 @@ module StackRep = struct
     | Vanilla, UnboxedFloat64 -> Float.unbox env
 
     | Const value, Vanilla -> 
-        materialize_shared_constant env value
+        materialize_constant env value
     | Const Const.Lit (Const.Vanilla n), UnboxedWord32 ty ->
         compile_unboxed_const n ^^
         TaggedSmallWord.untag env ty
@@ -8589,7 +8597,7 @@ module StackRep = struct
     | Const c, UnboxedTuple 0 -> G.nop
     | Const Const.Array cs, UnboxedTuple n ->
       assert (n = List.length cs);
-      G.concat_map (fun c -> materialize_shared_constant env c) cs
+      G.concat_map (fun c -> materialize_constant env c) cs
     | _, _ ->
       Printf.eprintf "Unknown stack_rep conversion %s -> %s\n"
         (to_string sr_in) (to_string sr_out);
diff --git a/test/bench/ok/bignum.drun-run.ok b/test/bench/ok/bignum.drun-run.ok
index 2dd7f220987..a01bcb6c4ed 100644
--- a/test/bench/ok/bignum.drun-run.ok
+++ b/test/bench/ok/bignum.drun-run.ok
@@ -1,6 +1,6 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 2_626_994; size = +60_128}
+debug.print: {cycles = 2_627_084; size = +60_128}
 ingress Completed: Reply: 0x4449444c0000
 debug.print: {cycles = 107_960_332; size = +1_826_940}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/palindrome.drun-run.ok b/test/bench/ok/palindrome.drun-run.ok
index f82af80bade..6356d04b55b 100644
--- a/test/bench/ok/palindrome.drun-run.ok
+++ b/test/bench/ok/palindrome.drun-run.ok
@@ -1,9 +1,9 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (true, +1_480, 20_073)
-debug.print: (false, +1_480, 19_000)
-debug.print: (false, +1_480, 20_050)
-debug.print: (true, +1_108, 18_905)
-debug.print: (false, +1_096, 17_293)
-debug.print: (false, +1_096, 18_763)
+debug.print: (true, +1_464, 19_881)
+debug.print: (false, +1_464, 18_808)
+debug.print: (false, +1_464, 19_858)
+debug.print: (true, +1_092, 18_713)
+debug.print: (false, +1_080, 17_101)
+debug.print: (false, +1_080, 18_571)
 ingress Completed: Reply: 0x4449444c0000

From 38878fd76d51d7c2eb07b2be2238052f58520035 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 11 Apr 2024 10:14:24 +0200
Subject: [PATCH 187/260] Code refactoring: Constant blobs

---
 src/codegen/compile.ml | 34 ++++++++++++----------------------
 1 file changed, 12 insertions(+), 22 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 4f727c5f017..16627926c7c 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -3834,11 +3834,6 @@ module Blob = struct
       BigNum.from_word32 env
     )
 
-  (* unskewed target address, data offset, and length on stack *)
-  let load_static_data env s =
-    let segment_index = E.add_static env StaticBytes.[Bytes s] in
-    G.i (MemoryInit (nr segment_index))
-
   let alloc env =
     E.call_import env "rts" "alloc_blob" ^^
     (* uninitialized blob payload is allowed by the barrier *)
@@ -3850,16 +3845,21 @@ module Blob = struct
     Tagged.load_forwarding_pointer env ^^
     compile_add_const (unskewed_payload_offset env)
 
+  let load_data_segment env segment_index data_length =
+    let (set_blob, get_blob) = new_local env "data_segment_blob" in
+    data_length ^^
+    alloc env ^^ set_blob ^^
+    get_blob ^^ payload_ptr_unskewed env ^^ (* target address *)
+    compile_unboxed_const 0l ^^ (* data offset *)
+    data_length ^^
+    G.i (MemoryInit (nr segment_index)) ^^
+    get_blob
+
   let constant env payload =
     Tagged.shared_object env (fun env -> 
       let blob_length = Int32.of_int (String.length payload) in
-      let (set_new_blob, get_new_blob) = new_local env "new_blob" in
-      compile_unboxed_const blob_length ^^ alloc env ^^ set_new_blob ^^
-      get_new_blob ^^ payload_ptr_unskewed env ^^ (* target address *)
-      compile_unboxed_const 0l ^^ (* data offset *)
-      compile_unboxed_const blob_length ^^ (* data length *)
-      load_static_data env payload ^^
-      get_new_blob
+      let segment_index = E.add_static env StaticBytes.[Bytes payload] in
+      load_data_segment env segment_index (compile_unboxed_const blob_length)
     )
 
   let lit env payload =
@@ -3874,16 +3874,6 @@ module Blob = struct
   let lit_ptr_len env s =
     lit env s ^^
     as_ptr_len env
-
-  let load_data_segment env segment_index data_length =
-    let (set_blob, get_blob) = new_local env "data_segment_blob" in
-    data_length ^^
-    alloc env ^^ set_blob ^^
-    get_blob ^^ payload_ptr_unskewed env ^^ (* target address *)
-    compile_unboxed_const 0l ^^ (* data offset *)
-    data_length ^^
-    G.i (MemoryInit (nr segment_index)) ^^
-    get_blob
   
   let of_ptr_size env = Func.share_code2 Func.Always env "blob_of_ptr_size" (("ptr", I32Type), ("size" , I32Type)) [I32Type] (
     fun env get_ptr get_size ->

From 03f1e893063b876ae347cec4ea0e6e643e15bf70 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 11 Apr 2024 10:36:24 +0200
Subject: [PATCH 188/260] Format adjustment

---
 src/codegen/compile.ml | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 16627926c7c..3974c76d278 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -6259,9 +6259,10 @@ module MakeSerialization (Strm : Stream) = struct
   *)
 
   module Strm = Strm
-    (* Globals recording known Candid types
-      See Note [Candid subtype checks]
-    *)
+  (* Globals recording known Candid types
+    See Note [Candid subtype checks]
+  *)
+  
     let register_delayed_globals env =
       (E.add_global32_delayed env "__candid_data_length" Immutable,
       E.add_global32_delayed env "__type_offsets_length" Immutable,

From af1e6c95b5367ac6b2798351e42048cc3e075bc9 Mon Sep 17 00:00:00 2001
From: Luc Blaeser <112870813+luc-blaeser@users.noreply.github.com>
Date: Thu, 11 Apr 2024 10:48:01 +0200
Subject: [PATCH 189/260] Update src/codegen/compile.ml

Co-authored-by: Claudio Russo <claudio@dfinity.org>
---
 src/codegen/compile.ml | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 3974c76d278..412bf6b5bdc 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -8227,13 +8227,14 @@ end
 (* New stable memory layout with new version.
    Prevents forward compatibility of old compiled programs that rely on deserialization.
   If size == 0: empty
+  let end = physical size * page_size
   If logical size N > 0:
-    [0..4]          0 (first word is backed up at `end-8`)
-    [4..N]          <stable memory>
+    [0..4)          0 (first word is backed up at `end-8`)
+    [4..N)          <stable memory>
             <zero padding>
-    [end-16..end-8] <size N>
-    [end-8..end-4]  <first word>
-    [end-4..end]    <new version>
+    [end-16..end-8) <size N>
+    [end-8..end-4)  <first word>
+    [end-4..end)   <new version>
   ending at page boundary
   Note: The first word must be empty to distinguish this version from the Candid legacy version 0 (which has first word != 0).
 *)

From 787b574927e7a54b2241deb192c25905d134c765 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 11 Apr 2024 11:02:56 +0200
Subject: [PATCH 190/260] Move "object pool frozen" safety check

---
 src/codegen/compile.ml | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 412bf6b5bdc..d58722b81d2 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -6262,7 +6262,7 @@ module MakeSerialization (Strm : Stream) = struct
   (* Globals recording known Candid types
     See Note [Candid subtype checks]
   *)
-  
+
     let register_delayed_globals env =
       (E.add_global32_delayed env "__candid_data_length" Immutable,
       E.add_global32_delayed env "__type_offsets_length" Immutable,
@@ -8421,17 +8421,18 @@ module Persistence = struct
 end
 
 module GCRoots = struct
-  let register_static_variables env =Func.share_code0 Func.Always env "initalize_root_array" [] (fun env ->
+  let register_static_variables env =
     E.(env.object_pool.frozen) := true;
-    let length = Int32.of_int (E.object_pool_size env) in
-    compile_unboxed_const length ^^
-    E.call_import env "rts" "initialize_static_variables" ^^
-    E.iterate_object_pool env (fun index allocation ->
-      compile_unboxed_const (Int32.of_int index) ^^
-      allocation env ^^
-      E.call_import env "rts" "set_static_variable"
+    Func.share_code0 Func.Always env "initalize_root_array" [] (fun env ->
+      let length = Int32.of_int (E.object_pool_size env) in
+      compile_unboxed_const length ^^
+      E.call_import env "rts" "initialize_static_variables" ^^
+      E.iterate_object_pool env (fun index allocation ->
+        compile_unboxed_const (Int32.of_int index) ^^
+        allocation env ^^
+        E.call_import env "rts" "set_static_variable"
+      )
     )
-  )
 end (* GCRoots *)
 
 module StackRep = struct

From 3d52046220b043315a14b7ae902e287140f6177f Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 11 Apr 2024 11:32:15 +0200
Subject: [PATCH 191/260] Code Refactoring: Getting rid of `Stream` interface.

---
 src/codegen/compile.ml | 311 +++++++++++++++++------------------------
 1 file changed, 129 insertions(+), 182 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index d58722b81d2..e0468692cb5 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -6094,146 +6094,7 @@ module RTS_Exports = struct
 
 end (* RTS_Exports *)
 
-
-(* Below signature is needed by the serialiser to supply the
-   methods various formats and auxiliary routines. A stream
-   token refers to the stream itself. Depending on the stream's
-   methodology, the token can be a (bump) pointer or a handle
-   (like a `Blob`). The former needs to be updated at certain
-   points because the token will normally reside in locals that
-   nested functions won't have access to. *)
-module type Stream = sig
-  (* Bottleneck routines for streaming in different formats.
-     The `code` must be used linearly. `token` is a fragment
-     of Wasm that puts the stream token onto the stack.
-     Arguments:    env    token  code *)
-  val write_byte : E.t -> G.t -> G.t -> G.t
-  val write_word_leb : E.t -> G.t -> G.t -> G.t
-  val write_word_32 : E.t -> G.t -> G.t -> G.t
-  val write_blob : E.t -> G.t -> G.t -> G.t
-  val write_text : E.t -> G.t -> G.t -> G.t
-  val write_bignum_leb : E.t -> G.t -> G.t -> G.t
-  val write_bignum_sleb : E.t -> G.t -> G.t -> G.t
-
-  (* Creates a fresh stream with header, storing stream token.
-     Arguments:env    size   setter getter header *)
-  val create : E.t -> G.t -> G.t -> G.t -> string -> G.t
-
-  (* Checks the stream's filling, traps if unexpected
-     Arguments:      env    token  size *)
-  val check_filled : E.t -> G.t -> G.t -> G.t
-
-  (* Pushes the stream's current absolute byte offset on stack.
-     The requirement is that the difference between two uses
-     of this method must give a correct _relative_ offset.
-     Arguments:         env    token *)
-  val absolute_offset : E.t -> G.t -> G.t
-
-  (* Finishes the stream, performing consistency checks.
-     Leaves two words on stack, whose interpretation depends
-     on the Stream.
-     Arguments:   env    token  size   header_size *)
-  val terminate : E.t -> G.t -> G.t -> int32 -> G.t
-
-  (* Executes code to eliminate the residual buffer
-     that `terminate` returns (if at all) *)
-  val finalize_buffer : G.t -> G.t
-
-  (* Builds a unique name for a name seed and a type *)
-  val name_for : string -> Type.typ list -> string
-
-  (* Opportunity to flush or update the token. Stream token is on stack. *)
-  val checkpoint : E.t -> G.t -> G.t
-
-  (* Reserve a small fixed number of bytes in the stream and return an
-     address to it. The address is invalidated by a GC, and as such must
-     be written to in the next few instructions. *)
-  val reserve : E.t -> G.t -> int32 -> G.t
-end
-
-
-module BumpStream : Stream = struct
-  let create env get_data_size set_data_buf get_data_buf header =
-    let header_size = Int32.of_int (String.length header) in
-    get_data_size ^^ compile_add_const header_size ^^
-    Blob.dyn_alloc_scratch env ^^ set_data_buf ^^
-    get_data_buf ^^
-    Blob.lit env header ^^ Blob.payload_ptr_unskewed env ^^
-    compile_unboxed_const header_size ^^
-    Heap.memcpy env ^^
-    get_data_buf ^^ compile_add_const header_size ^^ set_data_buf
-
-  let check_filled env get_data_buf get_data_size =
-    get_data_buf ^^ get_data_size ^^ G.i (Binary (Wasm.Values.I32 I32Op.Add)) ^^
-    G.i (Compare (Wasm.Values.I32 I32Op.Eq)) ^^
-    E.else_trap_with env "data buffer not filled"
-
-  let terminate env get_data_buf get_data_size header_size =
-    get_data_buf ^^ compile_sub_const header_size ^^
-    get_data_size ^^ compile_add_const header_size
-
-  let finalize_buffer code = code
-
-  let name_for fn_name ts = "@" ^ fn_name ^ "<" ^ Typ_hash.typ_seq_hash ts ^ ">"
-
-  let advance_data_buf get_data_buf =
-    get_data_buf ^^ G.i (Binary (Wasm.Values.I32 I32Op.Add)) ^^ G.setter_for get_data_buf
-
-  let absolute_offset _env get_data_buf = get_data_buf
-
-  let checkpoint _env get_data_buf = G.setter_for get_data_buf
-
-  let reserve _env get_data_buf bytes =
-    get_data_buf ^^ get_data_buf ^^ compile_add_const bytes ^^ G.setter_for get_data_buf
-
-  let write_word_leb env get_data_buf code =
-    let set_word, get_word = new_local env "word" in
-    code ^^ set_word ^^
-    I32Leb.compile_store_to_data_buf_unsigned env get_word get_data_buf ^^
-    advance_data_buf get_data_buf
-
-  let write_word_32 env get_data_buf code =
-    get_data_buf ^^ code ^^
-    G.i (Store {ty = I32Type; align = 0; offset = 0l; sz = None}) ^^
-    compile_unboxed_const Heap.word_size ^^ advance_data_buf get_data_buf
-
-  let write_byte _env get_data_buf code =
-    get_data_buf ^^ code ^^
-    G.i (Store {ty = I32Type; align = 0; offset = 0l; sz = Some Wasm.Types.Pack8}) ^^
-    compile_unboxed_const 1l ^^ advance_data_buf get_data_buf
-
-  let write_blob env get_data_buf get_x =
-    let set_len, get_len = new_local env "len" in
-    get_x ^^ Blob.len env ^^ set_len ^^
-    write_word_leb env get_data_buf get_len ^^
-    get_data_buf ^^
-    get_x ^^ Blob.payload_ptr_unskewed env ^^
-    get_len ^^
-    Heap.memcpy env ^^
-    get_len ^^ advance_data_buf get_data_buf
-
-  let write_text env get_data_buf get_x =
-    let set_len, get_len = new_local env "len" in
-    get_x ^^ Text.size env ^^ set_len ^^
-    write_word_leb env get_data_buf get_len ^^
-    get_x ^^ get_data_buf ^^ Text.to_buf env ^^
-    get_len ^^ advance_data_buf get_data_buf
-
-  let write_bignum_leb env get_data_buf get_x =
-    get_data_buf ^^
-    get_x ^^
-    BigNum.compile_store_to_data_buf_unsigned env ^^
-    advance_data_buf get_data_buf
-
-  let write_bignum_sleb env get_data_buf get_x =
-    get_data_buf ^^
-    get_x ^^
-    BigNum.compile_store_to_data_buf_signed env ^^
-    advance_data_buf get_data_buf
-
-end
-
-module MakeSerialization (Strm : Stream) = struct
+module Serialization = struct
   (*
     The general serialization strategy is as follows:
     * We statically generate the IDL type description header.
@@ -6258,52 +6119,140 @@ module MakeSerialization (Strm : Stream) = struct
       by the next GC.
   *)
 
-  module Strm = Strm
+  module Strm = struct
+    (* Creates a fresh stream with header, storing stream token. *)
+    let create env get_data_size set_data_buf get_data_buf header =
+      let header_size = Int32.of_int (String.length header) in
+      get_data_size ^^ compile_add_const header_size ^^
+      Blob.dyn_alloc_scratch env ^^ set_data_buf ^^
+      get_data_buf ^^
+      Blob.lit env header ^^ Blob.payload_ptr_unskewed env ^^
+      compile_unboxed_const header_size ^^
+      Heap.memcpy env ^^
+      get_data_buf ^^ compile_add_const header_size ^^ set_data_buf
+  
+    (* Checks the stream's filling, traps if unexpected *)
+    let check_filled env get_data_buf get_data_size =
+      get_data_buf ^^ get_data_size ^^ G.i (Binary (Wasm.Values.I32 I32Op.Add)) ^^
+      G.i (Compare (Wasm.Values.I32 I32Op.Eq)) ^^
+      E.else_trap_with env "data buffer not filled"
+  
+    (* Finishes the stream, performing consistency checks. 
+       Returns payload address and size including the header. *)
+    let terminate env get_data_buf get_data_size header_size =
+      get_data_buf ^^ compile_sub_const header_size ^^
+      get_data_size ^^ compile_add_const header_size
+  
+    (* Builds a unique name for a name seed and a type. *)
+    let name_for fn_name ts = "@" ^ fn_name ^ "<" ^ Typ_hash.typ_seq_hash ts ^ ">"
+  
+    let advance_data_buf get_data_buf =
+      get_data_buf ^^ G.i (Binary (Wasm.Values.I32 I32Op.Add)) ^^ G.setter_for get_data_buf
+  
+    (* Pushes the stream's current absolute byte offset on stack.
+       The requirement is that the difference between two uses
+       of this method must give a correct _relative_ offset. *)
+    let absolute_offset _env get_data_buf = get_data_buf
+  
+    (* Opportunity to flush or update the token. Stream token is on stack. *)
+    let checkpoint _env get_data_buf = G.setter_for get_data_buf
+  
+    (* Reserve a small fixed number of bytes in the stream and return an
+       address to it. The address is invalidated by a GC, and as such must
+       be written to in the next few instructions. *)
+    let reserve _env get_data_buf bytes =
+      get_data_buf ^^ get_data_buf ^^ compile_add_const bytes ^^ G.setter_for get_data_buf
+  
+    let write_word_leb env get_data_buf code =
+      let set_word, get_word = new_local env "word" in
+      code ^^ set_word ^^
+      I32Leb.compile_store_to_data_buf_unsigned env get_word get_data_buf ^^
+      advance_data_buf get_data_buf
+  
+    let write_word_32 env get_data_buf code =
+      get_data_buf ^^ code ^^
+      G.i (Store {ty = I32Type; align = 0; offset = 0l; sz = None}) ^^
+      compile_unboxed_const Heap.word_size ^^ advance_data_buf get_data_buf
+  
+    let write_byte _env get_data_buf code =
+      get_data_buf ^^ code ^^
+      G.i (Store {ty = I32Type; align = 0; offset = 0l; sz = Some Wasm.Types.Pack8}) ^^
+      compile_unboxed_const 1l ^^ advance_data_buf get_data_buf
+  
+    let write_blob env get_data_buf get_x =
+      let set_len, get_len = new_local env "len" in
+      get_x ^^ Blob.len env ^^ set_len ^^
+      write_word_leb env get_data_buf get_len ^^
+      get_data_buf ^^
+      get_x ^^ Blob.payload_ptr_unskewed env ^^
+      get_len ^^
+      Heap.memcpy env ^^
+      get_len ^^ advance_data_buf get_data_buf
+  
+    let write_text env get_data_buf get_x =
+      let set_len, get_len = new_local env "len" in
+      get_x ^^ Text.size env ^^ set_len ^^
+      write_word_leb env get_data_buf get_len ^^
+      get_x ^^ get_data_buf ^^ Text.to_buf env ^^
+      get_len ^^ advance_data_buf get_data_buf
+  
+    let write_bignum_leb env get_data_buf get_x =
+      get_data_buf ^^
+      get_x ^^
+      BigNum.compile_store_to_data_buf_unsigned env ^^
+      advance_data_buf get_data_buf
+  
+    let write_bignum_sleb env get_data_buf get_x =
+      get_data_buf ^^
+      get_x ^^
+      BigNum.compile_store_to_data_buf_signed env ^^
+      advance_data_buf get_data_buf
+  end (* Strm *)
+
   (* Globals recording known Candid types
     See Note [Candid subtype checks]
   *)
+  let register_delayed_globals env =
+    (E.add_global32_delayed env "__candid_data_length" Immutable,
+    E.add_global32_delayed env "__type_offsets_length" Immutable,
+    E.add_global32_delayed env "__idl_types_length" Immutable)
+
+  let get_candid_data_length env =
+    G.i (GlobalGet (nr (E.get_global env "__candid_data_length")))
+  let get_type_offsets_length env =
+    G.i (GlobalGet (nr (E.get_global env "__type_offsets_length")))
+  let get_idl_types_length env =
+    G.i (GlobalGet (nr (E.get_global env "__idl_types_length")))
+
+  let candid_type_offset_size = 4l
+
+  let get_global_type_descriptor env =
+    match !(E.(env.global_type_descriptor)) with
+    | Some descriptor -> descriptor
+    | None -> assert false
 
-    let register_delayed_globals env =
-      (E.add_global32_delayed env "__candid_data_length" Immutable,
-      E.add_global32_delayed env "__type_offsets_length" Immutable,
-      E.add_global32_delayed env "__idl_types_length" Immutable)
-
-    let get_candid_data_length env =
-      G.i (GlobalGet (nr (E.get_global env "__candid_data_length")))
-    let get_type_offsets_length env =
-      G.i (GlobalGet (nr (E.get_global env "__type_offsets_length")))
-    let get_idl_types_length env =
-      G.i (GlobalGet (nr (E.get_global env "__idl_types_length")))
-
-    let candid_type_offset_size = 4l
-
-    let get_global_type_descriptor env =
-      match !(E.(env.global_type_descriptor)) with
-      | Some descriptor -> descriptor
-      | None -> assert false
-
-    let get_global_candid_data env =
-      Tagged.share env (fun env -> 
-        let descriptor = get_global_type_descriptor env in
-        Blob.load_data_segment env E.(descriptor.candid_data_segment) (get_candid_data_length env)
-      )
+  let get_global_candid_data env =
+    Tagged.share env (fun env -> 
+      let descriptor = get_global_type_descriptor env in
+      Blob.load_data_segment env E.(descriptor.candid_data_segment) (get_candid_data_length env)
+    )
 
-    let get_global_type_offsets env =
-      Tagged.share env (fun env -> 
-        let descriptor = get_global_type_descriptor env in
-        Blob.load_data_segment env E.(descriptor.type_offsets_segment) (get_type_offsets_length env)
-      )
+  let get_global_type_offsets env =
+    Tagged.share env (fun env -> 
+      let descriptor = get_global_type_descriptor env in
+      Blob.load_data_segment env E.(descriptor.type_offsets_segment) (get_type_offsets_length env)
+    )
 
-    let count_global_type_offsets env =
-      get_type_offsets_length env ^^
-      compile_divU_const candid_type_offset_size
+  let count_global_type_offsets env =
+    get_type_offsets_length env ^^
+    compile_divU_const candid_type_offset_size
 
-    let get_global_idl_types env =
-      Tagged.share env (fun env -> 
-        let descriptor = get_global_type_descriptor env in
-        Blob.load_data_segment env E.(descriptor.idl_types_segment) (get_idl_types_length env)
-      )
-      
+  let get_global_idl_types env =
+    Tagged.share env (fun env -> 
+      let descriptor = get_global_type_descriptor env in
+      Blob.load_data_segment env E.(descriptor.idl_types_segment) (get_idl_types_length env)
+    )
+  
   module Registers = struct
     let register_globals env =
       E.add_global32 env "@@rel_buf_opt" Mutable 0l;
@@ -8010,9 +7959,7 @@ from a Boolean to a three-valued argument to efficiently check equality for
 invariant type constructors in a single pass.
 *)
 
-end (* MakeSerialization *)
-
-module Serialization = MakeSerialization(BumpStream)
+end (* Serialization *)
 
 (* OldStabilization as migration code: 
   Deserializing a last time from explicit stable memory into the stable heap:

From 2c6875c2431d395f9b60c2a029843547f9d5b4ee Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 11 Apr 2024 13:59:41 +0200
Subject: [PATCH 192/260] Handle all cases on constant equality

---
 src/codegen/compile.ml | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index e0468692cb5..938a6ea9f24 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -280,10 +280,21 @@ module Const = struct
     | Opt of v
     | Lit of lit
 
-  let eq v1 v2 = match v1, v2 with
-    | Lit l1, Lit l2 -> lit_eq l1 l2
+  let rec eq v1 v2 = match v1, v2 with
     | Fun (id1, _, _), Fun (id2, _, _) -> id1 = id2
-    | _ -> v1 = v2
+    | Message fi1, Message fi2 -> fi1 = fi2
+    | Obj fields1, Obj fields2 ->
+      let equal_fields (name1, field_value1) (name2, field_value2) = (name1 = name2) && (eq field_value1 field_value2) in
+      List.for_all2 equal_fields fields1 fields2
+    | Unit, Unit -> true
+    | Array elements1, Array elements2 ->
+      List.for_all2 eq elements1 elements2
+    | Tag (name1, tag_value1), Tag (name2, tag_value2) ->
+      (name1 = name2) && (eq tag_value1 tag_value2)
+    | Opt opt_value1, Opt opt_value2 -> eq opt_value1 opt_value2
+    | Lit l1, Lit l2 -> lit_eq l1 l2
+    | Fun _, _ | Message _, _ | Obj _, _ | Unit, _ 
+    | Array _, _ | Tag _, _ | Opt _, _ | Lit _, _ -> false
 
 end (* Const *)
 

From 24cfff4edb23135b04ca9d754c00bac04fdce8c1 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 11 Apr 2024 14:10:08 +0200
Subject: [PATCH 193/260] Refactor null comparison

---
 src/codegen/compile.ml | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 938a6ea9f24..991dcb37e31 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -2011,6 +2011,8 @@ module Tagged = struct
   let null_vanilla_pointer = 0xffff_fffbl (* skewed, pointing to last unallocated Wasm page *)
   let null_pointer = compile_unboxed_const null_vanilla_pointer
 
+  let is_null env = compile_eq_const null_vanilla_pointer
+
   let not_null env =
     (* null test works without forwarding pointer resolution of a non-null comparand *)
     null_pointer ^^ 
@@ -2278,6 +2280,7 @@ module Opt = struct
   let null_vanilla_lit = Tagged.null_vanilla_pointer
   let null_lit env = Tagged.null_pointer
 
+  let is_null = Tagged.is_null
   let is_some = Tagged.not_null
 
   let alloc_some env get_payload =
@@ -11834,8 +11837,7 @@ enabled mutual recursion.
 and compile_lit_pat env l =
   match l with
   | NullLit ->
-    Opt.is_some env ^^
-    Bool.neg
+    Opt.is_null env
   | BoolLit true ->
     G.nop
   | BoolLit false ->

From 7912b94a30ef9bd4997615f9281465dbe5bf8c64 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 11 Apr 2024 14:42:53 +0200
Subject: [PATCH 194/260] Adding upgrade option with explicit control of memory
 persistence

---
 src/mo_types/type.ml                          | 15 ++++++++++++++-
 src/prelude/internals.mo                      |  9 +++++++--
 test/run-drun/actor-class-mgmt.mo             | 16 ++++++++++++++--
 test/run-drun/ok/actor-class-mgmt.drun-run.ok |  2 +-
 4 files changed, 36 insertions(+), 6 deletions(-)

diff --git a/src/mo_types/type.ml b/src/mo_types/type.ml
index 4fe364fbe69..cc4e27c8c7b 100644
--- a/src/mo_types/type.ml
+++ b/src/mo_types/type.ml
@@ -1387,12 +1387,25 @@ let canister_settings_typ =
       ("memory_allocation", Opt nat);
       ("freezing_threshold", Opt nat)])]
 
+let wasm_memory_persistence_typ =
+  sum [
+    ("Keep", unit);
+    ("Replace", unit);
+  ]
+
+let upgrade_with_persistence_option_typ =
+  obj Object [
+    ("wasm_memory_persistence", wasm_memory_persistence_typ);
+    ("canister", obj Actor []);
+  ]
+
 let install_arg_typ =
   sum [
     ("new", canister_settings_typ);
     ("install", principal);
     ("reinstall", obj Actor []);
-    ("upgrade", obj Actor [])
+    ("upgrade", obj Actor []);
+    ("upgrade_with_persistence", upgrade_with_persistence_option_typ );
   ]
 
 let install_typ ts actor_typ =
diff --git a/src/prelude/internals.mo b/src/prelude/internals.mo
index a48cfd9b9e8..671426e993c 100644
--- a/src/prelude/internals.mo
+++ b/src/prelude/internals.mo
@@ -420,7 +420,8 @@ func @install_actor_helper(
       #new : { settings : ?@ManagementCanister.canister_settings } ;
       #install : Principal;
       #reinstall : actor {} ;
-      #upgrade : actor {}
+      #upgrade : actor {} ;
+      #upgrade_with_persistence : { wasm_memory_persistence: WasmMemoryPersistence; canister: actor {} };
     },
     wasm_module : Blob,
     arg : Blob)
@@ -447,7 +448,11 @@ func @install_actor_helper(
           wasm_memory_persistence = ?(#Keep);
         };
         ((#upgrade (?upgradeOptions)), (prim "cast" : (actor {}) -> Principal) actor2)
-      }
+      };
+      case (#upgrade_with_persistence { wasm_memory_persistence; canister } ) {
+        let upgradeOptions = { wasm_memory_persistence = ?wasm_memory_persistence };
+        ((#upgrade (?upgradeOptions)), (prim "cast" : (actor {}) -> Principal) canister)
+      };
     };
   await @ic00.install_code {
     mode;
diff --git a/test/run-drun/actor-class-mgmt.mo b/test/run-drun/actor-class-mgmt.mo
index 8f11a38d773..a3234d32557 100644
--- a/test/run-drun/actor-class-mgmt.mo
+++ b/test/run-drun/actor-class-mgmt.mo
@@ -105,10 +105,22 @@ actor a {
 
       // no need to add cycles
       let c5 = await
-        (system Cs.C)(#reinstall c4)(5, null);
-      assert ({args = 5; upgrades = 0} == (await c5.observe()));
+        (system Cs.C)(#upgrade_with_persistence { wasm_memory_persistence = #Keep ; canister = c4 })(5, null);
+      assert ({args = 5; upgrades = 2} == (await c5.observe()));
       assert (c5 == c4);
 
+      // no need to add cycles
+      let c6 = await
+        (system Cs.C)(#reinstall c5)(6, null);
+      assert ({args = 6; upgrades = 0} == (await c6.observe()));
+      assert (c6 == c5);
+
+      // no need to add cycles
+      let c7 = await
+        (system Cs.C)(#upgrade_with_persistence { wasm_memory_persistence = #Replace ; canister = c6 })(7, null);
+      assert ({args = 7; upgrades = 0} == (await c7.observe()));
+      assert (c7 == c6);
+
       let info = await ic00.canister_info {
           canister_id = p;
           num_requested_changes = ?4
diff --git a/test/run-drun/ok/actor-class-mgmt.drun-run.ok b/test/run-drun/ok/actor-class-mgmt.drun-run.ok
index ff06ef84fef..bddc341e0a0 100644
--- a/test/run-drun/ok/actor-class-mgmt.drun-run.ok
+++ b/test/run-drun/ok/actor-class-mgmt.drun-run.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {controllers = [rwlgt-iiaaa-aaaaa-aaaaa-cai]; recent_changes = [{canister_version = 0; details = #creation({controllers = [rwlgt-iiaaa-aaaaa-aaaaa-cai]}); origin = #from_canister({canister_id = rwlgt-iiaaa-aaaaa-aaaaa-cai; canister_version = null})}, {canister_version = 1; details = #code_deployment({mode = #install}); origin = #from_canister({canister_id = rwlgt-iiaaa-aaaaa-aaaaa-cai; canister_version = ?18})}, {canister_version = 3; details = #code_deployment({mode = #upgrade}); origin = #from_canister({canister_id = rwlgt-iiaaa-aaaaa-aaaaa-cai; canister_version = ?22})}, {canister_version = 5; details = #code_deployment({mode = #reinstall}); origin = #from_canister({canister_id = rwlgt-iiaaa-aaaaa-aaaaa-cai; canister_version = ?26})}]; total_num_changes = 4}
+debug.print: {controllers = [rwlgt-iiaaa-aaaaa-aaaaa-cai]; recent_changes = [{canister_version = 3; details = #code_deployment({mode = #upgrade}); origin = #from_canister({canister_id = rwlgt-iiaaa-aaaaa-aaaaa-cai; canister_version = ?22})}, {canister_version = 5; details = #code_deployment({mode = #upgrade}); origin = #from_canister({canister_id = rwlgt-iiaaa-aaaaa-aaaaa-cai; canister_version = ?26})}, {canister_version = 7; details = #code_deployment({mode = #reinstall}); origin = #from_canister({canister_id = rwlgt-iiaaa-aaaaa-aaaaa-cai; canister_version = ?30})}, {canister_version = 9; details = #code_deployment({mode = #upgrade}); origin = #from_canister({canister_id = rwlgt-iiaaa-aaaaa-aaaaa-cai; canister_version = ?34})}]; total_num_changes = 6}
 ingress Completed: Reply: 0x4449444c0000

From 02315752e95d86539dadd540168ca28a47abecda Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 11 Apr 2024 16:00:39 +0200
Subject: [PATCH 195/260] Adjust test

---
 test/run-drun/max-stack-variant.mo | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/run-drun/max-stack-variant.mo b/test/run-drun/max-stack-variant.mo
index fad29cf2893..d790de7a793 100644
--- a/test/run-drun/max-stack-variant.mo
+++ b/test/run-drun/max-stack-variant.mo
@@ -2,7 +2,7 @@
 import { errorMessage; debugPrint; } = "mo:⛔";
 
 actor {
-    let expectedMinimumSize = 26_000;
+    let expectedMinimumSize = 31_000;
 
     public func ser() : async () { await go(false) };
     public func deser() : async () { await go(true) };

From 7d71dafeea24bd049ead0d69dabadefc69a0aa3d Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 12 Apr 2024 14:42:23 +0200
Subject: [PATCH 196/260] Bug fix: Enforce invariance for mutable objects,
 variants, and services

---
 rts/motoko-rts/src/idl.rs                     | 17 ++++---
 .../run-drun/ok/upgrade-mutable-array.drun.ok | 17 +++++++
 .../ok/upgrade-mutable-service.drun.ok        | 33 ++++++++++++++
 .../ok/upgrade-mutable-variant.drun.ok        |  9 ++++
 test/run-drun/ok/upgrade-service.drun.ok      | 20 +++++++++
 test/run-drun/upgrade-mutable-array.drun      |  5 +++
 .../upgrade-mutable-array/version0.mo         | 22 ++++++++++
 .../upgrade-mutable-array/version1.mo         | 28 ++++++++++++
 test/run-drun/upgrade-mutable-service.drun    |  9 ++++
 .../original-service.mo                       | 19 ++++++++
 .../reduced-service.mo                        | 11 +++++
 .../upgrade-mutable-service/version0.mo       | 42 ++++++++++++++++++
 .../upgrade-mutable-service/version1.mo       | 44 +++++++++++++++++++
 test/run-drun/upgrade-mutable-variant.drun    |  5 +++
 .../upgrade-mutable-variant/version0.mo       | 16 +++++++
 .../upgrade-mutable-variant/version1.mo       | 26 +++++++++++
 test/run-drun/upgrade-service.drun            | 14 ++++++
 .../upgrade-service/original-service.mo       | 11 +++++
 .../upgrade-service/reduced-service.mo        |  7 +++
 test/run-drun/upgrade-service/version0.mo     | 28 ++++++++++++
 test/run-drun/upgrade-service/version1.mo     | 30 +++++++++++++
 21 files changed, 408 insertions(+), 5 deletions(-)
 create mode 100644 test/run-drun/ok/upgrade-mutable-array.drun.ok
 create mode 100644 test/run-drun/ok/upgrade-mutable-service.drun.ok
 create mode 100644 test/run-drun/ok/upgrade-mutable-variant.drun.ok
 create mode 100644 test/run-drun/ok/upgrade-service.drun.ok
 create mode 100644 test/run-drun/upgrade-mutable-array.drun
 create mode 100644 test/run-drun/upgrade-mutable-array/version0.mo
 create mode 100644 test/run-drun/upgrade-mutable-array/version1.mo
 create mode 100644 test/run-drun/upgrade-mutable-service.drun
 create mode 100644 test/run-drun/upgrade-mutable-service/original-service.mo
 create mode 100644 test/run-drun/upgrade-mutable-service/reduced-service.mo
 create mode 100644 test/run-drun/upgrade-mutable-service/version0.mo
 create mode 100644 test/run-drun/upgrade-mutable-service/version1.mo
 create mode 100644 test/run-drun/upgrade-mutable-variant.drun
 create mode 100644 test/run-drun/upgrade-mutable-variant/version0.mo
 create mode 100644 test/run-drun/upgrade-mutable-variant/version1.mo
 create mode 100644 test/run-drun/upgrade-service.drun
 create mode 100644 test/run-drun/upgrade-service/original-service.mo
 create mode 100644 test/run-drun/upgrade-service/reduced-service.mo
 create mode 100644 test/run-drun/upgrade-service/version0.mo
 create mode 100644 test/run-drun/upgrade-service/version1.mo

diff --git a/rts/motoko-rts/src/idl.rs b/rts/motoko-rts/src/idl.rs
index 4dd8fe76c4f..b827b5ef546 100644
--- a/rts/motoko-rts/src/idl.rs
+++ b/rts/motoko-rts/src/idl.rs
@@ -816,7 +816,10 @@ pub(crate) unsafe fn memory_compatible(
                 let t21 = sleb128_decode(&mut tb2);
                 if n1 == 0 {
                     // Optional additional fields are only supported in the main actor type.
-                    if !main_actor || !is_opt_reserved(typtbl2, end2, t21) {
+                    if variance == TypeVariance::Invariance
+                        || !main_actor
+                        || !is_opt_reserved(typtbl2, end2, t21)
+                    {
                         return false;
                     }
                     continue;
@@ -826,14 +829,18 @@ pub(crate) unsafe fn memory_compatible(
                         tag1 = leb128_decode(&mut tb1);
                         t11 = sleb128_decode(&mut tb1);
                         n1 -= 1;
-                        if !(tag1 < tag2 && n1 > 0) {
+                        // Do not skip fields during invariance check.
+                        if variance == TypeVariance::Invariance || !(tag1 < tag2 && n1 > 0) {
                             break;
                         }
                     }
                 };
                 if tag1 > tag2 {
                     // Optional additional fields are only supported in the main actor type.
-                    if !main_actor || !is_opt_reserved(typtbl2, end2, t21) {
+                    if variance == TypeVariance::Invariance
+                        || !main_actor
+                        || !is_opt_reserved(typtbl2, end2, t21)
+                    {
                         return false;
                     }
                     advance = false; // reconsider this field in next round
@@ -862,7 +869,7 @@ pub(crate) unsafe fn memory_compatible(
                     tag2 = leb128_decode(&mut tb2);
                     t21 = sleb128_decode(&mut tb2);
                     n2 -= 1;
-                    if !(tag2 < tag1 && n2 > 0) {
+                    if variance == TypeVariance::Invariance || !(tag2 < tag1 && n2 > 0) {
                         break;
                     }
                 }
@@ -896,7 +903,7 @@ pub(crate) unsafe fn memory_compatible(
                     t11 = sleb128_decode(&mut tb1);
                     n1 -= 1;
                     cmp = utf8_cmp(len1, p1, len2, p2);
-                    if cmp < 0 && n1 > 0 {
+                    if variance != TypeVariance::Invariance && cmp < 0 && n1 > 0 {
                         continue;
                     };
                     break;
diff --git a/test/run-drun/ok/upgrade-mutable-array.drun.ok b/test/run-drun/ok/upgrade-mutable-array.drun.ok
new file mode 100644
index 00000000000..4c7859d1354
--- /dev/null
+++ b/test/run-drun/ok/upgrade-mutable-array.drun.ok
@@ -0,0 +1,17 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+debug.print: firstField=0
+debug.print: secondField=0
+debug.print: thirdField=0
+debug.print: firstField=0
+debug.print: secondField=0
+debug.print: thirdField=0
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+debug.print: firstField=0
+debug.print: secondField=0
+debug.print: thirdField=0
+debug.print: firstField=0
+debug.print: secondField=0
+debug.print: thirdField=0
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/upgrade-mutable-service.drun.ok b/test/run-drun/ok/upgrade-mutable-service.drun.ok
new file mode 100644
index 00000000000..45933d721fe
--- /dev/null
+++ b/test/run-drun/ok/upgrade-mutable-service.drun.ok
@@ -0,0 +1,33 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: original test0
+debug.print: original test1
+debug.print: original test2
+debug.print: original test3
+debug.print: original test0
+debug.print: original test1
+debug.print: original test2
+debug.print: original test3
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: original test0
+debug.print: original test1
+debug.print: original test2
+debug.print: original test3
+debug.print: original test0
+debug.print: original test1
+debug.print: original test2
+debug.print: original test3
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+ingress Completed: Reply: 0x4449444c0000
+debug.print: original test0
+debug.print: original test1
+debug.print: original test2
+debug.print: original test3
+debug.print: original test0
+debug.print: original test1
+debug.print: original test2
+debug.print: original test3
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/upgrade-mutable-variant.drun.ok b/test/run-drun/ok/upgrade-mutable-variant.drun.ok
new file mode 100644
index 00000000000..09d407cb897
--- /dev/null
+++ b/test/run-drun/ok/upgrade-mutable-variant.drun.ok
@@ -0,0 +1,9 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+debug.print: instance=[var #Option1]
+debug.print: alias=[var #Option1]
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+debug.print: instance=[var #Option1]
+debug.print: alias=[var #Option1]
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/upgrade-service.drun.ok b/test/run-drun/ok/upgrade-service.drun.ok
new file mode 100644
index 00000000000..9706bca1b6f
--- /dev/null
+++ b/test/run-drun/ok/upgrade-service.drun.ok
@@ -0,0 +1,20 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: original test1
+debug.print: original test2
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: original test1
+debug.print: original test2
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: reduced test1
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: reduced test1
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+debug.print: reduced test1
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/upgrade-mutable-array.drun b/test/run-drun/upgrade-mutable-array.drun
new file mode 100644
index 00000000000..6249be67613
--- /dev/null
+++ b/test/run-drun/upgrade-mutable-array.drun
@@ -0,0 +1,5 @@
+# SKIP ic-ref-run
+install $ID upgrade-mutable-array/version0.mo ""
+ingress $ID test "DIDL\x00\x00"
+upgrade $ID upgrade-mutable-array/version1.mo ""
+ingress $ID test "DIDL\x00\x00"
diff --git a/test/run-drun/upgrade-mutable-array/version0.mo b/test/run-drun/upgrade-mutable-array/version0.mo
new file mode 100644
index 00000000000..52f1b329629
--- /dev/null
+++ b/test/run-drun/upgrade-mutable-array/version0.mo
@@ -0,0 +1,22 @@
+import Prim "mo:prim";
+
+actor {
+    stable let instance = [
+        var {
+            firstField = 0;
+            secondField = 0;
+            thirdField = 0;
+        }
+    ];
+
+    stable let alias = instance;
+
+    public func test() : async () {
+        Prim.debugPrint("firstField=" # debug_show (instance[0].firstField));
+        Prim.debugPrint("secondField=" # debug_show (instance[0].secondField));
+        Prim.debugPrint("thirdField=" # debug_show (instance[0].thirdField));
+        Prim.debugPrint("firstField=" # debug_show (alias[0].firstField));
+        Prim.debugPrint("secondField=" # debug_show (alias[0].secondField));
+        Prim.debugPrint("thirdField=" # debug_show (alias[0].thirdField));
+    };
+};
diff --git a/test/run-drun/upgrade-mutable-array/version1.mo b/test/run-drun/upgrade-mutable-array/version1.mo
new file mode 100644
index 00000000000..6d134e47568
--- /dev/null
+++ b/test/run-drun/upgrade-mutable-array/version1.mo
@@ -0,0 +1,28 @@
+import Prim "mo:prim";
+
+actor {
+    stable let instance = [
+        var {
+            secondField = 1;
+        }
+    ];
+
+    stable let alias = [
+        var {
+            firstField = 1;
+            secondField = 1;
+            thirdField = 1;
+        }
+    ];
+
+    public func test() : async () {
+        // This would break type safety if memory compatibility check does not prevent upgrade.
+        instance[0] := { secondField = 2 };
+        // alias[0] would no longer have the firstField and thirdField.
+
+        Prim.debugPrint("secondField=" # debug_show (instance[0].secondField));
+        Prim.debugPrint("firstField=" # debug_show (alias[0].firstField));
+        Prim.debugPrint("secondField=" # debug_show (alias[0].secondField));
+        Prim.debugPrint("thirdField=" # debug_show (alias[0].thirdField));
+    };
+};
diff --git a/test/run-drun/upgrade-mutable-service.drun b/test/run-drun/upgrade-mutable-service.drun
new file mode 100644
index 00000000000..21a1a6c172e
--- /dev/null
+++ b/test/run-drun/upgrade-mutable-service.drun
@@ -0,0 +1,9 @@
+# SKIP ic-ref-run
+install $ID upgrade-mutable-service/version0.mo ""
+ingress $ID initialize "DIDL\x00\x00"
+ingress $ID test "DIDL\x00\x00"
+upgrade $ID upgrade-mutable-service/version0.mo ""
+ingress $ID test "DIDL\x00\x00"
+upgrade $ID upgrade-mutable-service/version1.mo ""
+ingress $ID initialize "DIDL\x00\x01\x7d\x0F"
+ingress $ID test "DIDL\x00\x00"
diff --git a/test/run-drun/upgrade-mutable-service/original-service.mo b/test/run-drun/upgrade-mutable-service/original-service.mo
new file mode 100644
index 00000000000..5cfefeb2ef3
--- /dev/null
+++ b/test/run-drun/upgrade-mutable-service/original-service.mo
@@ -0,0 +1,19 @@
+import Prim "mo:prim";
+
+actor class OriginalActor() {
+    public func test0() : async () {
+        Prim.debugPrint("original test0");
+    };
+
+    public func test1() : async () {
+        Prim.debugPrint("original test1");
+    };
+
+    public func test2() : async () {
+        Prim.debugPrint("original test2");
+    };
+    
+    public func test3() : async () {
+        Prim.debugPrint("original test3");
+    };
+};
diff --git a/test/run-drun/upgrade-mutable-service/reduced-service.mo b/test/run-drun/upgrade-mutable-service/reduced-service.mo
new file mode 100644
index 00000000000..b274c09b3ae
--- /dev/null
+++ b/test/run-drun/upgrade-mutable-service/reduced-service.mo
@@ -0,0 +1,11 @@
+import Prim "mo:prim";
+
+actor class ReducedActor() {
+    public func test1() : async () {
+        Prim.debugPrint("reduced test1");
+    };
+
+    public func test3() : async () {
+        Prim.debugPrint("reduced test3");
+    };
+};
diff --git a/test/run-drun/upgrade-mutable-service/version0.mo b/test/run-drun/upgrade-mutable-service/version0.mo
new file mode 100644
index 00000000000..eef8f85d250
--- /dev/null
+++ b/test/run-drun/upgrade-mutable-service/version0.mo
@@ -0,0 +1,42 @@
+import Prim "mo:prim";
+import Cycles = "../cycles/cycles";
+import OriginalService "original-service";
+
+actor this {
+    type OriginalActor = actor {
+        test0() : async ();
+        test1() : async ();
+        test2() : async ();
+        test3() : async ();
+    };
+
+    stable var instance = [var null : ?OriginalActor];
+    stable var alias = instance;
+
+    public func initialize() : async () {
+        await Cycles.provisional_top_up_actor(this, 100_000_000_000_000);
+        Cycles.add<system>(2_000_000_000_000);
+        instance[0] := ?(await OriginalService.OriginalActor());
+    };
+
+    public func test() : async () {
+        switch (instance[0]) {
+            case (?instance) {
+                await instance.test0();
+                await instance.test1();
+                await instance.test2();
+                await instance.test3();
+            };
+            case null Prim.trap("Null");
+        };
+        switch (alias[0]) {
+            case (?alias) {
+                await alias.test0();
+                await alias.test1();
+                await alias.test2();
+                await alias.test3();
+            };
+            case null Prim.trap("Null");
+        };
+    };
+};
diff --git a/test/run-drun/upgrade-mutable-service/version1.mo b/test/run-drun/upgrade-mutable-service/version1.mo
new file mode 100644
index 00000000000..17f3f968008
--- /dev/null
+++ b/test/run-drun/upgrade-mutable-service/version1.mo
@@ -0,0 +1,44 @@
+import Prim "mo:prim";
+import Cycles = "../cycles/cycles";
+import ReducedService "reduced-service";
+
+actor this {
+    type OriginalActor = actor {
+        test0() : async ();
+        test1() : async ();
+        test2() : async ();
+        test3() : async ();
+    };
+
+    type ReducedActor = actor {
+        test1() : async ();
+        test3() : async ();
+    };
+
+    stable var instance = [var null : ?ReducedActor];
+    stable var alias = [var null : ?OriginalActor];
+
+    public func initialize() : async () {
+        Cycles.add<system>(2_000_000_000_000);
+        instance[0] := ?(await ReducedService.ReducedActor());
+    };
+
+    public func test() : async () {
+        switch (instance[0]) {
+            case (?instance) {
+                await instance.test1();
+                await instance.test3();
+            };
+            case null Prim.trap("Null");
+        };
+        switch (alias[0]) {
+            case (?alias) {
+                await alias.test0();
+                await alias.test1();
+                await alias.test2();
+                await alias.test3();
+            };
+            case null Prim.trap("Null");
+        };
+    };
+};
diff --git a/test/run-drun/upgrade-mutable-variant.drun b/test/run-drun/upgrade-mutable-variant.drun
new file mode 100644
index 00000000000..76601ff8da5
--- /dev/null
+++ b/test/run-drun/upgrade-mutable-variant.drun
@@ -0,0 +1,5 @@
+# SKIP ic-ref-run
+install $ID upgrade-mutable-variant/version0.mo ""
+ingress $ID test "DIDL\x00\x00"
+upgrade $ID upgrade-mutable-variant/version1.mo ""
+ingress $ID test "DIDL\x00\x00"
diff --git a/test/run-drun/upgrade-mutable-variant/version0.mo b/test/run-drun/upgrade-mutable-variant/version0.mo
new file mode 100644
index 00000000000..00a90693ae9
--- /dev/null
+++ b/test/run-drun/upgrade-mutable-variant/version0.mo
@@ -0,0 +1,16 @@
+import Prim "mo:prim";
+
+actor {
+    type OriginalVariant = {
+        #Option1;
+        #Option2;
+    };
+
+    stable let instance = [ var #Option1: OriginalVariant ];
+    stable let alias = instance;
+
+    public func test() : async () {
+        Prim.debugPrint("instance=" # debug_show (instance));
+        Prim.debugPrint("alias=" # debug_show (alias));
+    };
+};
diff --git a/test/run-drun/upgrade-mutable-variant/version1.mo b/test/run-drun/upgrade-mutable-variant/version1.mo
new file mode 100644
index 00000000000..241a83ab89b
--- /dev/null
+++ b/test/run-drun/upgrade-mutable-variant/version1.mo
@@ -0,0 +1,26 @@
+import Prim "mo:prim";
+
+actor {
+    type OriginalVariant = {
+        #Option1;
+        #Option2;
+    };
+
+    type ExtendedVariant = {
+        #Option0;
+        #Option1;
+        #Option2;
+    };
+
+    stable let instance = [ var #Option1: OriginalVariant ];
+    stable let alias = [ var #Option1: ExtendedVariant ];
+
+    public func test() : async () {
+        // Would break type safety if not rejected by the memory compatibility check of the upgrade.
+        alias[0] := #Option0;
+        // instance would observe invalid enum value.
+
+        Prim.debugPrint("instance=" # debug_show (instance));
+        Prim.debugPrint("alias=" # debug_show (alias));
+    };
+};
diff --git a/test/run-drun/upgrade-service.drun b/test/run-drun/upgrade-service.drun
new file mode 100644
index 00000000000..5879eacc822
--- /dev/null
+++ b/test/run-drun/upgrade-service.drun
@@ -0,0 +1,14 @@
+# SKIP ic-ref-run
+install $ID upgrade-service/version0.mo ""
+ingress $ID initialize "DIDL\x00\x00"
+ingress $ID test "DIDL\x00\x00"
+upgrade $ID upgrade-service/version0.mo ""
+ingress $ID test "DIDL\x00\x00"
+upgrade $ID upgrade-service/version1.mo ""
+ingress $ID initialize "DIDL\x00\x01\x7d\x0F"
+ingress $ID test "DIDL\x00\x00"
+upgrade $ID upgrade-service/version1.mo ""
+ingress $ID test "DIDL\x00\x00"
+upgrade $ID upgrade-service/version0.mo ""
+ingress $ID test "DIDL\x00\x00"
+
diff --git a/test/run-drun/upgrade-service/original-service.mo b/test/run-drun/upgrade-service/original-service.mo
new file mode 100644
index 00000000000..a1f18a67e07
--- /dev/null
+++ b/test/run-drun/upgrade-service/original-service.mo
@@ -0,0 +1,11 @@
+import Prim "mo:prim";
+
+actor class OriginalActor() {
+    public func test1() : async () {
+        Prim.debugPrint("original test1");
+    };
+
+    public func test2() : async () {
+        Prim.debugPrint("original test2");
+    };
+};
diff --git a/test/run-drun/upgrade-service/reduced-service.mo b/test/run-drun/upgrade-service/reduced-service.mo
new file mode 100644
index 00000000000..400a36c5373
--- /dev/null
+++ b/test/run-drun/upgrade-service/reduced-service.mo
@@ -0,0 +1,7 @@
+import Prim "mo:prim";
+
+actor class ReducedActor() {
+    public func test1() : async () {
+        Prim.debugPrint("reduced test1");
+    };
+};
diff --git a/test/run-drun/upgrade-service/version0.mo b/test/run-drun/upgrade-service/version0.mo
new file mode 100644
index 00000000000..b20a14d49bb
--- /dev/null
+++ b/test/run-drun/upgrade-service/version0.mo
@@ -0,0 +1,28 @@
+import Prim "mo:prim";
+import Cycles = "../cycles/cycles";
+import OriginalService "original-service";
+
+actor this {
+    type OriginalActor = actor {
+        test1() : async ();
+        test2() : async ();
+    };
+
+    stable var instance : ?OriginalActor = null;
+
+    public func initialize() : async () {
+        await Cycles.provisional_top_up_actor(this, 100_000_000_000_000);
+        Cycles.add<system>(2_000_000_000_000);
+        instance := ?(await OriginalService.OriginalActor());
+    };
+
+    public func test() : async () {
+        switch instance {
+            case (?instance) {
+                await instance.test1();
+                await instance.test2();
+            };
+            case null Prim.trap("Null");
+        };
+    };
+};
diff --git a/test/run-drun/upgrade-service/version1.mo b/test/run-drun/upgrade-service/version1.mo
new file mode 100644
index 00000000000..a48bc474128
--- /dev/null
+++ b/test/run-drun/upgrade-service/version1.mo
@@ -0,0 +1,30 @@
+import Prim "mo:prim";
+import Cycles = "../cycles/cycles";
+import ReducedService "reduced-service";
+
+actor this {
+    type OriginalActor = actor {
+        test1() : async ();
+        test2() : async ();
+    };
+
+    type ReducedActor = actor {
+        test1() : async ();
+    };
+
+    stable var instance : ?ReducedActor = null;
+
+    public func initialize() : async () {
+        Cycles.add<system>(2_000_000_000_000);
+        instance := ?(await ReducedService.ReducedActor());
+    };
+
+    public func test() : async () {
+        switch instance {
+            case (?instance) {
+                await instance.test1();
+            };
+            case null Prim.trap("Null");
+        };
+    };
+};

From 66abe498b8b586070b933f0a100efaa6118af487 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 12 Apr 2024 15:30:50 +0200
Subject: [PATCH 197/260] Refine test case

---
 test/run-drun/upgrade-to-any/version1.mo | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/run-drun/upgrade-to-any/version1.mo b/test/run-drun/upgrade-to-any/version1.mo
index 76f8107b1be..bf0f251ca60 100644
--- a/test/run-drun/upgrade-to-any/version1.mo
+++ b/test/run-drun/upgrade-to-any/version1.mo
@@ -11,7 +11,7 @@ actor {
    };
 
    stable var firstVariable : Any = largeAllocation("first variable");
-   stable var secondVariable : Any = largeAllocation("second variable");
+   stable var secondVariable : [var Nat] = largeAllocation("second variable");
    
    public func check(): async() {
       // Extra GC increments.

From 695b3ef4fcbb5b53b20c6546fdf37ffb0135bb44 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 12 Apr 2024 15:35:32 +0200
Subject: [PATCH 198/260] Refine test case

---
 test/run-drun/ok/variant-upgrades.drun.ok  |  1 +
 test/run-drun/variant-upgrades.drun        |  1 +
 test/run-drun/variant-upgrades/version3.mo | 23 ++++++++++++++++++++++
 3 files changed, 25 insertions(+)
 create mode 100644 test/run-drun/variant-upgrades/version3.mo

diff --git a/test/run-drun/ok/variant-upgrades.drun.ok b/test/run-drun/ok/variant-upgrades.drun.ok
index 9372abbd22e..cd317ed4b8d 100644
--- a/test/run-drun/ok/variant-upgrades.drun.ok
+++ b/test/run-drun/ok/variant-upgrades.drun.ok
@@ -16,3 +16,4 @@ ingress Completed: Reply: 0x4449444c0000
 debug.print: #two({key = 1; name = "TEST TEST TEST TEST TEST"})
 ingress Completed: Reply: 0x4449444c0000
 ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
diff --git a/test/run-drun/variant-upgrades.drun b/test/run-drun/variant-upgrades.drun
index 6773ddcb92b..b27a021eb78 100644
--- a/test/run-drun/variant-upgrades.drun
+++ b/test/run-drun/variant-upgrades.drun
@@ -12,3 +12,4 @@ upgrade $ID variant-upgrades/version1.mo ""
 ingress $ID modify "DIDL\x00\x01\x7d\x0F"
 ingress $ID print "DIDL\x00\x00"
 upgrade $ID variant-upgrades/version2.mo ""
+upgrade $ID variant-upgrades/version3.mo ""
diff --git a/test/run-drun/variant-upgrades/version3.mo b/test/run-drun/variant-upgrades/version3.mo
new file mode 100644
index 00000000000..12d06fca486
--- /dev/null
+++ b/test/run-drun/variant-upgrades/version3.mo
@@ -0,0 +1,23 @@
+import Prim "mo:prim";
+
+// Compatible upgrade
+actor {
+  type Variant = {
+    #two : { key : Nat; var name : Text; newField: Int };
+    #one : Nat;
+    #three : Text;
+  };
+
+  stable var root : Variant = #three "ERROR";
+
+  public func modify() : async () {
+    switch root {
+      case (#two record) record.name #= " TEST";
+      case _ assert false;
+    };
+  };
+
+  public func print() : async () {
+    Prim.debugPrint(debug_show (root));
+  };
+};

From 932f6507ecdbc74a72840adcc1f815471dfe7880 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 12 Apr 2024 15:49:58 +0200
Subject: [PATCH 199/260] Adding some explanatory comments to test case

---
 test/run-drun/function-upgrades/version1.mo | 6 ++++++
 test/run-drun/function-upgrades/version2.mo | 3 +++
 test/run-drun/function-upgrades/version3.mo | 3 +++
 test/run-drun/function-upgrades/version4.mo | 3 +++
 4 files changed, 15 insertions(+)

diff --git a/test/run-drun/function-upgrades/version1.mo b/test/run-drun/function-upgrades/version1.mo
index c951177bfbb..bcb49a61460 100644
--- a/test/run-drun/function-upgrades/version1.mo
+++ b/test/run-drun/function-upgrades/version1.mo
@@ -1,12 +1,18 @@
+// Upgrade succeeds.
 actor {
+   // Identical function type.
    public shared query func f0() : async () { loop {} };
    stable let x0 = f0;
 
+   // Identical function type.
    public shared composite query func f1(_ : Nat, _ : Bool) : async (Nat, Bool) {
       loop {};
    };
    stable let x1 = f1;
 
+   // Compatible change:
+   // - Both parameters are changed to sub-types (removing an variant tag, adding an object field).
+   // - Return type is changed to a super-type (removing object field).
    public shared func f2(_ : {#one}, _ : { oldField : Nat; newField: Text }) : async { } {
       loop {};
    };
diff --git a/test/run-drun/function-upgrades/version2.mo b/test/run-drun/function-upgrades/version2.mo
index 2f1da5cc8b7..bf538ad1790 100644
--- a/test/run-drun/function-upgrades/version2.mo
+++ b/test/run-drun/function-upgrades/version2.mo
@@ -1,4 +1,7 @@
+// Upgrade should fail (version 1 to 2).
 actor {
+   // Incompatible function type change:
+   // - First parameter is a super-type of version 1 (adding option tag `#three`).
    public shared func f2(_ : {#one; #three}, _ : { oldField : Nat; newField: Text }) : async { } {
       loop {};
    };
diff --git a/test/run-drun/function-upgrades/version3.mo b/test/run-drun/function-upgrades/version3.mo
index 6fe5a3ac75c..416b29b964f 100644
--- a/test/run-drun/function-upgrades/version3.mo
+++ b/test/run-drun/function-upgrades/version3.mo
@@ -1,4 +1,7 @@
+// Upgrade should fail (version 1 to 3).
 actor {
+   // Incompatible function type change:
+   // - Second parameter is a super-type of version 1 (removing a field).
    public shared func f2(_ : {#one}, _ : { newField: Text }) : async { } {
       loop {};
    };
diff --git a/test/run-drun/function-upgrades/version4.mo b/test/run-drun/function-upgrades/version4.mo
index 0503260205c..6fe806b640b 100644
--- a/test/run-drun/function-upgrades/version4.mo
+++ b/test/run-drun/function-upgrades/version4.mo
@@ -1,4 +1,7 @@
+// Upgrade should fail (version 1 to 4).
 actor {
+   // Incompatible function type change:
+   // - Return type is a sub-type (adding an object field).
    public shared func f2(_ : {#one}, _ : { oldField : Nat; newField: Text }) : async { newField: Bool } {
       loop {};
    };

From 0af485e9a89543baba5d01981e73918c555ceb2b Mon Sep 17 00:00:00 2001
From: Claudio Russo <claudio@dfinity.org>
Date: Fri, 12 Apr 2024 14:50:18 +0100
Subject: [PATCH 200/260] experiment: remove regression in idl_sub  (#4497)

* add measurements from master

* current measurements showing regression

* Update test/bench/candid-subtype-cost.mo

* Update test/bench/candid-subtype-cost.mo

* update test output to reflect use of object pooling; better, but still worse than master

* first draft

* comment out unused

* simplify idl_sub env arguments; refactor; update tests

* increase expected stack size back to original

* fix comment

* simplify

* update bench
---
 rts/motoko-rts/src/idl.rs                     |  26 +++-
 src/codegen/compile.ml                        |  99 +++++++-----
 test/bench/candid-subtype-cost.mo             | 143 ++++++++++++++++++
 test/bench/ok/bignum.drun-run.ok              |   4 +-
 test/bench/ok/candid-subtype-cost.drun-run.ok |   4 +
 test/run-drun/max-stack-variant.mo            |   4 +-
 test/run-drun/max-stack.mo                    |   4 +-
 test/run/idl.mo                               |   2 +-
 8 files changed, 235 insertions(+), 51 deletions(-)
 create mode 100644 test/bench/candid-subtype-cost.mo
 create mode 100644 test/bench/ok/candid-subtype-cost.drun-run.ok

diff --git a/rts/motoko-rts/src/idl.rs b/rts/motoko-rts/src/idl.rs
index b827b5ef546..408776a0868 100644
--- a/rts/motoko-rts/src/idl.rs
+++ b/rts/motoko-rts/src/idl.rs
@@ -1215,24 +1215,34 @@ unsafe extern "C" fn idl_sub_buf_init(rel_buf: *mut u32, typtbl_size1: u32, typt
 }
 
 #[ic_mem_fn]
-unsafe fn idl_sub<M: Memory>(
+unsafe fn idl_alloc_typtbl<M: Memory>(
     mem: &mut M,
+    candid_data: Value,
+    type_offsets: Value,
+    typtbl_out: *mut *mut *mut u8,
+    typtbl_end_out: *mut *mut u8,
+    typtbl_size_out: *mut u32,
+) {
+    let mut type_descriptor = TypeDescriptor::new(candid_data, type_offsets);
+    *typtbl_out = type_descriptor.build_type_table(mem);
+    *typtbl_end_out = type_descriptor.type_table_end();
+    *typtbl_size_out = type_descriptor.type_count() as u32;
+}
+
+#[no_mangle]
+unsafe extern "C" fn idl_sub(
     rel_buf: *mut u32, // a buffer with at least 2 * typtbl_size1 * typtbl_size2 bits
     typtbl1: *mut *mut u8,
+    typtbl2: *mut *mut u8,
     typtbl_end1: *mut u8,
+    typtbl_end2: *mut u8,
     typtbl_size1: u32,
-    candid_data2: Value,
-    type_offsets2: Value,
+    typtbl_size2: u32,
     t1: i32,
     t2: i32,
 ) -> bool {
     debug_assert!(rel_buf != (0 as *mut u32));
 
-    let mut type_descriptor2 = TypeDescriptor::new(candid_data2, type_offsets2);
-    let typtbl2 = type_descriptor2.build_type_table(mem);
-    let typtbl_end2 = type_descriptor2.type_table_end();
-    let typtbl_size2 = type_descriptor2.type_count() as u32;
-
     let rel = BitRel {
         ptr: rel_buf,
         end: rel_buf.add(idl_sub_buf_words(typtbl_size1, typtbl_size2) as usize),
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 991dcb37e31..c2e2d540349 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -1061,7 +1061,7 @@ module Func = struct
       g3
       g4
     )
-  let [@warning "-8"] share_code6 sharing env name (p1, p2, p3, p4, p5, p6) retty mk_body =
+  let [@warning "-8"] _share_code6 sharing env name (p1, p2, p3, p4, p5, p6) retty mk_body =
     share_code sharing env name [p1; p2; p3; p4; p5; p6] retty (fun env [g1; g2; g3; g4; g5; g6] -> mk_body env
       g1
       g2
@@ -1120,10 +1120,11 @@ module RTS = struct
     E.add_func_import env "rts" "memcmp" [I32Type; I32Type; I32Type] [I32Type];
     E.add_func_import env "rts" "version" [] [I32Type];
     E.add_func_import env "rts" "parse_idl_header" [I32Type; I32Type; I32Type; I32Type; I32Type] [];
+    E.add_func_import env "rts" "idl_alloc_typtbl" [I32Type; I32Type; I32Type; I32Type; I32Type] [];
     E.add_func_import env "rts" "idl_sub_buf_words" [I32Type; I32Type] [I32Type];
     E.add_func_import env "rts" "idl_sub_buf_init" [I32Type; I32Type; I32Type] [];
     E.add_func_import env "rts" "idl_sub"
-      [I32Type; I32Type; I32Type; I32Type; I32Type; I32Type; I32Type; I32Type] [I32Type];
+      [I32Type; I32Type; I32Type; I32Type; I32Type; I32Type; I32Type; I32Type; I32Type] [I32Type];
     E.add_func_import env "rts" "leb128_decode" [I32Type] [I32Type];
     E.add_func_import env "rts" "sleb128_decode" [I32Type] [I32Type];
     E.add_func_import env "rts" "bigint_of_word32" [I32Type] [I32Type];
@@ -6257,10 +6258,6 @@ module Serialization = struct
       Blob.load_data_segment env E.(descriptor.type_offsets_segment) (get_type_offsets_length env)
     )
 
-  let count_global_type_offsets env =
-    get_type_offsets_length env ^^
-    compile_divU_const candid_type_offset_size
-
   let get_global_idl_types env =
     Tagged.share env (fun env -> 
       let descriptor = get_global_type_descriptor env in
@@ -6274,7 +6271,11 @@ module Serialization = struct
       E.add_global32 env "@@ref_buf" Mutable 0l;
       E.add_global32 env "@@typtbl" Mutable 0l;
       E.add_global32 env "@@typtbl_end" Mutable 0l;
-      E.add_global32 env "@@typtbl_size" Mutable 0l
+      E.add_global32 env "@@typtbl_size" Mutable 0l;
+      E.add_global32 env "@@global_typtbl" Mutable 0l;
+      E.add_global32 env "@@global_typtbl_end" Mutable 0l;
+      E.add_global32 env "@@global_typtbl_size" Mutable 0l
+
 
     let get_rel_buf_opt env =
       G.i (GlobalGet (nr (E.get_global env "@@rel_buf_opt")))
@@ -6305,6 +6306,22 @@ module Serialization = struct
       G.i (GlobalGet (nr (E.get_global env "@@typtbl_size")))
     let set_typtbl_size env =
       G.i (GlobalSet (nr (E.get_global env "@@typtbl_size")))
+
+    let get_global_typtbl env =
+      G.i (GlobalGet (nr (E.get_global env "@@global_typtbl")))
+    let set_global_typtbl env =
+      G.i (GlobalSet (nr (E.get_global env "@@global_typtbl")))
+
+    let get_global_typtbl_end env =
+      G.i (GlobalGet (nr (E.get_global env "@@global_typtbl_end")))
+    let set_global_typtbl_end env =
+      G.i (GlobalSet (nr (E.get_global env "@@global_typtbl_end")))
+
+    let get_global_typtbl_size env =
+      G.i (GlobalGet (nr (E.get_global env "@@global_typtbl_size")))
+    let set_global_typtbl_size env =
+      G.i (GlobalSet (nr (E.get_global env "@@global_typtbl_size")))
+
   end
 
   open Typ_hash
@@ -6900,14 +6917,14 @@ module Serialization = struct
   let coercion_error_value env = 0xffff_fffdl
 
   (* See Note [Candid subtype checks] *)
-  let with_rel_buf_opt env extended get_typtbl_size1 f =
+  let with_rel_buf_opt env extended get_typtbl_size1 get_typtbl_size2 f =
     if extended then
       f (compile_unboxed_const 0l)
     else
-      get_typtbl_size1 ^^ count_global_type_offsets env ^^
+      get_typtbl_size1 ^^ get_typtbl_size2 ^^
       E.call_import env "rts" "idl_sub_buf_words" ^^
       Stack.dynamic_with_words env "rel_buf" (fun get_ptr ->
-        get_ptr ^^ get_typtbl_size1 ^^ count_global_type_offsets env ^^
+        get_ptr ^^ get_typtbl_size1 ^^ get_typtbl_size2 ^^
         E.call_import env "rts" "idl_sub_buf_init" ^^
         f get_ptr)
 
@@ -6917,24 +6934,21 @@ module Serialization = struct
     get_global_idl_types env ^^
     Blob.payload_ptr_unskewed env ^^
     G.i (Load {ty = I32Type; align = 0; offset = Int32.mul idx candid_type_offset_size (*!*); sz = None}) ^^
-    Func.share_code6 Func.Always env ("idl_sub")
-      (("rel_buf", I32Type),
-       ("typtbl1", I32Type),
-       ("typtbl_end1", I32Type),
-       ("typtbl_size1", I32Type),
-       ("idltyp1", I32Type),
+    Func.share_code2 Func.Always env ("idl_sub")
+      (("idltyp1", I32Type),
        ("idltyp2", I32Type)
       )
       [I32Type]
-      (fun env get_rel_buf get_typtbl1 get_typtbl_end1 get_typtbl_size1 get_idltyp1 get_idltyp2 ->
-        get_rel_buf ^^
+      (fun env get_idltyp1 get_idltyp2 ->
+        Registers.get_rel_buf_opt env ^^
         E.else_trap_with env "null rel_buf" ^^
-        get_rel_buf ^^
-        get_typtbl1 ^^
-        get_typtbl_end1 ^^
-        get_typtbl_size1 ^^
-        get_global_candid_data env ^^
-        get_global_type_offsets env ^^
+        Registers.get_rel_buf_opt env ^^
+        Registers.get_typtbl env ^^
+        Registers.get_global_typtbl env ^^
+        Registers.get_typtbl_end env ^^
+        Registers.get_global_typtbl_end env ^^
+        Registers.get_typtbl_size env ^^
+        Registers.get_global_typtbl_size env ^^
         get_idltyp1 ^^
         get_idltyp2 ^^
         E.call_import env "rts" "idl_sub")
@@ -6985,7 +6999,7 @@ module Serialization = struct
       let get_data_buf = Registers.get_data_buf env in
       let _get_ref_buf = Registers.get_ref_buf env in
       let get_typtbl = Registers.get_typtbl env in
-      let get_typtbl_end = Registers.get_typtbl_end env in
+      let _get_typtbl_end = Registers.get_typtbl_end env in
       let get_typtbl_size = Registers.get_typtbl_size env in
 
       (* Check recursion depth (protects against empty record etc.) *)
@@ -7595,10 +7609,6 @@ module Serialization = struct
         get_rel_buf_opt ^^
         G.if1 I32Type
           begin
-            get_rel_buf_opt ^^
-            get_typtbl ^^
-            get_typtbl_end ^^
-            get_typtbl_size ^^
             get_idltyp ^^
             idl_sub env t
           end
@@ -7618,10 +7628,6 @@ module Serialization = struct
         get_rel_buf_opt ^^
         G.if1 I32Type
           begin
-            get_rel_buf_opt ^^
-            get_typtbl ^^
-            get_typtbl_end ^^
-            get_typtbl_size ^^
             get_idltyp ^^
             idl_sub env t
           end
@@ -7728,6 +7734,11 @@ module Serialization = struct
       Stack.with_words env "get_typtbl_ptr" 1l (fun get_typtbl_ptr ->
       Stack.with_words env "get_maintyps_ptr" 1l (fun get_maintyps_ptr ->
 
+      (* Allocate space for out parameters of idl_alloc_typtbl *)
+      Stack.with_words env "get_global_typtbl_ptr" 1l (fun get_global_typtbl_ptr ->
+      Stack.with_words env "get_global_typtbl_end_ptr" 1l (fun get_global_typtbl_end_ptr ->
+      Stack.with_words env "get_global_typtbl_size_ptr" 1l (fun get_global_typtbl_size_ptr ->
+
       (* Set up read buffers *)
       ReadBuf.alloc env (fun get_data_buf -> ReadBuf.alloc env (fun get_ref_buf ->
 
@@ -7740,8 +7751,21 @@ module Serialization = struct
       Bool.lit extended ^^ get_data_buf ^^ get_typtbl_ptr ^^ get_typtbl_size_ptr ^^ get_maintyps_ptr ^^
       E.call_import env "rts" "parse_idl_header" ^^
 
+      (* Allocate global type type, if necessary for subtype checks *)
+      (if extended then
+         G.nop
+       else begin
+         get_global_candid_data env ^^
+         get_global_type_offsets env ^^
+         get_global_typtbl_ptr ^^ get_global_typtbl_end_ptr ^^ get_global_typtbl_size_ptr ^^
+         E.call_import env "rts" "idl_alloc_typtbl"
+      end) ^^
+
       (* Allocate memo table, if necessary *)
-      with_rel_buf_opt env extended (get_typtbl_size_ptr ^^ load_unskewed_ptr) (fun get_rel_buf_opt ->
+      with_rel_buf_opt env extended
+        (get_typtbl_size_ptr ^^ load_unskewed_ptr)
+        (get_global_typtbl_size_ptr ^^ load_unskewed_ptr)
+        (fun get_rel_buf_opt ->
 
       (* set up a dedicated read buffer for the list of main types *)
       ReadBuf.alloc env (fun get_main_typs_buf ->
@@ -7773,7 +7797,10 @@ module Serialization = struct
                 get_ref_buf ^^ Registers.set_ref_buf env ^^
                 get_typtbl_ptr ^^ load_unskewed_ptr ^^ Registers.set_typtbl env ^^
                 get_maintyps_ptr ^^ load_unskewed_ptr ^^ Registers.set_typtbl_end env ^^
-                get_typtbl_size_ptr ^^ load_unskewed_ptr ^^ Registers.set_typtbl_size env
+                get_typtbl_size_ptr ^^ load_unskewed_ptr ^^ Registers.set_typtbl_size env ^^
+                get_global_typtbl_ptr ^^ load_unskewed_ptr ^^ Registers.set_global_typtbl env ^^
+                get_global_typtbl_end_ptr ^^ load_unskewed_ptr ^^ Registers.set_global_typtbl_end env ^^
+                get_global_typtbl_size_ptr ^^ load_unskewed_ptr ^^ Registers.set_global_typtbl_size env
               end ^^
               (* set up variable frame arguments *)
               Stack.with_frame env "frame_ptr" 3l (fun () ->
@@ -7813,7 +7840,7 @@ module Serialization = struct
         E.else_trap_with env ("IDL error: left-over bytes " ^ ts_name) ^^
         ReadBuf.is_empty env get_ref_buf ^^
         E.else_trap_with env ("IDL error: left-over references " ^ ts_name)
-      ))))))
+      )))))))))
 
     ))
 
diff --git a/test/bench/candid-subtype-cost.mo b/test/bench/candid-subtype-cost.mo
new file mode 100644
index 00000000000..1ffe2ef5ea1
--- /dev/null
+++ b/test/bench/candid-subtype-cost.mo
@@ -0,0 +1,143 @@
+// measure cost of repeated candid subtype checks
+import { Array_tabulate; performanceCounter; debugPrint; rts_heap_size } = "mo:⛔";
+
+actor {
+
+  func counters() : (Int, Nat64) = (rts_heap_size(), performanceCounter(0));
+
+  public func go() : async () {
+    let a0 : [Self] = Array_tabulate<Self>(1024, func _ { actor "aaaaa-aa" : Self } );
+    let b = to_candid (a0);
+    let (m0, n0) = counters();
+    let o : ?[Self] = from_candid b;
+    let (m1, n1) = counters();
+    assert (?a0 == o);
+    debugPrint(debug_show {heap_bytes = m1 - m0; cycles = n1 - n0});
+  };
+
+  // stolen from https://github.com/krpeacock/ic-management-canister
+
+  public type bitcoin_address = Text;
+  public type bitcoin_network = { #mainnet; #testnet };
+  public type block_hash = [Nat8];
+  public type canister_id = Principal;
+  public type canister_settings = {
+    freezing_threshold : ?Nat;
+    controllers : ?[Principal];
+    memory_allocation : ?Nat;
+    compute_allocation : ?Nat;
+  };
+  public type definite_canister_settings = {
+    freezing_threshold : Nat;
+    controllers : [Principal];
+    memory_allocation : Nat;
+    compute_allocation : Nat;
+  };
+  public type ecdsa_curve = { #secp256k1 };
+  public type get_balance_request = {
+    network : bitcoin_network;
+    address : bitcoin_address;
+    min_confirmations : ?Nat32;
+  };
+  public type get_current_fee_percentiles_request = {
+    network : bitcoin_network;
+  };
+  public type get_utxos_request = {
+    network : bitcoin_network;
+    filter : ?{ #page : [Nat8]; #min_confirmations : Nat32 };
+    address : bitcoin_address;
+  };
+  public type get_utxos_response = {
+    next_page : ?[Nat8];
+    tip_height : Nat32;
+    tip_block_hash : block_hash;
+    utxos : [utxo];
+  };
+  public type http_header = { value : Text; name : Text };
+  public type http_response = {
+    status : Nat;
+    body : [Nat8];
+    headers : [http_header];
+  };
+  public type millisatoshi_per_byte = Nat64;
+  public type outpoint = { txid : [Nat8]; vout : Nat32 };
+  public type satoshi = Nat64;
+  public type send_transaction_request = {
+    transaction : [Nat8];
+    network : bitcoin_network;
+  };
+  public type user_id = Principal;
+  public type utxo = { height : Nat32; value : satoshi; outpoint : outpoint };
+  public type wasm_module = [Nat8];
+  public type Self = actor {
+    bitcoin_get_balance : shared get_balance_request -> async satoshi;
+    bitcoin_get_current_fee_percentiles : shared get_current_fee_percentiles_request -> async [
+        millisatoshi_per_byte
+      ];
+    bitcoin_get_utxos : shared get_utxos_request -> async get_utxos_response;
+    bitcoin_send_transaction : shared send_transaction_request -> async ();
+    canister_status : shared { canister_id : canister_id } -> async {
+        status : { #stopped; #stopping; #running };
+        memory_size : Nat;
+        cycles : Nat;
+        settings : definite_canister_settings;
+        idle_cycles_burned_per_day : Nat;
+        module_hash : ?[Nat8];
+      };
+    create_canister : shared { settings : ?canister_settings } -> async {
+        canister_id : canister_id;
+      };
+    delete_canister : shared { canister_id : canister_id } -> async ();
+    deposit_cycles : shared { canister_id : canister_id } -> async ();
+    ecdsa_public_key : shared {
+        key_id : { name : Text; curve : ecdsa_curve };
+        canister_id : ?canister_id;
+        derivation_path : [[Nat8]];
+      } -> async { public_key : [Nat8]; chain_code : [Nat8] };
+    http_request : shared {
+        url : Text;
+        method : { #get; #head; #post };
+        max_response_bytes : ?Nat64;
+        body : ?[Nat8];
+        transform : ?{
+          function : shared query {
+              context : [Nat8];
+              response : http_response;
+            } -> async http_response;
+          context : [Nat8];
+        };
+        headers : [http_header];
+      } -> async http_response;
+    install_code : shared {
+        arg : [Nat8];
+        wasm_module : wasm_module;
+        mode : { #reinstall; #upgrade; #install };
+        canister_id : canister_id;
+      } -> async ();
+    provisional_create_canister_with_cycles : shared {
+        settings : ?canister_settings;
+        specified_id : ?canister_id;
+        amount : ?Nat;
+      } -> async { canister_id : canister_id };
+    provisional_top_up_canister : shared {
+        canister_id : canister_id;
+        amount : Nat;
+      } -> async ();
+    raw_rand : shared () -> async [Nat8];
+    sign_with_ecdsa : shared {
+        key_id : { name : Text; curve : ecdsa_curve };
+        derivation_path : [[Nat8]];
+        message_hash : [Nat8];
+      } -> async { signature : [Nat8] };
+    start_canister : shared { canister_id : canister_id } -> async ();
+    stop_canister : shared { canister_id : canister_id } -> async ();
+    uninstall_code : shared { canister_id : canister_id } -> async ();
+    update_settings : shared {
+        canister_id : Principal;
+        settings : canister_settings;
+      } -> async ();
+  }
+
+}
+
+//CALL ingress go 0x4449444C0000
diff --git a/test/bench/ok/bignum.drun-run.ok b/test/bench/ok/bignum.drun-run.ok
index a01bcb6c4ed..da0ee2e44a1 100644
--- a/test/bench/ok/bignum.drun-run.ok
+++ b/test/bench/ok/bignum.drun-run.ok
@@ -1,6 +1,6 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 2_627_084; size = +60_128}
+debug.print: {cycles = 2_626_994; size = +60_128}
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 107_960_332; size = +1_826_940}
+debug.print: {cycles = 107_960_717; size = +1_826_952}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/candid-subtype-cost.drun-run.ok b/test/bench/ok/candid-subtype-cost.drun-run.ok
new file mode 100644
index 00000000000..13d6560db04
--- /dev/null
+++ b/test/bench/ok/candid-subtype-cost.drun-run.ok
@@ -0,0 +1,4 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {cycles = 998_213; heap_bytes = +16_936}
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/max-stack-variant.mo b/test/run-drun/max-stack-variant.mo
index d790de7a793..d1806399d02 100644
--- a/test/run-drun/max-stack-variant.mo
+++ b/test/run-drun/max-stack-variant.mo
@@ -37,9 +37,9 @@ actor {
             done := true
           }
         };
-        
+
         assert(i > expectedMinimumSize);
-        
+
         let b = to_candid(l);
         debugPrint("serialized");
 
diff --git a/test/run-drun/max-stack.mo b/test/run-drun/max-stack.mo
index 0edbfc6b5bb..55d49b83431 100644
--- a/test/run-drun/max-stack.mo
+++ b/test/run-drun/max-stack.mo
@@ -27,7 +27,7 @@ actor {
                if deserialize
                  from_candid(b)
                else null;
-              
+
               ()
             };
           } catch e {
@@ -37,7 +37,7 @@ actor {
         };
 
         assert i > expectedMinimumSize;
-        
+
         let b = to_candid(l);
         debugPrint("serialized");
 
diff --git a/test/run/idl.mo b/test/run/idl.mo
index 5343e1364a6..83ad7aae6ab 100644
--- a/test/run/idl.mo
+++ b/test/run/idl.mo
@@ -45,7 +45,7 @@ assert(arrayNat == deserArrayInt (serArrayNat arrayNat));
 assert(arrayNat == deserArrayInt (serArrayInt arrayNat));
 assert(arrayInt == deserArrayInt (serArrayInt arrayInt));
 let heapDifference = Prim.rts_heap_size() : Int - started_with;
-assert(heapDifference == 5_340);  
+assert(heapDifference == 5_388);
 
 //SKIP run
 //SKIP run-ir

From 0efcfd56013f25fe5c4ac3b8b041e220581e7599 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 3 May 2024 10:40:39 +0200
Subject: [PATCH 201/260] Simplify memory compatibility check

Additional main actor fields are unconditionally allowed (and implicitly optional)
---
 rts/motoko-rts/src/idl.rs | 14 ++++----------
 1 file changed, 4 insertions(+), 10 deletions(-)

diff --git a/rts/motoko-rts/src/idl.rs b/rts/motoko-rts/src/idl.rs
index 408776a0868..c13ae9fd200 100644
--- a/rts/motoko-rts/src/idl.rs
+++ b/rts/motoko-rts/src/idl.rs
@@ -815,11 +815,8 @@ pub(crate) unsafe fn memory_compatible(
                 let tag2 = leb128_decode(&mut tb2);
                 let t21 = sleb128_decode(&mut tb2);
                 if n1 == 0 {
-                    // Optional additional fields are only supported in the main actor type.
-                    if variance == TypeVariance::Invariance
-                        || !main_actor
-                        || !is_opt_reserved(typtbl2, end2, t21)
-                    {
+                    // Additional fields are only supported in the main actor type.
+                    if variance == TypeVariance::Invariance || !main_actor {
                         return false;
                     }
                     continue;
@@ -836,11 +833,8 @@ pub(crate) unsafe fn memory_compatible(
                     }
                 };
                 if tag1 > tag2 {
-                    // Optional additional fields are only supported in the main actor type.
-                    if variance == TypeVariance::Invariance
-                        || !main_actor
-                        || !is_opt_reserved(typtbl2, end2, t21)
-                    {
+                    // Additional fields are only supported in the main actor type.
+                    if variance == TypeVariance::Invariance || !main_actor {
                         return false;
                     }
                     advance = false; // reconsider this field in next round

From beb54abae80d0c867ee123c268d6f6fc4f24547b Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 3 May 2024 10:58:03 +0200
Subject: [PATCH 202/260] Refine documentation for actor field mutability
 variance

---
 design/OrthogonalPersistence.md | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/design/OrthogonalPersistence.md b/design/OrthogonalPersistence.md
index e66fa94cfcf..3551af8469c 100644
--- a/design/OrthogonalPersistence.md
+++ b/design/OrthogonalPersistence.md
@@ -53,9 +53,14 @@ Compatible changes for immutable types are equivalent to the allowed Motoko subt
 
 The existing IDL-subtype functionality is reused with some adjustments to check memory compatibility: The compiler generates the type descriptor, a type table, that is recorded in the persistent metadata. Upon an upgrade, the new type descriptor is compared against the existing type descriptor, and the upgrade only succeeds for compatible changes.
 
-This compatibility check serves as an additional safety measure on top of the DFX Candid subtype check that can be bypassed by users (when ignoring a warning). Moreoever, the memory compatibility rules is in some aspects different to the Candid sub-type check:
-* Types cannot be made optional.
-* Mutable types (aliases) are supported with type invariance.
+This compatibility check serves as an additional safety measure on top of the DFX Candid subtype check that can be bypassed by users (when ignoring a warning). Moreover, in some aspects, the memory compatibility rules differ to the Candid sub-type check:
+* Top-level actor fields (`stable` fields) can change mutability (`let` to `var` and vice-versa).
+* Support of variable (MutBox) with type invariance.
+* Types cannot be made optional (no insertion of Option).
+* Same arity for function parameters and function return types (no removed optional parameters, no additional optional results).
+* Records cannot introduce additional optional fields.
+* Same arity for tuple types (no insertion of optional items).
+* Records and tuples are distinct.
 
 ### Garbage Collection
 The implementation focuses on the incremental GC and abandons the other GCs because the GCs use different memory layouts. For example, the incremental GC uses a partitioned heap with objects carrying a forwarding pointer.

From 2ed5e036e7004597c0f21149556e169dea4fa829 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 3 May 2024 11:24:11 +0200
Subject: [PATCH 203/260] Add safety guard for temporary pointers during IDL
 deserialization

---
 rts/motoko-rts/src/idl.rs |  4 ++++
 src/codegen/compile.ml    | 17 +++++++++++++++--
 2 files changed, 19 insertions(+), 2 deletions(-)

diff --git a/rts/motoko-rts/src/idl.rs b/rts/motoko-rts/src/idl.rs
index c13ae9fd200..6065ac5a436 100644
--- a/rts/motoko-rts/src/idl.rs
+++ b/rts/motoko-rts/src/idl.rs
@@ -1236,6 +1236,10 @@ unsafe extern "C" fn idl_sub(
     t2: i32,
 ) -> bool {
     debug_assert!(rel_buf != (0 as *mut u32));
+    debug_assert!(typtbl1 != (0 as *mut *mut u8));
+    debug_assert!(typtbl2 != (0 as *mut *mut u8));
+    debug_assert!(typtbl_end1 != (0 as *mut u8));
+    debug_assert!(typtbl_end2 != (0 as *mut u8));
 
     let rel = BitRel {
         ptr: rel_buf,
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index c2e2d540349..68b0e47a77a 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -6276,7 +6276,6 @@ module Serialization = struct
       E.add_global32 env "@@global_typtbl_end" Mutable 0l;
       E.add_global32 env "@@global_typtbl_size" Mutable 0l
 
-
     let get_rel_buf_opt env =
       G.i (GlobalGet (nr (E.get_global env "@@rel_buf_opt")))
     let set_rel_buf_opt env =
@@ -6322,6 +6321,17 @@ module Serialization = struct
     let set_global_typtbl_size env =
       G.i (GlobalSet (nr (E.get_global env "@@global_typtbl_size")))
 
+    (* Used as safety guard that no temporary pointers remain in the registers across GC increments. *)
+    let clear_registers env =
+      compile_unboxed_const 0l ^^ set_rel_buf_opt env ^^
+      compile_unboxed_const 0l ^^ set_data_buf env ^^
+      compile_unboxed_const 0l ^^ set_ref_buf env ^^
+      compile_unboxed_const 0l ^^ set_typtbl env ^^
+      compile_unboxed_const 0l ^^ set_typtbl_end env ^^
+      compile_unboxed_const 0l ^^ set_typtbl_size env ^^ (* also reset for symmetry, even if no pointer *)
+      compile_unboxed_const 0l ^^ set_global_typtbl env ^^
+      compile_unboxed_const 0l ^^ set_global_typtbl_end env ^^
+      compile_unboxed_const 0l ^^ set_global_typtbl_size env (* also reset for symmetry, even if no pointer *)
   end
 
   open Typ_hash
@@ -7839,7 +7849,10 @@ module Serialization = struct
         ReadBuf.is_empty env get_data_buf ^^
         E.else_trap_with env ("IDL error: left-over bytes " ^ ts_name) ^^
         ReadBuf.is_empty env get_ref_buf ^^
-        E.else_trap_with env ("IDL error: left-over references " ^ ts_name)
+        E.else_trap_with env ("IDL error: left-over references " ^ ts_name) ^^
+
+        (* Safety guard: The temporary pointers in the registers must no longer be used when a GC increment runs. *)
+        Registers.clear_registers env
       )))))))))
 
     ))

From cbc4908ae719fa6608d9660463e6ae4615111c95 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 3 May 2024 11:26:43 +0200
Subject: [PATCH 204/260] Update benchmark results

---
 test/bench/ok/bignum.drun-run.ok              | 2 +-
 test/bench/ok/candid-subtype-cost.drun-run.ok | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/bench/ok/bignum.drun-run.ok b/test/bench/ok/bignum.drun-run.ok
index da0ee2e44a1..1866c3af1b3 100644
--- a/test/bench/ok/bignum.drun-run.ok
+++ b/test/bench/ok/bignum.drun-run.ok
@@ -2,5 +2,5 @@ ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a000000000000000001
 ingress Completed: Reply: 0x4449444c0000
 debug.print: {cycles = 2_626_994; size = +60_128}
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 107_960_717; size = +1_826_952}
+debug.print: {cycles = 107_960_744; size = +1_826_952}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/candid-subtype-cost.drun-run.ok b/test/bench/ok/candid-subtype-cost.drun-run.ok
index 13d6560db04..1f9ce73bf68 100644
--- a/test/bench/ok/candid-subtype-cost.drun-run.ok
+++ b/test/bench/ok/candid-subtype-cost.drun-run.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 998_213; heap_bytes = +16_936}
+debug.print: {cycles = 998_240; heap_bytes = +16_936}
 ingress Completed: Reply: 0x4449444c0000

From 6d7fe43436cec43efbc2c6d28bf9dedc14406f66 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Tue, 14 May 2024 14:31:26 +0200
Subject: [PATCH 205/260] Detect persistence mode

E.g. when wrong upgrade option `wasm_memory_persistence: ?Keep` is specified when upgrading from classical persistence to enhanced orthogonal persistence.
---
 rts/motoko-rts/src/persistence.rs | 18 +++++++++++++++++-
 rts/motoko-rts/src/region.rs      |  7 +++++--
 rts/motoko-rts/src/stable_mem.rs  | 26 +++++++++++++++++++++++++-
 src/codegen/compile.ml            | 14 ++++++++++++++
 4 files changed, 61 insertions(+), 4 deletions(-)

diff --git a/rts/motoko-rts/src/persistence.rs b/rts/motoko-rts/src/persistence.rs
index b1fb0e7a5e4..c77a357946b 100644
--- a/rts/motoko-rts/src/persistence.rs
+++ b/rts/motoko-rts/src/persistence.rs
@@ -12,7 +12,12 @@ use crate::{
     gc::incremental::State,
     memory::Memory,
     persistence::compatibility::memory_compatible,
+    region::{
+        LEGACY_VERSION_NO_STABLE_MEMORY, LEGACY_VERSION_REGIONS, LEGACY_VERSION_SOME_STABLE_MEMORY,
+        VERSION_STABLE_HEAP_NO_REGIONS, VERSION_STABLE_HEAP_REGIONS,
+    },
     rts_trap_with,
+    stable_mem::read_persistence_version,
     types::{Value, TAG_BLOB},
 };
 
@@ -108,13 +113,24 @@ impl PersistentMetadata {
 pub unsafe fn initialize_memory<M: Memory>(mem: &mut M) {
     mem.grow_memory(HEAP_START as u64);
     let metadata = PersistentMetadata::get();
-    if metadata.is_initialized() {
+    if use_enhanced_orthogonal_persistence() && metadata.is_initialized() {
         metadata.check_version();
     } else {
         metadata.initialize(mem);
     }
 }
 
+#[cfg(feature = "ic")]
+unsafe fn use_enhanced_orthogonal_persistence() -> bool {
+    match read_persistence_version() {
+        VERSION_STABLE_HEAP_NO_REGIONS | VERSION_STABLE_HEAP_REGIONS => true,
+        LEGACY_VERSION_NO_STABLE_MEMORY
+        | LEGACY_VERSION_SOME_STABLE_MEMORY
+        | LEGACY_VERSION_REGIONS => false,
+        _ => rts_trap_with("Unsupported persistence version"),
+    }
+}
+
 /// Returns the stable sub-record of the actor of the upgraded canister version.
 /// Returns scalar 0 if no actor is stored after on a fresh memory.
 #[no_mangle]
diff --git a/rts/motoko-rts/src/region.rs b/rts/motoko-rts/src/region.rs
index 1f7db49a0ad..df77dee6fc7 100644
--- a/rts/motoko-rts/src/region.rs
+++ b/rts/motoko-rts/src/region.rs
@@ -6,8 +6,11 @@ use crate::types::{size_of, Blob, Bytes, Region, Value, TAG_REGION};
 // Versions
 // Should agree with constants in StableMem in compile.ml
 // Version 0 to 2 are legacy.
-const VERSION_STABLE_HEAP_NO_REGIONS: u32 = 3;
-const VERSION_STABLE_HEAP_REGIONS: u32 = 4;
+pub const LEGACY_VERSION_NO_STABLE_MEMORY: u32 = 0; // Never manifests in serialized form
+pub const LEGACY_VERSION_SOME_STABLE_MEMORY: u32 = 1;
+pub const LEGACY_VERSION_REGIONS: u32 = 2;
+pub const VERSION_STABLE_HEAP_NO_REGIONS: u32 = 3;
+pub const VERSION_STABLE_HEAP_REGIONS: u32 = 4;
 
 const _: () = assert!(meta_data::size::PAGES_IN_BLOCK <= u8::MAX as u32);
 const _: () = assert!(meta_data::max::BLOCKS <= u16::MAX);
diff --git a/rts/motoko-rts/src/stable_mem.rs b/rts/motoko-rts/src/stable_mem.rs
index 9d447d7d4de..29dc5d04c3d 100644
--- a/rts/motoko-rts/src/stable_mem.rs
+++ b/rts/motoko-rts/src/stable_mem.rs
@@ -1,8 +1,12 @@
+pub const PAGE_SIZE: u64 = 64 * 1024;
+
 extern "C" {
     // physical ic0_stable64 operations re-exported by moc
     pub fn ic0_stable64_write(offset: u64, src: u64, size: u64);
     pub fn ic0_stable64_read(dst: u64, offset: u64, size: u64);
-    // (virtual) stable_mem operations implemented by moc
+    #[cfg(feature = "ic")]
+    pub fn ic0_stable64_size() -> u64; // physical memory size
+                                       // (virtual) stable_mem operations implemented by moc
     pub fn moc_stable_mem_get_version() -> u32;
     pub fn moc_stable_mem_set_version(version: u32);
     pub fn moc_stable_mem_size() -> u64;
@@ -84,3 +88,23 @@ pub fn read_u64(offset: u64) -> u64 {
 pub fn write_u64(offset: u64, n: u64) {
     write(offset, &core::primitive::u64::to_le_bytes(n));
 }
+
+#[cfg(feature = "ic")]
+#[no_mangle]
+pub extern "C" fn read_persistence_version() -> u32 {
+    use crate::region::{LEGACY_VERSION_NO_STABLE_MEMORY, VERSION_STABLE_HEAP_NO_REGIONS};
+
+    let physical_pages = unsafe { ic0_stable64_size() };
+    if physical_pages == 0 {
+        // No stable memory -> Use the new default: Enhanced orthogonal persistence.
+        return VERSION_STABLE_HEAP_NO_REGIONS;
+    }
+    if read_u32(0) != 0 {
+        // Old stabilization with no experimental stable memory and no regions.
+        // It stores non-zero marker at address 0 -> Legacy version 0.
+        return LEGACY_VERSION_NO_STABLE_MEMORY;
+    }
+    let address = physical_pages * PAGE_SIZE - core::mem::size_of::<u32>() as u64;
+    let version = read_u32(address);
+    version
+}
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 68b0e47a77a..96d931e5391 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -6054,6 +6054,20 @@ module RTS_Exports = struct
       edesc = nr (FuncExport (nr ic0_stable64_read_fi))
     });
 
+    let ic0_stable64_size_fi =
+      if E.mode env = Flags.WASIMode then
+        E.add_fun env "ic0_stable64_size" (
+            Func.of_body env [] [I64Type]
+              (fun env ->
+                E.trap_with env "ic0_stable64_size is not supposed to be called in WASI"
+              )
+          )
+      else E.reuse_import env "ic0" "stable64_size" in
+    E.add_export env (nr {
+      name = Lib.Utf8.decode "ic0_stable64_size";
+      edesc = nr (FuncExport (nr ic0_stable64_size_fi))
+    });
+
     let moc_stable_mem_grow_fi =
       E.add_fun env "moc_stable_mem_grow" (
         Func.of_body env ["newPages", I64Type] [I64Type]

From 24e6f03ba2501d48dcb1528e6e3f41f7f0e65bf8 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Tue, 14 May 2024 14:31:34 +0200
Subject: [PATCH 206/260] Code refactoring

---
 rts/motoko-rts/src/persistence.rs | 13 -------------
 1 file changed, 13 deletions(-)

diff --git a/rts/motoko-rts/src/persistence.rs b/rts/motoko-rts/src/persistence.rs
index c77a357946b..c2dadeaf31b 100644
--- a/rts/motoko-rts/src/persistence.rs
+++ b/rts/motoko-rts/src/persistence.rs
@@ -23,12 +23,10 @@ use crate::{
 
 use self::compatibility::TypeDescriptor;
 
-#[cfg(feature = "ic")]
 const FINGERPRINT: [char; 32] = [
     'M', 'O', 'T', 'O', 'K', 'O', ' ', 'O', 'R', 'T', 'H', 'O', 'G', 'O', 'N', 'A', 'L', ' ', 'P',
     'E', 'R', 'S', 'I', 'S', 'T', 'E', 'N', 'C', 'E', ' ', '3', '2',
 ];
-#[cfg(feature = "ic")]
 const VERSION: usize = 1;
 /// The `Value` representation in the default-initialized Wasm memory.
 /// The GC ignores this value since it is a scalar representation.
@@ -70,7 +68,6 @@ impl PersistentMetadata {
         METADATA_ADDRESS as *mut Self
     }
 
-    #[cfg(feature = "ic")]
     unsafe fn is_initialized(self: *mut Self) -> bool {
         // Wasm memory is zero-initialized according to the Wasm specification.
         let initialized = (*self).version != 0;
@@ -83,7 +80,6 @@ impl PersistentMetadata {
         initialized
     }
 
-    #[cfg(feature = "ic")]
     unsafe fn check_version(self: *const Self) {
         if (*self).version != VERSION {
             panic!(
@@ -94,7 +90,6 @@ impl PersistentMetadata {
         }
     }
 
-    #[cfg(feature = "ic")]
     unsafe fn initialize<M: Memory>(self: *mut Self, mem: &mut M) {
         use crate::gc::incremental::IncrementalGC;
         debug_assert!(!self.is_initialized());
@@ -109,7 +104,6 @@ impl PersistentMetadata {
 
 /// Initialize fresh persistent memory after the canister installation or
 /// reuse the persistent memory on a canister upgrade.
-#[cfg(feature = "ic")]
 pub unsafe fn initialize_memory<M: Memory>(mem: &mut M) {
     mem.grow_memory(HEAP_START as u64);
     let metadata = PersistentMetadata::get();
@@ -120,7 +114,6 @@ pub unsafe fn initialize_memory<M: Memory>(mem: &mut M) {
     }
 }
 
-#[cfg(feature = "ic")]
 unsafe fn use_enhanced_orthogonal_persistence() -> bool {
     match read_persistence_version() {
         VERSION_STABLE_HEAP_NO_REGIONS | VERSION_STABLE_HEAP_REGIONS => true,
@@ -160,7 +153,6 @@ pub unsafe fn free_stable_actor<M: Memory>(mem: &mut M) {
     write_with_barrier(mem, location, DEFAULT_VALUE);
 }
 
-#[cfg(feature = "ic")]
 /// GC root pointer required for GC marking and updating.
 pub(crate) unsafe fn stable_actor_location() -> *mut Value {
     let metadata = PersistentMetadata::get();
@@ -170,7 +162,6 @@ pub(crate) unsafe fn stable_actor_location() -> *mut Value {
 /// Determine whether an object contains a specific field.
 /// Used for upgrading to an actor with additional stable fields.
 #[no_mangle]
-#[cfg(feature = "ic")]
 pub unsafe extern "C" fn contains_field(actor: Value, field_hash: u32) -> bool {
     use crate::constants::WORD_SIZE;
 
@@ -211,27 +202,23 @@ pub unsafe fn register_stable_type<M: Memory>(
     (*metadata).stable_type.assign(mem, &new_type);
 }
 
-#[cfg(feature = "ic")]
 pub(crate) unsafe fn stable_type_descriptor() -> &'static mut TypeDescriptor {
     let metadata = PersistentMetadata::get();
     &mut (*metadata).stable_type
 }
 
-#[cfg(feature = "ic")]
 pub(crate) unsafe fn get_incremental_gc_state() -> &'static mut State {
     let metadata = PersistentMetadata::get();
     &mut (*metadata).incremental_gc_state
 }
 
 #[no_mangle]
-#[cfg(feature = "ic")]
 pub unsafe extern "C" fn get_upgrade_instructions() -> u64 {
     let metadata = PersistentMetadata::get();
     (*metadata).upgrade_instructions
 }
 
 #[no_mangle]
-#[cfg(feature = "ic")]
 pub unsafe extern "C" fn set_upgrade_instructions(instructions: u64) {
     let metadata = PersistentMetadata::get();
     (*metadata).upgrade_instructions = instructions;

From db2536e9936d3ffccdb953e4e14d5a0f4d92ecae Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Tue, 14 May 2024 15:30:28 +0200
Subject: [PATCH 207/260] Add WASI support when detecting persistence version

---
 src/codegen/compile.ml | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 96d931e5391..d6815f88b3f 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -6055,14 +6055,17 @@ module RTS_Exports = struct
     });
 
     let ic0_stable64_size_fi =
-      if E.mode env = Flags.WASIMode then
+      match E.mode env with
+      | Flags.ICMode | Flags.RefMode ->
+        E.reuse_import env "ic0" "stable64_size"
+      | Flags.WASIMode | Flags.WasmMode ->
         E.add_fun env "ic0_stable64_size" (
-            Func.of_body env [] [I64Type]
-              (fun env ->
-                E.trap_with env "ic0_stable64_size is not supposed to be called in WASI"
-              )
+          Func.of_body env [] [I64Type]
+            (fun env ->
+              when_stable_memory_required_else_trap env (fun () ->
+                StableMem.stable64_size env))
           )
-      else E.reuse_import env "ic0" "stable64_size" in
+    in
     E.add_export env (nr {
       name = Lib.Utf8.decode "ic0_stable64_size";
       edesc = nr (FuncExport (nr ic0_stable64_size_fi))

From f0d78ecf77cb6f3aaa82857e163e04de78e00944 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Tue, 14 May 2024 17:45:20 +0200
Subject: [PATCH 208/260] Support Wasi mode without stable memory support

---
 src/codegen/compile.ml | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index d6815f88b3f..16baeb48d64 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -6062,8 +6062,12 @@ module RTS_Exports = struct
         E.add_fun env "ic0_stable64_size" (
           Func.of_body env [] [I64Type]
             (fun env ->
-              when_stable_memory_required_else_trap env (fun () ->
-                StableMem.stable64_size env))
+              if E.requires_stable_memory env then
+                StableMem.stable64_size env
+              else
+                (* The RTS also checks the persistence mode on Wasi without stable memory support *)
+                compile_const_64 0L
+            )
           )
     in
     E.add_export env (nr {

From 6be52e1dd351536115f98a93103f56b101fe2a9e Mon Sep 17 00:00:00 2001
From: Claudio Russo <claudio@dfinity.org>
Date: Fri, 17 May 2024 16:28:59 +0100
Subject: [PATCH 209/260] subdivide ambiguous tags

---
 src/codegen/compile.ml | 131 +++++++++++++++++++++++------------------
 1 file changed, 74 insertions(+), 57 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index bbce0ee1646..abb61b3d141 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -1996,18 +1996,22 @@ module Tagged = struct
      so update all!
    *)
 
+  type bits_sort = U | S | F
+  type array_sort = M | I | T
+  type blob_sort = B | T | P
+
   type [@warning "-37"] tag  =
     | Object
     | ObjInd (* The indirection used for object fields *)
-    | Array (* Also a tuple *)
-    | Bits64 (* Contains a 64 bit number *)
+    | Array of array_sort (* Also a tuple *)
+    | Bits64 of bits_sort (* Contains a 64 bit number *)
     | MutBox (* used for mutable heap-allocated variables *)
     | Closure
     | Some (* For opt *)
     | Variant
-    | Blob
+    | Blob of blob_sort
     | Indirection (* Only used by the GC *)
-    | Bits32 (* Contains a 32 bit unsigned number *)
+    | Bits32 of bits_sort (* Contains a 32 bit value *)
     | BigInt
     | Concat (* String concatenation, used by rts/text.c *)
     | Null (* For opt. Static singleton! *)
@@ -2026,15 +2030,15 @@ module Tagged = struct
   let int_of_tag = function
     | Object -> 1l
     | ObjInd -> 3l
-    | Array -> 5l
-    | Bits64 -> 7l
+    | Array _ -> 5l
+    | Bits64 _ -> 7l
     | MutBox -> 9l
     | Closure -> 11l
     | Some -> 13l
     | Variant -> 15l
-    | Blob -> 17l
+    | Blob _ -> 17l
     | Indirection -> 19l
-    | Bits32 -> 21l
+    | Bits32 _ -> 21l
     | BigInt -> 23l
     | Concat -> 25l
     | Region -> 27l
@@ -2197,7 +2201,7 @@ module Tagged = struct
     let (set_o, get_o) = new_local env "o" in
     let prep (t, code) = (t, get_o ^^ code)
     in set_o ^^ get_o ^^ branch_default env retty def (List.map prep cases)
-
+(*
   (* like branch_default_with but the tag is known statically *)
   let branch_with env retty = function
     | [] -> G.i Unreachable
@@ -2227,7 +2231,7 @@ module Tagged = struct
       | (Prim _ |  Obj _ | Opt _ | Variant _ | Func _ | Non) -> false
       | (Pre | Async _ | Mut _ | Var _ | Typ _) -> assert false
       end
-    | Blob ->
+    | Blob  ->
       begin match normalize ty with
       | (Con _ | Any) -> true
       | (Prim (Text|Blob|Principal)) -> true
@@ -2247,6 +2251,7 @@ module Tagged = struct
   let _branch_typed_with env ty retty branches =
     branch_with env retty (List.filter (fun (tag,c) -> can_have_tag ty tag) branches)
 
+ *)
   let allocation_barrier env =
     (if !Flags.gc_strategy = Flags.Incremental then
       E.call_import env "rts" "allocation_barrier"
@@ -2571,7 +2576,11 @@ module BoxedWord64 = struct
 
   let payload_field = Tagged.header_size
 
-  let heap_tag env pty = Tagged.Bits64 (* TODO *)
+  let heap_tag env pty =
+    match pty with
+    | Type.Nat64 -> Tagged.(Bits64 U)
+    | Type.Int64 -> Tagged.(Bits64 S)
+    | _ -> assert false
 
   let vanilla_lit env pty i =
     if BitTagged.can_tag_const pty i
@@ -2701,7 +2710,11 @@ module BoxedSmallWord = struct
 
   *)
 
-  let heap_tag env pty = Tagged.Bits32 (* TODO *)
+  let heap_tag env pty =
+    match pty with
+    | Type.Nat32 -> Tagged.(Bits32 U)
+    | Type.Int32 -> Tagged.(Bits32 S)
+    | _ -> assert false
 
   let payload_field env = Tagged.header_size env
 
@@ -2987,14 +3000,14 @@ module Float = struct
   let compile_unboxed_const f = G.i (Const (nr (Wasm.Values.F64 f)))
 
   let vanilla_lit env f =
-    Tagged.shared_static_obj env Tagged.Bits64 StaticBytes.[
+    Tagged.shared_static_obj env Tagged.(Bits64 F) StaticBytes.[
       I64 (Wasm.F64.to_bits f)
     ]
 
   let box env = Func.share_code1 Func.Never env "box_f64" ("f", F64Type) [I32Type] (fun env get_f ->
     let (set_i, get_i) = new_local env "boxed_f64" in
     let size = Int32.add (Tagged.header_size env)  2l in
-    Tagged.alloc env size Tagged.Bits64 ^^
+    Tagged.alloc env size Tagged.(Bits64 F) ^^
     set_i ^^
     get_i ^^ get_f ^^ Tagged.store_field_float64 env (payload_field env) ^^
     get_i ^^
@@ -4227,7 +4240,7 @@ module Blob = struct
     )
 
   let vanilla_lit env s =
-    Tagged.shared_static_obj env Tagged.Blob StaticBytes.[
+    Tagged.shared_static_obj env Tagged.(Blob B) StaticBytes.[
       I32 (Int32.of_int (String.length s));
       Bytes s;
     ]
@@ -4238,8 +4251,8 @@ module Blob = struct
     compile_unboxed_const (Int32.add ptr_unskew (E.add_static env StaticBytes.[Bytes s])) ^^
     compile_unboxed_const (Int32.of_int (String.length s))
 
-  let alloc env =
-    E.call_import env "rts" "alloc_blob" ^^
+  let alloc env sort =
+    E.call_import env "rts" "alloc_blob" ^^ (*TODO sorts!*)
     (* uninitialized blob payload is allowed by the barrier *)
     Tagged.allocation_barrier env
 
@@ -4258,7 +4271,7 @@ module Blob = struct
   let of_ptr_size env = Func.share_code2 Func.Always env "blob_of_ptr_size" (("ptr", I32Type), ("size" , I32Type)) [I32Type] (
     fun env get_ptr get_size ->
       let (set_x, get_x) = new_local env "x" in
-      get_size ^^ alloc env ^^ set_x ^^
+      get_size ^^ alloc env Tagged.B ^^ set_x ^^
       get_x ^^ payload_ptr_unskewed env ^^
       get_ptr ^^
       get_size ^^
@@ -4266,12 +4279,12 @@ module Blob = struct
       get_x
     )
 
-  let of_size_copy env get_size_fun copy_fun offset_fun =
+  let of_size_copy env sort get_size_fun copy_fun offset_fun =
     let (set_len, get_len) = new_local env "len" in
     let (set_blob, get_blob) = new_local env "blob" in
     get_size_fun env ^^ set_len ^^
 
-    get_len ^^ alloc env ^^ set_blob ^^
+    get_len ^^ alloc env sort ^^ set_blob ^^
     get_blob ^^ payload_ptr_unskewed env ^^
     offset_fun env ^^
     get_len ^^
@@ -4388,7 +4401,7 @@ module Blob = struct
     E.call_import env "rts" "blob_iter_next" ^^
     TaggedSmallWord.msb_adjust Type.Nat8
 
-  let dyn_alloc_scratch env = alloc env ^^ payload_ptr_unskewed env
+  let dyn_alloc_scratch env = alloc env Tagged.B ^^ payload_ptr_unskewed env
 
   (* TODO: rewrite using MemoryFill *)
   let clear env =
@@ -4658,22 +4671,22 @@ module Arr = struct
      | Type.Array element_type -> element_type
      | _ -> assert false
 
-  let vanilla_lit env ptrs =
-    Tagged.shared_static_obj env Tagged.Array StaticBytes.[
+  let vanilla_lit env sort ptrs =
+    Tagged.shared_static_obj env Tagged.(Array sort) StaticBytes.[
       I32 (Int32.of_int (List.length ptrs));
       i32s ptrs;
     ]
 
   (* Compile an array literal. *)
-  let lit env element_instructions =
-    Tagged.obj env Tagged.Array
+  let lit env sort element_instructions =
+    Tagged.obj env Tagged.(Array sort)
      ([ compile_unboxed_const (Wasm.I32.of_int_u (List.length element_instructions))
       ] @ element_instructions)
 
   (* Does not initialize the fields! *)
   (* Note: Post allocation barrier must be applied after initialization *)
-  let alloc env =
-    E.call_import env "rts" "alloc_array"
+  let alloc env array_sort =
+    E.call_import env "rts" "alloc_array" (* TODO *)
 
   let iterate env get_array body =
     let (set_boundary, get_boundary) = new_local env "boundary" in
@@ -4720,7 +4733,7 @@ module Arr = struct
 
     (* Allocate *)
     BigNum.to_word32 env ^^
-    alloc env ^^
+    alloc env Tagged.M ^^
     set_r ^^
 
     (* Write elements *)
@@ -4741,7 +4754,7 @@ module Arr = struct
 
     (* Allocate *)
     BigNum.to_word32 env ^^
-    alloc env ^^
+    alloc env Tagged.I ^^
     set_r ^^
 
     (* Initial index *)
@@ -4771,14 +4784,15 @@ module Arr = struct
     get_r ^^
     Tagged.allocation_barrier env
 
-  let ofBlob env =
-    Func.share_code1 Func.Always env "Arr.ofBlob" ("blob", I32Type) [I32Type] (fun env get_blob ->
+  let ofBlob env sort =
+    let name = Tagged.(match sort with I -> "Arr.ofBlob" | M -> "Arr.ofBlobMut" | _ -> assert false) in
+    Func.share_code1 Func.Always env name ("blob", I32Type) [I32Type] (fun env get_blob ->
       let (set_len, get_len) = new_local env "len" in
       let (set_r, get_r) = new_local env "r" in
 
       get_blob ^^ Blob.len env ^^ set_len ^^
 
-      get_len ^^ alloc env ^^ set_r ^^
+      get_len ^^ alloc env sort ^^ set_r ^^
 
       get_len ^^ from_0_to_n env (fun get_i ->
         get_r ^^ get_i ^^ unsafe_idx env ^^
@@ -4800,7 +4814,7 @@ module Arr = struct
 
       get_a ^^ len env ^^ set_len ^^
 
-      get_len ^^ Blob.alloc env ^^ set_r ^^
+      get_len ^^ Blob.alloc env Tagged.B ^^ set_r ^^
 
       get_len ^^ from_0_to_n env (fun get_i ->
         get_r ^^ Blob.payload_ptr_unskewed env ^^
@@ -4841,7 +4855,7 @@ module Tuple = struct
       let name = Printf.sprintf "to_%i_tuple" n in
       let args = Lib.List.table n (fun i -> Printf.sprintf "arg%i" i, I32Type) in
       Func.share_code Func.Never env name args [I32Type] (fun env getters ->
-        Arr.lit env (Lib.List.table n (fun i -> List.nth getters i))
+        Arr.lit env Tagged.T (Lib.List.table n (fun i -> List.nth getters i))
       )
 
   (* Takes an argument tuple and puts the elements on the stack: *)
@@ -5264,7 +5278,7 @@ module IC = struct
     match E.mode env with
     | Flags.ICMode | Flags.RefMode ->
       Func.share_code0 Func.Never env "canister_self" [I32Type] (fun env ->
-        Blob.of_size_copy env
+        Blob.of_size_copy env Tagged.P
           (fun env -> system_call env "canister_self_size")
           (fun env -> system_call env "canister_self_copy")
           (fun env -> compile_unboxed_const 0l)
@@ -5282,7 +5296,7 @@ module IC = struct
   let caller env =
     match E.mode env with
     | Flags.ICMode | Flags.RefMode ->
-      Blob.of_size_copy env
+      Blob.of_size_copy env Tagged.P
         (fun env -> system_call env "msg_caller_size")
         (fun env -> system_call env "msg_caller_copy")
         (fun env -> compile_unboxed_const 0l)
@@ -5292,7 +5306,7 @@ module IC = struct
   let method_name env =
     match E.mode env with
     | Flags.ICMode | Flags.RefMode ->
-      Blob.of_size_copy env
+      Blob.of_size_copy env Tagged.T
         (fun env -> system_call env "msg_method_name_size")
         (fun env -> system_call env "msg_method_name_copy")
         (fun env -> compile_unboxed_const 0l)
@@ -5302,7 +5316,7 @@ module IC = struct
   let arg_data env =
     match E.mode env with
     | Flags.ICMode | Flags.RefMode ->
-      Blob.of_size_copy env
+      Blob.of_size_copy env Tagged.B
         (fun env -> system_call env "msg_arg_data_size")
         (fun env -> system_call env "msg_arg_data_copy")
         (fun env -> compile_unboxed_const 0l)
@@ -5338,7 +5352,7 @@ module IC = struct
 
   let error_message env =
     Func.share_code0 Func.Never env "error_message" [I32Type] (fun env ->
-      Blob.of_size_copy env
+      Blob.of_size_copy env Tagged.T
         (fun env -> system_call env "msg_reject_msg_size")
         (fun env -> system_call env "msg_reject_msg_copy")
         (fun env -> compile_unboxed_const 0l)
@@ -5476,7 +5490,7 @@ module IC = struct
       G.if1 I32Type
       begin
         Opt.inject_simple env (
-          Blob.of_size_copy env
+          Blob.of_size_copy env Tagged.B
             (fun env -> system_call env "data_certificate_size")
             (fun env -> system_call env "data_certificate_copy")
             (fun env -> compile_unboxed_const 0l)
@@ -5934,7 +5948,7 @@ module StableMem = struct
           get_offset ^^
           get_len ^^
           guard_range env ^^
-          get_len ^^ Blob.alloc env ^^ set_blob ^^
+          get_len ^^ Blob.alloc env Tagged.B ^^ set_blob ^^
           get_blob ^^ Blob.payload_ptr_unskewed env ^^ G.i (Convert (Wasm.Values.I64 I64Op.ExtendUI32)) ^^
           get_offset ^^
           get_len ^^ G.i (Convert (Wasm.Values.I64 I64Op.ExtendUI32)) ^^
@@ -6842,7 +6856,7 @@ module MakeSerialization (Strm : Stream) = struct
         G.i (Compare (Wasm.Values.I32 I32Op.GeU)) ^^
         G.i (Binary (Wasm.Values.I32 I32Op.And)) ^^
         G.if1 I32Type begin
-          (compile_unboxed_const Tagged.(int_of_tag Array))
+          (compile_unboxed_const Tagged.(int_of_tag (Array M)))
         end begin
           get_temp
         end
@@ -6858,7 +6872,7 @@ module MakeSerialization (Strm : Stream) = struct
         G.i (Binary (Wasm.Values.I32 I32Op.Or)) ^^
         get_tag ^^ compile_eq_const Tagged.(int_of_tag ObjInd) ^^
         G.i (Binary (Wasm.Values.I32 I32Op.Or)) ^^
-        get_tag ^^ compile_eq_const Tagged.(int_of_tag Array) ^^
+        get_tag ^^ compile_eq_const Tagged.(int_of_tag (Array M)) ^^
         G.i (Binary (Wasm.Values.I32 I32Op.Or)) ^^
         get_tag ^^ compile_eq_const Tagged.(int_of_tag Region) ^^
         G.i (Binary (Wasm.Values.I32 I32Op.Or)) ^^
@@ -7011,7 +7025,7 @@ module MakeSerialization (Strm : Stream) = struct
           E.then_trap_with env "unvisited mutable data in serialize_go (MutBox)" ^^
           get_tag ^^ compile_eq_const Tagged.(int_of_tag ObjInd) ^^
           E.then_trap_with env "unvisited mutable data in serialize_go (ObjInd)" ^^
-          get_tag ^^ compile_eq_const Tagged.(int_of_tag Array) ^^
+          get_tag ^^ compile_eq_const Tagged.(int_of_tag (Array M)) ^^
           E.then_trap_with env "unvisited mutable data in serialize_go (Array)" ^^
           get_tag ^^ compile_eq_const Tagged.(int_of_tag Region) ^^
           E.then_trap_with env "unvisited mutable data in serialize_go (Region)" ^^
@@ -7325,7 +7339,7 @@ module MakeSerialization (Strm : Stream) = struct
         let (set_x, get_x) = new_local env "x" in
         ReadBuf.read_leb128 env get_data_buf ^^ set_len ^^
 
-        get_len ^^ Blob.alloc env ^^ set_x ^^
+        get_len ^^ Blob.alloc env Tagged.B ^^ set_x ^^
         get_x ^^ Blob.payload_ptr_unskewed env ^^
         ReadBuf.read_blob env get_data_buf get_len ^^
         get_x
@@ -7342,7 +7356,7 @@ module MakeSerialization (Strm : Stream) = struct
         get_len ^^ compile_unboxed_const 29l ^^ G.i (Compare (Wasm.Values.I32 I32Op.LeU)) ^^
         E.else_trap_with env "IDL error: principal too long" ^^
 
-        get_len ^^ Blob.alloc env ^^ set_x ^^
+        get_len ^^ Blob.alloc env Tagged.P ^^ set_x ^^
         get_x ^^ Blob.payload_ptr_unskewed env ^^
         ReadBuf.read_blob env get_data_buf get_len ^^
         get_x
@@ -7691,7 +7705,7 @@ module MakeSerialization (Strm : Stream) = struct
           *)
           with_composite_arg_typ get_array_typ idl_vec (ReadBuf.read_sleb128 env) ^^ set_arg_typ ^^
           ReadBuf.read_leb128 env get_data_buf ^^ set_len ^^
-          get_len ^^ Arr.alloc env ^^ set_x ^^
+          get_len ^^ Arr.alloc env Tagged.M ^^ set_x ^^
           on_alloc get_x ^^
           get_len ^^ from_0_to_n env (fun get_i ->
             get_x ^^ get_i ^^ Arr.unsafe_idx env ^^
@@ -7733,7 +7747,7 @@ module MakeSerialization (Strm : Stream) = struct
           ReadBuf.read_sleb128 env get_typ_buf ^^
           set_arg_typ ^^
           ReadBuf.read_leb128 env get_data_buf ^^ set_len ^^
-          get_len ^^ Arr.alloc env ^^ set_x ^^
+          get_len ^^ Arr.alloc env Tagged.I ^^ set_x ^^
           get_len ^^ from_0_to_n env (fun get_i ->
           get_x ^^ get_i ^^ Arr.unsafe_idx env ^^
           get_arg_typ ^^ go env t ^^ set_val ^^
@@ -8597,7 +8611,7 @@ module Stabilization = struct
 
           let (set_blob, get_blob) = new_local env "blob" in
           (* read blob from stable memory *)
-          get_len ^^ Blob.alloc env ^^ set_blob ^^
+          get_len ^^ Blob.alloc env Tagged.B ^^ set_blob ^^
           extend64 (get_blob ^^ Blob.payload_ptr_unskewed env) ^^
           get_offset ^^
           extend64 get_len ^^
@@ -8639,7 +8653,7 @@ module GCRoots = struct
     })
 
   let store_static_roots env =
-    Arr.vanilla_lit env (E.get_static_roots env)
+    Arr.vanilla_lit env Tagged.M (E.get_static_roots env)
 
 end (* GCRoots *)
 
@@ -8747,7 +8761,7 @@ module StackRep = struct
     | Const.Unit -> Tuple.unit_vanilla_lit env
     | Const.Array cs ->
       let ptrs = List.map (materialize_const_t env) cs in
-      Arr.vanilla_lit env ptrs
+      Arr.vanilla_lit env Tagged.T ptrs
     | Const.Tag (i, c) ->
       let ptr = materialize_const_t env c in
       Variant.vanilla_lit env i ptr
@@ -9333,7 +9347,7 @@ module FuncDec = struct
         (1,
          "@callback",
          (fun env ->
-           Blob.of_size_copy env
+           Blob.of_size_copy env Tagged.B
            (fun env -> IC.system_call env "msg_arg_data_size")
            (fun env -> IC.system_call env "msg_arg_data_copy")
            (fun env -> compile_unboxed_const 0l)))
@@ -9384,7 +9398,7 @@ module FuncDec = struct
        the first and second must be the reply and reject continuations. *)
     fun closure_getters ->
       let (set_cb_index, get_cb_index) = new_local env "cb_index" in
-      Arr.lit env closure_getters ^^
+      Arr.lit env Tagged.T closure_getters ^^
       ContinuationTable.remember env ^^
       set_cb_index ^^
 
@@ -10713,7 +10727,7 @@ and compile_prim_invocation (env : E.t) ae p es at =
 
   | ArrayPrim (m, t), es ->
     SR.Vanilla,
-    Arr.lit env (List.map (compile_exp_vanilla env ae) es)
+    Arr.lit env Tagged.(if m = Ir.Var then M else I) (List.map (compile_exp_vanilla env ae) es)
   | IdxPrim, [e1; e2] ->
     SR.Vanilla,
     compile_array_index env ae e1 e2 ^^
@@ -11070,7 +11084,7 @@ and compile_prim_invocation (env : E.t) ae p es at =
               (Opt.null_lit env)
               (go ls')
           | [] ->
-            Opt.inject env (Arr.lit env locals)
+            Opt.inject env (Arr.lit env Tagged.T locals)
         in
         go locals)
     end
@@ -11605,8 +11619,11 @@ and compile_prim_invocation (env : E.t) ae p es at =
     compile_exp_vanilla env ae e ^^
     IC.trap_text env
 
-  | OtherPrim ("blobToArray" | "blobToArrayMut"), e ->
-    const_sr SR.Vanilla (Arr.ofBlob env)
+  | OtherPrim "blobToArray", e ->
+    const_sr SR.Vanilla (Arr.ofBlob env Tagged.I)
+  | OtherPrim "blobToArrayMut", e ->
+    const_sr SR.Vanilla (Arr.ofBlob env Tagged.M)
+
   | OtherPrim ("arrayToBlob" | "arrayMutToBlob"), e ->
     const_sr SR.Vanilla (Arr.toBlob env)
 

From 7b03506b1bad77afbeca371a9d2522400b0c6c72 Mon Sep 17 00:00:00 2001
From: Claudio Russo <claudio@dfinity.org>
Date: Fri, 17 May 2024 18:18:40 +0100
Subject: [PATCH 210/260] WIP: rts for precise tagging

---
 .../src/gc/compacting/mark_stack.rs           |  8 +--
 rts/motoko-rts-tests/src/gc/heap.rs           |  6 +-
 .../src/gc/incremental/partitioned_heap.rs    |  4 +-
 rts/motoko-rts/src/blob_iter.rs               |  4 +-
 rts/motoko-rts/src/debug.rs                   |  8 +--
 rts/motoko-rts/src/gc/generational.rs         |  2 +-
 .../src/gc/incremental/array_slicing.rs       |  2 +-
 rts/motoko-rts/src/memory.rs                  |  4 +-
 rts/motoko-rts/src/principal_id.rs            |  4 +-
 rts/motoko-rts/src/stream.rs                  |  4 +-
 rts/motoko-rts/src/text.rs                    | 16 ++---
 rts/motoko-rts/src/text_iter.rs               |  6 +-
 rts/motoko-rts/src/types.rs                   | 71 ++++++++++++-------
 rts/motoko-rts/src/visitor.rs                 |  8 ++-
 14 files changed, 86 insertions(+), 61 deletions(-)

diff --git a/rts/motoko-rts-tests/src/gc/compacting/mark_stack.rs b/rts/motoko-rts-tests/src/gc/compacting/mark_stack.rs
index 87ab1c130a0..2458ff35128 100644
--- a/rts/motoko-rts-tests/src/gc/compacting/mark_stack.rs
+++ b/rts/motoko-rts-tests/src/gc/compacting/mark_stack.rs
@@ -36,15 +36,15 @@ fn test_push_pop() {
 static TAGS: [Tag; 14] = [
     TAG_OBJECT,
     TAG_OBJ_IND,
-    TAG_ARRAY,
-    TAG_BITS64,
+    TAG_ARRAY_I, TAG_ARRAY_M, TAG_ARRAY_T,
+    TAG_BITS64_U, TAG_BITS64_S, TAG_BITS64_F,
     TAG_MUTBOX,
     TAG_CLOSURE,
     TAG_SOME,
     TAG_VARIANT,
-    TAG_BLOB,
+    TAG_BLOB_B, TAG_BLOB_T, TAG_BLOB_P,
     TAG_FWD_PTR,
-    TAG_BITS32,
+    TAG_BITS32_U, TAG_BITS32_S, TAG_BITS32_F,
     TAG_BIGINT,
     TAG_CONCAT,
     TAG_NULL,
diff --git a/rts/motoko-rts-tests/src/gc/heap.rs b/rts/motoko-rts-tests/src/gc/heap.rs
index a8cfc74f454..9877e0a5c2f 100644
--- a/rts/motoko-rts-tests/src/gc/heap.rs
+++ b/rts/motoko-rts-tests/src/gc/heap.rs
@@ -442,7 +442,7 @@ fn create_dynamic_heap(
 
             // Store object header
             let address = u32::try_from(heap_start + heap_offset).unwrap();
-            write_word(dynamic_heap, heap_offset, TAG_ARRAY);
+            write_word(dynamic_heap, heap_offset, TAG_ARRAY_M);
             heap_offset += WORD_SIZE;
 
             if incremental {
@@ -497,7 +497,7 @@ fn create_dynamic_heap(
         let mut heap_offset = continuation_table_offset;
 
         let continuation_table_address = u32::try_from(heap_start + heap_offset).unwrap();
-        write_word(dynamic_heap, heap_offset, TAG_ARRAY);
+        write_word(dynamic_heap, heap_offset, TAG_ARRAY_M); // TODO: TBR
         heap_offset += WORD_SIZE;
 
         if incremental {
@@ -570,7 +570,7 @@ fn create_static_heap(
     // root.
     let array_addr = u32::try_from(heap.as_ptr() as usize).unwrap();
     let mut offset = 0;
-    write_word(heap, offset, TAG_ARRAY);
+    write_word(heap, offset, TAG_ARRAY_M); // TODO: TBR
     offset += WORD_SIZE;
 
     if incremental {
diff --git a/rts/motoko-rts-tests/src/gc/incremental/partitioned_heap.rs b/rts/motoko-rts-tests/src/gc/incremental/partitioned_heap.rs
index c60f37ac4f9..f98bdf66408 100644
--- a/rts/motoko-rts-tests/src/gc/incremental/partitioned_heap.rs
+++ b/rts/motoko-rts-tests/src/gc/incremental/partitioned_heap.rs
@@ -412,10 +412,10 @@ impl PartitionedTestHeap {
 
 unsafe fn block_size(block: *const Tag) -> usize {
     match *block {
-        TAG_ARRAY => {
+        TAG_ARRAY_I | TAG_ARRAY_M | TAG_ARRAY_T => {
             size_of::<Array>() + (block as *const Array).len() as usize * WORD_SIZE as usize
         }
-        TAG_BLOB => size_of::<Blob>() + (block as *const Blob).len().as_usize(),
+        TAG_BLOB_B | TAG_BLOB_T | TAG_BLOB_P => size_of::<Blob>() + (block as *const Blob).len().as_usize(),
         _ => unimplemented!(),
     }
 }
diff --git a/rts/motoko-rts/src/blob_iter.rs b/rts/motoko-rts/src/blob_iter.rs
index b63419f3d78..6625ea718ff 100644
--- a/rts/motoko-rts/src/blob_iter.rs
+++ b/rts/motoko-rts/src/blob_iter.rs
@@ -1,6 +1,6 @@
 use crate::{
     barriers::allocation_barrier,
-    types::{size_of, Array, Bytes, Value, Words, TAG_ARRAY},
+    types::{size_of, Array, Bytes, Value, Words, TAG_ARRAY_T},
 };
 
 use motoko_rts_macros::ic_mem_fn;
@@ -16,7 +16,7 @@ unsafe fn blob_iter<M: crate::memory::Memory>(mem: &mut M, blob: Value) -> Value
 
     // NB. cannot use as_array() here as we didn't write the header yet
     let iter_array = iter_ptr.get_ptr() as *mut Array;
-    (*iter_array).header.tag = TAG_ARRAY;
+    (*iter_array).header.tag = TAG_ARRAY_T;
     (*iter_array).header.init_forward(iter_ptr);
     (*iter_array).len = 2;
 
diff --git a/rts/motoko-rts/src/debug.rs b/rts/motoko-rts/src/debug.rs
index e5007115ab0..2a97b423a1f 100644
--- a/rts/motoko-rts/src/debug.rs
+++ b/rts/motoko-rts/src/debug.rs
@@ -165,7 +165,7 @@ pub(crate) unsafe fn print_boxed_object(buf: &mut WriteBuf, p: usize) {
             let obj_ind = obj as *const ObjInd;
             let _ = write!(buf, "<ObjInd field={:#x}>", (*obj_ind).field.get_raw());
         }
-        TAG_ARRAY | TAG_ARRAY_SLICE_MIN.. => {
+        TAG_ARRAY_I | TAG_ARRAY_M | TAG_ARRAY_T | TAG_ARRAY_SLICE_MIN.. => {
             let array = obj as *mut Array;
             let _ = write!(buf, "<Array len={:#x}", (*array).len);
 
@@ -179,7 +179,7 @@ pub(crate) unsafe fn print_boxed_object(buf: &mut WriteBuf, p: usize) {
                 let _ = write!(buf, ">");
             }
         }
-        TAG_BITS64 => {
+        TAG_BITS64_U | TAG_BITS64_S | TAG_BITS64_F => {
             let bits64 = obj as *const Bits64;
             let _ = write!(buf, "<Bits64 {:#x}>", (*bits64).bits());
         }
@@ -204,7 +204,7 @@ pub(crate) unsafe fn print_boxed_object(buf: &mut WriteBuf, p: usize) {
                 (*variant).field.get_raw()
             );
         }
-        TAG_BLOB => {
+        TAG_BLOB_B | TAG_BLOB_T | TAG_BLOB_P => {
             let blob = obj.as_blob();
             let _ = write!(buf, "<Blob len={:#x}>", blob.len().as_u32());
         }
@@ -212,7 +212,7 @@ pub(crate) unsafe fn print_boxed_object(buf: &mut WriteBuf, p: usize) {
             let ind = obj as *const FwdPtr;
             let _ = write!(buf, "<Forwarding to {:#x}>", (*ind).fwd.get_raw());
         }
-        TAG_BITS32 => {
+        TAG_BITS32_U | TAG_BITS32_S | TAG_BITS32_F => {
             let bits32 = obj as *const Bits32;
             let _ = write!(buf, "<Bits32 {:#x}>", (*bits32).bits);
         }
diff --git a/rts/motoko-rts/src/gc/generational.rs b/rts/motoko-rts/src/gc/generational.rs
index a3b86531549..6b13927fe22 100644
--- a/rts/motoko-rts/src/gc/generational.rs
+++ b/rts/motoko-rts/src/gc/generational.rs
@@ -304,7 +304,7 @@ impl<'a, M: Memory> GenerationalGC<'a, M> {
                     new_start
                 } else {
                     // No further visits of this array. Restore the tag.
-                    (*array).header.tag = TAG_ARRAY;
+                    (*array).header.tag = TAG_ARRAY_M; // TODO: restore precise tag!
                     array.len()
                 }
             },
diff --git a/rts/motoko-rts/src/gc/incremental/array_slicing.rs b/rts/motoko-rts/src/gc/incremental/array_slicing.rs
index 39ccaee55ac..ab200c2407c 100644
--- a/rts/motoko-rts/src/gc/incremental/array_slicing.rs
+++ b/rts/motoko-rts/src/gc/incremental/array_slicing.rs
@@ -15,7 +15,7 @@ pub unsafe fn slice_array(array: *mut Array) -> u32 {
         (*array).header.tag = new_start;
         new_start
     } else {
-        (*array).header.tag = TAG_ARRAY;
+        (*array).header.tag = TAG_ARRAY_M; // TODO: restore original tag somehow
         array.len()
     }
 }
diff --git a/rts/motoko-rts/src/memory.rs b/rts/motoko-rts/src/memory.rs
index 65ff5255b94..cc3a8e18b32 100644
--- a/rts/motoko-rts/src/memory.rs
+++ b/rts/motoko-rts/src/memory.rs
@@ -49,7 +49,7 @@ pub unsafe fn alloc_blob<M: Memory>(mem: &mut M, size: Bytes<u32>) -> Value {
     let ptr = mem.alloc_words(size_of::<Blob>() + size.to_words());
     // NB. Cannot use `as_blob` here as we didn't write the header yet
     let blob = ptr.get_ptr() as *mut Blob;
-    (*blob).header.tag = TAG_BLOB;
+    (*blob).header.tag = TAG_BLOB_B;
     (*blob).header.init_forward(ptr);
     (*blob).len = size;
 
@@ -68,7 +68,7 @@ pub unsafe fn alloc_array<M: Memory>(mem: &mut M, len: u32) -> Value {
     let skewed_ptr = mem.alloc_words(size_of::<Array>() + Words(len));
 
     let ptr: *mut Array = skewed_ptr.get_ptr() as *mut Array;
-    (*ptr).header.tag = TAG_ARRAY;
+    (*ptr).header.tag = TAG_ARRAY_M;
     (*ptr).header.init_forward(skewed_ptr);
     (*ptr).len = len;
 
diff --git a/rts/motoko-rts/src/principal_id.rs b/rts/motoko-rts/src/principal_id.rs
index 6bbe8e10a8a..dfc21faf21a 100644
--- a/rts/motoko-rts/src/principal_id.rs
+++ b/rts/motoko-rts/src/principal_id.rs
@@ -5,7 +5,7 @@ use crate::mem_utils::memcpy_bytes;
 use crate::memory::{alloc_blob, Memory};
 use crate::rts_trap_with;
 use crate::text::{blob_compare, blob_of_text};
-use crate::types::{Bytes, Value, TAG_BLOB};
+use crate::types::{Bytes, Value, TAG_BLOB_B};
 
 use motoko_rts_macros::ic_mem_fn;
 
@@ -13,7 +13,7 @@ use motoko_rts_macros::ic_mem_fn;
 
 #[no_mangle]
 pub unsafe extern "C" fn compute_crc32(blob: Value) -> u32 {
-    if blob.tag() != TAG_BLOB {
+    if blob.tag() != TAG_BLOB_B {
         panic!("compute_crc32: Blob expected");
     }
 
diff --git a/rts/motoko-rts/src/stream.rs b/rts/motoko-rts/src/stream.rs
index 4a9299ae3ed..0317ae2dce7 100644
--- a/rts/motoko-rts/src/stream.rs
+++ b/rts/motoko-rts/src/stream.rs
@@ -38,7 +38,7 @@ use crate::mem_utils::memcpy_bytes;
 use crate::memory::{alloc_blob, Memory};
 use crate::rts_trap_with;
 use crate::tommath_bindings::{mp_div_2d, mp_int};
-use crate::types::{size_of, Blob, Bytes, Stream, Value, TAG_BLOB};
+use crate::types::{size_of, Blob, Bytes, Stream, Value, TAG_BLOB_B};
 
 use motoko_rts_macros::ic_mem_fn;
 
@@ -195,7 +195,7 @@ impl Stream {
         (*self).header.len = INITIAL_STREAM_FILLED - size_of::<Blob>().to_bytes();
         (*self).filled -= INITIAL_STREAM_FILLED;
         let blob = (self.cache_addr() as *mut Blob).sub(1);
-        (*blob).header.tag = TAG_BLOB;
+        (*blob).header.tag = TAG_BLOB_B;
         let ptr = Value::from_ptr(blob as usize);
         (*blob).header.init_forward(ptr);
         debug_assert_eq!(blob.len(), (*self).filled);
diff --git a/rts/motoko-rts/src/text.rs b/rts/motoko-rts/src/text.rs
index 47c5dd3b945..1f58f8fa347 100644
--- a/rts/motoko-rts/src/text.rs
+++ b/rts/motoko-rts/src/text.rs
@@ -30,7 +30,7 @@ use crate::barriers::allocation_barrier;
 use crate::mem_utils::memcpy_bytes;
 use crate::memory::{alloc_blob, Memory};
 use crate::rts_trap_with;
-use crate::types::{size_of, Blob, Bytes, Concat, Stream, Value, TAG_BLOB, TAG_CONCAT};
+use crate::types::{size_of, Blob, Bytes, Concat, Stream, Value, TAG_BLOB_T, TAG_CONCAT};
 
 use alloc::string::String;
 use core::cmp::{min, Ordering};
@@ -133,7 +133,7 @@ unsafe extern "C" fn text_to_buf(mut s: Value, mut buf: *mut u8) {
 
     loop {
         let s_ptr = s.as_obj();
-        if s_ptr.tag() == TAG_BLOB {
+        if s_ptr.tag() == TAG_BLOB_T {
             let blob = s_ptr.as_blob();
             memcpy_bytes(buf as usize, blob.payload_addr() as usize, blob.len());
 
@@ -172,7 +172,7 @@ unsafe extern "C" fn text_to_buf(mut s: Value, mut buf: *mut u8) {
 unsafe extern "C" fn stream_write_text(stream: *mut Stream, mut s: Value) {
     loop {
         let s_ptr = s.as_obj();
-        if s_ptr.tag() == TAG_BLOB {
+        if s_ptr.tag() == TAG_BLOB_T {
             let blob = s_ptr.as_blob();
             stream.cache_bytes(blob.payload_addr(), blob.len());
             break;
@@ -188,7 +188,7 @@ unsafe extern "C" fn stream_write_text(stream: *mut Stream, mut s: Value) {
 #[ic_mem_fn]
 pub unsafe fn blob_of_text<M: Memory>(mem: &mut M, s: Value) -> Value {
     let obj = s.as_obj();
-    if obj.tag() == TAG_BLOB {
+    if obj.tag() == TAG_BLOB_T {
         s
     } else {
         let concat = obj.as_concat();
@@ -254,8 +254,8 @@ unsafe fn text_compare_range(
             ),
         }
     } else {
-        debug_assert_eq!(s1_obj.tag(), TAG_BLOB);
-        debug_assert_eq!(s2_obj.tag(), TAG_BLOB);
+        debug_assert_eq!(s1_obj.tag(), TAG_BLOB_T);
+        debug_assert_eq!(s2_obj.tag(), TAG_BLOB_T);
 
         let s1_blob = s1_obj.as_blob();
         let s2_blob = s2_obj.as_blob();
@@ -305,7 +305,7 @@ unsafe fn text_get_range(
                 continue;
             }
         } else {
-            debug_assert_eq!(s_obj.tag(), TAG_BLOB);
+            debug_assert_eq!(s_obj.tag(), TAG_BLOB_T);
         }
 
         break;
@@ -360,7 +360,7 @@ pub(crate) unsafe fn blob_compare(s1: Value, s2: Value) -> i32 {
 /// Length in characters
 #[no_mangle]
 pub unsafe extern "C" fn text_len(text: Value) -> u32 {
-    if text.tag() == TAG_BLOB {
+    if text.tag() == TAG_BLOB_T {
         let blob = text.as_blob();
         let payload_addr = blob.payload_const();
         let len = blob.len();
diff --git a/rts/motoko-rts/src/text_iter.rs b/rts/motoko-rts/src/text_iter.rs
index 4129f78724f..e8809c6fd06 100644
--- a/rts/motoko-rts/src/text_iter.rs
+++ b/rts/motoko-rts/src/text_iter.rs
@@ -16,7 +16,7 @@ use crate::barriers::allocation_barrier;
 use crate::memory::{alloc_array, Memory};
 use crate::rts_trap_with;
 use crate::text::decode_code_point;
-use crate::types::{Array, Value, TAG_BLOB, TAG_CONCAT};
+use crate::types::{Array, Value, TAG_BLOB_T, TAG_CONCAT};
 
 use motoko_rts_macros::ic_mem_fn;
 
@@ -42,7 +42,7 @@ unsafe fn find_leaf<M: Memory>(mem: &mut M, mut text: Value, todo: *mut Value) -
         text = (*concat).text1;
     }
 
-    debug_assert_eq!(text.tag(), TAG_BLOB);
+    debug_assert_eq!(text.tag(), TAG_BLOB_T);
     text
 }
 
@@ -126,7 +126,7 @@ pub unsafe fn text_iter_next<M: Memory>(mem: &mut M, iter: Value) -> u32 {
             text_iter_next(mem, iter)
         } else {
             // Otherwise remove the entry from the chain
-            debug_assert_eq!(text.tag(), TAG_BLOB);
+            debug_assert_eq!(text.tag(), TAG_BLOB_T);
 
             iter_array.set_pointer(ITER_BLOB_IDX, text, mem);
             iter_array.set_scalar(ITER_POS_IDX, Value::from_scalar(0));
diff --git a/rts/motoko-rts/src/types.rs b/rts/motoko-rts/src/types.rs
index dbe1690e6bc..5c8823351e2 100644
--- a/rts/motoko-rts/src/types.rs
+++ b/rts/motoko-rts/src/types.rs
@@ -326,6 +326,17 @@ impl Value {
         tag != TAG_FWD_PTR && tag != TAG_ONE_WORD_FILLER && tag != TAG_FREE_SPACE
     }
 
+    pub unsafe fn is_blob(self) -> bool {
+       let tag = self.tag();
+       tag == TAG_BLOB_B || tag == TAG_BLOB_T || tag == TAG_BLOB_P
+    }
+
+    pub unsafe fn is_array(self) -> bool {
+       let tag = self.tag();
+       tag == TAG_ARRAY_I || tag == TAG_ARRAY_M || tag == TAG_ARRAY_T || tag >= TAG_ARRAY_SLICE_MIN
+    }
+
+
     /// Get the pointer as `Obj` using forwarding. In debug mode panics if the value is not a pointer.
     pub unsafe fn as_obj(self) -> *mut Obj {
         debug_assert!(self.get().is_ptr());
@@ -343,7 +354,7 @@ impl Value {
     /// Get the pointer as `Array` using forwarding. In debug mode panics if the value is not a pointer or the
     /// pointed object is not an `Array`.
     pub unsafe fn as_array(self) -> *mut Array {
-        debug_assert!(self.tag() == TAG_ARRAY || self.tag() >= TAG_ARRAY_SLICE_MIN);
+        debug_assert!(self.is_array());
         self.check_forwarding_pointer();
         self.forward().get_ptr() as *mut Array
     }
@@ -373,14 +384,14 @@ impl Value {
     /// Get the pointer as `Blob` using forwarding. In debug mode panics if the value is not a pointer or the
     /// pointed object is not a `Blob`.
     pub unsafe fn as_blob(self) -> *const Blob {
-        debug_assert_eq!(self.tag(), TAG_BLOB);
+        debug_assert!(self.is_blob());
         self.check_forwarding_pointer();
         self.forward().get_ptr() as *const Blob
     }
 
     /// Get the pointer as mutable `Blob` using forwarding.
     pub unsafe fn as_blob_mut(self) -> *mut Blob {
-        debug_assert_eq!(self.tag(), TAG_BLOB);
+        debug_assert!(self.is_blob());
         self.check_forwarding_pointer();
         self.forward().get_ptr() as *mut Blob
     }
@@ -389,7 +400,7 @@ impl Value {
     /// In debug mode panics if the value is not a pointer or the
     /// pointed object is not a `Blob`.
     pub unsafe fn as_stream(self) -> *mut Stream {
-        debug_assert_eq!(self.tag(), TAG_BLOB);
+        debug_assert!(self.is_blob());
         self.check_forwarding_pointer();
         self.forward().get_ptr() as *mut Stream
     }
@@ -447,21 +458,29 @@ pub type Tag = u32;
 // locations in mark-compact GC. (Reminder: objects and fields are word aligned)
 pub const TAG_OBJECT: Tag = 1;
 pub const TAG_OBJ_IND: Tag = 3;
-pub const TAG_ARRAY: Tag = 5;
-pub const TAG_BITS64: Tag = 7;
-pub const TAG_MUTBOX: Tag = 9;
-pub const TAG_CLOSURE: Tag = 11;
-pub const TAG_SOME: Tag = 13;
-pub const TAG_VARIANT: Tag = 15;
-pub const TAG_BLOB: Tag = 17;
-pub const TAG_FWD_PTR: Tag = 19; // Only used by the copying GC - not to be confused with forwarding pointer in the header used for incremental GC.
-pub const TAG_BITS32: Tag = 21;
-pub const TAG_BIGINT: Tag = 23;
-pub const TAG_CONCAT: Tag = 25;
-pub const TAG_REGION: Tag = 27;
-pub const TAG_NULL: Tag = 29;
-pub const TAG_ONE_WORD_FILLER: Tag = 31;
-pub const TAG_FREE_SPACE: Tag = 33;
+pub const TAG_ARRAY_I: Tag = 5;
+pub const TAG_ARRAY_M: Tag = 7;
+pub const TAG_ARRAY_T: Tag = 9;
+pub const TAG_BITS64_U: Tag = 11;
+pub const TAG_BITS64_S: Tag = 13;
+pub const TAG_BITS64_F: Tag = 15;
+pub const TAG_MUTBOX: Tag = 17;
+pub const TAG_CLOSURE: Tag = 19;
+pub const TAG_SOME: Tag = 21;
+pub const TAG_VARIANT: Tag = 23;
+pub const TAG_BLOB_B: Tag = 25;
+pub const TAG_BLOB_T: Tag = 27;
+pub const TAG_BLOB_P: Tag = 29;
+pub const TAG_FWD_PTR: Tag = 31; // Only used by the copying GC - not to be confused with forwarding pointer in the header used for incremental GC.
+pub const TAG_BITS32_U: Tag = 33;
+pub const TAG_BITS32_S: Tag = 35;
+pub const TAG_BITS32_F: Tag = 37;
+pub const TAG_BIGINT: Tag = 39;
+pub const TAG_CONCAT: Tag = 41;
+pub const TAG_REGION: Tag = 43;
+pub const TAG_NULL: Tag = 45;
+pub const TAG_ONE_WORD_FILLER: Tag = 47;
+pub const TAG_FREE_SPACE: Tag = 49;
 
 // Special value to visit only a range of array fields.
 // This and all values above it are reserved and mean
@@ -469,7 +488,7 @@ pub const TAG_FREE_SPACE: Tag = 33;
 // purposes of `visit_pointer_fields`.
 // Invariant: the value of this (pseudo-)tag must be
 //            higher than all other tags defined above
-pub const TAG_ARRAY_SLICE_MIN: Tag = 34;
+pub const TAG_ARRAY_SLICE_MIN: Tag = 50;
 
 // Common parts of any object. Other object pointers can be coerced into a pointer to this.
 #[repr(C)] // See the note at the beginning of this module
@@ -506,7 +525,9 @@ impl Obj {
     }
 
     pub unsafe fn as_blob(self: *mut Self) -> *mut Blob {
-        debug_assert_eq!(self.tag(), TAG_BLOB);
+        debug_assert!(
+             self.tag() == TAG_BLOB_B || self.tag() == TAG_BLOB_T || self.tag() == TAG_BLOB_P
+        );
         self as *mut Blob
     }
 
@@ -940,13 +961,13 @@ pub(crate) unsafe fn block_size(address: usize) -> Words<u32> {
 
         // `block_size` is not used during the incremental mark phase and
         // therefore, does not support array slicing.
-        TAG_ARRAY => {
+        TAG_ARRAY_I | TAG_ARRAY_M | TAG_ARRAY_T => {
             let array = address as *mut Array;
             let size = array.len();
             size_of::<Array>() + Words(size)
         }
 
-        TAG_BITS64 => size_of::<Bits64>(),
+        TAG_BITS64_U | TAG_BITS64_S | TAG_BITS64_F => size_of::<Bits64>(),
 
         TAG_MUTBOX => size_of::<MutBox>(),
 
@@ -960,7 +981,7 @@ pub(crate) unsafe fn block_size(address: usize) -> Words<u32> {
 
         TAG_VARIANT => size_of::<Variant>(),
 
-        TAG_BLOB => {
+        TAG_BLOB_B | TAG_BLOB_T | TAG_BLOB_P => {
             let blob = address as *mut Blob;
             size_of::<Blob>() + blob.len().to_words()
         }
@@ -969,7 +990,7 @@ pub(crate) unsafe fn block_size(address: usize) -> Words<u32> {
             rts_trap_with("object_size: forwarding pointer");
         }
 
-        TAG_BITS32 => size_of::<Bits32>(),
+        TAG_BITS32_U | TAG_BITS32_S | TAG_BITS32_F => size_of::<Bits32>(),
 
         TAG_BIGINT => {
             let bigint = address as *mut BigInt;
diff --git a/rts/motoko-rts/src/visitor.rs b/rts/motoko-rts/src/visitor.rs
index a06370b2405..2a750a48e68 100644
--- a/rts/motoko-rts/src/visitor.rs
+++ b/rts/motoko-rts/src/visitor.rs
@@ -43,7 +43,8 @@ pub unsafe fn visit_pointer_fields<C, F, G>(
             }
         }
 
-        TAG_ARRAY | TAG_ARRAY_SLICE_MIN.. => {
+        TAG_ARRAY_I | TAG_ARRAY_M | TAG_ARRAY_T
+            | TAG_ARRAY_SLICE_MIN.. => {
             let slice_start = if tag >= TAG_ARRAY_SLICE_MIN { tag } else { 0 };
             let array = obj as *mut Array;
             let array_payload = array.payload_addr();
@@ -120,7 +121,10 @@ pub unsafe fn visit_pointer_fields<C, F, G>(
             }
         }
 
-        TAG_BITS64 | TAG_BITS32 | TAG_BLOB | TAG_BIGINT => {
+        | TAG_BITS32_U | TAG_BITS32_S | TAG_BITS32_F
+        | TAG_BITS64_U | TAG_BITS64_S | TAG_BITS64_F
+        | TAG_BLOB_B | TAG_BLOB_T | TAG_BLOB_P
+        | TAG_BIGINT => {
             // These don't have pointers, skip
         }
 

From cc85f8091f6ccc9ade44c2a4da048d42d0e58896 Mon Sep 17 00:00:00 2001
From: Claudio Russo <claudio@dfinity.org>
Date: Fri, 17 May 2024 18:43:32 +0100
Subject: [PATCH 211/260] used correct tags in compile.ml

---
 src/codegen/compile.ml | 40 ++++++++++++++++++++++++----------------
 1 file changed, 24 insertions(+), 16 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index abb61b3d141..8434f4dba40 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -2030,22 +2030,30 @@ module Tagged = struct
   let int_of_tag = function
     | Object -> 1l
     | ObjInd -> 3l
-    | Array _ -> 5l
-    | Bits64 _ -> 7l
-    | MutBox -> 9l
-    | Closure -> 11l
-    | Some -> 13l
-    | Variant -> 15l
-    | Blob _ -> 17l
-    | Indirection -> 19l
-    | Bits32 _ -> 21l
-    | BigInt -> 23l
-    | Concat -> 25l
-    | Region -> 27l
-    | Null -> 29l
-    | OneWordFiller -> 31l
-    | FreeSpace -> 33l
-    | ArraySliceMinimum -> 34l
+    | Array I -> 5l
+    | Array M -> 7l
+    | Array T -> 9l
+    | Bits64 U -> 11l
+    | Bits64 S -> 13l
+    | Bits64 F -> 15l
+    | MutBox -> 17l
+    | Closure -> 19l
+    | Some -> 21l
+    | Variant -> 23l
+    | Blob B -> 25l
+    | Blob T -> 27l
+    | Blob P -> 29l
+    | Indirection -> 31l
+    | Bits32 U -> 33l
+    | Bits32 S -> 35l
+    | Bits32 F -> 37l
+    | BigInt -> 39l
+    | Concat -> 41l
+    | Region -> 43l
+    | Null -> 45l
+    | OneWordFiller -> 47l
+    | FreeSpace -> 49l
+    | ArraySliceMinimum -> 50l
     (* Next two tags won't be seen by the GC, so no need to set the lowest bit
        for `CoercionFailure` and `StableSeen` *)
     | CoercionFailure -> 0xfffffffel

From 8430baa9fdfb783d3cccdcb7a3b50963bcf4a16f Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Wed, 22 May 2024 14:33:28 +0200
Subject: [PATCH 212/260] Optimization

---
 src/codegen/compile.ml | 21 ++++++++-------------
 1 file changed, 8 insertions(+), 13 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 16baeb48d64..2ab2f687d48 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -3001,7 +3001,7 @@ sig
   (* word from SR.Vanilla, trapping, unsigned semantics *)
   val to_word32 : E.t -> G.t
   val to_word64 : E.t -> G.t
-  val to_word32_with : E.t -> G.t (* with error message on stack (ptr/len) *)
+  val to_word32_with : E.t -> G.t -> G.t (* with error message on stack (ptr/len) *)
 
   (* word from SR.Vanilla, lossy, raw bits *)
   val truncate_to_word32 : E.t -> G.t
@@ -3677,21 +3677,19 @@ module MakeCompact (Num : BigNumType) : BigNumType = struct
       (get_a ^^ BitTagged.untag_i32 __LINE__ env Type.Int) (*TBR*)
       (get_a ^^ Num.to_word32 env)
 
-  let to_word32_with env =
+  let to_word32_with env get_err_msg =
     let set_a, get_a = new_local env "a" in
-    let set_err_msg, get_err_msg = new_local env "err_msg" in
-    set_err_msg ^^ set_a ^^
-    get_a ^^
+    set_a ^^ get_a ^^
     BitTagged.if_tagged_scalar env [I32Type]
       (get_a ^^ BitTagged.untag_i32 __LINE__ env Type.Int) (* TBR *)
-      (get_a ^^ get_err_msg ^^ Num.to_word32_with env)
+      (get_a ^^ Num.to_word32_with env get_err_msg)
 end
 
 module BigNumLibtommath : BigNumType = struct
 
   let to_word32 env = E.call_import env "rts" "bigint_to_word32_trap"
   let to_word64 env = E.call_import env "rts" "bigint_to_word64_trap"
-  let to_word32_with env = E.call_import env "rts" "bigint_to_word32_trap_with"
+  let to_word32_with env get_err_msg = get_err_msg ^^ E.call_import env "rts" "bigint_to_word32_trap_with"
 
   let truncate_to_word32 env = E.call_import env "rts" "bigint_to_word32_wrap"
   let truncate_to_word64 env = E.call_import env "rts" "bigint_to_word64_wrap"
@@ -4460,8 +4458,7 @@ module Arr = struct
     Func.share_code2 Func.Never env "Array.idx_bigint" (("array", I32Type), ("idx", I32Type)) [I32Type] (fun env get_array get_idx ->
       get_array ^^
       get_idx ^^
-      Blob.lit env "Array index out of bounds" ^^
-      BigNum.to_word32_with env ^^
+      BigNum.to_word32_with env (Blob.lit env "Array index out of bounds") ^^
       idx env
   )
 
@@ -11117,8 +11114,7 @@ and compile_prim_invocation (env : E.t) ae p es at =
     compile_exp_as env ae SR.Vanilla e0 ^^
     compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
     compile_exp_as env ae SR.Vanilla e2 ^^
-    Blob.lit env "Blob size out of bounds" ^^
-    BigNum.to_word32_with env ^^
+    BigNum.to_word32_with env (Blob.lit env "Blob size out of bounds") ^^
     Region.load_blob env
 
   | OtherPrim ("regionStoreBlob"), [e0; e1; e2] ->
@@ -11454,8 +11450,7 @@ and compile_prim_invocation (env : E.t) ae p es at =
     SR.Vanilla,
     compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
     compile_exp_as env ae SR.Vanilla e2 ^^
-    Blob.lit env "Blob size out of bounds" ^^
-    BigNum.to_word32_with env ^^
+    BigNum.to_word32_with env (Blob.lit env "Blob size out of bounds") ^^
     StableMemoryInterface.load_blob env
 
   | OtherPrim "stableMemoryStoreBlob", [e1; e2] ->

From bdf39b04e264cf8076d3c81d4451e6a9f7b2512d Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Wed, 22 May 2024 15:05:14 +0200
Subject: [PATCH 213/260] Update benchmark result

---
 test/bench/ok/bignum.drun-run.ok | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/bench/ok/bignum.drun-run.ok b/test/bench/ok/bignum.drun-run.ok
index 1866c3af1b3..5a8de38cd74 100644
--- a/test/bench/ok/bignum.drun-run.ok
+++ b/test/bench/ok/bignum.drun-run.ok
@@ -1,6 +1,6 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 2_626_994; size = +60_128}
+debug.print: {cycles = 2_626_730; size = +60_128}
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 107_960_744; size = +1_826_952}
+debug.print: {cycles = 107_960_480; size = +1_826_952}
 ingress Completed: Reply: 0x4449444c0000

From 99b2985c9b3435680efb24a8c09f2fd0f2a71a05 Mon Sep 17 00:00:00 2001
From: Claudio Russo <claudio@dfinity.org>
Date: Sat, 18 May 2024 00:59:53 +0100
Subject: [PATCH 214/260] ugly attempt to tag allocations

---
 .../src/continuation_table.rs                 |  4 +-
 .../src/gc/incremental/array_slicing.rs       |  2 +-
 .../src/gc/incremental/partitioned_heap.rs    |  6 +--
 rts/motoko-rts/src/allocator.rs               |  4 +-
 rts/motoko-rts/src/continuation_table.rs      |  6 +--
 .../src/gc/generational/mark_stack.rs         |  4 +-
 .../src/gc/generational/sanity_checks.rs      |  2 +-
 .../src/gc/incremental/mark_stack.rs          |  4 +-
 rts/motoko-rts/src/gc/mark_compact/bitmap.rs  |  4 +-
 .../src/gc/mark_compact/mark_stack.rs         |  4 +-
 rts/motoko-rts/src/gc/remembered_set.rs       |  6 +--
 rts/motoko-rts/src/idl.rs                     |  4 +-
 rts/motoko-rts/src/memory.rs                  |  8 ++--
 rts/motoko-rts/src/principal_id.rs            | 10 ++---
 rts/motoko-rts/src/region.rs                  | 11 ++---
 rts/motoko-rts/src/stream.rs                  |  2 +-
 rts/motoko-rts/src/text.rs                    |  8 ++--
 rts/motoko-rts/src/text_iter.rs               |  6 +--
 src/codegen/compile.ml                        | 43 +++++++++++--------
 19 files changed, 74 insertions(+), 64 deletions(-)

diff --git a/rts/motoko-rts-tests/src/continuation_table.rs b/rts/motoko-rts-tests/src/continuation_table.rs
index 877eb4714c7..9a152e0524b 100644
--- a/rts/motoko-rts-tests/src/continuation_table.rs
+++ b/rts/motoko-rts-tests/src/continuation_table.rs
@@ -6,7 +6,7 @@ use motoko_rts::continuation_table::{
     continuation_count, recall_continuation, remember_continuation,
 };
 use motoko_rts::memory::alloc_blob;
-use motoko_rts::types::{size_of, Array, Blob, Bytes, Value, Words};
+use motoko_rts::types::{size_of, Array, Blob, Bytes, Value, Words, TAG_BLOB_B};
 
 pub unsafe fn test() {
     println!("Testing continuation table ...");
@@ -22,7 +22,7 @@ pub unsafe fn test() {
             + N as u32 * size_of::<Blob>().to_bytes().as_u32(),
     ));
 
-    let pointers: [Value; N] = from_fn(|_| alloc_blob(&mut heap, Bytes(0)));
+    let pointers: [Value; N] = from_fn(|_| alloc_blob(&mut heap, TAB_BLOB_B, Bytes(0)));
 
     let mut references: [u32; N] = [0; N];
     for i in 0..N {
diff --git a/rts/motoko-rts-tests/src/gc/incremental/array_slicing.rs b/rts/motoko-rts-tests/src/gc/incremental/array_slicing.rs
index 956e856e62c..8c5ca19dea2 100644
--- a/rts/motoko-rts-tests/src/gc/incremental/array_slicing.rs
+++ b/rts/motoko-rts-tests/src/gc/incremental/array_slicing.rs
@@ -21,7 +21,7 @@ pub unsafe fn test() {
 }
 
 unsafe fn test_array_slicing(mem: &mut TestMemory, array_length: u32) {
-    let array = alloc_array(mem, array_length).as_array();
+    let array = alloc_array(mem, TAG_ARRAY_M, array_length).as_array();
     let mut last_offset = 0;
     loop {
         let new_offset = slice_array(array);
diff --git a/rts/motoko-rts-tests/src/gc/incremental/partitioned_heap.rs b/rts/motoko-rts-tests/src/gc/incremental/partitioned_heap.rs
index f98bdf66408..ace2b2b3e0c 100644
--- a/rts/motoko-rts-tests/src/gc/incremental/partitioned_heap.rs
+++ b/rts/motoko-rts-tests/src/gc/incremental/partitioned_heap.rs
@@ -13,7 +13,7 @@ use motoko_rts::{
         time::BoundedTime,
     },
     memory::{alloc_array, alloc_blob, Memory},
-    types::{Array, Blob, Bytes, Obj, Tag, Value, Words, TAG_ARRAY, TAG_BLOB},
+    types::{Array, Blob, Bytes, Obj, Tag, Value, Words, TAG_ARRAY_M, TAG_BLOB_B},
 };
 
 use crate::{gc::utils::WORD_SIZE, memory::TestMemory};
@@ -396,7 +396,7 @@ impl PartitionedTestHeap {
 
     pub fn allocate_array(&mut self, elements: &[Value]) -> Value {
         unsafe {
-            let array = alloc_array(self, elements.len() as u32);
+            let array = alloc_array(self, TAG_ARRAY_M, elements.len() as u32);
             for index in 0..elements.len() {
                 let raw_array = array.as_array();
                 raw_array.set_scalar(index as u32, elements[index]);
@@ -406,7 +406,7 @@ impl PartitionedTestHeap {
     }
 
     pub fn allocate_blob(&mut self, size: usize) -> Value {
-        unsafe { alloc_blob(self, Bytes(size as u32)) }
+        unsafe { alloc_blob(self, TAG_BLOB_B, Bytes(size as u32)) }
     }
 }
 
diff --git a/rts/motoko-rts/src/allocator.rs b/rts/motoko-rts/src/allocator.rs
index f460265ae77..d09da81629e 100644
--- a/rts/motoko-rts/src/allocator.rs
+++ b/rts/motoko-rts/src/allocator.rs
@@ -3,7 +3,7 @@
 use alloc::alloc::{GlobalAlloc, Layout};
 //use core::ptr::null_mut;
 use crate::memory::{alloc_blob, ic};
-use crate::types::Bytes;
+use crate::types::{Bytes, TAG_BLOB_B};
 
 pub struct EphemeralAllocator;
 
@@ -24,7 +24,7 @@ unsafe impl GlobalAlloc for EphemeralAllocator {
         let min_align = (align + word_size - 1) / word_size * word_size;
         let blob_size = size + min_align - word_size;
         let blob =
-            alloc_blob::<ic::IcMemory>(&mut ic::IcMemory, Bytes(blob_size as u32)).as_blob_mut();
+            alloc_blob::<ic::IcMemory>(&mut ic::IcMemory, TAG_BLOB_B, Bytes(blob_size as u32)).as_blob_mut();
         let payload_address = blob.payload_addr() as usize;
         let aligned_address = (payload_address + min_align - 1) / min_align * min_align;
 
diff --git a/rts/motoko-rts/src/continuation_table.rs b/rts/motoko-rts/src/continuation_table.rs
index b0be5f4dbda..d162d6278b3 100644
--- a/rts/motoko-rts/src/continuation_table.rs
+++ b/rts/motoko-rts/src/continuation_table.rs
@@ -25,7 +25,7 @@
 use crate::barriers::allocation_barrier;
 use crate::memory::{alloc_array, Memory};
 use crate::rts_trap_with;
-use crate::types::Value;
+use crate::types::{Value, TAG_ARRAY_M};
 
 use motoko_rts_macros::ic_mem_fn;
 
@@ -42,7 +42,7 @@ static mut N_CONTINUATIONS: u32 = 0;
 static mut FREE_SLOT: u32 = 0;
 
 unsafe fn create_continuation_table<M: Memory>(mem: &mut M) {
-    TABLE = alloc_array(mem, INITIAL_SIZE);
+    TABLE = alloc_array(mem, TAG_ARRAY_M,  INITIAL_SIZE);
     FREE_SLOT = 0;
     N_CONTINUATIONS = 0;
 
@@ -61,7 +61,7 @@ unsafe fn double_continuation_table<M: Memory>(mem: &mut M) {
 
     let new_size = old_size * 2;
 
-    TABLE = alloc_array(mem, new_size);
+    TABLE = alloc_array(mem, TAG_ARRAY_M, new_size);
     let new_array = TABLE.as_array();
 
     for i in 0..old_size {
diff --git a/rts/motoko-rts/src/gc/generational/mark_stack.rs b/rts/motoko-rts/src/gc/generational/mark_stack.rs
index 3bc6134e533..7515fe7cb36 100644
--- a/rts/motoko-rts/src/gc/generational/mark_stack.rs
+++ b/rts/motoko-rts/src/gc/generational/mark_stack.rs
@@ -2,7 +2,7 @@
 //! Simplified to only store object pointers without tags.
 
 use crate::memory::{alloc_blob, Memory};
-use crate::types::{Blob, Words};
+use crate::types::{Blob, Words, TAG_BLOB_B};
 
 use core::ptr::null_mut;
 
@@ -27,7 +27,7 @@ pub unsafe fn alloc_mark_stack<M: Memory>(mem: &mut M) {
 
     // Allocating an actual object here to not break dump_heap
     // No post allocation barrier as this RTS-internal blob will be collected by the GC.
-    STACK_BLOB_PTR = alloc_blob(mem, INIT_STACK_SIZE.to_bytes()).get_ptr() as *mut Blob;
+    STACK_BLOB_PTR = alloc_blob(mem, TAG_BLOB_B, INIT_STACK_SIZE.to_bytes()).get_ptr() as *mut Blob;
     STACK_BASE = STACK_BLOB_PTR.payload_addr() as *mut usize;
     STACK_PTR = STACK_BASE;
     STACK_TOP = STACK_BASE.add(INIT_STACK_SIZE.as_usize());
diff --git a/rts/motoko-rts/src/gc/generational/sanity_checks.rs b/rts/motoko-rts/src/gc/generational/sanity_checks.rs
index 2fd5531af9b..5786b47cc8a 100644
--- a/rts/motoko-rts/src/gc/generational/sanity_checks.rs
+++ b/rts/motoko-rts/src/gc/generational/sanity_checks.rs
@@ -18,7 +18,7 @@ static mut SNAPSHOT: *mut Blob = null_mut();
 pub unsafe fn take_snapshot<M: Memory>(heap: &mut Heap<M>) {
     let length = Bytes(heap.limits.free as u32);
     // No post allocation barrier as this RTS-internal blob will be collected by the GC.
-    let blob = alloc_blob(heap.mem, length).get_ptr() as *mut Blob;
+    let blob = alloc_blob(heap.mem, TAG_BLOB_B, length).get_ptr() as *mut Blob;
     memcpy_bytes(blob.payload_addr() as usize, 0, length);
     SNAPSHOT = blob;
 }
diff --git a/rts/motoko-rts/src/gc/incremental/mark_stack.rs b/rts/motoko-rts/src/gc/incremental/mark_stack.rs
index b5d249c7245..6a78a702cd2 100644
--- a/rts/motoko-rts/src/gc/incremental/mark_stack.rs
+++ b/rts/motoko-rts/src/gc/incremental/mark_stack.rs
@@ -29,7 +29,7 @@
 use core::ptr::null_mut;
 
 use crate::memory::{alloc_blob, Memory};
-use crate::types::{size_of, Blob, Value};
+use crate::types::{size_of, Blob, Value, TAG_BLOB_B};
 
 pub struct MarkStack {
     last: *mut StackTable,
@@ -97,7 +97,7 @@ impl MarkStack {
     unsafe fn new_table<M: Memory>(mem: &mut M, previous: *mut StackTable) -> *mut StackTable {
         // No post allocation barrier as this RTS-internal blob will be collected by the GC.
         let table =
-            alloc_blob(mem, size_of::<StackTable>().to_bytes()).as_blob_mut() as *mut StackTable;
+            alloc_blob(mem, TAG_BLOB_B, size_of::<StackTable>().to_bytes()).as_blob_mut() as *mut StackTable;
         (*table).previous = previous;
         (*table).next = null_mut();
         if previous != null_mut() {
diff --git a/rts/motoko-rts/src/gc/mark_compact/bitmap.rs b/rts/motoko-rts/src/gc/mark_compact/bitmap.rs
index dc86885489a..d3b5848cf7e 100644
--- a/rts/motoko-rts/src/gc/mark_compact/bitmap.rs
+++ b/rts/motoko-rts/src/gc/mark_compact/bitmap.rs
@@ -1,6 +1,6 @@
 use crate::mem_utils::memzero;
 use crate::memory::{alloc_blob, Memory};
-use crate::types::{size_of, Blob, Bytes, Obj};
+use crate::types::{size_of, Blob, Bytes, Obj, TAG_BLOB_B};
 
 /* How the Wasm-heap maps to the bitmap
 
@@ -78,7 +78,7 @@ pub unsafe fn alloc_bitmap<M: Memory>(mem: &mut M, heap_size: Bytes<u32>, heap_p
     let bitmap_bytes = Bytes(((BITMAP_SIZE + 7) / 8) * 8);
     // Allocating an actual object here as otherwise dump_heap gets confused
     // No post allocation barrier as this RTS-internal blob will be collected by the GC.
-    let blob = alloc_blob(mem, bitmap_bytes).get_ptr() as *mut Blob;
+    let blob = alloc_blob(mem, TAG_BLOB_B, bitmap_bytes).get_ptr() as *mut Blob;
     memzero(blob.payload_addr() as usize, bitmap_bytes.to_words());
 
     BITMAP_PTR = blob.payload_addr();
diff --git a/rts/motoko-rts/src/gc/mark_compact/mark_stack.rs b/rts/motoko-rts/src/gc/mark_compact/mark_stack.rs
index 990cf32ff25..a419e3e9c4a 100644
--- a/rts/motoko-rts/src/gc/mark_compact/mark_stack.rs
+++ b/rts/motoko-rts/src/gc/mark_compact/mark_stack.rs
@@ -2,7 +2,7 @@
 //! otherwise things will break as we push. This invariant is checked in debug builds.
 
 use crate::memory::{alloc_blob, Memory};
-use crate::types::{Blob, Tag, Words};
+use crate::types::{Blob, Tag, Words, TAG_BLOB_B};
 
 use core::ptr::null_mut;
 
@@ -26,7 +26,7 @@ pub unsafe fn alloc_mark_stack<M: Memory>(mem: &mut M) {
 
     // Allocating an actual object here to not break dump_heap
     // No post allocation barrier as this RTS-internal blob will be collected by the GC.
-    STACK_BLOB_PTR = alloc_blob(mem, INIT_STACK_SIZE.to_bytes()).get_ptr() as *mut Blob;
+    STACK_BLOB_PTR = alloc_blob(mem, TAG_BLOB_B, INIT_STACK_SIZE.to_bytes()).get_ptr() as *mut Blob;
     STACK_BASE = STACK_BLOB_PTR.payload_addr() as *mut usize;
     STACK_PTR = STACK_BASE;
     STACK_TOP = STACK_BASE.add(INIT_STACK_SIZE.as_usize());
diff --git a/rts/motoko-rts/src/gc/remembered_set.rs b/rts/motoko-rts/src/gc/remembered_set.rs
index 03c1cdc13a0..fe7d08a50f8 100644
--- a/rts/motoko-rts/src/gc/remembered_set.rs
+++ b/rts/motoko-rts/src/gc/remembered_set.rs
@@ -38,7 +38,7 @@ use core::ptr::null_mut;
 
 use crate::constants::WORD_SIZE;
 use crate::memory::{alloc_blob, Memory};
-use crate::types::{block_size, Blob, Bytes, Value};
+use crate::types::{block_size, Blob, Bytes, TAG_BLOB_B, Value};
 
 pub struct RememberedSet {
     hash_table: *mut Blob,
@@ -224,7 +224,7 @@ impl RememberedSetIterator {
 
 unsafe fn new_table<M: Memory>(mem: &mut M, size: u32) -> *mut Blob {
     // No post allocation barrier as this RTS-internal blob will be collected by the GC.
-    let table = alloc_blob(mem, Bytes(size * size_of::<HashEntry>() as u32)).as_blob_mut();
+    let table = alloc_blob(mem, TAG_BLOB_B, Bytes(size * size_of::<HashEntry>() as u32)).as_blob_mut();
     for index in 0..size {
         table_set(table, index, null_ptr_value());
     }
@@ -235,7 +235,7 @@ unsafe fn new_collision_node<M: Memory>(mem: &mut M, value: Value) -> *mut Colli
     debug_assert!(!is_null_ptr_value(value));
     // No post allocation barrier as this RTS-internal blob will be collected by the GC.
     let node =
-        alloc_blob(mem, Bytes(size_of::<HashEntry>() as u32)).as_blob_mut() as *mut CollisionNode;
+        alloc_blob(mem, TAG_BLOB_B, Bytes(size_of::<HashEntry>() as u32)).as_blob_mut() as *mut CollisionNode;
     (*node).entry = HashEntry {
         value,
         next_collision_ptr: null_mut(),
diff --git a/rts/motoko-rts/src/idl.rs b/rts/motoko-rts/src/idl.rs
index 21378c4a384..db0d3ef469b 100644
--- a/rts/motoko-rts/src/idl.rs
+++ b/rts/motoko-rts/src/idl.rs
@@ -4,7 +4,7 @@ use crate::buf::{read_byte, read_word, skip_leb128, Buf};
 use crate::idl_trap_with;
 use crate::leb128::{leb128_decode, sleb128_decode};
 use crate::memory::{alloc_blob, Memory};
-use crate::types::Words;
+use crate::types::{Words, TAG_BLOB_B};
 use crate::utf8::utf8_validate;
 
 use core::cmp::min;
@@ -101,7 +101,7 @@ unsafe fn parse_fields(extended: bool, buf: *mut Buf, n_types: u32) {
 // NB. This function assumes the allocation does not need to survive GC
 // Therefore, no post allocation barrier is applied.
 unsafe fn alloc<M: Memory>(mem: &mut M, size: Words<u32>) -> *mut u8 {
-    alloc_blob(mem, size.to_bytes())
+    alloc_blob(mem, TAG_BLOB_B, size.to_bytes())
         .as_blob_mut()
         .payload_addr()
 }
diff --git a/rts/motoko-rts/src/memory.rs b/rts/motoko-rts/src/memory.rs
index cc3a8e18b32..fed09c4218e 100644
--- a/rts/motoko-rts/src/memory.rs
+++ b/rts/motoko-rts/src/memory.rs
@@ -45,11 +45,11 @@ pub trait Memory {
 /// Note: After initialization, the post allocation barrier needs to be applied to all mutator objects.
 /// For RTS-internal blobs that can be collected by the next GC run, the post allocation barrier can be omitted.
 #[ic_mem_fn]
-pub unsafe fn alloc_blob<M: Memory>(mem: &mut M, size: Bytes<u32>) -> Value {
+pub unsafe fn alloc_blob<M: Memory>(mem: &mut M, tag: u32, size: Bytes<u32>) -> Value {
     let ptr = mem.alloc_words(size_of::<Blob>() + size.to_words());
     // NB. Cannot use `as_blob` here as we didn't write the header yet
     let blob = ptr.get_ptr() as *mut Blob;
-    (*blob).header.tag = TAG_BLOB_B;
+    (*blob).header.tag = tag;
     (*blob).header.init_forward(ptr);
     (*blob).len = size;
 
@@ -59,7 +59,7 @@ pub unsafe fn alloc_blob<M: Memory>(mem: &mut M, size: Bytes<u32>) -> Value {
 /// Allocate a new array.
 /// Note: After initialization, the post allocation barrier needs to be applied to all mutator objects.
 #[ic_mem_fn]
-pub unsafe fn alloc_array<M: Memory>(mem: &mut M, len: u32) -> Value {
+pub unsafe fn alloc_array<M: Memory>(mem: &mut M, tag: u32, len: u32) -> Value {
     // Array payload should not be larger than half of the memory
     if len > MAX_ARRAY_SIZE {
         rts_trap_with("Array allocation too large");
@@ -68,7 +68,7 @@ pub unsafe fn alloc_array<M: Memory>(mem: &mut M, len: u32) -> Value {
     let skewed_ptr = mem.alloc_words(size_of::<Array>() + Words(len));
 
     let ptr: *mut Array = skewed_ptr.get_ptr() as *mut Array;
-    (*ptr).header.tag = TAG_ARRAY_M;
+    (*ptr).header.tag = tag;
     (*ptr).header.init_forward(skewed_ptr);
     (*ptr).len = len;
 
diff --git a/rts/motoko-rts/src/principal_id.rs b/rts/motoko-rts/src/principal_id.rs
index dfc21faf21a..0d08ed7dfe5 100644
--- a/rts/motoko-rts/src/principal_id.rs
+++ b/rts/motoko-rts/src/principal_id.rs
@@ -5,7 +5,7 @@ use crate::mem_utils::memcpy_bytes;
 use crate::memory::{alloc_blob, Memory};
 use crate::rts_trap_with;
 use crate::text::{blob_compare, blob_of_text};
-use crate::types::{Bytes, Value, TAG_BLOB_B};
+use crate::types::{Bytes, Value, TAG_BLOB_B, TAG_BLOB_P, TAG_BLOB_T};
 
 use motoko_rts_macros::ic_mem_fn;
 
@@ -98,7 +98,7 @@ pub unsafe fn base32_of_checksummed_blob<M: Memory>(mem: &mut M, b: Value) -> Va
     let n = b.as_blob().len();
     let mut data = b.as_blob().payload_const();
 
-    let r = alloc_blob(mem, Bytes((n.as_u32() + 4 + 4) / 5 * 8)); // contains padding
+    let r = alloc_blob(mem, TAG_BLOB_P, Bytes((n.as_u32() + 4 + 4) / 5 * 8)); // contains padding
     let blob = r.as_blob_mut();
     let dest = blob.payload_addr();
 
@@ -185,7 +185,7 @@ pub unsafe fn base32_to_blob<M: Memory>(mem: &mut M, b: Value) -> Value {
     let mut data = b.as_blob().payload_const();
 
     // Every group of 8 characters will yield 5 bytes
-    let r = alloc_blob(mem, Bytes(((n.as_u32() + 7) / 8) * 5)); // we deal with padding later
+    let r = alloc_blob(mem, TAG_BLOB_T, Bytes(((n.as_u32() + 7) / 8) * 5)); // we deal with padding later
     let blob = r.as_blob_mut();
     let dest = blob.payload_addr();
 
@@ -225,7 +225,7 @@ unsafe fn base32_to_principal<M: Memory>(mem: &mut M, b: Value) -> Value {
     let mut data = blob.payload_const();
 
     // Every group of 5 characters will yield 6 bytes (due to the hypen)
-    let r = alloc_blob(mem, Bytes(((n.as_u32() + 4) / 5) * 6));
+    let r = alloc_blob(mem, TAG_BLOB_T, Bytes(((n.as_u32() + 4) / 5) * 6));
     let blob = r.as_blob_mut();
     let mut dest = blob.payload_addr();
 
@@ -269,7 +269,7 @@ pub unsafe fn blob_of_principal<M: Memory>(mem: &mut M, t: Value) -> Value {
         rts_trap_with("blob_of_principal: principal too short");
     }
 
-    let stripped = alloc_blob(mem, bytes_len - Bytes(4));
+    let stripped = alloc_blob(mem, TAG_BLOB_B, bytes_len - Bytes(4));
     memcpy_bytes(
         stripped.as_blob_mut().payload_addr() as usize,
         bytes.as_blob().payload_const().add(4) as usize,
diff --git a/rts/motoko-rts/src/region.rs b/rts/motoko-rts/src/region.rs
index 566ff6848d2..07852e6e04e 100644
--- a/rts/motoko-rts/src/region.rs
+++ b/rts/motoko-rts/src/region.rs
@@ -1,7 +1,7 @@
 use crate::barriers::{allocation_barrier, init_with_barrier, write_with_barrier};
 use crate::memory::{alloc_blob, Memory};
 use crate::trap_with_prefix;
-use crate::types::{size_of, Blob, Bytes, Region, Value, TAG_REGION};
+use crate::types::{size_of, Blob, Bytes, Region, Value, TAG_REGION, TAG_BLOB_B};
 
 // Versions
 // Should agree with constants StableMem.version_no_stable_memory etc. in compile.ml
@@ -490,7 +490,7 @@ pub unsafe fn region_new<M: Memory>(mem: &mut M) -> Value {
 
     meta_data::total_allocated_regions::set(next_id + 1);
 
-    let vec_pages = alloc_blob(mem, Bytes(0));
+    let vec_pages = alloc_blob(mem, TAG_BLOB_B, Bytes(0));
     allocation_barrier(vec_pages);
     let r_ptr = alloc_region(mem, next_id, 0, vec_pages);
 
@@ -524,7 +524,7 @@ pub unsafe fn region_recover<M: Memory>(mem: &mut M, rid: &RegionId) -> Value {
     debug_assert!(page_count < (u32::MAX - (PAGES_IN_BLOCK - 1)));
 
     let block_count = (page_count + PAGES_IN_BLOCK - 1) / PAGES_IN_BLOCK;
-    let vec_pages = alloc_blob(mem, Bytes(block_count * bytes_of::<u16>() as u32));
+    let vec_pages = alloc_blob(mem, TAG_BLOB_B, Bytes(block_count * bytes_of::<u16>() as u32));
 
     let av = AccessVector(vec_pages.as_blob_mut());
     let mut recovered_blocks = 0;
@@ -659,7 +659,7 @@ pub(crate) unsafe fn region_migration_from_some_stable_memory<M: Memory>(mem: &m
     // Temp for the head block, which we move to be physically last.
     // NB: no allocation_barrier is required: header_val is temporary and can be reclaimed by the next GC increment/run.
     // TODO: instead of allocating an 8MB blob, just stack-allocate a tmp page and zero page, and transfer/zero-init via the stack, using a loop.
-    let header_val = crate::memory::alloc_blob(mem, crate::types::Bytes(header_len));
+    let header_val = crate::memory::alloc_blob(mem, TAG_BLOB_B, crate::types::Bytes(header_len));
     let header_blob = header_val.as_blob_mut();
     let header_bytes =
         core::slice::from_raw_parts_mut(header_blob.payload_addr(), header_len as usize);
@@ -855,6 +855,7 @@ pub unsafe fn region_grow<M: Memory>(mem: &mut M, r: Value, new_pages: u64) -> u
 
     let new_vec_pages = alloc_blob(
         mem,
+        TAG_BLOB_B,
         Bytes(new_block_count * meta_data::bytes_of::<u16>() as u32),
     );
     let old_vec_byte_count = old_block_count * meta_data::bytes_of::<u16>() as u32;
@@ -1042,7 +1043,7 @@ pub(crate) unsafe fn region_load_blob<M: Memory>(
     offset: u64,
     len: u32,
 ) -> Value {
-    let blob_val = crate::memory::alloc_blob(mem, crate::types::Bytes(len));
+    let blob_val = crate::memory::alloc_blob(mem, TAG_BLOB_B, crate::types::Bytes(len));
     let blob = blob_val.as_blob_mut();
 
     if len < (isize::MAX as u32) {
diff --git a/rts/motoko-rts/src/stream.rs b/rts/motoko-rts/src/stream.rs
index 0317ae2dce7..b756caac007 100644
--- a/rts/motoko-rts/src/stream.rs
+++ b/rts/motoko-rts/src/stream.rs
@@ -55,7 +55,7 @@ pub unsafe fn alloc_stream<M: Memory>(mem: &mut M, size: Bytes<u32>) -> *mut Str
     if size > MAX_STREAM_SIZE {
         rts_trap_with("alloc_stream: Cache too large");
     }
-    let ptr = alloc_blob(mem, size + INITIAL_STREAM_FILLED);
+    let ptr = alloc_blob(mem, TAG_BLOB_B, size + INITIAL_STREAM_FILLED);
     let stream = ptr.as_stream();
     stream.write_ptr64(0);
     stream.write_start64(0);
diff --git a/rts/motoko-rts/src/text.rs b/rts/motoko-rts/src/text.rs
index 1f58f8fa347..c0bc6c53c63 100644
--- a/rts/motoko-rts/src/text.rs
+++ b/rts/motoko-rts/src/text.rs
@@ -30,7 +30,7 @@ use crate::barriers::allocation_barrier;
 use crate::mem_utils::memcpy_bytes;
 use crate::memory::{alloc_blob, Memory};
 use crate::rts_trap_with;
-use crate::types::{size_of, Blob, Bytes, Concat, Stream, Value, TAG_BLOB_T, TAG_CONCAT};
+use crate::types::{size_of, Blob, Bytes, Concat, Stream, Value, TAG_BLOB_T, TAG_BLOB_B, TAG_BLOB_P, TAG_CONCAT};
 
 use alloc::string::String;
 use core::cmp::{min, Ordering};
@@ -49,7 +49,7 @@ unsafe fn alloc_text_blob<M: Memory>(mem: &mut M, size: Bytes<u32>) -> Value {
     if size > MAX_STR_SIZE {
         rts_trap_with("alloc_text_blob: Text too large");
     }
-    alloc_blob(mem, size)
+    alloc_blob(mem, TAG_BLOB_T, size)
 }
 
 #[ic_mem_fn]
@@ -188,7 +188,7 @@ unsafe extern "C" fn stream_write_text(stream: *mut Stream, mut s: Value) {
 #[ic_mem_fn]
 pub unsafe fn blob_of_text<M: Memory>(mem: &mut M, s: Value) -> Value {
     let obj = s.as_obj();
-    if obj.tag() == TAG_BLOB_T {
+    if obj.tag() == TAG_BLOB_T ||obj.tag() == TAG_BLOB_B || obj.tag() == TAG_BLOB_P {
         s
     } else {
         let concat = obj.as_concat();
@@ -444,7 +444,7 @@ where
     ));
     let string = to_string(&str);
     let bytes = string.as_bytes();
-    let lowercase = alloc_blob(mem, Bytes(bytes.len() as u32));
+    let lowercase = alloc_blob(mem, TAG_BLOB_T, Bytes(bytes.len() as u32));
     let mut i = 0;
     let target_ptr = lowercase.as_blob_mut().payload_addr();
     for b in bytes {
diff --git a/rts/motoko-rts/src/text_iter.rs b/rts/motoko-rts/src/text_iter.rs
index e8809c6fd06..259c62de2c9 100644
--- a/rts/motoko-rts/src/text_iter.rs
+++ b/rts/motoko-rts/src/text_iter.rs
@@ -16,7 +16,7 @@ use crate::barriers::allocation_barrier;
 use crate::memory::{alloc_array, Memory};
 use crate::rts_trap_with;
 use crate::text::decode_code_point;
-use crate::types::{Array, Value, TAG_BLOB_T, TAG_CONCAT};
+use crate::types::{Array, Value, TAG_BLOB_T, TAG_ARRAY_T, TAG_CONCAT};
 
 use motoko_rts_macros::ic_mem_fn;
 
@@ -30,7 +30,7 @@ unsafe fn find_leaf<M: Memory>(mem: &mut M, mut text: Value, todo: *mut Value) -
         let concat = text.as_concat();
 
         // Add right node to TODOs
-        let new_todo = alloc_array(mem, 2);
+        let new_todo = alloc_array(mem, TAG_ARRAY_T, 2);
         let new_todo_array = new_todo.as_array();
         // No pre-update barrier for object initialization, but do perform post-update barrier.
         new_todo_array.initialize(TODO_TEXT_IDX, (*concat).text2, mem);
@@ -53,7 +53,7 @@ const ITER_TODO_IDX: u32 = 2;
 /// Returns a new iterator for the text
 #[ic_mem_fn]
 pub unsafe fn text_iter<M: Memory>(mem: &mut M, text: Value) -> Value {
-    let iter = alloc_array(mem, 3);
+    let iter = alloc_array(mem, TAG_ARRAY_T, 3);
     let array = iter.as_array();
 
     // Initialize the TODO field first, to be able to use it use the location to `find_leaf`
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 8434f4dba40..a3289c809f3 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -1249,8 +1249,8 @@ module RTS = struct
     E.add_func_import env "rts" "alloc_words" [I32Type] [I32Type];
     E.add_func_import env "rts" "get_total_allocations" [] [I64Type];
     E.add_func_import env "rts" "get_heap_size" [] [I32Type];
-    E.add_func_import env "rts" "alloc_blob" [I32Type] [I32Type];
-    E.add_func_import env "rts" "alloc_array" [I32Type] [I32Type];
+    E.add_func_import env "rts" "alloc_blob" [I32Type; I32Type] [I32Type];
+    E.add_func_import env "rts" "alloc_array" [I32Type; I32Type] [I32Type];
     E.add_func_import env "rts" "alloc_stream" [I32Type] [I32Type];
     E.add_func_import env "rts" "stream_write" [I32Type; I32Type; I32Type] [];
     E.add_func_import env "rts" "stream_write_byte" [I32Type; I32Type] [];
@@ -4259,7 +4259,9 @@ module Blob = struct
     compile_unboxed_const (Int32.add ptr_unskew (E.add_static env StaticBytes.[Bytes s])) ^^
     compile_unboxed_const (Int32.of_int (String.length s))
 
-  let alloc env sort =
+  let alloc env sort len =
+    compile_unboxed_const Tagged.(int_of_tag (Blob sort)) ^^
+    len ^^
     E.call_import env "rts" "alloc_blob" ^^ (*TODO sorts!*)
     (* uninitialized blob payload is allowed by the barrier *)
     Tagged.allocation_barrier env
@@ -4279,7 +4281,7 @@ module Blob = struct
   let of_ptr_size env = Func.share_code2 Func.Always env "blob_of_ptr_size" (("ptr", I32Type), ("size" , I32Type)) [I32Type] (
     fun env get_ptr get_size ->
       let (set_x, get_x) = new_local env "x" in
-      get_size ^^ alloc env Tagged.B ^^ set_x ^^
+      alloc env Tagged.B get_size ^^ set_x ^^
       get_x ^^ payload_ptr_unskewed env ^^
       get_ptr ^^
       get_size ^^
@@ -4292,7 +4294,7 @@ module Blob = struct
     let (set_blob, get_blob) = new_local env "blob" in
     get_size_fun env ^^ set_len ^^
 
-    get_len ^^ alloc env sort ^^ set_blob ^^
+    alloc env sort get_len ^^ set_blob ^^
     get_blob ^^ payload_ptr_unskewed env ^^
     offset_fun env ^^
     get_len ^^
@@ -4409,7 +4411,10 @@ module Blob = struct
     E.call_import env "rts" "blob_iter_next" ^^
     TaggedSmallWord.msb_adjust Type.Nat8
 
-  let dyn_alloc_scratch env = alloc env Tagged.B ^^ payload_ptr_unskewed env
+  let dyn_alloc_scratch env =
+    let (set_len, get_len) = new_local env "len" in
+    set_len ^^
+    alloc env Tagged.B get_len ^^ payload_ptr_unskewed env
 
   (* TODO: rewrite using MemoryFill *)
   let clear env =
@@ -4693,7 +4698,9 @@ module Arr = struct
 
   (* Does not initialize the fields! *)
   (* Note: Post allocation barrier must be applied after initialization *)
-  let alloc env array_sort =
+  let alloc env array_sort len =
+    compile_unboxed_const Tagged.(int_of_tag (Array array_sort)) ^^
+    len ^^
     E.call_import env "rts" "alloc_array" (* TODO *)
 
   let iterate env get_array body =
@@ -4741,7 +4748,8 @@ module Arr = struct
 
     (* Allocate *)
     BigNum.to_word32 env ^^
-    alloc env Tagged.M ^^
+    set_r ^^
+    alloc env Tagged.M get_r ^^
     set_r ^^
 
     (* Write elements *)
@@ -4762,7 +4770,8 @@ module Arr = struct
 
     (* Allocate *)
     BigNum.to_word32 env ^^
-    alloc env Tagged.I ^^
+    set_r ^^
+    alloc env Tagged.I get_r ^^
     set_r ^^
 
     (* Initial index *)
@@ -4800,7 +4809,7 @@ module Arr = struct
 
       get_blob ^^ Blob.len env ^^ set_len ^^
 
-      get_len ^^ alloc env sort ^^ set_r ^^
+      alloc env sort get_len ^^ set_r ^^
 
       get_len ^^ from_0_to_n env (fun get_i ->
         get_r ^^ get_i ^^ unsafe_idx env ^^
@@ -4822,7 +4831,7 @@ module Arr = struct
 
       get_a ^^ len env ^^ set_len ^^
 
-      get_len ^^ Blob.alloc env Tagged.B ^^ set_r ^^
+      Blob.alloc env Tagged.B get_len ^^ set_r ^^
 
       get_len ^^ from_0_to_n env (fun get_i ->
         get_r ^^ Blob.payload_ptr_unskewed env ^^
@@ -5956,7 +5965,7 @@ module StableMem = struct
           get_offset ^^
           get_len ^^
           guard_range env ^^
-          get_len ^^ Blob.alloc env Tagged.B ^^ set_blob ^^
+          Blob.alloc env Tagged.B get_len ^^ set_blob ^^
           get_blob ^^ Blob.payload_ptr_unskewed env ^^ G.i (Convert (Wasm.Values.I64 I64Op.ExtendUI32)) ^^
           get_offset ^^
           get_len ^^ G.i (Convert (Wasm.Values.I64 I64Op.ExtendUI32)) ^^
@@ -7347,7 +7356,7 @@ module MakeSerialization (Strm : Stream) = struct
         let (set_x, get_x) = new_local env "x" in
         ReadBuf.read_leb128 env get_data_buf ^^ set_len ^^
 
-        get_len ^^ Blob.alloc env Tagged.B ^^ set_x ^^
+        Blob.alloc env Tagged.B get_len ^^ set_x ^^
         get_x ^^ Blob.payload_ptr_unskewed env ^^
         ReadBuf.read_blob env get_data_buf get_len ^^
         get_x
@@ -7364,7 +7373,7 @@ module MakeSerialization (Strm : Stream) = struct
         get_len ^^ compile_unboxed_const 29l ^^ G.i (Compare (Wasm.Values.I32 I32Op.LeU)) ^^
         E.else_trap_with env "IDL error: principal too long" ^^
 
-        get_len ^^ Blob.alloc env Tagged.P ^^ set_x ^^
+        Blob.alloc env Tagged.P get_len ^^ set_x ^^
         get_x ^^ Blob.payload_ptr_unskewed env ^^
         ReadBuf.read_blob env get_data_buf get_len ^^
         get_x
@@ -7713,7 +7722,7 @@ module MakeSerialization (Strm : Stream) = struct
           *)
           with_composite_arg_typ get_array_typ idl_vec (ReadBuf.read_sleb128 env) ^^ set_arg_typ ^^
           ReadBuf.read_leb128 env get_data_buf ^^ set_len ^^
-          get_len ^^ Arr.alloc env Tagged.M ^^ set_x ^^
+          Arr.alloc env Tagged.M get_len ^^ set_x ^^
           on_alloc get_x ^^
           get_len ^^ from_0_to_n env (fun get_i ->
             get_x ^^ get_i ^^ Arr.unsafe_idx env ^^
@@ -7755,7 +7764,7 @@ module MakeSerialization (Strm : Stream) = struct
           ReadBuf.read_sleb128 env get_typ_buf ^^
           set_arg_typ ^^
           ReadBuf.read_leb128 env get_data_buf ^^ set_len ^^
-          get_len ^^ Arr.alloc env Tagged.I ^^ set_x ^^
+          Arr.alloc env Tagged.I get_len ^^ set_x ^^
           get_len ^^ from_0_to_n env (fun get_i ->
           get_x ^^ get_i ^^ Arr.unsafe_idx env ^^
           get_arg_typ ^^ go env t ^^ set_val ^^
@@ -8619,7 +8628,7 @@ module Stabilization = struct
 
           let (set_blob, get_blob) = new_local env "blob" in
           (* read blob from stable memory *)
-          get_len ^^ Blob.alloc env Tagged.B ^^ set_blob ^^
+          Blob.alloc env Tagged.B get_len ^^ set_blob ^^
           extend64 (get_blob ^^ Blob.payload_ptr_unskewed env) ^^
           get_offset ^^
           extend64 get_len ^^

From 0b0976a2449859a48c52d6308843768204752ee6 Mon Sep 17 00:00:00 2001
From: Claudio Russo <claudio@dfinity.org>
Date: Sat, 18 May 2024 23:07:02 +0100
Subject: [PATCH 215/260] implement refined tagging; refine Blob Const (WIP);
 todo: refine Const.Array in compile.ml

---
 rts/motoko-rts/src/principal_id.rs |  2 +-
 src/codegen/compile.ml             | 43 ++++++++++++++++--------------
 2 files changed, 24 insertions(+), 21 deletions(-)

diff --git a/rts/motoko-rts/src/principal_id.rs b/rts/motoko-rts/src/principal_id.rs
index 0d08ed7dfe5..d92acf4ff94 100644
--- a/rts/motoko-rts/src/principal_id.rs
+++ b/rts/motoko-rts/src/principal_id.rs
@@ -13,7 +13,7 @@ use motoko_rts_macros::ic_mem_fn;
 
 #[no_mangle]
 pub unsafe extern "C" fn compute_crc32(blob: Value) -> u32 {
-    if blob.tag() != TAG_BLOB_B {
+    if !blob.is_blob() {
         panic!("compute_crc32: Blob expected");
     }
 
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index a3289c809f3..b5362f8c1ab 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -225,6 +225,7 @@ module Const = struct
     | Word32 of Type.prim * int32
     | Word64 of Type.prim * int64
     | Float64 of Numerics.Float.t
+    | Text of string
     | Blob of string
     | Null
 
@@ -235,6 +236,7 @@ module Const = struct
     | Word64 (tyi, i), Word64 (tyj, j) -> tyi = tyj && i = j
     | Float64 i, Float64 j -> i = j
     | Bool i, Bool j -> i = j
+    | Text s, Text t
     | Blob s, Blob t -> s = t
     | Null, Null -> true
     | _ -> false
@@ -274,7 +276,7 @@ module Const = struct
     | Message of int32 (* anonymous message, only temporary *)
     | Obj of (string * t) list
     | Unit
-    | Array of t list (* also tuples, but not nullary *)
+    | Array of t list (* also tuples, but not nullary *) (*TODO: add Tuple constructor *)
     | Tag of (string * t)
     | Opt of t
     | Lit of lit
@@ -4247,13 +4249,13 @@ module Blob = struct
       BigNum.from_word32 env
     )
 
-  let vanilla_lit env s =
-    Tagged.shared_static_obj env Tagged.(Blob B) StaticBytes.[
+  let vanilla_lit env sort s =
+    Tagged.shared_static_obj env Tagged.(Blob sort) StaticBytes.[
       I32 (Int32.of_int (String.length s));
       Bytes s;
     ]
 
-  let lit env s = compile_unboxed_const (vanilla_lit env s)
+  let lit env sort s = compile_unboxed_const (vanilla_lit env sort s)
 
   let lit_ptr_len env s =
     compile_unboxed_const (Int32.add ptr_unskew (E.add_static env StaticBytes.[Bytes s])) ^^
@@ -4675,7 +4677,7 @@ module Arr = struct
     Func.share_code2 Func.Never env "Array.idx_bigint" (("array", I32Type), ("idx", I32Type)) [I32Type] (fun env get_array get_idx ->
       get_array ^^
       get_idx ^^
-      Blob.lit env "Array index out of bounds" ^^
+      Blob.lit env Tagged.T "Array index out of bounds" ^^
       BigNum.to_word32_with env ^^
       idx env
   )
@@ -5013,7 +5015,7 @@ module IC = struct
     G.i (GlobalSet (nr (E.get_global env "__call_perform_message")))
 
   let init_globals env =
-    Blob.lit env "" ^^
+    Blob.lit env Tagged.T "" ^^
     set_call_perform_message env
 
   let i32s n = Lib.List.make n I32Type
@@ -5394,7 +5396,7 @@ module IC = struct
   (* Actor reference on the stack *)
   let actor_public_field env name =
     (* simply tuple canister name and function name *)
-    Blob.lit env name ^^
+    Blob.lit env Tagged.T name ^^
     Tuple.from_stack env 2
 
   let fail_assert env at =
@@ -6436,7 +6438,7 @@ module BumpStream : Stream = struct
     get_data_size ^^ compile_add_const header_size ^^
     Blob.dyn_alloc_scratch env ^^ set_data_buf ^^
     get_data_buf ^^
-    Blob.lit env header ^^ Blob.payload_ptr_unskewed env ^^
+    Blob.lit env Tagged.B header ^^ Blob.payload_ptr_unskewed env ^^
     compile_unboxed_const header_size ^^
     Heap.memcpy env ^^
     get_data_buf ^^ compile_add_const header_size ^^ set_data_buf
@@ -7550,11 +7552,11 @@ module MakeSerialization (Strm : Stream) = struct
             *)
             get_thing ^^ set_result ^^
             get_memo ^^ get_result ^^ store_unskewed_ptr ^^
-            get_memo ^^ compile_add_const 4l ^^ Blob.lit env (typ_hash t) ^^ store_unskewed_ptr
+            get_memo ^^ compile_add_const 4l ^^ Blob.lit env Tagged.T (typ_hash t) ^^ store_unskewed_ptr
           )
           end begin
           (* Decoded before. Check type hash *)
-          ReadBuf.read_word32 env get_data_buf ^^ Blob.lit env (typ_hash t) ^^
+          ReadBuf.read_word32 env get_data_buf ^^ Blob.lit env Tagged.T (typ_hash t) ^^
           G.i (Compare (Wasm.Values.I32 I32Op.Eq)) ^^
           E.else_trap_with env ("Stable memory error: Aliased at wrong type, expected: " ^ typ_hash t)
         end ^^
@@ -7744,7 +7746,7 @@ module MakeSerialization (Strm : Stream) = struct
           (* pre-allocate a region object, with dummy fields *)
           compile_const_64 0L ^^ (* id *)
           compile_unboxed_const 0l ^^ (* pagecount *)
-          Blob.lit env "" ^^ (* vec_pages *)
+          Blob.lit env Tagged.B "" ^^ (* vec_pages *)
           Region.alloc_region env ^^
           set_region ^^
           on_alloc get_region ^^
@@ -8244,7 +8246,7 @@ module BlobStream : Stream = struct
     get_data_size ^^ compile_add_const header_size ^^
     E.call_import env "rts" "alloc_stream" ^^ set_token ^^ (* allocation barrier called in alloc_stream *)
     get_token ^^
-    Blob.lit env header ^^
+    Blob.lit env Tagged.B header ^^
     E.call_import env "rts" "stream_write_text"
 
   let check_filled env get_token get_data_size =
@@ -8763,7 +8765,8 @@ module StackRep = struct
     | Const.Word32 (pty, n) -> BoxedSmallWord.vanilla_lit env pty n
     | Const.Word64 (pty, n) -> BoxedWord64.vanilla_lit env pty n
     | Const.Float64 f  -> Float.vanilla_lit env f
-    | Const.Blob t     -> Blob.vanilla_lit env t
+    | Const.Text t -> Blob.vanilla_lit env Tagged.T t
+    | Const.Blob t -> Blob.vanilla_lit env Tagged.B t
     | Const.Null       -> Opt.null_vanilla_lit env
 
   let rec materialize_const_t env (p, cv) : int32 =
@@ -9471,7 +9474,7 @@ module FuncDec = struct
       (* done! *)
       IC.system_call env "call_perform" ^^
       IC.set_call_perform_status env ^^
-      Blob.lit env message ^^
+      Blob.lit env Tagged.T message ^^
       IC.set_call_perform_message env ^^
       IC.get_call_perform_status env ^^
       (* save error code, cleanup on error *)
@@ -9546,11 +9549,11 @@ module FuncDec = struct
          G.i Drop ^^
          compile_unboxed_zero ^^
          IC.set_call_perform_status env ^^
-         Blob.lit env "" ^^
+         Blob.lit env Tagged.T "" ^^
          IC.set_call_perform_message env
        else
          IC.set_call_perform_status env ^^
-         Blob.lit env "could not perform oneway" ^^
+         Blob.lit env Tagged.T "could not perform oneway" ^^
          IC.set_call_perform_message env)
 
     | _ -> assert false
@@ -9922,7 +9925,7 @@ let const_lit_of_lit : Ir.lit -> Const.lit = function
   | CharLit c     -> Const.Vanilla (TaggedSmallWord.vanilla_lit Type.Char c)
 
   | NullLit       -> Const.Null
-  | TextLit t
+  | TextLit t     -> Const.Text t
   | BlobLit t     -> Const.Blob t
   | FloatLit f    -> Const.Float64 f
 
@@ -11377,7 +11380,7 @@ and compile_prim_invocation (env : E.t) ae p es at =
     compile_exp_as env ae SR.Vanilla e0 ^^
     compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
     compile_exp_as env ae SR.Vanilla e2 ^^
-    Blob.lit env "Blob size out of bounds" ^^
+    Blob.lit env Tagged.T "Blob size out of bounds" ^^
     BigNum.to_word32_with env ^^
     Region.load_blob env
 
@@ -11717,7 +11720,7 @@ and compile_prim_invocation (env : E.t) ae p es at =
     SR.Vanilla,
     compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
     compile_exp_as env ae SR.Vanilla e2 ^^
-    Blob.lit env "Blob size out of bounds" ^^
+    Blob.lit env Tagged.T "Blob size out of bounds" ^^
     BigNum.to_word32_with env ^^
     StableMemoryInterface.load_blob env
 
@@ -11739,7 +11742,7 @@ and compile_prim_invocation (env : E.t) ae p es at =
   | OtherPrim "stableVarQuery", [] ->
     SR.UnboxedTuple 2,
     IC.get_self_reference env ^^
-    Blob.lit env Type.(motoko_stable_var_info_fld.lab)
+    Blob.lit env Tagged.T Type.(motoko_stable_var_info_fld.lab)
 
   (* Other prims, binary*)
   | OtherPrim "Array.init", [_;_] ->

From 00e5895b6b3e718d189e0b816f849bae7c31381d Mon Sep 17 00:00:00 2001
From: Claudio Russo <claudio@dfinity.org>
Date: Wed, 22 May 2024 08:51:01 +0100
Subject: [PATCH 216/260] copy, don't alias, in blob_to_text;restrict
 blob_of_text; generslize stream_write_text to accept blob or text

---
 rts/motoko-rts/src/text.rs | 4 ++--
 src/codegen/compile.ml     | 7 ++++++-
 2 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/rts/motoko-rts/src/text.rs b/rts/motoko-rts/src/text.rs
index c0bc6c53c63..f5e1c256ca6 100644
--- a/rts/motoko-rts/src/text.rs
+++ b/rts/motoko-rts/src/text.rs
@@ -172,7 +172,7 @@ unsafe extern "C" fn text_to_buf(mut s: Value, mut buf: *mut u8) {
 unsafe extern "C" fn stream_write_text(stream: *mut Stream, mut s: Value) {
     loop {
         let s_ptr = s.as_obj();
-        if s_ptr.tag() == TAG_BLOB_T {
+        if s_ptr.tag() == TAG_BLOB_B || s_ptr.tag() == TAG_BLOB_T {
             let blob = s_ptr.as_blob();
             stream.cache_bytes(blob.payload_addr(), blob.len());
             break;
@@ -188,7 +188,7 @@ unsafe extern "C" fn stream_write_text(stream: *mut Stream, mut s: Value) {
 #[ic_mem_fn]
 pub unsafe fn blob_of_text<M: Memory>(mem: &mut M, s: Value) -> Value {
     let obj = s.as_obj();
-    if obj.tag() == TAG_BLOB_T ||obj.tag() == TAG_BLOB_B || obj.tag() == TAG_BLOB_P {
+    if obj.tag() == TAG_BLOB_T {
         s
     } else {
         let concat = obj.as_concat();
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index b5362f8c1ab..f91ce2aa210 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -4576,7 +4576,12 @@ module Text = struct
     set_blob ^^
     get_blob ^^ Blob.as_ptr_len env ^^
     E.call_import env "rts" "utf8_valid" ^^
-    G.if1 I32Type (Opt.inject_simple env get_blob) (Opt.null_lit env)
+    G.if1 I32Type
+      (get_blob ^^ Blob.as_ptr_len env ^^
+       of_ptr_size env ^^ (* creates text blob *)
+       set_blob ^^
+       Opt.inject_simple env get_blob)
+      (Opt.null_lit env)
 
   let iter env =
     E.call_import env "rts" "text_iter"

From 6bbfdeab0266fecc2762d028dee52356306914ba Mon Sep 17 00:00:00 2001
From: Claudio Russo <claudio@dfinity.org>
Date: Wed, 22 May 2024 14:58:12 +0100
Subject: [PATCH 217/260] refine Const.Array into Const.Array and Const.Tuple
 to reflect precise heap tagging

---
 src/codegen/compile.ml | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index f91ce2aa210..a68ad9b9150 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -276,7 +276,8 @@ module Const = struct
     | Message of int32 (* anonymous message, only temporary *)
     | Obj of (string * t) list
     | Unit
-    | Array of t list (* also tuples, but not nullary *) (*TODO: add Tuple constructor *)
+    | Array of t list (* immutable arrays *)
+    | Tuple of t list (* non-nullary tuples *)
     | Tag of (string * t)
     | Opt of t
     | Lit of lit
@@ -8785,6 +8786,9 @@ module StackRep = struct
       Object.vanilla_lit env fs'
     | Const.Unit -> Tuple.unit_vanilla_lit env
     | Const.Array cs ->
+      let ptrs = List.map (materialize_const_t env) cs in
+      Arr.vanilla_lit env Tagged.I ptrs
+    | Const.Tuple cs ->
       let ptrs = List.map (materialize_const_t env) cs in
       Arr.vanilla_lit env Tagged.T ptrs
     | Const.Tag (i, c) ->
@@ -8846,7 +8850,7 @@ module StackRep = struct
        compile_const_64 n
     | Const (_, Const.Lit (Const.Float64 f)), UnboxedFloat64 -> Float.compile_unboxed_const f
     | Const c, UnboxedTuple 0 -> G.nop
-    | Const (_, Const.Array cs), UnboxedTuple n ->
+    | Const (_, Const.Tuple cs), UnboxedTuple n ->
       assert (n = List.length cs);
       G.concat_map (fun c -> compile_unboxed_const (materialize_const_t env c)) cs
     | _, _ ->
@@ -12521,16 +12525,19 @@ and compile_const_exp env pre_ae exp : Const.t * (E.t -> VarEnv.t -> unit) =
   | PrimE (ProjPrim i, [e]) ->
     let (object_ct, fill) = compile_const_exp env pre_ae e in
     let cs = match object_ct with
-      | _, Const.Array cs -> cs
+      | _, Const.Tuple cs -> cs
       | _ -> fatal "compile_const_exp/ProjE: not a static tuple" in
     (List.nth cs i, fill)
   | LitE l -> Const.(t_of_v (Lit (const_lit_of_lit l))), (fun _ _ -> ())
   | PrimE (TupPrim, []) -> Const.t_of_v Const.Unit, (fun _ _ -> ())
-  | PrimE (ArrayPrim (Const, _), es)
-  | PrimE (TupPrim, es) ->
+  | PrimE (ArrayPrim (Const, _), es) ->
     let (cs, fills) = List.split (List.map (compile_const_exp env pre_ae) es) in
     Const.(t_of_v (Array cs)),
     (fun env ae -> List.iter (fun fill -> fill env ae) fills)
+  | PrimE (TupPrim, es) ->
+    let (cs, fills) = List.split (List.map (compile_const_exp env pre_ae) es) in
+    Const.(t_of_v (Tuple cs)),
+    (fun env ae -> List.iter (fun fill -> fill env ae) fills)
   | PrimE (TagPrim i, [e]) ->
     let (arg_ct, fill) = compile_const_exp env pre_ae e in
     Const.(t_of_v (Tag (i, arg_ct))),
@@ -12575,7 +12582,7 @@ and destruct_const_pat ae pat const : VarEnv.t option = match pat.it with
     if l = None then destruct_const_pat ae p2 const
     else l
   | TupP ps ->
-    let cs = match const with (_, Const.Array cs) -> cs | (_, Const.Unit) -> [] | _ -> assert false in
+    let cs = match const with (_, Const.Tuple cs) -> cs | (_, Const.Unit) -> [] | _ -> assert false in
     let go ae p c = match ae with
       | Some ae -> destruct_const_pat ae p c
       | _ -> None in

From 4981b3ae817c338bd9e3ebbaff40c7e6afdb18c4 Mon Sep 17 00:00:00 2001
From: Claudio Russo <claudio@dfinity.org>
Date: Thu, 23 May 2024 15:35:22 +0100
Subject: [PATCH 218/260] adapt incremental array slicing; fix rts tests

---
 rts/motoko-rts-tests/src/continuation_table.rs           | 2 +-
 rts/motoko-rts-tests/src/gc.rs                           | 9 +++++----
 rts/motoko-rts-tests/src/gc/compacting/mark_stack.rs     | 2 +-
 rts/motoko-rts-tests/src/gc/incremental/array_slicing.rs | 4 ++--
 .../src/gc/incremental/partitioned_heap.rs               | 4 ++--
 rts/motoko-rts-tests/src/principal_id.rs                 | 6 +++---
 rts/motoko-rts-tests/src/text.rs                         | 4 ++--
 rts/motoko-rts/src/gc/incremental/array_slicing.rs       | 8 +++++---
 rts/motoko-rts/src/principal_id.rs                       | 4 ++--
 rts/motoko-rts/src/text.rs                               | 5 +++--
 rts/motoko-rts/src/visitor.rs                            | 2 +-
 11 files changed, 27 insertions(+), 23 deletions(-)

diff --git a/rts/motoko-rts-tests/src/continuation_table.rs b/rts/motoko-rts-tests/src/continuation_table.rs
index 9a152e0524b..3241db12d66 100644
--- a/rts/motoko-rts-tests/src/continuation_table.rs
+++ b/rts/motoko-rts-tests/src/continuation_table.rs
@@ -22,7 +22,7 @@ pub unsafe fn test() {
             + N as u32 * size_of::<Blob>().to_bytes().as_u32(),
     ));
 
-    let pointers: [Value; N] = from_fn(|_| alloc_blob(&mut heap, TAB_BLOB_B, Bytes(0)));
+    let pointers: [Value; N] = from_fn(|_| alloc_blob(&mut heap, TAG_BLOB_B, Bytes(0)));
 
     let mut references: [u32; N] = [0; N];
     for i in 0..N {
diff --git a/rts/motoko-rts-tests/src/gc.rs b/rts/motoko-rts-tests/src/gc.rs
index 6611e952e17..7155aa6fc0a 100644
--- a/rts/motoko-rts-tests/src/gc.rs
+++ b/rts/motoko-rts-tests/src/gc.rs
@@ -271,7 +271,7 @@ fn check_dynamic_heap(
 
             let is_forwarded = forward != make_pointer(address as u32);
 
-            if incremental && tag == TAG_BLOB {
+            if incremental && tag == TAG_BLOB_B {
                 assert!(!is_forwarded);
                 // in-heap mark stack blobs
                 let length = read_word(heap, offset);
@@ -285,9 +285,10 @@ fn check_dynamic_heap(
                     .as_usize();
             } else {
                 if incremental {
-                    assert!(tag == TAG_ARRAY || tag >= TAG_ARRAY_SLICE_MIN);
+                    assert!(tag == TAG_ARRAY_I || tag == TAG_ARRAY_M || tag == TAG_ARRAY_T
+                            || tag >= TAG_ARRAY_SLICE_MIN);
                 } else {
-                    assert_eq!(tag, TAG_ARRAY);
+                    assert!(tag == TAG_ARRAY_I || tag == TAG_ARRAY_M || tag == TAG_ARRAY_T)
                 }
 
                 if is_forwarded {
@@ -431,7 +432,7 @@ fn check_continuation_table(mut offset: usize, continuation_table: &[ObjectIdx],
     let incremental = cfg!(feature = "incremental_gc");
 
     let table_addr = heap.as_ptr() as usize + offset;
-    assert_eq!(read_word(heap, offset), TAG_ARRAY);
+    assert_eq!(read_word(heap, offset), TAG_ARRAY_M);
     offset += WORD_SIZE;
 
     if incremental {
diff --git a/rts/motoko-rts-tests/src/gc/compacting/mark_stack.rs b/rts/motoko-rts-tests/src/gc/compacting/mark_stack.rs
index 2458ff35128..d27d44cf6b7 100644
--- a/rts/motoko-rts-tests/src/gc/compacting/mark_stack.rs
+++ b/rts/motoko-rts-tests/src/gc/compacting/mark_stack.rs
@@ -33,7 +33,7 @@ fn test_push_pop() {
         .unwrap();
 }
 
-static TAGS: [Tag; 14] = [
+static TAGS: [Tag; 22] = [
     TAG_OBJECT,
     TAG_OBJ_IND,
     TAG_ARRAY_I, TAG_ARRAY_M, TAG_ARRAY_T,
diff --git a/rts/motoko-rts-tests/src/gc/incremental/array_slicing.rs b/rts/motoko-rts-tests/src/gc/incremental/array_slicing.rs
index 8c5ca19dea2..57505d0986e 100644
--- a/rts/motoko-rts-tests/src/gc/incremental/array_slicing.rs
+++ b/rts/motoko-rts-tests/src/gc/incremental/array_slicing.rs
@@ -1,7 +1,7 @@
 use motoko_rts::{
     gc::incremental::array_slicing::slice_array,
     memory::alloc_array,
-    types::{Words, TAG_ARRAY, TAG_ARRAY_SLICE_MIN},
+    types::{Words, TAG_ARRAY_M, TAG_ARRAY_SLICE_MIN},
 };
 
 use crate::memory::TestMemory;
@@ -27,7 +27,7 @@ unsafe fn test_array_slicing(mem: &mut TestMemory, array_length: u32) {
         let new_offset = slice_array(array);
         assert!(new_offset > last_offset || array.len() == 0 && new_offset == 0);
         last_offset = new_offset;
-        if (*array).header.tag == TAG_ARRAY {
+        if (*array).header.tag == TAG_ARRAY_M {
             break;
         }
         assert!((*array).header.tag >= TAG_ARRAY_SLICE_MIN);
diff --git a/rts/motoko-rts-tests/src/gc/incremental/partitioned_heap.rs b/rts/motoko-rts-tests/src/gc/incremental/partitioned_heap.rs
index ace2b2b3e0c..16c24e28ab5 100644
--- a/rts/motoko-rts-tests/src/gc/incremental/partitioned_heap.rs
+++ b/rts/motoko-rts-tests/src/gc/incremental/partitioned_heap.rs
@@ -13,7 +13,7 @@ use motoko_rts::{
         time::BoundedTime,
     },
     memory::{alloc_array, alloc_blob, Memory},
-    types::{Array, Blob, Bytes, Obj, Tag, Value, Words, TAG_ARRAY_M, TAG_BLOB_B},
+    types::{Array, Blob, Bytes, Obj, Tag, Value, Words, TAG_ARRAY_I, TAG_ARRAY_M, TAG_ARRAY_T, TAG_BLOB_B, TAG_BLOB_T, TAG_BLOB_P},
 };
 
 use crate::{gc::utils::WORD_SIZE, memory::TestMemory};
@@ -308,7 +308,7 @@ unsafe fn iterate_large_partition(
     let mut time = BoundedTime::new(0);
     while iterator.has_object() {
         let object = iterator.current_object();
-        assert_eq!(object.tag(), TAG_BLOB);
+        assert_eq!(object.tag(), TAG_BLOB_B);
         let size = block_size(object as *const Tag);
         detected_sizes.push(size);
         time.tick();
diff --git a/rts/motoko-rts-tests/src/principal_id.rs b/rts/motoko-rts-tests/src/principal_id.rs
index be37cb33d5b..fbaf1812319 100644
--- a/rts/motoko-rts-tests/src/principal_id.rs
+++ b/rts/motoko-rts-tests/src/principal_id.rs
@@ -1,7 +1,7 @@
 use crate::memory::TestMemory;
 
 use motoko_rts::principal_id::{blob_of_principal, principal_of_blob};
-use motoko_rts::text::{text_compare, text_of_ptr_size, text_of_str};
+use motoko_rts::text::{text_compare, text_of_ptr_size, text_of_str, blob_compare};
 use motoko_rts::types::{Bytes, Words};
 
 pub unsafe fn test() {
@@ -36,11 +36,11 @@ pub unsafe fn test() {
 
     let text = text_of_str(&mut heap, "aaaaa-aa");
     let principal = blob_of_principal(&mut heap, text);
-    assert_eq!(text_compare(principal, text_of_str(&mut heap, ""),), 0);
+    assert_eq!(blob_compare(principal, text_of_str(&mut heap, ""),), 0);
 
     let text = text_of_str(&mut heap, "bfozs-kwa73-7nadi");
     assert_eq!(
-        text_compare(
+        blob_compare(
             blob_of_principal(&mut heap, text),
             text_of_ptr_size(&mut heap, b"\xC0\xFE\xFE\xD0\x0D".as_ptr(), Bytes(5))
         ),
diff --git a/rts/motoko-rts-tests/src/text.rs b/rts/motoko-rts-tests/src/text.rs
index 3fbbc3d8e0c..8f0e75f63ff 100644
--- a/rts/motoko-rts-tests/src/text.rs
+++ b/rts/motoko-rts-tests/src/text.rs
@@ -8,7 +8,7 @@ use motoko_rts::text::{
     text_singleton, text_size,
 };
 use motoko_rts::text_iter::{text_iter, text_iter_done, text_iter_next};
-use motoko_rts::types::{Bytes, Value, Words, TAG_BLOB};
+use motoko_rts::types::{Bytes, Value, Words, TAG_BLOB_T};
 
 use std::convert::TryFrom;
 
@@ -68,7 +68,7 @@ pub unsafe fn test() {
     for i in 0..8 {
         let str = &STR[0..i + 1];
         let text = text_of_str(&mut mem, str);
-        assert_eq!(text.tag(), TAG_BLOB);
+        assert_eq!(text.tag(), TAG_BLOB_T);
         let iter = TextIter::from_text(&mut mem, text);
         assert_eq!(iter.collect::<String>(), str);
     }
diff --git a/rts/motoko-rts/src/gc/incremental/array_slicing.rs b/rts/motoko-rts/src/gc/incremental/array_slicing.rs
index ab200c2407c..7979bd16551 100644
--- a/rts/motoko-rts/src/gc/incremental/array_slicing.rs
+++ b/rts/motoko-rts/src/gc/incremental/array_slicing.rs
@@ -9,13 +9,15 @@ pub unsafe fn slice_array(array: *mut Array) -> u32 {
     const SLICE_INCREMENT: u32 = 128;
     debug_assert!(SLICE_INCREMENT >= TAG_ARRAY_SLICE_MIN);
     let tag = (*array).header.tag;
-    let slice_start = if tag >= TAG_ARRAY_SLICE_MIN { tag } else { 0 };
+    let (sort, slice_start) =
+        if tag >= TAG_ARRAY_SLICE_MIN { (tag >> 30, tag << 2 >> 2) } else {
+        ((tag - TAG_ARRAY_I) / 2, 0) };
     if array.len() - slice_start > SLICE_INCREMENT {
         let new_start = slice_start + SLICE_INCREMENT;
-        (*array).header.tag = new_start;
+        (*array).header.tag = (sort << 30) | new_start;
         new_start
     } else {
-        (*array).header.tag = TAG_ARRAY_M; // TODO: restore original tag somehow
+        (*array).header.tag = TAG_ARRAY_I + sort * 2; // TODO: restore original tag somehow
         array.len()
     }
 }
diff --git a/rts/motoko-rts/src/principal_id.rs b/rts/motoko-rts/src/principal_id.rs
index d92acf4ff94..e8dfef2a069 100644
--- a/rts/motoko-rts/src/principal_id.rs
+++ b/rts/motoko-rts/src/principal_id.rs
@@ -5,7 +5,7 @@ use crate::mem_utils::memcpy_bytes;
 use crate::memory::{alloc_blob, Memory};
 use crate::rts_trap_with;
 use crate::text::{blob_compare, blob_of_text};
-use crate::types::{Bytes, Value, TAG_BLOB_B, TAG_BLOB_P, TAG_BLOB_T};
+use crate::types::{Bytes, Value, TAG_BLOB_B, TAG_BLOB_T};
 
 use motoko_rts_macros::ic_mem_fn;
 
@@ -98,7 +98,7 @@ pub unsafe fn base32_of_checksummed_blob<M: Memory>(mem: &mut M, b: Value) -> Va
     let n = b.as_blob().len();
     let mut data = b.as_blob().payload_const();
 
-    let r = alloc_blob(mem, TAG_BLOB_P, Bytes((n.as_u32() + 4 + 4) / 5 * 8)); // contains padding
+    let r = alloc_blob(mem, TAG_BLOB_T /*?*/, Bytes((n.as_u32() + 4 + 4) / 5 * 8)); // contains padding
     let blob = r.as_blob_mut();
     let dest = blob.payload_addr();
 
diff --git a/rts/motoko-rts/src/text.rs b/rts/motoko-rts/src/text.rs
index f5e1c256ca6..cb283dd5c0a 100644
--- a/rts/motoko-rts/src/text.rs
+++ b/rts/motoko-rts/src/text.rs
@@ -30,7 +30,7 @@ use crate::barriers::allocation_barrier;
 use crate::mem_utils::memcpy_bytes;
 use crate::memory::{alloc_blob, Memory};
 use crate::rts_trap_with;
-use crate::types::{size_of, Blob, Bytes, Concat, Stream, Value, TAG_BLOB_T, TAG_BLOB_B, TAG_BLOB_P, TAG_CONCAT};
+use crate::types::{size_of, Blob, Bytes, Concat, Stream, Value, TAG_BLOB_T, TAG_BLOB_B, TAG_CONCAT};
 
 use alloc::string::String;
 use core::cmp::{min, Ordering};
@@ -335,7 +335,8 @@ pub unsafe extern "C" fn text_compare(s1: Value, s2: Value) -> i32 {
     }
 }
 
-pub(crate) unsafe fn blob_compare(s1: Value, s2: Value) -> i32 {
+#[no_mangle]
+pub unsafe extern "C" fn blob_compare(s1: Value, s2: Value) -> i32 {
     let n1 = text_size(s1);
     let n2 = text_size(s2);
     let n = min(n1, n2);
diff --git a/rts/motoko-rts/src/visitor.rs b/rts/motoko-rts/src/visitor.rs
index 2a750a48e68..b592fbf2b9b 100644
--- a/rts/motoko-rts/src/visitor.rs
+++ b/rts/motoko-rts/src/visitor.rs
@@ -45,7 +45,7 @@ pub unsafe fn visit_pointer_fields<C, F, G>(
 
         TAG_ARRAY_I | TAG_ARRAY_M | TAG_ARRAY_T
             | TAG_ARRAY_SLICE_MIN.. => {
-            let slice_start = if tag >= TAG_ARRAY_SLICE_MIN { tag } else { 0 };
+            let slice_start = if tag >= TAG_ARRAY_SLICE_MIN { tag << 2 >> 2 } else { 0 };
             let array = obj as *mut Array;
             let array_payload = array.payload_addr();
             let stop = visit_field_range(ctx, slice_start, array);

From 788f403f1b841c014cd925558484a17b5dcec131 Mon Sep 17 00:00:00 2001
From: Claudio Russo <claudio@dfinity.org>
Date: Thu, 23 May 2024 15:36:32 +0100
Subject: [PATCH 219/260] rust format

---
 rts/motoko-rts-tests/src/gc.rs                   |  8 ++++++--
 .../src/gc/compacting/mark_stack.rs              | 16 ++++++++++++----
 .../src/gc/incremental/partitioned_heap.rs       |  9 +++++++--
 rts/motoko-rts-tests/src/principal_id.rs         |  2 +-
 rts/motoko-rts/src/allocator.rs                  |  3 ++-
 rts/motoko-rts/src/continuation_table.rs         |  2 +-
 .../src/gc/incremental/array_slicing.rs          |  8 +++++---
 rts/motoko-rts/src/gc/incremental/mark_stack.rs  |  4 ++--
 rts/motoko-rts/src/gc/remembered_set.rs          |  9 +++++----
 rts/motoko-rts/src/principal_id.rs               |  6 +++++-
 rts/motoko-rts/src/region.rs                     |  8 ++++++--
 rts/motoko-rts/src/text.rs                       |  4 +++-
 rts/motoko-rts/src/text_iter.rs                  |  2 +-
 rts/motoko-rts/src/types.rs                      | 11 +++++------
 rts/motoko-rts/src/visitor.rs                    | 15 ++++++++-------
 15 files changed, 69 insertions(+), 38 deletions(-)

diff --git a/rts/motoko-rts-tests/src/gc.rs b/rts/motoko-rts-tests/src/gc.rs
index 7155aa6fc0a..e390295e425 100644
--- a/rts/motoko-rts-tests/src/gc.rs
+++ b/rts/motoko-rts-tests/src/gc.rs
@@ -285,8 +285,12 @@ fn check_dynamic_heap(
                     .as_usize();
             } else {
                 if incremental {
-                    assert!(tag == TAG_ARRAY_I || tag == TAG_ARRAY_M || tag == TAG_ARRAY_T
-                            || tag >= TAG_ARRAY_SLICE_MIN);
+                    assert!(
+                        tag == TAG_ARRAY_I
+                            || tag == TAG_ARRAY_M
+                            || tag == TAG_ARRAY_T
+                            || tag >= TAG_ARRAY_SLICE_MIN
+                    );
                 } else {
                     assert!(tag == TAG_ARRAY_I || tag == TAG_ARRAY_M || tag == TAG_ARRAY_T)
                 }
diff --git a/rts/motoko-rts-tests/src/gc/compacting/mark_stack.rs b/rts/motoko-rts-tests/src/gc/compacting/mark_stack.rs
index d27d44cf6b7..b5388c45a97 100644
--- a/rts/motoko-rts-tests/src/gc/compacting/mark_stack.rs
+++ b/rts/motoko-rts-tests/src/gc/compacting/mark_stack.rs
@@ -36,15 +36,23 @@ fn test_push_pop() {
 static TAGS: [Tag; 22] = [
     TAG_OBJECT,
     TAG_OBJ_IND,
-    TAG_ARRAY_I, TAG_ARRAY_M, TAG_ARRAY_T,
-    TAG_BITS64_U, TAG_BITS64_S, TAG_BITS64_F,
+    TAG_ARRAY_I,
+    TAG_ARRAY_M,
+    TAG_ARRAY_T,
+    TAG_BITS64_U,
+    TAG_BITS64_S,
+    TAG_BITS64_F,
     TAG_MUTBOX,
     TAG_CLOSURE,
     TAG_SOME,
     TAG_VARIANT,
-    TAG_BLOB_B, TAG_BLOB_T, TAG_BLOB_P,
+    TAG_BLOB_B,
+    TAG_BLOB_T,
+    TAG_BLOB_P,
     TAG_FWD_PTR,
-    TAG_BITS32_U, TAG_BITS32_S, TAG_BITS32_F,
+    TAG_BITS32_U,
+    TAG_BITS32_S,
+    TAG_BITS32_F,
     TAG_BIGINT,
     TAG_CONCAT,
     TAG_NULL,
diff --git a/rts/motoko-rts-tests/src/gc/incremental/partitioned_heap.rs b/rts/motoko-rts-tests/src/gc/incremental/partitioned_heap.rs
index 16c24e28ab5..a836344f41d 100644
--- a/rts/motoko-rts-tests/src/gc/incremental/partitioned_heap.rs
+++ b/rts/motoko-rts-tests/src/gc/incremental/partitioned_heap.rs
@@ -13,7 +13,10 @@ use motoko_rts::{
         time::BoundedTime,
     },
     memory::{alloc_array, alloc_blob, Memory},
-    types::{Array, Blob, Bytes, Obj, Tag, Value, Words, TAG_ARRAY_I, TAG_ARRAY_M, TAG_ARRAY_T, TAG_BLOB_B, TAG_BLOB_T, TAG_BLOB_P},
+    types::{
+        Array, Blob, Bytes, Obj, Tag, Value, Words, TAG_ARRAY_I, TAG_ARRAY_M, TAG_ARRAY_T,
+        TAG_BLOB_B, TAG_BLOB_P, TAG_BLOB_T,
+    },
 };
 
 use crate::{gc::utils::WORD_SIZE, memory::TestMemory};
@@ -415,7 +418,9 @@ unsafe fn block_size(block: *const Tag) -> usize {
         TAG_ARRAY_I | TAG_ARRAY_M | TAG_ARRAY_T => {
             size_of::<Array>() + (block as *const Array).len() as usize * WORD_SIZE as usize
         }
-        TAG_BLOB_B | TAG_BLOB_T | TAG_BLOB_P => size_of::<Blob>() + (block as *const Blob).len().as_usize(),
+        TAG_BLOB_B | TAG_BLOB_T | TAG_BLOB_P => {
+            size_of::<Blob>() + (block as *const Blob).len().as_usize()
+        }
         _ => unimplemented!(),
     }
 }
diff --git a/rts/motoko-rts-tests/src/principal_id.rs b/rts/motoko-rts-tests/src/principal_id.rs
index fbaf1812319..4495111f883 100644
--- a/rts/motoko-rts-tests/src/principal_id.rs
+++ b/rts/motoko-rts-tests/src/principal_id.rs
@@ -1,7 +1,7 @@
 use crate::memory::TestMemory;
 
 use motoko_rts::principal_id::{blob_of_principal, principal_of_blob};
-use motoko_rts::text::{text_compare, text_of_ptr_size, text_of_str, blob_compare};
+use motoko_rts::text::{blob_compare, text_compare, text_of_ptr_size, text_of_str};
 use motoko_rts::types::{Bytes, Words};
 
 pub unsafe fn test() {
diff --git a/rts/motoko-rts/src/allocator.rs b/rts/motoko-rts/src/allocator.rs
index d09da81629e..8111e3f4a52 100644
--- a/rts/motoko-rts/src/allocator.rs
+++ b/rts/motoko-rts/src/allocator.rs
@@ -24,7 +24,8 @@ unsafe impl GlobalAlloc for EphemeralAllocator {
         let min_align = (align + word_size - 1) / word_size * word_size;
         let blob_size = size + min_align - word_size;
         let blob =
-            alloc_blob::<ic::IcMemory>(&mut ic::IcMemory, TAG_BLOB_B, Bytes(blob_size as u32)).as_blob_mut();
+            alloc_blob::<ic::IcMemory>(&mut ic::IcMemory, TAG_BLOB_B, Bytes(blob_size as u32))
+                .as_blob_mut();
         let payload_address = blob.payload_addr() as usize;
         let aligned_address = (payload_address + min_align - 1) / min_align * min_align;
 
diff --git a/rts/motoko-rts/src/continuation_table.rs b/rts/motoko-rts/src/continuation_table.rs
index d162d6278b3..b1010254ad7 100644
--- a/rts/motoko-rts/src/continuation_table.rs
+++ b/rts/motoko-rts/src/continuation_table.rs
@@ -42,7 +42,7 @@ static mut N_CONTINUATIONS: u32 = 0;
 static mut FREE_SLOT: u32 = 0;
 
 unsafe fn create_continuation_table<M: Memory>(mem: &mut M) {
-    TABLE = alloc_array(mem, TAG_ARRAY_M,  INITIAL_SIZE);
+    TABLE = alloc_array(mem, TAG_ARRAY_M, INITIAL_SIZE);
     FREE_SLOT = 0;
     N_CONTINUATIONS = 0;
 
diff --git a/rts/motoko-rts/src/gc/incremental/array_slicing.rs b/rts/motoko-rts/src/gc/incremental/array_slicing.rs
index 7979bd16551..e74353a0a1b 100644
--- a/rts/motoko-rts/src/gc/incremental/array_slicing.rs
+++ b/rts/motoko-rts/src/gc/incremental/array_slicing.rs
@@ -9,9 +9,11 @@ pub unsafe fn slice_array(array: *mut Array) -> u32 {
     const SLICE_INCREMENT: u32 = 128;
     debug_assert!(SLICE_INCREMENT >= TAG_ARRAY_SLICE_MIN);
     let tag = (*array).header.tag;
-    let (sort, slice_start) =
-        if tag >= TAG_ARRAY_SLICE_MIN { (tag >> 30, tag << 2 >> 2) } else {
-        ((tag - TAG_ARRAY_I) / 2, 0) };
+    let (sort, slice_start) = if tag >= TAG_ARRAY_SLICE_MIN {
+        (tag >> 30, tag << 2 >> 2)
+    } else {
+        ((tag - TAG_ARRAY_I) / 2, 0)
+    };
     if array.len() - slice_start > SLICE_INCREMENT {
         let new_start = slice_start + SLICE_INCREMENT;
         (*array).header.tag = (sort << 30) | new_start;
diff --git a/rts/motoko-rts/src/gc/incremental/mark_stack.rs b/rts/motoko-rts/src/gc/incremental/mark_stack.rs
index 6a78a702cd2..e16dba65989 100644
--- a/rts/motoko-rts/src/gc/incremental/mark_stack.rs
+++ b/rts/motoko-rts/src/gc/incremental/mark_stack.rs
@@ -96,8 +96,8 @@ impl MarkStack {
 
     unsafe fn new_table<M: Memory>(mem: &mut M, previous: *mut StackTable) -> *mut StackTable {
         // No post allocation barrier as this RTS-internal blob will be collected by the GC.
-        let table =
-            alloc_blob(mem, TAG_BLOB_B, size_of::<StackTable>().to_bytes()).as_blob_mut() as *mut StackTable;
+        let table = alloc_blob(mem, TAG_BLOB_B, size_of::<StackTable>().to_bytes()).as_blob_mut()
+            as *mut StackTable;
         (*table).previous = previous;
         (*table).next = null_mut();
         if previous != null_mut() {
diff --git a/rts/motoko-rts/src/gc/remembered_set.rs b/rts/motoko-rts/src/gc/remembered_set.rs
index fe7d08a50f8..9904244af18 100644
--- a/rts/motoko-rts/src/gc/remembered_set.rs
+++ b/rts/motoko-rts/src/gc/remembered_set.rs
@@ -38,7 +38,7 @@ use core::ptr::null_mut;
 
 use crate::constants::WORD_SIZE;
 use crate::memory::{alloc_blob, Memory};
-use crate::types::{block_size, Blob, Bytes, TAG_BLOB_B, Value};
+use crate::types::{block_size, Blob, Bytes, Value, TAG_BLOB_B};
 
 pub struct RememberedSet {
     hash_table: *mut Blob,
@@ -224,7 +224,8 @@ impl RememberedSetIterator {
 
 unsafe fn new_table<M: Memory>(mem: &mut M, size: u32) -> *mut Blob {
     // No post allocation barrier as this RTS-internal blob will be collected by the GC.
-    let table = alloc_blob(mem, TAG_BLOB_B, Bytes(size * size_of::<HashEntry>() as u32)).as_blob_mut();
+    let table =
+        alloc_blob(mem, TAG_BLOB_B, Bytes(size * size_of::<HashEntry>() as u32)).as_blob_mut();
     for index in 0..size {
         table_set(table, index, null_ptr_value());
     }
@@ -234,8 +235,8 @@ unsafe fn new_table<M: Memory>(mem: &mut M, size: u32) -> *mut Blob {
 unsafe fn new_collision_node<M: Memory>(mem: &mut M, value: Value) -> *mut CollisionNode {
     debug_assert!(!is_null_ptr_value(value));
     // No post allocation barrier as this RTS-internal blob will be collected by the GC.
-    let node =
-        alloc_blob(mem, TAG_BLOB_B, Bytes(size_of::<HashEntry>() as u32)).as_blob_mut() as *mut CollisionNode;
+    let node = alloc_blob(mem, TAG_BLOB_B, Bytes(size_of::<HashEntry>() as u32)).as_blob_mut()
+        as *mut CollisionNode;
     (*node).entry = HashEntry {
         value,
         next_collision_ptr: null_mut(),
diff --git a/rts/motoko-rts/src/principal_id.rs b/rts/motoko-rts/src/principal_id.rs
index e8dfef2a069..94c4a238f05 100644
--- a/rts/motoko-rts/src/principal_id.rs
+++ b/rts/motoko-rts/src/principal_id.rs
@@ -98,7 +98,11 @@ pub unsafe fn base32_of_checksummed_blob<M: Memory>(mem: &mut M, b: Value) -> Va
     let n = b.as_blob().len();
     let mut data = b.as_blob().payload_const();
 
-    let r = alloc_blob(mem, TAG_BLOB_T /*?*/, Bytes((n.as_u32() + 4 + 4) / 5 * 8)); // contains padding
+    let r = alloc_blob(
+        mem,
+        TAG_BLOB_T, /*?*/
+        Bytes((n.as_u32() + 4 + 4) / 5 * 8),
+    ); // contains padding
     let blob = r.as_blob_mut();
     let dest = blob.payload_addr();
 
diff --git a/rts/motoko-rts/src/region.rs b/rts/motoko-rts/src/region.rs
index 07852e6e04e..e22ed5d554c 100644
--- a/rts/motoko-rts/src/region.rs
+++ b/rts/motoko-rts/src/region.rs
@@ -1,7 +1,7 @@
 use crate::barriers::{allocation_barrier, init_with_barrier, write_with_barrier};
 use crate::memory::{alloc_blob, Memory};
 use crate::trap_with_prefix;
-use crate::types::{size_of, Blob, Bytes, Region, Value, TAG_REGION, TAG_BLOB_B};
+use crate::types::{size_of, Blob, Bytes, Region, Value, TAG_BLOB_B, TAG_REGION};
 
 // Versions
 // Should agree with constants StableMem.version_no_stable_memory etc. in compile.ml
@@ -524,7 +524,11 @@ pub unsafe fn region_recover<M: Memory>(mem: &mut M, rid: &RegionId) -> Value {
     debug_assert!(page_count < (u32::MAX - (PAGES_IN_BLOCK - 1)));
 
     let block_count = (page_count + PAGES_IN_BLOCK - 1) / PAGES_IN_BLOCK;
-    let vec_pages = alloc_blob(mem, TAG_BLOB_B, Bytes(block_count * bytes_of::<u16>() as u32));
+    let vec_pages = alloc_blob(
+        mem,
+        TAG_BLOB_B,
+        Bytes(block_count * bytes_of::<u16>() as u32),
+    );
 
     let av = AccessVector(vec_pages.as_blob_mut());
     let mut recovered_blocks = 0;
diff --git a/rts/motoko-rts/src/text.rs b/rts/motoko-rts/src/text.rs
index cb283dd5c0a..eeea9275339 100644
--- a/rts/motoko-rts/src/text.rs
+++ b/rts/motoko-rts/src/text.rs
@@ -30,7 +30,9 @@ use crate::barriers::allocation_barrier;
 use crate::mem_utils::memcpy_bytes;
 use crate::memory::{alloc_blob, Memory};
 use crate::rts_trap_with;
-use crate::types::{size_of, Blob, Bytes, Concat, Stream, Value, TAG_BLOB_T, TAG_BLOB_B, TAG_CONCAT};
+use crate::types::{
+    size_of, Blob, Bytes, Concat, Stream, Value, TAG_BLOB_B, TAG_BLOB_T, TAG_CONCAT,
+};
 
 use alloc::string::String;
 use core::cmp::{min, Ordering};
diff --git a/rts/motoko-rts/src/text_iter.rs b/rts/motoko-rts/src/text_iter.rs
index 259c62de2c9..d74ec6c9deb 100644
--- a/rts/motoko-rts/src/text_iter.rs
+++ b/rts/motoko-rts/src/text_iter.rs
@@ -16,7 +16,7 @@ use crate::barriers::allocation_barrier;
 use crate::memory::{alloc_array, Memory};
 use crate::rts_trap_with;
 use crate::text::decode_code_point;
-use crate::types::{Array, Value, TAG_BLOB_T, TAG_ARRAY_T, TAG_CONCAT};
+use crate::types::{Array, Value, TAG_ARRAY_T, TAG_BLOB_T, TAG_CONCAT};
 
 use motoko_rts_macros::ic_mem_fn;
 
diff --git a/rts/motoko-rts/src/types.rs b/rts/motoko-rts/src/types.rs
index 5c8823351e2..1edcb217107 100644
--- a/rts/motoko-rts/src/types.rs
+++ b/rts/motoko-rts/src/types.rs
@@ -327,16 +327,15 @@ impl Value {
     }
 
     pub unsafe fn is_blob(self) -> bool {
-       let tag = self.tag();
-       tag == TAG_BLOB_B || tag == TAG_BLOB_T || tag == TAG_BLOB_P
+        let tag = self.tag();
+        tag == TAG_BLOB_B || tag == TAG_BLOB_T || tag == TAG_BLOB_P
     }
 
     pub unsafe fn is_array(self) -> bool {
-       let tag = self.tag();
-       tag == TAG_ARRAY_I || tag == TAG_ARRAY_M || tag == TAG_ARRAY_T || tag >= TAG_ARRAY_SLICE_MIN
+        let tag = self.tag();
+        tag == TAG_ARRAY_I || tag == TAG_ARRAY_M || tag == TAG_ARRAY_T || tag >= TAG_ARRAY_SLICE_MIN
     }
 
-
     /// Get the pointer as `Obj` using forwarding. In debug mode panics if the value is not a pointer.
     pub unsafe fn as_obj(self) -> *mut Obj {
         debug_assert!(self.get().is_ptr());
@@ -526,7 +525,7 @@ impl Obj {
 
     pub unsafe fn as_blob(self: *mut Self) -> *mut Blob {
         debug_assert!(
-             self.tag() == TAG_BLOB_B || self.tag() == TAG_BLOB_T || self.tag() == TAG_BLOB_P
+            self.tag() == TAG_BLOB_B || self.tag() == TAG_BLOB_T || self.tag() == TAG_BLOB_P
         );
         self as *mut Blob
     }
diff --git a/rts/motoko-rts/src/visitor.rs b/rts/motoko-rts/src/visitor.rs
index b592fbf2b9b..6b5c955a532 100644
--- a/rts/motoko-rts/src/visitor.rs
+++ b/rts/motoko-rts/src/visitor.rs
@@ -43,9 +43,12 @@ pub unsafe fn visit_pointer_fields<C, F, G>(
             }
         }
 
-        TAG_ARRAY_I | TAG_ARRAY_M | TAG_ARRAY_T
-            | TAG_ARRAY_SLICE_MIN.. => {
-            let slice_start = if tag >= TAG_ARRAY_SLICE_MIN { tag << 2 >> 2 } else { 0 };
+        TAG_ARRAY_I | TAG_ARRAY_M | TAG_ARRAY_T | TAG_ARRAY_SLICE_MIN.. => {
+            let slice_start = if tag >= TAG_ARRAY_SLICE_MIN {
+                tag << 2 >> 2
+            } else {
+                0
+            };
             let array = obj as *mut Array;
             let array_payload = array.payload_addr();
             let stop = visit_field_range(ctx, slice_start, array);
@@ -121,10 +124,8 @@ pub unsafe fn visit_pointer_fields<C, F, G>(
             }
         }
 
-        | TAG_BITS32_U | TAG_BITS32_S | TAG_BITS32_F
-        | TAG_BITS64_U | TAG_BITS64_S | TAG_BITS64_F
-        | TAG_BLOB_B | TAG_BLOB_T | TAG_BLOB_P
-        | TAG_BIGINT => {
+        TAG_BITS32_U | TAG_BITS32_S | TAG_BITS32_F | TAG_BITS64_U | TAG_BITS64_S | TAG_BITS64_F
+        | TAG_BLOB_B | TAG_BLOB_T | TAG_BLOB_P | TAG_BIGINT => {
             // These don't have pointers, skip
         }
 

From 30c91ee9dd77dcaf8d629ace7a56eccad94045a3 Mon Sep 17 00:00:00 2001
From: Claudio Russo <claudio@dfinity.org>
Date: Fri, 24 May 2024 16:34:09 +0100
Subject: [PATCH 220/260] adapt generational array slicing; updeate bench
 numbers

---
 rts/motoko-rts/src/gc/generational.rs              | 10 ++++++++--
 rts/motoko-rts/src/gc/incremental/array_slicing.rs |  2 +-
 test/bench/ok/bignum.drun-run-opt.ok               |  2 +-
 test/bench/ok/bignum.drun-run.ok                   |  2 +-
 test/bench/ok/heap-32.drun-run-opt.ok              |  4 ++--
 test/bench/ok/heap-32.drun-run.ok                  |  4 ++--
 test/bench/ok/palindrome.drun-run-opt.ok           | 12 ++++++------
 test/bench/ok/palindrome.drun-run.ok               | 12 ++++++------
 8 files changed, 27 insertions(+), 21 deletions(-)

diff --git a/rts/motoko-rts/src/gc/generational.rs b/rts/motoko-rts/src/gc/generational.rs
index 6b13927fe22..42e9d04c519 100644
--- a/rts/motoko-rts/src/gc/generational.rs
+++ b/rts/motoko-rts/src/gc/generational.rs
@@ -296,15 +296,21 @@ impl<'a, M: Memory> GenerationalGC<'a, M> {
             |gc, slice_start, array| {
                 const SLICE_INCREMENT: u32 = 255;
                 debug_assert!(SLICE_INCREMENT >= TAG_ARRAY_SLICE_MIN);
+                let tag = (*array).header.tag;
+                let sort = if tag >= TAG_ARRAY_SLICE_MIN {
+                    tag >> 30
+                } else {
+                    (tag - TAG_ARRAY_I) / 2
+                };
                 if array.len() - slice_start > SLICE_INCREMENT {
                     let new_start = slice_start + SLICE_INCREMENT;
                     // Remember to visit the array suffix later, store the next visit offset in the tag.
-                    (*array).header.tag = new_start;
+                    (*array).header.tag = (sort << 30) | new_start;
                     push_mark_stack(gc.heap.mem, array as usize);
                     new_start
                 } else {
                     // No further visits of this array. Restore the tag.
-                    (*array).header.tag = TAG_ARRAY_M; // TODO: restore precise tag!
+                    (*array).header.tag = TAG_ARRAY_I + sort * 2; // restore original tag
                     array.len()
                 }
             },
diff --git a/rts/motoko-rts/src/gc/incremental/array_slicing.rs b/rts/motoko-rts/src/gc/incremental/array_slicing.rs
index e74353a0a1b..12e695e421c 100644
--- a/rts/motoko-rts/src/gc/incremental/array_slicing.rs
+++ b/rts/motoko-rts/src/gc/incremental/array_slicing.rs
@@ -19,7 +19,7 @@ pub unsafe fn slice_array(array: *mut Array) -> u32 {
         (*array).header.tag = (sort << 30) | new_start;
         new_start
     } else {
-        (*array).header.tag = TAG_ARRAY_I + sort * 2; // TODO: restore original tag somehow
+        (*array).header.tag = TAG_ARRAY_I + sort * 2; // restore original tag
         array.len()
     }
 }
diff --git a/test/bench/ok/bignum.drun-run-opt.ok b/test/bench/ok/bignum.drun-run-opt.ok
index 007530eef47..ea48a3a0384 100644
--- a/test/bench/ok/bignum.drun-run-opt.ok
+++ b/test/bench/ok/bignum.drun-run-opt.ok
@@ -2,5 +2,5 @@ ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a000000000000000001
 ingress Completed: Reply: 0x4449444c0000
 debug.print: {cycles = 2_512_723; size = +59_652}
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 107_695_051; size = +1_817_872}
+debug.print: {cycles = 107_695_097; size = +1_817_872}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/bignum.drun-run.ok b/test/bench/ok/bignum.drun-run.ok
index b037729f278..f816a6e2671 100644
--- a/test/bench/ok/bignum.drun-run.ok
+++ b/test/bench/ok/bignum.drun-run.ok
@@ -2,5 +2,5 @@ ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a000000000000000001
 ingress Completed: Reply: 0x4449444c0000
 debug.print: {cycles = 2_619_856; size = +59_652}
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 107_890_020; size = +1_817_872}
+debug.print: {cycles = 107_890_038; size = +1_817_872}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/heap-32.drun-run-opt.ok b/test/bench/ok/heap-32.drun-run-opt.ok
index faf3bfb29da..9565f3e40ca 100644
--- a/test/bench/ok/heap-32.drun-run-opt.ok
+++ b/test/bench/ok/heap-32.drun-run-opt.ok
@@ -1,5 +1,5 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (50_227, +29_863_068, 708_174_952)
-debug.print: (50_070, +32_992_212, 766_613_680)
+debug.print: (50_227, +29_863_068, 708_174_961)
+debug.print: (50_070, +32_992_212, 766_613_689)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/heap-32.drun-run.ok b/test/bench/ok/heap-32.drun-run.ok
index f51bd0ff0c3..59ff737f097 100644
--- a/test/bench/ok/heap-32.drun-run.ok
+++ b/test/bench/ok/heap-32.drun-run.ok
@@ -1,5 +1,5 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (50_227, +29_863_068, 769_000_085)
-debug.print: (50_070, +32_992_212, 830_427_376)
+debug.print: (50_227, +29_863_068, 769_000_089)
+debug.print: (50_070, +32_992_212, 830_427_380)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/palindrome.drun-run-opt.ok b/test/bench/ok/palindrome.drun-run-opt.ok
index a1c6781e286..8750208bdef 100644
--- a/test/bench/ok/palindrome.drun-run-opt.ok
+++ b/test/bench/ok/palindrome.drun-run-opt.ok
@@ -1,9 +1,9 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (true, +1_188, 11_393)
-debug.print: (false, +1_188, 10_488)
-debug.print: (false, +1_188, 11_373)
-debug.print: (true, +868, 11_589)
-debug.print: (false, +868, 10_160)
-debug.print: (false, +868, 11_540)
+debug.print: (true, +1_188, 11_394)
+debug.print: (false, +1_188, 10_489)
+debug.print: (false, +1_188, 11_374)
+debug.print: (true, +868, 11_590)
+debug.print: (false, +868, 10_161)
+debug.print: (false, +868, 11_541)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/palindrome.drun-run.ok b/test/bench/ok/palindrome.drun-run.ok
index 3bbcfef98a7..91b2581fc37 100644
--- a/test/bench/ok/palindrome.drun-run.ok
+++ b/test/bench/ok/palindrome.drun-run.ok
@@ -1,9 +1,9 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (true, +1_188, 12_669)
-debug.print: (false, +1_188, 11_718)
-debug.print: (false, +1_188, 12_648)
-debug.print: (true, +868, 12_777)
-debug.print: (false, +868, 11_240)
-debug.print: (false, +868, 12_725)
+debug.print: (true, +1_188, 12_670)
+debug.print: (false, +1_188, 11_719)
+debug.print: (false, +1_188, 12_649)
+debug.print: (true, +868, 12_778)
+debug.print: (false, +868, 11_241)
+debug.print: (false, +868, 12_726)
 ingress Completed: Reply: 0x4449444c0000

From 28d98e031c85f5ab068ce94ee10e752b9b3c12dd Mon Sep 17 00:00:00 2001
From: Claudio Russo <claudio@dfinity.org>
Date: Thu, 30 May 2024 12:24:37 +0100
Subject: [PATCH 221/260] fix blob comparistion in patterns

---
 src/codegen/compile.ml | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index a68ad9b9150..cd7656ca095 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -12224,10 +12224,12 @@ and compile_lit_pat env l =
   | CharLit _ ->
     compile_lit_as env SR.Vanilla l ^^
     compile_eq env Type.(Prim Char)
-  | TextLit t
-  | BlobLit t ->
+  | TextLit t ->
     compile_lit_as env SR.Vanilla l ^^
     Text.compare env Operator.EqOp
+  | BlobLit t ->
+    compile_lit_as env SR.Vanilla l ^^
+    Blob.compare env (Some Operator.EqOp)
   | FloatLit _ ->
     todo_trap env "compile_lit_pat" (Arrange_ir.lit l)
 

From 4310118812fdc70e5d36399120e4d7dafa6f39e1 Mon Sep 17 00:00:00 2001
From: Claudio Russo <claudio@dfinity.org>
Date: Thu, 30 May 2024 14:00:53 +0100
Subject: [PATCH 222/260] refactor slicing

---
 rts/motoko-rts/src/gc/generational.rs         | 11 +++-----
 .../src/gc/incremental/array_slicing.rs       | 11 +++-----
 rts/motoko-rts/src/types.rs                   | 27 +++++++++++++++++++
 3 files changed, 33 insertions(+), 16 deletions(-)

diff --git a/rts/motoko-rts/src/gc/generational.rs b/rts/motoko-rts/src/gc/generational.rs
index 42e9d04c519..a81c676134f 100644
--- a/rts/motoko-rts/src/gc/generational.rs
+++ b/rts/motoko-rts/src/gc/generational.rs
@@ -296,21 +296,16 @@ impl<'a, M: Memory> GenerationalGC<'a, M> {
             |gc, slice_start, array| {
                 const SLICE_INCREMENT: u32 = 255;
                 debug_assert!(SLICE_INCREMENT >= TAG_ARRAY_SLICE_MIN);
-                let tag = (*array).header.tag;
-                let sort = if tag >= TAG_ARRAY_SLICE_MIN {
-                    tag >> 30
-                } else {
-                    (tag - TAG_ARRAY_I) / 2
-                };
+                let sort = array.sort();
                 if array.len() - slice_start > SLICE_INCREMENT {
                     let new_start = slice_start + SLICE_INCREMENT;
                     // Remember to visit the array suffix later, store the next visit offset in the tag.
-                    (*array).header.tag = (sort << 30) | new_start;
+                    array.set_slice_start(sort, new_start);
                     push_mark_stack(gc.heap.mem, array as usize);
                     new_start
                 } else {
                     // No further visits of this array. Restore the tag.
-                    (*array).header.tag = TAG_ARRAY_I + sort * 2; // restore original tag
+                    array.restore_tag(sort); // restore original tag
                     array.len()
                 }
             },
diff --git a/rts/motoko-rts/src/gc/incremental/array_slicing.rs b/rts/motoko-rts/src/gc/incremental/array_slicing.rs
index 12e695e421c..92e0d2f2afd 100644
--- a/rts/motoko-rts/src/gc/incremental/array_slicing.rs
+++ b/rts/motoko-rts/src/gc/incremental/array_slicing.rs
@@ -8,18 +8,13 @@ use crate::types::*;
 pub unsafe fn slice_array(array: *mut Array) -> u32 {
     const SLICE_INCREMENT: u32 = 128;
     debug_assert!(SLICE_INCREMENT >= TAG_ARRAY_SLICE_MIN);
-    let tag = (*array).header.tag;
-    let (sort, slice_start) = if tag >= TAG_ARRAY_SLICE_MIN {
-        (tag >> 30, tag << 2 >> 2)
-    } else {
-        ((tag - TAG_ARRAY_I) / 2, 0)
-    };
+    let (sort, slice_start) = array.get_slice_start();
     if array.len() - slice_start > SLICE_INCREMENT {
         let new_start = slice_start + SLICE_INCREMENT;
-        (*array).header.tag = (sort << 30) | new_start;
+        array.set_slice_start(sort, new_start);
         new_start
     } else {
-        (*array).header.tag = TAG_ARRAY_I + sort * 2; // restore original tag
+        array.restore_tag(sort);
         array.len()
     }
 }
diff --git a/rts/motoko-rts/src/types.rs b/rts/motoko-rts/src/types.rs
index 1edcb217107..08290a30cf3 100644
--- a/rts/motoko-rts/src/types.rs
+++ b/rts/motoko-rts/src/types.rs
@@ -592,6 +592,33 @@ impl Array {
     pub unsafe fn len(self: *const Self) -> u32 {
         (*self).len
     }
+
+    pub unsafe fn sort(self: *const Self) -> u32 {
+        if (*self).header.tag >= TAG_ARRAY_SLICE_MIN {
+            (*self).header.tag >> 30
+        }
+        else {
+           ((*self).header.tag - TAG_ARRAY_I) / 2
+        }
+    }
+
+    pub unsafe fn get_slice_start(self: *const Self) -> (u32, u32) {
+        if (*self).header.tag >= TAG_ARRAY_SLICE_MIN {
+           ((*self).header.tag >> 30, (*self).header.tag << 2 >> 2)
+        }
+        else {
+           (((*self).header.tag - TAG_ARRAY_I) / 2, 0)
+        }
+    }
+
+    pub unsafe fn set_slice_start(self: *mut Self, sort: u32, start: u32) -> ()     {
+        (*self).header.tag = sort << 30 | start
+    }
+
+    pub unsafe fn restore_tag(self: *mut Self, sort: u32) -> () {
+        (*self).header.tag = TAG_ARRAY_I + sort * 2
+    }
+
 }
 
 #[rustfmt::skip]

From 448962fff0c6207f0a93b9a8b854723a3551c643 Mon Sep 17 00:00:00 2001
From: Claudio Russo <claudio@dfinity.org>
Date: Thu, 30 May 2024 14:18:51 +0100
Subject: [PATCH 223/260] hide encoding of array tags in helpers

---
 rts/motoko-rts/src/gc/generational.rs         |  6 ++--
 .../src/gc/incremental/array_slicing.rs       |  6 ++--
 rts/motoko-rts/src/types.rs                   | 29 +++++++++----------
 rts/motoko-rts/src/visitor.rs                 |  6 +---
 4 files changed, 21 insertions(+), 26 deletions(-)

diff --git a/rts/motoko-rts/src/gc/generational.rs b/rts/motoko-rts/src/gc/generational.rs
index a81c676134f..a77be350587 100644
--- a/rts/motoko-rts/src/gc/generational.rs
+++ b/rts/motoko-rts/src/gc/generational.rs
@@ -296,16 +296,16 @@ impl<'a, M: Memory> GenerationalGC<'a, M> {
             |gc, slice_start, array| {
                 const SLICE_INCREMENT: u32 = 255;
                 debug_assert!(SLICE_INCREMENT >= TAG_ARRAY_SLICE_MIN);
-                let sort = array.sort();
+                let base_tag = array.base_tag();
                 if array.len() - slice_start > SLICE_INCREMENT {
                     let new_start = slice_start + SLICE_INCREMENT;
                     // Remember to visit the array suffix later, store the next visit offset in the tag.
-                    array.set_slice_start(sort, new_start);
+                    array.set_slice_start(base_tag, new_start);
                     push_mark_stack(gc.heap.mem, array as usize);
                     new_start
                 } else {
                     // No further visits of this array. Restore the tag.
-                    array.restore_tag(sort); // restore original tag
+                    array.restore_tag(base_tag); // restore original tag
                     array.len()
                 }
             },
diff --git a/rts/motoko-rts/src/gc/incremental/array_slicing.rs b/rts/motoko-rts/src/gc/incremental/array_slicing.rs
index 92e0d2f2afd..a18fcb72217 100644
--- a/rts/motoko-rts/src/gc/incremental/array_slicing.rs
+++ b/rts/motoko-rts/src/gc/incremental/array_slicing.rs
@@ -8,13 +8,13 @@ use crate::types::*;
 pub unsafe fn slice_array(array: *mut Array) -> u32 {
     const SLICE_INCREMENT: u32 = 128;
     debug_assert!(SLICE_INCREMENT >= TAG_ARRAY_SLICE_MIN);
-    let (sort, slice_start) = array.get_slice_start();
+    let (base_tag, slice_start) = array.get_slice_start();
     if array.len() - slice_start > SLICE_INCREMENT {
         let new_start = slice_start + SLICE_INCREMENT;
-        array.set_slice_start(sort, new_start);
+        array.set_slice_start(base_tag, new_start);
         new_start
     } else {
-        array.restore_tag(sort);
+        array.restore_tag(base_tag);
         array.len()
     }
 }
diff --git a/rts/motoko-rts/src/types.rs b/rts/motoko-rts/src/types.rs
index 08290a30cf3..d84834f6fd0 100644
--- a/rts/motoko-rts/src/types.rs
+++ b/rts/motoko-rts/src/types.rs
@@ -593,32 +593,31 @@ impl Array {
         (*self).len
     }
 
-    pub unsafe fn sort(self: *const Self) -> u32 {
+    pub unsafe fn base_tag(self: *const Self) -> Tag {
         if (*self).header.tag >= TAG_ARRAY_SLICE_MIN {
-            (*self).header.tag >> 30
-        }
-        else {
-           ((*self).header.tag - TAG_ARRAY_I) / 2
+            TAG_ARRAY_I + ((*self).header.tag >> 30) * 2
+        } else {
+            (*self).header.tag
         }
     }
 
-    pub unsafe fn get_slice_start(self: *const Self) -> (u32, u32) {
+    pub unsafe fn get_slice_start(self: *const Self) -> (Tag, u32) {
         if (*self).header.tag >= TAG_ARRAY_SLICE_MIN {
-           ((*self).header.tag >> 30, (*self).header.tag << 2 >> 2)
-        }
-        else {
-           (((*self).header.tag - TAG_ARRAY_I) / 2, 0)
+            let tag = TAG_ARRAY_I + ((*self).header.tag >> 30) * 2;
+            (tag, (*self).header.tag << 2 >> 2)
+        } else {
+            ((*self).header.tag, 0)
         }
     }
 
-    pub unsafe fn set_slice_start(self: *mut Self, sort: u32, start: u32) -> ()     {
-        (*self).header.tag = sort << 30 | start
+    pub unsafe fn set_slice_start(self: *mut Self, base_tag: Tag, start: u32) -> () {
+        let compressed_tag = (base_tag - TAG_ARRAY_I) / 2;
+        (*self).header.tag = compressed_tag << 30 | start
     }
 
-    pub unsafe fn restore_tag(self: *mut Self, sort: u32) -> () {
-        (*self).header.tag = TAG_ARRAY_I + sort * 2
+    pub unsafe fn restore_tag(self: *mut Self, base_tag: Tag) -> () {
+        (*self).header.tag = base_tag;
     }
-
 }
 
 #[rustfmt::skip]
diff --git a/rts/motoko-rts/src/visitor.rs b/rts/motoko-rts/src/visitor.rs
index 6b5c955a532..f1b8279d745 100644
--- a/rts/motoko-rts/src/visitor.rs
+++ b/rts/motoko-rts/src/visitor.rs
@@ -44,12 +44,8 @@ pub unsafe fn visit_pointer_fields<C, F, G>(
         }
 
         TAG_ARRAY_I | TAG_ARRAY_M | TAG_ARRAY_T | TAG_ARRAY_SLICE_MIN.. => {
-            let slice_start = if tag >= TAG_ARRAY_SLICE_MIN {
-                tag << 2 >> 2
-            } else {
-                0
-            };
             let array = obj as *mut Array;
+            let (_, slice_start) = array.get_slice_start();
             let array_payload = array.payload_addr();
             let stop = visit_field_range(ctx, slice_start, array);
             debug_assert!(stop <= array.len());

From 2cb651a56573fc8878f4e56f3a86295134ba0acc Mon Sep 17 00:00:00 2001
From: Claudio Russo <claudio@dfinity.org>
Date: Thu, 30 May 2024 18:44:30 +0100
Subject: [PATCH 224/260] refactor array_slicing

---
 rts/motoko-rts/src/types.rs   | 56 +++++++++++++++++++++++++----------
 rts/motoko-rts/src/visitor.rs |  3 +-
 2 files changed, 42 insertions(+), 17 deletions(-)

diff --git a/rts/motoko-rts/src/types.rs b/rts/motoko-rts/src/types.rs
index d84834f6fd0..cd23f277874 100644
--- a/rts/motoko-rts/src/types.rs
+++ b/rts/motoko-rts/src/types.rs
@@ -489,6 +489,40 @@ pub const TAG_FREE_SPACE: Tag = 49;
 //            higher than all other tags defined above
 pub const TAG_ARRAY_SLICE_MIN: Tag = 50;
 
+pub fn slice_tag(array_tag: Tag, slice_start: u32) -> Tag {
+    debug_assert!(array_tag == TAG_ARRAY_I || array_tag == TAG_ARRAY_M || array_tag == TAG_ARRAY_T);
+    debug_assert!(slice_start >= TAG_ARRAY_SLICE_MIN && slice_start < (1 << 30));
+    (((array_tag - TAG_ARRAY_I) / 2) << 30) | slice_start
+}
+
+pub fn slice_start(tag: Tag) -> (Tag, u32) {
+    debug_assert!(
+        tag == TAG_ARRAY_I
+            || tag == TAG_ARRAY_M
+            || tag == TAG_ARRAY_T
+            || tag >= TAG_ARRAY_SLICE_MIN
+    );
+    if tag >= TAG_ARRAY_SLICE_MIN {
+        (TAG_ARRAY_I + (tag >> 30) * 2, tag << 2 >> 2)
+    } else {
+        (tag, 0)
+    }
+}
+
+pub fn base_array_tag(tag: Tag) -> Tag {
+    debug_assert!(
+        tag == TAG_ARRAY_I
+            || tag == TAG_ARRAY_M
+            || tag == TAG_ARRAY_T
+            || tag >= TAG_ARRAY_SLICE_MIN
+    );
+    if tag >= TAG_ARRAY_SLICE_MIN {
+        TAG_ARRAY_I + (tag >> 30) * 2
+    } else {
+        tag
+    }
+}
+
 // Common parts of any object. Other object pointers can be coerced into a pointer to this.
 #[repr(C)] // See the note at the beginning of this module
 pub struct Obj {
@@ -594,29 +628,19 @@ impl Array {
     }
 
     pub unsafe fn base_tag(self: *const Self) -> Tag {
-        if (*self).header.tag >= TAG_ARRAY_SLICE_MIN {
-            TAG_ARRAY_I + ((*self).header.tag >> 30) * 2
-        } else {
-            (*self).header.tag
-        }
+        base_array_tag((*self).header.tag)
     }
 
     pub unsafe fn get_slice_start(self: *const Self) -> (Tag, u32) {
-        if (*self).header.tag >= TAG_ARRAY_SLICE_MIN {
-            let tag = TAG_ARRAY_I + ((*self).header.tag >> 30) * 2;
-            (tag, (*self).header.tag << 2 >> 2)
-        } else {
-            ((*self).header.tag, 0)
-        }
+        slice_start((*self).header.tag)
     }
 
-    pub unsafe fn set_slice_start(self: *mut Self, base_tag: Tag, start: u32) -> () {
-        let compressed_tag = (base_tag - TAG_ARRAY_I) / 2;
-        (*self).header.tag = compressed_tag << 30 | start
+    pub unsafe fn set_slice_start(self: *mut Self, array_tag: Tag, start: u32) -> () {
+        (*self).header.tag = slice_tag(array_tag, start)
     }
 
-    pub unsafe fn restore_tag(self: *mut Self, base_tag: Tag) -> () {
-        (*self).header.tag = base_tag;
+    pub unsafe fn restore_tag(self: *mut Self, array_tag: Tag) -> () {
+        (*self).header.tag = array_tag;
     }
 }
 
diff --git a/rts/motoko-rts/src/visitor.rs b/rts/motoko-rts/src/visitor.rs
index f1b8279d745..27c2f84fa12 100644
--- a/rts/motoko-rts/src/visitor.rs
+++ b/rts/motoko-rts/src/visitor.rs
@@ -44,8 +44,9 @@ pub unsafe fn visit_pointer_fields<C, F, G>(
         }
 
         TAG_ARRAY_I | TAG_ARRAY_M | TAG_ARRAY_T | TAG_ARRAY_SLICE_MIN.. => {
+            let (_, slice_start) = slice_start(tag);
             let array = obj as *mut Array;
-            let (_, slice_start) = array.get_slice_start();
+            debug_assert!(slice_start <= array.len());
             let array_payload = array.payload_addr();
             let stop = visit_field_range(ctx, slice_start, array);
             debug_assert!(stop <= array.len());

From b44b133405e24cc9f794d02c338871211a0b1adc Mon Sep 17 00:00:00 2001
From: Claudio Russo <claudio@dfinity.org>
Date: Fri, 31 May 2024 11:35:06 +0100
Subject: [PATCH 225/260] extern array_slicing test

---
 .../src/gc/incremental/array_slicing.rs       | 30 +++++++++++--------
 1 file changed, 17 insertions(+), 13 deletions(-)

diff --git a/rts/motoko-rts-tests/src/gc/incremental/array_slicing.rs b/rts/motoko-rts-tests/src/gc/incremental/array_slicing.rs
index 57505d0986e..fc180b091dc 100644
--- a/rts/motoko-rts-tests/src/gc/incremental/array_slicing.rs
+++ b/rts/motoko-rts-tests/src/gc/incremental/array_slicing.rs
@@ -1,7 +1,7 @@
 use motoko_rts::{
     gc::incremental::array_slicing::slice_array,
     memory::alloc_array,
-    types::{Words, TAG_ARRAY_M, TAG_ARRAY_SLICE_MIN},
+    types::{Tag, Words, TAG_ARRAY_I, TAG_ARRAY_M, TAG_ARRAY_SLICE_MIN, TAG_ARRAY_T},
 };
 
 use crate::memory::TestMemory;
@@ -9,25 +9,29 @@ use crate::memory::TestMemory;
 pub unsafe fn test() {
     println!("  Testing array slicing...");
 
-    let mut mem = TestMemory::new(Words(1024 * 1024));
-    // multiple of slice increment
-    test_array_slicing(&mut mem, 4096);
-    // odd remainder of slice increment
-    test_array_slicing(&mut mem, 3999);
-    // small array
-    test_array_slicing(&mut mem, 10);
-    // empty array
-    test_array_slicing(&mut mem, 0);
+    let tags = vec![TAG_ARRAY_I, TAG_ARRAY_M, TAG_ARRAY_T];
+
+    for tag in tags.into_iter() {
+        let mut mem = TestMemory::new(Words(1024 * 1024));
+        // multiple of slice increment
+        test_array_slicing(&mut mem, tag, 4096);
+        // odd remainder of slice increment
+        test_array_slicing(&mut mem, tag, 3999);
+        // small array
+        test_array_slicing(&mut mem, tag, 10);
+        // empty array
+        test_array_slicing(&mut mem, tag, 0);
+    }
 }
 
-unsafe fn test_array_slicing(mem: &mut TestMemory, array_length: u32) {
-    let array = alloc_array(mem, TAG_ARRAY_M, array_length).as_array();
+unsafe fn test_array_slicing(mem: &mut TestMemory, tag: Tag, array_length: u32) {
+    let array = alloc_array(mem, tag, array_length).as_array();
     let mut last_offset = 0;
     loop {
         let new_offset = slice_array(array);
         assert!(new_offset > last_offset || array.len() == 0 && new_offset == 0);
         last_offset = new_offset;
-        if (*array).header.tag == TAG_ARRAY_M {
+        if (*array).header.tag == tag {
             break;
         }
         assert!((*array).header.tag >= TAG_ARRAY_SLICE_MIN);

From 8dbe8854d7fc102bd4df16969485b9fc01276eb7 Mon Sep 17 00:00:00 2001
From: Claudio Russo <claudio@dfinity.org>
Date: Fri, 31 May 2024 14:37:08 +0100
Subject: [PATCH 226/260] add basic tag checking on unboxing of new tags

---
 src/codegen/compile.ml | 33 +++++++++++++++++++++++++++++----
 1 file changed, 29 insertions(+), 4 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index cd7656ca095..80b9acef0bb 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -2129,6 +2129,21 @@ module Tagged = struct
     load_forwarding_pointer env ^^
     Heap.load_field tag_field
 
+  let sanity_check_tag env tag =
+    let tag = int_of_tag tag in
+    let name = "sanity_check_tag_" ^ Int32.to_string tag in
+    if TaggingScheme.debug || !Flags.sanity then
+      Func.share_code1 Func.Always env name ("obj", I32Type) [I32Type]
+        (fun env get_obj ->
+         get_obj ^^
+         load_tag env  ^^
+         compile_unboxed_const tag ^^
+         G.i (Compare (Wasm.Values.I32 I32Op.Eq)) ^^
+         E.else_trap_with env name ^^
+         get_obj)
+    else
+      G.nop
+
   let check_forwarding env unskewed =
     (if !Flags.gc_strategy = Flags.Incremental then
       let name = "check_forwarding_" ^ if unskewed then "unskewed" else "skewed" in
@@ -2624,7 +2639,10 @@ module BoxedWord64 = struct
       get_n ^^
       BitTagged.if_tagged_scalar env [I64Type]
         (get_n ^^ BitTagged.untag __LINE__ env pty)
-        (get_n ^^ Tagged.load_forwarding_pointer env ^^ Tagged.load_field64 env (payload_field env))
+        (get_n ^^
+         Tagged.load_forwarding_pointer env ^^
+         Tagged.(sanity_check_tag env (heap_tag env pty)) ^^
+         Tagged.load_field64 env (payload_field env))
     )
 end (* BoxedWord64 *)
 
@@ -2760,7 +2778,10 @@ module BoxedSmallWord = struct
       get_n ^^
       BitTagged.if_tagged_scalar env [I32Type]
         (get_n ^^ BitTagged.untag_i32 __LINE__ env pty)
-        (get_n ^^ Tagged.load_forwarding_pointer env ^^ Tagged.load_field env (payload_field env))
+        (get_n ^^
+         Tagged.load_forwarding_pointer env ^^
+         Tagged.(sanity_check_tag env (heap_tag env pty)) ^^
+         Tagged.load_field env (payload_field env))
     )
 
   let _lit env pty n = compile_unboxed_const n ^^ box env pty
@@ -3025,7 +3046,10 @@ module Float = struct
     Tagged.allocation_barrier env
   )
 
-  let unbox env = Tagged.load_forwarding_pointer env ^^ Tagged.load_field_float64 env (payload_field env)
+  let unbox env =
+    Tagged.load_forwarding_pointer env ^^
+    Tagged.(sanity_check_tag env (Bits64 F)) ^^
+    Tagged.load_field_float64 env (payload_field env)
 
 end (* Float *)
 
@@ -4265,7 +4289,7 @@ module Blob = struct
   let alloc env sort len =
     compile_unboxed_const Tagged.(int_of_tag (Blob sort)) ^^
     len ^^
-    E.call_import env "rts" "alloc_blob" ^^ (*TODO sorts!*)
+    E.call_import env "rts" "alloc_blob" ^^
     (* uninitialized blob payload is allowed by the barrier *)
     Tagged.allocation_barrier env
 
@@ -4871,6 +4895,7 @@ module Tuple = struct
   (* Expects on the stack the pointer to the array. *)
   let load_n env n =
     Tagged.load_forwarding_pointer env ^^
+    Tagged.(sanity_check_tag env (Array T)) ^^
     Tagged.load_field env (Int32.add (Arr.header_size env) n)
 
   (* Takes n elements of the stack and produces an argument tuple *)

From ac886156c77ad817fe88c930bce9090f0ed94257 Mon Sep 17 00:00:00 2001
From: Claudio Russo <claudio@dfinity.org>
Date: Fri, 31 May 2024 18:14:33 +0100
Subject: [PATCH 227/260] refine tags for actors and shared functions,
 TAG_BLOB_A and TAB_ARRAY_S

---
 rts/motoko-rts-tests/src/gc.rs                |  6 +-
 .../src/gc/compacting/mark_stack.rs           |  4 +-
 .../src/gc/incremental/array_slicing.rs       |  5 +-
 .../src/gc/incremental/partitioned_heap.rs    |  9 +-
 rts/motoko-rts/src/debug.rs                   |  2 +-
 rts/motoko-rts/src/types.rs                   | 60 +++++++------
 rts/motoko-rts/src/visitor.rs                 |  4 +-
 src/codegen/compile.ml                        | 88 ++++++++++++-------
 src/prelude/internals.mo                      |  4 +-
 src/prelude/prim.mo                           |  6 +-
 10 files changed, 112 insertions(+), 76 deletions(-)

diff --git a/rts/motoko-rts-tests/src/gc.rs b/rts/motoko-rts-tests/src/gc.rs
index e390295e425..a0b5175d126 100644
--- a/rts/motoko-rts-tests/src/gc.rs
+++ b/rts/motoko-rts-tests/src/gc.rs
@@ -289,10 +289,14 @@ fn check_dynamic_heap(
                         tag == TAG_ARRAY_I
                             || tag == TAG_ARRAY_M
                             || tag == TAG_ARRAY_T
+                            || tag == TAG_ARRAY_S
                             || tag >= TAG_ARRAY_SLICE_MIN
                     );
                 } else {
-                    assert!(tag == TAG_ARRAY_I || tag == TAG_ARRAY_M || tag == TAG_ARRAY_T)
+                    assert!(tag == TAG_ARRAY_I
+                            || tag == TAG_ARRAY_M
+                            || tag == TAG_ARRAY_T
+                            || tag == TAG_ARRAY_S)
                 }
 
                 if is_forwarded {
diff --git a/rts/motoko-rts-tests/src/gc/compacting/mark_stack.rs b/rts/motoko-rts-tests/src/gc/compacting/mark_stack.rs
index b5388c45a97..f8e494bdf63 100644
--- a/rts/motoko-rts-tests/src/gc/compacting/mark_stack.rs
+++ b/rts/motoko-rts-tests/src/gc/compacting/mark_stack.rs
@@ -33,12 +33,13 @@ fn test_push_pop() {
         .unwrap();
 }
 
-static TAGS: [Tag; 22] = [
+static TAGS: [Tag; 24] = [
     TAG_OBJECT,
     TAG_OBJ_IND,
     TAG_ARRAY_I,
     TAG_ARRAY_M,
     TAG_ARRAY_T,
+    TAG_ARRAY_S,
     TAG_BITS64_U,
     TAG_BITS64_S,
     TAG_BITS64_F,
@@ -49,6 +50,7 @@ static TAGS: [Tag; 22] = [
     TAG_BLOB_B,
     TAG_BLOB_T,
     TAG_BLOB_P,
+    TAG_BLOB_A,
     TAG_FWD_PTR,
     TAG_BITS32_U,
     TAG_BITS32_S,
diff --git a/rts/motoko-rts-tests/src/gc/incremental/array_slicing.rs b/rts/motoko-rts-tests/src/gc/incremental/array_slicing.rs
index fc180b091dc..1320f9b1239 100644
--- a/rts/motoko-rts-tests/src/gc/incremental/array_slicing.rs
+++ b/rts/motoko-rts-tests/src/gc/incremental/array_slicing.rs
@@ -1,7 +1,8 @@
 use motoko_rts::{
     gc::incremental::array_slicing::slice_array,
     memory::alloc_array,
-    types::{Tag, Words, TAG_ARRAY_I, TAG_ARRAY_M, TAG_ARRAY_SLICE_MIN, TAG_ARRAY_T},
+    types::{Tag, Words,
+            TAG_ARRAY_I, TAG_ARRAY_M, TAG_ARRAY_T, TAG_ARRAY_S, TAG_ARRAY_SLICE_MIN },
 };
 
 use crate::memory::TestMemory;
@@ -9,7 +10,7 @@ use crate::memory::TestMemory;
 pub unsafe fn test() {
     println!("  Testing array slicing...");
 
-    let tags = vec![TAG_ARRAY_I, TAG_ARRAY_M, TAG_ARRAY_T];
+    let tags = vec![TAG_ARRAY_I, TAG_ARRAY_M, TAG_ARRAY_T, TAG_ARRAY_S];
 
     for tag in tags.into_iter() {
         let mut mem = TestMemory::new(Words(1024 * 1024));
diff --git a/rts/motoko-rts-tests/src/gc/incremental/partitioned_heap.rs b/rts/motoko-rts-tests/src/gc/incremental/partitioned_heap.rs
index a836344f41d..56b5eebd837 100644
--- a/rts/motoko-rts-tests/src/gc/incremental/partitioned_heap.rs
+++ b/rts/motoko-rts-tests/src/gc/incremental/partitioned_heap.rs
@@ -14,8 +14,9 @@ use motoko_rts::{
     },
     memory::{alloc_array, alloc_blob, Memory},
     types::{
-        Array, Blob, Bytes, Obj, Tag, Value, Words, TAG_ARRAY_I, TAG_ARRAY_M, TAG_ARRAY_T,
-        TAG_BLOB_B, TAG_BLOB_P, TAG_BLOB_T,
+        Array, Blob, Bytes, Obj, Tag, Value, Words,
+        TAG_ARRAY_I, TAG_ARRAY_M, TAG_ARRAY_T, TAG_ARRAY_S,
+        TAG_BLOB_B, TAG_BLOB_P, TAG_BLOB_T, TAG_BLOB_A
     },
 };
 
@@ -415,10 +416,10 @@ impl PartitionedTestHeap {
 
 unsafe fn block_size(block: *const Tag) -> usize {
     match *block {
-        TAG_ARRAY_I | TAG_ARRAY_M | TAG_ARRAY_T => {
+        TAG_ARRAY_I | TAG_ARRAY_M | TAG_ARRAY_T | TAG_ARRAY_S => {
             size_of::<Array>() + (block as *const Array).len() as usize * WORD_SIZE as usize
         }
-        TAG_BLOB_B | TAG_BLOB_T | TAG_BLOB_P => {
+        TAG_BLOB_B | TAG_BLOB_T | TAG_BLOB_P | TAG_BLOB_A => {
             size_of::<Blob>() + (block as *const Blob).len().as_usize()
         }
         _ => unimplemented!(),
diff --git a/rts/motoko-rts/src/debug.rs b/rts/motoko-rts/src/debug.rs
index 2a97b423a1f..bf71cd1e90f 100644
--- a/rts/motoko-rts/src/debug.rs
+++ b/rts/motoko-rts/src/debug.rs
@@ -165,7 +165,7 @@ pub(crate) unsafe fn print_boxed_object(buf: &mut WriteBuf, p: usize) {
             let obj_ind = obj as *const ObjInd;
             let _ = write!(buf, "<ObjInd field={:#x}>", (*obj_ind).field.get_raw());
         }
-        TAG_ARRAY_I | TAG_ARRAY_M | TAG_ARRAY_T | TAG_ARRAY_SLICE_MIN.. => {
+        TAG_ARRAY_I | TAG_ARRAY_M | TAG_ARRAY_T | TAG_ARRAY_S | TAG_ARRAY_SLICE_MIN.. => {
             let array = obj as *mut Array;
             let _ = write!(buf, "<Array len={:#x}", (*array).len);
 
diff --git a/rts/motoko-rts/src/types.rs b/rts/motoko-rts/src/types.rs
index cd23f277874..5625b840b98 100644
--- a/rts/motoko-rts/src/types.rs
+++ b/rts/motoko-rts/src/types.rs
@@ -328,12 +328,12 @@ impl Value {
 
     pub unsafe fn is_blob(self) -> bool {
         let tag = self.tag();
-        tag == TAG_BLOB_B || tag == TAG_BLOB_T || tag == TAG_BLOB_P
+        tag == TAG_BLOB_B || tag == TAG_BLOB_T || tag == TAG_BLOB_P || tag == TAG_BLOB_A
     }
 
     pub unsafe fn is_array(self) -> bool {
         let tag = self.tag();
-        tag == TAG_ARRAY_I || tag == TAG_ARRAY_M || tag == TAG_ARRAY_T || tag >= TAG_ARRAY_SLICE_MIN
+        tag == TAG_ARRAY_I || tag == TAG_ARRAY_M || tag == TAG_ARRAY_T || tag == TAG_ARRAY_S || tag >= TAG_ARRAY_SLICE_MIN
     }
 
     /// Get the pointer as `Obj` using forwarding. In debug mode panics if the value is not a pointer.
@@ -460,26 +460,28 @@ pub const TAG_OBJ_IND: Tag = 3;
 pub const TAG_ARRAY_I: Tag = 5;
 pub const TAG_ARRAY_M: Tag = 7;
 pub const TAG_ARRAY_T: Tag = 9;
-pub const TAG_BITS64_U: Tag = 11;
-pub const TAG_BITS64_S: Tag = 13;
-pub const TAG_BITS64_F: Tag = 15;
-pub const TAG_MUTBOX: Tag = 17;
-pub const TAG_CLOSURE: Tag = 19;
-pub const TAG_SOME: Tag = 21;
-pub const TAG_VARIANT: Tag = 23;
-pub const TAG_BLOB_B: Tag = 25;
-pub const TAG_BLOB_T: Tag = 27;
-pub const TAG_BLOB_P: Tag = 29;
-pub const TAG_FWD_PTR: Tag = 31; // Only used by the copying GC - not to be confused with forwarding pointer in the header used for incremental GC.
-pub const TAG_BITS32_U: Tag = 33;
-pub const TAG_BITS32_S: Tag = 35;
-pub const TAG_BITS32_F: Tag = 37;
-pub const TAG_BIGINT: Tag = 39;
-pub const TAG_CONCAT: Tag = 41;
-pub const TAG_REGION: Tag = 43;
-pub const TAG_NULL: Tag = 45;
-pub const TAG_ONE_WORD_FILLER: Tag = 47;
-pub const TAG_FREE_SPACE: Tag = 49;
+pub const TAG_ARRAY_S: Tag = 11;
+pub const TAG_BITS64_U: Tag = 13;
+pub const TAG_BITS64_S: Tag = 15;
+pub const TAG_BITS64_F: Tag = 17;
+pub const TAG_MUTBOX: Tag = 19;
+pub const TAG_CLOSURE: Tag = 21;
+pub const TAG_SOME: Tag = 23;
+pub const TAG_VARIANT: Tag = 25;
+pub const TAG_BLOB_B: Tag = 27;
+pub const TAG_BLOB_T: Tag = 29;
+pub const TAG_BLOB_P: Tag = 31;
+pub const TAG_BLOB_A: Tag  = 33;
+pub const TAG_FWD_PTR: Tag = 35; // Only used by the copying GC - not to be confused with forwarding pointer in the header used for incremental GC.
+pub const TAG_BITS32_U: Tag = 37;
+pub const TAG_BITS32_S: Tag = 39;
+pub const TAG_BITS32_F: Tag = 41;
+pub const TAG_BIGINT: Tag = 43;
+pub const TAG_CONCAT: Tag = 45;
+pub const TAG_REGION: Tag = 47;
+pub const TAG_NULL: Tag = 49;
+pub const TAG_ONE_WORD_FILLER: Tag = 51;
+pub const TAG_FREE_SPACE: Tag = 53;
 
 // Special value to visit only a range of array fields.
 // This and all values above it are reserved and mean
@@ -487,10 +489,14 @@ pub const TAG_FREE_SPACE: Tag = 49;
 // purposes of `visit_pointer_fields`.
 // Invariant: the value of this (pseudo-)tag must be
 //            higher than all other tags defined above
-pub const TAG_ARRAY_SLICE_MIN: Tag = 50;
+pub const TAG_ARRAY_SLICE_MIN: Tag = 54;
 
 pub fn slice_tag(array_tag: Tag, slice_start: u32) -> Tag {
-    debug_assert!(array_tag == TAG_ARRAY_I || array_tag == TAG_ARRAY_M || array_tag == TAG_ARRAY_T);
+    debug_assert!(array_tag == TAG_ARRAY_I
+                  || array_tag == TAG_ARRAY_M
+                  || array_tag == TAG_ARRAY_T
+                  || array_tag == TAG_ARRAY_S
+    );
     debug_assert!(slice_start >= TAG_ARRAY_SLICE_MIN && slice_start < (1 << 30));
     (((array_tag - TAG_ARRAY_I) / 2) << 30) | slice_start
 }
@@ -500,6 +506,7 @@ pub fn slice_start(tag: Tag) -> (Tag, u32) {
         tag == TAG_ARRAY_I
             || tag == TAG_ARRAY_M
             || tag == TAG_ARRAY_T
+            || tag == TAG_ARRAY_S
             || tag >= TAG_ARRAY_SLICE_MIN
     );
     if tag >= TAG_ARRAY_SLICE_MIN {
@@ -514,6 +521,7 @@ pub fn base_array_tag(tag: Tag) -> Tag {
         tag == TAG_ARRAY_I
             || tag == TAG_ARRAY_M
             || tag == TAG_ARRAY_T
+            || tag == TAG_ARRAY_S
             || tag >= TAG_ARRAY_SLICE_MIN
     );
     if tag >= TAG_ARRAY_SLICE_MIN {
@@ -1010,7 +1018,7 @@ pub(crate) unsafe fn block_size(address: usize) -> Words<u32> {
 
         // `block_size` is not used during the incremental mark phase and
         // therefore, does not support array slicing.
-        TAG_ARRAY_I | TAG_ARRAY_M | TAG_ARRAY_T => {
+        TAG_ARRAY_I | TAG_ARRAY_M | TAG_ARRAY_T | TAG_ARRAY_S => {
             let array = address as *mut Array;
             let size = array.len();
             size_of::<Array>() + Words(size)
@@ -1030,7 +1038,7 @@ pub(crate) unsafe fn block_size(address: usize) -> Words<u32> {
 
         TAG_VARIANT => size_of::<Variant>(),
 
-        TAG_BLOB_B | TAG_BLOB_T | TAG_BLOB_P => {
+        TAG_BLOB_B | TAG_BLOB_T | TAG_BLOB_P | TAG_BLOB_A => {
             let blob = address as *mut Blob;
             size_of::<Blob>() + blob.len().to_words()
         }
diff --git a/rts/motoko-rts/src/visitor.rs b/rts/motoko-rts/src/visitor.rs
index 27c2f84fa12..eb44a145883 100644
--- a/rts/motoko-rts/src/visitor.rs
+++ b/rts/motoko-rts/src/visitor.rs
@@ -43,7 +43,7 @@ pub unsafe fn visit_pointer_fields<C, F, G>(
             }
         }
 
-        TAG_ARRAY_I | TAG_ARRAY_M | TAG_ARRAY_T | TAG_ARRAY_SLICE_MIN.. => {
+        TAG_ARRAY_I | TAG_ARRAY_M | TAG_ARRAY_T | TAG_ARRAY_S | TAG_ARRAY_SLICE_MIN.. => {
             let (_, slice_start) = slice_start(tag);
             let array = obj as *mut Array;
             debug_assert!(slice_start <= array.len());
@@ -122,7 +122,7 @@ pub unsafe fn visit_pointer_fields<C, F, G>(
         }
 
         TAG_BITS32_U | TAG_BITS32_S | TAG_BITS32_F | TAG_BITS64_U | TAG_BITS64_S | TAG_BITS64_F
-        | TAG_BLOB_B | TAG_BLOB_T | TAG_BLOB_P | TAG_BIGINT => {
+        | TAG_BLOB_B | TAG_BLOB_T | TAG_BLOB_P | TAG_BLOB_A | TAG_BIGINT => {
             // These don't have pointers, skip
         }
 
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 80b9acef0bb..3227d202cc5 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -1999,9 +1999,20 @@ module Tagged = struct
      so update all!
    *)
 
-  type bits_sort = U | S | F
-  type array_sort = M | I | T
-  type blob_sort = B | T | P
+  type bits_sort =
+    | U (* signed *)
+    | S (* unsigned *)
+    | F (* float *)
+  type array_sort =
+    | I (* [ T ] *)
+    | M (* [var T ] *)
+    | T (* (T,+) *)
+    | S (* shared ... -> ... *)
+  type blob_sort =
+    |  B (* Blob *)
+    | T (* Text *)
+    | P (* Principal *)
+    | A (* actor { ... } *)
 
   type [@warning "-37"] tag  =
     | Object
@@ -2036,27 +2047,29 @@ module Tagged = struct
     | Array I -> 5l
     | Array M -> 7l
     | Array T -> 9l
-    | Bits64 U -> 11l
-    | Bits64 S -> 13l
-    | Bits64 F -> 15l
-    | MutBox -> 17l
-    | Closure -> 19l
-    | Some -> 21l
-    | Variant -> 23l
-    | Blob B -> 25l
-    | Blob T -> 27l
-    | Blob P -> 29l
-    | Indirection -> 31l
-    | Bits32 U -> 33l
-    | Bits32 S -> 35l
-    | Bits32 F -> 37l
-    | BigInt -> 39l
-    | Concat -> 41l
-    | Region -> 43l
-    | Null -> 45l
-    | OneWordFiller -> 47l
-    | FreeSpace -> 49l
-    | ArraySliceMinimum -> 50l
+    | Array S -> 11l
+    | Bits64 U -> 13l
+    | Bits64 S -> 15l
+    | Bits64 F -> 17l
+    | MutBox -> 19l
+    | Closure -> 21l
+    | Some -> 23l
+    | Variant -> 25l
+    | Blob B -> 27l
+    | Blob T -> 29l
+    | Blob P -> 31l
+    | Blob A -> 33l
+    | Indirection -> 35l
+    | Bits32 U -> 37l
+    | Bits32 S -> 39l
+    | Bits32 F -> 41l
+    | BigInt -> 43l
+    | Concat -> 45l
+    | Region -> 47l
+    | Null -> 49l
+    | OneWordFiller -> 51l
+    | FreeSpace -> 53l
+    | ArraySliceMinimum -> 54l
     (* Next two tags won't be seen by the GC, so no need to set the lowest bit
        for `CoercionFailure` and `StableSeen` *)
     | CoercionFailure -> 0xfffffffel
@@ -5427,8 +5440,13 @@ module IC = struct
   (* Actor reference on the stack *)
   let actor_public_field env name =
     (* simply tuple canister name and function name *)
+    Tagged.(sanity_check_tag env (Blob A)) ^^
     Blob.lit env Tagged.T name ^^
-    Tuple.from_stack env 2
+    Func.share_code2 Func.Never env "actor_public_field" (("actor", I32Type), ("func", I32Type)) [] (
+      fun env get_actor get_func ->
+      Arr.lit env Tagged.S [get_actor; get_func]
+   )
+
 
   let fail_assert env at =
     let open Source in
@@ -7395,7 +7413,7 @@ module MakeSerialization (Strm : Stream) = struct
         get_x
       in
 
-      let read_principal () =
+      let read_principal sort () =
         let (set_len, get_len) = new_local env "len" in
         let (set_x, get_x) = new_local env "x" in
         ReadBuf.read_leb128 env get_data_buf ^^ set_len ^^
@@ -7406,7 +7424,7 @@ module MakeSerialization (Strm : Stream) = struct
         get_len ^^ compile_unboxed_const 29l ^^ G.i (Compare (Wasm.Values.I32 I32Op.LeU)) ^^
         E.else_trap_with env "IDL error: principal too long" ^^
 
-        Blob.alloc env Tagged.P get_len ^^ set_x ^^
+        Blob.alloc env sort get_len ^^ set_x ^^
         get_x ^^ Blob.payload_ptr_unskewed env ^^
         ReadBuf.read_blob env get_data_buf get_len ^^
         get_x
@@ -7427,7 +7445,7 @@ module MakeSerialization (Strm : Stream) = struct
       let read_actor_data () =
         read_byte_tagged
           [ E.trap_with env "IDL error: unexpected actor reference"
-          ; read_principal ()
+          ; read_principal Tagged.A ()
           ]
       in
 
@@ -7681,7 +7699,7 @@ module MakeSerialization (Strm : Stream) = struct
         begin
           read_byte_tagged
             [ E.trap_with env "IDL error: unexpected principal reference"
-            ; read_principal ()
+            ; read_principal Tagged.P ()
             ]
         end
       | Prim Text ->
@@ -7907,9 +7925,11 @@ module MakeSerialization (Strm : Stream) = struct
           (with_composite_typ idl_func (fun _get_typ_buf ->
             read_byte_tagged
               [ E.trap_with env "IDL error: unexpected function reference"
-              ; read_actor_data () ^^
-                read_text () ^^
-                Tuple.from_stack env 2
+              ; let (set_actor, get_actor) = new_local env "actor" in
+                let (set_func, get_func) = new_local env "func" in
+                read_actor_data () ^^ set_actor ^^
+                read_text () ^^ set_func ^^
+                Arr.lit env Tagged.S [get_actor; get_func]
               ]))
           (skip get_idltyp ^^
            coercion_failed "IDL error: incompatible function type")
@@ -11774,9 +11794,9 @@ and compile_prim_invocation (env : E.t) ae p es at =
     StableMemoryInterface.grow env
 
   | OtherPrim "stableVarQuery", [] ->
-    SR.UnboxedTuple 2,
+    SR.Vanilla,
     IC.get_self_reference env ^^
-    Blob.lit env Tagged.T Type.(motoko_stable_var_info_fld.lab)
+    IC.actor_public_field env Type.(motoko_stable_var_info_fld.lab)
 
   (* Other prims, binary*)
   | OtherPrim "Array.init", [_;_] ->
diff --git a/src/prelude/internals.mo b/src/prelude/internals.mo
index 3cba8906b82..f9f9ea0d822 100644
--- a/src/prelude/internals.mo
+++ b/src/prelude/internals.mo
@@ -427,10 +427,10 @@ func @install_actor_helper(
         (#install, principal1)
       };
       case (#reinstall actor1) {
-        (#reinstall, (prim "cast" : (actor {}) -> Principal) actor1)
+        (#reinstall, (prim "cast" : (actor {}) -> Principal) actor1) /* FIXME */
       };
       case (#upgrade actor2) {
-        (#upgrade, (prim "cast" : (actor {}) -> Principal) actor2)
+        (#upgrade, (prim "cast" : (actor {}) -> Principal) actor2) /* FIXME */
       }
     };
   await @ic00.install_code {
diff --git a/src/prelude/prim.mo b/src/prelude/prim.mo
index 27e2efa3783..8c76c9a8060 100644
--- a/src/prelude/prim.mo
+++ b/src/prelude/prim.mo
@@ -307,15 +307,15 @@ func time() : Nat64 = (prim "time" : () -> Nat64)();
 
 // Principal
 
-func blobOfPrincipal(id : Principal) : Blob = (prim "cast" : Principal -> Blob) id;
+func blobOfPrincipal(id : Principal) : Blob = (prim "cast" : Principal -> Blob) id; /* FIXME */
 func principalOfBlob(act : Blob) : Principal {
   if (act.size() > 29) {
     trap("blob too long for principal");
   };
-  (prim "cast" : Blob -> Principal) act;
+  (prim "cast" : Blob -> Principal) act; /* FIXME */
 };
 
-func principalOfActor(act : actor {}) : Principal = (prim "cast" : (actor {}) -> Principal) act;
+func principalOfActor(act : actor {}) : Principal = (prim "cast" : (actor {}) -> Principal) act; //* FIXME */
 func isController(p : Principal) : Bool = (prim "is_controller" : Principal -> Bool) p;
 func canisterVersion() : Nat64 = (prim "canister_version" : () -> Nat64)();
 

From 6f581c630765dc7f6163d4776b51476f5eaede5a Mon Sep 17 00:00:00 2001
From: Claudio Russo <claudio@dfinity.org>
Date: Fri, 31 May 2024 18:17:11 +0100
Subject: [PATCH 228/260] format

---
 rts/motoko-rts-tests/src/gc.rs                  |  6 ++++--
 .../src/gc/incremental/array_slicing.rs         |  3 +--
 .../src/gc/incremental/partitioned_heap.rs      |  5 ++---
 rts/motoko-rts/src/types.rs                     | 17 +++++++++++------
 4 files changed, 18 insertions(+), 13 deletions(-)

diff --git a/rts/motoko-rts-tests/src/gc.rs b/rts/motoko-rts-tests/src/gc.rs
index a0b5175d126..5d1b6f51ef7 100644
--- a/rts/motoko-rts-tests/src/gc.rs
+++ b/rts/motoko-rts-tests/src/gc.rs
@@ -293,10 +293,12 @@ fn check_dynamic_heap(
                             || tag >= TAG_ARRAY_SLICE_MIN
                     );
                 } else {
-                    assert!(tag == TAG_ARRAY_I
+                    assert!(
+                        tag == TAG_ARRAY_I
                             || tag == TAG_ARRAY_M
                             || tag == TAG_ARRAY_T
-                            || tag == TAG_ARRAY_S)
+                            || tag == TAG_ARRAY_S
+                    )
                 }
 
                 if is_forwarded {
diff --git a/rts/motoko-rts-tests/src/gc/incremental/array_slicing.rs b/rts/motoko-rts-tests/src/gc/incremental/array_slicing.rs
index 1320f9b1239..72086c92f85 100644
--- a/rts/motoko-rts-tests/src/gc/incremental/array_slicing.rs
+++ b/rts/motoko-rts-tests/src/gc/incremental/array_slicing.rs
@@ -1,8 +1,7 @@
 use motoko_rts::{
     gc::incremental::array_slicing::slice_array,
     memory::alloc_array,
-    types::{Tag, Words,
-            TAG_ARRAY_I, TAG_ARRAY_M, TAG_ARRAY_T, TAG_ARRAY_S, TAG_ARRAY_SLICE_MIN },
+    types::{Tag, Words, TAG_ARRAY_I, TAG_ARRAY_M, TAG_ARRAY_S, TAG_ARRAY_SLICE_MIN, TAG_ARRAY_T},
 };
 
 use crate::memory::TestMemory;
diff --git a/rts/motoko-rts-tests/src/gc/incremental/partitioned_heap.rs b/rts/motoko-rts-tests/src/gc/incremental/partitioned_heap.rs
index 56b5eebd837..f829a6b8a49 100644
--- a/rts/motoko-rts-tests/src/gc/incremental/partitioned_heap.rs
+++ b/rts/motoko-rts-tests/src/gc/incremental/partitioned_heap.rs
@@ -14,9 +14,8 @@ use motoko_rts::{
     },
     memory::{alloc_array, alloc_blob, Memory},
     types::{
-        Array, Blob, Bytes, Obj, Tag, Value, Words,
-        TAG_ARRAY_I, TAG_ARRAY_M, TAG_ARRAY_T, TAG_ARRAY_S,
-        TAG_BLOB_B, TAG_BLOB_P, TAG_BLOB_T, TAG_BLOB_A
+        Array, Blob, Bytes, Obj, Tag, Value, Words, TAG_ARRAY_I, TAG_ARRAY_M, TAG_ARRAY_S,
+        TAG_ARRAY_T, TAG_BLOB_A, TAG_BLOB_B, TAG_BLOB_P, TAG_BLOB_T,
     },
 };
 
diff --git a/rts/motoko-rts/src/types.rs b/rts/motoko-rts/src/types.rs
index 5625b840b98..adeeb0f1216 100644
--- a/rts/motoko-rts/src/types.rs
+++ b/rts/motoko-rts/src/types.rs
@@ -333,7 +333,11 @@ impl Value {
 
     pub unsafe fn is_array(self) -> bool {
         let tag = self.tag();
-        tag == TAG_ARRAY_I || tag == TAG_ARRAY_M || tag == TAG_ARRAY_T || tag == TAG_ARRAY_S || tag >= TAG_ARRAY_SLICE_MIN
+        tag == TAG_ARRAY_I
+            || tag == TAG_ARRAY_M
+            || tag == TAG_ARRAY_T
+            || tag == TAG_ARRAY_S
+            || tag >= TAG_ARRAY_SLICE_MIN
     }
 
     /// Get the pointer as `Obj` using forwarding. In debug mode panics if the value is not a pointer.
@@ -471,7 +475,7 @@ pub const TAG_VARIANT: Tag = 25;
 pub const TAG_BLOB_B: Tag = 27;
 pub const TAG_BLOB_T: Tag = 29;
 pub const TAG_BLOB_P: Tag = 31;
-pub const TAG_BLOB_A: Tag  = 33;
+pub const TAG_BLOB_A: Tag = 33;
 pub const TAG_FWD_PTR: Tag = 35; // Only used by the copying GC - not to be confused with forwarding pointer in the header used for incremental GC.
 pub const TAG_BITS32_U: Tag = 37;
 pub const TAG_BITS32_S: Tag = 39;
@@ -492,10 +496,11 @@ pub const TAG_FREE_SPACE: Tag = 53;
 pub const TAG_ARRAY_SLICE_MIN: Tag = 54;
 
 pub fn slice_tag(array_tag: Tag, slice_start: u32) -> Tag {
-    debug_assert!(array_tag == TAG_ARRAY_I
-                  || array_tag == TAG_ARRAY_M
-                  || array_tag == TAG_ARRAY_T
-                  || array_tag == TAG_ARRAY_S
+    debug_assert!(
+        array_tag == TAG_ARRAY_I
+            || array_tag == TAG_ARRAY_M
+            || array_tag == TAG_ARRAY_T
+            || array_tag == TAG_ARRAY_S
     );
     debug_assert!(slice_start >= TAG_ARRAY_SLICE_MIN && slice_start < (1 << 30));
     (((array_tag - TAG_ARRAY_I) / 2) << 30) | slice_start

From 9f86d9176bb6d2b94d128c1963bce1f3e83f20cc Mon Sep 17 00:00:00 2001
From: Claudio Russo <claudio@dfinity.org>
Date: Sat, 1 Jun 2024 20:05:26 +0100
Subject: [PATCH 229/260] implement required coercions

---
 src/codegen/compile.ml   | 23 +++++++++++++++++++++++
 src/prelude/internals.mo |  4 ++--
 src/prelude/prim.mo      |  6 +++---
 3 files changed, 28 insertions(+), 5 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 3227d202cc5..388e4c91ce6 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -4329,6 +4329,22 @@ module Blob = struct
       get_x
     )
 
+  let copy env src_sort dst_sort =
+    let name = Printf.sprintf "blob_copy_%s_%s"
+                 (Int32.to_string (Tagged.int_of_tag (Tagged.Blob src_sort)))
+                 (Int32.to_string (Tagged.int_of_tag (Tagged.Blob dst_sort)))
+    in
+    Func.share_code1 Func.Never env name ("src", I32Type) [I32Type] (
+      fun env get_src ->
+       let (set_dst, get_dst) = new_local env "dst" in
+       alloc env dst_sort (get_src ^^ len env) ^^ set_dst ^^
+       get_dst ^^ payload_ptr_unskewed env ^^
+       get_src ^^ Tagged.sanity_check_tag env (Tagged.Blob src_sort) ^^
+       as_ptr_len env ^^
+       Heap.memcpy env ^^
+       get_dst
+    )
+
   let of_size_copy env sort get_size_fun copy_fun offset_fun =
     let (set_len, get_len) = new_local env "len" in
     let (set_blob, get_blob) = new_local env "blob" in
@@ -11693,6 +11709,13 @@ and compile_prim_invocation (env : E.t) ae p es at =
     compile_exp_vanilla env ae e ^^
     IC.trap_text env
 
+  | OtherPrim "blobToPrincipal", e ->
+    const_sr SR.Vanilla (Blob.copy env Tagged.B Tagged.P)
+  | OtherPrim "principalToBlob", e ->
+    const_sr SR.Vanilla (Blob.copy env Tagged.P Tagged.B)
+  | OtherPrim "actorToPrincipal", e ->
+    const_sr SR.Vanilla (Blob.copy env Tagged.A Tagged.P)
+
   | OtherPrim "blobToArray", e ->
     const_sr SR.Vanilla (Arr.ofBlob env Tagged.I)
   | OtherPrim "blobToArrayMut", e ->
diff --git a/src/prelude/internals.mo b/src/prelude/internals.mo
index f9f9ea0d822..80124cb7954 100644
--- a/src/prelude/internals.mo
+++ b/src/prelude/internals.mo
@@ -427,10 +427,10 @@ func @install_actor_helper(
         (#install, principal1)
       };
       case (#reinstall actor1) {
-        (#reinstall, (prim "cast" : (actor {}) -> Principal) actor1) /* FIXME */
+        (#reinstall, (prim "actorToPrincipal" : (actor {}) -> Principal) actor1)
       };
       case (#upgrade actor2) {
-        (#upgrade, (prim "cast" : (actor {}) -> Principal) actor2) /* FIXME */
+        (#upgrade, (prim "actorToPrincipal" : (actor {}) -> Principal) actor2)
       }
     };
   await @ic00.install_code {
diff --git a/src/prelude/prim.mo b/src/prelude/prim.mo
index 8c76c9a8060..205ea3c2795 100644
--- a/src/prelude/prim.mo
+++ b/src/prelude/prim.mo
@@ -307,15 +307,15 @@ func time() : Nat64 = (prim "time" : () -> Nat64)();
 
 // Principal
 
-func blobOfPrincipal(id : Principal) : Blob = (prim "cast" : Principal -> Blob) id; /* FIXME */
+func blobOfPrincipal(id : Principal) : Blob = (prim "principalToBlob" : Principal -> Blob) id;
 func principalOfBlob(act : Blob) : Principal {
   if (act.size() > 29) {
     trap("blob too long for principal");
   };
-  (prim "cast" : Blob -> Principal) act; /* FIXME */
+  (prim "blobToPrincipal" : Blob -> Principal) act;
 };
 
-func principalOfActor(act : actor {}) : Principal = (prim "cast" : (actor {}) -> Principal) act; //* FIXME */
+func principalOfActor(act : actor {}) : Principal = (prim "actorToPrincipal" : (actor {}) -> Principal) act;
 func isController(p : Principal) : Bool = (prim "is_controller" : Principal -> Bool) p;
 func canisterVersion() : Nat64 = (prim "canister_version" : () -> Nat64)();
 

From ba137c7091d6c9e01eecbc143812e4871b505ee8 Mon Sep 17 00:00:00 2001
From: Claudio Russo <claudio@dfinity.org>
Date: Mon, 3 Jun 2024 16:21:46 +0100
Subject: [PATCH 230/260] fix bugs; extend interpreter; rename prims; add
 __LINE__ to Tagged.sanity_check_tag

---
 src/codegen/compile.ml   | 29 ++++++++++++++++-------------
 src/mo_values/prim.ml    |  6 ++++++
 src/prelude/internals.mo |  4 ++--
 src/prelude/prim.mo      |  7 ++++---
 4 files changed, 28 insertions(+), 18 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 388e4c91ce6..89cfe0198ac 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -2142,9 +2142,11 @@ module Tagged = struct
     load_forwarding_pointer env ^^
     Heap.load_field tag_field
 
-  let sanity_check_tag env tag =
+  let sanity_check_tag line env tag =
     let tag = int_of_tag tag in
-    let name = "sanity_check_tag_" ^ Int32.to_string tag in
+    let name = "sanity_check_tag_" ^ Int32.to_string tag ^
+                 (if TaggingScheme.debug then Int.to_string line else "")
+    in
     if TaggingScheme.debug || !Flags.sanity then
       Func.share_code1 Func.Always env name ("obj", I32Type) [I32Type]
         (fun env get_obj ->
@@ -2654,7 +2656,7 @@ module BoxedWord64 = struct
         (get_n ^^ BitTagged.untag __LINE__ env pty)
         (get_n ^^
          Tagged.load_forwarding_pointer env ^^
-         Tagged.(sanity_check_tag env (heap_tag env pty)) ^^
+         Tagged.(sanity_check_tag __LINE__ env (heap_tag env pty)) ^^
          Tagged.load_field64 env (payload_field env))
     )
 end (* BoxedWord64 *)
@@ -2793,7 +2795,7 @@ module BoxedSmallWord = struct
         (get_n ^^ BitTagged.untag_i32 __LINE__ env pty)
         (get_n ^^
          Tagged.load_forwarding_pointer env ^^
-         Tagged.(sanity_check_tag env (heap_tag env pty)) ^^
+         Tagged.(sanity_check_tag __LINE__ env (heap_tag env pty)) ^^
          Tagged.load_field env (payload_field env))
     )
 
@@ -3061,7 +3063,7 @@ module Float = struct
 
   let unbox env =
     Tagged.load_forwarding_pointer env ^^
-    Tagged.(sanity_check_tag env (Bits64 F)) ^^
+    Tagged.(sanity_check_tag __LINE__ env (Bits64 F)) ^^
     Tagged.load_field_float64 env (payload_field env)
 
 end (* Float *)
@@ -4339,7 +4341,7 @@ module Blob = struct
        let (set_dst, get_dst) = new_local env "dst" in
        alloc env dst_sort (get_src ^^ len env) ^^ set_dst ^^
        get_dst ^^ payload_ptr_unskewed env ^^
-       get_src ^^ Tagged.sanity_check_tag env (Tagged.Blob src_sort) ^^
+       get_src ^^ Tagged.sanity_check_tag __LINE__ env (Tagged.Blob src_sort) ^^
        as_ptr_len env ^^
        Heap.memcpy env ^^
        get_dst
@@ -4924,7 +4926,7 @@ module Tuple = struct
   (* Expects on the stack the pointer to the array. *)
   let load_n env n =
     Tagged.load_forwarding_pointer env ^^
-    Tagged.(sanity_check_tag env (Array T)) ^^
+    Tagged.(sanity_check_tag __LINE__ env (Array T)) ^^
     Tagged.load_field env (Int32.add (Arr.header_size env) n)
 
   (* Takes n elements of the stack and produces an argument tuple *)
@@ -5357,7 +5359,7 @@ module IC = struct
     match E.mode env with
     | Flags.ICMode | Flags.RefMode ->
       Func.share_code0 Func.Never env "canister_self" [I32Type] (fun env ->
-        Blob.of_size_copy env Tagged.P
+        Blob.of_size_copy env Tagged.A
           (fun env -> system_call env "canister_self_size")
           (fun env -> system_call env "canister_self_copy")
           (fun env -> compile_unboxed_const 0l)
@@ -5456,7 +5458,7 @@ module IC = struct
   (* Actor reference on the stack *)
   let actor_public_field env name =
     (* simply tuple canister name and function name *)
-    Tagged.(sanity_check_tag env (Blob A)) ^^
+    Tagged.(sanity_check_tag __LINE__ env (Blob A)) ^^
     Blob.lit env Tagged.T name ^^
     Func.share_code2 Func.Never env "actor_public_field" (("actor", I32Type), ("func", I32Type)) [] (
       fun env get_actor get_func ->
@@ -11709,11 +11711,11 @@ and compile_prim_invocation (env : E.t) ae p es at =
     compile_exp_vanilla env ae e ^^
     IC.trap_text env
 
-  | OtherPrim "blobToPrincipal", e ->
+  | OtherPrim "principalOfBlob", e ->
     const_sr SR.Vanilla (Blob.copy env Tagged.B Tagged.P)
-  | OtherPrim "principalToBlob", e ->
+  | OtherPrim "blobOfPrincipal", e ->
     const_sr SR.Vanilla (Blob.copy env Tagged.P Tagged.B)
-  | OtherPrim "actorToPrincipal", e ->
+  | OtherPrim "principalOfActor", e ->
     const_sr SR.Vanilla (Blob.copy env Tagged.A Tagged.P)
 
   | OtherPrim "blobToArray", e ->
@@ -11871,7 +11873,8 @@ and compile_prim_invocation (env : E.t) ae p es at =
     compile_unboxed_const 29l ^^
     G.i (Compare (Wasm.Values.I32 I32Op.LeU)) ^^
     E.else_trap_with env "blob too long for actor principal" ^^
-    get_blob
+    get_blob ^^
+    Blob.copy env Tagged.B Tagged.A
 
   | SelfRef _, [] ->
     SR.Vanilla, IC.get_self_reference env
diff --git a/src/mo_values/prim.ml b/src/mo_values/prim.ml
index 64a1ac0e4e2..7bd4b49c3b7 100644
--- a/src/mo_values/prim.ml
+++ b/src/mo_values/prim.ml
@@ -292,6 +292,12 @@ let prim trap =
       in go (fun xs -> xs) k 0
     | _ -> assert false
     )
+
+
+  | "blobOfPrincipal" -> fun _ v k -> k v
+  | "principalOfBlob" -> fun _ v k -> k v
+  | "principalOfActor" -> fun _ v k -> k v
+
   | "blobToArray" -> fun _ v k ->
     k (Array (Array.of_seq (Seq.map (fun c ->
       Nat8 (Nat8.of_int (Char.code c))
diff --git a/src/prelude/internals.mo b/src/prelude/internals.mo
index 80124cb7954..129d30a72a0 100644
--- a/src/prelude/internals.mo
+++ b/src/prelude/internals.mo
@@ -427,10 +427,10 @@ func @install_actor_helper(
         (#install, principal1)
       };
       case (#reinstall actor1) {
-        (#reinstall, (prim "actorToPrincipal" : (actor {}) -> Principal) actor1)
+        (#reinstall, (prim "principalOfActor" : (actor {}) -> Principal) actor1)
       };
       case (#upgrade actor2) {
-        (#upgrade, (prim "actorToPrincipal" : (actor {}) -> Principal) actor2)
+        (#upgrade, (prim "principalOfActor" : (actor {}) -> Principal) actor2)
       }
     };
   await @ic00.install_code {
diff --git a/src/prelude/prim.mo b/src/prelude/prim.mo
index 205ea3c2795..22a7ba8f53c 100644
--- a/src/prelude/prim.mo
+++ b/src/prelude/prim.mo
@@ -307,15 +307,16 @@ func time() : Nat64 = (prim "time" : () -> Nat64)();
 
 // Principal
 
-func blobOfPrincipal(id : Principal) : Blob = (prim "principalToBlob" : Principal -> Blob) id;
+func blobOfPrincipal(id : Principal) : Blob = (prim "blobOfPrincipal" : Principal -> Blob) id;
 func principalOfBlob(act : Blob) : Principal {
+  // TODO: better: check size in prim "principalOfBob" instead
   if (act.size() > 29) {
     trap("blob too long for principal");
   };
-  (prim "blobToPrincipal" : Blob -> Principal) act;
+  (prim "principalOfBlob" : Blob -> Principal) act;
 };
 
-func principalOfActor(act : actor {}) : Principal = (prim "actorToPrincipal" : (actor {}) -> Principal) act;
+func principalOfActor(act : actor {}) : Principal = (prim "principalOfActor" : (actor {}) -> Principal) act;
 func isController(p : Principal) : Bool = (prim "is_controller" : Principal -> Bool) p;
 func canisterVersion() : Nat64 = (prim "canister_version" : () -> Nat64)();
 

From 4d4188929452e5f0f7188ecfc477af2408ef1973 Mon Sep 17 00:00:00 2001
From: Claudio Russo <claudio@dfinity.org>
Date: Tue, 4 Jun 2024 11:00:20 +0100
Subject: [PATCH 231/260] Update rts/motoko-rts/src/debug.rs

---
 rts/motoko-rts/src/debug.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rts/motoko-rts/src/debug.rs b/rts/motoko-rts/src/debug.rs
index bf71cd1e90f..485528c7c32 100644
--- a/rts/motoko-rts/src/debug.rs
+++ b/rts/motoko-rts/src/debug.rs
@@ -204,7 +204,7 @@ pub(crate) unsafe fn print_boxed_object(buf: &mut WriteBuf, p: usize) {
                 (*variant).field.get_raw()
             );
         }
-        TAG_BLOB_B | TAG_BLOB_T | TAG_BLOB_P => {
+        TAG_BLOB_B | TAG_BLOB_T | TAG_BLOB_P | TAG_BLOB_A => {
             let blob = obj.as_blob();
             let _ = write!(buf, "<Blob len={:#x}>", blob.len().as_u32());
         }

From 0fdbc12e50119565ac783dbe9e7b05051c476b41 Mon Sep 17 00:00:00 2001
From: Claudio Russo <claudio@dfinity.org>
Date: Tue, 4 Jun 2024 11:35:10 +0100
Subject: [PATCH 232/260] document tags

---
 rts/motoko-rts/src/types.rs | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/rts/motoko-rts/src/types.rs b/rts/motoko-rts/src/types.rs
index adeeb0f1216..41e8d4b6b4c 100644
--- a/rts/motoko-rts/src/types.rs
+++ b/rts/motoko-rts/src/types.rs
@@ -403,7 +403,7 @@ impl Value {
     /// In debug mode panics if the value is not a pointer or the
     /// pointed object is not a `Blob`.
     pub unsafe fn as_stream(self) -> *mut Stream {
-        debug_assert!(self.is_blob());
+        debug_assert_eq!(self.tag(), TAG_BLOB_B);
         self.check_forwarding_pointer();
         self.forward().get_ptr() as *mut Stream
     }
@@ -461,25 +461,25 @@ pub type Tag = u32;
 // locations in mark-compact GC. (Reminder: objects and fields are word aligned)
 pub const TAG_OBJECT: Tag = 1;
 pub const TAG_OBJ_IND: Tag = 3;
-pub const TAG_ARRAY_I: Tag = 5;
-pub const TAG_ARRAY_M: Tag = 7;
-pub const TAG_ARRAY_T: Tag = 9;
-pub const TAG_ARRAY_S: Tag = 11;
-pub const TAG_BITS64_U: Tag = 13;
-pub const TAG_BITS64_S: Tag = 15;
-pub const TAG_BITS64_F: Tag = 17;
+pub const TAG_ARRAY_I: Tag = 5;   // Immutable Array ([T])
+pub const TAG_ARRAY_M: Tag = 7;   // Mutable Array ([var T])
+pub const TAG_ARRAY_T: Tag = 9;   // Non-nullary Tuple ((T,+))
+pub const TAG_ARRAY_S: Tag = 11;  // Shared function pairing TAG_BLOB_A with TAG_BLOB_T (shared ... -> ...)
+pub const TAG_BITS64_U: Tag = 13; // Unsigned (Nat64)
+pub const TAG_BITS64_S: Tag = 15; // Signed (Int64)
+pub const TAG_BITS64_F: Tag = 17; // Float
 pub const TAG_MUTBOX: Tag = 19;
 pub const TAG_CLOSURE: Tag = 21;
 pub const TAG_SOME: Tag = 23;
 pub const TAG_VARIANT: Tag = 25;
-pub const TAG_BLOB_B: Tag = 27;
-pub const TAG_BLOB_T: Tag = 29;
-pub const TAG_BLOB_P: Tag = 31;
-pub const TAG_BLOB_A: Tag = 33;
+pub const TAG_BLOB_B: Tag = 27;   // Blob of Bytes (Blob)
+pub const TAG_BLOB_T: Tag = 29;   // Blob of Utf8 (Text)
+pub const TAG_BLOB_P: Tag = 31;   // Principal (Principal)
+pub const TAG_BLOB_A: Tag = 33;   // Actor (actor {})
 pub const TAG_FWD_PTR: Tag = 35; // Only used by the copying GC - not to be confused with forwarding pointer in the header used for incremental GC.
-pub const TAG_BITS32_U: Tag = 37;
-pub const TAG_BITS32_S: Tag = 39;
-pub const TAG_BITS32_F: Tag = 41;
+pub const TAG_BITS32_U: Tag = 37; // Unsigned (Nat32)
+pub const TAG_BITS32_S: Tag = 39; // Signed (Int32)
+pub const TAG_BITS32_F: Tag = 41; // Reserved (Float32)
 pub const TAG_BIGINT: Tag = 43;
 pub const TAG_CONCAT: Tag = 45;
 pub const TAG_REGION: Tag = 47;

From 0ed4fe613f21c4f0af7d08ef126f8db73666e0de Mon Sep 17 00:00:00 2001
From: Claudio Russo <claudio@dfinity.org>
Date: Wed, 5 Jun 2024 12:57:28 +0100
Subject: [PATCH 233/260] reformat; implement and use blob_of_ptr_size,
 blob_of_str; fix base32_to_blob to produce TAG_BLOB_B

---
 rts/motoko-rts-tests/src/crc32.rs        | 20 ++++++++++----------
 rts/motoko-rts-tests/src/principal_id.rs |  8 +++++---
 rts/motoko-rts/src/principal_id.rs       | 20 ++++++++++++++------
 rts/motoko-rts/src/types.rs              | 16 ++++++++--------
 4 files changed, 37 insertions(+), 27 deletions(-)

diff --git a/rts/motoko-rts-tests/src/crc32.rs b/rts/motoko-rts-tests/src/crc32.rs
index 167c46d6fc1..725ea36d183 100644
--- a/rts/motoko-rts-tests/src/crc32.rs
+++ b/rts/motoko-rts-tests/src/crc32.rs
@@ -1,7 +1,7 @@
 use crate::memory::TestMemory;
 
-use motoko_rts::principal_id::{base32_of_checksummed_blob, base32_to_blob};
-use motoko_rts::text::{text_compare, text_of_ptr_size};
+use motoko_rts::principal_id::{base32_of_checksummed_blob, base32_to_blob, blob_of_ptr_size};
+use motoko_rts::text::{blob_compare, text_compare, text_of_ptr_size};
 use motoko_rts::types::{Bytes, Words};
 
 pub unsafe fn test() {
@@ -41,36 +41,36 @@ pub unsafe fn test() {
 
     let text = text_of_ptr_size(&mut heap, b"".as_ptr(), Bytes(0));
     assert_eq!(
-        text_compare(
+        blob_compare(
             base32_to_blob(&mut heap, text),
-            text_of_ptr_size(&mut heap, b"".as_ptr(), Bytes(0))
+            blob_of_ptr_size(&mut heap, b"".as_ptr(), Bytes(0))
         ),
         0
     );
 
     let text = text_of_ptr_size(&mut heap, b"GEZDGNBVGY3TQOI".as_ptr(), Bytes(15));
     assert_eq!(
-        text_compare(
+        blob_compare(
             base32_to_blob(&mut heap, text),
-            text_of_ptr_size(&mut heap, b"123456789".as_ptr(), Bytes(9))
+            blob_of_ptr_size(&mut heap, b"123456789".as_ptr(), Bytes(9))
         ),
         0
     );
 
     let text = text_of_ptr_size(&mut heap, b"MFRGGZDFMZTWQ2LKNNWG23TPOA".as_ptr(), Bytes(26));
     assert_eq!(
-        text_compare(
+        blob_compare(
             base32_to_blob(&mut heap, text),
-            text_of_ptr_size(&mut heap, b"abcdefghijklmnop".as_ptr(), Bytes(16))
+            blob_of_ptr_size(&mut heap, b"abcdefghijklmnop".as_ptr(), Bytes(16))
         ),
         0
     );
 
     let text = text_of_ptr_size(&mut heap, b"em77e-bvlzu-aq".as_ptr(), Bytes(14));
     assert_eq!(
-        text_compare(
+        blob_compare(
             base32_to_blob(&mut heap, text),
-            text_of_ptr_size(
+            blob_of_ptr_size(
                 &mut heap,
                 b"\x23\x3f\xf2\x06\xab\xcd\x01".as_ptr(),
                 Bytes(7)
diff --git a/rts/motoko-rts-tests/src/principal_id.rs b/rts/motoko-rts-tests/src/principal_id.rs
index 4495111f883..1fa6cd14b56 100644
--- a/rts/motoko-rts-tests/src/principal_id.rs
+++ b/rts/motoko-rts-tests/src/principal_id.rs
@@ -1,6 +1,8 @@
 use crate::memory::TestMemory;
 
-use motoko_rts::principal_id::{blob_of_principal, principal_of_blob};
+use motoko_rts::principal_id::{
+    blob_of_principal, blob_of_ptr_size, blob_of_str, principal_of_blob,
+};
 use motoko_rts::text::{blob_compare, text_compare, text_of_ptr_size, text_of_str};
 use motoko_rts::types::{Bytes, Words};
 
@@ -36,13 +38,13 @@ pub unsafe fn test() {
 
     let text = text_of_str(&mut heap, "aaaaa-aa");
     let principal = blob_of_principal(&mut heap, text);
-    assert_eq!(blob_compare(principal, text_of_str(&mut heap, ""),), 0);
+    assert_eq!(blob_compare(principal, blob_of_str(&mut heap, ""),), 0);
 
     let text = text_of_str(&mut heap, "bfozs-kwa73-7nadi");
     assert_eq!(
         blob_compare(
             blob_of_principal(&mut heap, text),
-            text_of_ptr_size(&mut heap, b"\xC0\xFE\xFE\xD0\x0D".as_ptr(), Bytes(5))
+            blob_of_ptr_size(&mut heap, b"\xC0\xFE\xFE\xD0\x0D".as_ptr(), Bytes(5))
         ),
         0
     );
diff --git a/rts/motoko-rts/src/principal_id.rs b/rts/motoko-rts/src/principal_id.rs
index 94c4a238f05..c24be6009eb 100644
--- a/rts/motoko-rts/src/principal_id.rs
+++ b/rts/motoko-rts/src/principal_id.rs
@@ -98,11 +98,7 @@ pub unsafe fn base32_of_checksummed_blob<M: Memory>(mem: &mut M, b: Value) -> Va
     let n = b.as_blob().len();
     let mut data = b.as_blob().payload_const();
 
-    let r = alloc_blob(
-        mem,
-        TAG_BLOB_T, /*?*/
-        Bytes((n.as_u32() + 4 + 4) / 5 * 8),
-    ); // contains padding
+    let r = alloc_blob(mem, TAG_BLOB_T, Bytes((n.as_u32() + 4 + 4) / 5 * 8)); // contains padding
     let blob = r.as_blob_mut();
     let dest = blob.payload_addr();
 
@@ -189,7 +185,7 @@ pub unsafe fn base32_to_blob<M: Memory>(mem: &mut M, b: Value) -> Value {
     let mut data = b.as_blob().payload_const();
 
     // Every group of 8 characters will yield 5 bytes
-    let r = alloc_blob(mem, TAG_BLOB_T, Bytes(((n.as_u32() + 7) / 8) * 5)); // we deal with padding later
+    let r = alloc_blob(mem, TAG_BLOB_B, Bytes(((n.as_u32() + 7) / 8) * 5)); // we deal with padding later
     let blob = r.as_blob_mut();
     let dest = blob.payload_addr();
 
@@ -288,3 +284,15 @@ pub unsafe fn blob_of_principal<M: Memory>(mem: &mut M, t: Value) -> Value {
 
     allocation_barrier(stripped)
 }
+
+// for testing
+pub unsafe fn blob_of_ptr_size<M: Memory>(mem: &mut M, buf: *const u8, n: Bytes<u32>) -> Value {
+    let blob = alloc_blob(mem, TAG_BLOB_B, n);
+    let payload_addr = blob.as_blob_mut().payload_addr();
+    memcpy_bytes(payload_addr as usize, buf as usize, n);
+    allocation_barrier(blob)
+}
+
+pub unsafe fn blob_of_str<M: Memory>(mem: &mut M, s: &str) -> Value {
+    blob_of_ptr_size(mem, s.as_ptr(), Bytes(s.len() as u32))
+}
diff --git a/rts/motoko-rts/src/types.rs b/rts/motoko-rts/src/types.rs
index 41e8d4b6b4c..ae44903172c 100644
--- a/rts/motoko-rts/src/types.rs
+++ b/rts/motoko-rts/src/types.rs
@@ -461,10 +461,10 @@ pub type Tag = u32;
 // locations in mark-compact GC. (Reminder: objects and fields are word aligned)
 pub const TAG_OBJECT: Tag = 1;
 pub const TAG_OBJ_IND: Tag = 3;
-pub const TAG_ARRAY_I: Tag = 5;   // Immutable Array ([T])
-pub const TAG_ARRAY_M: Tag = 7;   // Mutable Array ([var T])
-pub const TAG_ARRAY_T: Tag = 9;   // Non-nullary Tuple ((T,+))
-pub const TAG_ARRAY_S: Tag = 11;  // Shared function pairing TAG_BLOB_A with TAG_BLOB_T (shared ... -> ...)
+pub const TAG_ARRAY_I: Tag = 5; // Immutable Array ([T])
+pub const TAG_ARRAY_M: Tag = 7; // Mutable Array ([var T])
+pub const TAG_ARRAY_T: Tag = 9; // Non-nullary Tuple ((T,+))
+pub const TAG_ARRAY_S: Tag = 11; // Shared function pairing TAG_BLOB_A with TAG_BLOB_T (shared ... -> ...)
 pub const TAG_BITS64_U: Tag = 13; // Unsigned (Nat64)
 pub const TAG_BITS64_S: Tag = 15; // Signed (Int64)
 pub const TAG_BITS64_F: Tag = 17; // Float
@@ -472,10 +472,10 @@ pub const TAG_MUTBOX: Tag = 19;
 pub const TAG_CLOSURE: Tag = 21;
 pub const TAG_SOME: Tag = 23;
 pub const TAG_VARIANT: Tag = 25;
-pub const TAG_BLOB_B: Tag = 27;   // Blob of Bytes (Blob)
-pub const TAG_BLOB_T: Tag = 29;   // Blob of Utf8 (Text)
-pub const TAG_BLOB_P: Tag = 31;   // Principal (Principal)
-pub const TAG_BLOB_A: Tag = 33;   // Actor (actor {})
+pub const TAG_BLOB_B: Tag = 27; // Blob of Bytes (Blob)
+pub const TAG_BLOB_T: Tag = 29; // Blob of Utf8 (Text)
+pub const TAG_BLOB_P: Tag = 31; // Principal (Principal)
+pub const TAG_BLOB_A: Tag = 33; // Actor (actor {})
 pub const TAG_FWD_PTR: Tag = 35; // Only used by the copying GC - not to be confused with forwarding pointer in the header used for incremental GC.
 pub const TAG_BITS32_U: Tag = 37; // Unsigned (Nat32)
 pub const TAG_BITS32_S: Tag = 39; // Signed (Int32)

From 41f891706dfa86459835f2f4d71b8c2d43271a58 Mon Sep 17 00:00:00 2001
From: Claudio Russo <claudio@dfinity.org>
Date: Wed, 5 Jun 2024 13:21:02 +0100
Subject: [PATCH 234/260] remove unused pattern match code from compile.ml

---
 src/codegen/compile.ml | 57 ------------------------------------------
 1 file changed, 57 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 89cfe0198ac..5d4931d2896 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -2236,63 +2236,6 @@ module Tagged = struct
     set_tag ^^
     go cases
 
-  (* like branch_default but also pushes the scrutinee on the stack for the
-   * branch's consumption *)
-  let _branch_default_with env retty def cases =
-    let (set_o, get_o) = new_local env "o" in
-    let prep (t, code) = (t, get_o ^^ code)
-    in set_o ^^ get_o ^^ branch_default env retty def (List.map prep cases)
-(*
-  (* like branch_default_with but the tag is known statically *)
-  let branch_with env retty = function
-    | [] -> G.i Unreachable
-    | [_, code] -> code
-    | (_, code) :: cases ->
-       let (set_o, get_o) = new_local env "o" in
-       let prep (t, code) = (t, get_o ^^ code)
-       in set_o ^^ get_o ^^ branch_default env retty (get_o ^^ code) (List.map prep cases)
-
-  (* Can a value of this type be represented by a heap object with this tag? *)
-  (* Needs to be conservative, i.e. return `true` if unsure *)
-  (* This function can also be used as assertions in a lint mode, e.g. in compile_exp *)
-  let can_have_tag ty tag =
-    let open Mo_types.Type in
-    match (tag : tag) with
-    | Region ->
-      begin match normalize ty with
-      | (Con _ | Any) -> true
-      | (Prim Region) -> true
-      | (Prim _ | Obj _ | Array _ | Tup _ | Opt _ | Variant _ | Func _ | Non) -> false
-      | (Pre | Async _ | Mut _ | Var _ | Typ _) -> assert false
-      end
-    | Array ->
-      begin match normalize ty with
-      | (Con _ | Any) -> true
-      | (Array _ | Tup _) -> true
-      | (Prim _ |  Obj _ | Opt _ | Variant _ | Func _ | Non) -> false
-      | (Pre | Async _ | Mut _ | Var _ | Typ _) -> assert false
-      end
-    | Blob  ->
-      begin match normalize ty with
-      | (Con _ | Any) -> true
-      | (Prim (Text|Blob|Principal)) -> true
-      | (Prim _ | Obj _ | Array _ | Tup _ | Opt _ | Variant _ | Func _ | Non) -> false
-      | (Pre | Async _ | Mut _ | Var _ | Typ _) -> assert false
-      end
-    | Object ->
-      begin match normalize ty with
-      | (Con _ | Any) -> true
-      | (Obj _) -> true
-      | (Prim _ | Array _ | Tup _ | Opt _ | Variant _ | Func _ | Non) -> false
-      | (Pre | Async _ | Mut _ | Var _ | Typ _) -> assert false
-      end
-    | _ -> true
-
-  (* like branch_with but with type information to statically skip some branches *)
-  let _branch_typed_with env ty retty branches =
-    branch_with env retty (List.filter (fun (tag,c) -> can_have_tag ty tag) branches)
-
- *)
   let allocation_barrier env =
     (if !Flags.gc_strategy = Flags.Incremental then
       E.call_import env "rts" "allocation_barrier"

From 1e8d0f621b342ecb6ac10cd09c84178a6db43878 Mon Sep 17 00:00:00 2001
From: Claudio Russo <claudio@dfinity.org>
Date: Wed, 5 Jun 2024 13:33:58 +0100
Subject: [PATCH 235/260] use binary, not text, blob for IDL decoding check

---
 src/codegen/compile.ml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 5d4931d2896..74b094d0d03 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -4707,7 +4707,7 @@ module Arr = struct
   let alloc env array_sort len =
     compile_unboxed_const Tagged.(int_of_tag (Array array_sort)) ^^
     len ^^
-    E.call_import env "rts" "alloc_array" (* TODO *)
+    E.call_import env "rts" "alloc_array"
 
   let iterate env get_array body =
     let (set_boundary, get_boundary) = new_local env "boundary" in
@@ -7562,11 +7562,11 @@ module MakeSerialization (Strm : Stream) = struct
             *)
             get_thing ^^ set_result ^^
             get_memo ^^ get_result ^^ store_unskewed_ptr ^^
-            get_memo ^^ compile_add_const 4l ^^ Blob.lit env Tagged.T (typ_hash t) ^^ store_unskewed_ptr
+            get_memo ^^ compile_add_const 4l ^^ Blob.lit env Tagged.B (typ_hash t) ^^ store_unskewed_ptr
           )
           end begin
           (* Decoded before. Check type hash *)
-          ReadBuf.read_word32 env get_data_buf ^^ Blob.lit env Tagged.T (typ_hash t) ^^
+          ReadBuf.read_word32 env get_data_buf ^^ Blob.lit env Tagged.B (typ_hash t) ^^
           G.i (Compare (Wasm.Values.I32 I32Op.Eq)) ^^
           E.else_trap_with env ("Stable memory error: Aliased at wrong type, expected: " ^ typ_hash t)
         end ^^

From e8c4c192d4aaacf135a37fcb3ea6c39600d5c9ab Mon Sep 17 00:00:00 2001
From: Claudio Russo <claudio@dfinity.org>
Date: Wed, 5 Jun 2024 15:55:48 +0100
Subject: [PATCH 236/260] add more assertions

---
 rts/motoko-rts/src/static_checks.rs |  9 ++++
 rts/motoko-rts/src/types.rs         | 70 +++++++++++++++--------------
 2 files changed, 46 insertions(+), 33 deletions(-)

diff --git a/rts/motoko-rts/src/static_checks.rs b/rts/motoko-rts/src/static_checks.rs
index 9ea55c1f79c..ca64a670df7 100644
--- a/rts/motoko-rts/src/static_checks.rs
+++ b/rts/motoko-rts/src/static_checks.rs
@@ -1,5 +1,6 @@
 //! Compile-time assertions to make sure object layouts are as expected
 
+use crate::constants::*;
 use crate::types::*;
 use motoko_rts_macros::*;
 
@@ -61,3 +62,11 @@ const _: () = assert!(align_of::<Bits64>() == WORD_SIZE);
 const _: () = assert!(align_of::<OneWordFiller>() == WORD_SIZE);
 const _: () = assert!(align_of::<FreeSpace>() == WORD_SIZE);
 const _: () = assert!(align_of::<FwdPtr>() == WORD_SIZE);
+
+// Array slicing
+// TAG_ARRAY_I is smallest tag
+const _: () =
+    assert!(TAG_ARRAY_I < TAG_ARRAY_M && TAG_ARRAY_M < TAG_ARRAY_T && TAG_ARRAY_T < TAG_ARRAY_S);
+// 2-bits suffice to encode base array tag in slice, remaining bits suffice to encode slice start.
+const _: () = assert!((TAG_ARRAY_S - TAG_ARRAY_I) / 2 < 4);
+const _: () = assert!(MAX_ARRAY_SIZE < (1 << (usize::BITS - 2)));
diff --git a/rts/motoko-rts/src/types.rs b/rts/motoko-rts/src/types.rs
index ae44903172c..439b124ce19 100644
--- a/rts/motoko-rts/src/types.rs
+++ b/rts/motoko-rts/src/types.rs
@@ -27,7 +27,7 @@ use core::ptr::null;
 use motoko_rts_macros::is_incremental_gc;
 use motoko_rts_macros::*;
 
-use crate::constants::WORD_SIZE;
+use crate::constants::{MAX_ARRAY_SIZE, WORD_SIZE};
 use crate::rts_trap_with;
 
 pub fn size_of<T>() -> Words<u32> {
@@ -333,11 +333,7 @@ impl Value {
 
     pub unsafe fn is_array(self) -> bool {
         let tag = self.tag();
-        tag == TAG_ARRAY_I
-            || tag == TAG_ARRAY_M
-            || tag == TAG_ARRAY_T
-            || tag == TAG_ARRAY_S
-            || tag >= TAG_ARRAY_SLICE_MIN
+        is_array_or_slice_tag(tag)
     }
 
     /// Get the pointer as `Obj` using forwarding. In debug mode panics if the value is not a pointer.
@@ -489,51 +485,57 @@ pub const TAG_FREE_SPACE: Tag = 53;
 
 // Special value to visit only a range of array fields.
 // This and all values above it are reserved and mean
-// a slice of an array object (i.e. start index) for
+// a slice of an array object (i.e. compressed array tag + start index) for
 // purposes of `visit_pointer_fields`.
+// The top two bits encode the original array tag, the remaining bits are the start index of the slice.
 // Invariant: the value of this (pseudo-)tag must be
 //            higher than all other tags defined above
 pub const TAG_ARRAY_SLICE_MIN: Tag = 54;
 
+pub const TAG_SPACING: Tag = 2;
+
+pub fn is_base_array_tag(tag: Tag) -> bool {
+    tag == TAG_ARRAY_I || tag == TAG_ARRAY_M || tag == TAG_ARRAY_T || tag == TAG_ARRAY_S
+}
+
+pub fn is_array_or_slice_tag(tag: Tag) -> bool {
+    is_base_array_tag(tag) || tag >= TAG_ARRAY_SLICE_MIN
+}
+
+#[inline]
+pub fn start_of_slice(tag: Tag) -> u32 {
+    tag << 2 >> 2
+}
+
+#[inline]
+pub fn tag_of_slice(tag: Tag) -> Tag {
+    TAG_ARRAY_I + (tag >> (usize::BITS - 2)) * TAG_SPACING
+}
+
 pub fn slice_tag(array_tag: Tag, slice_start: u32) -> Tag {
-    debug_assert!(
-        array_tag == TAG_ARRAY_I
-            || array_tag == TAG_ARRAY_M
-            || array_tag == TAG_ARRAY_T
-            || array_tag == TAG_ARRAY_S
-    );
-    debug_assert!(slice_start >= TAG_ARRAY_SLICE_MIN && slice_start < (1 << 30));
-    (((array_tag - TAG_ARRAY_I) / 2) << 30) | slice_start
+    debug_assert!(is_base_array_tag(array_tag));
+    debug_assert!(slice_start >= TAG_ARRAY_SLICE_MIN && slice_start <= MAX_ARRAY_SIZE);
+    (((array_tag - TAG_ARRAY_I) / TAG_SPACING) << (usize::BITS - 2)) | slice_start
 }
 
 pub fn slice_start(tag: Tag) -> (Tag, u32) {
-    debug_assert!(
-        tag == TAG_ARRAY_I
-            || tag == TAG_ARRAY_M
-            || tag == TAG_ARRAY_T
-            || tag == TAG_ARRAY_S
-            || tag >= TAG_ARRAY_SLICE_MIN
-    );
+    debug_assert!(is_array_or_slice_tag(tag));
     if tag >= TAG_ARRAY_SLICE_MIN {
-        (TAG_ARRAY_I + (tag >> 30) * 2, tag << 2 >> 2)
+        (tag_of_slice(tag), start_of_slice(tag))
     } else {
         (tag, 0)
     }
 }
 
 pub fn base_array_tag(tag: Tag) -> Tag {
-    debug_assert!(
-        tag == TAG_ARRAY_I
-            || tag == TAG_ARRAY_M
-            || tag == TAG_ARRAY_T
-            || tag == TAG_ARRAY_S
-            || tag >= TAG_ARRAY_SLICE_MIN
-    );
-    if tag >= TAG_ARRAY_SLICE_MIN {
-        TAG_ARRAY_I + (tag >> 30) * 2
+    debug_assert!(is_array_or_slice_tag(tag));
+    let base = if tag >= TAG_ARRAY_SLICE_MIN {
+        tag_of_slice(tag)
     } else {
         tag
-    }
+    };
+    debug_assert!(is_base_array_tag(base));
+    base
 }
 
 // Common parts of any object. Other object pointers can be coerced into a pointer to this.
@@ -649,10 +651,12 @@ impl Array {
     }
 
     pub unsafe fn set_slice_start(self: *mut Self, array_tag: Tag, start: u32) -> () {
+        debug_assert!(is_base_array_tag(array_tag));
         (*self).header.tag = slice_tag(array_tag, start)
     }
 
     pub unsafe fn restore_tag(self: *mut Self, array_tag: Tag) -> () {
+        debug_assert!(is_base_array_tag(array_tag));
         (*self).header.tag = array_tag;
     }
 }

From f5e97a995538c0313c9c356faa6ac47bca23f296 Mon Sep 17 00:00:00 2001
From: Claudio Russo <claudio@dfinity.org>
Date: Wed, 5 Jun 2024 16:07:04 +0100
Subject: [PATCH 237/260] assert array tag difference is even

---
 rts/motoko-rts/src/types.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/rts/motoko-rts/src/types.rs b/rts/motoko-rts/src/types.rs
index 439b124ce19..d0010dfdaab 100644
--- a/rts/motoko-rts/src/types.rs
+++ b/rts/motoko-rts/src/types.rs
@@ -515,6 +515,7 @@ pub fn tag_of_slice(tag: Tag) -> Tag {
 pub fn slice_tag(array_tag: Tag, slice_start: u32) -> Tag {
     debug_assert!(is_base_array_tag(array_tag));
     debug_assert!(slice_start >= TAG_ARRAY_SLICE_MIN && slice_start <= MAX_ARRAY_SIZE);
+    debug_assert!((array_tag - TAG_ARRAY_I) % TAG_SPACING == 0);
     (((array_tag - TAG_ARRAY_I) / TAG_SPACING) << (usize::BITS - 2)) | slice_start
 }
 

From afde9e17690ea447aaa8b3378c76abc6f1fc6910 Mon Sep 17 00:00:00 2001
From: Claudio Russo <claudio@dfinity.org>
Date: Wed, 5 Jun 2024 16:45:41 +0100
Subject: [PATCH 238/260] fix one broken assert (missing TAG_BLOB_A case);
 refactor other asserts

---
 rts/motoko-rts-tests/src/gc.rs | 15 ++-------------
 rts/motoko-rts/src/types.rs    | 10 ++++++----
 2 files changed, 8 insertions(+), 17 deletions(-)

diff --git a/rts/motoko-rts-tests/src/gc.rs b/rts/motoko-rts-tests/src/gc.rs
index 5d1b6f51ef7..2bc951503ad 100644
--- a/rts/motoko-rts-tests/src/gc.rs
+++ b/rts/motoko-rts-tests/src/gc.rs
@@ -285,20 +285,9 @@ fn check_dynamic_heap(
                     .as_usize();
             } else {
                 if incremental {
-                    assert!(
-                        tag == TAG_ARRAY_I
-                            || tag == TAG_ARRAY_M
-                            || tag == TAG_ARRAY_T
-                            || tag == TAG_ARRAY_S
-                            || tag >= TAG_ARRAY_SLICE_MIN
-                    );
+                    assert!(is_array_or_slice_tag(tag));
                 } else {
-                    assert!(
-                        tag == TAG_ARRAY_I
-                            || tag == TAG_ARRAY_M
-                            || tag == TAG_ARRAY_T
-                            || tag == TAG_ARRAY_S
-                    )
+                    assert!(is_base_array_tag(tag))
                 }
 
                 if is_forwarded {
diff --git a/rts/motoko-rts/src/types.rs b/rts/motoko-rts/src/types.rs
index d0010dfdaab..07445ad376a 100644
--- a/rts/motoko-rts/src/types.rs
+++ b/rts/motoko-rts/src/types.rs
@@ -328,7 +328,7 @@ impl Value {
 
     pub unsafe fn is_blob(self) -> bool {
         let tag = self.tag();
-        tag == TAG_BLOB_B || tag == TAG_BLOB_T || tag == TAG_BLOB_P || tag == TAG_BLOB_A
+        is_blob_tag(tag)
     }
 
     pub unsafe fn is_array(self) -> bool {
@@ -494,6 +494,10 @@ pub const TAG_ARRAY_SLICE_MIN: Tag = 54;
 
 pub const TAG_SPACING: Tag = 2;
 
+pub fn is_blob_tag(tag: Tag) -> bool {
+    tag == TAG_BLOB_B || tag == TAG_BLOB_T || tag == TAG_BLOB_P || tag == TAG_BLOB_A
+}
+
 pub fn is_base_array_tag(tag: Tag) -> bool {
     tag == TAG_ARRAY_I || tag == TAG_ARRAY_M || tag == TAG_ARRAY_T || tag == TAG_ARRAY_S
 }
@@ -574,9 +578,7 @@ impl Obj {
     }
 
     pub unsafe fn as_blob(self: *mut Self) -> *mut Blob {
-        debug_assert!(
-            self.tag() == TAG_BLOB_B || self.tag() == TAG_BLOB_T || self.tag() == TAG_BLOB_P
-        );
+        debug_assert!(is_blob_tag(self.tag()));
         self as *mut Blob
     }
 

From 34dd29dd823fd45ff817113e6886f8bf3c4687d1 Mon Sep 17 00:00:00 2001
From: Claudio Russo <claudio@dfinity.org>
Date: Thu, 6 Jun 2024 16:30:31 +0100
Subject: [PATCH 239/260] Update rts/motoko-rts-tests/src/gc/heap.rs

Co-authored-by: Luc Blaeser <112870813+luc-blaeser@users.noreply.github.com>
---
 rts/motoko-rts-tests/src/gc/heap.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rts/motoko-rts-tests/src/gc/heap.rs b/rts/motoko-rts-tests/src/gc/heap.rs
index 9877e0a5c2f..2a4f20e90bd 100644
--- a/rts/motoko-rts-tests/src/gc/heap.rs
+++ b/rts/motoko-rts-tests/src/gc/heap.rs
@@ -497,7 +497,7 @@ fn create_dynamic_heap(
         let mut heap_offset = continuation_table_offset;
 
         let continuation_table_address = u32::try_from(heap_start + heap_offset).unwrap();
-        write_word(dynamic_heap, heap_offset, TAG_ARRAY_M); // TODO: TBR
+        write_word(dynamic_heap, heap_offset, TAG_ARRAY_M);
         heap_offset += WORD_SIZE;
 
         if incremental {

From 0082f1db83c73ade9a4eb81f75b9e054fd4ad1ce Mon Sep 17 00:00:00 2001
From: Claudio Russo <claudio@dfinity.org>
Date: Fri, 7 Jun 2024 10:44:32 +0100
Subject: [PATCH 240/260] Update rts/motoko-rts-tests/src/gc/heap.rs

Co-authored-by: Luc Blaeser <112870813+luc-blaeser@users.noreply.github.com>
---
 rts/motoko-rts-tests/src/gc/heap.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rts/motoko-rts-tests/src/gc/heap.rs b/rts/motoko-rts-tests/src/gc/heap.rs
index 2a4f20e90bd..4aecd75754d 100644
--- a/rts/motoko-rts-tests/src/gc/heap.rs
+++ b/rts/motoko-rts-tests/src/gc/heap.rs
@@ -570,7 +570,7 @@ fn create_static_heap(
     // root.
     let array_addr = u32::try_from(heap.as_ptr() as usize).unwrap();
     let mut offset = 0;
-    write_word(heap, offset, TAG_ARRAY_M); // TODO: TBR
+    write_word(heap, offset, TAG_ARRAY_M);
     offset += WORD_SIZE;
 
     if incremental {

From b7cdc7a545eb0691a57a4387057ecd95dfd54447 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 7 Jun 2024 15:54:42 +0200
Subject: [PATCH 241/260] Manual merge conflict resolution

---
 rts/motoko-rts/src/gc/incremental/roots.rs      | 4 ++--
 rts/motoko-rts/src/memory.rs                    | 4 ++++
 rts/motoko-rts/src/persistence.rs               | 5 +++--
 rts/motoko-rts/src/persistence/compatibility.rs | 6 +++---
 4 files changed, 12 insertions(+), 7 deletions(-)

diff --git a/rts/motoko-rts/src/gc/incremental/roots.rs b/rts/motoko-rts/src/gc/incremental/roots.rs
index e629f927c28..afef9cf7577 100644
--- a/rts/motoko-rts/src/gc/incremental/roots.rs
+++ b/rts/motoko-rts/src/gc/incremental/roots.rs
@@ -56,9 +56,9 @@ unsafe fn static_variables_location() -> *mut Value {
 pub unsafe fn initialize_static_variables<M: crate::memory::Memory>(mem: &mut M, amount: u32) {
     use super::barriers::write_with_barrier;
     use crate::memory::alloc_array;
-    use crate::types::NULL_POINTER;
+    use crate::types::{NULL_POINTER, TAG_ARRAY_M};
 
-    let variables = alloc_array(mem, amount);
+    let variables = alloc_array(mem, TAG_ARRAY_M, amount);
     let array = variables.as_array();
     for index in 0..amount {
         array.initialize(index, NULL_POINTER, mem);
diff --git a/rts/motoko-rts/src/memory.rs b/rts/motoko-rts/src/memory.rs
index fed09c4218e..8ec17ac2777 100644
--- a/rts/motoko-rts/src/memory.rs
+++ b/rts/motoko-rts/src/memory.rs
@@ -46,6 +46,7 @@ pub trait Memory {
 /// For RTS-internal blobs that can be collected by the next GC run, the post allocation barrier can be omitted.
 #[ic_mem_fn]
 pub unsafe fn alloc_blob<M: Memory>(mem: &mut M, tag: u32, size: Bytes<u32>) -> Value {
+    debug_assert!(tag == TAG_BLOB_B || tag == TAG_BLOB_T || tag == TAG_BLOB_P || tag == TAG_BLOB_A);
     let ptr = mem.alloc_words(size_of::<Blob>() + size.to_words());
     // NB. Cannot use `as_blob` here as we didn't write the header yet
     let blob = ptr.get_ptr() as *mut Blob;
@@ -60,6 +61,9 @@ pub unsafe fn alloc_blob<M: Memory>(mem: &mut M, tag: u32, size: Bytes<u32>) ->
 /// Note: After initialization, the post allocation barrier needs to be applied to all mutator objects.
 #[ic_mem_fn]
 pub unsafe fn alloc_array<M: Memory>(mem: &mut M, tag: u32, len: u32) -> Value {
+    debug_assert!(
+        tag == TAG_ARRAY_I || tag == TAG_ARRAY_M || tag == TAG_ARRAY_T || tag == TAG_ARRAY_S
+    );
     // Array payload should not be larger than half of the memory
     if len > MAX_ARRAY_SIZE {
         rts_trap_with("Array allocation too large");
diff --git a/rts/motoko-rts/src/persistence.rs b/rts/motoko-rts/src/persistence.rs
index c2dadeaf31b..f5d903dad3a 100644
--- a/rts/motoko-rts/src/persistence.rs
+++ b/rts/motoko-rts/src/persistence.rs
@@ -18,7 +18,7 @@ use crate::{
     },
     rts_trap_with,
     stable_mem::read_persistence_version,
-    types::{Value, TAG_BLOB},
+    types::{Value, TAG_BLOB_B, TAG_BLOB_T},
 };
 
 use self::compatibility::TypeDescriptor;
@@ -192,7 +192,8 @@ pub unsafe fn register_stable_type<M: Memory>(
     new_candid_data: Value,
     new_type_offsets: Value,
 ) {
-    assert_eq!(new_candid_data.tag(), TAG_BLOB);
+    assert_eq!(new_candid_data.tag(), TAG_BLOB_B);
+    assert_eq!(new_type_offsets.tag(), TAG_BLOB_T);
     let mut new_type = TypeDescriptor::new(new_candid_data, new_type_offsets);
     let metadata = PersistentMetadata::get();
     let old_type = &mut (*metadata).stable_type;
diff --git a/rts/motoko-rts/src/persistence/compatibility.rs b/rts/motoko-rts/src/persistence/compatibility.rs
index 9649a23ba0d..ce61aadc1fb 100644
--- a/rts/motoko-rts/src/persistence/compatibility.rs
+++ b/rts/motoko-rts/src/persistence/compatibility.rs
@@ -8,7 +8,7 @@ use crate::{
     constants::WORD_SIZE,
     idl::TypeVariance,
     memory::{alloc_blob, Memory},
-    types::{Value, Words},
+    types::{Value, Words, TAG_BLOB_B},
 };
 
 const DEFAULT_VALUE: Value = Value::from_scalar(0);
@@ -80,7 +80,7 @@ impl TypeDescriptor {
     // be used during a single IC message when no GC increment is running in between.
     pub unsafe fn build_type_table<M: Memory>(&mut self, mem: &mut M) -> *mut *mut u8 {
         let type_count = self.type_count();
-        let temporary_blob = alloc_blob(mem, Words(type_count as u32).to_bytes());
+        let temporary_blob = alloc_blob(mem, TAG_BLOB_B, Words(type_count as u32).to_bytes());
         let offset_table = self.type_offsets.as_blob().payload_const() as *const u32;
         let type_table = temporary_blob.as_blob_mut().payload_addr() as *mut *mut u8;
         let candid_data = self.candid_data.as_blob_mut().payload_addr();
@@ -114,7 +114,7 @@ unsafe fn create_type_check_cache<M: Memory>(
     let new_type_count = new_type.type_count() as u32;
     let words = Words(BitRel::words(old_type_count, new_type_count));
     let byte_length = words.to_bytes();
-    let blob_value = alloc_blob(mem, byte_length);
+    let blob_value = alloc_blob(mem, TAG_BLOB_B, byte_length);
     let ptr = blob_value.as_blob_mut().payload_addr() as *mut u32;
     let end = blob_value
         .as_blob()

From 8cffb0ee105c66ffea6ddc854e7011fa8ea337eb Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 7 Jun 2024 21:18:40 +0200
Subject: [PATCH 242/260] Fix usage of specific blob tags

---
 rts/motoko-rts/src/persistence.rs | 4 ++--
 src/codegen/compile.ml            | 8 ++++----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/rts/motoko-rts/src/persistence.rs b/rts/motoko-rts/src/persistence.rs
index f5d903dad3a..f51cf6da1fe 100644
--- a/rts/motoko-rts/src/persistence.rs
+++ b/rts/motoko-rts/src/persistence.rs
@@ -18,7 +18,7 @@ use crate::{
     },
     rts_trap_with,
     stable_mem::read_persistence_version,
-    types::{Value, TAG_BLOB_B, TAG_BLOB_T},
+    types::{Value, TAG_BLOB_B},
 };
 
 use self::compatibility::TypeDescriptor;
@@ -193,7 +193,7 @@ pub unsafe fn register_stable_type<M: Memory>(
     new_type_offsets: Value,
 ) {
     assert_eq!(new_candid_data.tag(), TAG_BLOB_B);
-    assert_eq!(new_type_offsets.tag(), TAG_BLOB_T);
+    assert_eq!(new_type_offsets.tag(), TAG_BLOB_B);
     let mut new_type = TypeDescriptor::new(new_candid_data, new_type_offsets);
     let metadata = PersistentMetadata::get();
     let old_type = &mut (*metadata).stable_type;
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index e52c24a2499..2a84df27200 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -4120,7 +4120,7 @@ module Object = struct
         List.sort compare in
       let hash_blob =
         let hash_payload = StaticBytes.[ i32s hashes ] in
-        Blob.constant env Tagged.T (StaticBytes.as_bytes hash_payload)
+        Blob.constant env Tagged.B (StaticBytes.as_bytes hash_payload)
       in
       
       (fun env -> 
@@ -6318,13 +6318,13 @@ module Serialization = struct
   let get_global_type_offsets env =
     Tagged.share env (fun env -> 
       let descriptor = get_global_type_descriptor env in
-      Blob.load_data_segment env Tagged.T E.(descriptor.type_offsets_segment) (get_type_offsets_length env)
+      Blob.load_data_segment env Tagged.B E.(descriptor.type_offsets_segment) (get_type_offsets_length env)
     )
 
   let get_global_idl_types env =
     Tagged.share env (fun env -> 
       let descriptor = get_global_type_descriptor env in
-      Blob.load_data_segment env Tagged.T E.(descriptor.idl_types_segment) (get_idl_types_length env)
+      Blob.load_data_segment env Tagged.B E.(descriptor.idl_types_segment) (get_idl_types_length env)
     )
   
   module Registers = struct
@@ -8437,7 +8437,7 @@ module Persistence = struct
     let serialized_offsets = StaticBytes.(as_bytes [i32s (List.map Int32.of_int type_offsets)]) in
     assert (type_indices = [0l]);
     Blob.lit env Tagged.B candid_type_desc ^^
-    Blob.lit env Tagged.T serialized_offsets ^^
+    Blob.lit env Tagged.B serialized_offsets ^^
     E.call_import env "rts" "register_stable_type"
 
   let create_actor env actor_type get_field_value =

From f0f432e402c59358ca30e8955ece5203285cc1db Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 24 Jun 2024 10:00:18 +0200
Subject: [PATCH 243/260] Code refactoring in RTS

---
 rts/motoko-rts/src/memory.rs | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/rts/motoko-rts/src/memory.rs b/rts/motoko-rts/src/memory.rs
index 8ec17ac2777..15a272263e5 100644
--- a/rts/motoko-rts/src/memory.rs
+++ b/rts/motoko-rts/src/memory.rs
@@ -46,7 +46,7 @@ pub trait Memory {
 /// For RTS-internal blobs that can be collected by the next GC run, the post allocation barrier can be omitted.
 #[ic_mem_fn]
 pub unsafe fn alloc_blob<M: Memory>(mem: &mut M, tag: u32, size: Bytes<u32>) -> Value {
-    debug_assert!(tag == TAG_BLOB_B || tag == TAG_BLOB_T || tag == TAG_BLOB_P || tag == TAG_BLOB_A);
+    debug_assert!(is_blob_tag(tag));
     let ptr = mem.alloc_words(size_of::<Blob>() + size.to_words());
     // NB. Cannot use `as_blob` here as we didn't write the header yet
     let blob = ptr.get_ptr() as *mut Blob;
@@ -61,9 +61,7 @@ pub unsafe fn alloc_blob<M: Memory>(mem: &mut M, tag: u32, size: Bytes<u32>) ->
 /// Note: After initialization, the post allocation barrier needs to be applied to all mutator objects.
 #[ic_mem_fn]
 pub unsafe fn alloc_array<M: Memory>(mem: &mut M, tag: u32, len: u32) -> Value {
-    debug_assert!(
-        tag == TAG_ARRAY_I || tag == TAG_ARRAY_M || tag == TAG_ARRAY_T || tag == TAG_ARRAY_S
-    );
+    debug_assert!(is_base_array_tag(tag));
     // Array payload should not be larger than half of the memory
     if len > MAX_ARRAY_SIZE {
         rts_trap_with("Array allocation too large");

From e7bf60c7ff04b0d98521d7fd7c08b20c9756bc1a Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 24 Jun 2024 10:11:57 +0200
Subject: [PATCH 244/260] Code refactoring in compiler backend

---
 src/codegen/compile.ml | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 2a84df27200..790d3c97b18 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -4388,8 +4388,7 @@ module Text = struct
     get_blob ^^ Blob.as_ptr_len env ^^
     E.call_import env "rts" "utf8_valid" ^^
     G.if1 I32Type
-      (get_blob ^^ Blob.as_ptr_len env ^^
-       of_ptr_size env ^^ (* creates text blob *)
+      (get_blob ^^ Blob.copy env Tagged.B Tagged.T ^^
        set_blob ^^
        Opt.inject_simple env get_blob)
       (Opt.null_lit env)

From 0ff25ce291b04d294f747bd3fb3f7a69cc3d41e9 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Tue, 25 Jun 2024 21:30:44 +0200
Subject: [PATCH 245/260] Manual merge conflict resolution

---
 test/run-drun/ok/stable-size-no-overflow.tc.ok | 2 ++
 1 file changed, 2 insertions(+)
 create mode 100644 test/run-drun/ok/stable-size-no-overflow.tc.ok

diff --git a/test/run-drun/ok/stable-size-no-overflow.tc.ok b/test/run-drun/ok/stable-size-no-overflow.tc.ok
new file mode 100644
index 00000000000..4c1a57bfe2b
--- /dev/null
+++ b/test/run-drun/ok/stable-size-no-overflow.tc.ok
@@ -0,0 +1,2 @@
+stable-mem/StableMemory.mo:5.21-5.42: warning [M0199], this code is (or uses) the deprecated library `ExperimentalStableMemory`.
+Please use the `Region` library instead: https://internetcomputer.org/docs/current/motoko/main/stable-memory/stable-regions/#the-region-library or compile with flag `--experimental-stable-memory 1` to suppress this message.

From e83e95b1e747f444fd94f8d44e698cbaee38f917 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Wed, 26 Jun 2024 10:21:11 +0200
Subject: [PATCH 246/260] Code refactoring, RTS project config

---
 rts/.gitignore         | 3 +--
 rts/Makefile           | 3 +--
 src/codegen/compile.ml | 1 -
 3 files changed, 2 insertions(+), 5 deletions(-)

diff --git a/rts/.gitignore b/rts/.gitignore
index 31939c72d62..c6e88c02f69 100644
--- a/rts/.gitignore
+++ b/rts/.gitignore
@@ -1,3 +1,2 @@
-mo-rts.wasm
-mo-rts-debug.wasm
+mo-rts*.wasm
 _build
diff --git a/rts/Makefile b/rts/Makefile
index 70132dde886..052952ee45d 100644
--- a/rts/Makefile
+++ b/rts/Makefile
@@ -296,8 +296,7 @@ format:
 clean:
 	rm -rf \
 	  _build \
-	  mo-rts.wasm \
-	  mo-rts-debug.wasm \
+	  mo-rts*.wasm \
 	  motoko-rts/target \
 	  motoko-rts-tests/target \
 	  motoko-rts-macros/target \
diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 790d3c97b18..973dfe92e6f 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -4078,7 +4078,6 @@ module Object = struct
      The hash blob needs to be tracked by the GC, but not the content of the hash blob.
      This is because the hash values are plain numbers that would look like skewed pointers.ters.
      The hash_ptr is skewed.
-     TODO: Optimize by sharing the hash blob for objects of the same type.
  
      The field2_data for immutable fields is a vanilla word.
  

From e00bafb55de3e4c64b2970cbbd8d7cd787737a92 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Thu, 27 Jun 2024 17:28:51 +0200
Subject: [PATCH 247/260] Make memory check feature compile again

---
 rts/motoko-rts/src/gc/incremental/sanity_checks.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/rts/motoko-rts/src/gc/incremental/sanity_checks.rs b/rts/motoko-rts/src/gc/incremental/sanity_checks.rs
index ed39fecde16..1cbe922a0a4 100644
--- a/rts/motoko-rts/src/gc/incremental/sanity_checks.rs
+++ b/rts/motoko-rts/src/gc/incremental/sanity_checks.rs
@@ -102,7 +102,7 @@ impl<'a, M: Memory> MemoryChecker<'a, M> {
             object.tag(),
             |gc, field_address| {
                 let value = *field_address;
-                if value.is_ptr() {
+                if value.is_non_null_ptr() {
                     gc.check_object(value);
                 } else {
                     gc.check_object_header(value);
@@ -114,7 +114,7 @@ impl<'a, M: Memory> MemoryChecker<'a, M> {
 
     unsafe fn check_object_header(&self, object: Value) {
         let tag = object.tag();
-        assert!(tag >= TAG_OBJECT && tag <= TAG_NULL);
+        assert!(is_object_tag(tag));
         object.check_forwarding_pointer();
         if let CheckerMode::UpdateCompletion = self.mode {
             // Forwarding is no longer allowed on a completed GC.

From 49e0bc46b2b0bffb5270dc733d822a1ab2c4dfd2 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 8 Jul 2024 15:10:43 +0200
Subject: [PATCH 248/260] Deprecate `stableVarQuery`

---
 src/codegen/compile.ml                       | 8 +-------
 test/run-drun/ok/query-footprint.drun-run.ok | 8 ++++----
 2 files changed, 5 insertions(+), 11 deletions(-)

diff --git a/src/codegen/compile.ml b/src/codegen/compile.ml
index 973dfe92e6f..966eac9dca1 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile.ml
@@ -10894,13 +10894,7 @@ and compile_prim_invocation (env : E.t) ae p es at =
 
   | ICStableSize t, [e] ->
     SR.UnboxedWord64 Type.Nat64,
-    let (tydesc, _, _) = Serialization.(type_desc env Candid [t]) in
-    let tydesc_len = Int32.of_int (String.length tydesc) in
-    compile_exp_vanilla env ae e ^^
-    Serialization.buffer_size env t ^^
-    G.i Drop ^^
-    compile_add_const tydesc_len ^^
-    G.i (Convert (Wasm.Values.I64 I64Op.ExtendUI32))
+    E.trap_with env "Deprecated with enhanced orthogonal persistence"
 
   (* Other prims, unary *)
 
diff --git a/test/run-drun/ok/query-footprint.drun-run.ok b/test/run-drun/ok/query-footprint.drun-run.ok
index e9dfaac3f24..e29028fdae6 100644
--- a/test/run-drun/ok/query-footprint.drun-run.ok
+++ b/test/run-drun/ok/query-footprint.drun-run.ok
@@ -1,6 +1,6 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-ingress Completed: Reply: 0x4449444c016c01c1c1cee2047801005118000000000000
-Ok: Reply: 0x4449444c016c01c1c1cee2047801005118000000000000
-ingress Completed: Reply: 0x4449444c0001785118000000000000
-ingress Completed: Reply: 0x4449444c0001785118000000000000
+ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: Deprecated with enhanced orthogonal persistence
+Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: Deprecated with enhanced orthogonal persistence
+ingress Completed: Reject: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: Deprecated with enhanced orthogonal persistence
+ingress Completed: Reject: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: Deprecated with enhanced orthogonal persistence

From b8471c8cbcfba2fb00c80bd3b16a2bd918b27e77 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 8 Jul 2024 15:16:27 +0200
Subject: [PATCH 249/260] Manual merge conflict resolution

---
 test/bench/ok/bignum.drun-run.ok | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/bench/ok/bignum.drun-run.ok b/test/bench/ok/bignum.drun-run.ok
index dcab51a7f2e..b7ccbbf2d34 100644
--- a/test/bench/ok/bignum.drun-run.ok
+++ b/test/bench/ok/bignum.drun-run.ok
@@ -1,6 +1,6 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 2_626_820; size = +60_128}
+debug.print: {cycles = 2_626_730; size = +60_128}
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 107_960_464; size = +1_826_952}
+debug.print: {cycles = 107_960_494; size = +1_826_952}
 ingress Completed: Reply: 0x4449444c0000

From 0a8a13fc34eff8ea4f8be54fc74fb5e3459e79b6 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 8 Jul 2024 16:09:42 +0200
Subject: [PATCH 250/260] Adjust expected test output

---
 test/run-drun/ok/query-footprint-overflow.drun-run.ok | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/run-drun/ok/query-footprint-overflow.drun-run.ok b/test/run-drun/ok/query-footprint-overflow.drun-run.ok
index 68f885e7493..c12bbde1992 100644
--- a/test/run-drun/ok/query-footprint-overflow.drun-run.ok
+++ b/test/run-drun/ok/query-footprint-overflow.drun-run.ok
@@ -1,3 +1,3 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-ingress Completed: Reject: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: buffer_size overflow
+ingress Completed: Reject: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: Deprecated with enhanced orthogonal persistence

From a2101193e0079627c36214d2d18ffe438e8b0669 Mon Sep 17 00:00:00 2001
From: Luc Blaeser <112870813+luc-blaeser@users.noreply.github.com>
Date: Fri, 12 Jul 2024 10:38:17 +0200
Subject: [PATCH 251/260] EOP: Using a Dedicated Stable Option Type in
 Persistent State (#4601)

---
 rts/motoko-rts-tests/src/main.rs              |  2 +
 rts/motoko-rts-tests/src/stable_option.rs     | 24 +++++++++
 rts/motoko-rts/src/gc/incremental.rs          | 10 ++--
 .../src/gc/incremental/partitioned_heap.rs    | 11 ++--
 .../phases/evacuation_increment.rs            |  5 +-
 .../gc/incremental/phases/mark_increment.rs   |  5 +-
 .../gc/incremental/phases/update_increment.rs |  5 +-
 rts/motoko-rts/src/lib.rs                     |  2 +
 rts/motoko-rts/src/stable_option.rs           | 53 +++++++++++++++++++
 9 files changed, 101 insertions(+), 16 deletions(-)
 create mode 100644 rts/motoko-rts-tests/src/stable_option.rs
 create mode 100644 rts/motoko-rts/src/stable_option.rs

diff --git a/rts/motoko-rts-tests/src/main.rs b/rts/motoko-rts-tests/src/main.rs
index c1dd4f4e505..7e0b3e1dcfb 100644
--- a/rts/motoko-rts-tests/src/main.rs
+++ b/rts/motoko-rts-tests/src/main.rs
@@ -8,6 +8,7 @@ mod gc;
 mod leb128;
 mod memory;
 mod principal_id;
+mod stable_option;
 mod text;
 mod utf8;
 
@@ -28,6 +29,7 @@ fn main() {
         gc::test();
         leb128::test();
         principal_id::test();
+        stable_option::test();
         text::test();
         utf8::test();
     }
diff --git a/rts/motoko-rts-tests/src/stable_option.rs b/rts/motoko-rts-tests/src/stable_option.rs
new file mode 100644
index 00000000000..bf150dd54ba
--- /dev/null
+++ b/rts/motoko-rts-tests/src/stable_option.rs
@@ -0,0 +1,24 @@
+use motoko_rts::stable_option::StableOption;
+
+pub fn test() {
+    println!("Testing StableOption ...");
+
+    let mut none: StableOption<usize> = StableOption::None;
+    assert!(none.is_none());
+    assert!(!none.is_some());
+    assert!(none.as_ref().is_none());
+    assert!(!none.as_ref().is_some());
+    assert!(none.as_mut().is_none());
+    assert!(!none.as_mut().is_some());
+
+    const TEST_VALUE: usize = 123456;
+    let mut some = Some(TEST_VALUE);
+    assert!(!some.is_none());
+    assert!(some.is_some());
+    assert_eq!(some.unwrap(), TEST_VALUE);
+    assert_eq!(some.as_ref().unwrap(), &TEST_VALUE);
+    assert_eq!(*some.as_mut().unwrap(), TEST_VALUE);
+
+    *some.as_mut().unwrap() = 0;
+    assert_eq!(some.unwrap(), 0);
+}
diff --git a/rts/motoko-rts/src/gc/incremental.rs b/rts/motoko-rts/src/gc/incremental.rs
index 79f2f2bd66b..ce6d8956577 100644
--- a/rts/motoko-rts/src/gc/incremental.rs
+++ b/rts/motoko-rts/src/gc/incremental.rs
@@ -13,7 +13,7 @@
 
 use motoko_rts_macros::ic_mem_fn;
 
-use crate::{memory::Memory, types::*, visitor::visit_pointer_fields};
+use crate::{memory::Memory, stable_option::StableOption, types::*, visitor::visit_pointer_fields};
 
 use self::{
     partitioned_heap::{PartitionedHeap, PartitionedHeapIterator},
@@ -162,8 +162,8 @@ pub struct State {
     phase: Phase,
     partitioned_heap: PartitionedHeap,
     allocation_count: usize, // Number of allocations during an active GC run.
-    mark_state: Option<MarkState>,
-    iterator_state: Option<PartitionedHeapIterator>,
+    mark_state: StableOption<MarkState>,
+    iterator_state: StableOption<PartitionedHeapIterator>,
     statistics: Statistics,
 }
 
@@ -191,8 +191,8 @@ impl<'a, M: Memory + 'a> IncrementalGC<'a, M> {
             phase: Phase::Pause,
             partitioned_heap,
             allocation_count: 0,
-            mark_state: None,
-            iterator_state: None,
+            mark_state: StableOption::None,
+            iterator_state: StableOption::None,
             statistics,
         }
     }
diff --git a/rts/motoko-rts/src/gc/incremental/partitioned_heap.rs b/rts/motoko-rts/src/gc/incremental/partitioned_heap.rs
index bb59667270e..3e9765da092 100644
--- a/rts/motoko-rts/src/gc/incremental/partitioned_heap.rs
+++ b/rts/motoko-rts/src/gc/incremental/partitioned_heap.rs
@@ -45,6 +45,7 @@ use crate::{
     gc::incremental::mark_bitmap::BITMAP_ITERATION_END,
     memory::Memory,
     rts_trap_with,
+    stable_option::StableOption,
     types::*,
 };
 
@@ -231,7 +232,7 @@ impl Partition {
 #[repr(C)]
 pub struct PartitionedHeapIterator {
     partition_index: usize,
-    bitmap_iterator: Option<BitmapIterator>,
+    bitmap_iterator: StableOption<BitmapIterator>,
     visit_large_object: bool,
 }
 
@@ -239,7 +240,7 @@ impl PartitionedHeapIterator {
     pub fn new(heap: &PartitionedHeap) -> PartitionedHeapIterator {
         let mut iterator = PartitionedHeapIterator {
             partition_index: 0,
-            bitmap_iterator: None,
+            bitmap_iterator: StableOption::None,
             visit_large_object: false,
         };
         iterator.skip_empty_partitions(heap);
@@ -286,15 +287,15 @@ impl PartitionedHeapIterator {
     fn start_object_iteration(&mut self, heap: &PartitionedHeap) {
         debug_assert!(self.partition_index <= MAX_PARTITIONS);
         if self.partition_index == MAX_PARTITIONS {
-            self.bitmap_iterator = None;
+            self.bitmap_iterator = StableOption::None;
             self.visit_large_object = false;
         } else {
             let partition = heap.get_partition(self.partition_index);
             if partition.has_large_content() {
-                self.bitmap_iterator = None;
+                self.bitmap_iterator = StableOption::None;
                 self.visit_large_object = partition.marked_size() > 0
             } else {
-                self.bitmap_iterator = Some(partition.get_bitmap().iterate());
+                self.bitmap_iterator = StableOption::Some(partition.get_bitmap().iterate());
                 self.visit_large_object = false;
             }
         }
diff --git a/rts/motoko-rts/src/gc/incremental/phases/evacuation_increment.rs b/rts/motoko-rts/src/gc/incremental/phases/evacuation_increment.rs
index 58f90925f31..548f0f62b07 100644
--- a/rts/motoko-rts/src/gc/incremental/phases/evacuation_increment.rs
+++ b/rts/motoko-rts/src/gc/incremental/phases/evacuation_increment.rs
@@ -6,6 +6,7 @@ use crate::{
     },
     mem_utils::memcpy_words,
     memory::Memory,
+    stable_option::StableOption,
     types::*,
 };
 
@@ -20,13 +21,13 @@ impl<'a, M: Memory + 'a> EvacuationIncrement<'a, M> {
     pub unsafe fn start_phase(state: &mut State) {
         debug_assert!(state.iterator_state.is_none());
         let heap = &mut state.partitioned_heap;
-        state.iterator_state = Some(PartitionedHeapIterator::new(heap));
+        state.iterator_state = StableOption::Some(PartitionedHeapIterator::new(heap));
         heap.plan_evacuations();
     }
 
     pub unsafe fn complete_phase(state: &mut State) {
         debug_assert!(Self::evacuation_completed(state));
-        state.iterator_state = None;
+        state.iterator_state = StableOption::None;
     }
 
     pub unsafe fn evacuation_completed(state: &State) -> bool {
diff --git a/rts/motoko-rts/src/gc/incremental/phases/mark_increment.rs b/rts/motoko-rts/src/gc/incremental/phases/mark_increment.rs
index 92fe4836a84..e71c8be3713 100644
--- a/rts/motoko-rts/src/gc/incremental/phases/mark_increment.rs
+++ b/rts/motoko-rts/src/gc/incremental/phases/mark_increment.rs
@@ -8,6 +8,7 @@ use crate::{
         State,
     },
     memory::Memory,
+    stable_option::StableOption,
     types::*,
     visitor::visit_pointer_fields,
 };
@@ -32,7 +33,7 @@ impl<'a, M: Memory + 'a> MarkIncrement<'a, M> {
         state.partitioned_heap.start_collection(mem, time);
         debug_assert!(state.mark_state.is_none());
         let mark_stack = MarkStack::new(mem);
-        state.mark_state = Some(MarkState {
+        state.mark_state = StableOption::Some(MarkState {
             mark_stack,
             complete: false,
         });
@@ -40,7 +41,7 @@ impl<'a, M: Memory + 'a> MarkIncrement<'a, M> {
 
     pub unsafe fn complete_phase(state: &mut State) {
         debug_assert!(Self::mark_completed(state));
-        state.mark_state = None;
+        state.mark_state = StableOption::None;
     }
 
     pub unsafe fn mark_completed(state: &State) -> bool {
diff --git a/rts/motoko-rts/src/gc/incremental/phases/update_increment.rs b/rts/motoko-rts/src/gc/incremental/phases/update_increment.rs
index 4403296c812..57e0dc21c54 100644
--- a/rts/motoko-rts/src/gc/incremental/phases/update_increment.rs
+++ b/rts/motoko-rts/src/gc/incremental/phases/update_increment.rs
@@ -6,6 +6,7 @@ use crate::{
         time::BoundedTime,
         Roots, State,
     },
+    stable_option::StableOption,
     types::*,
     visitor::visit_pointer_fields,
 };
@@ -21,14 +22,14 @@ impl<'a> UpdateIncrement<'a> {
     pub unsafe fn start_phase(state: &mut State) {
         debug_assert!(state.iterator_state.is_none());
         let heap = &mut state.partitioned_heap;
-        state.iterator_state = Some(PartitionedHeapIterator::new(heap));
+        state.iterator_state = StableOption::Some(PartitionedHeapIterator::new(heap));
         heap.collect_large_objects();
         heap.plan_updates();
     }
 
     pub unsafe fn complete_phase(state: &mut State) {
         debug_assert!(Self::update_completed(state));
-        state.iterator_state = None;
+        state.iterator_state = StableOption::None;
         state.partitioned_heap.complete_collection();
     }
 
diff --git a/rts/motoko-rts/src/lib.rs b/rts/motoko-rts/src/lib.rs
index 8700941789a..52130eba35f 100644
--- a/rts/motoko-rts/src/lib.rs
+++ b/rts/motoko-rts/src/lib.rs
@@ -13,6 +13,8 @@ extern crate alloc;
 #[cfg(feature = "ic")]
 pub mod allocator;
 
+pub mod stable_option;
+
 #[macro_use]
 mod print;
 
diff --git a/rts/motoko-rts/src/stable_option.rs b/rts/motoko-rts/src/stable_option.rs
new file mode 100644
index 00000000000..48669954d98
--- /dev/null
+++ b/rts/motoko-rts/src/stable_option.rs
@@ -0,0 +1,53 @@
+//! Customized option type with a fixed C-representation.
+//! As the native Rust type may change in future Rust releases,
+//! the Motoko runtime system uses its own dedicated `StableOption`
+//! type with a fixed long-term representation. This is used in the
+//! persistent metadata, such as in the garbage collector state.
+//! See:
+//! * `gc::incremental::State`
+//! * `gc::partitioned_heap::PartitionedHeapIterator`
+
+/// Stable option type used for orthogonal persistent state.
+/// Analogous use like the Rust-native `Option`.
+#[repr(C)]
+pub enum StableOption<T> {
+    None,
+    Some(T),
+}
+
+impl<T> StableOption<T> {
+    pub const fn is_none(&self) -> bool {
+        match self {
+            Self::None => true,
+            Self::Some(_) => false,
+        }
+    }
+
+    pub const fn is_some(&self) -> bool {
+        match self {
+            Self::None => false,
+            Self::Some(_) => true,
+        }
+    }
+
+    pub fn unwrap(self) -> T {
+        match self {
+            Self::None => panic!("Unwrapping `None` on `StableOption`"),
+            Self::Some(x) => x,
+        }
+    }
+
+    pub fn as_mut(&mut self) -> StableOption<&mut T> {
+        match *self {
+            Self::Some(ref mut x) => StableOption::Some(x),
+            Self::None => StableOption::None,
+        }
+    }
+
+    pub const fn as_ref(&self) -> StableOption<&T> {
+        match *self {
+            Self::Some(ref x) => StableOption::Some(x),
+            Self::None => StableOption::None,
+        }
+    }
+}

From d3d9776b0acafcd29ab8d7e4a13d17079643559e Mon Sep 17 00:00:00 2001
From: Luc Blaeser <112870813+luc-blaeser@users.noreply.github.com>
Date: Mon, 22 Jul 2024 10:33:59 +0200
Subject: [PATCH 252/260] EOP: Relaxed Upgrade Compatibility Check (#4602)

---
 src/lang_utils/error_codes.ml |  4 ++--
 src/mo_frontend/stability.ml  | 42 +++++++++++++++++------------------
 src/mo_types/type.ml          | 14 +++++-------
 test/cmp/ok/mut-x-x.cmp.ok    |  6 +----
 test/cmp/ok/neg-xyz-x.cmp.ok  | 10 ++++-----
 test/cmp/ok/neg-xyz-y.cmp.ok  | 10 ++++-----
 test/cmp/ok/old-new.cmp.ok    | 10 ++++-----
 test/cmp/ok/x-mut-x.cmp.ok    |  6 +----
 8 files changed, 45 insertions(+), 57 deletions(-)

diff --git a/src/lang_utils/error_codes.ml b/src/lang_utils/error_codes.ml
index 15158cb264a..7c700edfb2c 100644
--- a/src/lang_utils/error_codes.ml
+++ b/src/lang_utils/error_codes.ml
@@ -172,9 +172,9 @@ let error_codes : (string * string option) list =
     "M0166", None; (* Type intersection results in abstract type *)
     "M0167", None; (* Type union results in bottom type *)
     "M0168", None; (* Type union or intersection on forward types *)
-    "M0169", None; (* Stable variable cannot be discarded *)
+    "M0169", None; (* Stable variable will be discarded. This may cause data loss. *)
     "M0170", None; (* Stable variable must subtype *)
-    "M0171", None; (* Stable variable changing mutability *)
+    (* "M0171" DEFUNCT Stable variable changing mutability *)
     "M0172", None; (* to_candid produces Blob, not -- *)
     "M0173", None; (* to_candid arg must have shared type, not -- *)
     "M0174", None; (* from_candid produces an optional shared, not -- *)
diff --git a/src/mo_frontend/stability.ml b/src/mo_frontend/stability.ml
index 57e444f12a3..b3069f5e307 100644
--- a/src/mo_frontend/stability.ml
+++ b/src/mo_frontend/stability.ml
@@ -14,10 +14,10 @@ let display_typ = Lib.Format.display Type.pp_typ
 
 let display_typ_expand = Lib.Format.display Type.pp_typ_expand
 
-let error_discard s tf =
+let warning_discard s tf =
   Diag.add_msg s
-    (Diag.error_message Source.no_region "M0169" cat
-      (Format.asprintf "stable variable %s of previous type%a\ncannot be discarded; promote to type `Any` instead"
+    (Diag.warning_message Source.no_region "M0169" cat
+      (Format.asprintf "stable variable %s of previous type%a\n will be discarded. This may cause data loss. Are you sure?"
         tf.lab
         display_typ tf.typ))
 
@@ -29,39 +29,39 @@ let error_sub s tf1 tf2 =
         display_typ_expand tf1.typ
         display_typ_expand tf2.typ))
 
-let error_mut s tf1 tf2 =
-  Diag.add_msg s
-    (Diag.error_message Source.no_region "M0171" cat
-      (Format.asprintf "stable variable %s changes mutability from previous type%a\nto new type %a"
-         tf1.lab
-         display_typ_expand tf1.typ
-         display_typ_expand tf2.typ))
+(* Relaxed rules with enhanced orthogonal persistence for more flexible upgrades.
+   - Mutability of stable fields can be changed because they are never aliased.
+   - Stable fields can be dropped, however, with a warning of potential data loss. 
+     For this, we give up the transitivity property of upgrades.
 
+   Upgrade transitivity means that an upgrade from a program A to B and then from B to C 
+   should have the same effect as directly upgrading from A to C. If B discards a field 
+   and C re-adds it, this transitivity is no longer maintained. However, rigorous upgrade 
+   transitivity was also not guaranteed before, since B may contain initialization logic
+   or pre-/post-upgrade hooks that alter the stable data.
+*)
 let match_stab_sig tfs1 tfs2 : unit Diag.result =
   (* Assume that tfs1 and tfs2 are sorted. *)
   let res = Diag.with_message_store (fun s ->
-    (* Should we insist on monotonic preservation of fields, or relax? *)
     let rec go tfs1 tfs2 = match tfs1, tfs2 with
       | [], _ ->
         Some () (* no or additional fields ok *)
       | tf1 :: tfs1', [] ->
-        error_discard s tf1;
+        (* dropped field is allowed with warning, recurse on tfs1' *)
+        warning_discard s tf1;
         go tfs1' []
       | tf1::tfs1', tf2::tfs2' ->
         (match Type.compare_field tf1 tf2 with
          | 0 ->
-           (* Should we enforce equal mutability or not?
-              Seems unnecessary since upgrade is read-once *)
-            if Type.is_mut tf1.typ <> Type.is_mut tf2.typ then
-              error_mut s tf1 tf2;
             if not (sub (as_immut tf1.typ) (as_immut tf2.typ)) then
               error_sub s tf1 tf2;
             go tfs1' tfs2'
-       | -1 ->
-          error_discard s tf1;
-          go tfs1' tfs2
-        | _ ->
-          go tfs1 tfs2' (* new field ok, recurse on tfs2' *)
+         | -1 ->
+           (* dropped field is allowed with warning, recurse on tfs1' *)
+           warning_discard s tf1;
+           go tfs1' tfs2 
+         | _ ->
+           go tfs1 tfs2' (* new field ok, recurse on tfs2' *)
         )
     in go tfs1 tfs2)
   in
diff --git a/src/mo_types/type.ml b/src/mo_types/type.ml
index cc4e27c8c7b..48829a3bf51 100644
--- a/src/mo_types/type.ml
+++ b/src/mo_types/type.ml
@@ -1821,22 +1821,18 @@ let _ = str := string_of_typ
 
 let rec match_stab_sig tfs1 tfs2 =
   (* Assume that tfs1 and tfs2 are sorted. *)
-  (* Should we insist on monotonic preservation of fields, or relax? *)
   match tfs1, tfs2 with
-  | [], _ ->
-    true (* no or additional fields ok *)
-  | _, [] ->
-    false (* true, should we allow fields to be dropped *)
+  | [], _ | _, [] ->
+    (* same amount of fields, new fields, or dropped fields ok *)
+    true
   | tf1::tfs1', tf2::tfs2' ->
     (match compare_field tf1 tf2 with
      | 0 ->
-       is_mut tf1.typ = is_mut tf2.typ &&
        sub (as_immut tf1.typ) (as_immut tf2.typ) &&
-         (* should we enforce equal mutability or not? Seems unncessary
-            since upgrade is read-once *)
        match_stab_sig tfs1' tfs2'
      | -1 ->
-       false (* match_sig tfs1' tfs2', should we allow fields to be dropped *)
+       (* dropped field ok *)
+       match_stab_sig tfs1' tfs2
      | _ ->
        (* new field ok *)
        match_stab_sig tfs1 tfs2'
diff --git a/test/cmp/ok/mut-x-x.cmp.ok b/test/cmp/ok/mut-x-x.cmp.ok
index 8fefa3b3f0f..ef2f5130b85 100644
--- a/test/cmp/ok/mut-x-x.cmp.ok
+++ b/test/cmp/ok/mut-x-x.cmp.ok
@@ -1,5 +1 @@
-(unknown location): Compatibility error [M0171], stable variable x changes mutability from previous type
-  var Nat
-to new type 
-  Nat
-FALSE
+TRUE
diff --git a/test/cmp/ok/neg-xyz-x.cmp.ok b/test/cmp/ok/neg-xyz-x.cmp.ok
index 6349767d29a..161146300d9 100644
--- a/test/cmp/ok/neg-xyz-x.cmp.ok
+++ b/test/cmp/ok/neg-xyz-x.cmp.ok
@@ -1,7 +1,7 @@
-(unknown location): Compatibility error [M0169], stable variable y of previous type
+(unknown location): warning [M0169], stable variable y of previous type
   Int
-cannot be discarded; promote to type `Any` instead
-(unknown location): Compatibility error [M0169], stable variable z of previous type
+ will be discarded. This may cause data loss. Are you sure?
+(unknown location): warning [M0169], stable variable z of previous type
   Bool
-cannot be discarded; promote to type `Any` instead
-FALSE
+ will be discarded. This may cause data loss. Are you sure?
+TRUE
diff --git a/test/cmp/ok/neg-xyz-y.cmp.ok b/test/cmp/ok/neg-xyz-y.cmp.ok
index 8f5122cdab5..1c9364ac506 100644
--- a/test/cmp/ok/neg-xyz-y.cmp.ok
+++ b/test/cmp/ok/neg-xyz-y.cmp.ok
@@ -1,7 +1,7 @@
-(unknown location): Compatibility error [M0169], stable variable x of previous type
+(unknown location): warning [M0169], stable variable x of previous type
   Nat
-cannot be discarded; promote to type `Any` instead
-(unknown location): Compatibility error [M0169], stable variable z of previous type
+ will be discarded. This may cause data loss. Are you sure?
+(unknown location): warning [M0169], stable variable z of previous type
   Bool
-cannot be discarded; promote to type `Any` instead
-FALSE
+ will be discarded. This may cause data loss. Are you sure?
+TRUE
diff --git a/test/cmp/ok/old-new.cmp.ok b/test/cmp/ok/old-new.cmp.ok
index bc29a991e43..98986beaf74 100644
--- a/test/cmp/ok/old-new.cmp.ok
+++ b/test/cmp/ok/old-new.cmp.ok
@@ -1,7 +1,7 @@
-(unknown location): Compatibility error [M0169], stable variable config_royalty_address of previous type
+(unknown location): warning [M0169], stable variable config_royalty_address of previous type
   var Text
-cannot be discarded; promote to type `Any` instead
-(unknown location): Compatibility error [M0169], stable variable config_royalty_fee of previous type
+ will be discarded. This may cause data loss. Are you sure?
+(unknown location): warning [M0169], stable variable config_royalty_fee of previous type
   var Nat64
-cannot be discarded; promote to type `Any` instead
-FALSE
+ will be discarded. This may cause data loss. Are you sure?
+TRUE
diff --git a/test/cmp/ok/x-mut-x.cmp.ok b/test/cmp/ok/x-mut-x.cmp.ok
index 16c5762ce6e..ef2f5130b85 100644
--- a/test/cmp/ok/x-mut-x.cmp.ok
+++ b/test/cmp/ok/x-mut-x.cmp.ok
@@ -1,5 +1 @@
-(unknown location): Compatibility error [M0171], stable variable x changes mutability from previous type
-  Nat
-to new type 
-  var Nat
-FALSE
+TRUE

From 77d6b84feac861f63f3fa0a4799421f1668f2b97 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 9 Aug 2024 11:49:03 +0200
Subject: [PATCH 253/260] Manual merge conflict resolution

---
 src/lowering/desugar.ml | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/lowering/desugar.ml b/src/lowering/desugar.ml
index ea6a9b2fe37..8e22d11fa89 100644
--- a/src/lowering/desugar.ml
+++ b/src/lowering/desugar.ml
@@ -474,11 +474,7 @@ and export_runtime_information self_id =
   let bind2 = typ_arg scope_con2 Scope scope_bound in
   let gc_strategy = 
     let open Mo_config in
-    let strategy = match !Flags.gc_strategy with
-    | Flags.MarkCompact -> "compacting"
-    | Flags.Copying -> "copying"
-    | Flags.Generational -> "generational"
-    | Flags.Incremental -> "incremental" in
+    let strategy = "incremental" in
     if !Flags.force_gc then (Printf.sprintf "%s force" strategy) else strategy
   in
   let prim_call function_name = primE (I.OtherPrim function_name) [] in

From 5fb73411573bc75e782f46925a3686e6d7e5c1fb Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Fri, 9 Aug 2024 14:57:12 +0200
Subject: [PATCH 254/260] Update benchmark result

---
 test/bench/ok/bignum.drun-run.ok | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/bench/ok/bignum.drun-run.ok b/test/bench/ok/bignum.drun-run.ok
index b7ccbbf2d34..dcab51a7f2e 100644
--- a/test/bench/ok/bignum.drun-run.ok
+++ b/test/bench/ok/bignum.drun-run.ok
@@ -1,6 +1,6 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 2_626_730; size = +60_128}
+debug.print: {cycles = 2_626_820; size = +60_128}
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 107_960_494; size = +1_826_952}
+debug.print: {cycles = 107_960_464; size = +1_826_952}
 ingress Completed: Reply: 0x4449444c0000

From 60296040a429cfa927de0fcf7e706c8b3ec67ad6 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 19 Aug 2024 16:16:40 +0200
Subject: [PATCH 255/260] Update benchmark result

---
 test/bench/ok/bignum.drun-run.ok | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/bench/ok/bignum.drun-run.ok b/test/bench/ok/bignum.drun-run.ok
index e4e0cf45f59..d7497c87ad5 100644
--- a/test/bench/ok/bignum.drun-run.ok
+++ b/test/bench/ok/bignum.drun-run.ok
@@ -1,6 +1,6 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 2_626_730; size = +60_128}
+debug.print: {cycles = 2_626_820; size = +60_128}
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 107_960_904; size = +1_826_952}
+debug.print: {cycles = 107_960_874; size = +1_826_952}
 ingress Completed: Reply: 0x4449444c0000

From c32571080d6aa122ef23e75d94ce82d73b006369 Mon Sep 17 00:00:00 2001
From: Luc Blaeser <112870813+luc-blaeser@users.noreply.github.com>
Date: Mon, 26 Aug 2024 16:20:42 +0200
Subject: [PATCH 256/260] Enhanced Orthogonal Persistence (64-Bit without Graph
 Copy) (#4225)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Adjust emscripten dependency for nix

* Use latest emscripten from nix unstable channel

* Adjust CI build

* Adjust CI build

* Adjust CI build

* Adjust CI build

* Add latest emscripten via nix `sources.json`

* Adjust emscripten dependency in `sources.json`

* Update sources.json

* Update sources.json

* Disable base library tests

* Adjust build

* Adjust tests, disable benchmark

* Enable random tests on 64-bit

* Bug fix

* Exclude inter-actor quickcheck tests

* Downscale test for CI

* Remove unnecessary clean-up function

* Adjust `is_controller` system call

* Manual merge from master

* Fix direct numeric conversions

* Use `drun` with 64-bit main memory

* Adjust callback signatures

* Adjust ignore callback sentinel value

* Bug fix

* Remove memory reserve feature

* Adjust CI build

* Adjust serialization

* Bug fix

* Bug fix

* Bug fix

* Adjust IC system calls

* Adjust IC system calls

* Bug fix

* Create Cargo.lock

* Adjust region and stable memory accesses

* Fix float format length

* Update nix setup

* Adjust tests

* Adjust nix config

* Adjust stabilization

* Bug fix

* Adjust stable memory and region accesses

* Adjust region RTS calls

* Manual merge RTS tests

* Manual merge of compiler

* Adjust IC call

* Update benchmark

* Adjust test

* Adjust test script

* Adjust tests

* Bug fix

* Adjust tests

* Adjust linker tests

* Minor refactoring

* Adjust test

* Adjust CI build

* Update IC dependency

* Wasm profiler does not support 64-bit

* Test case beyond 4GB

* Update CI test configuration

* Increase partitioned heap to 64GB

* Update IC dependency

* Manual merge, to be continued

* Adjust BigInt literals

* Bug fix

* Adjust tests

* Manual merge conflict resolution

* Code refactoring

* Update IC dependency

* Increase data segment limit

* Adjust test case

* Update migration test case

* Revert "Code refactoring"

This reverts commit 8063f8bb8c3af19fd4370bd6402e97078fde4f9b.

* Adjust test case

* Update benchmark results

* Update documentation

* Update fingerprint to 64-bit

* Manual merge Rust allocator

* Remove memory reserve

* Test CI build

* Refine memory compatibility check

* Add test case

* Distinguish blob and Nat8 arrays

* Bug fix

* Reformat code

* Update benchmark results

* Distinguish tuple type in memory compatibility check

* Update IC dependency

* Revert "Test CI build"

This reverts commit d4889f984d42e7802fa7f4aba37799a78abd6bc8.

* Use 64-bit IC API

* Update IC dependency

* Update benchmark results

* Adjust sanity checks

* Reformat

* Upgrade IC dependency, use persistence flag

* Update IC dependency

* Update IC dependency

* Manual resolution of undetected merge conflicts

* Manual merge conflict resolution

* Resolve merge conflicts

* Manual merge conflict resolution

* Manual merge: Adjust test

* Merge branch 'luc/stable-heap' into luc/stable-heap64

* Update base library dependency

* Manual merge conflict resolution

* Updating nix hashes

* Limit array length because of optimized array iterator

* Code refactoring

* Update benchmark results

* Update motoko base dependency

* Enhanced Orthogonal Persistence: Use Passive Data Segments (64-Bit) (#4411)

Only passive Wasm data segments are used by the compiler and runtime system. In contrast to ordinary active data segments, passive segments can be explicitly loaded to a dynamic address.

This simplifies two aspects:
* The generated Motoko code can contain arbitrarily large data segments which can loaded to dynamic heap when needed.
* The IC can simply retain the main memory on an upgrade without needing to patch the active data segments of the new program version to the persistent memory.

However, more specific handling is required for the Rust-implemented runtime system:
The Rust-generated active data segments of the runtime system is changed to passive and loaded to the expected static address at the program start (canister initialization and upgrade).
The location and size of the RTS data segments is therefore limited to a defined reserve, see above.
This is acceptable because the RTS only uses a small sized data segment that is independent of the compiled Motoko program.

* Update IC dependency

* Merge Preparation: Precise Tagging + Enhanced Orthogonal Persistence (64-Bit) (#4392)

Preparing merging https://github.com/dfinity/motoko/pull/4369 in https://github.com/dfinity/motoko/pull/4225

* Manual merge conflict resolution

* Update Motoko base depedency

* Manual merge conflict resolution

* Manual merge conflict resolution

* Optimization: Object Pooling for Enhanced Orthogonal Persistence (#4465)

* Object pooling

* Update benchmark results

* Optimize further (BigNum pooling)

* Update benchmark results

* Adjust tests

* Optimize static blobs

* Adjust test and benchmark results

* Update documentation

* Manual merge conflict resolution

* Update .gitignore

* Enhanced Orthogonal Persistence: Refactor 64-bit Port of SLEB128 for BigInt (#4486)

* Refactor 64-bit port of SLEB128 for BigInt

* Remove redundant test file

* Adjust data segment loading

To avoid allocation of trap text blob during object pool creation.

* Manual merge conflict resolution

* Manual merge conflict resolution

* Manual merge conflict resolution

* Update benchmark results

* Manual merge conflict resolution

* Update Motoko base dependency

* Manual merge conflict resolution

* Apply the expected shift distance

* Remove redundant code

* Code refactoring: Move constant

* Add a debug assertion

* Code refactoring: Reduce code difference

* Update comment

* Represent function indices as `i32`

* Use pointer compression on Candid destabilization

Candid destabilization remembers aliases as 32-bit pointers in deserialized data. However, the deserialized pointers can be larger than 32-bit due to the 64-bit representation. Therefore, use pointer compression (by 3 bits) to store the 64-bit addresses in the 32-bit alias memo section.

* Manual merge conflict resolution

* Fix test case

* Add comment

* Add TODO comment

* Code refactoring: Arithmetics

* Fix boundary check in small `Int` `pow` function

* Code refactoring: `Nat` conversions

* Code refactoring: Remove redundant blank.

Co-authored-by: Claudio Russo <claudio@dfinity.org>

* Fix tagging for `hashBlob`

* Remove redundant shifts for signed bit count operations

* Reenable randomized tests

* Update quickcheck documentation

* Revert unwanted modification in test case

This partially reverts commit ea20c6c3199e249b4302762819e0977f86c03abc.

* Adjust test case to original configuration

* Try to run original `map-upgrades` test

* Tests for wasi stable memory beyond 4GB

* Update expected test result

* Code refactoring: Linker

* Optimizations

* Manual merge conflict resolution

* Use 64-bit version of Tom's math library

* Add benchmark case

* Optimize float to int conversion for 64-bit

* Manual merge conflict resolution

* Experiment Remove `musl`/`libc` dependency from RTS (#4577)

* Remove MUSL/LIBC dependency from RTS
* Update benchmark result

* Manual merge conflict resolution

* Unbounded Number of Heap Partitions for 64-Bit (#4556)

* EOP: Support Unknown Main Memory Capacity in 64-Bit (#4585)

* Tune for unknown memory capacity in 64-bit

* Adjust benchmark results

* Fix debug assertion, code refactoring

* Code refactoring: Improve comments

* Reformat

* Re-enable memory reserve for upgrade and queries

See PR https://github.com/dfinity/motoko/pull/4158

* Adjust comment

* Fix build

* EOP: Integrating Latest IC with Memory 64 (#4610)

* Adjust to new system API

* Port to latest IC 64-bit system API

* Update to new IC with Wasm64

* Updating nix hashes

* Update IC dependency (Wasm64 enabled)

* Update expected test results

* Fix migration test

* Use latest `drun`

* Adjust expected test results

* Updating nix hashes

* Update expected test results

* Fix `drun` nix build for Linux

* Disable DTS in `drun`, refactor `drun` patches

* Adjust expected test results

---------

Co-authored-by: Nix hash updater <41898282+github-actions[bot]@users.noreply.github.com>

* Enhanced Orthogonal Persistence (64-Bit with Graph Copy) (#4475)

* Graph copy: Work in progress

* Implement stable memory reader writer

* Add skip function

* Code refactoring

* Continue stabilization function

* Support update at scan position

* Code refactoring

* Code refactoring

* Extend unit test

* Continue implementation

* Adjust test

* Prepare memory compatibility check

* Variable stable to-space offset

* Deserialize with partitioned heap

* Prepare metadata stabilization

* Adjust stable memory size

* Stabilization version management

* Remove code redundancies

* Fix version upgrade

* Put object field hashes in a blob

* Support object type

* Code refactoring

* Support blob, fix bug

* Renaming variable

* Adjust deserialization heap start

* Handle null singleton

* Fix version upgrade

* Support regions

* Backup first word in stable memory

* Support additional fields in upgraded actor

* Make unit tests runnable again

* Dummy null singleton in unit test

* Add test cases

* Support boxed 32-bit and 64-bit numbers

* Support more object types

* Support more object types

* Handle `true` bool constant

* Grow main memory on bulk copy

* Update benchmark results

* Support bigint

* Clear deserialized data in stable memory

* Update test results

* Add documentation

* Reformat

* Add missing file

* Update design/GraphCopyStabilization.md

Co-authored-by: Claudio Russo <claudio@dfinity.org>

* Update rts/motoko-rts/src/stabilization.rs

Co-authored-by: Claudio Russo <claudio@dfinity.org>

* Update rts/motoko-rts/src/stabilization.rs

Co-authored-by: Claudio Russo <claudio@dfinity.org>

* Graph Copy: Explicit Stable Data Layout (#4293)

Refinement of Graph-Copy-Based Stabilization (https://github.com/dfinity/motoko/pull/4286):

Serialize/deserialize in an explicitly defined and fixed stable layout for a long-term perspective.
* Supporting 64-bit pointer representations in stable format, even if main memory currently only uses 32-bit addresses.

Open aspect:
* Make `BigInt` stable format independent of Tom's math library.

* Update rts/motoko-rts/src/stabilization.rs

Co-authored-by: Claudio Russo <claudio@dfinity.org>

* Update rts/motoko-rts/src/stabilization/layout.rs

Co-authored-by: Claudio Russo <claudio@dfinity.org>

* Handle non-stable fields in stable records

* Add object type `Some`

* Add test case

* Adjust stabilization to incremental GC

* Update benchmark results

* Distinguish assertions

* Fix RTS unit test

* Update benchmark results

* Adjust test

* Adjust test

* Fix: Handle all non-stable types during serialization

* Fix typos and complete comment

* Experiment: Simplified Graph-Copy-Based Stabilization (#4313)

# Experiment: Simplified Graph-Copy-Based Stabilization

**Simplified version of https://github.com/dfinity/motoko/pull/4286, without stable memory buffering and without memory flipping on deserialization.**

Using graph copying instead of Candid-based serialization for stabilization, to save stable variables across upgrades.

## Goals

* **Stop-gap solution until enhanced orthogonal persistence**: More scalable stabilization than the current Candid(ish) serialization.
* **With enhanced orthogonal persistence**: Upgrades in the presence of memory layout changes introduced by future compiler versions.

## Design

Graph copy of sub-graph of stable objects from main memory to stable memory and vice versa on upgrades.

## Properties
* Preserve sharing for all objects like in the heap.
* Allow the serialization format to be independent of the main memory layout.
* Limit the additional main memory needed during serialization and deserialization.
* Avoid deep call stack recursion (stack overflow).

## Memory Compatibility Check
Apply a memory compatibility check analogous to the enhanced orthogonal persistence, since the upgrade compatibility of the graph copy is not identical to the Candid subtype relation.

## Algorithm
Applying Cheney’s algorithm [1, 2] for both serialization and deserialization:

### Serialization
* Cheney’s algorithm using main memory as from-space and stable memory as to-space:
* Focusing on stable variables as root (sub-graph of stable objects).
* The target pointers and Cheney’s forwarding pointers denote the (skewed) offsets in stable memory.
* Using streaming reads for the `scan`-pointer and streaming writes for the `free`-pointer in stable memory.

### Deserialization
* Cheney’s algorithm using stable memory as from-space and main memory as to-space:
* Starting with the stable root created during the serialization process.
* Objects are allocated in main memory using the default allocator.
* Using random read/write access on the stable memory.

## Stable Format
For a long-term perspective, the object layout of the serialized data in the stable memory is fixed and independent of the main memory layout.
* Pointers support 64-bit representations, even if only 32-bit pointers are used in current main memory address space.
* The Brooks forwarding pointer is omitted (used by the incremental GC).
* The pointers encode skewed stable memory offsets to the corresponding target objects.
* References to the null objects are encoded by a sentinel value.

## Specific Aspects
* The null object is handled specifically to guarantee the singleton property. For this purpose, null references are encoded as sentinel values that are decoded back to the static singleton of the new program version.
* Field hashes in objects are serialized in a blob. On deserialization, the hash blob is allocated in the dynamic heap. Same-typed objects that have been created by the same program version share the same hash blob.
* Stable records can dynamically contain non-stable fields due to structural sub-typing. A dummy value can be serialized for such fields as a new program version can no longer access this field through the stable types.
* For backwards compatibility, old Candid destabilzation is still supported when upgrading from a program that used older compiler version.
* Incremental GC: Serialization needs to consider Brooks forwarding pointers (not to be confused with the Cheney's forwarding information), while deserialization can deal with partitioned heap that can have internal fragmentation (free space at partition ends).

## Complexity
Specific aspects that entail complexity:
* For each object type, not only serialization and deserialization needs to be implemeneted but also the pointer scanning logic of its serialized and deserialized format. Since the deserialization also targets stable memory the existing pointer visitor logic cannot be used for scanning pointers in its deserialized format.
* The deserialization requires scanning the heap which is more complicated for the partitioned heap. The allocator must yield monotonously growing addresses during deserialization. Free space gaps are allowed to complete partitions.

## Open Aspects
* Unused fields in stable records that are no longer declared in a new program versions should be removed. This could be done during garbage collection, when objects are moved/evacuated.
* The binary serialization and deserialization of `BigInt` entails dynamic allocations (cf. `mp_to_sbin` and `mp_from_sbin` of Tom's math library).

## Related PRs

* Motoko Enhanced Orthogonal Persistence: https://github.com/dfinity/motoko/pull/4225
* Motoko Incremental Garbage Collector: https://github.com/dfinity/motoko/pull/3837

## References

[1] C. J. Cheney. A Non-Recursive List Compacting Algorithm. Communications of the ACM, 13(11):677-8, November 1970.

[2] R. Jones and R. Lins. Garbage Collection: Algorithms for Automatic Dynamic Memory Management. Wiley 2003. Algorithm 6.1: Cheney's algorithm, page 123.

* Bug fix: Allocations are not monotonically growing in partitioned heap for large objects

* Update benchmark results

* Update benchmark results

* Drop content of destabilized `Any`-typed actor field

* Refactor `is_primitive_type` in Candid parser and subtype check

* Do not use the cache for the main actor type compatibility check

* Update benchmark results

* Increase chunk size for stable memory clearing

* Custom bigint serialization

* Update benchmark results

* Update documentation

* Update documentation

* Optimize array deserialization

* Update benchmark results

* Code refactoring of upgrade version checks

* Remove redundant math functions

* Eliminate size redundancy in the `Object` header

* Also adjust the `Object` header in the compiler

* Revert "Also adjust the `Object` header in the compiler"

This reverts commit f75bb7685abe9c3103c872dff53f0b37abd223f4.

* Revert "Eliminate size redundancy in the `Object` header"

This reverts commit 0fe3926022662abd8ce3d03da042306600f9d952.

* Record the upgrade instruction costs

* Update tests for new `Prim.rts_upgrade_instructions()` function

* Make test more ergonomic

* Incremental Graph-Copy-Based Upgrades (#4361)

# Incremental Graph-Copy-Based Upgrades

Refinement of https://github.com/dfinity/motoko/pull/4286

Supporting arbitrarily large graph-copy-based upgrades beyond the instruction limit:
* Splitting the stabilization/destabilization in multiple asynchronous messages.
* Limiting the stabilization work units to fit the update or upgrade messages.
* Blocking other messages during the explicit incremental stabilization.
* Restricting the upgrade functionality to the canister owner and controllers.
* Stopping the GC during the explicit incremental upgrade process.

## Usage

For large upgrades:
1. Initiate the explicit stabilization before the upgrade:

```
dfx canister call CANISTER_ID __motoko_stabilize_before_upgrade "()"
```

* An assertion first checks that the caller is the canister owner or a canister controller.
* All other messages to the canister will be blocked until the upgrade has been successfully completed.
* The GC is stopped.
* If defined, the actor's pre-upgrade function is called before the explicit stabilization.
* The stabilzation runs in possibly multiple asynchronous messages, each with a limited number of instructions.

2. Run the actual upgrade:

```
dfx deploy CANISTER_ID
```

* Run and complete the stabilization if not yet done in advance.
* Perform the actual upgrade of the canister on the IC.
* Start the destabilization with a limited number of steps to fit into the upgrade message.
* If destabilization cannot be completed, the canister does not start the GC and does not accept messages except step 3.

3. Complete the explicit destabilization after the upgrade:

```
dfx canister call CANISTER_ID __motoko_destabilze_after_upgrade "()"
```

* An assertion checks that the caller is the canister owner or a canister controller.
* All other messages remain blocked until the successful completion of the destabilization.
* The destabilzation runs in possibly multiple asynchronous messages, each with a limited number of instructions.
* If defined, the actor's post-upgrade function is called at the end of the explicit destabilization.
* The GC is restarted.

## Remarks

* Steps 1 (explicit stabilization) and/or 2 (explicit destabilization) may not be needed if the corresponding operation fits into the upgrade message.
* Stabilization and destabilization steps are limited to the increment limits:

    Operation | Message Type | IC Instruction Limit | **Increment Limit**
    ----------|--------------|----------------------|--------------------
    **Explicit (de)stabilization step** | Update | 20e9 | **16e9**
    **Actual upgrade** | Upgrade | 200e9 | **160e9**

* The stabilization code in the RTS has been restructured to be less monolithic.

* Manual merge conflict resolution (work in progress)

* Adjust tests, resolve some merge bugs

* Adjust RTS test case

* Make RTS tests run again

* Add missing function export

* Adjust imports, manual merge conflict resolution

* Manual merge conflict resolution

* Manual merge conflict resolution

* Adjust persistence initialization

* Adjust persistence version management

* Adjust stable memory metadata for enhanced orthogonal persistence

Distinguish enhanced orthogonal persistence from Candid legacy stabilization

* Add comment

* Adjust graph stabilization initialization

* Adjust GC mode during destabilization

* Adjust object visitor for graph destabilization

* Adjust incremental graph destabilization

* Adjust error message

* Adjust tests

* Adjust tests

* Update benchmark results

* Adjust test

* Upgrade stable memory version after graph destabilization

* Adjust memory sanity check

* Clear memory on graph destabilization as first step

* Adjust big int serialization for 64-bit

* Fix: Clear memory on graph destabilization

* Add test case for graph stabilization

* Add test case for incremental graph stabilization

* Add tests for graph stabilization

* Add more tests for graph stabilization

* Add more test cases for graph stabilization

* Add more test cases for graph stabilization

* More conservative persistence version check

* Adjust expected test results

* Adjust test

* Adjust tests

* Adjust tests

* Adjust RTS test for stabilization

* Adjust tests

* Adjust test results

* Remove unwanted binary files

* Adjust comment

* Code refactoring

* Fix merge mistake

* Manual merge conflict resolution

* Add test cases

* Manual merge conflict resolution

* Fix typo in documentation

Co-authored-by: Claudio Russo <claudio@dfinity.org>

* Fix typo in documentation

Co-authored-by: Claudio Russo <claudio@dfinity.org>

* Bug fix: Allow stabilization beyond compiler-specified stable memory limit

* Adjustment to RTS unit tests

* Add comments

* Code refactoring

* Fix difference between debug and release test execution

* Fix typo in comment

Co-authored-by: Claudio Russo <claudio@dfinity.org>

* Fix typo in comment

Co-authored-by: Claudio Russo <claudio@dfinity.org>

* Fix typo in comment

Co-authored-by: Claudio Russo <claudio@dfinity.org>

* Fix typo in comment

Co-authored-by: Claudio Russo <claudio@dfinity.org>

* Delete unused file

* Code refactoring

* Use correct trap for an unreachable case

* Remove dead code

* Fix typo in comment

Co-authored-by: Claudio Russo <claudio@dfinity.org>

* Fix typo in function identifier

* Fix indendation

Co-authored-by: Claudio Russo <claudio@dfinity.org>

* Removing unused code

* Fix typo in comment

Co-authored-by: Claudio Russo <claudio@dfinity.org>

* Fix typo in comment

Co-authored-by: Claudio Russo <claudio@dfinity.org>

* Fix RTS compile error

* Bug fix: Object size lookup during stabilization

* experiment: refactoring of ir extensions in graph-copy PR (#4543)

* refactoring of ir

* fix arrange_ir.ml

---------

Co-authored-by: luc-blaeser <luc.blaeser@dfinity.org>

* Manual merge conflict resolution

* Adjust test case, remove file check

* Manual merge conflict resolution

* Manual merge conflict resolution

* test graph copy of text and blob iterators (#4562)

* Optimize instruction limit checks

* Bug fix graph copy limit on destabilization

* Incremental stable memory clearing after graph copy

* Parameter tuning for graph copy

* Manual merge conflict resolution

* Manual merge conflict resolution

* Remove redundant code

* Manual merge conflict resolution: Remove `ObjInd` from graph-copy stabilization

* Manual merge conflict resolution

* Merge Preparation: Latest IC with Graph Copy (#4630)

* Adjust to new system API

* Port to latest IC 64-bit system API

* Update to new IC with Wasm64

* Updating nix hashes

* Update IC dependency (Wasm64 enabled)

* Update expected test results

* Fix migration test

* Use latest `drun`

* Adjust expected test results

* Updating nix hashes

* Update expected test results

* Fix `drun` nix build for Linux

* Disable DTS in `drun`, refactor `drun` patches

* Update expected test results for new `drun`

* Limiting amount of stable memory accessed per graph copy increment

* Reformat

* Adjust expected test result

---------

Co-authored-by: Nix hash updater <41898282+github-actions[bot]@users.noreply.github.com>

* Message-dependent stable memory access limit

* Graph copy: Fix accessed memory limit during stabilization

* Enhanced Orthogonal Persistence (Complete Integration) (#4488)

* Prepare two compilation targets

* Combined RTS Makefile

* Port classical compiler backend to combined solution

* Adjust nix config file

* Start combined RTS

* Reduce classical compiler backend changes

* Continue combined RTS

* Make RTS compilable for enhanced orthogonal persistence

* Make RTS tests runnable again for enhanced orthogonal persistence

* Adjust compiler backend of enhanced orthogonal persistence

* Unify Tom's math library binding

* Make classical non-incremental RTS compile again

* Make classical incremental GC version compilable again

* Make all RTS versions compile again

* Adjust memory sanity check for combined RTS modes

* Prepare RTS tests for combined modes

* Continue RTS test merge

* Continue RTS tests combined modes

* Continue RTS tests support for combined modes

* Adjust LEB128 encoding for combined mode

* Adjust RTS test for classical incremental GC

* Adjust RTS GC tests

* Different heap layouts in RTS tests

* Continue RTS GC test multi-mode support

* Make all RTS run again

* Adjust linker to support combined modes

* Adjust libc import in RTS for combined mode

* Adjust RTS test dependencies

* Bugfix in Makefile

* Adjust compiler backend import for combined mode

* Adjust RTS import for combined mode

* Adjust region management to combined modes

* Adjust classical compiler backend to fit combined modes

* Reorder object tags to match combined RTS

* Adjust test

* Adjust linker for multi memory during Wasi mode with regions

* Adjust tests

* Adjust bigint LEB encoding for combined modes

* Adjust bigint LEB128 encoding for combined modes

* Adjust test

* Adjust tests

* Adjust test

* Code refactoring: SLEB128 for BigInt

* Adjust tests

* Adjust test

* Reformat

* Adjust tests

* Adjust benchmark results

* Adjust RTS for unit tests

* Reintroduce compiler flags in classical mode

* Support classical incremental GC

* Add missing export for classical incremental GC

* Adjust tests

* Adjust test

* Adjust test

* Adjust test

* Adjust test

* Adjust test

* Adjust test

* Pass `keep_main_memory` upgrade option only for enhanced orthogonal persistence

* Adjust test

* Update nix hash

* Adjust Motoko base dependency

* Adjust tests

* Extend documentation

* Adjust test

* Update documentation

* Update documentation

* Manual merge conflict resolution

* Manual merge refinement

* Manual merge conflict resolution

* Manual merge conflict resolution

* Refactor migration test from classical to new persistence

* Adjust migration test

* Manual merge conflict resolution

* Manual merge conflict resolution

* Adjust compiler reference documentation

* Test CI build

* Test CI build

* Adjust performance comparison in CI build

* Manual merge conflict resolution

* Add test for migration paths

* Adjust test for integrated PR

* Adjust test case

* Manual merge conflict resolution

* Manual merge conflict resolution

* Manual merge conflict resolution

* Manual merge conflict resolution

* Code refactoring

* Fix typo in comment

Co-authored-by: Claudio Russo <claudio@dfinity.org>

* Manual merge conflict resolution

* Add static assertions, code formatting

* Manual merge conflict resolution

* Add test case

* Refine comment

Co-authored-by: Claudio Russo <claudio@dfinity.org>

* Manual merge conflict resolution

* Manual merge conflict resolution

* Code refactoring

* Manual merge conflict resolution

* Adjust test run script messages

* Manual merge conflict resolution

* Manual merge conflict resolution

* Manual merge conflict resolution

* Manual merge conflict resolution

* Merge Preparation: Dynamic Memory Capacity for Integrated EOP (#4586)

* Tune for unknown memory capacity in 64-bit

* Adjust benchmark results

* Fix debug assertion, code refactoring

* Manual merge conflict resolution

* Manual merge conflict resolution

* Code refactoring: Improve comments

* Reformat

* Fix debug assertion

* Re-enable memory reserve for upgrade and queries

See PR https://github.com/dfinity/motoko/pull/4158

* Manual merge conflict resolution

* Manual merge conflict resolution

* Update benchmark results

* Manual merge conflict resolution

* Manual merge conflict resolution

* Merge Preparation: Latest IC with Integrated EOP  (#4638)

* Adjust to new system API

* Port to latest IC 64-bit system API

* Update to new IC with Wasm64

* Updating nix hashes

* Update IC dependency (Wasm64 enabled)

* Update expected test results

* Fix migration test

* Use latest `drun`

* Adjust expected test results

* Updating nix hashes

* Update expected test results

* Fix `drun` nix build for Linux

* Disable DTS in `drun`, refactor `drun` patches

* Update expected test results for new `drun`

* Limiting amount of stable memory accessed per graph copy increment

* Reformat

* Manual merge conflict resolution

* Manual merge conflict resolution

* Adjust expected test result

---------

Co-authored-by: Nix hash updater <41898282+github-actions[bot]@users.noreply.github.com>

* Manual merge conflict resolution

* Documentation Update for Enhanced Orthogonal Persistence (#4670)

---------

Co-authored-by: Claudio Russo <claudio@dfinity.org>
Co-authored-by: Nix hash updater <41898282+github-actions[bot]@users.noreply.github.com>

---------

Co-authored-by: Claudio Russo <claudio@dfinity.org>
Co-authored-by: Nix hash updater <41898282+github-actions[bot]@users.noreply.github.com>

---------

Co-authored-by: Nix hash updater <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: Claudio Russo <claudio@dfinity.org>
---
 bin/wrapper.sh                                |    10 +-
 default.nix                                   |    76 +-
 design/Custom-Sections.md                     |     4 +
 design/DFX-Interface.md                       |     8 +
 design/GraphCopyStabilization.md              |   132 +
 design/Implementation.md                      |    25 +-
 design/Memory.md                              |   106 +-
 design/OldStableMemory.md                     |     9 +-
 design/OrthogonalPersistence.md               |   112 +-
 design/PersistenceModes.md                    |    50 +
 design/Stable.md                              |    21 +-
 design/StableMemory.md                        |    30 +
 design/StableRegions.md                       |     6 +-
 design/WhitePaper.md                          |    12 +-
 doc/md/canister-maintenance/compatibility.md  |   215 +-
 .../orthogonal-persistence/_category_.yml     |     4 +
 .../orthogonal-persistence/classical.md       |    23 +
 .../orthogonal-persistence/enhanced.md        |   101 +
 .../orthogonal-persistence/modes.md           |    11 +
 doc/md/canister-maintenance/upgrades.md       |   199 +-
 doc/md/examples/count-v0.did                  |     4 +-
 doc/md/examples/count-v0.mo                   |    12 +-
 doc/md/examples/count-v0.most                 |     3 +-
 doc/md/examples/count-v1.did                  |     4 +-
 doc/md/examples/count-v1.mo                   |    11 +-
 doc/md/examples/count-v1.most                 |     2 +-
 doc/md/examples/count-v2.did                  |     5 +-
 doc/md/examples/count-v2.mo                   |    11 +-
 doc/md/examples/count-v3.did                  |     7 +-
 doc/md/examples/count-v3.mo                   |    16 +-
 doc/md/examples/count-v3.most                 |     2 +-
 doc/md/examples/count-v4.mo                   |    19 +-
 doc/md/examples/count-v5.mo                   |    23 +
 doc/md/examples/count-v6.mo                   |    22 +
 doc/md/getting-started/motoko-introduction.md |     6 +-
 doc/md/reference/compiler-ref.md              |     6 +
 doc/md/stable-memory/stable-regions.md        |    22 +-
 nix/default.nix                               |     4 +-
 nix/drun.nix                                  |    67 +-
 nix/sources.json                              |    30 +-
 perf-delta.nix                                |     2 +-
 rts/Makefile                                  |   305 +-
 rts/README.md                                 |     4 +-
 rts/motoko-rts-macros/Cargo.lock              |    16 +-
 rts/motoko-rts-macros/Cargo.toml              |     6 +-
 rts/motoko-rts-macros/src/lib.rs              |    64 +
 rts/motoko-rts-tests/Cargo.lock               |    76 +-
 rts/motoko-rts-tests/Cargo.toml               |     9 +-
 rts/motoko-rts-tests/build.rs                 |     7 +-
 rts/motoko-rts-tests/src/bigint.rs            |    31 +-
 rts/motoko-rts-tests/src/bitrel.rs            |    18 +-
 .../src/continuation_table.rs                 |    10 +-
 rts/motoko-rts-tests/src/gc.rs                |   444 +-
 rts/motoko-rts-tests/src/gc/classical.rs      |   358 +
 rts/motoko-rts-tests/src/gc/compacting.rs     |    10 +
 .../src/gc/compacting/bitmap.rs               |   166 +
 .../src/gc/compacting/mark_stack.rs           |   115 +
 rts/motoko-rts-tests/src/gc/enhanced.rs       |   321 +
 rts/motoko-rts-tests/src/gc/generational.rs   |    10 +
 .../src/gc/generational/mark_stack.rs         |    89 +
 .../src/gc/generational/remembered_set.rs     |    96 +
 rts/motoko-rts-tests/src/gc/heap.rs           |   397 +-
 rts/motoko-rts-tests/src/gc/heap/classical.rs |   294 +
 rts/motoko-rts-tests/src/gc/heap/enhanced.rs  |   285 +
 .../src/gc/incremental/array_slicing.rs       |     2 +-
 .../src/gc/incremental/mark_bitmap.rs         |    34 +-
 .../src/gc/incremental/mark_stack.rs          |     4 +-
 .../src/gc/incremental/partitioned_heap.rs    |    65 +-
 .../src/gc/incremental/roots.rs               |   121 +-
 .../src/gc/incremental/sort.rs                |     6 +-
 rts/motoko-rts-tests/src/gc/random.rs         |    14 +-
 rts/motoko-rts-tests/src/gc/utils.rs          |    71 +-
 rts/motoko-rts-tests/src/leb128.rs            |    65 +-
 rts/motoko-rts-tests/src/main.rs              |    66 +-
 rts/motoko-rts-tests/src/memory.rs            |    35 +-
 rts/motoko-rts-tests/src/print.rs             |    79 +
 rts/motoko-rts-tests/src/stabilization.rs     |   182 +
 .../src/stabilization/layout.rs               |    32 +
 .../src/stabilization/reader_writer.rs        |   378 +
 .../src/stabilization/stable_bigints.rs       |    85 +
 .../src/stabilization/stable_memory.rs        |    49 +
 rts/motoko-rts-tests/src/stable_mem.rs        |     0
 rts/motoko-rts-tests/src/text.rs              |    91 +-
 rts/motoko-rts-tests/src/utf8.rs              |    10 +-
 rts/motoko-rts/.vim/coc-settings.json         |     2 +-
 rts/motoko-rts/Cargo.lock                     |    16 +-
 rts/motoko-rts/Cargo.toml                     |    11 +-
 rts/motoko-rts/native/Cargo.toml              |     7 +-
 rts/motoko-rts/src/allocator.rs               |    38 +-
 rts/motoko-rts/src/barriers.rs                |    22 +
 rts/motoko-rts/src/bigint.rs                  |   228 +-
 rts/motoko-rts/src/bitrel.rs                  |    42 +-
 rts/motoko-rts/src/blob_iter.rs               |     8 +-
 rts/motoko-rts/src/buf.rs                     |    19 +-
 rts/motoko-rts/src/constants.rs               |    32 +-
 rts/motoko-rts/src/continuation_table.rs      |    20 +-
 rts/motoko-rts/src/debug.rs                   |    59 +-
 rts/motoko-rts/src/float.rs                   |    41 +-
 rts/motoko-rts/src/float/classical.rs         |    39 +
 rts/motoko-rts/src/float/enhanced.rs          |    39 +
 rts/motoko-rts/src/gc.rs                      |    27 +
 rts/motoko-rts/src/gc/copying.rs              |   229 +
 rts/motoko-rts/src/gc/generational.rs         |   531 +
 .../src/gc/generational/mark_stack.rs         |    75 +
 .../src/gc/generational/sanity_checks.rs      |   173 +
 .../src/gc/generational/write_barrier.rs      |    46 +
 rts/motoko-rts/src/gc/incremental.rs          |   158 +-
 .../src/gc/incremental/array_slicing.rs       |     4 +-
 rts/motoko-rts/src/gc/incremental/barriers.rs |     2 +-
 .../src/gc/incremental/mark_bitmap.rs         |    59 +-
 .../src/gc/incremental/partitioned_heap.rs    |   486 +-
 .../phases/evacuation_increment.rs            |     4 +-
 .../gc/incremental/phases/mark_increment.rs   |    15 +-
 .../gc/incremental/phases/update_increment.rs |    10 +-
 rts/motoko-rts/src/gc/incremental/roots.rs    |    97 +-
 .../src/gc/incremental/roots/classical.rs     |    75 +
 .../src/gc/incremental/roots/enhanced.rs      |    89 +
 .../src/gc/incremental/sanity_checks.rs       |    13 +-
 .../src/gc/incremental/scheduling.rs          |   105 +
 rts/motoko-rts/src/gc/incremental/sort.rs     |    44 +-
 rts/motoko-rts/src/gc/incremental/time.rs     |     1 +
 rts/motoko-rts/src/gc/mark_compact.rs         |   303 +
 rts/motoko-rts/src/gc/mark_compact/bitmap.rs  |   209 +
 .../src/gc/mark_compact/mark_stack.rs         |    76 +
 .../sanity_checks => }/remembered_set.rs      |    40 +-
 rts/motoko-rts/src/idl.rs                     |   140 +-
 rts/motoko-rts/src/leb128.rs                  |    50 +-
 rts/motoko-rts/src/lib.rs                     |    32 +-
 rts/motoko-rts/src/libc_declarations.rs       |    36 +
 rts/motoko-rts/src/mem_utils.rs               |    18 +-
 rts/motoko-rts/src/memory.rs                  |    31 +-
 rts/motoko-rts/src/memory/ic.rs               |   119 +-
 .../src/memory/ic/classical_memory.rs         |    62 +
 .../src/memory/ic/enhanced_memory.rs          |    84 +
 rts/motoko-rts/src/memory/ic/linear_memory.rs |    80 +
 .../src/memory/ic/partitioned_memory.rs       |    35 +
 rts/motoko-rts/src/persistence.rs             |    52 +-
 .../src/persistence/compatibility.rs          |    38 +-
 rts/motoko-rts/src/principal_id.rs            |    26 +-
 rts/motoko-rts/src/print.rs                   |    16 +-
 rts/motoko-rts/src/region.rs                  |   189 +-
 rts/motoko-rts/src/stabilization.rs           |    88 +
 .../src/stabilization/deserialization.rs      |   222 +
 .../deserialization/scan_stack.rs             |   118 +
 .../deserialization/stable_memory_access.rs   |    58 +
 .../src/stabilization/graph_copy.rs           |   112 +
 .../src/stabilization/graph_copy/limit.rs     |   122 +
 rts/motoko-rts/src/stabilization/ic.rs        |   278 +
 .../src/stabilization/ic/metadata.rs          |   220 +
 .../src/stabilization/ic/performance.rs       |    37 +
 rts/motoko-rts/src/stabilization/layout.rs    |   447 +
 .../src/stabilization/layout/stable_array.rs  |   149 +
 .../src/stabilization/layout/stable_bigint.rs |   219 +
 .../src/stabilization/layout/stable_bits64.rs |    45 +
 .../src/stabilization/layout/stable_blob.rs   |   112 +
 .../src/stabilization/layout/stable_concat.rs |    54 +
 .../src/stabilization/layout/stable_mutbox.rs |    46 +
 .../src/stabilization/layout/stable_object.rs |   145 +
 .../src/stabilization/layout/stable_region.rs |    52 +
 .../src/stabilization/layout/stable_some.rs   |    46 +
 .../stabilization/layout/stable_variant.rs    |    49 +
 .../src/stabilization/serialization.rs        |   202 +
 .../serialization/stable_memory_stream.rs     |   147 +
 rts/motoko-rts/src/stable_mem.rs              |    53 +-
 rts/motoko-rts/src/static_checks.rs           |    50 +-
 rts/motoko-rts/src/stream.rs                  |   216 +
 rts/motoko-rts/src/text.rs                    |    76 +-
 rts/motoko-rts/src/text_iter.rs               |    24 +-
 rts/motoko-rts/src/tommath_bindings.rs        |     9 +-
 rts/motoko-rts/src/types.rs                   |   503 +-
 rts/motoko-rts/src/utf8.rs                    |     8 +-
 rts/motoko-rts/src/visitor.rs                 |   149 +-
 rts/motoko-rts/src/visitor/classical.rs       |   134 +
 rts/motoko-rts/src/visitor/enhanced.rs        |   129 +
 .../{compile.ml => compile_classical.ml}      |  3044 ++--
 .../{compile.mli => compile_classical.mli}    |     0
 src/codegen/compile_enhanced.ml               | 13273 ++++++++++++++++
 src/codegen/compile_enhanced.mli              |     3 +
 src/codegen/die.ml                            |     4 +-
 src/codegen/instrList.ml                      |    33 +-
 src/exes/candid_tests.ml                      |     2 +-
 src/exes/moc.ml                               |    43 +
 src/ir_def/arrange_ir.ml                      |     4 +-
 src/ir_def/check_ir.ml                        |    11 +-
 src/ir_def/construct.ml                       |     2 +-
 src/ir_def/freevars.ml                        |     5 +-
 src/ir_def/ir.ml                              |    14 +-
 src/ir_def/rename.ml                          |     9 +-
 src/ir_interpreter/interpret_ir.ml            |     2 -
 src/ir_passes/async.ml                        |    18 +-
 src/ir_passes/await.ml                        |    10 +-
 src/ir_passes/const.ml                        |     8 +-
 src/ir_passes/eq.ml                           |    18 +-
 src/ir_passes/erase_typ_field.ml              |    15 +-
 src/ir_passes/show.ml                         |    15 +-
 src/ir_passes/tailcall.ml                     |    10 +-
 src/linking/linkModule.ml                     |   187 +-
 src/lowering/desugar.ml                       |    31 +-
 src/mo_config/flags.ml                        |    24 +-
 src/pipeline/pipeline.ml                      |    45 +-
 src/prelude/internals.mo                      |    13 +-
 src/rts/gen.sh                                |    10 +-
 src/rts/rts.ml                                |    14 +-
 src/rts/rts.mli                               |    11 +-
 src/wasm-exts/ast.ml                          |    11 +-
 src/wasm-exts/customModuleDecode.ml           |    32 +-
 src/wasm-exts/customModuleEncode.ml           |    25 +-
 src/wasm-exts/memory.ml                       |   155 +
 src/wasm-exts/memory.mli                      |    49 +
 src/wasm-exts/operators.ml                    |     9 +-
 src/wasm-exts/types.ml                        |   140 +
 src/wasm-exts/values.ml                       |    86 +
 test/Makefile                                 |     3 +-
 test/bench/heap-64.mo                         |    55 +
 test/bench/ok/alloc.drun-run.ok               |     6 +-
 test/bench/ok/bignum.drun-run.ok              |     4 +-
 test/bench/ok/candid-subtype-cost.drun-run.ok |     2 +-
 test/bench/ok/heap-32.drun-run.ok             |     4 +-
 test/bench/ok/heap-64.drun-run.ok             |     5 +
 test/bench/ok/nat16.drun-run.ok               |     2 +-
 test/bench/ok/palindrome.drun-run.ok          |    12 +-
 test/bench/ok/region-mem.drun-run.ok          |     2 +-
 test/bench/ok/region0-mem.drun-run.ok         |     2 +-
 test/bench/ok/stable-mem.drun-run.ok          |     2 +-
 test/ld/Makefile                              |    12 +-
 test/ld/fun-ptr.c                             |    12 +-
 test/ld/fun-ptr.wat                           |    13 +-
 test/ld/ok/fun-ptr.linked.wat.ok              |    43 +-
 test/ld/ok/representative.linked.wat.ok       |     4 +-
 test/ld/representative.c                      |     1 -
 test/ld/representative.wat                    |     4 +-
 test/ld/wrong-type.c                          |     1 -
 test/ld/wrong-type.wat                        |     4 +-
 test/random/Embedder.hs                       |     2 +-
 test/random/Main.hs                           |     2 +-
 test/random/README.md                         |     2 +-
 test/run-drun-non-ci/actor64.mo               |    66 +
 .../memory-reserve-composite.drun             |     5 -
 .../memory-reserve-composite.mo               |    39 -
 .../run-drun-non-ci/memory-reserve-query.drun |     5 -
 .../memory-reserve-query.mo                   |    31 -
 .../memory-reserve-update.drun                |     5 -
 .../memory-reserve-update.mo                  |    30 -
 .../memory-reserve-upgrade.drun               |     5 -
 .../memory-reserve-upgrade.mo                 |    25 -
 test/run-drun-non-ci/ok/actor64.drun-run.ok   |    67 +
 test/run-drun/actor-class-mgmt-enhanced.mo    |   156 +
 test/run-drun/actor-class-mgmt.mo             |    16 +-
 test/run-drun/any-stabilization.drun          |    11 +
 test/run-drun/any-stabilization/version0.mo   |     3 +
 test/run-drun/any-stabilization/version1.mo   |     3 +
 test/run-drun/any-stabilization/version2.mo   |     3 +
 test/run-drun/any-upgrades.drun               |     1 +
 test/run-drun/array-stabilization.drun        |    29 +
 test/run-drun/array-stabilization/version0.mo |    16 +
 test/run-drun/array-stabilization/version1.mo |    16 +
 test/run-drun/array-stabilization/version2.mo |    16 +
 test/run-drun/array-stabilization/version3.mo |    16 +
 test/run-drun/array-stabilization/version4.mo |    15 +
 test/run-drun/array-upgrades.drun             |     1 +
 test/run-drun/blob-array-mismatch.drun        |     1 +
 test/run-drun/blob-stabilization.mo           |    24 +
 test/run-drun/blob-upgrade.mo                 |    22 +
 test/run-drun/class-import.mo                 |     4 +-
 test/run-drun/destabilization-crash.drun      |     4 +
 .../destabilization-crash.mo                  |    44 +
 test/run-drun/double-sharing-benchmark.mo     |    41 +
 ...mpty-actor.mo => empty-actor-classical.mo} |     5 +-
 test/run-drun/empty-actor-enhanced.mo         |    18 +
 test/run-drun/free-callbacks.mo               |     2 +-
 test/run-drun/function-stabilization.drun     |    16 +
 .../function-stabilization/version0.mo        |    14 +
 .../function-stabilization/version1.mo        |    14 +
 .../function-stabilization/version2.mo        |     6 +
 .../function-stabilization/version3.mo        |     6 +
 .../function-stabilization/version4.mo        |     6 +
 test/run-drun/function-upgrades.drun          |     1 +
 test/run-drun/gc-trigger.mo                   |    10 +-
 test/run-drun/hashBlob.mo                     |    12 +
 .../incremental-actor-class-stabilization.mo  |    51 +
 .../test-actor.mo                             |    26 +
 test/run-drun/incremental-stabilization.mo    |    69 +
 test/run-drun/large-destabilization.drun      |     1 +
 test/run-drun/map-mixed-upgrades.drun         |    36 +
 test/run-drun/map-mixed-upgrades/map0.mo      |   107 +
 test/run-drun/map-mixed-upgrades/map1.mo      |   143 +
 test/run-drun/map-mixed-upgrades/node0.mo     |    42 +
 test/run-drun/map-mixed-upgrades/node1.mo     |    64 +
 test/run-drun/map-stabilization.drun          |    15 +
 test/run-drun/map-stabilization/map0.mo       |    82 +
 test/run-drun/map-stabilization/map1.mo       |    96 +
 test/run-drun/map-stabilization/node0.mo      |    42 +
 test/run-drun/map-stabilization/node1.mo      |    64 +
 test/run-drun/map-upgrades.drun               |     1 -
 test/run-drun/max-stack-variant.mo            |     2 +-
 test/run-drun/migrate-candid-sharing.drun     |     7 +
 .../new-stabilization.mo                      |    13 +
 .../old-stabilization.mo                      |    13 +
 test/run-drun/migrate-stabilization.drun      |     8 +-
 .../new-stabilization.mo                      |     1 +
 .../old-stabilization-source.txt              |     1 -
 .../old-stabilization.mo                      |    51 +
 .../old-stabilization.wasm                    |   Bin 599897 -> 0 bytes
 test/run-drun/migration-paths.drun            |    26 +
 .../run-drun/migration-paths/new-installer.mo |    57 +
 .../run-drun/migration-paths/old-installer.mo |    49 +
 .../run-drun/migration-paths/test_canister.mo |    18 +
 .../run-drun/more-function-stabilization.drun |     8 +
 .../more-function-stabilization/version0.mo   |     4 +
 .../more-function-stabilization/version1.mo   |     4 +
 .../more-function-stabilization/version2.mo   |     4 +
 test/run-drun/more-function-upgrades.drun     |     1 +
 .../run-drun/non-incremental-stabilization.mo |    39 +
 test/run-drun/ok/actor-arg.drun.ok            |     3 +-
 .../ok/actor-class-mgmt-enhanced.drun-run.ok  |     4 +
 test/run-drun/ok/actor-class-mgmt.drun-run.ok |     2 +-
 .../ok/actor-reference-bad.drun-run.ok        |    15 +-
 test/run-drun/ok/any-stabilization.drun.ok    |    11 +
 test/run-drun/ok/any-upgrades.drun.ok         |     3 +-
 .../ok/array-out-of-bounds.drun-run.ok        |     6 +-
 test/run-drun/ok/array-stabilization.drun.ok  |    52 +
 test/run-drun/ok/array-upgrades.drun.ok       |     6 +-
 test/run-drun/ok/assert.drun-run.ok           |     3 +-
 test/run-drun/ok/basic-cycles.drun-run.ok     |     9 +-
 test/run-drun/ok/blob-array-mismatch.drun.ok  |     6 +-
 .../ok/blob-stabilization.drun-run.ok         |     6 +
 test/run-drun/ok/blob-stabilization.tc.ok     |     2 +
 test/run-drun/ok/blob-upgrade.drun-run.ok     |     5 +
 test/run-drun/ok/blob-upgrade.tc.ok           |     2 +
 .../run-drun/ok/call-async-method.drun-run.ok |     3 +-
 test/run-drun/ok/call-raw-candid.drun-run.ok  |     6 +-
 test/run-drun/ok/call-raw.drun-run.ok         |     3 +-
 .../ok/callback-trap-upgrade.drun-run.ok      |     3 +-
 test/run-drun/ok/class-import.tc.ok           |     2 -
 .../run-drun/ok/destabilization-crash.drun.ok |    13 +
 test/run-drun/ok/divide-by-zero.drun-run.ok   |     3 +-
 .../ok/double-sharing-benchmark.drun-run.ok   |     6 +
 ...n.ok => empty-actor-classical.drun-run.ok} |     0
 .../ok/empty-actor-enhanced.drun-run.ok       |     2 +
 test/run-drun/ok/error-codes.drun-run.ok      |     3 +-
 test/run-drun/ok/explicit-trap.drun-run.ok    |     3 +-
 .../ok/function-stabilization.drun.ok         |    19 +
 test/run-drun/ok/function-upgrades.drun.ok    |     9 +-
 test/run-drun/ok/gc-trigger-acl.drun-run.ok   |     3 +-
 test/run-drun/ok/hashBlob.drun-run.ok         |     5 +
 test/run-drun/ok/hashBlob.run-ir.ok           |     2 +
 test/run-drun/ok/hashBlob.run-low.ok          |     2 +
 test/run-drun/ok/hashBlob.run.ok              |     2 +
 test/run-drun/ok/idl-any-stable.drun-run.ok   |     3 +-
 test/run-drun/ok/idl-bad.drun-run.ok          |     3 +-
 test/run-drun/ok/idl-bool.drun-run.ok         |     3 +-
 .../run-drun/ok/idl-candid-config.drun-run.ok |     3 +-
 .../ok/idl-large-principal.drun-run.ok        |     9 +-
 test/run-drun/ok/idl-nary.drun-run.ok         |     6 +-
 test/run-drun/ok/idl-record.drun-run.ok       |     3 +-
 test/run-drun/ok/idl-spacebomb.drun-run.ok    |   105 +-
 test/run-drun/ok/idl-sub-rec.drun-run.ok      |     6 +-
 test/run-drun/ok/idl-sub-variant.drun-run.ok  |     3 +-
 test/run-drun/ok/idl-tuple.drun-run.ok        |     3 +-
 ...ntal-actor-class-stabilization.drun-run.ok |    24 +
 .../ok/incremental-stabilization.drun-run.ok  |    36 +
 test/run-drun/ok/issue-1847.drun-run.ok       |     3 +-
 test/run-drun/ok/issue-4229.drun-run.ok       |     3 +-
 test/run-drun/ok/let-else-actor.drun-run.ok   |     3 +-
 test/run-drun/ok/live-upgrade.drun.ok         |     3 +-
 test/run-drun/ok/map-mixed-upgrades.drun.ok   |   181 +
 test/run-drun/ok/map-stabilization.drun.ok    |    67 +
 .../run-drun/ok/max-stack-variant.drun-run.ok |     6 +-
 test/run-drun/ok/max-stack.drun-run.ok        |     6 +-
 .../ok/migrate-candid-sharing.drun.ok         |     8 +
 test/run-drun/ok/migration-paths.drun.ok      |    28 +
 .../ok/more-function-stabilization.drun.ok    |    10 +
 .../ok/more-function-upgrades.drun.ok         |     6 +-
 .../non-incremental-stabilization.drun-run.ok |    29 +
 .../run-drun/ok/oneshot-callbacks.drun-run.ok |     6 +-
 .../ok/query-footprint-overflow.drun-run.ok   |     3 +-
 .../ok/query-footprint-overflow.tc.ok         |     2 +-
 test/run-drun/ok/query-footprint.drun-run.ok  |     8 +-
 test/run-drun/ok/query-footprint.tc.ok        |     6 +-
 .../ok/query-size-overflow.drun-run.ok        |     6 +-
 test/run-drun/ok/region-test.drun-run.ok      |     3 +-
 test/run-drun/ok/region0-overflow.drun-run.ok |    18 +-
 .../run-drun/ok/region0-rts-stats.drun-run.ok |    17 +-
 test/run-drun/ok/region0-rts-stats.tc.ok      |     4 +-
 ...un.ok => rts-stats2-classical.drun-run.ok} |     0
 .../ok/rts-stats2-enhanced.drun-run.ok        |    16 +
 test/run-drun/ok/runtime-info-acl.drun-run.ok |     3 +-
 test/run-drun/ok/selftail.drun-run.ok         |     3 +-
 .../ok/send-failure-example-trap.drun-run.ok  |     6 +-
 .../stabilization-authorization.drun-run.ok   |    17 +
 .../ok/stabilization-instructions.drun-run.ok |    15 +
 .../ok/stabilization-upgrade-hooks.drun.ok    |    33 +
 .../stabilize-beyond-stable-limit.drun-run.ok |    19 +
 .../ok/stabilize-beyond-stable-limit.tc.ok    |     2 +
 .../ok/stabilize-bignat-bigint.drun.ok        |    31 +
 .../run-drun/ok/stabilize-bignums.drun-run.ok |    29 +
 test/run-drun/ok/stabilize-blob-iter.drun.ok  |    21 +
 .../ok/stabilize-boxed-numbers.drun-run.ok    |    27 +
 test/run-drun/ok/stabilize-generics.drun.ok   |    29 +
 .../ok/stabilize-large-array.drun-run.ok      |    11 +
 .../ok/stabilize-mutable-array.drun.ok        |    14 +
 .../ok/stabilize-mutable-service.drun.ok      |    30 +
 .../ok/stabilize-mutable-variant.drun.ok      |    10 +
 test/run-drun/ok/stabilize-mutable.drun.ok    |    20 +
 test/run-drun/ok/stabilize-nat-to-int.drun.ok |    25 +
 test/run-drun/ok/stabilize-non-stable.drun.ok |    21 +
 test/run-drun/ok/stabilize-optional.drun.ok   |    26 +
 .../ok/stabilize-primitive-types.drun-run.ok  |    85 +
 .../ok/stabilize-recursive-type.drun.ok       |    24 +
 .../ok/stabilize-remove-add-fields.drun.ok    |    38 +
 test/run-drun/ok/stabilize-service.drun.ok    |    25 +
 test/run-drun/ok/stabilize-text-iter.drun.ok  |    21 +
 test/run-drun/ok/stabilize-to-any.drun.ok     |    20 +
 test/run-drun/ok/stabilize-variant.drun.ok    |    23 +
 .../ok/stable-mem-rts-stats.drun-run.ok       |    17 +-
 test/run-drun/ok/stable-mem-rts-stats.tc.ok   |     4 +-
 .../ok/stable-memory-test.drun-run.ok         |     3 +-
 test/run-drun/ok/stable-overflow.drun-run.ok  |    18 +-
 ...regions-new-each-stabilization.drun-run.ok |    31 +
 .../stable-regions-stabilization.drun-run.ok  |    13 +
 .../ok/stable-regions-stabilization.tc.ok     |     2 +
 .../ok/stable-size-overflow.drun-run.ok       |     5 +
 test/run-drun/ok/stable-size-overflow.tc.ok   |     1 -
 .../ok/trap-on-async-failure.drun-run.ok      |     6 +-
 .../ok/trap-on-await-failure.drun-run.ok      |     6 +-
 .../ok/trap-on-call-raw-failure.drun-run.ok   |     6 +-
 .../ok/trap-on-local-failure.drun-run.ok      |     6 +-
 .../ok/trap-on-send-failure.drun-run.ok       |     6 +-
 .../ok/try-finally-trap-stop.drun-run.ok      |     3 +-
 test/run-drun/ok/try-finally-trap.drun.ok     |     7 +-
 test/run-drun/ok/try-finally.drun-run.ok      |    12 +-
 .../run-drun/ok/tuple-record-mismatch.drun.ok |     6 +-
 test/run-drun/ok/tuple-stabilization.drun.ok  |    50 +
 test/run-drun/ok/tuple-upgrades.drun.ok       |    12 +-
 .../run-drun/ok/upgrade-bignat-bigint.drun.ok |     3 +-
 test/run-drun/ok/upgrade-bignums.drun-run.ok  |    15 +
 test/run-drun/ok/upgrade-generics.drun.ok     |     3 +-
 .../run-drun/ok/upgrade-mutable-array.drun.ok |     3 +-
 .../ok/upgrade-mutable-service.drun.ok        |     3 +-
 .../ok/upgrade-mutable-variant.drun.ok        |     3 +-
 test/run-drun/ok/upgrade-mutable.drun.ok      |     3 +-
 test/run-drun/ok/upgrade-nat-to-int.drun.ok   |     3 +-
 test/run-drun/ok/upgrade-non-stable.drun.ok   |     3 +-
 .../ok/upgrade-recursive-type.drun.ok         |     6 +-
 .../ok/upgrade-remove-add-fields.drun.ok      |     6 +-
 test/run-drun/ok/upgrade-service.drun.ok      |     3 +-
 test/run-drun/ok/variant-upgrades.drun.ok     |     6 +-
 test/run-drun/ok/vec-any-bomb.drun-run.ok     |     3 +-
 test/run-drun/oneshot-callbacks.mo            |     1 +
 test/run-drun/query-footprint-overflow.mo     |     1 +
 test/run-drun/query-footprint.mo              |     1 +
 test/run-drun/region0-rts-stats.mo            |     4 +-
 test/run-drun/rts-stats.mo                    |     6 +-
 ...{rts-stats2.mo => rts-stats2-classical.mo} |     3 +-
 test/run-drun/rts-stats2-enhanced.mo          |    55 +
 test/run-drun/runtime-info.mo                 |     2 +-
 test/run-drun/stabilization-authorization.mo  |    43 +
 .../access-tester.mo                          |    23 +
 .../upgrade-target.mo                         |    13 +
 test/run-drun/stabilization-instructions.mo   |    44 +
 .../run-drun/stabilization-upgrade-hooks.drun |    18 +
 .../upgrade-hook.mo                           |     4 +
 .../upgrade-hook0.mo                          |    20 +
 .../upgrade-hook1.mo                          |    25 +
 .../upgrade-hook2.mo                          |    21 +
 .../run-drun/stabilize-beyond-stable-limit.mo |    46 +
 test/run-drun/stabilize-bignat-bigint.drun    |    31 +
 .../stabilize-bignat-bigint/version0.mo       |    13 +
 .../stabilize-bignat-bigint/version1.mo       |    13 +
 test/run-drun/stabilize-bignums.mo            |    36 +
 test/run-drun/stabilize-blob-iter.drun        |    16 +
 test/run-drun/stabilize-blob-iter/version0.mo |    27 +
 test/run-drun/stabilize-blob-iter/version1.mo |    19 +
 test/run-drun/stabilize-boxed-numbers.mo      |    26 +
 test/run-drun/stabilize-generics.drun         |    22 +
 test/run-drun/stabilize-generics/version0.mo  |    15 +
 test/run-drun/stabilize-generics/version1.mo  |    15 +
 test/run-drun/stabilize-generics/version2.mo  |    15 +
 test/run-drun/stabilize-large-array.mo        |    35 +
 test/run-drun/stabilize-mutable-array.drun    |     7 +
 .../stabilize-mutable-array/version0.mo       |    22 +
 .../stabilize-mutable-array/version1.mo       |    28 +
 test/run-drun/stabilize-mutable-service.drun  |    12 +
 .../original-service.mo                       |    19 +
 .../reduced-service.mo                        |    11 +
 .../stabilize-mutable-service/version0.mo     |    42 +
 .../stabilize-mutable-service/version1.mo     |    44 +
 test/run-drun/stabilize-mutable-variant.drun  |     7 +
 .../stabilize-mutable-variant/version0.mo     |    16 +
 .../stabilize-mutable-variant/version1.mo     |    26 +
 test/run-drun/stabilize-mutable.drun          |    14 +
 test/run-drun/stabilize-mutable/version0.mo   |    18 +
 test/run-drun/stabilize-mutable/version1.mo   |    20 +
 test/run-drun/stabilize-nat-to-int.drun       |    20 +
 .../run-drun/stabilize-nat-to-int/version0.mo |    13 +
 .../run-drun/stabilize-nat-to-int/version1.mo |    13 +
 test/run-drun/stabilize-non-stable.drun       |    16 +
 .../run-drun/stabilize-non-stable/version0.mo |    29 +
 .../run-drun/stabilize-non-stable/version1.mo |    19 +
 test/run-drun/stabilize-optional.drun         |    21 +
 test/run-drun/stabilize-optional/version0.mo  |     9 +
 test/run-drun/stabilize-optional/version1.mo  |     9 +
 test/run-drun/stabilize-optional/version2.mo  |     9 +
 test/run-drun/stabilize-primitive-types.mo    |    73 +
 test/run-drun/stabilize-recursive-type.drun   |    17 +
 .../stabilize-recursive-type/version0.mo      |    31 +
 .../stabilize-recursive-type/version1.mo      |    25 +
 .../run-drun/stabilize-remove-add-fields.drun |    25 +
 .../stabilize-remove-add-fields/version0.mo   |    21 +
 .../stabilize-remove-add-fields/version1.mo   |    15 +
 .../stabilize-remove-add-fields/version2.mo   |    18 +
 test/run-drun/stabilize-service.drun          |    18 +
 .../stabilize-service/original-service.mo     |    11 +
 .../stabilize-service/reduced-service.mo      |     7 +
 test/run-drun/stabilize-service/version0.mo   |    28 +
 test/run-drun/stabilize-service/version1.mo   |    30 +
 test/run-drun/stabilize-text-iter.drun        |    16 +
 test/run-drun/stabilize-text-iter/version0.mo |    27 +
 test/run-drun/stabilize-text-iter/version1.mo |    19 +
 test/run-drun/stabilize-to-any.drun           |    15 +
 test/run-drun/stabilize-to-any/version0.mo    |    23 +
 test/run-drun/stabilize-to-any/version1.mo    |    25 +
 test/run-drun/stabilize-to-any/version2.mo    |    23 +
 test/run-drun/stabilize-variant.drun          |    19 +
 test/run-drun/stabilize-variant/version0.mo   |    21 +
 test/run-drun/stabilize-variant/version1.mo   |    23 +
 test/run-drun/stabilize-variant/version2.mo   |    22 +
 test/run-drun/stable-mem-rts-stats.mo         |     4 +-
 .../stable-regions-new-each-stabilization.mo  |    46 +
 test/run-drun/stable-regions-stabilization.mo |    52 +
 test/run-drun/stable-size-no-overflow.mo      |     1 +
 test/run-drun/stable-size-overflow.mo         |    25 +
 test/run-drun/tuple-record-mismatch.drun      |     1 +
 test/run-drun/tuple-stabilization.drun        |    27 +
 test/run-drun/tuple-stabilization/version0.mo |    15 +
 test/run-drun/tuple-stabilization/version1.mo |    18 +
 test/run-drun/tuple-stabilization/version2.mo |    10 +
 test/run-drun/tuple-stabilization/version3.mo |    10 +
 test/run-drun/tuple-stabilization/version4.mo |    10 +
 test/run-drun/tuple-stabilization/version5.mo |    16 +
 test/run-drun/tuple-upgrades.drun             |     1 +
 test/run-drun/upgrade-bignat-bigint.drun      |     1 +
 test/run-drun/upgrade-bignums.mo              |    24 +
 test/run-drun/upgrade-generics.drun           |     1 +
 test/run-drun/upgrade-instructions.mo         |     1 +
 test/run-drun/upgrade-mutable-array.drun      |     1 +
 test/run-drun/upgrade-mutable-service.drun    |     1 +
 test/run-drun/upgrade-mutable-variant.drun    |     1 +
 test/run-drun/upgrade-mutable.drun            |     1 +
 test/run-drun/upgrade-nat-to-int.drun         |     1 +
 test/run-drun/upgrade-non-stable.drun         |     1 +
 test/run-drun/upgrade-non-stable/version0.mo  |    16 +-
 test/run-drun/upgrade-non-stable/version1.mo  |    11 +-
 test/run-drun/upgrade-recursive-type.drun     |     1 +
 test/run-drun/upgrade-remove-add-fields.drun  |     1 +
 test/run-drun/upgrade-service.drun            |     1 +
 test/run-drun/upgrade-to-any.drun             |     1 +
 test/run-drun/upgrade-to-any/version0.mo      |     5 +-
 test/run-drun/upgrade-to-any/version1.mo      |     5 +-
 test/run-drun/upgrade-to-any/version2.mo      |     3 +-
 test/run-drun/variant-upgrades.drun           |     1 +
 test/run.sh                                   |    51 +-
 test/run/beyond-4GB.mo                        |    23 +
 test/run/compact-float.mo                     |    21 +
 .../{empty-if.mo => empty-if-classical.mo}    |     1 +
 test/run/empty-if-eop.mo                      |    17 +
 .../{float-fmt.mo => float-fmt-classical.mo}  |     1 +
 test/run/float-fmt-eop.mo                     |    41 +
 test/run/float-ops.mo                         |     5 +-
 test/run/idl-ops.mo                           |     2 +-
 test/run/idl.mo                               |     4 +-
 test/run/if-swap.mo                           |    12 -
 test/run/inc-oom.mo                           |    18 -
 .../{issue1356.mo => issue1356-classical.mo}  |     1 +
 test/run/issue1356-enhanced.mo                |    39 +
 test/run/leb-random.mo                        |    44 +
 test/run/ok/compact-float.run-ir.ok           |    10 +
 test/run/ok/compact-float.run-low.ok          |    10 +
 test/run/ok/compact-float.run.ok              |    10 +
 test/run/ok/compact-float.wasm-run.ok         |    10 +
 ...un-ir.ok => float-fmt-classical.run-ir.ok} |     0
 ...-low.ok => float-fmt-classical.run-low.ok} |     0
 ...-fmt.run.ok => float-fmt-classical.run.ok} |     0
 ...run.ok => float-fmt-classical.wasm-run.ok} |     0
 test/run/ok/float-fmt-eop.run-ir.ok           |    24 +
 test/run/ok/float-fmt-eop.run-low.ok          |    24 +
 test/run/ok/float-fmt-eop.run.ok              |    24 +
 test/run/ok/float-fmt-eop.wasm-run.ok         |    24 +
 test/run/ok/float-ops.run-ir.ok               |     2 -
 test/run/ok/float-ops.run-low.ok              |     2 -
 test/run/ok/float-ops.run.ok                  |     2 -
 test/run/ok/float-ops.wasm-run.ok             |     2 -
 test/run/ok/inc-oom.wasm-run.ok               |     1 -
 ...=> optimise-for-array-classical.run-ir.ok} |     0
 ...> optimise-for-array-classical.run-low.ok} |     0
 ...ok => optimise-for-array-classical.run.ok} |     0
 .../run/ok/optimise-for-array-classical.tc.ok |     1 +
 ... optimise-for-array-classical.wasm-run.ok} |     0
 .../ok/optimise-for-array-enhanced.run-ir.ok  |    12 +
 .../ok/optimise-for-array-enhanced.run-low.ok |    12 +
 .../run/ok/optimise-for-array-enhanced.run.ok |    12 +
 test/run/ok/optimise-for-array-enhanced.tc.ok |     1 +
 .../optimise-for-array-enhanced.wasm-run.ok   |    12 +
 test/run/ok/optimise-for-array.tc.ok          |     1 -
 test/run/ok/stable-memory-beyond-4GB.tc.ok    |     2 +
 .../ok/stable-memory-beyond-4GB.wasm-run.ok   |     4 +
 test/run/ok/stable-region-beyond-4GB.tc.ok    |     2 +
 .../ok/stable-region-beyond-4GB.wasm-run.ok   |     4 +
 ...ds.run-ir.ok => words-classical.run-ir.ok} |     0
 ....run-low.ok => words-classical.run-low.ok} |     0
 .../{words.run.ok => words-classical.run.ok}  |     0
 ...asm-run.ok => words-classical.wasm-run.ok} |     0
 test/run/ok/words-enhanced.run-ir.ok          |    94 +
 test/run/ok/words-enhanced.run-low.ok         |    94 +
 test/run/ok/words-enhanced.run.ok             |    94 +
 test/run/ok/words-enhanced.wasm-run.ok        |    94 +
 ...ray.mo => optimise-for-array-classical.mo} |    19 +-
 test/run/optimise-for-array-enhanced.mo       |   131 +
 test/run/refuted-const-float.mo               |     6 -
 test/run/refuted-const-option-null.mo         |     6 -
 test/run/refuted-const-option.mo              |     6 -
 test/run/refuted-const-variant.mo             |     6 -
 test/run/stable-memory-beyond-4GB.mo          |    25 +
 test/run/stable-region-beyond-4GB.mo          |    26 +
 test/run/unboxed-let.mo                       |    70 +-
 test/run/variant-specials.mo                  |     8 +-
 test/run/{words.mo => words-classical.mo}     |     1 +
 test/run/words-enhanced.mo                    |   340 +
 .../{divInt32.mo => divInt32-classical.mo}    |     1 +
 test/trap/divInt32-enhanced.mo                |     3 +
 test/trap/mulInt8-upper.mo                    |     5 +-
 test/trap/mulNat8.mo                          |     5 +-
 test/trap/ok/divInt32-classical.run-ir.ok     |     1 +
 test/trap/ok/divInt32-classical.run-low.ok    |     1 +
 test/trap/ok/divInt32-classical.run.ok        |     1 +
 ...n.ret.ok => divInt32-classical.run.ret.ok} |     0
 ...-run.ok => divInt32-classical.wasm-run.ok} |     2 +-
 .../ok/divInt32-classical.wasm-run.ret.ok}    |     0
 test/trap/ok/divInt32-enhanced.run-ir.ok      |     1 +
 test/trap/ok/divInt32-enhanced.run-low.ok     |     1 +
 test/trap/ok/divInt32-enhanced.run.ok         |     1 +
 test/trap/ok/divInt32-enhanced.run.ret.ok     |     1 +
 test/trap/ok/divInt32-enhanced.wasm-run.ok    |     9 +
 ...t.ok => divInt32-enhanced.wasm-run.ret.ok} |     0
 test/trap/ok/divInt32.run-ir.ok               |     1 -
 test/trap/ok/divInt32.run-low.ok              |     1 -
 test/trap/ok/divInt32.run.ok                  |     1 -
 647 files changed, 35050 insertions(+), 4526 deletions(-)
 create mode 100644 design/GraphCopyStabilization.md
 create mode 100644 design/PersistenceModes.md
 create mode 100644 design/StableMemory.md
 create mode 100644 doc/md/canister-maintenance/orthogonal-persistence/_category_.yml
 create mode 100644 doc/md/canister-maintenance/orthogonal-persistence/classical.md
 create mode 100644 doc/md/canister-maintenance/orthogonal-persistence/enhanced.md
 create mode 100644 doc/md/canister-maintenance/orthogonal-persistence/modes.md
 create mode 100644 doc/md/examples/count-v5.mo
 create mode 100644 doc/md/examples/count-v6.mo
 create mode 100644 rts/motoko-rts-tests/src/gc/classical.rs
 create mode 100644 rts/motoko-rts-tests/src/gc/compacting.rs
 create mode 100644 rts/motoko-rts-tests/src/gc/compacting/bitmap.rs
 create mode 100644 rts/motoko-rts-tests/src/gc/compacting/mark_stack.rs
 create mode 100644 rts/motoko-rts-tests/src/gc/enhanced.rs
 create mode 100644 rts/motoko-rts-tests/src/gc/generational.rs
 create mode 100644 rts/motoko-rts-tests/src/gc/generational/mark_stack.rs
 create mode 100644 rts/motoko-rts-tests/src/gc/generational/remembered_set.rs
 create mode 100644 rts/motoko-rts-tests/src/gc/heap/classical.rs
 create mode 100644 rts/motoko-rts-tests/src/gc/heap/enhanced.rs
 create mode 100644 rts/motoko-rts-tests/src/print.rs
 create mode 100644 rts/motoko-rts-tests/src/stabilization.rs
 create mode 100644 rts/motoko-rts-tests/src/stabilization/layout.rs
 create mode 100644 rts/motoko-rts-tests/src/stabilization/reader_writer.rs
 create mode 100644 rts/motoko-rts-tests/src/stabilization/stable_bigints.rs
 create mode 100644 rts/motoko-rts-tests/src/stabilization/stable_memory.rs
 create mode 100644 rts/motoko-rts-tests/src/stable_mem.rs
 create mode 100644 rts/motoko-rts/src/float/classical.rs
 create mode 100644 rts/motoko-rts/src/float/enhanced.rs
 create mode 100644 rts/motoko-rts/src/gc/copying.rs
 create mode 100644 rts/motoko-rts/src/gc/generational.rs
 create mode 100644 rts/motoko-rts/src/gc/generational/mark_stack.rs
 create mode 100644 rts/motoko-rts/src/gc/generational/sanity_checks.rs
 create mode 100644 rts/motoko-rts/src/gc/generational/write_barrier.rs
 create mode 100644 rts/motoko-rts/src/gc/incremental/roots/classical.rs
 create mode 100644 rts/motoko-rts/src/gc/incremental/roots/enhanced.rs
 create mode 100644 rts/motoko-rts/src/gc/incremental/scheduling.rs
 create mode 100644 rts/motoko-rts/src/gc/mark_compact.rs
 create mode 100644 rts/motoko-rts/src/gc/mark_compact/bitmap.rs
 create mode 100644 rts/motoko-rts/src/gc/mark_compact/mark_stack.rs
 rename rts/motoko-rts/src/gc/{incremental/sanity_checks => }/remembered_set.rs (88%)
 create mode 100644 rts/motoko-rts/src/libc_declarations.rs
 create mode 100644 rts/motoko-rts/src/memory/ic/classical_memory.rs
 create mode 100644 rts/motoko-rts/src/memory/ic/enhanced_memory.rs
 create mode 100644 rts/motoko-rts/src/memory/ic/linear_memory.rs
 create mode 100644 rts/motoko-rts/src/memory/ic/partitioned_memory.rs
 create mode 100644 rts/motoko-rts/src/stabilization.rs
 create mode 100644 rts/motoko-rts/src/stabilization/deserialization.rs
 create mode 100644 rts/motoko-rts/src/stabilization/deserialization/scan_stack.rs
 create mode 100644 rts/motoko-rts/src/stabilization/deserialization/stable_memory_access.rs
 create mode 100644 rts/motoko-rts/src/stabilization/graph_copy.rs
 create mode 100644 rts/motoko-rts/src/stabilization/graph_copy/limit.rs
 create mode 100644 rts/motoko-rts/src/stabilization/ic.rs
 create mode 100644 rts/motoko-rts/src/stabilization/ic/metadata.rs
 create mode 100644 rts/motoko-rts/src/stabilization/ic/performance.rs
 create mode 100644 rts/motoko-rts/src/stabilization/layout.rs
 create mode 100644 rts/motoko-rts/src/stabilization/layout/stable_array.rs
 create mode 100644 rts/motoko-rts/src/stabilization/layout/stable_bigint.rs
 create mode 100644 rts/motoko-rts/src/stabilization/layout/stable_bits64.rs
 create mode 100644 rts/motoko-rts/src/stabilization/layout/stable_blob.rs
 create mode 100644 rts/motoko-rts/src/stabilization/layout/stable_concat.rs
 create mode 100644 rts/motoko-rts/src/stabilization/layout/stable_mutbox.rs
 create mode 100644 rts/motoko-rts/src/stabilization/layout/stable_object.rs
 create mode 100644 rts/motoko-rts/src/stabilization/layout/stable_region.rs
 create mode 100644 rts/motoko-rts/src/stabilization/layout/stable_some.rs
 create mode 100644 rts/motoko-rts/src/stabilization/layout/stable_variant.rs
 create mode 100644 rts/motoko-rts/src/stabilization/serialization.rs
 create mode 100644 rts/motoko-rts/src/stabilization/serialization/stable_memory_stream.rs
 create mode 100644 rts/motoko-rts/src/stream.rs
 create mode 100644 rts/motoko-rts/src/visitor/classical.rs
 create mode 100644 rts/motoko-rts/src/visitor/enhanced.rs
 rename src/codegen/{compile.ml => compile_classical.ml} (87%)
 rename src/codegen/{compile.mli => compile_classical.mli} (100%)
 create mode 100644 src/codegen/compile_enhanced.ml
 create mode 100644 src/codegen/compile_enhanced.mli
 create mode 100644 src/wasm-exts/memory.ml
 create mode 100644 src/wasm-exts/memory.mli
 create mode 100644 src/wasm-exts/types.ml
 create mode 100644 src/wasm-exts/values.ml
 create mode 100644 test/bench/heap-64.mo
 create mode 100644 test/bench/ok/heap-64.drun-run.ok
 create mode 100644 test/run-drun-non-ci/actor64.mo
 delete mode 100644 test/run-drun-non-ci/memory-reserve-composite.drun
 delete mode 100644 test/run-drun-non-ci/memory-reserve-composite/memory-reserve-composite.mo
 delete mode 100644 test/run-drun-non-ci/memory-reserve-query.drun
 delete mode 100644 test/run-drun-non-ci/memory-reserve-query/memory-reserve-query.mo
 delete mode 100644 test/run-drun-non-ci/memory-reserve-update.drun
 delete mode 100644 test/run-drun-non-ci/memory-reserve-update/memory-reserve-update.mo
 delete mode 100644 test/run-drun-non-ci/memory-reserve-upgrade.drun
 delete mode 100644 test/run-drun-non-ci/memory-reserve-upgrade/memory-reserve-upgrade.mo
 create mode 100644 test/run-drun-non-ci/ok/actor64.drun-run.ok
 create mode 100644 test/run-drun/actor-class-mgmt-enhanced.mo
 create mode 100644 test/run-drun/any-stabilization.drun
 create mode 100644 test/run-drun/any-stabilization/version0.mo
 create mode 100644 test/run-drun/any-stabilization/version1.mo
 create mode 100644 test/run-drun/any-stabilization/version2.mo
 create mode 100644 test/run-drun/array-stabilization.drun
 create mode 100644 test/run-drun/array-stabilization/version0.mo
 create mode 100644 test/run-drun/array-stabilization/version1.mo
 create mode 100644 test/run-drun/array-stabilization/version2.mo
 create mode 100644 test/run-drun/array-stabilization/version3.mo
 create mode 100644 test/run-drun/array-stabilization/version4.mo
 create mode 100644 test/run-drun/blob-stabilization.mo
 create mode 100644 test/run-drun/blob-upgrade.mo
 create mode 100644 test/run-drun/destabilization-crash.drun
 create mode 100644 test/run-drun/destabilization-crash/destabilization-crash.mo
 create mode 100644 test/run-drun/double-sharing-benchmark.mo
 rename test/run-drun/{empty-actor.mo => empty-actor-classical.mo} (83%)
 create mode 100644 test/run-drun/empty-actor-enhanced.mo
 create mode 100644 test/run-drun/function-stabilization.drun
 create mode 100644 test/run-drun/function-stabilization/version0.mo
 create mode 100644 test/run-drun/function-stabilization/version1.mo
 create mode 100644 test/run-drun/function-stabilization/version2.mo
 create mode 100644 test/run-drun/function-stabilization/version3.mo
 create mode 100644 test/run-drun/function-stabilization/version4.mo
 create mode 100644 test/run-drun/hashBlob.mo
 create mode 100644 test/run-drun/incremental-actor-class-stabilization.mo
 create mode 100644 test/run-drun/incremental-actor-class-stabilization/test-actor.mo
 create mode 100644 test/run-drun/incremental-stabilization.mo
 create mode 100644 test/run-drun/map-mixed-upgrades.drun
 create mode 100644 test/run-drun/map-mixed-upgrades/map0.mo
 create mode 100644 test/run-drun/map-mixed-upgrades/map1.mo
 create mode 100644 test/run-drun/map-mixed-upgrades/node0.mo
 create mode 100644 test/run-drun/map-mixed-upgrades/node1.mo
 create mode 100644 test/run-drun/map-stabilization.drun
 create mode 100644 test/run-drun/map-stabilization/map0.mo
 create mode 100644 test/run-drun/map-stabilization/map1.mo
 create mode 100644 test/run-drun/map-stabilization/node0.mo
 create mode 100644 test/run-drun/map-stabilization/node1.mo
 create mode 100644 test/run-drun/migrate-candid-sharing.drun
 create mode 100644 test/run-drun/migrate-candid-sharing/new-stabilization.mo
 create mode 100644 test/run-drun/migrate-candid-sharing/old-stabilization.mo
 delete mode 100644 test/run-drun/migrate-stabilization/old-stabilization-source.txt
 create mode 100644 test/run-drun/migrate-stabilization/old-stabilization.mo
 delete mode 100644 test/run-drun/migrate-stabilization/old-stabilization.wasm
 create mode 100644 test/run-drun/migration-paths.drun
 create mode 100644 test/run-drun/migration-paths/new-installer.mo
 create mode 100644 test/run-drun/migration-paths/old-installer.mo
 create mode 100644 test/run-drun/migration-paths/test_canister.mo
 create mode 100644 test/run-drun/more-function-stabilization.drun
 create mode 100644 test/run-drun/more-function-stabilization/version0.mo
 create mode 100644 test/run-drun/more-function-stabilization/version1.mo
 create mode 100644 test/run-drun/more-function-stabilization/version2.mo
 create mode 100644 test/run-drun/non-incremental-stabilization.mo
 create mode 100644 test/run-drun/ok/actor-class-mgmt-enhanced.drun-run.ok
 create mode 100644 test/run-drun/ok/any-stabilization.drun.ok
 create mode 100644 test/run-drun/ok/array-stabilization.drun.ok
 create mode 100644 test/run-drun/ok/blob-stabilization.drun-run.ok
 create mode 100644 test/run-drun/ok/blob-stabilization.tc.ok
 create mode 100644 test/run-drun/ok/blob-upgrade.drun-run.ok
 create mode 100644 test/run-drun/ok/blob-upgrade.tc.ok
 delete mode 100644 test/run-drun/ok/class-import.tc.ok
 create mode 100644 test/run-drun/ok/destabilization-crash.drun.ok
 create mode 100644 test/run-drun/ok/double-sharing-benchmark.drun-run.ok
 rename test/run-drun/ok/{empty-actor.drun-run.ok => empty-actor-classical.drun-run.ok} (100%)
 create mode 100644 test/run-drun/ok/empty-actor-enhanced.drun-run.ok
 create mode 100644 test/run-drun/ok/function-stabilization.drun.ok
 create mode 100644 test/run-drun/ok/hashBlob.drun-run.ok
 create mode 100644 test/run-drun/ok/hashBlob.run-ir.ok
 create mode 100644 test/run-drun/ok/hashBlob.run-low.ok
 create mode 100644 test/run-drun/ok/hashBlob.run.ok
 create mode 100644 test/run-drun/ok/incremental-actor-class-stabilization.drun-run.ok
 create mode 100644 test/run-drun/ok/incremental-stabilization.drun-run.ok
 create mode 100644 test/run-drun/ok/map-mixed-upgrades.drun.ok
 create mode 100644 test/run-drun/ok/map-stabilization.drun.ok
 create mode 100644 test/run-drun/ok/migrate-candid-sharing.drun.ok
 create mode 100644 test/run-drun/ok/migration-paths.drun.ok
 create mode 100644 test/run-drun/ok/more-function-stabilization.drun.ok
 create mode 100644 test/run-drun/ok/non-incremental-stabilization.drun-run.ok
 rename test/run-drun/ok/{rts-stats2.drun-run.ok => rts-stats2-classical.drun-run.ok} (100%)
 create mode 100644 test/run-drun/ok/rts-stats2-enhanced.drun-run.ok
 create mode 100644 test/run-drun/ok/stabilization-authorization.drun-run.ok
 create mode 100644 test/run-drun/ok/stabilization-instructions.drun-run.ok
 create mode 100644 test/run-drun/ok/stabilization-upgrade-hooks.drun.ok
 create mode 100644 test/run-drun/ok/stabilize-beyond-stable-limit.drun-run.ok
 create mode 100644 test/run-drun/ok/stabilize-beyond-stable-limit.tc.ok
 create mode 100644 test/run-drun/ok/stabilize-bignat-bigint.drun.ok
 create mode 100644 test/run-drun/ok/stabilize-bignums.drun-run.ok
 create mode 100644 test/run-drun/ok/stabilize-blob-iter.drun.ok
 create mode 100644 test/run-drun/ok/stabilize-boxed-numbers.drun-run.ok
 create mode 100644 test/run-drun/ok/stabilize-generics.drun.ok
 create mode 100644 test/run-drun/ok/stabilize-large-array.drun-run.ok
 create mode 100644 test/run-drun/ok/stabilize-mutable-array.drun.ok
 create mode 100644 test/run-drun/ok/stabilize-mutable-service.drun.ok
 create mode 100644 test/run-drun/ok/stabilize-mutable-variant.drun.ok
 create mode 100644 test/run-drun/ok/stabilize-mutable.drun.ok
 create mode 100644 test/run-drun/ok/stabilize-nat-to-int.drun.ok
 create mode 100644 test/run-drun/ok/stabilize-non-stable.drun.ok
 create mode 100644 test/run-drun/ok/stabilize-optional.drun.ok
 create mode 100644 test/run-drun/ok/stabilize-primitive-types.drun-run.ok
 create mode 100644 test/run-drun/ok/stabilize-recursive-type.drun.ok
 create mode 100644 test/run-drun/ok/stabilize-remove-add-fields.drun.ok
 create mode 100644 test/run-drun/ok/stabilize-service.drun.ok
 create mode 100644 test/run-drun/ok/stabilize-text-iter.drun.ok
 create mode 100644 test/run-drun/ok/stabilize-to-any.drun.ok
 create mode 100644 test/run-drun/ok/stabilize-variant.drun.ok
 create mode 100644 test/run-drun/ok/stable-regions-new-each-stabilization.drun-run.ok
 create mode 100644 test/run-drun/ok/stable-regions-stabilization.drun-run.ok
 create mode 100644 test/run-drun/ok/stable-regions-stabilization.tc.ok
 create mode 100644 test/run-drun/ok/stable-size-overflow.drun-run.ok
 create mode 100644 test/run-drun/ok/tuple-stabilization.drun.ok
 create mode 100644 test/run-drun/ok/upgrade-bignums.drun-run.ok
 rename test/run-drun/{rts-stats2.mo => rts-stats2-classical.mo} (96%)
 create mode 100644 test/run-drun/rts-stats2-enhanced.mo
 create mode 100644 test/run-drun/stabilization-authorization.mo
 create mode 100644 test/run-drun/stabilization-authorization/access-tester.mo
 create mode 100644 test/run-drun/stabilization-authorization/upgrade-target.mo
 create mode 100644 test/run-drun/stabilization-instructions.mo
 create mode 100644 test/run-drun/stabilization-upgrade-hooks.drun
 create mode 100644 test/run-drun/stabilization-upgrade-hooks/upgrade-hook.mo
 create mode 100644 test/run-drun/stabilization-upgrade-hooks/upgrade-hook0.mo
 create mode 100644 test/run-drun/stabilization-upgrade-hooks/upgrade-hook1.mo
 create mode 100644 test/run-drun/stabilization-upgrade-hooks/upgrade-hook2.mo
 create mode 100644 test/run-drun/stabilize-beyond-stable-limit.mo
 create mode 100644 test/run-drun/stabilize-bignat-bigint.drun
 create mode 100644 test/run-drun/stabilize-bignat-bigint/version0.mo
 create mode 100644 test/run-drun/stabilize-bignat-bigint/version1.mo
 create mode 100644 test/run-drun/stabilize-bignums.mo
 create mode 100644 test/run-drun/stabilize-blob-iter.drun
 create mode 100644 test/run-drun/stabilize-blob-iter/version0.mo
 create mode 100644 test/run-drun/stabilize-blob-iter/version1.mo
 create mode 100644 test/run-drun/stabilize-boxed-numbers.mo
 create mode 100644 test/run-drun/stabilize-generics.drun
 create mode 100644 test/run-drun/stabilize-generics/version0.mo
 create mode 100644 test/run-drun/stabilize-generics/version1.mo
 create mode 100644 test/run-drun/stabilize-generics/version2.mo
 create mode 100644 test/run-drun/stabilize-large-array.mo
 create mode 100644 test/run-drun/stabilize-mutable-array.drun
 create mode 100644 test/run-drun/stabilize-mutable-array/version0.mo
 create mode 100644 test/run-drun/stabilize-mutable-array/version1.mo
 create mode 100644 test/run-drun/stabilize-mutable-service.drun
 create mode 100644 test/run-drun/stabilize-mutable-service/original-service.mo
 create mode 100644 test/run-drun/stabilize-mutable-service/reduced-service.mo
 create mode 100644 test/run-drun/stabilize-mutable-service/version0.mo
 create mode 100644 test/run-drun/stabilize-mutable-service/version1.mo
 create mode 100644 test/run-drun/stabilize-mutable-variant.drun
 create mode 100644 test/run-drun/stabilize-mutable-variant/version0.mo
 create mode 100644 test/run-drun/stabilize-mutable-variant/version1.mo
 create mode 100644 test/run-drun/stabilize-mutable.drun
 create mode 100644 test/run-drun/stabilize-mutable/version0.mo
 create mode 100644 test/run-drun/stabilize-mutable/version1.mo
 create mode 100644 test/run-drun/stabilize-nat-to-int.drun
 create mode 100644 test/run-drun/stabilize-nat-to-int/version0.mo
 create mode 100644 test/run-drun/stabilize-nat-to-int/version1.mo
 create mode 100644 test/run-drun/stabilize-non-stable.drun
 create mode 100644 test/run-drun/stabilize-non-stable/version0.mo
 create mode 100644 test/run-drun/stabilize-non-stable/version1.mo
 create mode 100644 test/run-drun/stabilize-optional.drun
 create mode 100644 test/run-drun/stabilize-optional/version0.mo
 create mode 100644 test/run-drun/stabilize-optional/version1.mo
 create mode 100644 test/run-drun/stabilize-optional/version2.mo
 create mode 100644 test/run-drun/stabilize-primitive-types.mo
 create mode 100644 test/run-drun/stabilize-recursive-type.drun
 create mode 100644 test/run-drun/stabilize-recursive-type/version0.mo
 create mode 100644 test/run-drun/stabilize-recursive-type/version1.mo
 create mode 100644 test/run-drun/stabilize-remove-add-fields.drun
 create mode 100644 test/run-drun/stabilize-remove-add-fields/version0.mo
 create mode 100644 test/run-drun/stabilize-remove-add-fields/version1.mo
 create mode 100644 test/run-drun/stabilize-remove-add-fields/version2.mo
 create mode 100644 test/run-drun/stabilize-service.drun
 create mode 100644 test/run-drun/stabilize-service/original-service.mo
 create mode 100644 test/run-drun/stabilize-service/reduced-service.mo
 create mode 100644 test/run-drun/stabilize-service/version0.mo
 create mode 100644 test/run-drun/stabilize-service/version1.mo
 create mode 100644 test/run-drun/stabilize-text-iter.drun
 create mode 100644 test/run-drun/stabilize-text-iter/version0.mo
 create mode 100644 test/run-drun/stabilize-text-iter/version1.mo
 create mode 100644 test/run-drun/stabilize-to-any.drun
 create mode 100644 test/run-drun/stabilize-to-any/version0.mo
 create mode 100644 test/run-drun/stabilize-to-any/version1.mo
 create mode 100644 test/run-drun/stabilize-to-any/version2.mo
 create mode 100644 test/run-drun/stabilize-variant.drun
 create mode 100644 test/run-drun/stabilize-variant/version0.mo
 create mode 100644 test/run-drun/stabilize-variant/version1.mo
 create mode 100644 test/run-drun/stabilize-variant/version2.mo
 create mode 100644 test/run-drun/stable-regions-new-each-stabilization.mo
 create mode 100644 test/run-drun/stable-regions-stabilization.mo
 create mode 100644 test/run-drun/stable-size-overflow.mo
 create mode 100644 test/run-drun/tuple-stabilization.drun
 create mode 100644 test/run-drun/tuple-stabilization/version0.mo
 create mode 100644 test/run-drun/tuple-stabilization/version1.mo
 create mode 100644 test/run-drun/tuple-stabilization/version2.mo
 create mode 100644 test/run-drun/tuple-stabilization/version3.mo
 create mode 100644 test/run-drun/tuple-stabilization/version4.mo
 create mode 100644 test/run-drun/tuple-stabilization/version5.mo
 create mode 100644 test/run-drun/upgrade-bignums.mo
 create mode 100644 test/run/beyond-4GB.mo
 create mode 100644 test/run/compact-float.mo
 rename test/run/{empty-if.mo => empty-if-classical.mo} (88%)
 create mode 100644 test/run/empty-if-eop.mo
 rename test/run/{float-fmt.mo => float-fmt-classical.mo} (98%)
 create mode 100644 test/run/float-fmt-eop.mo
 delete mode 100644 test/run/if-swap.mo
 delete mode 100644 test/run/inc-oom.mo
 rename test/run/{issue1356.mo => issue1356-classical.mo} (98%)
 create mode 100644 test/run/issue1356-enhanced.mo
 create mode 100644 test/run/leb-random.mo
 create mode 100644 test/run/ok/compact-float.run-ir.ok
 create mode 100644 test/run/ok/compact-float.run-low.ok
 create mode 100644 test/run/ok/compact-float.run.ok
 create mode 100644 test/run/ok/compact-float.wasm-run.ok
 rename test/run/ok/{float-fmt.run-ir.ok => float-fmt-classical.run-ir.ok} (100%)
 rename test/run/ok/{float-fmt.run-low.ok => float-fmt-classical.run-low.ok} (100%)
 rename test/run/ok/{float-fmt.run.ok => float-fmt-classical.run.ok} (100%)
 rename test/run/ok/{float-fmt.wasm-run.ok => float-fmt-classical.wasm-run.ok} (100%)
 create mode 100644 test/run/ok/float-fmt-eop.run-ir.ok
 create mode 100644 test/run/ok/float-fmt-eop.run-low.ok
 create mode 100644 test/run/ok/float-fmt-eop.run.ok
 create mode 100644 test/run/ok/float-fmt-eop.wasm-run.ok
 delete mode 100644 test/run/ok/inc-oom.wasm-run.ok
 rename test/run/ok/{optimise-for-array.run-ir.ok => optimise-for-array-classical.run-ir.ok} (100%)
 rename test/run/ok/{optimise-for-array.run-low.ok => optimise-for-array-classical.run-low.ok} (100%)
 rename test/run/ok/{optimise-for-array.run.ok => optimise-for-array-classical.run.ok} (100%)
 create mode 100644 test/run/ok/optimise-for-array-classical.tc.ok
 rename test/run/ok/{optimise-for-array.wasm-run.ok => optimise-for-array-classical.wasm-run.ok} (100%)
 create mode 100644 test/run/ok/optimise-for-array-enhanced.run-ir.ok
 create mode 100644 test/run/ok/optimise-for-array-enhanced.run-low.ok
 create mode 100644 test/run/ok/optimise-for-array-enhanced.run.ok
 create mode 100644 test/run/ok/optimise-for-array-enhanced.tc.ok
 create mode 100644 test/run/ok/optimise-for-array-enhanced.wasm-run.ok
 delete mode 100644 test/run/ok/optimise-for-array.tc.ok
 create mode 100644 test/run/ok/stable-memory-beyond-4GB.tc.ok
 create mode 100644 test/run/ok/stable-memory-beyond-4GB.wasm-run.ok
 create mode 100644 test/run/ok/stable-region-beyond-4GB.tc.ok
 create mode 100644 test/run/ok/stable-region-beyond-4GB.wasm-run.ok
 rename test/run/ok/{words.run-ir.ok => words-classical.run-ir.ok} (100%)
 rename test/run/ok/{words.run-low.ok => words-classical.run-low.ok} (100%)
 rename test/run/ok/{words.run.ok => words-classical.run.ok} (100%)
 rename test/run/ok/{words.wasm-run.ok => words-classical.wasm-run.ok} (100%)
 create mode 100644 test/run/ok/words-enhanced.run-ir.ok
 create mode 100644 test/run/ok/words-enhanced.run-low.ok
 create mode 100644 test/run/ok/words-enhanced.run.ok
 create mode 100644 test/run/ok/words-enhanced.wasm-run.ok
 rename test/run/{optimise-for-array.mo => optimise-for-array-classical.mo} (90%)
 create mode 100644 test/run/optimise-for-array-enhanced.mo
 create mode 100644 test/run/stable-memory-beyond-4GB.mo
 create mode 100644 test/run/stable-region-beyond-4GB.mo
 rename test/run/{words.mo => words-classical.mo} (99%)
 create mode 100644 test/run/words-enhanced.mo
 rename test/trap/{divInt32.mo => divInt32-classical.mo} (72%)
 create mode 100644 test/trap/divInt32-enhanced.mo
 create mode 100644 test/trap/ok/divInt32-classical.run-ir.ok
 create mode 100644 test/trap/ok/divInt32-classical.run-low.ok
 create mode 100644 test/trap/ok/divInt32-classical.run.ok
 rename test/trap/ok/{divInt32.run.ret.ok => divInt32-classical.run.ret.ok} (100%)
 rename test/trap/ok/{divInt32.wasm-run.ok => divInt32-classical.wasm-run.ok} (72%)
 rename test/{run/ok/inc-oom.wasm-run.ret.ok => trap/ok/divInt32-classical.wasm-run.ret.ok} (100%)
 create mode 100644 test/trap/ok/divInt32-enhanced.run-ir.ok
 create mode 100644 test/trap/ok/divInt32-enhanced.run-low.ok
 create mode 100644 test/trap/ok/divInt32-enhanced.run.ok
 create mode 100644 test/trap/ok/divInt32-enhanced.run.ret.ok
 create mode 100644 test/trap/ok/divInt32-enhanced.wasm-run.ok
 rename test/trap/ok/{divInt32.wasm-run.ret.ok => divInt32-enhanced.wasm-run.ret.ok} (100%)
 delete mode 100644 test/trap/ok/divInt32.run-ir.ok
 delete mode 100644 test/trap/ok/divInt32.run-low.ok
 delete mode 100644 test/trap/ok/divInt32.run.ok

diff --git a/bin/wrapper.sh b/bin/wrapper.sh
index ffb6e673478..5131878d71d 100755
--- a/bin/wrapper.sh
+++ b/bin/wrapper.sh
@@ -18,7 +18,7 @@ declare -A envs # list of expected environment variables with paths to products
 # Define build products here
 real[moc]=src/moc
 hint[moc]="make -C $rel_root/src moc"
-envs[moc]="MOC_RELEASE_RTS MOC_DEBUG_RTS"
+envs[moc]="MOC_NON_INCREMENTAL_RELEASE_RTS MOC_NON_INCREMENTAL_DEBUG_RTS MOC_INCREMENTAL_RELEASE_RTS MOC_INCREMENTAL_DEBUG_RTS MOC_EOP_RELEASE_RTS MOC_EOP_DEBUG_RTS"
 real[mo-ld]=src/mo-ld
 hint[mo-ld]="make -C $rel_root/src mo-ld"
 real[mo-doc]=src/mo-doc
@@ -32,8 +32,12 @@ hint[candid-tests]="make -C $rel_root/src candid-tests"
 
 rts_hint="make -C $rel_root/rts"
 
-real[MOC_RELEASE_RTS]=rts/mo-rts.wasm
-real[MOC_DEBUG_RTS]=rts/mo-rts-debug.wasm
+real[MOC_NON_INCREMENTAL_RELEASE_RTS]=rts/mo-rts-non-incremental.wasm
+real[MOC_NON_INCREMENTAL_DEBUG_RTS]=rts/mo-rts-non-incremental-debug.wasm
+real[MOC_INCREMENTAL_RELEASE_RTS]=rts/mo-rts-incremental.wasm
+real[MOC_INCREMENTAL_DEBUG_RTS]=rts/mo-rts-incremental-debug.wasm
+real[MOC_EOP_RELEASE_RTS]=rts/mo-rts-eop.wasm
+real[MOC_EOP_DEBUG_RTS]=rts/mo-rts-eop-debug.wasm
 
 for var in ${envs[moc]}; do
   hint[$var]=$rts_hint
diff --git a/default.nix b/default.nix
index b59f1cdfea9..a582d9adcd1 100644
--- a/default.nix
+++ b/default.nix
@@ -20,6 +20,10 @@ let ic-ref-run =
       cp ${ic-hs-pkgs.ic-hs}/bin/ic-ref-run $out/bin
   ''; in
 
+let
+  nixos-unstable = import nixpkgs.sources.nixpkgs-unstable {};
+in
+
 let haskellPackages = nixpkgs.haskellPackages.override {
       overrides = import nix/haskell-packages.nix nixpkgs subpath;
     }; in
@@ -35,6 +39,7 @@ let
     wasmtime
     rust-bindgen
     python3
+    nixos-unstable.emscripten
   ] ++ pkgs.lib.optional pkgs.stdenv.isDarwin [
     libiconv
   ];
@@ -193,7 +198,7 @@ rec {
         name = "motoko-rts-deps";
         src = subpath ./rts;
         sourceRoot = "rts/motoko-rts-tests";
-        sha256 = "sha256-jN5nx5UNBHlYKnC0kk90h6mWPUNrqPS7Wln2TixbGgA=";
+        sha256 = "sha256-prLZVOWV3BFb8/nKHyqZw8neJyBu1gs5d0D56DsDV2o=";
         copyLockfile = true;
       };
 
@@ -241,6 +246,7 @@ rec {
           "directory" = "$(stripHash ${allDeps})"
         __END__
 
+        
         ${llvmEnv}
         export TOMMATHSRC=${nixpkgs.sources.libtommath}
         export MUSLSRC=${nixpkgs.sources.musl-wasi}/libc-top-half/musl
@@ -255,8 +261,12 @@ rec {
 
       installPhase = ''
         mkdir -p $out/rts
-        cp mo-rts.wasm $out/rts
-        cp mo-rts-debug.wasm $out/rts
+        cp mo-rts-non-incremental.wasm $out/rts
+        cp mo-rts-non-incremental-debug.wasm $out/rts
+        cp mo-rts-incremental.wasm $out/rts
+        cp mo-rts-incremental-debug.wasm $out/rts
+        cp mo-rts-eop.wasm $out/rts
+        cp mo-rts-eop-debug.wasm $out/rts
       '';
 
       # This needs to be self-contained. Remove mention of nix path in debug
@@ -266,7 +276,17 @@ rec {
           -t ${nixpkgs.rustc-nightly} \
           -t ${rtsDeps} \
           -t ${rustStdDeps} \
-          $out/rts/mo-rts.wasm $out/rts/mo-rts-debug.wasm
+          $out/rts/mo-rts-non-incremental.wasm $out/rts/mo-rts-non-incremental-debug.wasm
+        remove-references-to \
+          -t ${nixpkgs.rustc-nightly} \
+          -t ${rtsDeps} \
+          -t ${rustStdDeps} \
+          $out/rts/mo-rts-incremental.wasm $out/rts/mo-rts-incremental-debug.wasm
+        remove-references-to \
+          -t ${nixpkgs.rustc-nightly} \
+          -t ${rtsDeps} \
+          -t ${rustStdDeps} \
+          $out/rts/mo-rts-eop.wasm $out/rts/mo-rts-eop-debug.wasm
       '';
 
       allowedRequisites = [];
@@ -357,6 +377,31 @@ rec {
           EXTRA_MOC_ARGS = "--sanity-checks";
       };
 
+    snty_compacting_gc_subdir = dir: deps:
+      (test_subdir dir deps).overrideAttrs {
+          EXTRA_MOC_ARGS = "--sanity-checks --compacting-gc";
+      };
+
+    snty_generational_gc_subdir = dir: deps:
+      (test_subdir dir deps).overrideAttrs {
+          EXTRA_MOC_ARGS = "--sanity-checks --generational-gc";
+      };
+
+    snty_incremental_gc_subdir = dir: deps:
+      (test_subdir dir deps).overrideAttrs {
+          EXTRA_MOC_ARGS = "--sanity-checks --incremental-gc";
+      };
+
+    enhanced_orthogonal_persistence_subdir = dir: deps:
+      (test_subdir dir deps).overrideAttrs {
+          EXTRA_MOC_ARGS = "--enhanced-orthogonal-persistence";
+      };
+
+    snty_enhanced_orthogonal_persistence_subdir = dir: deps:
+      (test_subdir dir deps).overrideAttrs {
+          EXTRA_MOC_ARGS = "--sanity-checks --enhanced-orthogonal-persistence";
+      };
+
     perf_subdir = dir: deps:
       (test_subdir dir deps).overrideAttrs (args: {
         checkPhase = ''
@@ -415,7 +460,7 @@ rec {
       '';
     };
 
-    # wasm-profiler is not compatible with passive data segments
+    # wasm-profiler is not compatible with passive data segments and memory64
     # profiling-graphs = testDerivation {
     #  src = test_src "perf";
     #  buildInputs =
@@ -468,20 +513,32 @@ rec {
   in fix_names ({
       run        = test_subdir "run"        [ moc ] ;
       run-dbg    = snty_subdir "run"        [ moc ] ;
+      run-eop-release = enhanced_orthogonal_persistence_subdir "run" [ moc ];
+      run-eop-debug = snty_enhanced_orthogonal_persistence_subdir "run" [ moc ];
       # ic-ref-run = test_subdir "run-drun"   [ moc ic-ref-run ];
       drun       = test_subdir "run-drun"   [ moc nixpkgs.drun ];
       drun-dbg   = snty_subdir "run-drun"   [ moc nixpkgs.drun ];
+      drun-compacting-gc = snty_compacting_gc_subdir "run-drun" [ moc nixpkgs.drun ] ;
+      drun-generational-gc = snty_generational_gc_subdir "run-drun" [ moc nixpkgs.drun ] ;
+      drun-incremental-gc = snty_incremental_gc_subdir "run-drun" [ moc nixpkgs.drun ] ;
+      drun-eop-release = enhanced_orthogonal_persistence_subdir "run-drun" [ moc nixpkgs.drun ] ;
+      drun-eop-debug = snty_enhanced_orthogonal_persistence_subdir "run-drun" [ moc nixpkgs.drun ] ;
       fail       = test_subdir "fail"       [ moc ];
+      fail-eop   = enhanced_orthogonal_persistence_subdir "fail"       [ moc ];
       repl       = test_subdir "repl"       [ moc ];
+      repl-eop   = enhanced_orthogonal_persistence_subdir "repl"       [ moc ];
       ld         = test_subdir "ld"         ([ mo-ld ] ++ ldTestDeps);
+      ld-eop     = enhanced_orthogonal_persistence_subdir "ld" ([ mo-ld ] ++ ldTestDeps);
       idl        = test_subdir "idl"        [ didc ];
       mo-idl     = test_subdir "mo-idl"     [ moc didc ];
+      mo-idl-eop = enhanced_orthogonal_persistence_subdir "mo-idl" [ moc didc ];
       trap       = test_subdir "trap"       [ moc ];
+      trap-eop   = enhanced_orthogonal_persistence_subdir "trap" [ moc ];
       run-deser  = test_subdir "run-deser"  [ deser ];
       perf       = perf_subdir "perf"       [ moc nixpkgs.drun ];
       bench      = perf_subdir "bench"      [ moc nixpkgs.drun ic-wasm ];
       viper      = test_subdir "viper"      [ moc nixpkgs.which nixpkgs.openjdk nixpkgs.z3_4_12 ];
-      # TODO: profiling-graph is excluded because the underlying partity_wasm is deprecated and does not support passive data segments.
+      # TODO: profiling-graph is excluded because the underlying partity_wasm is deprecated and does not support passive data segments and memory64.
       inherit qc lsp unit candid coverage;
     }) // { recurseForDerivations = true; };
 
@@ -526,7 +583,7 @@ rec {
         doInstallCheck = true;
         test = ./test + "/test-${n}.js";
         installCheckPhase = ''
-          NODE_PATH=$out/bin node $test
+          NODE_PATH=$out/bin node --experimental-wasm-memory64 $test
         '';
       };
     in
@@ -749,8 +806,9 @@ EOF
       check-grammar
       check-error-codes
     ] ++
-    builtins.attrValues tests ++
-    builtins.attrValues js;
+    builtins.attrValues tests
+    ++ builtins.attrValues js
+    ;
   };
 
   viperServer = nixpkgs.fetchurl {
diff --git a/design/Custom-Sections.md b/design/Custom-Sections.md
index 35f70d7cb68..fe0d8cba31e 100644
--- a/design/Custom-Sections.md
+++ b/design/Custom-Sections.md
@@ -34,3 +34,7 @@ let hash : string -> int32 = fun s ->
       (Lib.String.explode s)
   )
 ```
+
+Motoko generates an additional `"enhanced-orthogonal-persistence"` private custom section to
+mark Motoko Wasm binaries that rely on IC's support to retain the main Wasm memory on an upgrade, 
+cf. [Orthogonal Persistence](OrthogonalPersistence.md).
diff --git a/design/DFX-Interface.md b/design/DFX-Interface.md
index 5370bcba09c..8e6c565890a 100644
--- a/design/DFX-Interface.md
+++ b/design/DFX-Interface.md
@@ -118,6 +118,10 @@ used only in very specific cases.
 The above metadata is stored in the Wasm module, and is only accessible by the controllers of the canister, unless the
 metadata name is specified in the `--public-metadata` flag.
 
+Moreover, the compiler generates a special marker custom section `"enhanced-orthogonal-persistence"` if the new orthogonal 
+persistence support is enabled, see [Orthogonal Persistence](OrthogonalPersistence.md). This section is always private and
+always emited independent of the compiler flags `--public-metadata` or `--public-metadata`.
+
 Checking stable type compatibility
 ----------------------------------
 
@@ -130,6 +134,10 @@ a type safe way without unintentional data loss.
 
 If the check succeeds, nothing will be printed. 
 If the check fails, the error message will be printed in stderr and the command returns with exit code 1.
+The check can also emit warning messages, e.g. if stable variables are dropped.
+
+With [enhanced orthogonal persistence](OrthogonalPersistence.md), the stable compatibility is also integrated in the runtime
+system, to atomically guarantee memory compatibility during an upgrade.
 
 Invoking the IDE
 ----------------
diff --git a/design/GraphCopyStabilization.md b/design/GraphCopyStabilization.md
new file mode 100644
index 00000000000..aa125afc896
--- /dev/null
+++ b/design/GraphCopyStabilization.md
@@ -0,0 +1,132 @@
+# Graph-Copy-Based Stabilization
+
+This is part of the enhanced orthogonal persistence support, see [Orthogonal Persistence](OrthogonalPersistence.md).
+
+## Purpose
+This allows future potentially radical changes of the persistent memory layout, such as introducing a new GC, rearranging persistent metadata, or specializing arrays for small element types etc. 
+This also relies on precise value tagging to allow more advanced changes that require value metadata, e.g. specializing arrays for small value element types or even downgrading to 32-bit heap layouts (provided that the amount of live data fits into a 32-bit memory).
+
+## Design
+Graph copy of sub-graph of stable objects from main memory to stable memory and vice versa on upgrades.
+
+## Properties
+* Preserve sharing for all objects like in the heap.
+* Allow the serialization format to be independent of the main memory layout.
+* Limit the additional main memory needed during serialization and deserialization.
+* Avoid deep call stack recursion (stack overflow).
+* Allows arbitrarily long large stabilization/destabilization due to incremental mechanism (see below).
+
+## Memory Compatibility Check
+Apply a memory compatibility check analogous to the enhanced orthogonal persistence, since the upgrade compatibility of the graph copy is not identical to the Candid subtype relation.
+
+## Incremental Upgrade
+Supporting arbitrarily large upgrades beyond the instruction limit:
+* Splitting the stabilization/destabilization in multiple asynchronous messages.
+* Limiting the stabilization work units to fit the update or upgrade messages.
+* Blocking other messages during the explicit incremental stabilization.
+* Restricting the upgrade functionality to the canister owner and controllers.
+* Stopping the GC during the explicit incremental upgrade process.
+
+**Note**: Graph copying needs to be explicitly initiated as the usual upgrade engages enhanced orthogonal persistence, simply retaining main memory with compatibility check.
+
+### Usage
+When upgrading to a Motoko version that is not compatible with the current enhanced orthogonal persistence:
+
+1. Initiate the explicit stabilization before the upgrade:
+    
+```
+dfx canister call CANISTER_ID __motoko_stabilize_before_upgrade "()"
+```
+
+* An assertion first checks that the caller is the canister owner or a canister controller.
+* All other messages to the canister will be blocked until the upgrade has been successfully completed.
+* The GC is stopped.
+* If defined, the actor's pre-upgrade function is called before the explicit stabilization.
+* The stabilzation runs in possibly multiple asynchronous messages, each with a limited number of instructions.
+
+2. Run the actual upgrade:
+
+```
+dfx deploy CANISTER_ID
+```
+
+* Completes the explicit stabilization if not yet done before this call.
+* Perform the actual upgrade of the canister on the IC.
+* Detects that graph-copying is in use.
+* Clears the heap if enhanced orthogonal persistence is active.
+* Start the destabilization with a limited number of steps to fit into the upgrade message.
+* If destabilization cannot be completed, the canister does not start the GC and does not accept messages except step 3.
+
+3. Complete the explicit destabilization after the upgrade:
+
+```
+dfx canister call CANISTER_ID __motoko_destabilize_after_upgrade "()"
+```
+
+* An assertion checks that the caller is the canister owner or a canister controller.
+* All other messages remain blocked until the successful completion of the destabilization.
+* The destabilzation runs in possibly multiple asynchronous messages, each with a limited number of instructions.
+* If defined, the actor's post-upgrade function is called at the end of the explicit destabilization.
+* The GC is restarted.
+
+### Remarks
+* When receiving the `dfx` error "The request timed out." during explicit stabilization, upgrade, or destabilization, one can simply repeat the call until it completes.
+* Steps 3 (explicit destabilization) may not be needed if the corresponding operation fits into the upgrade message.
+* Stabilization and destabilization steps are limited to the increment limits:
+
+    Operation | Message Type | IC Instruction Limit | **Increment Limit**
+    ----------|--------------|----------------------|--------------------
+    **Explicit (de)stabilization step** | Update | 20e9 | **16e9**
+    **Actual upgrade** | Upgrade | 200e9 | **160e9**
+
+* The graph copy steps also limit the amount of processed stable data (read or write), in order not to exceed the 
+IC's stable memory access limits.
+
+    Operation | Message Type | IC Stable Access Limit | **Increment Limit**
+    ----------|--------------|----------------------|--------------------
+    **Explicit (de)stabilization step** | Update | 2 GB | **1 GB**
+    **Actual upgrade** | Upgrade | 8 GB | **6 GB**
+
+## Graph-Copy Algorithm
+Applying Cheney’s algorithm [1, 2] for both serialization and deserialization:
+
+### Serialization
+* Cheney’s algorithm using main memory as from-space and stable memory as to-space: 
+* Focusing on stable variables as root (sub-graph of stable objects).
+* The target pointers and Cheney’s forwarding pointers denote the (skewed) offsets in stable memory.
+* Using streaming reads for the `scan`-pointer and streaming writes for the `free`-pointer in stable memory.
+
+### Deserialization
+* Cheney’s algorithm using stable memory as from-space and main memory as to-space: 
+* Starting with the stable root created during the serialization process.
+* A scan stack is used in the main memory to remember the deserialized objects for later scanning.
+* Objects are allocated in main memory using the default allocator.
+* Using random read/write access on the stable memory.
+
+## Stable Format
+For a long-term perspective, the object layout of the serialized data in the stable memory is fixed and independent of the main memory layout.
+* Pointers are represented in 64-bit like main memory in enhanced orthogonal persistence.
+* The Brooks forwarding pointer used by the incremental GC is omitted.
+* The pointers encode skewed stable memory offsets to the corresponding target objects.
+* References to the null objects are encoded by a defined null sentinel value.
+* `BigInt` are explicitly serialized in a defined portable little endian representation, without that the serialization or deserialization allocates temporary objects.
+The format is also versioned to allow future refinements of the graph copy algorithm.
+
+## Specific Aspects
+* Field hashes in objects are serialized in a blob. On deserialization, the hash blob is allocated in the dynamic heap. Same-typed objects that have been created by the same program version share the same hash blob.
+* Stable records can dynamically contain non-stable fields due to structural sub-typing. A dummy value can be serialized for such fields as a new program version can no longer access this field through the stable types.
+* For backwards compatibility, old Candid destabilization is still supported when upgrading from a program that used older compiler version.
+* Incremental GC: Serialization needs to consider Brooks forwarding pointers (not to be confused with the Cheney's forwarding information), while deserialization can deal with partitioned heap that can have internal fragmentation (free space at partition ends).
+* The partitioned heap prevents linear scanning of the heap, especially in the presence of large objects that can be placed at a higher partition than subsequently allocated normal-sized objects. For this reason, a scan stack is allocated in the main memory, remembering the deserialized objects that still need to be scanned. With this, the deserialization does not need to make any assumptions of the heap structure (e.g. monotonically increasing allocations, free space markers, empty heap on deserialization start etc.).
+* If actor fields are promoted to the `Any` type in a new program version, their content is released in that variable to allow memory reclamation.
+* Both stabilization and destabilization read and write data linearly, which is beneficial for guarding a work set limit (number of accessed pages) per IC message. Destabilization is also linear because it deserializes objects in the same order back as they have been serialized.
+
+## Open Aspects
+* Unused fields in stable records that are no longer declared in a new program versions should be removed. This could be done during garbage collection, when objects are moved/evacuated. This scenario equally applies to enhanced orthogonal persistence.
+* The scan stack used during destabilization involves dynamic allocations.
+
+## References
+
+[1] C. J. Cheney. A Non-Recursive List Compacting Algorithm. Communications of the ACM, 13(11):677-8, November 1970.
+
+[2] R. Jones and R. Lins. Garbage Collection: Algorithms for Automatic Dynamic Memory Management. Wiley 2003. Algorithm 6.1: Cheney's algorithm, page 123.
diff --git a/design/Implementation.md b/design/Implementation.md
index be892d3cadc..9d73ed44efa 100644
--- a/design/Implementation.md
+++ b/design/Implementation.md
@@ -9,25 +9,29 @@
 
 ## Heap
 
-* Uniform representation with 32 bit word size.
+* Uniform representation with a defined word size. 
+For [enhanced orthogonal persistence](OrthogonalPersistence.md), 64-bit words are used, while for classical persistence, the word size is 32-bit.
 
-* Use pointer tagging in LSB;.
-  - 0 for pointers, 1 for scalars.
-  - Scalars are real value shifted left by 1, lowest bit set.
-
-* Q: Allocation and GC strategies?
+* Use pointer tagging in the LSB:
+  - 1 for pointers, 0 for scalars.
+  - Scalars are real value shifted left by 1, lowest bit clear.
+  For [enhanced orthogonal persistence](OrthogonalPersistence.md), the types of scalars are additionally tagged.
+  
+* Garbage collected.
 
 
 ## Primitive types
 
 * Nat and Int compile to heap-allocated big nums; unboxed for small numbers `<= 31` bit.
 
-* Nat8/16 compile to unboxed scalars; Nat32/64 are boxed.
+* Nat8/16 compile to unboxed scalars; 
+  On a 32-bit heap, Nat32/64 are boxed. 
+  On a 64-bit heap, only Nat64 is boxed, while Nat32 remains unboxed.
   - May unbox locally.
 
 * Characters are scalars (unicode code points).
 
-* Text is heap-allocated.
+* Text is heap-allocated. Using ropes for concatenations.
 
 
 ## Tuples
@@ -103,6 +107,11 @@ TODO
 
 TODO
 
+## Persistence
+
+Different * [persistence modes](OrthogonalPersistence.md):
+* [Enhanced orthogonal persistence](OrthogonalPersistence.md).
+* [Classical persistence](OldStableMemory.md).
 
 # Hypervisor Extensions needed
 
diff --git a/design/Memory.md b/design/Memory.md
index 7f628ad9a11..ab245410cf4 100644
--- a/design/Memory.md
+++ b/design/Memory.md
@@ -29,8 +29,11 @@ In the future (with the GC proposal), Wasm will have a 4th form of mutable state
 
 The Heap is *not* an explicit entity that can be im/exported, only individual references to structures on the heap can be passed.
 
-Note: It is highly likely that most languages implemented on Wasm will eventually use Wasm GC.
-Various implementers are currently waiting for it to become available before they start porting their language to Wasm.
+Note: It is highly likely that several managed languages implemented on Wasm will eventually use Wasm GC.
+However, in our case, it would require snapshotting the Wasm managed heap which is currently not possible for `wasmtime`.
+Moreover, the GC implemented on the managed heap does probably not fit the IC with hard instruction limits. 
+A fully incremental GC would be needed, which is currently not implemented in any Wasm engine (often only using reference counting or a GC that has worst-case unbounded pauses).
+Conceptually, enhanced orthogonal persistence could be implemented on Wasm GC.
 
 ### Internet Computer (IC)
 
@@ -48,19 +51,16 @@ All references are *sharable*, i.e., can be passed between actors as message arg
 Other than actors, all reference types must be pure (immutable and without identity) to prevent shared state and allow transparent copying by the implementation.
 Element buffers can encode arbitrary object trees.
 
-Once Wasm GC is available, some of these types (esp. buffers) could be replaced by proper Wasm types.
-
-
-## Language Implementation
+## Language Implementation Rationales
 
 ### Representing Data Structures
 
 There are 3 possible ways of representing structured data in Wasm/IC.
 
-#### Using Wasm Memory
+#### Using Wasm Memory <- Chosen Design
 
-All data structures are laid out and managed in Memory by the compiler and the language runtime.
-References are stored via indirections through a Table.
+All data structures are laid out and managed in Wasm memory by the compiler and the runtime system.
+Function references are stored via indirections through a Wasm table.
 
    Pros:
    1. local data access maximally efficient
@@ -69,7 +69,7 @@ References are stored via indirections through a Table.
    Cons:
    1. message arguments require de/serialisation into IC buffers on both ends (in addition to the de/serialisation steps already performed by IC)
    2. each actor must ship its own instance of a GC (for both memory and table) and de/serialisation code
-   3. all references require an indirection
+   3. all function references require an indirection
    4. more implementation effort
 
 #### Using IC API
@@ -102,88 +102,8 @@ All data structures are represented as Wasm GCed objects.
    1. Wasm GC is 1-2 years out
    2. unclear how to implement transparent persistence (see below)
 
-
 ## Persistence
 
-### Persistence models
-
-There are at least 3 general models for providing persistence.
-
-#### *Explicit* persistence
-
-IC API provides explicit system calls to manage persistent data.
-Wasm state is volatile; each message received runs in a fresh instance of the actor's module.
-
-   Pros:
-   1. easy and efficient to implement
-   2. apps have maximal control over persistent data and its layout
-
-   Cons:
-   1. bifurcation of state space
-   2. programs need to load/store and de/serialise persistent data to/from local state
-
-#### *Transparent* persistence
-
-All Wasm state is implicitly made persistent.
-Conceptually, each message received runs in the same instance of the actor's module.
-
-   Pros:
-   1. "perfect" model of infinitely running program
-   2. programmers need to "think" less
-
-   Cons:
-   1. hard to implement efficiently without knowing neither language nor application
-   2. can easily lead to space leaks or inefficiencies if programmers aren't careful
-
-#### *Hybrid* persistence
-Wasm state entities can be marked as persistent selectively.
-Conceptually, each message received runs in the same instance of the actor's module,
-but Wasm is extended with some notion of volatile state and reinitialisation.
-
-   Pros:
-   1. compromise between other two models
-
-   Cons:
-   1. compromise between other two models
-   2. creates dangling references between bifurcated state parts
-   3. incoherent with Wasm semantics (segments, start function)
-
-### Implementing Transparent persistence
-
-#### *High-level* implementation of persistence
-
-Hypervisor walks data graph (wherever it lives), turns it into merkle tree.
-
-   Pros:
-   1. agnostic to implementation details of the engine
-   2. agnostic to GC (or subsumes GC)
-
-   Cons:
-   1. requires knowledge of and access to data graph
-   2. deep mutations result in deep changes in merkle tree (mutation cost is logarithmic in depth)
-   3. unclear how to detect changes efficiently
-
-#### *Low-level* implementation of persistence
-
-Hypervisor provides memory to Wasm engine, detects dirty pages; could be memory-mapped files.
-
-   Pros:
-   1. agnostic to language and data graph
-   2. fast when mutation patterns have good locality
-   3. can potentially offload much of the implementation to existing hardware/OS/library mechanisms
-
-   Cons:
-   1. bad interaction with language-internal GC (mutates large portions of the memory at once)
-   2. does not extend to tables (contain position-dependent physical pointers)
-   3. no obvious migration path to Wasm GC
-   4. dependent on VM specifics (and internals?)
-
-#### *Selectable* implementation of persistence
-
-Provide both previous options, possibly in a mutually exclusive fashion.
-
-   Pros:
-   1. choice for implementers
-
-   Cons:
-   1. maximal complexity for platform
+Different * [persistence modes](OrthogonalPersistence.md):
+* [Enhanced orthogonal persistence](OrthogonalPersistence.md).
+* [Classical persistence](OldStableMemory.md).
diff --git a/design/OldStableMemory.md b/design/OldStableMemory.md
index 322543e8777..7267b4e2b45 100644
--- a/design/OldStableMemory.md
+++ b/design/OldStableMemory.md
@@ -124,10 +124,10 @@ module StableMemory {
 (I think the compiler will still optimize these nested calls to known
 function calls, but it would be worth checking).
 
-# Maintaining existing Stable Variables.
+# Maintaining existing Stable Variables (Legacy Persistence).
 
-Stable memory is currently hidden behind the abstraction of stable
-variables, which we will still need to maintain. The current
+In classical persistence, stable memory is hidden behind the abstraction of stable
+variables, which we will still need to maintain. This old
 implementation of stable variables stores all variables as a
 Candidish record of _stable_ fields, starting at stable memory address 0 with
 initial word encoding size (in bytes?) followed by contents.
@@ -170,6 +170,9 @@ and other metadata (so that initial reads after growing beyond page `size`  alwa
 This scheme avoids relocating most of StableMem and is constant time when
 there are no stable variables.
 
+[Enhanced orthogonal persistence](OrthogonalPersistence.md) introduces a new peristence implementation.
+The old mechanism is only supported for backwards compatibility.
+
 # Details:
 
 Stable memory layout (during execution):
diff --git a/design/OrthogonalPersistence.md b/design/OrthogonalPersistence.md
index 3551af8469c..e1b971fffdb 100644
--- a/design/OrthogonalPersistence.md
+++ b/design/OrthogonalPersistence.md
@@ -1,29 +1,33 @@
-# Orthogonal Persistence (Stable Heap)
 
-This realizes the vision of keeping the canister main memory persistent even across upgrades and thus allows scalable upgrades.
-Canister upgrades do no longer involve serialization and deserialization to and from secondary stable memory.
+# Enhanced Orthogonal Persistence
 
-## Purpose
-* **Instantenous upgrades**: New program versions simply resume on the existing main memory and have access to the memory-compatible data.
-* **Scalable upgrades**: The upgrade mechanism scales with larger heaps and in contrast to serialization, does not hit IC instruction limits.
+This implements the vision of **enhanced orthogonal persistence** in Motoko that combines:
+* **Stable heap**: Persisting the program main memory across canister upgrades.
+* **64-bit heap**: Extending the main memory to 64-bit for large-scaled persistence.
 
-## Broader Vision
-In the longer term, this approach aims to enable **true orthogonal persistence** that is simple, flexible, efficient, and scalable.
-While this version implements the runtime support for 32-bit memory, this could be leveraged to 64-bit persistent main memory in future.
-As a result, the use of secondary storage (explicit stable memory, dedicated stable data structures, DB-like storage abstractions) will no longer be necessary: 
-Motoko developers could directly work on their normal object-oriented program structures that are automatically persisted and retained across program version changes.
-With 64-bit main memory, large-scaled orthogonal persistence would be enabled, supported by the incremental GC that is designed to also scale in 64-bit.
+As a result, the use of secondary storage (explicit stable memory, dedicated stable data structures, DB-like storage abstractions) will no longer be necessary: Motoko developers can directly work on their normal object-oriented program structures that are automatically persisted and retained across program version changes.
+
+## Advantages
+Compared to the existing orthogonal persistence in Motoko, this design offers:
+* **Performance**: New program versions directly resume from the existing main memory and have access to the memory-compatible data.
+* **Scalability**: The upgrade mechanism scales with larger heaps and in contrast to serialization, does not hit IC instruction limits.
+
+Compared to the explicit use of stable memory, this design improves:
+* **Simplicity**: Developers do not need to deal with explicit stable memory.
+* **Performance**: No copying to and from the separate stable memory is necessary.
 
 ## Design
-The stable heap is based on the following main properties:
+The enhanced orthogonal persistence is based on the following main properties:
 * Extension of the IC to retain main memory on upgrades.
+* Supporting 64-bit main memory on the IC.
 * A long-term memory layout that is invariant to new compiled program versions.
 * A fast memory compatibility check performed on each canister upgrade.
 * Incremental garbage collection using a partitioned heap.
 
-### IC Extension
-As a prerequisite for the stable heap support, the IC runtime support has to be extended in order not to erase the main memory on upgrades.
-This is realized in a specific IC PR (https://github.com/luc-blaeser/ic/tree/luc/stable-heap-on-release) that retains the main memory even on upgrades, similar to normal canister message execution. 
+### Integration with Classical Persistence
+Enhanced orthogonal persistence is offered for **beta testing** via the compiler flag `--enhanced-orthogonal-persistence`.
+Classical persistence with 32-bit main memory and Candid stabilization currently remains the default mode.
+See `design/PersistenceModes.md` for more information.
 
 ### Memory Layout
 In a co-design between the compiler and the runtime system, the main memory is arranged in the following structure, invariant of the compiled program version:
@@ -34,6 +38,7 @@ In a co-design between the compiler and the runtime system, the main memory is a
 
 ### Persistent Metadata
 The persistent metadata describes all anchor information for the program to resume after an upgrade. 
+
 More specifically, it comprises:
 * A stable heap version that allows evolving the persistent memory layout in the future.
 * The stable subset of the main actor, containing all stable variables declared in the main actor.
@@ -42,9 +47,9 @@ More specifically, it comprises:
 * A reserve for future metadata extensions.
 
 ### Compatibility Check
-Upgrades are only permitted if the new program version is compatible to the old version, such that the runtime system guarantees a compatible memory structure.
+Upgrades are only permitted if the new program version is compatible with the old version, such that the runtime system guarantees a compatible memory structure.
 
-Compatible changes for immutable types are equivalent to the allowed Motoko subtype relation, e.g.
+Compatible changes for immutable types are largely analogous to the allowed Motoko subtype relation, e.g.
 * Adding or removing actor fields.
 * Removing object fields.
 * Adding variant fields.
@@ -65,10 +70,9 @@ This compatibility check serves as an additional safety measure on top of the DF
 ### Garbage Collection
 The implementation focuses on the incremental GC and abandons the other GCs because the GCs use different memory layouts. For example, the incremental GC uses a partitioned heap with objects carrying a forwarding pointer.
 
-The incremental GC is chosen because it is designed to scale on large heaps and the stable heap design also aims to increase scalability. Moreover, it is suited to scale on 64-bit memory in future.
+The incremental GC is chosen because it is designed to scale on large heaps and the stable heap design also aims to increase scalability.
 
-The garbage collection state needs to be persisted and retained across upgrades. 
-This is because the GC may not yet be completed at the time of an upgrade, such that object forwarding is still in use. The partition table is stored as part of the GC state.
+The garbage collection state needs to be persisted and retained across upgrades. This is because the GC may not yet be completed at the time of an upgrade, such that object forwarding is still in use. The heap partition structure is described by a linked list of partition tables that is reachable from the GC state.
 
 The garbage collector uses two kinds of roots:
 * Persistent roots: These refer to root objects that need to survive canister upgrades.
@@ -82,50 +86,60 @@ The transient roots are referenced by the Wasm data segments and comprise:
 * All canister variables of the current version, including flexible variables.
 
 ### Main Actor
-On an upgrade, the main actor is recreated and existing stable variables are recovered from the persistent root.
-The remaining actor variables, the flexible fields as well as new stable variables, are (re)initialized.
-As a result, the GC can collect unreachable flexible objects of previous canister versions. 
-Unused stable variables of former versions can also be reclaimed by the GC.
+On an upgrade, the main actor is recreated and existing stable variables are recovered from the persistent root. The remaining actor variables, the flexible fields as well as new stable variables, are (re)initialized. 
 
-### No Static Heap
-The static heap is abandoned and former static objects need to be allocated in the dynamic heap.
-This is because these objects may also need to survive upgrades and must not be not overwritten by new data segments. 
+As a result, the GC can collect unreachable flexible objects of previous canister versions. Unused stable variables of former versions can also be reclaimed by the GC.
 
-The incremental GC also operates on these objects, meaning that forwarding pointer resolution is also necessary for these objects.
+### No Static Heap
+The static heap is abandoned and former static objects need to be allocated in the dynamic heap. This is because these objects may also need to survive upgrades and the persistent main memory cannot accommodate a growing static heap of a new program version in front of the existing dynamic heap. The incremental GC also operates on these objects, meaning that forwarding pointer resolution is also necessary for these objects. 
 
 For memory and runtime efficiency, object pooling is implemented for compile-time-known constant objects (with side-effect-free initialization), i.e. those objects are already created on program initialization/upgrade in the dynamic heap and thereafter the reference to the corresponding prefabricated object is looked up whenever the constant value is needed at runtime.
 
-The runtime systems avoids any global Wasm variables for state that needs to be preserved on upgrades.
-Instead, such global runtime state is stored in the persistent metadata.
+The runtime system avoids any global Wasm variables for state that needs to be preserved on upgrades. Instead, such global runtime state is stored in the persistent metadata.
 
 ### Wasm Data Segments
-Only passive Wasm data segments are used by the compiler and runtime system. In contrast to ordinary active data segments, passive segments can be explicitly loaded to a dynamic address.
+Only passive Wasm data segments are used by the Motoko compiler and runtime system. In contrast to ordinary active data segments, passive segments can be explicitly loaded to a dynamic address.
 
 This simplifies two aspects: 
-* The generated Motoko code can contain arbitrarily large data segments which can be loaded to dynamic heap when needed.
-* The IC can simply retain the main memory on an upgrade without needing to patch the active data segments of the new program version to the persistent memory.
+* The generated Motoko code can contain arbitrarily large data segments (to the maximum that is supported by the IC). The segments can be loaded to the dynamic heap when needed.
+* The IC can simply retain the main memory on an upgrade without needing to patch any active data segments of the new program version to the persistent main memory.
 
-However, more specific handling is required for the Rust-implemented runtime system:
-The Rust-generated active data segments of the runtime system is changed to passive and loaded to the expected static address at the program start (canister initialization and upgrade).
-The location and size of the RTS data segments is therefore limited to a defined reserve, see above. 
-This is acceptable because the RTS only uses small size for data segments (e.g. 54KB) that is independent of the compiled Motoko program.
+However, more specific handling is required for the Rust-implemented runtime system (RTS): The Rust-generated active data segment of the runtime system is changed to the passive mode and loaded to the expected static address on the program start (canister initialization and upgrade). The location and size of the RTS data segments is therefore limited to a defined reserve of 512 KB, see above. This is acceptable because the RTS only requires a controlled small amount of memory for its data segments, independent of the compiled Motoko program.
 
 ### Null Sentinel
 As an optimization, the top-level `null` pointer is represented as a constant sentinel value pointing to the last unallocated Wasm page. This allows fast null tests without involving forwarding pointer resolution of potential non-null comparand pointers.
 
+### Memory Capacity
+The canister has no upfront knowledge of the maximum allocatable Wasm main memory in 64-bit address space, as there is no IC API call to query the main memory limit. This limit may also be increased in future IC releases.
+
+Therefore, a mechanism is implemented to deal with an unknown and dynamically increasable main memory capacity offered by the IC. This is needed in two cases:
+
+* GC reserve (strict): The runtime system ensures sufficient free space to allow garbage collection at all times, even if the heap is full. For this purpose, the runtime system already pre-allocates the reserve, to be sure that the reserve is available despite the unknown capacity. As an optimization, this pre-allocation is skipped when the memory demand including the GC reserve is below a guaranteed minimum Wasm memory limit of the IC, e.g. 4GB or 6GB.
+* GC scheduling (heuristic): The GC schedules at high frequency when memory is becoming scarce. For this purpose, the GC maintains an assumption of the minimum memory limit and probes the supposed limit when the heap size approaches this limit. If the allocation succeeds, the assumed limit is increased. Otherwise, the critical high-frequency GC scheduling rate is activated.
+
+In both cases, the runtime system tries to reduce Wasm memory allocations as much as possible, i.e. not pre-allocating memory for small heap sizes, and not probing an allocation in certain memory ranges by assuming that the IC only offers main memory of a certain granularity, e.g. multiples of 2GB. To save instructions, the critical GC scheduling is only activated when reaching the actual memory limit. Moreover, the mechanism can handle an increased memory capacity at runtime, e.g. when the IC is upgraded to a new release with a higher memory limit.
+
 ### Migration Path
-When migrating from the old serialization-based stabilization to the new stable heap, the old data is deserialized one last time from stable memory and then placed in the new stable heap layout.
-Once operating on the stable heap, the system prevents downgrade attempts to the old serialization-based persistence.
+When migrating from the old serialization-based stabilization to the new persistent heap, the old data is deserialized one last time from stable memory and then placed in the new persistent heap layout. Once operating on the persistent heap, the system should prevent downgrade attempts to the old serialization-based persistence. 
 
-### Old Stable Memory
-The old stable memory remains equally accessible as secondary memory with the new support.
+Assuming that the persistent memory layout needs to be changed in the future, the runtime system supports serialization and deserialization to and from stable memory in a defined data format using graph copy. 
 
-## Current Limitations
-* Freeing old object fields: While new program versions can drop object fields, the runtime system should also delete the redundant fields of persistent objects of previous program versions. This could be realized during garbage collection when objects are copied. For this purpose, the runtime system may maintain a set of field hashes in use and consult this table during garbage collection.
-* Bounded Rust call stack size: The Rust call stack size needs to be bounded and can no longer be configured by the user.
-* The Wasm profiler (only used for the flamegraphs) is no longer applicable because the underlying `parity-wasm` crate lacks full support of passive data segments. A re-implementation of the profiler would be needed.
+### Graph Copy
+The graph copy is an alternative persistence mechanism that will be only used in the rare situation when the persistent memory layout will be changed in the future. Arbitrarily large data can be serialized and deserialized beyond the instruction and working set limit of upgrades: Large data serialization and deserialization is split in multiple messages, running before and/or after the IC upgrade to migrate large heaps. Of course, other messages will be blocked during this process and only the canister owner or the canister controllers are permitted to initiate this process. 
+
+Graph copying needs to be explicitly initiated before an upgrade to new Motoko version that is incompatible to the current enhanced orthogonal persistent layout. For large data, the graph copy needs to be manually completed after the actual upgrade.
 
-## Related PRs
+```
+dfx canister call CANISTER_ID __motoko_stabilize_before_upgrade "()"
+dfx deploy CANISTER_ID
+dfx canister call CANISTER_ID __motoko_destabilze_after_upgrade "()"
+```
 
-* IC with stable main memory support: https://github.com/luc-blaeser/ic/tree/luc/stable-heap-on-release
-* Wasm64 Support for Motoko: https://github.com/dfinity/motoko/pull/4136
+More detailed information and instructions on graph copy are contained in `design/GraphCopyStabilization.md`.
+
+### Old Stable Memory
+The old stable memory remains equally accessible as secondary (legacy) memory with the new support.
+
+## Current Limitations
+* The memory footprint of a program increases with 64 bit as the word size for scalars and pointers are doubled. In turn, in some cases, boxing can be avoided due to larger word size which again reduces memory demand.
+* Freeing old object fields: While new program versions can drop object fields, the runtime system should also delete the redundant fields of persistent objects of previous program versions. This could be realized during garbage collection when objects are copied. For this purpose, the runtime system may maintain a set of field hashes in use and consult this table during garbage collection. Another, probably too restrictive solution could be to disallow field removal (subtyping) on object upgrades during the memory compatibility check.
diff --git a/design/PersistenceModes.md b/design/PersistenceModes.md
new file mode 100644
index 00000000000..520cc8b9fbf
--- /dev/null
+++ b/design/PersistenceModes.md
@@ -0,0 +1,50 @@
+# Persistence Modes
+
+This Motoko build includes two substantially different persistence modes in one build:
+
+* [Classical Persistence](OldStableMemory.md) (default): 
+    This is the traditional Motoko compiler design based on 32-bit memory and Candid-based stabilization for upgrades.
+    This mode is known to have severe scalability problems on upgrades, because the stabilization may exceed upgrade instruction limit for stable data amounts, besides other problems such as exponential duplication or stack overflows depending on the data structures.
+    The mode is temporarily retained to allow beta testing of the new enhanced orthogonal persistence until the new persistence is officialized.
+* [Enhanced Orthogonal Persistence](OrthogonalPersistence.md) (new, for beta testing):
+    This implements scalable persistence with 64-bit main memory that is retained across upgrades without stabilization to stable memory.
+    The mode needs to be enabled by the compiler flag `--enhanced-orthogonal-persistence` and is intended to become the future default mode, deprecating classical persistence.
+
+The reason for having one build instead of two separate branches and release artefact is for having a unified branch, and ensure that new features are implemented and tested for both persistence modes, passing the same CI.
+
+## Compiler Flags
+
+* (no flag): Use classical persistence
+* `--enhanced-orthogonal-persistence`: Use enhanced orthogonal persistence. NOTE: This is currently in the **beta testing** phase.
+
+Certain compiler flags are only applicable to a specific persistence mode:
+
+Flag              | Applicable Mode
+------------------|----------------
+--rts-stack-pages | Classical persistence only
+--stabilization-instruction-limit | Enhanced persistence only
+--copying-gc      | Classical persistence only
+--compacting-gc   | Classical persistence only
+--generational-gc | Classical persistence only
+
+(All other flags are applicable to both modes.)
+
+Incremental graph copy stabilization with `__motoko_stabilize_before_upgrade` and `__motoko_destabilize_after_upgrade` are only available with enhanced orthogonal persistence and only needed in a seldom case of memory layout upgrade.
+
+## Source Structure
+
+## Runtime System
+The Motoko runtime system (RTS) is a combined source base supporting 3 modes, each with a debug and release build:
+* 32-bit classical persistence, with classical non-incremental GCs
+* 32-bit classical persistence, with the incremental GC
+* 64-bit enhanced orthogonal persistence
+
+## Compiler
+For pragmatic purposes, the compiler backend is split/duplicated in two parts
+* `compile-enhanced.ml`: Enhanced orthogonal persistence, 64-bit, passive data segments, incremental graph copy.
+* `compile-classical.ml`: Classical persistence, 32-bit, Candid stabilization.
+
+The linker integrates both persistence modes and 32-bit and 64-bit in one package.
+
+## Tests
+Most tests run on both modes. Specific tests apply to selected modes, as defined by the `ENHANCED-ORTHOGONAL-PERSISTENCE` or `CLASSICAL-PERSISTENCE` tags.
diff --git a/design/Stable.md b/design/Stable.md
index 2dfd34975f6..eba0623e275 100644
--- a/design/Stable.md
+++ b/design/Stable.md
@@ -22,10 +22,12 @@ Concretely, the syntax of `<dec-field>` is extended as follows:
 ```
 
 Additional restrictions apply:
-* Either a `stable` or `flexible` modifier _must_ appear on `let` and `var` declarations that are actor fields.
+* A `stable` or `flexible` modifier _can_ appear on `let` and `var` declarations that are actor fields.
 * A `stable` or `flexible` modifier _must not_ appear anywhere else.
 
-Both restrictions may be relaxed in the future.
+Currently, `flexible` is assumed as implicit keyword on actor fields if no keyword is declared.
+However, we should revise this design, as it may lead to accidental loss of data on upgrade if programmers accidentally forgot to specify `stable`.
+In other languages of orthogonal persistence, pointers are by default persistent, analogous to `stable` in Motoko.
 
 (Note: One possible future use case might be to mark private methods as stable, which would be a requisite that they can be handed out as capabilities, because such methods must also remain backwards compatible.)
 
@@ -122,7 +124,7 @@ Question: Should the stable signature become a superset of Candid signatures, i.
 
 Like the Candid IDL, the Motoko compiler can produce stable signatures for the actors it compiles.
 
-We will also need a tool (the compiler, or a separate one?) that can compare stable signature and verify that an extension is valid according to the Motoko subtyping rules.
+By using `moc --stable-compatible`, one can compare stable signature and verify that an extension is valid according to the Motoko subtyping rules.
 
 To make that test reliable, the stable signature of an actor should be contained in the Wasm module of a deployed Motoko actor.
 That way, it is ensured that accurate signature information is always available for each installed actor.
@@ -132,17 +134,14 @@ In either case, it is probably sufficient to use a textual representation.
 
 Like for the IDL, the System would need to provide a way to extract this information from an on-chain canister.
 
+For even higher safety, [enhanced orthogonal persistence](OrthogonalPersistence.md) integrates the compatibility check in the runtime system, 
+such that it is atomically guarded and cannot be bypassed e.g. by skipping a `dfx` stable compatibility warning.
 
 ## Upgrade Hooks
 
 The System API provides a number of hooks that a canister can implement.
 In particular, this includes the pre & post upgrade hooks.
-
-Motoko does not currently provide a way to define these hooks.
-While the post upgrade hook can be exploited by using expression declarations (see above), there is no immediate way to define the pre upgrade hook.
-
-Note: This feature could potentially be deferred until later.
-
+Motoko allows to define custom pre-/post upgrade hooks, see below.
 
 ### Syntax
 
@@ -180,4 +179,6 @@ Note: The post-upgrade method differs from expression declarations in the body o
 
 ## Implementation
 
-See `OrthogonalPersistence.md`.
+Different [persistence modes](OrthogonalPersistence.md):
+* [Enhanced orthogonal persistence](OrthogonalPersistence.md).
+* [Classical orthogonal persistence](OldStableMemory.md).
diff --git a/design/StableMemory.md b/design/StableMemory.md
new file mode 100644
index 00000000000..759ba39390d
--- /dev/null
+++ b/design/StableMemory.md
@@ -0,0 +1,30 @@
+# The IC's Stable Memory API
+
+The IC provides a very small set of functions for operating on stable memory:
+
+```
+ic0.stable_size : () -> (page_count : i32);                                 // *
+ic0.stable_grow : (new_pages : i32) -> (old_page_count : i32);              // *
+ic0.stable_write : (offset : i32, src : i32, size : i32) -> ();             // *
+ic0.stable_read : (dst : i32, offset : i32, size : i32) -> ();              // *
+```
+
+(see https://sdk.dfinity.org/docs/interface-spec/index.html#system-api-stable-memory)
+
+These grow memory and do bulk transfers between Wasm and stable
+memory.  The `// *` means that they can be called in all contexts
+(e.g. init, update, query etc).  Direct reads and writes of word-sized
+data to/from the stack are not supported but can be emulated at cost.
+The initial size of the stable memory is zero. The contents of fresh pages (after grow) is initially zero.
+
+Note that, in this API, the client is responsible for growing (both
+stable and wasm) memory before access by read or write (out-of-bounds
+access will trap).
+
+# Stable Memory Accesses
+
+Direct stable memory accesses (`ExperimentalStableMemory` in Motoko's base library) has been deprecated.
+Instead, [stable regions](StableRegions.md) are available to explicitly access stable memory.
+
+However, generally, programmers do not need to use stable memory due to the support of orthogonal persistence,
+see [Enhanced Orthogonal Persistence](OrthogonalPersistence.md).
diff --git a/design/StableRegions.md b/design/StableRegions.md
index 604343edbcd..b3fe0cc709d 100644
--- a/design/StableRegions.md
+++ b/design/StableRegions.md
@@ -13,7 +13,7 @@ The **region manager** is the state and logic to support this generalization.
 
 The current stable memory module in `base` has been "experimental" for a long time, and requires a more composable API to graduate from this status.
 
-Stable regions address the problem that today's `ExperimentalStableMemory` module only provides a single, monolithic memory that makes it unsuitable for directly building composable software parts.
+Stable regions address the problem that the deprecated `ExperimentalStableMemory` module only provided a single, monolithic memory that makes it unsuitable for directly building composable software parts.
 
 Stable regions permit a new API that supports composable use cases.
 
@@ -331,3 +331,7 @@ Since we do not move the remaining blocks of region 0, the first block of memory
 
 This design ensures that an existing canister using very large amounts of experimental stable memory can be migrated with only constant-cost movement
 of the first block (128 pages) of memory.
+
+## Orthogonal Persistence
+
+Stable regions can be used together with orthogonal persistence, see [Classical Persistence](OldStableMemory.md) and [Enhanced Orthogonal Persistence](OrthogonalPersistence.md).
\ No newline at end of file
diff --git a/design/WhitePaper.md b/design/WhitePaper.md
index 8045e4d4b41..bac583de1e4 100644
--- a/design/WhitePaper.md
+++ b/design/WhitePaper.md
@@ -621,14 +621,8 @@ Note: the obvious "solution", namely storing closure environments inside the ori
 
 #### Upgrades and Memory
 
-The most difficult problem to solve in the programming model of the IC by far is the question of safe and robust upgrades. Motoko currently uses the IC's _stable memory_ API to serialise the entire heap of an actor into stable memory before an upgrade, and restore it afterwards. The crucial point of this is that the serialised format is fixed and not dependent on the compiler version. Consequently, it is perfectly fine if the new version of the actor has been compiled with a different (typically newer) compiler version that potentially uses a different memory layout internally (e.g., a new garbage collector).
-
-The drawback is that this serialisation/deserialisation step is expensive. Worse, it may even run out of cycles.
-
-There are multiple ways in which the representation of stable variables could be improved to avoid this overhead (or rather, trade it off against a different overhead). However, most of them would be extremely costly with the IC's stable memory API. This API was merely a stop-gap measure while we wait for the IC to support the upcoming Wasm proposal for accessing multiple memories. Once this becomes available, it would unlock a number of new and better implementation options.
-
-Yet, representing all persistent data in terms of serialised Motoko values might never be enough for all use cases. Imagine, for example, emulating a file system or a high-performance data base as persistent storage. For these use cases, Motoko will provide a low-level interface that enables direct access to raw stable memory, leaving it up to respective libraries to build suitable high-level abstraction on top.
-
+The most difficult problem to solve in the programming model of the IC by far is the question of safe and robust upgrades. 
+For this purpose, Motoko implements powerful and safe persistence, see [Enhanced Orthogonal Persistence](OrthogonalPersistence.md).
 
 #### Upgrades and Methods
 
@@ -669,6 +663,8 @@ The ability to link compiled modules together would also be a first step towards
 
 Unfortunately, though, this is a more difficult problem than linking modules compiled in the same language, since the data types, memory management, and calling conventions used by different languages are rarely compatible. Supporting cross-language calls requires a suitable ABI agreed upon by different Wasm compilers, which in turn requires some kind of standard. There is work on a proposal ([interface types](https://github.com/WebAssembly/interface-types/blob/main/proposals/interface-types/Explainer.md)) for Wasm that could be the basis of such a mechanism, but it's not ready yet.
 
+Wasm component model offers a solution for secure intra-canister language interop on the IC.
+
 
 #### On-chain Linking
 
diff --git a/doc/md/canister-maintenance/compatibility.md b/doc/md/canister-maintenance/compatibility.md
index b05fd92739e..957bdf64924 100644
--- a/doc/md/canister-maintenance/compatibility.md
+++ b/doc/md/canister-maintenance/compatibility.md
@@ -6,13 +6,13 @@ sidebar_position: 4
 
 ## Overview
 
-When upgrading a canister, it is important to verify that an upgrade can proceed without:
+When upgrading a canister, it is important to verify that the upgrade can proceed without:
 
+-   Introducing an incompatible change in stable declarations.
 -   Breaking clients due to a Candid interface change.
 
--   Discarding the Motoko stable state due to a change in stable declarations.
-
-Motoko checks these properties statically before attempting the upgrade.
+`dfx` checks these properties statically before attempting the upgrade. 
+Moreover, with [enhanced orthogonal persistence](orthogonal-persistence/enhanced.md), Motoko rejects incompatible changes of stable declarations.
 
 ## Upgrade example
 
@@ -21,7 +21,8 @@ The following is a simple example of how to declare a stateful counter:
 ``` motoko no-repl file=../examples/count-v0.mo
 ```
 
-In this example, when the counter is upgraded, its state is lost.
+Importantly, in this example, when the counter is upgraded, its state is lost.
+This is because actor variables are by default `flexible`, meaning they get reinitialized on an upgrade.
 
 To fix this, you can declare a stable variable that is retained across upgrades:
 
@@ -31,52 +32,40 @@ To fix this, you can declare a stable variable that is retained across upgrades:
 
 If the variable `state` were not declared `stable`, `state` would restart from `0` on upgrade.
 
+## Evolving the stable declarations
 
-## Evolving the Candid interface
-
-In this extension of our interface, old clients remain satisfied, while new ones get extra features such as the `read` query in this example.
+Changing counter from `Nat` to `Int` is a compatible change in stable declarations. The counter value is retained during the upgrade.
 
 ``` motoko no-repl file=../examples/count-v2.mo
 ```
 
-## Changing the stable interface
-
-Let's take a look at an example where the counter is refactored from using [`Int`](../base/Int.md) to [`Nat`](../base/Nat.md).
-
-``` motoko no-repl file=../examples/count-v3.mo
-```
-
-Now, the code has been upgraded, but the counter value is back to `0`. The state was lost in an upgrade.
-
-This is because the Candid interface evolved safely​ but the stable types did not.
-
-An upgrade must be able to:
-
--   Consume any stable variable value from its predecessor, or
-
--   Run the initializer for a new stable variable.
-
-Since `Int </: Nat`, the upgrade logic discards the saved [`Int`](../base/Int.md) and re-runs the initializer instead. The upgrade silently "succeeded", resetting the counter to `0`.
-
 ## Stable type signatures
 
 A stable type signature describes the stable content of a Motoko actor.
 You can think of this as the interior interface of the actor, that it presents to its future upgrades.
 
-For example, `v2`'s stable types:
+For example, `v1`'s stable types:
+
+``` motoko no-repl file=../examples/count-v1.most
+```
+
+An upgrade from `v1` to `v2`'s stable types consumes a [`Nat`](../base/Int.md) as an [`Int`](../base/Nat.md), which is valid because `Int <: Nat`.
 
 ``` motoko no-repl file=../examples/count-v2.most
 ```
 
-An upgrade from `v2` to `v3`'s stable types requires consuming an [`Int`](../base/Int.md) as a [`Nat`](../base/Nat.md), which is a **type error**.
-For example, `-1` is an [`Int`](../base/Int.md), but is not a [`Nat`](../base/Nat.md).
+## Evolving the Candid interface
 
-``` motoko no-repl file=../examples/count-v3.most
+In this extension of our interface, old clients remain satisfied, while new ones get extra features such as the `decrement` function and the `read` query in this example.
+
+``` motoko no-repl file=../examples/count-v3.mo
 ```
 
 ## Dual interface evolution
 
-An upgrade is safe provided that the Candid interface evolves to a subtype and the stable interface evolves to a compatible one: a stable variable must either be newly declared, or re-declared at a supertype of its old type.
+An upgrade is safe provided that both the Candid interface and stable type signatures remain compatible:
+* Each stable variable must either be newly declared, dropped, or re-declared at a supertype of its old type.
+* The Candid interface evolves to a subtype.
 
 Consider the following four versions of the counter example:
 
@@ -112,78 +101,182 @@ Version `v3` with Candid interface `v3.did` and stable type interface `v3.most`:
 ``` motoko no-repl file=../examples/count-v3.most
 ```
 
+## Incompatible upgrade
+
+Let's take a look at another example where the counter's type is again changed, this time from [`Int`](../base/Int.md) to [`Nat`](../base/Float.md):
+
+``` motoko no-repl file=../examples/count-v4.mo
+```
+
+This version is neither compatible to Candid interface nor to the stable type declarations.
+- Since `Float </: Int`, the new type of `state` is not compatible to the old type.
+- The return type change of `read` is also not valid.
+
+Motoko rejects upgrades with incompatible state changes with [enhanced orthogonal persistence](orthogonal-persistence/enhanced.md).
+This is to guarantee that the stable state is always kept safe.
+
+```
+Error from Canister ...: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+```
+
+In addition to Motoko's check, `dfx` raises a warning message for these incompatible changes, including the breaking Candid change.
+
+:::danger
+Versions of Motoko using [classical orthogonal persistence](orthogonal-persistence/classical.md) will drop the state and reinitialize the counter with `0.0`, if the `dfx` warning is ignored.
+:::
+
+## Explicit migration
+
+There is always a migration path to change structure of stable state, even if a direct type change is not compatible.
+
+For this purpose, a user-instructed migration can be done in three steps:
+
+1. Introduce new variables of the desired types, while keeping the old declarations.
+2. Write logic to copy the state from the old variables to the new variables on upgrade.
+
+    While the previous attempt of changing state from [`Int`](../base/Int.md) to [`Nat`](../base/Float.md) was invalid, we now can realize the desired change as follows:
+
+    ``` motoko no-repl file=../examples/count-v5.mo
+    ```
+
+    To also keep the Candid interface, the `readFloat` has been added, while the old `read` is retired by keeping its declaration and raising a trap internally.
+
+3. Drop the old declarations, once all data has been migrated:
+
+    ``` motoko no-repl file=../examples/count-v6.mo
+    ```
+
+Alternatively, the type of `state` can be changed to `Any`, also implying that this variable is no longer used.
+
 ## Upgrade tooling
 
-The Motoko compiler (`moc`) supports:
+`dfx` incorporates an upgrade check. For this purpose, it uses the Motoko compiler (`moc`) that supports:
 
 -   `moc --stable-types …​`: Emits stable types to a `.most` file.
 
 -   `moc --stable-compatible <pre> <post>`: Checks two `.most` files for upgrade compatibility.
 
-To upgrade from `cur.wasm` to `nxt.wasm` we need check that both the Candid interface and stable variables are compatible.
+Motoko embeds `.did` and `.most` files as Wasm custom sections for use by `dfx` or other tools.
+
+To upgrade e.g. from `cur.wasm` to `nxt.wasm`, `dfx` checks that both the Candid interface and stable variables are compatible:
 
 ```
 didc check nxt.did cur.did  // nxt <: cur
 moc --stable-compatible cur.most nxt.most  // cur <<: nxt
 ```
 
-Using the versions above, the upgrade from `v2` to `v3` fails this check:
+Using the versions above, the upgrade from `v3` to `v4` fails this check:
 
 ```
-> moc --stable-compatible v2.most v3.most
+> moc --stable-compatible v3.most v4.most
 (unknown location): Compatibility error [M0170], stable variable state of previous type
   var Int
 cannot be consumed at new type
-  var Nat
+  var Float
 ```
 
-Because of the compatibility error, you should not attempt to upgrade from `v2.wasm` to `v3.wasm`. The result of upgrading is unpredictable. At best, the upgrade will detect the incompatibility, trap and roll back to the current version, as if the upgrade had never been attempted. At worst, the upgrade will appear to succeed, but lose some or all of the state of the previous version, re-initializing some of the stable variables you intended to preserve.
+With [enhanced orthogonal persistence](orthogonal-persistence/enhanced.md), compatibility errors of stable variables are always detected in the runtime system and if failing, the upgrade is safely rolled back.
 
-One way to correctly change the logical state to [`Nat`](../base/Nat.md), is to introduce a new stable variable, `newState`, of type [`Nat`](../base/Nat.md), initialized from the old one (`state`). Unlike the stable signature of v3.wasm, the stable signature of v4.wasm:
+:::danger
+With [classical orthogonal persistence](orthogonal-persistence/classical.md), however, an upgrade attempt from `v2.wasm` to `v3.wasm` is unpredictable and may lead to partial or complete data loss, if the `dfx` warning is ignored.
+:::
 
-``` motoko no-repl file=../examples/count-v4.mo
-```
-
-``` motoko no-repl file=../examples/count-v4.most
-```
-
-## Incompatible upgrade example
+## Adding record fields
 
 A common, real-world example of an incompatible upgrade can be found [on the forum](https://forum.dfinity.org/t/questions-about-data-structures-and-migrations/822/12?u=claudio/).
 
 In that example, a user was attempting to add a field to the record payload of an array, by upgrading from stable type interface:
 
 ``` motoko no-repl
-type Card = {
-  title : Text
-};
 actor {
-  stable var map: [(Nat32, Card)]
-}
+  type Card = {
+    title : Text;
+  };
+  stable var map : [(Nat32, Card)] = [(0, { title = "TEST"})];
+};
 ```
 
 to *incompatible* stable type interface:
 
 ``` motoko no-repl
-type Card = {
-  title : Text;
-  description : Text
+actor {
+  type Card = {
+    title : Text;
+    description : Text;
+  };
+  stable var map : [(Nat32, Card)] = [];
 };
+```
+
+### Problem
+
+When trying this upgrade, `dfx` issues the following warning:
+
+```
+Stable interface compatibility check issued an ERROR for canister ...
+Upgrade will either FAIL or LOSE some stable variable data.
+
+(unknown location): Compatibility error [M0170], stable variable map of previous type
+  var [(Nat32, Card)]
+cannot be consumed at new type
+  var [(Nat32, Card__1)]
+
+Do you want to proceed? yes/No
+```
+It is recommended not to continue, as you will lose the state in older versions of Motoko that use [classical orthogonal persistence](orthogonal-persistence/classical.md). 
+Upgrading with [enhanced orthogonal persistence](orthogonal-persistence/enhanced.md) will trap and roll back, keeping the old state.
+
+Adding a new record field to the type of existing stable variable is not supported. The reason is simple: The upgrade would need to supply values for the new field out of thin air. In this example, the upgrade would need to conjure up some value for the  `description` field of every existing `card` in `map`. Moreover, allowing to add optional fields is also a problem, as a record can be shared from various variables with different static types, some of them already declaring the added field or adding a same-named optional field with a potentially different type (and/or different semantics).
+
+### Solution
+
+To resolve this issue, again, an [explicit](#explicit-migration) is needed:
+
+1. We keep the old variable `map` with the same structural type. However, we are allowed to change type alias name (`Card` to `OldCard`).
+2. We introduce a new variable `newMap` and copy the old state to the new one, initializing the new field as needed.
+3. We upgrade to this new version.
+
+``` motoko no-repl
+import Array "mo:base/Array";
+
 actor {
-  stable var map : [(Nat32, Card)]
-}
+  type OldCard = {
+    title : Text;
+  };
+  type NewCard = {
+    title : Text;
+    description : Text;
+  };
+  
+  stable var map : [(Nat32, OldCard)] = [];
+  stable var newMap : [(Nat32, NewCard)] = Array.map<(Nat32, OldCard), (Nat32, NewCard)>(
+    map,
+    func(key, { title }) { (key, { title; description = "<empty>" }) },
+  );
+};
 ```
 
-Adding a new record field  does not work. The reason is simple: the upgrade would need to supply values for the new field out of thin air. In this example, the upgrade would need to conjure up some value for the  `description` field of every existing `card` in `map`.
+4. **After** we have successfully upgraded to this new version, we can upgrade once more to a version, that drops the old `map`.
 
-## Metadata sections
+``` motoko no-repl
+actor {
+  type Card = {
+    title : Text;
+    description : Text;
+  };
+  stable var newMap : [(Nat32, Card)] = [];
+};
+```
 
-Motoko embeds `.did` and `.most` files as Wasm custom sections for use by other tools, e.g. dfx.
+`dfx` will issue a warning that `map` will be dropped. 
 
-`dfx deploy` and `dfx canister install --all --mode upgrade` commands check that the interface is compatible, and if not, show this message and ask if you want to continue:
+Make sure, you have previously migrated the old state to `newMap` before applying this final reduced version.
 
 ```
-let msg = format!("Candid interface compatibility check failed for canister '{}'.\nYou are making a BREAKING change. Other canisters or frontend clients relying on your canister may stop working.\n\n", canister_info.get_name()) + &err;
+Stable interface compatibility check issued a WARNING for canister ...
+(unknown location): warning [M0169], stable variable map of previous type
+  var [(Nat32, OldCard)]
+ will be discarded. This may cause data loss. Are you sure?
 ```
 
 <img src="https://github.com/user-attachments/assets/844ca364-4d71-42b3-aaec-4a6c3509ee2e" alt="Logo" width="150" height="150" />
diff --git a/doc/md/canister-maintenance/orthogonal-persistence/_category_.yml b/doc/md/canister-maintenance/orthogonal-persistence/_category_.yml
new file mode 100644
index 00000000000..cb2f5e1e941
--- /dev/null
+++ b/doc/md/canister-maintenance/orthogonal-persistence/_category_.yml
@@ -0,0 +1,4 @@
+position: 5
+label: 'Orthogonal persistence'
+collapsible: true # make the category collapsible
+collapsed: true
diff --git a/doc/md/canister-maintenance/orthogonal-persistence/classical.md b/doc/md/canister-maintenance/orthogonal-persistence/classical.md
new file mode 100644
index 00000000000..fe14a8c8a5f
--- /dev/null
+++ b/doc/md/canister-maintenance/orthogonal-persistence/classical.md
@@ -0,0 +1,23 @@
+---
+sidebar_position: 3
+---
+
+# Classical orthogonal persistence
+
+Classical orthogonal persistence is the old implementation of Motoko's orthogonal persistence. It is currently still the default option, as enhanced orthogonal persistence is in beta-testing stage.
+
+On an upgrade, the classical orthogonal persistence mechanism serializes all stable data to the stable memory and then again deserializes it back to the main memory. This has several downsides:
+
+* At maximum, 2 GB of heap data can be persisted across upgrades. This is because of an implementation restriction, first copying the stable data back in main memory and then deserializing it from there. Note that in practice, the supported amount of stable data can be way lower. 
+* Shared immutable heap objects can duplicated, leading to potential state explosion on upgrades.
+* Deeply nested structures can lead to a call stack overflow.
+* The serialization and deserialization is expensive and can hit IC's instruction limits.
+* There is no inbuilt stable compatibility check in the runtime system. If users ignore the `dfx` upgrade warning, data may be lost or upgrade fails.
+
+:::danger
+All these issues can lead to a stuck canister that can no longer be upgraded.
+It is therefore absolutely necessary to thoroughly test how much data an upgrade of your application can handle and then conservatively limit the data held by that canister.
+Moreover, it is good to have a backup possibility to rescue data even if upgrades fail, e.g. by controller-privileged data query calls.
+:::
+
+These issues will be solved by [enhanced orthogonal persistence](enhanced.md).
diff --git a/doc/md/canister-maintenance/orthogonal-persistence/enhanced.md b/doc/md/canister-maintenance/orthogonal-persistence/enhanced.md
new file mode 100644
index 00000000000..5b46305e6bd
--- /dev/null
+++ b/doc/md/canister-maintenance/orthogonal-persistence/enhanced.md
@@ -0,0 +1,101 @@
+---
+sidebar_position: 2
+---
+
+# Enhanced orthogonal persistence
+
+This implements the vision of efficient and scalable orthogonal persistence in Motoko that combines:
+* **Stable heap**: Persisting the program main memory across canister upgrades.
+* **64-bit heap**: Extending the main memory to 64-bit for large-scaled persistence.
+
+As a result, the use of secondary storage (explicit stable memory, dedicated stable data structures, DB-like storage abstractions) will no longer be necessary: Motoko developers can directly work on their normal object-oriented program structures that are automatically persisted and retained across program version changes.
+
+### Activation
+Enhanced orthogonal persistence is currently offered for **beta testing** via the compiler flag `--enhanced-orthogonal-persistence`.
+
+To activate enhanced orthogonal persistence under `dfx`, the following command-line argument needs to be specified in `dfx.json`:
+
+```
+...
+    "type" : "motoko"
+    ...
+    "args" : "--incremental-gc"
+...
+```
+
+:::tip
+Despite the use of enhanced orthogonal persistence, it is strongly recommended to thoroughly test the upgrades of your application.
+Moreover, it is advised to have a backup possibility for rescuing data even when upgrades fail, e.g. by controller-privileged data query calls.
+:::
+
+[Classical orthogonal persistence](classical.md) with 32-bit main memory and Candid stabilization currently remains the default mode.
+See [orthogonal persistence modes](modes.md) for a comparison.
+
+## Advantages
+Compared to the existing orthogonal persistence in Motoko, this design offers:
+* **Performance**: New program versions directly resume from the existing main memory and have access to the memory-compatible data.
+* **Scalability**: The upgrade mechanism scales with larger heaps and in contrast to serialization, does not hit IC instruction limits.
+
+Compared to the explicit use of stable memory, this design improves:
+* **Simplicity**: Developers do not need to deal with explicit stable memory.
+* **Performance**: No copying to and from the separate stable memory is necessary.
+
+## Design
+The enhanced orthogonal persistence is based on the following main properties:
+* Extension of the IC to retain main memory on upgrades.
+* Supporting 64-bit main memory on the IC.
+* A long-term memory layout that is invariant to new compiled program versions.
+* A fast memory compatibility check performed on each canister upgrade.
+* Incremental garbage collection using a partitioned heap.
+
+### Compatibility Check
+Upgrades are only permitted if the new program version is compatible with the old version, such that the runtime system guarantees a compatible memory structure.
+
+Compatible changes for immutable types are largely analogous to the allowed Motoko subtype relation modulo some flexibility for actor fields, i.e.
+* Adding or removing actor fields.
+* Changing mutability of actor fields (`let` to `var` and vice-versa).
+* Removing object fields.
+* Adding variant fields.
+* Changing `Nat` to `Int`.
+* Supporting hared function parameter contravariance and return type covariance.
+* Any other change according to Motoko's subtyping rule.
+
+The runtime system checks checks migration compatibility on upgrade, and if not fulfilled, rolls back the upgrade. This compatibility check serves as an additional safety measure on top of the `dfx` warning that can be bypassed by users.
+
+Any more complex change can be performed with programmatic instruction, see [explicit migration](../upgrades.md#explicit-migration).
+
+### Migration Path
+When migrating from the old serialization-based stabilization to the new persistent heap, the old data is deserialized one last time from stable memory and then placed in the new persistent heap layout. Once operating on the persistent heap, the system should prevent downgrade attempts to the old serialization-based persistence. 
+
+#### Graph-Copy-Based Stabilization
+Assuming that the persistent memory layout needs to be changed in the future, the runtime system supports serialization and deserialization to and from stable memory in a defined data format using graph-copy-based stabilization. Arbitrarily large data can be serialized and deserialized beyond the instruction and working set limit of upgrades: Large data serialization and deserialization is split in multiple messages, running before and/or after the IC upgrade to migrate large heaps. Of course, other messages will be blocked during this process and only the canister owner or the canister controllers are permitted to initiate this process. 
+
+This will only be needed in rare situation when Motoko's implementation changes its internal memory layout. Users will then be instructed to explicitly initiate this migration.
+
+#### Usage
+Graph-copy-based stabilization can be performed in three steps:
+
+1. Initiate the explicit stabilization before the upgrade:
+    
+```
+dfx canister call CANISTER_ID __motoko_stabilize_before_upgrade "()"
+```
+
+2. Run the actual upgrade:
+
+```
+dfx deploy CANISTER_ID
+```
+
+3. Complete the explicit destabilization after the upgrade:
+
+```
+dfx canister call CANISTER_ID __motoko_destabilize_after_upgrade "()"
+```
+
+Remarks:
+* When receiving the `dfx` error "The request timed out." during explicit stabilization, upgrade, or destabilization, one can simply repeat the call until it completes.
+* Steps 3 (explicit destabilization) may not be needed if the corresponding operation fits into the upgrade message.
+
+### Old Stable Memory
+The old stable memory remains equally accessible as secondary (legacy) memory with the new support. Therefore, stable regions can be combined with orthogonal persistence.
diff --git a/doc/md/canister-maintenance/orthogonal-persistence/modes.md b/doc/md/canister-maintenance/orthogonal-persistence/modes.md
new file mode 100644
index 00000000000..0af9f7b680f
--- /dev/null
+++ b/doc/md/canister-maintenance/orthogonal-persistence/modes.md
@@ -0,0 +1,11 @@
+---
+sidebar_position: 1
+---
+
+# Persistence modes
+
+Motoko features two implementations for orthogonal persistence:
+
+* [Enhanced orthogonal persistence](enhanced.md), currently in beta stage, provides very fast upgrades, scaling independently of the heap size: This is realized by retaining the Wasm entire main memory on an upgrade and simply performing a type-driven upgrade safety check. By using 64-bit address space, it is designed to scale beyond 4 GB and in future, offer the same capacity like stable memory.
+
+* [Classical orthogonal persistence](classical.md) is the old implementation of orthogonal persistence that will be superseded by enhanced orthogonal persistence. On upgrade, the runtime system first serializes the persistent data to stable memory and then deserializes it back again to main memory. While this is both inefficient and unscalable, it exhibits problems on shared immutable data (potentially leading to state explosion), deep structures (call stack overflow) and larger heaps (the implementation limits the stable data to at most 2 GB).
diff --git a/doc/md/canister-maintenance/upgrades.md b/doc/md/canister-maintenance/upgrades.md
index 340cada8d1a..5e1d89e3bf1 100644
--- a/doc/md/canister-maintenance/upgrades.md
+++ b/doc/md/canister-maintenance/upgrades.md
@@ -6,21 +6,19 @@ sidebar_position: 3
 
 ## Overview
 
-One key feature of ICP is its ability to persist canister state using WebAssembly memory and globals rather than a traditional database. This means that the entire state of a canister is restored before and saved after each message, without explicit user instruction. This automatic and user-transparent preservation of state between messages is called **orthogonal persistence**.
+One key feature of Motoko is its ability to automatically persist the program's state without explicit user instruction, called **orthogonal persistence**. This not only covers persistence across transactions but also includes canister upgrades. For this purpose, Motoko features a bespoke compiler and runtime system that manages upgrades in a sophisticated way such that a new program version can pick of the state left behind by a previous program version. As a result, Motoko data persistence is not simple, but also prevents data corruption and loss and is efficient at the same time. No database, stable memory API, or stable data structure is required to retain state across upgrades. Instead, a simple `stable` keyword is sufficient declare an data structure of arbitrary shape persistent, even if the structure uses sharing, has a deep complexity, or contains cycles.
 
-Though convenient, orthogonal persistence poses a challenge when it comes to upgrading the code of a canister. Without an explicit representation of the canister’s state, how does one transfer any application data from the retired canister to its replacement? For example, if you want to deploy a new version of a user registration canister to fix an issue or add functionality, you need to ensure that existing registrations survive the upgrade process.
-
-Accommodating upgrades without data loss requires some new facility to **migrate** a canister’s crucial data to the upgraded canister. ICP's persistence model allows a canister to save and restore long-lived data to dedicated **stable memory** that, unlike ordinary canister memory, is not cleared but retained across an upgrade. This facility allows a canister to transfer data in bulk to its replacement canister, provided that data is placed in stable memory, either throughout its lifetime, or just before an upgrade.
-
-Motoko provides high-level support for preserving state that leverages stable memory. This feature, called **stable storage**, is designed to accommodate changes to both the application data and the Motoko compiler used to produce the application code.
-
-Utilizing stable storage depends on the developer anticipating and indicating the data to retain after an upgrade. Depending on the application, the data you decide to persist might be some, all, or none of a given actor’s state.
+This is substantially different to other languages supported on the IC, which use off-the-shelf language implementations that are not designed for orthogonal persistence in mind: They rearrange memory structures in an uncontrolled manner on re-compilation or at runtime. As an alternative, in other languages, programmers have to explicilty use stable memory or special stable data structures to rescue their data between upgrades. Contrary to Motoko, this approach is not only cumbersome, but also unsafe and inefficient. Compared to using stable data structures, Motoko's orthogonal persistence allows more natural data modeling and significantly faster data accesses, eventually resulting in way more efficient programs.
 
 ## Declaring stable variables
 
-In an actor, you can configure a variable to use stable storage through the `stable` keyword modifier in the variable’s declaration.
+In an actor, you can configure which part of the program is considered to be persistent, i.e. survives upgrades, and which part are ephemeral, i.e. are reset on upgrades.
+
+More precisely, each `let` and `var` variable declaration in an actor can specify whether the variable is `stable` or `flexible`. If you don’t provide a modifier, the variable is  assumed to be `flexible` by default.
 
-More precisely, every `let` and `var` variable declaration in an actor can specify whether the variable is `stable` or `flexible`. If you don’t provide a modifier, the variable is declared as `flexible` by default.
+The semantics of the modifiers is as follows:
+* `stable` means that all values directly or indirectly reachable from that stable actor variable are considered persistent and automatically retained across upgrades. This is the primary choice for most of the program's state.
+* `flexible` means that the variable is re-initialized on upgrade, such that the values referenced by this flexible variable can be discarded, unless the values are transitively reachable by other variables that are stable. `flexible` is only used for temporal state or references to high-order types, such as local function references, see [stable types](#stable-types).
 
 The following is a simple example of how to declare a stable counter that can be upgraded while preserving the counter’s value:
 
@@ -35,41 +33,23 @@ You can only use the `stable` or `flexible` modifier on `let` and `var` declarat
 
 When you first compile and deploy a canister, all flexible and stable variables in the actor are initialized in sequence. When you deploy a canister using the `upgrade` mode, all stable variables that existed in the previous version of the actor are pre-initialized with their old values. After the stable variables are initialized with their previous values, the remaining flexible and newly-added stable variables are initialized in sequence.
 
-## Preupgrade and postupgrade system methods
-
-Declaring a variable to be `stable` requires its type to be stable too. Since not all types are stable, some variables cannot be declared `stable`.
-
-As a simple example, consider the following `Registry` actor:
-
-``` motoko file=../examples/Registry.mo
-```
-
-This actor assigns sequential identifiers to [`Text`](../base/Text.md) values, using the size of the underlying `map` object to determine the next identifier. Like other actors, it relies on orthogonal persistence to maintain the state of the hashmap between calls.
-
-This example would like to make the `Register` upgradable without the upgrade losing any existing registrations, but its state, `map`, has a proper object type that contains member functions, so the `map` variable cannot be declared `stable`.
-
-For scenarios like this that can’t be solved using stable variables alone, Motoko supports user-defined upgrade hooks that run immediately before and after an upgrade. These upgrade hooks allow you to migrate state between unrestricted flexible variables to more restricted stable variables. These hooks are declared as `system` functions with special names, `preugrade` and `postupgrade`. Both functions must have type `: () → ()`.
-
-The `preupgrade` method lets you make a final update to stable variables before the runtime commits their values to stable memory and performs an upgrade. The `postupgrade` method is run after an upgrade has initialized the replacement actor, including its stable variables, but before executing any shared function call or message on that actor.
-
-The following example introduces a new stable variable, `entries`, to save and restore the entries of the unstable hash table:
-
-``` motoko file=../examples/StableRegistry.mo
-```
+:::danger
+Do not forget to declare variables `stable` if they should survive canister upgrades as the default is `flexible` if no modifier is declared.
+:::
 
-Note that the type of `entries`, being an array of [`Text`](../base/Text.md) and [`Nat`](../base/Nat.md) pairs, is indeed a stable type.
+## Persistence modes
 
-In this example, the `preupgrade` system method writes the current `map` entries to `entries` before `entries` is saved to stable memory. The `postupgrade` system method resets `entries` to the empty array after `map` has been populated from `entries`.
+Motoko currently features two implementations for orthogonal persistence, see [persistence modes](orthogonal-persistence/modes.md).
 
-## Typing
+## Stable types
 
 Because the compiler must ensure that stable variables are both compatible with and meaningful in the replacement program after an upgrade, every `stable` variable must have a stable type. A type is stable if the type obtained by ignoring any `var` modifiers within it is shared.
 
-The only difference between stable types and shared types is the former’s support for mutation. Like shared types, stable types are restricted to first-order data, excluding local functions and structures built from local functions, such as objects. This exclusion of functions is required because the meaning of a function value, consisting of both data and code, cannot easily be preserved across an upgrade. The meaning of plain data, mutable or not, can be.
+The only difference between stable types and shared types is the former’s support for mutation. Like shared types, stable types are restricted to first-order data, excluding local functions and structures built from local functions (such as class instances). This exclusion of functions is required because the meaning of a function value, consisting of both data and code, cannot easily be preserved across an upgrade. The meaning of plain data, mutable or not, can be.
 
 :::note
 
-In general, object types are not stable because they can contain local functions. However, a plain record of stable data is a special case of object types that are stable. Moreover, references to actors and shared functions are also stable, allowing you to preserve their values across upgrades. For example, you can preserve the state record of a set of actors or shared function callbacks subscribing to a service.
+In general, classes are not stable because they can contain local functions. However, a plain record of stable data is a special case of object types that are stable. Moreover, references to actors and shared functions are also stable, allowing you to preserve their values across upgrades. For example, you can preserve the state record of a set of actors or shared function callbacks subscribing to a service.
 
 :::
 
@@ -83,39 +63,39 @@ For variables that do not have a stable type, there are two options for making t
   - [StableHashMap](https://github.com/canscale/StableHashMap)
   - [StableRBTree](https://github.com/canscale/StableRBTree)
 
-2. You can convert the variable to another type that is stable, such as the following example that converts a `Buffer` to an `Array`:
-
-```motoko
-let theProjectsBuffer : Buffer.Buffer = Buffer.Buffer(theProjectsNew.size());
-
-for (x in theProjectsNew.vals()) {
-
-theProjectsBuffer.add(x);
-
-};
-
-theProjectsBuffer.add(newProject);
+:::note
+Unlike stable data structures in the Rust CDK, these modules do not use stable memory but rely on orthogonal persistence. The adjective "stable" only denotes a stable type in Motoko.
+:::
 
-return theProjectsBuffer.toArray();
-```
+2. Extract the state in a stable type, and wrap it in the non-stable type. 
 
-Here is another example that takes a `HashMap` type and creates a stable `Array`:
+For example, the stable type `TemperatureSeries` covers the persistent data, while the non-stable type `Weather` wraps this with additional methods (local function types).
 
 ```motoko
-private var canisters: HashMap.HashMap<Principal, CanisterId> = HashMap.HashMap<Principal, CanisterId>(10, isPrincipalEqual, Principal.hash);
-
-private stable var upgradeCanisters : [(Principal, CanisterId)] = [];
-
-system func preupgrade() {
-        upgradeCanisters := Iter.toArray(canisters.entries());
+actor {
+  type TemperatureSeries = [Float];
+
+  class Weather(temperatures : TemperatureSeries) {
+    public func averageTemperature() : Float {
+      var sum = 0.0;
+      var count = 0.0;
+      for (value in temperatures.vals()) {
+        sum += value;
+        count += 1;
+      };
+      return sum / count;
     };
+  };
 
-    system func postupgrade() {
-        canisters := HashMap.fromIter<Principal, CanisterId>(upgradeCanisters.vals(), 10, isPrincipalEqual, Principal.hash);
-        upgradeCanisters := [];
-    };
+  stable var temperatures : TemperatureSeries = [30.0, 31.5, 29.2];
+  flexible var weather = Weather(temperatures);
+};
 ```
 
+3. __Not recommended__: [Pre- and post-upgrade hooks](#preupgrade-and-postupgrade-system-methods) allow to copy non-stable types to stable types during upgrades.
+The downside of this approach is that it is error-prone and does not scale for large data. 
+Conceptually, it also does not align well with the idea of orthogonal persistence.
+
 ## Stable type signatures
 
 The collection of stable variable declarations in an actor can be summarized in a stable signature.
@@ -138,13 +118,14 @@ You can emit the stable signature of the main actor or actor class to a `.most`
 
 :::
 
-A stable signature `<stab-sig1>` is stable-compatible with signature `<stab-sig2>`, if:
+A stable signature `<stab-sig1>` is stable-compatible with signature `<stab-sig2>`, if for each stable field `<id> : T` in `<stab-sig1>` one of the following conditions hold:
 
--   Every immutable field `stable <id> : T` in `<stab-sig1>` has a matching field `stable <id> : U` in `<stab-sig2>` with `T <: U`.
+- `<stab-sig2>` does not contain a stable field `<id>`.
+- `<stab-sig>` has a matchng stable field `<id> : U` with `T <: U`.
 
--   Every mutable field `stable var <id> : T` in `<stab-sig1>` has a matching field `stable var <id> : U` in `<stab-sig2>` with `T <: U`.
+Note that `<stab-sig2>` may contain additional fields or abandon fields of `<stab-sig1>`. Mutability can be different for matching fields. 
 
-Note that `<stab-sig2>` may contain additional fields. Typically, `<stab-sig1>` is the signature of an older version while `<stab-sig2>` is the signature of a newer version.
+`<stab-sig1>` is the signature of an older version while `<stab-sig2>` is the signature of a newer version.
 
 The subtyping condition on stable fields ensures that the final value of some field can be consumed as the initial value of that field in the upgraded code.
 
@@ -154,27 +135,25 @@ You can check the stable-compatibility of two `.most` files containing stable si
 
 :::
 
-:::note
-
-The stable-compatible relation is quite conservative. In the future, it may be relaxed to accommodate a change in field mutability and/or abandoning fields from `<stab-sig1>` but with a warning.
-
-:::
 
 ## Upgrade safety
 
-Before upgrading a deployed canister, you should ensure that the upgrade is safe and will not:
+When upgrading a canister, it is important to verify that the upgrade can proceed without:
 
--   Break existing clients due to a Candid interface change.
+-   Introducing an incompatible change in stable declarations.
+-   Breaking clients due to a Candid interface change.
 
--   Discard Motoko stable state due to an incompatible change in stable declarations.
+With [enhanced orthogonal persistence](orthogonal-persistence/enhanced.md), Motoko rejects incompatible changes of stable declarations during upgrade attempt.
+Moreover, `dfx` checks the two conditions before attempting then upgrade and warns users correspondingly.
 
 A Motoko canister upgrade is safe provided:
 
--   The canister’s Candid interface evolves to a Candid subtype.
-
+-  The canister’s Candid interface evolves to a Candid subtype.
 -  The canister’s Motoko stable signature evolves to a stable-compatible one.
 
-Upgrade safety does not guarantee that the upgrade process will succeed, as it can still fail due to resource constraints. However, it should at least ensure that a successful upgrade will not break Candid type compatibility with existing clients or unexpectedly lose data that was marked `stable`.
+:::danger
+With [classical orthogonal persistence](orthogonal-persistence/classical.md), the upgrade can still fail due to resource constraints. This is problematic as the canister can then not be upgraded. It is therefore strongly advised to test the scalability of upgrades well. Enhanced orthogonal persistence will abandon this issue.
+:::
 
 :::tip
 
@@ -182,21 +161,71 @@ You can check valid Candid subtyping between two services described in `.did` fi
 
 :::
 
+## Upgrading a deployed actor or canister
+
+After you have deployed a Motoko actor with the appropriate `stable` variables, you can use the `dfx deploy` command to upgrade an already deployed version. For information about upgrading a deployed canister, see [upgrade a canister smart contract](/docs/current/developer-docs/smart-contracts/maintain/upgrade).
 
-## Metadata sections
+`dfx deploy` checks that the interface is compatible, and if not, show this message and ask if you want to continue:
 
-The Motoko compiler embeds the Candid interface and stable signature of a canister as canister metadata, recorded in additional Wasm custom sections of a compiled binary.
+```
+You are making a BREAKING change. Other canisters or frontend clients relying on your canister may stop working.
+```
 
-This metadata can be selectively exposed by ICP and used by tools such as `dfx` to verify upgrade compatibility.
+In addition, Motoko with enhanced orthogonal persistence implements extra safe guard in the runtime system to ensure that the stable data is compatible, to exclude any data corruption or misinterpretation. Moreover, `dfx` also warns about dropping of stable variables.
 
-## Upgrading a deployed actor or canister
+## Data migration
 
-After you have deployed a Motoko actor with the appropriate `stable` variables or `preupgrade` and `postupgrade` system methods, you can use the `dfx canister install` command with the `--mode=upgrade` option to upgrade an already deployed version. For information about upgrading a deployed canister, see [upgrade a canister smart contract](/docs/current/developer-docs/smart-contracts/maintain/upgrade).
+Often, the data representation changes with a new program version. For orthogonal persistence, it is important the language is able to allow flexible data migration to the new version.
 
-`dfx canister install --mode=upgrade` checks that the interface is compatible, and if not, show this message and ask if you want to continue:
+Motoko supports two kinds of data migrations: Implicit migration and explicit migration.
 
-```
-let msg = format!("Candid interface compatibility check failed for canister '{}'.\nYou are making a BREAKING change. Other canisters or frontend clients relying on your canister may stop working.\n\n", canister_info.get_name()) + &err;
-```
+### Implicit migration
+
+This is automatically supported when the new program version is stable-compatible with the old version. The runtime system of Motoko then automatically handles the migration on upgrade.
+
+More precisely, the following changes can be implicitly migrated:
+* Adding or removing actor fields.
+* Changing mutability of the actor field.
+* Removing record fields.
+* Adding variant fields.
+* Changing `Nat` to `Int`.
+* Shared function parameter contravariance and return type covariance.
+* Any change that is allowed by the Motoko's subtyping rule.
+
+### Explicit migration
+
+Any more complex migration is possible by user-defined functionality.
+
+For this purpose, a three step approach is taken:
+1. Introduce new variables of the desired types, while keeping the old declarations.
+2. Write logic to copy the state from the old variables to the new variables on upgrade.
+3. Drop the old declarations, once all data has been migrated.
+
+For more information, see the [example of explicit migration](compatibility.md#explicit-migration).
+
+## Legacy features
+
+The following aspects are retained for historical reasons and backwards compatibility:
+
+### Preupgrade and postupgrade system methods
+
+This is only advanced functionality that is not recommended for standard cases, as it is error-prone and can render the canister unusable.
+
+Motoko supports user-defined upgrade hooks that run immediately before and after an upgrade. These upgrade hooks allow to trigger additional logic on upgrade. 
+These hooks are declared as `system` functions with special names, `preugrade` and `postupgrade`. Both functions must have type `: () → ()`.
+
+:::danger
+If `preupgrade` raises a trap or hits the instruction limit or another IC computing limit, the upgrade cannot no longer succeed and the canister is stuck with the existing version.
+:::
+
+:::tip
+`postupgrade` is not needed as the equal effect can be achieved by introducing initializing expressions in the actor, e.g. non-stable let expressions or expression statements.
+:::
+
+### Stable Memory and stable regions
+
+Stable memory was introduced on the IC to allow upgrades in languages that do not implement orthogonal persistence of the main memory. This is the case with Motoko's classical persistence as well as other languages besides Motoko.
+
+Stable memory and stable regions can still be used in combination with orthogonal persistence, although there is little practical need for this with enhanced orthogonal persistence and the future large main memory capacity on the IC.
 
 <img src="https://github.com/user-attachments/assets/844ca364-4d71-42b3-aaec-4a6c3509ee2e" alt="Logo" width="150" height="150" />
diff --git a/doc/md/examples/count-v0.did b/doc/md/examples/count-v0.did
index f743214c13b..c4b13980af3 100644
--- a/doc/md/examples/count-v0.did
+++ b/doc/md/examples/count-v0.did
@@ -1,3 +1,3 @@
 service : {
-  inc: () -> (int);
-}
+  increment : () -> ();
+};
diff --git a/doc/md/examples/count-v0.mo b/doc/md/examples/count-v0.mo
index 5981d106d44..62ab0849f25 100644
--- a/doc/md/examples/count-v0.mo
+++ b/doc/md/examples/count-v0.mo
@@ -1,10 +1,10 @@
-actor Counter_v0 {
+import Debug "mo:base/Debug";
 
-  var state : Int = 0;
+actor Counter_v0 {
+  var state : Nat = 0;
 
-  public func inc() : async Int {
+  public func increment() : async () {
     state += 1;
-    return state;
+    Debug.print(debug_show (state));
   };
-
-}
+};
diff --git a/doc/md/examples/count-v0.most b/doc/md/examples/count-v0.most
index a1802043bdc..1fe45ff42ed 100644
--- a/doc/md/examples/count-v0.most
+++ b/doc/md/examples/count-v0.most
@@ -1,3 +1,2 @@
-actor {
-  
+actor {  
 };
diff --git a/doc/md/examples/count-v1.did b/doc/md/examples/count-v1.did
index f743214c13b..c4b13980af3 100644
--- a/doc/md/examples/count-v1.did
+++ b/doc/md/examples/count-v1.did
@@ -1,3 +1,3 @@
 service : {
-  inc: () -> (int);
-}
+  increment : () -> ();
+};
diff --git a/doc/md/examples/count-v1.mo b/doc/md/examples/count-v1.mo
index 2cc2360632d..b75935bb314 100644
--- a/doc/md/examples/count-v1.mo
+++ b/doc/md/examples/count-v1.mo
@@ -1,9 +1,10 @@
-actor Counter_v1 {
+import Debug "mo:base/Debug";
 
-  stable var state : Int = 0;
+actor Counter_v1 {
+  stable var state : Nat = 0;
 
-  public func inc() : async Int {
+  public func increment() : async () {
     state += 1;
-    return state;
+    Debug.print(debug_show (state));
   };
-}
+};
diff --git a/doc/md/examples/count-v1.most b/doc/md/examples/count-v1.most
index 31801da83fa..302a837fa10 100644
--- a/doc/md/examples/count-v1.most
+++ b/doc/md/examples/count-v1.most
@@ -1,3 +1,3 @@
 actor {
-  stable var state : Int
+  stable var state : Nat
 };
diff --git a/doc/md/examples/count-v2.did b/doc/md/examples/count-v2.did
index 57e9012e2bb..c4b13980af3 100644
--- a/doc/md/examples/count-v2.did
+++ b/doc/md/examples/count-v2.did
@@ -1,4 +1,3 @@
 service : {
-  inc: () -> (int);
-  read: () -> (int) query;
-}
+  increment : () -> ();
+};
diff --git a/doc/md/examples/count-v2.mo b/doc/md/examples/count-v2.mo
index 95c29027c77..cc288c81b86 100644
--- a/doc/md/examples/count-v2.mo
+++ b/doc/md/examples/count-v2.mo
@@ -1,11 +1,10 @@
-actor Counter_v2 {
+import Debug "mo:base/Debug";
 
+actor Counter_v2 {
   stable var state : Int = 0;
 
-  public func inc() : async Int {
+  public func increment() : async () {
     state += 1;
-    return state;
+    Debug.print(debug_show (state));
   };
-
-  public query func read() : async Int { return state; }
-}
+};
diff --git a/doc/md/examples/count-v3.did b/doc/md/examples/count-v3.did
index 902cf3b1469..cef4206e459 100644
--- a/doc/md/examples/count-v3.did
+++ b/doc/md/examples/count-v3.did
@@ -1,4 +1,5 @@
 service : {
-  inc: () -> (nat);
-  read: () -> (nat) query;
-}
+  increment : () -> ();
+  decrement : () -> ();
+  read : () -> (int) query;
+};
diff --git a/doc/md/examples/count-v3.mo b/doc/md/examples/count-v3.mo
index e9cb87d5c1d..aba6e495f3f 100644
--- a/doc/md/examples/count-v3.mo
+++ b/doc/md/examples/count-v3.mo
@@ -1,11 +1,15 @@
 actor Counter_v3 {
+  stable var state : Int = 0;
 
-  stable var state : Nat = 0;
-
-  public func inc() : async Nat {
+  public func increment() : async () {
     state += 1;
-    return state;
   };
 
-  public query func read() : async Nat { return state; }
-}
+  public func decrement() : async () {
+    state -= 1;
+  };
+
+  public query func read() : async Int {
+    return state;
+  };
+};
diff --git a/doc/md/examples/count-v3.most b/doc/md/examples/count-v3.most
index 302a837fa10..31801da83fa 100644
--- a/doc/md/examples/count-v3.most
+++ b/doc/md/examples/count-v3.most
@@ -1,3 +1,3 @@
 actor {
-  stable var state : Nat
+  stable var state : Int
 };
diff --git a/doc/md/examples/count-v4.mo b/doc/md/examples/count-v4.mo
index f12e2fba784..22234fc879a 100644
--- a/doc/md/examples/count-v4.mo
+++ b/doc/md/examples/count-v4.mo
@@ -1,14 +1,17 @@
-import Int "mo:base/Int";
+import Float "mo:base/Float";
 
 actor Counter_v4 {
+  stable var state : Float = 0.0;
 
-  stable var state : Int = 0;
-  stable var newState : Nat = Int.abs(state);
+  public func increment() : async () {
+    state += 0.5;
+  };
 
-  public func inc() : async Nat {
-    newState += 1;
-    return newState;
+  public func decrement() : async () {
+    state -= 0.5;
   };
 
-  public query func read() : async Nat { return newState; }
-}
+  public query func read() : async Float {
+    return state;
+  };
+};
diff --git a/doc/md/examples/count-v5.mo b/doc/md/examples/count-v5.mo
new file mode 100644
index 00000000000..58843e7b29f
--- /dev/null
+++ b/doc/md/examples/count-v5.mo
@@ -0,0 +1,23 @@
+import Debug "mo:base/Debug";
+import Float "mo:base/Float";
+
+actor Counter_v5 {
+  stable var state : Int = 0;
+  stable var newState : Float = Float.fromInt(state);
+
+  public func increment() : async () {
+    newState += 0.5;
+  };
+
+  public func decrement() : async () {
+    newState -= 0.5;
+  };
+
+  public query func read() : async Int {
+    Debug.trap("No longer supported: Use `readFloat`");
+  };
+
+  public query func readFloat() : async Float {
+    return newState;
+  };
+};
diff --git a/doc/md/examples/count-v6.mo b/doc/md/examples/count-v6.mo
new file mode 100644
index 00000000000..e0c6f0df284
--- /dev/null
+++ b/doc/md/examples/count-v6.mo
@@ -0,0 +1,22 @@
+import Debug "mo:base/Debug";
+import Float "mo:base/Float";
+
+actor Counter_v6 {
+  stable var newState : Float = 0.0;
+
+  public func increment() : async () {
+    newState += 0.5;
+  };
+
+  public func decrement() : async () {
+    newState -= 0.5;
+  };
+
+  public query func read() : async Int {
+    Debug.trap("No longer supported: Use `readFloat`");
+  };
+
+  public query func readFloat() : async Float {
+    return newState;
+  };
+};
diff --git a/doc/md/getting-started/motoko-introduction.md b/doc/md/getting-started/motoko-introduction.md
index b2dd2f28a69..b4d450cade0 100644
--- a/doc/md/getting-started/motoko-introduction.md
+++ b/doc/md/getting-started/motoko-introduction.md
@@ -18,6 +18,8 @@ Motoko provides:
 
 -   An **actor-based** programming model optimized for efficient message handling.
 
+-   **Orthogonal persistence** for simple, safe, and efficient data storage without a database or secondary memory.
+
 -   An interpreter and compiler that you can use to test and compile the WebAssembly code for autonomous applications.
 
 # Why Motoko?
@@ -87,9 +89,7 @@ Motoko provides numerous features to help you leverage orthogonal persistence, i
 
 For example, Motoko lets you declare certain variables as `stable`. The values of `stable` variables are automatically preserved across canister upgrades.
 
-Once upgraded, the new interface is compatible with the previous one, meaning existing clients referencing the canister will continue to work, but new clients will be able to exploit its upgraded functionality.
-
-For scenarios that can’t be solved using stable variables alone, Motoko provides user-definable upgrade hooks that run immediately before and after upgrade, and allow you to migrate arbitrary state to stable variables.
+Once upgraded, the new interface is compatible with the previous one, meaning existing clients referencing the canister will continue to work, but new clients will be able to exploit its upgraded functionality. For more complex changes of any kind, Motoko provides a safe way of user-defined [explicit migration](../canister-maintenance/compatibility.md#explicit-migration).
 
 ## Getting started
 
diff --git a/doc/md/reference/compiler-ref.md b/doc/md/reference/compiler-ref.md
index b43f9d3f139..f98aad255d0 100644
--- a/doc/md/reference/compiler-ref.md
+++ b/doc/md/reference/compiler-ref.md
@@ -32,14 +32,19 @@ You can use the following options with the `moc` command.
 | `--args0 <file>`                          | Read additional `NUL` separated command line arguments from `<file>`.                                                                                 |
 | `-c`                                      | Compile to WebAssembly.                                                                                                                               |
 | `--check`                                 | Performs type checking only.                                                                                                                          |
+| `--compacting-gc`                         | Use compacting GC (not supported with enhanced orthogonal persistence).                                                                               |
+| `--copying-gc`                            | Use copying GC (default with classical persistence, not supported with enhanced orthogonal persistence).                                              |
 | `--debug`                                 | Respects debug expressions in the source (the default).                                                                                               |
+| `--enhanced-orthogonal-persistence`       | Use enhanced orthogonal persistence (experimental): Scalable and fast upgrades using a persistent 64-bit main memory.                                 |
 | `--error-detail <n>`                      | Set level of error message detail for syntax errors, n in \[0..3\] (default 2).                                                                       |
 | `--experimental-stable-memory <n>`        | Select support for the deprecated `ExperimentalStableMemory.mo` library (n < 0: error, n = 0: warn, n > 0: allow) (default 0).                        |
 | `-fno-shared-code`                        | Do not share low-level utility code: larger code size but decreased cycle consumption (default).                                                      |
+| `--generational-gc`                       | Use generational GC (not supported with enhanced orthogonal persistence)                                                                              |
 | `-fshared-code`                           | Do share low-level utility code: smaller code size but increased cycle consumption.                                                                   |
 | `-help`,`--help`                          | Displays usage information.                                                                                                                           |
 | `--hide-warnings`                         | Hides compiler warnings.                                                                                                                              |
 | `-Werror`                                 | Treat warnings as errors.                                                                                                                             |
+| `--incremental-gc`                        | Use incremental GC (default of enhanced orthogonal persistence, also available for classical persistence)                                             |
 | `--idl`                                   | Compile binary and emit Candid IDL specification to `.did` file.                                                                                      |
 | `-i`                                      | Runs the compiler in an interactive read–eval–print loop (REPL) shell so you can evaluate program execution (implies -r).                             |
 | `--map`                                   | Outputs a JavaScript source map.                                                                                                                      |
@@ -57,6 +62,7 @@ You can use the following options with the `moc` command.
 | `--stable-regions`                        | Force eager initialization of stable regions metadata (for testing purposes); consumes between 386KiB or 8MiB of additional physical stable memory, depending on current use of ExperimentalStableMemory. |
 | `--stable-types`                          | Compile binary and emit signature of stable types to `.most` file.                                                                                    |
 | `--stable-compatible <pre> <post>`        | Test upgrade compatibility between stable-type signatures `<pre>` and `<post>`.                                                                       |
+| `--rts-stack-pages <n>`                   | Set maximum number of pages available for runtime system stack (only supported with classical persistence, default 32).                               |
 | `--trap-on-call-error`                    | Trap, don't throw an [`Error`](../base/Error.md), when an IC call fails due to destination queue full or freezing threshold is crossed.               |
 |                                           | Emulates behaviour of moc versions < 0.8.0.                                                                                                           |
 | `-t`                                      | Activates tracing in interpreter.                                                                                                                     |
diff --git a/doc/md/stable-memory/stable-regions.md b/doc/md/stable-memory/stable-regions.md
index 85850008559..9b6c8b0ddf1 100644
--- a/doc/md/stable-memory/stable-regions.md
+++ b/doc/md/stable-memory/stable-regions.md
@@ -8,19 +8,13 @@ sidebar_position: 1
 
 The `Region` library provides low-level access to ICP stable memory feature.
 
-<!--
-TODO: extend example to illustrate stableVarQuery
--->
+Stable regions were historically introduced with [classical orthogonal persistence](../canister-maintenance/orthogonal-persistence/classical.md) to allow larger scaled data to be retained across upgrades. For this purpose, programmers could explicitly store persistent data in stable memory, with regions helping to isolate different instances using stable memory.
 
-Motoko stable variables require serialization and deserialization on [upgrade](../canister-maintenance/upgrades.md). During an upgrade, the current values of stable variables are first saved to the ICP stable memory, then restored from stable memory after the new code is installed. This mechanism, however, does not scale to canisters that maintain large amounts of data in stable variables. There may not be enough cycle budget to store then restore all stable variables within an upgrade, resulting in failed upgrades.
-
-Due to the current 32-bit address space of Motoko, stable variables cannot store more than 4GiB of data.
-
-Additionally, some stable variables use a representation that is not itself `stable`, requiring a non-trivial pre-upgrade routine to pre-process the data into a `stable` form.  These pre-upgrade steps are critical, and if they trap for any reason, the Motoko canister may be stuck in an evolutionary dead-end, unable to upgrade.
+This is superseded by [enhanced orthogonal persistence](../canister-maintenance/orthogonal-persistence/enhanced.md). Nevertheless, regions are still offered for backwards-compatibility and for specific use cases where developers prefer to manage data explicitly in a persistent linear memory.
 
 ## The `Region` library
 
-To avoid these upgrade hazards, actors can elect to use the [ExperimentalStableMemory](stablememory.md) or [`Region`](../base/Region.md) libraries in package `base`. The `Region` library allows the programmer to incrementally allocate pages of 64-bit stable memory and use those pages to incrementally read and write data in a user-defined binary format.
+The [`Region`](../base/Region.md) library in package `base` allows the programmer to incrementally allocate pages of 64-bit stable memory and use those pages to incrementally read and write data in a user-defined binary format.
 
 Several pages may be allocated at once, with each page containing 64KiB. Allocation may fail due to resource limits imposed by ICP. Pages are zero-initialized.
 
@@ -81,6 +75,16 @@ module {
 }
 ```
 
+:::danger
+A stable region exposes low-level linear memory and it is the programmer's task to properly manipulate and interpret this data.
+This can be very error-prone when managing data in a stable region.
+However, the safety of Motoko's native values heap objects is always guaranteed, independent of the stable region content.
+::: 
+
+:::note
+The cost of accessing stable regions is significantly higher than using Motoko's native memory, i.e. regular Motoko values and objects.
+:::
+
 ## Example
 
 To demonstrate the `Region` library, the following is a simple implementation of a logging actor that records text messages in a scalable, persistent log.
diff --git a/nix/default.nix b/nix/default.nix
index 7e266fa6ea8..4823456b5d3 100644
--- a/nix/default.nix
+++ b/nix/default.nix
@@ -108,9 +108,9 @@ let
           };
         })
 
-        # Rust 1.69
+        # Rust stable
         (self: super: let
-          rust-channel = self.moz_overlay.rustChannelOf { date = "2023-04-20"; channel = "stable"; };
+          rust-channel = self.moz_overlay.rustChannelOf { version = "1.78.0"; channel = "stable"; };
         in {
           rustPlatform_moz_stable = self.makeRustPlatform {
             rustc = rust-channel.rust;
diff --git a/nix/drun.nix b/nix/drun.nix
index 267e4810cca..7c69c049063 100644
--- a/nix/drun.nix
+++ b/nix/drun.nix
@@ -1,6 +1,6 @@
 pkgs:
 { drun =
-    pkgs.rustPlatform.buildRustPackage {
+    pkgs.rustPlatform_moz_stable.buildRustPackage {
       name = "drun";
 
       src = pkgs.sources.ic;
@@ -19,12 +19,10 @@ pkgs:
         lockFile = "${pkgs.sources.ic}/Cargo.lock";
         outputHashes = {
           "build-info-0.0.27" = "sha256-SkwWwDNrTsntkNiCv6rsyTFGazhpRDnKtVzPpYLKF9U=";
-          "derive_more-0.99.8-alpha.0" = "sha256-tEsfYC9oCAsDjinCsUDgRg3q6ruvayuA1lRmsEP9cys=";
-          "ic-btc-interface-0.1.0" = "sha256-JoVg1t62C2FIe0la1oQzidybLj1CyAQy80gkRh/MTn0=";
-          "ic-btc-test-utils-0.1.0" = "sha256-VecEMFjoeiRi0VgJ9CeDoOzdyJbJNiZ5MBmiV1+b7As=";
-          "icrc1-test-env-0.1.1" = "sha256-yWJF+KM8l65Nr0pwR9QeltkqbHDzOLNPVnLhf1mRukQ=";
+          "cloudflare-0.11.0" = "sha256-bJYiypmDI4KEy/VWt/7UcOv+g2CZLb9qUA9c1xlLxhM=";
+          "ic-agent-0.36.0" = "sha256-vDONIVjz0cwVgiszVRIjTKcqRUMHdVwTURflAMqmzHM=";
+          "icrc1-test-env-0.1.1" = "sha256-2PB7e64Owin/Eji3k8UoeWs+pfDfOOTaAyXjvjOZ/4g=";
           "jsonrpc-0.12.1" = "sha256-3FtdZlt2PqVDkE5iKWYIp1eiIELsaYlUPRSP2Xp8ejM=";
-          "libssh2-sys-0.2.23" = "sha256-9Hb7CnPF+lxrVO1NAhS7EXcPVWZutJXr6UWxpptzk4U=";
           "lmdb-rkv-0.14.99" = "sha256-5WcUzapkrc/s3wCBNCuUDhtbp17n67rTbm2rx0qtITg=";
         };
       };
@@ -43,9 +41,64 @@ pkgs:
 
      for file in lib_sources {
 EOF
-
         cd -
 
+        # Disable DTS for `drun`
+        patch rs/config/src/subnet_config.rs << EOF
+@@ -290,9 +290,9 @@ impl SchedulerConfig {
+     }
+ 
+     pub fn system_subnet() -> Self {
+-        let max_instructions_per_message_without_dts = NumInstructions::from(50 * B);
++        let max_instructions_per_message_without_dts =
++            MAX_INSTRUCTIONS_PER_MESSAGE_WITHOUT_DTS * SYSTEM_SUBNET_FACTOR;
+         let max_instructions_per_install_code = NumInstructions::from(1_000 * B);
+-        let max_instructions_per_slice = NumInstructions::from(10 * B);
+         Self {
+             scheduler_cores: NUMBER_OF_EXECUTION_THREADS,
+             max_paused_executions: MAX_PAUSED_EXECUTIONS,
+@@ -300,20 +300,19 @@ impl SchedulerConfig {
+             // TODO(RUN-993): Enable heap delta rate limiting for system subnets.
+             // Setting initial reserve to capacity effectively disables the rate limiting.
+             heap_delta_initial_reserve: SUBNET_HEAP_DELTA_CAPACITY,
+-            // Round limit is set to allow on average 2B instructions.
+-            // See also comment about \`MAX_INSTRUCTIONS_PER_ROUND\`.
+-            max_instructions_per_round: max_instructions_per_message_without_dts
+-                .max(max_instructions_per_slice)
+-                + NumInstructions::from(2 * B),
++            max_instructions_per_round: MAX_INSTRUCTIONS_PER_ROUND * SYSTEM_SUBNET_FACTOR,
++            // Effectively disable DTS on system subnets.
+             max_instructions_per_message: max_instructions_per_message_without_dts,
+             max_instructions_per_message_without_dts,
+-            max_instructions_per_slice,
++            // Effectively disable DTS on system subnets.
++            max_instructions_per_slice: max_instructions_per_message_without_dts,
+             instruction_overhead_per_execution: INSTRUCTION_OVERHEAD_PER_EXECUTION,
+             instruction_overhead_per_canister: INSTRUCTION_OVERHEAD_PER_CANISTER,
+             instruction_overhead_per_canister_for_finalization:
+                 INSTRUCTION_OVERHEAD_PER_CANISTER_FOR_FINALIZATION,
+             max_instructions_per_install_code,
+-            max_instructions_per_install_code_slice: max_instructions_per_slice,
++            // Effectively disable DTS on system subnets.
++            max_instructions_per_install_code_slice: max_instructions_per_install_code,
+             max_heap_delta_per_iteration: MAX_HEAP_DELTA_PER_ITERATION * SYSTEM_SUBNET_FACTOR,
+             max_message_duration_before_warn_in_seconds:
+                 MAX_MESSAGE_DURATION_BEFORE_WARN_IN_SECONDS,
+EOF
+
+        # static linking of libunwind fails under nix Linux
+        patch rs/monitoring/backtrace/build.rs << EOF
+@@ -1,8 +1,2 @@
+ fn main() {
+-    if std::env::var("TARGET").unwrap() == "x86_64-unknown-linux-gnu" {
+-        println!("cargo:rustc-link-lib=static=unwind");
+-        println!("cargo:rustc-link-lib=static=unwind-ptrace");
+-        println!("cargo:rustc-link-lib=static=unwind-x86_64");
+-        println!("cargo:rustc-link-lib=dylib=lzma");
+-    }
+ }
+EOF
+
         mkdir -p .cargo
         cat > .cargo/config.toml << EOF
 [target.x86_64-apple-darwin]
diff --git a/nix/sources.json b/nix/sources.json
index 5668002540a..074cba24db2 100644
--- a/nix/sources.json
+++ b/nix/sources.json
@@ -21,15 +21,15 @@
         "version": "3.2.25"
     },
     "ic": {
-        "branch": "pull/143/head",
+        "branch": "luc/latest-ic-wasm64-test",
         "description": "Internet Computer blockchain source: the client/replica software run by nodes",
         "homepage": "",
-        "owner": "dfinity",
+        "owner": "luc-blaeser",
         "repo": "ic",
-        "rev": "31f02c1b08aef1c6ee4c1b6bb9d25c21c5a4ff41",
-        "sha256": "04k278900kv082axrgv6vga0n8sw6c3lcc9298ih9gjyx8hanfb1",
+        "rev": "7921f5f3dc0d9fb774e3222f8ff6b1c00a086f1a",
+        "sha256": "1ykawbpaqnf1y508vh81m30p813ykmnbffxc3p0hw0p0k1ynq6zz",
         "type": "tarball",
-        "url": "https://github.com/dfinity/ic/archive/31f02c1b08aef1c6ee4c1b6bb9d25c21c5a4ff41.tar.gz",
+        "url": "https://github.com/luc-blaeser/ic/archive/7921f5f3dc0d9fb774e3222f8ff6b1c00a086f1a.tar.gz",
         "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
     },
     "ic-hs": {
@@ -72,13 +72,13 @@
     "motoko-base": {
         "branch": "next-moc",
         "description": "The Motoko base library",
-        "homepage": null,
+        "homepage": "",
         "owner": "dfinity",
         "repo": "motoko-base",
-        "rev": "4abc98e92909d7b178629912057473302cf0d8be",
-        "sha256": "09yhfk17rb9xk2cvi6353hfb43df05pg0x1gw5qrf8n0g0dvd3jx",
+        "rev": "dfabfc3201950263a0057f5d1a78d2ede5c87478",
+        "sha256": "1wd9rcmhg82h08l3gz3gmn2xpgalvf679w7yz2g35yzbg2b5g2fd",
         "type": "tarball",
-        "url": "https://github.com/dfinity/motoko-base/archive/4abc98e92909d7b178629912057473302cf0d8be.tar.gz",
+        "url": "https://github.com/dfinity/motoko-base/archive/dfabfc3201950263a0057f5d1a78d2ede5c87478.tar.gz",
         "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
     },
     "motoko-matchers": {
@@ -133,6 +133,18 @@
         "url": "https://github.com/mozilla/nixpkgs-mozilla/archive/1ca9ee7192f973fd67b0988bdd77b8c11ae245a6.tar.gz",
         "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
     },
+    "nixpkgs-unstable": {
+        "branch": "master",
+        "description": "Nix Packages collection & NixOS",
+        "homepage": "",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "9d2864289e65d0dc841123ae86bc7b3f77b6d12d",
+        "sha256": "0f3bcphzrjm1hs81mhpfx1hqxfnbvhhv5hv82wi1h3f735i279ja",
+        "type": "tarball",
+        "url": "https://github.com/NixOS/nixpkgs/archive/9d2864289e65d0dc841123ae86bc7b3f77b6d12d.tar.gz",
+        "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
+    },
     "ocaml-vlq": {
         "branch": "v0.2.0",
         "builtin": false,
diff --git a/perf-delta.nix b/perf-delta.nix
index 3a6ebed3693..d4ede1f6236 100644
--- a/perf-delta.nix
+++ b/perf-delta.nix
@@ -37,7 +37,7 @@ let
         do
           # ignore all errors
           echo -n $file
-          if timeout 10s moc $file --omit-metadata motoko:compiler --force-gc --compacting-gc -no-check-ir -ref-system-api -o $file.wasm 2>/dev/null
+          if timeout 10s moc $file --omit-metadata motoko:compiler -no-check-ir -ref-system-api -o $file.wasm 2>/dev/null
           then echo " ok"
           else echo " failed (ignored)"
           fi
diff --git a/rts/Makefile b/rts/Makefile
index 052952ee45d..7f55ab3eff1 100644
--- a/rts/Makefile
+++ b/rts/Makefile
@@ -21,7 +21,7 @@ TOMMATHFILES = \
    s_mp_mul_digs_fast s_mp_mul_digs mp_init_multi mp_clear_multi mp_mul_2 mp_div_2 mp_div_3 mp_lshd mp_incr \
    mp_decr mp_add_d mp_sub_d
 
-MUSLFILES = \
+MUSLFILES_32 = \
   pow pow_data sin cos tan asin acos atan atan2 exp exp_data log log_data fmod \
   floor scalbn frexp strlen strnlen memcpy memset memchr memcmp snprintf vsnprintf vfprintf \
   __math_oflow __math_uflow __math_xflow __math_divzero __math_invalid \
@@ -37,8 +37,7 @@ MUSL_WASI_SYSROOT ?= $(MUSLSRC)/../../sysroot
 # manager
 #
 
-TOMMATH_FLAGS = \
-  -DMP_32BIT \
+TOMMATH_FLAGS_COMMON = \
   -DMP_MALLOC=mp_malloc \
   -DMP_REALLOC=mp_realloc \
   -DMP_CALLOC=mp_calloc \
@@ -47,7 +46,13 @@ TOMMATH_FLAGS = \
   -DMP_FIXED_CUTOFFS \
   -DMP_PREC=4 \
   -DMP_NO_FILE \
-  -D__STDC_IEC_559__ \
+  -D__STDC_IEC_559__
+
+TOMMATH_FLAGS_32 = $(TOMMATH_FLAGS_COMMON) \
+  -DMP_32BIT
+
+TOMMATH_FLAGS_64 = $(TOMMATH_FLAGS_COMMON) \
+  -DMP_64BIT
 
 # Note: the above __STDC_IEC_559__ define is somewhat of a misnomer
 #       as only IEEE 754 features are used.
@@ -63,11 +68,11 @@ TOMMATH_FLAGS = \
 #       and will need tweaks/additions below.
 #       Similarly we define include guards (to suppress certain headers), but those should be
 #       pretty stable.
-#       TODO: run `wasm2wat mo-rts.wasm | grep -F '(import' | grep __fwritex_` expecting empty.
+#       TODO: run `wasm2wat --enable-memory64 mo-rts-eop.wasm | grep -F '(import' | grep __fwritex_` expecting empty.
 #
 #       See also https://stackoverflow.com/questions/1597007/creating-c-macro-with-and-line-token-concatenation-with-positioning-macr
 
-MUSL_FLAGS = \
+MUSL_FLAGS_32 = \
   -isystem $(MUSLSRC)/arch/wasm32 \
   -isystem $(MUSLSRC)/src/include \
   -isystem $(MUSLSRC)/src/internal \
@@ -91,66 +96,77 @@ MUSL_FLAGS = \
   -D__NEED_locale_t \
   -Dsqrt=__builtin_sqrt \
   -Dfabs=__builtin_fabs
-
 #
 # clang flags
 #
 
-CLANG_FLAGS = \
-   --compile \
+CLANG_FLAGS_COMMON = \
+	--compile \
    -fpic \
    -fvisibility=hidden \
    --std=c11 \
-   --target=wasm32-emscripten \
    -fno-builtin -ffreestanding \
    --optimize=s \
    -resource-dir=$(wildcard $(WASM_CLANG_LIB)/lib/clang/*)
 
+CLANG_FLAGS_32 = $(CLANG_FLAGS_COMMON) \
+   --target=wasm32-emscripten
+
+CLANG_FLAGS_64 = $(CLANG_FLAGS_COMMON) \
+   --target=wasm64
+
 #
 # Build targets
 #
 
 .PHONY: all
 
-all: mo-rts.wasm mo-rts-debug.wasm
+all: mo-rts-non-incremental.wasm mo-rts-non-incremental-debug.wasm mo-rts-incremental.wasm mo-rts-incremental-debug.wasm mo-rts-eop.wasm mo-rts-eop-debug.wasm
 
 _build:
 	mkdir -p $@
 
-_build/wasm:
+_build/wasm64:
 	mkdir -p $@
 
-_build/i686:
+_build/wasm32:
 	mkdir -p $@
 
+# 
+# Common configuration
+# 
+
+RTS_EMSCRIPTEN_64=emcc -c --target=wasm64-unknown-emscripten -fpic
+RTS_EMSCRIPTEN_64_DEBUG=$(RTS_EMSCRIPTEN_64)
+RTS_EMSCRIPTEN_64_RELEASE=$(RTS_EMSCRIPTEN_64) -O2
+
 #
-# Let make automatically search these directorys (tommath and musl) for .c files
+# Let make automatically search these directories (tommath and musl) for .c files
 #
 
 vpath %.c $(MUSLSRC)/src/math $(MUSLSRC)/src/stdio $(MUSLSRC)/src/string $(MUSLSRC)/src/ctype $(TOMMATHSRC)
 
-
 #
 # Building the libtommath files
 #
 
-TOMMATH_WASM_O=$(TOMMATHFILES:%=_build/wasm/tommath_%.o)
-TOMMATH_WASM_A=_build/libtommath.a
+TOMMATH_WASM_32_O=$(TOMMATHFILES:%=_build/wasm32/tommath_%.o)
+TOMMATH_WASM_32_A=_build/libtommath_wasm32.a
+
+TOMMATH_WASM_64_O=$(TOMMATHFILES:%=_build/wasm64/tommath_%.o)
+TOMMATH_WASM_64_A=_build/libtommath_wasm64.a
 
-TOMMATH_i686_O=$(TOMMATHFILES:%=_build/i686/tommath_%.o)
-TOMMATH_i686_A=_build/libtommath_i686.a
+_build/wasm32/tommath_%.o: bn_%.c | _build/wasm32
+	$(WASM_CLANG) $(CLANG_FLAGS_32) $(TOMMATH_FLAGS_32) $< --output $@
 
-_build/wasm/tommath_%.o: bn_%.c | _build/wasm
-	$(WASM_CLANG) $(CLANG_FLAGS) $(TOMMATH_FLAGS) $< --output $@
+_build/wasm64/tommath_%.o: bn_%.c | _build/wasm64
+	$(WASM_CLANG) $(CLANG_FLAGS_64) $(TOMMATH_FLAGS_64) $< --output $@
 
-$(TOMMATH_WASM_A): $(TOMMATH_WASM_O)
+$(TOMMATH_WASM_32_A): $(TOMMATH_WASM_32_O)
 	llvm-ar rcs $@ $^
 	llvm-ranlib $@
 
-_build/i686/tommath_%.o: bn_%.c | _build/i686
-	$(WASM_CLANG) $(CLANG_FLAGS) $(TOMMATH_FLAGS) --target=i686-unknown-linux $< --output $@
-
-$(TOMMATH_i686_A): $(TOMMATH_i686_O)
+$(TOMMATH_WASM_64_A): $(TOMMATH_WASM_64_O)
 	llvm-ar rcs $@ $^
 	llvm-ranlib $@
 
@@ -158,14 +174,13 @@ $(TOMMATH_i686_A): $(TOMMATH_i686_O)
 # Building the musl files
 #
 
-MUSL_WASM_O=$(MUSLFILES:%=_build/wasm/musl_%.o)
-MUSL_WASM_A=_build/libmusl.a
-
-_build/wasm/musl_%.o: %.c | _build/wasm
-	$(WASM_CLANG) $(CLANG_FLAGS) $(MUSL_FLAGS) $< --output $@
+MUSL_WASM_32_O=$(MUSLFILES_32:%=_build/wasm32/musl_%.o)
+MUSL_WASM_32_A=_build/libmusl_wasm32.a
 
+_build/wasm32/musl_%.o: %.c | _build/wasm32
+	$(WASM_CLANG) $(CLANG_FLAGS_32) $(MUSL_FLAGS_32) $< --output $@
 
-$(MUSL_WASM_A): $(MUSL_WASM_O)
+$(MUSL_WASM_32_A): $(MUSL_WASM_32_O)
 	llvm-ar rcs $@ $^
 	llvm-ranlib $@
 
@@ -177,12 +192,12 @@ $(MUSL_WASM_A): $(MUSL_WASM_O)
 RTS_RUST_FILES=$(shell ls **/*.rs)
 RTS_CARGO_FILES=$(shell ls **/Cargo.toml)
 
-TOMMATH_BINDINGS_RS=_build/tommath_bindings.rs
+TOMMATH_BINDINGS_RS_32=_build/wasm32/tommath_bindings.rs
+TOMMATH_BINDINGS_RS_64=_build/wasm64/tommath_bindings.rs
 
-$(TOMMATH_BINDINGS_RS): | _build
-	bindgen $(TOMMATHSRC)/tommath.h \
-	    -o $@ \
-	    --use-core --ctypes-prefix=libc --no-layout-tests \
+TOMMATH_BIND_OPTIONS = \
+		--use-core \
+		--no-layout-tests \
 	    --allowlist-function mp_init \
 	    --allowlist-function mp_init_copy \
 	    --allowlist-function mp_set_u32 \
@@ -210,7 +225,21 @@ $(TOMMATH_BINDINGS_RS): | _build
 	    --blocklist-type __int64_t \
 	    --blocklist-type __uint32_t \
 	    --blocklist-type __uint64_t \
-            -- $(TOMMATH_FLAGS)
+
+
+$(TOMMATH_BINDINGS_RS_32): | _build/wasm32
+	bindgen $(TOMMATHSRC)/tommath.h \
+	    -o $@ \
+	    --ctypes-prefix=libc \
+		$(TOMMATH_BIND_OPTIONS) \
+		-- $(TOMMATH_FLAGS_32)
+
+$(TOMMATH_BINDINGS_RS_64): | _build/wasm64
+	bindgen $(TOMMATHSRC)/tommath.h \
+	    -o $@ \
+	    --ctypes-prefix="crate::libc_declarations" \
+		$(TOMMATH_BIND_OPTIONS) \
+		-- $(TOMMATH_FLAGS_64)
 
 	# Whitelist parameters used as libtommath.h has lots of definitions that we don't
 	# need. Blacklist parameters are used because bindgen still generates unused type
@@ -219,43 +248,160 @@ $(TOMMATH_BINDINGS_RS): | _build
 	# Note that bindgen can't generate Rust macros or functions for CPP macros, so
 	# macros like `mp_get_u32` and `mp_isneg` need to be manually implemented.
 
-RTS_DEPENDENCIES=$(TOMMATH_BINDINGS_RS) $(RTS_RUST_FILES) $(RTS_CARGO_FILES) | _build/wasm
-RTS_BUILD=cd motoko-rts && cargo build --target=wasm32-unknown-emscripten -Zbuild-std=core,alloc
-RTS_DEBUG_BUILD=$(RTS_BUILD)
-RTS_RELEASE_BUILD=$(RTS_BUILD) --release
-RTS_DEBUG_TARGET=motoko-rts/target/wasm32-unknown-emscripten/debug/libmotoko_rts.a
-RTS_RELEASE_TARGET=motoko-rts/target/wasm32-unknown-emscripten/release/libmotoko_rts.a
+# 32-bit Wasm builds
+
+RTS_DEPENDENCIES_32=$(TOMMATH_BINDINGS_RS_32) $(RTS_RUST_FILES) $(RTS_CARGO_FILES) | _build/wasm32
+RTS_BUILD_32=cd motoko-rts && cargo build --target=wasm32-unknown-emscripten -Zbuild-std=core,alloc
+RTS_DEBUG_BUILD_32=$(RTS_BUILD_32)
+RTS_RELEASE_BUILD_32=$(RTS_BUILD_32) --release
+RTS_DEBUG_TARGET_32=motoko-rts/target/wasm32-unknown-emscripten/debug/libmotoko_rts.a
+RTS_RELEASE_TARGET_32=motoko-rts/target/wasm32-unknown-emscripten/release/libmotoko_rts.a
+
+RTS_RUST_NON_INCREMENTAL_WASM_32_A=_build/wasm32/libmotoko_rts.a
+RTS_RUST_NON_INCREMENTAL_DEBUG_WASM_32_A=_build/wasm32/libmotoko_rts_debug.a
+
+RTS_RUST_INCREMENTAL_WASM_32_A=_build/wasm32/libmotoko_rts_incremental.a
+RTS_RUST_INCREMENTAL_DEBUG_WASM_32_A=_build/wasm32/libmotoko_rts_incremental_debug.a
+
+$(RTS_RUST_NON_INCREMENTAL_WASM_32_A): $(RTS_DEPENDENCIES_32)
+	$(RTS_RELEASE_BUILD_32) --features classical_persistence
+	cp $(RTS_RELEASE_TARGET_32) $@
+
+$(RTS_RUST_NON_INCREMENTAL_DEBUG_WASM_32_A): $(RTS_DEPENDENCIES_32)
+	$(RTS_DEBUG_BUILD_32) --features classical_persistence
+	cp $(RTS_DEBUG_TARGET_32) $@
+
+$(RTS_RUST_INCREMENTAL_WASM_32_A): $(RTS_DEPENDENCIES_32)
+	$(RTS_RELEASE_BUILD_32) --features classical_persistence,incremental_gc
+	cp $(RTS_RELEASE_TARGET_32) $@
+
+$(RTS_RUST_INCREMENTAL_DEBUG_WASM_32_A): $(RTS_DEPENDENCIES_32)
+	$(RTS_DEBUG_BUILD_32) --features classical_persistence,incremental_gc
+	cp $(RTS_DEBUG_TARGET_32) $@
+
+# 64-bit Wasm builds
+
+RTS_DEPENDENCIES_64=$(TOMMATH_BINDINGS_RS_64) $(RTS_RUST_FILES) $(RTS_CARGO_FILES) | _build/wasm64
+COMPILER_FLAGS_64=--emit=llvm-ir
+RTS_BUILD_64=cd motoko-rts && RUSTFLAGS="${COMPILER_FLAGS_64}" cargo build --target=wasm64-unknown-unknown -Zbuild-std=core,alloc --features enhanced_orthogonal_persistence
+RTS_DEBUG_BUILD_64=$(RTS_BUILD_64)
+RTS_RELEASE_BUILD_64=$(RTS_BUILD_64) --release
+
+RTS_DEBUG_TARGET_64_FOLDER=motoko-rts/target/wasm64-unknown-unknown/debug
+RTS_RELEASE_TARGET_64_FOLDER=motoko-rts/target/wasm64-unknown-unknown/release
+
+RTS_DEBUG_TARGET_64=$(RTS_DEBUG_TARGET_64_FOLDER)/deps/motoko_rts-*.ll
+RTS_RELEASE_TARGET_64=$(RTS_RELEASE_TARGET_64_FOLDER)/deps/motoko_rts-*.ll
+
+CORE_DEBUG_TARGET_64=$(RTS_DEBUG_TARGET_64_FOLDER)/deps/core-*.ll
+CORE_RELEASE_TARGET_64=$(RTS_RELEASE_TARGET_64_FOLDER)/deps/core-*.ll
+
+ALLOC_DEBUG_TARGET_64=$(RTS_DEBUG_TARGET_64_FOLDER)/deps/alloc-*.ll
+ALLOC_RELEASE_TARGET_64=$(RTS_RELEASE_TARGET_64_FOLDER)/deps/alloc-*.ll
+
+COMPILER_BUILTINS_DEBUG_TARGET_64=$(RTS_DEBUG_TARGET_64_FOLDER)/deps/compiler_builtins-*.ll
+COMPILER_BUILTINS_RELEASE_TARGET_64=$(RTS_RELEASE_TARGET_64_FOLDER)/deps/compiler_builtins-*.ll
+
+BUILD_64_FOLDER=_build/wasm64
+
+RTS_RUST_LLVM_IR_64=$(BUILD_64_FOLDER)/libmotoko_rts.ll
+RTS_RUST_DEBUG_LLVM_IR_64=$(BUILD_64_FOLDER)/libmotoko_rts_debug.ll
 
-RTS_RUST_WASM_A=_build/wasm/libmotoko_rts.a
-RTS_RUST_DEBUG_WASM_A=_build/wasm/libmotoko_rts_debug.a
+CORE_DEBUG_LLVM_IR_64=$(BUILD_64_FOLDER)/core_debug.ll
+CORE_RELEASE_LLVM_IR_64=$(BUILD_64_FOLDER)/core.ll
 
-$(RTS_RUST_WASM_A): $(RTS_DEPENDENCIES)
-	$(RTS_RELEASE_BUILD)
-	cp $(RTS_RELEASE_TARGET) $@
+ALLOC_DEBUG_LLVM_IR_64=$(BUILD_64_FOLDER)/alloc_debug.ll
+ALLOC_RELEASE_LLVM_IR_64=$(BUILD_64_FOLDER)/alloc.ll
 
-$(RTS_RUST_DEBUG_WASM_A): $(RTS_DEPENDENCIES)
-	$(RTS_DEBUG_BUILD)
-	cp $(RTS_DEBUG_TARGET) $@
+COMPILER_BUILTINS_DEBUG_LLVM_IR_64=$(BUILD_64_FOLDER)/compiler_builtins_debug.ll
+COMPILER_BUILTINS_RELEASE_LLVM_IR_64=$(BUILD_64_FOLDER)/compiler_builtins.ll
+
+$(RTS_RUST_LLVM_IR_64): $(RTS_DEPENDENCIES_64)
+	rm -rf $(RTS_RELEASE_TARGET_64_FOLDER)
+	$(RTS_RELEASE_BUILD_64)
+	cp $(CORE_RELEASE_TARGET_64) -T $(CORE_RELEASE_LLVM_IR_64)
+	cp $(ALLOC_RELEASE_TARGET_64) -T $(ALLOC_RELEASE_LLVM_IR_64)
+	cp $(COMPILER_BUILTINS_RELEASE_TARGET_64) -T $(COMPILER_BUILTINS_RELEASE_LLVM_IR_64)
+	cp $(RTS_RELEASE_TARGET_64) -T $@
+
+$(RTS_RUST_DEBUG_LLVM_IR_64): $(RTS_DEPENDENCIES_64)
+	rm -rf $(RTS_DEBUG_TARGET_64_FOLDER) 
+	$(RTS_DEBUG_BUILD_64)
+	cp $(CORE_DEBUG_TARGET_64) -T $(CORE_DEBUG_LLVM_IR_64)
+	cp $(ALLOC_DEBUG_TARGET_64) -T $(ALLOC_DEBUG_LLVM_IR_64)
+	cp $(COMPILER_BUILTINS_DEBUG_TARGET_64) -T $(COMPILER_BUILTINS_DEBUG_LLVM_IR_64)
+	cp $(RTS_DEBUG_TARGET_64) -T $@
+
+RTS_RUST_WASM_64_A=$(BUILD_64_FOLDER)/libmotoko_rts.o
+RTS_RUST_DEBUG_WASM_64_A=$(BUILD_64_FOLDER)/libmotoko_rts_debug.o
+
+CORE_WASM_64_A=$(BUILD_64_FOLDER)/core.o
+CORE_DEBUG_WASM_64_A=$(BUILD_64_FOLDER)/core_debug.o
+
+ALLOC_WASM_64_A=$(BUILD_64_FOLDER)/alloc.o
+ALLOC_DEBUG_WASM_64_A=$(BUILD_64_FOLDER)/alloc_debug.o
+
+COMPILER_BUILTINS_WASM_64_A=$(BUILD_64_FOLDER)/compiler_builtins.o
+COMPILER_BUILTINS_DEBUG_WASM_64_A=$(BUILD_64_FOLDER)/compiler_builtins_debug.o
+
+$(RTS_RUST_WASM_64_A): $(RTS_RUST_LLVM_IR_64)
+	$(RTS_EMSCRIPTEN_64_RELEASE) -o $@ $+
+
+$(RTS_RUST_DEBUG_WASM_64_A): $(RTS_RUST_DEBUG_LLVM_IR_64)
+	$(RTS_EMSCRIPTEN_64_DEBUG) -o $@ $+
+
+$(CORE_WASM_64_A): $(CORE_RELEASE_LLVM_IR_64)
+	$(RTS_EMSCRIPTEN_64_RELEASE) -o $@ $+
+
+$(CORE_DEBUG_WASM_64_A): $(CORE_DEBUG_LLVM_IR_64)
+	$(RTS_EMSCRIPTEN_64_DEBUG) -o $@ $+
+
+$(ALLOC_WASM_64_A): $(ALLOC_RELEASE_LLVM_IR_64)
+	$(RTS_EMSCRIPTEN_64_RELEASE) -o $@ $+
+
+$(ALLOC_DEBUG_WASM_64_A): $(ALLOC_DEBUG_LLVM_IR_64)
+	$(RTS_EMSCRIPTEN_64_DEBUG) -o $@ $+
+
+$(COMPILER_BUILTINS_WASM_64_A): $(COMPILER_BUILTINS_RELEASE_LLVM_IR_64)
+	$(RTS_EMSCRIPTEN_64_RELEASE) -o $@ $+
+
+$(COMPILER_BUILTINS_DEBUG_WASM_64_A): $(COMPILER_BUILTINS_DEBUG_LLVM_IR_64)
+	$(RTS_EMSCRIPTEN_64_DEBUG) -o $@ $+
 
 #
 # The test suite
 #
 
-TEST_DEPENDENCIES=$(TOMMATH_WASM_A) $(TOMMATH_BINDINGS_RS)
-TEST_BUILD=cd motoko-rts-tests && cargo build --target=wasm32-wasi
-TEST_RUN=wasmtime -C cache=n -W nan-canonicalization=y motoko-rts-tests/target/wasm32-wasi/debug/motoko-rts-tests.wasm
+TEST_DEPENDENCIES_32=$(TOMMATH_WASM_32_A) $(TOMMATH_BINDINGS_RS_32)
+TEST_BUILD_32=cd motoko-rts-tests && cargo build --target=wasm32-wasi
+TEST_RUN_32=wasmtime -C cache=n -W nan-canonicalization=y motoko-rts-tests/target/wasm32-wasi/debug/motoko-rts-tests.wasm
+
+TEST_DEPENDENCIES_64=$(TOMMATH_WASM_64_A) $(TOMMATH_BINDINGS_RS_64)
+TEST_BUILD_64=cd motoko-rts-tests && cargo build --target=wasm64-unknown-unknown -Zbuild-std=core,alloc,std,panic_abort --features enhanced_orthogonal_persistence
+TEST_RUN_64=wasmtime -C cache=n -W nan-canonicalization=y -W memory64 motoko-rts-tests/target/wasm64-unknown-unknown/debug/motoko-rts-tests.wasm
 
 .PHONY: test
 
-test: $(TEST_DEPENDENCIES)
-	$(TEST_BUILD)
-	$(TEST_RUN)
+test: test32-non-incremental test32-incremental test64
+
+test32-non-incremental: $(TEST_DEPENDENCIES_32)
+	$(TEST_BUILD_32) --features classical_persistence
+	$(TEST_RUN_32)
+
+test32-incremental: $(TEST_DEPENDENCIES_32)
+	$(TEST_BUILD_32) --features classical_persistence,incremental_gc
+	$(TEST_RUN_32)
+
+test64: $(TEST_DEPENDENCIES_64)
+	$(TEST_BUILD_64)
+	$(TEST_RUN_64)
 
 #
 # Putting it all together
 #
 
 # These symbols from musl are used by the code generator directly
+
 EXPORTED_SYMBOLS=\
   __wasm_call_ctors \
   memcpy \
@@ -270,22 +416,49 @@ EXPORTED_SYMBOLS=\
   cos \
   exp \
   fmod \
-  log \
+  log
 
-WASM_A_DEPENDENCIES=$(TOMMATH_WASM_A) $(MUSL_WASM_A)
-LINKER_OPTIONS=\
+WASM_A_DEPENDENCIES_32=$(TOMMATH_WASM_32_A) $(MUSL_WASM_32_A)
+LINKER_OPTIONS_32=\
   --import-memory --shared --no-entry --gc-sections \
   $(EXPORTED_SYMBOLS:%=--export=%) \
   --whole-archive
 
-mo-rts.wasm: $(RTS_RUST_WASM_A) $(WASM_A_DEPENDENCIES)
+WASM_A_DEPENDENCIES_64=$(TOMMATH_WASM_64_A)
+LINKER_OPTIONS_64=\
+  -mwasm64 --import-memory --shared --no-entry --gc-sections \
+  $(EXPORTED_SYMBOLS:%=--export=%) \
+  --whole-archive
+
+
+mo-rts-non-incremental.wasm: $(RTS_RUST_NON_INCREMENTAL_WASM_32_A) $(WASM_A_DEPENDENCIES_32)
+	$(WASM_LD) -o $@ \
+		$(LINKER_OPTIONS_32) \
+		$+
+
+mo-rts-non-incremental-debug.wasm: $(RTS_RUST_NON_INCREMENTAL_DEBUG_WASM_32_A) $(WASM_A_DEPENDENCIES_32)
+	$(WASM_LD) -o $@ \
+		$(LINKER_OPTIONS_32) \
+		$+
+
+mo-rts-incremental.wasm: $(RTS_RUST_INCREMENTAL_WASM_32_A) $(WASM_A_DEPENDENCIES_32)
+	$(WASM_LD) -o $@ \
+		$(LINKER_OPTIONS_32) \
+		$+
+
+mo-rts-incremental-debug.wasm: $(RTS_RUST_INCREMENTAL_DEBUG_WASM_32_A) $(WASM_A_DEPENDENCIES_32)
+	$(WASM_LD) -o $@ \
+		$(LINKER_OPTIONS_32) \
+		$+
+
+mo-rts-eop.wasm: $(RTS_RUST_WASM_64_A) $(CORE_WASM_64_A) $(ALLOC_WASM_64_A) $(COMPILER_BUILTINS_WASM_64_A) $(WASM_A_DEPENDENCIES_64)
 	$(WASM_LD) -o $@ \
-		$(LINKER_OPTIONS) \
+		$(LINKER_OPTIONS_64) \
 		$+
 
-mo-rts-debug.wasm: $(RTS_RUST_DEBUG_WASM_A) $(WASM_A_DEPENDENCIES)
+mo-rts-eop-debug.wasm: $(RTS_RUST_DEBUG_WASM_64_A) $(CORE_DEBUG_WASM_64_A) $(ALLOC_DEBUG_WASM_64_A) $(COMPILER_BUILTINS_DEBUG_WASM_64_A) $(WASM_A_DEPENDENCIES_64)
 	$(WASM_LD) -o $@ \
-		$(LINKER_OPTIONS) \
+		$(LINKER_OPTIONS_64) \
 		$+
 
 format:
@@ -300,4 +473,4 @@ clean:
 	  motoko-rts/target \
 	  motoko-rts-tests/target \
 	  motoko-rts-macros/target \
-	  motoko-rts/cargo-home
+	  motoko-rts/cargo-home \
diff --git a/rts/README.md b/rts/README.md
index 0afe4cd7d66..b50cef615ea 100644
--- a/rts/README.md
+++ b/rts/README.md
@@ -6,7 +6,7 @@ This directory contains the parts of the Motoko runtime implemented in Rust.
 tl;dr
 -----
 
-If you just want to get `mo-rts.wasm` in this directory, run
+If you just want to get RTS wasm files in this directory, run
 
     nix-shell --run 'make -C rts'
 
@@ -15,7 +15,7 @@ from the top-level directory of the Motoko repository.
 Compilation
 -----------
 
-Running `make` should produce `mo-rts.wasm`.
+Running `make` should produce RTS Wasm files (different versions).
 
 If run within `nix-shell`, the environment variables `WASM_CLANG` and `WASM_LD`
 should point to suitable binaries (we track a specific unreleased version of
diff --git a/rts/motoko-rts-macros/Cargo.lock b/rts/motoko-rts-macros/Cargo.lock
index 229431b180c..8e125546d33 100644
--- a/rts/motoko-rts-macros/Cargo.lock
+++ b/rts/motoko-rts-macros/Cargo.lock
@@ -13,27 +13,27 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.50"
+version = "1.0.67"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ef7d57beacfaf2d8aee5937dab7b7f28de3cb8b1828479bb5de2a7106f2bae2"
+checksum = "3d433d9f1a3e8c1263d9456598b16fec66f4acc9a74dacffd35c7bb09b3a1328"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.23"
+version = "1.0.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8856d8364d252a14d474036ea1358d63c9e6965c8e5c1885c18f73d70bff9c7b"
+checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae"
 dependencies = [
  "proc-macro2",
 ]
 
 [[package]]
 name = "syn"
-version = "1.0.107"
+version = "1.0.109"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f4064b5b16e03ae50984a5a8ed5d4f8803e6bc1fd170a3cda91a1be4b18e3f5"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -42,6 +42,6 @@ dependencies = [
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.6"
+version = "1.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84a22b9f218b40614adcb3f4ff08b703773ad44fa9423e4e0d346d5db86e4ebc"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
diff --git a/rts/motoko-rts-macros/Cargo.toml b/rts/motoko-rts-macros/Cargo.toml
index 08e37be9cf5..5af623a0ac7 100644
--- a/rts/motoko-rts-macros/Cargo.toml
+++ b/rts/motoko-rts-macros/Cargo.toml
@@ -8,6 +8,6 @@ edition = "2018"
 proc_macro = true
 
 [dependencies]
-proc-macro2 = "1.0.50"
-syn = { version = "1.0.107", features = ["full"] }
-quote = "1.0.23"
+proc-macro2 = "1.0.66"
+syn = { version = "1.0.109", features = ["full"] }
+quote = "1.0.26"
diff --git a/rts/motoko-rts-macros/src/lib.rs b/rts/motoko-rts-macros/src/lib.rs
index 49ac0e18d3e..10c47079284 100644
--- a/rts/motoko-rts-macros/src/lib.rs
+++ b/rts/motoko-rts-macros/src/lib.rs
@@ -136,3 +136,67 @@ pub fn ic_mem_fn(attr: TokenStream, input: TokenStream) -> TokenStream {
     )
     .into()
 }
+
+/// Feature macro for incremental GC features, in particular forwarding pointers.
+/// Equivalent to using the attribute `#[cfg(feature = "incremental_gc")]`.
+#[proc_macro_attribute]
+pub fn incremental_gc(attr: TokenStream, input: TokenStream) -> TokenStream {
+    assert!(attr.is_empty());
+    let block = syn::parse_macro_input!(input as syn::Item);
+    quote!(
+        #[cfg(feature = "incremental_gc")]
+        #block
+    )
+    .into()
+}
+
+/// Feature macro for non-incremental GC features, in particular forwarding pointers.
+/// Equivalent to using the attribute `#[cfg(not(feature = "incremental_gc"))]`.
+#[proc_macro_attribute]
+pub fn non_incremental_gc(attr: TokenStream, input: TokenStream) -> TokenStream {
+    assert!(attr.is_empty());
+    let block = syn::parse_macro_input!(input as syn::Item);
+    quote!(
+        #[cfg(not(feature = "incremental_gc"))]
+        #block
+    )
+    .into()
+}
+
+#[proc_macro]
+pub fn is_incremental_gc(_item: TokenStream) -> TokenStream {
+    "cfg!(feature = \"incremental_gc\")".parse().unwrap()
+}
+
+/// Feature macro for enhanced orthogonal persistence.
+/// Equivalent to using the attribute `#[cfg(feature = "enhanced_orthogonal_persistence")]`.
+#[proc_macro_attribute]
+pub fn enhanced_orthogonal_persistence(attr: TokenStream, input: TokenStream) -> TokenStream {
+    assert!(attr.is_empty());
+    let block = syn::parse_macro_input!(input as syn::Item);
+    quote!(
+        #[cfg(feature = "enhanced_orthogonal_persistence")]
+        #block
+    )
+    .into()
+}
+
+/// Feature macro for classical persistence, based on Candid stabilization.
+/// Equivalent to using the attribute `#[cfg(not(feature = "enhanced_orthogonal_persistence"))]`.
+#[proc_macro_attribute]
+pub fn classical_persistence(attr: TokenStream, input: TokenStream) -> TokenStream {
+    assert!(attr.is_empty());
+    let block = syn::parse_macro_input!(input as syn::Item);
+    quote!(
+        #[cfg(not(feature = "enhanced_orthogonal_persistence"))]
+        #block
+    )
+    .into()
+}
+
+#[proc_macro]
+pub fn uses_enhanced_orthogonal_persistence(_item: TokenStream) -> TokenStream {
+    "cfg!(feature = \"enhanced_orthogonal_persistence\")"
+        .parse()
+        .unwrap()
+}
diff --git a/rts/motoko-rts-tests/Cargo.lock b/rts/motoko-rts-tests/Cargo.lock
index dea7c950617..a822b629b70 100644
--- a/rts/motoko-rts-tests/Cargo.lock
+++ b/rts/motoko-rts-tests/Cargo.lock
@@ -20,12 +20,6 @@ version = "1.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
 
-[[package]]
-name = "cfg-if"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
-
 [[package]]
 name = "fxhash"
 version = "0.2.1"
@@ -36,27 +30,16 @@ dependencies = [
 ]
 
 [[package]]
-name = "getrandom"
-version = "0.2.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c85e1d9ab2eadba7e5040d4e09cbd6d072b76a557ad64e797c2cb9d4da21d7e4"
-dependencies = [
- "cfg-if",
- "libc",
- "wasi",
-]
-
-[[package]]
-name = "lazy_static"
-version = "1.4.0"
+name = "libc"
+version = "0.2.153"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd"
 
 [[package]]
-name = "libc"
-version = "0.2.142"
+name = "libm"
+version = "0.2.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a987beff54b60ffa6d51982e1aa1146bc42f19bd26be28b0586f252fccf5317"
+checksum = "f7012b1bbb0719e1097c47611d3898568c546d597c2e74d66f6087edd5233ff4"
 
 [[package]]
 name = "motoko-rts"
@@ -81,7 +64,6 @@ version = "0.1.0"
 dependencies = [
  "byteorder",
  "fxhash",
- "libc",
  "motoko-rts",
  "motoko-rts-macros",
  "oorandom",
@@ -95,6 +77,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
 dependencies = [
  "autocfg",
+ "libm",
 ]
 
 [[package]]
@@ -111,41 +94,33 @@ checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.56"
+version = "1.0.66"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b63bdb0cd06f1f4dedf69b254734f9b45af66e4a031e42a7480257d9898b435"
+checksum = "18fb31db3f9bddb2ea821cde30a9f70117e3f119938b5ee630b7403aa6e2ead9"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "proptest"
-version = "1.0.0"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e0d9cc07f18492d879586c92b485def06bc850da3118075cd45d50e9c95b0e5"
+checksum = "4e35c06b98bf36aba164cc17cb25f7e232f5c4aeea73baa14b8a9f0d92dbfa65"
 dependencies = [
  "bitflags",
  "byteorder",
- "lazy_static",
  "num-traits",
- "quick-error",
  "rand",
  "rand_chacha",
  "rand_xorshift",
- "regex-syntax",
+ "unarray",
 ]
 
-[[package]]
-name = "quick-error"
-version = "2.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
-
 [[package]]
 name = "quote"
-version = "1.0.26"
+version = "1.0.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4424af4bf778aae2051a77b60283332f386554255d722233d09fbfc7e30da2fc"
+checksum = "5fe8a65d69dd0808184ebb5f836ab526bb259db23c657efa38711b1072ee47f0"
 dependencies = [
  "proc-macro2",
 ]
@@ -156,8 +131,6 @@ version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
 dependencies = [
- "libc",
- "rand_chacha",
  "rand_core",
 ]
 
@@ -176,9 +149,6 @@ name = "rand_core"
 version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
-dependencies = [
- "getrandom",
-]
 
 [[package]]
 name = "rand_xorshift"
@@ -189,12 +159,6 @@ dependencies = [
  "rand_core",
 ]
 
-[[package]]
-name = "regex-syntax"
-version = "0.6.29"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
-
 [[package]]
 name = "syn"
 version = "1.0.109"
@@ -207,13 +171,13 @@ dependencies = [
 ]
 
 [[package]]
-name = "unicode-ident"
-version = "1.0.8"
+name = "unarray"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5464a87b239f13a63a501f2701565754bae92d243d4bb7eb12f6d57d2269bf4"
+checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94"
 
 [[package]]
-name = "wasi"
-version = "0.11.0+wasi-snapshot-preview1"
+name = "unicode-ident"
+version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+checksum = "301abaae475aa91687eb82514b328ab47a211a533026cb25fc3e519b86adfc3c"
diff --git a/rts/motoko-rts-tests/Cargo.toml b/rts/motoko-rts-tests/Cargo.toml
index 82558e9caf6..61147688f00 100644
--- a/rts/motoko-rts-tests/Cargo.toml
+++ b/rts/motoko-rts-tests/Cargo.toml
@@ -4,11 +4,16 @@ version = "0.1.0"
 authors = ["dfinity <team-motoko@dfinity.org"]
 edition = "2018"
 
+[features]
+incremental_gc = ["motoko-rts/incremental_gc"]
+classical_persistence = ["motoko-rts/classical_persistence"]
+enhanced_orthogonal_persistence = ["motoko-rts/enhanced_orthogonal_persistence", "incremental_gc"]
+
 [dependencies]
 byteorder = "1.4.3"
 fxhash = "0.2.1"
-libc = { version = "0.2.139", default_features = false }
+# libc = { version = "0.2.139", default_features = false }
 motoko-rts = { path = "../motoko-rts/native" }
 oorandom = "11.1.3"
-proptest = { version = "1.0.0", default-features = false, features = ["std"] }
+proptest = { version = "1.0.0", default-features = false, features = ["alloc"] }
 motoko-rts-macros = { path = "../motoko-rts-macros" }
diff --git a/rts/motoko-rts-tests/build.rs b/rts/motoko-rts-tests/build.rs
index 90327ce458b..227bfac6743 100644
--- a/rts/motoko-rts-tests/build.rs
+++ b/rts/motoko-rts-tests/build.rs
@@ -2,9 +2,14 @@ fn main() {
     let target = std::env::var("TARGET").unwrap();
 
     match target.as_str() {
+        "wasm64-unknown-unknown" => {
+            println!("cargo:rustc-link-search=native=../_build");
+            println!("cargo:rustc-link-lib=static=tommath_wasm64");
+        }
+
         "wasm32-wasi" => {
             println!("cargo:rustc-link-search=native=../_build");
-            println!("cargo:rustc-link-lib=static=tommath");
+            println!("cargo:rustc-link-lib=static=tommath_wasm32");
         }
 
         "i686-unknown-linux-gnu" => {
diff --git a/rts/motoko-rts-tests/src/bigint.rs b/rts/motoko-rts-tests/src/bigint.rs
index 2bf93a7dde8..4180be6cd27 100644
--- a/rts/motoko-rts-tests/src/bigint.rs
+++ b/rts/motoko-rts-tests/src/bigint.rs
@@ -1,4 +1,5 @@
 use crate::memory::{initialize_test_memory, reset_test_memory, TestMemory};
+use std::ffi::c_void;
 
 use motoko_rts::bigint::{self, *};
 use motoko_rts::buf::Buf;
@@ -10,17 +11,21 @@ use motoko_rts::types::{Bytes, Value};
 // This global is used to pass a reference to heap to the mp functions
 static mut HEAP: *mut TestMemory = std::ptr::null_mut();
 
+pub unsafe fn set_bigint_heap(heap: *mut TestMemory) {
+    HEAP = heap;
+}
+
 #[no_mangle]
-unsafe extern "C" fn mp_calloc(n_elems: usize, elem_size: Bytes<usize>) -> *mut libc::c_void {
+unsafe extern "C" fn mp_calloc(n_elems: usize, elem_size: Bytes<usize>) -> *mut c_void {
     bigint::mp_calloc(&mut *HEAP, n_elems, elem_size)
 }
 
 #[no_mangle]
 unsafe extern "C" fn mp_realloc(
-    ptr: *mut libc::c_void,
-    old_size: Bytes<u32>,
-    new_size: Bytes<u32>,
-) -> *mut libc::c_void {
+    ptr: *mut c_void,
+    old_size: Bytes<usize>,
+    new_size: Bytes<usize>,
+) -> *mut c_void {
     bigint::mp_realloc(&mut *HEAP, ptr, old_size, new_size)
 }
 
@@ -28,13 +33,13 @@ pub unsafe fn test() {
     println!("Testing BigInt ...");
 
     let mut heap = initialize_test_memory();
-    HEAP = &mut heap;
+    set_bigint_heap(&mut heap);
 
     assert!(bigint_eq(
-        bigint_pow(bigint_of_word32(70), bigint_of_word32(32)),
+        bigint_pow(bigint_of_word64(70), bigint_of_word64(32)),
         bigint_mul(
-            bigint_pow(bigint_of_word32(70), bigint_of_word32(31)),
-            bigint_of_word32(70)
+            bigint_pow(bigint_of_word64(70), bigint_of_word64(31)),
+            bigint_of_word64(70)
         )
     ));
 
@@ -42,10 +47,10 @@ pub unsafe fn test() {
     // (s)leb128 encoding
     //
 
-    let one = bigint_of_word32(1);
-    let two = bigint_of_word32(2);
+    let one = bigint_of_word64(1);
+    let two = bigint_of_word64(2);
     for i in 0..100 {
-        let two_pow_i = bigint_pow(two, bigint_of_word32(i));
+        let two_pow_i = bigint_pow(two, bigint_of_word64(i));
         let minus_one = bigint_sub(two_pow_i, one);
         let plus_one = bigint_add(two_pow_i, one);
 
@@ -61,7 +66,7 @@ pub unsafe fn test() {
         test_bigint_sleb128(bigint_neg(plus_one));
     }
 
-    HEAP = std::ptr::null_mut();
+    set_bigint_heap(std::ptr::null_mut());
     reset_test_memory();
     drop(heap);
 }
diff --git a/rts/motoko-rts-tests/src/bitrel.rs b/rts/motoko-rts-tests/src/bitrel.rs
index a6d650accb0..b79e96d6de4 100644
--- a/rts/motoko-rts-tests/src/bitrel.rs
+++ b/rts/motoko-rts-tests/src/bitrel.rs
@@ -1,21 +1,29 @@
 use motoko_rts::bitrel::BitRel;
+use motoko_rts_macros::uses_enhanced_orthogonal_persistence;
 
 pub unsafe fn test() {
     println!("Testing bitrel ...");
 
-    const K: u32 = 128;
+    const K: usize = 48;
 
-    const N: usize = (2 * K * K * 2 / usize::BITS) as usize;
+    const N: usize = 2 * K * K * 2 / usize::BITS as usize;
 
-    let mut cache: [u32; N] = [0xFFFFFFF; N];
+    let mut cache: [usize; N] = [0xFFFFFFF; N];
 
-    assert_eq!(usize::BITS, 32);
+    assert_eq!(
+        usize::BITS,
+        if uses_enhanced_orthogonal_persistence!() {
+            64
+        } else {
+            32
+        }
+    );
     for size1 in 0..K {
         for size2 in 0..K {
             let w = BitRel::words(size1, size2);
             let bitrel = BitRel {
                 ptr: &mut cache[0],
-                end: &mut cache[w as usize],
+                end: &mut cache[w],
                 size1: size1,
                 size2: size2,
             };
diff --git a/rts/motoko-rts-tests/src/continuation_table.rs b/rts/motoko-rts-tests/src/continuation_table.rs
index 9021e1312b4..9f83fa28f64 100644
--- a/rts/motoko-rts-tests/src/continuation_table.rs
+++ b/rts/motoko-rts-tests/src/continuation_table.rs
@@ -19,21 +19,21 @@ pub unsafe fn test() {
 
     let pointers: [Value; N] = from_fn(|_| alloc_blob(&mut heap, TAG_BLOB_B, Bytes(0)));
 
-    let mut references: [u32; N] = [0; N];
+    let mut references: [usize; N] = [0; N];
     for i in 0..N {
         references[i] = remember_continuation(&mut heap, pointers[i]);
-        assert_eq!(continuation_count(), (i + 1) as u32);
+        assert_eq!(continuation_count(), i + 1);
     }
 
     for i in 0..N / 2 {
         let c = recall_continuation(&mut heap, references[i]);
         assert_eq!(c.get_ptr(), pointers[i].get_ptr());
-        assert_eq!(continuation_count(), (N - i - 1) as u32);
+        assert_eq!(continuation_count(), N - i - 1);
     }
 
     for i in 0..N / 2 {
         references[i] = remember_continuation(&mut heap, pointers[i]);
-        assert_eq!(continuation_count(), (N / 2 + i + 1) as u32);
+        assert_eq!(continuation_count(), N / 2 + i + 1);
     }
 
     for i in (0..N).rev() {
@@ -41,7 +41,7 @@ pub unsafe fn test() {
             recall_continuation(&mut heap, references[i]).get_ptr(),
             pointers[i].get_ptr(),
         );
-        assert_eq!(continuation_count(), i as u32);
+        assert_eq!(continuation_count(), i);
     }
 
     reset_test_memory();
diff --git a/rts/motoko-rts-tests/src/gc.rs b/rts/motoko-rts-tests/src/gc.rs
index c1bc94ff821..bd6c9b57b86 100644
--- a/rts/motoko-rts-tests/src/gc.rs
+++ b/rts/motoko-rts-tests/src/gc.rs
@@ -5,26 +5,37 @@
 //
 // To convert an offset into an address, add heap array's address to the offset.
 
-mod heap;
+use motoko_rts_macros::{
+    classical_persistence, enhanced_orthogonal_persistence, incremental_gc, non_incremental_gc,
+};
+
+#[classical_persistence]
+mod classical;
+#[enhanced_orthogonal_persistence]
+mod enhanced;
+
+#[non_incremental_gc]
+mod compacting;
+#[non_incremental_gc]
+mod generational;
+#[incremental_gc]
 mod incremental;
-mod random;
-mod utils;
 
-use heap::MotokoHeap;
-use utils::{get_scalar_value, make_pointer, read_word, unskew_pointer, ObjectIdx, WORD_SIZE};
-
-use motoko_rts::types::*;
-
-use std::fmt::Write;
+pub mod heap;
+pub mod random;
+pub mod utils;
 
+use self::utils::{GC, GC_IMPLS};
 use fxhash::{FxHashMap, FxHashSet};
+use heap::MotokoHeap;
+use utils::ObjectIdx;
 
 pub fn test() {
     println!("Testing garbage collection ...");
 
     println!("  Testing pre-defined heaps...");
     for test_heap in test_heaps() {
-        test_gcs(&test_heap);
+        run_gc_tests(&test_heap);
     }
 
     println!("  Testing random heaps...");
@@ -39,6 +50,13 @@ pub fn test() {
     test_gc_components();
 }
 
+#[non_incremental_gc]
+fn test_gc_components() {
+    compacting::test();
+    generational::test();
+}
+
+#[incremental_gc]
 fn test_gc_components() {
     incremental::test();
 }
@@ -77,43 +95,52 @@ fn test_heaps() -> Vec<TestHeap> {
     ]
 }
 
-fn test_random_heap(seed: u64, max_objects: u32) {
+fn test_random_heap(seed: u64, max_objects: usize) {
     let random_heap = random::generate(seed, max_objects);
-    test_gcs(&random_heap);
+    run_gc_tests(&random_heap);
 }
 
 // All fields are vectors to preserve ordering. Objects are allocated/ added to root arrays etc. in
 // the same order they appear in these vectors. Each object in `heap` should have a unique index,
 // which is checked when creating the heap.
 #[derive(Debug)]
-struct TestHeap {
-    heap: Vec<(ObjectIdx, Vec<ObjectIdx>)>,
-    roots: Vec<ObjectIdx>,
-    continuation_table: Vec<ObjectIdx>,
+pub struct TestHeap {
+    pub heap: Vec<(ObjectIdx, Vec<ObjectIdx>)>,
+    pub roots: Vec<ObjectIdx>,
+    pub continuation_table: Vec<ObjectIdx>,
+}
+
+impl TestHeap {
+    pub fn build(&self, gc: GC, free_space: usize) -> MotokoHeap {
+        MotokoHeap::new(
+            &self.heap,
+            &self.roots,
+            &self.continuation_table,
+            gc,
+            free_space,
+        )
+    }
 }
 
 /// Test all GC implementations with the given heap
-fn test_gcs(heap_descr: &TestHeap) {
-    test_gc(
-        &heap_descr.heap,
-        &heap_descr.roots,
-        &heap_descr.continuation_table,
-    );
+fn run_gc_tests(test_heap: &TestHeap) {
+    for gc in &GC_IMPLS {
+        test_gc(*gc, test_heap);
+    }
     reset_gc();
 }
 
-fn test_gc(
-    refs: &[(ObjectIdx, Vec<ObjectIdx>)],
-    roots: &[ObjectIdx],
-    continuation_table: &[ObjectIdx],
-) {
-    let mut heap = MotokoHeap::new(refs, roots, continuation_table);
+fn test_gc(gc: GC, test_heap: &TestHeap) {
+    let mut heap = test_heap.build(gc, 0);
+    let refs = &test_heap.heap;
+    let roots = &test_heap.roots;
+    let continuation_table = &test_heap.continuation_table;
 
     initialize_gc(&mut heap);
 
     // Check `create_dynamic_heap` sanity
     check_dynamic_heap(
-        false, // before gc
+        CheckMode::Reachability,
         refs,
         roots,
         continuation_table,
@@ -125,8 +152,8 @@ fn test_gc(
         heap.region0_pointer_variable_offset(),
     );
 
-    for _ in 0..3 {
-        let check_all_reclaimed = run(&mut heap);
+    for round in 0..3 {
+        let check_all_reclaimed = gc.run(&mut heap, round);
 
         let heap_base_offset = heap.heap_base_offset();
         let heap_ptr_offset = heap.heap_ptr_offset();
@@ -134,7 +161,11 @@ fn test_gc(
         let continuation_table_variable_offset = heap.continuation_table_variable_offset();
         let region0_ptr_offset = heap.region0_pointer_variable_offset();
         check_dynamic_heap(
-            check_all_reclaimed, // check for unreachable objects
+            if check_all_reclaimed {
+                CheckMode::AllReclaimed
+            } else {
+                CheckMode::Reachability
+            },
             refs,
             roots,
             continuation_table,
@@ -148,24 +179,32 @@ fn test_gc(
     }
 }
 
+#[non_incremental_gc]
+fn initialize_gc(_heap: &mut MotokoHeap) {}
+
+#[incremental_gc]
 fn initialize_gc(heap: &mut MotokoHeap) {
     use motoko_rts::gc::incremental::{
         get_partitioned_heap, set_incremental_gc_state, IncrementalGC,
     };
+    use motoko_rts::types::Bytes;
     unsafe {
-        let state = IncrementalGC::initial_gc_state(heap, heap.heap_base_address());
+        let state = IncrementalGC::<MotokoHeap>::initial_gc_state(heap.heap_base_address());
         set_incremental_gc_state(Some(state));
         let allocation_size = heap.heap_ptr_address() - heap.heap_base_address();
 
         // Synchronize the partitioned heap with one big combined allocation by starting from the base pointer as the heap pointer.
-        let result =
-            get_partitioned_heap().allocate(heap, Bytes(allocation_size as u32).to_words());
+        let result = get_partitioned_heap().allocate(heap, Bytes(allocation_size).to_words());
         // Check that the heap pointer (here equals base pointer) is unchanged, i.e. no partition switch has happened.
         // This is a restriction in the unit test where `MotokoHeap` only supports contiguous bump allocation during initialization.
         assert_eq!(result.get_ptr(), heap.heap_base_address());
     }
 }
 
+#[non_incremental_gc]
+fn reset_gc() {}
+
+#[incremental_gc]
 fn reset_gc() {
     use motoko_rts::gc::incremental::set_incremental_gc_state;
     unsafe {
@@ -173,210 +212,69 @@ fn reset_gc() {
     }
 }
 
-/// Check the dynamic heap:
-///
-/// - All (and in post-gc mode, only) reachable objects should be in the heap. Reachable objects
-///   are those in the transitive closure of roots.
-///
-/// - Objects should point to right objects. E.g. if object with index X points to objects with
-///   indices Y and Z in the `objects` map, it should point to objects with indices Y and Z on the
-///   heap.
-///
-fn check_dynamic_heap(
-    post_gc: bool,
+#[derive(Debug, PartialEq)]
+pub enum CheckMode {
+    /// Check reachability of all necessary objects.
+    Reachability,
+    /// Check the reachability of all necessary objects and
+    /// that all garbage objects have been reclaimed.
+    AllReclaimed,
+    /// Check valid dynamic heap after stabilization.
+    #[cfg(feature = "enhanced_orthogonal_persistence")]
+    Stabilzation,
+}
+
+#[classical_persistence]
+pub fn check_dynamic_heap(
+    mode: CheckMode,
     objects: &[(ObjectIdx, Vec<ObjectIdx>)],
     roots: &[ObjectIdx],
     continuation_table: &[ObjectIdx],
     heap: &[u8],
     heap_base_offset: usize,
     heap_ptr_offset: usize,
-    static_root_array_variable_offset: usize,
+    _static_root_array_variable_offset: usize,
     continuation_table_variable_offset: usize,
     region0_ptr_offset: usize,
 ) {
-    let objects_map: FxHashMap<ObjectIdx, &[ObjectIdx]> = objects
-        .iter()
-        .map(|(obj, refs)| (*obj, refs.as_slice()))
-        .collect();
-
-    // Current offset in the heap
-    let mut offset = heap_base_offset;
-
-    // Maps objects to their addresses (not offsets!). Used when debugging duplicate objects.
-    let mut seen: FxHashMap<ObjectIdx, usize> = Default::default();
-
-    let static_root_array_address =
-        unskew_pointer(read_word(heap, static_root_array_variable_offset));
-    let static_root_array_offset = static_root_array_address as usize - heap.as_ptr() as usize;
-
-    let continuation_table_address =
-        unskew_pointer(read_word(heap, continuation_table_variable_offset));
-    let continuation_table_offset = continuation_table_address as usize - heap.as_ptr() as usize;
-
-    let region0_addr = unskew_pointer(read_word(heap, region0_ptr_offset));
-
-    while offset < heap_ptr_offset {
-        let object_offset = offset;
-
-        // Address of the current object. Used for debugging.
-        let address = offset as usize + heap.as_ptr() as usize;
-
-        if object_offset == static_root_array_offset {
-            check_static_root_array(object_offset, roots, heap);
-            offset += (size_of::<Array>() + Words(roots.len() as u32))
-                .to_bytes()
-                .as_usize();
-            continue;
-        }
-
-        if object_offset == continuation_table_offset {
-            check_continuation_table(object_offset, continuation_table, heap);
-            offset += (size_of::<Array>() + Words(continuation_table.len() as u32))
-                .to_bytes()
-                .as_usize();
-            continue;
-        }
-
-        let tag = read_word(heap, offset);
-        offset += WORD_SIZE;
-
-        if tag == TAG_ONE_WORD_FILLER {
-        } else if tag == TAG_FREE_SPACE {
-            let words = read_word(heap, offset) as usize;
-            offset += WORD_SIZE;
-            offset += words * WORD_SIZE;
-        } else {
-            let forward;
-            forward = read_word(heap, offset);
-            offset += WORD_SIZE;
-
-            let is_forwarded = forward != make_pointer(address as u32);
-
-            if tag == TAG_MUTBOX {
-                // MutBoxes of static root array, will be scanned indirectly when checking the static root array.
-                offset += WORD_SIZE;
-            } else if tag == TAG_BLOB_B {
-                assert!(!is_forwarded);
-                // in-heap mark stack blobs
-                let length = read_word(heap, offset);
-                offset += WORD_SIZE + length as usize;
-            } else if tag == TAG_REGION {
-                if !is_forwarded {
-                    assert_eq!(address, region0_addr as usize);
-                }
-                offset += (size_of::<Region>() - size_of::<Obj>())
-                    .to_bytes()
-                    .as_usize();
-            } else {
-                assert!(is_array_or_slice_tag(tag));
-
-                if is_forwarded {
-                    let forward_offset = forward as usize - heap.as_ptr() as usize;
-                    let length = read_word(
-                        heap,
-                        forward_offset + size_of::<Obj>().to_bytes().as_usize(),
-                    );
-
-                    // Skip stale object version that has been relocated during incremental GC.
-                    offset += length as usize * WORD_SIZE;
-                } else {
-                    let n_fields = read_word(heap, offset);
-                    offset += WORD_SIZE;
-
-                    // There should be at least one field for the index
-                    assert!(n_fields >= 1);
-
-                    let object_idx = get_scalar_value(read_word(heap, offset));
-                    offset += WORD_SIZE;
-
-                    let old = seen.insert(object_idx, address);
-                    if let Some(old) = old {
-                        panic!(
-                            "Object with index {} seen multiple times: {:#x}, {:#x}",
-                            object_idx, old, address
-                        );
-                    }
-
-                    let object_expected_pointees =
-                        objects_map.get(&object_idx).unwrap_or_else(|| {
-                            panic!("Object with index {} is not in the objects map", object_idx)
-                        });
-
-                    for field_idx in 1..n_fields {
-                        let field = read_word(heap, offset);
-                        offset += WORD_SIZE;
-
-                        // Get index of the object pointed by the field
-                        let pointee_address = field.wrapping_add(1); // unskew
-
-                        let pointee_idx = read_object_id(pointee_address, heap);
-                        let expected_pointee_idx =
-                            object_expected_pointees[(field_idx - 1) as usize];
-                        assert_eq!(
-                            pointee_idx,
-                            expected_pointee_idx,
-                            "Object with index {} points to {} in field {}, but expected to point to {}",
-                            object_idx,
-                            pointee_idx,
-                            field_idx - 1,
-                            expected_pointee_idx,
-                        );
-                    }
-                }
-            }
-        }
-    }
-
-    // At this point we've checked that all seen objects point to the expected objects (as
-    // specified by `objects`). Check that we've seen the reachable objects and only the reachable
-    // objects.
-    let reachable_objects = compute_reachable_objects(roots, continuation_table, &objects_map);
-
-    // Objects we've seen in the heap
-    let seen_objects: FxHashSet<ObjectIdx> = seen.keys().copied().collect();
-
-    // Reachable objects that we haven't seen in the heap
-    let missing_objects: Vec<ObjectIdx> = reachable_objects
-        .difference(&seen_objects)
-        .copied()
-        .collect();
-
-    let mut error_message = String::new();
-
-    if !missing_objects.is_empty() {
-        write!(
-            &mut error_message,
-            "Reachable objects missing in the {} heap: {:?}",
-            if post_gc { "post-gc" } else { "pre-gc" },
-            missing_objects,
-        )
-        .unwrap();
-    }
-
-    if post_gc {
-        // Unreachable objects that we've seen in the heap
-        let extra_objects: Vec<ObjectIdx> = seen_objects
-            .difference(&reachable_objects)
-            .copied()
-            .collect();
-
-        if !extra_objects.is_empty() {
-            if !error_message.is_empty() {
-                error_message.push('\n');
-            }
-
-            write!(
-                &mut error_message,
-                "Unreachable objects seen in the post-GC heap: {:?}",
-                extra_objects,
-            )
-            .unwrap();
-        }
-    }
+    self::classical::check_dynamic_heap(
+        mode,
+        objects,
+        roots,
+        continuation_table,
+        heap,
+        heap_base_offset,
+        heap_ptr_offset,
+        continuation_table_variable_offset,
+        region0_ptr_offset,
+    );
+}
 
-    if !error_message.is_empty() {
-        panic!("{}", error_message);
-    }
+#[enhanced_orthogonal_persistence]
+pub fn check_dynamic_heap(
+    mode: CheckMode,
+    objects: &[(ObjectIdx, Vec<ObjectIdx>)],
+    roots: &[ObjectIdx],
+    continuation_table: &[ObjectIdx],
+    heap: &[u8],
+    heap_base_offset: usize,
+    heap_ptr_offset: usize,
+    static_root_array_variable_offset: usize,
+    continuation_table_variable_offset: usize,
+    region0_ptr_offset: usize,
+) {
+    self::enhanced::check_dynamic_heap(
+        mode,
+        objects,
+        roots,
+        continuation_table,
+        heap,
+        heap_base_offset,
+        heap_ptr_offset,
+        static_root_array_variable_offset,
+        continuation_table_variable_offset,
+        region0_ptr_offset,
+    );
 }
 
 fn compute_reachable_objects(
@@ -403,91 +301,3 @@ fn compute_reachable_objects(
 
     closure
 }
-
-fn check_static_root_array(mut offset: usize, roots: &[ObjectIdx], heap: &[u8]) {
-    let array_address = heap.as_ptr() as usize + offset;
-    assert_eq!(read_word(heap, offset), TAG_ARRAY_M);
-    offset += WORD_SIZE;
-
-    assert_eq!(read_word(heap, offset), make_pointer(array_address as u32));
-    offset += WORD_SIZE;
-
-    assert_eq!(read_word(heap, offset), roots.len() as u32);
-    offset += WORD_SIZE;
-
-    for obj in roots.iter() {
-        let mutbox_address = unskew_pointer(read_word(heap, offset));
-        offset += WORD_SIZE;
-
-        let object_address = unskew_pointer(read_mutbox_field(mutbox_address, heap));
-        let idx = read_object_id(object_address, heap);
-        assert_eq!(idx, *obj);
-    }
-}
-
-fn read_mutbox_field(mutbox_address: u32, heap: &[u8]) -> u32 {
-    let mut mutbox_offset = mutbox_address as usize - heap.as_ptr() as usize;
-
-    let mutbox_tag = read_word(heap, mutbox_offset);
-    assert_eq!(mutbox_tag, TAG_MUTBOX);
-    mutbox_offset += WORD_SIZE;
-
-    assert_eq!(read_word(heap, mutbox_offset), make_pointer(mutbox_address));
-    mutbox_offset += WORD_SIZE;
-
-    read_word(heap, mutbox_offset)
-}
-
-fn check_continuation_table(mut offset: usize, continuation_table: &[ObjectIdx], heap: &[u8]) {
-    let table_addr = heap.as_ptr() as usize + offset;
-    assert_eq!(read_word(heap, offset), TAG_ARRAY_M);
-    offset += WORD_SIZE;
-
-    assert_eq!(read_word(heap, offset), make_pointer(table_addr as u32));
-    offset += WORD_SIZE;
-
-    assert_eq!(read_word(heap, offset), continuation_table.len() as u32);
-    offset += WORD_SIZE;
-
-    for obj in continuation_table.iter() {
-        let ptr = unskew_pointer(read_word(heap, offset));
-        offset += WORD_SIZE;
-
-        let idx = read_object_id(ptr, heap);
-        assert_eq!(idx, *obj);
-    }
-}
-
-fn read_object_id(object_address: u32, heap: &[u8]) -> ObjectIdx {
-    let tag = read_word(heap, object_address as usize - heap.as_ptr() as usize);
-    assert!(is_array_or_slice_tag(tag));
-
-    // Skip object header for idx
-    let idx_address = object_address as usize + size_of::<Array>().to_bytes().as_usize();
-    get_scalar_value(read_word(heap, idx_address - heap.as_ptr() as usize))
-}
-
-fn run(heap: &mut MotokoHeap) -> bool {
-    let static_root = heap.static_root_array_variable_address() as *mut Value;
-    let continuation_table_location = heap.continuation_table_variable_address() as *mut Value;
-    let region0_pointer_location = heap.region0_pointer_variable_address() as *mut Value;
-    let unused_root = &mut Value::from_scalar(0) as *mut Value;
-
-    unsafe {
-        use motoko_rts::gc::incremental::{get_incremental_gc_state, IncrementalGC};
-        const INCREMENTS_UNTIL_COMPLETION: usize = 16;
-        for _ in 0..INCREMENTS_UNTIL_COMPLETION {
-            let roots = [
-                static_root,
-                continuation_table_location,
-                region0_pointer_location,
-                unused_root,
-                unused_root,
-                unused_root,
-            ];
-            IncrementalGC::instance(heap, get_incremental_gc_state())
-                .empty_call_stack_increment(roots);
-        }
-        false
-    }
-}
diff --git a/rts/motoko-rts-tests/src/gc/classical.rs b/rts/motoko-rts-tests/src/gc/classical.rs
new file mode 100644
index 00000000000..73bdf9f087f
--- /dev/null
+++ b/rts/motoko-rts-tests/src/gc/classical.rs
@@ -0,0 +1,358 @@
+use super::heap::MotokoHeap;
+use super::utils::{
+    get_scalar_value, make_pointer, read_word, unskew_pointer, ObjectIdx, GC, WORD_SIZE,
+};
+use crate::gc::{compute_reachable_objects, CheckMode};
+use fxhash::{FxHashMap, FxHashSet};
+use motoko_rts::types::*;
+use motoko_rts_macros::{incremental_gc, is_incremental_gc, non_incremental_gc};
+use std::fmt::Write;
+
+impl GC {
+    #[non_incremental_gc]
+    pub fn run(&self, heap: &mut MotokoHeap, _round: usize) -> bool {
+        let heap_base = heap.heap_base_address();
+        let static_roots = Value::from_ptr(heap.static_root_array_variable_address());
+        let mut region_0 = Value::from_scalar(0);
+        let continuation_table_ptr_address =
+            heap.continuation_table_variable_address() as *mut Value;
+
+        let heap_1 = heap.clone();
+        let heap_2 = heap.clone();
+
+        match self {
+            GC::Copying => {
+                unsafe {
+                    motoko_rts::gc::copying::copying_gc_internal(
+                        heap,
+                        heap_base,
+                        // get_hp
+                        || heap_1.heap_ptr_address(),
+                        // set_hp
+                        move |hp| heap_2.set_heap_ptr_address(hp),
+                        static_roots,
+                        continuation_table_ptr_address,
+                        &mut region_0,
+                        // note_live_size
+                        |_live_size| {},
+                        // note_reclaimed
+                        |_reclaimed| {},
+                    );
+                }
+                true
+            }
+
+            GC::MarkCompact => {
+                unsafe {
+                    motoko_rts::gc::mark_compact::compacting_gc_internal(
+                        heap,
+                        heap_base,
+                        // get_hp
+                        || heap_1.heap_ptr_address(),
+                        // set_hp
+                        move |hp| heap_2.set_heap_ptr_address(hp),
+                        static_roots,
+                        continuation_table_ptr_address,
+                        &mut region_0,
+                        // note_live_size
+                        |_live_size| {},
+                        // note_reclaimed
+                        |_reclaimed| {},
+                    );
+                }
+                true
+            }
+
+            GC::Generational => {
+                use motoko_rts::gc::{
+                    generational::{
+                        write_barrier::{LAST_HP, REMEMBERED_SET},
+                        GenerationalGC, Strategy,
+                    },
+                    remembered_set::RememberedSet,
+                };
+
+                let strategy = match _round {
+                    0 => Strategy::Young,
+                    _ => Strategy::Full,
+                };
+                unsafe {
+                    REMEMBERED_SET = Some(RememberedSet::new(heap));
+                    LAST_HP = heap_1.last_ptr_address();
+
+                    let limits = motoko_rts::gc::generational::Limits {
+                        base: heap_base,
+                        last_free: heap_1.last_ptr_address(),
+                        free: heap_1.heap_ptr_address(),
+                    };
+                    let roots = motoko_rts::gc::generational::Roots {
+                        static_roots,
+                        continuation_table_ptr_loc: continuation_table_ptr_address,
+                        region0_ptr_loc: &mut region_0,
+                    };
+                    let gc_heap = motoko_rts::gc::generational::Heap {
+                        mem: heap,
+                        limits,
+                        roots,
+                    };
+                    let mut gc = GenerationalGC::new(gc_heap, strategy);
+                    gc.run();
+                    let free = gc.heap.limits.free;
+                    heap.set_last_ptr_address(free);
+                    heap.set_heap_ptr_address(free);
+                }
+                _round >= 2
+            }
+        }
+    }
+
+    #[incremental_gc]
+    pub fn run(&self, heap: &mut MotokoHeap, _round: usize) -> bool {
+        let static_roots = Value::from_ptr(heap.static_root_array_variable_address());
+        let continuation_table_ptr_address =
+            heap.continuation_table_variable_address() as *mut Value;
+        let region0_ptr_address = heap.region0_pointer_variable_address() as *mut Value;
+
+        match self {
+            GC::Incremental => unsafe {
+                use motoko_rts::gc::incremental::{get_incremental_gc_state, IncrementalGC};
+                const INCREMENTS_UNTIL_COMPLETION: usize = 16;
+                for _ in 0..INCREMENTS_UNTIL_COMPLETION {
+                    let roots = motoko_rts::gc::incremental::roots::Roots {
+                        static_roots,
+                        continuation_table_location: continuation_table_ptr_address,
+                        region0_ptr_location: region0_ptr_address,
+                    };
+                    IncrementalGC::instance(heap, get_incremental_gc_state())
+                        .empty_call_stack_increment(roots);
+                }
+                false
+            },
+        }
+    }
+}
+
+/// Check the dynamic heap:
+///
+/// - All (and in post-gc mode, only) reachable objects should be in the heap. Reachable objects
+///   are those in the transitive closure of roots.
+///
+/// - Objects should point to right objects. E.g. if object with index X points to objects with
+///   indices Y and Z in the `objects` map, it should point to objects with indices Y and Z on the
+///   heap.
+///
+pub fn check_dynamic_heap(
+    mode: CheckMode,
+    objects: &[(ObjectIdx, Vec<ObjectIdx>)],
+    roots: &[ObjectIdx],
+    continuation_table: &[ObjectIdx],
+    heap: &[u8],
+    heap_base_offset: usize,
+    heap_ptr_offset: usize,
+    continuation_table_ptr_offset: usize,
+    region0_ptr_offset: usize,
+) {
+    let incremental = cfg!(feature = "incremental_gc");
+    let objects_map: FxHashMap<ObjectIdx, &[ObjectIdx]> = objects
+        .iter()
+        .map(|(obj, refs)| (*obj, refs.as_slice()))
+        .collect();
+
+    // Current offset in the heap
+    let mut offset = heap_base_offset;
+
+    // Maps objects to their addresses (not offsets!). Used when debugging duplicate objects.
+    let mut seen: FxHashMap<ObjectIdx, usize> = Default::default();
+
+    let continuation_table_addr = unskew_pointer(read_word(heap, continuation_table_ptr_offset));
+    let continuation_table_offset = continuation_table_addr - heap.as_ptr() as usize;
+
+    let region0_addr = unskew_pointer(read_word(heap, region0_ptr_offset));
+
+    while offset < heap_ptr_offset {
+        let object_offset = offset;
+
+        // Address of the current object. Used for debugging.
+        let address = offset + heap.as_ptr() as usize;
+
+        if object_offset == continuation_table_offset {
+            check_continuation_table(object_offset, continuation_table, heap);
+            offset += (size_of::<Array>() + Words(continuation_table.len()))
+                .to_bytes()
+                .as_usize();
+            continue;
+        }
+
+        let tag = read_word(heap, offset);
+        offset += WORD_SIZE;
+
+        if tag == TAG_ONE_WORD_FILLER {
+            assert!(incremental);
+        } else if tag == TAG_FREE_SPACE {
+            assert!(incremental);
+            let words = read_word(heap, offset);
+            offset += WORD_SIZE;
+            offset += words * WORD_SIZE;
+        } else {
+            let forward;
+            if incremental {
+                forward = read_word(heap, offset);
+                offset += WORD_SIZE;
+            } else {
+                forward = make_pointer(address);
+            }
+
+            let is_forwarded = forward != make_pointer(address);
+
+            if incremental && tag == TAG_BLOB_B {
+                assert!(!is_forwarded);
+                // in-heap mark stack blobs
+                let length = read_word(heap, offset);
+                offset += WORD_SIZE + length;
+            } else if tag == TAG_REGION {
+                if !is_forwarded {
+                    assert_eq!(address, region0_addr);
+                }
+                offset += (size_of::<Region>() - size_of::<Obj>())
+                    .to_bytes()
+                    .as_usize();
+            } else {
+                if incremental {
+                    assert!(is_array_or_slice_tag(tag));
+                } else {
+                    assert!(is_base_array_tag(tag));
+                }
+
+                if is_forwarded {
+                    assert!(incremental);
+
+                    let forward_offset = forward - heap.as_ptr() as usize;
+                    let length = read_word(
+                        heap,
+                        forward_offset + size_of::<Obj>().to_bytes().as_usize(),
+                    );
+
+                    // Skip stale object version that has been relocated during incremental GC.
+                    offset += length * WORD_SIZE;
+                } else {
+                    let n_fields = read_word(heap, offset);
+                    offset += WORD_SIZE;
+
+                    // There should be at least one field for the index
+                    assert!(n_fields >= 1);
+
+                    let object_idx = get_scalar_value(read_word(heap, offset));
+                    offset += WORD_SIZE;
+
+                    let old = seen.insert(object_idx, address);
+                    if let Some(old) = old {
+                        panic!(
+                            "Object with index {} seen multiple times: {:#x}, {:#x}",
+                            object_idx, old, address
+                        );
+                    }
+
+                    let object_expected_pointees =
+                        objects_map.get(&object_idx).unwrap_or_else(|| {
+                            panic!("Object with index {} is not in the objects map", object_idx)
+                        });
+
+                    for field_idx in 1..n_fields {
+                        let field = read_word(heap, offset);
+                        offset += WORD_SIZE;
+                        // Get index of the object pointed by the field
+                        let pointee_address = field.wrapping_add(1); // unskew
+                        let pointee_offset = pointee_address - heap.as_ptr() as usize;
+                        let pointee_idx_offset =
+                            pointee_offset + size_of::<Array>().to_bytes().as_usize(); // skip array header (incl. length)
+                        let pointee_idx = get_scalar_value(read_word(heap, pointee_idx_offset));
+                        let expected_pointee_idx = object_expected_pointees[field_idx - 1];
+                        assert_eq!(
+                            pointee_idx,
+                            expected_pointee_idx,
+                            "Object with index {} points to {} in field {}, but expected to point to {}",
+                            object_idx,
+                            pointee_idx,
+                            field_idx - 1,
+                            expected_pointee_idx,
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+    // At this point we've checked that all seen objects point to the expected objects (as
+    // specified by `objects`). Check that we've seen the reachable objects and only the reachable
+    // objects.
+    let reachable_objects = compute_reachable_objects(roots, continuation_table, &objects_map);
+
+    // Objects we've seen in the heap
+    let seen_objects: FxHashSet<ObjectIdx> = seen.keys().copied().collect();
+
+    // Reachable objects that we haven't seen in the heap
+    let missing_objects: Vec<ObjectIdx> = reachable_objects
+        .difference(&seen_objects)
+        .copied()
+        .collect();
+
+    let mut error_message = String::new();
+
+    if !missing_objects.is_empty() {
+        write!(
+            &mut error_message,
+            "Reachable objects missing in the heap: {missing_objects:?}",
+        )
+        .unwrap();
+    }
+
+    if mode == CheckMode::AllReclaimed {
+        // Unreachable objects that we've seen in the heap
+        let extra_objects: Vec<ObjectIdx> = seen_objects
+            .difference(&reachable_objects)
+            .copied()
+            .collect();
+
+        if !extra_objects.is_empty() {
+            if !error_message.is_empty() {
+                error_message.push('\n');
+            }
+
+            write!(
+                &mut error_message,
+                "Unreachable objects seen in the post-GC heap: {:?}",
+                extra_objects,
+            )
+            .unwrap();
+        }
+    }
+
+    if !error_message.is_empty() {
+        panic!("{}", error_message);
+    }
+}
+
+fn check_continuation_table(mut offset: usize, continuation_table: &[ObjectIdx], heap: &[u8]) {
+    let table_addr = heap.as_ptr() as usize + offset;
+    assert_eq!(read_word(heap, offset), TAG_ARRAY_M);
+    offset += WORD_SIZE;
+
+    if is_incremental_gc!() {
+        assert_eq!(read_word(heap, offset), make_pointer(table_addr));
+        offset += WORD_SIZE;
+    }
+
+    assert_eq!(read_word(heap, offset), continuation_table.len());
+    offset += WORD_SIZE;
+
+    for obj in continuation_table.iter() {
+        let ptr = unskew_pointer(read_word(heap, offset));
+        offset += WORD_SIZE;
+
+        // Skip object header for idx
+        let idx_address = ptr + size_of::<Array>().to_bytes().as_usize();
+        let idx = get_scalar_value(read_word(heap, idx_address - heap.as_ptr() as usize));
+
+        assert_eq!(idx, *obj);
+    }
+}
diff --git a/rts/motoko-rts-tests/src/gc/compacting.rs b/rts/motoko-rts-tests/src/gc/compacting.rs
new file mode 100644
index 00000000000..42cfa936cd2
--- /dev/null
+++ b/rts/motoko-rts-tests/src/gc/compacting.rs
@@ -0,0 +1,10 @@
+mod bitmap;
+mod mark_stack;
+
+pub fn test() {
+    println!("Testing compacting GC components ...");
+    unsafe {
+        bitmap::test();
+        mark_stack::test();
+    }
+}
diff --git a/rts/motoko-rts-tests/src/gc/compacting/bitmap.rs b/rts/motoko-rts-tests/src/gc/compacting/bitmap.rs
new file mode 100644
index 00000000000..237c047ad9c
--- /dev/null
+++ b/rts/motoko-rts-tests/src/gc/compacting/bitmap.rs
@@ -0,0 +1,166 @@
+use crate::memory::TestMemory;
+
+use motoko_rts::constants::WORD_SIZE;
+use motoko_rts::gc::mark_compact::bitmap::{
+    alloc_bitmap, free_bitmap, get_bit, iter_bits, set_bit, BITMAP_ITER_END,
+};
+use motoko_rts::memory::Memory;
+use motoko_rts::types::{Bytes, Words};
+
+use std::collections::HashSet;
+
+use proptest::strategy::Strategy;
+use proptest::test_runner::{Config, TestCaseError, TestCaseResult, TestRunner};
+
+pub unsafe fn test() {
+    println!("  Testing bitmap ...");
+    println!("    Testing set_bit/get_bit");
+
+    {
+        let mut mem = TestMemory::new(Words(1024));
+        test_set_get(&mut mem, vec![0, 33]).unwrap();
+    }
+
+    let mut proptest_runner = TestRunner::new(Config {
+        cases: 100,
+        failure_persistence: None,
+        ..Default::default()
+    });
+
+    proptest_runner
+        .run(&bit_index_vector_strategy(), |bits| {
+            // Max bit idx = 65,534, requires 2048 words. Add 2 words for Blob header (header +
+            // length).
+            let mut mem = TestMemory::new(Words(2051));
+            test_set_get_proptest(&mut mem, bits)
+        })
+        .unwrap();
+
+    println!("    Testing bit iteration");
+    proptest_runner
+        .run(&bit_index_vector_strategy(), |bits| {
+            let mut hash_set = HashSet::new();
+            for value in bits {
+                hash_set.insert(value);
+            }
+            let mut mem = TestMemory::new(Words(2051));
+            test_bit_iter(&mut mem, hash_set)
+        })
+        .unwrap();
+}
+
+/// Generates vectors of bit indices
+fn bit_index_vector_strategy() -> impl Strategy<Value = Vec<u16>> {
+    proptest::collection::vec(0u16..u16::MAX, 0..1_000)
+}
+
+fn test_set_get_proptest<M: Memory>(mem: &mut M, bits: Vec<u16>) -> TestCaseResult {
+    test_set_get(mem, bits).map_err(|err| TestCaseError::Fail(err.into()))
+}
+
+fn test_set_get<M: Memory>(mem: &mut M, mut bits: Vec<u16>) -> Result<(), String> {
+    if bits.is_empty() {
+        return Ok(());
+    }
+
+    unsafe {
+        alloc_bitmap(
+            mem,
+            Bytes((*bits.iter().max().unwrap() as usize + 1) * WORD_SIZE),
+            0,
+        );
+
+        for bit in &bits {
+            set_bit(*bit as usize);
+            if !get_bit(*bit as usize) {
+                return Err("set-get error".to_string());
+            }
+        }
+
+        bits.sort();
+
+        let mut last_bit: Option<u16> = None;
+        for bit in bits {
+            // Bits from the last set bit up to current bit should be 0
+            if let Some(last_bit) = last_bit {
+                for i in last_bit + 1..bit {
+                    if get_bit(i as usize) {
+                        return Err(format!("get_bit({}) of unset bit is true", i));
+                    }
+                }
+            }
+
+            // Current bit should be set
+            if !get_bit(bit as usize) {
+                return Err("get_bit of set bit is false".to_string());
+            }
+
+            last_bit = Some(bit);
+        }
+
+        free_bitmap()
+    }
+
+    Ok(())
+}
+
+fn test_bit_iter<M: Memory>(mem: &mut M, bits: HashSet<u16>) -> TestCaseResult {
+    // If the max bit is N, the heap size is at least N+1 words
+    let heap_size = Words(
+        bits.iter()
+            .max()
+            .map(|max_bit| *max_bit as usize + 1)
+            .unwrap_or(0),
+    )
+    .to_bytes();
+
+    unsafe {
+        alloc_bitmap(mem, heap_size, 0);
+
+        for bit in bits.iter() {
+            set_bit(*bit as usize);
+        }
+
+        let mut bits_sorted = bits.into_iter().collect::<Vec<_>>();
+        bits_sorted.sort();
+
+        let mut bit_vec_iter = bits_sorted.into_iter();
+        let mut bit_map_iter = iter_bits();
+
+        while let Some(vec_bit) = bit_vec_iter.next() {
+            match bit_map_iter.next() {
+                BITMAP_ITER_END => {
+                    return Err(TestCaseError::Fail(
+                        "bitmap iterator didn't yield but there are more bits".into(),
+                    ));
+                }
+                map_bit => {
+                    if map_bit != vec_bit as usize {
+                        return Err(TestCaseError::Fail(
+                            format!(
+                                "bitmap iterator yields {}, but actual bit is {}",
+                                map_bit, vec_bit
+                            )
+                            .into(),
+                        ));
+                    }
+                }
+            }
+        }
+
+        let map_bit = bit_map_iter.next();
+        if map_bit != BITMAP_ITER_END {
+            return Err(TestCaseError::Fail(
+                format!(
+                    "bitmap iterator yields {}, but there are no more bits left",
+                    map_bit
+                )
+                .into(),
+            ));
+        }
+
+        free_bitmap()
+    }
+
+    Ok(())
+}
diff --git a/rts/motoko-rts-tests/src/gc/compacting/mark_stack.rs b/rts/motoko-rts-tests/src/gc/compacting/mark_stack.rs
new file mode 100644
index 00000000000..756fcb9d99e
--- /dev/null
+++ b/rts/motoko-rts-tests/src/gc/compacting/mark_stack.rs
@@ -0,0 +1,115 @@
+use crate::memory::TestMemory;
+
+use motoko_rts::gc::mark_compact::mark_stack::{
+    alloc_mark_stack, free_mark_stack, grow_stack, pop_mark_stack, push_mark_stack,
+    INIT_STACK_SIZE, STACK_BASE, STACK_PTR, STACK_TOP,
+};
+use motoko_rts::memory::Memory;
+use motoko_rts::types::*;
+
+use proptest::test_runner::{Config, TestCaseError, TestCaseResult, TestRunner};
+
+pub unsafe fn test() {
+    println!("  Testing mark stack ...");
+
+    test_push_pop();
+    test_grow_stack();
+}
+
+fn test_push_pop() {
+    println!("    Testing push/pop");
+
+    let mut proptest_runner = TestRunner::new(Config {
+        cases: 100,
+        failure_persistence: None,
+        ..Default::default()
+    });
+
+    proptest_runner
+        .run(&(0u32..1000u32), |n_objs| {
+            let mut mem = TestMemory::new(Words(1024 * 1024));
+            test_(&mut mem, n_objs)
+        })
+        .unwrap();
+}
+
+static TAGS: [Tag; 23] = [
+    TAG_OBJECT,
+    TAG_ARRAY_I,
+    TAG_ARRAY_M,
+    TAG_ARRAY_T,
+    TAG_ARRAY_S,
+    TAG_BITS64_U,
+    TAG_BITS64_S,
+    TAG_BITS64_F,
+    TAG_MUTBOX,
+    TAG_CLOSURE,
+    TAG_SOME,
+    TAG_VARIANT,
+    TAG_BLOB_B,
+    TAG_BLOB_T,
+    TAG_BLOB_P,
+    TAG_BLOB_A,
+    TAG_FWD_PTR,
+    TAG_BITS32_U,
+    TAG_BITS32_S,
+    TAG_BITS32_F,
+    TAG_BIGINT,
+    TAG_CONCAT,
+    TAG_NULL,
+];
+
+fn test_<M: Memory>(mem: &mut M, n_objs: u32) -> TestCaseResult {
+    let objs: Vec<u32> = (0..n_objs).collect();
+
+    unsafe {
+        alloc_mark_stack(mem);
+
+        for obj in &objs {
+            push_mark_stack(mem, *obj as usize, TAGS[(*obj as usize) % TAGS.len()]);
+        }
+
+        for obj in objs.iter().copied().rev() {
+            let popped = pop_mark_stack();
+            if popped != Some((obj as usize, TAGS[(obj as usize) % TAGS.len()])) {
+                free_mark_stack();
+                return Err(TestCaseError::Fail(
+                    format!(
+                        "Unexpected object popped, expected={:?}, popped={:?}",
+                        obj, popped
+                    )
+                    .into(),
+                ));
+            }
+        }
+
+        free_mark_stack();
+    }
+
+    Ok(())
+}
+
+unsafe fn test_grow_stack() {
+    println!("    Testing grow_stack");
+
+    // Allow doubling twice
+    let mut mem = TestMemory::new(
+        size_of::<Blob>() + INIT_STACK_SIZE + INIT_STACK_SIZE + INIT_STACK_SIZE * 2,
+    );
+
+    alloc_mark_stack(&mut mem);
+
+    let mut current_size = INIT_STACK_SIZE.as_usize();
+    assert_eq!(STACK_BASE.add(current_size), STACK_TOP);
+    assert_eq!(STACK_BASE, STACK_PTR);
+
+    grow_stack(&mut mem);
+    current_size *= 2;
+    assert_eq!(STACK_BASE.add(current_size), STACK_TOP);
+    assert_eq!(STACK_BASE, STACK_PTR);
+
+    grow_stack(&mut mem);
+    current_size *= 2;
+    assert_eq!(STACK_BASE.add(current_size), STACK_TOP);
+    assert_eq!(STACK_BASE, STACK_PTR);
+}
diff --git a/rts/motoko-rts-tests/src/gc/enhanced.rs b/rts/motoko-rts-tests/src/gc/enhanced.rs
new file mode 100644
index 00000000000..645c95cef71
--- /dev/null
+++ b/rts/motoko-rts-tests/src/gc/enhanced.rs
@@ -0,0 +1,321 @@
+use super::heap::MotokoHeap;
+use super::utils::{
+    get_scalar_value, make_pointer, read_word, unskew_pointer, ObjectIdx, GC, WORD_SIZE,
+};
+use crate::gc::{compute_reachable_objects, CheckMode};
+use fxhash::{FxHashMap, FxHashSet};
+use motoko_rts::types::*;
+use std::fmt::Write;
+
+impl GC {
+    pub fn run(&self, heap: &mut MotokoHeap, _round: usize) -> bool {
+        let static_root = heap.static_root_array_variable_address() as *mut Value;
+        let continuation_table_location = heap.continuation_table_variable_address() as *mut Value;
+        let region0_pointer_location = heap.region0_pointer_variable_address() as *mut Value;
+        let unused_root = &mut Value::from_scalar(0) as *mut Value;
+
+        unsafe {
+            use motoko_rts::gc::incremental::{get_incremental_gc_state, IncrementalGC};
+            const INCREMENTS_UNTIL_COMPLETION: usize = 16;
+            for _ in 0..INCREMENTS_UNTIL_COMPLETION {
+                let roots = [
+                    static_root,
+                    continuation_table_location,
+                    region0_pointer_location,
+                    unused_root,
+                    unused_root,
+                    unused_root,
+                ];
+                IncrementalGC::instance(heap, get_incremental_gc_state())
+                    .empty_call_stack_increment(roots);
+            }
+            false
+        }
+    }
+}
+
+/// Check the dynamic heap:
+///
+/// - All (and in post-gc mode, only) reachable objects should be in the heap. Reachable objects
+///   are those in the transitive closure of roots.
+///
+/// - Objects should point to right objects. E.g. if object with index X points to objects with
+///   indices Y and Z in the `objects` map, it should point to objects with indices Y and Z on the
+///   heap.
+///
+pub fn check_dynamic_heap(
+    mode: CheckMode,
+    objects: &[(ObjectIdx, Vec<ObjectIdx>)],
+    roots: &[ObjectIdx],
+    continuation_table: &[ObjectIdx],
+    heap: &[u8],
+    heap_base_offset: usize,
+    heap_ptr_offset: usize,
+    static_root_array_variable_offset: usize,
+    continuation_table_variable_offset: usize,
+    region0_ptr_offset: usize,
+) {
+    let objects_map: FxHashMap<ObjectIdx, &[ObjectIdx]> = objects
+        .iter()
+        .map(|(obj, refs)| (*obj, refs.as_slice()))
+        .collect();
+
+    // Current offset in the heap
+    let mut offset = heap_base_offset;
+
+    // Maps objects to their addresses (not offsets!). Used when debugging duplicate objects.
+    let mut seen: FxHashMap<ObjectIdx, usize> = Default::default();
+
+    let static_root_array_address =
+        unskew_pointer(read_word(heap, static_root_array_variable_offset));
+    let static_root_array_offset = static_root_array_address as usize - heap.as_ptr() as usize;
+
+    let continuation_table_address =
+        unskew_pointer(read_word(heap, continuation_table_variable_offset));
+    let continuation_table_offset = continuation_table_address as usize - heap.as_ptr() as usize;
+
+    let region0_addr = unskew_pointer(read_word(heap, region0_ptr_offset));
+
+    while offset < heap_ptr_offset {
+        let object_offset = offset;
+
+        // Address of the current object. Used for debugging.
+        let address = offset + heap.as_ptr() as usize;
+
+        if object_offset == static_root_array_offset {
+            check_static_root_array(object_offset, roots, heap);
+            offset += (size_of::<Array>() + Words(roots.len()))
+                .to_bytes()
+                .as_usize();
+            continue;
+        }
+
+        if object_offset == continuation_table_offset {
+            check_continuation_table(object_offset, continuation_table, heap);
+            offset += (size_of::<Array>() + Words(continuation_table.len()))
+                .to_bytes()
+                .as_usize();
+            continue;
+        }
+
+        let tag = read_word(heap, offset);
+        offset += WORD_SIZE;
+
+        if tag == TAG_ONE_WORD_FILLER {
+        } else if tag == TAG_FREE_SPACE {
+            let words = read_word(heap, offset);
+            offset += WORD_SIZE;
+            offset += words * WORD_SIZE;
+        } else {
+            let forward;
+            forward = read_word(heap, offset);
+            offset += WORD_SIZE;
+
+            let is_forwarded = forward != make_pointer(address);
+
+            if tag == TAG_MUTBOX {
+                // MutBoxes of static root array, will be scanned indirectly when checking the static root array.
+                offset += WORD_SIZE;
+            } else if tag == TAG_BLOB_B {
+                assert!(!is_forwarded);
+                // in-heap mark stack blobs
+                let length = read_word(heap, offset);
+                offset += WORD_SIZE + length;
+            } else if tag == TAG_REGION {
+                if !is_forwarded {
+                    assert_eq!(address, region0_addr);
+                }
+                offset += (size_of::<Region>() - size_of::<Obj>())
+                    .to_bytes()
+                    .as_usize();
+            } else if mode == CheckMode::Stabilzation && tag == TAG_MUTBOX {
+                offset += WORD_SIZE;
+            } else {
+                assert!(is_array_or_slice_tag(tag));
+
+                if is_forwarded {
+                    let forward_offset = forward - heap.as_ptr() as usize;
+                    let length = read_word(
+                        heap,
+                        forward_offset + size_of::<Obj>().to_bytes().as_usize(),
+                    );
+
+                    // Skip stale object version that has been relocated during incremental GC.
+                    offset += length * WORD_SIZE;
+                } else {
+                    let n_fields = read_word(heap, offset);
+                    offset += WORD_SIZE;
+
+                    // There should be at least one field for the index
+                    assert!(n_fields >= 1);
+
+                    let object_idx = get_scalar_value(read_word(heap, offset));
+                    offset += WORD_SIZE;
+
+                    let old = seen.insert(object_idx, address);
+                    if let Some(old) = old {
+                        panic!(
+                            "Object with index {} seen multiple times: {:#x}, {:#x}",
+                            object_idx, old, address
+                        );
+                    }
+
+                    let object_expected_pointees =
+                        objects_map.get(&object_idx).unwrap_or_else(|| {
+                            panic!("Object with index {} is not in the objects map", object_idx)
+                        });
+
+                    for field_idx in 1..n_fields {
+                        let field = read_word(heap, offset);
+
+                        offset += WORD_SIZE;
+
+                        // Get index of the object pointed by the field
+                        let pointee_address = field.wrapping_add(1); // unskew
+
+                        let pointee_idx = read_object_id(pointee_address, heap);
+                        let expected_pointee_idx =
+                            object_expected_pointees[(field_idx - 1) as usize];
+                        assert_eq!(
+                            pointee_idx,
+                            expected_pointee_idx,
+                            "Object with index {} points to {} in field {}, but expected to point to {}",
+                            object_idx,
+                            pointee_idx,
+                            field_idx - 1,
+                            expected_pointee_idx,
+                        );
+                    }
+                }
+            }
+        }
+
+        skip_empty_partition_space(heap, &mut offset, heap_ptr_offset);
+    }
+
+    // At this point we've checked that all seen objects point to the expected objects (as
+    // specified by `objects`). Check that we've seen the reachable objects and only the reachable
+    // objects.
+    let reachable_objects = compute_reachable_objects(roots, continuation_table, &objects_map);
+
+    // Objects we've seen in the heap
+    let seen_objects: FxHashSet<ObjectIdx> = seen.keys().copied().collect();
+
+    // Reachable objects that we haven't seen in the heap
+    let missing_objects: Vec<ObjectIdx> = reachable_objects
+        .difference(&seen_objects)
+        .copied()
+        .collect();
+
+    let mut error_message = String::new();
+
+    if !missing_objects.is_empty() {
+        write!(
+            &mut error_message,
+            "{mode:?}: Reachable objects missing in the heap: {missing_objects:?}",
+        )
+        .unwrap();
+    }
+
+    if mode == CheckMode::AllReclaimed {
+        // Unreachable objects that we've seen in the heap
+        let extra_objects: Vec<ObjectIdx> = seen_objects
+            .difference(&reachable_objects)
+            .copied()
+            .collect();
+
+        if !extra_objects.is_empty() {
+            if !error_message.is_empty() {
+                error_message.push('\n');
+            }
+
+            write!(
+                &mut error_message,
+                "Unreachable objects seen in the post-GC heap: {:?}",
+                extra_objects,
+            )
+            .unwrap();
+        }
+    }
+
+    if !error_message.is_empty() {
+        panic!("{}", error_message);
+    }
+}
+
+fn check_static_root_array(mut offset: usize, roots: &[ObjectIdx], heap: &[u8]) {
+    let array_address = heap.as_ptr() as usize + offset;
+    assert_eq!(read_word(heap, offset), TAG_ARRAY_M);
+    offset += WORD_SIZE;
+
+    assert_eq!(read_word(heap, offset), make_pointer(array_address));
+    offset += WORD_SIZE;
+
+    assert_eq!(read_word(heap, offset), roots.len());
+    offset += WORD_SIZE;
+
+    for obj in roots.iter() {
+        let mutbox_address = unskew_pointer(read_word(heap, offset));
+        offset += WORD_SIZE;
+
+        let object_address = unskew_pointer(read_mutbox_field(mutbox_address, heap));
+        let idx = read_object_id(object_address, heap);
+        assert_eq!(idx, *obj);
+    }
+}
+
+fn read_mutbox_field(mutbox_address: usize, heap: &[u8]) -> usize {
+    let mut mutbox_offset = mutbox_address - heap.as_ptr() as usize;
+
+    let mutbox_tag = read_word(heap, mutbox_offset);
+    assert_eq!(mutbox_tag, TAG_MUTBOX);
+    mutbox_offset += WORD_SIZE;
+
+    assert_eq!(read_word(heap, mutbox_offset), make_pointer(mutbox_address));
+    mutbox_offset += WORD_SIZE;
+
+    read_word(heap, mutbox_offset)
+}
+
+fn check_continuation_table(mut offset: usize, continuation_table: &[ObjectIdx], heap: &[u8]) {
+    let table_addr = heap.as_ptr() as usize + offset;
+    assert_eq!(read_word(heap, offset), TAG_ARRAY_M);
+    offset += WORD_SIZE;
+
+    assert_eq!(read_word(heap, offset), make_pointer(table_addr));
+    offset += WORD_SIZE;
+
+    assert_eq!(read_word(heap, offset), continuation_table.len());
+    offset += WORD_SIZE;
+
+    for obj in continuation_table.iter() {
+        let ptr = unskew_pointer(read_word(heap, offset));
+        offset += WORD_SIZE;
+
+        let idx = read_object_id(ptr, heap);
+        assert_eq!(idx, *obj);
+    }
+}
+
+fn read_object_id(object_address: usize, heap: &[u8]) -> ObjectIdx {
+    let tag = read_word(heap, object_address - heap.as_ptr() as usize);
+    assert!(is_array_or_slice_tag(tag));
+
+    // Skip object header for idx
+    let idx_address = object_address + size_of::<Array>().to_bytes().as_usize();
+    get_scalar_value(read_word(heap, idx_address - heap.as_ptr() as usize))
+}
+
+fn skip_empty_partition_space(heap: &[u8], offset: &mut usize, heap_ptr_offset: usize) {
+    use motoko_rts::gc::incremental::{get_partitioned_heap, partitioned_heap::PARTITION_SIZE};
+    let heap_start = heap.as_ptr() as usize;
+    while *offset < heap_ptr_offset {
+        let address = *offset + heap_start;
+        let partition_index = address / PARTITION_SIZE;
+        let partition = unsafe { get_partitioned_heap().get_partition(partition_index) };
+        if address < partition.dynamic_space_end() {
+            return;
+        }
+        *offset = (partition_index + 1) * PARTITION_SIZE - heap_start;
+    }
+}
diff --git a/rts/motoko-rts-tests/src/gc/generational.rs b/rts/motoko-rts-tests/src/gc/generational.rs
new file mode 100644
index 00000000000..5a86ed7cf10
--- /dev/null
+++ b/rts/motoko-rts-tests/src/gc/generational.rs
@@ -0,0 +1,10 @@
+mod mark_stack;
+mod remembered_set;
+
+pub fn test() {
+    println!("Testing generational GC ...");
+    unsafe {
+        mark_stack::test();
+        remembered_set::test();
+    }
+}
diff --git a/rts/motoko-rts-tests/src/gc/generational/mark_stack.rs b/rts/motoko-rts-tests/src/gc/generational/mark_stack.rs
new file mode 100644
index 00000000000..959b913e87d
--- /dev/null
+++ b/rts/motoko-rts-tests/src/gc/generational/mark_stack.rs
@@ -0,0 +1,89 @@
+use crate::memory::TestMemory;
+
+use motoko_rts::gc::generational::mark_stack::{
+    alloc_mark_stack, free_mark_stack, grow_stack, pop_mark_stack, push_mark_stack,
+    INIT_STACK_SIZE, STACK_BASE, STACK_PTR, STACK_TOP,
+};
+use motoko_rts::memory::Memory;
+use motoko_rts::types::*;
+
+use proptest::test_runner::{Config, TestCaseError, TestCaseResult, TestRunner};
+
+pub unsafe fn test() {
+    println!("  Testing mark stack ...");
+
+    test_push_pop();
+    test_grow_stack();
+}
+
+fn test_push_pop() {
+    println!("    Testing push/pop");
+
+    let mut proptest_runner = TestRunner::new(Config {
+        cases: 100,
+        failure_persistence: None,
+        ..Default::default()
+    });
+
+    proptest_runner
+        .run(&(0u32..1000u32), |n_objs| {
+            let mut mem = TestMemory::new(Words(1024 * 1024));
+            test_(&mut mem, n_objs)
+        })
+        .unwrap();
+}
+
+fn test_<M: Memory>(mem: &mut M, n_objs: u32) -> TestCaseResult {
+    let objs: Vec<u32> = (0..n_objs).collect();
+
+    unsafe {
+        alloc_mark_stack(mem);
+
+        for obj in &objs {
+            push_mark_stack(mem, *obj as usize);
+        }
+
+        for obj in objs.iter().copied().rev() {
+            let popped = pop_mark_stack();
+            if popped != Some(obj as usize) {
+                free_mark_stack();
+                return Err(TestCaseError::Fail(
+                    format!(
+                        "Unexpected object popped, expected={:?}, popped={:?}",
+                        obj, popped
+                    )
+                    .into(),
+                ));
+            }
+        }
+
+        free_mark_stack();
+    }
+
+    Ok(())
+}
+
+unsafe fn test_grow_stack() {
+    println!("    Testing grow_stack");
+
+    // Allow doubling twice
+    let mut mem = TestMemory::new(
+        size_of::<Blob>() + INIT_STACK_SIZE + INIT_STACK_SIZE + INIT_STACK_SIZE * 2,
+    );
+
+    alloc_mark_stack(&mut mem);
+
+    let mut current_size = INIT_STACK_SIZE.as_usize();
+    assert_eq!(STACK_BASE.add(current_size), STACK_TOP);
+    assert_eq!(STACK_BASE, STACK_PTR);
+
+    grow_stack(&mut mem);
+    current_size *= 2;
+    assert_eq!(STACK_BASE.add(current_size), STACK_TOP);
+    assert_eq!(STACK_BASE, STACK_PTR);
+
+    grow_stack(&mut mem);
+    current_size *= 2;
+    assert_eq!(STACK_BASE.add(current_size), STACK_TOP);
+    assert_eq!(STACK_BASE, STACK_PTR);
+}
diff --git a/rts/motoko-rts-tests/src/gc/generational/remembered_set.rs b/rts/motoko-rts-tests/src/gc/generational/remembered_set.rs
new file mode 100644
index 00000000000..691185f9a1c
--- /dev/null
+++ b/rts/motoko-rts-tests/src/gc/generational/remembered_set.rs
@@ -0,0 +1,96 @@
+use std::collections::HashSet;
+
+use crate::memory::TestMemory;
+use motoko_rts::gc::remembered_set::{
+    RememberedSet, INITIAL_TABLE_LENGTH, OCCUPATION_THRESHOLD_PERCENT,
+};
+use motoko_rts::types::{Value, Words};
+
+const GROW_LIMIT: usize = INITIAL_TABLE_LENGTH * OCCUPATION_THRESHOLD_PERCENT / 100;
+
+pub unsafe fn test() {
+    println!("  Testing remembered set ...");
+
+    test_remembered_set(0);
+    test_remembered_set(1);
+    test_remembered_set(INITIAL_TABLE_LENGTH / 2);
+    test_remembered_set(GROW_LIMIT - 1);
+    test_remembered_set(GROW_LIMIT);
+    test_remembered_set(GROW_LIMIT + 1);
+    test_remembered_set(INITIAL_TABLE_LENGTH);
+    test_remembered_set(2 * GROW_LIMIT - 1);
+    test_remembered_set(2 * GROW_LIMIT);
+    test_remembered_set(2 * GROW_LIMIT + 1);
+    test_remembered_set(128 * GROW_LIMIT);
+}
+
+unsafe fn test_remembered_set(amount: usize) {
+    test_insert_iterate(amount);
+    test_duplicates(amount);
+    test_collisions(amount);
+}
+
+unsafe fn test_insert_iterate(amount: usize) {
+    let mut mem = TestMemory::new(Words(2 * amount + 1024 * 1024));
+
+    let mut remembered_set = RememberedSet::new(&mut mem);
+    let mut test_set: HashSet<usize> = HashSet::new();
+    // start at 1 since 0 is the null ptr and not stored in the remembered set
+    for value in 1..amount + 1 {
+        remembered_set.insert(&mut mem, Value::from_raw(value));
+        test_set.insert(value);
+    }
+
+    let mut iterator = remembered_set.iterate();
+    for _ in 1..amount + 1 {
+        assert!(iterator.has_next());
+        let value = iterator.current().get_raw();
+        assert!(test_set.contains(&value));
+        iterator.next();
+    }
+    assert!(!iterator.has_next());
+}
+
+unsafe fn test_duplicates(amount: usize) {
+    let mut mem = TestMemory::new(Words(2 * amount + 1024 * 1024));
+
+    let mut remembered_set = RememberedSet::new(&mut mem);
+    // start at 1 since 0 is the null ptr and not stored in the remembered set
+    for value in 1..amount + 1 {
+        remembered_set.insert(&mut mem, Value::from_raw(value));
+    }
+
+    let count = remembered_set.count();
+    for value in 1..amount + 1 {
+        remembered_set.insert(&mut mem, Value::from_raw(value));
+        assert_eq!(remembered_set.count(), count);
+    }
+}
+
+unsafe fn test_collisions(amount: usize) {
+    let mut mem = TestMemory::new(Words(2 * amount + 1024 * 1024));
+
+    let mut remembered_set = RememberedSet::new(&mut mem);
+    let mut test_set: HashSet<usize> = HashSet::new();
+
+    // start at 1 since 0 is the null ptr and not stored in the remembered set
+    for index in 1..amount + 1 {
+        const FACTOR: usize = 1024 * 1024;
+        let value = if index <= usize::MAX / FACTOR {
+            index * FACTOR
+        } else {
+            index
+        };
+        remembered_set.insert(&mut mem, Value::from_raw(value));
+        test_set.insert(value);
+    }
+
+    let mut iterator = remembered_set.iterate();
+    for _ in 1..amount + 1 {
+        assert!(iterator.has_next());
+        let value = iterator.current().get_raw();
+        assert!(test_set.contains(&value));
+        iterator.next();
+    }
+    assert!(!iterator.has_next());
+}
diff --git a/rts/motoko-rts-tests/src/gc/heap.rs b/rts/motoko-rts-tests/src/gc/heap.rs
index 1b1018fac59..045deda114e 100644
--- a/rts/motoko-rts-tests/src/gc/heap.rs
+++ b/rts/motoko-rts-tests/src/gc/heap.rs
@@ -1,16 +1,20 @@
-use super::utils::{make_pointer, make_scalar, write_word, ObjectIdx, WORD_SIZE};
+use motoko_rts_macros::{
+    classical_persistence, enhanced_orthogonal_persistence, incremental_gc, non_incremental_gc,
+};
+
+#[classical_persistence]
+mod classical;
+#[enhanced_orthogonal_persistence]
+mod enhanced;
+
+use super::utils::{ObjectIdx, GC};
 
 use motoko_rts::memory::Memory;
 use motoko_rts::types::*;
 
 use std::cell::{Ref, RefCell};
-use std::convert::TryFrom;
 use std::rc::Rc;
 
-use fxhash::{FxHashMap, FxHashSet};
-
-use motoko_rts::gc::incremental::partitioned_heap::PARTITION_SIZE;
-
 /// Represents Motoko heaps. Reference counted (implements `Clone`) so we can clone and move values
 /// of this type to GC callbacks.
 #[derive(Clone)]
@@ -19,12 +23,12 @@ pub struct MotokoHeap {
 }
 
 impl Memory for MotokoHeap {
-    unsafe fn alloc_words(&mut self, n: Words<u32>) -> Value {
+    unsafe fn alloc_words(&mut self, n: Words<usize>) -> Value {
         self.inner.borrow_mut().alloc_words(n)
     }
 
-    unsafe fn grow_memory(&mut self, ptr: u64) {
-        self.inner.borrow_mut().grow_memory(ptr as usize);
+    unsafe fn grow_memory(&mut self, ptr: usize) {
+        self.inner.borrow_mut().grow_memory(ptr);
     }
 }
 
@@ -39,12 +43,16 @@ impl MotokoHeap {
         map: &[(ObjectIdx, Vec<ObjectIdx>)],
         roots: &[ObjectIdx],
         continuation_table: &[ObjectIdx],
+        gc: GC,
+        free_space: usize,
     ) -> MotokoHeap {
         MotokoHeap {
             inner: Rc::new(RefCell::new(MotokoHeapInner::new(
                 map,
                 roots,
                 continuation_table,
+                gc,
+                free_space,
             ))),
         }
     }
@@ -65,6 +73,25 @@ impl MotokoHeap {
         self.inner.borrow().heap_ptr_address()
     }
 
+    /// Update the heap pointer given as an address in the current process.
+    #[non_incremental_gc]
+    pub fn set_heap_ptr_address(&self, address: usize) {
+        self.inner.borrow_mut().set_heap_ptr_address(address)
+    }
+
+    /// Get the last heap pointer, as address in the current process. The address can be used to mutate
+    /// the heap.
+    #[non_incremental_gc]
+    pub fn last_ptr_address(&self) -> usize {
+        self.inner.borrow().last_ptr_address()
+    }
+
+    /// Update the last heap pointer given as an address in the current process.
+    #[non_incremental_gc]
+    pub fn set_last_ptr_address(&self, address: usize) {
+        self.inner.borrow_mut().set_last_ptr_address(address)
+    }
+
     /// Get the beginning of dynamic heap, as an address in the current process
     pub fn heap_base_address(&self) -> usize {
         self.inner.borrow().heap_base_address()
@@ -96,6 +123,7 @@ impl MotokoHeap {
     }
 
     /// Get the address of the variable pointing to region0
+    #[incremental_gc]
     pub fn region0_pointer_variable_address(&self) -> usize {
         self.inner.borrow().region0_pointer_address()
     }
@@ -110,8 +138,8 @@ impl MotokoHeap {
     pub fn dump(&self) {
         unsafe {
             motoko_rts::debug::dump_heap(
-                self.heap_base_address() as u32,
-                self.heap_ptr_address() as u32,
+                self.heap_base_address(),
+                self.heap_ptr_address(),
                 self.static_root_array_variable_address() as *mut Value,
                 self.continuation_table_variable_address() as *mut Value,
             );
@@ -175,6 +203,18 @@ impl MotokoHeapInner {
         self.heap_ptr_offset = self.address_to_offset(address);
     }
 
+    /// Get last heap pointer (i.e. where the dynamic heap ends last GC run) in the process's address space
+    #[non_incremental_gc]
+    fn last_ptr_address(&self) -> usize {
+        self.offset_to_address(self._heap_ptr_last)
+    }
+
+    /// Set last heap pointer
+    #[non_incremental_gc]
+    fn set_last_ptr_address(&mut self, address: usize) {
+        self._heap_ptr_last = self.address_to_offset(address);
+    }
+
     /// Get the address of the variable pointing to the static root array.
     fn static_root_array_variable_address(&self) -> usize {
         self.offset_to_address(self.static_root_array_variable_offset)
@@ -186,99 +226,40 @@ impl MotokoHeapInner {
     }
 
     /// Get the address of the region0 pointer
+    #[incremental_gc]
     fn region0_pointer_address(&self) -> usize {
         self.offset_to_address(self.region0_pointer_variable_offset)
     }
 
-    fn new(
+    #[classical_persistence]
+    pub fn new(
         map: &[(ObjectIdx, Vec<ObjectIdx>)],
         roots: &[ObjectIdx],
         continuation_table: &[ObjectIdx],
+        gc: GC,
+        _free_space: usize,
     ) -> MotokoHeapInner {
-        // Check test correctness: an object should appear at most once in `map`
-        {
-            let heap_objects: FxHashSet<ObjectIdx> = map.iter().map(|(obj, _)| *obj).collect();
-            assert_eq!(
-                heap_objects.len(),
-                map.len(),
-                "Invalid test heap: some objects appear multiple times"
-            );
-        }
-
-        // Three pointers: Static root array, continuation table, and region 0.
-        let root_pointers_size_bytes = 3 * WORD_SIZE;
-
-        // Each object will have array header plus one word for id per object + one word for each reference.
-        // The static root is an array (header + length) with one element, one MutBox for each static variable.
-        let static_root_set_size_bytes = (size_of::<Array>().as_usize()
-            + roots.len()
-            + roots.len() * size_of::<MutBox>().as_usize())
-            * WORD_SIZE;
-
-        let dynamic_heap_size_without_roots = {
-            let object_headers_words = map.len() * (size_of::<Array>().as_usize() + 1);
-            let references_words = map.iter().map(|(_, refs)| refs.len()).sum::<usize>();
-            (object_headers_words + references_words) * WORD_SIZE
-        };
-
-        let continuation_table_size = (size_of::<Array>() + Words(continuation_table.len() as u32))
-            .to_bytes()
-            .as_usize();
-
-        let region0_size = size_of::<Region>().to_bytes().as_usize();
-
-        let dynamic_heap_size_bytes = dynamic_heap_size_without_roots
-            + static_root_set_size_bytes
-            + continuation_table_size
-            + region0_size;
-
-        let total_heap_size_bytes = root_pointers_size_bytes + dynamic_heap_size_bytes;
-
-        let heap_size = heap_size_for_gc();
-
-        // The Worst-case unalignment w.r.t. 32-byte alignment is 28 (assuming
-        // that we have general word alignment). So we over-allocate 28 bytes.
-        let mut heap = vec![0u8; heap_size + 28];
-
-        // Align the dynamic heap starts at a 32-byte multiple.
-        let realign = (32 - (heap.as_ptr() as usize + root_pointers_size_bytes) % 32) % 32;
-        assert_eq!(realign % 4, 0);
+        self::classical::new_heap(map, roots, continuation_table, gc)
+    }
 
-        // Maps `ObjectIdx`s into their offsets in the heap.
-        let (static_root_array_address, continuation_table_address, region0_address) =
-            create_dynamic_heap(
-                map,
-                roots,
-                continuation_table,
-                &mut heap[root_pointers_size_bytes + realign..heap_size + realign],
-            );
+    #[enhanced_orthogonal_persistence]
+    pub fn new(
+        map: &[(ObjectIdx, Vec<ObjectIdx>)],
+        roots: &[ObjectIdx],
+        continuation_table: &[ObjectIdx],
+        _gc: GC,
+        free_space: usize,
+    ) -> MotokoHeapInner {
+        self::enhanced::new_heap(map, roots, continuation_table, free_space)
+    }
 
-        // Root pointers in static memory space.
-        let static_root_array_variable_offset = root_pointers_size_bytes - 3 * WORD_SIZE;
-        let continuation_table_variable_offset = root_pointers_size_bytes - 2 * WORD_SIZE;
-        let region0_pointer_variable_offset = root_pointers_size_bytes - WORD_SIZE;
-        create_static_memory(
-            static_root_array_variable_offset,
-            continuation_table_variable_offset,
-            region0_pointer_variable_offset,
-            static_root_array_address,
-            continuation_table_address,
-            region0_address,
-            &mut heap[realign..root_pointers_size_bytes + realign],
-        );
-
-        MotokoHeapInner {
-            heap: heap.into_boxed_slice(),
-            heap_base_offset: root_pointers_size_bytes + realign,
-            _heap_ptr_last: root_pointers_size_bytes + realign,
-            heap_ptr_offset: total_heap_size_bytes + realign,
-            static_root_array_variable_offset: static_root_array_variable_offset + realign,
-            continuation_table_variable_offset: continuation_table_variable_offset + realign,
-            region0_pointer_variable_offset: region0_pointer_variable_offset + realign,
-        }
+    #[non_incremental_gc]
+    unsafe fn alloc_words(&mut self, n: Words<usize>) -> Value {
+        self.linear_alloc_words(n)
     }
 
-    unsafe fn alloc_words(&mut self, n: Words<u32>) -> Value {
+    #[incremental_gc]
+    unsafe fn alloc_words(&mut self, n: Words<usize>) -> Value {
         let mut dummy_memory = DummyMemory {};
         let result =
             motoko_rts::gc::incremental::get_partitioned_heap().allocate(&mut dummy_memory, n);
@@ -287,7 +268,7 @@ impl MotokoHeapInner {
         self.linear_alloc_words(n)
     }
 
-    unsafe fn linear_alloc_words(&mut self, n: Words<u32>) -> Value {
+    unsafe fn linear_alloc_words(&mut self, n: Words<usize>) -> Value {
         // Update heap pointer
         let old_hp = self.heap_ptr_address();
         let new_hp = old_hp + n.to_bytes().as_usize();
@@ -313,206 +294,54 @@ impl MotokoHeapInner {
 struct DummyMemory {}
 
 impl Memory for DummyMemory {
-    unsafe fn alloc_words(&mut self, _n: Words<u32>) -> Value {
+    unsafe fn alloc_words(&mut self, _n: Words<usize>) -> Value {
         unreachable!()
     }
 
-    unsafe fn grow_memory(&mut self, _ptr: u64) {}
+    unsafe fn grow_memory(&mut self, _ptr: usize) {}
 }
 
 /// Compute the size of the heap to be allocated for the GC test.
-fn heap_size_for_gc() -> usize {
-    3 * PARTITION_SIZE
-}
-
-/// Given a heap description (as a map from objects to objects), and the dynamic part of the heap
-/// (as an array), initialize the dynamic heap with objects.
-///
-/// Returns a pair containing the address of the static root array and the address of the continuation table.
-fn create_dynamic_heap(
-    refs: &[(ObjectIdx, Vec<ObjectIdx>)],
-    static_roots: &[ObjectIdx],
-    continuation_table: &[ObjectIdx],
-    dynamic_heap: &mut [u8],
-) -> (u32, u32, u32) {
-    let heap_start = dynamic_heap.as_ptr() as usize;
-
-    // Maps objects to their addresses
-    let mut object_addrs: FxHashMap<ObjectIdx, usize> = Default::default();
-
-    // First pass allocates objects without fields
-    {
-        let mut heap_offset = 0;
-        for (obj, refs) in refs {
-            object_addrs.insert(*obj, heap_start + heap_offset);
-
-            // Store object header
-            let address = u32::try_from(heap_start + heap_offset).unwrap();
-            write_word(dynamic_heap, heap_offset, TAG_ARRAY_M);
-            heap_offset += WORD_SIZE;
-
-            write_word(dynamic_heap, heap_offset, make_pointer(address)); // forwarding pointer
-            heap_offset += WORD_SIZE;
-
-            // Store length: idx + refs
-            write_word(
-                dynamic_heap,
-                heap_offset,
-                u32::try_from(refs.len() + 1).unwrap(),
-            );
-            heap_offset += WORD_SIZE;
-
-            // Store object value (idx)
-            write_word(dynamic_heap, heap_offset, make_scalar(*obj));
-            heap_offset += WORD_SIZE;
-
-            // Leave space for the fields
-            heap_offset += refs.len() * WORD_SIZE;
+#[non_incremental_gc]
+fn heap_size_for_gc(gc: GC, total_heap_size_bytes: usize, n_objects: usize) -> usize {
+    use super::utils::WORD_SIZE;
+    match gc {
+        GC::Copying => 2 * total_heap_size_bytes,
+        GC::MarkCompact => {
+            let bitmap_size_bytes = {
+                let heap_bytes = Bytes(total_heap_size_bytes);
+                // `...to_words().to_bytes()` below effectively rounds up heap size to word size
+                // then gets the bytes
+                let heap_words = heap_bytes.to_words();
+                let mark_bit_bytes = heap_words.to_bytes();
+
+                // The bitmap implementation rounds up to 64-bits to be able to read as many
+                // bits as possible in one instruction and potentially skip 64 words in the
+                // heap with single 64-bit comparison
+                (((mark_bit_bytes.as_usize() + 7) / 8) * 8)
+                    + size_of::<Blob>().to_bytes().as_usize()
+            };
+            // In the worst case the entire heap will be pushed to the mark stack, but in tests
+            // we limit the size
+            let mark_stack_words = n_objects.clamp(
+                motoko_rts::gc::mark_compact::mark_stack::INIT_STACK_SIZE.as_usize(),
+                super::utils::MAX_MARK_STACK_SIZE,
+            ) + size_of::<Blob>().as_usize();
+
+            total_heap_size_bytes + bitmap_size_bytes as usize + (mark_stack_words * WORD_SIZE)
         }
-    }
-
-    // println!("object addresses={:#?}", object_addrs);
-
-    // Second pass adds fields
-    for (obj, refs) in refs {
-        let obj_offset = object_addrs.get(obj).unwrap() - heap_start;
-        for (ref_idx, ref_) in refs.iter().enumerate() {
-            let ref_addr = make_pointer(*object_addrs.get(ref_).unwrap() as u32);
-            let field_offset = obj_offset
-                + (size_of::<Array>() + Words(1 + ref_idx as u32))
-                    .to_bytes()
-                    .as_usize();
-            write_word(dynamic_heap, field_offset, u32::try_from(ref_addr).unwrap());
+        GC::Generational => {
+            const ROUNDS: usize = 3;
+            const REMEMBERED_SET_MAXIMUM_SIZE: usize = 1024 * 1024 * WORD_SIZE;
+            let size = heap_size_for_gc(GC::MarkCompact, total_heap_size_bytes, n_objects);
+            size + ROUNDS * REMEMBERED_SET_MAXIMUM_SIZE
         }
     }
-
-    // Add the static root table
-    let n_objects = refs.len();
-    // fields+1 for the scalar field (idx)
-    let n_fields: usize = refs.iter().map(|(_, fields)| fields.len() + 1).sum();
-    let root_section_offset = (size_of::<Array>() * n_objects as u32)
-        .to_bytes()
-        .as_usize()
-        + n_fields * WORD_SIZE;
-
-    let mut heap_offset = root_section_offset;
-    let mut root_mutboxes = vec![];
-    {
-        for root_id in static_roots {
-            let mutbox_address = u32::try_from(heap_start + heap_offset).unwrap();
-            root_mutboxes.push(mutbox_address);
-            write_word(dynamic_heap, heap_offset, TAG_MUTBOX);
-            heap_offset += WORD_SIZE;
-
-            write_word(dynamic_heap, heap_offset, make_pointer(mutbox_address));
-            heap_offset += WORD_SIZE;
-
-            let root_ptr = *object_addrs.get(root_id).unwrap();
-            write_word(dynamic_heap, heap_offset, make_pointer(root_ptr as u32));
-            heap_offset += WORD_SIZE;
-        }
-    }
-    let static_root_array_address = u32::try_from(heap_start + heap_offset).unwrap();
-    {
-        write_word(dynamic_heap, heap_offset, TAG_ARRAY_M);
-        heap_offset += WORD_SIZE;
-
-        write_word(
-            dynamic_heap,
-            heap_offset,
-            make_pointer(static_root_array_address),
-        );
-        heap_offset += WORD_SIZE;
-
-        assert_eq!(static_roots.len(), root_mutboxes.len());
-        write_word(dynamic_heap, heap_offset, root_mutboxes.len() as u32);
-        heap_offset += WORD_SIZE;
-
-        for mutbox_address in root_mutboxes {
-            write_word(dynamic_heap, heap_offset, make_pointer(mutbox_address));
-            heap_offset += WORD_SIZE;
-        }
-    }
-
-    let continuation_table_address = u32::try_from(heap_start + heap_offset).unwrap();
-    {
-        write_word(dynamic_heap, heap_offset, TAG_ARRAY_M);
-        heap_offset += WORD_SIZE;
-
-        write_word(
-            dynamic_heap,
-            heap_offset,
-            make_pointer(continuation_table_address),
-        );
-        heap_offset += WORD_SIZE;
-
-        write_word(dynamic_heap, heap_offset, continuation_table.len() as u32);
-        heap_offset += WORD_SIZE;
-
-        for idx in continuation_table {
-            let idx_ptr = *object_addrs.get(idx).unwrap();
-            write_word(dynamic_heap, heap_offset, make_pointer(idx_ptr as u32));
-            heap_offset += WORD_SIZE;
-        }
-    }
-
-    // Add region0
-    let region0_address = u32::try_from(heap_start + heap_offset).unwrap();
-    {
-        write_word(dynamic_heap, heap_offset, TAG_REGION);
-        heap_offset += WORD_SIZE;
-
-        write_word(dynamic_heap, heap_offset, make_pointer(region0_address));
-        heap_offset += WORD_SIZE;
-
-        // lower part of region id
-        write_word(dynamic_heap, heap_offset, 0);
-        heap_offset += WORD_SIZE;
-        // upper part of region id
-        write_word(dynamic_heap, heap_offset, 0);
-        heap_offset += WORD_SIZE;
-        // zero pages
-        write_word(dynamic_heap, heap_offset, 0);
-        heap_offset += WORD_SIZE;
-        // Simplification: Skip the vector pages blob
-        write_word(dynamic_heap, heap_offset, make_scalar(0));
-    }
-
-    (
-        static_root_array_address,
-        continuation_table_address,
-        region0_address,
-    )
 }
 
-/// Static memory part containing the root pointers.
-fn create_static_memory(
-    static_root_array_variable_offset: usize,
-    continuation_table_variable_offset: usize,
-    region0_pointer_variable_offset: usize,
-    static_root_array_address: u32,
-    continuation_table_address: u32,
-    region0_address: u32,
-    heap: &mut [u8],
-) {
-    // Write static array pointer as the third last word in static memory
-    write_word(
-        heap,
-        static_root_array_variable_offset,
-        make_pointer(static_root_array_address),
-    );
-
-    // Write continuation table pointer as the second last word in static memory
-    write_word(
-        heap,
-        continuation_table_variable_offset,
-        make_pointer(continuation_table_address),
-    );
-
-    // Write region 0 pointer as the very last word in static memory
-    write_word(
-        heap,
-        region0_pointer_variable_offset,
-        make_pointer(region0_address),
-    );
+#[incremental_gc]
+fn heap_size_for_gc(gc: GC, _total_heap_size_bytes: usize, _n_objects: usize) -> usize {
+    match gc {
+        GC::Incremental => 3 * motoko_rts::gc::incremental::partitioned_heap::PARTITION_SIZE,
+    }
 }
diff --git a/rts/motoko-rts-tests/src/gc/heap/classical.rs b/rts/motoko-rts-tests/src/gc/heap/classical.rs
new file mode 100644
index 00000000000..e613f84708d
--- /dev/null
+++ b/rts/motoko-rts-tests/src/gc/heap/classical.rs
@@ -0,0 +1,294 @@
+use super::{heap_size_for_gc, MotokoHeapInner};
+
+use crate::gc::utils::{make_pointer, make_scalar, write_word, ObjectIdx, GC, WORD_SIZE};
+
+use motoko_rts::types::*;
+
+use fxhash::{FxHashMap, FxHashSet};
+
+pub(super) fn new_heap(
+    map: &[(ObjectIdx, Vec<ObjectIdx>)],
+    roots: &[ObjectIdx],
+    continuation_table: &[ObjectIdx],
+    gc: GC,
+) -> MotokoHeapInner {
+    // Check test correctness: an object should appear at most once in `map`
+    {
+        let heap_objects: FxHashSet<ObjectIdx> = map.iter().map(|(obj, _)| *obj).collect();
+        assert_eq!(
+            heap_objects.len(),
+            map.len(),
+            "Invalid test heap: some objects appear multiple times"
+        );
+    }
+
+    // Each object will have array header plus one word for id per object + one word for each reference. Static heap will
+    // have an array (header + length) with one element, one MutBox for each root. +1 for
+    // continuation table pointer.
+    let static_heap_size_bytes = (size_of::<Array>().as_usize()
+        + roots.len()
+        + (roots.len() * size_of::<MutBox>().as_usize())
+        + 2)
+        * WORD_SIZE;
+
+    let dynamic_heap_size_without_roots = {
+        let object_headers_words = map.len() * (size_of::<Array>().as_usize() + 1);
+        let references_words = map.iter().map(|(_, refs)| refs.len()).sum::<usize>();
+        (object_headers_words + references_words) * WORD_SIZE
+    };
+
+    let continuation_table_size = (size_of::<Array>() + Words(continuation_table.len()))
+        .to_bytes()
+        .as_usize();
+
+    let region0_size = size_of::<Region>().to_bytes().as_usize();
+
+    let dynamic_heap_size_bytes =
+        dynamic_heap_size_without_roots + continuation_table_size + region0_size;
+
+    let total_heap_size_bytes = static_heap_size_bytes + dynamic_heap_size_bytes;
+
+    let heap_size = heap_size_for_gc(gc, total_heap_size_bytes, map.len());
+
+    // The Worst-case unalignment w.r.t. 32-byte alignment is 28 (assuming
+    // that we have general word alignment). So we over-allocate 28 bytes.
+    let mut heap = vec![0u8; heap_size + 28];
+
+    // Align the dynamic heap starts at a 32-byte multiple.
+    let realign = (32 - (heap.as_ptr() as usize + static_heap_size_bytes) % 32) % 32;
+    assert_eq!(realign % 4, 0);
+
+    // Maps `ObjectIdx`s into their offsets in the heap.
+    let object_addrs: FxHashMap<ObjectIdx, usize> = create_dynamic_heap(
+        map,
+        continuation_table,
+        &mut heap[static_heap_size_bytes + realign..heap_size + realign],
+    );
+
+    // Closure table pointer is the second last word in the static heap.
+    let continuation_table_ptr_offset = static_heap_size_bytes - WORD_SIZE * 2;
+
+    // Region0 pointer is the very last word in the static heap.
+    let region0_ptr_location_offset = static_heap_size_bytes - WORD_SIZE;
+
+    create_static_heap(
+        roots,
+        &object_addrs,
+        continuation_table_ptr_offset,
+        static_heap_size_bytes + dynamic_heap_size_without_roots,
+        region0_ptr_location_offset,
+        static_heap_size_bytes + dynamic_heap_size_without_roots + continuation_table_size,
+        &mut heap[realign..static_heap_size_bytes + realign],
+    );
+
+    MotokoHeapInner {
+        heap: heap.into_boxed_slice(),
+        heap_base_offset: static_heap_size_bytes + realign,
+        _heap_ptr_last: static_heap_size_bytes + realign,
+        heap_ptr_offset: total_heap_size_bytes + realign,
+        static_root_array_variable_offset: realign,
+        continuation_table_variable_offset: continuation_table_ptr_offset + realign,
+        region0_pointer_variable_offset: region0_ptr_location_offset + realign,
+    }
+}
+
+/// Given a heap description (as a map from objects to objects), and the dynamic part of the heap
+/// (as an array), initialize the dynamic heap with objects.
+///
+/// Returns a mapping from object indices (`ObjectIdx`) to their addresses (see module
+/// documentation for "offset" and "address" definitions).
+fn create_dynamic_heap(
+    refs: &[(ObjectIdx, Vec<ObjectIdx>)],
+    continuation_table: &[ObjectIdx],
+    dynamic_heap: &mut [u8],
+) -> FxHashMap<ObjectIdx, usize> {
+    let incremental = cfg!(feature = "incremental_gc");
+    let heap_start = dynamic_heap.as_ptr() as usize;
+
+    // Maps objects to their addresses
+    let mut object_addrs: FxHashMap<ObjectIdx, usize> = Default::default();
+
+    // First pass allocates objects without fields
+    {
+        let mut heap_offset = 0;
+        for (obj, refs) in refs {
+            object_addrs.insert(*obj, heap_start + heap_offset);
+
+            // Store object header
+            let address = heap_start + heap_offset;
+            write_word(dynamic_heap, heap_offset, TAG_ARRAY_M);
+            heap_offset += WORD_SIZE;
+
+            if incremental {
+                write_word(dynamic_heap, heap_offset, make_pointer(address)); // forwarding pointer
+                heap_offset += WORD_SIZE;
+            }
+
+            // Store length: idx + refs
+            write_word(dynamic_heap, heap_offset, refs.len() + 1);
+            heap_offset += WORD_SIZE;
+
+            // Store object value (idx)
+            write_word(dynamic_heap, heap_offset, make_scalar(*obj));
+            heap_offset += WORD_SIZE;
+
+            // Leave space for the fields
+            heap_offset += refs.len() * WORD_SIZE;
+        }
+    }
+
+    // println!("object addresses={:#?}", object_addrs);
+
+    // Second pass adds fields
+    for (obj, refs) in refs {
+        let obj_offset = object_addrs.get(obj).unwrap() - heap_start;
+        for (ref_idx, ref_) in refs.iter().enumerate() {
+            let ref_addr = make_pointer(*object_addrs.get(ref_).unwrap());
+            let field_offset = obj_offset
+                + (size_of::<Array>() + Words(1 + ref_idx))
+                    .to_bytes()
+                    .as_usize();
+            write_word(dynamic_heap, field_offset, ref_addr);
+        }
+    }
+
+    // Add the continuation table
+    let n_objects = refs.len();
+    // fields+1 for the scalar field (idx)
+    let n_fields: usize = refs.iter().map(|(_, fields)| fields.len() + 1).sum();
+    let continuation_table_offset =
+        (size_of::<Array>() * n_objects).to_bytes().as_usize() + n_fields * WORD_SIZE;
+    let continuation_table_size =
+        size_of::<Array>().to_bytes().as_usize() + continuation_table.len() * WORD_SIZE;
+
+    {
+        let mut heap_offset = continuation_table_offset;
+
+        let continuation_table_address = heap_start + heap_offset;
+        write_word(dynamic_heap, heap_offset, TAG_ARRAY_M);
+        heap_offset += WORD_SIZE;
+
+        if incremental {
+            write_word(
+                dynamic_heap,
+                heap_offset,
+                make_pointer(continuation_table_address),
+            );
+            heap_offset += WORD_SIZE;
+        }
+
+        write_word(dynamic_heap, heap_offset, continuation_table.len());
+        heap_offset += WORD_SIZE;
+
+        for idx in continuation_table {
+            let idx_ptr = *object_addrs.get(idx).unwrap();
+            write_word(dynamic_heap, heap_offset, make_pointer(idx_ptr));
+            heap_offset += WORD_SIZE;
+        }
+    }
+
+    // Add region0
+    let region0_offset = continuation_table_offset + continuation_table_size;
+    {
+        let mut heap_offset = region0_offset;
+        let region0_address = heap_start + heap_offset;
+        write_word(dynamic_heap, heap_offset, TAG_REGION);
+        heap_offset += WORD_SIZE;
+
+        if incremental {
+            write_word(dynamic_heap, heap_offset, make_pointer(region0_address));
+            heap_offset += WORD_SIZE;
+        }
+
+        // lower part of region id
+        write_word(dynamic_heap, heap_offset, 0);
+        heap_offset += WORD_SIZE;
+        // upper part of region id
+        write_word(dynamic_heap, heap_offset, 0);
+        heap_offset += WORD_SIZE;
+        // zero pages
+        write_word(dynamic_heap, heap_offset, 0);
+        heap_offset += WORD_SIZE;
+        // Simplification: Skip the vector pages blob
+        write_word(dynamic_heap, heap_offset, make_scalar(0));
+    }
+
+    object_addrs
+}
+
+/// Given a root set (`roots`, may contain duplicates), a mapping from object indices to addresses
+/// (`object_addrs`), and the static part of the heap, initialize the static heap with the static
+/// root array.
+fn create_static_heap(
+    roots: &[ObjectIdx],
+    object_addrs: &FxHashMap<ObjectIdx, usize>,
+    continuation_table_ptr_offset: usize,
+    continuation_table_offset: usize,
+    region0_ptr_offset: usize,
+    region0_offset: usize,
+    heap: &mut [u8],
+) {
+    let incremental = cfg!(feature = "incremental_gc");
+    let root_addresses: Vec<usize> = roots
+        .iter()
+        .map(|obj| *object_addrs.get(obj).unwrap())
+        .collect();
+
+    // Create static root array. Each element of the array is a MutBox pointing to the actual
+    // root.
+    let array_addr = heap.as_ptr() as usize;
+    let mut offset = 0;
+    write_word(heap, offset, TAG_ARRAY_M);
+    offset += WORD_SIZE;
+
+    if incremental {
+        write_word(heap, offset, make_pointer(array_addr));
+        offset += WORD_SIZE;
+    }
+
+    write_word(heap, offset, roots.len());
+    offset += WORD_SIZE;
+
+    // Current offset in the heap for the next static roots array element
+    let mut root_addr_offset = size_of::<Array>().to_bytes().as_usize();
+    assert_eq!(offset, root_addr_offset);
+
+    // Current offset in the heap for the MutBox of the next root
+    let mut mutbox_offset = (size_of::<Array>().as_usize() + roots.len()) * WORD_SIZE;
+
+    for root_address in root_addresses {
+        // Add a MutBox for the object
+        let mutbox_addr = heap.as_ptr() as usize + mutbox_offset;
+        let mutbox_ptr = make_pointer(mutbox_addr);
+
+        offset = mutbox_offset;
+        write_word(heap, offset, TAG_MUTBOX);
+        offset += WORD_SIZE;
+
+        if incremental {
+            write_word(heap, offset, mutbox_ptr);
+            offset += WORD_SIZE;
+        }
+
+        write_word(heap, offset, make_pointer(root_address));
+        offset += WORD_SIZE;
+
+        write_word(heap, root_addr_offset, mutbox_ptr);
+
+        root_addr_offset += WORD_SIZE;
+        mutbox_offset += size_of::<MutBox>().to_bytes().as_usize();
+        assert_eq!(offset, mutbox_offset);
+    }
+
+    // Write continuation table pointer as the second last word in static heap
+    let continuation_table_ptr = continuation_table_offset + heap.as_ptr() as usize;
+    write_word(
+        heap,
+        continuation_table_ptr_offset,
+        make_pointer(continuation_table_ptr),
+    );
+
+    // Write continuation table pointer as the second last word in static heap
+    let region0_ptr = region0_offset + heap.as_ptr() as usize;
+    write_word(heap, region0_ptr_offset, make_pointer(region0_ptr));
+}
diff --git a/rts/motoko-rts-tests/src/gc/heap/enhanced.rs b/rts/motoko-rts-tests/src/gc/heap/enhanced.rs
new file mode 100644
index 00000000000..853a468f308
--- /dev/null
+++ b/rts/motoko-rts-tests/src/gc/heap/enhanced.rs
@@ -0,0 +1,285 @@
+use super::{heap_size_for_gc, MotokoHeapInner};
+
+use crate::gc::utils::{make_pointer, make_scalar, write_word, ObjectIdx, GC, WORD_SIZE};
+
+use motoko_rts::types::*;
+
+use fxhash::{FxHashMap, FxHashSet};
+
+pub(super) fn new_heap(
+    map: &[(ObjectIdx, Vec<ObjectIdx>)],
+    roots: &[ObjectIdx],
+    continuation_table: &[ObjectIdx],
+    free_space: usize,
+) -> MotokoHeapInner {
+    // Check test correctness: an object should appear at most once in `map`
+    {
+        let heap_objects: FxHashSet<ObjectIdx> = map.iter().map(|(obj, _)| *obj).collect();
+        assert_eq!(
+            heap_objects.len(),
+            map.len(),
+            "Invalid test heap: some objects appear multiple times"
+        );
+    }
+
+    // Three pointers: Static root array, continuation table, and region 0.
+    let root_pointers_size_bytes = 3 * WORD_SIZE;
+
+    // Each object will have array header plus one word for id per object + one word for each reference.
+    // The static root is an array (header + length) with one element, one MutBox for each static variable.
+    let static_root_set_size_bytes = (size_of::<Array>().as_usize()
+        + roots.len()
+        + roots.len() * size_of::<MutBox>().as_usize())
+        * WORD_SIZE;
+
+    let dynamic_heap_size_without_roots = {
+        let object_headers_words = map.len() * (size_of::<Array>().as_usize() + 1);
+        let references_words = map.iter().map(|(_, refs)| refs.len()).sum::<usize>();
+        (object_headers_words + references_words) * WORD_SIZE
+    };
+
+    let continuation_table_size = (size_of::<Array>() + Words(continuation_table.len()))
+        .to_bytes()
+        .as_usize();
+
+    let region0_size = size_of::<Region>().to_bytes().as_usize();
+
+    let dynamic_heap_size_bytes = dynamic_heap_size_without_roots
+        + static_root_set_size_bytes
+        + continuation_table_size
+        + region0_size;
+
+    let total_heap_size_bytes = root_pointers_size_bytes + dynamic_heap_size_bytes;
+
+    let heap_size = heap_size_for_gc(GC::Incremental, total_heap_size_bytes, map.len());
+
+    const HEAP_ALIGNMENT: usize = usize::BITS as usize;
+    // The Worst-case unalignment is one word less than the intended heap alignment
+    // (assuming that we have general word alignment). So we over-allocate `HEAP_ALIGNMENT - WORD_SIZE` bytes.
+    let mut heap = vec![0u8; heap_size + HEAP_ALIGNMENT - WORD_SIZE + free_space];
+
+    // Align the dynamic heap start.
+    let realign = (HEAP_ALIGNMENT
+        - (heap.as_ptr() as usize + root_pointers_size_bytes) % HEAP_ALIGNMENT)
+        % HEAP_ALIGNMENT;
+    assert_eq!(realign % WORD_SIZE, 0);
+
+    // Maps `ObjectIdx`s into their offsets in the heap.
+    let (static_root_array_address, continuation_table_address, region0_address) =
+        create_dynamic_heap(
+            map,
+            roots,
+            continuation_table,
+            &mut heap[root_pointers_size_bytes + realign..heap_size + realign],
+        );
+
+    // Root pointers in static memory space.
+    let static_root_array_variable_offset = root_pointers_size_bytes - 3 * WORD_SIZE;
+    let continuation_table_variable_offset = root_pointers_size_bytes - 2 * WORD_SIZE;
+    let region0_pointer_variable_offset = root_pointers_size_bytes - WORD_SIZE;
+    create_static_memory(
+        static_root_array_variable_offset,
+        continuation_table_variable_offset,
+        region0_pointer_variable_offset,
+        static_root_array_address,
+        continuation_table_address,
+        region0_address,
+        &mut heap[realign..root_pointers_size_bytes + realign],
+    );
+
+    MotokoHeapInner {
+        heap: heap.into_boxed_slice(),
+        heap_base_offset: root_pointers_size_bytes + realign,
+        _heap_ptr_last: root_pointers_size_bytes + realign,
+        heap_ptr_offset: total_heap_size_bytes + realign,
+        static_root_array_variable_offset: static_root_array_variable_offset + realign,
+        continuation_table_variable_offset: continuation_table_variable_offset + realign,
+        region0_pointer_variable_offset: region0_pointer_variable_offset + realign,
+    }
+}
+
+/// Given a heap description (as a map from objects to objects), and the dynamic part of the heap
+/// (as an array), initialize the dynamic heap with objects.
+///
+/// Returns a pair containing the address of the static root array and the address of the continuation table.
+fn create_dynamic_heap(
+    refs: &[(ObjectIdx, Vec<ObjectIdx>)],
+    static_roots: &[ObjectIdx],
+    continuation_table: &[ObjectIdx],
+    dynamic_heap: &mut [u8],
+) -> (usize, usize, usize) {
+    let heap_start = dynamic_heap.as_ptr() as usize;
+
+    // Maps objects to their addresses
+    let mut object_addrs: FxHashMap<ObjectIdx, usize> = Default::default();
+
+    // First pass allocates objects without fields
+    {
+        let mut heap_offset = 0;
+        for (obj, refs) in refs {
+            object_addrs.insert(*obj, heap_start + heap_offset);
+
+            // Store object header
+            let address = heap_start + heap_offset;
+            write_word(dynamic_heap, heap_offset, TAG_ARRAY_M);
+            heap_offset += WORD_SIZE;
+
+            write_word(dynamic_heap, heap_offset, make_pointer(address)); // forwarding pointer
+            heap_offset += WORD_SIZE;
+
+            // Store length: idx + refs
+            write_word(dynamic_heap, heap_offset, refs.len() + 1);
+            heap_offset += WORD_SIZE;
+
+            // Store object value (idx)
+            write_word(dynamic_heap, heap_offset, make_scalar(*obj));
+            heap_offset += WORD_SIZE;
+
+            // Leave space for the fields
+            heap_offset += refs.len() * WORD_SIZE;
+        }
+    }
+
+    // println!("object addresses={:#?}", object_addrs);
+
+    // Second pass adds fields
+    for (obj, refs) in refs {
+        let obj_offset = object_addrs.get(obj).unwrap() - heap_start;
+        for (ref_idx, ref_) in refs.iter().enumerate() {
+            let ref_addr = make_pointer(*object_addrs.get(ref_).unwrap());
+            let field_offset = obj_offset
+                + (size_of::<Array>() + Words(1 + ref_idx))
+                    .to_bytes()
+                    .as_usize();
+            write_word(dynamic_heap, field_offset, ref_addr);
+        }
+    }
+
+    // Add the static root table
+    let n_objects = refs.len();
+    // fields+1 for the scalar field (idx)
+    let n_fields: usize = refs.iter().map(|(_, fields)| fields.len() + 1).sum();
+    let root_section_offset =
+        (size_of::<Array>() * n_objects).to_bytes().as_usize() + n_fields * WORD_SIZE;
+
+    let mut heap_offset = root_section_offset;
+    let mut root_mutboxes = vec![];
+    {
+        for root_id in static_roots {
+            let mutbox_address = heap_start + heap_offset;
+            root_mutboxes.push(mutbox_address);
+            write_word(dynamic_heap, heap_offset, TAG_MUTBOX);
+            heap_offset += WORD_SIZE;
+
+            write_word(dynamic_heap, heap_offset, make_pointer(mutbox_address));
+            heap_offset += WORD_SIZE;
+
+            let root_ptr = *object_addrs.get(root_id).unwrap();
+            write_word(dynamic_heap, heap_offset, make_pointer(root_ptr));
+            heap_offset += WORD_SIZE;
+        }
+    }
+    let static_root_array_address = heap_start + heap_offset;
+    {
+        write_word(dynamic_heap, heap_offset, TAG_ARRAY_M);
+        heap_offset += WORD_SIZE;
+
+        write_word(
+            dynamic_heap,
+            heap_offset,
+            make_pointer(static_root_array_address),
+        );
+        heap_offset += WORD_SIZE;
+
+        assert_eq!(static_roots.len(), root_mutboxes.len());
+        write_word(dynamic_heap, heap_offset, root_mutboxes.len());
+        heap_offset += WORD_SIZE;
+
+        for mutbox_address in root_mutboxes {
+            write_word(dynamic_heap, heap_offset, make_pointer(mutbox_address));
+            heap_offset += WORD_SIZE;
+        }
+    }
+
+    let continuation_table_address = heap_start + heap_offset;
+    {
+        write_word(dynamic_heap, heap_offset, TAG_ARRAY_M);
+        heap_offset += WORD_SIZE;
+
+        write_word(
+            dynamic_heap,
+            heap_offset,
+            make_pointer(continuation_table_address),
+        );
+        heap_offset += WORD_SIZE;
+
+        write_word(dynamic_heap, heap_offset, continuation_table.len());
+        heap_offset += WORD_SIZE;
+
+        for idx in continuation_table {
+            let idx_ptr = *object_addrs.get(idx).unwrap();
+            write_word(dynamic_heap, heap_offset, make_pointer(idx_ptr));
+            heap_offset += WORD_SIZE;
+        }
+    }
+
+    // Add region0
+    let region0_address = heap_start + heap_offset;
+    {
+        write_word(dynamic_heap, heap_offset, TAG_REGION);
+        heap_offset += WORD_SIZE;
+
+        write_word(dynamic_heap, heap_offset, make_pointer(region0_address));
+        heap_offset += WORD_SIZE;
+
+        // lower part of region id
+        write_word(dynamic_heap, heap_offset, 0);
+        heap_offset += WORD_SIZE;
+        // upper part of region id
+        write_word(dynamic_heap, heap_offset, 0);
+        heap_offset += WORD_SIZE;
+        // zero pages
+        write_word(dynamic_heap, heap_offset, 0);
+        heap_offset += WORD_SIZE;
+        // Simplification: Skip the vector pages blob
+        write_word(dynamic_heap, heap_offset, make_scalar(0));
+    }
+
+    (
+        static_root_array_address,
+        continuation_table_address,
+        region0_address,
+    )
+}
+
+/// Static memory part containing the root pointers.
+fn create_static_memory(
+    static_root_array_variable_offset: usize,
+    continuation_table_variable_offset: usize,
+    region0_pointer_variable_offset: usize,
+    static_root_array_address: usize,
+    continuation_table_address: usize,
+    region0_address: usize,
+    heap: &mut [u8],
+) {
+    // Write static array pointer as the third last word in static memory
+    write_word(
+        heap,
+        static_root_array_variable_offset,
+        make_pointer(static_root_array_address),
+    );
+
+    // Write continuation table pointer as the second last word in static memory
+    write_word(
+        heap,
+        continuation_table_variable_offset,
+        make_pointer(continuation_table_address),
+    );
+
+    // Write region 0 pointer as the very last word in static memory
+    write_word(
+        heap,
+        region0_pointer_variable_offset,
+        make_pointer(region0_address),
+    );
+}
diff --git a/rts/motoko-rts-tests/src/gc/incremental/array_slicing.rs b/rts/motoko-rts-tests/src/gc/incremental/array_slicing.rs
index 72086c92f85..df2060a222c 100644
--- a/rts/motoko-rts-tests/src/gc/incremental/array_slicing.rs
+++ b/rts/motoko-rts-tests/src/gc/incremental/array_slicing.rs
@@ -24,7 +24,7 @@ pub unsafe fn test() {
     }
 }
 
-unsafe fn test_array_slicing(mem: &mut TestMemory, tag: Tag, array_length: u32) {
+unsafe fn test_array_slicing(mem: &mut TestMemory, tag: Tag, array_length: usize) {
     let array = alloc_array(mem, tag, array_length).as_array();
     let mut last_offset = 0;
     loop {
diff --git a/rts/motoko-rts-tests/src/gc/incremental/mark_bitmap.rs b/rts/motoko-rts-tests/src/gc/incremental/mark_bitmap.rs
index 163ab7d3f82..4df813cff71 100644
--- a/rts/motoko-rts-tests/src/gc/incremental/mark_bitmap.rs
+++ b/rts/motoko-rts-tests/src/gc/incremental/mark_bitmap.rs
@@ -14,7 +14,7 @@ use proptest::test_runner::{Config, TestCaseResult, TestRunner};
 
 pub unsafe fn test() {
     println!("  Testing mark bitmap ...");
-    let bitmap_size = Bytes(PARTITION_SIZE as u32).to_words();
+    let bitmap_size = Bytes(PARTITION_SIZE).to_words();
     let mut mem = TestMemory::new(bitmap_size);
     let bitmap_pointer = mem.alloc_words(bitmap_size);
 
@@ -34,32 +34,34 @@ pub unsafe fn test() {
 
     println!("  Testing bit iteration");
     proptest_runner
-        .run(&bit_index_set_strategy(), |bits| {
-            test_iterator_proptest(bitmap_pointer, bits)
+        .run(&bit_index_vector_strategy(), |bits| {
+            let mut hash_set = HashSet::new();
+            for value in bits {
+                hash_set.insert(value);
+            }
+            test_iterator_proptest(bitmap_pointer, hash_set)
         })
         .unwrap();
 
     test_last_bit(bitmap_pointer);
 }
 
-fn bit_index_vector_strategy() -> impl Strategy<Value = Vec<u16>> {
-    proptest::collection::vec(0u16..u16::MAX, 0..1_000)
-}
+const MAX_TEST_BIT_INDEX: usize = u16::MAX as usize;
 
-fn bit_index_set_strategy() -> impl Strategy<Value = HashSet<u16>> {
-    proptest::collection::hash_set(0u16..u16::MAX, 0..1_000)
+fn bit_index_vector_strategy() -> impl Strategy<Value = Vec<usize>> {
+    proptest::collection::vec(0..MAX_TEST_BIT_INDEX, 0..1_000)
 }
 
-fn test_mark_proptest(bitmap_pointer: Value, bits: Vec<u16>) -> TestCaseResult {
+fn test_mark_proptest(bitmap_pointer: Value, bits: Vec<usize>) -> TestCaseResult {
     test_mark(bitmap_pointer, bits);
     Ok(())
 }
 
-fn address_of_bit(bit: u16) -> usize {
-    bit as usize * WORD_SIZE as usize
+fn address_of_bit(bit: usize) -> usize {
+    bit * WORD_SIZE
 }
 
-fn test_mark(bitmap_pointer: Value, mut bits: Vec<u16>) {
+fn test_mark(bitmap_pointer: Value, mut bits: Vec<usize>) {
     unsafe {
         let mut bitmap = MarkBitmap::new();
         bitmap.assign(bitmap_pointer.get_ptr() as *mut u8);
@@ -71,7 +73,7 @@ fn test_mark(bitmap_pointer: Value, mut bits: Vec<u16>) {
             assert!(bitmap.is_marked(address_of_bit(*bit)));
         }
         bits.sort();
-        let mut last_bit: Option<u16> = None;
+        let mut last_bit: Option<usize> = None;
         for bit in bits {
             if let Some(last_bit) = last_bit {
                 for i in last_bit + 1..bit {
@@ -85,12 +87,12 @@ fn test_mark(bitmap_pointer: Value, mut bits: Vec<u16>) {
     }
 }
 
-fn test_iterator_proptest(bitmap_pointer: Value, bits: HashSet<u16>) -> TestCaseResult {
+fn test_iterator_proptest(bitmap_pointer: Value, bits: HashSet<usize>) -> TestCaseResult {
     test_iterator(bitmap_pointer, bits);
     Ok(())
 }
 
-fn test_iterator(bitmap_pointer: Value, bits: HashSet<u16>) {
+fn test_iterator(bitmap_pointer: Value, bits: HashSet<usize>) {
     unsafe {
         let mut bitmap = MarkBitmap::new();
         bitmap.assign(bitmap_pointer.get_ptr() as *mut u8);
@@ -117,7 +119,7 @@ fn test_iterator(bitmap_pointer: Value, bits: HashSet<u16>) {
 }
 
 fn test_last_bit(bitmap_pointer: Value) {
-    const LAST_OFFSET: usize = PARTITION_SIZE - WORD_SIZE as usize;
+    const LAST_OFFSET: usize = PARTITION_SIZE - WORD_SIZE;
     unsafe {
         let mut bitmap = MarkBitmap::new();
         bitmap.assign(bitmap_pointer.get_ptr() as *mut u8);
diff --git a/rts/motoko-rts-tests/src/gc/incremental/mark_stack.rs b/rts/motoko-rts-tests/src/gc/incremental/mark_stack.rs
index 373c9432e52..fca830d9653 100644
--- a/rts/motoko-rts-tests/src/gc/incremental/mark_stack.rs
+++ b/rts/motoko-rts-tests/src/gc/incremental/mark_stack.rs
@@ -33,12 +33,12 @@ unsafe fn internal_push_pop(
     regrow_step: usize,
 ) {
     for count in 0..amount {
-        stack.push(mem, Value::from_scalar(count as u32));
+        stack.push(mem, Value::from_scalar(count));
         if count == regrow_step {
             internal_push_pop(mem, stack, amount - count, regrow_step);
         }
     }
     for count in (0..amount).rev() {
-        assert_eq!(stack.pop().get_scalar() as usize, count);
+        assert_eq!(stack.pop().get_scalar(), count);
     }
 }
diff --git a/rts/motoko-rts-tests/src/gc/incremental/partitioned_heap.rs b/rts/motoko-rts-tests/src/gc/incremental/partitioned_heap.rs
index cac98d79f02..e9d82289f77 100644
--- a/rts/motoko-rts-tests/src/gc/incremental/partitioned_heap.rs
+++ b/rts/motoko-rts-tests/src/gc/incremental/partitioned_heap.rs
@@ -23,7 +23,8 @@ use motoko_rts::{
 
 use crate::{gc::utils::WORD_SIZE, memory::TestMemory};
 
-const NUMBER_OF_OBJECTS: usize = 2 * PARTITION_SIZE / 16;
+const OBJECT_SIZE: usize = size_of::<Array>() + WORD_SIZE;
+const NUMBER_OF_OBJECTS: usize = 2 * PARTITION_SIZE / OBJECT_SIZE;
 const HEAP_SIZE: usize = 4 * PARTITION_SIZE;
 
 pub unsafe fn test() {
@@ -103,10 +104,9 @@ unsafe fn iterate_partition(
 ) {
     while iterator.has_object() {
         let object = iterator.current_object();
-        //println!("FOUND {:#x} {}", object as usize, set.len());
         let array = Value::from_ptr(object as usize).as_array();
         let content = array.get(0).get_scalar();
-        let inserted = set.insert(content as usize);
+        let inserted = set.insert(content);
         assert!(inserted);
         progress(set.len(), NUMBER_OF_OBJECTS);
         assert_eq!(partition.get_index(), object as usize / PARTITION_SIZE);
@@ -121,7 +121,7 @@ unsafe fn iterate_partition(
 unsafe fn test_evacuation_plan(heap: &mut PartitionedTestHeap, occupied_partitions: usize) {
     println!("    Test evacuation plan...");
     unmark_all_objects(heap);
-    heap.inner.plan_evacuations();
+    heap.inner.plan_evacuations(&mut heap.memory);
     let mut iterator = PartitionedHeapIterator::new(&heap.inner);
     while iterator.has_partition() {
         let partition = iterator.current_partition(&heap.inner);
@@ -153,8 +153,6 @@ unsafe fn test_freeing_partitions(heap: &mut PartitionedTestHeap, occupied_parti
     heap.inner.complete_collection();
 }
 
-const OBJECT_SIZE: usize = size_of::<Array>() + WORD_SIZE;
-
 unsafe fn test_reallocations(heap: &mut PartitionedTestHeap) {
     println!("    Test reallocations...");
     let mut time = BoundedTime::new(0);
@@ -192,7 +190,7 @@ unsafe fn count_objects_in_partition(
         let object = iterator.current_object();
         assert_eq!(partition.get_index(), object as usize / PARTITION_SIZE);
         let array = Value::from_ptr(object as usize).as_array();
-        let content = array.get(0).get_scalar() as usize;
+        let content = array.get(0).get_scalar();
         assert!(content < NUMBER_OF_OBJECTS);
         time.tick();
         count += 1;
@@ -206,6 +204,11 @@ unsafe fn count_objects_in_partition(
 
 fn test_close_partition(heap: &mut PartitionedTestHeap) {
     println!("    Test close partition...");
+    // Due to Rust borrow check restrictions, preceding `plan_evacuations`
+    // allocates directly in `heap.memory` without synchronizing the heap
+    // pointer in `heap`. Therefore, re-align the heap pointer of `heap`
+    // with `heap.memory`.
+    heap.allocate_blob(0);
     test_close_partition_multi_word(heap);
     test_close_partition_single_word(heap);
 }
@@ -253,19 +256,28 @@ unsafe fn test_large_size_scenario() {
     println!("    Test large allocations...");
     const LARGE: usize = PARTITION_SIZE + WORD_SIZE;
     const EXTRA_LARGE: usize = 2 * PARTITION_SIZE;
-    test_allocation_sizes(&[32, PARTITION_SIZE, 16], 3);
-    test_allocation_sizes(&[28, LARGE, 20], 3);
-    test_allocation_sizes(&[24, LARGE, LARGE, 36], 5);
-    test_allocation_sizes(&[24, EXTRA_LARGE, 16], 3);
-    test_allocation_sizes(&[24, EXTRA_LARGE, LARGE, 16], 6);
-    test_allocation_sizes(&[24, EXTRA_LARGE, 32, LARGE, 16], 6);
+    test_allocation_sizes(&[8 * WORD_SIZE, PARTITION_SIZE, 4 * WORD_SIZE], 3);
+    test_allocation_sizes(&[7 * WORD_SIZE, LARGE, 5 * WORD_SIZE], 3);
+    test_allocation_sizes(&[6 * WORD_SIZE, LARGE, LARGE, 9 * WORD_SIZE], 5);
+    test_allocation_sizes(&[6 * WORD_SIZE, EXTRA_LARGE, 4 * WORD_SIZE], 3);
+    test_allocation_sizes(&[6 * WORD_SIZE, EXTRA_LARGE, LARGE, 4 * WORD_SIZE], 6);
+    test_allocation_sizes(
+        &[
+            6 * WORD_SIZE,
+            EXTRA_LARGE,
+            8 * WORD_SIZE,
+            LARGE,
+            4 * WORD_SIZE,
+        ],
+        6,
+    );
 }
 
 unsafe fn test_allocation_sizes(sizes: &[usize], number_of_partitions: usize) {
     let total_partitions = number_of_partitions + 1; // Plus temporary partition.
     let mut heap = PartitionedTestHeap::new(total_partitions * PARTITION_SIZE);
     let heap_base = heap.heap_base();
-    let state = IncrementalGC::initial_gc_state(&mut heap, heap_base);
+    let state = IncrementalGC::<PartitionedTestHeap>::initial_gc_state(heap_base);
     set_incremental_gc_state(Some(state));
     assert!(heap.inner.occupied_size().as_usize() < PARTITION_SIZE + heap.heap_base());
     let mut time = BoundedTime::new(0);
@@ -283,7 +295,7 @@ unsafe fn test_allocation_sizes(sizes: &[usize], number_of_partitions: usize) {
     );
     iterate_large_objects(&heap.inner, sizes);
     unmark_all_objects(&mut heap);
-    heap.inner.plan_evacuations();
+    heap.inner.plan_evacuations(&mut heap.memory);
     heap.inner.collect_large_objects();
     heap.inner.complete_collection();
     heap.inner.start_collection(&mut heap.memory, &mut time);
@@ -343,7 +355,7 @@ unsafe fn create_test_heap() -> PartitionedTestHeap {
     println!("    Create test heap...");
     let mut heap = PartitionedTestHeap::new(HEAP_SIZE);
     let heap_base = heap.heap_base();
-    let state = IncrementalGC::initial_gc_state(&mut heap, heap_base);
+    let state = IncrementalGC::<PartitionedTestHeap>::initial_gc_state(heap_base);
     set_incremental_gc_state(Some(state));
     let mut time = BoundedTime::new(0);
     unsafe {
@@ -361,7 +373,7 @@ unsafe fn create_test_heap() -> PartitionedTestHeap {
 fn allocate_objects(heap: &mut PartitionedTestHeap) {
     for index in 0..NUMBER_OF_OBJECTS {
         progress(index + 1, NUMBER_OF_OBJECTS);
-        let value = Value::from_scalar(index as u32);
+        let value = Value::from_scalar(index);
         let array = heap.allocate_array(&[value]);
         unsafe {
             let object = array.get_ptr() as *mut Obj;
@@ -393,9 +405,10 @@ pub struct PartitionedTestHeap {
 
 impl PartitionedTestHeap {
     pub fn new(size: usize) -> PartitionedTestHeap {
-        let mut memory = TestMemory::new(Bytes(size as u32).to_words());
+        let memory = TestMemory::new(Bytes(size).to_words());
         let heap_base = memory.heap_base();
-        let inner = unsafe { PartitionedHeap::new(&mut memory, heap_base) };
+        let inner = PartitionedHeap::new(heap_base);
+        assert_eq!(inner.base_address(), heap_base);
         PartitionedTestHeap { memory, inner }
     }
 
@@ -409,24 +422,24 @@ impl PartitionedTestHeap {
 
     pub fn allocate_array(&mut self, elements: &[Value]) -> Value {
         unsafe {
-            let array = alloc_array(self, TAG_ARRAY_M, elements.len() as u32);
+            let array = alloc_array(self, TAG_ARRAY_M, elements.len());
             for index in 0..elements.len() {
                 let raw_array = array.as_array();
-                raw_array.set(index as u32, elements[index], self);
+                raw_array.set(index, elements[index], self);
             }
             array
         }
     }
 
     pub fn allocate_blob(&mut self, size: usize) -> Value {
-        unsafe { alloc_blob(self, TAG_BLOB_B, Bytes(size as u32)) }
+        unsafe { alloc_blob(self, TAG_BLOB_B, Bytes(size)) }
     }
 }
 
 unsafe fn block_size(block: *const Tag) -> usize {
     match *block {
         TAG_ARRAY_I | TAG_ARRAY_M | TAG_ARRAY_T | TAG_ARRAY_S => {
-            size_of::<Array>() + (block as *const Array).len() as usize * WORD_SIZE as usize
+            size_of::<Array>() + (block as *const Array).len() * WORD_SIZE
         }
         TAG_BLOB_B | TAG_BLOB_T | TAG_BLOB_P | TAG_BLOB_A => {
             size_of::<Blob>() + (block as *const Blob).len().as_usize()
@@ -436,14 +449,14 @@ unsafe fn block_size(block: *const Tag) -> usize {
 }
 
 impl Memory for PartitionedTestHeap {
-    unsafe fn alloc_words(&mut self, size: Words<u32>) -> Value {
+    unsafe fn alloc_words(&mut self, size: Words<usize>) -> Value {
         let result = self.inner.allocate(&mut self.memory, size);
         self.memory
             .set_heap_pointer(result.get_ptr() + size.to_bytes().as_usize());
         result
     }
 
-    unsafe fn grow_memory(&mut self, ptr: u64) {
-        assert!(ptr as usize <= self.memory.heap_end());
+    unsafe fn grow_memory(&mut self, ptr: usize) {
+        assert!(ptr <= self.memory.heap_end());
     }
 }
diff --git a/rts/motoko-rts-tests/src/gc/incremental/roots.rs b/rts/motoko-rts-tests/src/gc/incremental/roots.rs
index 41f6fe195a7..52fe1fa0b24 100644
--- a/rts/motoko-rts-tests/src/gc/incremental/roots.rs
+++ b/rts/motoko-rts-tests/src/gc/incremental/roots.rs
@@ -1,3 +1,7 @@
+use motoko_rts_macros::{
+    classical_persistence, enhanced_orthogonal_persistence, uses_enhanced_orthogonal_persistence,
+};
+
 use std::{array::from_fn, mem::size_of, ptr::null_mut};
 
 use motoko_rts::{
@@ -7,17 +11,23 @@ use motoko_rts::{
 
 use crate::gc::{
     heap::MotokoHeap,
-    utils::{ObjectIdx, WORD_SIZE},
+    utils::{ObjectIdx, GC, WORD_SIZE},
 };
 
 pub unsafe fn test() {
     println!("  Testing roots...");
 
-    let object_map: [(ObjectIdx, Vec<ObjectIdx>); 10] = from_fn(|id| (id as u32, vec![]));
+    let object_map: [(ObjectIdx, Vec<ObjectIdx>); 10] = from_fn(|id| (id, vec![]));
     let root_ids = [2, 4, 6, 8];
     let continuation_ids = [3, 5, 7];
 
-    let heap = MotokoHeap::new(&object_map, &root_ids, &continuation_ids);
+    let heap = MotokoHeap::new(
+        &object_map,
+        &root_ids,
+        &continuation_ids,
+        GC::Incremental,
+        0,
+    );
     check_visit_static_roots(&heap, &root_ids);
     check_visit_continuation_table(&heap, &continuation_ids);
     check_visit_region0(&heap);
@@ -26,57 +36,93 @@ pub unsafe fn test() {
 unsafe fn check_visit_static_roots(heap: &MotokoHeap, root_ids: &[ObjectIdx]) {
     let roots = get_roots(heap);
     let mut visited_static_roots = vec![];
-    visit_roots(roots, &mut visited_static_roots, |context, field| {
-        let object = *field;
-        if object.tag() != TAG_REGION {
-            let array = object.as_array();
-            if array.len() == root_ids.len() as u32 {
-                for index in 0..array.len() {
-                    let mutbox_value = array.get(index);
-                    let mutbox = mutbox_value.as_mutbox();
-                    let root_address = (*mutbox).field.get_ptr();
-                    let root_id = object_id(heap, root_address);
-                    context.push(root_id);
+    visit_roots(
+        roots,
+        heap.heap_base_address(),
+        &mut visited_static_roots,
+        |context, field| {
+            let object = *field;
+            if object.tag() != TAG_REGION {
+                let array = object.as_array();
+                if uses_enhanced_orthogonal_persistence!() {
+                    if array.len() == root_ids.len() {
+                        for index in 0..array.len() {
+                            let mutbox_value = array.get(index);
+                            let mutbox = mutbox_value.as_mutbox();
+                            let root_address = (*mutbox).field.get_ptr();
+                            let root_id = object_id(heap, root_address);
+                            context.push(root_id);
+                        }
+                    }
+                } else {
+                    if array.len() == 1 {
+                        let id = object_id(&heap, array as usize);
+                        context.push(id);
+                    }
                 }
             }
-        }
-    });
+        },
+    );
     assert_eq!(visited_static_roots, root_ids);
 }
 
 unsafe fn check_visit_continuation_table(heap: &MotokoHeap, continuation_ids: &[ObjectIdx]) {
     let roots = get_roots(heap);
     let mut visited_continuations = vec![];
-    visit_roots(roots, &mut visited_continuations, |context, field| {
-        let object = *field;
-        if object.tag() != TAG_REGION {
-            let array = object.as_array();
-            if array.len() == continuation_ids.len() as u32 {
-                assert_eq!(context.len(), 0);
-                for index in 0..array.len() {
-                    let element = array.get(index);
-                    let id = object_id(&heap, element.get_ptr());
-                    context.push(id);
+    visit_roots(
+        roots,
+        heap.heap_base_address(),
+        &mut visited_continuations,
+        |context, field| {
+            let object = *field;
+            if object.tag() != TAG_REGION {
+                let array = object.as_array();
+                if array.len() == continuation_ids.len() {
+                    assert_eq!(context.len(), 0);
+                    for index in 0..array.len() {
+                        let element = array.get(index);
+                        let id = object_id(&heap, element.get_ptr());
+                        context.push(id);
+                    }
                 }
             }
-        }
-    });
+        },
+    );
     assert_eq!(visited_continuations, continuation_ids);
 }
 
 unsafe fn check_visit_region0(heap: &MotokoHeap) {
     let roots = get_roots(heap);
     let mut visited_region0 = false;
-    visit_roots(roots, &mut visited_region0, |visited, field| {
-        let object = *field;
-        if object.tag() == TAG_REGION {
-            assert!(!*visited);
-            *visited = true;
-        }
-    });
+    visit_roots(
+        roots,
+        heap.heap_base_address(),
+        &mut visited_region0,
+        |visited, field| {
+            let object = *field;
+            if object.tag() == TAG_REGION {
+                assert!(!*visited);
+                *visited = true;
+            }
+        },
+    );
     assert!(visited_region0);
 }
 
+#[classical_persistence]
+unsafe fn get_roots(heap: &MotokoHeap) -> Roots {
+    let static_roots = Value::from_ptr(heap.static_root_array_variable_address());
+    let continuation_table_location = heap.continuation_table_variable_address() as *mut Value;
+    let region0_ptr_location = heap.region0_pointer_variable_address() as *mut Value;
+    assert_ne!(continuation_table_location, null_mut());
+    Roots {
+        static_roots,
+        continuation_table_location,
+        region0_ptr_location,
+    }
+}
+
+#[enhanced_orthogonal_persistence]
 unsafe fn get_roots(heap: &MotokoHeap) -> Roots {
     let static_root = heap.static_root_array_variable_address() as *mut Value;
     let continuation_table_location = heap.continuation_table_variable_address() as *mut Value;
@@ -93,10 +139,9 @@ unsafe fn get_roots(heap: &MotokoHeap) -> Roots {
     ]
 }
 
-fn object_id(heap: &MotokoHeap, address: usize) -> u32 {
+fn object_id(heap: &MotokoHeap, address: usize) -> usize {
     let offset = address - heap.heap_base_address();
     const OBJECT_SIZE: usize = size_of::<Array>() + WORD_SIZE;
-    assert_eq!(OBJECT_SIZE, 16);
     assert_eq!(offset % OBJECT_SIZE, 0);
-    (offset / OBJECT_SIZE) as u32
+    offset / OBJECT_SIZE
 }
diff --git a/rts/motoko-rts-tests/src/gc/incremental/sort.rs b/rts/motoko-rts-tests/src/gc/incremental/sort.rs
index 1e6f92dc885..e641753110e 100644
--- a/rts/motoko-rts-tests/src/gc/incremental/sort.rs
+++ b/rts/motoko-rts-tests/src/gc/incremental/sort.rs
@@ -34,7 +34,11 @@ pub fn test() {
 }
 
 fn sort_test(array: &mut [usize]) {
-    sort(array, &|left, right| left.cmp(&right));
+    unsafe {
+        sort(array.as_mut_ptr(), array.len(), &|left, right| {
+            left.cmp(&right)
+        });
+    }
     check_sorted(array);
 }
 
diff --git a/rts/motoko-rts-tests/src/gc/random.rs b/rts/motoko-rts-tests/src/gc/random.rs
index 7be7fc41c4a..9afff801203 100644
--- a/rts/motoko-rts-tests/src/gc/random.rs
+++ b/rts/motoko-rts-tests/src/gc/random.rs
@@ -7,28 +7,28 @@ fn rand_bool(rng: &mut Rand32) -> bool {
     rng.rand_range(0..2) == 1
 }
 
-pub(super) fn generate(seed: u64, max_objects: u32) -> TestHeap {
+pub fn generate(seed: u64, max_objects: usize) -> TestHeap {
     let mut rng = Rand32::new(seed);
 
-    let n_objects = rng.rand_range(0..max_objects + 1);
+    let n_objects = rng.rand_range(0..max_objects as u32 + 1);
 
     let roots: Vec<ObjectIdx> = (0..n_objects)
         .filter_map(|obj_idx| {
             if rand_bool(&mut rng) {
-                Some(obj_idx)
+                Some(obj_idx as usize)
             } else {
                 None
             }
         })
         .collect();
 
-    let heap: Vec<(ObjectIdx, Vec<ObjectIdx>)> = (0..n_objects)
+    let heap: Vec<(ObjectIdx, Vec<ObjectIdx>)> = (0..n_objects as usize)
         .map(|obj_idx| {
-            let n_fields = rng.rand_range(0..n_objects);
+            let n_fields = rng.rand_range(0..n_objects) as usize;
 
             let field_values = (0..n_fields)
                 .filter_map(|_field_idx| {
-                    let field_value = rng.rand_range(0..n_objects);
+                    let field_value = rng.rand_range(0..n_objects) as usize;
                     if field_value == obj_idx {
                         None
                     } else {
@@ -42,7 +42,7 @@ pub(super) fn generate(seed: u64, max_objects: u32) -> TestHeap {
         .collect();
 
     // Same as roots
-    let continuation_table: Vec<ObjectIdx> = (0..n_objects)
+    let continuation_table: Vec<ObjectIdx> = (0..n_objects as usize)
         .filter_map(|obj_idx| {
             if rand_bool(&mut rng) {
                 Some(obj_idx)
diff --git a/rts/motoko-rts-tests/src/gc/utils.rs b/rts/motoko-rts-tests/src/gc/utils.rs
index 48d3e6e9063..5e3d84523a9 100644
--- a/rts/motoko-rts-tests/src/gc/utils.rs
+++ b/rts/motoko-rts-tests/src/gc/utils.rs
@@ -1,43 +1,92 @@
+use std::mem::size_of;
+
 use byteorder::{ReadBytesExt, WriteBytesExt, LE};
+use motoko_rts_macros::{
+    classical_persistence, enhanced_orthogonal_persistence, incremental_gc, non_incremental_gc,
+};
 
 /// A unique object index, used in heap descriptions.
 ///
-/// These are written as scalar values in object payloads, so they can be at most 31 bits. Larger
-/// values will cause test failure in `make_scalar` below.
-pub type ObjectIdx = u32;
+/// These are written as scalar values in object payloads, so they can be at most `usize::BITS - 1` bits.
+/// Larger values will cause test failure in `make_scalar` below.
+pub type ObjectIdx = usize;
 
 /// Same as RTS `WORD_SIZE`, but `usize`
 pub const WORD_SIZE: usize = motoko_rts::constants::WORD_SIZE as usize;
 
+// Max allowed size for the mark stack in mark-compact GC tests
+#[non_incremental_gc]
+pub const MAX_MARK_STACK_SIZE: usize = 100;
+
+/// Enum for the GC implementations. GC functions are generic so we can't put them into arrays or
+/// other data types, we use this type instead.
+#[non_incremental_gc]
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum GC {
+    Copying,
+    MarkCompact,
+    Generational,
+}
+
+#[incremental_gc]
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum GC {
+    Incremental,
+}
+
+#[non_incremental_gc]
+pub static GC_IMPLS: [GC; 3] = [GC::Copying, GC::MarkCompact, GC::Generational];
+
+#[incremental_gc]
+pub static GC_IMPLS: [GC; 1] = [GC::Incremental];
+
+/// Read a little-endian (Wasm) word from given offset
+#[classical_persistence]
+pub fn read_word(heap: &[u8], offset: usize) -> usize {
+    assert_eq!(size_of::<usize>(), size_of::<u32>());
+    (&heap[offset..]).read_u32::<LE>().unwrap() as usize
+}
+
+/// Write a little-endian (Wasm) word to given offset
+#[classical_persistence]
+pub fn write_word(heap: &mut [u8], offset: usize, word: usize) {
+    assert_eq!(size_of::<usize>(), size_of::<u32>());
+    (&mut heap[offset..]).write_u32::<LE>(word as u32).unwrap()
+}
+
 /// Read a little-endian (Wasm) word from given offset
-pub fn read_word(heap: &[u8], offset: usize) -> u32 {
-    (&heap[offset..]).read_u32::<LE>().unwrap()
+#[enhanced_orthogonal_persistence]
+pub fn read_word(heap: &[u8], offset: usize) -> usize {
+    assert_eq!(size_of::<usize>(), size_of::<u64>());
+    (&heap[offset..]).read_u64::<LE>().unwrap() as usize
 }
 
 /// Write a little-endian (Wasm) word to given offset
-pub fn write_word(heap: &mut [u8], offset: usize, word: u32) {
-    (&mut heap[offset..]).write_u32::<LE>(word).unwrap()
+#[enhanced_orthogonal_persistence]
+pub fn write_word(heap: &mut [u8], offset: usize, word: usize) {
+    assert_eq!(size_of::<usize>(), size_of::<u64>());
+    (&mut heap[offset..]).write_u64::<LE>(word as u64).unwrap()
 }
 
 /// Make a scalar value to be used in heap object payload
-pub fn make_scalar(value: u32) -> u32 {
+pub fn make_scalar(value: usize) -> usize {
     // Scalar values can be at most 31 bits
     assert_eq!(value >> 31, 0);
     value << 1
 }
 
 /// Inverse of `make_scalar`
-pub fn get_scalar_value(scalar: u32) -> u32 {
+pub fn get_scalar_value(scalar: usize) -> usize {
     assert_eq!(scalar & 0b1, 0);
     scalar >> 1
 }
 
 /// Make a pointer value to be used in heap object payload
-pub fn make_pointer(addr: u32) -> u32 {
+pub fn make_pointer(addr: usize) -> usize {
     addr.wrapping_sub(1)
 }
 
 /// Inverse of `make_pointer`
-pub fn unskew_pointer(skewed_ptr: u32) -> u32 {
+pub fn unskew_pointer(skewed_ptr: usize) -> usize {
     skewed_ptr.wrapping_add(1)
 }
diff --git a/rts/motoko-rts-tests/src/leb128.rs b/rts/motoko-rts-tests/src/leb128.rs
index 8dcd53c4fe9..bac32c89d46 100644
--- a/rts/motoko-rts-tests/src/leb128.rs
+++ b/rts/motoko-rts-tests/src/leb128.rs
@@ -3,6 +3,7 @@ use motoko_rts::leb128::{
     leb128_decode_checked, leb128_encode, sleb128_decode_checked, sleb128_encode,
 };
 
+use motoko_rts_macros::{classical_persistence, enhanced_orthogonal_persistence};
 use proptest::test_runner::{Config, TestCaseError, TestCaseResult, TestRunner};
 
 pub unsafe fn test() {
@@ -17,23 +18,27 @@ pub unsafe fn test() {
     roundtrip_signed(1).unwrap();
     roundtrip_signed(0).unwrap();
     roundtrip_signed(-1).unwrap();
-    roundtrip_signed(i32::MIN).unwrap(); // -2147483648
-    roundtrip_signed(i32::MAX).unwrap(); // 2147483647
+    roundtrip_signed(isize::MIN).unwrap();
+    roundtrip_signed(isize::MAX).unwrap();
 
     proptest_runner
-        .run(&proptest::num::i32::ANY, roundtrip_signed)
+        .run(&proptest::num::isize::ANY, roundtrip_signed)
         .unwrap();
 
     roundtrip_unsigned(1).unwrap();
     roundtrip_unsigned(0).unwrap();
-    roundtrip_unsigned(u32::MIN).unwrap();
-    roundtrip_unsigned(u32::MAX).unwrap();
+    roundtrip_unsigned(usize::MIN).unwrap();
+    roundtrip_unsigned(usize::MAX).unwrap();
 
     proptest_runner
-        .run(&proptest::num::u32::ANY, roundtrip_unsigned)
+        .run(&proptest::num::usize::ANY, roundtrip_unsigned)
         .unwrap();
 
-    // Check overflows
+    check_overflows();
+}
+
+#[classical_persistence]
+unsafe fn check_overflows() {
     check_signed_decode_overflow(&[
         0b1111_1111,
         0b1111_1111,
@@ -59,7 +64,49 @@ pub unsafe fn test() {
     ]); // u32::MAX + 1
 }
 
-fn roundtrip_signed(val: i32) -> TestCaseResult {
+#[enhanced_orthogonal_persistence]
+unsafe fn check_overflows() {
+    check_signed_decode_overflow(&[
+        0b1111_1111,
+        0b1111_1111,
+        0b1111_1111,
+        0b1111_1111,
+        0b1111_1111,
+        0b1111_1111,
+        0b1111_1111,
+        0b1111_1111,
+        0b1111_1111,
+        0b0001_0001,
+    ]); // isize::MIN - 1
+
+    check_signed_decode_overflow(&[
+        0b1000_0000,
+        0b1000_0000,
+        0b1000_0000,
+        0b1000_0000,
+        0b1000_0000,
+        0b1000_0000,
+        0b1000_0000,
+        0b1000_0000,
+        0b1000_0000,
+        0b0000_0001,
+    ]); // isize::MAX + 1
+
+    check_unsigned_decode_overflow(&[
+        0b1000_0000,
+        0b1000_0000,
+        0b1000_0000,
+        0b1000_0000,
+        0b1000_0000,
+        0b1000_0000,
+        0b1000_0000,
+        0b1000_0000,
+        0b1000_0000,
+        0b0000_0010,
+    ]); // usize::MAX + 1
+}
+
+fn roundtrip_signed(val: isize) -> TestCaseResult {
     unsafe {
         let mut buf = [0u8; 100];
         sleb128_encode(val, buf.as_mut_ptr());
@@ -86,7 +133,7 @@ fn roundtrip_signed(val: i32) -> TestCaseResult {
     }
 }
 
-fn roundtrip_unsigned(val: u32) -> TestCaseResult {
+fn roundtrip_unsigned(val: usize) -> TestCaseResult {
     unsafe {
         let mut buf = [0u8; 100];
         leb128_encode(val, buf.as_mut_ptr());
diff --git a/rts/motoko-rts-tests/src/main.rs b/rts/motoko-rts-tests/src/main.rs
index 7e0b3e1dcfb..2a88243b4e1 100644
--- a/rts/motoko-rts-tests/src/main.rs
+++ b/rts/motoko-rts-tests/src/main.rs
@@ -1,5 +1,10 @@
 #![feature(proc_macro_hygiene)]
 
+use motoko_rts_macros::{classical_persistence, enhanced_orthogonal_persistence};
+
+#[macro_use]
+mod print;
+
 mod bigint;
 mod bitrel;
 mod continuation_table;
@@ -8,20 +13,17 @@ mod gc;
 mod leb128;
 mod memory;
 mod principal_id;
+
+#[enhanced_orthogonal_persistence]
+mod stabilization;
 mod stable_option;
 mod text;
 mod utf8;
 
-use motoko_rts::types::{read64, write64, Bytes};
-
 fn main() {
-    if std::mem::size_of::<usize>() != 4 {
-        println!("Motoko RTS only works on 32-bit architectures");
-        std::process::exit(1);
-    }
+    check_architecture();
 
     unsafe {
-        test_read_write_64_bit();
         bigint::test();
         bitrel::test();
         continuation_table::test();
@@ -29,13 +31,46 @@ fn main() {
         gc::test();
         leb128::test();
         principal_id::test();
+        persistence_test();
         stable_option::test();
         text::test();
         utf8::test();
     }
 }
 
+#[classical_persistence]
+fn check_architecture() {
+    if std::mem::size_of::<usize>() != 4 {
+        println!("Motoko RTS for classical persistence only works on 32-bit architectures");
+        std::process::exit(1);
+    }
+}
+
+#[enhanced_orthogonal_persistence]
+fn check_architecture() {
+    if std::mem::size_of::<usize>() != 8 {
+        println!(
+            "Motoko RTS for enhanced orthogonal persistence only works on 64-bit architectures"
+        );
+        std::process::exit(1);
+    }
+}
+
+#[enhanced_orthogonal_persistence]
+fn persistence_test() {
+    unsafe {
+        stabilization::test();
+    }
+}
+
+#[classical_persistence]
+fn persistence_test() {
+    test_read_write_64_bit();
+}
+
+#[classical_persistence]
 fn test_read_write_64_bit() {
+    use motoko_rts::types::{read64, write64};
     println!("Testing 64-bit read-write");
     const TEST_VALUE: u64 = 0x1234_5678_9abc_def0;
     let mut lower = 0u32;
@@ -48,8 +83,8 @@ fn test_read_write_64_bit() {
 
 // Called by the RTS to panic
 #[no_mangle]
-extern "C" fn rts_trap(ptr: *const u8, len: Bytes<u32>) -> ! {
-    let msg = unsafe { std::slice::from_raw_parts(ptr, len.as_usize()) };
+extern "C" fn rts_trap(ptr: *const u8, len: u32) -> ! {
+    let msg = unsafe { std::slice::from_raw_parts(ptr, len as usize) };
     match core::str::from_utf8(msg) {
         Err(err) => panic!(
             "rts_trap_with called with non-UTF8 string (error={:?}, string={:?})",
@@ -67,7 +102,14 @@ extern "C" fn bigint_trap() -> ! {
 
 // Called by the RTS for debug prints
 #[no_mangle]
-unsafe extern "C" fn print_ptr(ptr: usize, len: u32) {
-    let str: &[u8] = core::slice::from_raw_parts(ptr as *const u8, len as usize);
-    println!("[RTS] {}", String::from_utf8_lossy(str));
+unsafe extern "C" fn print_ptr(ptr: usize, len: usize) {
+    let str: &[u8] = core::slice::from_raw_parts(ptr as *const u8, len);
+    println!("[RTS] {}", &String::from_utf8_lossy(str));
+}
+
+// Program entry point by wasmtime
+#[enhanced_orthogonal_persistence]
+#[no_mangle]
+pub fn _start() {
+    main();
 }
diff --git a/rts/motoko-rts-tests/src/memory.rs b/rts/motoko-rts-tests/src/memory.rs
index 7e1280a9ae0..73211c52e45 100644
--- a/rts/motoko-rts-tests/src/memory.rs
+++ b/rts/motoko-rts-tests/src/memory.rs
@@ -1,7 +1,6 @@
-use motoko_rts::gc::incremental::partitioned_heap::PARTITION_SIZE;
-use motoko_rts::gc::incremental::{set_incremental_gc_state, IncrementalGC};
 use motoko_rts::memory::Memory;
 use motoko_rts::types::{Bytes, Value, Words};
+use motoko_rts_macros::{incremental_gc, non_incremental_gc};
 
 pub struct TestMemory {
     heap: Box<[u8]>,
@@ -9,25 +8,29 @@ pub struct TestMemory {
 }
 
 impl TestMemory {
-    pub fn new(size: Words<u32>) -> TestMemory {
+    pub fn new(size: Words<usize>) -> TestMemory {
         let bytes = size.to_bytes().as_usize();
         let heap = vec![0u8; bytes].into_boxed_slice();
         let hp = heap.as_ptr() as usize;
         TestMemory { heap, hp }
     }
 
+    #[incremental_gc]
     pub fn heap_base(&self) -> usize {
         self.heap.as_ptr() as usize
     }
 
+    #[incremental_gc]
     pub fn heap_end(&self) -> usize {
         self.heap_base() + self.heap.len()
     }
 
+    #[incremental_gc]
     pub fn heap_pointer(&self) -> usize {
         self.hp
     }
 
+    #[incremental_gc]
     pub fn set_heap_pointer(&mut self, heap_pointer: usize) {
         assert!(heap_pointer >= self.heap_base());
         assert!(heap_pointer <= self.heap_end());
@@ -36,7 +39,7 @@ impl TestMemory {
 }
 
 impl Memory for TestMemory {
-    unsafe fn alloc_words(&mut self, n: Words<u32>) -> Value {
+    unsafe fn alloc_words(&mut self, n: Words<usize>) -> Value {
         let bytes = n.to_bytes();
 
         // Update heap pointer
@@ -45,12 +48,12 @@ impl Memory for TestMemory {
         self.hp = new_hp;
 
         // Grow memory if needed
-        self.grow_memory(new_hp as u64);
+        self.grow_memory(new_hp);
 
         Value::from_ptr(old_hp)
     }
 
-    unsafe fn grow_memory(&mut self, ptr: u64) {
+    unsafe fn grow_memory(&mut self, ptr: usize) {
         let heap_end = self.heap.as_ptr() as usize + self.heap.len();
         if ptr as usize > heap_end {
             // We don't allow growing memory in tests, allocate large enough for the test
@@ -62,13 +65,29 @@ impl Memory for TestMemory {
     }
 }
 
+#[incremental_gc]
 pub unsafe fn initialize_test_memory() -> TestMemory {
-    let mut memory = TestMemory::new(Bytes(PARTITION_SIZE as u32).to_words());
-    let state = IncrementalGC::initial_gc_state(&mut memory, 0);
+    use motoko_rts::gc::incremental::partitioned_heap::PARTITION_SIZE;
+    use motoko_rts::gc::incremental::{set_incremental_gc_state, IncrementalGC};
+
+    let memory = TestMemory::new(Bytes(PARTITION_SIZE).to_words());
+    let state = IncrementalGC::<TestMemory>::initial_gc_state(0);
     set_incremental_gc_state(Some(state));
     memory
 }
 
+#[non_incremental_gc]
+pub unsafe fn initialize_test_memory() -> TestMemory {
+    const TEST_MEMORY_SIZE: usize = 32 * 1024 * 1024;
+    TestMemory::new(Bytes(TEST_MEMORY_SIZE).to_words())
+}
+
+#[incremental_gc]
 pub unsafe fn reset_test_memory() {
+    use motoko_rts::gc::incremental::set_incremental_gc_state;
+
     set_incremental_gc_state(None);
 }
+
+#[non_incremental_gc]
+pub unsafe fn reset_test_memory() {}
diff --git a/rts/motoko-rts-tests/src/print.rs b/rts/motoko-rts-tests/src/print.rs
new file mode 100644
index 00000000000..05464001911
--- /dev/null
+++ b/rts/motoko-rts-tests/src/print.rs
@@ -0,0 +1,79 @@
+//! Support for standard output in wasmtime.
+
+#[link(wasm_import_module = "wasi_snapshot_preview1")]
+extern "C" {
+    fn fd_write(fd: i32, iovs: i32, iovs_len: i32, nwritten: i32) -> i32;
+}
+
+#[repr(C)]
+struct iov {
+    base: i32,
+    length: i32,
+}
+
+const BUFFER_LENGTH: usize = 1024;
+
+static mut WRITTEN: i32 = 0;
+static mut TEXT_BUFFER: [u8; BUFFER_LENGTH] = [0; BUFFER_LENGTH];
+static mut IO_VECTOR: iov = iov { base: 0, length: 0 };
+
+/// Truncates the text if it is longer than `BUFFER_LENGTH`.
+pub(crate) fn wasmtime_println(text: &str) {
+    unsafe {
+        let mut length = 0;
+        for byte in text.as_bytes() {
+            TEXT_BUFFER[length] = *byte;
+            length += 1;
+            if length + 1 >= TEXT_BUFFER.len() {
+                break;
+            }
+        }
+        TEXT_BUFFER[length] = '\n' as u8; // new-line is required for a working output
+        length += 1;
+
+        IO_VECTOR.base = &mut TEXT_BUFFER[0] as *mut u8 as i32;
+        IO_VECTOR.length = length as i32;
+
+        let io_vector_array = &mut IO_VECTOR as *mut iov;
+        const STANDARDD_OUTPUT: i32 = 1;
+        const IO_VECTOR_ARRAY_LENGTH: i32 = 1;
+        let written_pointer = (&mut WRITTEN) as *mut i32;
+
+        fd_write(
+            STANDARDD_OUTPUT,
+            io_vector_array as i32,
+            IO_VECTOR_ARRAY_LENGTH,
+            written_pointer as i32,
+        );
+    }
+}
+
+#[macro_export]
+macro_rules! println {
+    ($($arg:tt)*) => ({
+        {
+            use core::fmt::Write;
+            let mut output = String::new();
+            write!(&mut output, $($arg)*).unwrap();
+            crate::print::wasmtime_println(&output);
+        }
+    })
+}
+
+#[macro_export]
+macro_rules! print {
+    ($($arg:tt)*) => ({
+        println!($($arg)*);
+    })
+}
+
+#[macro_export]
+macro_rules! panic {
+    ($($arg:tt)*) => ({
+        use core::fmt::Write;
+        let mut output = String::from("[PANIC] ");
+        write!(&mut output, $($arg)*).unwrap();
+        crate::print::wasmtime_println(&output);
+        std::process::exit(1);
+    })
+}
diff --git a/rts/motoko-rts-tests/src/stabilization.rs b/rts/motoko-rts-tests/src/stabilization.rs
new file mode 100644
index 00000000000..d50d7bde35e
--- /dev/null
+++ b/rts/motoko-rts-tests/src/stabilization.rs
@@ -0,0 +1,182 @@
+mod layout;
+mod reader_writer;
+mod stable_bigints;
+mod stable_memory;
+
+use crate::{
+    gc::{
+        check_dynamic_heap, heap::MotokoHeap, random::generate, utils::GC, utils::WORD_SIZE,
+        CheckMode, TestHeap,
+    },
+    memory::TestMemory,
+    stabilization::stable_memory::clear_stable_memory,
+};
+use motoko_rts::{
+    memory::{alloc_array, Memory},
+    stabilization::{
+        deserialization::Deserialization, graph_copy::GraphCopy, serialization::Serialization,
+    },
+    types::{Value, Words, TAG_ARRAY_M},
+};
+use oorandom::Rand32;
+
+pub unsafe fn test() {
+    println!("Testing stabilization ...");
+    layout::test();
+    stable_bigints::test();
+    reader_writer::test();
+    test_stabilization();
+    reset_memory();
+}
+
+#[no_mangle]
+pub fn moc_stabilization_instruction_limit() -> u64 {
+    u64::MAX
+}
+
+#[no_mangle]
+pub fn moc_stable_memory_access_limit() -> u64 {
+    u64::MAX
+}
+
+#[no_mangle]
+pub fn ic0_performance_counter(_counter: u32) -> u64 {
+    0
+}
+
+// This is only called for graph copy increment limit testing.
+// Not used during RTS testing.
+#[no_mangle]
+pub fn deserialized_size() -> usize {
+    0
+}
+
+fn reset_gc(heap_base_address: usize) {
+    use motoko_rts::gc::incremental::{set_incremental_gc_state, IncrementalGC};
+
+    unsafe {
+        let state = IncrementalGC::<MotokoHeap>::initial_gc_state(heap_base_address);
+        set_incremental_gc_state(Some(state));
+    }
+}
+
+fn clear_heap(heap: &mut MotokoHeap) {
+    reset_gc(heap.heap_base_address());
+}
+
+fn reset_memory() {
+    clear_stable_memory();
+    reset_main_memory();
+}
+
+fn reset_main_memory() {
+    reset_gc(0);
+}
+
+struct RandomHeap {
+    descriptor: TestHeap,
+    memory: MotokoHeap,
+}
+
+impl RandomHeap {
+    fn clear(&mut self) {
+        clear_heap(&mut self.memory);
+    }
+
+    fn set_new_root(&mut self, stable_root: Value) {
+        self.clear_continuation_table();
+        self.reset_root_array(stable_root);
+        // Set the stable root as sole static root pointer.
+        self.reset_descriptor();
+    }
+
+    fn clear_continuation_table(&mut self) {
+        let table_pointer = self.memory.continuation_table_variable_address() as *mut Value;
+        unsafe {
+            *table_pointer = alloc_array(&mut self.memory, TAG_ARRAY_M, 0);
+        }
+    }
+
+    fn reset_root_array(&mut self, stable_root: Value) {
+        let root_array_pointer = self.memory.static_root_array_variable_address() as *mut Value;
+        unsafe {
+            *root_array_pointer = stable_root;
+        }
+    }
+
+    fn reset_descriptor(&mut self) {
+        self.descriptor.continuation_table.clear();
+    }
+
+    fn old_stable_root(&self) -> Value {
+        let root_array_pointer = self.memory.static_root_array_variable_address() as *mut Value;
+        unsafe { *root_array_pointer }
+    }
+
+    fn check_heap(&self) {
+        check_dynamic_heap(
+            CheckMode::Stabilzation,
+            &self.descriptor.heap,
+            &self.descriptor.roots,
+            &self.descriptor.continuation_table,
+            &self.memory.heap().as_ref(),
+            self.memory.heap_base_offset(),
+            self.memory.heap_ptr_offset(),
+            self.memory.static_root_array_variable_offset(),
+            self.memory.continuation_table_variable_offset(),
+            self.memory.region0_pointer_variable_offset(),
+        )
+    }
+}
+
+fn random_heap(random: &mut Rand32, max_objects: usize) -> RandomHeap {
+    let descriptor = generate(random.rand_u32() as u64, max_objects);
+    let pointers: usize = descriptor
+        .heap
+        .iter()
+        .map(|(_, references)| references.len() + 1)
+        .sum();
+    let memory = descriptor.build(GC::Incremental, pointers * WORD_SIZE as usize);
+    RandomHeap { descriptor, memory }
+}
+
+fn test_stabilization() {
+    println!("  Testing serialization and deserialization ...");
+    const RANDOM_SEED: u64 = 4711;
+    let mut random = Rand32::new(RANDOM_SEED);
+    test_serialization_deserialization(&mut random, 100, 0);
+    test_serialization_deserialization(&mut random, 1000, 200);
+    test_serialization_deserialization(&mut random, 10_000, 5_000);
+    test_serialization_deserialization(&mut random, 20_000, 7_000);
+}
+
+fn test_serialization_deserialization(random: &mut Rand32, max_objects: usize, stable_start: u64) {
+    println!("    Testing with {max_objects} objects");
+    clear_stable_memory();
+    let mut heap = random_heap(random, max_objects);
+    let old_stable_root = heap.old_stable_root();
+
+    let stable_size = serialize(old_stable_root, stable_start);
+
+    heap.clear();
+
+    let stable_root = deserialize(&mut heap.memory, stable_start, stable_size);
+
+    heap.set_new_root(stable_root);
+    heap.check_heap();
+}
+
+fn serialize(old_stable_root: Value, stable_start: u64) -> u64 {
+    let mut memory = TestMemory::new(Words(0));
+    let mut serialization = Serialization::start(&mut memory, old_stable_root, stable_start);
+    serialization.copy_increment(&mut memory);
+    assert!(serialization.is_completed());
+    serialization.serialized_data_length()
+}
+
+fn deserialize<M: Memory>(mem: &mut M, stable_start: u64, stable_size: u64) -> Value {
+    let mut deserialization = Deserialization::start(mem, stable_start, stable_size);
+    deserialization.copy_increment(mem);
+    assert!(deserialization.is_completed());
+    deserialization.get_stable_root()
+}
diff --git a/rts/motoko-rts-tests/src/stabilization/layout.rs b/rts/motoko-rts-tests/src/stabilization/layout.rs
new file mode 100644
index 00000000000..ccfd59cdbfd
--- /dev/null
+++ b/rts/motoko-rts-tests/src/stabilization/layout.rs
@@ -0,0 +1,32 @@
+use motoko_rts::stabilization::layout::StableObjectKind;
+
+pub unsafe fn test() {
+    println!("  Testing layout ...");
+
+    test_stable_tags();
+}
+
+fn test_stable_tags() {
+    for object_kind in [
+        StableObjectKind::ArrayImmutable,
+        StableObjectKind::ArrayMutable,
+        StableObjectKind::ArrayTuple,
+        StableObjectKind::ArraySharedFunction,
+        StableObjectKind::MutBox,
+        StableObjectKind::Object,
+        StableObjectKind::BlobBytes,
+        StableObjectKind::BlobText,
+        StableObjectKind::BlobPrincipal,
+        StableObjectKind::BlobActor,
+        StableObjectKind::Bits64Unsigned,
+        StableObjectKind::Bits64Signed,
+        StableObjectKind::Bits64Float,
+        StableObjectKind::Region,
+        StableObjectKind::Variant,
+        StableObjectKind::Concat,
+        StableObjectKind::BigInt,
+        StableObjectKind::Some,
+    ] {
+        assert!(object_kind.encode().decode() == object_kind);
+    }
+}
diff --git a/rts/motoko-rts-tests/src/stabilization/reader_writer.rs b/rts/motoko-rts-tests/src/stabilization/reader_writer.rs
new file mode 100644
index 00000000000..88de656f316
--- /dev/null
+++ b/rts/motoko-rts-tests/src/stabilization/reader_writer.rs
@@ -0,0 +1,378 @@
+use std::{array::from_fn, mem::size_of};
+
+use motoko_rts::stabilization::serialization::stable_memory_stream::{
+    ScanStream, StableMemoryStream, WriteStream,
+};
+use oorandom::Rand32;
+
+use crate::stabilization::stable_memory::ic0_stable64_read;
+
+pub unsafe fn test() {
+    println!("  Testing stable memory stream ...");
+    test_empy_reader_writer();
+    test_single_read_write();
+    test_single_update();
+    test_multiple_read_write();
+    test_multiple_updates();
+    test_skip_all();
+    test_interleaved_read_write();
+    test_interleaved_skip();
+    test_bulk_read_write();
+    test_raw_read_write();
+    test_randomized_read_write();
+}
+
+fn test_empy_reader_writer() {
+    println!("    Testing empty stream ...");
+    let mut reader_writer = StableMemoryStream::open(0);
+    assert!(reader_writer.scan_completed());
+    reader_writer.close();
+    assert_eq!(reader_writer.written_length(), 0);
+}
+
+fn test_single_read_write() {
+    println!("    Testing single read write ...");
+    let mut reader_writer = StableMemoryStream::open(0);
+    const NUMBER: u64 = 1234567890;
+    reader_writer.write(&NUMBER);
+    let result = reader_writer.read::<u64>();
+    assert_eq!(result, NUMBER);
+    assert!(reader_writer.scan_completed());
+    reader_writer.close();
+    assert_eq!(reader_writer.written_length(), size_of::<u64>() as u64);
+}
+
+fn test_single_update() {
+    println!("    Testing single update ...");
+    let mut reader_writer = StableMemoryStream::open(0);
+    const NUMBER: u64 = 1234567890;
+    reader_writer.write(&NUMBER);
+    let result = reader_writer.read::<u64>();
+    assert_eq!(result, NUMBER);
+    assert!(reader_writer.scan_completed());
+    const NEW_NUMBER: u64 = 321321321;
+    reader_writer.update(&NEW_NUMBER);
+    assert!(reader_writer.scan_completed());
+    let mut test_value = 0u64;
+    reader_writer.close();
+    assert_eq!(reader_writer.written_length(), size_of::<u64>() as u64);
+    ic0_stable64_read(
+        &mut test_value as *mut u64 as u64,
+        0,
+        size_of::<u64>() as u64,
+    );
+    assert_eq!(test_value, NEW_NUMBER);
+}
+
+fn test_multiple_read_write() {
+    println!("    Testing multiple read write ...");
+    let mut reader_writer = StableMemoryStream::open(0);
+    const AMOUNT: usize = 100_000;
+    for number in 0..AMOUNT {
+        reader_writer.write(&number);
+    }
+    for number in 0..AMOUNT {
+        assert!(!reader_writer.scan_completed());
+        let output = reader_writer.read::<usize>();
+        assert_eq!(output, number);
+    }
+    assert!(reader_writer.scan_completed());
+    reader_writer.close();
+    assert_eq!(
+        reader_writer.written_length(),
+        (AMOUNT * size_of::<usize>()) as u64
+    );
+}
+
+fn test_multiple_updates() {
+    println!("    Testing multiple read write ...");
+    let mut reader_writer = StableMemoryStream::open(0);
+    const AMOUNT: usize = 100_000;
+    const TOTAL_LENGTH: u64 = (AMOUNT * size_of::<usize>()) as u64;
+    for number in 0..AMOUNT {
+        reader_writer.write(&number);
+    }
+    for number in 0..AMOUNT {
+        assert!(!reader_writer.scan_completed());
+        let output = reader_writer.read::<usize>();
+        assert_eq!(output, number);
+        reader_writer.update(&(number * 2));
+    }
+    assert!(reader_writer.scan_completed());
+    reader_writer.close();
+    assert_eq!(reader_writer.written_length(), TOTAL_LENGTH);
+    let mut test_data = [0usize; AMOUNT];
+    ic0_stable64_read(&mut test_data[0] as *mut usize as u64, 0, TOTAL_LENGTH);
+    for index in 0..AMOUNT {
+        assert_eq!(test_data[index], index * 2)
+    }
+}
+
+fn test_skip_all() {
+    println!("    Testing skip all ...");
+    let mut reader_writer = StableMemoryStream::open(0);
+    const AMOUNT: usize = 100_000;
+    let total_size = AMOUNT * size_of::<usize>();
+    for number in 0..AMOUNT {
+        reader_writer.write(&number);
+    }
+    assert!(!reader_writer.scan_completed());
+    reader_writer.skip(total_size);
+    assert!(reader_writer.scan_completed());
+    reader_writer.close();
+    assert_eq!(reader_writer.written_length(), total_size as u64);
+}
+
+fn test_interleaved_read_write() {
+    println!("    Testing interleaved read write ...");
+    let mut reader_writer = StableMemoryStream::open(0);
+    const AMOUNT: usize = 100_000;
+    for counter in 0..AMOUNT {
+        let input = (counter, counter * 2, counter * 3);
+        reader_writer.write(&input);
+        assert!(!reader_writer.scan_completed());
+        let output = reader_writer.read::<(usize, usize, usize)>();
+        assert_eq!(output, input);
+        assert!(reader_writer.scan_completed());
+    }
+    reader_writer.close();
+    assert_eq!(
+        reader_writer.written_length(),
+        (AMOUNT * size_of::<(usize, usize, usize)>()) as u64
+    );
+}
+
+fn test_interleaved_skip() {
+    println!("    Testing interleaved read skip ...");
+    let mut reader_writer = StableMemoryStream::open(0);
+    let value_size = size_of::<(usize, usize, usize)>();
+    const AMOUNT: usize = 100_000;
+    for counter in 0..AMOUNT {
+        reader_writer.write(&(counter, counter * 2, counter * 3));
+        assert!(!reader_writer.scan_completed());
+    }
+    for counter in 0..AMOUNT {
+        if counter % 2 == 0 {
+            reader_writer.skip(value_size)
+        } else {
+            let output = reader_writer.read::<(usize, usize, usize)>();
+            assert_eq!(output, (counter, counter * 2, counter * 3));
+        }
+    }
+    reader_writer.close();
+    assert_eq!(reader_writer.written_length(), (AMOUNT * value_size) as u64);
+}
+
+fn test_bulk_read_write() {
+    println!("    Testing bulk read write ...");
+    const LENGTH: usize = 99_999;
+    let input: [u8; LENGTH] = from_fn(|index| index as u8);
+    let mut reader_writer = StableMemoryStream::open(0);
+    reader_writer.write(&input);
+    assert!(!reader_writer.scan_completed());
+    let mut output = [0u8; LENGTH];
+    reader_writer.raw_read(&mut output as *mut u8 as usize, LENGTH);
+    assert_eq!(input, output);
+    assert!(reader_writer.scan_completed());
+    reader_writer.close();
+    assert_eq!(reader_writer.written_length(), LENGTH as u64);
+}
+
+fn test_raw_read_write() {
+    println!("    Testing raw read write ...");
+    const LENGTH: usize = 99;
+    let mut reader_writer = StableMemoryStream::open(0);
+    const AMOUNT: usize = 100;
+    for counter in 0..AMOUNT {
+        let input: [u8; LENGTH] = from_fn(|index| (counter + index) as u8);
+        reader_writer.raw_write(&input[0] as *const u8 as usize, LENGTH);
+        assert!(!reader_writer.scan_completed());
+    }
+    for counter in 0..AMOUNT {
+        let mut output = [0u8; LENGTH];
+        reader_writer.raw_read(&mut output[0] as *mut u8 as usize, LENGTH);
+        assert_eq!(from_fn(|index| (counter + index) as u8), output);
+    }
+    assert!(reader_writer.scan_completed());
+    reader_writer.close();
+    assert_eq!(reader_writer.written_length(), (AMOUNT * LENGTH) as u64);
+}
+
+#[repr(C)]
+#[derive(Debug, PartialEq, Default)]
+struct RandomRecord {
+    field_0: i8,
+    padding_0: i8,
+    field_1: i16,
+    field_2: i32,
+    field_4: i64,
+    field_5: i128,
+    field_6: f64,
+    padding_6: i64,
+}
+
+type RandomTuple = (f64, i64);
+type RandomArray = [i64; 100];
+type RandomBulkData = [u8; 10_000];
+
+#[derive(Debug, PartialEq)]
+enum RandomValue {
+    SingleByte(u8),
+    SimpleNumber(usize),
+    LargeNumber(u128),
+    TupleValue(RandomTuple),
+    RecordValue(RandomRecord),
+    ArrayValue(RandomArray),
+    BulkValue(RandomBulkData),
+}
+
+impl RandomValue {
+    fn generate(random: &mut Rand32) -> RandomValue {
+        match random.rand_u32() % 7 {
+            0 => RandomValue::SingleByte(random.rand_u32() as u8),
+            1 => RandomValue::SimpleNumber(random.rand_u32() as usize),
+            2 => RandomValue::LargeNumber(
+                random.rand_u32() as u128
+                    * random.rand_u32() as u128
+                    * random.rand_u32() as u128
+                    * random.rand_u32() as u128,
+            ),
+            3 => RandomValue::TupleValue((
+                random.rand_float() as f64,
+                random.rand_i32() as i64 * random.rand_i32() as i64,
+            )),
+            4 => RandomValue::RecordValue(RandomRecord {
+                field_0: random.rand_i32() as i8,
+                padding_0: 0,
+                field_1: random.rand_i32() as i16,
+                field_2: random.rand_i32(),
+                field_4: random.rand_i32() as i64,
+                field_5: random.rand_i32() as i128,
+                field_6: random.rand_float() as f64,
+                padding_6: 0,
+            }),
+            5 => RandomValue::ArrayValue(from_fn(|_| random.rand_i32() as i64)),
+            6 => RandomValue::BulkValue(from_fn(|_| random.rand_u32() as u8)),
+            _ => unreachable!(),
+        }
+    }
+
+    fn size(&self) -> usize {
+        match self {
+            RandomValue::SingleByte(_) => size_of::<u8>(),
+            RandomValue::SimpleNumber(_) => size_of::<usize>(),
+            RandomValue::LargeNumber(_) => size_of::<u128>(),
+            RandomValue::TupleValue(_) => size_of::<RandomTuple>(),
+            RandomValue::RecordValue(_) => size_of::<RandomRecord>(),
+            RandomValue::ArrayValue(_) => size_of::<RandomArray>(),
+            RandomValue::BulkValue(_) => size_of::<RandomBulkData>(),
+        }
+    }
+
+    fn write(&self, reader_writer: &mut StableMemoryStream) {
+        match self {
+            RandomValue::SingleByte(value) => reader_writer.write(value),
+            RandomValue::SimpleNumber(value) => reader_writer.write(value),
+            RandomValue::LargeNumber(value) => reader_writer.write(value),
+            RandomValue::TupleValue(value) => reader_writer.write(value),
+            RandomValue::RecordValue(value) => reader_writer.write(value),
+            RandomValue::ArrayValue(value) => reader_writer.write(value),
+            RandomValue::BulkValue(value) => reader_writer.write(value),
+        }
+    }
+
+    fn empty_clone(&self) -> RandomValue {
+        match self {
+            RandomValue::SingleByte(_) => RandomValue::SingleByte(0),
+            RandomValue::SimpleNumber(_) => RandomValue::SimpleNumber(0),
+            RandomValue::LargeNumber(_) => RandomValue::LargeNumber(0),
+            RandomValue::TupleValue(_) => RandomValue::TupleValue((0.0, 0)),
+            RandomValue::RecordValue(_) => RandomValue::RecordValue(RandomRecord {
+                field_0: 0,
+                padding_0: 0,
+                field_1: 0,
+                field_2: 0,
+                field_4: 0,
+                field_5: 0,
+                field_6: 0.0,
+                padding_6: 0,
+            }),
+            RandomValue::ArrayValue(_) => RandomValue::ArrayValue(from_fn(|_| 0)),
+            RandomValue::BulkValue(_) => RandomValue::BulkValue(from_fn(|_| 0)),
+        }
+    }
+
+    fn read(&mut self, reader_writer: &mut StableMemoryStream) {
+        match self {
+            RandomValue::SingleByte(value) => *value = reader_writer.read(),
+            RandomValue::SimpleNumber(value) => *value = reader_writer.read(),
+            RandomValue::LargeNumber(value) => *value = reader_writer.read(),
+            RandomValue::TupleValue(value) => *value = reader_writer.read(),
+            RandomValue::RecordValue(value) => *value = reader_writer.read(),
+            RandomValue::ArrayValue(value) => {
+                reader_writer.raw_read(value as *mut i64 as usize, size_of::<RandomArray>())
+            }
+            RandomValue::BulkValue(value) => {
+                reader_writer.raw_read(value as *mut u8 as usize, size_of::<RandomBulkData>())
+            }
+        }
+    }
+
+    fn update(&self, reader_writer: &mut StableMemoryStream) {
+        match self {
+            RandomValue::SingleByte(value) => reader_writer.update(value),
+            RandomValue::SimpleNumber(value) => reader_writer.update(value),
+            RandomValue::LargeNumber(value) => reader_writer.update(value),
+            RandomValue::TupleValue(value) => reader_writer.update(value),
+            RandomValue::RecordValue(value) => reader_writer.update(value),
+            RandomValue::ArrayValue(value) => reader_writer.update(value),
+            RandomValue::BulkValue(value) => reader_writer.update(value),
+        }
+    }
+}
+
+fn test_randomized_read_write() {
+    println!("    Testing randomized read write ...");
+    const RANDOM_SEED: u64 = 4711;
+    let mut random = Rand32::new(RANDOM_SEED);
+    let mut series = vec![];
+    let stable_start = random.rand_range(0..1000) as u64;
+    let mut reader_writer = StableMemoryStream::open(stable_start);
+    let mut total_size = 0;
+    const AMOUNT: usize = 1000;
+    for _ in 0..AMOUNT {
+        let input = RandomValue::generate(&mut random);
+        input.write(&mut reader_writer);
+        total_size += input.size();
+        series.push(input);
+        assert!(!reader_writer.scan_completed());
+        if random.rand_u32() % 2 == 0 {
+            let expected = series.remove(0);
+            let mut output = expected.empty_clone();
+            output.read(&mut reader_writer);
+            assert_eq!(output, expected);
+            let empty = output.empty_clone();
+            empty.update(&mut reader_writer);
+        }
+    }
+    while !reader_writer.scan_completed() {
+        let expected = series.remove(0);
+        let mut output = expected.empty_clone();
+        output.read(&mut reader_writer);
+        assert_eq!(output, expected);
+        let empty = output.empty_clone();
+        empty.update(&mut reader_writer);
+    }
+    assert!(reader_writer.scan_completed());
+    reader_writer.close();
+    assert_eq!(reader_writer.written_length(), total_size as u64);
+    check_zeroed_stable_memory(stable_start, total_size);
+}
+
+fn check_zeroed_stable_memory(stable_start: u64, size: usize) {
+    for index in 0..size {
+        let mut data = 0u8;
+        ic0_stable64_read(&mut data as *mut u8 as u64, stable_start + index as u64, 1);
+        assert_eq!(data, 0);
+    }
+}
diff --git a/rts/motoko-rts-tests/src/stabilization/stable_bigints.rs b/rts/motoko-rts-tests/src/stabilization/stable_bigints.rs
new file mode 100644
index 00000000000..7be0f0e3be9
--- /dev/null
+++ b/rts/motoko-rts-tests/src/stabilization/stable_bigints.rs
@@ -0,0 +1,85 @@
+use std::ptr::null_mut;
+
+use motoko_rts::{
+    bigint::{bigint_add, bigint_eq, bigint_mul, bigint_neg, bigint_of_word64},
+    types::Value,
+};
+use oorandom::Rand32;
+
+use crate::{
+    bigint::set_bigint_heap,
+    memory::{initialize_test_memory, reset_test_memory},
+    stabilization::{deserialize, serialize, stable_memory::clear_stable_memory},
+};
+
+pub unsafe fn test() {
+    println!("  Testing stable big integers ...");
+
+    const RANDOM_SEED: u64 = 4711;
+    let mut random = Rand32::new(RANDOM_SEED);
+
+    test_simple_numbers();
+    test_small_random_numbers(&mut random);
+    test_big_random_numbers(&mut random);
+
+    clear_stable_memory();
+}
+
+unsafe fn test_simple_numbers() {
+    println!("    Testing simple numbers ...");
+
+    for number in 0..256 {
+        test_bigint(|| bigint_of_word64(number));
+    }
+}
+
+unsafe fn test_small_random_numbers(random: &mut Rand32) {
+    println!("    Testing small random numbers ...");
+
+    const TEST_RUNS: u32 = 1000;
+    for _ in 0..TEST_RUNS {
+        let number = random.rand_u32() as u64;
+        test_bigint(|| bigint_of_word64(number));
+    }
+}
+
+unsafe fn test_big_random_numbers(random: &mut Rand32) {
+    println!("    Testing big random numbers ...");
+
+    const TEST_RUNS: u32 = 10_000;
+    for _ in 0..TEST_RUNS {
+        test_bigint(|| random_bigint(random));
+    }
+}
+
+unsafe fn random_bigint(random: &mut Rand32) -> Value {
+    const STEPS: usize = 20;
+    let mut last = bigint_of_word64(random.rand_u32() as u64);
+    let mut current = bigint_of_word64(random.rand_u32() as u64);
+    for _ in 0..STEPS {
+        let computed = match random.rand_range(0..3) {
+            0 => bigint_add(last, current),
+            1 => bigint_mul(last, current),
+            2 => bigint_neg(current),
+            _ => unreachable!(),
+        };
+        last = current;
+        current = computed;
+    }
+    current
+}
+
+unsafe fn test_bigint<F: FnMut() -> Value>(mut generate_bigint: F) {
+    let mut memory = initialize_test_memory();
+    set_bigint_heap(&mut memory);
+    let input = generate_bigint();
+    // Clone the input bigint object, because it is destructed on serialization.
+    let clone = bigint_add(input, bigint_of_word64(0));
+    assert!(bigint_eq(clone, input));
+    let stable_size = serialize(clone, 0);
+    // Note: `clone` is no longer a valid bigint because it has been replaced by a forwarding object.
+    let output = deserialize(&mut memory, 0, stable_size);
+    assert!(bigint_eq(output, input));
+    set_bigint_heap(null_mut());
+    reset_test_memory();
+}
diff --git a/rts/motoko-rts-tests/src/stabilization/stable_memory.rs b/rts/motoko-rts-tests/src/stabilization/stable_memory.rs
new file mode 100644
index 00000000000..a734a9e7c89
--- /dev/null
+++ b/rts/motoko-rts-tests/src/stabilization/stable_memory.rs
@@ -0,0 +1,49 @@
+use motoko_rts::{mem_utils::memcpy_bytes, types::Bytes};
+use std::cell::RefCell;
+
+const PAGE_SIZE: u64 = 64 * 1024;
+
+thread_local! {
+    static STABLE_MEMORY: RefCell<Vec<u8>> = RefCell::new(vec![]);
+}
+
+pub fn clear_stable_memory() {
+    STABLE_MEMORY.with(|memory| {
+        memory.borrow_mut().clear();
+    })
+}
+
+#[no_mangle]
+pub fn ic0_stable64_write(offset: u64, source: u64, size: u64) {
+    STABLE_MEMORY.with(|memory| {
+        assert!(offset + size <= memory.borrow().len() as u64);
+        let destination = memory.borrow_mut().as_mut_ptr() as u64 + offset;
+        unsafe {
+            memcpy_bytes(destination as usize, source as usize, Bytes(size as usize));
+        }
+    });
+}
+
+#[no_mangle]
+pub fn ic0_stable64_read(destination: u64, offset: u64, size: u64) {
+    STABLE_MEMORY.with(|memory| {
+        assert!(offset + size <= memory.borrow().len() as u64);
+        let source = memory.borrow_mut().as_mut_ptr() as u64 + offset;
+        unsafe {
+            memcpy_bytes(destination as usize, source as usize, Bytes(size as usize));
+        }
+    });
+}
+
+#[no_mangle]
+pub fn ic0_stable64_size() -> u64 {
+    STABLE_MEMORY.with(|memory| memory.borrow().len()) as u64 / PAGE_SIZE
+}
+
+#[no_mangle]
+pub fn ic0_stable64_grow(additional_pages: u64) -> u64 {
+    for _ in 0..additional_pages * PAGE_SIZE {
+        STABLE_MEMORY.with(|memory| memory.borrow_mut().push(0));
+    }
+    additional_pages
+}
diff --git a/rts/motoko-rts-tests/src/stable_mem.rs b/rts/motoko-rts-tests/src/stable_mem.rs
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/rts/motoko-rts-tests/src/text.rs b/rts/motoko-rts-tests/src/text.rs
index 1d534f4df85..218d265a5d2 100644
--- a/rts/motoko-rts-tests/src/text.rs
+++ b/rts/motoko-rts-tests/src/text.rs
@@ -1,6 +1,6 @@
 //! Text and text iterator tests
 
-use crate::memory::{initialize_test_memory, reset_test_memory, TestMemory};
+use crate::memory::{initialize_test_memory, reset_test_memory};
 
 use motoko_rts::memory::Memory;
 use motoko_rts::text::{
@@ -8,12 +8,10 @@ use motoko_rts::text::{
     text_singleton, text_size,
 };
 use motoko_rts::text_iter::{text_iter, text_iter_done, text_iter_next};
-use motoko_rts::types::{Bytes, Value, Words, TAG_BLOB_T};
+use motoko_rts::types::{Bytes, Value, TAG_BLOB_T};
 
 use std::convert::TryFrom;
 
-use proptest::test_runner::{Config, TestCaseError, TestCaseResult, TestRunner};
-
 static STR: &str = "abcdefgh";
 
 struct TextIter<'a, M: Memory> {
@@ -55,9 +53,9 @@ pub unsafe fn test() {
         let char = char::try_from(i).unwrap();
         let mut str = String::new();
         str.push(char);
-        let mut out: u32 = 0;
+        let mut out: usize = 0;
         let char_decoded = decode_code_point(str.as_ptr(), &mut out as *mut _);
-        assert_eq!(out, str.len() as u32);
+        assert_eq!(out, str.len());
         assert_eq!(char::try_from(char_decoded).unwrap(), char);
 
         let text = text_singleton(&mut mem, char as u32);
@@ -76,23 +74,32 @@ pub unsafe fn test() {
     println!("  Testing concatenation");
     concat1(&mut mem);
 
-    drop(mem);
+    let mut long_text = String::from("");
+    for i in 0..=255u32 {
+        long_text.push(char::try_from(i).unwrap());
+    }
+    concat_test(&mut mem, vec![String::from("")]);
+    concat_test(&mut mem, vec![String::from(""), String::from("")]);
+    concat_test(&mut mem, vec![String::from("a"), String::from("")]);
+    concat_test(&mut mem, vec![String::from(""), String::from("b")]);
+    concat_test(&mut mem, vec![String::from("a"), String::from("b")]);
+    concat_test(
+        &mut mem,
+        vec![String::from(""), String::from(""), String::from("")],
+    );
+    concat_test(
+        &mut mem,
+        vec![
+            String::from("test-"),
+            String::from("abc"),
+            String::from("-0123"),
+            String::from("_!?"),
+            String::from("äöü"),
+            long_text,
+        ],
+    );
 
-    let mut proptest_runner = TestRunner::new(Config {
-        cases: 1_000,
-        failure_persistence: None,
-        ..Default::default()
-    });
-
-    proptest_runner
-        .run(
-            &proptest::collection::vec(proptest::string::string_regex(".{0, 20}").unwrap(), 1..20),
-            |strs| {
-                let mut mem = TestMemory::new(Words(1024 * 1024));
-                concat_prop(&mut mem, strs)
-            },
-        )
-        .unwrap();
+    drop(mem);
 
     reset_test_memory();
 }
@@ -110,19 +117,19 @@ unsafe fn concat1<M: Memory>(mem: &mut M) {
     let expected = strs.concat();
 
     // Check number of characters
-    assert_eq!(text_len(obj), expected.chars().count() as u32);
+    assert_eq!(text_len(obj), expected.chars().count());
 
     // Check text size in bytes
-    assert_eq!(text_size(obj), Bytes(expected.len() as u32));
+    assert_eq!(text_size(obj), Bytes(expected.len()));
 
     // Generate blob
     let text_blob = blob_of_text(mem, obj);
 
     // Check number of characters in blob
-    assert_eq!(text_len(text_blob), expected.chars().count() as u32);
+    assert_eq!(text_len(text_blob), expected.chars().count());
 
     // Check blob size in bytes
-    assert_eq!(text_size(text_blob), Bytes(expected.len() as u32));
+    assert_eq!(text_size(text_blob), Bytes(expected.len()));
 
     // Check blob iteration
     let blob = blob_of_text(mem, obj);
@@ -135,7 +142,7 @@ unsafe fn concat1<M: Memory>(mem: &mut M) {
     assert_eq!(TextIter::from_text(mem, obj).collect::<String>(), expected);
 }
 
-fn concat_prop<M: Memory>(mem: &mut M, strs: Vec<String>) -> TestCaseResult {
+fn concat_test<M: Memory>(mem: &mut M, strs: Vec<String>) {
     unsafe {
         let mut obj = text_of_str(mem, "");
         for str in &strs {
@@ -146,44 +153,28 @@ fn concat_prop<M: Memory>(mem: &mut M, strs: Vec<String>) -> TestCaseResult {
         let expected = strs.concat();
 
         // Check number of characters
-        if text_len(obj) != expected.chars().count() as u32 {
-            return Err(TestCaseError::Fail("text_len".into()));
-        }
+        assert_eq!(text_len(obj), expected.chars().count());
 
         // Check text size in bytes
-        if text_size(obj) != Bytes(expected.len() as u32) {
-            return Err(TestCaseError::Fail("text_size".into()));
-        }
+        assert_eq!(text_size(obj), Bytes(expected.len()));
 
         // Generate blob
         let text_blob = blob_of_text(mem, obj);
 
         // Check number of characters in blob
-        if text_len(text_blob) != expected.chars().count() as u32 {
-            return Err(TestCaseError::Fail("blob text_len".into()));
-        }
+        assert_eq!(text_len(text_blob), expected.chars().count());
 
         // Check blob size in bytes
-        if text_size(text_blob) != Bytes(expected.len() as u32) {
-            return Err(TestCaseError::Fail("blob text_size".into()));
-        }
+        assert_eq!(text_size(text_blob), Bytes(expected.len()));
 
         // Check blob iteration
         let blob = blob_of_text(mem, obj);
-        if TextIter::from_text(mem, blob).collect::<String>() != expected {
-            return Err(TestCaseError::Fail("blob_of_text iteration".into()));
-        }
+        assert_eq!(TextIter::from_text(mem, blob).collect::<String>(), expected);
 
         // Check blob-concat comparison
-        if text_compare(text_blob, obj) != 0 {
-            return Err(TestCaseError::Fail("text_compare of blob and text".into()));
-        }
+        assert_eq!(text_compare(text_blob, obj), 0);
 
         // Check concat iteration
-        if TextIter::from_text(mem, obj).collect::<String>() != expected {
-            return Err(TestCaseError::Fail("iteration".into()));
-        }
-
-        Ok(())
+        assert_eq!(TextIter::from_text(mem, obj).collect::<String>(), expected);
     }
 }
diff --git a/rts/motoko-rts-tests/src/utf8.rs b/rts/motoko-rts-tests/src/utf8.rs
index 209bedce4b4..5c3b6e4dc9e 100644
--- a/rts/motoko-rts-tests/src/utf8.rs
+++ b/rts/motoko-rts-tests/src/utf8.rs
@@ -56,16 +56,10 @@ pub unsafe fn test() {
     println!("Testing UTF8 validation ...");
 
     for test_str in TEST_STRS_VALID.iter() {
-        assert!(utf8_valid(
-            test_str.as_ptr() as *const _,
-            test_str.len() as u32
-        ));
+        assert!(utf8_valid(test_str.as_ptr() as *const _, test_str.len()));
     }
 
     for test_str in TEST_STRS_INVALID.iter() {
-        assert!(!utf8_valid(
-            test_str.as_ptr() as *const _,
-            test_str.len() as u32
-        ));
+        assert!(!utf8_valid(test_str.as_ptr() as *const _, test_str.len()));
     }
 }
diff --git a/rts/motoko-rts/.vim/coc-settings.json b/rts/motoko-rts/.vim/coc-settings.json
index 36bd8a25530..40b2134566b 100644
--- a/rts/motoko-rts/.vim/coc-settings.json
+++ b/rts/motoko-rts/.vim/coc-settings.json
@@ -1,6 +1,6 @@
 // https://github.com/rust-analyzer/rust-analyzer/blob/master/editors/code/package.json
 {
-    "rust-analyzer.cargo.target": "wasm32-unknown-emscripten",
+    "rust-analyzer.cargo.target": "wasm64-unknown-unknown",
 
     // This is required as `cargo check --all-targets` doesn't seem to work well
     // on no-std crates, it generates false "duplicate lang item" errors.
diff --git a/rts/motoko-rts/Cargo.lock b/rts/motoko-rts/Cargo.lock
index 38910e441b2..bd9a8511232 100644
--- a/rts/motoko-rts/Cargo.lock
+++ b/rts/motoko-rts/Cargo.lock
@@ -4,9 +4,9 @@ version = 3
 
 [[package]]
 name = "libc"
-version = "0.2.142"
+version = "0.2.153"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a987beff54b60ffa6d51982e1aa1146bc42f19bd26be28b0586f252fccf5317"
+checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd"
 
 [[package]]
 name = "motoko-rts"
@@ -27,18 +27,18 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.56"
+version = "1.0.66"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b63bdb0cd06f1f4dedf69b254734f9b45af66e4a031e42a7480257d9898b435"
+checksum = "18fb31db3f9bddb2ea821cde30a9f70117e3f119938b5ee630b7403aa6e2ead9"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.26"
+version = "1.0.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4424af4bf778aae2051a77b60283332f386554255d722233d09fbfc7e30da2fc"
+checksum = "5fe8a65d69dd0808184ebb5f836ab526bb259db23c657efa38711b1072ee47f0"
 dependencies = [
  "proc-macro2",
 ]
@@ -56,6 +56,6 @@ dependencies = [
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.8"
+version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5464a87b239f13a63a501f2701565754bae92d243d4bb7eb12f6d57d2269bf4"
+checksum = "301abaae475aa91687eb82514b328ab47a211a533026cb25fc3e519b86adfc3c"
diff --git a/rts/motoko-rts/Cargo.toml b/rts/motoko-rts/Cargo.toml
index 59350673ba4..8acedf98c21 100644
--- a/rts/motoko-rts/Cargo.toml
+++ b/rts/motoko-rts/Cargo.toml
@@ -25,8 +25,17 @@ ic = []
 # This feature enables extensive memory sanity checks in the incremental GC.
 memory_check = []
 
+# Incremental GC, using the extended object header containing the forwarding pointer. 
+incremental_gc = []
+
+# Classical persistence, 32-bit, with Candid stabilization
+classical_persistence = ["libc"]
+
+# Enhanced orthogonal persistence, 64-bit, retaining the main memory across upgrades.
+enhanced_orthogonal_persistence = ["incremental_gc"]
+
 [dependencies]
-libc = { version = "0.2.139", default_features = false }
+libc = { version = "0.2.139", default_features = false, optional = true }
 motoko-rts-macros = { path = "../motoko-rts-macros" }
 
 [profile.dev]
diff --git a/rts/motoko-rts/native/Cargo.toml b/rts/motoko-rts/native/Cargo.toml
index b78322947c7..690ca564c23 100644
--- a/rts/motoko-rts/native/Cargo.toml
+++ b/rts/motoko-rts/native/Cargo.toml
@@ -8,8 +8,13 @@ edition = "2018"
 crate-type = ["rlib"]
 path = "../src/lib.rs"
 
+[features]
+incremental_gc = []
+classical_persistence = ["libc"]
+enhanced_orthogonal_persistence = ["incremental_gc"]
+
 [dependencies]
-libc = { version = "0.2.112", default_features = false }
+libc = { version = "0.2.112", default_features = false, optional = true }
 motoko-rts-macros = { path = "../../motoko-rts-macros" }
 
 [profile.dev]
diff --git a/rts/motoko-rts/src/allocator.rs b/rts/motoko-rts/src/allocator.rs
index 8111e3f4a52..a0492cd3e79 100644
--- a/rts/motoko-rts/src/allocator.rs
+++ b/rts/motoko-rts/src/allocator.rs
@@ -1,6 +1,7 @@
 // c.f. https://os.phil-opp.com/heap-allocation/#dynamic-memory
 
 use alloc::alloc::{GlobalAlloc, Layout};
+use motoko_rts_macros::enhanced_orthogonal_persistence;
 //use core::ptr::null_mut;
 use crate::memory::{alloc_blob, ic};
 use crate::types::{Bytes, TAG_BLOB_B};
@@ -20,12 +21,11 @@ unsafe impl GlobalAlloc for EphemeralAllocator {
         let align = layout.align();
         // align is a power of 2
         debug_assert!(align.count_ones() == 1);
-        let word_size = crate::constants::WORD_SIZE as usize;
+        let word_size = crate::constants::WORD_SIZE;
         let min_align = (align + word_size - 1) / word_size * word_size;
         let blob_size = size + min_align - word_size;
-        let blob =
-            alloc_blob::<ic::IcMemory>(&mut ic::IcMemory, TAG_BLOB_B, Bytes(blob_size as u32))
-                .as_blob_mut();
+        let blob = alloc_blob::<ic::IcMemory>(&mut ic::IcMemory, TAG_BLOB_B, Bytes(blob_size))
+            .as_blob_mut();
         let payload_address = blob.payload_addr() as usize;
         let aligned_address = (payload_address + min_align - 1) / min_align * min_align;
 
@@ -41,3 +41,33 @@ unsafe impl GlobalAlloc for EphemeralAllocator {
 
 #[global_allocator]
 static ALLOCATOR: EphemeralAllocator = EphemeralAllocator;
+
+#[no_mangle]
+#[enhanced_orthogonal_persistence]
+unsafe fn __rust_alloc(size: usize, align: usize) -> *mut u8 {
+    ALLOCATOR.alloc(Layout::from_size_align_unchecked(size, align))
+}
+
+#[no_mangle]
+#[enhanced_orthogonal_persistence]
+unsafe fn __rust_dealloc(ptr: *mut u8, size: usize, align: usize) {
+    ALLOCATOR.dealloc(ptr, Layout::from_size_align_unchecked(size, align));
+}
+
+#[no_mangle]
+#[enhanced_orthogonal_persistence]
+fn __rust_realloc(_ptr: *mut u8, _old_size: usize, _align: usize, _new_size: usize) -> *mut u8 {
+    unimplemented!();
+}
+
+#[no_mangle]
+#[enhanced_orthogonal_persistence]
+fn __rust_alloc_zeroed(_size: usize, _align: usize) -> *mut u8 {
+    unimplemented!();
+}
+
+#[no_mangle]
+#[enhanced_orthogonal_persistence]
+fn __rust_alloc_error_handler(_size: usize, _align: usize) -> ! {
+    panic!("Rust allocation error");
+}
diff --git a/rts/motoko-rts/src/barriers.rs b/rts/motoko-rts/src/barriers.rs
index 7a3e7759070..44f95bec811 100644
--- a/rts/motoko-rts/src/barriers.rs
+++ b/rts/motoko-rts/src/barriers.rs
@@ -1,13 +1,35 @@
+use motoko_rts_macros::{incremental_gc, non_incremental_gc};
+
 use crate::{memory::Memory, types::Value};
 
+#[incremental_gc]
 pub unsafe fn init_with_barrier<M: Memory>(_mem: &mut M, location: *mut Value, value: Value) {
     *location = value.forward_if_possible();
 }
 
+#[non_incremental_gc]
+pub unsafe fn init_with_barrier<M: Memory>(mem: &mut M, location: *mut Value, value: Value) {
+    *location = value;
+    crate::gc::generational::write_barrier::post_write_barrier(mem, location as usize);
+}
+
+#[incremental_gc]
 pub unsafe fn write_with_barrier<M: Memory>(mem: &mut M, location: *mut Value, value: Value) {
     crate::gc::incremental::barriers::write_with_barrier(mem, location, value);
 }
 
+#[non_incremental_gc]
+pub unsafe fn write_with_barrier<M: Memory>(mem: &mut M, location: *mut Value, value: Value) {
+    *location = value;
+    crate::gc::generational::write_barrier::post_write_barrier(mem, location as usize);
+}
+
+#[incremental_gc]
 pub unsafe fn allocation_barrier(new_object: Value) -> Value {
     crate::gc::incremental::barriers::allocation_barrier(new_object)
 }
+
+#[non_incremental_gc]
+pub unsafe fn allocation_barrier(new_object: Value) -> Value {
+    new_object
+}
diff --git a/rts/motoko-rts/src/bigint.rs b/rts/motoko-rts/src/bigint.rs
index fcbb4e6a06b..cc2131a27cf 100644
--- a/rts/motoko-rts/src/bigint.rs
+++ b/rts/motoko-rts/src/bigint.rs
@@ -38,14 +38,38 @@ use crate::memory::Memory;
 use crate::tommath_bindings::*;
 use crate::types::{size_of, BigInt, Bytes, Value, TAG_BIGINT};
 
-use motoko_rts_macros::ic_mem_fn;
+use crate::libc_declarations::c_void;
+
+#[classical_persistence]
+use crate::types::Stream;
+
+use motoko_rts_macros::{classical_persistence, ic_mem_fn};
+
+#[cfg(feature = "ic")]
+use motoko_rts_macros::enhanced_orthogonal_persistence;
 
 // Provided by generated code
+#[cfg(feature = "ic")]
 extern "C" {
-    fn int_from_i32(value: i32) -> Value;
+    #[enhanced_orthogonal_persistence]
+    fn int_from_i64(value: isize) -> Value;
+    #[classical_persistence]
+    fn int_from_i32(value: isize) -> Value;
+}
+
+#[cfg(feature = "ic")]
+#[enhanced_orthogonal_persistence]
+unsafe fn int_from_isize(value: isize) -> Value {
+    int_from_i64(value)
 }
 
-unsafe fn mp_alloc<M: Memory>(mem: &mut M, size: Bytes<u32>) -> *mut u8 {
+#[cfg(feature = "ic")]
+#[classical_persistence]
+unsafe fn int_from_isize(value: isize) -> Value {
+    int_from_i32(value)
+}
+
+unsafe fn mp_alloc<M: Memory>(mem: &mut M, size: Bytes<usize>) -> *mut u8 {
     let ptr = mem.alloc_words(size_of::<BigInt>() + size.to_words());
     // NB. Cannot use as_bigint() here as header is not written yet
     let blob = ptr.get_ptr() as *mut BigInt;
@@ -55,7 +79,9 @@ unsafe fn mp_alloc<M: Memory>(mem: &mut M, size: Bytes<u32>) -> *mut u8 {
     // libtommath stores the size of the object in alloc as count of mp_digits (u64)
     let size = size.as_usize();
     debug_assert_eq!((size % core::mem::size_of::<mp_digit>()), 0);
-    (*blob).mp_int.alloc = (size / core::mem::size_of::<mp_digit>()) as i32;
+    let count = size / core::mem::size_of::<mp_digit>();
+    assert!(count <= i32::MAX as usize);
+    (*blob).mp_int.alloc = count as i32;
     allocation_barrier(ptr);
     blob.payload_addr() as *mut u8
 }
@@ -65,18 +91,18 @@ pub unsafe fn mp_calloc<M: Memory>(
     mem: &mut M,
     n_elems: usize,
     elem_size: Bytes<usize>,
-) -> *mut libc::c_void {
+) -> *mut c_void {
     debug_assert_eq!(elem_size.0, core::mem::size_of::<mp_digit>());
     // Overflow check for the following multiplication
     if n_elems > 1 << 30 {
         bigint_trap();
     }
-    let size = Bytes((n_elems * elem_size.0) as u32);
-    let payload = mp_alloc(mem, size) as *mut u32;
+    let size = Bytes(n_elems * elem_size.0);
+    let payload = mp_alloc(mem, size) as *mut usize;
 
     // NB. alloc_bytes rounds up to words so we do the same here to set the whole buffer
     for i in 0..size.to_words().as_usize() {
-        *payload.add(i as usize) = 0;
+        *payload.add(i) = 0;
     }
 
     payload as *mut _
@@ -85,10 +111,10 @@ pub unsafe fn mp_calloc<M: Memory>(
 #[ic_mem_fn]
 pub unsafe fn mp_realloc<M: Memory>(
     mem: &mut M,
-    ptr: *mut libc::c_void,
-    old_size: Bytes<u32>,
-    new_size: Bytes<u32>,
-) -> *mut libc::c_void {
+    ptr: *mut c_void,
+    old_size: Bytes<usize>,
+    new_size: Bytes<usize>,
+) -> *mut c_void {
     let bigint = BigInt::from_payload(ptr as *mut mp_digit);
 
     debug_assert_eq!((*bigint).header.tag, TAG_BIGINT);
@@ -108,7 +134,7 @@ pub unsafe fn mp_realloc<M: Memory>(
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn mp_free(_ptr: *mut libc::c_void, _size: u32) {}
+pub unsafe extern "C" fn mp_free(_ptr: *mut c_void, _size: usize) {}
 
 /*
 Note on libtommath error handling
@@ -161,14 +187,14 @@ pub(crate) unsafe fn mp_iszero(p: *const mp_int) -> bool {
 }
 
 // Allocates an mp_int on the stack
-unsafe fn tmp_bigint() -> mp_int {
+pub(crate) unsafe fn tmp_bigint() -> mp_int {
     let mut i: mp_int = core::mem::zeroed();
     check(mp_init(&mut i));
     i
 }
 
 // Persists an mp_int from the stack on the heap
-unsafe fn persist_bigint(i: mp_int) -> Value {
+pub(crate) unsafe fn persist_bigint(i: mp_int) -> Value {
     if i.dp == core::ptr::null_mut() {
         panic!("persist_bigint: dp == NULL?");
     }
@@ -181,6 +207,7 @@ unsafe fn persist_bigint(i: mp_int) -> Value {
 }
 
 #[no_mangle]
+#[classical_persistence]
 pub unsafe extern "C" fn bigint_of_word32(w: u32) -> Value {
     let mut i = tmp_bigint();
     mp_set_u32(&mut i, w);
@@ -189,6 +216,7 @@ pub unsafe extern "C" fn bigint_of_word32(w: u32) -> Value {
 
 #[cfg(feature = "ic")]
 #[no_mangle]
+#[classical_persistence]
 unsafe extern "C" fn bigint_of_int32(j: i32) -> Value {
     let mut i = tmp_bigint();
     mp_set_i32(&mut i, j);
@@ -212,14 +240,16 @@ unsafe extern "C" fn bigint_to_word32_trap(p: Value) -> u32 {
     mp_get_u32(mp_int)
 }
 
-// a : BigInt, msg : Blob
+// p : BigInt, msg : Blob
 #[cfg(feature = "ic")]
 #[no_mangle]
 unsafe extern "C" fn bigint_to_word32_trap_with(p: Value, msg: Value) -> u32 {
     let mp_int = p.as_bigint().mp_int_ptr();
 
     if mp_isneg(mp_int) || mp_count_bits(mp_int) > 32 {
-        crate::rts_trap(msg.as_blob().payload_const(), msg.as_blob().len());
+        let length = msg.as_blob().len().as_usize();
+        assert!(length <= u32::MAX as usize);
+        crate::rts_trap(msg.as_blob().payload_const(), length as u32);
     }
 
     mp_get_u32(mp_int)
@@ -243,9 +273,23 @@ unsafe extern "C" fn bigint_to_word64_trap(p: Value) -> u64 {
     mp_get_u64(mp_int)
 }
 
+// p : BigInt, msg : Blob
 #[cfg(feature = "ic")]
 #[no_mangle]
-unsafe extern "C" fn bigint_of_word64(w: u64) -> Value {
+unsafe extern "C" fn bigint_to_word64_trap_with(p: Value, msg: Value) -> u64 {
+    let mp_int = p.as_bigint().mp_int_ptr();
+
+    if mp_isneg(mp_int) || mp_count_bits(mp_int) > 64 {
+        let length = msg.as_blob().len().as_usize();
+        assert!(length <= u32::MAX as usize);
+        crate::rts_trap(msg.as_blob().payload_const(), length as u32);
+    }
+
+    mp_get_u64(mp_int)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn bigint_of_word64(w: u64) -> Value {
     let mut i = tmp_bigint();
     mp_set_u64(&mut i, w);
     persist_bigint(i)
@@ -262,12 +306,38 @@ unsafe extern "C" fn bigint_of_int64(j: i64) -> Value {
 #[cfg(feature = "ic")]
 #[no_mangle]
 unsafe extern "C" fn bigint_of_float64(j: f64) -> Value {
-    // handle fast path: some numbers (when rounded towards zero by `j as i32`)
-    // may be represented as `Int` without resorting to heap allocation, i.e.
-    // in the range `-1073741824 == 0xc0000000 <= j as i32 <= 0x3fffffff == 1073741823`
-    if j < 1073741824.0 && j > -1073741825.0 {
+    // Fast path: Determine when the integer numbers can be represented as a compact (unboxed) `Int`.
+    let is_compact = match usize::BITS {
+        u64::BITS => {
+            // The integer can be represented in compact 64-bit scalar if it is in the range
+            // `-4611686018427387904 == -2 ** 62 <= j as i64 < 2 ** 62 == 4611686018427387904`, by
+            // considering that the two most significant bits are reserved for the `BigInt` scalar tag.
+            // The closest binary64 float representations in IEEE 754 for the boundaries are:
+            // Lower boundary approximation >= -2 ** 62:
+            //   `f64::from_bits(0xC3CF_FFFF_FFFF_FFFF`) == -4611686018427387400 > -4611686018427387904
+            // Upper boundary approximation < 2 ** 62:
+            //   `f64::from_bits(0x43CF_FFFF_FFFF_FFFF) == 4611686018427387400 < 4611686018427387904.
+            // IEEE754 double precision encoding:
+            // ┌───────────────┬────────────────────────┬─────────────────────────┐
+            // │ sign (bit 63) │ exponent (bits 52..62) |  mantissa (bits 0..51)  |
+            // └───────────────┴────────────────────────┴─────────────────────────┘
+            // The exponent has a bias of 1023:
+            // * Example: Exponent 61 is encoded 0x43C == 1023 + 61.
+            // The mantissa has an implicit extra most significant bit 1.
+            // * Example: Mantissa `F_FFFF_FFFF_FFFF` actually represents `1F_FFFF_FFFF_FFFF`.
+            j >= -4611686018427387400.0f64 && j <= 4611686018427387400.0f64
+        }
+        u32::BITS => {
+            // The integer can be represented in compact 32-bit scalar if it is in the range
+            // `-1073741824 == 0xc0000000 <= j as i32 <= 0x3fffffff == 1073741823`, by
+            // considering that the two most significant bits are reserved for the `BigInt` scalar tag.
+            j < 1073741824.0 && j > -1073741825.0
+        }
+        _ => unreachable!(),
+    };
+    if is_compact {
         // defer to generated code to create compact or boxed Int value
-        return int_from_i32(j as i32);
+        return int_from_isize(j as isize);
     }
     let mut i = tmp_bigint();
     check(mp_set_double(&mut i, j));
@@ -401,19 +471,19 @@ unsafe extern "C" fn bigint_isneg(a: Value) -> bool {
 
 #[cfg(feature = "ic")]
 #[no_mangle]
-unsafe extern "C" fn bigint_lsh(a: Value, b: i32) -> Value {
+unsafe extern "C" fn bigint_lsh(a: Value, b: isize) -> Value {
     let mut i = tmp_bigint();
-    check(mp_mul_2d(a.as_bigint().mp_int_ptr(), b, &mut i));
+    check(mp_mul_2d(a.as_bigint().mp_int_ptr(), b as i32, &mut i));
     persist_bigint(i)
 }
 
 #[cfg(feature = "ic")]
 #[no_mangle]
-unsafe extern "C" fn bigint_rsh(a: Value, b: i32) -> Value {
+unsafe extern "C" fn bigint_rsh(a: Value, b: isize) -> Value {
     let mut i = tmp_bigint();
     check(mp_div_2d(
         a.as_bigint().mp_int_ptr(),
-        b,
+        b as i32,
         &mut i,
         core::ptr::null_mut(),
     ));
@@ -421,16 +491,16 @@ unsafe extern "C" fn bigint_rsh(a: Value, b: i32) -> Value {
 }
 
 #[no_mangle]
-unsafe extern "C" fn bigint_count_bits(a: Value) -> i32 {
-    mp_count_bits(a.as_bigint().mp_int_ptr())
+unsafe extern "C" fn bigint_count_bits(a: Value) -> usize {
+    mp_count_bits(a.as_bigint().mp_int_ptr()) as usize
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn bigint_leb128_size(a: Value) -> u32 {
+pub unsafe extern "C" fn bigint_leb128_size(a: Value) -> usize {
     if mp_iszero(a.as_bigint().mp_int_ptr()) {
         1
     } else {
-        (bigint_count_bits(a) as u32 + 6) / 7 // divide by 7, round up
+        (bigint_count_bits(a) + 6) / 7 // divide by 7, round up
     }
 }
 
@@ -461,20 +531,29 @@ pub unsafe extern "C" fn bigint_leb128_encode(n: Value, buf: *mut u8) {
 }
 
 #[no_mangle]
-unsafe extern "C" fn bigint_2complement_bits(n: Value) -> u32 {
+#[classical_persistence]
+pub unsafe extern "C" fn bigint_leb128_stream_encode(stream: *mut Stream, n: Value) {
+    debug_assert!(!stream.is_forwarded());
+    let mut tmp: mp_int = core::mem::zeroed(); // or core::mem::uninitialized?
+    check(mp_init_copy(&mut tmp, n.as_bigint().mp_int_ptr()));
+    stream.write_leb128(&mut tmp, false)
+}
+
+#[no_mangle]
+unsafe extern "C" fn bigint_2complement_bits(n: Value) -> usize {
     let mp_int = n.as_bigint().mp_int_ptr();
     if mp_isneg(mp_int) {
         let mut tmp: mp_int = core::mem::zeroed(); // or core::mem::uninitialized?
         check(mp_init_copy(&mut tmp, mp_int));
         check(mp_incr(&mut tmp));
-        1 + mp_count_bits(&tmp) as u32
+        1 + mp_count_bits(&tmp) as usize
     } else {
-        1 + mp_count_bits(mp_int) as u32
+        1 + mp_count_bits(mp_int) as usize
     }
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn bigint_sleb128_size(n: Value) -> u32 {
+pub unsafe extern "C" fn bigint_sleb128_size(n: Value) -> usize {
     (bigint_2complement_bits(n) + 6) / 7 // divide by 7, round up
 }
 
@@ -496,6 +575,26 @@ pub unsafe extern "C" fn bigint_sleb128_encode(n: Value, buf: *mut u8) {
     }
 }
 
+#[no_mangle]
+#[classical_persistence]
+pub unsafe extern "C" fn bigint_sleb128_stream_encode(stream: *mut Stream, n: Value) {
+    debug_assert!(!stream.is_forwarded());
+    let mut tmp: mp_int = core::mem::zeroed(); // or core::mem::uninitialized?
+    check(mp_init_copy(&mut tmp, n.as_bigint().mp_int_ptr()));
+
+    if mp_isneg(&tmp) {
+        // Turn negative numbers into the two's complement of the right size
+        let mut big: mp_int = core::mem::zeroed();
+        check(mp_init(&mut big));
+        let bytes = bigint_sleb128_size(n);
+        check(mp_2expt(&mut big, 7 * bytes as i32));
+        check(mp_add(&mut tmp, &big, &mut tmp));
+        stream.write_leb128(&mut tmp, false)
+    } else {
+        stream.write_leb128(&mut tmp, true)
+    }
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn bigint_leb128_decode(buf: *mut Buf) -> Value {
     let mut i = tmp_bigint();
@@ -517,7 +616,21 @@ pub unsafe extern "C" fn bigint_leb128_decode(buf: *mut Buf) -> Value {
     persist_bigint(i)
 }
 
-/// Decode at most 5 bytes of LEB128 data to a compact bignum `Value`.
+#[cfg(feature = "ic")]
+const BITS_PER_CHUNK: usize = 7;
+
+#[cfg(feature = "ic")]
+const MAX_CHUNKS_PER_WORD: usize = (usize::BITS as usize + BITS_PER_CHUNK - 1) / BITS_PER_CHUNK;
+
+#[classical_persistence]
+#[cfg(feature = "ic")]
+const _: () = assert!(MAX_CHUNKS_PER_WORD == 5);
+
+#[enhanced_orthogonal_persistence]
+#[cfg(feature = "ic")]
+const _: () = assert!(MAX_CHUNKS_PER_WORD == 10);
+
+/// Decode bytes of LEB128 data to a compact bignum `Value`.
 /// The number of 7-bit chunks are located in the lower portion of `leb`
 /// as indicated by `bits`.
 ///
@@ -528,7 +641,7 @@ pub unsafe extern "C" fn bigint_leb128_decode_word64(
     mut bits: u64,
     buf: *mut Buf,
 ) -> Value {
-    let continuations = bits as u32 / 8;
+    let continuations = bits as usize / 8;
     buf.advance(continuations + 1);
 
     let mut mask: u64 = 0b111_1111; // sliding mask
@@ -536,20 +649,20 @@ pub unsafe extern "C" fn bigint_leb128_decode_word64(
     loop {
         acc |= leb & mask;
         if bits < 8 {
-            if continuations == 4 {
+            if continuations == MAX_CHUNKS_PER_WORD - 1 {
                 break;
             }
-            return int_from_i32(acc as i32);
+            return int_from_isize(acc as isize);
         }
         bits -= 8;
         mask <<= 7;
         leb >>= 1;
     }
 
-    let tentative = (acc as i32) << 1 >> 1; // top two bits must match
+    let tentative = (acc as isize) << 1 >> 1; // top two bits must match
     if tentative as u64 == acc {
         // roundtrip is valid
-        return int_from_i32(tentative);
+        return int_from_isize(tentative);
     }
 
     bigint_of_word64(acc)
@@ -585,7 +698,7 @@ pub unsafe extern "C" fn bigint_sleb128_decode(buf: *mut Buf) -> Value {
     persist_bigint(i)
 }
 
-/// Decode at most 5 bytes of SLEB128 data to a compact bignum `Value`.
+/// Decode bytes of SLEB128 data to a compact bignum `Value`.
 /// The number of 7-bit chunks are located in the lower portion of `sleb`
 /// as indicated by `bits`.
 ///
@@ -596,7 +709,7 @@ pub unsafe extern "C" fn bigint_sleb128_decode_word64(
     mut bits: u64,
     buf: *mut Buf,
 ) -> Value {
-    let continuations = bits as u32 / 8;
+    let continuations = bits as usize / 8;
     buf.advance(continuations + 1);
 
     let mut mask: u64 = 0b111_1111; // sliding mask
@@ -604,23 +717,38 @@ pub unsafe extern "C" fn bigint_sleb128_decode_word64(
     loop {
         acc |= sleb & mask;
         if bits < 8 {
-            if continuations == 4 {
+            if continuations == MAX_CHUNKS_PER_WORD - 1 {
                 break;
             }
-            let sext = 25 - 7 * continuations; // this many top bits will get a copy of the sign
-            return int_from_i32((acc as i32) << sext >> sext);
+            let sext = usize::BITS as usize - (BITS_PER_CHUNK * (continuations + 1)); // this many top bits will get a copy of the sign
+            return int_from_isize((acc as isize) << sext >> sext);
         }
         bits -= 8;
         mask <<= 7;
         sleb >>= 1;
     }
 
-    let signed = (acc as i64) << 29 >> 29; // sign extend
-    let tentative = (signed as i32) << 1 >> 1; // top two bits must match
+    sleb128_decode_word64_result(acc)
+}
+
+#[cfg(feature = "ic")]
+#[classical_persistence]
+unsafe fn sleb128_decode_word64_result(accumulator: u64) -> Value {
+    // Check if it fits into 32-bit or needs boxing to BigInt.
+    const UNUSED_BITS: u32 = u64::BITS - (BITS_PER_CHUNK * MAX_CHUNKS_PER_WORD) as u32;
+    const _: () = assert!(UNUSED_BITS == 29);
+    let signed = (accumulator as i64) << UNUSED_BITS >> UNUSED_BITS;
+    let tentative = (signed as isize) << 1 >> 1; // top two bits must match
     if tentative as i64 == signed {
         // roundtrip is valid
-        return int_from_i32(tentative);
+        return int_from_isize(tentative);
     }
-
     bigint_of_int64(signed)
 }
+
+#[cfg(feature = "ic")]
+#[enhanced_orthogonal_persistence]
+unsafe fn sleb128_decode_word64_result(accumulator: u64) -> Value {
+    // No unused bits in 64-bit representation. The sign bit is already set at bit 63.
+    int_from_isize(accumulator as isize)
+}
diff --git a/rts/motoko-rts/src/bitrel.rs b/rts/motoko-rts/src/bitrel.rs
index ec71fcf78f6..002445bdc6c 100644
--- a/rts/motoko-rts/src/bitrel.rs
+++ b/rts/motoko-rts/src/bitrel.rs
@@ -5,22 +5,22 @@ use crate::idl_trap_with;
 use crate::mem_utils::memzero;
 use crate::types::Words;
 
-const BITS: u32 = 2;
+const BITS: usize = 2;
 
 #[repr(packed)]
 pub struct BitRel {
     /// Pointer into the bit set
-    pub ptr: *mut u32,
+    pub ptr: *mut usize,
     /// Pointer to the end of the bit set
     /// must allow at least 2 * size1 * size2 bits
-    pub end: *mut u32,
-    pub size1: u32,
-    pub size2: u32,
+    pub end: *mut usize,
+    pub size1: usize,
+    pub size2: usize,
 }
 
 impl BitRel {
-    pub fn words(size1: u32, size2: u32) -> u32 {
-        return ((2 * size1 * size2 * BITS) + (usize::BITS - 1)) / usize::BITS;
+    pub fn words(size1: usize, size2: usize) -> usize {
+        return ((2 * size1 * size2 * BITS) + (usize::BITS as usize - 1)) / usize::BITS as usize;
     }
 
     pub unsafe fn init(&self) {
@@ -28,14 +28,20 @@ impl BitRel {
             idl_trap_with("BitRel invalid fields");
         };
 
-        let bytes = ((self.end as usize) - (self.ptr as usize)) as u32;
+        let bytes = (self.end as usize) - (self.ptr as usize);
         if bytes != BitRel::words(self.size1, self.size2) * WORD_SIZE {
             idl_trap_with("BitRel missized");
         };
         memzero(self.ptr as usize, Words(bytes / WORD_SIZE));
     }
 
-    unsafe fn locate_ptr_bit(&self, p: bool, i_j: u32, j_i: u32, bit: u32) -> (*mut u32, u32) {
+    unsafe fn locate_ptr_bit(
+        &self,
+        p: bool,
+        i_j: usize,
+        j_i: usize,
+        bit: usize,
+    ) -> (*mut usize, usize) {
         let size1 = self.size1;
         let size2 = self.size2;
         let (base, i, j) = if p { (0, i_j, j_i) } else { (size1, j_i, i_j) };
@@ -43,8 +49,8 @@ impl BitRel {
         debug_assert!(j < size2);
         debug_assert!(bit < BITS);
         let k = ((base + i) * size2 + j) * BITS + bit;
-        let word = (k / usize::BITS) as usize;
-        let bit = (k % usize::BITS) as u32;
+        let word = k / (usize::BITS as usize);
+        let bit = k % (usize::BITS as usize);
         let ptr = self.ptr.add(word);
         if ptr > self.end {
             idl_trap_with("BitRel indices out of bounds");
@@ -52,7 +58,7 @@ impl BitRel {
         return (ptr, bit);
     }
 
-    unsafe fn set(&self, p: bool, i_j: u32, j_i: u32, bit: u32, v: bool) {
+    unsafe fn set(&self, p: bool, i_j: usize, j_i: usize, bit: usize, v: bool) {
         let (ptr, bit) = self.locate_ptr_bit(p, i_j, j_i, bit);
         if v {
             *ptr = *ptr | (1 << bit);
@@ -61,32 +67,32 @@ impl BitRel {
         }
     }
 
-    unsafe fn get(&self, p: bool, i_j: u32, j_i: u32, bit: u32) -> bool {
+    unsafe fn get(&self, p: bool, i_j: usize, j_i: usize, bit: usize) -> bool {
         let (ptr, bit) = self.locate_ptr_bit(p, i_j, j_i, bit);
         let mask = 1 << bit;
         return *ptr & mask == mask;
     }
 
-    pub unsafe fn visited(&self, p: bool, i_j: u32, j_i: u32) -> bool {
+    pub unsafe fn visited(&self, p: bool, i_j: usize, j_i: usize) -> bool {
         self.get(p, i_j, j_i, 0)
     }
 
-    pub unsafe fn visit(&self, p: bool, i_j: u32, j_i: u32) {
+    pub unsafe fn visit(&self, p: bool, i_j: usize, j_i: usize) {
         self.set(p, i_j, j_i, 0, true)
     }
 
     #[allow(dead_code)]
     // NB: we store related bits in negated form to avoid setting on assumption
     // This code is a nop in production code.
-    pub unsafe fn assume(&self, p: bool, i_j: u32, j_i: u32) {
+    pub unsafe fn assume(&self, p: bool, i_j: usize, j_i: usize) {
         debug_assert!(!self.get(p, i_j, j_i, 1));
     }
 
-    pub unsafe fn related(&self, p: bool, i_j: u32, j_i: u32) -> bool {
+    pub unsafe fn related(&self, p: bool, i_j: usize, j_i: usize) -> bool {
         !self.get(p, i_j, j_i, 1)
     }
 
-    pub unsafe fn disprove(&self, p: bool, i_j: u32, j_i: u32) {
+    pub unsafe fn disprove(&self, p: bool, i_j: usize, j_i: usize) {
         self.set(p, i_j, j_i, 1, true)
     }
 }
diff --git a/rts/motoko-rts/src/blob_iter.rs b/rts/motoko-rts/src/blob_iter.rs
index 2e23e38f9ba..85f9ea94b7a 100644
--- a/rts/motoko-rts/src/blob_iter.rs
+++ b/rts/motoko-rts/src/blob_iter.rs
@@ -6,9 +6,9 @@ use crate::{
 
 use motoko_rts_macros::ic_mem_fn;
 
-const ITER_BLOB_IDX: u32 = 0;
+const ITER_BLOB_IDX: usize = 0;
 
-const ITER_POS_IDX: u32 = 1;
+const ITER_POS_IDX: usize = 1;
 
 /// Returns iterator for the given blob
 #[ic_mem_fn]
@@ -29,7 +29,7 @@ unsafe fn blob_iter<M: crate::memory::Memory>(mem: &mut M, blob: Value) -> Value
 
 /// Returns whether the iterator is finished
 #[no_mangle]
-unsafe extern "C" fn blob_iter_done(iter: Value) -> u32 {
+unsafe extern "C" fn blob_iter_done(iter: Value) -> usize {
     let iter_array = iter.as_array();
 
     let blob = iter_array.get(ITER_BLOB_IDX);
@@ -40,7 +40,7 @@ unsafe extern "C" fn blob_iter_done(iter: Value) -> u32 {
 
 /// Reads next byte, advances the iterator
 #[ic_mem_fn]
-unsafe fn blob_iter_next<M: Memory>(mem: &mut M, iter: Value) -> u32 {
+unsafe fn blob_iter_next<M: Memory>(mem: &mut M, iter: Value) -> usize {
     let iter_array = iter.as_array();
 
     let blob = iter_array.get(ITER_BLOB_IDX);
diff --git a/rts/motoko-rts/src/buf.rs b/rts/motoko-rts/src/buf.rs
index c0867ac6d0d..40872b1682d 100644
--- a/rts/motoko-rts/src/buf.rs
+++ b/rts/motoko-rts/src/buf.rs
@@ -12,7 +12,7 @@ pub struct Buf {
 
 impl Buf {
     #[cfg(feature = "ic")]
-    pub(crate) unsafe fn advance(self: *mut Self, n: u32) {
+    pub(crate) unsafe fn advance(self: *mut Self, n: usize) {
         advance(self, n)
     }
 }
@@ -32,25 +32,30 @@ pub(crate) unsafe fn read_byte(buf: *mut Buf) -> u8 {
 #[cfg(feature = "ic")]
 /// Read a little-endian word
 pub(crate) unsafe fn read_word(buf: *mut Buf) -> u32 {
-    if (*buf).ptr.add(3) >= (*buf).end {
+    // IDL buffer is still 32-bit-based.
+    const WORD_SIZE: usize = core::mem::size_of::<u32>();
+
+    if (*buf).ptr.add(WORD_SIZE - 1) >= (*buf).end {
         idl_trap_with("word read out of buffer");
     }
 
     let p = (*buf).ptr;
-    let word = u32::from_le_bytes([*p, *p.add(1), *p.add(2), *p.add(3)]);
 
-    (*buf).ptr = (*buf).ptr.add(4);
+    let bytes: [u8; WORD_SIZE] = core::array::from_fn(|count| *p.add(count));
+    let word = u32::from_le_bytes(bytes);
+
+    (*buf).ptr = (*buf).ptr.add(WORD_SIZE);
 
     word
 }
 
 #[cfg(feature = "ic")]
-unsafe fn advance(buf: *mut Buf, n: u32) {
-    if (*buf).ptr.add(n as usize) > (*buf).end {
+unsafe fn advance(buf: *mut Buf, n: usize) {
+    if (*buf).ptr.add(n) > (*buf).end {
         idl_trap_with("advance out of buffer");
     }
 
-    (*buf).ptr = (*buf).ptr.add(n as usize);
+    (*buf).ptr = (*buf).ptr.add(n);
 }
 
 /// Can also be used for sleb
diff --git a/rts/motoko-rts/src/constants.rs b/rts/motoko-rts/src/constants.rs
index 327fe3f251c..3afd682d8c1 100644
--- a/rts/motoko-rts/src/constants.rs
+++ b/rts/motoko-rts/src/constants.rs
@@ -1,23 +1,27 @@
-use crate::types::{Bytes, Words};
+use motoko_rts_macros::classical_persistence;
 
-/// Wasm word size. RTS only works correctly on platforms with this word size.
-pub const WORD_SIZE: u32 = 4;
+use crate::types::Bytes;
 
-/// Maximum Motoko array size 2^29 (inclusive)
-/// NB: Must agree with Arr.max_array_size in compile.ml.
-pub const MAX_ARRAY_SIZE: u32 = 1 << 29;
+/// Wasm word size. RTS only works correctly on platforms with this word size.
+pub const WORD_SIZE: usize = core::mem::size_of::<usize>();
 
 /// Wasm page size (64 KiB) in bytes
-pub const WASM_PAGE_SIZE: Bytes<u32> = Bytes(64 * 1024);
-
-/// Wasm heap size (4 GiB) in words. Note that `to_bytes` on this value will overflow as 4 GiB in
-/// bytes is `u32::MAX + 1`.
-pub const WASM_HEAP_SIZE: Words<u32> = Words(1024 * 1024 * 1024);
-
-/// Wasm memory size (4 GiB) in bytes. Note: Represented as `u64` in order not to overflow.
-pub const WASM_MEMORY_BYTE_SIZE: Bytes<u64> = Bytes(4 * 1024 * 1024 * 1024);
+pub const WASM_PAGE_SIZE: Bytes<usize> = Bytes(64 * KB);
 
 /// Byte constants
 pub const KB: usize = 1024;
 pub const MB: usize = 1024 * KB;
 pub const GB: usize = 1024 * MB;
+
+#[classical_persistence]
+use crate::types::Words;
+
+/// Wasm 32-bit heap size (4 GiB) in words.
+/// Note that `to_bytes` on this value will overflow as 4 GiB in bytes is `u32::MAX + 1`.
+#[classical_persistence]
+pub const WASM32_HEAP_SIZE: Words<usize> = Words(1024 * 1024 * 1024);
+
+// The optimized array iterator requires array lengths to fit in signed compact numbers.
+// See `compile_enhanced.ml`, `GetPastArrayOffset`.
+// Two bits reserved: Two for Int tag (0b10L) and one for the sign bit.
+pub const MAX_ARRAY_LENGTH_FOR_ITERATOR: usize = 1 << (usize::BITS as usize - 3);
diff --git a/rts/motoko-rts/src/continuation_table.rs b/rts/motoko-rts/src/continuation_table.rs
index e53eebd9bb0..6f9ee486695 100644
--- a/rts/motoko-rts/src/continuation_table.rs
+++ b/rts/motoko-rts/src/continuation_table.rs
@@ -6,7 +6,7 @@
 //!
 //! It needs to support the following operations
 //!
-//!  1. Adding a continuation (any heap pointer) and getting an index (i32)
+//!  1. Adding a continuation (any heap pointer) and getting an index (usize)
 //!  2. Looking up a continuation by index, which also frees it
 //!  3. Peek into an existing continuation and hand back additional data
 //!  4. GC must be able to traverse and move continuations in the table
@@ -34,7 +34,7 @@ use crate::types::{Value, TAG_ARRAY_M};
 
 use motoko_rts_macros::ic_mem_fn;
 
-const INITIAL_SIZE: u32 = 256;
+const INITIAL_SIZE: usize = 256;
 
 // The static variables are re-initialized on canister upgrades and therefore not part of the
 // persistent metadata.
@@ -44,10 +44,10 @@ const INITIAL_SIZE: u32 = 256;
 static mut TABLE: Value = Value::from_scalar(0);
 
 // Number of currently live continuations
-static mut N_CONTINUATIONS: u32 = 0;
+static mut N_CONTINUATIONS: usize = 0;
 
 // Next free slot
-static mut FREE_SLOT: u32 = 0;
+static mut FREE_SLOT: usize = 0;
 
 unsafe fn create_continuation_table<M: Memory>(mem: &mut M) {
     TABLE = alloc_array(mem, TAG_ARRAY_M, INITIAL_SIZE);
@@ -91,7 +91,7 @@ pub unsafe fn table_initialized() -> bool {
 }
 
 #[ic_mem_fn]
-pub unsafe fn remember_continuation<M: Memory>(mem: &mut M, ptr: Value) -> u32 {
+pub unsafe fn remember_continuation<M: Memory>(mem: &mut M, ptr: Value) -> usize {
     if !table_initialized() {
         create_continuation_table(mem);
     }
@@ -120,10 +120,10 @@ pub unsafe fn remember_continuation<M: Memory>(mem: &mut M, ptr: Value) -> u32 {
 
 // Position of the future in explicit self-send ContinuationTable entries
 // Invariant: keep this synchronised with compiler.ml (see future_array_index)
-const FUTURE_ARRAY_INDEX: u32 = 3;
+const FUTURE_ARRAY_INDEX: usize = 3;
 
 #[no_mangle]
-pub unsafe extern "C" fn peek_future_continuation(idx: u32) -> Value {
+pub unsafe extern "C" fn peek_future_continuation(idx: usize) -> Value {
     if !table_initialized() {
         rts_trap_with("peek_future_continuation: Continuation table not allocated");
     }
@@ -142,7 +142,7 @@ pub unsafe extern "C" fn peek_future_continuation(idx: u32) -> Value {
 }
 
 #[ic_mem_fn]
-pub unsafe fn recall_continuation<M: Memory>(mem: &mut M, idx: u32) -> Value {
+pub unsafe fn recall_continuation<M: Memory>(mem: &mut M, idx: usize) -> Value {
     if !table_initialized() {
         rts_trap_with("recall_continuation: Continuation table not allocated");
     }
@@ -169,7 +169,7 @@ pub unsafe fn recall_continuation<M: Memory>(mem: &mut M, idx: u32) -> Value {
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn continuation_count() -> u32 {
+pub unsafe extern "C" fn continuation_count() -> usize {
     N_CONTINUATIONS
 }
 
@@ -180,7 +180,7 @@ pub(crate) unsafe fn continuation_table_loc() -> *mut Value {
 
 #[cfg(feature = "ic")]
 #[no_mangle]
-unsafe extern "C" fn continuation_table_size() -> u32 {
+unsafe extern "C" fn continuation_table_size() -> usize {
     if !table_initialized() {
         0
     } else {
diff --git a/rts/motoko-rts/src/debug.rs b/rts/motoko-rts/src/debug.rs
index b60f136b051..9b0b2c4373c 100644
--- a/rts/motoko-rts/src/debug.rs
+++ b/rts/motoko-rts/src/debug.rs
@@ -1,5 +1,8 @@
 #![allow(dead_code)]
 
+use motoko_rts_macros::classical_persistence;
+use motoko_rts_macros::enhanced_orthogonal_persistence;
+
 use crate::print::*;
 use crate::types::*;
 
@@ -21,8 +24,8 @@ pub unsafe extern "C" fn print_value(value: Value) {
 }
 
 pub unsafe fn dump_heap(
-    heap_base: u32,
-    hp: u32,
+    heap_base: usize,
+    hp: usize,
     static_root_location: *mut Value,
     continuation_table_location: *mut Value,
 ) {
@@ -52,7 +55,7 @@ pub(crate) unsafe fn print_continuation_table(continuation_tbl_loc: *mut Value)
 
     for i in 0..len {
         let elem = arr.get(i);
-        if elem.is_non_null_ptr() {
+        if is_valid_pointer(elem) {
             let _ = write!(&mut write_buf, "{}: ", i);
             print_boxed_object(&mut write_buf, elem.get_ptr());
             print(&write_buf);
@@ -62,6 +65,16 @@ pub(crate) unsafe fn print_continuation_table(continuation_tbl_loc: *mut Value)
     println!(50, "End of continuation table");
 }
 
+#[classical_persistence]
+fn is_valid_pointer(value: Value) -> bool {
+    value.is_ptr()
+}
+
+#[enhanced_orthogonal_persistence]
+fn is_valid_pointer(value: Value) -> bool {
+    value.is_non_null_ptr()
+}
+
 pub(crate) unsafe fn print_static_roots(static_roots: Value) {
     let static_roots = static_roots.as_array();
     println!(100, "static roots at {:#x}", static_roots as usize);
@@ -80,7 +93,7 @@ pub(crate) unsafe fn print_static_roots(static_roots: Value) {
 
     let payload_addr = static_roots.payload_addr();
     for i in 0..len {
-        let field_addr = payload_addr.add(i as usize);
+        let field_addr = payload_addr.add(i);
         let _ = write!(&mut write_buf, "{}: {:#x} --> ", i, field_addr as usize);
         print_boxed_object(&mut write_buf, (*field_addr).get_ptr());
         print(&write_buf);
@@ -90,7 +103,7 @@ pub(crate) unsafe fn print_static_roots(static_roots: Value) {
     println!(50, "End of static roots");
 }
 
-unsafe fn print_heap(heap_start: u32, heap_end: u32) {
+unsafe fn print_heap(heap_start: usize, heap_end: usize) {
     println!(
         200,
         "Heap start={:#x}, heap end={:#x}, size={} bytes",
@@ -103,19 +116,19 @@ unsafe fn print_heap(heap_start: u32, heap_end: u32) {
     let mut write_buf = WriteBuf::new(&mut buf);
 
     let mut p = heap_start;
-    let mut i: Words<u32> = Words(0);
+    let mut i: Words<usize> = Words(0);
     while p < heap_end {
-        print_boxed_object(&mut write_buf, p as usize);
+        print_boxed_object(&mut write_buf, p);
         print(&write_buf);
         write_buf.reset();
 
-        let obj_size = block_size(p as usize);
-        p += obj_size.to_bytes().as_u32();
+        let obj_size = block_size(p);
+        p += obj_size.to_bytes().as_usize();
         i += obj_size;
     }
 }
 
-unsafe fn print_tagged_scalar(buf: &mut WriteBuf, p: u32) {
+unsafe fn print_tagged_scalar(buf: &mut WriteBuf, p: usize) {
     let _ = write!(buf, "<Scalar {:#x}>", p);
 }
 
@@ -123,13 +136,13 @@ unsafe fn print_tagged_scalar(buf: &mut WriteBuf, p: u32) {
 pub(crate) unsafe fn print_boxed_object(buf: &mut WriteBuf, p: usize) {
     let _ = write!(buf, "{:#x}: ", p);
 
-    let obj = p as *mut Obj;
-    let forward = (*obj).forward;
+    let forward = (*(p as *mut Value)).forward();
     if forward.get_ptr() != p {
         let _ = write!(buf, "<forwarded to {:#x}>", forward.get_ptr());
         return;
     }
 
+    let obj = p as *mut Obj;
     let tag = obj.tag();
 
     if tag == 0 {
@@ -143,7 +156,7 @@ pub(crate) unsafe fn print_boxed_object(buf: &mut WriteBuf, p: usize) {
                 buf,
                 "<Object size={:#x} hash_ptr={:#x} field=[",
                 object.size(),
-                (*object).hash_blob.get_raw()
+                get_obj_hash_pointer(object),
             );
             for i in 0..object.size() {
                 let val = object.get(i);
@@ -202,16 +215,12 @@ pub(crate) unsafe fn print_boxed_object(buf: &mut WriteBuf, p: usize) {
         }
         TAG_BLOB_B | TAG_BLOB_T | TAG_BLOB_P | TAG_BLOB_A => {
             let blob = obj.as_blob();
-            let _ = write!(buf, "<Blob len={:#x}>", blob.len().as_u32());
+            let _ = write!(buf, "<Blob len={:#x}>", blob.len().as_usize());
         }
         TAG_FWD_PTR => {
             let ind = obj as *const FwdPtr;
             let _ = write!(buf, "<Forwarding to {:#x}>", (*ind).fwd.get_raw());
         }
-        TAG_BITS32_U | TAG_BITS32_S | TAG_BITS32_F => {
-            let bits32 = obj as *const Bits32;
-            let _ = write!(buf, "<Bits32 {:#x}>", (*bits32).bits);
-        }
         TAG_BIGINT => {
             // Add more details here as needed
             let _ = write!(buf, "<BigInt>");
@@ -221,7 +230,7 @@ pub(crate) unsafe fn print_boxed_object(buf: &mut WriteBuf, p: usize) {
             let _ = write!(
                 buf,
                 "<Concat n_bytes={:#x} obj1={:#x} obj2={:#x}>",
-                (*concat).n_bytes.as_u32(),
+                (*concat).n_bytes.as_usize(),
                 (*concat).text1.get_raw(),
                 (*concat).text2.get_raw()
             );
@@ -231,10 +240,20 @@ pub(crate) unsafe fn print_boxed_object(buf: &mut WriteBuf, p: usize) {
         }
         TAG_FREE_SPACE => {
             let free_space = obj as *const FreeSpace;
-            let _ = write!(buf, "<Free space {} words>", (*free_space).words.as_u32());
+            let _ = write!(buf, "<Free space {} words>", (*free_space).words.as_usize());
         }
         other => {
             let _ = write!(buf, "<??? {} ???>", other);
         }
     }
 }
+
+#[classical_persistence]
+unsafe fn get_obj_hash_pointer(object: *mut Object) -> usize {
+    (*object).hash_ptr
+}
+
+#[enhanced_orthogonal_persistence]
+unsafe fn get_obj_hash_pointer(object: *mut Object) -> usize {
+    (*object).hash_blob.get_raw()
+}
diff --git a/rts/motoko-rts/src/float.rs b/rts/motoko-rts/src/float.rs
index 644823e4a15..0fee1086138 100644
--- a/rts/motoko-rts/src/float.rs
+++ b/rts/motoko-rts/src/float.rs
@@ -1,38 +1,7 @@
-use crate::memory::Memory;
-use crate::text::text_of_ptr_size;
-use crate::types::{Bytes, Value};
+#[enhanced_orthogonal_persistence]
+pub mod enhanced;
 
-use motoko_rts_macros::ic_mem_fn;
+#[classical_persistence]
+pub mod classical;
 
-// The meaning of the `mode` parameter is documented in motoko-base, function Float.format()
-#[ic_mem_fn]
-unsafe fn float_fmt<M: Memory>(mem: &mut M, a: f64, prec: u32, mode: u32) -> Value {
-    // prec and mode are tagged small words (`Nat8`s), so we shift 24 bits. See
-    // `TaggedSmallWord.bits_of_type` in compile.ml.
-    let mode = mode >> 24;
-    let prec = core::cmp::min(prec >> 24, 100) as usize;
-
-    // 320 bytes needed for max precision (1.7e308)
-    let buf = [0u8; 320];
-
-    // NB. Using snprintf because I think only 0 and 3 are supposed by Rust's built-in formatter
-    let fmt = match mode {
-        0 => "%.*f\0",
-        1 => "%.*e\0",
-        2 => "%.*g\0",
-        3 => "%.*a\0",
-        _ => panic!("float_fmt: unrecognized mode"),
-    };
-
-    let n_written = libc::snprintf(
-        buf.as_ptr() as *mut _,
-        320,
-        fmt.as_ptr() as *const _,
-        prec,
-        a as libc::c_double,
-    );
-
-    assert!(n_written > 0);
-
-    text_of_ptr_size(mem, buf.as_ptr(), Bytes(n_written as u32))
-}
+use motoko_rts_macros::{classical_persistence, enhanced_orthogonal_persistence};
diff --git a/rts/motoko-rts/src/float/classical.rs b/rts/motoko-rts/src/float/classical.rs
new file mode 100644
index 00000000000..1ea8ce8ccb7
--- /dev/null
+++ b/rts/motoko-rts/src/float/classical.rs
@@ -0,0 +1,39 @@
+use crate::libc_declarations::c_double;
+use crate::memory::Memory;
+use crate::text::text_of_ptr_size;
+use crate::types::{Bytes, Value};
+
+use motoko_rts_macros::ic_mem_fn;
+
+// The meaning of the `mode` parameter is documented in motoko-base, function Float.format()
+#[ic_mem_fn]
+unsafe fn float_fmt<M: Memory>(mem: &mut M, a: f64, prec: u32, mode: u32) -> Value {
+    // prec and mode are tagged small words (`Nat8`s), so we shift 24 bits. See
+    // `TaggedSmallWord.bits_of_type` in compile.ml.
+    let mode = mode >> 24;
+    let prec = core::cmp::min(prec >> 24, 100) as usize;
+
+    // 320 bytes needed for max precision (1.7e308)
+    let buf = [0u8; 320];
+
+    // NB. Using snprintf because I think only 0 and 3 are supposed by Rust's built-in formatter
+    let fmt = match mode {
+        0 => "%.*f\0",
+        1 => "%.*e\0",
+        2 => "%.*g\0",
+        3 => "%.*a\0",
+        _ => panic!("float_fmt: unrecognized mode"),
+    };
+
+    let n_written = libc::snprintf(
+        buf.as_ptr() as *mut _,
+        320,
+        fmt.as_ptr() as *const _,
+        prec,
+        a as c_double,
+    );
+
+    assert!(n_written > 0);
+
+    text_of_ptr_size(mem, buf.as_ptr(), Bytes(n_written as usize))
+}
diff --git a/rts/motoko-rts/src/float/enhanced.rs b/rts/motoko-rts/src/float/enhanced.rs
new file mode 100644
index 00000000000..9055880fb83
--- /dev/null
+++ b/rts/motoko-rts/src/float/enhanced.rs
@@ -0,0 +1,39 @@
+use crate::memory::Memory;
+use crate::text::text_of_ptr_size;
+use crate::types::{Bytes, Value};
+
+use motoko_rts_macros::ic_mem_fn;
+
+// The meaning of the `mode` parameter is documented in motoko-base, function Float.format()
+#[ic_mem_fn]
+pub unsafe fn float_fmt<M: Memory>(mem: &mut M, a: f64, prec: usize, mode: usize) -> Value {
+    // prec and mode are tagged small words (`Nat8`s), so we shift 56 bits. See
+    // `TaggedSmallWord.bits_of_type` in compile.ml.
+    let mode = mode >> 56;
+    let prec = core::cmp::min(prec >> 56, 100) as usize;
+
+    // 320 bytes needed for max precision (1.7e308)
+    const BUFFER_LENGTH: usize = 320;
+    let buffer = match mode {
+        0 => format!(BUFFER_LENGTH, "{:.*}", prec, a),
+        1 => format!(BUFFER_LENGTH, "{:.*e}", prec, a),
+        2 => format!(BUFFER_LENGTH, "{:.*}", prec, a),
+        3 => panic!("float_fmt: unsupported mode"), // TODO: Support this mode (or deprecate in base library).
+        4 => format!(BUFFER_LENGTH, "{}", a),
+        _ => panic!("float_fmt: unrecognized mode"),
+    };
+
+    // TODO: Certain modes are not supported such as hexadecimal output (mode 3).
+
+    let length = written_length(&buffer);
+    text_of_ptr_size(mem, buffer.as_ptr(), Bytes(length))
+}
+
+fn written_length(buffer: &[u8]) -> usize {
+    for index in 0..buffer.len() {
+        if buffer[index] == 0 {
+            return index;
+        }
+    }
+    buffer.len()
+}
diff --git a/rts/motoko-rts/src/gc.rs b/rts/motoko-rts/src/gc.rs
index a2b3e2acd74..31663df866f 100644
--- a/rts/motoko-rts/src/gc.rs
+++ b/rts/motoko-rts/src/gc.rs
@@ -1 +1,28 @@
+#[non_incremental_gc]
+pub mod copying;
+#[non_incremental_gc]
+pub mod generational;
+#[incremental_gc]
 pub mod incremental;
+#[non_incremental_gc]
+pub mod mark_compact;
+
+pub mod remembered_set;
+
+use motoko_rts_macros::*;
+
+#[cfg(feature = "ic")]
+#[non_incremental_gc]
+unsafe fn should_do_gc(max_live: crate::types::Bytes<u64>) -> bool {
+    use crate::memory::ic::linear_memory::{get_hp_unskewed, LAST_HP};
+
+    // A factor of last heap size. We allow at most this much allocation before doing GC.
+    const HEAP_GROWTH_FACTOR: f64 = 1.5;
+
+    let heap_limit = core::cmp::min(
+        (f64::from(LAST_HP as u32) * HEAP_GROWTH_FACTOR) as u64,
+        (u64::from(LAST_HP as u32) + max_live.0) / 2,
+    );
+
+    u64::from(get_hp_unskewed() as u32) >= heap_limit
+}
diff --git a/rts/motoko-rts/src/gc/copying.rs b/rts/motoko-rts/src/gc/copying.rs
new file mode 100644
index 00000000000..378dfada791
--- /dev/null
+++ b/rts/motoko-rts/src/gc/copying.rs
@@ -0,0 +1,229 @@
+use crate::constants::WORD_SIZE;
+use crate::mem_utils::{memcpy_bytes, memcpy_words};
+use crate::memory::Memory;
+use crate::types::*;
+
+use motoko_rts_macros::ic_mem_fn;
+
+// Only designed for 32-bit.
+const _: () = assert!(core::mem::size_of::<usize>() == core::mem::size_of::<u32>());
+
+#[no_mangle]
+#[cfg(feature = "ic")]
+pub unsafe extern "C" fn initialize_copying_gc() {
+    crate::memory::ic::linear_memory::initialize();
+}
+
+#[ic_mem_fn(ic_only)]
+unsafe fn schedule_copying_gc<M: Memory>(mem: &mut M) {
+    // Half of the heap.
+    // NB. This expression is evaluated in compile time to a constant.
+    let max_live: Bytes<u64> =
+        Bytes((crate::constants::WASM32_HEAP_SIZE / 2).as_usize() as u64 * WORD_SIZE as u64);
+
+    if super::should_do_gc(max_live) {
+        copying_gc(mem);
+    }
+}
+
+#[ic_mem_fn(ic_only)]
+unsafe fn copying_gc<M: Memory>(mem: &mut M) {
+    use crate::memory::ic::{self, linear_memory};
+
+    copying_gc_internal(
+        mem,
+        ic::get_aligned_heap_base(),
+        // get_hp
+        || linear_memory::get_hp_unskewed(),
+        // set_hp
+        |hp| linear_memory::set_hp_unskewed(hp),
+        ic::get_static_roots(),
+        crate::continuation_table::continuation_table_loc(),
+        crate::region::region0_get_ptr_loc(),
+        // note_live_size
+        |live_size| linear_memory::MAX_LIVE = ::core::cmp::max(linear_memory::MAX_LIVE, live_size),
+        // note_reclaimed
+        |reclaimed| linear_memory::RECLAIMED += Bytes(reclaimed.as_usize() as u64),
+    );
+
+    linear_memory::LAST_HP = linear_memory::get_hp_unskewed();
+}
+
+pub unsafe fn copying_gc_internal<
+    M: Memory,
+    GetHp: Fn() -> usize,
+    SetHp: FnMut(usize),
+    NoteLiveSize: Fn(Bytes<usize>),
+    NoteReclaimed: Fn(Bytes<usize>),
+>(
+    mem: &mut M,
+    heap_base: usize,
+    get_hp: GetHp,
+    mut set_hp: SetHp,
+    static_roots: Value,
+    continuation_table_ptr_loc: *mut Value,
+    region0_ptr_loc: *mut Value,
+    note_live_size: NoteLiveSize,
+    note_reclaimed: NoteReclaimed,
+) {
+    let begin_from_space = heap_base as usize;
+    let end_from_space = get_hp();
+    let begin_to_space = end_from_space;
+
+    let static_roots = static_roots.as_array();
+
+    // Evacuate roots
+    evac_static_roots(mem, begin_from_space, begin_to_space, static_roots);
+
+    if (*continuation_table_ptr_loc).is_ptr() {
+        evac(
+            mem,
+            begin_from_space,
+            begin_to_space,
+            continuation_table_ptr_loc as usize,
+        );
+    }
+
+    if (*region0_ptr_loc).is_ptr() {
+        // Region0 is not always a pointer during GC?
+        evac(
+            mem,
+            begin_from_space,
+            begin_to_space,
+            region0_ptr_loc as usize,
+        );
+    }
+
+    // Scavenge to-space
+    let mut p = begin_to_space;
+    while p < get_hp() {
+        let size = block_size(p);
+        scav(mem, begin_from_space, begin_to_space, Value::from_ptr(p));
+        p += size.to_bytes().as_usize();
+    }
+
+    let end_to_space = get_hp();
+
+    // Note the stats
+    let new_live_size = end_to_space - begin_to_space;
+    note_live_size(Bytes(new_live_size));
+
+    let reclaimed = (end_from_space - begin_from_space) - (end_to_space - begin_to_space);
+    note_reclaimed(Bytes(reclaimed));
+
+    // Copy to-space to the beginning of from-space
+    memcpy_bytes(
+        begin_from_space,
+        begin_to_space,
+        Bytes(end_to_space - begin_to_space),
+    );
+
+    // Reset the heap pointer
+    let new_hp = begin_from_space + (end_to_space - begin_to_space);
+    set_hp(new_hp);
+}
+
+/// Evacuate (copy) an object in from-space to to-space.
+///
+/// Arguments:
+///
+/// - begin_from_space: Where the dynamic heap starts. Used for two things:
+///
+///   - An object is static if its address is below this value. These objects either don't point to
+///     dynamic heap, or are listed in static_roots array. Objects in static_roots are scavenged
+///     separately in `evac_static_roots` below. So we skip these objects here.
+///
+///   - After all objects are evacuated we move to-space to from-space, to be able to do that the
+///     pointers need to point to their (eventual) locations in from-space, which is calculated with
+///     `address_in_to_space - begin_to_space + begin_from_space`.
+///
+/// - begin_to_space: Where to-space starts. See above for how this is used.
+///
+/// - ptr_loc: Location of the object to evacuate, e.g. an object field address.
+///
+unsafe fn evac<M: Memory>(
+    mem: &mut M,
+    begin_from_space: usize,
+    begin_to_space: usize,
+    ptr_loc: usize,
+) {
+    // Field holds a skewed pointer to the object to evacuate
+    let ptr_loc = ptr_loc as *mut Value;
+
+    // Check object alignment to avoid undefined behavior. See also static_checks module.
+    debug_assert_eq!((*ptr_loc).get_ptr() % WORD_SIZE, 0);
+
+    // Update the field if the object is already evacuated
+    if (*ptr_loc).tag() == TAG_FWD_PTR {
+        let block = (*ptr_loc).get_ptr() as *const FwdPtr;
+        let fwd = (*block).fwd;
+        *ptr_loc = fwd;
+        return;
+    }
+
+    let obj = (*ptr_loc).get_ptr() as *mut Obj;
+
+    let obj_size = block_size(obj as usize);
+
+    // Allocate space in to-space for the object
+    let obj_addr = mem.alloc_words(obj_size).get_ptr();
+
+    // Copy object to to-space
+    memcpy_words(obj_addr, obj as usize, obj_size);
+
+    // Final location of the object after copying to-space back to from-space
+    let obj_loc = (obj_addr - begin_to_space) + begin_from_space;
+
+    // Set forwarding pointer
+    let fwd = obj as *mut FwdPtr;
+    (*fwd).tag = TAG_FWD_PTR;
+    (*fwd).fwd = Value::from_ptr(obj_loc);
+
+    // Update evacuated field
+    *ptr_loc = Value::from_ptr(obj_loc);
+
+    // Update forwarding pointer
+    let to_space_obj = obj_addr as *mut Obj;
+    debug_assert!(obj_size.as_usize() > size_of::<Obj>().as_usize());
+    debug_assert!(to_space_obj.tag() >= TAG_OBJECT && to_space_obj.tag() <= TAG_NULL);
+}
+
+unsafe fn scav<M: Memory>(
+    mem: &mut M,
+    begin_from_space: usize,
+    begin_to_space: usize,
+    block: Value,
+) {
+    if !block.is_obj() {
+        // Skip `OneWordFiller` and `FreeSpace` that have no regular object header.
+        return;
+    }
+    let obj = block.get_ptr() as *mut Obj;
+
+    crate::visitor::visit_pointer_fields(
+        mem,
+        obj,
+        obj.tag(),
+        begin_from_space,
+        |mem, field_addr| {
+            evac(mem, begin_from_space, begin_to_space, field_addr as usize);
+        },
+        |_, _, arr| arr.len(),
+    );
+}
+
+// We have a special evacuation routine for "static roots" array: we don't evacuate elements of
+// "static roots", we just scavenge them.
+unsafe fn evac_static_roots<M: Memory>(
+    mem: &mut M,
+    begin_from_space: usize,
+    begin_to_space: usize,
+    roots: *mut Array,
+) {
+    // The array and the objects pointed by the array are all static so we don't evacuate them. We
+    // only evacuate fields of objects in the array.
+    for i in 0..roots.len() {
+        let obj = roots.get(i);
+        scav(mem, begin_from_space, begin_to_space, obj);
+    }
+}
diff --git a/rts/motoko-rts/src/gc/generational.rs b/rts/motoko-rts/src/gc/generational.rs
new file mode 100644
index 00000000000..abe23ae3fa7
--- /dev/null
+++ b/rts/motoko-rts/src/gc/generational.rs
@@ -0,0 +1,531 @@
+//! Generational compacting GC.
+//! Two generations: young and old.
+//! Frequent collection of young generation, sporadic full collection (old + young).
+//! Young generation collection requires an extra root set of old-to-young pointers.
+//! A write barrier catches all pointers leading from old to young generation.
+//! Compaction is based on the existing Motoko RTS threaded mark & compact GC.
+
+pub mod mark_stack;
+#[cfg(feature = "memory_check")]
+mod sanity_checks;
+pub mod write_barrier;
+
+use crate::gc::generational::mark_stack::{alloc_mark_stack, push_mark_stack};
+use crate::gc::mark_compact::bitmap::{
+    alloc_bitmap, free_bitmap, get_bit, iter_bits, set_bit, BITMAP_ITER_END,
+};
+
+use crate::constants::WORD_SIZE;
+use crate::mem_utils::memcpy_words;
+use crate::memory::Memory;
+use crate::types::*;
+use crate::visitor::{classical::pointer_to_dynamic_heap, visit_pointer_fields};
+
+use motoko_rts_macros::ic_mem_fn;
+
+use self::mark_stack::{free_mark_stack, pop_mark_stack};
+use self::write_barrier::REMEMBERED_SET;
+
+// Only designed for 32-bit.
+const _: () = assert!(core::mem::size_of::<usize>() == core::mem::size_of::<u32>());
+
+#[ic_mem_fn(ic_only)]
+unsafe fn initialize_generational_gc<M: Memory>(mem: &mut M) {
+    crate::memory::ic::linear_memory::initialize();
+    write_barrier::init_generational_write_barrier(mem);
+}
+
+#[ic_mem_fn(ic_only)]
+unsafe fn schedule_generational_gc<M: Memory>(mem: &mut M) {
+    let limits = get_limits();
+    if decide_strategy(&limits).is_some() {
+        generational_gc(mem);
+    }
+}
+
+#[ic_mem_fn(ic_only)]
+unsafe fn generational_gc<M: Memory>(mem: &mut M) {
+    use crate::memory::ic;
+
+    let old_limits = get_limits();
+    let roots = Roots {
+        static_roots: ic::get_static_roots(),
+        region0_ptr_loc: crate::region::region0_get_ptr_loc(),
+        continuation_table_ptr_loc: crate::continuation_table::continuation_table_loc(),
+    };
+    let heap = Heap {
+        mem,
+        limits: get_limits(),
+        roots,
+    };
+    let strategy = decide_strategy(&heap.limits);
+
+    let strategy = strategy.unwrap_or(Strategy::Young);
+    let mut gc = GenerationalGC::new(heap, strategy);
+
+    #[cfg(feature = "memory_check")]
+    sanity_checks::verify_snapshot(&gc.heap, false);
+
+    gc.run();
+
+    let new_limits = &gc.heap.limits;
+    set_limits(&gc.heap.limits);
+    update_statistics(&old_limits, new_limits);
+    update_strategy(strategy, new_limits);
+
+    #[cfg(feature = "memory_check")]
+    sanity_checks::check_memory(&gc.heap.limits, &gc.heap.roots);
+    #[cfg(feature = "memory_check")]
+    sanity_checks::take_snapshot(&mut gc.heap);
+
+    write_barrier::init_generational_write_barrier(gc.heap.mem);
+}
+
+#[cfg(feature = "ic")]
+unsafe fn get_limits() -> Limits {
+    use crate::memory::ic::{self, linear_memory};
+    assert!(linear_memory::LAST_HP >= ic::get_aligned_heap_base());
+    Limits {
+        base: ic::get_aligned_heap_base(),
+        last_free: linear_memory::LAST_HP,
+        free: (linear_memory::get_hp_unskewed()),
+    }
+}
+
+#[cfg(feature = "ic")]
+unsafe fn set_limits(limits: &Limits) {
+    use crate::memory::ic::linear_memory;
+    linear_memory::set_hp_unskewed(limits.free);
+    linear_memory::LAST_HP = limits.free;
+}
+
+#[cfg(feature = "ic")]
+unsafe fn update_statistics(old_limits: &Limits, new_limits: &Limits) {
+    use crate::memory::ic::linear_memory;
+    let live_size = Bytes(new_limits.free - new_limits.base);
+    linear_memory::MAX_LIVE = ::core::cmp::max(linear_memory::MAX_LIVE, live_size);
+    linear_memory::RECLAIMED += Bytes(old_limits.free as u64 - new_limits.free as u64);
+}
+
+#[derive(PartialEq, Clone, Copy, Debug)]
+pub enum Strategy {
+    Young,
+    Full,
+}
+
+#[cfg(feature = "ic")]
+static mut OLD_GENERATION_THRESHOLD: usize = 32 * 1024 * 1024;
+
+#[cfg(feature = "ic")]
+static mut PASSED_CRITICAL_LIMIT: bool = false;
+
+#[cfg(feature = "ic")]
+const CRITICAL_MEMORY_LIMIT: usize =
+    (4096 - 512) * 1024 * 1024 - crate::memory::GENERAL_MEMORY_RESERVE;
+
+#[cfg(feature = "ic")]
+unsafe fn decide_strategy(limits: &Limits) -> Option<Strategy> {
+    const YOUNG_GENERATION_THRESHOLD: usize = 8 * 1024 * 1024;
+
+    assert!(limits.base <= limits.last_free);
+    let old_generation_size = limits.last_free - limits.base;
+    assert!(limits.last_free <= limits.free);
+    let young_generation_size = limits.free - limits.last_free;
+
+    if limits.free >= CRITICAL_MEMORY_LIMIT && !PASSED_CRITICAL_LIMIT {
+        PASSED_CRITICAL_LIMIT = true;
+        Some(Strategy::Full)
+    } else if old_generation_size > OLD_GENERATION_THRESHOLD {
+        Some(Strategy::Full)
+    } else if young_generation_size > YOUNG_GENERATION_THRESHOLD {
+        Some(Strategy::Young)
+    } else {
+        None
+    }
+}
+
+#[cfg(feature = "ic")]
+unsafe fn update_strategy(strategy: Strategy, limits: &Limits) {
+    const GROWTH_RATE: f64 = 2.0;
+    if strategy == Strategy::Full {
+        OLD_GENERATION_THRESHOLD = ((limits.free - limits.base) as f64 * GROWTH_RATE) as usize;
+        if limits.free < CRITICAL_MEMORY_LIMIT {
+            PASSED_CRITICAL_LIMIT = false
+        }
+    }
+}
+
+pub struct Heap<'a, M: Memory> {
+    pub mem: &'a mut M,
+    pub limits: Limits,
+    pub roots: Roots,
+}
+
+pub struct Roots {
+    pub static_roots: Value,
+    pub continuation_table_ptr_loc: *mut Value,
+    pub region0_ptr_loc: *mut Value,
+    // For possible future additional roots, please extend the functionality in:
+    // * `mark_root_set`
+    // * `thread_initial_phase`
+}
+
+pub struct Limits {
+    pub base: usize,
+    pub last_free: usize, // this separates the old generation from the young generation
+    pub free: usize,
+}
+
+pub struct GenerationalGC<'a, M: Memory> {
+    pub heap: Heap<'a, M>,
+    marked_space: usize,
+    strategy: Strategy,
+}
+
+impl<'a, M: Memory> GenerationalGC<'a, M> {
+    pub fn new(heap: Heap<M>, strategy: Strategy) -> GenerationalGC<M> {
+        GenerationalGC {
+            heap,
+            marked_space: 0,
+            strategy,
+        }
+    }
+
+    pub unsafe fn run(&mut self) {
+        self.alloc_mark_structures();
+        self.mark_phase();
+        self.compact_phase();
+        self.free_mark_structures();
+    }
+
+    unsafe fn alloc_mark_structures(&mut self) {
+        const BITMAP_ALIGNMENT: usize = 8 * WORD_SIZE as usize;
+        let heap_prefix = match self.strategy {
+            Strategy::Young => self.heap.limits.last_free / BITMAP_ALIGNMENT * BITMAP_ALIGNMENT,
+            Strategy::Full => self.heap.limits.base,
+        };
+        let heap_size = Bytes(self.heap.limits.free - heap_prefix);
+        alloc_bitmap(self.heap.mem, heap_size, heap_prefix / WORD_SIZE);
+        alloc_mark_stack(self.heap.mem);
+    }
+
+    unsafe fn free_mark_structures(&mut self) {
+        free_mark_stack();
+        free_bitmap();
+    }
+
+    unsafe fn mark_phase(&mut self) {
+        self.marked_space = 0;
+        self.mark_root_set();
+        self.mark_all_reachable();
+    }
+
+    unsafe fn mark_root_set(&mut self) {
+        self.mark_static_roots();
+
+        let continuation_table = *self.heap.roots.continuation_table_ptr_loc;
+        if continuation_table.is_ptr() && continuation_table.get_ptr() >= self.generation_base() {
+            self.mark_object(continuation_table);
+        }
+
+        let region0 = *self.heap.roots.region0_ptr_loc;
+        if region0.is_ptr() && region0.get_ptr() >= self.generation_base() {
+            self.mark_object(region0);
+        }
+
+        if self.strategy == Strategy::Young {
+            self.mark_additional_young_root_set();
+        }
+    }
+
+    unsafe fn mark_static_roots(&mut self) {
+        let root_array = self.heap.roots.static_roots.as_array();
+        for i in 0..root_array.len() {
+            let object = root_array.get(i).as_obj();
+            assert_eq!(object.tag(), TAG_MUTBOX);
+            assert!((object as usize) < self.heap.limits.base);
+            self.mark_root_mutbox_fields(object as *mut MutBox);
+        }
+    }
+
+    unsafe fn mark_additional_young_root_set(&mut self) {
+        let mut iterator = REMEMBERED_SET.as_ref().unwrap().iterate();
+        while iterator.has_next() {
+            let location = iterator.current().get_raw() as *mut Value;
+            let value = *location;
+            // Check whether the location still refers to young object as this may have changed
+            // due to subsequent writes to that location after the write barrier recording.
+            if value.points_to_or_beyond(self.heap.limits.last_free) {
+                self.mark_object(value);
+            }
+            iterator.next();
+        }
+    }
+
+    unsafe fn mark_object(&mut self, object: Value) {
+        let pointer = object.get_ptr();
+        assert!(pointer >= self.generation_base());
+        assert_eq!(pointer % WORD_SIZE, 0);
+
+        let obj_idx = pointer / WORD_SIZE;
+        if get_bit(obj_idx) {
+            return;
+        }
+        set_bit(obj_idx);
+
+        push_mark_stack(self.heap.mem, pointer as usize);
+        self.marked_space += block_size(pointer as usize).to_bytes().as_usize();
+    }
+
+    unsafe fn mark_all_reachable(&mut self) {
+        while let Some(obj) = pop_mark_stack() {
+            self.mark_fields(obj as *mut Obj);
+        }
+    }
+
+    unsafe fn mark_fields(&mut self, object: *mut Obj) {
+        visit_pointer_fields(
+            self,
+            object,
+            object.tag(),
+            self.generation_base(),
+            |gc, field_address| {
+                let field_value = *field_address;
+                gc.mark_object(field_value);
+
+                // Should become a debug assertion in future.
+                gc.barrier_coverage_check(field_address);
+            },
+            |gc, slice_start, array| {
+                const SLICE_INCREMENT: usize = 255;
+                debug_assert!(SLICE_INCREMENT >= TAG_ARRAY_SLICE_MIN);
+                let base_tag = array.base_tag();
+                if array.len() - slice_start > SLICE_INCREMENT {
+                    let new_start = slice_start + SLICE_INCREMENT;
+                    // Remember to visit the array suffix later, store the next visit offset in the tag.
+                    array.set_slice_start(base_tag, new_start);
+                    push_mark_stack(gc.heap.mem, array as usize);
+                    new_start
+                } else {
+                    // No further visits of this array. Restore the tag.
+                    array.restore_tag(base_tag); // restore original tag
+                    array.len()
+                }
+            },
+        );
+    }
+
+    unsafe fn barrier_coverage_check(&self, field_address: *mut Value) {
+        if self.strategy == Strategy::Full
+            && (field_address as usize) >= self.heap.limits.base
+            && (field_address as usize) < self.heap.limits.last_free
+            && (*field_address).points_to_or_beyond(self.heap.limits.last_free)
+        {
+            assert!(REMEMBERED_SET
+                .as_ref()
+                .unwrap()
+                .contains(Value::from_raw(field_address as usize)));
+        }
+    }
+
+    unsafe fn mark_root_mutbox_fields(&mut self, mutbox: *mut MutBox) {
+        let field_address = &mut (*mutbox).field;
+        if pointer_to_dynamic_heap(field_address, self.generation_base()) {
+            self.mark_object(*field_address);
+        }
+    }
+
+    unsafe fn compact_phase(&mut self) {
+        if self.is_compaction_beneficial() {
+            self.thread_initial_phase();
+            self.move_phase();
+        }
+    }
+
+    fn is_compaction_beneficial(&self) -> bool {
+        // Returns false if the survival rate is f64::INF for an empty generation.
+        const SURVIVAL_THRESHOLD: f64 = 0.95;
+        self.survival_rate() < SURVIVAL_THRESHOLD
+    }
+
+    fn generation_base(&self) -> usize {
+        match self.strategy {
+            Strategy::Young => self.heap.limits.last_free,
+            Strategy::Full => self.heap.limits.base,
+        }
+    }
+
+    fn generation_size(&self) -> usize {
+        self.heap.limits.free - self.generation_base()
+    }
+
+    fn survival_rate(&self) -> f64 {
+        // Returns f64::INF if the generation size is zero, e.g. on forced GC.
+        self.marked_space as f64 / self.generation_size() as f64
+    }
+
+    unsafe fn thread_initial_phase(&mut self) {
+        self.thread_all_backward_pointers();
+
+        // For static roots, also forward pointers are threaded.
+        // Therefore, this must happen after the heap traversal for backwards pointer threading.
+        self.thread_static_roots();
+
+        let continuation_table = *self.heap.roots.continuation_table_ptr_loc;
+        if continuation_table.is_ptr() && continuation_table.get_ptr() >= self.generation_base() {
+            self.thread(self.heap.roots.continuation_table_ptr_loc);
+        }
+
+        let region0 = *self.heap.roots.region0_ptr_loc;
+        if region0.is_ptr() && region0.get_ptr() >= self.generation_base() {
+            self.thread(self.heap.roots.region0_ptr_loc);
+        }
+
+        // For the young generation GC run, the forward pointers from the old generation must be threaded too.
+        if self.strategy == Strategy::Young {
+            self.thread_old_generation_pointers();
+        }
+    }
+
+    unsafe fn thread_static_roots(&self) {
+        let root_array = self.heap.roots.static_roots.as_array();
+        for i in 0..root_array.len() {
+            let object = root_array.get(i).as_obj();
+            assert_eq!(object.tag(), TAG_MUTBOX);
+            assert!((object as usize) < self.heap.limits.base);
+            self.thread_root_mutbox_fields(object as *mut MutBox);
+        }
+    }
+
+    unsafe fn thread_root_mutbox_fields(&self, mutbox: *mut MutBox) {
+        let field_addr = &mut (*mutbox).field;
+        if pointer_to_dynamic_heap(field_addr, self.generation_base()) {
+            self.thread(field_addr);
+        }
+    }
+
+    unsafe fn thread_all_backward_pointers(&mut self) {
+        let mut bitmap_iter = iter_bits();
+        let mut bit = bitmap_iter.next();
+        while bit != BITMAP_ITER_END {
+            let object = (bit * WORD_SIZE) as *mut Obj;
+            self.thread_backward_pointer_fields(object);
+            bit = bitmap_iter.next();
+        }
+    }
+
+    unsafe fn thread_backward_pointer_fields(&mut self, object: *mut Obj) {
+        debug_assert!(object.tag() < TAG_ARRAY_SLICE_MIN);
+        visit_pointer_fields(
+            &mut (),
+            object,
+            object.tag(),
+            self.generation_base(),
+            |_, field_address| {
+                let field_value = *field_address;
+                // Thread if backwards or self pointer
+                if field_value.get_ptr() <= object as usize {
+                    (&self).thread(field_address);
+                }
+            },
+            |_, _, array| array.len(),
+        );
+    }
+
+    // Thread forward pointers in old generation leading to young generation
+    unsafe fn thread_old_generation_pointers(&mut self) {
+        let mut iterator = REMEMBERED_SET.as_ref().unwrap().iterate();
+        while iterator.has_next() {
+            let location = iterator.current().get_raw() as *mut Value;
+            assert!(
+                (location as usize) >= self.heap.limits.base
+                    && (location as usize) < self.heap.limits.last_free
+            );
+            let value = *location;
+            // value in the location may have changed since recording by the write barrer
+            if value.points_to_or_beyond(self.heap.limits.last_free) {
+                self.thread(location);
+            }
+            iterator.next();
+        }
+    }
+
+    unsafe fn move_phase(&mut self) {
+        REMEMBERED_SET = None; // no longer valid when the moving phase starts
+        let mut free = self.heap.limits.base;
+
+        let mut bitmap_iter = iter_bits();
+        if self.strategy == Strategy::Young {
+            free = self.heap.limits.last_free;
+        }
+        let mut bit = bitmap_iter.next();
+        while bit != BITMAP_ITER_END {
+            let old_pointer = (bit * WORD_SIZE) as *mut Obj;
+            let new_pointer = free;
+
+            // Unthread backwards pointers as well as forward pointers of static objects.
+            // In the case of a young collection, also unthread forward pointers of old objects.
+            self.unthread(old_pointer, new_pointer);
+
+            // Move the object
+            let object_size = block_size(old_pointer as usize);
+            if new_pointer as usize != old_pointer as usize {
+                memcpy_words(new_pointer as usize, old_pointer as usize, object_size);
+                debug_assert!(object_size.as_usize() > size_of::<Obj>().as_usize());
+
+                // Update forwarding pointer
+                let new_obj = new_pointer as *mut Obj;
+                debug_assert!(new_obj.tag() >= TAG_OBJECT && new_obj.tag() <= TAG_NULL);
+            }
+
+            free += object_size.to_bytes().as_usize();
+
+            // Thread forward pointers of the object, even if not moved
+            self.thread_forward_pointers(new_pointer as *mut Obj);
+
+            bit = bitmap_iter.next();
+        }
+
+        self.heap.limits.free = free;
+    }
+
+    /// Thread forward pointers in object
+    unsafe fn thread_forward_pointers(&mut self, object: *mut Obj) {
+        visit_pointer_fields(
+            &mut (),
+            object,
+            object.tag(),
+            self.generation_base(),
+            |_, field_address| {
+                if (*field_address).get_ptr() > object as usize {
+                    (&self).thread(field_address)
+                }
+            },
+            |_, _, array| array.len(),
+        );
+    }
+
+    unsafe fn thread(&self, field: *mut Value) {
+        let pointed = (*field).get_ptr() as *mut Obj;
+        assert!(self.should_be_threaded(pointed));
+        let pointed_header = pointed.tag();
+        *field = Value::from_raw(pointed_header);
+        (*pointed).tag = field as usize;
+    }
+
+    unsafe fn unthread(&self, object: *mut Obj, new_location: usize) {
+        assert!(self.should_be_threaded(object));
+        let mut header = object.tag();
+        while header & 0b1 == 0 {
+            let tmp = (header as *const Obj).tag();
+            (*(header as *mut Value)) = Value::from_ptr(new_location);
+            header = tmp;
+        }
+        debug_assert!(header >= TAG_OBJECT && header <= TAG_NULL);
+        (*object).tag = header;
+    }
+
+    unsafe fn should_be_threaded(&self, object: *mut Obj) -> bool {
+        object as usize >= self.generation_base()
+    }
+}
diff --git a/rts/motoko-rts/src/gc/generational/mark_stack.rs b/rts/motoko-rts/src/gc/generational/mark_stack.rs
new file mode 100644
index 00000000000..7137e8afad9
--- /dev/null
+++ b/rts/motoko-rts/src/gc/generational/mark_stack.rs
@@ -0,0 +1,75 @@
+//! A stack for marking heap objects (for GC). Adopted from mark & compact GC.
+//! Simplified to only store object pointers without tags.
+
+use crate::gc::generational::TAG_BLOB_B;
+use crate::memory::{alloc_blob, Memory};
+use crate::types::{Blob, Words};
+
+use core::ptr::null_mut;
+
+/// Initial stack size
+pub const INIT_STACK_SIZE: Words<usize> = Words(64);
+
+/// Pointer to the `blob` object for the mark stack. Used to get the capacity of the stack.
+static mut STACK_BLOB_PTR: *mut Blob = null_mut();
+
+/// Bottom of the mark stack
+pub static mut STACK_BASE: *mut usize = null_mut();
+
+/// Top of the mark stack
+pub static mut STACK_TOP: *mut usize = null_mut();
+
+/// Next free slot in the mark stack
+pub static mut STACK_PTR: *mut usize = null_mut();
+
+/// Allocate the mark stack at the start of each GC run
+pub unsafe fn alloc_mark_stack<M: Memory>(mem: &mut M) {
+    assert!(STACK_BLOB_PTR.is_null());
+
+    // Allocating an actual object here to not break dump_heap
+    // No post allocation barrier as this RTS-internal blob will be collected by the GC.
+    STACK_BLOB_PTR = alloc_blob(mem, TAG_BLOB_B, INIT_STACK_SIZE.to_bytes()).get_ptr() as *mut Blob;
+    STACK_BASE = STACK_BLOB_PTR.payload_addr() as *mut usize;
+    STACK_PTR = STACK_BASE;
+    STACK_TOP = STACK_BASE.add(INIT_STACK_SIZE.as_usize());
+}
+
+/// Deallocate the mark stack after each GC run
+pub unsafe fn free_mark_stack() {
+    STACK_BLOB_PTR = null_mut();
+    STACK_BASE = null_mut();
+    STACK_PTR = null_mut();
+    STACK_TOP = null_mut();
+}
+
+/// Doubles the stack size
+pub unsafe fn grow_stack<M: Memory>(mem: &mut M) {
+    let stack_cap: Words<usize> = STACK_BLOB_PTR.len().to_words();
+    let p = mem.alloc_words(stack_cap).get_ptr() as *mut usize;
+
+    // Make sure nothing was allocated after the stack
+    assert_eq!(STACK_TOP, p);
+
+    let new_cap: Words<usize> = stack_cap * 2;
+    (*STACK_BLOB_PTR).len = new_cap.to_bytes();
+    STACK_TOP = STACK_BASE.add(new_cap.as_usize());
+}
+
+/// Push a new unskewed object pointer to be marked later
+pub unsafe fn push_mark_stack<M: Memory>(mem: &mut M, object: usize) {
+    if STACK_PTR == STACK_TOP {
+        grow_stack(mem);
+    }
+    *STACK_PTR = object;
+    STACK_PTR = STACK_PTR.add(1);
+}
+
+/// Pop a unskewed object pointer if existend to be visited next
+pub unsafe fn pop_mark_stack() -> Option<usize> {
+    if STACK_PTR == STACK_BASE {
+        return None;
+    }
+    STACK_PTR = STACK_PTR.sub(1);
+    let object = *STACK_PTR;
+    return Some(object);
+}
diff --git a/rts/motoko-rts/src/gc/generational/sanity_checks.rs b/rts/motoko-rts/src/gc/generational/sanity_checks.rs
new file mode 100644
index 00000000000..f0063006229
--- /dev/null
+++ b/rts/motoko-rts/src/gc/generational/sanity_checks.rs
@@ -0,0 +1,173 @@
+//! Extensive sanity checks for generational GC features.
+//! * Write barrier coverage by memory snapshot comparisons.
+//! * Memory sanity check, including a full heap scan.
+#![allow(dead_code)]
+
+use core::ptr::null_mut;
+
+use super::write_barrier::REMEMBERED_SET;
+use super::{Heap, Limits, Roots};
+use crate::mem_utils::memcpy_bytes;
+use crate::memory::{alloc_blob, Memory};
+use crate::types::*;
+use crate::visitor::{classical::pointer_to_dynamic_heap, visit_pointer_fields};
+
+static mut SNAPSHOT: *mut Blob = null_mut();
+
+/// Take a memory snapshot. To be initiated after GC run.
+pub unsafe fn take_snapshot<M: Memory>(heap: &mut Heap<M>) {
+    let length = Bytes(heap.limits.free);
+    // No post allocation barrier as this RTS-internal blob will be collected by the GC.
+    let blob = alloc_blob(heap.mem, TAG_BLOB_B, length).get_ptr() as *mut Blob;
+    memcpy_bytes(blob.payload_addr() as usize, 0, length);
+    SNAPSHOT = blob;
+}
+
+/// Verify write barrier coverage by comparing the memory against the previous snapshot.
+/// To be initiated before the next GC run. No effect if no snapshpot has been taken.
+pub unsafe fn verify_snapshot<M: Memory>(heap: &Heap<M>, verify_roots: bool) {
+    if SNAPSHOT.is_null() {
+        return;
+    }
+    assert!(heap.limits.base <= heap.limits.free);
+    if verify_roots {
+        verify_static_roots(heap.roots.static_roots.as_array(), heap.limits.free);
+    }
+    verify_heap(&heap.limits);
+    SNAPSHOT = null_mut();
+}
+
+unsafe fn verify_static_roots(static_roots: *mut Array, last_free: usize) {
+    for index in 0..static_roots.len() {
+        let current = static_roots.get(index).as_obj();
+        assert_eq!(current.tag(), TAG_MUTBOX); // check tag
+        let mutbox = current as *mut MutBox;
+        let current_field = &mut (*mutbox).field;
+        if relevant_field(current_field, last_free) {
+            verify_field(current_field);
+        }
+    }
+}
+
+unsafe fn verify_heap(limits: &Limits) {
+    assert!(SNAPSHOT.len().as_usize() <= limits.free);
+    let mut pointer = limits.base;
+    while pointer < SNAPSHOT.len().as_usize() {
+        if Value::from_ptr(pointer).is_obj() {
+            let current = pointer as *mut Obj;
+            let previous = (SNAPSHOT.payload_addr() as usize + pointer) as *mut Obj;
+            assert!(current.tag() == previous.tag());
+            visit_pointer_fields(
+                &mut (),
+                current,
+                current.tag(),
+                0,
+                |_, current_field| {
+                    if relevant_field(current_field, limits.last_free) {
+                        verify_field(current_field);
+                    }
+                },
+                |_, slice_start, arr| {
+                    assert!(slice_start == 0);
+                    arr.len()
+                },
+            );
+        }
+        pointer += block_size(pointer).to_bytes().as_usize();
+    }
+}
+
+unsafe fn relevant_field(current_field: *mut Value, last_free: usize) -> bool {
+    if (current_field as usize) < last_free {
+        let value = *current_field;
+        value.is_ptr() && value.get_ptr() as usize >= last_free
+    } else {
+        false
+    }
+}
+
+unsafe fn verify_field(current_field: *mut Value) {
+    let memory_copy = SNAPSHOT.payload_addr() as usize;
+    let previous_field = (memory_copy + current_field as usize) as *mut Value;
+    if *previous_field != *current_field && !recorded(current_field as usize) {
+        panic!("Missing write barrier at {:#x}", current_field as usize);
+    }
+}
+
+unsafe fn recorded(value: usize) -> bool {
+    match &REMEMBERED_SET {
+        None => panic!("No remembered set"),
+        Some(remembered_set) => remembered_set.contains(Value::from_raw(value)),
+    }
+}
+
+pub struct MemoryChecker<'a> {
+    limits: &'a Limits,
+    roots: &'a Roots,
+}
+
+pub unsafe fn check_memory(limits: &Limits, roots: &Roots) {
+    let checker = MemoryChecker { limits, roots };
+    checker.check_memory();
+}
+
+impl<'a> MemoryChecker<'a> {
+    unsafe fn check_memory(&self) {
+        self.check_static_roots();
+        if (*self.roots.continuation_table_ptr_loc).is_ptr() {
+            self.check_object(*self.roots.continuation_table_ptr_loc);
+        }
+        self.check_heap();
+    }
+
+    unsafe fn check_static_roots(&self) {
+        let root_array = self.roots.static_roots.as_array();
+        for i in 0..root_array.len() {
+            let obj = root_array.get(i).as_obj();
+            assert_eq!(obj.tag(), TAG_MUTBOX);
+            assert!((obj as usize) < self.limits.base);
+            let mutbox = obj as *mut MutBox;
+            let field_addr = &mut (*mutbox).field;
+            if pointer_to_dynamic_heap(field_addr, self.limits.base as usize) {
+                let object = *field_addr;
+                self.check_object(object);
+            }
+        }
+    }
+
+    unsafe fn check_object(&self, object: Value) {
+        self.check_object_header(object);
+        visit_pointer_fields(
+            &mut (),
+            object.as_obj(),
+            object.tag(),
+            0,
+            |_, field_address| {
+                // Ignore null pointers used in text_iter.
+                if (*field_address).get_ptr() as *mut Obj != null_mut() {
+                    (&self).check_object_header(*field_address);
+                }
+            },
+            |_, _, arr| arr.len(),
+        );
+    }
+
+    unsafe fn check_object_header(&self, object: Value) {
+        assert!(object.is_ptr());
+        let pointer = object.get_ptr();
+        assert!(pointer < self.limits.free);
+        let tag = object.tag();
+        assert!(tag >= TAG_OBJECT && tag <= TAG_NULL);
+    }
+
+    unsafe fn check_heap(&self) {
+        let mut pointer = self.limits.base;
+        while pointer < self.limits.free {
+            let block = Value::from_ptr(pointer as usize);
+            if block.tag() != TAG_ONE_WORD_FILLER {
+                self.check_object(block);
+            }
+            pointer += block_size(pointer as usize).to_bytes().as_usize();
+        }
+    }
+}
diff --git a/rts/motoko-rts/src/gc/generational/write_barrier.rs b/rts/motoko-rts/src/gc/generational/write_barrier.rs
new file mode 100644
index 00000000000..1f03facd98b
--- /dev/null
+++ b/rts/motoko-rts/src/gc/generational/write_barrier.rs
@@ -0,0 +1,46 @@
+//! Write barrier, used for generational GC
+
+use crate::gc::remembered_set::RememberedSet;
+use crate::memory::Memory;
+use crate::types::Value;
+use motoko_rts_macros::ic_mem_fn;
+
+pub static mut REMEMBERED_SET: Option<RememberedSet> = None;
+pub static mut HEAP_BASE: usize = 0;
+pub static mut LAST_HP: usize = 0;
+
+#[cfg(feature = "ic")]
+/// (Re-)initialize the write barrier for generational GC.
+pub(crate) unsafe fn init_generational_write_barrier<M: Memory>(mem: &mut M) {
+    use crate::memory::ic::{self, linear_memory};
+    REMEMBERED_SET = Some(RememberedSet::new(mem));
+    HEAP_BASE = ic::get_aligned_heap_base();
+    LAST_HP = linear_memory::LAST_HP;
+}
+
+/// Write barrier to be called AFTER the pointer store, used for the generational GC.
+/// `location`: location of modified pointer (address of object field or array element).
+///
+/// As the barrier is called after the write, `*location` refers to the NEW value.
+/// No effect if the write barrier is deactivated.
+#[ic_mem_fn]
+pub unsafe fn post_write_barrier<M: Memory>(mem: &mut M, location: usize) {
+    // Must be an unskewed address.
+    debug_assert_eq!(location & 0b1, 0);
+    // Checks have been optimized according to the frequency of occurrence.
+    // Only record locations inside old generation. Static roots are anyway marked by GC.
+    if location < LAST_HP {
+        // Nested ifs are more efficient when counting instructions on IC (explicit return counts as an instruction).
+        let value = *(location as *mut Value);
+        if value.points_to_or_beyond(LAST_HP) {
+            #[allow(clippy::collapsible_if)]
+            if location >= HEAP_BASE {
+                // Trap pointers that lead from old generation (or static roots) to young generation.
+                REMEMBERED_SET
+                    .as_mut()
+                    .unwrap()
+                    .insert(mem, Value::from_raw(location));
+            }
+        }
+    }
+}
diff --git a/rts/motoko-rts/src/gc/incremental.rs b/rts/motoko-rts/src/gc/incremental.rs
index ce6d8956577..4c8bf761942 100644
--- a/rts/motoko-rts/src/gc/incremental.rs
+++ b/rts/motoko-rts/src/gc/incremental.rs
@@ -11,7 +11,9 @@
 //! retained across upgrades and therefore be stored part of the
 //! persistent metadata, cf. `persistence::PersistentMetadata`.
 
-use motoko_rts_macros::ic_mem_fn;
+#[cfg(feature = "ic")]
+use motoko_rts_macros::classical_persistence;
+use motoko_rts_macros::{enhanced_orthogonal_persistence, ic_mem_fn};
 
 use crate::{memory::Memory, stable_option::StableOption, types::*, visitor::visit_pointer_fields};
 
@@ -35,21 +37,39 @@ mod phases;
 pub mod roots;
 #[cfg(feature = "memory_check")]
 pub mod sanity_checks;
+#[cfg(feature = "ic")]
+mod scheduling;
 pub mod sort;
 pub mod time;
 
 #[ic_mem_fn(ic_only)]
 unsafe fn initialize_incremental_gc<M: Memory>(mem: &mut M) {
+    initialize(mem);
+}
+
+#[cfg(feature = "ic")]
+#[enhanced_orthogonal_persistence]
+unsafe fn initialize<M: Memory>(_mem: &mut M) {
     use crate::persistence::initialize_memory;
+    initialize_memory::<M>();
+}
 
-    initialize_memory(mem);
+#[cfg(feature = "ic")]
+#[classical_persistence]
+unsafe fn initialize<M: Memory>(_mem: &mut M) {
+    use crate::memory::ic;
+
+    let state = STATE.get_mut();
+    let heap_base = ic::get_aligned_heap_base();
+    *state = IncrementalGC::<M>::initial_gc_state(heap_base);
+    partitioned_heap::allocate_initial_memory(Bytes(heap_base));
 }
 
 #[ic_mem_fn(ic_only)]
 unsafe fn schedule_incremental_gc<M: Memory>(mem: &mut M) {
     let state = get_incremental_gc_state();
     let running = state.phase != Phase::Pause;
-    if running || should_start() {
+    if running || scheduling::should_start_gc() {
         incremental_gc(mem);
     }
 }
@@ -58,6 +78,7 @@ unsafe fn schedule_incremental_gc<M: Memory>(mem: &mut M) {
 unsafe fn incremental_gc<M: Memory>(mem: &mut M) {
     use self::roots::root_set;
     let state = get_incremental_gc_state();
+    assert!(state.phase != Phase::Stop);
     if state.phase == Phase::Pause {
         record_gc_start::<M>();
     }
@@ -67,50 +88,20 @@ unsafe fn incremental_gc<M: Memory>(mem: &mut M) {
     }
 }
 
-#[cfg(feature = "ic")]
-unsafe fn should_start() -> bool {
-    use self::partitioned_heap::PARTITION_SIZE;
-    use crate::constants::GB;
-    use crate::memory::ic;
-
-    const CRITICAL_HEAP_LIMIT: Bytes<u32> = Bytes((2 * GB + 256 * MB) as u32);
-    const CRITICAL_GROWTH_THRESHOLD: f64 = 0.01;
-    const MEDIUM_HEAP_LIMIT: Bytes<u32> = Bytes(1 * GB as u32);
-    const MEDIUM_GROWTH_THRESHOLD: f64 = 0.35;
-    const LOW_GROWTH_THRESHOLD: f64 = 0.65;
-
-    let heap_size = ic::get_heap_size();
-    let growth_threshold = if heap_size > CRITICAL_HEAP_LIMIT {
-        CRITICAL_GROWTH_THRESHOLD
-    } else if heap_size > MEDIUM_HEAP_LIMIT {
-        MEDIUM_GROWTH_THRESHOLD
-    } else {
-        LOW_GROWTH_THRESHOLD
-    };
-
-    let current_allocations = ic::get_total_allocations();
-    let state = get_incremental_gc_state();
-    debug_assert!(current_allocations >= state.statistics.last_allocations);
-    let absolute_growth = current_allocations - state.statistics.last_allocations;
-    let relative_growth = absolute_growth.0 as f64 / heap_size.as_usize() as f64;
-    relative_growth > growth_threshold && heap_size.as_usize() >= PARTITION_SIZE
-}
-
 #[cfg(feature = "ic")]
 unsafe fn record_gc_start<M: Memory>() {
-    use crate::memory::ic;
+    use crate::memory::ic::partitioned_memory;
 
     let state = get_incremental_gc_state();
-    state.statistics.last_allocations = ic::get_total_allocations();
+    state.statistics.last_allocations = partitioned_memory::get_total_allocations();
 }
 
 #[cfg(feature = "ic")]
 unsafe fn record_gc_stop<M: Memory>() {
-    use crate::memory::ic;
-    use crate::persistence::HEAP_START;
+    use crate::memory::ic::{self, partitioned_memory};
 
-    let heap_size = ic::get_heap_size();
-    let static_size = Bytes(HEAP_START as u32);
+    let heap_size = partitioned_memory::get_heap_size();
+    let static_size = Bytes(ic::get_aligned_heap_base());
     debug_assert!(heap_size >= static_size);
     let dynamic_size = heap_size - static_size;
     let state = get_incremental_gc_state();
@@ -122,7 +113,7 @@ struct Statistics {
     // Total number of allocation at the start of the last GC run.
     last_allocations: Bytes<u64>,
     // Maximum heap size the end of a GC run.
-    max_live: Bytes<u32>,
+    max_live: Bytes<usize>,
 }
 
 /// GC phases per run. Each of the following phases is performed in potentially multiple increments.
@@ -149,6 +140,7 @@ const INCREMENT_ALLOCATION_FACTOR: usize = 50; // Additional time factor per con
 #[derive(PartialEq)]
 #[repr(C)]
 enum Phase {
+    Stop,     // GC stopped during canister upgrade and explicit stabilization/destabilization.
     Pause,    // Inactive, waiting for the next GC run.
     Mark,     // Incremental marking.
     Evacuate, // Incremental evacuation compaction.
@@ -167,6 +159,21 @@ pub struct State {
     statistics: Statistics,
 }
 
+/// GC state retained over multiple GC increments.
+#[classical_persistence]
+#[cfg(feature = "ic")]
+static mut STATE: core::cell::RefCell<State> = core::cell::RefCell::new(State {
+    phase: Phase::Pause,
+    partitioned_heap: self::partitioned_heap::UNINITIALIZED_HEAP,
+    allocation_count: 0,
+    mark_state: StableOption::None,
+    iterator_state: StableOption::None,
+    statistics: Statistics {
+        last_allocations: Bytes(0),
+        max_live: Bytes(0),
+    },
+});
+
 /// Temporary state during message execution, not part of the persistent metadata.
 static mut RUNNING_GC_INCREMENT: bool = false;
 
@@ -181,8 +188,8 @@ pub struct IncrementalGC<'a, M: Memory> {
 impl<'a, M: Memory + 'a> IncrementalGC<'a, M> {
     /// (Re-)Initialize the entire incremental garbage collector.
     /// Called on a runtime system start with incremental GC and also during RTS testing.
-    pub unsafe fn initial_gc_state(mem: &'a mut M, heap_base: usize) -> State {
-        let partitioned_heap = PartitionedHeap::new(mem, heap_base);
+    pub unsafe fn initial_gc_state(heap_base: usize) -> State {
+        let partitioned_heap = PartitionedHeap::new(heap_base);
         let statistics = Statistics {
             last_allocations: Bytes(0),
             max_live: Bytes(0),
@@ -276,7 +283,7 @@ impl<'a, M: Memory + 'a> IncrementalGC<'a, M> {
         debug_assert!(self.mark_completed());
         MarkIncrement::<M>::complete_phase(self.state);
         self.state.phase = Phase::Evacuate;
-        EvacuationIncrement::<M>::start_phase(self.state);
+        EvacuationIncrement::<M>::start_phase(self.mem, self.state);
     }
 
     unsafe fn evacuation_completed(&self) -> bool {
@@ -328,7 +335,10 @@ unsafe fn pre_write_barrier<M: Memory>(mem: &mut M, state: &mut State, overwritt
         if overwritten_value.points_to_or_beyond(base_address) {
             let mut time = BoundedTime::new(0);
             let mut increment = MarkIncrement::instance(mem, state, &mut time);
+
+            #[enhanced_orthogonal_persistence]
             debug_assert_ne!(overwritten_value, NULL_POINTER);
+
             increment.mark_object(overwritten_value);
         }
     }
@@ -395,6 +405,7 @@ unsafe fn update_new_allocation(state: &State, new_object: Value) {
             &mut (),
             object,
             object.tag(),
+            state.partitioned_heap.base_address(),
             |_, field| {
                 *field = (*field).forward_if_possible();
             },
@@ -416,15 +427,52 @@ pub unsafe fn get_partitioned_heap() -> &'static mut PartitionedHeap {
 }
 
 #[cfg(feature = "ic")]
+#[enhanced_orthogonal_persistence]
 pub unsafe fn get_incremental_gc_state() -> &'static mut State {
     crate::persistence::get_incremental_gc_state()
 }
 
 #[cfg(feature = "ic")]
-pub unsafe fn get_max_live_size() -> Bytes<u32> {
+#[classical_persistence]
+pub unsafe fn get_incremental_gc_state() -> &'static mut State {
+    STATE.get_mut()
+}
+
+#[cfg(feature = "ic")]
+pub unsafe fn get_max_live_size() -> Bytes<usize> {
     get_incremental_gc_state().statistics.max_live
 }
 
+/// Stop the GC. Called before stabilzation and destabilization.
+pub unsafe fn stop_gc() {
+    let state = get_incremental_gc_state();
+    state.phase = Phase::Stop;
+}
+
+/// Resume the stopped GC. Called after completed destabilization.
+pub unsafe fn resume_gc() {
+    let state = get_incremental_gc_state();
+    assert!(state.phase == Phase::Stop);
+    state.phase = Phase::Pause;
+    // The allocation during destabilization should not count as concurrent
+    // mutator allocation. Therefore, reset the allocation count.
+    state.allocation_count = 0;
+}
+
+pub unsafe fn is_gc_stopped() -> bool {
+    get_incremental_gc_state().phase == Phase::Stop
+}
+
+/// Safety guard before Candid-stabilization with classical persistence.
+/// For graph copying, a different GC stop function is used, see
+/// `stabilization::ic::stop_gc_before_stabilization()`.
+#[classical_persistence]
+#[cfg(feature = "ic")]
+#[no_mangle]
+unsafe extern "C" fn stop_gc_on_upgrade() {
+    stop_gc();
+}
+
 /// For RTS unit testing only.
 #[cfg(not(feature = "ic"))]
 static mut TEST_GC_STATE: Option<State> = None;
@@ -445,23 +493,21 @@ pub unsafe fn set_incremental_gc_state(state: Option<State>) {
     TEST_GC_STATE = state;
 }
 
-#[cfg(feature = "ic")]
-use crate::constants::MB;
-
-/// Additional memory reserve in bytes for the GC.
-/// * To allow mark bitmap allocation, i.e. max. 128 MB in 4 GB address space.
-/// * 512 MB of free space for evacuations/compactions.
-#[cfg(feature = "ic")]
-const GC_MEMORY_RESERVE: usize = (128 + 512) * MB;
-
 #[cfg(feature = "ic")]
 pub unsafe fn memory_reserve() -> usize {
+    use crate::constants::MB;
     use crate::memory::GENERAL_MEMORY_RESERVE;
 
-    let additional_reserve = if RUNNING_GC_INCREMENT {
+    if RUNNING_GC_INCREMENT {
         0
     } else {
-        GC_MEMORY_RESERVE
-    };
-    GENERAL_MEMORY_RESERVE + additional_reserve
+        // Ensure there are free partitions for evacuation.
+        // 16 free partitions in 32-bit. 8 free partitions in 64-bit.
+        const EVACUATION_RESERVE: usize = 512 * MB;
+        // Reserve space for the mark bitmap, the evacuation space, and
+        // extra space for query and (stabilization) upgrade calls.
+        get_partitioned_heap().maximum_mark_bitmap_size()
+            + EVACUATION_RESERVE
+            + GENERAL_MEMORY_RESERVE
+    }
 }
diff --git a/rts/motoko-rts/src/gc/incremental/array_slicing.rs b/rts/motoko-rts/src/gc/incremental/array_slicing.rs
index a18fcb72217..d3aef1c28fc 100644
--- a/rts/motoko-rts/src/gc/incremental/array_slicing.rs
+++ b/rts/motoko-rts/src/gc/incremental/array_slicing.rs
@@ -5,8 +5,8 @@ use crate::types::*;
 /// This helps:
 /// * Ensure bounded increments when visiting fields on large arrays.
 /// * Prevent mark stack overflows on large arrays.
-pub unsafe fn slice_array(array: *mut Array) -> u32 {
-    const SLICE_INCREMENT: u32 = 128;
+pub unsafe fn slice_array(array: *mut Array) -> usize {
+    const SLICE_INCREMENT: usize = 128;
     debug_assert!(SLICE_INCREMENT >= TAG_ARRAY_SLICE_MIN);
     let (base_tag, slice_start) = array.get_slice_start();
     if array.len() - slice_start > SLICE_INCREMENT {
diff --git a/rts/motoko-rts/src/gc/incremental/barriers.rs b/rts/motoko-rts/src/gc/incremental/barriers.rs
index 091c255892a..beab2de3492 100644
--- a/rts/motoko-rts/src/gc/incremental/barriers.rs
+++ b/rts/motoko-rts/src/gc/incremental/barriers.rs
@@ -28,7 +28,7 @@ pub unsafe extern "C" fn running_gc() -> bool {
 /// * Resolve forwarding: Used during the GC update phase to adjust old pointers to their new forwarded addresses.
 #[ic_mem_fn]
 pub unsafe fn write_with_barrier<M: Memory>(mem: &mut M, location: *mut Value, value: Value) {
-    debug_assert!(!is_skewed(location as u32));
+    debug_assert!(!is_skewed(location as usize));
     debug_assert_ne!(location, core::ptr::null_mut());
 
     let state = get_incremental_gc_state();
diff --git a/rts/motoko-rts/src/gc/incremental/mark_bitmap.rs b/rts/motoko-rts/src/gc/incremental/mark_bitmap.rs
index d6f5cde880f..a0a4a5b71ce 100644
--- a/rts/motoko-rts/src/gc/incremental/mark_bitmap.rs
+++ b/rts/motoko-rts/src/gc/incremental/mark_bitmap.rs
@@ -5,8 +5,8 @@
 //! of a GC run.
 //!
 //! A bitmap is represented in raw memory (no object header, no blob) of the fixed size
-//! `PARTITION_SIZE / WORD_SIZE / u8::bits`, which is `PARTITION_SIZE /32` bytes. For simplicity, the bitmaps
-//! is not shortened for partitions that also accommodate static space besides dynamic space.
+//! `PARTITION_SIZE / WORD_SIZE / u8::BITS` bytes. For simplicity, the bitmaps is not shortened for partitions
+//! that also accommodate static space besides dynamic space.
 //!
 //! To access a mark bit of an object, the corresponding bitmap and address offset inside the object's partition
 //! needs to be first determined. The corresponding bit is then accessed at the byte with index
@@ -20,13 +20,14 @@
 //! The mark bitmap serves for fast traversal of marked objects in a partition with few marked objects
 //! (and many garbage objects).
 
-use core::{mem::size_of, ptr::null_mut};
+use core::ptr::null_mut;
 
 use crate::{constants::WORD_SIZE, mem_utils::memzero, types::Bytes};
 
 use super::partitioned_heap::PARTITION_SIZE;
 
-const BITMAP_FRACTION: usize = (WORD_SIZE * u8::BITS) as usize;
+const BITS_PER_BYTE: usize = u8::BITS as usize;
+const BITMAP_FRACTION: usize = WORD_SIZE * BITS_PER_BYTE;
 
 pub const BITMAP_SIZE: usize = PARTITION_SIZE / BITMAP_FRACTION;
 
@@ -48,13 +49,9 @@ impl MarkBitmap {
     }
 
     /// Assign and initialize the bitmap memory at the defined address.
-    /// The `bitmap_address` must be 64-bit-aligned for fast iteration.
     pub unsafe fn assign(&mut self, bitmap_address: *mut u8) {
-        debug_assert_eq!(bitmap_address as usize % size_of::<u64>(), 0);
-        memzero(
-            bitmap_address as usize,
-            Bytes(BITMAP_SIZE as u32).to_words(),
-        );
+        debug_assert_eq!(bitmap_address as usize % WORD_SIZE, 0);
+        memzero(bitmap_address as usize, Bytes(BITMAP_SIZE).to_words());
         debug_assert_eq!(self.pointer, null_mut());
         self.pointer = bitmap_address;
     }
@@ -65,17 +62,17 @@ impl MarkBitmap {
     }
 
     fn word_index(&self, offset_in_partition: usize) -> usize {
-        debug_assert_eq!(offset_in_partition % WORD_SIZE as usize, 0);
+        debug_assert_eq!(offset_in_partition % WORD_SIZE, 0);
         debug_assert!(offset_in_partition < PARTITION_SIZE);
-        offset_in_partition / (WORD_SIZE as usize)
+        offset_in_partition / WORD_SIZE
     }
 
     /// Check whether the object at defined address offset in the partition is marked.
     pub unsafe fn is_marked(&self, offset_in_partition: usize) -> bool {
         debug_assert_ne!(self.pointer, null_mut());
         let word_index = self.word_index(offset_in_partition);
-        let byte_index = word_index / u8::BITS as usize;
-        let bit_index = word_index % u8::BITS as usize;
+        let byte_index = word_index / BITS_PER_BYTE;
+        let bit_index = word_index % BITS_PER_BYTE;
         let byte = self.pointer.add(byte_index);
         (*byte >> bit_index) & 0b1 != 0
     }
@@ -84,8 +81,8 @@ impl MarkBitmap {
     pub unsafe fn mark(&mut self, offset_in_partition: usize) {
         debug_assert_ne!(self.pointer, null_mut());
         let word_index = self.word_index(offset_in_partition);
-        let byte_index = word_index / u8::BITS as usize;
-        let bit_index = word_index % u8::BITS as usize;
+        let byte_index = word_index / BITS_PER_BYTE;
+        let bit_index = word_index % BITS_PER_BYTE;
         let byte = self.pointer.add(byte_index);
         *byte |= 0b1 << bit_index;
     }
@@ -101,7 +98,7 @@ impl MarkBitmap {
 /// to better support the incremental evacuation and update GC increments.
 #[repr(C)]
 pub struct BitmapIterator {
-    /// Start address of the mark bitmap. Must be 64-bit-aligned.
+    /// Start address of the mark bitmap.
     bitmap_pointer: *mut u8,
     /// Index of next bit to continue iteration in the bitmap.
     /// Invariant during (initialized and unfinished):
@@ -110,10 +107,8 @@ pub struct BitmapIterator {
     /// reading the corresponding bit in the bitmap.
     /// Sentinel: `BITMAP_ITERATION_END` if the iteration is finished.
     next_bit_index: usize,
-    /// Current 64-bit word in the bitmap that we are iterating.
-    /// Optimization: Reading in 64-bit chunks to check as many bits as
-    /// possible with a single `word != 0`.
-    current_word: u64,
+    /// Current word in the bitmap that we are iterating.
+    current_word: usize,
     /// Number of leading bits that are initially zeroed in `current_word`.
     leading_zeros: usize,
 }
@@ -123,16 +118,15 @@ pub struct BitmapIterator {
 pub const BITMAP_ITERATION_END: usize = usize::MAX;
 
 /// Last possible valid value of `next_bit_index`.
-const BIT_INDEX_END: usize = BITMAP_SIZE * u8::BITS as usize;
+const BIT_INDEX_END: usize = BITMAP_SIZE * BITS_PER_BYTE;
 
 const _: () = assert!(BIT_INDEX_END < BITMAP_ITERATION_END);
 
 impl BitmapIterator {
-    /// The `bitmap_pointer` must be 64-bit-aligned.
     fn new(bitmap_pointer: *mut u8) -> BitmapIterator {
         debug_assert_ne!(bitmap_pointer, null_mut());
-        debug_assert_eq!(PARTITION_SIZE % size_of::<u64>(), 0);
-        debug_assert_eq!(bitmap_pointer as usize % size_of::<u64>(), 0);
+        debug_assert_eq!(PARTITION_SIZE % WORD_SIZE, 0);
+        debug_assert_eq!(bitmap_pointer as usize % WORD_SIZE, 0);
         let mut iterator = BitmapIterator {
             bitmap_pointer,
             next_bit_index: 0,
@@ -151,19 +145,19 @@ impl BitmapIterator {
         if self.next_bit_index == BITMAP_ITERATION_END {
             return BITMAP_ITERATION_END;
         } else {
-            (self.next_bit_index - 1) * WORD_SIZE as usize
+            (self.next_bit_index - 1) * WORD_SIZE
         }
     }
 
     /// Advance the iterator to the next marked offset.
     pub fn next(&mut self) {
         debug_assert!(self.next_bit_index <= BIT_INDEX_END);
-        // Outer loop iterates the 64-bit words.
+        // Outer loop iterates the words.
         while self.next_bit_index < BIT_INDEX_END {
             // Examine the least significant bit(s) in the current word.
             if self.current_word != 0 {
                 let shift = self.current_word.trailing_zeros() as usize;
-                // Two shifts to avoid an overflow in the case of `shift == 63`.
+                // Two shifts to avoid an overflow in the case of `shift == usize::BITS - 1`.
                 self.current_word >>= shift;
                 self.current_word >>= 1;
                 self.next_bit_index += shift + 1;
@@ -172,14 +166,13 @@ impl BitmapIterator {
                 return;
             }
 
-            // Move on to next word, always within a 64-bit boundary.
+            // Move on to next word.
             self.next_bit_index += self.leading_zeros;
             if self.next_bit_index < BIT_INDEX_END {
-                debug_assert_eq!(self.next_bit_index % u8::BITS as usize, 0);
-                let word64_index = self.next_bit_index / u8::BITS as usize;
-                // The bitmap pointer is guaranteed to be always 64-bit aligned, see `BitmapIterator::new()`.
+                debug_assert_eq!(self.next_bit_index % BITS_PER_BYTE, 0);
+                let word_index = self.next_bit_index / BITS_PER_BYTE;
                 self.current_word =
-                    unsafe { *(self.bitmap_pointer.add(word64_index) as *const u64) };
+                    unsafe { *(self.bitmap_pointer.add(word_index) as *const usize) };
                 self.leading_zeros = self.current_word.leading_zeros() as usize;
             }
         }
diff --git a/rts/motoko-rts/src/gc/incremental/partitioned_heap.rs b/rts/motoko-rts/src/gc/incremental/partitioned_heap.rs
index 3e9765da092..174116bb3a7 100644
--- a/rts/motoko-rts/src/gc/incremental/partitioned_heap.rs
+++ b/rts/motoko-rts/src/gc/incremental/partitioned_heap.rs
@@ -1,12 +1,13 @@
 //! Partitioned heap used in incremental GC for compacting evacuation.
 //! The heap is divided in equal sized partitions of a large size `PARTITION_SIZE`.
-//! The first partition(s) may contain a static heap space with static objects that are never moved.
-//! Beyond the static objects of a partition, the dynamic heap space starts with `dynamic_size`.
+//! Some partitions contain a static (pinned) heap space that is never moved.
+//! This is used for static objects at the beginning of the heap or for a partition table.
+//! Beyond the static space of a partition, the dynamic heap space starts with `dynamic_size`.
 //!
-//! Heap layout, with N = `MAX_PARTITIONS`:
-//! ┌───────────────┬───────────────┬───────────────┬───────────────┐
-//! │  partition 0  │  partition 1  |      ...      | partition N-1 |
-//! └───────────────┴───────────────┴───────────────┴───────────────┘
+//! Heap layout, with a dynamic number of partitions:
+//! ┌───────────────┬───────────────┬───────────────┐
+//! │  partition 0  │  partition 1  |      ...      |
+//! └───────────────┴───────────────┴───────────────┘
 //!
 //! Partition layout:
 //! ┌───────────────┬───────────────┬───────────────┐
@@ -18,6 +19,15 @@
 //! Whenever a partition is full or has insufficient space to accommodate a new allocation,
 //! a new empty partition is selected for allocation.
 //!
+//! A linked list of partition tables allows dynamic growth of the heap memory even in 64-bit address
+//! space. The first partition table is placed in the record of the partitioned heap. Subsequent
+//! partition tables reside in the static space of a partition.
+//!
+//! ┌─────────────────────┐ extension ┌─────────────────────┐ extension
+//! │   Partition table   │---------->│   Partition table   │----------> ...
+//! └─────────────────────┘           └─────────────────────┘
+//! (in `PartitionedHeap`)              (in static space)
+//!
 //! On garbage collection, partitions are selected for evacuation by prioritizing high-garbage
 //! partitions. The live objects of the partitions selected for evacuation are moved out to
 //! other remaining partitions (through allocation). Thereby, objects from different evacuated
@@ -38,12 +48,18 @@
 //! of the last partition of a huge object is not used for further small object allocations,
 //! which implies limited internal fragmentation.
 
-use core::{array::from_fn, ops::Range, ptr::null_mut};
+use core::{
+    array::from_fn,
+    iter::Iterator,
+    ops::Range,
+    ptr::{null, null_mut},
+};
+
+use motoko_rts_macros::{classical_persistence, enhanced_orthogonal_persistence};
 
 use crate::{
-    constants::{MB, WASM_MEMORY_BYTE_SIZE},
     gc::incremental::mark_bitmap::BITMAP_ITERATION_END,
-    memory::Memory,
+    memory::{alloc_blob, Memory},
     rts_trap_with,
     stable_option::StableOption,
     types::*,
@@ -57,16 +73,25 @@ use super::{
 
 /// Size of each partition.
 /// Select the size of the power of two with the smallest WASM memory size in the benchmark.
-/// -> Small partitions below 32 MB are inefficient in terms of both memory and runtime costs
+/// -> Small partitions are inefficient in terms of both memory and runtime costs
 ///    due to the increased frequency of large object handling.
-/// -> Large partitions above 32 MB are a waste for small programs, since the WASM memory is
+/// -> Large partitions are a waste for small programs, since the WASM memory is
 ///    allocated in that granularity and GC is then triggered later.
-pub const PARTITION_SIZE: usize = 32 * MB;
+#[enhanced_orthogonal_persistence]
+pub const PARTITION_SIZE: usize = 64 * 1024 * 1024;
+
+#[classical_persistence]
+pub const PARTITION_SIZE: usize = 32 * 1024 * 1024;
 
-/// Total number of partitions in the memory.
+/// Number of entries per partition table.
+/// Tables are linearly linked, allowing the usage of the entire address space.
+/// Maximum contiguous space is `(PARTITION_PER_TABLE - 1) * PARTITION_SIZE`.
+const PARTITIONS_PER_TABLE: usize = 128; // 8 GB of space for 64 MB partitions and 4 GB for 32 MB partitions.
+
+/// Maximum number of partitions in the memory.
 /// For simplicity, the last partition is left unused, to avoid a numeric overflow when
 /// computing the end address of the last partition.
-const MAX_PARTITIONS: usize = (WASM_MEMORY_BYTE_SIZE.0 / PARTITION_SIZE as u64) as usize - 1;
+const MAX_PARTITIONS: usize = usize::MAX / PARTITION_SIZE;
 
 /// Partitions are only evacuated if the space occupation of alive objects in the partition
 /// is greater than this threshold.
@@ -92,6 +117,21 @@ pub struct Partition {
     update: bool,        // Specifies whether the pointers in the partition have to be updated.
 }
 
+/// Optimization: Avoiding `Option` or `Lazy`.
+#[classical_persistence]
+const UNINITIALIZED_PARTITION: Partition = Partition {
+    index: usize::MAX,
+    free: false,
+    large_content: false,
+    marked_size: 0,
+    static_size: 0,
+    dynamic_size: 0,
+    bitmap: super::mark_bitmap::DEFAULT_MARK_BITMAP,
+    temporary: false,
+    evacuate: false,
+    update: false,
+};
+
 impl Partition {
     pub fn get_index(&self) -> usize {
         self.index
@@ -174,23 +214,23 @@ impl Partition {
         use crate::constants::WORD_SIZE;
         debug_assert!(self.dynamic_space_end() <= self.end_address());
         let remaining_space = self.end_address() - self.dynamic_space_end();
-        debug_assert_eq!(remaining_space % WORD_SIZE as usize, 0);
+        debug_assert_eq!(remaining_space % WORD_SIZE, 0);
         debug_assert!(remaining_space <= PARTITION_SIZE);
         if remaining_space == 0 {
             return;
         }
         let block = self.dynamic_space_end() as *mut Tag;
-        if remaining_space == WORD_SIZE as usize {
+        if remaining_space == WORD_SIZE {
             *block = TAG_ONE_WORD_FILLER;
         } else {
             *block = TAG_FREE_SPACE;
             let header_size = size_of::<FreeSpace>().to_bytes().as_usize();
             debug_assert!(remaining_space >= header_size);
             let free_space = block as *mut FreeSpace;
-            (*free_space).words = Bytes((remaining_space - header_size) as u32).to_words();
+            (*free_space).words = Bytes(remaining_space - header_size).to_words();
             // Clear the remainder of the free space.
             let clear_start = free_space as usize + header_size;
-            let clear_length = Bytes((remaining_space - header_size) as u32);
+            let clear_length = Bytes(remaining_space - header_size);
             crate::mem_utils::memzero(clear_start, clear_length.to_words());
             debug_assert_eq!(free_space.size().to_bytes().as_usize(), remaining_space);
         }
@@ -232,6 +272,7 @@ impl Partition {
 #[repr(C)]
 pub struct PartitionedHeapIterator {
     partition_index: usize,
+    number_of_partitions: usize,
     bitmap_iterator: StableOption<BitmapIterator>,
     visit_large_object: bool,
 }
@@ -240,6 +281,7 @@ impl PartitionedHeapIterator {
     pub fn new(heap: &PartitionedHeap) -> PartitionedHeapIterator {
         let mut iterator = PartitionedHeapIterator {
             partition_index: 0,
+            number_of_partitions: heap.number_of_partitions,
             bitmap_iterator: StableOption::None,
             visit_large_object: false,
         };
@@ -250,7 +292,7 @@ impl PartitionedHeapIterator {
 
     fn skip_empty_partitions(&mut self, heap: &PartitionedHeap) {
         loop {
-            if self.partition_index == MAX_PARTITIONS {
+            if self.partition_index == self.number_of_partitions {
                 return;
             }
             let partition = heap.get_partition(self.partition_index);
@@ -262,16 +304,16 @@ impl PartitionedHeapIterator {
     }
 
     pub fn has_partition(&self) -> bool {
-        self.partition_index < MAX_PARTITIONS
+        self.partition_index < self.number_of_partitions
     }
 
     pub fn current_partition<'a>(&self, heap: &'a PartitionedHeap) -> &'a Partition {
-        debug_assert!(self.partition_index < MAX_PARTITIONS);
+        debug_assert!(self.partition_index < self.number_of_partitions);
         heap.get_partition(self.partition_index)
     }
 
     pub unsafe fn next_partition(&mut self, heap: &PartitionedHeap) {
-        debug_assert!(self.partition_index < MAX_PARTITIONS);
+        debug_assert!(self.partition_index < self.number_of_partitions);
         let partition = heap.get_partition(self.partition_index);
         let number_of_partitions = if partition.has_large_content() {
             let large_object = partition.dynamic_space_start() as *mut Obj;
@@ -285,8 +327,8 @@ impl PartitionedHeapIterator {
     }
 
     fn start_object_iteration(&mut self, heap: &PartitionedHeap) {
-        debug_assert!(self.partition_index <= MAX_PARTITIONS);
-        if self.partition_index == MAX_PARTITIONS {
+        debug_assert!(self.partition_index <= self.number_of_partitions);
+        if self.partition_index == self.number_of_partitions {
             self.bitmap_iterator = StableOption::None;
             self.visit_large_object = false;
         } else {
@@ -337,11 +379,111 @@ impl PartitionedHeapIterator {
     }
 }
 
+/// The first table is part of the static `PartionedHeap` record.
+/// Extension tables reside in the static space of a partition.
+/// Therefore, partition tables are never moved in memory.
+#[repr(C)]
+struct PartitionTable {
+    partitions: [Partition; PARTITIONS_PER_TABLE],
+    extension: *mut PartitionTable,
+}
+
+/// Optimization: Avoiding `Option` or `Lazy`.
+#[classical_persistence]
+const UNINITIALIZED_PARTITION_TABLE: PartitionTable = PartitionTable {
+    partitions: [UNINITIALIZED_PARTITION; PARTITIONS_PER_TABLE],
+    extension: null_mut(),
+};
+
+const PARTITION_TABLE_SIZE: usize = core::mem::size_of::<PartitionTable>();
+
+impl PartitionTable {
+    /// The start index is the first partition index in the table.
+    /// The static space starts at the first partition entry of the partition table.
+    pub fn new(start_index: usize, static_space: usize) -> PartitionTable {
+        let completely_static_partitions = static_space / PARTITION_SIZE;
+        let partitions = from_fn(|offset| Partition {
+            index: start_index + offset,
+            free: true,
+            large_content: false,
+            marked_size: 0,
+            static_size: if offset < completely_static_partitions {
+                PARTITION_SIZE
+            } else if offset == completely_static_partitions {
+                static_space % PARTITION_SIZE
+            } else {
+                0
+            },
+            dynamic_size: 0,
+            bitmap: MarkBitmap::new(),
+            temporary: false,
+            evacuate: false,
+            update: false,
+        });
+        PartitionTable {
+            partitions,
+            extension: null_mut(),
+        }
+    }
+
+    /// The table address must point to static partition space.
+    /// The start index is the first partition index in the table.
+    /// The static space starts at the first partition entry of the partition table.
+    pub unsafe fn allocate(
+        table_address: usize,
+        start_index: usize,
+        static_space: usize,
+    ) -> *mut PartitionTable {
+        let table = table_address as *mut PartitionTable;
+        *table = Self::new(start_index, static_space);
+        table
+    }
+}
+
+struct PartitionIterator {
+    table: *mut PartitionTable,
+    index: usize,
+}
+
+impl PartitionIterator {
+    pub fn new(heap: &mut PartitionedHeap) -> PartitionIterator {
+        let first_table = &mut heap.partition_table as *mut PartitionTable;
+        PartitionIterator {
+            table: first_table,
+            index: 0,
+        }
+    }
+}
+
+impl Iterator for PartitionIterator {
+    type Item = &'static mut Partition;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        debug_assert_ne!(self.table, null_mut());
+        if self.index > MAX_PARTITIONS {
+            return None;
+        }
+        let table_offset = self.index % PARTITIONS_PER_TABLE;
+        unsafe {
+            if self.index > 0 && table_offset == 0 {
+                self.table = (*self.table).extension;
+                if self.table == null_mut() {
+                    return None;
+                }
+            }
+            let partition = &mut (*self.table).partitions[table_offset];
+            self.index += 1;
+            Some(partition)
+        }
+    }
+}
+
 /// Partitioned heap used by the incremental GC.
 /// Use a long-term representation by relying on C layout.
 #[repr(C)]
 pub struct PartitionedHeap {
-    partitions: [Partition; MAX_PARTITIONS],
+    partition_table: PartitionTable,
+    number_of_partitions: usize,
     heap_base: usize,
     allocation_index: usize, // Index of the partition currently used for allocations.
     free_partitions: usize,  // Number of free partitions.
@@ -353,32 +495,34 @@ pub struct PartitionedHeap {
     evacuated_size: usize, // Size of all evacuated objects during a GC run. Serves for accurate total allocation statistics.
 }
 
+/// Optimization: Avoiding `Option` or `LazyCell`.
+#[classical_persistence]
+pub const UNINITIALIZED_HEAP: PartitionedHeap = PartitionedHeap {
+    partition_table: UNINITIALIZED_PARTITION_TABLE,
+    number_of_partitions: 0,
+    heap_base: 0,
+    allocation_index: 0,
+    free_partitions: 0,
+    evacuating: false,
+    reclaimed: 0,
+    bitmap_allocation_pointer: 0,
+    gc_running: false,
+    precomputed_heap_size: 0,
+    evacuated_size: 0,
+};
+
 impl PartitionedHeap {
-    pub unsafe fn new<M: Memory>(mem: &mut M, heap_base: usize) -> PartitionedHeap {
+    pub fn new(heap_base: usize) -> PartitionedHeap {
+        let number_of_partitions = PARTITIONS_PER_TABLE;
         let allocation_index = heap_base / PARTITION_SIZE;
-        mem.grow_memory(((allocation_index + 1) * PARTITION_SIZE) as u64);
-        let partitions = from_fn(|index| Partition {
-            index,
-            free: index > allocation_index,
-            large_content: false,
-            marked_size: 0,
-            static_size: if index < allocation_index {
-                PARTITION_SIZE
-            } else if index == allocation_index {
-                heap_base % PARTITION_SIZE
-            } else {
-                0
-            },
-            dynamic_size: 0,
-            bitmap: MarkBitmap::new(),
-            temporary: false,
-            evacuate: false,
-            update: false,
-        });
-        debug_assert!(allocation_index <= MAX_PARTITIONS);
-        let free_partitions = MAX_PARTITIONS - allocation_index - 1;
+        let mut partition_table = PartitionTable::new(0, heap_base);
+        for index in 0..allocation_index + 1 {
+            partition_table.partitions[index].free = false;
+        }
+        let free_partitions = number_of_partitions - allocation_index - 1;
         PartitionedHeap {
-            partitions,
+            partition_table,
+            number_of_partitions,
             heap_base,
             allocation_index,
             free_partitions,
@@ -391,47 +535,132 @@ impl PartitionedHeap {
         }
     }
 
+    pub fn maximum_mark_bitmap_size(&self) -> usize {
+        debug_assert!(self.free_partitions <= self.number_of_partitions);
+        let used_partitions = self.number_of_partitions - self.free_partitions;
+        used_partitions * BITMAP_SIZE
+    }
+
+    fn partitions(&mut self) -> PartitionIterator {
+        PartitionIterator::new(self)
+    }
+
     pub fn is_initialized(&self) -> bool {
-        self.partitions[0].index == 0
+        self.number_of_partitions > 0
     }
 
     pub fn base_address(&self) -> usize {
         self.heap_base
     }
 
+    unsafe fn get_extension_table(&self, partition_index: usize) -> *mut PartitionTable {
+        debug_assert!(partition_index >= PARTITIONS_PER_TABLE);
+        let mut index = partition_index - PARTITIONS_PER_TABLE;
+        let mut table = self.partition_table.extension;
+        while index >= PARTITIONS_PER_TABLE {
+            index -= PARTITIONS_PER_TABLE;
+            debug_assert_ne!((*table).extension, null_mut());
+            table = (*table).extension;
+        }
+        table
+    }
+
+    unsafe fn get_partition_table(&self, partition_index: usize) -> *const PartitionTable {
+        if partition_index < PARTITIONS_PER_TABLE {
+            let first_table = &self.partition_table as *const PartitionTable;
+            debug_assert_ne!(first_table, null());
+            first_table
+        } else {
+            self.get_extension_table(partition_index)
+        }
+    }
+
+    unsafe fn mutable_partition_table(&mut self, partition_index: usize) -> *mut PartitionTable {
+        self.get_partition_table(partition_index) as *mut PartitionTable
+    }
+
     pub fn get_partition(&self, index: usize) -> &Partition {
-        &self.partitions[index]
+        unsafe {
+            let table = self.get_partition_table(index);
+            let offset = index % PARTITIONS_PER_TABLE;
+            &(*table).partitions[offset]
+        }
     }
 
     fn mutable_partition(&mut self, index: usize) -> &mut Partition {
-        &mut self.partitions[index]
+        unsafe {
+            let table = self.mutable_partition_table(index);
+            let offset = index % PARTITIONS_PER_TABLE;
+            &mut (*table).partitions[offset]
+        }
+    }
+
+    unsafe fn add_partition_table<M: Memory>(&mut self, mem: &mut M) {
+        debug_assert!(self.number_of_partitions > 0);
+        let last_table = self.mutable_partition_table(self.number_of_partitions - 1);
+        debug_assert_ne!(last_table, null_mut());
+        debug_assert_eq!((*last_table).extension, null_mut());
+        let table_address = self.number_of_partitions * PARTITION_SIZE;
+        mem.grow_memory(table_address + PARTITION_SIZE);
+        (*last_table).extension = PartitionTable::allocate(
+            table_address,
+            self.number_of_partitions,
+            PARTITION_TABLE_SIZE,
+        );
+        // The partition table is small enough such that all partitions contain free space.
+        debug_assert!(PARTITION_TABLE_SIZE < PARTITION_SIZE);
+        self.free_partitions += PARTITIONS_PER_TABLE;
+        self.number_of_partitions += PARTITIONS_PER_TABLE;
+        self.precomputed_heap_size += PARTITION_TABLE_SIZE;
     }
 
-    unsafe fn allocate_temporary_partition(&mut self) -> &mut Partition {
-        for partition in &mut self.partitions {
+    unsafe fn allocate_partition<M: Memory, F: Fn(&mut Self) -> Option<usize>>(
+        &mut self,
+        mem: &mut M,
+        find_partition: &F,
+    ) -> usize {
+        let mut result = find_partition(self);
+        if result.is_none() {
+            self.add_partition_table(mem);
+            result = find_partition(self);
+        }
+        if result.is_none() {
+            rts_trap_with("Cannot grow memory");
+        }
+        result.unwrap()
+    }
+
+    fn scan_for_temporary_partition(&mut self) -> Option<usize> {
+        for partition in self.partitions() {
             if partition.is_completely_free() {
-                debug_assert_eq!(partition.dynamic_size, 0);
-                partition.free = false;
-                partition.temporary = true;
-                debug_assert!(self.free_partitions > 0);
-                self.free_partitions -= 1;
-                return partition;
+                return Some(partition.index);
             }
         }
-        rts_trap_with("Cannot grow memory");
+        None
+    }
+
+    unsafe fn allocate_temporary_partition<M: Memory>(&mut self, mem: &mut M) -> &mut Partition {
+        let index = self.allocate_partition(mem, &Self::scan_for_temporary_partition);
+        debug_assert!(self.free_partitions > 0);
+        self.free_partitions -= 1;
+        let partition = self.mutable_partition(index);
+        debug_assert_eq!(partition.dynamic_size, 0);
+        partition.free = false;
+        partition.temporary = true;
+        partition
     }
 
     /// The returned bitmap address is guaranteed to be 64-bit-aligned.
     unsafe fn allocate_bitmap<M: Memory>(&mut self, mem: &mut M) -> *mut u8 {
         if self.bitmap_allocation_pointer % PARTITION_SIZE == 0 {
-            let partition = self.allocate_temporary_partition();
-            mem.grow_memory(partition.end_address() as u64);
+            let partition = self.allocate_temporary_partition(mem);
+            mem.grow_memory(partition.end_address());
             self.bitmap_allocation_pointer = partition.start_address();
         }
         let bitmap_address = self.bitmap_allocation_pointer as *mut u8;
         self.bitmap_allocation_pointer += BITMAP_SIZE;
         debug_assert_eq!(
-            bitmap_address as usize % size_of::<u64>().to_bytes().as_usize(),
+            bitmap_address as usize % size_of::<usize>().to_bytes().as_usize(),
             0
         );
         bitmap_address
@@ -473,23 +702,21 @@ impl PartitionedHeap {
         debug_assert_eq!(self.bitmap_allocation_pointer, 0);
         debug_assert!(!self.gc_running);
         self.gc_running = true;
-        for partition_index in 0..MAX_PARTITIONS {
+        for partition_index in 0..self.number_of_partitions {
             let partition = self.get_partition(partition_index);
             if partition.has_dynamic_space() && !partition.has_large_content() {
                 let bitmap_address = self.allocate_bitmap(mem);
                 self.mutable_partition(partition_index)
                     .bitmap
                     .assign(bitmap_address);
-                time.advance(Bytes(BITMAP_SIZE as u32).to_words().as_usize());
+                time.advance(Bytes(BITMAP_SIZE).to_words().as_usize());
             }
         }
     }
 
-    pub fn plan_evacuations(&mut self) {
-        let ranked_partitions = self.rank_partitions_by_garbage();
+    pub unsafe fn plan_evacuations<M: Memory>(&mut self, mem: &mut M) {
         debug_assert_eq!(
-            self.partitions
-                .iter()
+            self.partitions()
                 .filter(|partition| partition.is_free())
                 .count(),
             self.free_partitions
@@ -500,7 +727,9 @@ impl PartitionedHeap {
         let reserved_partitions =
             (self.free_partitions + EVACUATION_FRACTION - 1) / EVACUATION_FRACTION;
         let mut evacuation_space = reserved_partitions * PARTITION_SIZE;
-        for index in ranked_partitions {
+        let ranked_partitions = self.rank_partitions_by_garbage(mem);
+        for rank in 0..self.number_of_partitions {
+            let index = *ranked_partitions.add(rank);
             if index != self.allocation_index && self.get_partition(index).is_evacuation_candidate()
             {
                 let partition = self.mutable_partition(index);
@@ -516,26 +745,40 @@ impl PartitionedHeap {
         }
     }
 
-    fn rank_partitions_by_garbage(&self) -> [usize; MAX_PARTITIONS] {
-        let mut ranked_partitions: [usize; MAX_PARTITIONS] = from_fn(|index| index);
-        sort(&mut ranked_partitions, &|left, right| {
-            self.get_partition(left)
-                .garbage_amount()
-                .cmp(&self.get_partition(right).garbage_amount())
-                .reverse()
-        });
+    unsafe fn temporary_array<M: Memory>(mem: &mut M, length: usize) -> *mut usize {
+        // No post allocation barrier as this RTS-internal blob can be collected by the GC.
+        let blob = alloc_blob(mem, TAG_BLOB_B, Words(length).to_bytes());
+        let payload = blob.as_blob_mut().payload_addr();
+        payload as *mut usize
+    }
+
+    unsafe fn rank_partitions_by_garbage<M: Memory>(&self, mem: &mut M) -> *mut usize {
+        let ranked_partitions = Self::temporary_array(mem, self.number_of_partitions);
+        for index in 0..self.number_of_partitions {
+            *ranked_partitions.add(index) = index;
+        }
+        sort(
+            ranked_partitions,
+            self.number_of_partitions,
+            &|left, right| {
+                self.get_partition(left)
+                    .garbage_amount()
+                    .cmp(&self.get_partition(right).garbage_amount())
+                    .reverse()
+            },
+        );
         ranked_partitions
     }
 
     pub fn plan_updates(&mut self) {
-        for partition in &mut self.partitions {
+        for partition in self.partitions() {
             debug_assert!(!partition.update);
             partition.update = !partition.is_free() && !partition.evacuate;
         }
     }
 
     pub unsafe fn complete_collection(&mut self) {
-        for partition in &mut self.partitions {
+        for partition in self.partitions() {
             let marked_size = partition.marked_size;
             partition.update = false;
             partition.marked_size = 0;
@@ -564,17 +807,26 @@ impl PartitionedHeap {
     }
 
     fn allocation_partition(&self) -> &Partition {
-        &self.partitions[self.allocation_index]
+        self.get_partition(self.allocation_index)
     }
 
     fn mut_allocation_partition(&mut self) -> &mut Partition {
-        &mut self.partitions[self.allocation_index]
+        self.mutable_partition(self.allocation_index)
     }
 
     pub fn is_allocation_partition(&self, index: usize) -> bool {
         self.allocation_index == index
     }
 
+    fn scan_for_free_partition(&mut self, requested_space: usize) -> Option<usize> {
+        for partition in self.partitions() {
+            if partition.free && partition.free_size() >= requested_space {
+                return Some(partition.index);
+            }
+        }
+        None
+    }
+
     unsafe fn allocate_free_partition<M: Memory>(
         &mut self,
         mem: &mut M,
@@ -585,40 +837,38 @@ impl PartitionedHeap {
         } else {
             null_mut()
         };
-        for partition in &mut self.partitions {
-            if partition.free && partition.free_size() >= requested_space {
-                debug_assert_eq!(partition.dynamic_size, 0);
-                partition.free = false;
-                debug_assert!(self.free_partitions > 0);
-                self.free_partitions -= 1;
-                if bitmap_address != null_mut() {
-                    partition.bitmap.assign(bitmap_address);
-                }
-                return partition;
-            }
+        let index = self.allocate_partition(mem, &|context| {
+            context.scan_for_free_partition(requested_space)
+        });
+        debug_assert!(self.free_partitions > 0);
+        self.free_partitions -= 1;
+        let partition = self.mutable_partition(index);
+        debug_assert_eq!(partition.dynamic_size, 0);
+        partition.free = false;
+        if bitmap_address != null_mut() {
+            partition.bitmap.assign(bitmap_address);
         }
-        rts_trap_with("Cannot grow memory");
+        partition
     }
 
-    fn check_occupied_size(&self) {
+    fn check_occupied_size(&mut self) {
         debug_assert_eq!(
-            self.partitions
-                .iter()
+            self.partitions()
                 .map(|partition| partition.static_size + partition.dynamic_size)
                 .sum::<usize>(),
             self.occupied_size().as_usize()
         );
     }
 
-    pub fn occupied_size(&self) -> Bytes<u32> {
-        Bytes((self.precomputed_heap_size + self.allocation_partition().dynamic_size) as u32)
+    pub fn occupied_size(&self) -> Bytes<usize> {
+        Bytes(self.precomputed_heap_size + self.allocation_partition().dynamic_size)
     }
 
     pub fn reclaimed_size(&self) -> Bytes<u64> {
         Bytes(self.reclaimed)
     }
 
-    pub fn increase_evacuated_size(&mut self, size: Words<u32>) {
+    pub fn increase_evacuated_size(&mut self, size: Words<usize>) {
         self.evacuated_size += size.to_bytes().as_usize();
     }
 
@@ -628,7 +878,7 @@ impl PartitionedHeap {
         Bytes(heap_size_without_evacuations as u64) + self.reclaimed_size()
     }
 
-    pub unsafe fn allocate<M: Memory>(&mut self, mem: &mut M, words: Words<u32>) -> Value {
+    pub unsafe fn allocate<M: Memory>(&mut self, mem: &mut M, words: Words<usize>) -> Value {
         let size = words.to_bytes().as_usize();
         if size <= PARTITION_SIZE {
             self.allocate_normal_object(mem, size)
@@ -660,7 +910,7 @@ impl PartitionedHeap {
         self.precomputed_heap_size += self.allocation_partition().dynamic_size;
 
         let new_partition = self.allocate_free_partition(mem, size);
-        mem.grow_memory(new_partition.end_address() as u64);
+        mem.grow_memory(new_partition.end_address());
         let heap_pointer = new_partition.dynamic_space_end();
         new_partition.dynamic_size += size;
         self.allocation_index = new_partition.index;
@@ -676,14 +926,16 @@ impl PartitionedHeap {
         let number_of_partitions = (size + PARTITION_SIZE - 1) / PARTITION_SIZE;
         debug_assert!(number_of_partitions > 0);
 
-        let first_index = self.find_large_space(number_of_partitions);
+        let first_index = self.allocate_partition(mem, &|context| {
+            context.scan_for_large_space(number_of_partitions)
+        });
         let last_index = first_index + number_of_partitions - 1;
 
         debug_assert!(self.free_partitions >= number_of_partitions);
         self.free_partitions -= number_of_partitions;
 
         let end_address = self.get_partition(last_index).end_address();
-        mem.grow_memory(end_address as u64);
+        mem.grow_memory(end_address);
         for index in first_index..last_index + 1 {
             let partition = self.mutable_partition(index);
             debug_assert!(partition.free);
@@ -707,19 +959,19 @@ impl PartitionedHeap {
         Value::from_ptr(first_partition.dynamic_space_start())
     }
 
-    unsafe fn find_large_space(&self, number_of_partitions: usize) -> usize {
+    unsafe fn scan_for_large_space(&self, number_of_partitions: usize) -> Option<usize> {
         let mut start_of_free_range = 0;
-        for index in 0..MAX_PARTITIONS {
+        for index in 0..self.number_of_partitions {
             // Invariant: [start_of_free_range .. index) contains only free partitions.
             if self.get_partition(index).is_completely_free() {
                 if index + 1 - start_of_free_range >= number_of_partitions {
-                    return start_of_free_range;
+                    return Some(start_of_free_range);
                 }
             } else {
                 start_of_free_range = index + 1;
             }
         }
-        rts_trap_with("Cannot grow memory");
+        None
     }
 
     unsafe fn occupied_partition_range(large_object: *mut Obj) -> Range<usize> {
@@ -737,7 +989,7 @@ impl PartitionedHeap {
 
     pub unsafe fn collect_large_objects(&mut self) {
         let mut index = 0;
-        while index < MAX_PARTITIONS {
+        while index < self.number_of_partitions {
             let partition = self.get_partition(index);
             if partition.has_large_content() {
                 debug_assert!(!partition.free);
@@ -772,20 +1024,28 @@ impl PartitionedHeap {
     #[inline(never)]
     unsafe fn mark_large_object(&mut self, object: *mut Obj) -> bool {
         let range = Self::occupied_partition_range(object);
-        if self.partitions[range.start].marked_size > 0 {
+        if self.get_partition(range.start).marked_size > 0 {
             return false;
         }
         for index in range.start..range.end - 1 {
-            self.partitions[index].marked_size = PARTITION_SIZE;
+            self.mutable_partition(index).marked_size = PARTITION_SIZE;
         }
         let object_size = block_size(object as usize).to_bytes().as_usize();
-        self.partitions[range.end - 1].marked_size = object_size % PARTITION_SIZE;
+        self.mutable_partition(range.end - 1).marked_size = object_size % PARTITION_SIZE;
         true
     }
 
     #[cfg(debug_assertions)]
     unsafe fn is_large_object_marked(&self, object: *mut Obj) -> bool {
         let range = Self::occupied_partition_range(object);
-        self.partitions[range.start].marked_size > 0
+        self.get_partition(range.start).marked_size > 0
     }
 }
+
+#[cfg(feature = "ic")]
+pub(crate) unsafe fn allocate_initial_memory(heap_base: Bytes<usize>) {
+    use crate::memory::ic::allocate_wasm_memory;
+
+    let memory_size = heap_base.next_multiple_of(PARTITION_SIZE);
+    allocate_wasm_memory(memory_size);
+}
diff --git a/rts/motoko-rts/src/gc/incremental/phases/evacuation_increment.rs b/rts/motoko-rts/src/gc/incremental/phases/evacuation_increment.rs
index 548f0f62b07..50f414ea031 100644
--- a/rts/motoko-rts/src/gc/incremental/phases/evacuation_increment.rs
+++ b/rts/motoko-rts/src/gc/incremental/phases/evacuation_increment.rs
@@ -18,11 +18,11 @@ pub struct EvacuationIncrement<'a, M: Memory> {
 }
 
 impl<'a, M: Memory + 'a> EvacuationIncrement<'a, M> {
-    pub unsafe fn start_phase(state: &mut State) {
+    pub unsafe fn start_phase(mem: &mut M, state: &mut State) {
         debug_assert!(state.iterator_state.is_none());
         let heap = &mut state.partitioned_heap;
         state.iterator_state = StableOption::Some(PartitionedHeapIterator::new(heap));
-        heap.plan_evacuations();
+        heap.plan_evacuations(mem);
     }
 
     pub unsafe fn complete_phase(state: &mut State) {
diff --git a/rts/motoko-rts/src/gc/incremental/phases/mark_increment.rs b/rts/motoko-rts/src/gc/incremental/phases/mark_increment.rs
index e71c8be3713..7ddc52c6088 100644
--- a/rts/motoko-rts/src/gc/incremental/phases/mark_increment.rs
+++ b/rts/motoko-rts/src/gc/incremental/phases/mark_increment.rs
@@ -1,3 +1,5 @@
+use motoko_rts_macros::{classical_persistence, enhanced_orthogonal_persistence};
+
 use crate::{
     gc::incremental::{
         array_slicing::slice_array,
@@ -67,7 +69,7 @@ impl<'a, M: Memory + 'a> MarkIncrement<'a, M> {
     }
 
     pub unsafe fn mark_roots(&mut self, roots: Roots) {
-        visit_roots(roots, self, |gc, field| {
+        visit_roots(roots, self.heap.base_address(), self, |gc, field| {
             gc.mark_object(*field);
             gc.time.tick();
         });
@@ -81,7 +83,12 @@ impl<'a, M: Memory + 'a> MarkIncrement<'a, M> {
         }
         loop {
             let value = self.mark_stack.pop();
+
+            #[enhanced_orthogonal_persistence]
             debug_assert!(value.is_non_null_ptr());
+            #[classical_persistence]
+            debug_assert!(value.is_ptr());
+
             if value == STACK_EMPTY {
                 self.complete_marking();
                 return;
@@ -98,7 +105,10 @@ impl<'a, M: Memory + 'a> MarkIncrement<'a, M> {
 
     pub unsafe fn mark_object(&mut self, value: Value) {
         self.time.tick();
+
+        #[enhanced_orthogonal_persistence]
         debug_assert_ne!(value, NULL_POINTER);
+
         debug_assert!((value.get_ptr() >= self.heap.base_address()));
         debug_assert!(!value.is_forwarded());
         let object = value.as_obj();
@@ -115,6 +125,7 @@ impl<'a, M: Memory + 'a> MarkIncrement<'a, M> {
             self,
             object,
             object.tag(),
+            self.heap.base_address(),
             |gc, field_address| {
                 let field_value = *field_address;
                 gc.mark_object(field_value);
@@ -124,7 +135,7 @@ impl<'a, M: Memory + 'a> MarkIncrement<'a, M> {
                 if (*array).header.tag >= TAG_ARRAY_SLICE_MIN {
                     gc.mark_stack.push(gc.mem, Value::from_ptr(array as usize));
                 }
-                gc.time.advance(1 + (length - slice_start) as usize);
+                gc.time.advance(1 + length - slice_start);
                 length
             },
         );
diff --git a/rts/motoko-rts/src/gc/incremental/phases/update_increment.rs b/rts/motoko-rts/src/gc/incremental/phases/update_increment.rs
index 57e0dc21c54..ee9159ed03c 100644
--- a/rts/motoko-rts/src/gc/incremental/phases/update_increment.rs
+++ b/rts/motoko-rts/src/gc/incremental/phases/update_increment.rs
@@ -1,3 +1,5 @@
+use motoko_rts_macros::enhanced_orthogonal_persistence;
+
 use crate::{
     gc::incremental::{
         array_slicing::slice_array,
@@ -50,9 +52,12 @@ impl<'a> UpdateIncrement<'a> {
     }
 
     pub unsafe fn update_roots(&mut self, roots: Roots) {
-        visit_roots(roots, self, |gc, field| {
+        visit_roots(roots, self.heap.base_address(), self, |gc, field| {
             let value = *field;
+
+            #[enhanced_orthogonal_persistence]
             debug_assert_ne!(value, NULL_POINTER);
+
             if value.is_forwarded() {
                 *field = value.forward_if_possible();
             }
@@ -108,13 +113,14 @@ impl<'a> UpdateIncrement<'a> {
                 self,
                 object,
                 object.tag(),
+                self.heap.base_address(),
                 |gc, field_address| {
                     *field_address = (*field_address).forward_if_possible();
                     gc.time.tick();
                 },
                 |gc, slice_start, array| {
                     let length = slice_array(array);
-                    gc.time.advance(1 + (length - slice_start) as usize);
+                    gc.time.advance(1 + length - slice_start);
                     length
                 },
             );
diff --git a/rts/motoko-rts/src/gc/incremental/roots.rs b/rts/motoko-rts/src/gc/incremental/roots.rs
index afef9cf7577..b0ad5a77d84 100644
--- a/rts/motoko-rts/src/gc/incremental/roots.rs
+++ b/rts/motoko-rts/src/gc/incremental/roots.rs
@@ -1,84 +1,47 @@
-use motoko_rts_macros::ic_mem_fn;
+#[enhanced_orthogonal_persistence]
+pub mod enhanced;
 
-use crate::{types::Value, visitor::is_non_null_pointer_field};
+#[classical_persistence]
+pub mod classical;
 
-/// An array referring to the static program variables, being
-/// - All canister variables.
-/// - Pooled shared objects.
-/// The array constitutes a GC root that is reinitialized on each canister upgrade.
-/// The scalar sentinel denotes an uninitialized root.
-#[cfg(feature = "ic")]
-static mut STATIC_VARIABLES: Value = crate::types::NULL_POINTER;
+use motoko_rts_macros::{classical_persistence, enhanced_orthogonal_persistence};
 
-/// Sanity check for the variable initialization: The variables must be initialized
-/// in increasing order and may only read precedingly initialized variables.
-#[cfg(feature = "ic")]
-static mut INITIALIZED_VARIABLES: u32 = 0;
+use crate::types::Value;
+
+#[enhanced_orthogonal_persistence]
+pub type Roots = self::enhanced::Roots;
 
-/// GC root set.
-pub type Roots = [*mut Value; 6];
+#[classical_persistence]
+pub type Roots = self::classical::Roots;
 
 #[cfg(feature = "ic")]
+#[enhanced_orthogonal_persistence]
 pub unsafe fn root_set() -> Roots {
-    use crate::{
-        continuation_table::continuation_table_loc,
-        persistence::{stable_actor_location, stable_type_descriptor},
-        region::region0_get_ptr_loc,
-    };
-    [
-        static_variables_location(),
-        continuation_table_loc(),
-        stable_actor_location(),
-        stable_type_descriptor().candid_data_location(),
-        stable_type_descriptor().type_offsets_location(),
-        region0_get_ptr_loc(),
-    ]
+    self::enhanced::root_set()
 }
 
+#[cfg(feature = "ic")]
+#[classical_persistence]
+pub unsafe fn root_set() -> Roots {
+    self::classical::root_set()
+}
+
+#[enhanced_orthogonal_persistence]
 pub unsafe fn visit_roots<C, V: Fn(&mut C, *mut Value)>(
     roots: Roots,
+    _heap_base: usize, // Only used with classical persistence.
     context: &mut C,
     visit_field: V,
 ) {
-    for location in roots {
-        if is_non_null_pointer_field(location) {
-            visit_field(context, location);
-        }
-    }
+    self::enhanced::visit_roots(roots, context, visit_field);
 }
 
-#[cfg(feature = "ic")]
-unsafe fn static_variables_location() -> *mut Value {
-    &mut STATIC_VARIABLES as *mut Value
-}
-
-#[ic_mem_fn(ic_only)]
-pub unsafe fn initialize_static_variables<M: crate::memory::Memory>(mem: &mut M, amount: u32) {
-    use super::barriers::write_with_barrier;
-    use crate::memory::alloc_array;
-    use crate::types::{NULL_POINTER, TAG_ARRAY_M};
-
-    let variables = alloc_array(mem, TAG_ARRAY_M, amount);
-    let array = variables.as_array();
-    for index in 0..amount {
-        array.initialize(index, NULL_POINTER, mem);
-    }
-    let location = &mut STATIC_VARIABLES as *mut Value;
-    write_with_barrier(mem, location, variables);
-}
-
-#[no_mangle]
-#[cfg(feature = "ic")]
-pub unsafe extern "C" fn get_static_variable(index: u32) -> Value {
-    debug_assert!(STATIC_VARIABLES.is_non_null_ptr());
-    debug_assert!(index < INITIALIZED_VARIABLES);
-    STATIC_VARIABLES.as_array().get(index)
-}
-
-#[ic_mem_fn(ic_only)]
-pub unsafe fn set_static_variable<M: crate::memory::Memory>(mem: &mut M, index: u32, value: Value) {
-    debug_assert!(STATIC_VARIABLES.is_non_null_ptr());
-    debug_assert!(index == INITIALIZED_VARIABLES);
-    STATIC_VARIABLES.as_array().set(index, value, mem);
-    INITIALIZED_VARIABLES += 1;
+#[classical_persistence]
+pub unsafe fn visit_roots<C, V: Fn(&mut C, *mut Value)>(
+    roots: Roots,
+    heap_base: usize, // Only used with classical persistence.
+    context: &mut C,
+    visit_field: V,
+) {
+    self::classical::visit_roots(roots, heap_base, context, visit_field);
 }
diff --git a/rts/motoko-rts/src/gc/incremental/roots/classical.rs b/rts/motoko-rts/src/gc/incremental/roots/classical.rs
new file mode 100644
index 00000000000..d6313822fb1
--- /dev/null
+++ b/rts/motoko-rts/src/gc/incremental/roots/classical.rs
@@ -0,0 +1,75 @@
+use crate::types::Value;
+use crate::visitor::classical::pointer_to_dynamic_heap;
+
+#[derive(Clone, Copy)]
+pub struct Roots {
+    pub static_roots: Value,
+    pub continuation_table_location: *mut Value,
+    pub region0_ptr_location: *mut Value,
+    // If new roots are added in future, extend `visit_roots()`.
+}
+
+#[cfg(feature = "ic")]
+pub unsafe fn root_set() -> Roots {
+    use crate::memory::ic;
+    Roots {
+        static_roots: ic::get_static_roots(),
+        continuation_table_location: crate::continuation_table::continuation_table_loc(),
+        region0_ptr_location: crate::region::region0_get_ptr_loc(),
+    }
+}
+
+pub unsafe fn visit_roots<C, V: Fn(&mut C, *mut Value)>(
+    roots: Roots,
+    heap_base: usize,
+    context: &mut C,
+    visit_field: V,
+) {
+    visit_static_roots(roots.static_roots, heap_base, context, &visit_field);
+    visit_continuation_table(
+        roots.continuation_table_location,
+        heap_base,
+        context,
+        &visit_field,
+    );
+    visit_region0_ptr(roots.region0_ptr_location, heap_base, context, &visit_field);
+}
+
+unsafe fn visit_static_roots<C, V: Fn(&mut C, *mut Value)>(
+    static_roots: Value,
+    heap_base: usize,
+    context: &mut C,
+    visit_field: &V,
+) {
+    let root_array = static_roots.as_array();
+    for index in 0..root_array.len() {
+        let mutbox = root_array.get(index).as_mutbox();
+        debug_assert!((mutbox as usize) < heap_base);
+        let field = &mut (*mutbox).field;
+        if pointer_to_dynamic_heap(field, heap_base) {
+            visit_field(context, field);
+        }
+    }
+}
+
+unsafe fn visit_continuation_table<C, V: Fn(&mut C, *mut Value)>(
+    continuation_table_location: *mut Value,
+    heap_base: usize,
+    context: &mut C,
+    visit_field: &V,
+) {
+    if pointer_to_dynamic_heap(continuation_table_location, heap_base) {
+        visit_field(context, continuation_table_location);
+    }
+}
+
+unsafe fn visit_region0_ptr<C, V: Fn(&mut C, *mut Value)>(
+    region0_ptr_location: *mut Value,
+    heap_base: usize,
+    context: &mut C,
+    visit_field: &V,
+) {
+    if pointer_to_dynamic_heap(region0_ptr_location, heap_base) {
+        visit_field(context, region0_ptr_location);
+    }
+}
diff --git a/rts/motoko-rts/src/gc/incremental/roots/enhanced.rs b/rts/motoko-rts/src/gc/incremental/roots/enhanced.rs
new file mode 100644
index 00000000000..a34feee9406
--- /dev/null
+++ b/rts/motoko-rts/src/gc/incremental/roots/enhanced.rs
@@ -0,0 +1,89 @@
+use motoko_rts_macros::ic_mem_fn;
+
+use crate::types::Value;
+use crate::visitor::enhanced::is_non_null_pointer_field;
+
+/// An array referring to the static program variables, being
+/// - All canister variables.
+/// - Pooled shared objects.
+/// The array constitutes a GC root that is reinitialized on each canister upgrade.
+/// The scalar sentinel denotes an uninitialized root.
+#[cfg(feature = "ic")]
+static mut STATIC_VARIABLES: Value = crate::types::NULL_POINTER;
+
+/// Sanity check for the variable initialization: The variables must be initialized
+/// in increasing order and may only read precedingly initialized variables.
+#[cfg(feature = "ic")]
+static mut INITIALIZED_VARIABLES: usize = 0;
+
+/// GC root set.
+pub type Roots = [*mut Value; 6];
+
+pub unsafe fn visit_roots<C, V: Fn(&mut C, *mut Value)>(
+    roots: Roots,
+    context: &mut C,
+    visit_field: V,
+) {
+    for location in roots {
+        if is_non_null_pointer_field(location) {
+            visit_field(context, location);
+        }
+    }
+}
+
+#[cfg(feature = "ic")]
+pub unsafe fn root_set() -> Roots {
+    use crate::{
+        continuation_table::continuation_table_loc,
+        persistence::{stable_actor_location, stable_type_descriptor},
+        region::region0_get_ptr_loc,
+    };
+    [
+        static_variables_location(),
+        continuation_table_loc(),
+        stable_actor_location(),
+        stable_type_descriptor().candid_data_location(),
+        stable_type_descriptor().type_offsets_location(),
+        region0_get_ptr_loc(),
+    ]
+}
+
+#[cfg(feature = "ic")]
+unsafe fn static_variables_location() -> *mut Value {
+    &mut STATIC_VARIABLES as *mut Value
+}
+
+#[ic_mem_fn(ic_only)]
+pub unsafe fn initialize_static_variables<M: crate::memory::Memory>(mem: &mut M, amount: usize) {
+    use crate::barriers::write_with_barrier;
+    use crate::memory::alloc_array;
+    use crate::types::{NULL_POINTER, TAG_ARRAY_M};
+
+    let variables = alloc_array(mem, TAG_ARRAY_M, amount);
+    let array = variables.as_array();
+    for index in 0..amount {
+        array.initialize(index, NULL_POINTER, mem);
+    }
+    let location = &mut STATIC_VARIABLES as *mut Value;
+    write_with_barrier(mem, location, variables);
+}
+
+#[no_mangle]
+#[cfg(feature = "ic")]
+pub unsafe extern "C" fn get_static_variable(index: usize) -> Value {
+    debug_assert!(STATIC_VARIABLES.is_non_null_ptr());
+    debug_assert!(index < INITIALIZED_VARIABLES);
+    STATIC_VARIABLES.as_array().get(index)
+}
+
+#[ic_mem_fn(ic_only)]
+pub unsafe fn set_static_variable<M: crate::memory::Memory>(
+    mem: &mut M,
+    index: usize,
+    value: Value,
+) {
+    debug_assert!(STATIC_VARIABLES.is_non_null_ptr());
+    debug_assert!(index == INITIALIZED_VARIABLES);
+    STATIC_VARIABLES.as_array().set(index, value, mem);
+    INITIALIZED_VARIABLES += 1;
+}
diff --git a/rts/motoko-rts/src/gc/incremental/sanity_checks.rs b/rts/motoko-rts/src/gc/incremental/sanity_checks.rs
index 1cbe922a0a4..aaa12dd1e0e 100644
--- a/rts/motoko-rts/src/gc/incremental/sanity_checks.rs
+++ b/rts/motoko-rts/src/gc/incremental/sanity_checks.rs
@@ -1,14 +1,12 @@
 //! Incremental GC sanity checker
 #![allow(dead_code)]
 
-mod remembered_set;
-
 use crate::gc::incremental::partitioned_heap::PARTITION_SIZE;
 use crate::memory::Memory;
 use crate::types::*;
 use crate::visitor::visit_pointer_fields;
 
-use self::remembered_set::RememberedSet;
+use crate::gc::remembered_set::RememberedSet;
 
 use super::mark_stack::{MarkStack, STACK_EMPTY};
 use super::partitioned_heap::PartitionedHeap;
@@ -65,7 +63,7 @@ impl<'a, M: Memory> MemoryChecker<'a, M> {
     }
 
     unsafe fn check_roots(&mut self) {
-        visit_roots(self.roots, self, |gc, field| {
+        visit_roots(self.roots, self.heap.base_address(), self, |gc, field| {
             gc.check_object(*field);
         });
     }
@@ -100,13 +98,10 @@ impl<'a, M: Memory> MemoryChecker<'a, M> {
             self,
             object,
             object.tag(),
+            0,
             |gc, field_address| {
                 let value = *field_address;
-                if value.is_non_null_ptr() {
-                    gc.check_object(value);
-                } else {
-                    gc.check_object_header(value);
-                }
+                gc.check_object(value);
             },
             |_, _, array| array.len(),
         );
diff --git a/rts/motoko-rts/src/gc/incremental/scheduling.rs b/rts/motoko-rts/src/gc/incremental/scheduling.rs
new file mode 100644
index 00000000000..ef081a94e38
--- /dev/null
+++ b/rts/motoko-rts/src/gc/incremental/scheduling.rs
@@ -0,0 +1,105 @@
+//! Heuristics for GC scheduling.
+//! Tuned for 64-bit main memory with unknown IC memory capacity.
+//!
+//! Distinction of three scheduling modes:
+//! * Critical: The heap exceeds 80% of the memory capacity (using capacity probing):
+//!   - Schedule a GC start with a frequency of 1% of the heap growth.
+//! * Medium: The heap exceeds 50% of the memory capacity:
+//!   - Schedule a GC start with a frequency of 35% of the heap growth.
+//! * Low: The heap is below 50% of the memory capacity.
+//!   - Schedule a GC start with a frequency of 65% of the heap growth.
+//!
+//! A heuristics for capacity probing is used to determine the minimum amount of memory capacity.
+//! This is necessary because the IC does not provide runtime information about the implemented
+//! Wasm memory capacity in 64-bit. This capacity may also increase over time with newer IC versions.
+
+use crate::gc::incremental::{get_incremental_gc_state, partitioned_heap::PARTITION_SIZE};
+use crate::memory::ic::partitioned_memory::{get_heap_size, get_total_allocations};
+use crate::types::Bytes;
+use motoko_rts_macros::{classical_persistence, enhanced_orthogonal_persistence};
+
+struct HeapThresholds {
+    critical_heap_limit: Bytes<usize>,
+    medium_heap_limit: Bytes<usize>,
+}
+
+#[classical_persistence]
+impl HeapThresholds {
+    unsafe fn get() -> HeapThresholds {
+        use crate::constants::{GB, MB};
+
+        const CRITICAL_HEAP_LIMIT: Bytes<usize> = Bytes(2 * GB + 256 * MB);
+        const MEDIUM_HEAP_LIMIT: Bytes<usize> = Bytes(1 * GB);
+        HeapThresholds {
+            critical_heap_limit: CRITICAL_HEAP_LIMIT,
+            medium_heap_limit: MEDIUM_HEAP_LIMIT,
+        }
+    }
+}
+
+#[enhanced_orthogonal_persistence]
+impl HeapThresholds {
+    /// Heuristics: Determine the threshold values of the heap size to schedule a new GC start.
+    /// Note:
+    /// As the maximum Wasm memory capacity supported by the IC is not known and can be increased
+    /// over time, we probe the memory extension when the free space seems to be critically low.
+    /// This is to avoid unnecessary heavy GC scheduling when approaching a supposed memory limit
+    /// that can actually be extended.
+    unsafe fn get() -> HeapThresholds {
+        use crate::memory::ic::enhanced_memory::{minimum_memory_capacity, probe_wasm_memory};
+
+        let thresholds = HeapThresholds::get_without_probing();
+        let heap_size = get_heap_size();
+        // Only if the heap size seems to be critically low, try to expand the Wasm memory beyond the
+        // assumed current available memory.
+        if heap_size > thresholds.critical_heap_limit
+            && probe_wasm_memory(minimum_memory_capacity() + Bytes(1))
+        {
+            // Obtain the extended heap thresholds.
+            HeapThresholds::get_without_probing()
+        } else {
+            thresholds
+        }
+    }
+
+    /// Obtain the heap thresholds without memory probing:
+    /// The critical limit is 80% of the currently known memory size.
+    /// The medium limit is 50% of the currently known memory size.
+    unsafe fn get_without_probing() -> HeapThresholds {
+        use crate::memory::ic::enhanced_memory::minimum_memory_capacity;
+
+        let available_memory = minimum_memory_capacity().as_usize();
+        let critical_heap_limit = Bytes(available_memory / 10 * 8); // 80%
+        let medium_heap_limit: Bytes<usize> = Bytes(available_memory / 2); // 50%
+        HeapThresholds {
+            critical_heap_limit,
+            medium_heap_limit,
+        }
+    }
+}
+
+/// Determine whether a new GC run should be started based on the heap growth since
+/// the last GC completion.
+pub unsafe fn should_start_gc() -> bool {
+    let heap_size = get_heap_size();
+
+    const CRITICAL_GROWTH_THRESHOLD: f64 = 0.01;
+    const MEDIUM_GROWTH_THRESHOLD: f64 = 0.35;
+    const LOW_GROWTH_THRESHOLD: f64 = 0.65;
+
+    let heap_thresholds = HeapThresholds::get();
+    let growth_threshold = if heap_size > heap_thresholds.critical_heap_limit {
+        CRITICAL_GROWTH_THRESHOLD
+    } else if heap_size > heap_thresholds.medium_heap_limit {
+        MEDIUM_GROWTH_THRESHOLD
+    } else {
+        LOW_GROWTH_THRESHOLD
+    };
+
+    let current_allocations = get_total_allocations();
+    let state = get_incremental_gc_state();
+    debug_assert!(current_allocations >= state.statistics.last_allocations);
+    let absolute_growth = current_allocations - state.statistics.last_allocations;
+    let relative_growth = absolute_growth.0 as f64 / heap_size.as_usize() as f64;
+    relative_growth > growth_threshold && heap_size.as_usize() >= PARTITION_SIZE
+}
diff --git a/rts/motoko-rts/src/gc/incremental/sort.rs b/rts/motoko-rts/src/gc/incremental/sort.rs
index 34d4dfa76e5..ea4e2e8097e 100644
--- a/rts/motoko-rts/src/gc/incremental/sort.rs
+++ b/rts/motoko-rts/src/gc/incremental/sort.rs
@@ -2,32 +2,42 @@ use core::cmp::Ordering;
 
 /// Simple in-place sort algorithm that does not allocate additional memory.
 /// Based on quicksort. Average runtime costs of `O(n*log(n))`.
-pub fn sort<Compare: Fn(usize, usize) -> Ordering>(array: &mut [usize], compare: &Compare) {
-    if array.len() > 1 {
-        quicksort(array, compare);
+pub unsafe fn sort<Compare: Fn(usize, usize) -> Ordering>(
+    array: *mut usize,
+    length: usize,
+    compare: &Compare,
+) {
+    if length > 1 {
+        quicksort(array, 0, length - 1, compare);
     }
 }
 
 /// Special version of quicksort by Niklaus Wirth: https://people.inf.ethz.ch/wirth/AD.pdf, pages 65/66.
-fn quicksort<Compare: Fn(usize, usize) -> Ordering>(array: &mut [usize], compare: &Compare) {
+/// Sorting `array[start..end+1]`, i.e. `start` and `end` are inclusive indices.
+unsafe fn quicksort<Compare: Fn(usize, usize) -> Ordering>(
+    array: *mut usize,
+    start: usize,
+    end: usize,
+    compare: &Compare,
+) {
     // Require at least two elements to avoid the unsigned integer underflow of `backward`.
-    debug_assert!(array.len() > 1);
+    debug_assert!(start < end);
     // Take the middle element as pivot to optimize for the case of a sorted or nearly sorted array.
-    let pivot = array[array.len() / 2];
-    let mut forward = 0;
-    let mut backward = array.len() - 1;
+    let pivot = *array.add((start + end + 1) / 2);
+    let mut forward = start;
+    let mut backward = end;
     loop {
-        while compare(array[forward], pivot) == Ordering::Less {
+        while compare(*array.add(forward), pivot) == Ordering::Less {
             forward += 1;
         }
-        while compare(array[backward], pivot) == Ordering::Greater {
+        while compare(*array.add(backward), pivot) == Ordering::Greater {
             backward -= 1;
         }
         if forward <= backward {
             // Cannot use `array.swap()` since it imports `memmove` in debug build.
-            let temporary = array[forward];
-            array[forward] = array[backward];
-            array[backward] = temporary;
+            let temporary = *array.add(forward);
+            *array.add(forward) = *array.add(backward);
+            *array.add(backward) = temporary;
             forward += 1;
             backward -= 1;
         }
@@ -38,10 +48,10 @@ fn quicksort<Compare: Fn(usize, usize) -> Ordering>(array: &mut [usize], compare
     // Invariant after partitioning: `forward > backward`. Therefore:
     // * The left partition ends at `backward`.
     // * The right partition starts at `forward`.
-    if backward > 0 {
-        quicksort(&mut array[..backward + 1], compare);
+    if backward > start {
+        quicksort(array, start, backward, compare);
     }
-    if forward < array.len() - 1 {
-        quicksort(&mut array[forward..], compare);
+    if forward < end {
+        quicksort(array, forward, end, compare);
     }
 }
diff --git a/rts/motoko-rts/src/gc/incremental/time.rs b/rts/motoko-rts/src/gc/incremental/time.rs
index bc91a01cfdf..134d415e2ea 100644
--- a/rts/motoko-rts/src/gc/incremental/time.rs
+++ b/rts/motoko-rts/src/gc/incremental/time.rs
@@ -10,6 +10,7 @@ impl BoundedTime {
         BoundedTime { steps: 0, limit }
     }
 
+    // TODO: Saturating add is probably no longer needed in 64-bit (if that makes it faster).
     pub fn tick(&mut self) {
         self.steps = usize::saturating_add(self.steps, 1);
     }
diff --git a/rts/motoko-rts/src/gc/mark_compact.rs b/rts/motoko-rts/src/gc/mark_compact.rs
new file mode 100644
index 00000000000..c9d894f6c7f
--- /dev/null
+++ b/rts/motoko-rts/src/gc/mark_compact.rs
@@ -0,0 +1,303 @@
+//! Implements threaded compaction as described in "High-Performance Garbage Collection for
+//! Memory-Constrained Environments" section 5.1.2, which is an improved version of the original
+//! threaded compaction algorithm described in The Garbage Collection Handbook section 3.3.
+
+pub mod bitmap;
+pub mod mark_stack;
+
+use bitmap::{alloc_bitmap, free_bitmap, get_bit, iter_bits, set_bit, BITMAP_ITER_END};
+use mark_stack::{alloc_mark_stack, free_mark_stack, pop_mark_stack, push_mark_stack};
+
+use crate::constants::WORD_SIZE;
+use crate::mem_utils::memcpy_words;
+use crate::memory::Memory;
+use crate::types::*;
+use crate::visitor::{classical::pointer_to_dynamic_heap, visit_pointer_fields};
+
+use motoko_rts_macros::ic_mem_fn;
+
+// Only designed for 32-bit.
+const _: () = assert!(core::mem::size_of::<usize>() == core::mem::size_of::<u32>());
+
+#[no_mangle]
+#[cfg(feature = "ic")]
+pub unsafe extern "C" fn initialize_compacting_gc() {
+    crate::memory::ic::linear_memory::initialize();
+}
+
+#[ic_mem_fn(ic_only)]
+unsafe fn schedule_compacting_gc<M: Memory>(mem: &mut M) {
+    // 512 MiB slack for mark stack + allocation area for the next message
+    let slack: u64 = 512 * 1024 * 1024;
+    let heap_size_bytes: u64 =
+        crate::constants::WASM32_HEAP_SIZE.as_usize() as u64 * WORD_SIZE as u64;
+    // Larger than necessary to keep things simple
+    let max_bitmap_size_bytes = heap_size_bytes / 32;
+    // NB. `max_live` is evaluated in compile time to a constant
+    let max_live: Bytes<u64> = Bytes(heap_size_bytes - slack - max_bitmap_size_bytes);
+
+    if super::should_do_gc(max_live) {
+        compacting_gc(mem);
+    }
+}
+
+#[ic_mem_fn(ic_only)]
+unsafe fn compacting_gc<M: Memory>(mem: &mut M) {
+    use crate::memory::ic::{self, linear_memory};
+
+    compacting_gc_internal(
+        mem,
+        ic::get_aligned_heap_base(),
+        // get_hp
+        || linear_memory::get_hp_unskewed(),
+        // set_hp
+        |hp| linear_memory::set_hp_unskewed(hp),
+        ic::get_static_roots(),
+        crate::continuation_table::continuation_table_loc(),
+        crate::region::region0_get_ptr_loc(),
+        // note_live_size
+        |live_size| linear_memory::MAX_LIVE = ::core::cmp::max(linear_memory::MAX_LIVE, live_size),
+        // note_reclaimed
+        |reclaimed| linear_memory::RECLAIMED += Bytes(reclaimed.as_usize() as u64),
+    );
+
+    linear_memory::LAST_HP = linear_memory::get_hp_unskewed();
+}
+
+pub unsafe fn compacting_gc_internal<
+    M: Memory,
+    GetHp: Fn() -> usize,
+    SetHp: Fn(usize),
+    NoteLiveSize: Fn(Bytes<usize>),
+    NoteReclaimed: Fn(Bytes<usize>),
+>(
+    mem: &mut M,
+    heap_base: usize,
+    get_hp: GetHp,
+    set_hp: SetHp,
+    static_roots: Value,
+    continuation_table_ptr_loc: *mut Value,
+    region0_ptr_loc: *mut Value,
+    note_live_size: NoteLiveSize,
+    note_reclaimed: NoteReclaimed,
+) {
+    let old_hp = get_hp();
+
+    assert_eq!(heap_base % 32, 0);
+
+    mark_compact(
+        mem,
+        set_hp,
+        heap_base,
+        old_hp,
+        static_roots,
+        continuation_table_ptr_loc,
+        region0_ptr_loc,
+    );
+
+    let reclaimed = old_hp - get_hp();
+    note_reclaimed(Bytes(reclaimed));
+
+    let live = get_hp() - heap_base;
+    note_live_size(Bytes(live));
+}
+
+unsafe fn mark_compact<M: Memory, SetHp: Fn(usize)>(
+    mem: &mut M,
+    set_hp: SetHp,
+    heap_base: usize,
+    heap_end: usize,
+    static_roots: Value,
+    continuation_table_ptr_loc: *mut Value,
+    region0_ptr_loc: *mut Value,
+) {
+    let mem_size = Bytes(heap_end - heap_base);
+
+    alloc_bitmap(mem, mem_size, heap_base / WORD_SIZE);
+    alloc_mark_stack(mem);
+
+    mark_static_roots(mem, static_roots, heap_base);
+
+    if (*continuation_table_ptr_loc).is_ptr() {
+        mark_object(mem, *continuation_table_ptr_loc);
+        // Similar to `mark_root_mutbox_fields`, `continuation_table_ptr_loc` is in static heap so
+        // it will be readable when we unthread the continuation table
+        thread(continuation_table_ptr_loc);
+    }
+
+    if (*region0_ptr_loc).is_ptr() {
+        mark_object(mem, *region0_ptr_loc);
+        thread(region0_ptr_loc);
+    }
+
+    mark_stack(mem, heap_base);
+
+    update_refs(set_hp, heap_base);
+
+    free_mark_stack();
+    free_bitmap();
+}
+
+unsafe fn mark_static_roots<M: Memory>(mem: &mut M, static_roots: Value, heap_base: usize) {
+    let root_array = static_roots.as_array();
+
+    // Static objects are not in the dynamic heap so don't need marking.
+    for i in 0..root_array.len() {
+        let obj = root_array.get(i).as_obj();
+        // Root array should only have pointers to other static MutBoxes
+        debug_assert_eq!(obj.tag(), TAG_MUTBOX); // check tag
+        debug_assert!((obj as usize) < heap_base); // check that MutBox is static
+        mark_root_mutbox_fields(mem, obj as *mut MutBox, heap_base);
+    }
+}
+
+unsafe fn mark_object<M: Memory>(mem: &mut M, obj: Value) {
+    let obj_tag = obj.tag();
+    let obj = obj.get_ptr();
+
+    // Check object alignment to avoid undefined behavior. See also static_checks module.
+    debug_assert_eq!(obj % WORD_SIZE, 0);
+
+    let obj_idx = obj / WORD_SIZE;
+
+    if get_bit(obj_idx) {
+        // Already marked
+        return;
+    }
+
+    set_bit(obj_idx);
+    push_mark_stack(mem, obj, obj_tag);
+}
+
+unsafe fn mark_stack<M: Memory>(mem: &mut M, heap_base: usize) {
+    while let Some((obj, tag)) = pop_mark_stack() {
+        mark_fields(mem, obj as *mut Obj, tag, heap_base)
+    }
+}
+
+unsafe fn mark_fields<M: Memory>(mem: &mut M, obj: *mut Obj, obj_tag: Tag, heap_base: usize) {
+    visit_pointer_fields(
+        mem,
+        obj,
+        obj_tag,
+        heap_base,
+        |mem, field_addr| {
+            let field_value = *field_addr;
+            mark_object(mem, field_value);
+
+            // Thread if backwards or self pointer
+            if field_value.get_ptr() <= obj as usize {
+                thread(field_addr);
+            }
+        },
+        |mem, slice_start, arr| {
+            const SLICE_INCREMENT: usize = 127;
+            debug_assert!(SLICE_INCREMENT >= TAG_ARRAY_SLICE_MIN);
+            if arr.len() - slice_start > SLICE_INCREMENT {
+                let new_start = slice_start + SLICE_INCREMENT;
+                // push an entire (suffix) array slice
+                push_mark_stack(mem, arr as usize, new_start);
+                new_start
+            } else {
+                arr.len()
+            }
+        },
+    );
+}
+
+/// Specialized version of `mark_fields` for root `MutBox`es.
+unsafe fn mark_root_mutbox_fields<M: Memory>(mem: &mut M, mutbox: *mut MutBox, heap_base: usize) {
+    let field_addr = &mut (*mutbox).field;
+    if pointer_to_dynamic_heap(field_addr, heap_base) {
+        mark_object(mem, *field_addr);
+        // It's OK to thread forward pointers here as the static objects won't be moved, so we will
+        // be able to unthread objects pointed by these fields later.
+        thread(field_addr);
+    }
+}
+
+/// Linearly scan the heap, for each live object:
+///
+/// - Mark step threads all backwards pointers and pointers from roots, so unthread to update those
+///   pointers to the objects new location.
+///
+/// - Move the object
+///
+/// - Thread forward pointers of the object
+///
+unsafe fn update_refs<SetHp: Fn(usize)>(set_hp: SetHp, heap_base: usize) {
+    let mut free = heap_base;
+
+    let mut bitmap_iter = iter_bits();
+    let mut bit = bitmap_iter.next();
+    while bit != BITMAP_ITER_END {
+        let p = (bit * WORD_SIZE) as *mut Obj;
+        let p_new = free;
+
+        // Update backwards references to the object's new location and restore object header
+        unthread(p, p_new);
+
+        // Move the object
+        let p_size_words = block_size(p as usize);
+        if p_new as usize != p as usize {
+            memcpy_words(p_new as usize, p as usize, p_size_words);
+
+            debug_assert!(p_size_words.as_usize() > size_of::<Obj>().as_usize());
+            // Update forwarding pointer
+            let new_obj = p_new as *mut Obj;
+            debug_assert!(new_obj.tag() >= TAG_OBJECT && new_obj.tag() <= TAG_NULL);
+        }
+
+        free += p_size_words.to_bytes().as_usize();
+
+        // Thread forward pointers of the object
+        thread_fwd_pointers(p_new as *mut Obj, heap_base);
+
+        bit = bitmap_iter.next();
+    }
+
+    set_hp(free);
+}
+
+/// Thread forward pointers in object
+unsafe fn thread_fwd_pointers(obj: *mut Obj, heap_base: usize) {
+    visit_pointer_fields(
+        &mut (),
+        obj,
+        obj.tag(),
+        heap_base,
+        |_, field_addr| {
+            if (*field_addr).get_ptr() > obj as usize {
+                thread(field_addr)
+            }
+        },
+        |_, _, arr| arr.len(),
+    );
+}
+
+/// Thread a pointer field
+unsafe fn thread(field: *mut Value) {
+    // Store pointed object's header in the field, field address in the pointed object's header
+    let pointed = (*field).as_obj();
+    let pointed_header = pointed.tag();
+    *field = Value::from_raw(pointed_header);
+    (*pointed).tag = field as usize;
+}
+
+/// Unthread all references at given header, replacing with `new_loc`. Restores object header.
+unsafe fn unthread(obj: *mut Obj, new_loc: usize) {
+    let mut header = obj.tag();
+
+    // All objects and fields are word-aligned, and tags have the lowest bit set, so use the lowest
+    // bit to distinguish a header (tag) from a field address.
+    while header & 0b1 == 0 {
+        let tmp = (header as *const Obj).tag();
+        (*(header as *mut Value)) = Value::from_ptr(new_loc);
+        header = tmp;
+    }
+
+    // At the end of the chain is the original header for the object
+    debug_assert!(header >= TAG_OBJECT && header <= TAG_NULL);
+
+    (*obj).tag = header;
+}
diff --git a/rts/motoko-rts/src/gc/mark_compact/bitmap.rs b/rts/motoko-rts/src/gc/mark_compact/bitmap.rs
new file mode 100644
index 00000000000..ba7ed7483b3
--- /dev/null
+++ b/rts/motoko-rts/src/gc/mark_compact/bitmap.rs
@@ -0,0 +1,209 @@
+use crate::gc::mark_compact::TAG_BLOB_B;
+use crate::mem_utils::memzero;
+use crate::memory::{alloc_blob, Memory};
+use crate::types::{size_of, Blob, Bytes, Obj};
+
+/* How the Wasm-heap maps to the bitmap
+
+  +---- RTS stack ----+---- Motoko statics ----+---- Dynamic heap ------+ Heap limit
+                  (prefix words)                   bitmap lives here -> | BM |
+                                                                       /      \
+                                                                      /        \
+                                       each bit represents a word -> /...bits...\
+                                          in the dynamic heap
+
+## Marking with absolute addresses
+
+When marking, we need to map an address to a bit in the bitmap. Internally the
+bitmap is kept in a (non-moving) blob after the dynamic heap (DH). To
+efficiently mark the right bit in the bitmap, we maintain a pointer that points
+_before the start of the bitmap_ such that `address / 8` and `address % 8`
+will address the right bit:
+
+
+       +---- BITMAP_FORBIDDEN_PTR         +---- BITMAP_PTR
+       v                                  v
+       ,          (forbidden)             ,...................... bitmap ..........~~....,
+       |   heap_prefix_words / 8 bytes    |               heap_size / 32 bytes           |
+       |   get_bitmap_forbidden_size()    |                   BITMAP_SIZE                |
+       ^                                  ^                                              ^
+      /           ^^^^^^^^^^^              \                                             |
+     /            corresponds               \                 ^^^^^^^^^^^               /
+    /                                        \                corresponds              /
+   /                                          \                                       /
+  +---- Rts stack ----+---- Motoko statics ----+--------- Dynamic heap ----------~~--+
+                                               !
+                                               ! 32-byte aligned
+
+
+Debug assertions guard the forbidden bytes from access, as this area potentially
+overlaps with the Motoko dynamic heap.
+
+## The alignment caveat
+
+For this scheme to work, it is essential that the start of the DH is an address that
+is divisible by 32 (`heap_prefix_words % 8 == 0`). Otherwise the `address / 8`
+and `address % 8` operations on the DH's starting address will not yield the
+least significant bit in the BM.
+
+## Example calculation
+
+Assume the DH is at 0x80000. Assume heap limit being at 0xB0000. Then the BM thus
+could be placed at 0xB0008. Since the heap_prefix_words is 0x20000,
+BITMAP_FORBIDDEN_PTR = 0xB0008 - 0x20000 / 8 = 0xAC008.
+
+Now let's mark the address 0x80548 in the DH. Its absolute word number is 0x20152.
+The `(0x20152 / 8, 0x20152 % 8)`-rule gives a bit position 2 with byte offset 0x402A,
+thus we mark bit 2 in byte 0xAC004 + 0x402A = 0xB002E, which is in the BM.
+
+ */
+
+// Only designed for 32-bit.
+const _: () = assert!(core::mem::size_of::<usize>() == core::mem::size_of::<u32>());
+
+/// Current bitmap
+static mut BITMAP_FORBIDDEN_PTR: *mut u8 = core::ptr::null_mut();
+static mut BITMAP_PTR: *mut u8 = core::ptr::null_mut();
+static mut BITMAP_SIZE: usize = 0;
+
+unsafe fn get_bitmap_forbidden_size() -> usize {
+    BITMAP_PTR as usize - BITMAP_FORBIDDEN_PTR as usize
+}
+
+pub unsafe fn alloc_bitmap<M: Memory>(
+    mem: &mut M,
+    heap_size: Bytes<usize>,
+    heap_prefix_words: usize,
+) {
+    // See Note "How the Wasm-heap maps to the bitmap" above
+    debug_assert_eq!(heap_prefix_words % 8, 0);
+    // We will have at most this many objects in the heap, each requiring a bit
+    let n_bits = heap_size.to_words().as_usize();
+    // Each byte will hold 8 bits.
+    BITMAP_SIZE = (n_bits + 7) / 8;
+    // Also round allocation up to 8-bytes to make iteration efficient. We want to be able to read
+    // 64 bits in a single read and check as many bits as possible with a single `word != 0`.
+    let bitmap_bytes = Bytes(((BITMAP_SIZE + 7) / 8) * 8);
+    // Allocating an actual object here as otherwise dump_heap gets confused
+    // No post allocation barrier as this RTS-internal blob will be collected by the GC.
+    let blob = alloc_blob(mem, TAG_BLOB_B, bitmap_bytes).get_ptr() as *mut Blob;
+    memzero(blob.payload_addr() as usize, bitmap_bytes.to_words());
+
+    BITMAP_PTR = blob.payload_addr();
+    BITMAP_FORBIDDEN_PTR = BITMAP_PTR.sub(heap_prefix_words / 8)
+}
+
+pub unsafe fn free_bitmap() {
+    BITMAP_PTR = core::ptr::null_mut();
+    BITMAP_FORBIDDEN_PTR = core::ptr::null_mut();
+    BITMAP_SIZE = 0;
+}
+
+pub unsafe fn get_bit(idx: usize) -> bool {
+    let (byte_idx, bit_idx) = (idx / 8, idx % 8);
+    debug_assert!(byte_idx >= get_bitmap_forbidden_size());
+    debug_assert!(get_bitmap_forbidden_size() + BITMAP_SIZE > byte_idx);
+    let byte = *BITMAP_FORBIDDEN_PTR.add(byte_idx);
+    (byte >> bit_idx) & 0b1 != 0
+}
+
+pub unsafe fn set_bit(idx: usize) {
+    let (byte_idx, bit_idx) = (idx / 8, idx % 8);
+    debug_assert!(byte_idx >= get_bitmap_forbidden_size());
+    debug_assert!(get_bitmap_forbidden_size() + BITMAP_SIZE > byte_idx);
+    let byte = *BITMAP_FORBIDDEN_PTR.add(byte_idx);
+    let new_byte = byte | (0b1 << bit_idx);
+    *BITMAP_FORBIDDEN_PTR.add(byte_idx) = new_byte;
+}
+
+pub struct BitmapIter {
+    /// Size of the bitmap, in bits. Does not change after initialization.
+    size: u32,
+    /// Current bit index
+    current_bit_idx: u32,
+    /// Current 64-bit word in the bitmap that we're iterating. We read in 64-bit chunks to be able
+    /// to check as many bits as possible with a single `word != 0`.
+    current_word: u64,
+    /// How many leading bits are initially zeroed in the current_word
+    leading_zeros: u32,
+}
+
+pub unsafe fn iter_bits() -> BitmapIter {
+    let blob_len_bytes = (BITMAP_PTR.sub(size_of::<Blob>().to_bytes().as_usize()) as *mut Obj)
+        .as_blob()
+        .len()
+        .as_usize() as u32;
+
+    debug_assert_eq!(blob_len_bytes % 8, 0);
+
+    let blob_len_64bit_words = blob_len_bytes / 8;
+
+    let current_word = if blob_len_64bit_words == 0 {
+        0
+    } else {
+        let bitmap_ptr64 = BITMAP_PTR as *const u64;
+        bitmap_ptr64.read_unaligned()
+    };
+
+    debug_assert!(BITMAP_PTR as usize >= BITMAP_FORBIDDEN_PTR as usize);
+    let forbidden_bits = get_bitmap_forbidden_size() as u32 * 8;
+
+    BitmapIter {
+        size: blob_len_bytes * 8 + forbidden_bits,
+        current_bit_idx: forbidden_bits,
+        current_word,
+        leading_zeros: current_word.leading_zeros(),
+    }
+}
+
+/// This value marks the end-of-stream in `BitmapIter`. Using this value instead of `None` for
+/// end-of-stream reduces Wasm instructions executed by ~2.7% in some cases.
+//
+// Heap is 4GiB and each 32-bit word gets a bit, so this is one larger than the bit for the last
+// word in heap.
+//
+// (We actually need less bits than that as when the heap is full we can't allocate bitmap and mark
+// stack and can't do GC)
+pub const BITMAP_ITER_END: usize = usize::MAX;
+
+impl BitmapIter {
+    /// Returns the next bit, or `BITMAP_ITER_END` if there are no more bits set.
+    pub fn next(&mut self) -> usize {
+        debug_assert!(self.current_bit_idx <= self.size);
+
+        if self.current_bit_idx == self.size {
+            return BITMAP_ITER_END;
+        }
+
+        // Outer loop iterates 64-bit words
+        loop {
+            // Examine the least significant bit(s) in the current word
+            if self.current_word != 0 {
+                let shift_amt = self.current_word.trailing_zeros();
+                self.current_word >>= shift_amt;
+                self.current_word >>= 1;
+                let bit_idx = self.current_bit_idx + shift_amt;
+                self.current_bit_idx = bit_idx + 1;
+                return bit_idx as usize;
+            }
+
+            // Move on to next word (always 64-bit boundary)
+            self.current_bit_idx += self.leading_zeros;
+            unsafe {
+                debug_assert_eq!(
+                    (self.current_bit_idx - get_bitmap_forbidden_size() as u32 * 8) % 64,
+                    0
+                )
+            }
+            if self.current_bit_idx == self.size {
+                return BITMAP_ITER_END;
+            }
+            self.current_word = unsafe {
+                let ptr64 =
+                    BITMAP_FORBIDDEN_PTR.add(self.current_bit_idx as usize / 8) as *const u64;
+                ptr64.read_unaligned()
+            };
+            self.leading_zeros = self.current_word.leading_zeros();
+        }
+    }
+}
diff --git a/rts/motoko-rts/src/gc/mark_compact/mark_stack.rs b/rts/motoko-rts/src/gc/mark_compact/mark_stack.rs
new file mode 100644
index 00000000000..582214cc99e
--- /dev/null
+++ b/rts/motoko-rts/src/gc/mark_compact/mark_stack.rs
@@ -0,0 +1,76 @@
+//! A stack for marking heap objects (for GC). There should be no allocation after the stack
+//! otherwise things will break as we push. This invariant is checked in debug builds.
+
+use crate::gc::mark_compact::TAG_BLOB_B;
+use crate::memory::{alloc_blob, Memory};
+use crate::types::{Blob, Tag, Words};
+
+use core::ptr::null_mut;
+
+/// Initial stack size
+pub const INIT_STACK_SIZE: Words<usize> = Words(64);
+
+/// Pointer to the `blob` object for the mark stack. Used to get the capacity of the stack.
+static mut STACK_BLOB_PTR: *mut Blob = null_mut();
+
+/// Bottom of the mark stack
+pub static mut STACK_BASE: *mut usize = null_mut();
+
+/// Top of the mark stack
+pub static mut STACK_TOP: *mut usize = null_mut();
+
+/// Next free slot in the mark stack
+pub static mut STACK_PTR: *mut usize = null_mut();
+
+pub unsafe fn alloc_mark_stack<M: Memory>(mem: &mut M) {
+    debug_assert!(STACK_BLOB_PTR.is_null());
+
+    // Allocating an actual object here to not break dump_heap
+    // No post allocation barrier as this RTS-internal blob will be collected by the GC.
+    STACK_BLOB_PTR = alloc_blob(mem, TAG_BLOB_B, INIT_STACK_SIZE.to_bytes()).get_ptr() as *mut Blob;
+    STACK_BASE = STACK_BLOB_PTR.payload_addr() as *mut usize;
+    STACK_PTR = STACK_BASE;
+    STACK_TOP = STACK_BASE.add(INIT_STACK_SIZE.as_usize());
+}
+
+pub unsafe fn free_mark_stack() {
+    STACK_BLOB_PTR = null_mut();
+    STACK_BASE = null_mut();
+    STACK_PTR = null_mut();
+    STACK_TOP = null_mut();
+}
+
+/// Doubles the stack size
+pub unsafe fn grow_stack<M: Memory>(mem: &mut M) {
+    let stack_cap = STACK_BLOB_PTR.len().to_words();
+    let p = mem.alloc_words(stack_cap).get_ptr() as *mut usize;
+
+    // Make sure nothing was allocated after the stack
+    debug_assert_eq!(STACK_TOP, p);
+
+    let new_cap = stack_cap * 2;
+    (*STACK_BLOB_PTR).len = new_cap.to_bytes();
+    STACK_TOP = STACK_BASE.add(new_cap.as_usize());
+}
+
+pub unsafe fn push_mark_stack<M: Memory>(mem: &mut M, obj: usize, obj_tag: Tag) {
+    // We add 2 words in a push, and `STACK_PTR` and `STACK_TOP` are both multiples of 2, so we can
+    // do simple equality check here
+    if STACK_PTR == STACK_TOP {
+        grow_stack(mem);
+    }
+
+    *STACK_PTR = obj;
+    *STACK_PTR.add(1) = obj_tag;
+    STACK_PTR = STACK_PTR.add(2);
+}
+
+pub unsafe fn pop_mark_stack() -> Option<(usize, Tag)> {
+    if STACK_PTR == STACK_BASE {
+        return None;
+    }
+    STACK_PTR = STACK_PTR.sub(2);
+    let p = *STACK_PTR;
+    let tag = *STACK_PTR.add(1);
+    return Some((p, tag));
+}
diff --git a/rts/motoko-rts/src/gc/incremental/sanity_checks/remembered_set.rs b/rts/motoko-rts/src/gc/remembered_set.rs
similarity index 88%
rename from rts/motoko-rts/src/gc/incremental/sanity_checks/remembered_set.rs
rename to rts/motoko-rts/src/gc/remembered_set.rs
index 9904244af18..a88c5fd7d6e 100644
--- a/rts/motoko-rts/src/gc/incremental/sanity_checks/remembered_set.rs
+++ b/rts/motoko-rts/src/gc/remembered_set.rs
@@ -42,7 +42,7 @@ use crate::types::{block_size, Blob, Bytes, Value, TAG_BLOB_B};
 
 pub struct RememberedSet {
     hash_table: *mut Blob,
-    count: u32, // contained entries
+    count: usize, // contained entries
 }
 
 #[repr(C)]
@@ -59,13 +59,13 @@ struct CollisionNode {
 
 pub struct RememberedSetIterator {
     hash_table: *mut Blob,
-    hash_index: u32,
+    hash_index: usize,
     current_entry: *mut HashEntry,
 }
 
-pub const INITIAL_TABLE_LENGTH: u32 = 1024;
-const GROWTH_FACTOR: u32 = 2;
-pub const OCCUPATION_THRESHOLD_PERCENT: u32 = 65;
+pub const INITIAL_TABLE_LENGTH: usize = 1024;
+const GROWTH_FACTOR: usize = 2;
+pub const OCCUPATION_THRESHOLD_PERCENT: usize = 65;
 
 impl RememberedSet {
     pub unsafe fn new<M: Memory>(mem: &mut M) -> RememberedSet {
@@ -126,7 +126,7 @@ impl RememberedSet {
         false
     }
 
-    pub unsafe fn hash_index(&self, value: Value) -> u32 {
+    pub unsafe fn hash_index(&self, value: Value) -> usize {
         // Future optimization: Use bitwise modulo, check for power of 2
         let raw = value.get_raw();
         let length = table_length(self.hash_table);
@@ -138,7 +138,7 @@ impl RememberedSet {
         RememberedSetIterator::init(self)
     }
 
-    pub fn count(&self) -> u32 {
+    pub fn count(&self) -> usize {
         self.count
     }
 
@@ -222,10 +222,9 @@ impl RememberedSetIterator {
     }
 }
 
-unsafe fn new_table<M: Memory>(mem: &mut M, size: u32) -> *mut Blob {
+unsafe fn new_table<M: Memory>(mem: &mut M, size: usize) -> *mut Blob {
     // No post allocation barrier as this RTS-internal blob will be collected by the GC.
-    let table =
-        alloc_blob(mem, TAG_BLOB_B, Bytes(size * size_of::<HashEntry>() as u32)).as_blob_mut();
+    let table = alloc_blob(mem, TAG_BLOB_B, Bytes(size * size_of::<HashEntry>())).as_blob_mut();
     for index in 0..size {
         table_set(table, index, null_ptr_value());
     }
@@ -235,7 +234,7 @@ unsafe fn new_table<M: Memory>(mem: &mut M, size: u32) -> *mut Blob {
 unsafe fn new_collision_node<M: Memory>(mem: &mut M, value: Value) -> *mut CollisionNode {
     debug_assert!(!is_null_ptr_value(value));
     // No post allocation barrier as this RTS-internal blob will be collected by the GC.
-    let node = alloc_blob(mem, TAG_BLOB_B, Bytes(size_of::<HashEntry>() as u32)).as_blob_mut()
+    let node = alloc_blob(mem, TAG_BLOB_B, Bytes(size_of::<HashEntry>())).as_blob_mut()
         as *mut CollisionNode;
     (*node).entry = HashEntry {
         value,
@@ -244,31 +243,30 @@ unsafe fn new_collision_node<M: Memory>(mem: &mut M, value: Value) -> *mut Colli
     node
 }
 
-unsafe fn table_get(table: *mut Blob, index: u32) -> *mut HashEntry {
+unsafe fn table_get(table: *mut Blob, index: usize) -> *mut HashEntry {
     debug_assert!(table != null_mut());
-    let entry =
-        (table.payload_addr() as u32 + index * size_of::<HashEntry>() as u32) as *mut HashEntry;
+    let entry = (table.payload_addr() as usize + index * size_of::<HashEntry>()) as *mut HashEntry;
     debug_assert!(
-        entry as u32 + size_of::<HashEntry>() as u32
-            <= table as u32 + block_size(table as usize).to_bytes().as_u32()
+        entry as usize + size_of::<HashEntry>()
+            <= table as usize + block_size(table as usize).to_bytes().as_usize()
     );
     entry
 }
 
-unsafe fn table_set(table: *mut Blob, index: u32, value: Value) {
+unsafe fn table_set(table: *mut Blob, index: usize, value: Value) {
     let entry = table_get(table, index);
     (*entry).value = value;
     (*entry).next_collision_ptr = null_mut();
 }
 
-unsafe fn table_length(table: *mut Blob) -> u32 {
+unsafe fn table_length(table: *mut Blob) -> usize {
     debug_assert!(table != null_mut());
-    debug_assert!(table.len().as_u32() % size_of::<HashEntry>() as u32 == 0);
-    table.len().as_u32() / size_of::<HashEntry>() as u32
+    debug_assert!(table.len().as_usize() % size_of::<HashEntry>() == 0);
+    table.len().as_usize() / size_of::<HashEntry>()
 }
 
 unsafe fn null_ptr_value() -> Value {
-    Value::from_raw((null_mut() as *mut usize) as u32)
+    Value::from_raw((null_mut() as *mut usize) as usize)
 }
 
 unsafe fn is_null_ptr_value(value: Value) -> bool {
diff --git a/rts/motoko-rts/src/idl.rs b/rts/motoko-rts/src/idl.rs
index 6435eb1c5e1..cfca1b9bfc2 100644
--- a/rts/motoko-rts/src/idl.rs
+++ b/rts/motoko-rts/src/idl.rs
@@ -1,16 +1,21 @@
 #![allow(non_upper_case_globals)]
+
 use crate::bitrel::BitRel;
 use crate::buf::{read_byte, read_word, skip_leb128, Buf};
 use crate::idl_trap_with;
-use crate::leb128::{leb128_decode, sleb128_decode};
+
 use crate::memory::{alloc_blob, Memory};
-use crate::persistence::compatibility::TypeDescriptor;
-use crate::types::{Value, Words, TAG_BLOB_B};
+use crate::types::{Words, TAG_BLOB_B};
 use crate::utf8::utf8_validate;
 
 use core::cmp::min;
 
-use motoko_rts_macros::ic_mem_fn;
+use motoko_rts_macros::{enhanced_orthogonal_persistence, ic_mem_fn};
+
+use crate::libc_declarations::{c_void, memcmp};
+
+#[enhanced_orthogonal_persistence]
+use crate::types::Value;
 
 extern "C" {
     // check instruction decoding limit, exported by moc
@@ -57,9 +62,23 @@ const IDL_CON_alias: i32 = 1;
 const IDL_PRIM_lowest: i32 = -17;
 
 // Only used for memory compatiblity checks for orthogonal persistence.
+#[enhanced_orthogonal_persistence]
 const IDL_EXT_blob: i32 = -129;
+#[enhanced_orthogonal_persistence]
 const IDL_EXT_tuple: i32 = -130;
 
+unsafe fn leb128_decode(buf: *mut Buf) -> u32 {
+    let value = crate::leb128::leb128_decode(buf);
+    assert!(value <= u32::MAX as usize);
+    value as u32
+}
+
+unsafe fn sleb128_decode(buf: *mut Buf) -> i32 {
+    let value = crate::leb128::sleb128_decode(buf);
+    assert!(value >= i32::MIN as isize && value <= i32::MAX as isize);
+    value as i32
+}
+
 pub unsafe fn leb128_decode_ptr(buf: *mut Buf) -> (u32, *mut u8) {
     (leb128_decode(buf), (*buf).ptr)
 }
@@ -70,7 +89,8 @@ enum CompatibilityMode {
     PureCandid,
     /// Candidish stabilization (old stabilization format).
     CandidishStabilization,
-    /// Memory compatibility of orthogonal persistence.
+    /// Memory compatibility of orthogonal persistence (with or without graph copying).
+    #[cfg(feature = "enhanced_orthogonal_persistence")]
     MemoryCompatibility,
 }
 
@@ -84,18 +104,15 @@ unsafe fn is_primitive_type(mode: CompatibilityMode, ty: i32) -> bool {
     match mode {
         CompatibilityMode::PureCandid => false,
         CompatibilityMode::CandidishStabilization => ty == IDL_EXT_region,
+        #[cfg(feature = "enhanced_orthogonal_persistence")]
         CompatibilityMode::MemoryCompatibility => ty == IDL_EXT_region || ty == IDL_EXT_blob,
     }
 }
 
 // TBR; based on Text.text_compare
-unsafe fn utf8_cmp(len1: u32, p1: *mut u8, len2: u32, p2: *mut u8) -> i32 {
+unsafe fn utf8_cmp(len1: usize, p1: *mut u8, len2: usize, p2: *mut u8) -> i32 {
     let len = min(len1, len2);
-    let cmp = libc::memcmp(
-        p1 as *mut libc::c_void,
-        p2 as *mut libc::c_void,
-        len as usize,
-    );
+    let cmp = memcmp(p1 as *mut c_void, p2 as *mut c_void, len);
     if cmp != 0 {
         return cmp;
     } else if len1 > len {
@@ -129,7 +146,7 @@ unsafe fn parse_fields(mode: CompatibilityMode, buf: *mut Buf, n_types: u32) {
 
 // NB. This function assumes the allocation does not need to survive GC
 // Therefore, no post allocation barrier is applied.
-unsafe fn alloc<M: Memory>(mem: &mut M, size: Words<u32>) -> *mut u8 {
+unsafe fn alloc<M: Memory>(mem: &mut M, size: Words<usize>) -> *mut u8 {
     alloc_blob(mem, TAG_BLOB_B, size.to_bytes())
         .as_blob_mut()
         .payload_addr()
@@ -158,7 +175,7 @@ unsafe fn parse_idl_header<M: Memory>(
     extended: bool,
     buf: *mut Buf,
     typtbl_out: *mut *mut *mut u8,
-    typtbl_size_out: *mut u32,
+    typtbl_size_out: *mut usize,
     main_types_out: *mut *mut u8,
 ) {
     let mode = if extended {
@@ -187,10 +204,10 @@ unsafe fn parse_idl_header<M: Memory>(
     }
 
     // Let the caller know about the table size
-    *typtbl_size_out = n_types;
+    *typtbl_size_out = n_types as usize;
 
     // Allocate the type table to be passed out
-    let typtbl: *mut *mut u8 = alloc(mem, Words(n_types)) as *mut _;
+    let typtbl: *mut *mut u8 = alloc(mem, Words(n_types as usize)) as *mut _;
 
     // Go through the table
     for i in 0..n_types {
@@ -247,14 +264,14 @@ unsafe fn parse_idl_header<M: Memory>(
             for _ in 0..leb128_decode(buf) {
                 // Name
                 let (len, p) = leb128_decode_ptr(buf);
-                buf.advance(len);
+                buf.advance(len as usize);
                 // Method names must be valid unicode
-                utf8_validate(p as *const _, len);
+                utf8_validate(p as *const _, len as usize);
                 // Method names must be in order
                 if last_p != core::ptr::null_mut() {
-                    let cmp = libc::memcmp(
-                        last_p as *mut libc::c_void,
-                        p as *mut libc::c_void,
+                    let cmp = memcmp(
+                        last_p as *mut c_void,
+                        p as *mut c_void,
                         min(last_len, len) as usize,
                     );
                     if cmp > 0 || (cmp == 0 && last_len >= len) {
@@ -271,7 +288,7 @@ unsafe fn parse_idl_header<M: Memory>(
         } else {
             // Future type
             let n = leb128_decode(buf);
-            buf.advance(n);
+            buf.advance(n as usize);
         }
     }
 
@@ -291,7 +308,7 @@ unsafe fn parse_idl_header<M: Memory>(
             for _ in 0..leb128_decode(&mut tmp_buf) {
                 // Name
                 let len = leb128_decode(&mut tmp_buf);
-                Buf::advance(&mut tmp_buf, len);
+                Buf::advance(&mut tmp_buf, len as usize);
                 // Type
                 let t = sleb128_decode(&mut tmp_buf);
                 if !(t >= 0 && (t as u32) < n_types) {
@@ -330,13 +347,13 @@ unsafe fn read_byte_tag(buf: *mut Buf) -> u8 {
 
 unsafe fn skip_blob(buf: *mut Buf) {
     let len = leb128_decode(buf);
-    buf.advance(len);
+    buf.advance(len as usize);
 }
 
 unsafe fn skip_text(buf: *mut Buf) {
     let (len, p) = leb128_decode_ptr(buf);
-    buf.advance(len); // advance first; does the bounds check
-    utf8_validate(p as *const _, len);
+    buf.advance(len as usize); // advance first; does the bounds check
+    utf8_validate(p as *const _, len as usize);
 }
 
 unsafe fn skip_any_vec(buf: *mut Buf, typtbl: *mut *mut u8, t: i32, count: u32) {
@@ -492,7 +509,7 @@ unsafe extern "C" fn skip_any(buf: *mut Buf, typtbl: *mut *mut u8, t: i32, depth
                 // Future type
                 let n_data = leb128_decode(buf);
                 let n_ref = leb128_decode(buf);
-                buf.advance(n_data);
+                buf.advance(n_data as usize);
                 if n_ref > 0 {
                     idl_trap_with("skip_any: skipping references");
                 }
@@ -535,7 +552,7 @@ unsafe extern "C" fn find_field(
     typtbl: *mut *mut u8,
     tag: u32,
     n: *mut u8,
-) -> u32 {
+) -> bool {
     while *n > 0 {
         let last_p = (*tb).ptr;
         let this_tag = leb128_decode(tb);
@@ -545,15 +562,15 @@ unsafe extern "C" fn find_field(
             *n -= 1;
         } else if tag == this_tag {
             *n -= 1;
-            return 1;
+            return true;
         } else {
             // Rewind reading tag
             (*tb).ptr = last_p;
-            return 0;
+            return false;
         }
     }
 
-    0
+    false
 }
 
 #[no_mangle]
@@ -584,6 +601,7 @@ unsafe fn is_null_opt_reserved(typtbl: *mut *mut u8, end: *mut u8, t: i32) -> bo
     return t == IDL_CON_opt;
 }
 
+#[enhanced_orthogonal_persistence]
 #[derive(PartialEq, Clone, Copy, Debug)]
 pub(crate) enum TypeVariance {
     Covariance,
@@ -591,6 +609,7 @@ pub(crate) enum TypeVariance {
     Invariance,
 }
 
+#[enhanced_orthogonal_persistence]
 impl TypeVariance {
     fn invert(self) -> TypeVariance {
         match self {
@@ -601,7 +620,13 @@ impl TypeVariance {
     }
 }
 
-unsafe fn recurring_memory_check(cache: &BitRel, variance: TypeVariance, t1: u32, t2: u32) -> bool {
+#[enhanced_orthogonal_persistence]
+unsafe fn recurring_memory_check(
+    cache: &BitRel,
+    variance: TypeVariance,
+    t1: usize,
+    t2: usize,
+) -> bool {
     match variance {
         TypeVariance::Covariance => cache.visited(true, t1, t2),
         TypeVariance::Contravariance => cache.visited(false, t1, t2),
@@ -609,7 +634,8 @@ unsafe fn recurring_memory_check(cache: &BitRel, variance: TypeVariance, t1: u32
     }
 }
 
-unsafe fn remember_memory_check(cache: &BitRel, variance: TypeVariance, t1: u32, t2: u32) {
+#[enhanced_orthogonal_persistence]
+unsafe fn remember_memory_check(cache: &BitRel, variance: TypeVariance, t1: usize, t2: usize) {
     match variance {
         TypeVariance::Covariance => cache.visit(true, t1, t2),
         TypeVariance::Contravariance => cache.visit(false, t1, t2),
@@ -620,7 +646,7 @@ unsafe fn remember_memory_check(cache: &BitRel, variance: TypeVariance, t1: u32,
     }
 }
 
-/// Memory compatibility check for orthogonal persistence.
+/// Memory compatibility check for orthogonal persistence (with or without graph copying).
 /// Checks whether the new type (`typetbl2`) is compatible to the old type (`typetbl1`).
 /// The implementation is similar to the Candid sub-type test `sub()` below, however,
 /// with some relevant differences w.r.t. the permitted type relations:
@@ -630,6 +656,7 @@ unsafe fn remember_memory_check(cache: &BitRel, variance: TypeVariance, t1: u32,
 /// * Records cannot introduce additional optional fields.
 /// * Same arity for tuple types.
 /// * Records and tuples are distinct.
+#[enhanced_orthogonal_persistence]
 pub(crate) unsafe fn memory_compatible(
     rel: &BitRel,
     variance: TypeVariance,
@@ -645,8 +672,8 @@ pub(crate) unsafe fn memory_compatible(
     // i.e. new actor fields can be inserted in new program versions.
     // The `main_actor` flag only occurs non-recursively at the top level of the memory compatibility check.
     if !main_actor && t1 >= 0 && t2 >= 0 {
-        let t1 = t1 as u32;
-        let t2 = t2 as u32;
+        let t1 = t1 as usize;
+        let t2 = t2 as usize;
         if recurring_memory_check(rel, variance, t1, t2) {
             return true;
         };
@@ -894,7 +921,7 @@ pub(crate) unsafe fn memory_compatible(
                     return false;
                 };
                 let (len2, p2) = leb128_decode_ptr(&mut tb2);
-                Buf::advance(&mut tb2, len2);
+                Buf::advance(&mut tb2, len2 as usize);
                 let t21 = sleb128_decode(&mut tb2);
                 let mut len1: u32;
                 let mut p1: *mut u8;
@@ -902,10 +929,10 @@ pub(crate) unsafe fn memory_compatible(
                 let mut cmp: i32;
                 loop {
                     (len1, p1) = leb128_decode_ptr(&mut tb1);
-                    Buf::advance(&mut tb1, len1);
+                    Buf::advance(&mut tb1, len1 as usize);
                     t11 = sleb128_decode(&mut tb1);
                     n1 -= 1;
-                    cmp = utf8_cmp(len1, p1, len2, p2);
+                    cmp = utf8_cmp(len1 as usize, p1, len2 as usize, p2);
                     if variance != TypeVariance::Invariance && cmp < 0 && n1 > 0 {
                         continue;
                     };
@@ -938,8 +965,8 @@ pub(crate) unsafe fn sub(
     t2: i32,
 ) -> bool {
     if t1 >= 0 && t2 >= 0 {
-        let t1 = t1 as u32;
-        let t2 = t2 as u32;
+        let t1 = t1 as usize;
+        let t2 = t2 as usize;
         if rel.visited(p, t1, t2) {
             // visited? (bit 0)
             // return assumed or determined result
@@ -1161,7 +1188,7 @@ pub(crate) unsafe fn sub(
                         break 'return_false;
                     };
                     let (len2, p2) = leb128_decode_ptr(&mut tb2);
-                    Buf::advance(&mut tb2, len2);
+                    Buf::advance(&mut tb2, len2 as usize);
                     let t21 = sleb128_decode(&mut tb2);
                     let mut len1: u32;
                     let mut p1: *mut u8;
@@ -1169,10 +1196,10 @@ pub(crate) unsafe fn sub(
                     let mut cmp: i32;
                     loop {
                         (len1, p1) = leb128_decode_ptr(&mut tb1);
-                        Buf::advance(&mut tb1, len1);
+                        Buf::advance(&mut tb1, len1 as usize);
                         t11 = sleb128_decode(&mut tb1);
                         n1 -= 1;
-                        cmp = utf8_cmp(len1, p1, len2, p2);
+                        cmp = utf8_cmp(len1 as usize, p1, len2 as usize, p2);
                         if cmp < 0 && n1 > 0 {
                             continue;
                         };
@@ -1195,19 +1222,23 @@ pub(crate) unsafe fn sub(
     }
     // remember negative result ...
     if t1 >= 0 && t2 >= 0 {
-        rel.disprove(p, t1 as u32, t2 as u32);
+        rel.disprove(p, t1 as usize, t2 as usize);
     }
     // .. only then return false
     return false;
 }
 
 #[no_mangle]
-unsafe extern "C" fn idl_sub_buf_words(typtbl_size1: u32, typtbl_size2: u32) -> u32 {
+unsafe extern "C" fn idl_sub_buf_words(typtbl_size1: usize, typtbl_size2: usize) -> usize {
     return BitRel::words(typtbl_size1, typtbl_size2);
 }
 
 #[no_mangle]
-unsafe extern "C" fn idl_sub_buf_init(rel_buf: *mut u32, typtbl_size1: u32, typtbl_size2: u32) {
+unsafe extern "C" fn idl_sub_buf_init(
+    rel_buf: *mut usize,
+    typtbl_size1: usize,
+    typtbl_size2: usize,
+) {
     let rel = BitRel {
         ptr: rel_buf,
         end: rel_buf.add(idl_sub_buf_words(typtbl_size1, typtbl_size2) as usize),
@@ -1217,6 +1248,7 @@ unsafe extern "C" fn idl_sub_buf_init(rel_buf: *mut u32, typtbl_size1: u32, typt
     rel.init();
 }
 
+#[enhanced_orthogonal_persistence]
 #[ic_mem_fn]
 unsafe fn idl_alloc_typtbl<M: Memory>(
     mem: &mut M,
@@ -1224,27 +1256,29 @@ unsafe fn idl_alloc_typtbl<M: Memory>(
     type_offsets: Value,
     typtbl_out: *mut *mut *mut u8,
     typtbl_end_out: *mut *mut u8,
-    typtbl_size_out: *mut u32,
+    typtbl_size_out: *mut usize,
 ) {
+    use crate::persistence::compatibility::TypeDescriptor;
+
     let mut type_descriptor = TypeDescriptor::new(candid_data, type_offsets);
     *typtbl_out = type_descriptor.build_type_table(mem);
     *typtbl_end_out = type_descriptor.type_table_end();
-    *typtbl_size_out = type_descriptor.type_count() as u32;
+    *typtbl_size_out = type_descriptor.type_count();
 }
 
 #[no_mangle]
 unsafe extern "C" fn idl_sub(
-    rel_buf: *mut u32, // a buffer with at least 2 * typtbl_size1 * typtbl_size2 bits
+    rel_buf: *mut usize, // a buffer with at least 2 * typtbl_size1 * typtbl_size2 bits
     typtbl1: *mut *mut u8,
     typtbl2: *mut *mut u8,
     typtbl_end1: *mut u8,
     typtbl_end2: *mut u8,
-    typtbl_size1: u32,
-    typtbl_size2: u32,
+    typtbl_size1: usize,
+    typtbl_size2: usize,
     t1: i32,
     t2: i32,
 ) -> bool {
-    debug_assert!(rel_buf != (0 as *mut u32));
+    debug_assert!(rel_buf != (0 as *mut usize));
     debug_assert!(typtbl1 != (0 as *mut *mut u8));
     debug_assert!(typtbl2 != (0 as *mut *mut u8));
     debug_assert!(typtbl_end1 != (0 as *mut u8));
@@ -1256,9 +1290,7 @@ unsafe extern "C" fn idl_sub(
         size1: typtbl_size1,
         size2: typtbl_size2,
     };
-
     debug_assert!(t1 < (typtbl_size1 as i32) && t2 < (typtbl_size2 as i32));
-
     return sub(
         &rel,
         true,
diff --git a/rts/motoko-rts/src/leb128.rs b/rts/motoko-rts/src/leb128.rs
index 7df17efa77d..76a22eb1a2f 100644
--- a/rts/motoko-rts/src/leb128.rs
+++ b/rts/motoko-rts/src/leb128.rs
@@ -3,7 +3,7 @@
 use crate::buf::{read_byte, Buf};
 
 #[no_mangle]
-pub unsafe extern "C" fn leb128_encode(mut val: u32, mut buf: *mut u8) {
+pub unsafe extern "C" fn leb128_encode(mut val: usize, mut buf: *mut u8) {
     loop {
         let byte = (val & 0b0111_1111) as u8;
         val >>= 7;
@@ -18,7 +18,7 @@ pub unsafe extern "C" fn leb128_encode(mut val: u32, mut buf: *mut u8) {
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn sleb128_encode(mut val: i32, mut buf: *mut u8) {
+pub unsafe extern "C" fn sleb128_encode(mut val: isize, mut buf: *mut u8) {
     loop {
         let byte = (val & 0b0111_1111) as u8;
         val >>= 7;
@@ -34,23 +34,37 @@ pub unsafe extern "C" fn sleb128_encode(mut val: i32, mut buf: *mut u8) {
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn leb128_decode(buf: *mut Buf) -> u32 {
+pub unsafe extern "C" fn leb128_decode(buf: *mut Buf) -> usize {
     leb128_decode_checked(buf).expect("leb128_decode: overflow")
 }
 
 /// Returns `None` on overflow
-pub unsafe fn leb128_decode_checked(buf: *mut Buf) -> Option<u32> {
+pub unsafe fn leb128_decode_checked(buf: *mut Buf) -> Option<usize> {
     let mut result = 0;
     let mut shift = 0;
 
     loop {
         let byte = read_byte(buf);
 
-        result |= ((byte & 0b0111_1111) as u32) << shift;
-
-        // The 5th byte needs to be the last, and it must contribute at most 4 bits, otherwise we
+        result |= ((byte & 0b0111_1111) as usize) << shift;
+
+        let overflow = match usize::BITS {
+            u64::BITS => {
+                // The 10th byte needs to be the last, and it must contribute at most 1 bit, otherwise we
+                // have an overflow.
+                shift == 63 && (byte & 0b1111_1110) != 0
+            }
+            u32::BITS => {
+                // The 5th byte needs to be the last, and it must contribute at most 4 bits, otherwise we
+                // have an overflow.
+                shift == 28 && (byte & 0b1111_0000) != 0
+            }
+            _ => unreachable!(),
+        };
+
+        // The 10th byte needs to be the last, and it must contribute at most 1 bit, otherwise we
         // have an overflow
-        if shift == 28 && (byte & 0b1111_0000) != 0 {
+        if overflow {
             return None;
         }
 
@@ -65,23 +79,33 @@ pub unsafe fn leb128_decode_checked(buf: *mut Buf) -> Option<u32> {
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn sleb128_decode(buf: *mut Buf) -> i32 {
+pub unsafe extern "C" fn sleb128_decode(buf: *mut Buf) -> isize {
     sleb128_decode_checked(buf).expect("sleb128_decode: overflow")
 }
 
 /// Returns `None` on overflow
-pub unsafe fn sleb128_decode_checked(buf: *mut Buf) -> Option<i32> {
+pub unsafe fn sleb128_decode_checked(buf: *mut Buf) -> Option<isize> {
     let mut result = 0;
     let mut shift = 0;
 
     let last_byte = loop {
         let byte = read_byte(buf);
 
-        result |= ((byte & 0b0111_1111) as i32) << shift;
+        result |= ((byte & 0b0111_1111) as isize) << shift;
 
         // Overflow check ported from Wasm reference implementation:
         // https://github.com/WebAssembly/spec/blob/f9770eb75117cac0c878feaa5eaf4a4d9dda61f5/interpreter/binary/decode.ml#L89-L98
-        if shift == 28 && (byte & 0b0111_1000 != 0 && byte & 0b0111_1000 != 0b0111_1000) {
+        let overflow = match usize::BITS {
+            u64::BITS => {
+                shift == 63 && (byte & 0b0111_1111 != 0 && byte & 0b0111_1111 != 0b0111_1111)
+            }
+            u32::BITS => {
+                shift == 28 && (byte & 0b0111_1000 != 0 && byte & 0b0111_1000 != 0b0111_1000)
+            }
+            _ => unreachable!(),
+        };
+
+        if overflow {
             return None;
         }
 
@@ -93,7 +117,7 @@ pub unsafe fn sleb128_decode_checked(buf: *mut Buf) -> Option<i32> {
     };
 
     // Sign extend
-    if shift < 32 && last_byte & 0b0100_0000 != 0 {
+    if shift < usize::BITS && last_byte & 0b0100_0000 != 0 {
         result |= !0 << shift;
     }
 
diff --git a/rts/motoko-rts/src/lib.rs b/rts/motoko-rts/src/lib.rs
index 52130eba35f..e3579e31a8d 100644
--- a/rts/motoko-rts/src/lib.rs
+++ b/rts/motoko-rts/src/lib.rs
@@ -5,7 +5,10 @@
     arbitrary_self_types,
     core_intrinsics,
     panic_info_message,
-    proc_macro_hygiene
+    proc_macro_hygiene,
+    // // We do not need simd but this flag enables `core::arch:wasm64`.
+    // // See https://github.com/rust-lang/rust/issues/90599
+    simd_wasm64
 )]
 
 // c.f. https://os.phil-opp.com/heap-allocation/#dynamic-memory
@@ -36,16 +39,21 @@ pub mod gc;
 #[cfg(feature = "ic")]
 mod idl;
 pub mod leb128;
-mod mem_utils;
+mod libc_declarations;
+pub mod mem_utils;
 pub mod memory;
 #[cfg(feature = "ic")]
+#[enhanced_orthogonal_persistence]
 pub mod persistence;
 pub mod principal_id;
 #[cfg(feature = "ic")]
 pub mod region;
-#[cfg(feature = "ic")]
-mod stable_mem;
+#[enhanced_orthogonal_persistence]
+pub mod stabilization;
+pub mod stable_mem;
 mod static_checks;
+#[classical_persistence]
+pub mod stream;
 pub mod text;
 pub mod text_iter;
 mod tommath_bindings;
@@ -53,8 +61,6 @@ pub mod types;
 pub mod utf8;
 mod visitor;
 
-use types::Bytes;
-
 use motoko_rts_macros::*;
 
 #[ic_mem_fn(ic_only)]
@@ -62,13 +68,20 @@ unsafe fn version<M: memory::Memory>(mem: &mut M) -> types::Value {
     text::text_of_str(mem, "0.1")
 }
 
+#[non_incremental_gc]
+#[ic_mem_fn(ic_only)]
+unsafe fn alloc_words<M: memory::Memory>(mem: &mut M, n: types::Words<usize>) -> types::Value {
+    mem.alloc_words(n)
+}
+
+#[incremental_gc]
 #[ic_mem_fn(ic_only)]
-unsafe fn alloc_words<M: memory::Memory>(mem: &mut M, n: types::Words<u32>) -> types::Value {
+unsafe fn alloc_words<M: memory::Memory>(mem: &mut M, n: types::Words<usize>) -> types::Value {
     crate::gc::incremental::get_partitioned_heap().allocate(mem, n)
 }
 
 extern "C" {
-    fn rts_trap(msg: *const u8, len: Bytes<u32>) -> !;
+    fn rts_trap(msg: *const u8, len: u32) -> !;
 }
 
 pub(crate) unsafe fn trap_with_prefix(prefix: &str, msg: &str) -> ! {
@@ -99,7 +112,8 @@ pub(crate) unsafe fn trap_with_prefix(prefix: &str, msg: &str) -> ! {
         b_idx += 1;
     }
 
-    rts_trap(c_str.as_ptr(), Bytes(b_idx as u32));
+    assert!(b_idx <= u32::MAX as usize);
+    rts_trap(c_str.as_ptr(), b_idx as u32);
 }
 
 pub(crate) unsafe fn idl_trap_with(msg: &str) -> ! {
diff --git a/rts/motoko-rts/src/libc_declarations.rs b/rts/motoko-rts/src/libc_declarations.rs
new file mode 100644
index 00000000000..25a8b3c181c
--- /dev/null
+++ b/rts/motoko-rts/src/libc_declarations.rs
@@ -0,0 +1,36 @@
+// Declarations adopted from https://github.com/rust-lang/libc/blob/main/src/wasi.rs.
+#![allow(non_camel_case_types)]
+
+use motoko_rts_macros::classical_persistence;
+use motoko_rts_macros::enhanced_orthogonal_persistence;
+
+pub(crate) type c_void = core::ffi::c_void;
+pub(crate) type size_t = usize;
+pub(crate) type c_char = i8;
+pub(crate) type c_int = i32;
+
+#[classical_persistence]
+#[cfg(feature = "ic")]
+pub(crate) type c_double = f64;
+
+#[classical_persistence]
+pub(crate) unsafe fn memcpy(dest: *mut c_void, src: *const c_void, n: size_t) -> *mut c_void {
+    libc::memcpy(dest, src, n)
+}
+
+#[classical_persistence]
+pub(crate) unsafe fn memset(dest: *mut c_void, c: c_int, n: size_t) -> *mut c_void {
+    libc::memset(dest, c, n)
+}
+
+#[classical_persistence]
+pub(crate) unsafe fn memcmp(cx: *const c_void, ct: *const c_void, n: size_t) -> c_int {
+    libc::memcmp(cx, ct, n)
+}
+
+#[enhanced_orthogonal_persistence]
+extern "C" {
+    pub(crate) fn memcpy(dest: *mut c_void, src: *const c_void, n: size_t) -> *mut c_void;
+    pub(crate) fn memset(dest: *mut c_void, c: c_int, n: size_t) -> *mut c_void;
+    pub(crate) fn memcmp(cx: *const c_void, ct: *const c_void, n: size_t) -> c_int;
+}
diff --git a/rts/motoko-rts/src/mem_utils.rs b/rts/motoko-rts/src/mem_utils.rs
index 37b1d07e1ce..67bbc4c0207 100644
--- a/rts/motoko-rts/src/mem_utils.rs
+++ b/rts/motoko-rts/src/mem_utils.rs
@@ -1,18 +1,20 @@
 use crate::types::{Bytes, Words};
 
-pub(crate) unsafe fn memcpy_words(to: usize, from: usize, n: Words<u32>) {
-    libc::memcpy(to as *mut _, from as *const _, n.to_bytes().as_usize());
+use crate::libc_declarations::{memcpy, memset};
+
+pub unsafe fn memcpy_words(to: usize, from: usize, n: Words<usize>) {
+    memcpy(to as *mut _, from as *const _, n.to_bytes().as_usize());
 }
 
-pub(crate) unsafe fn memcpy_bytes(to: usize, from: usize, n: Bytes<u32>) {
-    libc::memcpy(to as *mut _, from as *const _, n.as_usize());
+pub unsafe fn memcpy_bytes(to: usize, from: usize, n: Bytes<usize>) {
+    memcpy(to as *mut _, from as *const _, n.as_usize());
 }
 
-pub(crate) unsafe fn memzero(to: usize, n: Words<u32>) {
-    libc::memset(to as *mut _, 0, n.to_bytes().as_usize());
+pub unsafe fn memzero(to: usize, n: Words<usize>) {
+    memset(to as *mut _, 0, n.to_bytes().as_usize());
 }
 
 #[cfg(feature = "ic")]
-pub(crate) unsafe fn memzero_bytes(to: usize, n: Bytes<u32>) {
-    libc::memset(to as *mut _, 0, n.as_usize());
+pub unsafe fn memzero_bytes(to: usize, n: Bytes<usize>) {
+    memset(to as *mut _, 0, n.as_usize());
 }
diff --git a/rts/motoko-rts/src/memory.rs b/rts/motoko-rts/src/memory.rs
index 15a272263e5..ad1f0e75bef 100644
--- a/rts/motoko-rts/src/memory.rs
+++ b/rts/motoko-rts/src/memory.rs
@@ -1,14 +1,24 @@
 #[cfg(feature = "ic")]
 pub mod ic;
+use crate::{constants::MAX_ARRAY_LENGTH_FOR_ITERATOR, types::*};
 
-use crate::constants::MAX_ARRAY_SIZE;
-use crate::rts_trap_with;
-use crate::types::*;
+use motoko_rts_macros::classical_persistence;
+use motoko_rts_macros::enhanced_orthogonal_persistence;
+use motoko_rts_macros::ic_mem_fn;
 
 #[cfg(feature = "ic")]
 use crate::constants::MB;
 
-use motoko_rts_macros::ic_mem_fn;
+#[enhanced_orthogonal_persistence]
+use crate::constants::GB;
+
+// TODO: Redesign for 64-bit support by using a dynamic partition list.
+/// Currently limited to 64 GB.
+#[enhanced_orthogonal_persistence]
+pub const MAXIMUM_MEMORY_SIZE: Bytes<u64> = Bytes(64u64 * GB as u64);
+
+#[classical_persistence]
+pub const MAXIMUM_MEMORY_SIZE: Bytes<u64> = Bytes(usize::MAX as u64);
 
 // Memory reserve in bytes ensured during update and initialization calls.
 // For use by queries and upgrade calls.
@@ -35,17 +45,17 @@ pub(crate) const GENERAL_MEMORY_RESERVE: usize = 256 * MB;
 /// This function does not take any `Memory` arguments can be used by the generated code.
 pub trait Memory {
     // General allocator working for all GC variants.
-    unsafe fn alloc_words(&mut self, n: Words<u32>) -> Value;
+    unsafe fn alloc_words(&mut self, n: Words<usize>) -> Value;
 
     // Grow the allocated memory size to at least the address of `ptr`.
-    unsafe fn grow_memory(&mut self, ptr: u64);
+    unsafe fn grow_memory(&mut self, ptr: usize);
 }
 
 /// Allocate a new blob.
 /// Note: After initialization, the post allocation barrier needs to be applied to all mutator objects.
 /// For RTS-internal blobs that can be collected by the next GC run, the post allocation barrier can be omitted.
 #[ic_mem_fn]
-pub unsafe fn alloc_blob<M: Memory>(mem: &mut M, tag: u32, size: Bytes<u32>) -> Value {
+pub unsafe fn alloc_blob<M: Memory>(mem: &mut M, tag: Tag, size: Bytes<usize>) -> Value {
     debug_assert!(is_blob_tag(tag));
     let ptr = mem.alloc_words(size_of::<Blob>() + size.to_words());
     // NB. Cannot use `as_blob` here as we didn't write the header yet
@@ -60,12 +70,9 @@ pub unsafe fn alloc_blob<M: Memory>(mem: &mut M, tag: u32, size: Bytes<u32>) ->
 /// Allocate a new array.
 /// Note: After initialization, the post allocation barrier needs to be applied to all mutator objects.
 #[ic_mem_fn]
-pub unsafe fn alloc_array<M: Memory>(mem: &mut M, tag: u32, len: u32) -> Value {
+pub unsafe fn alloc_array<M: Memory>(mem: &mut M, tag: Tag, len: usize) -> Value {
     debug_assert!(is_base_array_tag(tag));
-    // Array payload should not be larger than half of the memory
-    if len > MAX_ARRAY_SIZE {
-        rts_trap_with("Array allocation too large");
-    }
+    assert!(len <= MAX_ARRAY_LENGTH_FOR_ITERATOR);
 
     let skewed_ptr = mem.alloc_words(size_of::<Array>() + Words(len));
 
diff --git a/rts/motoko-rts/src/memory/ic.rs b/rts/motoko-rts/src/memory/ic.rs
index 8e8334dd76d..36cae23a4eb 100644
--- a/rts/motoko-rts/src/memory/ic.rs
+++ b/rts/motoko-rts/src/memory/ic.rs
@@ -1,77 +1,84 @@
 // This module is only enabled when compiling the RTS for IC or WASI.
 
+#[non_incremental_gc]
+pub mod linear_memory;
+
+#[incremental_gc]
+pub mod partitioned_memory;
+
+#[classical_persistence]
+pub mod classical_memory;
+
+#[enhanced_orthogonal_persistence]
+pub mod enhanced_memory;
+
+use motoko_rts_macros::{
+    classical_persistence, enhanced_orthogonal_persistence, incremental_gc, non_incremental_gc,
+};
+
 use super::Memory;
-use crate::constants::WASM_PAGE_SIZE;
-use crate::rts_trap_with;
-use crate::types::{Bytes, Value, Words};
-use core::arch::wasm32;
 
+// Provided by generated code
 extern "C" {
+    #[classical_persistence]
+    pub(crate) fn get_static_roots() -> crate::types::Value;
+
     fn keep_memory_reserve() -> bool;
 }
 
+#[classical_persistence]
+pub(crate) unsafe fn get_aligned_heap_base() -> usize {
+    classical_memory::get_aligned_heap_base()
+}
+
+#[enhanced_orthogonal_persistence]
+pub(crate) unsafe fn get_aligned_heap_base() -> usize {
+    enhanced_memory::get_aligned_heap_base()
+}
+
 /// Provides a `Memory` implementation, to be used in functions compiled for IC or WASI. The
 /// `Memory` implementation allocates in Wasm heap with Wasm `memory.grow` instruction.
 pub struct IcMemory;
 
-impl Memory for IcMemory {
-    #[inline]
-    unsafe fn alloc_words(&mut self, n: Words<u32>) -> Value {
-        crate::gc::incremental::get_partitioned_heap().allocate(self, n)
-    }
-
-    /// Page allocation. Ensures that the memory up to, but excluding, the given pointer is allocated.
-    /// Ensure a memory reserve of at least one Wasm page depending on the canister state.
-    /// `memory_reserve`: A memory reserve in bytes ensured during update and initialization calls.
-    /// For use by queries and upgrade calls. The reserve may vary depending on the phase of the incremental GC.
-    #[inline(never)]
-    unsafe fn grow_memory(&mut self, ptr: u64) {
-        const LAST_PAGE_LIMIT: usize = 0xFFFF_0000;
-        debug_assert_eq!(LAST_PAGE_LIMIT, usize::MAX - WASM_PAGE_SIZE.as_usize() + 1);
-        // Spare a memory reserve during update and initialization calls for use by queries and upgrades.
-        let memory_reserve = if keep_memory_reserve() {
-            crate::gc::incremental::memory_reserve()
-        } else {
-            0
-        };
-        // In any case, the last Wasm memory page is reserved to guard against shadow call stack overflows.
-        // This call stack is used both by the Rust runtime system implementation and by the compiler backend,
-        // see module `Stack` in `compile.ml`. This requires function activation frames to be less than the
-        // Wasm page size.
-        debug_assert!(memory_reserve <= LAST_PAGE_LIMIT);
-        let limit = LAST_PAGE_LIMIT - memory_reserve;
-        // The pointer is one byte larger than the memory size to be allocated, see the comment above.
-        if ptr > limit as u64 {
-            rts_trap_with("Cannot grow memory")
-        };
-        let page_size = u64::from(WASM_PAGE_SIZE.as_u32());
-        let total_pages_needed = ((ptr + page_size - 1) / page_size) as usize;
-        let current_pages = wasm32::memory_size(0);
-        if total_pages_needed > current_pages {
-            if wasm32::memory_grow(0, total_pages_needed - current_pages) == core::usize::MAX {
-                // replica signals that there is not enough memory
-                rts_trap_with("Cannot grow memory");
-            }
-        }
-    }
+/// Number of Wasm pages in main memory.
+#[classical_persistence]
+#[non_incremental_gc]
+fn wasm_memory_size() -> usize {
+    classical_memory::wasm_memory_size()
 }
 
-#[no_mangle]
-unsafe extern "C" fn get_reclaimed() -> Bytes<u64> {
-    crate::gc::incremental::get_partitioned_heap().reclaimed_size()
+/// Page allocation. Ensures that the memory up to, but excluding, the given pointer is allocated.
+/// Ensure a memory reserve of at least one Wasm page depending on the canister state.
+/// `memory_reserve`: A memory reserve in bytes ensured during update and initialization calls.
+/// The reserve can be used by queries and upgrade calls.
+#[classical_persistence]
+unsafe fn grow_memory(ptr: u64, memory_reserve: usize) {
+    classical_memory::grow_memory(ptr, memory_reserve);
 }
 
-#[no_mangle]
-pub unsafe extern "C" fn get_total_allocations() -> Bytes<u64> {
-    Bytes(u64::from(get_heap_size().as_u32())) + get_reclaimed()
+/// Page allocation. Ensures that the memory up to, but excluding, the given pointer is allocated.
+/// Ensure a memory reserve of at least one Wasm page depending on the canister state.
+/// `memory_reserve`: A memory reserve in bytes ensured during update and initialization calls.
+/// The reserve can be used by queries and upgrade calls.
+#[enhanced_orthogonal_persistence]
+unsafe fn grow_memory(ptr: u64, memory_reserve: usize) {
+    use core::mem::size_of;
+    // Statically assert the safe conversion from `u64` to `usize`.
+    const _: () = assert!(size_of::<u64>() == size_of::<usize>());
+    enhanced_memory::grow_memory(ptr as usize, memory_reserve);
 }
 
-#[no_mangle]
-pub unsafe extern "C" fn get_heap_size() -> Bytes<u32> {
-    crate::gc::incremental::get_partitioned_heap().occupied_size()
+/// Grow memory without memory reserve (except the last WASM page).
+/// Used during RTS initialization.
+#[classical_persistence]
+#[incremental_gc]
+pub(crate) unsafe fn allocate_wasm_memory(memory_size: crate::types::Bytes<usize>) {
+    classical_memory::allocate_wasm_memory(memory_size);
 }
 
-#[no_mangle]
-pub unsafe extern "C" fn get_max_live_size() -> Bytes<u32> {
-    crate::gc::incremental::get_max_live_size()
+/// Grow memory without memory reserve (except the last WASM page).
+/// Used during RTS initialization.
+#[enhanced_orthogonal_persistence]
+pub(crate) unsafe fn allocate_wasm_memory(memory_size: crate::types::Bytes<usize>) {
+    enhanced_memory::allocate_wasm_memory(memory_size);
 }
diff --git a/rts/motoko-rts/src/memory/ic/classical_memory.rs b/rts/motoko-rts/src/memory/ic/classical_memory.rs
new file mode 100644
index 00000000000..a26eeea8a87
--- /dev/null
+++ b/rts/motoko-rts/src/memory/ic/classical_memory.rs
@@ -0,0 +1,62 @@
+use motoko_rts_macros::incremental_gc;
+
+use crate::constants::WASM_PAGE_SIZE;
+use crate::memory::ic::keep_memory_reserve;
+use crate::rts_trap_with;
+use core::arch::wasm32;
+
+// Provided by generated code
+extern "C" {
+    fn get_heap_base() -> usize;
+}
+
+pub(crate) unsafe fn get_aligned_heap_base() -> usize {
+    // align to 32 bytes
+    ((get_heap_base() + 31) / 32) * 32
+}
+
+/// Number of Wasm pages in main memory.
+pub fn wasm_memory_size() -> usize {
+    wasm32::memory_size(0)
+}
+
+/// Page allocation. Ensures that the memory up to, but excluding, the given pointer is allocated.
+/// Ensure a memory reserve of at least one Wasm page depending on the canister state.
+/// `memory_reserve`: A memory reserve in bytes ensured during update and initialization calls.
+/// The reserve can be used by queries and upgrade calls. The reserve may vary depending on the GC
+/// and the phase of the GC.
+pub unsafe fn grow_memory(ptr: u64, memory_reserve: usize) {
+    const LAST_PAGE_LIMIT: usize = usize::MAX - WASM_PAGE_SIZE.as_usize() + 1;
+    // Spare a memory reserve during update and initialization calls for use by queries and upgrades.
+    let memory_reserve = if keep_memory_reserve() {
+        memory_reserve
+    } else {
+        0
+    };
+    // In any case, the last Wasm memory page is reserved to guard against shadow call stack overflows.
+    // This call stack is used both by the Rust runtime system implementation and by the compiler backend,
+    // see module `Stack` in `compile.ml`. This requires function activation frames to be less than the
+    // Wasm page size.
+    debug_assert!(memory_reserve <= LAST_PAGE_LIMIT);
+    let limit = LAST_PAGE_LIMIT - memory_reserve;
+    // The pointer is one byte larger than the memory size to be allocated, see the comment above.
+    if ptr > limit as u64 {
+        rts_trap_with("Cannot grow memory")
+    };
+    let page_size = WASM_PAGE_SIZE.as_usize() as u64;
+    let total_pages_needed = ((ptr + page_size - 1) / page_size) as usize;
+    let current_pages = wasm_memory_size();
+    if total_pages_needed > current_pages {
+        if wasm32::memory_grow(0, total_pages_needed - current_pages) == core::usize::MAX {
+            // replica signals that there is not enough memory
+            rts_trap_with("Cannot grow memory");
+        }
+    }
+}
+
+/// Grow memory without memory reserve (except the last WASM page).
+/// Used during RTS initialization.
+#[incremental_gc]
+pub(crate) unsafe fn allocate_wasm_memory(memory_size: crate::types::Bytes<usize>) {
+    grow_memory(memory_size.as_usize() as u64, WASM_PAGE_SIZE.as_usize());
+}
diff --git a/rts/motoko-rts/src/memory/ic/enhanced_memory.rs b/rts/motoko-rts/src/memory/ic/enhanced_memory.rs
new file mode 100644
index 00000000000..365e667ac74
--- /dev/null
+++ b/rts/motoko-rts/src/memory/ic/enhanced_memory.rs
@@ -0,0 +1,84 @@
+use crate::constants::{GB, WASM_PAGE_SIZE};
+use crate::memory::ic::keep_memory_reserve;
+use crate::rts_trap_with;
+use crate::types::Bytes;
+use core::arch::wasm64;
+use core::cmp::max;
+
+pub(crate) unsafe fn get_aligned_heap_base() -> usize {
+    crate::persistence::HEAP_START
+}
+
+/// Probe the memory capacity beyond this limit by pre-allocating the reserve.
+/// This is necessary because there is no function to query the IC's main memory capacity for 64-bit.
+/// It is assumed that the capacity is at least the 32-bit space of 4GB, minus the last reserved
+/// Wasm page (for Rust call stack overflow detection, see `compile.ml`).
+const GUARANTEED_MEMORY_CAPACITY: usize = 4 * GB - WASM_PAGE_SIZE.0;
+
+/// Assumption (not correctness-critical): The IC offers main memory in multiple of 2 GB.
+/// This helps to avoid overly frequent memory probing when the heap grows.
+/// The capacity granularity only serves as a heuristics for GC scheduling.
+const IC_MEMORY_CAPACITY_GRANULARITY: usize = 2 * GB;
+
+/// Page allocation. Ensures that the memory up to, but excluding, the given pointer is allocated.
+/// Ensure a memory reserve of at least one Wasm page depending on the canister state.
+/// `memory_reserve`: A memory reserve in bytes ensured during update and initialization calls.
+/// The reserve can be used by queries and upgrade calls.
+pub(crate) unsafe fn grow_memory(ptr: usize, memory_reserve: usize) {
+    debug_assert!(memory_reserve <= GUARANTEED_MEMORY_CAPACITY);
+    let memory_demand =
+        if keep_memory_reserve() && ptr > GUARANTEED_MEMORY_CAPACITY - memory_reserve {
+            // Detect overflow of `ptr + memory_reserve`.
+            if ptr > usize::MAX - memory_reserve {
+                rts_trap_with("Cannot grow memory");
+            }
+            // The reserve will be pre-allocated as a way to check the main memory capacity.
+            // As the reserve can be substantial, this is only done when memory demand has
+            // grown beyond `GUARANTEED_MEMORY_CAPACITY`.
+            ptr + memory_reserve
+        } else {
+            // Either no reserve is needed or there is enough guaranteed memory capacity for the reserve,
+            // we can skip the pre-allocation of a reserve.
+            ptr
+        };
+    allocate_wasm_memory(Bytes(memory_demand));
+}
+
+/// Supposed minimum memory capacity used for GC scheduling heuristics.
+/// The result may increase after time. This is because the actual capacity is
+/// not known upfront and can only derived by memory allocation probing.
+/// Moreover, the IC may increase the canister main memory capacity in newer versions.
+pub(crate) fn minimum_memory_capacity() -> Bytes<usize> {
+    let allocated_memory = wasm64::memory_size(0) * WASM_PAGE_SIZE.as_usize();
+    let unrounded_capacity = max(allocated_memory, GUARANTEED_MEMORY_CAPACITY);
+    Bytes(unrounded_capacity).next_multiple_of(IC_MEMORY_CAPACITY_GRANULARITY)
+}
+
+/// Grow memory without memory reserve. Used during RTS initialization and by the ordinary
+/// reserve-conscious memory-grow operation (`Memory::grow_memory`).
+pub(crate) unsafe fn allocate_wasm_memory(memory_size: Bytes<usize>) {
+    const LAST_PAGE_LIMIT: usize = 0xFFFF_FFFF_FFFF_0000;
+    debug_assert_eq!(LAST_PAGE_LIMIT, usize::MAX - WASM_PAGE_SIZE.as_usize() + 1);
+    // Never allocate the last page (shadow call stack overflow detection, see `compile.ml`).
+    if memory_size.as_usize() > LAST_PAGE_LIMIT {
+        rts_trap_with("Cannot grow memory");
+    }
+    if !probe_wasm_memory(memory_size) {
+        // replica signals that there is not enough memory
+        rts_trap_with("Cannot grow memory");
+    }
+}
+
+/// Try to allocate an amount of Wasm memory by growing the Wasm memory space if needed.
+/// Returns true if the memory has been allocated and is available.
+/// Otherwise, it returns false if there does not exist enough Wasm memory.
+pub(crate) unsafe fn probe_wasm_memory(memory_size: Bytes<usize>) -> bool {
+    let page_size = WASM_PAGE_SIZE.as_usize();
+    let total_pages_needed = (memory_size.as_usize() + page_size - 1) / page_size;
+    let current_pages = wasm64::memory_size(0);
+    if total_pages_needed > current_pages {
+        wasm64::memory_grow(0, total_pages_needed - current_pages) != core::usize::MAX
+    } else {
+        true
+    }
+}
diff --git a/rts/motoko-rts/src/memory/ic/linear_memory.rs b/rts/motoko-rts/src/memory/ic/linear_memory.rs
new file mode 100644
index 00000000000..6009546f4f6
--- /dev/null
+++ b/rts/motoko-rts/src/memory/ic/linear_memory.rs
@@ -0,0 +1,80 @@
+use super::{get_aligned_heap_base, IcMemory, Memory};
+use crate::{memory::GENERAL_MEMORY_RESERVE, types::*};
+
+/// Amount of garbage collected so far.
+pub(crate) static mut RECLAIMED: Bytes<u64> = Bytes(0);
+
+/// Maximum live data retained in a GC.
+pub(crate) static mut MAX_LIVE: Bytes<usize> = Bytes(0);
+
+// Heap pointer (skewed)
+extern "C" {
+    fn setHP(new_hp: usize);
+    fn getHP() -> usize;
+}
+
+pub(crate) unsafe fn set_hp_unskewed(new_hp: usize) {
+    setHP(skew(new_hp))
+}
+pub(crate) unsafe fn get_hp_unskewed() -> usize {
+    unskew(getHP())
+}
+
+/// Heap pointer after last GC
+pub(crate) static mut LAST_HP: usize = 0;
+
+pub(crate) unsafe fn initialize() {
+    LAST_HP = get_aligned_heap_base();
+    set_hp_unskewed(LAST_HP);
+}
+
+#[no_mangle]
+unsafe extern "C" fn get_reclaimed() -> Bytes<u64> {
+    RECLAIMED
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn get_total_allocations() -> Bytes<u64> {
+    Bytes(get_heap_size().as_usize() as u64) + get_reclaimed()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn get_heap_size() -> Bytes<usize> {
+    Bytes(get_hp_unskewed() - get_aligned_heap_base())
+}
+
+#[no_mangle]
+unsafe extern "C" fn get_max_live_size() -> Bytes<usize> {
+    MAX_LIVE
+}
+
+impl Memory for IcMemory {
+    #[inline]
+    unsafe fn alloc_words(&mut self, n: Words<usize>) -> Value {
+        let bytes = n.to_bytes();
+        let delta = bytes.as_usize() as u64;
+
+        // Update heap pointer
+        let old_hp = getHP() as u64;
+        let new_hp = old_hp + delta;
+
+        // Grow memory if needed
+        if new_hp > ((super::wasm_memory_size() as u64) << 16) {
+            linear_grow_memory(new_hp);
+        }
+
+        debug_assert!(new_hp <= core::usize::MAX as u64);
+        setHP(new_hp as usize);
+
+        Value::from_raw(old_hp as usize)
+    }
+
+    #[inline(never)]
+    unsafe fn grow_memory(&mut self, ptr: usize) {
+        linear_grow_memory(ptr as u64);
+    }
+}
+
+unsafe fn linear_grow_memory(ptr: u64) {
+    super::grow_memory(ptr as u64, GENERAL_MEMORY_RESERVE);
+}
diff --git a/rts/motoko-rts/src/memory/ic/partitioned_memory.rs b/rts/motoko-rts/src/memory/ic/partitioned_memory.rs
new file mode 100644
index 00000000000..7da5edaac66
--- /dev/null
+++ b/rts/motoko-rts/src/memory/ic/partitioned_memory.rs
@@ -0,0 +1,35 @@
+use super::{IcMemory, Memory};
+use crate::types::*;
+
+#[no_mangle]
+unsafe extern "C" fn get_reclaimed() -> Bytes<u64> {
+    crate::gc::incremental::get_partitioned_heap().reclaimed_size()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn get_total_allocations() -> Bytes<u64> {
+    crate::gc::incremental::get_partitioned_heap().total_allocated_size()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn get_max_live_size() -> Bytes<usize> {
+    crate::gc::incremental::get_max_live_size()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn get_heap_size() -> Bytes<usize> {
+    crate::gc::incremental::get_partitioned_heap().occupied_size()
+}
+
+impl Memory for IcMemory {
+    #[inline]
+    unsafe fn alloc_words(&mut self, n: Words<usize>) -> Value {
+        crate::gc::incremental::get_partitioned_heap().allocate(self, n)
+    }
+
+    #[inline(never)]
+    unsafe fn grow_memory(&mut self, ptr: usize) {
+        let memory_reserve = crate::gc::incremental::memory_reserve();
+        super::grow_memory(ptr as u64, memory_reserve);
+    }
+}
diff --git a/rts/motoko-rts/src/persistence.rs b/rts/motoko-rts/src/persistence.rs
index f51cf6da1fe..3f6f0e9735e 100644
--- a/rts/motoko-rts/src/persistence.rs
+++ b/rts/motoko-rts/src/persistence.rs
@@ -9,23 +9,24 @@ use motoko_rts_macros::ic_mem_fn;
 use crate::{
     barriers::write_with_barrier,
     constants::{KB, MB},
-    gc::incremental::State,
+    gc::incremental::{partitioned_heap::allocate_initial_memory, State},
     memory::Memory,
     persistence::compatibility::memory_compatible,
     region::{
         LEGACY_VERSION_NO_STABLE_MEMORY, LEGACY_VERSION_REGIONS, LEGACY_VERSION_SOME_STABLE_MEMORY,
-        VERSION_STABLE_HEAP_NO_REGIONS, VERSION_STABLE_HEAP_REGIONS,
+        VERSION_GRAPH_COPY_NO_REGIONS, VERSION_GRAPH_COPY_REGIONS, VERSION_STABLE_HEAP_NO_REGIONS,
+        VERSION_STABLE_HEAP_REGIONS,
     },
     rts_trap_with,
     stable_mem::read_persistence_version,
-    types::{Value, TAG_BLOB_B},
+    types::{Bytes, Value, TAG_BLOB_B},
 };
 
 use self::compatibility::TypeDescriptor;
 
 const FINGERPRINT: [char; 32] = [
     'M', 'O', 'T', 'O', 'K', 'O', ' ', 'O', 'R', 'T', 'H', 'O', 'G', 'O', 'N', 'A', 'L', ' ', 'P',
-    'E', 'R', 'S', 'I', 'S', 'T', 'E', 'N', 'C', 'E', ' ', '3', '2',
+    'E', 'R', 'S', 'I', 'S', 'T', 'E', 'N', 'C', 'E', ' ', '6', '4',
 ];
 const VERSION: usize = 1;
 /// The `Value` representation in the default-initialized Wasm memory.
@@ -90,34 +91,36 @@ impl PersistentMetadata {
         }
     }
 
-    unsafe fn initialize<M: Memory>(self: *mut Self, mem: &mut M) {
+    unsafe fn initialize<M: Memory>(self: *mut Self) {
         use crate::gc::incremental::IncrementalGC;
-        debug_assert!(!self.is_initialized());
         (*self).fingerprint = FINGERPRINT;
         (*self).version = VERSION;
         (*self).stable_actor = DEFAULT_VALUE;
         (*self).stable_type = TypeDescriptor::default();
-        (*self).incremental_gc_state = IncrementalGC::initial_gc_state(mem, HEAP_START);
+        (*self).incremental_gc_state = IncrementalGC::<M>::initial_gc_state(HEAP_START);
         (*self).upgrade_instructions = 0;
     }
 }
 
-/// Initialize fresh persistent memory after the canister installation or
-/// reuse the persistent memory on a canister upgrade.
-pub unsafe fn initialize_memory<M: Memory>(mem: &mut M) {
-    mem.grow_memory(HEAP_START as u64);
+/// Initialize fresh persistent memory after the canister installation or reuse
+/// the persistent memory on a canister upgrade if enhanced orthogonal persistence
+/// is active. For graph-copy-based destabilization, the memory is reinitialized.
+pub unsafe fn initialize_memory<M: Memory>() {
+    allocate_initial_memory(Bytes(HEAP_START));
     let metadata = PersistentMetadata::get();
     if use_enhanced_orthogonal_persistence() && metadata.is_initialized() {
         metadata.check_version();
     } else {
-        metadata.initialize(mem);
+        metadata.initialize::<M>();
     }
 }
 
 unsafe fn use_enhanced_orthogonal_persistence() -> bool {
     match read_persistence_version() {
         VERSION_STABLE_HEAP_NO_REGIONS | VERSION_STABLE_HEAP_REGIONS => true,
-        LEGACY_VERSION_NO_STABLE_MEMORY
+        VERSION_GRAPH_COPY_NO_REGIONS
+        | VERSION_GRAPH_COPY_REGIONS
+        | LEGACY_VERSION_NO_STABLE_MEMORY
         | LEGACY_VERSION_SOME_STABLE_MEMORY
         | LEGACY_VERSION_REGIONS => false,
         _ => rts_trap_with("Unsupported persistence version"),
@@ -162,16 +165,16 @@ pub(crate) unsafe fn stable_actor_location() -> *mut Value {
 /// Determine whether an object contains a specific field.
 /// Used for upgrading to an actor with additional stable fields.
 #[no_mangle]
-pub unsafe extern "C" fn contains_field(actor: Value, field_hash: u32) -> bool {
+pub unsafe extern "C" fn contains_field(actor: Value, field_hash: usize) -> bool {
     use crate::constants::WORD_SIZE;
 
     let object = actor.as_object();
     let hash_blob = (*object).hash_blob.as_blob();
-    assert_eq!(hash_blob.len().as_u32() % WORD_SIZE, 0);
-    let number_of_fields = hash_blob.len().as_u32() / WORD_SIZE;
-    let mut current_address = hash_blob.payload_const() as u32;
+    assert_eq!(hash_blob.len().as_usize() % WORD_SIZE, 0);
+    let number_of_fields = hash_blob.len().as_usize() / WORD_SIZE;
+    let mut current_address = hash_blob.payload_const() as usize;
     for _ in 0..number_of_fields {
-        let hash_address = current_address as *mut u32;
+        let hash_address = current_address as *mut usize;
         let hash_value = *hash_address;
         // The hash sequence is sorted: Stop when the hash matches or cannot exist.
         if hash_value >= field_hash {
@@ -182,7 +185,7 @@ pub unsafe extern "C" fn contains_field(actor: Value, field_hash: u32) -> bool {
     false
 }
 
-/// Register the stable actor type on canister installation and upgrade.
+/// Register the stable actor type on canister initialization and upgrade.
 /// The type is stored in the persistent metadata memory for later retrieval on canister upgrades.
 /// On an upgrade, the memory compatibility between the new and existing stable type is checked.
 /// The `new_type` value points to a blob encoding the new stable actor type.
@@ -224,3 +227,14 @@ pub unsafe extern "C" fn set_upgrade_instructions(instructions: u64) {
     let metadata = PersistentMetadata::get();
     (*metadata).upgrade_instructions = instructions;
 }
+
+/// Only used in WASI mode: Get a static temporary print buffer that resides in 32-bit address range.
+/// This buffer has a fix length of 512 bytes, and resides at the end of the metadata reserve.
+#[no_mangle]
+pub unsafe extern "C" fn buffer_in_32_bit_range() -> usize {
+    use crate::types::size_of;
+
+    const BUFFER_SIZE: usize = 512;
+    assert!(size_of::<PersistentMetadata>().to_bytes().as_usize() + BUFFER_SIZE < METADATA_RESERVE);
+    METADATA_ADDRESS + METADATA_RESERVE - BUFFER_SIZE
+}
diff --git a/rts/motoko-rts/src/persistence/compatibility.rs b/rts/motoko-rts/src/persistence/compatibility.rs
index ce61aadc1fb..e144a9ff04a 100644
--- a/rts/motoko-rts/src/persistence/compatibility.rs
+++ b/rts/motoko-rts/src/persistence/compatibility.rs
@@ -26,7 +26,7 @@ const DEFAULT_VALUE: Value = Value::from_scalar(0);
 pub struct TypeDescriptor {
     // Blob with candid-encoded type definitions.
     candid_data: Value,
-    // Blob with a list of `u32` offsets referring to the `candid_data`.
+    // Blob with a list of `usize` offsets referring to the `candid_data`.
     type_offsets: Value,
 }
 
@@ -38,10 +38,12 @@ impl TypeDescriptor {
         }
     }
 
-    pub unsafe fn new(candid_data: Value, type_offsets: Value) -> Self {
-        Self {
-            candid_data: candid_data.forward_if_possible(),
-            type_offsets: type_offsets.forward_if_possible(),
+    pub fn new(candid_data: Value, type_offsets: Value) -> Self {
+        unsafe {
+            Self {
+                candid_data: candid_data.forward_if_possible(),
+                type_offsets: type_offsets.forward_if_possible(),
+            }
         }
     }
 
@@ -53,6 +55,14 @@ impl TypeDescriptor {
         assert!(self.candid_data != DEFAULT_VALUE && self.type_offsets != DEFAULT_VALUE);
     }
 
+    pub fn candid_data(&self) -> Value {
+        self.candid_data
+    }
+
+    pub fn type_offsets(&self) -> Value {
+        self.type_offsets
+    }
+
     // GC root if part of the persistent stable type
     pub fn candid_data_location(&mut self) -> *mut Value {
         &mut self.candid_data as *mut Value
@@ -72,7 +82,7 @@ impl TypeDescriptor {
 
     pub unsafe fn type_count(&self) -> usize {
         let blob_size = self.type_offsets.as_blob().len();
-        assert_eq!(blob_size.as_u32() % WORD_SIZE, 0);
+        assert_eq!(blob_size.as_usize() % WORD_SIZE, 0);
         blob_size.to_words().as_usize()
     }
 
@@ -80,15 +90,15 @@ impl TypeDescriptor {
     // be used during a single IC message when no GC increment is running in between.
     pub unsafe fn build_type_table<M: Memory>(&mut self, mem: &mut M) -> *mut *mut u8 {
         let type_count = self.type_count();
-        let temporary_blob = alloc_blob(mem, TAG_BLOB_B, Words(type_count as u32).to_bytes());
-        let offset_table = self.type_offsets.as_blob().payload_const() as *const u32;
+        let temporary_blob = alloc_blob(mem, TAG_BLOB_B, Words(type_count).to_bytes());
+        let offset_table = self.type_offsets.as_blob().payload_const() as *const usize;
         let type_table = temporary_blob.as_blob_mut().payload_addr() as *mut *mut u8;
         let candid_data = self.candid_data.as_blob_mut().payload_addr();
         for index in 0..type_count {
             let offset = *offset_table.add(index);
-            debug_assert!((offset as usize) < self.candid_length());
+            debug_assert!(offset < self.candid_length());
             let entry = type_table.add(index);
-            *entry = candid_data.add(offset as usize);
+            *entry = candid_data.add(offset);
         }
         type_table
     }
@@ -110,16 +120,16 @@ unsafe fn create_type_check_cache<M: Memory>(
     old_type: &TypeDescriptor,
     new_type: &TypeDescriptor,
 ) -> BitRel {
-    let old_type_count = old_type.type_count() as u32;
-    let new_type_count = new_type.type_count() as u32;
+    let old_type_count = old_type.type_count();
+    let new_type_count = new_type.type_count();
     let words = Words(BitRel::words(old_type_count, new_type_count));
     let byte_length = words.to_bytes();
     let blob_value = alloc_blob(mem, TAG_BLOB_B, byte_length);
-    let ptr = blob_value.as_blob_mut().payload_addr() as *mut u32;
+    let ptr = blob_value.as_blob_mut().payload_addr() as *mut usize;
     let end = blob_value
         .as_blob()
         .payload_const()
-        .add(byte_length.as_usize()) as *mut u32;
+        .add(byte_length.as_usize()) as *mut usize;
     let cache = BitRel {
         ptr,
         end,
diff --git a/rts/motoko-rts/src/principal_id.rs b/rts/motoko-rts/src/principal_id.rs
index c24be6009eb..1be577a9ca2 100644
--- a/rts/motoko-rts/src/principal_id.rs
+++ b/rts/motoko-rts/src/principal_id.rs
@@ -22,7 +22,7 @@ pub unsafe extern "C" fn compute_crc32(blob: Value) -> u32 {
 
     let mut crc: u32 = !0;
 
-    for i in 0..len.as_u32() {
+    for i in 0..len.as_usize() {
         let octet = blob.get(i);
         crc = (crc >> 8) ^ CRC_TABLE[usize::from((crc & 0xFF) as u8 ^ octet)];
     }
@@ -98,7 +98,7 @@ pub unsafe fn base32_of_checksummed_blob<M: Memory>(mem: &mut M, b: Value) -> Va
     let n = b.as_blob().len();
     let mut data = b.as_blob().payload_const();
 
-    let r = alloc_blob(mem, TAG_BLOB_T, Bytes((n.as_u32() + 4 + 4) / 5 * 8)); // contains padding
+    let r = alloc_blob(mem, TAG_BLOB_T, Bytes((n.as_usize() + 4 + 4) / 5 * 8)); // contains padding
     let blob = r.as_blob_mut();
     let dest = blob.payload_addr();
 
@@ -114,7 +114,7 @@ pub unsafe fn base32_of_checksummed_blob<M: Memory>(mem: &mut M, b: Value) -> Va
     enc_stash(&mut pump, (checksum >> 8) as u8);
     enc_stash(&mut pump, checksum as u8);
 
-    for _ in 0..n.as_u32() {
+    for _ in 0..n.as_usize() {
         enc_stash(&mut pump, *data);
         data = data.add(1);
     }
@@ -125,7 +125,7 @@ pub unsafe fn base32_of_checksummed_blob<M: Memory>(mem: &mut M, b: Value) -> Va
         stash_enc_base32(pump.pending_data as u8, pump.dest);
         pump.dest = pump.dest.add(1);
         // Discount padding
-        let new_len = Bytes(pump.dest.offset_from(dest) as u32);
+        let new_len = Bytes(pump.dest.offset_from(dest) as usize);
         blob.shrink(new_len);
     }
 
@@ -185,7 +185,7 @@ pub unsafe fn base32_to_blob<M: Memory>(mem: &mut M, b: Value) -> Value {
     let mut data = b.as_blob().payload_const();
 
     // Every group of 8 characters will yield 5 bytes
-    let r = alloc_blob(mem, TAG_BLOB_B, Bytes(((n.as_u32() + 7) / 8) * 5)); // we deal with padding later
+    let r = alloc_blob(mem, TAG_BLOB_B, Bytes(((n.as_usize() + 7) / 8) * 5)); // we deal with padding later
     let blob = r.as_blob_mut();
     let dest = blob.payload_addr();
 
@@ -197,13 +197,13 @@ pub unsafe fn base32_to_blob<M: Memory>(mem: &mut M, b: Value) -> Value {
         pending_data: 0,
     };
 
-    for _ in 0..n.as_u32() {
+    for _ in 0..n.as_usize() {
         dec_stash(&mut pump, *data);
         data = data.add(1);
     }
 
     // Adjust resulting blob len
-    let new_len = Bytes(pump.dest.offset_from(dest) as u32);
+    let new_len = Bytes(pump.dest.offset_from(dest) as usize);
     blob.shrink(new_len);
 
     allocation_barrier(r)
@@ -225,12 +225,12 @@ unsafe fn base32_to_principal<M: Memory>(mem: &mut M, b: Value) -> Value {
     let mut data = blob.payload_const();
 
     // Every group of 5 characters will yield 6 bytes (due to the hypen)
-    let r = alloc_blob(mem, TAG_BLOB_T, Bytes(((n.as_u32() + 4) / 5) * 6));
+    let r = alloc_blob(mem, TAG_BLOB_T, Bytes(((n.as_usize() + 4) / 5) * 6));
     let blob = r.as_blob_mut();
     let mut dest = blob.payload_addr();
 
     let mut n_written = 0;
-    for i in 0..n.as_u32() {
+    for i in 0..n.as_usize() {
         let mut byte = *data;
         data = data.add(1);
 
@@ -244,7 +244,7 @@ unsafe fn base32_to_principal<M: Memory>(mem: &mut M, b: Value) -> Value {
         n_written += 1;
 
         // If quintet done, add hyphen
-        if n_written % 5 == 0 && i + 1 < n.as_u32() {
+        if n_written % 5 == 0 && i + 1 < n.as_usize() {
             n_written = 0;
             *dest = b'-';
             dest = dest.add(1);
@@ -252,7 +252,7 @@ unsafe fn base32_to_principal<M: Memory>(mem: &mut M, b: Value) -> Value {
     }
 
     // Adjust result length
-    let new_len = Bytes(dest as u32 - blob.payload_addr() as u32);
+    let new_len = Bytes(dest as usize - blob.payload_addr() as usize);
     blob.shrink(new_len);
     allocation_barrier(r)
 }
@@ -286,7 +286,7 @@ pub unsafe fn blob_of_principal<M: Memory>(mem: &mut M, t: Value) -> Value {
 }
 
 // for testing
-pub unsafe fn blob_of_ptr_size<M: Memory>(mem: &mut M, buf: *const u8, n: Bytes<u32>) -> Value {
+pub unsafe fn blob_of_ptr_size<M: Memory>(mem: &mut M, buf: *const u8, n: Bytes<usize>) -> Value {
     let blob = alloc_blob(mem, TAG_BLOB_B, n);
     let payload_addr = blob.as_blob_mut().payload_addr();
     memcpy_bytes(payload_addr as usize, buf as usize, n);
@@ -294,5 +294,5 @@ pub unsafe fn blob_of_ptr_size<M: Memory>(mem: &mut M, buf: *const u8, n: Bytes<
 }
 
 pub unsafe fn blob_of_str<M: Memory>(mem: &mut M, s: &str) -> Value {
-    blob_of_ptr_size(mem, s.as_ptr(), Bytes(s.len() as u32))
+    blob_of_ptr_size(mem, s.as_ptr(), Bytes(s.len()))
 }
diff --git a/rts/motoko-rts/src/print.rs b/rts/motoko-rts/src/print.rs
index 11ee84be33e..6832ab70d3b 100644
--- a/rts/motoko-rts/src/print.rs
+++ b/rts/motoko-rts/src/print.rs
@@ -8,7 +8,7 @@ use core::fmt;
 extern "C" {
     // `print_ptr` is implemented by the code generator and has different implementations depending
     // on the target platform (WASI or IC).
-    fn print_ptr(ptr: usize, len: u32);
+    fn print_ptr(ptr: usize, len: usize);
 }
 
 /*
@@ -61,13 +61,13 @@ macro_rules! format {
 
 /// A buffer that implements `core::fmt::Write`. `Write` methods will write to the buffer until
 /// it's filled and then ignore the rest, without failing.
-pub(crate) struct WriteBuf<'a> {
+pub struct WriteBuf<'a> {
     buf: &'a mut [u8],
     offset: usize,
 }
 
 impl<'a> WriteBuf<'a> {
-    pub(crate) fn new(buf: &'a mut [u8]) -> Self {
+    pub fn new(buf: &'a mut [u8]) -> Self {
         Self { buf, offset: 0 }
     }
 
@@ -76,7 +76,7 @@ impl<'a> WriteBuf<'a> {
     }
 
     pub(crate) unsafe fn print(&self) {
-        print_ptr(self.buf.as_ptr() as usize, self.offset as u32)
+        print_ptr(self.buf.as_ptr() as usize, self.offset)
     }
 }
 
@@ -96,10 +96,10 @@ impl<'a> fmt::Write for WriteBuf<'a> {
     }
 }
 
-pub(crate) unsafe fn print(buf: &WriteBuf) {
+pub unsafe fn print(buf: &WriteBuf) {
     buf.print()
 }
 
-// pub(crate) unsafe fn print_str(str: &str) {
-//     print_ptr(str.as_ptr() as usize, str.len() as u32)
-// }
+pub(crate) unsafe fn print_str(str: &str) {
+    print_ptr(str.as_ptr() as usize, str.len())
+}
diff --git a/rts/motoko-rts/src/region.rs b/rts/motoko-rts/src/region.rs
index 0df31a02629..6ec109d3aa4 100644
--- a/rts/motoko-rts/src/region.rs
+++ b/rts/motoko-rts/src/region.rs
@@ -5,18 +5,27 @@ use crate::types::{size_of, Blob, Bytes, Region, Value, TAG_BLOB_B, TAG_REGION};
 
 // Versions
 // Should agree with constants in StableMem in compile.ml
-// Version 0 to 2 are legacy.
-pub const LEGACY_VERSION_NO_STABLE_MEMORY: u32 = 0; // Never manifests in serialized form
-pub const LEGACY_VERSION_SOME_STABLE_MEMORY: u32 = 1;
-pub const LEGACY_VERSION_REGIONS: u32 = 2;
-pub const VERSION_STABLE_HEAP_NO_REGIONS: u32 = 3;
-pub const VERSION_STABLE_HEAP_REGIONS: u32 = 4;
 
+// Legacy versions, used with classical persistence
+pub const LEGACY_VERSION_NO_STABLE_MEMORY: usize = 0; // Never manifests in serialized form
+pub const LEGACY_VERSION_SOME_STABLE_MEMORY: usize = 1;
+pub const LEGACY_VERSION_REGIONS: usize = 2;
+
+// New versions, used with enhanced orthogonal persistence
+pub(crate) const VERSION_GRAPH_COPY_NO_REGIONS: usize = 3;
+pub(crate) const VERSION_GRAPH_COPY_REGIONS: usize = 4;
+pub(crate) const VERSION_STABLE_HEAP_NO_REGIONS: usize = 5;
+pub(crate) const VERSION_STABLE_HEAP_REGIONS: usize = 6;
+
+const _: () = assert!(meta_data::size::PAGE_IN_BYTES == crate::stable_mem::PAGE_SIZE);
 const _: () = assert!(meta_data::size::PAGES_IN_BLOCK <= u8::MAX as u32);
 const _: () = assert!(meta_data::max::BLOCKS <= u16::MAX);
 const _: () = assert!(meta_data::max::REGIONS <= u64::MAX - 1);
 
-use motoko_rts_macros::ic_mem_fn;
+use motoko_rts_macros::{
+    classical_persistence, enhanced_orthogonal_persistence, ic_mem_fn,
+    uses_enhanced_orthogonal_persistence,
+};
 
 unsafe fn region_trap_with(msg: &str) -> ! {
     trap_with_prefix("Region error: ", msg)
@@ -128,13 +137,13 @@ impl AccessVector {
     }
 
     pub unsafe fn set_ith_block_id(&self, i: u32, block_id: &BlockId) {
-        debug_assert!(i * 2 + 1 < self.0.len().as_u32());
-        self.0.set_u16(i, block_id.0)
+        debug_assert!((i as usize) * 2 + 1 < self.0.len().as_usize());
+        self.0.set_u16(i as usize, block_id.0)
     }
 
     pub unsafe fn get_ith_block_id(&self, i: u32) -> BlockId {
-        debug_assert!(i * 2 + 1 < self.0.len().as_u32());
-        BlockId(self.0.get_u16(i))
+        debug_assert!((i as usize) * 2 + 1 < self.0.len().as_usize());
+        BlockId(self.0.get_u16(i as usize))
     }
 }
 
@@ -379,7 +388,7 @@ unsafe fn write_magic() {
 unsafe fn alloc_region<M: Memory>(
     mem: &mut M,
     id: u64,
-    page_count: u32,
+    page_count: usize,
     vec_pages: Value,
 ) -> Value {
     let r_ptr = mem.alloc_words(size_of::<Region>());
@@ -391,8 +400,8 @@ unsafe fn alloc_region<M: Memory>(
     region.write_id64(id);
     debug_assert!(
         page_count
-            <= (vec_pages.as_blob().len().as_u32() / meta_data::bytes_of::<u16>() as u32)
-                * meta_data::size::PAGES_IN_BLOCK
+            <= (vec_pages.as_blob().len().as_usize() / meta_data::bytes_of::<u16>() as usize)
+                * meta_data::size::PAGES_IN_BLOCK as usize
     );
     (*region).page_count = page_count;
     init_with_barrier(mem, &mut (*region).vec_pages, vec_pages);
@@ -406,7 +415,7 @@ unsafe fn init_region<M: Memory>(
     mem: &mut M,
     r: Value,
     id: u64,
-    page_count: u32,
+    page_count: usize,
     vec_pages: Value,
 ) {
     let r = r.as_region();
@@ -414,8 +423,8 @@ unsafe fn init_region<M: Memory>(
     r.write_id64(id);
     debug_assert!(
         page_count
-            <= (vec_pages.as_blob().len().as_u32() / meta_data::bytes_of::<u16>() as u32)
-                * meta_data::size::PAGES_IN_BLOCK
+            <= (vec_pages.as_blob().len().as_usize() / meta_data::bytes_of::<u16>() as usize)
+                * meta_data::size::PAGES_IN_BLOCK as usize
     );
     (*r).page_count = page_count;
     write_with_barrier(mem, &mut (*r).vec_pages, vec_pages);
@@ -428,7 +437,7 @@ pub unsafe fn region_id<M: Memory>(_mem: &mut M, r: Value) -> u64 {
 }
 
 #[ic_mem_fn]
-pub unsafe fn region_page_count<M: Memory>(_mem: &mut M, r: Value) -> u32 {
+pub unsafe fn region_page_count<M: Memory>(_mem: &mut M, r: Value) -> usize {
     let r = r.as_untagged_region();
     (*r).page_count
 }
@@ -472,21 +481,43 @@ pub(crate) unsafe fn region0_get_ptr_loc() -> *mut Value {
     &mut REGION_0
 }
 
-#[ic_mem_fn]
-pub unsafe fn region_new<M: Memory>(mem: &mut M) -> Value {
+#[classical_persistence]
+unsafe fn migrate_on_new_region<M: Memory>(mem: &mut M) {
+    match crate::stable_mem::get_version() {
+        LEGACY_VERSION_NO_STABLE_MEMORY => {
+            assert_eq!(crate::stable_mem::size(), 0);
+            region_migration_from_no_stable_memory(mem);
+        }
+        LEGACY_VERSION_SOME_STABLE_MEMORY => {
+            region_migration_from_some_stable_memory(mem);
+        }
+        LEGACY_VERSION_REGIONS => {}
+        _ => {
+            assert!(false);
+        }
+    }
+}
+
+#[enhanced_orthogonal_persistence]
+unsafe fn migrate_on_new_region<M: Memory>(mem: &mut M) {
     match crate::stable_mem::get_version() {
-        VERSION_STABLE_HEAP_REGIONS => {}
-        VERSION_STABLE_HEAP_NO_REGIONS => {
+        VERSION_STABLE_HEAP_NO_REGIONS | VERSION_GRAPH_COPY_NO_REGIONS => {
             if crate::stable_mem::size() == 0 {
                 region_migration_from_no_stable_memory(mem);
             } else {
                 region_migration_from_some_stable_memory(mem);
             }
         }
+        VERSION_STABLE_HEAP_REGIONS | VERSION_GRAPH_COPY_REGIONS => {}
         _ => {
             assert!(false);
         }
-    };
+    }
+}
+
+#[ic_mem_fn]
+pub unsafe fn region_new<M: Memory>(mem: &mut M) -> Value {
+    migrate_on_new_region(mem);
 
     let next_id = meta_data::total_allocated_regions::get();
 
@@ -533,7 +564,7 @@ pub unsafe fn region_recover<M: Memory>(mem: &mut M, rid: &RegionId) -> Value {
     let vec_pages = alloc_blob(
         mem,
         TAG_BLOB_B,
-        Bytes(block_count * bytes_of::<u16>() as u32),
+        Bytes(block_count as usize * bytes_of::<u16>() as usize),
     );
 
     let av = AccessVector(vec_pages.as_blob_mut());
@@ -554,15 +585,36 @@ pub unsafe fn region_recover<M: Memory>(mem: &mut M, rid: &RegionId) -> Value {
     assert_eq!(recovered_blocks, block_count);
     allocation_barrier(vec_pages);
 
-    let r_ptr = alloc_region(mem, rid.0, page_count as u32, vec_pages);
+    let r_ptr = alloc_region(mem, rid.0, page_count as usize, vec_pages);
     r_ptr
 }
 
+fn upgrade_version_to_regions() {
+    let new_version = if uses_enhanced_orthogonal_persistence!() {
+        match crate::stable_mem::get_version() {
+            VERSION_STABLE_HEAP_NO_REGIONS => VERSION_STABLE_HEAP_REGIONS,
+            VERSION_GRAPH_COPY_NO_REGIONS => VERSION_GRAPH_COPY_REGIONS,
+            _ => unreachable!(),
+        }
+    } else {
+        LEGACY_VERSION_REGIONS
+    };
+    crate::stable_mem::set_version(new_version);
+}
+
 pub(crate) unsafe fn region_migration_from_no_stable_memory<M: Memory>(mem: &mut M) {
     use crate::stable_mem::{get_version, grow, size, write};
     use meta_data::size::{PAGES_IN_BLOCK, PAGE_IN_BYTES};
 
-    assert!(get_version() == VERSION_STABLE_HEAP_NO_REGIONS);
+    if uses_enhanced_orthogonal_persistence!() {
+        assert!(
+            get_version() == VERSION_STABLE_HEAP_NO_REGIONS
+                || get_version() == VERSION_GRAPH_COPY_NO_REGIONS
+        );
+    } else {
+        assert!(get_version() == LEGACY_VERSION_NO_STABLE_MEMORY);
+    }
+
     assert_eq!(size(), 0);
 
     // pages required for meta_data (9/ 960KiB), much less than PAGES_IN_BLOCK (128/ 8MB) for a full block
@@ -592,7 +644,7 @@ pub(crate) unsafe fn region_migration_from_no_stable_memory<M: Memory>(mem: &mut
     // Write magic header
     write_magic();
 
-    crate::stable_mem::set_version(VERSION_STABLE_HEAP_REGIONS);
+    upgrade_version_to_regions();
 
     // Region 0 -- classic API for stable memory, as a dedicated region.
     REGION_0 = region_new(mem);
@@ -669,7 +721,8 @@ pub(crate) unsafe fn region_migration_from_some_stable_memory<M: Memory>(mem: &m
     // Temp for the head block, which we move to be physically last.
     // NB: no allocation_barrier is required: header_val is temporary and can be reclaimed by the next GC increment/run.
     // TODO: instead of allocating an 8MB blob, just stack-allocate a tmp page and zero page, and transfer/zero-init via the stack, using a loop.
-    let header_val = crate::memory::alloc_blob(mem, TAG_BLOB_B, crate::types::Bytes(header_len));
+    let header_val =
+        crate::memory::alloc_blob(mem, TAG_BLOB_B, crate::types::Bytes(header_len as usize));
     let header_blob = header_val.as_blob_mut();
     let header_bytes =
         core::slice::from_raw_parts_mut(header_blob.payload_addr(), header_len as usize);
@@ -681,7 +734,10 @@ pub(crate) unsafe fn region_migration_from_some_stable_memory<M: Memory>(mem: &m
         header_bytes,
     );
 
-    crate::mem_utils::memzero_bytes((header_blob.payload_addr()) as usize, Bytes(header_len));
+    crate::mem_utils::memzero_bytes(
+        (header_blob.payload_addr()) as usize,
+        Bytes(header_len as usize),
+    );
 
     write(0, header_bytes); // Zero out first block, for region manager meta data.
 
@@ -716,7 +772,7 @@ pub(crate) unsafe fn region_migration_from_some_stable_memory<M: Memory>(mem: &m
         meta_data::block_region_table::set(BlockId(i), Some((RegionId(0), rank, page_count)))
     }
 
-    crate::stable_mem::set_version(VERSION_STABLE_HEAP_REGIONS);
+    upgrade_version_to_regions();
 
     /* "Recover" the region data into a heap object. */
     REGION_0 = region_recover(mem, &RegionId(0));
@@ -768,10 +824,42 @@ pub(crate) unsafe fn region_migration_from_regions_plus<M: Memory>(mem: &mut M)
 //
 // region manager migration/initialization, with pre-existing stable data.
 //
+#[classical_persistence]
+#[ic_mem_fn(ic_only)]
+pub(crate) unsafe fn region_init<M: Memory>(mem: &mut M, use_stable_regions: usize) {
+    match crate::stable_mem::get_version() {
+        LEGACY_VERSION_NO_STABLE_MEMORY => {
+            assert!(crate::stable_mem::size() == 0);
+            if use_stable_regions != 0 {
+                region_migration_from_no_stable_memory(mem);
+                debug_assert!(meta_data::offset::FREE < BLOCK_BASE);
+                debug_assert!(BLOCK_BASE == meta_data::offset::BASE_LOW);
+            };
+        }
+        LEGACY_VERSION_SOME_STABLE_MEMORY => {
+            assert!(crate::stable_mem::size() > 0);
+            if use_stable_regions != 0 {
+                region_migration_from_some_stable_memory(mem);
+                debug_assert!(meta_data::offset::FREE < BLOCK_BASE);
+                debug_assert!(BLOCK_BASE == meta_data::offset::BASE_HIGH);
+            };
+        }
+        _ => {
+            region_migration_from_regions_plus(mem); //check format & recover region0
+            debug_assert!(meta_data::offset::FREE < BLOCK_BASE);
+            debug_assert!(
+                BLOCK_BASE == meta_data::offset::BASE_LOW
+                    || BLOCK_BASE == meta_data::offset::BASE_HIGH
+            );
+        }
+    }
+}
+
+#[enhanced_orthogonal_persistence]
 #[ic_mem_fn(ic_only)]
-pub(crate) unsafe fn region_init<M: Memory>(mem: &mut M, use_stable_regions: u32) {
+pub(crate) unsafe fn region_init<M: Memory>(mem: &mut M, use_stable_regions: usize) {
     match crate::stable_mem::get_version() {
-        VERSION_STABLE_HEAP_NO_REGIONS => {
+        VERSION_STABLE_HEAP_NO_REGIONS | VERSION_GRAPH_COPY_NO_REGIONS => {
             if use_stable_regions != 0 {
                 if crate::stable_mem::size() == 0 {
                     region_migration_from_no_stable_memory(mem);
@@ -784,7 +872,7 @@ pub(crate) unsafe fn region_init<M: Memory>(mem: &mut M, use_stable_regions: u32
                 }
             }
         }
-        VERSION_STABLE_HEAP_REGIONS => {
+        VERSION_STABLE_HEAP_REGIONS | VERSION_GRAPH_COPY_REGIONS => {
             region_migration_from_regions_plus(mem); //check format & recover region0
             debug_assert!(meta_data::offset::FREE < BLOCK_BASE);
             debug_assert!(
@@ -799,7 +887,7 @@ pub(crate) unsafe fn region_init<M: Memory>(mem: &mut M, use_stable_regions: u32
 #[ic_mem_fn]
 pub unsafe fn region_size<M: Memory>(_mem: &mut M, r: Value) -> u64 {
     let r = r.as_region();
-    (*r).page_count.into()
+    (*r).page_count as u64
 }
 
 #[ic_mem_fn]
@@ -811,7 +899,7 @@ pub unsafe fn region_grow<M: Memory>(mem: &mut M, r: Value, new_pages: u64) -> u
     let r = r.as_region();
     let old_page_count = (*r).page_count;
 
-    if new_pages > (max_pages_in_region - old_page_count) as u64 {
+    if new_pages > (max_pages_in_region as usize - old_page_count) as u64 {
         return u64::MAX;
     }
 
@@ -819,8 +907,9 @@ pub unsafe fn region_grow<M: Memory>(mem: &mut M, r: Value, new_pages: u64) -> u
 
     let new_pages_ = new_pages as u32;
 
-    let old_block_count = (old_page_count + (PAGES_IN_BLOCK - 1)) / PAGES_IN_BLOCK;
-    let new_block_count = (old_page_count + new_pages_ + (PAGES_IN_BLOCK - 1)) / PAGES_IN_BLOCK;
+    let old_block_count = (old_page_count as u32 + (PAGES_IN_BLOCK - 1)) / PAGES_IN_BLOCK;
+    let new_block_count =
+        (old_page_count as u32 + new_pages_ + (PAGES_IN_BLOCK - 1)) / PAGES_IN_BLOCK;
     let inc_block_count = new_block_count - old_block_count;
 
     // Determine the required total number of allocated blocks,
@@ -848,14 +937,14 @@ pub unsafe fn region_grow<M: Memory>(mem: &mut M, r: Value, new_pages: u64) -> u
         let r_id = RegionId::from_id(r.read_id64());
 
         // Increase both:
-        (*r).page_count += new_pages_;
+        (*r).page_count += new_pages_ as usize;
         if old_block_count > 0 {
             let last_block_rank = (old_block_count - 1) as u16;
             let last_block_id =
                 AccessVector((*r).vec_pages.as_blob_mut()).get_ith_block_id(last_block_rank as u32);
-            debug_assert_eq!((*r).page_count, old_page_count + new_pages_);
+            debug_assert_eq!((*r).page_count, old_page_count + new_pages_ as usize);
             let last_page_count =
-                block_page_count(last_block_rank, new_block_count, (*r).page_count);
+                block_page_count(last_block_rank, new_block_count, (*r).page_count as u32);
             let assoc = Some((r_id, last_block_rank, last_page_count));
             meta_data::block_region_table::set(last_block_id, assoc);
         }
@@ -864,7 +953,7 @@ pub unsafe fn region_grow<M: Memory>(mem: &mut M, r: Value, new_pages: u64) -> u
     let new_vec_pages = alloc_blob(
         mem,
         TAG_BLOB_B,
-        Bytes(new_block_count * meta_data::bytes_of::<u16>() as u32),
+        Bytes(new_block_count as usize * meta_data::bytes_of::<u16>() as usize),
     );
     let old_vec_byte_count = old_block_count * meta_data::bytes_of::<u16>() as u32;
 
@@ -872,7 +961,7 @@ pub unsafe fn region_grow<M: Memory>(mem: &mut M, r: Value, new_pages: u64) -> u
     crate::mem_utils::memcpy_bytes(
         new_vec_pages.as_blob_mut().payload_addr() as usize,
         (*r).vec_pages.as_blob().payload_const() as usize,
-        Bytes(old_vec_byte_count),
+        Bytes(old_vec_byte_count as usize),
     );
 
     let new_pages = AccessVector::from_value(&new_vec_pages);
@@ -888,7 +977,7 @@ pub unsafe fn region_grow<M: Memory>(mem: &mut M, r: Value, new_pages: u64) -> u
         let block_id: u16 = (old_total_blocks + rel_i as u32) as u16;
 
         // Update stable memory with new association.
-        let block_page_count = block_page_count(i as u16, new_block_count, (*r).page_count);
+        let block_page_count = block_page_count(i as u16, new_block_count, (*r).page_count as u32);
         let assoc = Some((RegionId::from_id(r.read_id64()), i as u16, block_page_count));
         meta_data::block_region_table::set(BlockId(block_id), assoc);
 
@@ -897,7 +986,7 @@ pub unsafe fn region_grow<M: Memory>(mem: &mut M, r: Value, new_pages: u64) -> u
 
     allocation_barrier(new_vec_pages);
     write_with_barrier(mem, &mut (*r).vec_pages, new_vec_pages);
-    old_page_count.into()
+    old_page_count as u64
 }
 
 pub(crate) unsafe fn region_load<M: Memory>(_mem: &mut M, r: Value, offset: u64, dst: &mut [u8]) {
@@ -1049,16 +1138,16 @@ pub(crate) unsafe fn region_load_blob<M: Memory>(
     mem: &mut M,
     r: Value,
     offset: u64,
-    len: u32,
+    len: usize,
 ) -> Value {
-    let blob_val = crate::memory::alloc_blob(mem, TAG_BLOB_B, crate::types::Bytes(len));
+    let blob_val = crate::memory::alloc_blob(mem, TAG_BLOB_B, crate::types::Bytes(len as usize));
     let blob = blob_val.as_blob_mut();
 
-    if len < (isize::MAX as u32) {
+    if len < (isize::MAX as usize) {
         let bytes: &mut [u8] = core::slice::from_raw_parts_mut(blob.payload_addr(), len as usize);
         region_load(mem, r, offset, bytes);
     } else {
-        assert!((len / 2) < isize::MAX as u32);
+        assert!((len / 2) < isize::MAX as usize);
         let bytes_low: &mut [u8] =
             core::slice::from_raw_parts_mut(blob.payload_addr(), (len / 2) as usize);
         region_load(mem, r, offset, bytes_low);
@@ -1114,11 +1203,11 @@ pub(crate) unsafe fn region_store_blob<M: Memory>(mem: &mut M, r: Value, offset:
     let blob = blob.as_blob();
     let len = blob.len().0;
     let bytes = blob.payload_const();
-    if len < (isize::MAX as u32) {
+    if len < (isize::MAX as usize) {
         let bytes: &[u8] = core::slice::from_raw_parts(bytes, len as usize);
         region_store(mem, r, offset, bytes);
     } else {
-        assert!((len / 2) < isize::MAX as u32);
+        assert!((len / 2) < isize::MAX as usize);
         let bytes_low: &[u8] = core::slice::from_raw_parts(bytes, (len / 2) as usize);
         region_store(mem, r, offset, bytes_low);
         let bytes_high: &[u8] =
diff --git a/rts/motoko-rts/src/stabilization.rs b/rts/motoko-rts/src/stabilization.rs
new file mode 100644
index 00000000000..8840dd0e23d
--- /dev/null
+++ b/rts/motoko-rts/src/stabilization.rs
@@ -0,0 +1,88 @@
+//! Graph-copy-based stabilzation on upgrades, serializing the entire stable object graph into
+//! stable memory by using a defined long-term stable storage format.
+//!
+//! This is to support potentially radical changes of the persistent main memory layout, e.g.
+//! introducing a new GC or rearranging persistent metadata. This also relies on precise value
+//! tagging to allow more advanced changes that require value metadata, e.g. specializing arrays for
+//! small element types or even downgrading to 32-bit heap layouts (provided that the amount of live
+//! data fits into a 32-bit memory).
+//!
+//! A memory compatibility check similar to enhanced orthogonal persistence has to be performed.
+//! For this purpose, the type table of the serialized object graph is also stored in stable memory
+//! and on upgrade, compared to the new program version.
+//!
+//! A versioned stable storage format even permits future evolutions of the graph copy algorithm.
+//!  
+//! See `GraphCopyStabilization.md` for the stable format specification and the employed algorithm.
+
+pub mod deserialization;
+pub mod graph_copy;
+pub mod layout;
+pub mod serialization;
+
+#[cfg(feature = "ic")]
+pub mod ic;
+
+use core::cmp::min;
+
+use crate::{
+    constants::KB,
+    rts_trap_with,
+    stable_mem::{self, ic0_stable64_write, PAGE_SIZE},
+};
+
+use self::layout::StableValue;
+
+extern "C" {
+    pub fn moc_stabilization_instruction_limit() -> u64;
+    pub fn moc_stable_memory_access_limit() -> u64;
+    fn ic0_performance_counter(number: u32) -> u64;
+}
+
+// Dummy value used for non-stable objects that are potentially reachable from
+// stable variable because of structural subtyping or `Any`-subtyping.
+// Must be a non-skewed value such that the GC also ignores this value.
+const DUMMY_VALUE: StableValue = StableValue::from_raw(0);
+
+/// Note: This is called incrementally in smaller chunks by the destabilization
+/// as it may otherwise exceed the instruction limit.
+fn clear_stable_memory(start: u64, length: u64) {
+    // Optimal point for the two cost functions, according to experimental measurements:
+    // * Smaller chunks cause more stable API calls that incur costs.
+    // * Larger chunks cause higher chunk zero-initialization costs.
+    const CHUNK_SIZE: usize = KB;
+    let empty_chunk = [0u8; CHUNK_SIZE];
+    let mut position = start;
+    let end = start + length;
+    while position < end {
+        let size = min(end - position, CHUNK_SIZE as u64);
+        unsafe {
+            ic0_stable64_write(position, &empty_chunk as *const u8 as u64, size);
+        }
+        position += size;
+    }
+}
+
+fn grant_stable_space(byte_size: u64) {
+    debug_assert!(byte_size < u64::MAX - PAGE_SIZE - 1);
+    let required_pages = (byte_size + PAGE_SIZE - 1) / PAGE_SIZE;
+    let available_pages = stable_memory_physical_size();
+    if required_pages > available_pages {
+        let additional_pages = required_pages - available_pages;
+        debug_assert_ne!(additional_pages, u64::MAX);
+        let result = stable_memory_physical_grow(additional_pages);
+        if result == u64::MAX {
+            unsafe {
+                rts_trap_with("Insufficient stable memory");
+            }
+        }
+    }
+}
+
+fn stable_memory_physical_size() -> u64 {
+    unsafe { stable_mem::ic0_stable64_size() }
+}
+
+fn stable_memory_physical_grow(additional_pages: u64) -> u64 {
+    unsafe { stable_mem::ic0_stable64_grow(additional_pages) }
+}
diff --git a/rts/motoko-rts/src/stabilization/deserialization.rs b/rts/motoko-rts/src/stabilization/deserialization.rs
new file mode 100644
index 00000000000..7cd2d4501d0
--- /dev/null
+++ b/rts/motoko-rts/src/stabilization/deserialization.rs
@@ -0,0 +1,222 @@
+mod scan_stack;
+pub mod stable_memory_access;
+
+use crate::{
+    constants::MB,
+    gc::incremental::array_slicing::slice_array,
+    memory::Memory,
+    stabilization::deserialization::scan_stack::STACK_EMPTY,
+    types::{FwdPtr, Tag, Value, TAG_ARRAY_SLICE_MIN, TAG_FWD_PTR},
+    visitor::visit_pointer_fields,
+};
+
+use self::{scan_stack::ScanStack, stable_memory_access::StableMemoryAccess};
+
+use super::{
+    clear_stable_memory,
+    graph_copy::{limit::ExecutionMonitor, GraphCopy},
+    layout::{deserialize, StableValue},
+};
+
+pub struct Deserialization {
+    from_space: StableMemoryAccess,
+    scan_stack: ScanStack,
+    stable_start: u64,
+    stable_size: u64,
+    stable_root: Option<Value>,
+    limit: ExecutionMonitor,
+    clear_position: u64,
+}
+
+/// Helper type to pass serialization context instead of closures.
+pub struct DeserializationContext<'a, M: Memory> {
+    pub deserialization: &'a mut Deserialization,
+    pub mem: &'a mut M,
+}
+
+impl<'a, M: Memory> DeserializationContext<'a, M> {
+    fn new(
+        deserialization: &'a mut Deserialization,
+        mem: &'a mut M,
+    ) -> DeserializationContext<'a, M> {
+        DeserializationContext {
+            deserialization,
+            mem,
+        }
+    }
+}
+
+/// Graph-copy-based deserialization.
+/// Usage:
+/// ```
+/// let deserialization = Deserialization::start(mem, stable_start, stable_size);
+/// while !deserialization.is_completed() {
+///     deserialization.copy_increment();
+/// }
+/// ```
+/// Note: The deserialized memory is cleared as final process, using an incremental
+/// mechanism to avoid instruction limit exceeding.
+impl Deserialization {
+    /// Start the deserialization, followed by a series of copy increments.
+    pub fn start<M: Memory>(mem: &mut M, stable_start: u64, stable_size: u64) -> Deserialization {
+        let from_space = StableMemoryAccess::open(stable_start, stable_size);
+        let scan_stack = unsafe { ScanStack::new(mem) };
+        let limit = ExecutionMonitor::new();
+        let mut deserialization = Deserialization {
+            from_space,
+            scan_stack,
+            stable_start,
+            stable_size,
+            stable_root: None,
+            limit,
+            clear_position: stable_start,
+        };
+        deserialization.start(mem, StableValue::serialize(Value::from_ptr(0)));
+        deserialization
+    }
+
+    pub fn get_stable_root(&self) -> Value {
+        self.stable_root.unwrap()
+    }
+
+    unsafe fn scan_deserialized<
+        'a,
+        M: Memory,
+        F: Fn(&mut DeserializationContext<'a, M>, Value) -> Value,
+    >(
+        context: &mut DeserializationContext<'a, M>,
+        target_object: Value,
+        translate: &F,
+    ) {
+        debug_assert!(target_object.is_obj());
+        visit_pointer_fields(
+            context,
+            target_object.as_obj(),
+            target_object.tag(),
+            0,
+            |context, field_address| {
+                *field_address = translate(context, *field_address);
+            },
+            |context, _, array| {
+                let length = slice_array(array);
+                if (*array).header.tag >= TAG_ARRAY_SLICE_MIN {
+                    // Push the array back on the stack to visit the next array slice.
+                    context
+                        .deserialization
+                        .scan_stack
+                        .push(context.mem, target_object);
+                }
+                length
+            },
+        );
+    }
+
+    fn stable_end(&self) -> u64 {
+        self.stable_start.checked_add(self.stable_size).unwrap()
+    }
+
+    fn processed_memory(&self) -> u64 {
+        let deserialized_memory = unsafe { deserialized_size() as u64 };
+        debug_assert!(self.clear_position >= self.stable_start);
+        let cleared_memory = self.clear_position - self.stable_start;
+        deserialized_memory + cleared_memory
+    }
+}
+
+impl GraphCopy<StableValue, Value, u32> for Deserialization {
+    fn get_forward_address(&self, stable_object: StableValue) -> Option<Value> {
+        let address = stable_object.to_stable_address();
+        let tag = self.from_space.read::<Tag>(address);
+        match tag {
+            TAG_FWD_PTR => {
+                let forward_object = self.from_space.read::<FwdPtr>(address);
+                Some(forward_object.fwd)
+            }
+            _ => None,
+        }
+    }
+
+    fn set_forward_address(&mut self, stable_object: StableValue, target: Value) {
+        let address = stable_object.to_stable_address();
+        let forward_object = FwdPtr {
+            tag: TAG_FWD_PTR,
+            fwd: target,
+        };
+        self.from_space.write(address, &forward_object);
+    }
+
+    fn copy<M: Memory>(&mut self, mem: &mut M, stable_object: StableValue) -> Value {
+        unsafe {
+            let target = deserialize(mem, &mut self.from_space, stable_object);
+            if self.stable_root.is_none() {
+                self.stable_root = Some(target);
+            }
+            self.scan_stack.push(mem, target);
+            target
+        }
+    }
+
+    /// Note:
+    /// * The deserialized memory may contain free space at a partition end.
+    fn scan<M: Memory>(&mut self, mem: &mut M) {
+        let target_object = unsafe { self.scan_stack.pop() };
+        debug_assert!(target_object != STACK_EMPTY);
+        unsafe {
+            Self::scan_deserialized(
+                &mut DeserializationContext::new(self, mem),
+                target_object,
+                &|context, original| {
+                    let old_value = StableValue::serialize(original);
+                    if original.is_non_null_ptr() {
+                        context.deserialization.evacuate(context.mem, old_value)
+                    } else {
+                        original
+                    }
+                },
+            );
+        }
+    }
+
+    fn scanning_completed(&self) -> bool {
+        unsafe { self.scan_stack.is_empty() }
+    }
+
+    fn cleanup_completed(&self) -> bool {
+        debug_assert!(self.scanning_completed());
+        debug_assert!(self.clear_position <= self.stable_end());
+        self.clear_position >= self.stable_end()
+    }
+
+    fn cleanup(&mut self) {
+        // Optimum value according to experimental measurements:
+        // Smallest chunk size that does not cause noticeable performance regression.
+        // The granularity is still small enough to meet the instruction limit.
+        const MAX_CHUNK_SIZE: u64 = MB as u64;
+        debug_assert!(!self.cleanup_completed());
+        let end = self.stable_end();
+        assert!(self.clear_position < end);
+        let remainder = end - self.clear_position;
+        let chunk = core::cmp::min(MAX_CHUNK_SIZE, remainder);
+        clear_stable_memory(self.clear_position, chunk);
+        self.clear_position += chunk;
+    }
+
+    fn time_over(&mut self) -> bool {
+        self.limit.is_exceeded(self.processed_memory())
+    }
+
+    fn reset_time(&mut self) {
+        self.limit.reset(self.processed_memory());
+    }
+}
+
+#[cfg(feature = "ic")]
+unsafe fn deserialized_size() -> usize {
+    crate::memory::ic::partitioned_memory::get_heap_size().as_usize()
+}
+
+// Injection point for RTS unit testing.
+#[cfg(not(feature = "ic"))]
+extern "C" {
+    fn deserialized_size() -> usize;
+}
diff --git a/rts/motoko-rts/src/stabilization/deserialization/scan_stack.rs b/rts/motoko-rts/src/stabilization/deserialization/scan_stack.rs
new file mode 100644
index 00000000000..d426cc8dd51
--- /dev/null
+++ b/rts/motoko-rts/src/stabilization/deserialization/scan_stack.rs
@@ -0,0 +1,118 @@
+//! In-heap extendable scan stack to remember the deserialized objects,
+//! that still need to be scanned by Cheney's algorithm.
+//!
+//! This data structure is necessary for the partitioned heap used by the
+//! incremental GC where no linear scanning is possible because allocations
+//! addresses are not always montonically growing, not even on an empty heap.
+//! One example, is a large object that is allocated in a higher partition,
+//! while subsequently allocated normal-sized objects are placed in lower
+//! partitions.
+//!
+//! The scan stack cannot grow contiguously as new objects can be allocated
+//! during the deserialization. This is why the stack is represented as
+//! multiple tables.
+//!
+//! Doubly linked list of stack tables, each containing a series of entries.
+//! A table is represented as a blob with the following internal layout:
+//!
+//! ┌──────────┬─────────┬──────────┬─────────┬──────────────┬────────┐
+//! │ previous │   next  | entry[0] |  ...    | entry[top-1] | (free) |
+//! └──────────┴─────────┴──────────┴─────────┴──────────────┴────────┘
+//!
+//! The list is doubly linked for the following purpose:
+//! * `previous` to return to the previous table with preceding entries.
+//! * `next` avoid repeated allocations when the stack shrinks and regrows.
+//!
+//! Whenever a table is full and an entry needs to be pushed on the stack,
+//! a new stack table is allocated and linked, unless there already exists
+//! a next table. Only the last table can have free entry space.
+//!
+//! NOTES:
+//! * The tables are blobs, as their entries do not be analyzed by the
+//! destabilization or the GC.
+//! * The stack tables become garbage after a GC run and can be reclaimed.
+//!
+//! The design is mostly identical to the incremental GC's mark stack
+//! TODO: Eliminate code duplication by unfying the stack implementation for
+//! both cases.
+
+use core::ptr::null_mut;
+
+use crate::memory::{alloc_blob, Memory};
+use crate::types::{size_of, Blob, Value, TAG_BLOB_B};
+
+pub struct ScanStack {
+    last: *mut StackTable,
+    top: usize, // index of next free entry in the last stack table
+}
+
+pub const STACK_TABLE_CAPACITY: usize = 1018;
+
+pub const STACK_EMPTY: Value = Value::from_ptr(0);
+
+#[repr(C)]
+struct StackTable {
+    pub header: Blob,
+    pub previous: *mut StackTable,
+    pub next: *mut StackTable,
+    pub entries: [Value; STACK_TABLE_CAPACITY],
+}
+
+impl ScanStack {
+    pub unsafe fn new<M: Memory>(mem: &mut M) -> ScanStack {
+        let table = Self::new_table(mem, null_mut());
+        ScanStack {
+            last: table,
+            top: 0,
+        }
+    }
+
+    pub unsafe fn push<M: Memory>(&mut self, mem: &mut M, value: Value) {
+        debug_assert!(value != STACK_EMPTY);
+        debug_assert!(self.last != null_mut());
+        if self.top == STACK_TABLE_CAPACITY {
+            if (*self.last).next == null_mut() {
+                self.last = Self::new_table(mem, self.last);
+            } else {
+                self.last = (*self.last).next;
+            }
+            self.top = 0;
+        }
+        debug_assert!(self.top < STACK_TABLE_CAPACITY);
+        (*self.last).entries[self.top] = value;
+        self.top += 1;
+    }
+
+    /// Returns the sentinel `STACK_EMPTY` for an empty stack.
+    pub unsafe fn pop(&mut self) -> Value {
+        debug_assert!(self.last != null_mut());
+        if self.top == 0 {
+            if (*self.last).previous == null_mut() {
+                return STACK_EMPTY;
+            }
+            self.last = (*self.last).previous;
+            self.top = STACK_TABLE_CAPACITY;
+        }
+        debug_assert!(self.top > 0);
+        self.top -= 1;
+        debug_assert!(self.top < STACK_TABLE_CAPACITY);
+        (*self.last).entries[self.top]
+    }
+
+    pub unsafe fn is_empty(&self) -> bool {
+        debug_assert!(self.last != null_mut());
+        self.top == 0 && (*self.last).previous == null_mut()
+    }
+
+    unsafe fn new_table<M: Memory>(mem: &mut M, previous: *mut StackTable) -> *mut StackTable {
+        // No post allocation barrier as this RTS-internal blob will be collected by the GC.
+        let table = alloc_blob(mem, TAG_BLOB_B, size_of::<StackTable>().to_bytes()).as_blob_mut()
+            as *mut StackTable;
+        (*table).previous = previous;
+        (*table).next = null_mut();
+        if previous != null_mut() {
+            (*previous).next = table;
+        }
+        table
+    }
+}
diff --git a/rts/motoko-rts/src/stabilization/deserialization/stable_memory_access.rs b/rts/motoko-rts/src/stabilization/deserialization/stable_memory_access.rs
new file mode 100644
index 00000000000..60ec3a7d88b
--- /dev/null
+++ b/rts/motoko-rts/src/stabilization/deserialization/stable_memory_access.rs
@@ -0,0 +1,58 @@
+//! Random read/write access to stable memory.
+//! Supporting Cheney's from-space in stable memory.
+
+use core::mem::{size_of, MaybeUninit};
+
+use crate::stable_mem::{ic0_stable64_read, ic0_stable64_write};
+
+/// Random access to stable memory.
+/// Used for the from-space during destabilization.
+pub struct StableMemoryAccess {
+    base_address: u64,
+    length: u64,
+}
+
+impl StableMemoryAccess {
+    pub fn open(base_address: u64, length: u64) -> StableMemoryAccess {
+        StableMemoryAccess {
+            base_address,
+            length,
+        }
+    }
+
+    pub fn read<T>(&self, source_offset: u64) -> T {
+        let length = size_of::<T>();
+        let mut value = unsafe { MaybeUninit::<T>::uninit().assume_init() };
+        let value_address = &mut value as *mut T as usize;
+        self.raw_read(source_offset, value_address, length);
+        value
+    }
+
+    pub fn raw_read(&self, source_offset: u64, target_address: usize, length: usize) {
+        debug_assert!(source_offset + length as u64 <= self.length);
+        unsafe {
+            ic0_stable64_read(
+                target_address as u64,
+                self.base_address + source_offset,
+                length as u64,
+            );
+        }
+    }
+
+    pub fn write<T>(&mut self, target_offset: u64, value: &T) {
+        let length = size_of::<T>();
+        let value_address = value as *const T as usize;
+        self.raw_write(target_offset, value_address, length);
+    }
+
+    pub fn raw_write(&mut self, target_offset: u64, source_address: usize, length: usize) {
+        debug_assert!(target_offset + length as u64 <= self.length);
+        unsafe {
+            ic0_stable64_write(
+                self.base_address + target_offset,
+                source_address as u64,
+                length as u64,
+            );
+        }
+    }
+}
diff --git a/rts/motoko-rts/src/stabilization/graph_copy.rs b/rts/motoko-rts/src/stabilization/graph_copy.rs
new file mode 100644
index 00000000000..288b02e60e7
--- /dev/null
+++ b/rts/motoko-rts/src/stabilization/graph_copy.rs
@@ -0,0 +1,112 @@
+use crate::memory::Memory;
+
+pub mod limit;
+
+/// Generic graph copy from main memory (from-space) to stable memory (to-space).
+/// The direction of copying is fixed but the memory layout used in the from-space
+/// and the to-space flips when switching between serialization and deserialization.
+/// `S`: Source address type (from-space, main memory).
+/// `T`: Target address type (to-space, stable memory).
+/// `P`: Pointer encoding type (e.g. `u32` or `u64`).
+/// During serialization:
+/// * Main memory = main memory layout, S = Value.
+/// * Stable memory = stable memory layout, T = StableMemoryAddress.
+/// During derialization:
+/// * Main memory = stable memory layout, S = StableMemoryAddress.
+/// * Stable memory = main memory layout, T = Value.
+pub trait GraphCopy<S: Copy, T: Copy, P: Copy + Default> {
+    /// Start the entire graph copy algorithm: Copy the object graph reachable from the `root` pointer.
+    /// Use this as follows:
+    /// ```
+    /// copy_algorithm.start();
+    /// while !copy_algorithm.is_completed() {
+    ///     copy_algorthm.copy_increment();
+    /// }
+    /// ```
+    fn start<M: Memory>(&mut self, mem: &mut M, root: S) {
+        self.evacuate(mem, root);
+    }
+
+    /// Determine whether the scanning algorithm is completed,
+    /// i.e. a all necessary objects have been scanned and copied.
+    fn scanning_completed(&self) -> bool;
+
+    /// Determine whether potential final cleanup work has been completed.
+    fn cleanup_completed(&self) -> bool {
+        self.scanning_completed()
+    }
+
+    /// Perform optional cleanup work after completed scanning and copying.
+    /// This work can be done in incremental steps.
+    fn cleanup(&mut self) {}
+
+    /// Determine whether the entire graph copy algorithm has been completed.
+    /// This includes an incremental copying and an incremental cleanup phase.
+    fn is_completed(&self) -> bool {
+        self.scanning_completed() && self.cleanup_completed()
+    }
+
+    /// Complete the entire graph copy algorithm.
+    fn complete(&mut self) {}
+
+    /// Copy reachable objects in a time-bounded work step with a synthetic time bound.
+    /// This allows to spread the incremental graph copy where the work is
+    /// split in multiple increments over multiple IC messages.
+    fn copy_increment<M: Memory>(&mut self, mem: &mut M) {
+        self.reset_time();
+        while !self.scanning_completed() && !self.time_over() {
+            self.scan(mem);
+        }
+        if self.scanning_completed() {
+            while !self.cleanup_completed() && !self.time_over() {
+                self.cleanup();
+            }
+            if self.cleanup_completed() {
+                self.complete();
+            }
+        }
+    }
+
+    /// Reset the time at the beginning of a new copy increment.
+    fn reset_time(&mut self);
+
+    /// Determine whether the time of copy increment has been exceeded.
+    fn time_over(&mut self) -> bool;
+
+    /// Lazy evacuation of a single object.
+    /// Triggered for each pointer that is patched in the `scan()` function.
+    /// Determines whether the object has already been copied before, and if not,
+    /// copies it to the target space.
+    /// Returns the new target address of the object.
+    fn evacuate<M: Memory>(&mut self, mem: &mut M, object: S) -> T {
+        match self.get_forward_address(object) {
+            Some(target) => target,
+            None => {
+                let target = self.copy(mem, object);
+                self.set_forward_address(object, target);
+                target
+            }
+        }
+    }
+
+    /// Check if the object has been forwarded.
+    /// Returns `None` if not forwarded, or otherwise, the new target address.
+    fn get_forward_address(&self, object: S) -> Option<T>;
+
+    /// Mark the object as forwarded and record its new target address.
+    fn set_forward_address(&mut self, object: S, target: T);
+
+    /// Allocate the object in the to-space by bumping the `free` pointer.
+    /// Copy its content to that target location using the encoding of the target layout.
+    /// Notes:
+    /// * The pointer values in the field are retained as source addresses.
+    /// * The source and target layout must use the same size for addresses, e.g. 32-bit.
+    /// * The allocator must be contiguously growing. Free space must be inserted when the
+    ///   allocator uses internal fragmentation, e.g. for the partitioned heap.
+    fn copy<M: Memory>(&mut self, mem: &mut M, object: S) -> T;
+
+    /// Read an object at the `scan` position in the to-space, and patch all the pointer fields
+    /// by translating the source pointer to the corresponding new target pointer by calling
+    /// `evacuate()`.
+    fn scan<M: Memory>(&mut self, mem: &mut M);
+}
diff --git a/rts/motoko-rts/src/stabilization/graph_copy/limit.rs b/rts/motoko-rts/src/stabilization/graph_copy/limit.rs
new file mode 100644
index 00000000000..864aa89f419
--- /dev/null
+++ b/rts/motoko-rts/src/stabilization/graph_copy/limit.rs
@@ -0,0 +1,122 @@
+use crate::{
+    constants::KB,
+    stabilization::{
+        ic0_performance_counter, moc_stabilization_instruction_limit,
+        moc_stable_memory_access_limit,
+    },
+};
+
+/// Graph copy limits depending on the IC message type.
+/// Explicit stabilization and destabilization increments run as update messages
+/// with lower limits, while the graph copy during the actual upgrade can use
+/// higher limits.
+#[derive(Clone, Copy)]
+pub struct ExecutionLimits {
+    /// Limit of the instructions executed during a graph copy increment.
+    instruction_limit: u64,
+    /// Limit of read or written stable memory during a graph copy increment.
+    stable_memory_access_limit: u64,
+}
+
+impl ExecutionLimits {
+    /// Determine the limits for the current IC message.
+    pub fn determine() -> ExecutionLimits {
+        ExecutionLimits {
+            instruction_limit: unsafe { moc_stabilization_instruction_limit() },
+            stable_memory_access_limit: unsafe { moc_stable_memory_access_limit() },
+        }
+    }
+}
+
+/// Execution monitor for the graph copy increment.
+/// Monitoring the message instruction counter and
+/// the amount of processed memory.
+/// The latter is relevant to avoid exceeding the limit
+/// of how much stable memory be accessed in a message.
+/// Optimization: Avoiding frequent repeated calls to
+/// `ic0_performance_counter()` as this incurs 200
+/// instructions itself.
+/// Heuristic approach: The logic only occasionally
+/// synchronizes the actual instruction counter after a
+/// defined granularity of work:
+/// * A certain amount of memory has been processed:
+///     - During stabilization: Written stable memory.
+///     - During destabilization: Allocated main memory
+///       and cleared stable memory (during completion),
+///   or,
+/// * A certain number of `is_exceeded` calls has
+///   been made.
+/// Once the limit has been exceeded, the heuristics
+/// continuously returns exceeded until the monitoring
+/// is reset.
+pub struct ExecutionMonitor {
+    /// Limits depending on IC message type (upgrade or update).
+    limits: ExecutionLimits,
+    /// Instruction counter at the beginning of the measurement.
+    initial_instruction_counter: u64,
+    /// Amount of processed memory before the measurement.
+    initial_processed_memory: u64,
+    // Only used for sporadic synchronization heuristics:
+    /// Number of `is_exceeded` calls since the last instruction
+    /// counter synchronization.
+    call_counter: usize,
+    /// Amount of processed memory since the last instruction
+    /// counter synchronization.
+    last_processed: u64,
+    /// Denotes whether the limit has been exceeded.
+    exceeded: bool,
+}
+
+impl ExecutionMonitor {
+    /// Threshold on the number of `is_exceeded` calls since the
+    /// last instruction counter synchronization.
+    const CALL_THRESHOLD: usize = 1_000;
+    /// Threshold on the amount of processed memory since the last
+    /// instruction counter synchronization.
+    const MEMORY_THRESHOLD: u64 = 256 * KB as u64;
+
+    pub fn new() -> ExecutionMonitor {
+        ExecutionMonitor {
+            limits: ExecutionLimits::determine(),
+            initial_instruction_counter: Self::instruction_counter(),
+            initial_processed_memory: 0,
+            call_counter: 0,
+            last_processed: 0,
+            exceeded: false,
+        }
+    }
+
+    pub fn is_exceeded(&mut self, processed_memory: u64) -> bool {
+        debug_assert!(self.initial_processed_memory <= processed_memory);
+        // Check the memory limit.
+        if processed_memory - self.initial_processed_memory > self.limits.stable_memory_access_limit
+        {
+            return true;
+        }
+        // Check the instruction limit.
+        // Sporadic instruction counter synchronization, see above.
+        self.call_counter += 1;
+        if processed_memory >= self.last_processed.saturating_add(Self::MEMORY_THRESHOLD)
+            || self.call_counter >= Self::CALL_THRESHOLD
+        {
+            // Reset the heuristics counters.
+            self.call_counter = 0;
+            self.last_processed = processed_memory;
+            // Check actual instruction counter.
+            let current = Self::instruction_counter();
+            debug_assert!(self.initial_instruction_counter <= current);
+            let elapsed = current - self.initial_instruction_counter;
+            self.exceeded = elapsed > self.limits.instruction_limit;
+        }
+        self.exceeded
+    }
+
+    pub fn reset(&mut self, processed_memory: u64) {
+        *self = Self::new();
+        self.initial_processed_memory = processed_memory;
+    }
+
+    fn instruction_counter() -> u64 {
+        unsafe { ic0_performance_counter(0) }
+    }
+}
diff --git a/rts/motoko-rts/src/stabilization/ic.rs b/rts/motoko-rts/src/stabilization/ic.rs
new file mode 100644
index 00000000000..05a926479da
--- /dev/null
+++ b/rts/motoko-rts/src/stabilization/ic.rs
@@ -0,0 +1,278 @@
+mod metadata;
+mod performance;
+
+use motoko_rts_macros::ic_mem_fn;
+
+use crate::{
+    gc::incremental::{is_gc_stopped, resume_gc, stop_gc},
+    memory::Memory,
+    persistence::{
+        compatibility::{memory_compatible, TypeDescriptor},
+        set_upgrade_instructions,
+    },
+    rts_trap_with,
+    stabilization::ic::metadata::StabilizationMetadata,
+    stable_mem::{self, moc_stable_mem_set_size, PAGE_SIZE},
+    types::Value,
+};
+
+use self::{metadata::UpgradeStatistics, performance::InstructionMeter};
+
+use super::graph_copy::GraphCopy;
+use super::{deserialization::Deserialization, serialization::Serialization};
+
+struct StabilizationState {
+    old_candid_data: Value,
+    old_type_offsets: Value,
+    completed: bool,
+    serialization: Serialization,
+    instruction_meter: InstructionMeter,
+}
+
+impl StabilizationState {
+    fn new(
+        serialization: Serialization,
+        old_candid_data: Value,
+        old_type_offsets: Value,
+    ) -> StabilizationState {
+        StabilizationState {
+            old_candid_data,
+            old_type_offsets,
+            completed: false,
+            serialization,
+            instruction_meter: InstructionMeter::new(),
+        }
+    }
+}
+
+static mut STABILIZATION_STATE: Option<StabilizationState> = None;
+
+#[no_mangle]
+pub unsafe extern "C" fn is_graph_stabilization_started() -> bool {
+    STABILIZATION_STATE.is_some()
+}
+
+/// Start the incremental graph-copy-based stabilization.
+/// This operations initiates the graph copy stabilization instead of enhanced orthogonal persistence.
+/// It is required before a series of stabilization increments can be run.
+/// `stable_actor`: Root object for stabilization containing all stable variables of the actor.
+/// `old_candid_data`: A blob encoding the Candid type as a table.
+/// `old_type_offsets`: A blob encoding the type offsets in the Candid type table.
+///   Type index 0 represents the stable actor object to be serialized.
+/// Note:
+/// - Once started, the heap is invalidated. All application messages must be blocked after this start.
+#[ic_mem_fn(ic_only)]
+pub unsafe fn start_graph_stabilization<M: Memory>(
+    mem: &mut M,
+    stable_actor: Value,
+    old_candid_data: Value,
+    old_type_offsets: Value,
+) {
+    assert!(STABILIZATION_STATE.is_none());
+    assert!(is_gc_stopped());
+    let stable_memory_pages = stable_mem::size(); // Backup the virtual size.
+    let serialized_data_start = stable_memory_pages * PAGE_SIZE;
+    let serialization = Serialization::start(mem, stable_actor, serialized_data_start);
+    STABILIZATION_STATE = Some(StabilizationState::new(
+        serialization,
+        old_candid_data,
+        old_type_offsets,
+    ));
+}
+
+/// Incremental graph-copy-based stabilization, serializing a limited amount of heap objects reachable
+/// from stable variables into stable memory.
+/// This function can be called multiple times before the upgrade of a large heap.
+/// The incrementality serves to support the graph-copy-based serialization large heaps that do not fit
+/// into the upgrade message instruction limit.
+/// Returns true if the stabilization has been completed.
+/// Notes:
+/// - During stabilization, the heap is invalidated. Therefore and for consistent serialization,
+///   all application messages must be blocked during this process.
+/// - This operation only runs a limited number of instructions that may not yet complete the stabilization.
+///   The compiler may needs to trigger more messages that run additional stabilzation increments, before the
+///   stabilization has been completed and the actual canister upgrade is ready to be performed.
+/// Implementation:
+/// * Algorithm: Cheney's algorithm using main memory as from-space and stable memory as to-space.
+/// * Encoding: The from-space uses the main memory heap layout, while the to-space is encoded in
+///   the stable object graph layout (see `GraphCopyStabilization.md`).
+#[ic_mem_fn(ic_only)]
+pub unsafe fn graph_stabilization_increment<M: Memory>(mem: &mut M) -> bool {
+    let state = STABILIZATION_STATE.as_mut().unwrap();
+    if !state.completed {
+        assert!(is_gc_stopped());
+        state.instruction_meter.start();
+        state.serialization.copy_increment(mem);
+        state.instruction_meter.stop();
+        if state.serialization.is_completed() {
+            write_metadata();
+            state.completed = true;
+        }
+    }
+    state.completed
+}
+
+unsafe fn write_metadata() {
+    let state = STABILIZATION_STATE.as_mut().unwrap();
+    assert!(state.serialization.is_completed());
+    state.instruction_meter.start();
+    let serialized_data_start = state.serialization.serialized_data_start();
+    let serialized_data_length = state.serialization.serialized_data_length();
+
+    let type_descriptor = TypeDescriptor::new(state.old_candid_data, state.old_type_offsets);
+    let metadata = StabilizationMetadata {
+        serialized_data_start,
+        serialized_data_length,
+        type_descriptor,
+    };
+    state.instruction_meter.stop();
+    metadata.store(&mut state.instruction_meter);
+}
+
+struct DestabilizationState {
+    deserialization: Deserialization,
+    stabilization_statistics: UpgradeStatistics,
+    completed: bool,
+    instruction_meter: InstructionMeter,
+}
+
+static mut DESTABILIZATION_STATE: Option<DestabilizationState> = None;
+
+/// Starts the graph-copy-based destabilization process.
+/// This requires that the deserialization is subsequently run and completed.
+/// Also checks whether the new program version is compatible to the stored state by comparing the type
+/// tables of both the old and the new program version.
+/// The check is identical to enhanced orthogonal persistence, except that the metadata is obtained from
+/// stable memory and not the persistent main memory.
+/// The parameters encode the type table of the new program version to which that data is to be upgraded.
+/// `new_candid_data`: A blob encoding the Candid type as a table.
+/// `new_type_offsets`: A blob encoding the type offsets in the Candid type table.
+///   Type index 0 represents the stable actor object to be serialized.
+/// Traps if the stable state is incompatible with the new program version and the upgrade is not
+/// possible.
+#[ic_mem_fn(ic_only)]
+pub unsafe fn start_graph_destabilization<M: Memory>(
+    mem: &mut M,
+    new_candid_data: Value,
+    new_type_offsets: Value,
+) {
+    assert!(DESTABILIZATION_STATE.is_none());
+
+    let mut instruction_meter = InstructionMeter::new();
+    instruction_meter.start();
+    let mut new_type_descriptor = TypeDescriptor::new(new_candid_data, new_type_offsets);
+    let (metadata, statistics) = StabilizationMetadata::load(mem);
+    let mut old_type_descriptor = metadata.type_descriptor;
+    if !memory_compatible(mem, &mut old_type_descriptor, &mut new_type_descriptor) {
+        rts_trap_with("Memory-incompatible program upgrade");
+    }
+    // Restore the virtual size.
+    moc_stable_mem_set_size(metadata.serialized_data_start / PAGE_SIZE);
+
+    // Stop the GC until the incremental graph destabilization has been completed.
+    stop_gc();
+
+    let deserialization = Deserialization::start(
+        mem,
+        metadata.serialized_data_start,
+        metadata.serialized_data_length,
+    );
+    instruction_meter.stop();
+    DESTABILIZATION_STATE = Some(DestabilizationState {
+        deserialization,
+        stabilization_statistics: statistics,
+        completed: false,
+        instruction_meter,
+    });
+}
+
+/// Incremental graph-copy-based destabilization, deserializing a limited amount of serialized data from
+/// stable memory to the heap.
+/// This function can be called multiple times after the upgrade of a large heap.
+/// The incrementality serves to support the graph-copy-based deserialization of large heaps that do not fit
+/// into the upgrade message instruction limit.
+/// Returns true if the destabilization has been completed.
+/// Notes:
+/// - The heap is only valid after completed destabilization. Therefore and for consistent deserialization,
+///   all application messages must be blocked until this is completed.
+/// - This operation only runs a limited number of instructions that may not yet complete the upgrade.
+///   The compiler may need to trigger more messages that run additional destabilzation increments, before
+///   the destabilization is completed and the application code can resume its operation.
+/// Implementation:
+/// * Algorithm: Cheney's algorithm using stable memory as from-space and main memory as to-space.
+/// * Encoding: The from-space uses the stable memory layout, while the to-space is to be encoded in
+///   main memory layout (see `GraphCopyStabilization.md`).
+#[ic_mem_fn(ic_only)]
+pub unsafe fn graph_destabilization_increment<M: Memory>(mem: &mut M) -> bool {
+    let state = DESTABILIZATION_STATE
+        .as_mut()
+        .unwrap_or_else(|| rts_trap_with("No destabilization needed"));
+    if !state.completed {
+        assert!(is_gc_stopped());
+        state.instruction_meter.start();
+        state.deserialization.copy_increment(mem);
+        state.instruction_meter.stop();
+        if state.deserialization.is_completed() {
+            record_upgrade_costs();
+            state.completed = true;
+            memory_sanity_check(mem);
+        }
+    }
+    state.completed
+}
+
+unsafe fn memory_sanity_check<M: Memory>(_mem: &mut M) {
+    #[cfg(feature = "memory_check")]
+    {
+        use crate::gc::incremental::{
+            get_partitioned_heap,
+            sanity_checks::{check_memory, CheckerMode},
+        };
+
+        let state = DESTABILIZATION_STATE.as_mut().unwrap();
+        let unused_root = &mut Value::from_scalar(0) as *mut Value;
+        let roots = [
+            &mut state.deserialization.get_stable_root() as *mut Value,
+            unused_root,
+            unused_root,
+            unused_root,
+            unused_root,
+            unused_root,
+        ];
+        check_memory(
+            _mem,
+            get_partitioned_heap(),
+            roots,
+            CheckerMode::UpdateCompletion,
+        );
+    }
+}
+
+unsafe fn record_upgrade_costs() {
+    let state = DESTABILIZATION_STATE.as_ref().unwrap();
+    let total_instructions = state.stabilization_statistics.stabilization_instructions
+        + state.instruction_meter.total_elapsed();
+    set_upgrade_instructions(total_instructions);
+}
+
+/// Returns the deserialized stable actor root after the completed destabilization.
+#[no_mangle]
+pub unsafe extern "C" fn get_graph_destabilized_actor() -> Value {
+    let state = DESTABILIZATION_STATE.as_ref().unwrap();
+    assert!(state.completed);
+    state.deserialization.get_stable_root()
+}
+
+/// Stop the GC before performing incremental graph-copy-based stabilzation or destabilization.
+/// This is only a safe-guard since the compiler must not schedule the GC during stabilization
+/// and destabilization.
+#[no_mangle]
+pub unsafe extern "C" fn stop_gc_before_stabilization() {
+    stop_gc();
+}
+
+/// Start the GC after completed incremental graph-copy-based destabilization.
+#[no_mangle]
+pub unsafe extern "C" fn start_gc_after_destabilization() {
+    resume_gc();
+}
diff --git a/rts/motoko-rts/src/stabilization/ic/metadata.rs b/rts/motoko-rts/src/stabilization/ic/metadata.rs
new file mode 100644
index 00000000000..2ddcf99b5ad
--- /dev/null
+++ b/rts/motoko-rts/src/stabilization/ic/metadata.rs
@@ -0,0 +1,220 @@
+//! Graph-copy-bazed serialization format:
+//!
+//! (Very first word is zeroed and backed up in last page)
+//! -- Stable memory
+//! Raw stable memory or region data, size S in pages
+//! -- Stable variables
+//! Serialized data address N:
+//!   Serialized object graph, length L
+//!   (possible zero padding)
+//! Type descriptor address M:
+//!   Candid type table
+//!     Byte length (u64)
+//!     Data
+//!   Type offset table
+//!     Byte length (u64)
+//!     Data
+//!   (possible zero padding)
+//! -- Last physical page (metadata):
+//!   (zero padding to align at page end)
+//!   Upgrade statistics (instructions) (u64)
+//!   Serialized data address N (u64)
+//!   Serialized data length L (u64)
+//!   Type descriptor address M (u64)
+//!   First word of page 0
+//!   Version 3 or 4 (u32) (match with `VERSION_GRAPH_COPY_NO_REGIONS` and `VERSION_GRAPH_COPY_REGIONS` in `region.rs` and `compile.ml`.
+//! -- page end
+
+use crate::{
+    barriers::allocation_barrier,
+    memory::{alloc_blob, Memory},
+    persistence::compatibility::TypeDescriptor,
+    region::{
+        VERSION_GRAPH_COPY_NO_REGIONS, VERSION_GRAPH_COPY_REGIONS, VERSION_STABLE_HEAP_NO_REGIONS,
+        VERSION_STABLE_HEAP_REGIONS,
+    },
+    stabilization::{clear_stable_memory, grant_stable_space},
+    stable_mem::{
+        get_version, ic0_stable64_read, ic0_stable64_size, ic0_stable64_write, read_u32, read_u64,
+        set_version, write_u32, write_u64, PAGE_SIZE,
+    },
+    types::{size_of, Bytes, Tag, Value, TAG_BLOB_B},
+};
+
+use super::performance::InstructionMeter;
+
+#[repr(C)]
+#[derive(Default)]
+pub struct UpgradeStatistics {
+    pub stabilization_instructions: u64,
+}
+
+#[repr(C)]
+#[derive(Default)]
+struct LastPageRecord {
+    statistics: UpgradeStatistics,
+    serialized_data_address: u64,
+    serialized_data_length: u64,
+    type_descriptor_address: u64,
+    first_word_backup: u32,
+    version: u32,
+}
+
+pub struct StabilizationMetadata {
+    pub serialized_data_start: u64,
+    pub serialized_data_length: u64,
+    pub type_descriptor: TypeDescriptor,
+}
+
+impl StabilizationMetadata {
+    fn ensure_space(offset: u64, length: u64) {
+        grant_stable_space(offset + length);
+    }
+
+    fn write_length(offset: &mut u64, length: u64) {
+        Self::ensure_space(*offset, length as u64);
+        write_u64(*offset, length);
+        *offset += size_of::<u64>().to_bytes().as_usize() as u64;
+    }
+
+    fn write_blob(offset: &mut u64, value: Value) {
+        unsafe {
+            let length = value.as_blob().len().as_usize() as u64;
+            Self::write_length(offset, length);
+            Self::ensure_space(*offset, length as u64);
+            ic0_stable64_write(
+                *offset,
+                value.as_blob().payload_const() as u64,
+                length as u64,
+            );
+            *offset += length as u64;
+        }
+    }
+
+    fn align_page_start(offset: &mut u64) {
+        if *offset % PAGE_SIZE != 0 {
+            let remainder = PAGE_SIZE - *offset % PAGE_SIZE;
+            clear_stable_memory(*offset, remainder);
+            *offset += remainder;
+        }
+    }
+
+    fn save_type_descriptor(offset: &mut u64, descriptor: &TypeDescriptor) {
+        Self::write_blob(offset, descriptor.candid_data());
+        Self::write_blob(offset, descriptor.type_offsets());
+    }
+
+    fn read_length(offset: &mut u64) -> u64 {
+        let length = read_u64(*offset);
+        // Note: Do not use `types::size_of()` as it rounds to 64-bit words.
+        clear_stable_memory(*offset, core::mem::size_of::<u32>() as u64);
+        *offset += size_of::<u64>().to_bytes().as_usize() as u64;
+        length
+    }
+
+    fn read_blob<M: Memory>(mem: &mut M, tag: Tag, offset: &mut u64) -> Value {
+        let length = Self::read_length(offset);
+        unsafe {
+            let value = alloc_blob(mem, tag, Bytes(length as usize));
+            ic0_stable64_read(
+                value.as_blob_mut().payload_addr() as u64,
+                *offset,
+                length as u64,
+            );
+            clear_stable_memory(*offset, length as u64);
+            allocation_barrier(value);
+            *offset += length as u64;
+            value
+        }
+    }
+
+    fn load_type_descriptor<M: Memory>(mem: &mut M, offset: &mut u64) -> TypeDescriptor {
+        let candid_data = Self::read_blob(mem, TAG_BLOB_B, offset);
+        let type_offsets = Self::read_blob(mem, TAG_BLOB_B, offset);
+        TypeDescriptor::new(candid_data, type_offsets)
+    }
+
+    fn metadata_location() -> u64 {
+        let physical_pages = unsafe { ic0_stable64_size() };
+        assert!(physical_pages > 0);
+        let last_page_start = (physical_pages - 1) * PAGE_SIZE;
+        let size = size_of::<LastPageRecord>().to_bytes().as_usize() as u64;
+        assert!(size < PAGE_SIZE);
+        last_page_start + (PAGE_SIZE - size)
+    }
+
+    fn write_metadata(value: &LastPageRecord) {
+        let offset = Self::metadata_location();
+        let size = size_of::<LastPageRecord>().to_bytes().as_usize() as u64;
+        Self::ensure_space(offset, size);
+        unsafe {
+            ic0_stable64_write(offset, value as *const LastPageRecord as u64, size);
+        }
+    }
+
+    fn read_metadata() -> LastPageRecord {
+        let offset = Self::metadata_location();
+        let size = size_of::<LastPageRecord>().to_bytes().as_usize() as u64;
+        let mut value = LastPageRecord::default();
+        unsafe {
+            ic0_stable64_read(&mut value as *mut LastPageRecord as u64, offset, size);
+        }
+        value
+    }
+
+    fn clear_metadata() {
+        Self::write_metadata(&LastPageRecord::default());
+    }
+
+    pub fn store(&self, measurement: &mut InstructionMeter) {
+        measurement.start();
+        let mut offset = self.serialized_data_start + self.serialized_data_length;
+        Self::align_page_start(&mut offset);
+        let type_descriptor_address = offset;
+        Self::save_type_descriptor(&mut offset, &self.type_descriptor);
+        Self::align_page_start(&mut offset);
+        let first_word_backup = read_u32(0);
+        // Clear very first word that is backed up in the last page.
+        // This ensures compatibility with old legacy version 0 using no
+        // experimental stable memory and no regions.
+        write_u32(0, 0);
+        measurement.stop();
+        let statistics = UpgradeStatistics {
+            stabilization_instructions: measurement.total_elapsed(),
+        };
+        let last_page_record = LastPageRecord {
+            statistics,
+            serialized_data_address: self.serialized_data_start,
+            serialized_data_length: self.serialized_data_length,
+            type_descriptor_address,
+            first_word_backup,
+            version: Self::stabilization_version() as u32,
+        };
+        Self::write_metadata(&last_page_record);
+    }
+
+    pub fn load<M: Memory>(mem: &mut M) -> (StabilizationMetadata, UpgradeStatistics) {
+        let last_page_record = Self::read_metadata();
+        Self::clear_metadata();
+        let version = last_page_record.version as usize;
+        assert!(version == VERSION_GRAPH_COPY_NO_REGIONS || version == VERSION_GRAPH_COPY_REGIONS);
+        set_version(version);
+        write_u32(0, last_page_record.first_word_backup);
+        let mut offset = last_page_record.type_descriptor_address;
+        let type_descriptor = Self::load_type_descriptor(mem, &mut offset);
+        let metadata = StabilizationMetadata {
+            serialized_data_start: last_page_record.serialized_data_address,
+            serialized_data_length: last_page_record.serialized_data_length,
+            type_descriptor,
+        };
+        (metadata, last_page_record.statistics)
+    }
+
+    fn stabilization_version() -> usize {
+        match get_version() {
+            VERSION_STABLE_HEAP_NO_REGIONS => VERSION_GRAPH_COPY_NO_REGIONS,
+            VERSION_STABLE_HEAP_REGIONS => VERSION_GRAPH_COPY_REGIONS,
+            _ => unreachable!(),
+        }
+    }
+}
diff --git a/rts/motoko-rts/src/stabilization/ic/performance.rs b/rts/motoko-rts/src/stabilization/ic/performance.rs
new file mode 100644
index 00000000000..5f2a99ec74e
--- /dev/null
+++ b/rts/motoko-rts/src/stabilization/ic/performance.rs
@@ -0,0 +1,37 @@
+use crate::stabilization::ic0_performance_counter;
+
+pub struct InstructionMeter {
+    total_elapsed: u64,
+    start_offset: Option<u64>,
+}
+
+impl InstructionMeter {
+    pub fn new() -> InstructionMeter {
+        InstructionMeter {
+            total_elapsed: 0,
+            start_offset: None,
+        }
+    }
+
+    pub fn start(&mut self) {
+        assert!(self.start_offset.is_none());
+        self.start_offset = Some(Self::instruction_counter());
+    }
+
+    pub fn stop(&mut self) {
+        let start = self.start_offset.unwrap();
+        let stop = Self::instruction_counter();
+        debug_assert!(start <= stop);
+        self.total_elapsed += stop - start;
+        self.start_offset = None;
+    }
+
+    pub fn total_elapsed(&self) -> u64 {
+        assert!(self.start_offset.is_none());
+        self.total_elapsed
+    }
+
+    fn instruction_counter() -> u64 {
+        unsafe { ic0_performance_counter(0) }
+    }
+}
diff --git a/rts/motoko-rts/src/stabilization/layout.rs b/rts/motoko-rts/src/stabilization/layout.rs
new file mode 100644
index 00000000000..49a9e5d24b0
--- /dev/null
+++ b/rts/motoko-rts/src/stabilization/layout.rs
@@ -0,0 +1,447 @@
+//! The long-term layout definition of the stable format.
+//!
+//! The stable object graph resides a linear stable memory space.
+//!
+//! Pointers are serialized as 64-bit skewed offsets in that space.
+//! The stable encoding of scalars is currently identical to the
+//! main memory encoding, requiring the precise scalar tag as metadata.
+//! If the main memory scalar representation changes in future, the
+//! values need to be explicitly translated to the expected stable format.
+//!
+//! Each object uses a `StableTag` as header and is followed by
+//! the object payload as outlined in the corresponding Rust structs.
+//! Some objects, such as `StableArray`, `StableObject`, `StableBlob`,
+//! and `StableBigNum` have a dynamic payload body in addition to a static
+//! header.
+//!
+//! Not all heap memory object types are stabilized because some
+//! of them are not stable types. New object types can be added
+//! with backwards compatibility but encoding changes to existing stable
+//! data types must be handled with extra care to ensure backwards compatibility.
+//!
+//! Note: For a potential downgrade to 32-bit, the 64-bit stable pointer
+//! offsets can be scaled down by a factor `8` during the destabilization
+//! such that they fit into 32-bit values during Cheney's graph-copy.
+
+use crate::{
+    barriers::allocation_barrier,
+    constants::WORD_SIZE,
+    memory::Memory,
+    rts_trap_with,
+    types::{
+        base_array_tag, size_of, Tag, Value, TAG_ARRAY_I, TAG_ARRAY_M, TAG_ARRAY_S,
+        TAG_ARRAY_SLICE_MIN, TAG_ARRAY_T, TAG_BIGINT, TAG_BITS64_F, TAG_BITS64_S, TAG_BITS64_U,
+        TAG_BLOB_A, TAG_BLOB_B, TAG_BLOB_P, TAG_BLOB_T, TAG_CONCAT, TAG_MUTBOX, TAG_OBJECT,
+        TAG_REGION, TAG_SOME, TAG_VARIANT, TRUE_VALUE,
+    },
+};
+
+use self::{
+    stable_array::StableArray, stable_bigint::StableBigInt, stable_bits64::StableBits64,
+    stable_blob::StableBlob, stable_concat::StableConcat, stable_mutbox::StableMutBox,
+    stable_object::StableObject, stable_region::StableRegion, stable_some::StableSome,
+    stable_variant::StableVariant,
+};
+
+use super::{
+    deserialization::stable_memory_access::StableMemoryAccess,
+    serialization::{
+        stable_memory_stream::{ScanStream, StableMemoryStream, WriteStream},
+        SerializationContext,
+    },
+};
+
+mod stable_array;
+mod stable_bigint;
+mod stable_bits64;
+mod stable_blob;
+mod stable_concat;
+mod stable_mutbox;
+mod stable_object;
+mod stable_region;
+mod stable_some;
+mod stable_variant;
+
+/// Different kinds of objects used in the stable format.
+#[repr(u64)]
+#[derive(Clone, Copy, PartialEq, Debug)]
+pub enum StableObjectKind {
+    ArrayImmutable = 1,
+    ArrayMutable = 2,
+    ArrayTuple = 3,
+    ArraySharedFunction = 4,
+    MutBox = 5,
+    Object = 6,
+    BlobBytes = 7,
+    BlobText = 8,
+    BlobPrincipal = 9,
+    BlobActor = 10,
+    Bits64Unsigned = 11,
+    Bits64Signed = 12,
+    Bits64Float = 13,
+    Region = 14,
+    Variant = 15,
+    Concat = 16,
+    BigInt = 17,
+    Some = 18,
+}
+
+#[repr(C)]
+pub struct StableTag(u64);
+
+impl StableObjectKind {
+    pub fn encode(&self) -> StableTag {
+        StableTag(*self as u64)
+    }
+}
+
+impl StableTag {
+    pub fn decode(&self) -> StableObjectKind {
+        const STABLE_TAG_ARRAY_IMMUTABLE: u64 = StableObjectKind::ArrayImmutable as u64;
+        const STABLE_TAG_ARRAY_MUTABLE: u64 = StableObjectKind::ArrayMutable as u64;
+        const STABLE_TAG_ARRAY_TUPLE: u64 = StableObjectKind::ArrayTuple as u64;
+        const STABLE_TAG_ARRAY_SHARED_FUNCTION: u64 = StableObjectKind::ArraySharedFunction as u64;
+        const STABLE_TAG_MUTBOX: u64 = StableObjectKind::MutBox as u64;
+        const STABLE_TAG_OBJECT: u64 = StableObjectKind::Object as u64;
+        const STABLE_TAG_BLOB_BYTES: u64 = StableObjectKind::BlobBytes as u64;
+        const STABLE_TAG_BLOB_TEXT: u64 = StableObjectKind::BlobText as u64;
+        const STABLE_TAG_BLOB_PRINCIPAL: u64 = StableObjectKind::BlobPrincipal as u64;
+        const STABLE_TAG_BLOB_ACTOR: u64 = StableObjectKind::BlobActor as u64;
+        const STABLE_TAG_BITS64_UNSIGNED: u64 = StableObjectKind::Bits64Unsigned as u64;
+        const STABLE_TAG_BITS64_SIGNED: u64 = StableObjectKind::Bits64Signed as u64;
+        const STABLE_TAG_BITS64_FLOAT: u64 = StableObjectKind::Bits64Float as u64;
+        const STABLE_TAG_REGION: u64 = StableObjectKind::Region as u64;
+        const STABLE_TAG_VARIANT: u64 = StableObjectKind::Variant as u64;
+        const STABLE_TAG_CONCAT: u64 = StableObjectKind::Concat as u64;
+        const STABLE_TAG_BIGINT: u64 = StableObjectKind::BigInt as u64;
+        const STABLE_TAG_SOME: u64 = StableObjectKind::Some as u64;
+        match self.0 {
+            STABLE_TAG_ARRAY_IMMUTABLE => StableObjectKind::ArrayImmutable,
+            STABLE_TAG_ARRAY_MUTABLE => StableObjectKind::ArrayMutable,
+            STABLE_TAG_ARRAY_TUPLE => StableObjectKind::ArrayTuple,
+            STABLE_TAG_ARRAY_SHARED_FUNCTION => StableObjectKind::ArraySharedFunction,
+            STABLE_TAG_MUTBOX => StableObjectKind::MutBox,
+            STABLE_TAG_OBJECT => StableObjectKind::Object,
+            STABLE_TAG_BLOB_BYTES => StableObjectKind::BlobBytes,
+            STABLE_TAG_BLOB_TEXT => StableObjectKind::BlobText,
+            STABLE_TAG_BLOB_PRINCIPAL => StableObjectKind::BlobPrincipal,
+            STABLE_TAG_BLOB_ACTOR => StableObjectKind::BlobActor,
+            STABLE_TAG_BITS64_UNSIGNED => StableObjectKind::Bits64Unsigned,
+            STABLE_TAG_BITS64_SIGNED => StableObjectKind::Bits64Signed,
+            STABLE_TAG_BITS64_FLOAT => StableObjectKind::Bits64Float,
+            STABLE_TAG_REGION => StableObjectKind::Region,
+            STABLE_TAG_VARIANT => StableObjectKind::Variant,
+            STABLE_TAG_CONCAT => StableObjectKind::Concat,
+            STABLE_TAG_BIGINT => StableObjectKind::BigInt,
+            STABLE_TAG_SOME => StableObjectKind::Some,
+            _ => unsafe { rts_trap_with("Invalid tag") },
+        }
+    }
+}
+
+impl StableObjectKind {
+    fn deserialize(tag: Tag) -> StableObjectKind {
+        match tag {
+            // During the marking phase of the incremental GC, the mutator can see
+            // array slice information in the object tag.
+            TAG_ARRAY_I | TAG_ARRAY_M | TAG_ARRAY_T | TAG_ARRAY_S | TAG_ARRAY_SLICE_MIN.. => {
+                match base_array_tag(tag) {
+                    TAG_ARRAY_I => StableObjectKind::ArrayImmutable,
+                    TAG_ARRAY_M => StableObjectKind::ArrayMutable,
+                    TAG_ARRAY_T => StableObjectKind::ArrayTuple,
+                    TAG_ARRAY_S => StableObjectKind::ArraySharedFunction,
+                    _ => unreachable!("invalid array tag"),
+                }
+            }
+            TAG_MUTBOX => StableObjectKind::MutBox,
+            TAG_OBJECT => StableObjectKind::Object,
+            TAG_BLOB_B => StableObjectKind::BlobBytes,
+            TAG_BLOB_T => StableObjectKind::BlobText,
+            TAG_BLOB_P => StableObjectKind::BlobPrincipal,
+            TAG_BLOB_A => StableObjectKind::BlobActor,
+            TAG_BITS64_U => StableObjectKind::Bits64Unsigned,
+            TAG_BITS64_S => StableObjectKind::Bits64Signed,
+            TAG_BITS64_F => StableObjectKind::Bits64Float,
+            TAG_REGION => StableObjectKind::Region,
+            TAG_VARIANT => StableObjectKind::Variant,
+            TAG_CONCAT => StableObjectKind::Concat,
+            TAG_BIGINT => StableObjectKind::BigInt,
+            TAG_SOME => StableObjectKind::Some,
+            _ => unreachable!("invalid tag"),
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, PartialEq)]
+pub struct StableValue(u64);
+
+impl StableValue {
+    fn is_ptr(&self) -> bool {
+        self.0 & 0b1 == 1 && self.0 != TRUE_VALUE as u64
+    }
+
+    fn skew(address: u64) -> u64 {
+        address.wrapping_sub(1)
+    }
+
+    fn unskew(pointer: u64) -> u64 {
+        debug_assert!(Self::from_raw(pointer).is_ptr());
+        pointer.wrapping_add(1)
+    }
+
+    pub const fn from_raw(value: u64) -> Self {
+        StableValue(value)
+    }
+
+    pub fn from_stable_address(address: u64) -> Self {
+        debug_assert_eq!(address % WORD_SIZE as u64, 0);
+        StableValue(Self::skew(address))
+    }
+
+    pub fn to_stable_address(&self) -> u64 {
+        Self::unskew(self.0)
+    }
+
+    pub fn payload_address(&self) -> u64 {
+        self.to_stable_address() + size_of::<StableTag>().to_bytes().as_usize() as u64
+    }
+
+    pub fn serialize(value: Value) -> Self {
+        StableValue(value.get_raw() as u64)
+    }
+
+    pub fn deserialize(&self) -> Value {
+        Value::from_raw(self.0 as usize)
+    }
+}
+
+/// Scan the static part of the object.
+trait StaticScanner<T> {
+    // Updates potential pointers in the static part of the object.
+    // Returns true if values have been updated.
+    fn update_pointers<C, F: Fn(&mut C, T) -> T>(
+        &mut self,
+        _context: &mut C,
+        _translate: &F,
+    ) -> bool {
+        false
+    }
+}
+
+pub trait StableToSpace {
+    fn to_space(&mut self) -> &mut StableMemoryStream;
+}
+
+trait Serializer<T>
+where
+    Self: Sized + StaticScanner<StableValue>,
+{
+    unsafe fn serialize_static_part(
+        stable_memory: &mut StableMemoryStream,
+        main_object: *mut T,
+    ) -> Self;
+    unsafe fn serialize_dynamic_part(
+        _stable_memory: &mut StableMemoryStream,
+        _main_object: *mut T,
+    ) {
+    }
+
+    unsafe fn serialize(stable_memory: &mut StableMemoryStream, main_object: Value) {
+        let stable_tag = StableObjectKind::deserialize(main_object.tag()).encode();
+        let main_object = main_object.as_obj() as *mut T;
+        stable_memory.write(&stable_tag);
+        unsafe {
+            let static_part = Self::serialize_static_part(stable_memory, main_object);
+            stable_memory.write(&static_part);
+            Self::serialize_dynamic_part(stable_memory, main_object);
+        }
+    }
+
+    fn scan_serialized<
+        'a,
+        M,
+        F: Fn(&mut SerializationContext<'a, M>, StableValue) -> StableValue,
+    >(
+        context: &mut SerializationContext<'a, M>,
+        translate: &F,
+    ) {
+        let mut static_part = context.serialization.to_space().read::<Self>();
+        if static_part.update_pointers(context, translate) {
+            context.serialization.to_space().update(&static_part);
+        }
+        static_part.scan_serialized_dynamic(context, translate);
+    }
+
+    fn scan_serialized_dynamic<
+        'a,
+        M,
+        F: Fn(&mut SerializationContext<'a, M>, StableValue) -> StableValue,
+    >(
+        &self,
+        _context: &mut SerializationContext<'a, M>,
+        _translate: &F,
+    ) {
+    }
+
+    unsafe fn allocate_deserialized<M: Memory>(
+        &self,
+        main_memory: &mut M,
+        _object_kind: StableObjectKind,
+    ) -> Value {
+        main_memory.alloc_words(size_of::<T>())
+    }
+
+    unsafe fn deserialize_static_part(&self, target_object: *mut T, object_kind: StableObjectKind);
+
+    unsafe fn deserialize_dynamic_part<M: Memory>(
+        &self,
+        _main_memory: &mut M,
+        _stable_memory: &StableMemoryAccess,
+        _stable_object: StableValue,
+        _target_object: *mut T,
+    ) {
+    }
+
+    unsafe fn deserialize<M: Memory>(
+        main_memory: &mut M,
+        stable_memory: &StableMemoryAccess,
+        stable_object: StableValue,
+        object_kind: StableObjectKind,
+    ) -> Value {
+        let stable_address = stable_object.payload_address();
+        let stable_static_part = stable_memory.read::<Self>(stable_address);
+        let target = stable_static_part.allocate_deserialized(main_memory, object_kind);
+        let target_object = target.get_ptr() as *mut T;
+        stable_static_part.deserialize_static_part(target_object, object_kind);
+        stable_static_part.deserialize_dynamic_part(
+            main_memory,
+            stable_memory,
+            stable_object,
+            target_object,
+        );
+        allocation_barrier(target)
+    }
+}
+
+pub fn round_to_u64(length: u64) -> u64 {
+    let alignment = size_of::<u64>().to_bytes().as_usize() as u64;
+    (length + alignment - 1) / alignment * alignment
+}
+
+fn write_padding_u64(stable_memory: &mut StableMemoryStream, byte_length: usize) {
+    let rounded_length = round_to_u64(byte_length as u64);
+    let padding = rounded_length - byte_length as u64;
+    for _ in 0..padding {
+        stable_memory.write(&0u8);
+    }
+}
+
+pub fn scan_serialized<
+    'a,
+    M,
+    F: Fn(&mut SerializationContext<'a, M>, StableValue) -> StableValue,
+>(
+    context: &mut SerializationContext<'a, M>,
+    translate: &F,
+) {
+    if context.serialization.pending_array_scanning() {
+        StableArray::resume_scanning(context, translate);
+        return;
+    }
+    let tag = context.serialization.to_space().read::<StableTag>();
+    match tag.decode() {
+        StableObjectKind::ArrayImmutable
+        | StableObjectKind::ArrayMutable
+        | StableObjectKind::ArrayTuple
+        | StableObjectKind::ArraySharedFunction => StableArray::scan_serialized(context, translate),
+        StableObjectKind::MutBox => StableMutBox::scan_serialized(context, translate),
+        StableObjectKind::Object => StableObject::scan_serialized(context, translate),
+        StableObjectKind::BlobBytes
+        | StableObjectKind::BlobText
+        | StableObjectKind::BlobPrincipal
+        | StableObjectKind::BlobActor => StableBlob::scan_serialized(context, translate),
+        StableObjectKind::Bits64Unsigned
+        | StableObjectKind::Bits64Signed
+        | StableObjectKind::Bits64Float => StableBits64::scan_serialized(context, translate),
+        StableObjectKind::Region => StableRegion::scan_serialized(context, translate),
+        StableObjectKind::Variant => StableVariant::scan_serialized(context, translate),
+        StableObjectKind::Concat => StableConcat::scan_serialized(context, translate),
+        StableObjectKind::BigInt => StableBigInt::scan_serialized(context, translate),
+        StableObjectKind::Some => StableSome::scan_serialized(context, translate),
+    }
+}
+
+pub unsafe fn serialize(stable_memory: &mut StableMemoryStream, main_object: Value) {
+    match StableObjectKind::deserialize(main_object.tag()) {
+        StableObjectKind::ArrayImmutable
+        | StableObjectKind::ArrayMutable
+        | StableObjectKind::ArrayTuple
+        | StableObjectKind::ArraySharedFunction => {
+            StableArray::serialize(stable_memory, main_object)
+        }
+        StableObjectKind::MutBox => StableMutBox::serialize(stable_memory, main_object),
+        StableObjectKind::Object => StableObject::serialize(stable_memory, main_object),
+        StableObjectKind::BlobBytes
+        | StableObjectKind::BlobText
+        | StableObjectKind::BlobPrincipal
+        | StableObjectKind::BlobActor => StableBlob::serialize(stable_memory, main_object),
+        StableObjectKind::Bits64Unsigned
+        | StableObjectKind::Bits64Signed
+        | StableObjectKind::Bits64Float => StableBits64::serialize(stable_memory, main_object),
+        StableObjectKind::Region => StableRegion::serialize(stable_memory, main_object),
+        StableObjectKind::Variant => StableVariant::serialize(stable_memory, main_object),
+        StableObjectKind::Concat => StableConcat::serialize(stable_memory, main_object),
+        StableObjectKind::BigInt => StableBigInt::serialize(stable_memory, main_object),
+        StableObjectKind::Some => StableSome::serialize(stable_memory, main_object),
+    }
+}
+
+pub unsafe fn deserialize<M: Memory>(
+    main_memory: &mut M,
+    stable_memory: &mut StableMemoryAccess,
+    stable_object: StableValue,
+) -> Value {
+    let tag = stable_memory.read::<StableTag>(stable_object.to_stable_address());
+    let object_kind = tag.decode();
+    match object_kind {
+        StableObjectKind::ArrayImmutable
+        | StableObjectKind::ArrayMutable
+        | StableObjectKind::ArrayTuple
+        | StableObjectKind::ArraySharedFunction => {
+            StableArray::deserialize(main_memory, stable_memory, stable_object, object_kind)
+        }
+        StableObjectKind::MutBox => {
+            StableMutBox::deserialize(main_memory, stable_memory, stable_object, object_kind)
+        }
+        StableObjectKind::Object => {
+            StableObject::deserialize(main_memory, stable_memory, stable_object, object_kind)
+        }
+        StableObjectKind::BlobBytes
+        | StableObjectKind::BlobText
+        | StableObjectKind::BlobPrincipal
+        | StableObjectKind::BlobActor => {
+            StableBlob::deserialize(main_memory, stable_memory, stable_object, object_kind)
+        }
+        StableObjectKind::Bits64Unsigned
+        | StableObjectKind::Bits64Signed
+        | StableObjectKind::Bits64Float => {
+            StableBits64::deserialize(main_memory, stable_memory, stable_object, object_kind)
+        }
+        StableObjectKind::Region => {
+            StableRegion::deserialize(main_memory, stable_memory, stable_object, object_kind)
+        }
+        StableObjectKind::Variant => {
+            StableVariant::deserialize(main_memory, stable_memory, stable_object, object_kind)
+        }
+        StableObjectKind::Concat => {
+            StableConcat::deserialize(main_memory, stable_memory, stable_object, object_kind)
+        }
+        StableObjectKind::BigInt => {
+            StableBigInt::deserialize(main_memory, stable_memory, stable_object, object_kind)
+        }
+        StableObjectKind::Some => {
+            StableSome::deserialize(main_memory, stable_memory, stable_object, object_kind)
+        }
+    }
+}
diff --git a/rts/motoko-rts/src/stabilization/layout/stable_array.rs b/rts/motoko-rts/src/stabilization/layout/stable_array.rs
new file mode 100644
index 00000000000..7059e55ca38
--- /dev/null
+++ b/rts/motoko-rts/src/stabilization/layout/stable_array.rs
@@ -0,0 +1,149 @@
+use crate::{
+    memory::{alloc_array, Memory},
+    stabilization::{
+        deserialization::stable_memory_access::StableMemoryAccess,
+        graph_copy::GraphCopy,
+        serialization::{
+            stable_memory_stream::{ScanStream, StableMemoryStream, WriteStream},
+            ArraySlice, SerializationContext,
+        },
+    },
+    types::{size_of, Array, Tag, Value, TAG_ARRAY_I, TAG_ARRAY_M, TAG_ARRAY_S, TAG_ARRAY_T},
+};
+
+use super::{Serializer, StableObjectKind, StableToSpace, StableValue, StaticScanner};
+
+#[repr(C)]
+pub struct StableArray {
+    array_length: u64,
+    // Dynamically sized body with `array_length` elements, each of `StableValue`.
+}
+
+impl StaticScanner<StableValue> for StableArray {}
+
+impl Serializer<Array> for StableArray {
+    unsafe fn serialize_static_part(
+        _stable_memory: &mut StableMemoryStream,
+        array: *mut Array,
+    ) -> Self {
+        StableArray {
+            array_length: array.len() as u64,
+        }
+    }
+
+    unsafe fn serialize_dynamic_part(
+        stable_memory: &mut StableMemoryStream,
+        main_array: *mut Array,
+    ) {
+        for index in 0..main_array.len() {
+            let main_element = main_array.get(index);
+            let stable_element = StableValue::serialize(main_element);
+            stable_memory.write(&stable_element);
+        }
+    }
+
+    fn scan_serialized_dynamic<
+        'a,
+        M,
+        F: Fn(&mut SerializationContext<'a, M>, StableValue) -> StableValue,
+    >(
+        &self,
+        context: &mut SerializationContext<'a, M>,
+        translate: &F,
+    ) {
+        debug_assert!(!context.serialization.pending_array_scanning());
+        let mut index = 0;
+        self.sliced_array_scan(context, translate, &mut index);
+        if index < self.array_length {
+            let slice = ArraySlice::new(index, self.array_length);
+            context.serialization.set_array_slice(slice);
+        }
+    }
+
+    unsafe fn allocate_deserialized<M: Memory>(
+        &self,
+        main_memory: &mut M,
+        object_kind: StableObjectKind,
+    ) -> Value {
+        let array_tag = decode_array_tag(object_kind);
+        let array_length = self.array_length as usize;
+        alloc_array(main_memory, array_tag, array_length)
+    }
+
+    unsafe fn deserialize_static_part(
+        &self,
+        target_array: *mut Array,
+        object_kind: StableObjectKind,
+    ) {
+        debug_assert_eq!((*target_array).header.tag, decode_array_tag(object_kind));
+        debug_assert_eq!((*target_array).len as u64, self.array_length);
+    }
+
+    unsafe fn deserialize_dynamic_part<M: Memory>(
+        &self,
+        _main_memory: &mut M,
+        stable_memory: &StableMemoryAccess,
+        stable_object: StableValue,
+        target_array: *mut Array,
+    ) {
+        let stable_address = stable_object.payload_address();
+        let mut element_address =
+            stable_address + size_of::<StableArray>().to_bytes().as_usize() as u64;
+        for index in 0..(*target_array).len {
+            let element = stable_memory.read::<StableValue>(element_address);
+            target_array.set_raw(index, element.deserialize());
+            element_address += size_of::<StableValue>().to_bytes().as_usize() as u64;
+        }
+    }
+}
+
+fn decode_array_tag(object_kind: StableObjectKind) -> Tag {
+    match object_kind {
+        StableObjectKind::ArrayImmutable => TAG_ARRAY_I,
+        StableObjectKind::ArrayMutable => TAG_ARRAY_M,
+        StableObjectKind::ArrayTuple => TAG_ARRAY_T,
+        StableObjectKind::ArraySharedFunction => TAG_ARRAY_S,
+        _ => unreachable!("invalid stable array tag"),
+    }
+}
+
+impl StableArray {
+    pub fn resume_scanning<
+        'a,
+        M,
+        F: Fn(&mut SerializationContext<'a, M>, StableValue) -> StableValue,
+    >(
+        context: &mut SerializationContext<'a, M>,
+        translate: &F,
+    ) {
+        let mut slice = context.serialization.get_array_slice();
+        let stable_array = StableArray {
+            array_length: slice.array_length,
+        };
+        stable_array.sliced_array_scan(context, translate, &mut slice.next_index);
+        if slice.next_index < slice.array_length {
+            context.serialization.set_array_slice(slice);
+        }
+    }
+
+    fn sliced_array_scan<
+        'a,
+        M,
+        F: Fn(&mut SerializationContext<'a, M>, StableValue) -> StableValue,
+    >(
+        &self,
+        context: &mut SerializationContext<'a, M>,
+        translate: &F,
+        index: &mut u64,
+    ) {
+        while *index < self.array_length {
+            let old_value = context.serialization.to_space().read::<StableValue>();
+            let new_value = translate(context, old_value);
+            context.serialization.to_space().update(&new_value);
+            *index += 1;
+            if context.serialization.time_over() {
+                return;
+            }
+        }
+    }
+}
diff --git a/rts/motoko-rts/src/stabilization/layout/stable_bigint.rs b/rts/motoko-rts/src/stabilization/layout/stable_bigint.rs
new file mode 100644
index 00000000000..107508e9028
--- /dev/null
+++ b/rts/motoko-rts/src/stabilization/layout/stable_bigint.rs
@@ -0,0 +1,219 @@
+use crate::bigint::mp_calloc;
+use crate::memory::Memory;
+use crate::stabilization::deserialization::stable_memory_access::StableMemoryAccess;
+use crate::stabilization::serialization::stable_memory_stream::{
+    ScanStream, StableMemoryStream, WriteStream,
+};
+use crate::stabilization::serialization::SerializationContext;
+use crate::tommath_bindings::mp_digit;
+use crate::types::{size_of, BigInt, Bytes, Value, TAG_BIGINT};
+
+use super::{
+    round_to_u64, Serializer, StableObjectKind, StableToSpace, StableValue, StaticScanner,
+};
+
+// Tom's math library, as configured for Motoko RTS with 64-bit enhanced orthogonal persistence,
+// encodes a big numbers as an array of 64-bit elements, where each element stores 60 bits of the
+// number while its highest 4 bits are zero.
+// Similar to the little endian encoding, the element array starts with the least significant 60 bits,
+// with each subsequent element covering the next higher 60 bits.
+
+// Tom's math library functions `mp_to_sbin` and `mp_from_sbin` imply temporary object allocations
+// which could be problematic when memory is short.
+// Therefore, a custom serialization to the defined portable stable bignum format is implemented.
+
+#[repr(C)]
+pub struct StableBigInt {
+    is_negative: bool, // Sign bit.
+    number_of_bits: Bits, // Number of used bits in the payload.
+
+                       // Dynamically sized payload of the big integer number as
+                       // little endian encoded series of 60 bits packed in 64-bit elements.
+}
+
+type ElementType = u64;
+const USED_BITS_PER_ELEMENT: u32 = 60;
+const ELEMENT_SIZE: usize = core::mem::size_of::<ElementType>();
+
+// Assumes 64-bit representation for both Tom's math library and main memory.
+const _: () = assert!(usize::BITS == ElementType::BITS);
+const _: () = assert!(core::mem::size_of::<mp_digit>() == core::mem::size_of::<ElementType>());
+
+#[repr(C)]
+struct Bits(u64);
+
+impl Bits {
+    fn to_bytes(&self) -> Bytes<usize> {
+        let bytes = ceiling_div(self.0, u8::BITS as u64);
+        Bytes(bytes as usize)
+    }
+}
+
+impl StableBigInt {
+    fn is_negative(main_object: *mut BigInt) -> bool {
+        unsafe { (*main_object).mp_int.sign != 0 }
+    }
+
+    fn serialized_length(main_object: *mut BigInt) -> Bits {
+        let used_elements = unsafe { (*main_object).mp_int.used } as usize;
+        if used_elements == 0 {
+            return Bits(0);
+        }
+        let last_element = unsafe { *main_object.payload_addr().add(used_elements - 1) };
+        debug_assert_ne!(last_element, 0);
+        debug_assert_eq!(last_element >> USED_BITS_PER_ELEMENT, 0);
+        let last_bits = ElementType::BITS - last_element.leading_zeros();
+        Bits((used_elements - 1) as u64 * USED_BITS_PER_ELEMENT as u64 + last_bits as u64)
+    }
+
+    fn deserialized_elements(&self) -> usize {
+        ceiling_div(self.number_of_bits.0, USED_BITS_PER_ELEMENT as u64) as usize
+    }
+}
+
+fn ceiling_div(dividend: u64, divisor: u64) -> u64 {
+    (dividend + divisor - 1) / divisor
+}
+
+impl StaticScanner<StableValue> for StableBigInt {}
+
+impl Serializer<BigInt> for StableBigInt {
+    unsafe fn serialize_static_part(
+        _stable_memory: &mut StableMemoryStream,
+        main_object: *mut BigInt,
+    ) -> Self {
+        let is_negative = Self::is_negative(main_object);
+        let number_of_bits = Self::serialized_length(main_object);
+        StableBigInt {
+            is_negative,
+            number_of_bits,
+        }
+    }
+
+    unsafe fn serialize_dynamic_part(
+        stable_memory: &mut StableMemoryStream,
+        main_object: *mut BigInt,
+    ) {
+        let total_elements = (*main_object).mp_int.used as usize;
+        let total_bytes = Self::serialized_length(main_object).to_bytes().as_usize();
+        let payload = main_object.payload_addr();
+        let mut written_bytes = 0;
+        let mut element_index = 0;
+        let mut element: ElementType = 0;
+        let mut pending_bits = 0;
+        let mut next_element: ElementType = 0;
+        let mut next_pending_bits = 0;
+
+        while written_bytes < total_bytes {
+            while pending_bits < ElementType::BITS && element_index < total_elements {
+                debug_assert_eq!(next_pending_bits, 0);
+                next_element = *payload.add(element_index);
+                element_index += 1;
+                debug_assert_eq!(next_element >> USED_BITS_PER_ELEMENT, 0);
+                element |= next_element << pending_bits;
+                let consumed_bits =
+                    core::cmp::min(USED_BITS_PER_ELEMENT, ElementType::BITS - pending_bits);
+                pending_bits += consumed_bits;
+                next_element >>= consumed_bits;
+                next_pending_bits = USED_BITS_PER_ELEMENT - consumed_bits;
+            }
+            stable_memory.write(&element); // little endian
+            written_bytes += ELEMENT_SIZE;
+            element = next_element;
+            pending_bits = next_pending_bits;
+            next_pending_bits = 0;
+        }
+        debug_assert!(pending_bits == 0 || element == 0);
+        debug_assert_eq!(element_index, total_elements);
+        debug_assert_eq!(written_bytes % core::mem::size_of::<u64>(), 0);
+    }
+
+    fn scan_serialized_dynamic<
+        'a,
+        M,
+        F: Fn(&mut SerializationContext<'a, M>, StableValue) -> StableValue,
+    >(
+        &self,
+        context: &mut SerializationContext<'a, M>,
+        _translate: &F,
+    ) {
+        let rounded_length = round_to_u64(self.number_of_bits.to_bytes().as_usize() as u64);
+        context
+            .serialization
+            .to_space()
+            .skip(rounded_length as usize);
+    }
+
+    unsafe fn allocate_deserialized<M: Memory>(
+        &self,
+        main_memory: &mut M,
+        object_kind: StableObjectKind,
+    ) -> Value {
+        debug_assert_eq!(object_kind, StableObjectKind::BigInt);
+        let elements = self.deserialized_elements();
+        let payload = mp_calloc(main_memory, elements, Bytes(ELEMENT_SIZE)) as *mut mp_digit;
+        let bigint = BigInt::from_payload(payload);
+        Value::from_ptr(bigint as usize)
+    }
+
+    unsafe fn deserialize_static_part(
+        &self,
+        target_bigint: *mut BigInt,
+        object_kind: StableObjectKind,
+    ) {
+        debug_assert_eq!(object_kind, StableObjectKind::BigInt);
+        debug_assert_eq!((*target_bigint).header.tag, TAG_BIGINT);
+        let elements = self.deserialized_elements();
+        debug_assert_eq!((*target_bigint).mp_int.alloc as usize, elements);
+        (*target_bigint).mp_int.sign = if self.is_negative { 1 } else { 0 };
+        (*target_bigint).mp_int.used = elements as i32;
+    }
+
+    unsafe fn deserialize_dynamic_part<M: Memory>(
+        &self,
+        _main_memory: &mut M,
+        stable_memory: &StableMemoryAccess,
+        stable_object: StableValue,
+        target_bigint: *mut BigInt,
+    ) {
+        let stable_address = stable_object.payload_address();
+        let source_payload =
+            stable_address + size_of::<StableBigInt>().to_bytes().as_usize() as u64;
+        let target_payload = target_bigint.payload_addr();
+        let total_bytes = self.number_of_bits.to_bytes().as_usize();
+        let total_elements = self.deserialized_elements();
+
+        let mut read_offset = 0;
+        let mut element_index = 0;
+        let mut element: ElementType = 0;
+        let mut pending_bits = 0;
+        let mut next_byte = 0;
+        let mut next_pending_bits = 0;
+
+        while element_index < total_elements {
+            while pending_bits < USED_BITS_PER_ELEMENT && read_offset < total_bytes {
+                debug_assert_eq!(next_pending_bits, 0);
+                next_byte = stable_memory.read::<u8>(source_payload + read_offset as u64);
+                read_offset += 1;
+                element |= (next_byte as ElementType) << pending_bits;
+                element &= (1 << USED_BITS_PER_ELEMENT) - 1;
+                let consumed_bits = core::cmp::min(u8::BITS, USED_BITS_PER_ELEMENT - pending_bits);
+                pending_bits += consumed_bits;
+                next_byte = if consumed_bits < u8::BITS {
+                    next_byte >> consumed_bits
+                } else {
+                    0
+                };
+                next_pending_bits = u8::BITS - consumed_bits;
+            }
+            *target_payload.add(element_index) = element; // little endian
+            element_index += 1;
+            element = next_byte as ElementType;
+            pending_bits = next_pending_bits;
+            next_pending_bits = 0;
+        }
+
+        debug_assert!(pending_bits == 0 || element == 0);
+        debug_assert_eq!(element_index, self.deserialized_elements());
+    }
+}
diff --git a/rts/motoko-rts/src/stabilization/layout/stable_bits64.rs b/rts/motoko-rts/src/stabilization/layout/stable_bits64.rs
new file mode 100644
index 00000000000..8f5ee03be70
--- /dev/null
+++ b/rts/motoko-rts/src/stabilization/layout/stable_bits64.rs
@@ -0,0 +1,45 @@
+use crate::{
+    stabilization::serialization::stable_memory_stream::StableMemoryStream,
+    types::{Bits64, Tag, Value, TAG_BITS64_F, TAG_BITS64_S, TAG_BITS64_U},
+};
+
+use super::{Serializer, StableObjectKind, StableValue, StaticScanner};
+
+#[repr(C)]
+pub struct StableBits64 {
+    bits: u64,
+}
+
+impl StaticScanner<StableValue> for StableBits64 {}
+
+impl Serializer<Bits64> for StableBits64 {
+    unsafe fn serialize_static_part(
+        _stable_memory: &mut StableMemoryStream,
+        main_object: *mut Bits64,
+    ) -> Self {
+        StableBits64 {
+            bits: (*main_object).bits as u64,
+        }
+    }
+
+    unsafe fn deserialize_static_part(
+        &self,
+        target_bits64: *mut Bits64,
+        object_kind: StableObjectKind,
+    ) {
+        (*target_bits64).header.tag = decode_bits64_tag(object_kind);
+        (*target_bits64)
+            .header
+            .init_forward(Value::from_ptr(target_bits64 as usize));
+        (*target_bits64).bits = self.bits;
+    }
+}
+
+fn decode_bits64_tag(object_kind: StableObjectKind) -> Tag {
+    match object_kind {
+        StableObjectKind::Bits64Unsigned => TAG_BITS64_U,
+        StableObjectKind::Bits64Signed => TAG_BITS64_S,
+        StableObjectKind::Bits64Float => TAG_BITS64_F,
+        _ => unreachable!("invalid stable boxed word 64 tag"),
+    }
+}
diff --git a/rts/motoko-rts/src/stabilization/layout/stable_blob.rs b/rts/motoko-rts/src/stabilization/layout/stable_blob.rs
new file mode 100644
index 00000000000..97620328e9e
--- /dev/null
+++ b/rts/motoko-rts/src/stabilization/layout/stable_blob.rs
@@ -0,0 +1,112 @@
+use crate::{
+    memory::{alloc_blob, Memory},
+    stabilization::{
+        deserialization::stable_memory_access::StableMemoryAccess,
+        serialization::{
+            stable_memory_stream::{ScanStream, StableMemoryStream, WriteStream},
+            SerializationContext,
+        },
+    },
+    types::{size_of, Blob, Bytes, Tag, Value, TAG_BLOB_A, TAG_BLOB_B, TAG_BLOB_P, TAG_BLOB_T},
+};
+
+use super::{
+    round_to_u64, write_padding_u64, Serializer, StableObjectKind, StableToSpace, StableValue,
+    StaticScanner,
+};
+
+#[repr(C)]
+#[derive(Default)]
+pub struct StableBlob {
+    byte_length: u64,
+    // Dynamically sized body with `byte_length` bytes. No pointers to be scanned.
+    // Zero padding to align to next `u64`.
+    // Note: The rounding of object sizes to at least 2 bytes is necessary for the skewed pointer representation.
+}
+
+impl StableBlob {
+    pub fn byte_length(&self) -> u64 {
+        self.byte_length
+    }
+}
+
+impl StaticScanner<StableValue> for StableBlob {}
+
+impl Serializer<Blob> for StableBlob {
+    unsafe fn serialize_static_part(
+        _stable_memory: &mut StableMemoryStream,
+        main_object: *mut Blob,
+    ) -> Self {
+        StableBlob {
+            byte_length: main_object.len().as_usize() as u64,
+        }
+    }
+
+    unsafe fn serialize_dynamic_part(
+        stable_memory: &mut StableMemoryStream,
+        main_object: *mut Blob,
+    ) {
+        let byte_length = main_object.len().as_usize();
+        stable_memory.raw_write(main_object.payload_addr() as usize, byte_length);
+        write_padding_u64(stable_memory, byte_length);
+    }
+
+    fn scan_serialized_dynamic<
+        'a,
+        M,
+        F: Fn(&mut SerializationContext<'a, M>, StableValue) -> StableValue,
+    >(
+        &self,
+        context: &mut SerializationContext<'a, M>,
+        _translate: &F,
+    ) {
+        let rounded_length = round_to_u64(self.byte_length);
+        context
+            .serialization
+            .to_space()
+            .skip(rounded_length as usize);
+    }
+
+    unsafe fn allocate_deserialized<M: Memory>(
+        &self,
+        main_memory: &mut M,
+        object_kind: StableObjectKind,
+    ) -> Value {
+        let blob_tag = decode_blob_tag(object_kind);
+        let blob_length = self.byte_length as usize;
+        alloc_blob(main_memory, blob_tag, Bytes(blob_length))
+    }
+
+    unsafe fn deserialize_static_part(
+        &self,
+        target_blob: *mut Blob,
+        object_kind: StableObjectKind,
+    ) {
+        debug_assert_eq!((*target_blob).header.tag, decode_blob_tag(object_kind));
+        debug_assert_eq!((*target_blob).len.as_usize(), self.byte_length as usize);
+    }
+
+    unsafe fn deserialize_dynamic_part<M: Memory>(
+        &self,
+        _main_memory: &mut M,
+        stable_memory: &StableMemoryAccess,
+        stable_object: StableValue,
+        target_blob: *mut Blob,
+    ) {
+        let stable_address = stable_object.payload_address();
+        let source_payload = stable_address + size_of::<StableBlob>().to_bytes().as_usize() as u64;
+        let target_payload = target_blob.payload_addr() as usize;
+        let blob_length = self.byte_length as usize;
+        stable_memory.raw_read(source_payload, target_payload, blob_length);
+    }
+}
+
+fn decode_blob_tag(object_kind: StableObjectKind) -> Tag {
+    match object_kind {
+        StableObjectKind::BlobBytes => TAG_BLOB_B,
+        StableObjectKind::BlobText => TAG_BLOB_T,
+        StableObjectKind::BlobPrincipal => TAG_BLOB_P,
+        StableObjectKind::BlobActor => TAG_BLOB_A,
+        _ => unreachable!("invalid stable blob tag"),
+    }
+}
diff --git a/rts/motoko-rts/src/stabilization/layout/stable_concat.rs b/rts/motoko-rts/src/stabilization/layout/stable_concat.rs
new file mode 100644
index 00000000000..1f31c02c209
--- /dev/null
+++ b/rts/motoko-rts/src/stabilization/layout/stable_concat.rs
@@ -0,0 +1,54 @@
+use crate::{
+    stabilization::serialization::stable_memory_stream::StableMemoryStream,
+    types::{Bytes, Concat, Value, TAG_CONCAT},
+};
+
+use super::{Serializer, StableObjectKind, StableValue, StaticScanner};
+
+#[repr(C)]
+pub struct StableConcat {
+    number_of_bytes: u64,
+    text1: StableValue,
+    text2: StableValue,
+}
+
+impl StaticScanner<StableValue> for StableConcat {
+    fn update_pointers<C, F: Fn(&mut C, StableValue) -> StableValue>(
+        &mut self,
+        context: &mut C,
+        translate: &F,
+    ) -> bool {
+        self.text1 = translate(context, self.text1);
+        self.text2 = translate(context, self.text2);
+        true
+    }
+}
+
+impl Serializer<Concat> for StableConcat {
+    unsafe fn serialize_static_part(
+        _stable_memory: &mut StableMemoryStream,
+        main_object: *mut Concat,
+    ) -> Self {
+        StableConcat {
+            number_of_bytes: (*main_object).n_bytes.as_usize() as u64,
+            text1: StableValue::serialize(main_object.text1()),
+            text2: StableValue::serialize(main_object.text2()),
+        }
+    }
+
+    unsafe fn deserialize_static_part(
+        &self,
+        target_concat: *mut Concat,
+        object_kind: StableObjectKind,
+    ) {
+        debug_assert_eq!(object_kind, StableObjectKind::Concat);
+        let n_bytes = Bytes(self.number_of_bytes as usize);
+        (*target_concat).header.tag = TAG_CONCAT;
+        (*target_concat)
+            .header
+            .init_forward(Value::from_ptr(target_concat as usize));
+        (*target_concat).n_bytes = n_bytes;
+        (*target_concat).text1 = self.text1.deserialize();
+        (*target_concat).text2 = self.text2.deserialize();
+    }
+}
diff --git a/rts/motoko-rts/src/stabilization/layout/stable_mutbox.rs b/rts/motoko-rts/src/stabilization/layout/stable_mutbox.rs
new file mode 100644
index 00000000000..e9b1f8f4160
--- /dev/null
+++ b/rts/motoko-rts/src/stabilization/layout/stable_mutbox.rs
@@ -0,0 +1,46 @@
+use crate::{
+    stabilization::serialization::stable_memory_stream::StableMemoryStream,
+    types::{MutBox, Value, TAG_MUTBOX},
+};
+
+use super::{Serializer, StableObjectKind, StableValue, StaticScanner};
+
+#[repr(C)]
+pub struct StableMutBox {
+    field: StableValue,
+}
+
+impl StaticScanner<StableValue> for StableMutBox {
+    fn update_pointers<C, F: Fn(&mut C, StableValue) -> StableValue>(
+        &mut self,
+        context: &mut C,
+        translate: &F,
+    ) -> bool {
+        self.field = translate(context, self.field);
+        true
+    }
+}
+
+impl Serializer<MutBox> for StableMutBox {
+    unsafe fn serialize_static_part(
+        _stable_memory: &mut StableMemoryStream,
+        main_object: *mut MutBox,
+    ) -> Self {
+        StableMutBox {
+            field: StableValue::serialize((*main_object).field),
+        }
+    }
+
+    unsafe fn deserialize_static_part(
+        &self,
+        target_mutbox: *mut MutBox,
+        object_kind: StableObjectKind,
+    ) {
+        debug_assert_eq!(object_kind, StableObjectKind::MutBox);
+        (*target_mutbox).header.tag = TAG_MUTBOX;
+        (*target_mutbox)
+            .header
+            .init_forward(Value::from_ptr(target_mutbox as usize));
+        (*target_mutbox).field = self.field.deserialize();
+    }
+}
diff --git a/rts/motoko-rts/src/stabilization/layout/stable_object.rs b/rts/motoko-rts/src/stabilization/layout/stable_object.rs
new file mode 100644
index 00000000000..94ec0c41910
--- /dev/null
+++ b/rts/motoko-rts/src/stabilization/layout/stable_object.rs
@@ -0,0 +1,145 @@
+use crate::{
+    memory::Memory,
+    stabilization::{
+        deserialization::stable_memory_access::StableMemoryAccess,
+        layout::{stable_blob::StableBlob, StableObjectKind},
+        serialization::{
+            stable_memory_stream::{ScanStream, StableMemoryStream, WriteStream},
+            SerializationContext,
+        },
+    },
+    types::{size_of, FwdPtr, Object, Tag, Value, Words, TAG_FWD_PTR, TAG_OBJECT},
+};
+
+use super::{Serializer, StableTag, StableToSpace, StableValue, StaticScanner};
+
+#[repr(C)]
+pub struct StableObject {
+    size: u64, // Number of fields.
+    hash_blob: StableValue, // Pointer to a blob containing the `u32` hashes of the field labels.
+               // Dynamically sized body with `size` fields, each of `StableValue`, ordered according to the hashes in the blob.
+}
+
+impl StaticScanner<StableValue> for StableObject {
+    fn update_pointers<C, F: Fn(&mut C, StableValue) -> StableValue>(
+        &mut self,
+        context: &mut C,
+        translate: &F,
+    ) -> bool {
+        self.hash_blob = translate(context, self.hash_blob);
+        true
+    }
+}
+
+impl Serializer<Object> for StableObject {
+    unsafe fn serialize_static_part(
+        stable_memory: &mut StableMemoryStream,
+        main_object: *mut Object,
+    ) -> Self {
+        StableObject {
+            size: get_object_size(stable_memory, main_object) as u64,
+            hash_blob: StableValue::serialize((*main_object).hash_blob),
+        }
+    }
+
+    unsafe fn serialize_dynamic_part(
+        stable_memory: &mut StableMemoryStream,
+        main_object: *mut Object,
+    ) {
+        let object_size = get_object_size(stable_memory, main_object);
+        for index in 0..object_size {
+            let main_field = main_object.get(index);
+            let stable_field = StableValue::serialize(main_field);
+            stable_memory.write(&stable_field);
+        }
+    }
+
+    fn scan_serialized_dynamic<
+        'a,
+        M,
+        F: Fn(&mut SerializationContext<'a, M>, StableValue) -> StableValue,
+    >(
+        &self,
+        context: &mut SerializationContext<'a, M>,
+        translate: &F,
+    ) {
+        for _ in 0..self.size {
+            let old_value = context.serialization.to_space().read::<StableValue>();
+            // On a longer term, the GC could remove unnecessary fields (during evacuation) that have been
+            // declared in old program versions but which name does no longer exist in a new program version.
+            let new_value = translate(context, old_value);
+            context.serialization.to_space().update(&new_value);
+        }
+    }
+
+    unsafe fn allocate_deserialized<M: Memory>(
+        &self,
+        main_memory: &mut M,
+        object_kind: StableObjectKind,
+    ) -> Value {
+        debug_assert_eq!(object_kind, StableObjectKind::Object);
+        let total_size = size_of::<Object>() + Words(self.size as usize);
+        main_memory.alloc_words(total_size)
+    }
+
+    unsafe fn deserialize_static_part(
+        &self,
+        target_object: *mut Object,
+        object_kind: StableObjectKind,
+    ) {
+        debug_assert_eq!(object_kind, StableObjectKind::Object);
+        (*target_object).header.tag = TAG_OBJECT;
+        (*target_object)
+            .header
+            .init_forward(Value::from_ptr(target_object as usize));
+        (*target_object).hash_blob = self.hash_blob.deserialize();
+    }
+
+    unsafe fn deserialize_dynamic_part<M: Memory>(
+        &self,
+        _main_memory: &mut M,
+        stable_memory: &StableMemoryAccess,
+        stable_object: StableValue,
+        target_object: *mut Object,
+    ) {
+        let stable_address = stable_object.payload_address();
+        for index in 0..self.size {
+            let field_address = stable_address
+                + size_of::<StableObject>().to_bytes().as_usize() as u64
+                + (index * size_of::<StableValue>().to_bytes().as_usize() as u64);
+            let field = stable_memory.read::<StableValue>(field_address);
+            let target_field_address = target_object.payload_addr().add(index as usize);
+            *target_field_address = field.deserialize();
+        }
+    }
+}
+
+#[repr(C)]
+struct HashBlob {
+    tag: StableTag,
+    header: StableBlob,
+}
+
+/// Resolve object size during serialization.
+/// This requires a look up in the hash blob, which may however already have been
+/// serialized to stable memory.
+fn get_object_size(stable_memory: &StableMemoryStream, main_object: *mut Object) -> usize {
+    // Do not call tag as it resolves the forwarding pointer.
+    unsafe {
+        let main_hash_blob = (*main_object).hash_blob;
+        let main_tag = *(main_hash_blob.get_ptr() as *const Tag);
+        if main_tag == TAG_FWD_PTR {
+            // The Hash blob has already been moved to stable memory.
+            let target_location = (*(main_hash_blob.get_ptr() as *mut FwdPtr)).fwd;
+            let stable_offset = target_location.get_ptr() as u64;
+            let stable_hash_blob = stable_memory.read_preceding::<HashBlob>(stable_offset);
+            assert!(stable_hash_blob.tag.decode() == StableObjectKind::BlobBytes);
+            let hash_blob_length = stable_hash_blob.header.byte_length() as usize;
+            let hash_entry_length = size_of::<u64>().to_bytes().as_usize();
+            debug_assert_eq!(hash_blob_length % hash_entry_length, 0);
+            hash_blob_length / hash_entry_length
+        } else {
+            main_object.size()
+        }
+    }
+}
diff --git a/rts/motoko-rts/src/stabilization/layout/stable_region.rs b/rts/motoko-rts/src/stabilization/layout/stable_region.rs
new file mode 100644
index 00000000000..661dae5b2ca
--- /dev/null
+++ b/rts/motoko-rts/src/stabilization/layout/stable_region.rs
@@ -0,0 +1,52 @@
+use crate::{
+    stabilization::serialization::stable_memory_stream::StableMemoryStream,
+    types::{Region, Value, TAG_REGION},
+};
+
+use super::{Serializer, StableObjectKind, StableValue, StaticScanner};
+
+#[repr(C)]
+pub struct StableRegion {
+    id: u64,
+    page_count: u64,
+    vec_pages: StableValue, // Blob of `u16`, each denoting a page ID.
+}
+
+impl StaticScanner<StableValue> for StableRegion {
+    fn update_pointers<C, F: Fn(&mut C, StableValue) -> StableValue>(
+        &mut self,
+        context: &mut C,
+        translate: &F,
+    ) -> bool {
+        self.vec_pages = translate(context, self.vec_pages);
+        true
+    }
+}
+
+impl Serializer<Region> for StableRegion {
+    unsafe fn serialize_static_part(
+        _stable_memory: &mut StableMemoryStream,
+        main_object: *mut Region,
+    ) -> Self {
+        StableRegion {
+            id: (*main_object).id as u64,
+            page_count: (*main_object).page_count as u64,
+            vec_pages: StableValue::serialize((*main_object).vec_pages),
+        }
+    }
+
+    unsafe fn deserialize_static_part(
+        &self,
+        target_region: *mut Region,
+        object_kind: StableObjectKind,
+    ) {
+        debug_assert_eq!(object_kind, StableObjectKind::Region);
+        (*target_region).header.tag = TAG_REGION;
+        (*target_region)
+            .header
+            .init_forward(Value::from_ptr(target_region as usize));
+        (*target_region).id = self.id;
+        (*target_region).page_count = self.page_count as usize;
+        (*target_region).vec_pages = self.vec_pages.deserialize();
+    }
+}
diff --git a/rts/motoko-rts/src/stabilization/layout/stable_some.rs b/rts/motoko-rts/src/stabilization/layout/stable_some.rs
new file mode 100644
index 00000000000..29b118037f7
--- /dev/null
+++ b/rts/motoko-rts/src/stabilization/layout/stable_some.rs
@@ -0,0 +1,46 @@
+use crate::{
+    stabilization::serialization::stable_memory_stream::StableMemoryStream,
+    types::{Some, Value, TAG_SOME},
+};
+
+use super::{Serializer, StableObjectKind, StableValue, StaticScanner};
+
+#[repr(C)]
+pub struct StableSome {
+    field: StableValue,
+}
+
+impl StaticScanner<StableValue> for StableSome {
+    fn update_pointers<C, F: Fn(&mut C, StableValue) -> StableValue>(
+        &mut self,
+        context: &mut C,
+        translate: &F,
+    ) -> bool {
+        self.field = translate(context, self.field);
+        true
+    }
+}
+
+impl Serializer<Some> for StableSome {
+    unsafe fn serialize_static_part(
+        _stable_memory: &mut StableMemoryStream,
+        main_object: *mut Some,
+    ) -> Self {
+        StableSome {
+            field: StableValue::serialize((*main_object).field),
+        }
+    }
+
+    unsafe fn deserialize_static_part(
+        &self,
+        target_some: *mut Some,
+        object_kind: StableObjectKind,
+    ) {
+        debug_assert_eq!(object_kind, StableObjectKind::Some);
+        (*target_some).header.tag = TAG_SOME;
+        (*target_some)
+            .header
+            .init_forward(Value::from_ptr(target_some as usize));
+        (*target_some).field = self.field.deserialize();
+    }
+}
diff --git a/rts/motoko-rts/src/stabilization/layout/stable_variant.rs b/rts/motoko-rts/src/stabilization/layout/stable_variant.rs
new file mode 100644
index 00000000000..1016d00e75c
--- /dev/null
+++ b/rts/motoko-rts/src/stabilization/layout/stable_variant.rs
@@ -0,0 +1,49 @@
+use crate::{
+    stabilization::serialization::stable_memory_stream::StableMemoryStream,
+    types::{Value, Variant, TAG_VARIANT},
+};
+
+use super::{Serializer, StableObjectKind, StableValue, StaticScanner};
+
+#[repr(C)]
+pub struct StableVariant {
+    tag: u64,
+    field: StableValue,
+}
+
+impl StaticScanner<StableValue> for StableVariant {
+    fn update_pointers<C, F: Fn(&mut C, StableValue) -> StableValue>(
+        &mut self,
+        context: &mut C,
+        translate: &F,
+    ) -> bool {
+        self.field = translate(context, self.field);
+        true
+    }
+}
+
+impl Serializer<Variant> for StableVariant {
+    unsafe fn serialize_static_part(
+        _stable_memory: &mut StableMemoryStream,
+        main_object: *mut Variant,
+    ) -> Self {
+        StableVariant {
+            tag: (*main_object).tag as u64,
+            field: StableValue::serialize((*main_object).field),
+        }
+    }
+
+    unsafe fn deserialize_static_part(
+        &self,
+        target_variant: *mut Variant,
+        object_kind: StableObjectKind,
+    ) {
+        debug_assert_eq!(object_kind, StableObjectKind::Variant);
+        (*target_variant).header.tag = TAG_VARIANT;
+        (*target_variant)
+            .header
+            .init_forward(Value::from_ptr(target_variant as usize));
+        (*target_variant).tag = self.tag as usize;
+        (*target_variant).field = self.field.deserialize();
+    }
+}
diff --git a/rts/motoko-rts/src/stabilization/serialization.rs b/rts/motoko-rts/src/stabilization/serialization.rs
new file mode 100644
index 00000000000..fcf23b75671
--- /dev/null
+++ b/rts/motoko-rts/src/stabilization/serialization.rs
@@ -0,0 +1,202 @@
+pub mod stable_memory_stream;
+
+use crate::{
+    memory::Memory,
+    stabilization::layout::serialize,
+    types::{FwdPtr, Tag, Value, TAG_CLOSURE, TAG_FWD_PTR},
+};
+
+use self::stable_memory_stream::{ScanStream, StableMemoryStream};
+
+use super::{
+    graph_copy::{limit::ExecutionMonitor, GraphCopy},
+    layout::{scan_serialized, StableToSpace, StableValue},
+    DUMMY_VALUE,
+};
+
+pub struct Serialization {
+    to_space: StableMemoryStream,
+    limit: ExecutionMonitor,
+    array_slice: Option<ArraySlice>,
+}
+
+pub struct ArraySlice {
+    pub next_index: u64,
+    pub array_length: u64,
+}
+
+impl ArraySlice {
+    pub fn new(index: u64, length: u64) -> ArraySlice {
+        ArraySlice {
+            next_index: index,
+            array_length: length,
+        }
+    }
+}
+
+/// Helper type to pass serialization context instead of closures.
+pub struct SerializationContext<'a, M> {
+    pub serialization: &'a mut Serialization,
+    pub mem: &'a mut M,
+}
+
+impl<'a, M> SerializationContext<'a, M> {
+    fn new(serialization: &'a mut Serialization, mem: &'a mut M) -> SerializationContext<'a, M> {
+        SerializationContext { serialization, mem }
+    }
+}
+
+/// Graph-copy-based serialization.
+/// Notes:
+/// - Invalidates the heap by replacing reachable stable object by forwarding objects:
+/// The heap is finally no longer usable by mutator or GC.
+/// - `copy` and partially also `scan` depends on the heap layout. Adjust these functions
+/// whenever the heap layout is changed.
+/// Usage:
+/// ```
+/// let serialization = Serialization::start(root, stable_start);
+/// while !serialization.is_completed() {
+///     serialization.copy_increment();
+/// }
+/// ```
+impl Serialization {
+    /// Start the graph-copy-based heap serialization from the stable `root` object
+    /// by writing the serialized data to the stable memory at offset `stable_start`.
+    /// The start is followed by a series of copy increments before the serialization is completed.
+    pub fn start<M: Memory>(mem: &mut M, root: Value, stable_start: u64) -> Serialization {
+        let to_space = StableMemoryStream::open(stable_start);
+        let limit = ExecutionMonitor::new();
+        let mut serialization = Serialization {
+            limit,
+            to_space,
+            array_slice: None,
+        };
+        serialization.start(mem, root);
+        serialization
+    }
+
+    pub fn serialized_data_start(&self) -> u64 {
+        self.to_space.base_address()
+    }
+
+    pub fn serialized_data_length(&self) -> u64 {
+        self.to_space.written_length()
+    }
+
+    /// Resolve the Brooks forwarding pointer of the incremental GC by considering potential
+    /// forwarding objects (`FwdPtr`) used in Cheney's algorithm for stabilization.
+    unsafe fn resolve_gc_forwarding(object: Value) -> Value {
+        let tag = Self::read_object_tag(object);
+        if tag == TAG_FWD_PTR {
+            object
+        } else {
+            object.forward()
+        }
+    }
+    /// Read the object tag by considering potential forwarding objects (`FwdPtr`).
+    unsafe fn read_object_tag(object: Value) -> Tag {
+        // Do not call `tag()` as it dereferences the Brooks forwarding pointer of the incremental GC,
+        // which does not exist for the forwarding objects (`FwdPtr`) used by the Cheney's algorithm.
+        *(object.get_ptr() as *const Tag)
+    }
+
+    fn has_non_stable_type(old_field: Value) -> bool {
+        unsafe { old_field.tag() == TAG_CLOSURE }
+    }
+
+    pub fn pending_array_scanning(&self) -> bool {
+        self.array_slice.is_some()
+    }
+
+    pub fn get_array_slice(&mut self) -> ArraySlice {
+        self.array_slice.take().unwrap()
+    }
+
+    pub fn set_array_slice(&mut self, slice: ArraySlice) {
+        self.array_slice = Some(slice);
+    }
+
+    fn processed_memory(&self) -> u64 {
+        self.to_space.written_length() + self.to_space.scanned_length()
+    }
+}
+
+impl GraphCopy<Value, StableValue, u32> for Serialization {
+    fn get_forward_address(&self, object: Value) -> Option<StableValue> {
+        unsafe {
+            let object = Self::resolve_gc_forwarding(object);
+            let tag = Self::read_object_tag(object);
+            match tag {
+                TAG_FWD_PTR => {
+                    let new_location = (*(object.get_ptr() as *mut FwdPtr)).fwd;
+                    Some(StableValue::serialize(new_location))
+                }
+                _ => None,
+            }
+        }
+    }
+
+    fn set_forward_address(&mut self, object: Value, target: StableValue) {
+        unsafe {
+            let object = Self::resolve_gc_forwarding(object);
+            debug_assert!(object.is_obj());
+            let fwd = object.get_ptr() as *mut FwdPtr;
+            (*fwd).tag = TAG_FWD_PTR;
+            (*fwd).fwd = target.deserialize();
+        }
+    }
+
+    fn copy<M: Memory>(&mut self, _mem: &mut M, object: Value) -> StableValue {
+        unsafe {
+            let object = Self::resolve_gc_forwarding(object);
+            debug_assert!(object.is_obj());
+            let address = self.to_space.written_length();
+            serialize(&mut self.to_space, object);
+            debug_assert!(self.to_space.written_length() >= address);
+            StableValue::from_stable_address(address)
+        }
+    }
+
+    fn scan<M: Memory>(&mut self, mem: &mut M) {
+        scan_serialized(
+            &mut SerializationContext::new(self, mem),
+            &|context, original| {
+                let old_value = original.deserialize();
+                if old_value.is_non_null_ptr() {
+                    if Self::has_non_stable_type(old_value) {
+                        // Due to structural subtyping or `Any`-subtyping, a non-stable object (such as a closure) may be
+                        // be dynamically reachable from a stable varibale. The value is not accessible in the new program version.
+                        // Therefore, the content of these fields can serialized with a dummy value that is also ignored by the GC.
+                        DUMMY_VALUE
+                    } else {
+                        context.serialization.evacuate(context.mem, old_value)
+                    }
+                } else {
+                    original
+                }
+            },
+        );
+    }
+
+    fn scanning_completed(&self) -> bool {
+        self.to_space.scan_completed()
+    }
+
+    fn complete(&mut self) {
+        self.to_space.close();
+    }
+
+    fn time_over(&mut self) -> bool {
+        self.limit.is_exceeded(self.processed_memory())
+    }
+
+    fn reset_time(&mut self) {
+        self.limit.reset(self.processed_memory());
+    }
+}
+
+impl StableToSpace for Serialization {
+    fn to_space(&mut self) -> &mut StableMemoryStream {
+        &mut self.to_space
+    }
+}
diff --git a/rts/motoko-rts/src/stabilization/serialization/stable_memory_stream.rs b/rts/motoko-rts/src/stabilization/serialization/stable_memory_stream.rs
new file mode 100644
index 00000000000..488fb8db989
--- /dev/null
+++ b/rts/motoko-rts/src/stabilization/serialization/stable_memory_stream.rs
@@ -0,0 +1,147 @@
+//! Streamed read/write access to stable memory.
+//! Supporting Cheney's to-space in stable memory.
+
+use core::mem::{size_of, MaybeUninit};
+
+use crate::{
+    stabilization::{
+        deserialization::stable_memory_access::StableMemoryAccess, grant_stable_space,
+    },
+    stable_mem::{ic0_stable64_read, ic0_stable64_write},
+};
+
+/// Streamed reader/writer on stable memory.
+/// Used for the to-space during stabilization.
+///
+/// The memory supports two location-independent streams:
+/// * Streamed reading and updating, used for scanning and patching pointers.
+/// * Streamed writing, used for allocating new objects.
+pub struct StableMemoryStream {
+    /// The pointers used in the serialized stable memory layout are
+    /// relative to this start address of the to-space.
+    base_address: u64,
+    /// Used for reading and updating.
+    scan_address: u64,
+    /// Used for writing.
+    free_address: u64,
+}
+
+pub trait ScanStream {
+    // Determines whether the stream has reached the end.
+    fn scan_completed(&self) -> bool;
+    // Read a value from the stream.
+    fn read<T>(&mut self) -> T;
+    // Read raw data from the stream.
+    fn raw_read(&mut self, data_address: usize, length: usize);
+    // Skip data in the stream.
+    fn skip(&mut self, length: usize);
+    // Overwrite the value right before the stream position.
+    fn update<T>(&mut self, value: &T);
+    // Overwrite raw data right before the stream position.
+    fn raw_update(&mut self, data_address: usize, length: usize);
+}
+
+pub trait WriteStream {
+    // Append a value at the stream end.
+    fn write<T>(&mut self, value: &T);
+    // Append raw data at the stream end.
+    fn raw_write(&mut self, data_address: usize, length: usize);
+}
+
+impl StableMemoryStream {
+    pub fn open(start_address: u64) -> StableMemoryStream {
+        StableMemoryStream {
+            base_address: start_address,
+            scan_address: start_address,
+            free_address: start_address,
+        }
+    }
+
+    pub fn close(&mut self) {
+        debug_assert!(self.scan_address <= self.free_address);
+    }
+
+    /// Start address of the serialized data in stable memory.
+    pub fn base_address(&self) -> u64 {
+        self.base_address
+    }
+
+    /// Size of this memory space. Also serves to determine the addresses of a subsequently
+    /// written object in the serialized stable memory format.
+    pub fn written_length(&self) -> u64 {
+        debug_assert!(self.base_address <= self.free_address);
+        self.free_address - self.base_address
+    }
+
+    pub fn scanned_length(&self) -> u64 {
+        debug_assert!(self.base_address <= self.scan_address);
+        self.scan_address - self.base_address
+    }
+
+    pub fn read_preceding<T>(&self, offset: u64) -> T {
+        let length = self.free_address - self.base_address;
+        let access = StableMemoryAccess::open(self.base_address, length);
+        access.read::<T>(offset)
+    }
+}
+
+impl ScanStream for StableMemoryStream {
+    fn scan_completed(&self) -> bool {
+        debug_assert!(self.scan_address <= self.free_address);
+        self.scan_address == self.free_address
+    }
+
+    fn read<T>(&mut self) -> T {
+        let length = size_of::<T>();
+        let mut value = unsafe { MaybeUninit::<T>::uninit().assume_init() };
+        let value_address = &mut value as *mut T as usize;
+        self.raw_read(value_address, length);
+        value
+    }
+
+    fn raw_read(&mut self, data_address: usize, length: usize) {
+        debug_assert!(self.scan_address + length as u64 <= self.free_address);
+        unsafe {
+            ic0_stable64_read(data_address as u64, self.scan_address, length as u64);
+        }
+        self.scan_address += length as u64;
+    }
+
+    fn skip(&mut self, length: usize) {
+        debug_assert!(self.scan_address + length as u64 <= self.free_address);
+        self.scan_address += length as u64;
+    }
+
+    fn update<T>(&mut self, value: &T) {
+        let length = size_of::<T>();
+        let value_address = value as *const T as usize;
+        self.raw_update(value_address, length);
+    }
+
+    fn raw_update(&mut self, data_address: usize, length: usize) {
+        debug_assert!(length as u64 <= self.scan_address);
+        unsafe {
+            ic0_stable64_write(
+                self.scan_address - length as u64,
+                data_address as u64,
+                length as u64,
+            );
+        }
+    }
+}
+
+impl WriteStream for StableMemoryStream {
+    fn write<T>(&mut self, value: &T) {
+        let length = size_of::<T>();
+        let value_address = value as *const T as usize;
+        self.raw_write(value_address, length);
+    }
+
+    fn raw_write(&mut self, data_address: usize, length: usize) {
+        unsafe {
+            grant_stable_space(self.free_address + length as u64);
+            ic0_stable64_write(self.free_address, data_address as u64, length as u64);
+        }
+        self.free_address += length as u64;
+    }
+}
diff --git a/rts/motoko-rts/src/stable_mem.rs b/rts/motoko-rts/src/stable_mem.rs
index 29dc5d04c3d..40480e6d80d 100644
--- a/rts/motoko-rts/src/stable_mem.rs
+++ b/rts/motoko-rts/src/stable_mem.rs
@@ -1,47 +1,71 @@
+#[cfg(feature = "ic")]
+use motoko_rts_macros::enhanced_orthogonal_persistence;
+
 pub const PAGE_SIZE: u64 = 64 * 1024;
 
 extern "C" {
     // physical ic0_stable64 operations re-exported by moc
     pub fn ic0_stable64_write(offset: u64, src: u64, size: u64);
     pub fn ic0_stable64_read(dst: u64, offset: u64, size: u64);
+    /// Physical memory size.
+    pub fn ic0_stable64_size() -> u64;
+    /// Grow the physiscal memory by ignoring the compiler-specified stable memory limit.
+    pub fn ic0_stable64_grow(additional_pages: u64) -> u64;
+
+    // (virtual) stable_mem operations implemented by moc
+    #[cfg(feature = "ic")]
+    pub fn moc_stable_mem_get_version() -> usize;
+    #[cfg(feature = "ic")]
+    pub fn moc_stable_mem_set_version(version: usize);
+    /// Virtual memory size.
+    #[cfg(feature = "ic")]
+    pub fn moc_stable_mem_get_size() -> u64;
+    /// Initialize the virtual memory size.
+    #[cfg(feature = "ic")]
+    pub fn moc_stable_mem_set_size(pages: u64);
+    /// Grow the virtual memory by respecting the compiler-specified virtual memory limit.
     #[cfg(feature = "ic")]
-    pub fn ic0_stable64_size() -> u64; // physical memory size
-                                       // (virtual) stable_mem operations implemented by moc
-    pub fn moc_stable_mem_get_version() -> u32;
-    pub fn moc_stable_mem_set_version(version: u32);
-    pub fn moc_stable_mem_size() -> u64;
     pub fn moc_stable_mem_grow(additional_pages: u64) -> u64;
 }
 
-pub fn get_version() -> u32 {
+#[cfg(feature = "ic")]
+pub fn get_version() -> usize {
     unsafe { moc_stable_mem_get_version() }
 }
 
-pub fn set_version(version: u32) {
+#[cfg(feature = "ic")]
+pub fn set_version(version: usize) {
     unsafe { moc_stable_mem_set_version(version) }
 }
 
+/// Virtual memory size.
+#[cfg(feature = "ic")]
 pub fn size() -> u64 {
     // SAFETY: This is safe because of the ic0 api guarantees.
-    unsafe { moc_stable_mem_size() }
+    unsafe { moc_stable_mem_get_size() }
 }
 
+/// Grow the virtual memory by respecting the compiler-specified stable memory limit.
+#[cfg(feature = "ic")]
 pub fn grow(pages: u64) -> u64 {
     // SAFETY: This is safe because of the ic0 api guarantees.
     unsafe { moc_stable_mem_grow(pages) }
 }
 
+#[cfg(feature = "ic")]
 pub fn read(offset: u64, dst: &mut [u8]) {
     // SAFETY: This is safe because of the ic0 api guarantees.
     unsafe { ic0_stable64_read(dst.as_ptr() as u64, offset, dst.len() as u64) }
 }
 
+#[cfg(feature = "ic")]
 pub fn write(offset: u64, src: &[u8]) {
     // SAFETY: This is safe because of the ic0 api guarantees.
     unsafe { ic0_stable64_write(offset, src.as_ptr() as u64, src.len() as u64) }
 }
 
 // Little endian.
+#[cfg(feature = "ic")]
 pub fn read_u8(offset: u64) -> u8 {
     let mut res: [u8; 1] = [0; 1];
     read(offset, &mut res);
@@ -49,11 +73,13 @@ pub fn read_u8(offset: u64) -> u8 {
 }
 
 // Little endian.
+#[cfg(feature = "ic")]
 pub fn write_u8(offset: u64, value: u8) {
     write(offset, &core::primitive::u8::to_le_bytes(value));
 }
 
 // Little endian.
+#[cfg(feature = "ic")]
 pub fn read_u16(offset: u64) -> u16 {
     let mut res: [u8; 2] = [0; 2];
     read(offset, &mut res);
@@ -61,11 +87,13 @@ pub fn read_u16(offset: u64) -> u16 {
 }
 
 // Little endian.
+#[cfg(feature = "ic")]
 pub fn write_u16(offset: u64, value: u16) {
     write(offset, &core::primitive::u16::to_le_bytes(value));
 }
 
 // Little endian.
+#[cfg(feature = "ic")]
 pub fn read_u32(offset: u64) -> u32 {
     let mut res: [u8; 4] = [0; 4];
     read(offset, &mut res);
@@ -73,11 +101,13 @@ pub fn read_u32(offset: u64) -> u32 {
 }
 
 // Little endian.
+#[cfg(feature = "ic")]
 pub fn write_u32(offset: u64, value: u32) {
     write(offset, &core::primitive::u32::to_le_bytes(value));
 }
 
 // Little endian.
+#[cfg(feature = "ic")]
 pub fn read_u64(offset: u64) -> u64 {
     let mut res: [u8; 8] = [0; 8];
     read(offset, &mut res);
@@ -85,13 +115,15 @@ pub fn read_u64(offset: u64) -> u64 {
 }
 
 // Little endian.
+#[cfg(feature = "ic")]
 pub fn write_u64(offset: u64, n: u64) {
     write(offset, &core::primitive::u64::to_le_bytes(n));
 }
 
 #[cfg(feature = "ic")]
 #[no_mangle]
-pub extern "C" fn read_persistence_version() -> u32 {
+#[enhanced_orthogonal_persistence]
+pub extern "C" fn read_persistence_version() -> usize {
     use crate::region::{LEGACY_VERSION_NO_STABLE_MEMORY, VERSION_STABLE_HEAP_NO_REGIONS};
 
     let physical_pages = unsafe { ic0_stable64_size() };
@@ -104,7 +136,8 @@ pub extern "C" fn read_persistence_version() -> u32 {
         // It stores non-zero marker at address 0 -> Legacy version 0.
         return LEGACY_VERSION_NO_STABLE_MEMORY;
     }
+    // Note: Do not use `types::size_of()` as it rounds to 64-bit words.
     let address = physical_pages * PAGE_SIZE - core::mem::size_of::<u32>() as u64;
     let version = read_u32(address);
-    version
+    version as usize
 }
diff --git a/rts/motoko-rts/src/static_checks.rs b/rts/motoko-rts/src/static_checks.rs
index 99f8f8ae5eb..0ba21302b4d 100644
--- a/rts/motoko-rts/src/static_checks.rs
+++ b/rts/motoko-rts/src/static_checks.rs
@@ -1,36 +1,67 @@
 //! Compile-time assertions to make sure object layouts are as expected
 
-use crate::constants::*;
-use crate::types::*;
+use motoko_rts_macros::{
+    classical_persistence, enhanced_orthogonal_persistence, incremental_gc, is_incremental_gc,
+    non_incremental_gc, uses_enhanced_orthogonal_persistence,
+};
+
+use crate::{constants::MAX_ARRAY_LENGTH_FOR_ITERATOR, types::*};
 
 use core::mem::{align_of, size_of};
 
 // `_` suppresses "unused X" warnings so we don't get any warnings for the code below, but they use
 // `WORD_SIZE` so we get an "unused constant WORD_SIZE" warning without `allow(unused)` here.
 #[allow(unused)]
-const WORD_SIZE: usize = crate::constants::WORD_SIZE as usize;
+const WORD_SIZE: usize = crate::constants::WORD_SIZE;
 
 #[allow(unused)]
+#[incremental_gc]
 const HEADER_SIZE: usize = 2 * WORD_SIZE;
 
+#[allow(unused)]
+#[non_incremental_gc]
+const HEADER_SIZE: usize = WORD_SIZE;
+
 // We cannot use `assert_eq` below as `assert_eq` is not const yet
 
 // Check platform word size
+#[enhanced_orthogonal_persistence]
+const _: () = assert!(size_of::<usize>() == size_of::<u64>());
+
+#[classical_persistence]
 const _: () = assert!(size_of::<usize>() == size_of::<u32>());
+
 const _: () = assert!(size_of::<usize>() == WORD_SIZE);
 
 // Check that sizes of structs are as expected by the compiler
 // (Expectations are all over the place, e.g. `header_size` definitions in `compile.ml`, calls to `static_closure`, etc.)
 const _: () = assert!(size_of::<Obj>() == HEADER_SIZE);
 const _: () = assert!(size_of::<Closure>() == HEADER_SIZE + 2 * WORD_SIZE);
+const _: () = assert!(size_of::<Array>() == HEADER_SIZE + 1 * WORD_SIZE);
 const _: () = assert!(size_of::<Blob>() == HEADER_SIZE + 1 * WORD_SIZE);
-const _: () = assert!(size_of::<BigInt>() == HEADER_SIZE + 4 * WORD_SIZE);
+
+const _: () = assert!(
+    size_of::<BigInt>()
+        == if uses_enhanced_orthogonal_persistence!() {
+            HEADER_SIZE + 3 * WORD_SIZE
+        } else {
+            HEADER_SIZE + 4 * WORD_SIZE
+        }
+); // Enhanced orthogonal persistence: Three 32-bit components, padding, followed by one 64-bit pointer in `mp_int`
+
 const _: () = assert!(size_of::<MutBox>() == HEADER_SIZE + 1 * WORD_SIZE);
 const _: () = assert!(size_of::<Some>() == HEADER_SIZE + 1 * WORD_SIZE);
 const _: () = assert!(size_of::<Variant>() == HEADER_SIZE + 2 * WORD_SIZE);
 const _: () = assert!(size_of::<Concat>() == HEADER_SIZE + 3 * WORD_SIZE);
-const _: () = assert!(size_of::<Bits32>() == HEADER_SIZE + 1 * WORD_SIZE);
-const _: () = assert!(size_of::<Bits64>() == HEADER_SIZE + 2 * WORD_SIZE);
+
+const _: () = assert!(
+    size_of::<Bits64>()
+        == if uses_enhanced_orthogonal_persistence!() {
+            HEADER_SIZE + 1 * WORD_SIZE
+        } else {
+            HEADER_SIZE + 2 * WORD_SIZE
+        }
+);
 
 // These aren't used generated by the compiler
 const _: () = assert!(size_of::<OneWordFiller>() == 1 * WORD_SIZE);
@@ -42,12 +73,12 @@ const _: () = assert!(size_of::<FwdPtr>() == 2 * WORD_SIZE);
 const _: () = assert!(align_of::<Obj>() == WORD_SIZE);
 const _: () = assert!(align_of::<Closure>() == WORD_SIZE);
 const _: () = assert!(align_of::<Blob>() == WORD_SIZE);
+const _: () = assert!(align_of::<Array>() == WORD_SIZE);
 const _: () = assert!(align_of::<BigInt>() == WORD_SIZE);
 const _: () = assert!(align_of::<MutBox>() == WORD_SIZE);
 const _: () = assert!(align_of::<Some>() == WORD_SIZE);
 const _: () = assert!(align_of::<Variant>() == WORD_SIZE);
 const _: () = assert!(align_of::<Concat>() == WORD_SIZE);
-const _: () = assert!(align_of::<Bits32>() == WORD_SIZE);
 const _: () = assert!(align_of::<Bits64>() == WORD_SIZE);
 const _: () = assert!(align_of::<OneWordFiller>() == WORD_SIZE);
 const _: () = assert!(align_of::<FreeSpace>() == WORD_SIZE);
@@ -59,4 +90,7 @@ const _: () =
     assert!(TAG_ARRAY_I < TAG_ARRAY_M && TAG_ARRAY_M < TAG_ARRAY_T && TAG_ARRAY_T < TAG_ARRAY_S);
 // 2-bits suffice to encode base array tag in slice, remaining bits suffice to encode slice start.
 const _: () = assert!((TAG_ARRAY_S - TAG_ARRAY_I) / 2 < 4);
-const _: () = assert!(MAX_ARRAY_SIZE < (1 << (usize::BITS - 2)));
+const _: () = assert!(MAX_ARRAY_LENGTH_FOR_ITERATOR < (1 << (usize::BITS - 2)));
+
+// Check that the incremental GC is used with enhanced orthogonal persistence.
+const _: () = assert!(!uses_enhanced_orthogonal_persistence!() || is_incremental_gc!());
diff --git a/rts/motoko-rts/src/stream.rs b/rts/motoko-rts/src/stream.rs
new file mode 100644
index 00000000000..b23620ca434
--- /dev/null
+++ b/rts/motoko-rts/src/stream.rs
@@ -0,0 +1,216 @@
+//! The implementation of streaming serialisation.
+//! Only used for 32-bit classical persistence.
+//!
+//! When serialising Motoko stable variables to stable memory we used to first completely
+//! fill up an in-heap buffer and then copy that wholesale into stable memory. This can be
+//! disadvantageous for two reasons:
+//!  - double copying
+//!  - heap congestion (especially for the compacting collector)
+//!
+//! Instead now we'll only allocate a small(ish) blob that will serve as a temporary storage
+//! for bytes in transit, while bigger chunks will flush this staging area before being written
+//! directly to destination.
+//!
+//!
+
+// Layout of a stream node (32-bit only):
+//
+// ┌────────────┬─────┬─────────┬───────┬─────────┬─────────┬───────────┬────────┬──────────┐
+// │ obj header │ len │ padding | ptr64 │ start64 │ limit64 │ outputter │ filled │ cache... │
+// └────────────┴─────┴─────────┴───────┴─────────┴─────────┴───────────┴────────┴──────────┘
+//
+// We reuse the opaque nature of blobs (to Motoko) and stick Rust-related information
+// into the leading bytes:
+// - `obj header` contains tag (BLOB) and forwarding pointer
+// - `len` is in blob metadata
+// - `ptr64`, `start64`, and `limit64` are each represented as two 32-bit components
+//    in little endian encoding.
+// - `ptr64` and `limit64` are the next and past-end pointers into stable memory
+// - `filled` and `cache` are the number of bytes consumed from the blob, and the
+//   staging area of the stream, respectively
+// - `outputter` is the function to be called when `len - filled` approaches zero.
+// - INVARIANT: keep `BlobStream.{ptr64_field, start64_field, filled_field}`,
+//              (from `compile.ml`) in sync with the layout!
+// - Note: `len` and `filled` are relative to the encompassing blob.
+
+use crate::barriers::allocation_barrier;
+use crate::bigint::{check, mp_get_u32, mp_isneg, mp_iszero};
+use crate::mem_utils::memcpy_bytes;
+use crate::memory::{alloc_blob, Memory};
+use crate::rts_trap_with;
+use crate::tommath_bindings::{mp_div_2d, mp_int};
+use crate::types::{size_of, Blob, Bytes, Stream, Value, TAG_BLOB_B};
+
+use motoko_rts_macros::ic_mem_fn;
+
+/// NOTE: The stream implementation assumes 32-bit memory and has not been ported to 64-bit.
+/// It is not used by enhanced orthogonal persistence.
+const _: () = assert!(usize::BITS == 32);
+
+const MAX_STREAM_SIZE: Bytes<usize> = Bytes((1 << 30) - 1);
+const INITIAL_STREAM_FILLED: Bytes<usize> = Bytes(32);
+const STREAM_CHUNK_SIZE: Bytes<usize> = Bytes(128);
+
+#[ic_mem_fn]
+pub unsafe fn alloc_stream<M: Memory>(mem: &mut M, size: Bytes<usize>) -> *mut Stream {
+    debug_assert_eq!(
+        INITIAL_STREAM_FILLED,
+        (size_of::<Stream>() - size_of::<Blob>()).to_bytes()
+    );
+    if size > MAX_STREAM_SIZE {
+        rts_trap_with("alloc_stream: Cache too large");
+    }
+    let ptr = alloc_blob(mem, TAG_BLOB_B, size + INITIAL_STREAM_FILLED);
+    let stream = ptr.as_stream();
+    stream.write_ptr64(0);
+    stream.write_start64(0);
+    stream.write_limit64(0);
+    (*stream).outputter = Stream::no_backing_store;
+    (*stream).filled = INITIAL_STREAM_FILLED;
+    allocation_barrier(ptr);
+    stream
+}
+
+#[allow(dead_code)]
+extern "C" {
+    // generated by `moc`
+    fn ic0_stable64_write(to: u64, ptr: u64, n: u64);
+}
+
+impl Stream {
+    #[inline]
+    pub unsafe fn cache_addr(self: *const Self) -> *const u8 {
+        self.add(1) as *const u8 // skip closure header
+    }
+
+    /// make sure that the cache is empty
+    fn flush(self: *mut Self) {
+        unsafe {
+            if (*self).filled > INITIAL_STREAM_FILLED {
+                ((*self).outputter)(
+                    self,
+                    self.cache_addr(),
+                    (*self).filled - INITIAL_STREAM_FILLED,
+                );
+                (*self).filled = INITIAL_STREAM_FILLED
+            }
+        }
+    }
+
+    fn no_backing_store(self: *mut Self, _ptr: *const u8, _n: Bytes<usize>) {
+        assert!(false)
+    }
+
+    #[cfg(feature = "ic")]
+    fn send_to_stable(self: *mut Self, ptr: *const u8, n: Bytes<usize>) {
+        unsafe {
+            let next_ptr64 = self.read_ptr64() + n.as_usize() as u64;
+            ic0_stable64_write(self.read_ptr64(), ptr as u64, n.as_usize() as u64);
+            self.write_ptr64(next_ptr64);
+        }
+    }
+
+    #[cfg(feature = "ic")]
+    /// Sets up the bottleneck routine to output towards a range of stable memory
+    /// Note: assumes that the entire byte range is writable
+    #[export_name = "stream_stable_dest"]
+    pub fn setup_stable_dest(self: *mut Self, start: u64, limit: u64) {
+        unsafe {
+            self.write_ptr64(start);
+            self.write_start64(start);
+            self.write_limit64(limit);
+            (*self).outputter = Self::send_to_stable;
+        }
+    }
+
+    /// Ingest a number of bytes into the stream.
+    #[export_name = "stream_write"]
+    pub fn cache_bytes(self: *mut Self, ptr: *const u8, n: Bytes<usize>) {
+        unsafe {
+            if self.read_limit64() != 0 && n > STREAM_CHUNK_SIZE
+                || (*self).filled + n > (*self).header.len
+            {
+                self.flush();
+                ((*self).outputter)(self, ptr, n);
+            } else {
+                let dest = self
+                    .as_blob_mut()
+                    .payload_addr()
+                    .add((*self).filled.as_usize());
+                (*self).filled += n;
+                assert!((*self).filled <= (*self).header.len);
+                memcpy_bytes(dest as usize, ptr as usize, n);
+            }
+        }
+    }
+
+    /// Ingest a single byte into the stream.
+    #[inline]
+    #[export_name = "stream_write_byte"]
+    pub fn cache_byte(self: *mut Self, byte: u8) {
+        unsafe {
+            if (*self).filled >= (*self).header.len {
+                self.flush()
+            }
+            self.as_blob_mut().set((*self).filled.as_usize(), byte);
+            (*self).filled += Bytes(1)
+        }
+    }
+
+    /// Return a pointer to a reserved area of the cache and advance the
+    /// fill indicator beyond it.
+    #[export_name = "stream_reserve"]
+    pub fn reserve(self: *mut Self, bytes: Bytes<usize>) -> *mut u8 {
+        unsafe {
+            if (*self).filled + bytes > (*self).header.len {
+                self.flush()
+            }
+            let ptr = self
+                .as_blob_mut()
+                .payload_addr()
+                .add((*self).filled.as_usize());
+            (*self).filled += bytes;
+            ptr
+        }
+    }
+
+    /// like `bigint_leb128_encode_go`, but to a stream
+    pub(crate) unsafe fn write_leb128(self: *mut Stream, tmp: *mut mp_int, add_bit: bool) {
+        debug_assert!(!mp_isneg(tmp));
+
+        loop {
+            let byte = mp_get_u32(tmp) as u8;
+            check(mp_div_2d(tmp, 7, tmp, core::ptr::null_mut()));
+            if !mp_iszero(tmp) || (add_bit && byte & (1 << 6) != 0) {
+                self.cache_byte(byte | (1 << 7));
+            } else {
+                return self.cache_byte(byte);
+            }
+        }
+    }
+
+    /// Split the stream object into two `Blob`s, a front-runner (small) one
+    /// and a latter one that comprises the current amount of the cached bytes.
+    /// Lengths are adjusted correspondingly.
+    #[export_name = "stream_split"]
+    pub unsafe fn split(self: *mut Self) -> Value {
+        if (*self).header.len > (*self).filled {
+            self.as_blob_mut().shrink((*self).filled);
+        }
+        (*self).header.len = INITIAL_STREAM_FILLED - size_of::<Blob>().to_bytes();
+        (*self).filled -= INITIAL_STREAM_FILLED;
+        let blob = (self.cache_addr() as *mut Blob).sub(1);
+        (*blob).header.tag = TAG_BLOB_B;
+        let ptr = Value::from_ptr(blob as usize);
+        (*blob).header.init_forward(ptr);
+        debug_assert_eq!(blob.len(), (*self).filled);
+        allocation_barrier(ptr)
+    }
+
+    /// Shut down the stream by outputting all data. Lengths are
+    /// adjusted correspondingly, and the stream remains intact.
+    #[export_name = "stream_shutdown"]
+    pub unsafe fn shutdown(self: *mut Self) {
+        self.flush()
+    }
+}
diff --git a/rts/motoko-rts/src/text.rs b/rts/motoko-rts/src/text.rs
index 2f089aa08c8..3d1750ec9c7 100644
--- a/rts/motoko-rts/src/text.rs
+++ b/rts/motoko-rts/src/text.rs
@@ -35,17 +35,23 @@ use crate::types::{size_of, Blob, Bytes, Concat, Value, TAG_BLOB_T, TAG_CONCAT};
 use alloc::string::String;
 use core::cmp::{min, Ordering};
 use core::{slice, str};
+use motoko_rts_macros::classical_persistence;
+
+use crate::libc_declarations::memcmp;
+
+#[classical_persistence]
+use crate::types::Stream;
 
 use motoko_rts_macros::ic_mem_fn;
 
-const MAX_STR_SIZE: Bytes<u32> = Bytes((1 << 30) - 1);
+const MAX_STR_SIZE: Bytes<usize> = Bytes((1 << (usize::BITS - 2)) - 1);
 
 // Strings smaller than this must be blobs
 // Make this MAX_STR_SIZE to disable the use of ropes completely, e.g. for debugging
-const MIN_CONCAT_SIZE: Bytes<u32> = Bytes(9);
+const MIN_CONCAT_SIZE: Bytes<usize> = Bytes(9);
 
 // Note: Post allocation barrier needs to be applied after initilization.
-unsafe fn alloc_text_blob<M: Memory>(mem: &mut M, size: Bytes<u32>) -> Value {
+unsafe fn alloc_text_blob<M: Memory>(mem: &mut M, size: Bytes<usize>) -> Value {
     if size > MAX_STR_SIZE {
         rts_trap_with("alloc_text_blob: Text too large");
     }
@@ -53,7 +59,7 @@ unsafe fn alloc_text_blob<M: Memory>(mem: &mut M, size: Bytes<u32>) -> Value {
 }
 
 #[ic_mem_fn]
-pub unsafe fn text_of_ptr_size<M: Memory>(mem: &mut M, buf: *const u8, n: Bytes<u32>) -> Value {
+pub unsafe fn text_of_ptr_size<M: Memory>(mem: &mut M, buf: *const u8, n: Bytes<usize>) -> Value {
     let blob = alloc_text_blob(mem, n);
     let payload_addr = blob.as_blob_mut().payload_addr();
     memcpy_bytes(payload_addr as usize, buf as usize, n);
@@ -61,7 +67,7 @@ pub unsafe fn text_of_ptr_size<M: Memory>(mem: &mut M, buf: *const u8, n: Bytes<
 }
 
 pub unsafe fn text_of_str<M: Memory>(mem: &mut M, s: &str) -> Value {
-    text_of_ptr_size(mem, s.as_ptr(), Bytes(s.len() as u32))
+    text_of_ptr_size(mem, s.as_ptr(), Bytes(s.len()))
 }
 
 #[ic_mem_fn]
@@ -152,7 +158,7 @@ unsafe extern "C" fn text_to_buf(mut s: Value, mut buf: *mut u8) {
             let s1_len = text_size(s1);
             let s2_len = text_size(s2);
 
-            if s2_len < Bytes(core::mem::size_of::<Crumb>() as u32) {
+            if s2_len < Bytes(core::mem::size_of::<Crumb>()) {
                 // If second string is smaller than size of a crumb just do it directly
                 text_to_buf(s2, buf.add(s1_len.as_usize()));
                 s = s1;
@@ -168,6 +174,24 @@ unsafe extern "C" fn text_to_buf(mut s: Value, mut buf: *mut u8) {
     }
 }
 
+#[no_mangle]
+#[classical_persistence]
+unsafe extern "C" fn stream_write_text(stream: *mut Stream, mut s: Value) {
+    use crate::types::TAG_BLOB_B;
+    loop {
+        let s_ptr = s.as_obj();
+        if s_ptr.tag() == TAG_BLOB_B || s_ptr.tag() == TAG_BLOB_T {
+            let blob = s_ptr.as_blob();
+            stream.cache_bytes(blob.payload_addr(), blob.len());
+            break;
+        } else {
+            let concat = s_ptr.as_concat();
+            stream_write_text(stream, concat.text1());
+            s = concat.text2()
+        }
+    }
+}
+
 // Straighten into contiguous memory, if needed (e.g. for system calls)
 #[ic_mem_fn]
 pub unsafe fn blob_of_text<M: Memory>(mem: &mut M, s: Value) -> Value {
@@ -184,7 +208,7 @@ pub unsafe fn blob_of_text<M: Memory>(mem: &mut M, s: Value) -> Value {
 
 /// Size of the text, in bytes
 #[no_mangle]
-pub unsafe extern "C" fn text_size(s: Value) -> Bytes<u32> {
+pub unsafe extern "C" fn text_size(s: Value) -> Bytes<usize> {
     // We don't know whether the string is a blob or concat, but both types have the length in same
     // location so using any of the types to get the length is fine
     // NB. We can't use `s.as_blob()` here as that method checks the tag in debug mode
@@ -195,10 +219,10 @@ pub unsafe extern "C" fn text_size(s: Value) -> Bytes<u32> {
 /// Compares texts from given offset on for the given number of bytes. All assumed to be in range.
 unsafe fn text_compare_range(
     s1: Value,
-    offset1: Bytes<u32>,
+    offset1: Bytes<usize>,
     s2: Value,
-    offset2: Bytes<u32>,
-    n: Bytes<u32>,
+    offset2: Bytes<usize>,
+    n: Bytes<usize>,
 ) -> Ordering {
     // Follow the left/right strings of concat nodes until we reach to blobs or concats that cannot
     // be split further (the range spans left and right strings)
@@ -244,7 +268,7 @@ unsafe fn text_compare_range(
         let s1_blob = s1_obj.as_blob();
         let s2_blob = s2_obj.as_blob();
 
-        let cmp = libc::memcmp(
+        let cmp = memcmp(
             s1_blob.payload_addr().add(offset1.as_usize()) as *const _,
             s2_blob.payload_addr().add(offset2.as_usize()) as *const _,
             n.as_usize(),
@@ -264,9 +288,9 @@ unsafe fn text_compare_range(
 /// split further (i.e. range spans left and right nodes). Returns a BLOB or CONCAT.
 unsafe fn text_get_range(
     mut s: Value,
-    mut offset: Bytes<u32>,
-    n: Bytes<u32>,
-) -> (Value, Bytes<u32>) {
+    mut offset: Bytes<usize>,
+    n: Bytes<usize>,
+) -> (Value, Bytes<usize>) {
     loop {
         let s_obj = s.as_obj();
 
@@ -299,7 +323,7 @@ unsafe fn text_get_range(
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn text_compare(s1: Value, s2: Value) -> i32 {
+pub unsafe extern "C" fn text_compare(s1: Value, s2: Value) -> isize {
     let n1 = text_size(s1);
     let n2 = text_size(s2);
     let n = min(n1, n2);
@@ -320,14 +344,14 @@ pub unsafe extern "C" fn text_compare(s1: Value, s2: Value) -> i32 {
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn blob_compare(s1: Value, s2: Value) -> i32 {
+pub unsafe extern "C" fn blob_compare(s1: Value, s2: Value) -> isize {
     let n1 = text_size(s1);
     let n2 = text_size(s2);
     let n = min(n1, n2);
 
     let payload1 = s1.as_blob().payload_const();
     let payload2 = s2.as_blob().payload_const();
-    let cmp = libc::memcmp(payload1 as *const _, payload2 as *const _, n.as_usize());
+    let cmp = memcmp(payload1 as *const _, payload2 as *const _, n.as_usize()) as isize;
 
     if cmp == 0 {
         if n1 < n2 {
@@ -344,7 +368,7 @@ pub unsafe extern "C" fn blob_compare(s1: Value, s2: Value) -> i32 {
 
 /// Length in characters
 #[no_mangle]
-pub unsafe extern "C" fn text_len(text: Value) -> u32 {
+pub unsafe extern "C" fn text_len(text: Value) -> usize {
     if text.tag() == TAG_BLOB_T {
         let blob = text.as_blob();
         let payload_addr = blob.payload_const();
@@ -355,7 +379,7 @@ pub unsafe extern "C" fn text_len(text: Value) -> u32 {
             len.as_usize(),
         ))
         .chars()
-        .count() as u32
+        .count()
     } else {
         let concat = text.as_concat();
         text_len(concat.text1()) + text_len(concat.text2())
@@ -363,14 +387,14 @@ pub unsafe extern "C" fn text_len(text: Value) -> u32 {
 }
 
 /// Decodes the character at the pointer. Returns the character, the size via the `size` parameter
-pub unsafe fn decode_code_point(s: *const u8, size: *mut u32) -> u32 {
+pub unsafe fn decode_code_point(s: *const u8, size: *mut usize) -> u32 {
     // 0xxxxxxx
     // 110xxxxx 10xxxxxx
     // 1110xxxx 10xxxxxx 10xxxxxx
     // 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
 
     let (size, mut value) = {
-        let leading_ones = (*s).leading_ones();
+        let leading_ones = (*s).leading_ones() as usize;
         if leading_ones == 0 {
             *size = 1;
             return *s as u32;
@@ -382,24 +406,24 @@ pub unsafe fn decode_code_point(s: *const u8, size: *mut u32) -> u32 {
 
     for i in 1..size {
         value <<= 6;
-        value += ((*s.add(i as usize)) & 0b00111111) as u32;
+        value += ((*s.add(i)) & 0b00111111) as u32;
     }
 
-    value
+    value as u32
 }
 
 /// Allocate a text from a character
 #[ic_mem_fn]
 pub unsafe fn text_singleton<M: Memory>(mem: &mut M, char: u32) -> Value {
     let mut buf = [0u8; 4];
-    let str_len = char::from_u32_unchecked(char).encode_utf8(&mut buf).len() as u32;
+    let str_len = char::from_u32_unchecked(char).encode_utf8(&mut buf).len();
 
     let blob_ptr = alloc_text_blob(mem, Bytes(str_len));
 
     let blob = blob_ptr.as_blob_mut();
 
     for i in 0..str_len {
-        blob.set(i, buf[i as usize]);
+        blob.set(i, buf[i]);
     }
 
     allocation_barrier(blob_ptr)
@@ -429,7 +453,7 @@ where
     ));
     let string = to_string(&str);
     let bytes = string.as_bytes();
-    let lowercase = alloc_blob(mem, TAG_BLOB_T, Bytes(bytes.len() as u32));
+    let lowercase = alloc_blob(mem, TAG_BLOB_T, Bytes(bytes.len()));
     let mut i = 0;
     let target_ptr = lowercase.as_blob_mut().payload_addr();
     for b in bytes {
diff --git a/rts/motoko-rts/src/text_iter.rs b/rts/motoko-rts/src/text_iter.rs
index 3f51f68fb1d..d7b4acdab8d 100644
--- a/rts/motoko-rts/src/text_iter.rs
+++ b/rts/motoko-rts/src/text_iter.rs
@@ -18,8 +18,8 @@ use crate::types::{Value, TAG_ARRAY_T, TAG_BLOB_T, TAG_CONCAT};
 
 use motoko_rts_macros::ic_mem_fn;
 
-const TODO_TEXT_IDX: u32 = 0;
-const TODO_LINK_IDX: u32 = 1;
+const TODO_TEXT_IDX: usize = 0;
+const TODO_LINK_IDX: usize = 1;
 
 /// Find the left-most leaf of a text, putting all the others onto a list. Used to enforce the
 /// invariant about TEXT_ITER_BLOB to be a blob.
@@ -44,9 +44,9 @@ unsafe fn find_leaf<M: Memory>(mem: &mut M, mut text: Value, todo: *mut Value) -
     text
 }
 
-const ITER_BLOB_IDX: u32 = 0;
-const ITER_POS_IDX: u32 = 1;
-const ITER_TODO_IDX: u32 = 2;
+const ITER_BLOB_IDX: usize = 0;
+const ITER_POS_IDX: usize = 1;
+const ITER_TODO_IDX: usize = 2;
 
 // Use non-pointer sentinel value as `null` to allow simpler visitor logic.
 // Anlogous to the design of `continuation_table` and `persistence`.
@@ -59,7 +59,7 @@ pub unsafe fn text_iter<M: Memory>(mem: &mut M, text: Value) -> Value {
     let array = iter.as_array();
 
     // Initialize the TODO field first, to be able to use it use the location to `find_leaf`
-    let todo_addr = array.payload_addr().add(ITER_TODO_IDX as usize) as *mut _;
+    let todo_addr = array.payload_addr().add(ITER_TODO_IDX) as *mut _;
     *todo_addr = NO_OBJECT;
 
     // Initialize position field
@@ -76,13 +76,13 @@ pub unsafe fn text_iter<M: Memory>(mem: &mut M, text: Value) -> Value {
 
 /// Returns whether the iterator is finished
 #[no_mangle]
-pub unsafe extern "C" fn text_iter_done(iter: Value) -> u32 {
+pub unsafe extern "C" fn text_iter_done(iter: Value) -> usize {
     let array = iter.as_array();
     let pos = array.get(ITER_POS_IDX).get_scalar();
     let blob = array.get(ITER_BLOB_IDX).as_blob();
     let todo = array.get(ITER_TODO_IDX);
 
-    if pos >= blob.len().as_u32() && todo == NO_OBJECT {
+    if pos >= blob.len().as_usize() && todo == NO_OBJECT {
         1
     } else {
         0
@@ -98,7 +98,7 @@ pub unsafe fn text_iter_next<M: Memory>(mem: &mut M, iter: Value) -> u32 {
     let pos = iter_array.get(ITER_POS_IDX).get_scalar();
 
     // If we are at the end of the current blob, find the next blob
-    if pos >= blob.len().as_u32() {
+    if pos >= blob.len().as_usize() {
         let todo = iter_array.get(ITER_TODO_IDX);
 
         if todo == NO_OBJECT {
@@ -117,7 +117,7 @@ pub unsafe fn text_iter_next<M: Memory>(mem: &mut M, iter: Value) -> u32 {
 
             todo_array.set(TODO_TEXT_IDX, (*concat).text2, mem);
             iter_array.set(ITER_POS_IDX, Value::from_scalar(0), mem);
-            let todo_addr = iter_array.payload_addr().add(ITER_TODO_IDX as usize);
+            let todo_addr = iter_array.payload_addr().add(ITER_TODO_IDX);
 
             iter_array.set(
                 ITER_BLOB_IDX,
@@ -140,8 +140,8 @@ pub unsafe fn text_iter_next<M: Memory>(mem: &mut M, iter: Value) -> u32 {
     } else {
         // We are not at the end, read the next character from the blob
         let blob_payload = blob.payload_const();
-        let mut step: u32 = 0;
-        let char = decode_code_point(blob_payload.add(pos as usize), &mut step as *mut u32);
+        let mut step = 0;
+        let char = decode_code_point(blob_payload.add(pos), &mut step as *mut usize);
         iter_array.set(ITER_POS_IDX, Value::from_scalar(pos + step), mem);
         char
     }
diff --git a/rts/motoko-rts/src/tommath_bindings.rs b/rts/motoko-rts/src/tommath_bindings.rs
index 705acbf9739..bb723c19d53 100644
--- a/rts/motoko-rts/src/tommath_bindings.rs
+++ b/rts/motoko-rts/src/tommath_bindings.rs
@@ -1,2 +1,9 @@
 #![allow(unused, non_camel_case_types)]
-include!("../../_build/tommath_bindings.rs");
+
+use motoko_rts_macros::{classical_persistence, enhanced_orthogonal_persistence};
+
+#[classical_persistence]
+include!("../../_build/wasm32/tommath_bindings.rs");
+
+#[enhanced_orthogonal_persistence]
+include!("../../_build/wasm64/tommath_bindings.rs");
diff --git a/rts/motoko-rts/src/types.rs b/rts/motoko-rts/src/types.rs
index 2fc260650e1..929694c63e3 100644
--- a/rts/motoko-rts/src/types.rs
+++ b/rts/motoko-rts/src/types.rs
@@ -19,35 +19,38 @@
 // [1]: https://github.com/rust-lang/reference/blob/master/src/types/struct.md
 // [2]: https://doc.rust-lang.org/stable/reference/type-layout.html#the-c-representation
 
+use motoko_rts_macros::{
+    classical_persistence, enhanced_orthogonal_persistence, incremental_gc, is_incremental_gc,
+    non_incremental_gc,
+};
+
 use crate::barriers::{init_with_barrier, write_with_barrier};
 use crate::memory::Memory;
 use crate::tommath_bindings::{mp_digit, mp_int};
 use core::ops::{Add, AddAssign, Div, Mul, Sub, SubAssign};
 use core::ptr::null;
 
-use crate::constants::{MAX_ARRAY_SIZE, WORD_SIZE};
+use crate::constants::{MAX_ARRAY_LENGTH_FOR_ITERATOR, WORD_SIZE};
 use crate::rts_trap_with;
 
-pub fn size_of<T>() -> Words<u32> {
-    Bytes(::core::mem::size_of::<T>() as u32).to_words()
+pub fn size_of<T>() -> Words<usize> {
+    Bytes(::core::mem::size_of::<T>()).to_words()
 }
 
-/// The unit "words": `Words(123u32)` means 123 words.
+// TODO: Refactor by removing the generic type from `Words` and `Bytes`.
+
+/// The unit "words": `Words(123)` means 123 words.
 #[repr(transparent)]
 #[derive(PartialEq, Eq, Clone, Copy, PartialOrd, Ord)]
 pub struct Words<A>(pub A);
 
-impl Words<u32> {
-    pub fn to_bytes(self) -> Bytes<u32> {
+impl Words<usize> {
+    pub fn to_bytes(self) -> Bytes<usize> {
         Bytes(self.0 * WORD_SIZE)
     }
 
-    pub fn as_u32(self) -> u32 {
-        self.0
-    }
-
     pub fn as_usize(self) -> usize {
-        self.0 as usize
+        self.0
     }
 }
 
@@ -95,30 +98,31 @@ impl<A: SubAssign> SubAssign for Words<A> {
     }
 }
 
-impl From<Bytes<u32>> for Words<u32> {
-    fn from(bytes: Bytes<u32>) -> Words<u32> {
+impl From<Bytes<usize>> for Words<usize> {
+    fn from(bytes: Bytes<usize>) -> Words<usize> {
         bytes.to_words()
     }
 }
 
-/// The unit "bytes": `Bytes(123u32)` means 123 bytes.
+/// The unit "bytes": `Bytes(123)` means 123 bytes.
 #[repr(transparent)]
 #[derive(Debug, PartialEq, Eq, Clone, Copy, PartialOrd, Ord)]
 pub struct Bytes<A>(pub A);
 
-impl Bytes<u32> {
+impl Bytes<usize> {
     // Rounds up
-    pub fn to_words(self) -> Words<u32> {
+    pub fn to_words(self) -> Words<usize> {
         // Rust issue for adding ceiling_div: https://github.com/rust-lang/rfcs/issues/2844
         Words((self.0 + WORD_SIZE - 1) / WORD_SIZE)
     }
 
-    pub fn as_u32(self) -> u32 {
+    pub const fn as_usize(self) -> usize {
         self.0
     }
 
-    pub fn as_usize(self) -> usize {
-        self.0 as usize
+    /// Rust `next_multiple_of` is unstable, see https://github.com/rust-lang/rust/issues/88581.
+    pub fn next_multiple_of(self, multiple: usize) -> Self {
+        Bytes((self.0 + multiple - 1) / multiple * multiple)
     }
 }
 
@@ -150,24 +154,25 @@ impl<A: SubAssign> SubAssign for Bytes<A> {
     }
 }
 
-impl From<Words<u32>> for Bytes<u32> {
-    fn from(words: Words<u32>) -> Bytes<u32> {
+impl From<Words<usize>> for Bytes<usize> {
+    fn from(words: Words<usize>) -> Bytes<usize> {
         words.to_bytes()
     }
 }
 
 // The `true` value. The only scalar value that has the lowest bit set.
-pub const TRUE_VALUE: u32 = 0x1;
+pub const TRUE_VALUE: usize = 0x1;
 
 /// Constant sentinel pointer value for fast null tests.
 /// Points to the last unallocated Wasm page.
 /// See also `compile.ml` for other reserved sentinel values.
-pub const NULL_POINTER: Value = Value::from_raw(0xffff_fffb);
+#[enhanced_orthogonal_persistence]
+pub const NULL_POINTER: Value = Value::from_raw(0xffff_ffff_ffff_fffb);
 
 /// A value in a heap slot
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
-pub struct Value(u32);
+pub struct Value(usize);
 
 /// A view of `Value` for analyzing the slot contents.
 pub enum PtrOrScalar {
@@ -175,7 +180,7 @@ pub enum PtrOrScalar {
     Ptr(usize),
 
     /// Slot is an unboxed scalar value
-    Scalar(u32),
+    Scalar(usize),
 }
 
 impl PtrOrScalar {
@@ -193,26 +198,26 @@ impl Value {
     pub const fn from_ptr(ptr: usize) -> Self {
         // Cannot use `debug_assert_eq` in const yet, so using `debug_assert`
         debug_assert!(ptr & 0b1 == 0b0);
-        Value(skew(ptr) as u32)
+        Value(skew(ptr))
     }
 
     /// Create a value from a scalar
-    pub const fn from_scalar(value: u32) -> Self {
+    pub const fn from_scalar(value: usize) -> Self {
         // Cannot use `debug_assert_eq` in const yet, so using `debug_assert`
-        debug_assert!(value >> 31 == 0);
+        debug_assert!(value >> (usize::BITS - 1) == 0);
         Value(value << 1)
     }
 
     /// Create a value from a signed scalar. The scalar must be obtained with `get_signed_scalar`.
     /// Using `get_scalar` will return an incorrect scalar.
-    pub fn from_signed_scalar(value: i32) -> Self {
+    pub fn from_signed_scalar(value: isize) -> Self {
         debug_assert_eq!(value, value << 1 >> 1);
-        Value((value << 1) as u32)
+        Value((value << 1) as usize)
     }
 
     /// Create a value from raw representation. Useful when e.g. temporarily writing invalid values
     /// to object fields in garbage collection.
-    pub const fn from_raw(raw: u32) -> Self {
+    pub const fn from_raw(raw: usize) -> Self {
         Value(raw)
     }
 
@@ -225,7 +230,7 @@ impl Value {
     /// cycle.
     pub fn get(&self) -> PtrOrScalar {
         if is_ptr(self.0) {
-            PtrOrScalar::Ptr(unskew(self.0 as usize))
+            PtrOrScalar::Ptr(unskew(self.0))
         } else {
             PtrOrScalar::Scalar(self.0 >> 1)
         }
@@ -233,7 +238,7 @@ impl Value {
 
     /// Get the raw value
     #[inline]
-    pub fn get_raw(&self) -> u32 {
+    pub const fn get_raw(&self) -> usize {
         self.0
     }
 
@@ -242,56 +247,72 @@ impl Value {
         self.get().is_scalar()
     }
 
+    /// Is the value a pointer?
+    #[classical_persistence]
+    pub fn is_ptr(&self) -> bool {
+        self.get().is_ptr()
+    }
+
     /// Is the value a non-null pointer?
+    #[enhanced_orthogonal_persistence]
     pub fn is_non_null_ptr(&self) -> bool {
         self.get().is_ptr() && *self != NULL_POINTER
     }
 
     /// Assumes that the value is a scalar and returns the scalar value. In debug mode panics if
     /// the value is not a scalar.
-    pub fn get_scalar(&self) -> u32 {
+    pub fn get_scalar(&self) -> usize {
         debug_assert!(self.get().is_scalar());
         self.0 >> 1
     }
 
     /// Assumes that the value is a signed scalar and returns the scalar value. In debug mode
     /// panics if the value is not a scalar.
-    pub fn get_signed_scalar(&self) -> i32 {
+    pub fn get_signed_scalar(&self) -> isize {
         debug_assert!(self.get().is_scalar());
-        self.0 as i32 >> 1
+        self.0 as isize >> 1
     }
 
     /// Assumes that the value is a pointer and returns the pointer value. In debug mode panics if
     /// the value is not a pointer.
     pub fn get_ptr(self) -> usize {
         debug_assert!(self.get().is_ptr());
-        unskew(self.0 as usize)
+        unskew(self.0)
     }
 
     /// Check that the forwarding pointer is valid.
     #[inline]
     pub unsafe fn check_forwarding_pointer(self) {
-        debug_assert!(
-            self.forward().get_ptr() == self.get_ptr()
-                || self.forward().forward().get_ptr() == self.forward().get_ptr()
-        );
+        if is_incremental_gc!() {
+            debug_assert!(
+                self.forward().get_ptr() == self.get_ptr()
+                    || self.forward().forward().get_ptr() == self.forward().get_ptr()
+            );
+        }
     }
 
     /// Check whether the object's forwarding pointer refers to a different location.
     pub unsafe fn is_forwarded(self) -> bool {
-        self.check_forwarding_pointer();
-        self.forward().get_ptr() != self.get_ptr()
+        if is_incremental_gc!() {
+            self.check_forwarding_pointer();
+            self.forward().get_ptr() != self.get_ptr()
+        } else {
+            false
+        }
     }
 
     /// Get the object tag. No forwarding. Can be applied to any block, regular objects
     /// with a header as well as `OneWordFiller`, `FwdPtr`, and `FreeSpace`.
     /// In debug mode panics if the value is not a pointer.
     pub unsafe fn tag(self) -> Tag {
+        #[enhanced_orthogonal_persistence]
         debug_assert_ne!(self, NULL_POINTER);
+
         *(self.get_ptr() as *const Tag)
     }
 
     /// Get the forwarding pointer. Used by the incremental GC.
+    #[incremental_gc]
     pub unsafe fn forward(self) -> Value {
         debug_assert!(self.is_obj());
         debug_assert!(self.get_ptr() as *const Obj != null());
@@ -299,7 +320,25 @@ impl Value {
         (*obj).forward
     }
 
+    /// Get the forwarding pointer. Used without the incremental GC.
+    #[non_incremental_gc]
+    pub unsafe fn forward(self) -> Value {
+        self
+    }
+
     /// Resolve forwarding if the value is a pointer. Otherwise, return the same value.
+    #[classical_persistence]
+    pub unsafe fn forward_if_possible(self) -> Value {
+        // Second condition: Ignore raw null addresses used in `text_iter`.
+        if is_incremental_gc!() && self.is_ptr() && self.get_ptr() as *const Obj != null() {
+            self.forward()
+        } else {
+            self
+        }
+    }
+
+    /// Resolve forwarding if the value is a pointer. Otherwise, return the same value.
+    #[enhanced_orthogonal_persistence]
     pub unsafe fn forward_if_possible(self) -> Value {
         // Second condition: Ignore raw null addresses used in `text_iter`.
         if self.is_non_null_ptr() && self.get_ptr() as *const Obj != null() {
@@ -351,7 +390,7 @@ impl Value {
 
     /// Get the pointer as `Object` using forwarding. In debug mode panics if the value is not a pointer.
     pub unsafe fn as_object(self) -> *mut Object {
-        debug_assert!(self.get().is_ptr());
+        debug_assert!(self.tag() == TAG_OBJECT);
         self.check_forwarding_pointer();
         self.forward().get_ptr() as *mut Object
     }
@@ -363,6 +402,16 @@ impl Value {
         self.forward().get_ptr() as *mut Region
     }
 
+    /// Get the pointer as `Stream` using forwarding, which is a glorified `Blob`.
+    /// In debug mode panics if the value is not a pointer or the
+    /// pointed object is not a `Blob`.
+    #[classical_persistence]
+    pub unsafe fn as_stream(self) -> *mut Stream {
+        debug_assert_eq!(self.tag(), TAG_BLOB_B);
+        self.check_forwarding_pointer();
+        self.forward().get_ptr() as *mut Stream
+    }
+
     /// Get the pointer as `Region` using forwarding, without checking the tag.
     /// NB: One cannot check the tag during stabilization.
     pub unsafe fn as_untagged_region(self) -> *mut Region {
@@ -401,29 +450,38 @@ impl Value {
         self.forward().get_ptr() as *mut BigInt
     }
 
-    pub fn as_tiny(self) -> i32 {
+    pub fn as_tiny(self) -> isize {
         debug_assert!(self.is_scalar());
-        self.0 as i32 >> 1
+        self.0 as isize >> 1
     }
 
     // optimized version of `value.is_non_null_ptr() && value.get_ptr() >= address`
     // value is a non-null pointer equal or greater than the unskewed address > 1
     #[inline]
+    #[enhanced_orthogonal_persistence]
+    pub fn points_to_or_beyond(&self, address: usize) -> bool {
+        debug_assert!(address > TRUE_VALUE);
+        let raw = self.get_raw();
+        is_skewed(raw) && unskew(raw) >= address && *self != NULL_POINTER
+    }
+
+    #[inline]
+    #[classical_persistence]
     pub fn points_to_or_beyond(&self, address: usize) -> bool {
-        debug_assert!(address > TRUE_VALUE as usize);
+        debug_assert!(address > TRUE_VALUE);
         let raw = self.get_raw();
-        is_skewed(raw) && unskew(raw as usize) >= address && *self != NULL_POINTER
+        is_skewed(raw) && unskew(raw) >= address
     }
 }
 
 #[inline]
 /// Returns whether a raw value is representing a pointer. Useful when using `Value::get_raw`.
-pub fn is_ptr(value: u32) -> bool {
+pub fn is_ptr(value: usize) -> bool {
     is_skewed(value) && value != TRUE_VALUE
 }
 
 #[inline]
-pub const fn is_skewed(value: u32) -> bool {
+pub const fn is_skewed(value: usize) -> bool {
     value & 0b1 != 0
 }
 
@@ -440,10 +498,11 @@ pub const fn unskew(value: usize) -> usize {
 // NOTE: We don't create an enum for tags as we can never assume to do exhaustive pattern match on
 // tags, because of heap corruptions and other bugs (in the code generator or RTS, or maybe because
 // of an unsafe API usage).
-pub type Tag = u32;
+pub type Tag = usize;
 
 // Tags need to have the lowest bit set, to allow distinguishing a header (tag) from object
-// locations in mark-compact GC. (Reminder: objects and fields are word aligned)
+// locations in mark-compact GC. (Reminder: objects and fields are word aligned).
+// Odd tag numbers are expected by the mark-compact GC (for pointer threading).
 pub const TAG_OBJECT: Tag = 1;
 pub const TAG_ARRAY_I: Tag = 3; // Immutable Array ([T])
 pub const TAG_ARRAY_M: Tag = 5; // Mutable Array ([var T])
@@ -460,15 +519,15 @@ pub const TAG_BLOB_B: Tag = 25; // Blob of Bytes (Blob)
 pub const TAG_BLOB_T: Tag = 27; // Blob of Utf8 (Text)
 pub const TAG_BLOB_P: Tag = 29; // Principal (Principal)
 pub const TAG_BLOB_A: Tag = 31; // Actor (actor {})
-pub const TAG_FWD_PTR: Tag = 33; // Only used by the copying GC - not to be confused with forwarding pointer in the header used for incremental GC.
-pub const TAG_BITS32_U: Tag = 35; // Unsigned (Nat32)
-pub const TAG_BITS32_S: Tag = 37; // Signed (Int32)
-pub const TAG_BITS32_F: Tag = 39; // Reserved (Float32)
-pub const TAG_BIGINT: Tag = 41;
-pub const TAG_CONCAT: Tag = 43;
-pub const TAG_REGION: Tag = 45;
-pub const TAG_ONE_WORD_FILLER: Tag = 47;
-pub const TAG_FREE_SPACE: Tag = 49;
+pub const TAG_FWD_PTR: Tag = 33; // Used by graph copy stabilization and the copying GC - not to be confused with the incremental GC's forwarding pointer.
+pub const TAG_BIGINT: Tag = 35;
+pub const TAG_CONCAT: Tag = 37;
+pub const TAG_REGION: Tag = 39;
+
+#[enhanced_orthogonal_persistence]
+pub const TAG_ONE_WORD_FILLER: Tag = 41;
+#[enhanced_orthogonal_persistence]
+pub const TAG_FREE_SPACE: Tag = 43;
 
 // Special value to visit only a range of array fields.
 // This and all values above it are reserved and mean
@@ -476,14 +535,40 @@ pub const TAG_FREE_SPACE: Tag = 49;
 // purposes of `visit_pointer_fields`.
 // The top two bits encode the original array tag, the remaining bits are the start index of the slice.
 // Invariant: the value of this (pseudo-)tag must be
-//            higher than all other tags defined above
-pub const TAG_ARRAY_SLICE_MIN: Tag = 50;
+//            higher than all other tags defined above.
+// Note: The minimum value can be even, as it only denotes
+// a lower boundary to distinguish slice information from
+// the actual tag values.
+#[enhanced_orthogonal_persistence]
+pub const TAG_ARRAY_SLICE_MIN: Tag = 44;
+
 pub const TAG_SPACING: Tag = 2;
 
+#[classical_persistence]
+pub const TAG_BITS32_U: Tag = 41;
+#[classical_persistence]
+pub const TAG_BITS32_S: Tag = 43;
+#[classical_persistence]
+pub const TAG_BITS32_F: Tag = 45;
+#[classical_persistence]
+pub const TAG_NULL: Tag = 47;
+#[classical_persistence]
+pub const TAG_ONE_WORD_FILLER: Tag = 49;
+#[classical_persistence]
+pub const TAG_FREE_SPACE: Tag = 51;
+#[classical_persistence]
+pub const TAG_ARRAY_SLICE_MIN: Tag = 52;
+
+#[enhanced_orthogonal_persistence]
 pub fn is_object_tag(tag: Tag) -> bool {
     tag >= TAG_OBJECT && tag <= TAG_REGION
 }
 
+#[classical_persistence]
+pub fn is_object_tag(tag: Tag) -> bool {
+    tag >= TAG_OBJECT && tag <= TAG_NULL
+}
+
 pub fn is_blob_tag(tag: Tag) -> bool {
     tag == TAG_BLOB_B || tag == TAG_BLOB_T || tag == TAG_BLOB_P || tag == TAG_BLOB_A
 }
@@ -497,7 +582,7 @@ pub fn is_array_or_slice_tag(tag: Tag) -> bool {
 }
 
 #[inline]
-pub fn start_of_slice(tag: Tag) -> u32 {
+pub fn start_of_slice(tag: Tag) -> usize {
     tag << 2 >> 2
 }
 
@@ -506,14 +591,16 @@ pub fn tag_of_slice(tag: Tag) -> Tag {
     TAG_ARRAY_I + (tag >> (usize::BITS - 2)) * TAG_SPACING
 }
 
-pub fn slice_tag(array_tag: Tag, slice_start: u32) -> Tag {
+pub fn slice_tag(array_tag: Tag, slice_start: usize) -> Tag {
     debug_assert!(is_base_array_tag(array_tag));
-    debug_assert!(slice_start >= TAG_ARRAY_SLICE_MIN && slice_start <= MAX_ARRAY_SIZE);
+    debug_assert!(
+        slice_start >= TAG_ARRAY_SLICE_MIN && slice_start <= MAX_ARRAY_LENGTH_FOR_ITERATOR
+    );
     debug_assert!((array_tag - TAG_ARRAY_I) % TAG_SPACING == 0);
     (((array_tag - TAG_ARRAY_I) / TAG_SPACING) << (usize::BITS - 2)) | slice_start
 }
 
-pub fn slice_start(tag: Tag) -> (Tag, u32) {
+pub fn slice_start(tag: Tag) -> (Tag, usize) {
     debug_assert!(is_array_or_slice_tag(tag));
     if tag >= TAG_ARRAY_SLICE_MIN {
         (tag_of_slice(tag), start_of_slice(tag))
@@ -537,20 +624,37 @@ pub fn base_array_tag(tag: Tag) -> Tag {
 #[repr(C)] // See the note at the beginning of this module
 pub struct Obj {
     pub tag: Tag,
+    // Cannot use `#[incremental_gc]` as Rust only allows non-macro attributes for fields.
+    #[cfg(feature = "incremental_gc")]
     /// Forwarding pointer to support object moving in the incremental GC.
     pub forward: Value,
 }
 
 impl Obj {
+    #[enhanced_orthogonal_persistence]
+    pub fn new(tag: Tag, forward: Value) -> Obj {
+        Obj { tag, forward }
+    }
+
+    #[incremental_gc]
     pub fn init_forward(&mut self, value: Value) {
         self.forward = value;
     }
 
+    #[non_incremental_gc]
+    pub fn init_forward(&mut self, _value: Value) {}
+
     /// Check whether the object's forwarding pointer refers to a different location.
+    #[incremental_gc]
     pub unsafe fn is_forwarded(self: *const Self) -> bool {
         (*self).forward.get_ptr() != self as usize
     }
 
+    #[non_incremental_gc]
+    pub unsafe fn is_forwarded(self: *const Self) -> bool {
+        false
+    }
+
     pub unsafe fn tag(self: *const Self) -> Tag {
         (*self).tag
     }
@@ -570,9 +674,9 @@ impl Obj {
 #[repr(C)] // See the note at the beginning of this module
 pub struct Array {
     pub header: Obj,
-    pub len: u32, // number of elements
+    pub len: usize, // number of elements
 
-    // Array elements follow, each u32 sized. We can't have variable-sized structs in Rust so we
+    // Array elements follow, each of `usize` width. We can't have variable-sized structs in Rust so we
     // can't add a field here for the elements.
     // https://doc.rust-lang.org/nomicon/exotic-sizes.html
 }
@@ -582,7 +686,7 @@ impl Array {
         self.offset(1) as *mut Value // skip array header
     }
 
-    pub unsafe fn get(self: *mut Self, idx: u32) -> Value {
+    pub unsafe fn get(self: *mut Self, idx: usize) -> Value {
         let slot_addr = self.element_address(idx);
         *(slot_addr as *const Value)
     }
@@ -591,7 +695,7 @@ impl Array {
     /// Uses a generational post-update barrier on pointer writes.
     /// No incremental pre-update barrier as the previous value is undefined.
     /// Resolve pointer forwarding for the written value if necessary.
-    pub unsafe fn initialize<M: Memory>(self: *mut Self, idx: u32, value: Value, mem: &mut M) {
+    pub unsafe fn initialize<M: Memory>(self: *mut Self, idx: usize, value: Value, mem: &mut M) {
         let slot_addr = self.element_address(idx) as *mut Value;
         init_with_barrier(mem, slot_addr, value);
     }
@@ -600,18 +704,31 @@ impl Array {
     /// The written and overwritten value can be a scalar or a pointer.
     /// Applies an incremental pre-update barrier when needed.
     /// Resolves pointer forwarding for the written value.
-    pub unsafe fn set<M: Memory>(self: *mut Self, idx: u32, value: Value, mem: &mut M) {
+    pub unsafe fn set<M: Memory>(self: *mut Self, idx: usize, value: Value, mem: &mut M) {
         let slot_addr = self.element_address(idx) as *mut Value;
         write_with_barrier(mem, slot_addr, value);
     }
 
+    /// Write a scalar value to an array element.
+    /// No need for a write barrier.
+    pub unsafe fn set_scalar(self: *mut Self, idx: usize, value: Value) {
+        debug_assert!(value.is_scalar());
+        self.set_raw(idx, value);
+    }
+
+    /// Note: Only directly used by graph destabilization. No write barrier is applied.
+    pub unsafe fn set_raw(self: *mut Self, idx: usize, value: Value) {
+        let slot_addr = self.element_address(idx);
+        *(slot_addr as *mut Value) = value;
+    }
+
     #[inline]
-    unsafe fn element_address(self: *const Self, idx: u32) -> usize {
+    unsafe fn element_address(self: *const Self, idx: usize) -> usize {
         debug_assert!(self.len() > idx);
-        self.payload_addr() as usize + (idx * WORD_SIZE) as usize
+        self.payload_addr() as usize + idx * WORD_SIZE
     }
 
-    pub unsafe fn len(self: *const Self) -> u32 {
+    pub unsafe fn len(self: *const Self) -> usize {
         (*self).len
     }
 
@@ -619,11 +736,11 @@ impl Array {
         base_array_tag((*self).header.tag)
     }
 
-    pub unsafe fn get_slice_start(self: *const Self) -> (Tag, u32) {
+    pub unsafe fn get_slice_start(self: *const Self) -> (Tag, usize) {
         slice_start((*self).header.tag)
     }
 
-    pub unsafe fn set_slice_start(self: *mut Self, array_tag: Tag, start: u32) {
+    pub unsafe fn set_slice_start(self: *mut Self, array_tag: Tag, start: usize) {
         debug_assert!(is_base_array_tag(array_tag));
         (*self).header.tag = slice_tag(array_tag, start)
     }
@@ -636,15 +753,38 @@ impl Array {
 
 #[rustfmt::skip]
 #[repr(C)] // See the note at the beginning of this module
+#[enhanced_orthogonal_persistence]
+pub struct Region {
+    pub header: Obj,
+    pub id: u64,
+    pub page_count: usize,
+    pub vec_pages: Value, // Blob of u16's (each a page block ID).
+}
+
+#[enhanced_orthogonal_persistence]
+impl Region {
+    pub unsafe fn write_id64(self: *mut Self, value: u64) {
+        (*self).id = value;
+    }
+
+    pub unsafe fn read_id64(self: *mut Self) -> u64 {
+        (*self).id
+    }
+}
+
+#[rustfmt::skip]
+#[repr(C)] // See the note at the beginning of this module
+#[classical_persistence]
 pub struct Region {
     pub header: Obj,
     // 64-bit id split into lower and upper halves for alignment reasons
     pub id_lower: u32,
     pub id_upper: u32,
-    pub page_count: u32,
+    pub page_count: usize,
     pub vec_pages: Value, // Blob of u16's (each a page block ID).
 }
 
+#[classical_persistence]
 impl Region {
     pub unsafe fn write_id64(self: *mut Self, value: u64) {
         write64(&mut (*self).id_lower, &mut (*self).id_upper, value);
@@ -656,12 +796,22 @@ impl Region {
 }
 
 #[repr(C)] // See the note at the beginning of this module
+#[enhanced_orthogonal_persistence]
 pub struct Object {
     pub header: Obj,
     pub hash_blob: Value, // Pointer to a blob containing the hashes of the object field labels.
 }
 
+#[repr(C)] // See the note at the beginning of this module
+#[classical_persistence]
+pub struct Object {
+    pub header: Obj,
+    pub size: usize,     // Number of elements
+    pub hash_ptr: usize, // Pointer to static information about object field labels. Not important for GC (does not contain pointers).
+}
+
 impl Object {
+    #[enhanced_orthogonal_persistence]
     pub unsafe fn hash_blob_addr(self: *mut Self) -> *mut Value {
         &mut (*self).hash_blob
     }
@@ -671,24 +821,30 @@ impl Object {
     }
 
     /// Number of fields in the object.
-    pub(crate) unsafe fn size(self: *mut Self) -> u32 {
-        let hash_blob_length = (*self).hash_blob.as_blob().len().as_u32();
+    #[enhanced_orthogonal_persistence]
+    pub(crate) unsafe fn size(self: *mut Self) -> usize {
+        let hash_blob_length = (*self).hash_blob.as_blob().len().as_usize();
         debug_assert_eq!(hash_blob_length % WORD_SIZE, 0);
         hash_blob_length / WORD_SIZE
     }
 
-    #[cfg(debug_assertions)]
-    pub(crate) unsafe fn get(self: *mut Self, idx: u32) -> Value {
-        *self.payload_addr().add(idx as usize)
+    #[classical_persistence]
+    pub(crate) unsafe fn size(self: *mut Self) -> usize {
+        (*self).size
+    }
+
+    #[allow(unused)]
+    pub(crate) unsafe fn get(self: *mut Self, idx: usize) -> Value {
+        *self.payload_addr().add(idx)
     }
 }
 
 #[repr(C)] // See the note at the beginning of this module
 pub struct Closure {
     pub header: Obj,
-    pub funid: u32,
-    pub size: u32, // number of elements
-                   // other stuff follows ...
+    pub funid: usize,
+    pub size: usize, // number of elements
+                     // other stuff follows ...
 }
 
 impl Closure {
@@ -696,7 +852,7 @@ impl Closure {
         self.offset(1) as *mut Value // skip closure header
     }
 
-    pub(crate) unsafe fn size(self: *mut Self) -> u32 {
+    pub(crate) unsafe fn size(self: *mut Self) -> usize {
         (*self).size
     }
 }
@@ -704,7 +860,7 @@ impl Closure {
 #[repr(C)] // See the note at the beginning of this module
 pub struct Blob {
     pub header: Obj,
-    pub len: Bytes<u32>,
+    pub len: Bytes<usize>,
     // data follows ..
 }
 
@@ -717,16 +873,16 @@ impl Blob {
         self.add(1) as *mut u8 // skip blob header
     }
 
-    pub unsafe fn len(self: *const Self) -> Bytes<u32> {
+    pub unsafe fn len(self: *const Self) -> Bytes<usize> {
         (*self).len
     }
 
-    pub unsafe fn get(self: *const Self, idx: u32) -> u8 {
-        *self.payload_const().add(idx as usize)
+    pub unsafe fn get(self: *const Self, idx: usize) -> u8 {
+        *self.payload_const().add(idx)
     }
 
-    pub unsafe fn set(self: *mut Self, idx: u32, byte: u8) {
-        *self.payload_addr().add(idx as usize) = byte;
+    pub unsafe fn set(self: *mut Self, idx: usize, byte: u8) {
+        *self.payload_addr().add(idx) = byte;
     }
 
     pub unsafe fn payload_addr_u16(self: *mut Self) -> *mut u16 {
@@ -737,16 +893,16 @@ impl Blob {
         self.add(1) as *mut u16 // skip blob header
     }
 
-    pub unsafe fn get_u16(self: *const Self, idx: u32) -> u16 {
-        *self.payload_const_u16().add(idx as usize)
+    pub unsafe fn get_u16(self: *const Self, idx: usize) -> u16 {
+        *self.payload_const_u16().add(idx)
     }
 
-    pub unsafe fn set_u16(self: *mut Self, idx: u32, value: u16) {
-        *self.payload_addr_u16().add(idx as usize) = value;
+    pub unsafe fn set_u16(self: *mut Self, idx: usize, value: u16) {
+        *self.payload_addr_u16().add(idx) = value;
     }
 
     /// Shrink blob to the given size. Slop after the new size is filled with filler objects.
-    pub unsafe fn shrink(self: *mut Self, new_len: Bytes<u32>) {
+    pub unsafe fn shrink(self: *mut Self, new_len: Bytes<usize>) {
         let current_len_words = self.len().to_words();
         let new_len_words = new_len.to_words();
 
@@ -755,13 +911,13 @@ impl Blob {
         let slop = current_len_words - new_len_words;
 
         if slop == Words(1) {
-            let filler = (self.payload_addr() as *mut u32).add(new_len_words.as_usize())
+            let filler = (self.payload_addr() as *mut usize).add(new_len_words.as_usize())
                 as *mut OneWordFiller;
             (*filler).tag = TAG_ONE_WORD_FILLER;
         } else if slop != Words(0) {
             debug_assert!(slop >= size_of::<FreeSpace>());
             let filler =
-                (self.payload_addr() as *mut u32).add(new_len_words.as_usize()) as *mut FreeSpace;
+                (self.payload_addr() as *mut usize).add(new_len_words.as_usize()) as *mut FreeSpace;
             (*filler).tag = TAG_FREE_SPACE;
             (*filler).words = slop - size_of::<FreeSpace>();
         }
@@ -770,14 +926,76 @@ impl Blob {
     }
 }
 
-// Note: Do not declare 64-bit fields, as otherwise, the objects are expected to be 64-bit aligned.
-// This is not the case in the current heap design.
-// Moreover, fields would also get 64-bit aligned causing implicit paddding.
+/// NOTE: The stream is not used by enhanced orthogonal persistence and is designed for 32-bit only.
+/// Do not declare 64-bit fields for 32-bit stream, as otherwise, the objects are expected to be 64-bit
+/// aligned which is not the case in 32-bit heap. Moreover, fields would also get 64-bit aligned causing
+/// implicit paddding on 32-bit memory.
+#[repr(C)] // See the note at the beginning of this module
+#[classical_persistence]
+pub struct Stream {
+    pub header: Blob,
+
+    /// Components of the 64-bit `ptr` value. Little-endian encoding.
+    /// Use `read_ptr64()` and `write_ptr64()` to access.
+    pub ptr_lower: u32,
+    pub ptr_upper: u32,
+
+    /// Components of the 64-bit `start` value. Little-endian encoding.
+    /// Use `read_start64()` and `write_start64()` to access.
+    pub start_lower: u32,
+    pub start_upper: u32,
+
+    /// Components of the 64-bit `limit` value. Little-endian encoding.
+    /// Use `read_limit64()` and `write_limit64()` to access.
+    pub limit_lower: u32,
+    pub limit_upper: u32,
+
+    pub outputter: fn(*mut Self, *const u8, Bytes<usize>) -> (),
+    pub filled: Bytes<usize>, // cache data follows ..
+}
+
+#[classical_persistence]
+impl Stream {
+    pub unsafe fn is_forwarded(self: *const Self) -> bool {
+        (self as *const Obj).is_forwarded()
+    }
+
+    pub unsafe fn as_blob_mut(self: *mut Self) -> *mut Blob {
+        debug_assert!(!self.is_forwarded());
+        self as *mut Blob
+    }
+
+    pub unsafe fn write_ptr64(self: *mut Self, value: u64) {
+        write64(&mut (*self).ptr_lower, &mut (*self).ptr_upper, value);
+    }
+
+    pub unsafe fn read_ptr64(self: *const Self) -> u64 {
+        read64((*self).ptr_lower, (*self).ptr_upper)
+    }
+
+    pub unsafe fn write_start64(self: *mut Self, value: u64) {
+        write64(&mut (*self).start_lower, &mut (*self).start_upper, value);
+    }
+
+    pub unsafe fn read_start64(self: *const Self) -> u64 {
+        read64((*self).start_lower, (*self).start_upper)
+    }
+
+    pub unsafe fn write_limit64(self: *mut Self, value: u64) {
+        write64(&mut (*self).limit_lower, &mut (*self).limit_upper, value);
+    }
+
+    pub unsafe fn read_limit64(self: *const Self) -> u64 {
+        read64((*self).limit_lower, (*self).limit_upper)
+    }
+}
 
+#[classical_persistence]
 pub fn read64(lower: u32, upper: u32) -> u64 {
     ((upper as u64) << u32::BITS) | lower as u64
 }
 
+#[classical_persistence]
 pub fn write64(lower: &mut u32, upper: &mut u32, value: u64) {
     *upper = (value >> u32::BITS) as u32;
     *lower = (value & u32::MAX as u64) as u32;
@@ -799,25 +1017,57 @@ pub struct BigInt {
     /// The data pointer (mp_int.dp) is irrelevant, and will be changed to point to
     /// the data within this object before it is used.
     /// (NB: If we have a non-moving GC, we can make this an invariant)
+    /// NOTE: `mp_int` originates from Tom's math library implementation.
+    /// Layout in 64-bit memory (with enhanced orthogonal persistence):
+    /// ```
+    /// pub struct mp_int { // Total size 24
+    ///   pub used: c_int, // Offset 0, size 4
+    ///   pub alloc: c_int, // Offset 4, size 4
+    ///   pub sign: mp_sign, // Offset 8, size 4
+    ///   _padding: u32, // Implicit padding to align subsequent 64-bit pointer
+    ///   pub dp: *mut mp_digit, // Offset 16, size 8
+    /// }
+    /// ```
+    /// Layout in 32-bit memory (with classical persistence):
+    /// ```
+    /// pub struct mp_int { // Total size 24
+    ///   pub used: c_int, // Offset 0, size 4
+    ///   pub alloc: c_int, // Offset 4, size 4
+    ///   pub sign: mp_sign, // Offset 8, size 4
+    ///   pub dp: *mut mp_digit, // Offset 12, size 4
+    /// }
+    /// ```
     pub mp_int: mp_int,
     // data follows ..
+    // Array of `mp_int` with length `alloc`.
+    // Each `mp_int` has byte size `size_of<usize>()`.
 }
 
 impl BigInt {
-    pub unsafe fn len(self: *mut Self) -> Bytes<u32> {
-        Bytes(((*self).mp_int.alloc as usize * core::mem::size_of::<mp_digit>()) as u32)
+    pub unsafe fn len(self: *mut Self) -> Bytes<usize> {
+        Self::data_length(&(*self).mp_int)
+    }
+
+    pub unsafe fn data_length(mp_int: *const mp_int) -> Bytes<usize> {
+        Bytes((*mp_int).alloc as usize * core::mem::size_of::<mp_digit>())
     }
 
     pub unsafe fn payload_addr(self: *mut Self) -> *mut mp_digit {
         self.add(1) as *mut mp_digit // skip closure header
     }
 
+    #[incremental_gc]
     pub unsafe fn forward(self: *mut Self) -> *mut Self {
         (*self).header.forward.as_bigint()
     }
 
+    #[non_incremental_gc]
+    pub unsafe fn forward(self: *mut Self) -> *mut Self {
+        self
+    }
+
     pub unsafe fn from_payload(ptr: *mut mp_digit) -> *mut Self {
-        let bigint = (ptr as *mut u32).sub(size_of::<BigInt>().as_usize()) as *mut BigInt;
+        let bigint = (ptr as *mut usize).sub(size_of::<BigInt>().as_usize()) as *mut BigInt;
         bigint.forward()
     }
 
@@ -851,14 +1101,14 @@ pub struct Some {
 #[repr(C)] // See the note at the beginning of this module
 pub struct Variant {
     pub header: Obj,
-    pub tag: u32,
+    pub tag: usize,
     pub field: Value,
 }
 
 #[repr(C)] // See the note at the beginning of this module
 pub struct Concat {
     pub header: Obj,
-    pub n_bytes: Bytes<u32>,
+    pub n_bytes: Bytes<usize>,
     pub text1: Value,
     pub text2: Value,
 }
@@ -874,6 +1124,27 @@ impl Concat {
 }
 
 #[repr(C)] // See the note at the beginning of this module
+#[classical_persistence]
+pub struct Null {
+    pub header: Obj,
+}
+
+#[repr(C)] // See the note at the beginning of this module
+#[enhanced_orthogonal_persistence]
+pub struct Bits64 {
+    pub header: Obj,
+    pub bits: u64,
+}
+
+#[enhanced_orthogonal_persistence]
+impl Bits64 {
+    pub fn bits(&self) -> u64 {
+        self.bits
+    }
+}
+
+#[repr(C)] // See the note at the beginning of this module
+#[classical_persistence]
 pub struct Bits64 {
     pub header: Obj,
     // We have two 32-bit fields instead of one 64-bit to avoid aligning the fields on 64-bit
@@ -882,6 +1153,7 @@ pub struct Bits64 {
     bits_hi: u32,
 }
 
+#[classical_persistence]
 impl Bits64 {
     pub fn bits(&self) -> u64 {
         (u64::from(self.bits_hi) << 32) | u64::from(self.bits_lo)
@@ -889,6 +1161,7 @@ impl Bits64 {
 }
 
 #[repr(C)] // See the note at the beginning of this module
+#[classical_persistence]
 pub struct Bits32 {
     pub header: Obj,
     pub bits: u32,
@@ -904,12 +1177,12 @@ pub struct OneWordFiller {
 #[repr(C)] // See the note at the beginning of this module
 pub struct FreeSpace {
     pub tag: Tag,
-    pub words: Words<u32>,
+    pub words: Words<usize>,
 }
 
 impl FreeSpace {
     /// Size of the free space (includes object header)
-    pub unsafe fn size(self: *mut Self) -> Words<u32> {
+    pub unsafe fn size(self: *mut Self) -> Words<usize> {
         (*self).words + size_of::<FreeSpace>()
     }
 }
@@ -918,7 +1191,7 @@ impl FreeSpace {
 /// Handles both objects with header and forwarding pointer
 /// and special blocks such as `OneWordFiller`, `FwdPtr`, and `FreeSpace`
 /// that do not have a forwarding pointer.
-pub(crate) unsafe fn block_size(address: usize) -> Words<u32> {
+pub(crate) unsafe fn block_size(address: usize) -> Words<usize> {
     let tag = *(address as *mut Tag);
     match tag {
         TAG_OBJECT => {
@@ -958,8 +1231,6 @@ pub(crate) unsafe fn block_size(address: usize) -> Words<u32> {
             rts_trap_with("object_size: forwarding pointer");
         }
 
-        TAG_BITS32_U | TAG_BITS32_S | TAG_BITS32_F => size_of::<Bits32>(),
-
         TAG_BIGINT => {
             let bigint = address as *mut BigInt;
             size_of::<BigInt>() + bigint.len().to_words()
@@ -976,6 +1247,12 @@ pub(crate) unsafe fn block_size(address: usize) -> Words<u32> {
 
         TAG_REGION => size_of::<Region>(),
 
+        #[cfg(not(feature = "enhanced_orthogonal_persistence"))]
+        TAG_BITS32_U | TAG_BITS32_S | TAG_BITS32_F => size_of::<Bits32>(),
+
+        #[cfg(not(feature = "enhanced_orthogonal_persistence"))]
+        TAG_NULL => size_of::<Null>(),
+
         _ => {
             rts_trap_with("object_size: invalid object tag");
         }
diff --git a/rts/motoko-rts/src/utf8.rs b/rts/motoko-rts/src/utf8.rs
index 913206194e6..3cf43ce85ab 100644
--- a/rts/motoko-rts/src/utf8.rs
+++ b/rts/motoko-rts/src/utf8.rs
@@ -1,6 +1,8 @@
+use crate::libc_declarations::c_char;
+
 /// Panics if the string is not valid UTF-8
 #[no_mangle]
-pub(crate) unsafe extern "C" fn utf8_validate(str: *const libc::c_char, len: u32) {
+pub(crate) unsafe extern "C" fn utf8_validate(str: *const c_char, len: usize) {
     if !utf8_valid(str, len) {
         crate::rts_trap_with("utf8_validate: string is not UTF-8");
     }
@@ -8,6 +10,6 @@ pub(crate) unsafe extern "C" fn utf8_validate(str: *const libc::c_char, len: u32
 
 /// Returns whether the string is valid UTF-8
 #[no_mangle]
-pub unsafe extern "C" fn utf8_valid(str: *const libc::c_char, len: u32) -> bool {
-    core::str::from_utf8(core::slice::from_raw_parts(str as *const _, len as usize)).is_ok()
+pub unsafe extern "C" fn utf8_valid(str: *const c_char, len: usize) -> bool {
+    core::str::from_utf8(core::slice::from_raw_parts(str as *const _, len)).is_ok()
 }
diff --git a/rts/motoko-rts/src/visitor.rs b/rts/motoko-rts/src/visitor.rs
index 44de9d1490a..4773f5fdc08 100644
--- a/rts/motoko-rts/src/visitor.rs
+++ b/rts/motoko-rts/src/visitor.rs
@@ -1,4 +1,11 @@
-use crate::rts_trap_with;
+#[enhanced_orthogonal_persistence]
+pub mod enhanced;
+
+#[classical_persistence]
+pub mod classical;
+
+use motoko_rts_macros::{classical_persistence, enhanced_orthogonal_persistence};
+
 use crate::types::*;
 
 /// A visitor that passes field addresses of fields with pointers to dynamic heap to the given
@@ -9,137 +16,49 @@ use crate::types::*;
 /// * `ctx`: any context passed to the `visit_*` callbacks
 /// * `obj`: the heap object to be visited (note: its heap tag may be invalid)
 /// * `tag`: the heap object's logical tag (or start of array object's suffix slice)
+/// * `_heap_base`: start address of the dynamic heap, only used with classical persistence.
 /// * `visit_ptr_field`: callback for individual fields
 /// * `visit_field_range`: callback for determining the suffix slice
 ///   Arguments:
 ///   * `&mut C`: passed context
-///   * `u32`: start index of array suffix slice being visited
+///   * `usize`: start index of array suffix slice being visited
 ///   * `*mut Array`: home object of the slice (its heap tag may be invalid)
 ///   Returns:
-///   * `u32`: start of the suffix slice of fields not to be passed to `visit_ptr_field`;
+///   * `usize`: start of the suffix slice of fields not to be passed to `visit_ptr_field`;
 ///            it is the callback's responsibility to deal with the spanned slice
-
+#[enhanced_orthogonal_persistence]
 pub unsafe fn visit_pointer_fields<C, F, G>(
     ctx: &mut C,
     obj: *mut Obj,
     tag: Tag,
+    _heap_base: usize,
     visit_ptr_field: F,
     visit_field_range: G,
 ) where
     F: Fn(&mut C, *mut Value),
-    G: Fn(&mut C, u32, *mut Array) -> u32,
+    G: Fn(&mut C, usize, *mut Array) -> usize,
 {
-    match tag {
-        TAG_OBJECT => {
-            let obj = obj as *mut Object;
-            debug_assert!(is_non_null_pointer_field(obj.hash_blob_addr()));
-            visit_ptr_field(ctx, obj.hash_blob_addr());
-            let obj_payload = obj.payload_addr();
-            for i in 0..obj.size() {
-                let field_addr = obj_payload.add(i as usize);
-                if is_non_null_pointer_field(field_addr) {
-                    visit_ptr_field(ctx, obj_payload.add(i as usize));
-                }
-            }
-        }
-
-        TAG_ARRAY_I | TAG_ARRAY_M | TAG_ARRAY_T | TAG_ARRAY_S | TAG_ARRAY_SLICE_MIN.. => {
-            let (_, slice_start) = slice_start(tag);
-            let array = obj as *mut Array;
-            debug_assert!(slice_start <= array.len());
-            let array_payload = array.payload_addr();
-            let stop = visit_field_range(ctx, slice_start, array);
-            debug_assert!(stop <= array.len());
-            for i in slice_start..stop {
-                let field_addr = array_payload.add(i as usize);
-                if is_non_null_pointer_field(field_addr) {
-                    visit_ptr_field(ctx, field_addr);
-                }
-            }
-        }
-
-        TAG_MUTBOX => {
-            let mutbox = obj as *mut MutBox;
-            let field_addr = &mut (*mutbox).field;
-            if is_non_null_pointer_field(field_addr) {
-                visit_ptr_field(ctx, field_addr);
-            }
-        }
-
-        TAG_CLOSURE => {
-            let closure = obj as *mut Closure;
-            let closure_payload = closure.payload_addr();
-            for i in 0..closure.size() {
-                let field_addr = closure_payload.add(i as usize);
-                if is_non_null_pointer_field(field_addr) {
-                    visit_ptr_field(ctx, field_addr);
-                }
-            }
-        }
-
-        TAG_SOME => {
-            let some = obj as *mut Some;
-            let field_addr = &mut (*some).field;
-            if is_non_null_pointer_field(field_addr) {
-                visit_ptr_field(ctx, field_addr);
-            }
-        }
-
-        TAG_VARIANT => {
-            let variant = obj as *mut Variant;
-            let field_addr = &mut (*variant).field;
-            if is_non_null_pointer_field(field_addr) {
-                visit_ptr_field(ctx, field_addr);
-            }
-        }
-
-        TAG_REGION => {
-            let region = obj as *mut Region;
-            let field_addr = &mut (*region).vec_pages;
-            if is_non_null_pointer_field(field_addr) {
-                visit_ptr_field(ctx, field_addr);
-            }
-        }
-
-        TAG_CONCAT => {
-            let concat = obj as *mut Concat;
-            let field1_addr = &mut (*concat).text1;
-            if is_non_null_pointer_field(field1_addr) {
-                visit_ptr_field(ctx, field1_addr);
-            }
-            let field2_addr = &mut (*concat).text2;
-            if is_non_null_pointer_field(field2_addr) {
-                visit_ptr_field(ctx, field2_addr);
-            }
-        }
-
-        TAG_BITS32_U | TAG_BITS32_S | TAG_BITS32_F | TAG_BITS64_U | TAG_BITS64_S | TAG_BITS64_F
-        | TAG_BLOB_B | TAG_BLOB_T | TAG_BLOB_P | TAG_BLOB_A | TAG_BIGINT => {
-            // These don't have pointers, skip
-        }
-
-        TAG_FWD_PTR | TAG_ONE_WORD_FILLER | TAG_FREE_SPACE | _ => {
-            rts_trap_with("invalid object tag in visit_pointer_fields");
-        }
-    }
+    self::enhanced::visit_pointer_fields(ctx, obj, tag, visit_ptr_field, visit_field_range);
 }
 
-// Temporary function can be later removed.
-pub unsafe fn is_non_null_pointer_field(field_addr: *mut Value) -> bool {
-    let field_value = *field_addr;
-    check_field_value(field_value);
-    field_value.is_non_null_ptr()
-}
-
-// Temporary check, can be later removed.
-#[cfg(feature = "ic")]
-fn check_field_value(value: Value) {
-    debug_assert!(
-        value.is_scalar()
-            || value.get_ptr() >= crate::persistence::HEAP_START
-            || value == NULL_POINTER
+#[classical_persistence]
+pub unsafe fn visit_pointer_fields<C, F, G>(
+    ctx: &mut C,
+    obj: *mut Obj,
+    tag: Tag,
+    heap_base: usize,
+    visit_ptr_field: F,
+    visit_field_range: G,
+) where
+    F: Fn(&mut C, *mut Value),
+    G: Fn(&mut C, usize, *mut Array) -> usize,
+{
+    self::classical::visit_pointer_fields(
+        ctx,
+        obj,
+        tag,
+        heap_base,
+        visit_ptr_field,
+        visit_field_range,
     );
 }
-
-#[cfg(not(feature = "ic"))]
-fn check_field_value(_value: Value) {}
diff --git a/rts/motoko-rts/src/visitor/classical.rs b/rts/motoko-rts/src/visitor/classical.rs
new file mode 100644
index 00000000000..c2e7a95ab54
--- /dev/null
+++ b/rts/motoko-rts/src/visitor/classical.rs
@@ -0,0 +1,134 @@
+use crate::rts_trap_with;
+use crate::types::*;
+
+/// A visitor that passes field addresses of fields with pointers to dynamic heap to the given
+/// callback
+///
+/// Arguments:
+///
+/// * `ctx`: any context passed to the `visit_*` callbacks
+/// * `obj`: the heap object to be visited (note: its heap tag may be invalid)
+/// * `tag`: the heap object's logical tag (or start of array object's suffix slice)
+/// * `heap_base`: start address of the dynamic heap.
+/// * `visit_ptr_field`: callback for individual fields
+/// * `visit_field_range`: callback for determining the suffix slice
+///   Arguments:
+///   * `&mut C`: passed context
+///   * `usize`: start index of array suffix slice being visited
+///   * `*mut Array`: home object of the slice (its heap tag may be invalid)
+///   Returns:
+///   * `usize`: start of the suffix slice of fields not to be passed to `visit_ptr_field`;
+///            it is the callback's responsibility to deal with the spanned slice
+pub unsafe fn visit_pointer_fields<C, F, G>(
+    ctx: &mut C,
+    obj: *mut Obj,
+    tag: Tag,
+    heap_base: usize,
+    visit_ptr_field: F,
+    visit_field_range: G,
+) where
+    F: Fn(&mut C, *mut Value),
+    G: Fn(&mut C, usize, *mut Array) -> usize,
+{
+    match tag {
+        TAG_OBJECT => {
+            let obj = obj as *mut Object;
+            let obj_payload = obj.payload_addr();
+            for i in 0..obj.size() {
+                let field_addr = obj_payload.add(i);
+                if pointer_to_dynamic_heap(field_addr, heap_base) {
+                    visit_ptr_field(ctx, obj_payload.add(i));
+                }
+            }
+        }
+
+        TAG_ARRAY_I | TAG_ARRAY_M | TAG_ARRAY_T | TAG_ARRAY_S | TAG_ARRAY_SLICE_MIN.. => {
+            let (_, slice_start) = slice_start(tag);
+            let array = obj as *mut Array;
+            debug_assert!(slice_start <= array.len());
+            let array_payload = array.payload_addr();
+            let stop = visit_field_range(ctx, slice_start, array);
+            debug_assert!(stop <= array.len());
+            for i in slice_start..stop {
+                let field_addr = array_payload.add(i);
+                if pointer_to_dynamic_heap(field_addr, heap_base) {
+                    visit_ptr_field(ctx, field_addr);
+                }
+            }
+        }
+
+        TAG_MUTBOX => {
+            let mutbox = obj as *mut MutBox;
+            let field_addr = &mut (*mutbox).field;
+            if pointer_to_dynamic_heap(field_addr, heap_base) {
+                visit_ptr_field(ctx, field_addr);
+            }
+        }
+
+        TAG_CLOSURE => {
+            let closure = obj as *mut Closure;
+            let closure_payload = closure.payload_addr();
+            for i in 0..closure.size() {
+                let field_addr = closure_payload.add(i);
+                if pointer_to_dynamic_heap(field_addr, heap_base) {
+                    visit_ptr_field(ctx, field_addr);
+                }
+            }
+        }
+
+        TAG_SOME => {
+            let some = obj as *mut Some;
+            let field_addr = &mut (*some).field;
+            if pointer_to_dynamic_heap(field_addr, heap_base) {
+                visit_ptr_field(ctx, field_addr);
+            }
+        }
+
+        TAG_VARIANT => {
+            let variant = obj as *mut Variant;
+            let field_addr = &mut (*variant).field;
+            if pointer_to_dynamic_heap(field_addr, heap_base) {
+                visit_ptr_field(ctx, field_addr);
+            }
+        }
+
+        TAG_REGION => {
+            let region = obj as *mut Region;
+            let field_addr = &mut (*region).vec_pages;
+            if pointer_to_dynamic_heap(field_addr, heap_base) {
+                visit_ptr_field(ctx, field_addr);
+            }
+        }
+
+        TAG_CONCAT => {
+            let concat = obj as *mut Concat;
+            let field1_addr = &mut (*concat).text1;
+            if pointer_to_dynamic_heap(field1_addr, heap_base) {
+                visit_ptr_field(ctx, field1_addr);
+            }
+            let field2_addr = &mut (*concat).text2;
+            if pointer_to_dynamic_heap(field2_addr, heap_base) {
+                visit_ptr_field(ctx, field2_addr);
+            }
+        }
+
+        TAG_BITS64_U | TAG_BITS64_S | TAG_BITS64_F | TAG_BITS32_U | TAG_BITS32_S | TAG_BITS32_F
+        | TAG_BLOB_B | TAG_BLOB_T | TAG_BLOB_P | TAG_BLOB_A | TAG_BIGINT => {
+            // These don't have pointers, skip
+        }
+
+        TAG_NULL => {
+            rts_trap_with("encountered NULL object tag in visit_pointer_fields");
+        }
+
+        TAG_FWD_PTR | TAG_ONE_WORD_FILLER | TAG_FREE_SPACE | _ => {
+            rts_trap_with("invalid object tag in visit_pointer_fields");
+        }
+    }
+}
+
+pub unsafe fn pointer_to_dynamic_heap(field_addr: *mut Value, heap_base: usize) -> bool {
+    // NB. pattern matching on `field_addr.get()` generates inefficient code
+    let field_value = (*field_addr).get_raw();
+    is_ptr(field_value) && unskew(field_value as usize) >= heap_base
+}
diff --git a/rts/motoko-rts/src/visitor/enhanced.rs b/rts/motoko-rts/src/visitor/enhanced.rs
new file mode 100644
index 00000000000..57220bbd6a1
--- /dev/null
+++ b/rts/motoko-rts/src/visitor/enhanced.rs
@@ -0,0 +1,129 @@
+use crate::rts_trap_with;
+use crate::types::*;
+
+/// A visitor that passes field addresses of fields with pointers to dynamic heap to the given
+/// callback
+///
+/// Arguments:
+///
+/// * `ctx`: any context passed to the `visit_*` callbacks
+/// * `obj`: the heap object to be visited (note: its heap tag may be invalid)
+/// * `tag`: the heap object's logical tag (or start of array object's suffix slice)
+/// * `visit_ptr_field`: callback for individual fields
+/// * `visit_field_range`: callback for determining the suffix slice
+///   Arguments:
+///   * `&mut C`: passed context
+///   * `usize`: start index of array suffix slice being visited
+///   * `*mut Array`: home object of the slice (its heap tag may be invalid)
+///   Returns:
+///   * `usize`: start of the suffix slice of fields not to be passed to `visit_ptr_field`;
+///            it is the callback's responsibility to deal with the spanned slice
+pub unsafe fn visit_pointer_fields<C, F, G>(
+    ctx: &mut C,
+    obj: *mut Obj,
+    tag: Tag,
+    visit_ptr_field: F,
+    visit_field_range: G,
+) where
+    F: Fn(&mut C, *mut Value),
+    G: Fn(&mut C, usize, *mut Array) -> usize,
+{
+    match tag {
+        TAG_OBJECT => {
+            let obj = obj as *mut Object;
+            debug_assert!(is_non_null_pointer_field(obj.hash_blob_addr()));
+            visit_ptr_field(ctx, obj.hash_blob_addr());
+            let obj_payload = obj.payload_addr();
+            for i in 0..obj.size() {
+                let field_addr = obj_payload.add(i);
+                if is_non_null_pointer_field(field_addr) {
+                    visit_ptr_field(ctx, obj_payload.add(i));
+                }
+            }
+        }
+
+        TAG_ARRAY_I | TAG_ARRAY_M | TAG_ARRAY_T | TAG_ARRAY_S | TAG_ARRAY_SLICE_MIN.. => {
+            let (_, slice_start) = slice_start(tag);
+            let array = obj as *mut Array;
+            debug_assert!(slice_start <= array.len());
+            let array_payload = array.payload_addr();
+            let stop = visit_field_range(ctx, slice_start, array);
+            debug_assert!(stop <= array.len());
+            for i in slice_start..stop {
+                let field_addr = array_payload.add(i);
+                if is_non_null_pointer_field(field_addr) {
+                    visit_ptr_field(ctx, field_addr);
+                }
+            }
+        }
+
+        TAG_MUTBOX => {
+            let mutbox = obj as *mut MutBox;
+            let field_addr = &mut (*mutbox).field;
+            if is_non_null_pointer_field(field_addr) {
+                visit_ptr_field(ctx, field_addr);
+            }
+        }
+
+        TAG_CLOSURE => {
+            let closure = obj as *mut Closure;
+            let closure_payload = closure.payload_addr();
+            for i in 0..closure.size() {
+                let field_addr = closure_payload.add(i);
+                if is_non_null_pointer_field(field_addr) {
+                    visit_ptr_field(ctx, field_addr);
+                }
+            }
+        }
+
+        TAG_SOME => {
+            let some = obj as *mut Some;
+            let field_addr = &mut (*some).field;
+            if is_non_null_pointer_field(field_addr) {
+                visit_ptr_field(ctx, field_addr);
+            }
+        }
+
+        TAG_VARIANT => {
+            let variant = obj as *mut Variant;
+            let field_addr = &mut (*variant).field;
+            if is_non_null_pointer_field(field_addr) {
+                visit_ptr_field(ctx, field_addr);
+            }
+        }
+
+        TAG_REGION => {
+            let region = obj as *mut Region;
+            let field_addr = &mut (*region).vec_pages;
+            if is_non_null_pointer_field(field_addr) {
+                visit_ptr_field(ctx, field_addr);
+            }
+        }
+
+        TAG_CONCAT => {
+            let concat = obj as *mut Concat;
+            let field1_addr = &mut (*concat).text1;
+            if is_non_null_pointer_field(field1_addr) {
+                visit_ptr_field(ctx, field1_addr);
+            }
+            let field2_addr = &mut (*concat).text2;
+            if is_non_null_pointer_field(field2_addr) {
+                visit_ptr_field(ctx, field2_addr);
+            }
+        }
+
+        TAG_BITS64_U | TAG_BITS64_S | TAG_BITS64_F | TAG_BLOB_B | TAG_BLOB_T | TAG_BLOB_P
+        | TAG_BLOB_A | TAG_BIGINT => {
+            // These don't have pointers, skip
+        }
+
+        TAG_FWD_PTR | TAG_ONE_WORD_FILLER | TAG_FREE_SPACE | _ => {
+            rts_trap_with("invalid object tag in visit_pointer_fields");
+        }
+    }
+}
+
+pub unsafe fn is_non_null_pointer_field(field_addr: *mut Value) -> bool {
+    let field_value = *field_addr;
+    field_value.is_non_null_ptr()
+}
diff --git a/src/codegen/compile.ml b/src/codegen/compile_classical.ml
similarity index 87%
rename from src/codegen/compile.ml
rename to src/codegen/compile_classical.ml
index 809404ef7fe..18448230778 100644
--- a/src/codegen/compile.ml
+++ b/src/codegen/compile_classical.ml
@@ -16,12 +16,18 @@ open Mo_types
 open Mo_config
 
 open Wasm_exts.Ast
-open Wasm.Types
 open Source
-
 (* Re-shadow Source.(@@), to get Stdlib.(@@) *)
 let (@@) = Stdlib.(@@)
 
+module Wasm = struct
+include Wasm
+  module Types = Wasm_exts.Types
+  module Values = Wasm_exts.Values
+end
+
+open Wasm.Types
+
 module G = InstrList
 let (^^) = G.(^^) (* is this how we import a single operator from a module that we otherwise use qualified? *)
 
@@ -179,7 +185,7 @@ module StaticBytes = struct
 
   type t_ =
     | I32 of int32
-    (* | I64 of int64 *)
+    | I64 of int64
     | Seq of t
     | Bytes of string
 
@@ -189,7 +195,7 @@ module StaticBytes = struct
 
   let rec add : Buffer.t -> t_ -> unit = fun buf -> function
     | I32 i -> Buffer.add_int32_le buf i
-    (* | I64 i -> Buffer.add_int64_le buf i *)
+    | I64 i -> Buffer.add_int64_le buf i
     | Seq xs -> List.iter (add buf) xs
     | Bytes b -> Buffer.add_string buf b
 
@@ -230,7 +236,7 @@ module Const = struct
     | Blob of string
     | Null
 
-  let lit_eq l1 l2 = match l1, l2 with
+  let lit_eq = function
     | Vanilla i, Vanilla j -> i = j
     | BigInt i, BigInt j -> Big_int.eq_big_int i j
     | Word32 (tyi, i), Word32 (tyj, j) -> tyi = tyj && i = j
@@ -273,34 +279,23 @@ module Const = struct
   *)
 
   type v =
-    | Fun of int32 * (unit -> int32) * fun_rhs (* id is used for equality check, function pointer calculated upon first use *)
+    | Fun of (unit -> int32) * fun_rhs (* function pointer calculated upon first use *)
     | Message of int32 (* anonymous message, only temporary *)
-    | Obj of (string * v) list
+    | Obj of (string * t) list
     | Unit
-    | Array of v list (* immutable arrays *)
-    | Tuple of v list (* non-nullary tuples *)
-    | Tag of (string * v)
-    | Opt of v
+    | Array of t list (* immutable arrays *)
+    | Tuple of t list (* non-nullary tuples *)
+    | Tag of (string * t)
+    | Opt of t
     | Lit of lit
 
-  let rec eq v1 v2 = match v1, v2 with
-    | Fun (id1, _, _), Fun (id2, _, _) -> id1 = id2
-    | Message fi1, Message fi2 -> fi1 = fi2
-    | Obj fields1, Obj fields2 ->
-      let equal_fields (name1, field_value1) (name2, field_value2) = (name1 = name2) && (eq field_value1 field_value2) in
-      List.for_all2 equal_fields fields1 fields2
-    | Unit, Unit -> true
-    | Array elements1, Array elements2 ->
-      List.for_all2 eq elements1 elements2
-    | Tuple elements1, Tuple elements2 ->
-      List.for_all2 eq elements1 elements2
-    | Tag (name1, tag_value1), Tag (name2, tag_value2) ->
-      (name1 = name2) && (eq tag_value1 tag_value2)
-    | Opt opt_value1, Opt opt_value2 -> eq opt_value1 opt_value2
-    | Lit l1, Lit l2 -> lit_eq l1 l2
-    | Fun _, _ | Message _, _ | Obj _, _ | Unit, _ 
-    | Array _, _ | Tuple _, _ | Tag _, _ | Opt _, _ 
-    | Lit _, _ -> false
+  (* A constant known value together with a vanilla pointer.
+     Typically a static memory location, could be an unboxed scalar.
+     Filled on demand.
+   *)
+  and t = (int32 Lib.Promise.t * v)
+
+  let t_of_v v = (Lib.Promise.make (), v)
 
 end (* Const *)
 
@@ -320,7 +315,7 @@ module SR = struct
     | UnboxedWord32 of Type.prim
     | UnboxedFloat64
     | Unreachable
-    | Const of Const.v
+    | Const of Const.t
 
   let unit = UnboxedTuple 0
 
@@ -329,9 +324,16 @@ module SR = struct
   (* Because t contains Const.t, and that contains Const.v, and that contains
      Const.lit, and that contains Big_int, we cannot just use normal `=`. So we
      have to write our own equality.
+
+     This equalty is, I believe, used when joining branches. So for Const, we
+     just compare the promises, and do not descend into the Const.v. This is
+     conservative; the only downside is that if a branch returns different
+     Const.t with (semantically) the same Const.v we do not propagate that as
+     Const, but materialize before the branch.
+     Which is not really expected or important.
   *)
   let eq (t1 : t) (t2 : t) = match t1, t2 with
-    | Const c1, Const c2 -> Const.eq c1 c2
+    | Const (p1, _), Const (p2, _) -> p1 == p2
     | _ -> t1 = t2
 
   let to_var_type : t -> value_type = function
@@ -401,23 +403,7 @@ module E = struct
   type local_names = (int32 * string) list (* For the debug section: Names of locals *)
   type func_with_names = func * local_names
   type lazy_function = (int32, func_with_names) Lib.AllocOnUse.t
-  type type_descriptor = {
-    candid_data_segment : int32;
-    type_offsets_segment : int32;
-    idl_types_segment : int32;
-  }
-  (* Object allocation code. *)
-  type object_allocation = t -> G.t
-  (* Pool of shared objects.
-     Alllocated in the dynamic heap on program initialization/upgrade.
-     Identified by the index position in this list and accessed via the runtime system.
-     Registered as GC root set and replaced on program upgrade. 
-  *)
-  and object_pool = {
-    objects: object_allocation list ref;
-    frozen: bool ref;
-  }
-  and t = {
+  type t = {
     (* Global fields *)
     (* Static *)
     mode : Flags.compile_mode;
@@ -441,9 +427,20 @@ module E = struct
     named_imports : int32 NameEnv.t ref;
     built_in_funcs : lazy_function NameEnv.t ref;
     static_strings : int32 StringEnv.t ref;
-    data_segments : string list ref; (* Passive data segments *)
-    object_pool : object_pool;
-      
+      (* Pool for shared static objects. Their lookup needs to be specifically
+         handled by using the tag and the payload without the forwarding pointer.
+         This is because the forwarding pointer depends on the allocation adddress.
+         The lookup is different to `static_string` that has no such
+         allocation-dependent content and can thus be immediately looked up by
+         the string value. *)
+    object_pool : int32 StringEnv.t ref;
+    end_of_static_memory : int32 ref; (* End of statically allocated memory *)
+    static_memory : (int32 * string) list ref; (* Content of static memory *)
+    static_memory_frozen : bool ref;
+      (* Sanity check: Nothing should bump end_of_static_memory once it has been read *)
+    static_roots : int32 list ref;
+      (* GC roots in static memory. (Everything that may be mutable.) *)
+
     (* Types accumulated in global typtbl (for candid subtype checks)
        See Note [Candid subtype checks]
     *)
@@ -469,21 +466,11 @@ module E = struct
 
     (* requires stable memory (and emulation on wasm targets) *)
     requires_stable_memory : bool ref;
-
-    (* Type descriptor of current program version, created on `conclude_module`. *)
-    global_type_descriptor : type_descriptor option ref;
-
-    (* Counter for deriving a unique id per constant function. *)
-    constant_functions : int32 ref;
   }
 
-  (* Compile-time-known value, either a plain vanilla constant or a shared object. *)
-  type shared_value =
-  | Vanilla of int32
-  | SharedObject of int32 (* index in object pool *)
-  
+
   (* The initial global environment *)
-  let mk_global mode rts trap_with : t = {
+  let mk_global mode rts trap_with dyn_mem : t = {
     mode;
     rts;
     trap_with;
@@ -499,8 +486,11 @@ module E = struct
     named_imports = ref NameEnv.empty;
     built_in_funcs = ref NameEnv.empty;
     static_strings = ref StringEnv.empty;
-    data_segments = ref [];
-    object_pool = { objects = ref []; frozen = ref false };
+    object_pool = ref StringEnv.empty;
+    end_of_static_memory = ref dyn_mem;
+    static_memory = ref [];
+    static_memory_frozen = ref false;
+    static_roots = ref [];
     typtbl_typs = ref [];
     (* Metadata *)
     args = ref None;
@@ -514,8 +504,6 @@ module E = struct
     local_names = ref [];
     features = ref FeatureSet.empty;
     requires_stable_memory = ref false;
-    global_type_descriptor = ref None;
-    constant_functions = ref 0l;
   }
 
   (* This wraps Mo_types.Hash.hash to also record which labels we have seen,
@@ -621,11 +609,6 @@ module E = struct
   let make_lazy_function env name : lazy_function =
     Lib.AllocOnUse.make (fun () -> reserve_fun env name)
 
-  let get_constant_function_id (env : t) : int32 =
-    let id = !(env.constant_functions) in
-    env.constant_functions := (Int32.add id 1l);
-    id
-
   let lookup_built_in (env : t) name : lazy_function =
     match NameEnv.find_opt name !(env.built_in_funcs) with
     | None ->
@@ -708,10 +691,21 @@ module E = struct
   let then_trap_with env msg = G.if0 (trap_with env msg) G.nop
   let else_trap_with env msg = G.if0 G.nop (trap_with env msg)
 
-  let add_data_segment (env : t) data : int32 =
-    let index = List.length !(env.data_segments) in
-    env.data_segments := !(env.data_segments) @ [ data ];
-    Int32.of_int index
+  let reserve_static_memory (env : t) size : int32 =
+    if !(env.static_memory_frozen) then raise (Invalid_argument "Static memory frozen");
+    let ptr = !(env.end_of_static_memory) in
+    let aligned = Int32.logand (Int32.add size 3l) (Int32.lognot 3l) in
+    env.end_of_static_memory := Int32.add ptr aligned;
+    ptr
+
+  let write_static_memory (env : t) ptr data =
+    env.static_memory := !(env.static_memory) @ [ (ptr, data) ];
+    ()
+
+  let add_mutable_static_bytes (env : t) data : int32 =
+    let ptr = reserve_static_memory env (Int32.of_int (String.length data)) in
+    env.static_memory := !(env.static_memory) @ [ (ptr, data) ];
+    Int32.(add ptr ptr_skew) (* Return a skewed pointer *)
 
   let add_fun_ptr (env : t) fi : int32 =
     match FunEnv.find_opt fi !(env.func_ptrs) with
@@ -731,44 +725,50 @@ module E = struct
   let add_static (env : t) (data : StaticBytes.t) : int32 =
     let b = StaticBytes.as_bytes data in
     match StringEnv.find_opt b !(env.static_strings)  with
-    | Some segment_index -> segment_index
+    | Some ptr -> ptr
     | None ->
-      let segment_index = add_data_segment env b  in
-      env.static_strings := StringEnv.add b segment_index !(env.static_strings);
-      segment_index
-
-  let replace_data_segment (env : t) (segment_index : int32) (data : StaticBytes.t) : int32 =
-    let new_value = StaticBytes.as_bytes data in
-    let segment_index = Int32.to_int segment_index in
-    assert (segment_index < List.length !(env.data_segments));
-    env.data_segments := List.mapi (fun index old_value -> 
-      if index = segment_index then
-        (assert (old_value = "");
-        new_value)
-      else 
-        old_value
-      ) !(env.data_segments);
-    Int32.of_int (String.length new_value)
-
-  let get_data_segments (env : t) =
-    !(env.data_segments)
-
-  let object_pool_add (env : t) (allocation : t -> G.t) : int32 =
-    if !(env.object_pool.frozen) then raise (Invalid_argument "Object pool frozen");
-    let index = List.length !(env.object_pool.objects) in
-    env.object_pool.objects := !(env.object_pool.objects) @ [ allocation ];
-    Int32.of_int index
-
-  let object_pool_size (env : t) : int =
-    List.length !(env.object_pool.objects)
-
-  let iterate_object_pool (env : t) f =
-    G.concat_mapi f !(env.object_pool.objects)
+      let ptr = add_mutable_static_bytes env b  in
+      env.static_strings := StringEnv.add b ptr !(env.static_strings);
+      ptr
+
+  let object_pool_find (env: t) (key: string) : int32 option =
+    StringEnv.find_opt key !(env.object_pool)
+
+  let object_pool_add (env: t) (key: string) (ptr : int32)  : unit =
+    env.object_pool := StringEnv.add key ptr !(env.object_pool);
+    ()
+
+  let add_static_unskewed (env : t) (data : StaticBytes.t) : int32 =
+    Int32.add (add_static env data) ptr_unskew
+
+  let get_end_of_static_memory env : int32 =
+    env.static_memory_frozen := true;
+    !(env.end_of_static_memory)
+
+  let add_static_root (env : t) ptr =
+    env.static_roots := ptr :: !(env.static_roots)
+
+  let get_static_roots (env : t) =
+    !(env.static_roots)
+
+  let get_static_memory env =
+    !(env.static_memory)
+
+  let mem_size env =
+    Int32.(add (div (get_end_of_static_memory env) page_size) 1l)
+
+  let gc_strategy_name gc_strategy = match gc_strategy with
+    | Flags.MarkCompact -> "compacting"
+    | Flags.Copying -> "copying"
+    | Flags.Generational -> "generational"
+    | Flags.Incremental -> "incremental"
+    | Flags.Default -> assert false (* Already resolved in `pipeline.ml` *)
 
   let collect_garbage env force =
-    let name = "incremental_gc" in
+    (* GC function name = "schedule_"? ("compacting" | "copying" | "generational" | "incremental") "_gc" *)
+    let name = gc_strategy_name !Flags.gc_strategy in
     let gc_fn = if force || !Flags.force_gc then name else "schedule_" ^ name in
-    call_import env "rts" gc_fn
+    call_import env "rts" (gc_fn ^ "_gc")
 
   (* See Note [Candid subtype checks] *)
   (* NB: we don't bother detecting duplicate registrations here because the code sharing machinery
@@ -798,12 +798,12 @@ module E = struct
   let requires_stable_memory (env : t) =
     !(env.requires_stable_memory)
 
-  let get_memories (env : t) initial_memory_pages =
-    nr {mtype = MemoryType {min = initial_memory_pages; max = None}}
+  let get_memories (env : t) =
+    nr {mtype = MemoryType ({min = Int64.of_int32 (mem_size env); max = None}, I32IndexType)}
     ::
     match mode env with
     | Flags.WASIMode | Flags.WasmMode when !(env.requires_stable_memory) ->
-      [ nr {mtype = MemoryType {min = Int32.zero; max = None}} ]
+      [ nr {mtype = MemoryType ({min = Int64.zero; max = None}, I32IndexType)} ]
     | _ -> []
 end
 
@@ -863,7 +863,18 @@ let compile_xor64_const = function
 let compile_eq64_const i =
   compile_const_64 i ^^
   G.i (Compare (Wasm.Values.I64 I64Op.Eq))
-  
+
+(* more random utilities *)
+
+let bytes_of_int32 (i : int32) : string =
+  let b = Buffer.create 4 in
+  let i = Int32.to_int i in
+  Buffer.add_char b (Char.chr (i land 0xff));
+  Buffer.add_char b (Char.chr ((i lsr 8) land 0xff));
+  Buffer.add_char b (Char.chr ((i lsr 16) land 0xff));
+  Buffer.add_char b (Char.chr ((i lsr 24) land 0xff));
+  Buffer.contents b
+
 (* A common variant of todo *)
 
 let todo_trap env fn se = todo fn se (E.trap_with env ("TODO: " ^ fn))
@@ -921,22 +932,16 @@ let from_0_to_n env mk_body = from_m_to_n env 0l mk_body
 (* Pointer reference and dereference  *)
 
 let load_unskewed_ptr : G.t =
-  G.i (Load {ty = I32Type; align = 2; offset = 0l; sz = None})
+  G.i (Load {ty = I32Type; align = 2; offset = 0L; sz = None})
 
 let store_unskewed_ptr : G.t =
-  G.i (Store {ty = I32Type; align = 2; offset = 0l; sz = None})
+  G.i (Store {ty = I32Type; align = 2; offset = 0L; sz = None})
 
-let load_unskewed_ptr64 : G.t =
-  G.i (Load {ty = I64Type; align = 2; offset = 0l; sz = None})
-
-let store_unskewed_ptr64 : G.t =
-  G.i (Store {ty = I64Type; align = 2; offset = 0l; sz = None})
-  
 let load_ptr : G.t =
-  G.i (Load {ty = I32Type; align = 2; offset = ptr_unskew; sz = None})
+  G.i (Load {ty = I32Type; align = 2; offset = Int64.of_int32 ptr_unskew; sz = None})
 
 let store_ptr : G.t =
-  G.i (Store {ty = I32Type; align = 2; offset = ptr_unskew; sz = None})
+  G.i (Store {ty = I32Type; align = 2; offset = Int64.of_int32 ptr_unskew; sz = None})
 
 module FakeMultiVal = struct
   (* For some use-cases (e.g. processing the compiler output with analysis
@@ -1067,7 +1072,7 @@ module Func = struct
       g3
       g4
     )
-  let [@warning "-8"] _share_code6 sharing env name (p1, p2, p3, p4, p5, p6) retty mk_body =
+  let [@warning "-8"] share_code6 sharing env name (p1, p2, p3, p4, p5, p6) retty mk_body =
     share_code sharing env name [p1; p2; p3; p4; p5; p6] retty (fun env [g1; g2; g3; g4; g5; g6] -> mk_body env
       g1
       g2
@@ -1104,29 +1109,35 @@ module Func = struct
 end (* Func *)
 
 module RTS = struct
-  (* The connection to the C and Rust parts of the RTS *)
-  let system_imports env =
+  let incremental_gc_imports env =
     E.add_func_import env "rts" "initialize_incremental_gc" [] [];
     E.add_func_import env "rts" "schedule_incremental_gc" [] [];
     E.add_func_import env "rts" "incremental_gc" [] [];
     E.add_func_import env "rts" "write_with_barrier" [I32Type; I32Type] [];
     E.add_func_import env "rts" "allocation_barrier" [I32Type] [I32Type];
+    E.add_func_import env "rts" "stop_gc_on_upgrade" [] [];
     E.add_func_import env "rts" "running_gc" [] [I32Type];
-    E.add_func_import env "rts" "register_stable_type" [I32Type; I32Type] [];
-    E.add_func_import env "rts" "load_stable_actor" [] [I32Type];
-    E.add_func_import env "rts" "save_stable_actor" [I32Type] [];
-    E.add_func_import env "rts" "free_stable_actor" [] [];
-    E.add_func_import env "rts" "contains_field" [I32Type; I32Type] [I32Type];
-    E.add_func_import env "rts" "initialize_static_variables" [I32Type] [];
-    E.add_func_import env "rts" "get_static_variable" [I32Type] [I32Type];
-    E.add_func_import env "rts" "set_static_variable" [I32Type; I32Type] [];
-    E.add_func_import env "rts" "set_upgrade_instructions" [I64Type] [];
-    E.add_func_import env "rts" "get_upgrade_instructions" [] [I64Type];
+    ()
+
+  let non_incremental_gc_imports env =
+    E.add_func_import env "rts" "initialize_copying_gc" [] [];
+    E.add_func_import env "rts" "initialize_compacting_gc" [] [];
+    E.add_func_import env "rts" "initialize_generational_gc" [] [];
+    E.add_func_import env "rts" "schedule_copying_gc" [] [];
+    E.add_func_import env "rts" "schedule_compacting_gc" [] [];
+    E.add_func_import env "rts" "schedule_generational_gc" [] [];
+    E.add_func_import env "rts" "copying_gc" [] [];
+    E.add_func_import env "rts" "compacting_gc" [] [];
+    E.add_func_import env "rts" "generational_gc" [] [];
+    E.add_func_import env "rts" "post_write_barrier" [I32Type] [];
+    ()
+
+  (* The connection to the C and Rust parts of the RTS *)
+  let system_imports env =
     E.add_func_import env "rts" "memcpy" [I32Type; I32Type; I32Type] [I32Type]; (* standard libc memcpy *)
     E.add_func_import env "rts" "memcmp" [I32Type; I32Type; I32Type] [I32Type];
     E.add_func_import env "rts" "version" [] [I32Type];
     E.add_func_import env "rts" "parse_idl_header" [I32Type; I32Type; I32Type; I32Type; I32Type] [];
-    E.add_func_import env "rts" "idl_alloc_typtbl" [I32Type; I32Type; I32Type; I32Type; I32Type] [];
     E.add_func_import env "rts" "idl_sub_buf_words" [I32Type; I32Type] [I32Type];
     E.add_func_import env "rts" "idl_sub_buf_init" [I32Type; I32Type; I32Type] [];
     E.add_func_import env "rts" "idl_sub"
@@ -1164,10 +1175,12 @@ module RTS = struct
     E.add_func_import env "rts" "bigint_abs" [I32Type] [I32Type];
     E.add_func_import env "rts" "bigint_leb128_size" [I32Type] [I32Type];
     E.add_func_import env "rts" "bigint_leb128_encode" [I32Type; I32Type] [];
+    E.add_func_import env "rts" "bigint_leb128_stream_encode" [I32Type; I32Type] [];
     E.add_func_import env "rts" "bigint_leb128_decode" [I32Type] [I32Type];
     E.add_func_import env "rts" "bigint_leb128_decode_word64" [I64Type; I64Type; I32Type] [I32Type];
     E.add_func_import env "rts" "bigint_sleb128_size" [I32Type] [I32Type];
     E.add_func_import env "rts" "bigint_sleb128_encode" [I32Type; I32Type] [];
+    E.add_func_import env "rts" "bigint_sleb128_stream_encode" [I32Type; I32Type] [];
     E.add_func_import env "rts" "bigint_sleb128_decode" [I32Type] [I32Type];
     E.add_func_import env "rts" "bigint_sleb128_decode_word64" [I64Type; I64Type; I32Type] [I32Type];
     E.add_func_import env "rts" "leb128_encode" [I32Type; I32Type] [];
@@ -1249,6 +1262,18 @@ module RTS = struct
     E.add_func_import env "rts" "get_heap_size" [] [I32Type];
     E.add_func_import env "rts" "alloc_blob" [I32Type; I32Type] [I32Type];
     E.add_func_import env "rts" "alloc_array" [I32Type; I32Type] [I32Type];
+    E.add_func_import env "rts" "alloc_stream" [I32Type] [I32Type];
+    E.add_func_import env "rts" "stream_write" [I32Type; I32Type; I32Type] [];
+    E.add_func_import env "rts" "stream_write_byte" [I32Type; I32Type] [];
+    E.add_func_import env "rts" "stream_write_text" [I32Type; I32Type] [];
+    E.add_func_import env "rts" "stream_split" [I32Type] [I32Type];
+    E.add_func_import env "rts" "stream_shutdown" [I32Type] [];
+    E.add_func_import env "rts" "stream_reserve" [I32Type; I32Type] [I32Type];
+    E.add_func_import env "rts" "stream_stable_dest" [I32Type; I64Type; I64Type] [];
+    if !Flags.gc_strategy = Flags.Incremental then
+      incremental_gc_imports env
+    else
+      non_incremental_gc_imports env;
     ()
 
 end (* RTS *)
@@ -1262,7 +1287,9 @@ module GC = struct
 
   let register_globals env =
     E.add_global64 env "__mutator_instructions" Mutable 0L;
-    E.add_global64 env "__collector_instructions" Mutable 0L
+    E.add_global64 env "__collector_instructions" Mutable 0L;
+    if !Flags.gc_strategy <> Flags.Incremental then
+      E.add_global32 env "_HP" Mutable 0l
 
   let get_mutator_instructions env =
     G.i (GlobalGet (nr (E.get_global env "__mutator_instructions")))
@@ -1274,6 +1301,17 @@ module GC = struct
   let set_collector_instructions env =
     G.i (GlobalSet (nr (E.get_global env "__collector_instructions")))
 
+  let get_heap_pointer env =
+    if !Flags.gc_strategy <> Flags.Incremental then
+      G.i (GlobalGet (nr (E.get_global env "_HP")))
+    else
+      assert false
+  let set_heap_pointer env =
+    if !Flags.gc_strategy <> Flags.Incremental then
+      G.i (GlobalSet (nr (E.get_global env "_HP")))
+    else
+      assert false
+
   let record_mutator_instructions env =
     match E.mode env with
     | Flags.(ICMode | RefMode)  ->
@@ -1328,39 +1366,50 @@ module Heap = struct
     compile_unboxed_const n ^^
     E.call_import env "rts" "alloc_words"
 
+  let ensure_allocated env =
+    alloc env 0l ^^ G.i Drop (* dummy allocation, ensures that the page HP points into is backed *)
+
   (* Heap objects *)
 
   (* At this level of abstraction, heap objects are just flat arrays of words *)
 
+  let load_field_unskewed (i : int32) : G.t =
+    let offset = Int32.mul word_size i in
+    G.i (Load {ty = I32Type; align = 2; offset = Int64.of_int32 offset; sz = None})
+
   let load_field (i : int32) : G.t =
     let offset = Int32.(add (mul word_size i) ptr_unskew) in
-    G.i (Load {ty = I32Type; align = 2; offset; sz = None})
+    G.i (Load {ty = I32Type; align = 2; offset = Int64.of_int32 offset; sz = None})
 
   let store_field (i : int32) : G.t =
     let offset = Int32.(add (mul word_size i) ptr_unskew) in
-    G.i (Store {ty = I32Type; align = 2; offset; sz = None})
+    G.i (Store {ty = I32Type; align = 2; offset = Int64.of_int32 offset; sz = None})
 
   (* Although we occasionally want to treat two consecutive
      32 bit fields as one 64 bit number *)
 
-  (* Requires little-endian encoding *)
+  (* Requires little-endian encoding, see also `Stream` in `types.rs` *)
+  let load_field64_unskewed (i : int32) : G.t =
+    let offset = Int32.mul word_size i in
+    G.i (Load {ty = I64Type; align = 2; offset = Int64.of_int32 offset; sz = None})
+
   let load_field64 (i : int32) : G.t =
     let offset = Int32.(add (mul word_size i) ptr_unskew) in
-    G.i (Load {ty = I64Type; align = 2; offset; sz = None})
+    G.i (Load {ty = I64Type; align = 2; offset = Int64.of_int32 offset; sz = None})
 
   let store_field64 (i : int32) : G.t =
     let offset = Int32.(add (mul word_size i) ptr_unskew) in
-    G.i (Store {ty = I64Type; align = 2; offset; sz = None})
+    G.i (Store {ty = I64Type; align = 2; offset = Int64.of_int32 offset; sz = None})
 
   (* Or even as a single 64 bit float *)
 
   let load_field_float64 (i : int32) : G.t =
     let offset = Int32.(add (mul word_size i) ptr_unskew) in
-    G.i (Load {ty = F64Type; align = 2; offset; sz = None})
+    G.i (Load {ty = F64Type; align = 2; offset = Int64.of_int32 offset; sz = None})
 
   let store_field_float64 (i : int32) : G.t =
     let offset = Int32.(add (mul word_size i) ptr_unskew) in
-    G.i (Store {ty = F64Type; align = 2; offset; sz = None})
+    G.i (Store {ty = F64Type; align = 2; offset = Int64.of_int32 offset; sz = None})
 
   (* Convenience functions related to memory *)
   (* Copying bytes (works on unskewed memory addresses) *)
@@ -1381,10 +1430,6 @@ module Heap = struct
   let get_heap_size env =
     E.call_import env "rts" "get_heap_size"
 
-  let get_static_variable env index = 
-    compile_unboxed_const index ^^
-    E.call_import env "rts" "get_static_variable"
-
 end (* Heap *)
 
 module Stack = struct
@@ -1401,10 +1446,12 @@ module Stack = struct
      grows downwards.)
   *)
 
-  (* Predefined constant stack size of 4MB, according to the persistent memory layout. *)
-  let stack_size = 4 * 1024 * 1024
+  let rts_stack_pages () = match !Flags.rts_stack_pages with
+  | None -> assert false (* Already resolved by `pipeline.ml` *)
+  | Some pages -> pages
 
-  let end_ () = Int32.of_int stack_size 
+  let end_ () = 
+    Int32.mul (Int32.of_int (rts_stack_pages ())) page_size
 
   let register_globals env =
     (* stack pointer *)
@@ -1449,14 +1496,14 @@ module Stack = struct
     Func.share_code0 Func.Never env "stack_overflow" [] (fun env ->
       (* read last word of reserved page to force trap *)
       compile_unboxed_const 0xFFFF_FFFCl ^^
-      G.i (Load {ty = I32Type; align = 2; offset = 0l; sz = None}) ^^
+      G.i (Load {ty = I32Type; align = 2; offset = 0L; sz = None}) ^^
       G.i Unreachable
     )
 
   let alloc_words env n =
     let n_bytes = Int32.mul n Heap.word_size in
     (* avoid absurd allocations *)
-    assert (Int32.(to_int n_bytes) < stack_size);
+    assert Int32.(to_int n_bytes < (rts_stack_pages ()) * to_int page_size);
     (* alloc words *)
     get_stack_ptr env ^^
     compile_unboxed_const n_bytes ^^
@@ -1544,7 +1591,7 @@ module Stack = struct
     alloc_words env (Int32.add n 1l) ^^
     (* store the current frame_ptr at offset 0*)
     get_frame_ptr env ^^
-    G.i (Store {ty = I32Type; align = 2; offset = 0l; sz = None}) ^^
+    G.i (Store {ty = I32Type; align = 2; offset = 0L; sz = None}) ^^
     get_stack_ptr env ^^
     (* set_frame_ptr to stack_ptr *)
     set_frame_ptr env ^^
@@ -1557,7 +1604,7 @@ module Stack = struct
     E.else_trap_with env "frame_ptr <> stack_ptr" ^^
     (* restore the saved frame_ptr *)
     get_frame_ptr env ^^
-    G.i (Load {ty = I32Type; align = 2; offset = 0l; sz = None}) ^^
+    G.i (Load {ty = I32Type; align = 2; offset = 0L; sz = None}) ^^
     set_frame_ptr env ^^
     (* free the frame *)
     free_words env (Int32.add n 1l)
@@ -1566,15 +1613,15 @@ module Stack = struct
   let get_local env n =
     let offset = Int32.mul (Int32.add n 1l) Heap.word_size in
     get_frame_ptr env ^^
-      G.i (Load { ty = I32Type; align = 2; offset; sz = None})
+      G.i (Load { ty = I32Type; align = 2; offset = Int64.of_int32 offset; sz = None})
 
   (* read local n of previous frame *)
   let get_prev_local env n =
     let offset = Int32.mul (Int32.add n 1l) Heap.word_size in
     (* indirect through save frame_ptr at offset 0 *)
     get_frame_ptr env ^^
-    G.i (Load { ty = I32Type; align = 2; offset = 0l; sz = None}) ^^
-    G.i (Load { ty = I32Type; align = 2; offset; sz = None})
+    G.i (Load { ty = I32Type; align = 2; offset = 0L; sz = None}) ^^
+    G.i (Load { ty = I32Type; align = 2; offset = Int64.of_int32 offset; sz = None})
 
   (* set local n of current frame *)
   let set_local env n =
@@ -1583,7 +1630,7 @@ module Stack = struct
       (fun env get_val ->
          get_frame_ptr env ^^
          get_val ^^
-         G.i (Store { ty = I32Type; align = 2; offset; sz = None}))
+         G.i (Store { ty = I32Type; align = 2; offset = Int64.of_int32 offset; sz = None}))
 
 end (* Stack *)
 
@@ -1934,6 +1981,7 @@ end (* BitTagged *)
 
 module Tagged = struct
   (* Tagged objects all have an object header consisting of a tag and a forwarding pointer.
+     The forwarding pointer is only reserved if compiled for the incremental GC.
      The tag is to describe their runtime type and serves to traverse the heap
      (serialization, GC), but also for objectification of arrays.
 
@@ -1946,9 +1994,15 @@ module Tagged = struct
      │ tag  │ fwd ptr │ ...
      └──────┴─────────┴──
 
+     The copying GC requires that all tagged objects in the dynamic heap space have at least
+     two words in order to replace them by `Indirection`. This condition is except for `Null`
+     that only lives in static heap space and is therefore not replaced by `Indirection` during
+     copying GC.
+
      Attention: This mapping is duplicated in these places
        * here
        * motoko-rts/src/types.rs
+       * motoko-rts/src/stream.rs
        * motoko-rts/src/text.rs
        * motoko-rts/src/memory.rs
        * motoko-rts/src/bigint.rs
@@ -1986,6 +2040,7 @@ module Tagged = struct
     | Bits32 of bits_sort (* Contains a 32 bit value *)
     | BigInt
     | Concat (* String concatenation, used by rts/text.c *)
+    | Null (* For opt. Static singleton! *)
     | OneWordFiller (* Only used by the RTS *)
     | FreeSpace (* Only used by the RTS *)
     | Region
@@ -1998,6 +2053,8 @@ module Tagged = struct
 
      (Reminder: objects and fields are word-aligned so will have the lowest two
      bits unset) *)
+  (* Reordered with combined modes of classical and enhanced orthogonal persistence,
+     see `types.rs` *)
   let int_of_tag = function
     | Object -> 1l
     | Array I -> 3l
@@ -2016,63 +2073,80 @@ module Tagged = struct
     | Blob P -> 29l
     | Blob A -> 31l
     | Indirection -> 33l
-    | Bits32 U -> 35l
-    | Bits32 S -> 37l
-    | Bits32 F -> 39l
-    | BigInt -> 41l
-    | Concat -> 43l
-    | Region -> 45l
-    | OneWordFiller -> 47l
-    | FreeSpace -> 49l
-    | ArraySliceMinimum -> 50l
+    | BigInt -> 35l
+    | Concat -> 37l
+    | Region -> 39l
+    (* Only used during 32-bit classical persistence mode. *)
+    | Bits32 U -> 41l
+    | Bits32 S -> 43l
+    | Bits32 F -> 45l
+    | Null -> 47l
+    (* RTS-internal *)
+    | OneWordFiller -> 49l
+    | FreeSpace -> 51l
+    | ArraySliceMinimum -> 52l
     (* Next two tags won't be seen by the GC, so no need to set the lowest bit
        for `CoercionFailure` and `StableSeen` *)
     | CoercionFailure -> 0xfffffffel
     | StableSeen -> 0xffffffffl
 
-  (*
-     The null pointer is the sentinel `0xffff_fffbl` (skewed representation).
-    
-     This serves for efficient null tests by using direct pointer comparison.
-     The null pointer must not be dereferenced.
-     Null tests are possible without resolving the forwarding pointer of a non-null comparand.
-  *)
-
-  let null_vanilla_pointer = 0xffff_fffbl (* skewed, pointing to last unallocated Wasm page *)
-  let null_pointer = compile_unboxed_const null_vanilla_pointer
-
-  let is_null env = compile_eq_const null_vanilla_pointer
+  (* Declare `env` for lazy computation of the header size when the compile environment with compile flags are defined *)
+  let header_size env =
+    if !Flags.gc_strategy = Flags.Incremental then 2l else 1l
 
-  let not_null env =
-    (* null test works without forwarding pointer resolution of a non-null comparand *)
-    null_pointer ^^ 
-    G.i (Compare (Wasm.Values.I32 I32Op.Ne))  
-
-  let header_size = 2l
-  
   (* The tag *)
   let tag_field = 0l
-  let forwarding_pointer_field = 1l
+  let forwarding_pointer_field env =
+    assert (!Flags.gc_strategy = Flags.Incremental);
+    1l
 
   (* Note: post-allocation barrier must be applied after initialization *)
   let alloc env size tag =
     assert (size > 1l);
     let name = Printf.sprintf "alloc_size<%d>_tag<%d>" (Int32.to_int size) (Int32.to_int (int_of_tag tag)) in
-
+    (* Computes a (conservative) mask for the bumped HP, so that the existence of non-zero bits under it
+       guarantees that a page boundary crossing didn't happen (i.e. no ripple-carry). *)
+    let overflow_mask increment =
+      let n = Int32.to_int increment in
+      assert (n > 0 && n < 0x8000);
+      let page_mask = Int32.sub page_size 1l in
+      (* We can extend the mask to the right if the bump increment is a power of two. *)
+      let ext = if Numerics.Nat16.(to_int (popcnt (of_int n))) = 1 then increment else 0l in
+      Int32.(logor ext (logand page_mask (shift_left minus_one (16 - Numerics.Nat16.(to_int (clz (of_int n))))))) in
+    (* always inline *)
     Func.share_code0 Func.Never env name [I32Type] (fun env ->
       let set_object, get_object = new_local env "new_object" in
-      Heap.alloc env size ^^
+      let size_in_bytes = Int32.(mul size Heap.word_size) in
+      let half_page_size = Int32.div page_size 2l in
+      (if !Flags.gc_strategy <> Flags.Incremental && size_in_bytes < half_page_size then
+         GC.get_heap_pointer env ^^
+         GC.get_heap_pointer env ^^
+         compile_add_const size_in_bytes ^^
+         GC.set_heap_pointer env ^^
+         GC.get_heap_pointer env ^^
+         compile_bitand_const (overflow_mask size_in_bytes) ^^
+         G.if0
+           G.nop (* no page crossing *)
+           (Heap.ensure_allocated env) (* ensure that HP's page is allocated *)
+       else
+         Heap.alloc env size) ^^
       set_object ^^ get_object ^^
       compile_unboxed_const (int_of_tag tag) ^^
       Heap.store_field tag_field ^^
-      get_object ^^ (* object pointer *)
-      get_object ^^ (* forwarding pointer *)
-      Heap.store_field forwarding_pointer_field ^^
+      (if !Flags.gc_strategy = Flags.Incremental then
+        get_object ^^ (* object pointer *)
+        get_object ^^ (* forwarding pointer *)
+        Heap.store_field (forwarding_pointer_field env)
+      else
+        G.nop) ^^
       get_object
     )
 
   let load_forwarding_pointer env =
-    Heap.load_field forwarding_pointer_field
+    (if !Flags.gc_strategy = Flags.Incremental then
+      Heap.load_field (forwarding_pointer_field env)
+    else
+      G.nop)
 
   let store_tag env tag =
     load_forwarding_pointer env ^^
@@ -2101,29 +2175,33 @@ module Tagged = struct
       G.nop
 
   let check_forwarding env unskewed =
-    let name = "check_forwarding_" ^ if unskewed then "unskewed" else "skewed" in
-    Func.share_code1 Func.Always env name ("object", I32Type) [I32Type] (fun env get_object ->
-      let set_object = G.setter_for get_object in
-      (if unskewed then
+    (if !Flags.gc_strategy = Flags.Incremental then
+      let name = "check_forwarding_" ^ if unskewed then "unskewed" else "skewed" in
+      Func.share_code1 Func.Always env name ("object", I32Type) [I32Type] (fun env get_object ->
+        let set_object = G.setter_for get_object in
+        (if unskewed then
+          get_object ^^
+          compile_unboxed_const ptr_skew ^^
+          G.i (Binary (Wasm.Values.I32 I32Op.Add)) ^^
+          set_object
+        else G.nop) ^^
         get_object ^^
-        compile_unboxed_const ptr_skew ^^
-        G.i (Binary (Wasm.Values.I32 I32Op.Add)) ^^
-        set_object
-      else G.nop) ^^
-      get_object ^^
-      load_forwarding_pointer env ^^
-      get_object ^^
-      G.i (Compare (Wasm.Values.I32 I32Op.Eq)) ^^
-      E.else_trap_with env "missing object forwarding" ^^
-      get_object ^^
-      (if unskewed then
-        compile_unboxed_const ptr_unskew ^^
-        G.i (Binary (Wasm.Values.I32 I32Op.Add))
-      else G.nop))
-  
+        load_forwarding_pointer env ^^
+        get_object ^^
+        G.i (Compare (Wasm.Values.I32 I32Op.Eq)) ^^
+        E.else_trap_with env "missing object forwarding" ^^
+        get_object ^^
+        (if unskewed then
+          compile_unboxed_const ptr_unskew ^^
+          G.i (Binary (Wasm.Values.I32 I32Op.Add))
+        else G.nop))
+    else G.nop)
+
   let check_forwarding_for_store env typ =
-    let (set_value, get_value, _) = new_local_ env typ "value" in
-    set_value ^^ check_forwarding env false ^^ get_value
+    (if !Flags.gc_strategy = Flags.Incremental then
+      let (set_value, get_value, _) = new_local_ env typ "value" in
+      set_value ^^ check_forwarding env false ^^ get_value
+    else G.nop)
 
   let load_field env index =
     (if !Flags.sanity then check_forwarding env false else G.nop) ^^
@@ -2133,6 +2211,14 @@ module Tagged = struct
     (if !Flags.sanity then check_forwarding_for_store env I32Type else G.nop) ^^
     Heap.store_field index
 
+  let load_field_unskewed env index =
+    (if !Flags.sanity then check_forwarding env true else G.nop) ^^
+    Heap.load_field_unskewed index
+
+  let load_field64_unskewed env index =
+    (if !Flags.sanity then check_forwarding env true else G.nop) ^^
+    Heap.load_field64_unskewed index
+
   let load_field64 env index =
     (if !Flags.sanity then check_forwarding env false else G.nop) ^^
     Heap.load_field64 index
@@ -2166,7 +2252,10 @@ module Tagged = struct
     go cases
 
   let allocation_barrier env =
-    E.call_import env "rts" "allocation_barrier"
+    (if !Flags.gc_strategy = Flags.Incremental then
+      E.call_import env "rts" "allocation_barrier"
+    else
+      G.nop)
 
   let write_with_barrier env =
     let (set_value, get_value) = new_local env "written_value" in
@@ -2184,29 +2273,46 @@ module Tagged = struct
 
   let obj env tag element_instructions : G.t =
     let n = List.length element_instructions in
-    let size = (Int32.add (Wasm.I32.of_int_u n) header_size) in
+    let size = (Int32.add (Wasm.I32.of_int_u n) (header_size env)) in
     let (set_object, get_object) = new_local env "new_object" in
     alloc env size tag ^^
     set_object ^^
     let init_elem idx instrs : G.t =
       get_object ^^
       instrs ^^
-      Heap.store_field (Int32.add (Wasm.I32.of_int_u idx) header_size)
+      Heap.store_field (Int32.add (Wasm.I32.of_int_u idx) (header_size env))
     in
     G.concat_mapi init_elem element_instructions ^^
     get_object ^^
     allocation_barrier env
 
-  let shared_object env allocation =
-    let index = E.object_pool_add env allocation in
-    E.SharedObject index
-
-  let materialize_shared_value env = function
-  | E.Vanilla vanilla -> compile_unboxed_const vanilla
-  | E.SharedObject index -> Heap.get_static_variable env index
-
-  let share env allocation =
-    materialize_shared_value env (shared_object env allocation)
+  let new_static_obj env tag payload =
+    let payload = StaticBytes.as_bytes payload in
+    let header_size = Int32.(mul Heap.word_size (header_size env)) in
+    let size = Int32.(add header_size (Int32.of_int (String.length payload))) in
+    let unskewed_ptr = E.reserve_static_memory env size in
+    let skewed_ptr = Int32.(add unskewed_ptr ptr_skew) in
+    let tag = bytes_of_int32 (int_of_tag tag) in
+    let forward = bytes_of_int32 skewed_ptr in (* forwarding pointer *)
+    (if !Flags.gc_strategy = Flags.Incremental then
+      let incremental_gc_data = tag ^ forward ^ payload in
+      E.write_static_memory env unskewed_ptr incremental_gc_data
+    else
+      let non_incremental_gc_data = tag ^ payload in
+      E.write_static_memory env unskewed_ptr non_incremental_gc_data
+    );
+    skewed_ptr
+
+  let shared_static_obj env tag payload =
+    let tag_word = bytes_of_int32 (int_of_tag tag) in
+    let payload_bytes = StaticBytes.as_bytes payload in
+    let key = tag_word ^ payload_bytes in
+    match E.object_pool_find env key with
+    | Some ptr -> ptr (* no forwarding pointer dereferencing needed as static objects do not move *)
+    | None ->
+      let ptr = new_static_obj env tag payload in
+      E.object_pool_add env key ptr;
+      ptr
 
 end (* Tagged *)
 
@@ -2219,6 +2325,7 @@ module MutBox = struct
        └──────┴─────┴─────────┘
 
      The object header includes the obj tag (MutBox) and the forwarding pointer.
+     The forwarding pointer is only reserved if compiled for the incremental GC.
   *)
 
   let field = Tagged.header_size
@@ -2226,27 +2333,38 @@ module MutBox = struct
   let alloc env =
     Tagged.obj env Tagged.MutBox [ compile_unboxed_zero ]
 
+  let static env =
+    let ptr = Tagged.new_static_obj env Tagged.MutBox StaticBytes.[
+      I32 0l; (* zero *)
+    ] in
+    E.add_static_root env ptr;
+    ptr
+
   let load_field env =
     Tagged.load_forwarding_pointer env ^^
-    Tagged.load_field env field
+    Tagged.load_field env (field env)
 
   let store_field env =
     let (set_mutbox_value, get_mutbox_value) = new_local env "mutbox_value" in
     set_mutbox_value ^^
     Tagged.load_forwarding_pointer env ^^
     get_mutbox_value ^^
-    Tagged.store_field env field
-  
-  let add_global_mutbox env =
-    E.object_pool_add env alloc
+    Tagged.store_field env (field env)
 end
 
 
 module Opt = struct
   (* The Option type. Optional values are represented as
 
-    1. The null literal being the sentinel null pointer value, see above.
-       
+    1. ┌──────┐
+       │ null │
+       └──────┘
+
+       A special null value. It is fully static, and because it is unique, can
+       be recognized by pointer comparison (only the GC will care about the heap
+       tag).
+
+
     2. ┌──────┬─────────┐
        │ some │ payload │
        └──────┴─────────┘
@@ -2268,14 +2386,21 @@ module Opt = struct
 
   let some_payload_field = Tagged.header_size
 
-  let null_vanilla_lit = Tagged.null_vanilla_pointer
-  let null_lit env = Tagged.null_pointer
+  (* This relies on the fact that add_static deduplicates *)
+  let null_vanilla_lit env : int32 =
+    Tagged.shared_static_obj env Tagged.Null []
+
+  let null_lit env =
+    compile_unboxed_const (null_vanilla_lit env)
 
-  let is_null = Tagged.is_null
-  let is_some = Tagged.not_null
+  let vanilla_lit env ptr : int32 =
+    Tagged.shared_static_obj env Tagged.Some StaticBytes.[
+      I32 ptr
+    ]
 
-  let alloc_some env get_payload =
-    Tagged.obj env Tagged.Some [ get_payload ]
+ let is_some env =
+    null_lit env ^^
+    G.i (Compare (Wasm.Values.I32 I32Op.Ne))
 
   let inject env e =
     e ^^
@@ -2285,26 +2410,19 @@ module Opt = struct
         ( get_x ^^ BitTagged.is_true_literal env ^^ (* exclude true literal since `branch_default` follows the forwarding pointer *)
           E.if_ env [I32Type]
             ( get_x ) (* true literal, no wrapping *)
-            ( get_x ^^ is_some env ^^
-              E.if_ env [I32Type]
-                ( get_x ^^ Tagged.branch_default env [I32Type]
-                  ( get_x ) (* default tag, no wrapping *)
-                  [ Tagged.Some, alloc_some env get_x ]
-                )
-                ( alloc_some env get_x ) (* ?ⁿnull for n > 0 *)
+            ( get_x ^^ Tagged.branch_default env [I32Type]
+              ( get_x ) (* default tag, no wrapping *)
+              [ Tagged.Null,
+                (* NB: even ?null does not require allocation: We use a static
+                  singleton for that: *)
+                compile_unboxed_const (vanilla_lit env (null_vanilla_lit env))
+              ; Tagged.Some,
+                Tagged.obj env Tagged.Some [get_x]
+              ]
             )
         )
     )
 
-  let constant env = function
-  | E.Vanilla value when value = null_vanilla_lit -> Tagged.shared_object env (fun env -> alloc_some env (null_lit env)) (* ?ⁿnull for n > 0 *)
-  | E.Vanilla value -> E.Vanilla value (* not null and no `Opt` object *)
-  | shared_value ->
-    Tagged.shared_object env (fun env -> 
-      let materialized_value = Tagged.materialize_shared_value env shared_value in  
-      inject env materialized_value (* potentially wrap in new `Opt` *)
-    )
-
   (* This function is used where conceptually, Opt.inject should be used, but
   we know for sure that it wouldn’t do anything anyways, except dereferencing the forwarding pointer *)
   let inject_simple env e =
@@ -2312,7 +2430,7 @@ module Opt = struct
 
   let load_some_payload_field env =
     Tagged.load_forwarding_pointer env ^^
-    Tagged.load_field env some_payload_field
+    Tagged.load_field env (some_payload_field env)
 
   let project env =
     Func.share_code1 Func.Never env "opt_project" ("x", I32Type) [I32Type] (fun env get_x ->
@@ -2323,7 +2441,11 @@ module Opt = struct
             ( get_x ) (* true literal, no wrapping *)
             ( get_x ^^ Tagged.branch_default env [I32Type]
               ( get_x ) (* default tag, no wrapping *)
-              [ Tagged.Some, get_x ^^ load_some_payload_field env ]
+              [ Tagged.Some,
+                get_x ^^ load_some_payload_field env
+              ; Tagged.Null,
+                E.trap_with env "Internal error: opt_project: null!"
+              ]
             )
         )
     )
@@ -2340,10 +2462,11 @@ module Variant = struct
        └──────┴─────┴────────────┴─────────┘
 
      The object header includes the obj tag (TAG_VARIANT) and the forwarding pointer.
+     The forwarding pointer is only reserved if compiled for the incremental GC.
   *)
 
   let variant_tag_field = Tagged.header_size
-  let payload_field = Int32.add variant_tag_field 1l
+  let payload_field env = Int32.add (variant_tag_field env) 1l
 
   let hash_variant_label env : Mo_types.Type.lab -> int32 =
     E.hash env
@@ -2353,17 +2476,23 @@ module Variant = struct
 
   let get_variant_tag env =
     Tagged.load_forwarding_pointer env ^^
-    Tagged.load_field env variant_tag_field
+    Tagged.load_field env (variant_tag_field env)
 
   let project env =
     Tagged.load_forwarding_pointer env ^^
-    Tagged.load_field env payload_field
+    Tagged.load_field env (payload_field env)
 
   (* Test if the top of the stack points to a variant with this label *)
   let test_is env l =
     get_variant_tag env ^^
     compile_eq_const (hash_variant_label env l)
 
+  let vanilla_lit env i ptr =
+    Tagged.shared_static_obj env Tagged.Variant StaticBytes.[
+      I32 (hash_variant_label env i);
+      I32 ptr
+    ]
+
 end (* Variant *)
 
 
@@ -2378,22 +2507,24 @@ module Closure = struct
        └──────┴─────┴───────┴──────┴──────────────┘
 
      The object header includes the object tag (TAG_CLOSURE) and the forwarding pointer.
+     The forwarding pointer is only reserved if compiled for the incremental GC.
+
   *)
-  let header_size = Int32.add Tagged.header_size 2l
+  let header_size env = Int32.add (Tagged.header_size env) 2l
 
   let funptr_field = Tagged.header_size
-  let len_field = Int32.add 1l Tagged.header_size
+  let len_field env = Int32.add 1l (Tagged.header_size env)
 
   let load_data env i =
     Tagged.load_forwarding_pointer env ^^
-    Tagged.load_field env (Int32.add header_size i)
+    Tagged.load_field env (Int32.add (header_size env) i)
 
   let store_data env i =
     let (set_closure_data, get_closure_data) = new_local env "closure_data" in
     set_closure_data ^^
     Tagged.load_forwarding_pointer env ^^
     get_closure_data ^^
-    Tagged.store_field env (Int32.add header_size i)
+    Tagged.store_field env (Int32.add (header_size env) i)
 
   let prepare_closure_call env =
     Tagged.load_forwarding_pointer env
@@ -2411,17 +2542,16 @@ module Closure = struct
       FakeMultiVal.ty (Lib.List.make n_res I32Type))) in
     (* get the table index *)
     Tagged.load_forwarding_pointer env ^^
-    Tagged.load_field env funptr_field ^^
+    Tagged.load_field env (funptr_field env) ^^
     (* All done: Call! *)
     G.i (CallIndirect (nr ty)) ^^
     FakeMultiVal.load env (Lib.List.make n_res I32Type)
 
-  let constant env get_fi =
-    let fi = E.add_fun_ptr env (get_fi ()) in
-    Tagged.shared_object env (fun env -> Tagged.obj env Tagged.Closure [
-      compile_unboxed_const fi;
-      compile_unboxed_const 0l
-    ])
+  let static_closure env fi : int32 =
+    Tagged.shared_static_obj env Tagged.Closure StaticBytes.[
+      I32 (E.add_fun_ptr env fi);
+      I32 0l
+    ]
 
 end (* Closure *)
 
@@ -2439,6 +2569,8 @@ module BoxedWord64 = struct
        └──────┴─────┴─────┴─────┘
 
      The object header includes the object tag (Bits64) and the forwarding pointer.
+     The forwarding pointer is only reserved if compiled for the incremental GC.
+
   *)
 
   let payload_field = Tagged.header_size
@@ -2449,24 +2581,25 @@ module BoxedWord64 = struct
     | Type.Int64 -> Tagged.(Bits64 S)
     | _ -> assert false
 
+  let vanilla_lit env pty i =
+    if BitTagged.can_tag_const pty i
+    then BitTagged.tag_const pty i
+    else
+      Tagged.shared_static_obj env (heap_tag env pty) StaticBytes.[
+        I64 i
+      ]
+
   let compile_box env pty compile_elem : G.t =
     let (set_i, get_i) = new_local env "boxed_i64" in
-    let size = 4l in
+    let size = if !Flags.gc_strategy = Flags.Incremental then 4l else 3l in
     Tagged.alloc env size (heap_tag env pty) ^^
     set_i ^^
-    get_i ^^ compile_elem ^^ Tagged.store_field64 env payload_field ^^
+    get_i ^^ compile_elem ^^ Tagged.store_field64 env (payload_field env) ^^
     get_i ^^
     Tagged.allocation_barrier env
 
-  let constant env pty i =
-    if BitTagged.can_tag_const pty i
-    then 
-      E.Vanilla (BitTagged.tag_const pty i)
-    else
-      Tagged.shared_object env (fun env -> compile_box env pty (compile_const_64 i))
-
-  let box env pty = 
-    Func.share_code1 Func.Never env 
+  let box env pty =
+    Func.share_code1 Func.Never env
       (prim_fun_name pty "box64") ("n", I64Type) [I32Type] (fun env get_n ->
       get_n ^^ BitTagged.if_can_tag_i64 env pty [I32Type]
         (get_n ^^ BitTagged.tag env pty)
@@ -2482,7 +2615,7 @@ module BoxedWord64 = struct
         (get_n ^^
          Tagged.load_forwarding_pointer env ^^
          Tagged.(sanity_check_tag __LINE__ env (heap_tag env pty)) ^^
-         Tagged.load_field64 env payload_field)
+         Tagged.load_field64 env (payload_field env))
     )
 end (* BoxedWord64 *)
 
@@ -2585,23 +2718,22 @@ module BoxedSmallWord = struct
     | Type.Int32 -> Tagged.(Bits32 S)
     | _ -> assert false
 
-  let payload_field = Tagged.header_size
+  let payload_field env = Tagged.header_size env
 
-  let constant env pty i =
+  let vanilla_lit env pty i =
     if BitTagged.can_tag_const pty (Int64.of_int (Int32.to_int i))
-    then
-      E.Vanilla (BitTagged.tag_const pty (Int64.of_int (Int32.to_int i)))
+    then BitTagged.tag_const pty (Int64.of_int (Int32.to_int i))
     else
-      Tagged.shared_object env (fun env -> (Tagged.obj env (heap_tag env pty) [
-        compile_unboxed_const i
-      ]))
+      Tagged.shared_static_obj env (heap_tag env pty) StaticBytes.[
+        I32 i
+      ]
 
   let compile_box env pty compile_elem : G.t =
     let (set_i, get_i) = new_local env "boxed_i32" in
-    let size = 3l in
+    let size = if !Flags.gc_strategy = Flags.Incremental then 3l else 2l in
     Tagged.alloc env size (heap_tag env pty) ^^
     set_i ^^
-    get_i ^^ compile_elem ^^ Tagged.store_field env payload_field ^^
+    get_i ^^ compile_elem ^^ Tagged.store_field env (payload_field env) ^^
     get_i ^^
     Tagged.allocation_barrier env
 
@@ -2622,7 +2754,7 @@ module BoxedSmallWord = struct
         (get_n ^^
          Tagged.load_forwarding_pointer env ^^
          Tagged.(sanity_check_tag __LINE__ env (heap_tag env pty)) ^^
-         Tagged.load_field env payload_field)
+         Tagged.load_field env (payload_field env))
     )
 
   let _lit env pty n = compile_unboxed_const n ^^ box env pty
@@ -2865,30 +2997,32 @@ module Float = struct
      debug inspection (or GC representation change) arises.
 
      The object header includes the object tag (Bits64) and the forwarding pointer.
+     The forwarding pointer is only reserved if compiled for the incremental GC.
   *)
 
-  let payload_field = Tagged.header_size
+  let payload_field env = Tagged.header_size env
 
   let compile_unboxed_const f = G.i (Const (nr (Wasm.Values.F64 f)))
 
+  let vanilla_lit env f =
+    Tagged.shared_static_obj env Tagged.(Bits64 F) StaticBytes.[
+      I64 (Wasm.F64.to_bits f)
+    ]
+
   let box env = Func.share_code1 Func.Never env "box_f64" ("f", F64Type) [I32Type] (fun env get_f ->
     let (set_i, get_i) = new_local env "boxed_f64" in
-    let size = Int32.add Tagged.header_size  2l in
+    let size = Int32.add (Tagged.header_size env)  2l in
     Tagged.alloc env size Tagged.(Bits64 F) ^^
     set_i ^^
-    get_i ^^ get_f ^^ Tagged.store_field_float64 env payload_field ^^
+    get_i ^^ get_f ^^ Tagged.store_field_float64 env (payload_field env) ^^
     get_i ^^
     Tagged.allocation_barrier env
   )
 
-  let unbox env = 
-    Tagged.load_forwarding_pointer env ^^ 
+  let unbox env =
+    Tagged.load_forwarding_pointer env ^^
     Tagged.(sanity_check_tag __LINE__ env (Bits64 F)) ^^
-    Tagged.load_field_float64 env payload_field
-
-  let constant env f = Tagged.shared_object env (fun env -> 
-    compile_unboxed_const f ^^ 
-    box env)
+    Tagged.load_field_float64 env (payload_field env)
 
 end (* Float *)
 
@@ -2914,13 +3048,13 @@ module ReadBuf = struct
   *)
 
   let get_ptr get_buf =
-    get_buf ^^ G.i (Load {ty = I32Type; align = 2; offset = 0l; sz = None})
+    get_buf ^^ G.i (Load {ty = I32Type; align = 2; offset = 0L; sz = None})
   let get_end get_buf =
-    get_buf ^^ G.i (Load {ty = I32Type; align = 2; offset = Heap.word_size; sz = None})
+    get_buf ^^ G.i (Load {ty = I32Type; align = 2; offset = Int64.of_int32 Heap.word_size; sz = None})
   let set_ptr get_buf new_val =
-    get_buf ^^ new_val ^^ G.i (Store {ty = I32Type; align = 2; offset = 0l; sz = None})
+    get_buf ^^ new_val ^^ G.i (Store {ty = I32Type; align = 2; offset = 0L; sz = None})
   let set_end get_buf new_val =
-    get_buf ^^ new_val ^^ G.i (Store {ty = I32Type; align = 2; offset = Heap.word_size; sz = None})
+    get_buf ^^ new_val ^^ G.i (Store {ty = I32Type; align = 2; offset = Int64.of_int32 Heap.word_size; sz = None})
   let set_size get_buf get_size =
     set_end get_buf
       (get_ptr get_buf ^^ get_size ^^ G.i (Binary (Wasm.Values.I32 I32Op.Add)))
@@ -2954,19 +3088,19 @@ module ReadBuf = struct
   let read_byte env get_buf =
     check_space env get_buf (compile_unboxed_const 1l) ^^
     get_ptr get_buf ^^
-    G.i (Load {ty = I32Type; align = 0; offset = 0l; sz = Some Wasm.Types.(Pack8, ZX)}) ^^
+    G.i (Load {ty = I32Type; align = 0; offset = 0L; sz = Some Wasm.Types.(Pack8, ZX)}) ^^
     advance get_buf (compile_unboxed_const 1l)
 
   let read_word16 env get_buf =
     check_space env get_buf (compile_unboxed_const 2l) ^^
     get_ptr get_buf ^^
-    G.i (Load {ty = I32Type; align = 0; offset = 0l; sz = Some Wasm.Types.(Pack16, ZX)}) ^^
+    G.i (Load {ty = I32Type; align = 0; offset = 0L; sz = Some Wasm.Types.(Pack16, ZX)}) ^^
     advance get_buf (compile_unboxed_const 2l)
 
   let read_word32 env get_buf =
     check_space env get_buf (compile_unboxed_const 4l) ^^
     get_ptr get_buf ^^
-    G.i (Load {ty = I32Type; align = 0; offset = 0l; sz = None}) ^^
+    G.i (Load {ty = I32Type; align = 0; offset = 0L; sz = None}) ^^
     advance get_buf (compile_unboxed_const 4l)
 
   let speculative_read_word64 env get_buf =
@@ -2975,19 +3109,19 @@ module ReadBuf = struct
       (compile_const_64 (-1L))
       begin
         get_ptr get_buf ^^
-        G.i (Load {ty = I64Type; align = 0; offset = 0l; sz = None})
+        G.i (Load {ty = I64Type; align = 0; offset = 0L; sz = None})
       end
 
   let read_word64 env get_buf =
     check_space env get_buf (compile_unboxed_const 8l) ^^
     get_ptr get_buf ^^
-    G.i (Load {ty = I64Type; align = 0; offset = 0l; sz = None}) ^^
+    G.i (Load {ty = I64Type; align = 0; offset = 0L; sz = None}) ^^
     advance get_buf (compile_unboxed_const 8l)
 
   let read_float64 env get_buf =
     check_space env get_buf (compile_unboxed_const 8l) ^^
     get_ptr get_buf ^^
-    G.i (Load {ty = F64Type; align = 0; offset = 0l; sz = None}) ^^
+    G.i (Load {ty = F64Type; align = 0; offset = 0L; sz = None}) ^^
     advance get_buf (compile_unboxed_const 8l)
 
   let read_blob env get_buf get_len =
@@ -3008,7 +3142,7 @@ sig
   (* word from SR.Vanilla, trapping, unsigned semantics *)
   val to_word32 : E.t -> G.t
   val to_word64 : E.t -> G.t
-  val to_word32_with : E.t -> G.t -> G.t (* with error message on stack (ptr/len) *)
+  val to_word32_with : E.t -> G.t (* with error message on stack (ptr/len) *)
 
   (* word from SR.Vanilla, lossy, raw bits *)
   val truncate_to_word32 : E.t -> G.t
@@ -3037,6 +3171,13 @@ sig
    *)
   val compile_store_to_data_buf_signed : E.t -> G.t
   val compile_store_to_data_buf_unsigned : E.t -> G.t
+  (* given on stack
+     - numeric object (vanilla, TOS)
+     - (unskewed) stream
+    store the binary representation of the numeric object into the stream
+   *)
+  val compile_store_to_stream_signed : E.t -> G.t
+  val compile_store_to_stream_unsigned : E.t -> G.t
   (* given a ReadBuf on stack, consume bytes from it,
      deserializing to a numeric object
      and leave it on the stack (vanilla).
@@ -3044,8 +3185,8 @@ sig
    *)
   val compile_load_from_data_buf : E.t -> G.t -> bool -> G.t
 
-  (* constant *)
-  val constant : E.t -> Big_int.big_int -> E.shared_value
+  (* literals *)
+  val vanilla_lit : E.t -> Big_int.big_int -> int32
 
   (* arithmetic *)
   val compile_abs : E.t -> G.t
@@ -3375,10 +3516,10 @@ module MakeCompact (Num : BigNumType) : BigNumType = struct
       (get_n ^^ clear_tag env ^^ compile_unboxed_const 0l ^^ G.i (Compare (Wasm.Values.I32 I32Op.LtS)))
       (get_n ^^ Num.compile_is_negative env)
 
-  let constant env = function
+  let vanilla_lit env = function
     | n when Big_int.is_int_big_int n && BitTagged.can_tag_const Type.Int (Big_int.int64_of_big_int n) ->
-      E.Vanilla (BitTagged.tag_const Type.Int (Big_int.int64_of_big_int n))
-    | n -> Num.constant env n
+      BitTagged.tag_const Type.Int (Big_int.int64_of_big_int n)
+    | n -> Num.vanilla_lit env n
 
   let compile_neg env =
     let sminl = Int32.shift_left 1l (BitTagged.sbits_of Type.Int) in
@@ -3595,6 +3736,48 @@ module MakeCompact (Num : BigNumType) : BigNumType = struct
         get_buf ^^ get_x ^^ Num.compile_store_to_data_buf_signed env)
       env
 
+  let compile_store_to_stream_unsigned env =
+    let set_x, get_x = new_local env "x" in
+    let set_stream, get_stream = new_local env "stream" in
+    set_x ^^ set_stream ^^
+    get_x ^^
+    try_unbox I32Type
+      (fun env ->
+        BitTagged.untag_i32 __LINE__ env Type.Int ^^ set_x ^^
+        (* get size & reserve & encode *)
+        let dest =
+          get_stream ^^
+          I32Leb.compile_leb128_size get_x ^^
+          E.call_import env "rts" "stream_reserve" in
+        I32Leb.compile_store_to_data_buf_unsigned env get_x dest)
+      (fun env ->
+        G.i Drop ^^
+        get_stream ^^ get_x ^^ Num.compile_store_to_stream_unsigned env ^^
+        compile_unboxed_zero)
+      env ^^
+      G.i Drop
+
+  let compile_store_to_stream_signed env =
+    let set_x, get_x = new_local env "x" in
+    let set_stream, get_stream = new_local env "stream" in
+    set_x ^^ set_stream ^^
+    get_x ^^
+    try_unbox I32Type
+      (fun env ->
+        BitTagged.untag_i32 __LINE__ env Type.Int ^^ set_x ^^
+        (* get size & reserve & encode *)
+        let dest =
+          get_stream ^^
+          I32Leb.compile_sleb128_size get_x ^^
+          E.call_import env "rts" "stream_reserve" in
+        I32Leb.compile_store_to_data_buf_signed env get_x dest)
+      (fun env ->
+        G.i Drop ^^
+        get_stream ^^ get_x ^^ Num.compile_store_to_stream_signed env ^^
+        compile_unboxed_zero)
+      env ^^
+      G.i Drop
+
   let compile_data_size_unsigned env =
     try_unbox I32Type
       (fun _ ->
@@ -3684,19 +3867,21 @@ module MakeCompact (Num : BigNumType) : BigNumType = struct
       (get_a ^^ BitTagged.untag_i32 __LINE__ env Type.Int) (*TBR*)
       (get_a ^^ Num.to_word32 env)
 
-  let to_word32_with env get_err_msg =
+  let to_word32_with env =
     let set_a, get_a = new_local env "a" in
-    set_a ^^ get_a ^^
+    let set_err_msg, get_err_msg = new_local env "err_msg" in
+    set_err_msg ^^ set_a ^^
+    get_a ^^
     BitTagged.if_tagged_scalar env [I32Type]
       (get_a ^^ BitTagged.untag_i32 __LINE__ env Type.Int) (* TBR *)
-      (get_a ^^ Num.to_word32_with env get_err_msg)
+      (get_a ^^ get_err_msg ^^ Num.to_word32_with env)
 end
 
 module BigNumLibtommath : BigNumType = struct
 
   let to_word32 env = E.call_import env "rts" "bigint_to_word32_trap"
   let to_word64 env = E.call_import env "rts" "bigint_to_word64_trap"
-  let to_word32_with env get_err_msg = get_err_msg ^^ E.call_import env "rts" "bigint_to_word32_trap_with"
+  let to_word32_with env = E.call_import env "rts" "bigint_to_word32_trap_with"
 
   let truncate_to_word32 env = E.call_import env "rts" "bigint_to_word32_wrap"
   let truncate_to_word64 env = E.call_import env "rts" "bigint_to_word64_wrap"
@@ -3717,6 +3902,9 @@ module BigNumLibtommath : BigNumType = struct
     get_n ^^ get_buf ^^ E.call_import env "rts" "bigint_leb128_encode" ^^
     get_n ^^ E.call_import env "rts" "bigint_leb128_size"
 
+  let compile_store_to_stream_unsigned env =
+    E.call_import env "rts" "bigint_leb128_stream_encode"
+
   let compile_store_to_data_buf_signed env =
     let (set_buf, get_buf) = new_local env "buf" in
     let (set_n, get_n) = new_local env "n" in
@@ -3724,11 +3912,14 @@ module BigNumLibtommath : BigNumType = struct
     get_n ^^ get_buf ^^ E.call_import env "rts" "bigint_sleb128_encode" ^^
     get_n ^^ E.call_import env "rts" "bigint_sleb128_size"
 
+  let compile_store_to_stream_signed env =
+    E.call_import env "rts" "bigint_sleb128_stream_encode"
+
   let compile_load_from_data_buf env get_data_buf = function
     | false -> get_data_buf ^^ E.call_import env "rts" "bigint_leb128_decode"
     | true -> get_data_buf ^^ E.call_import env "rts" "bigint_sleb128_decode"
 
-  let constant env n =
+  let vanilla_lit env n =
     (* See enum mp_sign *)
     let sign = if Big_int.sign_big_int n >= 0 then 0l else 1l in
 
@@ -3742,19 +3933,22 @@ module BigNumLibtommath : BigNumType = struct
         then []
         else
           let (a, b) = Big_int.quomod_big_int n twoto28 in
-          [ compile_unboxed_const (Big_int.int32_of_big_int b) ] @ go a
+          [ Big_int.int32_of_big_int b ] @ go a
       in go n
     in
     (* how many 32 bit digits *)
     let size = Int32.of_int (List.length limbs) in
 
     (* cf. mp_int in tommath.h *)
-    Tagged.shared_object env (fun env -> Tagged.obj env Tagged.BigInt ([
-      compile_unboxed_const size; (* used *)
-      compile_unboxed_const size; (* size; relying on Heap.word_size == size_of(mp_digit) *)
-      compile_unboxed_const sign;
-      compile_unboxed_const 0l; (* dp; this will be patched in BigInt::mp_int_ptr in the RTS when used *)
-    ] @ limbs))
+    let ptr = Tagged.shared_static_obj env Tagged.BigInt StaticBytes.[
+      I32 size; (* used *)
+      I32 size; (* size; relying on Heap.word_size == size_of(mp_digit) *)
+      I32 sign;
+      I32 0l; (* dp; this will be patched in BigInt::mp_int_ptr in the RTS when used *)
+      i32s limbs
+
+    ] in
+    ptr
 
   let assert_nonneg env =
     Func.share_code1 Func.Never env "assert_nonneg" ("n", I32Type) [I32Type] (fun env get_n ->
@@ -3825,6 +4019,210 @@ module Prim = struct
     TaggedSmallWord.shift_leftWordNtoI32 b
 end (* Prim *)
 
+module Object = struct
+ (* An object with a mutable field1 and immutable field 2 has the following
+    heap layout:
+
+    ┌──────┬─────┬──────────┬──────────┬─────────┬─────────────┬───┐
+    │ obj header │ n_fields │ hash_ptr │ ind_ptr │ field2_data │ … │
+    └──────┴─────┴──────────┴┬─────────┴┬────────┴─────────────┴───┘
+         ┌───────────────────┘          │
+         │   ┌──────────────────────────┘
+         │   ↓
+         │  ╶─┬────────┬─────────────┐
+         │    │ MutBox │ field1_data │
+         ↓    └────────┴─────────────┘
+        ╶─┬─────────────┬─────────────┬───┐
+          │ field1_hash │ field2_hash │ … │
+          └─────────────┴─────────────┴───┘
+
+    The object header includes the object tag (Object) and the forwarding pointer.
+    The forwarding pointer is only reserved if compiled for the incremental GC.
+
+    The field hash array lives in static memory (so no size header needed).
+    The hash_ptr is skewed.
+
+    The field2_data for immutable fields is a vanilla word.
+
+    The field1_data for mutable fields are pointers to a MutBox. This indirection 
+    is a consequence of how we compile object literals with `await` instructions, 
+    as these mutable fields need to be able to alias local mutable variables, e.g.
+    `{ public let f = 1; await async (); public let var v = 2}`.
+    Other use cases are object constructors with public and private mutable fields, 
+    where the physical record only wraps the public fields.
+    Moreover, closures can selectively capture the individual fields instead of 
+    the containing object.
+    Finally, Candid stabilization/destabilization also relies on the indirection 
+    of mutable fields, to reserve and store alias information in those locations.
+
+    We could alternatively switch to an allocate-first approach in the
+    await-translation of objects, and get rid of this indirection -- if it were
+    not for the implementing of sharing of mutable stable values.
+  *)
+
+  let header_size env = Int32.add (Tagged.header_size env) 2l
+
+  (* Number of object fields *)
+  let size_field env = Int32.add (Tagged.header_size env) 0l
+  let hash_ptr_field env = Int32.add (Tagged.header_size env) 1l
+
+  module FieldEnv = Env.Make(String)
+
+  (* This is for static objects *)
+  let vanilla_lit env (fs : (string * int32) list) : int32 =
+    let (hashes, ptrs) = fs
+      |> List.map (fun (n, ptr) -> (Mo_types.Hash.hash n,ptr))
+      |> List.sort compare
+      |> List.split
+    in
+
+    let hash_ptr = E.add_static env StaticBytes.[ i32s hashes ] in
+
+    Tagged.shared_static_obj env Tagged.Object StaticBytes.[
+      I32 (Int32.of_int (List.length fs));
+      I32 hash_ptr;
+      i32s ptrs;
+    ]
+
+  (* This is for non-recursive objects, i.e. ObjNewE *)
+  (* The instructions in the field already create the indirection if needed *)
+  let lit_raw env (fs : (string * (unit -> G.t)) list ) =
+    let name_pos_map =
+      fs |>
+      (* We could store only public fields in the object, but
+         then we need to allocate separate boxes for the non-public ones:
+         List.filter (fun (_, vis, f) -> vis.it = Public) |>
+      *)
+      List.map (fun (n,_) -> (E.hash env n, n)) |>
+      List.sort compare |>
+      List.mapi (fun i (_h,n) -> (n,Int32.of_int i)) |>
+      List.fold_left (fun m (n,i) -> FieldEnv.add n i m) FieldEnv.empty in
+
+    let sz = Int32.of_int (FieldEnv.cardinal name_pos_map) in
+
+    (* Create hash array *)
+    let hashes = fs |>
+      List.map (fun (n,_) -> E.hash env n) |>
+      List.sort compare in
+    let hash_ptr = E.add_static env StaticBytes.[ i32s hashes ] in
+
+    (* Allocate memory *)
+    let (set_ri, get_ri, ri) = new_local_ env I32Type "obj" in
+    Tagged.alloc env (Int32.add (header_size env) sz) Tagged.Object ^^
+    set_ri ^^
+
+    (* Set size *)
+    get_ri ^^
+    compile_unboxed_const sz ^^
+    Tagged.store_field env (size_field env) ^^
+
+    (* Set hash_ptr *)
+    get_ri ^^
+    compile_unboxed_const hash_ptr ^^
+    Tagged.store_field env (hash_ptr_field env) ^^
+
+    (* Write all the fields *)
+    let init_field (name, mk_is) : G.t =
+      (* Write the pointer to the indirection *)
+      get_ri ^^
+      mk_is () ^^
+      let i = FieldEnv.find name name_pos_map in
+      let offset = Int32.add (header_size env) i in
+      Tagged.store_field env offset
+    in
+    G.concat_map init_field fs ^^
+
+    (* Return the pointer to the object *)
+    get_ri ^^
+    Tagged.allocation_barrier env
+
+  (* Returns a pointer to the object field (without following the field indirection) *)
+  let idx_hash_raw env low_bound =
+    let name = Printf.sprintf "obj_idx<%d>" low_bound  in
+    Func.share_code2 Func.Always env name (("x", I32Type), ("hash", I32Type)) [I32Type] (fun env get_x get_hash ->
+      let set_x = G.setter_for get_x in
+      let set_h_ptr, get_h_ptr = new_local env "h_ptr" in
+
+      get_x ^^ Tagged.load_forwarding_pointer env ^^ set_x ^^
+
+      get_x ^^ Tagged.load_field env (hash_ptr_field env) ^^
+
+      (* Linearly scan through the fields (binary search can come later) *)
+      (* unskew h_ptr and advance both to low bound *)
+      compile_add_const Int32.(add ptr_unskew (mul Heap.word_size (of_int low_bound))) ^^
+      set_h_ptr ^^
+      get_x ^^
+      compile_add_const Int32.(mul Heap.word_size (add (header_size env) (of_int low_bound))) ^^
+      set_x ^^
+      G.loop0 (
+          get_h_ptr ^^ load_unskewed_ptr ^^
+          get_hash ^^ G.i (Compare (Wasm.Values.I32 I32Op.Eq)) ^^
+          G.if0
+            (get_x ^^ G.i Return)
+            (get_h_ptr ^^ compile_add_const Heap.word_size ^^ set_h_ptr ^^
+             get_x ^^ compile_add_const Heap.word_size ^^ set_x ^^
+             G.i (Br (nr 1l)))
+        ) ^^
+      G.i Unreachable
+    )
+
+  (* Returns a pointer to the object field (possibly following the indirection) *)
+  let idx_hash env low_bound indirect =
+    if indirect
+    then
+      let name = Printf.sprintf "obj_idx_ind<%d>" low_bound in
+      Func.share_code2 Func.Never env name (("x", I32Type), ("hash", I32Type)) [I32Type] (fun env get_x get_hash ->
+      get_x ^^ get_hash ^^
+      idx_hash_raw env low_bound ^^
+      load_ptr ^^ Tagged.load_forwarding_pointer env ^^
+      compile_add_const (Int32.mul (MutBox.field env) Heap.word_size)
+    )
+    else idx_hash_raw env low_bound
+
+  let field_type env obj_type s =
+    let _, fields = Type.as_obj_sub [s] obj_type in
+    Type.lookup_val_field s fields
+
+  (* Determines whether the field is mutable (and thus needs an indirection) *)
+  let is_mut_field env obj_type s =
+    let _, fields = Type.as_obj_sub [s] obj_type in
+    Type.is_mut (Type.lookup_val_field s fields)
+
+  (* Computes a lower bound for the positional index of a field in an object *)
+  let field_lower_bound env obj_type s =
+    let open Type in
+    let _, fields = as_obj_sub [s] obj_type in
+    List.iter (function {typ = Typ _; _} -> assert false | _ -> ()) fields;
+    let sorted_by_hash =
+      List.sort
+        (fun (h1, _) (h2, _) -> Lib.Uint32.compare h1 h2)
+        (List.map (fun f -> Lib.Uint32.of_int32 (E.hash env f.lab), f) fields) in
+    match Lib.List.index_of s (List.map (fun (_, {lab; _}) -> lab) sorted_by_hash) with
+    | Some i -> i
+    | _ -> assert false
+
+  (* Returns a pointer to the object field (without following the indirection) *)
+  let idx_raw env f =
+    compile_unboxed_const (E.hash env f) ^^
+    idx_hash_raw env 0
+
+  (* Returns a pointer to the object field (possibly following the indirection) *)
+  let idx env obj_type f =
+    compile_unboxed_const (E.hash env f) ^^
+    idx_hash env (field_lower_bound env obj_type f) (is_mut_field env obj_type f)
+
+  (* load the value (or the mutbox) *)
+  let load_idx_raw env f =
+    idx_raw env f ^^
+    load_ptr
+
+  (* load the actual value (dereferencing the mutbox) *)
+  let load_idx env obj_type f =
+    idx env obj_type f ^^
+    load_ptr
+
+end (* Object *)
+
 module Blob = struct
   (* The layout of a blob object is
 
@@ -3833,6 +4231,7 @@ module Blob = struct
      └──────┴─────┴─────────┴──────────────────┘
 
     The object header includes the object tag (Blob) and the forwarding pointer.
+    The forwarding pointer is only reserved if compiled for the incremental GC.
 
     This heap object is used for various kinds of binary, non-pointer data.
 
@@ -3840,12 +4239,12 @@ module Blob = struct
     Unicode.
   *)
 
-  let header_size = Int32.add Tagged.header_size 1l
-  let len_field = Int32.add Tagged.header_size 0l
+  let header_size env = Int32.add (Tagged.header_size env) 1l
+  let len_field env = Int32.add (Tagged.header_size env) 0l
 
   let len env =
     Tagged.load_forwarding_pointer env ^^
-    Tagged.load_field env len_field
+    Tagged.load_field env (len_field env)
 
   let len_nat env =
     Func.share_code1 Func.Never env "blob_len" ("text", I32Type) [I32Type] (fun env get ->
@@ -3854,6 +4253,18 @@ module Blob = struct
       BigNum.from_word32 env
     )
 
+  let vanilla_lit env sort s =
+    Tagged.shared_static_obj env Tagged.(Blob sort) StaticBytes.[
+      I32 (Int32.of_int (String.length s));
+      Bytes s;
+    ]
+
+  let lit env sort s = compile_unboxed_const (vanilla_lit env sort s)
+
+  let lit_ptr_len env s =
+    compile_unboxed_const (Int32.add ptr_unskew (E.add_static env StaticBytes.[Bytes s])) ^^
+    compile_unboxed_const (Int32.of_int (String.length s))
+
   let alloc env sort len =
     compile_unboxed_const Tagged.(int_of_tag (Blob sort)) ^^
     len ^^
@@ -3861,41 +4272,18 @@ module Blob = struct
     (* uninitialized blob payload is allowed by the barrier *)
     Tagged.allocation_barrier env
 
-  let unskewed_payload_offset env = Int32.(add ptr_unskew (mul Heap.word_size header_size))
-  
+  let unskewed_payload_offset env = Int32.(add ptr_unskew (mul Heap.word_size (header_size env)))
+
   let payload_ptr_unskewed env =
     Tagged.load_forwarding_pointer env ^^
     compile_add_const (unskewed_payload_offset env)
 
-  let load_data_segment env sort segment_index data_length =
-    let (set_blob, get_blob) = new_local env "data_segment_blob" in
-    alloc env sort data_length ^^ set_blob ^^
-    get_blob ^^ payload_ptr_unskewed env ^^ (* target address *)
-    compile_unboxed_const 0l ^^ (* data offset *)
-    data_length ^^
-    G.i (MemoryInit (nr segment_index)) ^^
-    get_blob
-
-  let constant env sort payload =
-    Tagged.shared_object env (fun env -> 
-      let blob_length = Int32.of_int (String.length payload) in
-      let segment_index = E.add_static env StaticBytes.[Bytes payload] in
-      load_data_segment env sort segment_index (compile_unboxed_const blob_length)
-    )
-
-  let lit env sort payload =
-    Tagged.materialize_shared_value env (constant env sort payload)
-
   let as_ptr_len env = Func.share_code1 Func.Never env "as_ptr_size" ("x", I32Type) [I32Type; I32Type] (
     fun env get_x ->
       get_x ^^ payload_ptr_unskewed env ^^
       get_x ^^ len env
     )
 
-  let lit_ptr_len env sort s =
-    lit env sort s ^^
-    as_ptr_len env
-  
   let of_ptr_size env = Func.share_code2 Func.Always env "blob_of_ptr_size" (("ptr", I32Type), ("size" , I32Type)) [I32Type] (
     fun env get_ptr get_size ->
       let (set_x, get_x) = new_local env "x" in
@@ -3998,14 +4386,14 @@ module Blob = struct
           payload_ptr_unskewed env ^^
           get_i ^^
           G.i (Binary (Wasm.Values.I32 I32Op.Add)) ^^
-          G.i (Load {ty = I32Type; align = 0; offset = 0l; sz = Some Wasm.Types.(Pack8, ZX)}) ^^
+          G.i (Load {ty = I32Type; align = 0; offset = 0L; sz = Some Wasm.Types.(Pack8, ZX)}) ^^
           set_a ^^
 
           get_y ^^
           payload_ptr_unskewed env ^^
           get_i ^^
           G.i (Binary (Wasm.Values.I32 I32Op.Add)) ^^
-          G.i (Load {ty = I32Type; align = 0; offset = 0l; sz = Some Wasm.Types.(Pack8, ZX)}) ^^
+          G.i (Load {ty = I32Type; align = 0; offset = 0L; sz = Some Wasm.Types.(Pack8, ZX)}) ^^
           set_b ^^
 
           get_a ^^ get_b ^^ G.i (Compare (Wasm.Values.I32 I32Op.Eq)) ^^
@@ -4050,215 +4438,31 @@ module Blob = struct
     set_len ^^
     alloc env Tagged.B get_len ^^ payload_ptr_unskewed env
 
-end (* Blob *)
-
-module Object = struct
-  (* An object with a mutable field1 and immutable field 2 has the following
-     heap layout:
- 
-     ┌──────┬─────┬──────────┬─────────┬─────────────┬───┐
-     │ obj header │ hash_ptr │ ind_ptr │ field2_data │ … │
-     └──────┴─────┴┬─────────┴┬────────┴─────────────┴───┘
-          ┌────────┘          │
-          │   ┌───────────────┘
-          │   ↓
-          │  ╶─┬────────┬─────────────┐
-          │    │ MutBox │ field1_data │
-          ↓    └────────┴─────────────┘
-          ┌─────────────┬─────────────┬─────────────┬───┐
-          │ blob header │ field1_hash │ field2_hash │ … │
-          └─────────────┴─────────────┴─────────────┴───┘        
- 
-     The object header includes the object tag (Object) and the forwarding pointer.
-     The size of the object (number of fields) can be derived from the hash blob via `hash_ptr`.
-
-     The field hashes reside in a blob inside the dynamic heap.
-     The hash blob needs to be tracked by the GC, but not the content of the hash blob.
-     This is because the hash values are plain numbers that would look like skewed pointers.ters.
-     The hash_ptr is skewed.
- 
-     The field2_data for immutable fields is a vanilla word.
- 
-     The field1_data for mutable fields are pointers to a MutBox. This indirection 
-     is a consequence of how we compile object literals with `await` instructions, 
-     as these mutable fields need to be able to alias local mutable variables, e.g.
-     `{ public let f = 1; await async (); public let var v = 2}`.
-     Other use cases are object constructors with public and private mutable fields, 
-     where the physical record only wraps the public fields.
-     Moreover, closures can selectively capture the individual fields instead of 
-     the containing object.
-     Finally, classical Candid stabilization/destabilization also relies on the 
-     indirection of mutable fields, to reserve and store alias information in those 
-     locations.
- 
-     We could alternatively switch to an allocate-first approach in the
-     await-translation of objects, and get rid of this indirection -- if it were
-     not for the implementing of sharing of mutable stable values.
-   *)
- 
-  let header_size = Int32.add Tagged.header_size 1l
- 
-  let hash_ptr_field = Int32.add Tagged.header_size 0l
- 
-  module FieldEnv = Env.Make(String)
-
-  (* This is for non-recursive objects. *)
-  (* The instructions in the field already create the indirection if needed *)
-  let object_builder env (fs : (string * (E.t -> G.t)) list ) =
-    let name_pos_map =
-      fs |>
-        (* We could store only public fields in the object, but
-          then we need to allocate separate boxes for the non-public ones:
-          List.filter (fun (_, vis, f) -> vis.it = Public) |>
-        *)
-        List.map (fun (n,_) -> (E.hash env n, n)) |>
-        List.sort compare |>
-        List.mapi (fun i (_h,n) -> (n,Int32.of_int i)) |>
-        List.fold_left (fun m (n,i) -> FieldEnv.add n i m) FieldEnv.empty in
-
-      let sz = Int32.of_int (FieldEnv.cardinal name_pos_map) in
-
-      (* Create hash blob *)
-      let hashes = fs |>
-        List.map (fun (n,_) -> E.hash env n) |>
-        List.sort compare in
-      let hash_blob =
-        let hash_payload = StaticBytes.[ i32s hashes ] in
-        Blob.constant env Tagged.B (StaticBytes.as_bytes hash_payload)
-      in
-      
-      (fun env -> 
-        (* Allocate memory *)
-        let (set_ri, get_ri, ri) = new_local_ env I32Type "obj" in
-        Tagged.alloc env (Int32.add header_size sz) Tagged.Object ^^
-        set_ri ^^
-
-        (* Set hash_ptr *)
-        get_ri ^^
-        Tagged.materialize_shared_value env hash_blob ^^
-        Tagged.store_field env hash_ptr_field ^^
-
-        (* Write all the fields *)
-        let init_field (name, generate_value) : G.t =
-          (* Write the pointer to the indirection *)
-          get_ri ^^
-          generate_value env ^^
-          let i = FieldEnv.find name name_pos_map in
-          let offset = Int32.add header_size i in
-          Tagged.store_field env offset
-        in
-        G.concat_map init_field fs ^^
-
-        (* Return the pointer to the object *)
-        get_ri ^^
-        Tagged.allocation_barrier env
-      )
-
-  let constant env (fs : (string * E.shared_value) list) =
-    let materialize_fields = List.map (fun (name, value) -> (name, fun env -> Tagged.materialize_shared_value env value)) fs in
-    let allocation = object_builder env materialize_fields in
-    Tagged.shared_object env allocation
-
-  (* This is for non-recursive objects, i.e. ObjNewE *)
-  (* The instructions in the field already create the indirection if needed *)
-  let lit_raw env (fs : (string * (unit -> G.t)) list ) =
-    let materialize_fields = List.map (fun (name, generate_value) -> (name, (fun env -> generate_value ()))) fs in
-    let allocation = object_builder env materialize_fields in
-    allocation env
-
-  (* Reflection used by orthogonal persistence: 
-     Check whether an (actor) object contains a specific field *)
-  let contains_field env field =
-    compile_unboxed_const (E.hash env field) ^^
-    E.call_import env "rts" "contains_field"
- 
-  (* Returns a pointer to the object field (without following the field indirection) *)
-  let idx_hash_raw env low_bound =
-    let name = Printf.sprintf "obj_idx<%d>" low_bound  in
-    Func.share_code2 Func.Always env name (("x", I32Type), ("hash", I32Type)) [I32Type] (fun env get_x get_hash ->
-      let set_x = G.setter_for get_x in
-      let set_h_ptr, get_h_ptr = new_local env "h_ptr" in
-
-      get_x ^^ Tagged.load_forwarding_pointer env ^^ set_x ^^
-
-      get_x ^^ Tagged.load_field env hash_ptr_field ^^
-      Blob.payload_ptr_unskewed env ^^
-
-      (* Linearly scan through the fields (binary search can come later) *)
-      (* unskew h_ptr and advance both to low bound *)
-      compile_add_const Int32.(mul Heap.word_size (of_int low_bound)) ^^
-      set_h_ptr ^^
+  (* TODO: rewrite using MemoryFill *)
+  let clear env =
+    Func.share_code1 Func.Always env "blob_clear" ("x", I32Type) [] (fun env get_x ->
+      let (set_ptr, get_ptr) = new_local env "ptr" in
+      let (set_len, get_len) = new_local env "len" in
       get_x ^^
-      compile_add_const Int32.(mul Heap.word_size (add header_size (of_int low_bound))) ^^
-      set_x ^^
-      G.loop0 (
-          get_h_ptr ^^ load_unskewed_ptr ^^
-          get_hash ^^ G.i (Compare (Wasm.Values.I32 I32Op.Eq)) ^^
-          G.if0
-            (get_x ^^ G.i Return)
-            (get_h_ptr ^^ compile_add_const Heap.word_size ^^ set_h_ptr ^^
-            get_x ^^ compile_add_const Heap.word_size ^^ set_x ^^
-            G.i (Br (nr 1l)))
-        ) ^^
-      G.i Unreachable
-    )
-
-  (* Returns a pointer to the object field (possibly following the indirection) *)
-  let idx_hash env low_bound indirect =
-    if indirect
-    then
-      let name = Printf.sprintf "obj_idx_ind<%d>" low_bound in
-      Func.share_code2 Func.Never env name (("x", I32Type), ("hash", I32Type)) [I32Type] (fun env get_x get_hash ->
-      get_x ^^ get_hash ^^
-      idx_hash_raw env low_bound ^^
-      load_ptr ^^ Tagged.load_forwarding_pointer env ^^
-      compile_add_const (Int32.mul MutBox.field Heap.word_size)
-    )
-    else idx_hash_raw env low_bound
-
-  let field_type env obj_type s =
-    let _, fields = Type.as_obj_sub [s] obj_type in
-    Type.lookup_val_field s fields
-
-  (* Determines whether the field is mutable (and thus needs an indirection) *)
-  let is_mut_field env obj_type s =
-    let _, fields = Type.as_obj_sub [s] obj_type in
-    Type.is_mut (Type.lookup_val_field s fields)
-
-  (* Computes a lower bound for the positional index of a field in an object *)
-  let field_lower_bound env obj_type s =
-    let open Type in
-    let _, fields = as_obj_sub [s] obj_type in
-    List.iter (function {typ = Typ _; _} -> assert false | _ -> ()) fields;
-    let sorted_by_hash =
-      List.sort
-        (fun (h1, _) (h2, _) -> Lib.Uint32.compare h1 h2)
-        (List.map (fun f -> Lib.Uint32.of_int32 (E.hash env f.lab), f) fields) in
-    match Lib.List.index_of s (List.map (fun (_, {lab; _}) -> lab) sorted_by_hash) with
-    | Some i -> i
-    | _ -> assert false
-
-  (* Returns a pointer to the object field (without following the indirection) *)
-  let idx_raw env f =
-    compile_unboxed_const (E.hash env f) ^^
-    idx_hash_raw env 0
+      as_ptr_len env ^^
+      set_len ^^
+      set_ptr ^^
 
-  (* Returns a pointer to the object field (possibly following the indirection) *)
-  let idx env obj_type f =
-    compile_unboxed_const (E.hash env f) ^^
-    idx_hash env (field_lower_bound env obj_type f) (is_mut_field env obj_type f)
+      (* round to word size *)
+      get_len ^^
+      compile_add_const (Int32.sub Heap.word_size 1l) ^^
+      compile_divU_const Heap.word_size ^^
 
-  (* load the value (or the mutbox) *)
-  let load_idx_raw env f =
-    idx_raw env f ^^
-    load_ptr
+      (* clear all words *)
+      from_0_to_n env (fun get_i ->
+        get_ptr ^^
+        compile_unboxed_const 0l ^^
+        store_unskewed_ptr ^^
+        get_ptr ^^
+        compile_add_const Heap.word_size ^^
+        set_ptr))
 
-  (* load the actual value (dereferencing the mutbox) *)
-  let load_idx env obj_type f =
-    idx env obj_type f ^^
-    load_ptr
- 
-end (* Object *) 
+end (* Blob *)
 
 module Region = struct
   (*
@@ -4360,6 +4564,7 @@ module Text = struct
      └──────┴─────┴─────────┴───────┴───────┘
 
     The object header includes the object tag (TAG_CONCAT defined in rts/types.rs) and the forwarding pointer
+    The forwarding pointer is only reserved if compiled for the incremental GC.
 
     This is internal to rts/text.c, with the exception of GC-related code.
   *)
@@ -4392,7 +4597,8 @@ module Text = struct
     get_blob ^^ Blob.as_ptr_len env ^^
     E.call_import env "rts" "utf8_valid" ^^
     G.if1 I32Type
-      (get_blob ^^ Blob.copy env Tagged.B Tagged.T ^^
+      (get_blob ^^ Blob.as_ptr_len env ^^
+       of_ptr_size env ^^ (* creates text blob *)
        set_blob ^^
        Opt.inject_simple env get_blob)
       (Opt.null_lit env)
@@ -4439,32 +4645,33 @@ module Arr = struct
      └──────┴─────┴──────────┴────────┴───┘
 
      The object  header includes the object tag (Array) and the forwarding pointer.
+     The forwarding pointer is only reserved if compiled for the incremental GC.
 
      No difference between mutable and immutable arrays.
   *)
 
   (* NB max_array_size must agree with limit 2^29 imposed by RTS constants.MAX_ARRAY_SIZE *)
-  let max_array_size = Int32.shift_left 1l 29 (* inclusive *)
+  let max_array_size env = Int32.shift_left 1l 29 (* inclusive *)
 
-  let header_size = Int32.add Tagged.header_size 1l
+  let header_size env = Int32.add (Tagged.header_size env) 1l
   let element_size = 4l
-  let len_field = Int32.add Tagged.header_size 0l
+  let len_field env = Int32.add (Tagged.header_size env) 0l
 
   let len env =
     Tagged.load_forwarding_pointer env ^^
-    Tagged.load_field env len_field
+    Tagged.load_field env (len_field env)
 
   (* Static array access. No checking *)
   let load_field env n =
     Tagged.load_forwarding_pointer env ^^
-    Tagged.load_field env Int32.(add n header_size)
+    Tagged.load_field env Int32.(add n (header_size env))
 
   (* Dynamic array access. Returns the address (not the value) of the field.
      Does no bounds checking *)
   let unsafe_idx env =
     Func.share_code2 Func.Never env "Array.unsafe_idx" (("array", I32Type), ("idx", I32Type)) [I32Type] (fun env get_array get_idx ->
       get_idx ^^
-      compile_add_const header_size ^^
+      compile_add_const (header_size env) ^^
       compile_mul_const element_size ^^
       get_array ^^
       Tagged.load_forwarding_pointer env ^^
@@ -4483,7 +4690,7 @@ module Arr = struct
       E.else_trap_with env "Array index out of bounds" ^^
 
       get_idx ^^
-      compile_add_const header_size ^^
+      compile_add_const (header_size env) ^^
       compile_mul_const element_size ^^
       get_array ^^
       Tagged.load_forwarding_pointer env ^^
@@ -4495,7 +4702,8 @@ module Arr = struct
     Func.share_code2 Func.Never env "Array.idx_bigint" (("array", I32Type), ("idx", I32Type)) [I32Type] (fun env get_array get_idx ->
       get_array ^^
       get_idx ^^
-      BigNum.to_word32_with env (Blob.lit env Tagged.T "Array index out of bounds") ^^
+      Blob.lit env Tagged.T "Array index out of bounds" ^^
+      BigNum.to_word32_with env ^^
       idx env
   )
 
@@ -4503,18 +4711,18 @@ module Arr = struct
      | Type.Array element_type -> element_type
      | _ -> assert false
 
+  let vanilla_lit env sort ptrs =
+    Tagged.shared_static_obj env Tagged.(Array sort) StaticBytes.[
+      I32 (Int32.of_int (List.length ptrs));
+      i32s ptrs;
+    ]
+
   (* Compile an array literal. *)
   let lit env sort element_instructions =
     Tagged.obj env Tagged.(Array sort)
      ([ compile_unboxed_const (Wasm.I32.of_int_u (List.length element_instructions))
       ] @ element_instructions)
 
-  let constant env sort elements =
-    Tagged.shared_object env (fun env ->
-      let materialized_elements = List.map (fun element -> Tagged.materialize_shared_value env element) elements in
-      lit env sort materialized_elements
-    )
-
   (* Does not initialize the fields! *)
   (* Note: Post allocation barrier must be applied after initialization *)
   let alloc env array_sort len =
@@ -4530,7 +4738,7 @@ module Arr = struct
     get_array ^^ Tagged.load_forwarding_pointer env ^^ set_array ^^
 
     (* Initial element pointer, skewed *)
-    compile_unboxed_const header_size ^^
+    compile_unboxed_const (header_size env) ^^
     compile_mul_const element_size ^^
     get_array ^^
     G.i (Binary (Wasm.Values.I32 I32Op.Add)) ^^
@@ -4538,7 +4746,7 @@ module Arr = struct
 
     (* Upper pointer boundary, skewed *)
     get_array ^^
-    Tagged.load_field env len_field ^^
+    Tagged.load_field env (len_field env) ^^
     compile_mul_const element_size ^^
     get_pointer ^^
     G.i (Binary (Wasm.Values.I32 I32Op.Add)) ^^
@@ -4634,7 +4842,7 @@ module Arr = struct
         get_r ^^ get_i ^^ unsafe_idx env ^^
         get_blob ^^ Blob.payload_ptr_unskewed env ^^
         get_i ^^ G.i (Binary (Wasm.Values.I32 I32Op.Add)) ^^
-        G.i (Load {ty = I32Type; align = 0; offset = 0l; sz = Some Wasm.Types.(Pack8, ZX)}) ^^
+        G.i (Load {ty = I32Type; align = 0; offset = 0L; sz = Some Wasm.Types.(Pack8, ZX)}) ^^
         TaggedSmallWord.msb_adjust Type.Nat8 ^^
         TaggedSmallWord.tag env Type.Nat8 ^^
         store_ptr
@@ -4658,7 +4866,7 @@ module Arr = struct
         get_a ^^ get_i ^^ unsafe_idx env ^^
         load_ptr ^^
         TaggedSmallWord.lsb_adjust Type.Nat8 ^^
-        G.i (Store {ty = I32Type; align = 0; offset = 0l; sz = Some Wasm.Types.Pack8})
+        G.i (Store {ty = I32Type; align = 0; offset = 0L; sz = Some Wasm.Types.Pack8})
       ) ^^
 
       get_r
@@ -4683,7 +4891,7 @@ module Tuple = struct
   let load_n env n =
     Tagged.load_forwarding_pointer env ^^
     Tagged.(sanity_check_tag __LINE__ env (Array T)) ^^
-    Tagged.load_field env (Int32.add Arr.header_size n)
+    Tagged.load_field env (Int32.add (Arr.header_size env) n)
 
   (* Takes n elements of the stack and produces an argument tuple *)
   let from_stack env n =
@@ -4839,6 +5047,11 @@ module IC = struct
   let i32s n = Lib.List.make n I32Type
   let i64s n = Lib.List.make n I64Type
 
+  let get_actor_to_persist_function_name = "@get_actor_to_persist"
+
+  let get_actor_to_persist env =
+    G.i (Call (nr (E.built_in env get_actor_to_persist_function_name)))
+
   let import_ic0 env =
       E.add_func_import env "ic0" "accept_message" [] [];
       E.add_func_import env "ic0" "call_data_append" (i32s 2) [];
@@ -4912,23 +5125,23 @@ module IC = struct
             (* We use the iovec functionality to append a newline *)
             get_iovec_ptr ^^
             get_ptr ^^
-            G.i (Store {ty = I32Type; align = 2; offset = 0l; sz = None}) ^^
+            G.i (Store {ty = I32Type; align = 2; offset = 0L; sz = None}) ^^
 
             get_iovec_ptr ^^
             get_len ^^
-            G.i (Store {ty = I32Type; align = 2; offset = 4l; sz = None}) ^^
+            G.i (Store {ty = I32Type; align = 2; offset = 4L; sz = None}) ^^
 
             get_iovec_ptr ^^
             get_iovec_ptr ^^ compile_add_const 16l ^^
-            G.i (Store {ty = I32Type; align = 2; offset = 8l; sz = None}) ^^
+            G.i (Store {ty = I32Type; align = 2; offset = 8L; sz = None}) ^^
 
             get_iovec_ptr ^^
             compile_unboxed_const 1l ^^
-            G.i (Store {ty = I32Type; align = 2; offset = 12l; sz = None}) ^^
+            G.i (Store {ty = I32Type; align = 2; offset = 12L; sz = None}) ^^
 
             get_iovec_ptr ^^
             compile_unboxed_const (Int32.of_int (Char.code '\n')) ^^
-            G.i (Store {ty = I32Type; align = 0; offset = 16l; sz = Some Wasm.Types.Pack8}) ^^
+            G.i (Store {ty = I32Type; align = 0; offset = 16L; sz = Some Wasm.Types.Pack8}) ^^
 
             (* Call fd_write twice to work around
                https://github.com/bytecodealliance/wasmtime/issues/629
@@ -4979,7 +5192,7 @@ module IC = struct
 
   (* For debugging *)
   let _compile_static_print env s =
-    Blob.lit_ptr_len env Tagged.T s ^^ print_ptr_len env
+    Blob.lit_ptr_len env s ^^ print_ptr_len env
 
   let ic_trap env = system_call env "trap"
 
@@ -4990,7 +5203,7 @@ module IC = struct
     | Flags.ICMode | Flags.RefMode -> ic_trap env ^^ G.i Unreachable
 
   let trap_with env s =
-    Blob.lit_ptr_len env Tagged.T s ^^ trap_ptr_len env
+    Blob.lit_ptr_len env s ^^ trap_ptr_len env
 
   let trap_text env  =
     Text.to_blob env ^^ Blob.as_ptr_len env ^^ trap_ptr_len env
@@ -5349,18 +5562,18 @@ module Cycles = struct
     (fun env get_ptr ->
      let set_lower, get_lower = new_local env "lower" in
      get_ptr ^^
-     G.i (Load {ty = I64Type; align = 0; offset = 0l; sz = None }) ^^
+     G.i (Load {ty = I64Type; align = 0; offset = 0L; sz = None }) ^^
      BigNum.from_word64 env ^^
      set_lower ^^
      get_ptr ^^
-     G.i (Load {ty = I64Type; align = 0; offset = 8l; sz = None }) ^^
+     G.i (Load {ty = I64Type; align = 0; offset = 8L; sz = None }) ^^
      G.i (Test (Wasm.Values.I64 I64Op.Eqz)) ^^
      G.if1 I32Type
        get_lower
        begin
          get_lower ^^
          get_ptr ^^
-         G.i (Load {ty = I64Type; align = 0; offset = 8l; sz = None }) ^^
+         G.i (Load {ty = I64Type; align = 0; offset = 8L; sz = None }) ^^
          BigNum.from_word64 env ^^
          (* shift left 64 bits *)
          compile_unboxed_const 64l ^^
@@ -5374,7 +5587,7 @@ module Cycles = struct
     let (set_val, get_val) = new_local env "cycles" in
     set_val ^^
     get_val ^^
-    Tagged.materialize_shared_value env (BigNum.constant env (Big_int.power_int_positive_int 2 128)) ^^
+    compile_unboxed_const (BigNum.vanilla_lit env (Big_int.power_int_positive_int 2 128)) ^^
     BigNum.compile_relop env Lt ^^
     E.else_trap_with env "cycles out of bounds" ^^
 
@@ -5526,17 +5739,15 @@ module StableMem = struct
 
   (* Versioning (c.f. Region.rs) *)
   (* NB: these constants must agree with VERSION_NO_STABLE_MEMORY etc. in Region.rs *)
-  let legacy_version_no_stable_memory = Int32.of_int 0 (* never manifest in serialized form *)
-  let legacy_version_some_stable_memory = Int32.of_int 1
-  let legacy_version_regions = Int32.of_int 2
-  let version_stable_heap_no_regions = Int32.of_int 3
-  let version_stable_heap_regions = Int32.of_int 4
-  let version_max = version_stable_heap_regions
+  let version_no_stable_memory = Int32.of_int 0 (* never manifest in serialized form *)
+  let version_some_stable_memory = Int32.of_int 1
+  let version_regions = Int32.of_int 2
+  let version_max = version_regions
 
   let register_globals env =
     (* size (in pages) *)
     E.add_global64 env "__stablemem_size" Mutable 0L;
-    E.add_global32 env "__stablemem_version" Mutable version_stable_heap_no_regions
+    E.add_global32 env "__stablemem_version" Mutable version_no_stable_memory
 
   let get_mem_size env =
     G.i (GlobalGet (nr (E.get_global env "__stablemem_size")))
@@ -5550,10 +5761,6 @@ module StableMem = struct
   let set_version env =
     G.i (GlobalSet (nr (E.get_global env "__stablemem_version")))
 
-  let region_init env =
-    compile_unboxed_const (if !Flags.use_stable_regions then 1l else 0l) ^^
-    E.call_import env "rts" "region_init"
-
   (* stable memory bounds check *)
   let guard env =
        get_mem_size env ^^
@@ -5630,18 +5837,36 @@ module StableMem = struct
             compile_const_64 (Int64.of_int32 bytes) ^^
             stable64_write env))
 
+  let _read_word32 env =
+    read env false "word32" I32Type 4l load_unskewed_ptr
   let write_word32 env =
     write env false "word32" I32Type 4l store_unskewed_ptr
 
-  let write_word64 env =
-    write env false "word64" I64Type 8l store_unskewed_ptr64
 
-  let read_word32 env =
-    read env false "word32" I32Type 4l load_unskewed_ptr
-  
-  let read_word64 env =
-    read env false "word64" I64Type 8l load_unskewed_ptr64
-  
+  (* read and clear word32 from stable mem offset on stack *)
+  let read_and_clear_word32 env =
+      Func.share_code1 Func.Always env "__stablemem_read_and_clear_word32"
+        ("offset", I64Type) [I32Type]
+        (fun env get_offset ->
+          Stack.with_words env "temp_ptr" 1l (fun get_temp_ptr ->
+            let (set_word, get_word) = new_local env "word" in
+            (* read word *)
+            get_temp_ptr ^^ G.i (Convert (Wasm.Values.I64 I64Op.ExtendUI32)) ^^
+            get_offset ^^
+            compile_const_64 4L ^^
+            stable64_read env ^^
+            get_temp_ptr ^^ load_unskewed_ptr ^^
+            set_word ^^
+            (* write 0 *)
+            get_temp_ptr ^^ compile_unboxed_const 0l ^^ store_unskewed_ptr ^^
+            get_offset ^^
+            get_temp_ptr ^^ G.i (Convert (Wasm.Values.I64 I64Op.ExtendUI32)) ^^
+            compile_const_64 4L ^^
+            stable64_write env ^^
+            (* return word *)
+            get_word
+        ))
+
   (* ensure_pages : ensure at least num pages allocated,
      growing (real) stable memory if needed *)
   let ensure_pages env =
@@ -5667,7 +5892,7 @@ module StableMem = struct
              stable64_grow env)
             get_size)
 
-      (* ensure stable memory includes [offset..offset+size), assumes size > 0 *)
+  (* ensure stable memory includes [offset..offset+size), assumes size > 0 *)
   let ensure env =
       Func.share_code2 Func.Always env "__stablemem_ensure"
         (("offset", I64Type), ("size", I64Type)) []
@@ -5746,29 +5971,29 @@ module StableMem = struct
 
   let load_word8 env =
     read env true "word8" I32Type 1l
-      (G.i (Load {ty = I32Type; align = 0; offset = 0l; sz = Some Wasm.Types.(Pack8, ZX)}))
+      (G.i (Load {ty = I32Type; align = 0; offset = 0L; sz = Some Wasm.Types.(Pack8, ZX)}))
   let store_word8 env =
     write env true "word8" I32Type 1l store_unskewed_ptr
 
   let load_word16 env =
     read env true "word16" I32Type 2l
-      (G.i (Load {ty = I32Type; align = 0; offset = 0l; sz = Some Wasm.Types.(Pack16, ZX)}))
+      (G.i (Load {ty = I32Type; align = 0; offset = 0L; sz = Some Wasm.Types.(Pack16, ZX)}))
   let store_word16 env =
     write env true "word16" I32Type 2l store_unskewed_ptr
 
   let load_word64 env =
     read env true "word64" I64Type 8l
-      (G.i (Load {ty = I64Type; align = 0; offset = 0l; sz = None }))
+      (G.i (Load {ty = I64Type; align = 0; offset = 0L; sz = None }))
   let store_word64 env =
     write env true "word64" I64Type 8l
-      (G.i (Store {ty = I64Type; align = 0; offset = 0l; sz = None}))
+      (G.i (Store {ty = I64Type; align = 0; offset = 0L; sz = None}))
 
   let load_float64 env =
     read env true "float64" F64Type 8l
-      (G.i (Load {ty = F64Type; align = 0; offset = 0l; sz = None }))
+      (G.i (Load {ty = F64Type; align = 0; offset = 0L; sz = None }))
   let store_float64 env =
     write env true "float64" F64Type 8l
-      (G.i (Store {ty = F64Type; align = 0; offset = 0l; sz = None}))
+      (G.i (Store {ty = F64Type; align = 0; offset = 0L; sz = None}))
 
   let load_blob env =
       Func.share_code2 Func.Always env "__stablemem_load_blob"
@@ -5806,9 +6031,10 @@ end (* StableMem *)
 (* Core, legacy interface to IC stable memory, used to implement prims `stableMemoryXXX` of
    library `ExperimentalStableMemory.mo`.
    Each operation dispatches on the state of `StableMem.get_version()`.
-   * StableMem.version_stable_heap_no_regions
-     * use StableMem directly.
-   * StableMem.version_stable_heap_regions: use Region.mo
+   * StableMem.version_no_stable_memory/StableMem.version_some_stable_memory:
+     * use StableMem directly
+     * switch to version_some_stable_memory on non-trivial grow.
+   * StableMem.version_regions: use Region.mo
 *)
 module StableMemoryInterface = struct
 
@@ -5817,7 +6043,7 @@ module StableMemoryInterface = struct
 
   let if_regions env args tys is1 is2 =
     StableMem.get_version env ^^
-    compile_unboxed_const StableMem.version_stable_heap_regions ^^
+    compile_unboxed_const StableMem.version_regions ^^
     G.i (Compare (Wasm.Values.I32 I32Op.Eq)) ^^
     E.if_ env tys
       (get_region0 env ^^ args ^^ is1 env)
@@ -5843,8 +6069,27 @@ module StableMemoryInterface = struct
           [I64Type]
           Region.grow
           (fun env ->
+            (* do StableMem.grow, but detect and record change in version as well *)
+            let (set_res, get_res) = new_local64 env "size" in
             (* logical grow *)
-            StableMem.grow env))
+            StableMem.grow env ^^
+            set_res ^^
+            (* if version = version_no_stable_memory and new mem_size > 0
+               then version := version_some_stable_memory *)
+            StableMem.get_version env ^^
+            compile_eq_const StableMem.version_no_stable_memory ^^
+            StableMem.get_mem_size env ^^
+            compile_const_64 0L ^^
+            G.i (Compare (Wasm.Values.I64 I32Op.GtU)) ^^
+            G.i (Binary (Wasm.Values.I32 I32Op.And)) ^^
+            (G.if0
+               begin
+                 compile_unboxed_const StableMem.version_some_stable_memory ^^
+                 StableMem.set_version env
+               end
+               G.nop) ^^
+            (* return res *)
+            get_res))
 
   let load_blob env =
     E.require_stable_memory env;
@@ -5972,23 +6217,6 @@ module StableMemoryInterface = struct
 
 end
 
-module UpgradeStatistics = struct
-  let get_upgrade_instructions env =
-    E.call_import env "rts" "get_upgrade_instructions"
-  let set_upgrade_instructions env =
-    E.call_import env "rts" "set_upgrade_instructions"
-
-  let add_instructions env =
-    get_upgrade_instructions env ^^
-    GC.instruction_counter env ^^
-    G.i (Binary (Wasm.Values.I64 I64Op.Add)) ^^
-    set_upgrade_instructions env
-
-  let set_instructions env =
-    GC.instruction_counter env ^^
-    set_upgrade_instructions env
-end
-
 module RTS_Exports = struct
   (* Must be called late, after main codegen, to ensure correct generation of
      of functioning or unused-but-trapping stable memory exports (as required)
@@ -6048,6 +6276,34 @@ module RTS_Exports = struct
       edesc = nr (FuncExport (nr keep_memory_reserve_fi))
     });
 
+    if !Flags.gc_strategy <> Flags.Incremental then
+    begin
+      let set_hp_fi =
+        E.add_fun env "__set_hp" (
+        Func.of_body env ["new_hp", I32Type] [] (fun env ->
+          G.i (LocalGet (nr 0l)) ^^
+          GC.set_heap_pointer env
+        )
+      ) in
+      E.add_export env (nr {
+        name = Lib.Utf8.decode "setHP";
+        edesc = nr (FuncExport (nr set_hp_fi))
+      });
+
+      let get_hp_fi = E.add_fun env "__get_hp" (
+        Func.of_body env [] [I32Type] (fun env ->
+          GC.get_heap_pointer env
+        )
+      ) in
+      E.add_export env (nr {
+        name = Lib.Utf8.decode "getHP";
+        edesc = nr (FuncExport (nr get_hp_fi))
+      })
+    end;
+
+
+    (* Stable Memory related exports *)
+
     let when_stable_memory_required_else_trap env code =
       if E.requires_stable_memory env then
         code() else
@@ -6099,27 +6355,6 @@ module RTS_Exports = struct
       edesc = nr (FuncExport (nr ic0_stable64_read_fi))
     });
 
-    let ic0_stable64_size_fi =
-      match E.mode env with
-      | Flags.ICMode | Flags.RefMode ->
-        E.reuse_import env "ic0" "stable64_size"
-      | Flags.WASIMode | Flags.WasmMode ->
-        E.add_fun env "ic0_stable64_size" (
-          Func.of_body env [] [I64Type]
-            (fun env ->
-              if E.requires_stable_memory env then
-                StableMem.stable64_size env
-              else
-                (* The RTS also checks the persistence mode on Wasi without stable memory support *)
-                compile_const_64 0L
-            )
-          )
-    in
-    E.add_export env (nr {
-      name = Lib.Utf8.decode "ic0_stable64_size";
-      edesc = nr (FuncExport (nr ic0_stable64_size_fi))
-    });
-
     let moc_stable_mem_grow_fi =
       E.add_fun env "moc_stable_mem_grow" (
         Func.of_body env ["newPages", I64Type] [I64Type]
@@ -6134,8 +6369,8 @@ module RTS_Exports = struct
       edesc = nr (FuncExport (nr moc_stable_mem_grow_fi))
     });
 
-    let moc_stable_mem_size_fi =
-      E.add_fun env "moc_stable_mem_size" (
+    let moc_stable_mem_get_size_fi =
+      E.add_fun env "moc_stable_mem_get_size" (
         Func.of_body env [] [I64Type]
           (fun env ->
              when_stable_memory_required_else_trap env (fun () ->
@@ -6143,8 +6378,8 @@ module RTS_Exports = struct
         )
     in
     E.add_export env (nr {
-      name = Lib.Utf8.decode "moc_stable_mem_size";
-      edesc = nr (FuncExport (nr moc_stable_mem_size_fi))
+      name = Lib.Utf8.decode "moc_stable_mem_get_size";
+      edesc = nr (FuncExport (nr moc_stable_mem_get_size_fi))
     });
 
     let moc_stable_mem_get_version_fi =
@@ -6180,161 +6415,191 @@ module RTS_Exports = struct
 
 end (* RTS_Exports *)
 
-module Serialization = struct
-  (*
-    The general serialization strategy is as follows:
-    * We statically generate the IDL type description header.
-    * We traverse the data to calculate the size needed for the data buffer and the
-      reference buffer.
-    * We allocate memory for the data buffer and the reference buffer
-      (this memory area is not referenced, so will be dead with the next GC)
-    * We copy the IDL type header to the data buffer.
-    * We traverse the data and serialize it into the data buffer.
-      This is type driven, and we use the `share_code` machinery and names that
-      properly encode the type to resolve loops in a convenient way.
-    * We externalize all that new data space into a databuf
-    * We externalize the reference space into a elembuf
-    * We pass both databuf and elembuf to shared functions
-      (this mimicks the future system API)
 
-    The deserialization is analogous:
-    * We allocate some scratch space, and internalize the databuf and elembuf into it.
-    * We parse the data, in a type-driven way, using normal construction and
-      allocation, while keeping tabs on the type description header for subtyping.
-    * At the end, the scratch space is a hole in the heap, and will be reclaimed
-      by the next GC.
-  *)
+(* Below signature is needed by the serialiser to supply the
+   methods various formats and auxiliary routines. A stream
+   token refers to the stream itself. Depending on the stream's
+   methodology, the token can be a (bump) pointer or a handle
+   (like a `Blob`). The former needs to be updated at certain
+   points because the token will normally reside in locals that
+   nested functions won't have access to. *)
+module type Stream = sig
+  (* Bottleneck routines for streaming in different formats.
+     The `code` must be used linearly. `token` is a fragment
+     of Wasm that puts the stream token onto the stack.
+     Arguments:    env    token  code *)
+  val write_byte : E.t -> G.t -> G.t -> G.t
+  val write_word_leb : E.t -> G.t -> G.t -> G.t
+  val write_word_32 : E.t -> G.t -> G.t -> G.t
+  val write_blob : E.t -> G.t -> G.t -> G.t
+  val write_text : E.t -> G.t -> G.t -> G.t
+  val write_bignum_leb : E.t -> G.t -> G.t -> G.t
+  val write_bignum_sleb : E.t -> G.t -> G.t -> G.t
+
+  (* Creates a fresh stream with header, storing stream token.
+     Arguments:env    size   setter getter header *)
+  val create : E.t -> G.t -> G.t -> G.t -> string -> G.t
+
+  (* Checks the stream's filling, traps if unexpected
+     Arguments:      env    token  size *)
+  val check_filled : E.t -> G.t -> G.t -> G.t
+
+  (* Pushes the stream's current absolute byte offset on stack.
+     The requirement is that the difference between two uses
+     of this method must give a correct _relative_ offset.
+     Arguments:         env    token *)
+  val absolute_offset : E.t -> G.t -> G.t
+
+  (* Finishes the stream, performing consistency checks.
+     Leaves two words on stack, whose interpretation depends
+     on the Stream.
+     Arguments:   env    token  size   header_size *)
+  val terminate : E.t -> G.t -> G.t -> int32 -> G.t
+
+  (* Executes code to eliminate the residual buffer
+     that `terminate` returns (if at all) *)
+  val finalize_buffer : G.t -> G.t
+
+  (* Builds a unique name for a name seed and a type *)
+  val name_for : string -> Type.typ list -> string
+
+  (* Opportunity to flush or update the token. Stream token is on stack. *)
+  val checkpoint : E.t -> G.t -> G.t
+
+  (* Reserve a small fixed number of bytes in the stream and return an
+     address to it. The address is invalidated by a GC, and as such must
+     be written to in the next few instructions. *)
+  val reserve : E.t -> G.t -> int32 -> G.t
+end
 
-  module Strm = struct
-    (* Creates a fresh stream with header, storing stream token. *)
-    let create env get_data_size set_data_buf get_data_buf header =
-      let header_size = Int32.of_int (String.length header) in
-      get_data_size ^^ compile_add_const header_size ^^
-      Blob.dyn_alloc_scratch env ^^ set_data_buf ^^
-      get_data_buf ^^
-      Blob.lit env Tagged.B header ^^ Blob.payload_ptr_unskewed env ^^
-      compile_unboxed_const header_size ^^
-      Heap.memcpy env ^^
-      get_data_buf ^^ compile_add_const header_size ^^ set_data_buf
-  
-    (* Checks the stream's filling, traps if unexpected *)
-    let check_filled env get_data_buf get_data_size =
-      get_data_buf ^^ get_data_size ^^ G.i (Binary (Wasm.Values.I32 I32Op.Add)) ^^
-      G.i (Compare (Wasm.Values.I32 I32Op.Eq)) ^^
-      E.else_trap_with env "data buffer not filled"
-  
-    (* Finishes the stream, performing consistency checks. 
-       Returns payload address and size including the header. *)
-    let terminate env get_data_buf get_data_size header_size =
-      get_data_buf ^^ compile_sub_const header_size ^^
-      get_data_size ^^ compile_add_const header_size
-  
-    (* Builds a unique name for a name seed and a type. *)
-    let name_for fn_name ts = "@" ^ fn_name ^ "<" ^ Typ_hash.typ_seq_hash ts ^ ">"
-  
-    let advance_data_buf get_data_buf =
-      get_data_buf ^^ G.i (Binary (Wasm.Values.I32 I32Op.Add)) ^^ G.setter_for get_data_buf
-  
-    (* Pushes the stream's current absolute byte offset on stack.
-       The requirement is that the difference between two uses
-       of this method must give a correct _relative_ offset. *)
-    let absolute_offset _env get_data_buf = get_data_buf
-  
-    (* Opportunity to flush or update the token. Stream token is on stack. *)
-    let checkpoint _env get_data_buf = G.setter_for get_data_buf
-  
-    (* Reserve a small fixed number of bytes in the stream and return an
-       address to it. The address is invalidated by a GC, and as such must
-       be written to in the next few instructions. *)
-    let reserve _env get_data_buf bytes =
-      get_data_buf ^^ get_data_buf ^^ compile_add_const bytes ^^ G.setter_for get_data_buf
-  
-    let write_word_leb env get_data_buf code =
-      let set_word, get_word = new_local env "word" in
-      code ^^ set_word ^^
-      I32Leb.compile_store_to_data_buf_unsigned env get_word get_data_buf ^^
-      advance_data_buf get_data_buf
-  
-    let write_word_32 env get_data_buf code =
-      get_data_buf ^^ code ^^
-      G.i (Store {ty = I32Type; align = 0; offset = 0l; sz = None}) ^^
-      compile_unboxed_const Heap.word_size ^^ advance_data_buf get_data_buf
-  
-    let write_byte _env get_data_buf code =
-      get_data_buf ^^ code ^^
-      G.i (Store {ty = I32Type; align = 0; offset = 0l; sz = Some Wasm.Types.Pack8}) ^^
-      compile_unboxed_const 1l ^^ advance_data_buf get_data_buf
-  
-    let write_blob env get_data_buf get_x =
-      let set_len, get_len = new_local env "len" in
-      get_x ^^ Blob.len env ^^ set_len ^^
-      write_word_leb env get_data_buf get_len ^^
-      get_data_buf ^^
-      get_x ^^ Blob.payload_ptr_unskewed env ^^
-      get_len ^^
-      Heap.memcpy env ^^
-      get_len ^^ advance_data_buf get_data_buf
-  
-    let write_text env get_data_buf get_x =
-      let set_len, get_len = new_local env "len" in
-      get_x ^^ Text.size env ^^ set_len ^^
-      write_word_leb env get_data_buf get_len ^^
-      get_x ^^ get_data_buf ^^ Text.to_buf env ^^
-      get_len ^^ advance_data_buf get_data_buf
-  
-    let write_bignum_leb env get_data_buf get_x =
-      get_data_buf ^^
-      get_x ^^
-      BigNum.compile_store_to_data_buf_unsigned env ^^
-      advance_data_buf get_data_buf
-  
-    let write_bignum_sleb env get_data_buf get_x =
-      get_data_buf ^^
-      get_x ^^
-      BigNum.compile_store_to_data_buf_signed env ^^
-      advance_data_buf get_data_buf
-  end (* Strm *)
 
-  (* Globals recording known Candid types
-    See Note [Candid subtype checks]
+module BumpStream : Stream = struct
+  let create env get_data_size set_data_buf get_data_buf header =
+    let header_size = Int32.of_int (String.length header) in
+    get_data_size ^^ compile_add_const header_size ^^
+    Blob.dyn_alloc_scratch env ^^ set_data_buf ^^
+    get_data_buf ^^
+    Blob.lit env Tagged.B header ^^ Blob.payload_ptr_unskewed env ^^
+    compile_unboxed_const header_size ^^
+    Heap.memcpy env ^^
+    get_data_buf ^^ compile_add_const header_size ^^ set_data_buf
+
+  let check_filled env get_data_buf get_data_size =
+    get_data_buf ^^ get_data_size ^^ G.i (Binary (Wasm.Values.I32 I32Op.Add)) ^^
+    G.i (Compare (Wasm.Values.I32 I32Op.Eq)) ^^
+    E.else_trap_with env "data buffer not filled"
+
+  let terminate env get_data_buf get_data_size header_size =
+    get_data_buf ^^ compile_sub_const header_size ^^
+    get_data_size ^^ compile_add_const header_size
+
+  let finalize_buffer code = code
+
+  let name_for fn_name ts = "@" ^ fn_name ^ "<" ^ Typ_hash.typ_seq_hash ts ^ ">"
+
+  let advance_data_buf get_data_buf =
+    get_data_buf ^^ G.i (Binary (Wasm.Values.I32 I32Op.Add)) ^^ G.setter_for get_data_buf
+
+  let absolute_offset _env get_data_buf = get_data_buf
+
+  let checkpoint _env get_data_buf = G.setter_for get_data_buf
+
+  let reserve _env get_data_buf bytes =
+    get_data_buf ^^ get_data_buf ^^ compile_add_const bytes ^^ G.setter_for get_data_buf
+
+  let write_word_leb env get_data_buf code =
+    let set_word, get_word = new_local env "word" in
+    code ^^ set_word ^^
+    I32Leb.compile_store_to_data_buf_unsigned env get_word get_data_buf ^^
+    advance_data_buf get_data_buf
+
+  let write_word_32 env get_data_buf code =
+    get_data_buf ^^ code ^^
+    G.i (Store {ty = I32Type; align = 0; offset = 0L; sz = None}) ^^
+    compile_unboxed_const Heap.word_size ^^ advance_data_buf get_data_buf
+
+  let write_byte _env get_data_buf code =
+    get_data_buf ^^ code ^^
+    G.i (Store {ty = I32Type; align = 0; offset = 0L; sz = Some Wasm.Types.Pack8}) ^^
+    compile_unboxed_const 1l ^^ advance_data_buf get_data_buf
+
+  let write_blob env get_data_buf get_x =
+    let set_len, get_len = new_local env "len" in
+    get_x ^^ Blob.len env ^^ set_len ^^
+    write_word_leb env get_data_buf get_len ^^
+    get_data_buf ^^
+    get_x ^^ Blob.payload_ptr_unskewed env ^^
+    get_len ^^
+    Heap.memcpy env ^^
+    get_len ^^ advance_data_buf get_data_buf
+
+  let write_text env get_data_buf get_x =
+    let set_len, get_len = new_local env "len" in
+    get_x ^^ Text.size env ^^ set_len ^^
+    write_word_leb env get_data_buf get_len ^^
+    get_x ^^ get_data_buf ^^ Text.to_buf env ^^
+    get_len ^^ advance_data_buf get_data_buf
+
+  let write_bignum_leb env get_data_buf get_x =
+    get_data_buf ^^
+    get_x ^^
+    BigNum.compile_store_to_data_buf_unsigned env ^^
+    advance_data_buf get_data_buf
+
+  let write_bignum_sleb env get_data_buf get_x =
+    get_data_buf ^^
+    get_x ^^
+    BigNum.compile_store_to_data_buf_signed env ^^
+    advance_data_buf get_data_buf
+
+end
+
+module MakeSerialization (Strm : Stream) = struct
+  (*
+    The general serialization strategy is as follows:
+    * We statically generate the IDL type description header.
+    * We traverse the data to calculate the size needed for the data buffer and the
+      reference buffer.
+    * We allocate memory for the data buffer and the reference buffer
+      (this memory area is not referenced, so will be dead with the next GC)
+    * We copy the IDL type header to the data buffer.
+    * We traverse the data and serialize it into the data buffer.
+      This is type driven, and we use the `share_code` machinery and names that
+      properly encode the type to resolve loops in a convenient way.
+    * We externalize all that new data space into a databuf
+    * We externalize the reference space into a elembuf
+    * We pass both databuf and elembuf to shared functions
+      (this mimicks the future system API)
+
+    The deserialization is analogous:
+    * We allocate some scratch space, and internalize the databuf and elembuf into it.
+    * We parse the data, in a type-driven way, using normal construction and
+      allocation, while keeping tabs on the type description header for subtyping.
+    * At the end, the scratch space is a hole in the heap, and will be reclaimed
+      by the next GC.
   *)
-  let register_delayed_globals env =
-    (E.add_global32_delayed env "__candid_data_length" Immutable,
-    E.add_global32_delayed env "__type_offsets_length" Immutable,
-    E.add_global32_delayed env "__idl_types_length" Immutable)
-
-  let get_candid_data_length env =
-    G.i (GlobalGet (nr (E.get_global env "__candid_data_length")))
-  let get_type_offsets_length env =
-    G.i (GlobalGet (nr (E.get_global env "__type_offsets_length")))
-  let get_idl_types_length env =
-    G.i (GlobalGet (nr (E.get_global env "__idl_types_length")))
-
-  let candid_type_offset_size = 4l
-
-  let get_global_type_descriptor env =
-    match !(E.(env.global_type_descriptor)) with
-    | Some descriptor -> descriptor
-    | None -> assert false
 
-  let get_global_candid_data env =
-    Tagged.share env (fun env -> 
-      let descriptor = get_global_type_descriptor env in
-      Blob.load_data_segment env Tagged.B E.(descriptor.candid_data_segment) (get_candid_data_length env)
-    )
+  module Strm = Strm
 
-  let get_global_type_offsets env =
-    Tagged.share env (fun env -> 
-      let descriptor = get_global_type_descriptor env in
-      Blob.load_data_segment env Tagged.B E.(descriptor.type_offsets_segment) (get_type_offsets_length env)
-    )
+  (* Globals recording known Candid types
+     See Note [Candid subtype checks]
+   *)
+
+  let register_delayed_globals env =
+    (E.add_global32_delayed env "__typtbl" Immutable,
+     E.add_global32_delayed env "__typtbl_end" Immutable,
+     E.add_global32_delayed env "__typtbl_size" Immutable,
+     E.add_global32_delayed env "__typtbl_idltyps" Immutable)
+
+  let get_typtbl env =
+    G.i (GlobalGet (nr (E.get_global env "__typtbl")))
+  let get_typtbl_size env =
+    G.i (GlobalGet (nr (E.get_global env "__typtbl_size")))
+  let get_typtbl_end env =
+    G.i (GlobalGet (nr (E.get_global env "__typtbl_end")))
+  let get_typtbl_idltyps env =
+    G.i (GlobalGet (nr (E.get_global env "__typtbl_idltyps")))
 
-  let get_global_idl_types env =
-    Tagged.share env (fun env -> 
-      let descriptor = get_global_type_descriptor env in
-      Blob.load_data_segment env Tagged.B E.(descriptor.idl_types_segment) (get_idl_types_length env)
-    )
-  
   module Registers = struct
 
     (* interval for checking instruction counter *)
@@ -6349,9 +6614,6 @@ module Serialization = struct
       E.add_global32 env "@@typtbl" Mutable 0l;
       E.add_global32 env "@@typtbl_end" Mutable 0l;
       E.add_global32 env "@@typtbl_size" Mutable 0l;
-      E.add_global32 env "@@global_typtbl" Mutable 0l;
-      E.add_global32 env "@@global_typtbl_end" Mutable 0l;
-      E.add_global32 env "@@global_typtbl_size" Mutable 0l;
       E.add_global32 env "@@value_denominator" Mutable idl_value_denominator;
       E.add_global32 env "@@value_numerator" Mutable idl_value_numerator;
       E.add_global32 env "@@value_bias" Mutable idl_value_bias;
@@ -6387,33 +6649,6 @@ module Serialization = struct
     let set_typtbl_size env =
       G.i (GlobalSet (nr (E.get_global env "@@typtbl_size")))
 
-    let get_global_typtbl env =
-      G.i (GlobalGet (nr (E.get_global env "@@global_typtbl")))
-    let set_global_typtbl env =
-      G.i (GlobalSet (nr (E.get_global env "@@global_typtbl")))
-
-    let get_global_typtbl_end env =
-      G.i (GlobalGet (nr (E.get_global env "@@global_typtbl_end")))
-    let set_global_typtbl_end env =
-      G.i (GlobalSet (nr (E.get_global env "@@global_typtbl_end")))
-
-    let get_global_typtbl_size env =
-      G.i (GlobalGet (nr (E.get_global env "@@global_typtbl_size")))
-    let set_global_typtbl_size env =
-      G.i (GlobalSet (nr (E.get_global env "@@global_typtbl_size")))
-
-    (* Used as safety guard that no temporary pointers remain in the registers across GC increments. *)
-    let clear_registers env =
-      compile_unboxed_const 0l ^^ set_rel_buf_opt env ^^
-      compile_unboxed_const 0l ^^ set_data_buf env ^^
-      compile_unboxed_const 0l ^^ set_ref_buf env ^^
-      compile_unboxed_const 0l ^^ set_typtbl env ^^
-      compile_unboxed_const 0l ^^ set_typtbl_end env ^^
-      compile_unboxed_const 0l ^^ set_typtbl_size env ^^ (* also reset for symmetry, even if no pointer *)
-      compile_unboxed_const 0l ^^ set_global_typtbl env ^^
-      compile_unboxed_const 0l ^^ set_global_typtbl_end env ^^
-      compile_unboxed_const 0l ^^ set_global_typtbl_size env (* also reset for symmetry, even if no pointer *)
-
     let get_value_quota env =
       G.i (GlobalGet (nr (E.get_global env "@@value_quota")))
     let set_value_quota env =
@@ -6514,12 +6749,7 @@ module Serialization = struct
   *)
 
   module TM = Map.Make (Type.Ord)
-
-  type mode =
-    | Candid
-    | Persistence
-
-  let to_idl_prim mode = let open Type in function
+  let to_idl_prim = let open Type in function
     | Prim Null | Tup [] -> Some 1l
     | Prim Bool -> Some 2l
     | Prim Nat -> Some 3l
@@ -6539,11 +6769,6 @@ module Serialization = struct
     | Non -> Some 17l
     | Prim Principal -> Some 24l
     | Prim Region -> Some 128l
-    (* only used for memory compatibility checks *)
-    | Prim Blob -> 
-      (match mode with
-      | Candid -> None
-      | Persistence -> Some 129l)
     | _ -> None
 
   (* some constants, also see rts/idl.c *)
@@ -6554,12 +6779,9 @@ module Serialization = struct
   let idl_func      = -22l
   let idl_service   = -23l
   let idl_alias     = 1l (* see Note [mutable stable values] *)
-  
-  (* only used for memory compatibility checks *)
-  let idl_tuple     = -130l
 
   (* TODO: use record *)
-  let type_desc env mode ts :
+  let type_desc env ts :
      string * int list * int32 list  (* type_desc, (relative offsets), indices of ts *)
     =
     let open Type in
@@ -6571,7 +6793,7 @@ module Serialization = struct
       let idx = ref TM.empty in
       let rec go t =
         let t = Type.normalize t in
-        if to_idl_prim mode t <> None then () else
+        if to_idl_prim t <> None then () else
         if TM.mem t !idx then () else begin
           idx := TM.add t (Lib.List32.length !typs) !idx;
           typs := !typs @ [ t ];
@@ -6630,29 +6852,26 @@ module Serialization = struct
 
     let add_idx t =
       let t = Type.normalize t in
-      match to_idl_prim mode t with
+      match to_idl_prim t with
       | Some i -> add_sleb128 (Int32.neg i)
       | None -> add_sleb128 (TM.find (normalize t) idx) in
 
     let idx t =
       let t = Type.normalize t in
-      match to_idl_prim mode t with
+      match to_idl_prim t with
       | Some i -> Int32.neg i
       | None -> TM.find (normalize t) idx in
 
     let rec add_typ t =
       match t with
       | Non -> assert false
-      | Prim Blob -> 
-        assert (mode = Candid);
+      | Prim Blob ->
         add_typ Type.(Array (Prim Nat8))
       | Prim Region ->
         add_sleb128 idl_alias; add_idx t
       | Prim _ -> assert false
       | Tup ts ->
-        add_sleb128 (match mode with
-        | Candid -> idl_record
-        | Persistence -> idl_tuple);
+        add_sleb128 idl_record;
         add_leb128 (List.length ts);
         List.iteri (fun i t ->
           add_leb128 i;
@@ -6723,29 +6942,22 @@ module Serialization = struct
      List.map idx ts)
 
   (* See Note [Candid subtype checks] *)
-  let reserve_global_type_descriptor (env : E.t) =
-    let candid_data_segment = E.add_data_segment env "" in
-    let type_offsets_segment = E.add_data_segment env "" in
-    let idl_types_segment = E.add_data_segment env "" in
-    E.(env.global_type_descriptor := Some {
-      candid_data_segment;
-      type_offsets_segment;
-      idl_types_segment;
-    })
-
-  let create_global_type_descriptor (env : E.t) (set_candid_data_length, set_type_offsets_length, set_idl_types_length) =
-    let descriptor = get_global_type_descriptor env in
-    let candid_data, type_offsets, idl_types = type_desc env Candid (E.get_typtbl_typs env) in
-    let candid_data_binary = [StaticBytes.Bytes candid_data] in
-    let candid_data_length = E.replace_data_segment env E.(descriptor.candid_data_segment) candid_data_binary in
-    set_candid_data_length candid_data_length;
-    let type_offsets_binary = [StaticBytes.i32s (List.map Int32.of_int type_offsets)] in
-    let type_offsets_length = E.replace_data_segment env E.(descriptor.type_offsets_segment) type_offsets_binary in
-    set_type_offsets_length type_offsets_length;
-    let idl_types_binary = [StaticBytes.i32s idl_types] in
-    let idl_types_length = E.replace_data_segment env E.(descriptor.idl_types_segment) idl_types_binary in
-    set_idl_types_length idl_types_length
-
+  let set_delayed_globals (env : E.t) (set_typtbl, set_typtbl_end, set_typtbl_size, set_typtbl_idltyps) =
+    let typdesc, offsets, idltyps = type_desc env (E.get_typtbl_typs env) in
+    let static_typedesc = E.add_static_unskewed env [StaticBytes.Bytes typdesc] in
+    let static_typtbl =
+      let bytes = StaticBytes.i32s
+        (List.map (fun offset ->
+          Int32.(add static_typedesc (of_int(offset))))
+        offsets)
+      in
+      E.add_static_unskewed env [bytes]
+    in
+    let static_idltyps = E.add_static_unskewed env [StaticBytes.i32s idltyps] in
+    set_typtbl static_typtbl;
+    set_typtbl_end Int32.(add static_typedesc (of_int (String.length typdesc)));
+    set_typtbl_size (Int32.of_int (List.length offsets));
+    set_typtbl_idltyps static_idltyps
 
   (* Returns data (in bytes) and reference buffer size (in entries) needed *)
   let rec buffer_size env t =
@@ -6989,11 +7201,11 @@ module Serialization = struct
       | Prim Float ->
         reserve env get_data_buf 8l ^^
         get_x ^^ Float.unbox env ^^
-        G.i (Store {ty = F64Type; align = 0; offset = 0l; sz = None})
+        G.i (Store {ty = F64Type; align = 0; offset = 0L; sz = None})
       | Prim ((Int64|Nat64) as pty) ->
         reserve env get_data_buf 8l ^^
         get_x ^^ BoxedWord64.unbox env pty ^^
-        G.i (Store {ty = I64Type; align = 0; offset = 0l; sz = None})
+        G.i (Store {ty = I64Type; align = 0; offset = 0L; sz = None})
       | Prim ((Int32|Nat32) as ty) ->
         write_word_32 env get_data_buf (get_x ^^ BoxedSmallWord.unbox env ty)
       | Prim Char ->
@@ -7001,7 +7213,7 @@ module Serialization = struct
       | Prim ((Int16|Nat16) as ty) ->
         reserve env get_data_buf 2l ^^
         get_x ^^ TaggedSmallWord.lsb_adjust ty ^^
-        G.i (Store {ty = I32Type; align = 0; offset = 0l; sz = Some Wasm.Types.Pack16})
+        G.i (Store {ty = I32Type; align = 0; offset = 0L; sz = Some Wasm.Types.Pack16})
       | Prim ((Int8|Nat8) as ty) ->
         write_byte env get_data_buf (get_x ^^ TaggedSmallWord.lsb_adjust ty)
       | Prim Bool ->
@@ -7024,7 +7236,7 @@ module Serialization = struct
         write_alias (fun () ->
           reserve env get_data_buf 8l ^^
           get_x ^^ Region.id env ^^
-          G.i (Store {ty = I64Type; align = 0; offset = 0l; sz = None}) ^^
+          G.i (Store {ty = I64Type; align = 0; offset = 0L; sz = None}) ^^
           write_word_32 env get_data_buf (get_x ^^ Region.page_count env) ^^
           write_blob env get_data_buf (get_x ^^ Region.vec_pages env)
         )
@@ -7079,45 +7291,48 @@ module Serialization = struct
 
   (* This value is returned by deserialize_go if deserialization fails in a way
      that should be recoverable by opt parsing.
-     It is an (invalid) sentinel pointer value (in skewed format) and can be used for pointer comparison.
-     It will be never placed on the heap and must not be dereferenced.
-     If unskewed, it refers to the unallocated last Wasm memory page.
+     By virtue of being a deduped static value, it can be detected by pointer
+     comparison.
   *)
-  let coercion_error_value env = 0xffff_fffdl
+  let coercion_error_value env : int32 =
+    Tagged.shared_static_obj env Tagged.CoercionFailure []
 
   (* See Note [Candid subtype checks] *)
-  let with_rel_buf_opt env extended get_typtbl_size1 get_typtbl_size2 f =
+  let with_rel_buf_opt env extended get_typtbl_size1 f =
     if extended then
       f (compile_unboxed_const 0l)
     else
-      get_typtbl_size1 ^^ get_typtbl_size2 ^^
+      get_typtbl_size1 ^^ get_typtbl_size env ^^
       E.call_import env "rts" "idl_sub_buf_words" ^^
       Stack.dynamic_with_words env "rel_buf" (fun get_ptr ->
-        get_ptr ^^ get_typtbl_size1 ^^ get_typtbl_size2 ^^
+        get_ptr ^^ get_typtbl_size1 ^^ get_typtbl_size env ^^
         E.call_import env "rts" "idl_sub_buf_init" ^^
         f get_ptr)
 
   (* See Note [Candid subtype checks] *)
   let idl_sub env t2 =
     let idx = E.add_typtbl_typ env t2 in
-    get_global_idl_types env ^^
-    Blob.payload_ptr_unskewed env ^^
-    G.i (Load {ty = I32Type; align = 0; offset = Int32.mul idx candid_type_offset_size (*!*); sz = None}) ^^
-    Func.share_code2 Func.Always env ("idl_sub")
-      (("idltyp1", I32Type),
+    get_typtbl_idltyps env ^^
+    G.i (Load {ty = I32Type; align = 0; offset = Int64.of_int32 (Int32.mul idx 4l) (*!*); sz = None}) ^^
+    Func.share_code6 Func.Always env ("idl_sub")
+      (("rel_buf", I32Type),
+       ("typtbl1", I32Type),
+       ("typtbl_end1", I32Type),
+       ("typtbl_size1", I32Type),
+       ("idltyp1", I32Type),
        ("idltyp2", I32Type)
       )
       [I32Type]
-      (fun env get_idltyp1 get_idltyp2 ->
-        Registers.get_rel_buf_opt env ^^
+      (fun env get_rel_buf get_typtbl1 get_typtbl_end1 get_typtbl_size1 get_idltyp1 get_idltyp2 ->
+        get_rel_buf ^^
         E.else_trap_with env "null rel_buf" ^^
-        Registers.get_rel_buf_opt env ^^
-        Registers.get_typtbl env ^^
-        Registers.get_global_typtbl env ^^
-        Registers.get_typtbl_end env ^^
-        Registers.get_global_typtbl_end env ^^
-        Registers.get_typtbl_size env ^^
-        Registers.get_global_typtbl_size env ^^
+        get_rel_buf ^^
+        get_typtbl1 ^^
+        get_typtbl env ^^
+        get_typtbl_end1 ^^
+        get_typtbl_end env ^^
+        get_typtbl_size1 ^^
+        get_typtbl_size env ^^
         get_idltyp1 ^^
         get_idltyp2 ^^
         E.call_import env "rts" "idl_sub")
@@ -7168,7 +7383,7 @@ module Serialization = struct
       let get_data_buf = Registers.get_data_buf env in
       let _get_ref_buf = Registers.get_ref_buf env in
       let get_typtbl = Registers.get_typtbl env in
-      let _get_typtbl_end = Registers.get_typtbl_end env in
+      let get_typtbl_end = Registers.get_typtbl_end env in
       let get_typtbl_size = Registers.get_typtbl_size env in
 
       (* Decrement and check idl quota *)
@@ -7244,7 +7459,7 @@ module Serialization = struct
       (* returns true if we are looking at primitive type with this id *)
       let check_prim_typ t =
         get_idltyp ^^
-        compile_eq_const (Int32.neg (Option.get (to_idl_prim Candid t)))
+        compile_eq_const (Int32.neg (Option.get (to_idl_prim t)))
       in
 
       let with_prim_typ t f =
@@ -7393,7 +7608,7 @@ module Serialization = struct
         begin
           (* sanity check *)
           get_arg_typ ^^
-          compile_eq_const (Int32.neg (Option.get (to_idl_prim Candid (Prim Region)))) ^^
+          compile_eq_const (Int32.neg (Option.get (to_idl_prim (Prim Region)))) ^^
           E.else_trap_with env "IDL error: unexpecting primitive alias type" ^^
           get_arg_typ
         end
@@ -7476,7 +7691,7 @@ module Serialization = struct
           end begin
           (* Decoded before. Check type hash *)
           ReadBuf.read_word32 env get_data_buf ^^ Blob.lit env Tagged.B (typ_hash t) ^^
-          Blob.compare env (Some Operator.EqOp) ^^
+          G.i (Compare (Wasm.Values.I32 I32Op.Eq)) ^^
           E.else_trap_with env ("Stable memory error: Aliased at wrong type, expected: " ^ typ_hash t)
         end ^^
 
@@ -7660,7 +7875,7 @@ module Serialization = struct
           let (set_region, get_region) = new_local env "region" in
           (* sanity check *)
           get_region_typ ^^
-          compile_eq_const (Int32.neg (Option.get (to_idl_prim Candid (Prim Region)))) ^^
+          compile_eq_const (Int32.neg (Option.get (to_idl_prim (Prim Region)))) ^^
           E.else_trap_with env "deserialize_go (Region): unexpected idl_typ" ^^
           (* pre-allocate a region object, with dummy fields *)
           compile_const_64 0L ^^ (* id *)
@@ -7787,6 +8002,10 @@ module Serialization = struct
         get_rel_buf_opt ^^
         G.if1 I32Type
           begin
+            get_rel_buf_opt ^^
+            get_typtbl ^^
+            get_typtbl_end ^^
+            get_typtbl_size ^^
             get_idltyp ^^
             idl_sub env t
           end
@@ -7808,6 +8027,10 @@ module Serialization = struct
         get_rel_buf_opt ^^
         G.if1 I32Type
           begin
+            get_rel_buf_opt ^^
+            get_typtbl ^^
+            get_typtbl_end ^^
+            get_typtbl_size ^^
             get_idltyp ^^
             idl_sub env t
           end
@@ -7842,7 +8065,7 @@ module Serialization = struct
       let (set_data_size, get_data_size) = new_local env "data_size" in
       let (set_refs_size, get_refs_size) = new_local env "refs_size" in
 
-      let (tydesc, _offsets, _idltyps) = type_desc env Candid ts in
+      let (tydesc, _offsets, _idltyps) = type_desc env ts in
       let tydesc_len = Int32.of_int (String.length tydesc) in
 
       (* Get object sizes *)
@@ -7914,11 +8137,6 @@ module Serialization = struct
       Stack.with_words env "get_typtbl_ptr" 1l (fun get_typtbl_ptr ->
       Stack.with_words env "get_maintyps_ptr" 1l (fun get_maintyps_ptr ->
 
-      (* Allocate space for out parameters of idl_alloc_typtbl *)
-      Stack.with_words env "get_global_typtbl_ptr" 1l (fun get_global_typtbl_ptr ->
-      Stack.with_words env "get_global_typtbl_end_ptr" 1l (fun get_global_typtbl_end_ptr ->
-      Stack.with_words env "get_global_typtbl_size_ptr" 1l (fun get_global_typtbl_size_ptr ->
-
       (* Set up read buffers *)
       ReadBuf.alloc env (fun get_data_buf -> ReadBuf.alloc env (fun get_ref_buf ->
 
@@ -7931,21 +8149,8 @@ module Serialization = struct
       Bool.lit extended ^^ get_data_buf ^^ get_typtbl_ptr ^^ get_typtbl_size_ptr ^^ get_maintyps_ptr ^^
       E.call_import env "rts" "parse_idl_header" ^^
 
-      (* Allocate global type type, if necessary for subtype checks *)
-      (if extended then
-         G.nop
-       else begin
-         get_global_candid_data env ^^
-         get_global_type_offsets env ^^
-         get_global_typtbl_ptr ^^ get_global_typtbl_end_ptr ^^ get_global_typtbl_size_ptr ^^
-         E.call_import env "rts" "idl_alloc_typtbl"
-      end) ^^
-
       (* Allocate memo table, if necessary *)
-      with_rel_buf_opt env extended
-        (get_typtbl_size_ptr ^^ load_unskewed_ptr)
-        (get_global_typtbl_size_ptr ^^ load_unskewed_ptr)
-        (fun get_rel_buf_opt ->
+      with_rel_buf_opt env extended (get_typtbl_size_ptr ^^ load_unskewed_ptr) (fun get_rel_buf_opt ->
       begin
         (* set up invariant register arguments *)
         get_rel_buf_opt ^^ Registers.set_rel_buf_opt env ^^
@@ -7954,9 +8159,6 @@ module Serialization = struct
         get_typtbl_ptr ^^ load_unskewed_ptr ^^ Registers.set_typtbl env ^^
         get_maintyps_ptr ^^ load_unskewed_ptr ^^ Registers.set_typtbl_end env ^^
         get_typtbl_size_ptr ^^ load_unskewed_ptr ^^ Registers.set_typtbl_size env ^^
-        get_global_typtbl_ptr ^^ load_unskewed_ptr ^^ Registers.set_global_typtbl env ^^
-        get_global_typtbl_end_ptr ^^ load_unskewed_ptr ^^ Registers.set_global_typtbl_end env ^^
-        get_global_typtbl_size_ptr ^^ load_unskewed_ptr ^^ Registers.set_global_typtbl_size env ^^
         Registers.reset_value_limit env get_blob get_rel_buf_opt
       end ^^
 
@@ -8020,11 +8222,8 @@ module Serialization = struct
         ReadBuf.is_empty env get_data_buf ^^
         E.else_trap_with env ("IDL error: left-over bytes " ^ ts_name) ^^
         ReadBuf.is_empty env get_ref_buf ^^
-        E.else_trap_with env ("IDL error: left-over references " ^ ts_name) ^^
-
-        (* Safety guard: The temporary pointers in the registers must no longer be used when a GC increment runs. *)
-        Registers.clear_registers env
-      )))))))))
+        E.else_trap_with env ("IDL error: left-over references " ^ ts_name)
+      ))))))
 
     ))
 
@@ -8146,18 +8345,12 @@ encountered during code generation, the other is determined
 dynamically by, e.g. message payload. The latter will vary with
 each payload to decode.
 
-The static type table and a type descriptor are stored in passive 
-data segments. Instead of absolute memory addresses, the static type 
-table in the data segment only contains relative offsets into type 
-descriptor. When loaded, these offsets are patched by static addresses 
-that point into the type descriptor.
-
 The known Motoko types are accumulated in a global list as required
 and then, in a final compilation step, encoded to global type table
-and the type descriptor (sequence of type indices). The encoding is 
-stored in passive data segments referenced (by way of segment indices) 
-from dedicated wasm globals so that we can generate code that 
-references the globals before their final definitions are known.
+and sequence of type indices. The encoding is stored as static
+data referenced by dedicated wasm globals so that we can generate
+code that references the globals before their final definitions are
+known.
 
 Deserializing a proper (not extended) Candid value stack allocates a
 mutable word buffer, of size determined by `idl_sub_buf_words`.
@@ -8184,76 +8377,287 @@ from a Boolean to a three-valued argument to efficiently check equality for
 invariant type constructors in a single pass.
 *)
 
-end (* Serialization *)
+end (* MakeSerialization *)
+
+module Serialization = MakeSerialization(BumpStream)
+
+module BlobStream : Stream = struct
+  let create env get_data_size set_token get_token header =
+    let header_size = Int32.of_int (String.length header) in
+    get_data_size ^^ compile_add_const header_size ^^
+    E.call_import env "rts" "alloc_stream" ^^ set_token ^^ (* allocation barrier called in alloc_stream *)
+    get_token ^^
+    Blob.lit env Tagged.B header ^^
+    E.call_import env "rts" "stream_write_text"
+
+  let check_filled env get_token get_data_size =
+    G.i Drop
+
+  let terminate env get_token _get_data_size _header_size =
+    get_token ^^ E.call_import env "rts" "stream_split" ^^
+    let set_blob, get_blob = new_local env "blob" in
+    set_blob ^^
+    get_blob ^^ Blob.payload_ptr_unskewed env ^^
+    get_blob ^^ Blob.len env
+
+  let finalize_buffer code = code
+
+  let name_for fn_name ts = "@Bl_" ^ fn_name ^ "<" ^ Typ_hash.typ_seq_hash ts ^ ">"
+
+  let absolute_offset env get_token =
+    let offset = 8l in (* see invariant in `stream.rs` *)
+    let filled_field = Int32.add (Blob.len_field env) offset in
+    get_token ^^ Tagged.load_field_unskewed env filled_field
+
+  let checkpoint _env _get_token = G.i Drop
+
+  let reserve env get_token bytes =
+    get_token ^^ compile_unboxed_const bytes ^^ E.call_import env "rts" "stream_reserve"
+
+  let write_word_leb env get_token code =
+    let set_word, get_word = new_local env "word" in
+    code ^^ set_word ^^
+    I32Leb.compile_store_to_data_buf_unsigned env get_word
+      (get_token ^^ I32Leb.compile_leb128_size get_word ^^ E.call_import env "rts" "stream_reserve") ^^
+    G.i Drop
+
+  let write_word_32 env get_token code =
+    reserve env get_token Heap.word_size ^^
+    code ^^
+    G.i (Store {ty = I32Type; align = 0; offset = 0L; sz = None})
+
+  let write_byte env get_token code =
+    get_token ^^ code ^^
+    E.call_import env "rts" "stream_write_byte"
+
+  let write_blob env get_token get_x =
+    let set_len, get_len = new_local env "len" in
+    get_x ^^ Blob.len env ^^ set_len ^^
+    write_word_leb env get_token get_len ^^
+    get_token ^^
+    get_x ^^ Blob.payload_ptr_unskewed env ^^
+    get_len ^^
+    E.call_import env "rts" "stream_write"
+
+  let write_text env get_token get_x =
+    write_word_leb env get_token (get_x ^^ Text.size env) ^^
+    get_token ^^ get_x ^^
+    E.call_import env "rts" "stream_write_text"
+
+  let write_bignum_leb env get_token get_x =
+    get_token ^^ get_x ^^
+    BigNum.compile_store_to_stream_unsigned env
+
+  let write_bignum_sleb env get_token get_x =
+    get_token ^^ get_x ^^
+    BigNum.compile_store_to_stream_signed env
+
+end
+
 
-(* OldStabilization as migration code: 
-  Deserializing a last time from explicit stable memory into the stable heap:
+(* Stabilization (serialization to/from stable memory) of both:
    * stable variables; and
    * virtual stable memory.
    c.f.
    * ../../design/Stable.md
    * ../../design/StableMemory.md
 *)
-module OldStabilization = struct
+
+module Stabilization = struct
+
   let extend64 code = code ^^ G.i (Convert (Wasm.Values.I64 I64Op.ExtendUI32))
-  
-  let _read_word32 env =
-    StableMem.read env false "word32" I32Type 4l load_unskewed_ptr
-  let write_word32 env =
-    StableMem.write env false "word32" I32Type 4l store_unskewed_ptr
 
-  (* read and clear word32 from stable mem offset on stack *)
-  let read_and_clear_word32 env =
-    match E.mode env with
-    | Flags.ICMode | Flags.RefMode ->
-      Func.share_code1 Func.Always env "__stablemem_read_and_clear_word32"
-        ("offset", I64Type) [I32Type]
-        (fun env get_offset ->
-          Stack.with_words env "temp_ptr" 1l (fun get_temp_ptr ->
-            let (set_word, get_word) = new_local env "word" in
-            (* read word *)
-            get_temp_ptr ^^ G.i (Convert (Wasm.Values.I64 I64Op.ExtendUI32)) ^^
-            get_offset ^^
-            compile_const_64 4L ^^
-            StableMem.stable64_read env ^^
-            get_temp_ptr ^^ load_unskewed_ptr ^^
-            set_word ^^
-            (* write 0 *)
-            get_temp_ptr ^^ compile_unboxed_const 0l ^^ store_unskewed_ptr ^^
-            get_offset ^^
-            get_temp_ptr ^^ G.i (Convert (Wasm.Values.I64 I64Op.ExtendUI32)) ^^
-            compile_const_64 4L ^^
-            StableMem.stable64_write env ^^
-            (* return word *)
-            get_word
-        ))
-    | _ -> assert false
+  (* The below stream implementation is geared towards the
+     tail section of stable memory, where the serialised
+     stable variables go. As such a few intimate details of
+     the stable memory layout are burnt in, such as the
+     variable `N` from the design document. *)
+  module StableMemoryStream : Stream = struct
+    include BlobStream
+
+    let name_for fn_name ts = "@Sm_" ^ fn_name ^ "<" ^ Typ_hash.typ_seq_hash ts ^ ">"
+
+    let create env get_data_size set_token get_token header =
+      create env (compile_unboxed_const 0x8000l) set_token get_token header ^^
+        (* TODO: push header directly? *)
 
-  (* TODO: rewrite using MemoryFill *)
-  let blob_clear env =
-    Func.share_code1 Func.Always env "blob_clear" ("x", I32Type) [] (fun env get_x ->
-      let (set_ptr, get_ptr) = new_local env "ptr" in
       let (set_len, get_len) = new_local env "len" in
-      get_x ^^
-      Blob.as_ptr_len env ^^
+      get_data_size ^^
+      compile_add_const (Int32.of_int (String.length header)) ^^
       set_len ^^
-      set_ptr ^^
 
-      (* round to word size *)
-      get_len ^^
-      compile_add_const (Int32.sub Heap.word_size 1l) ^^
-      compile_divU_const Heap.word_size ^^
+      let (set_dst, get_dst) = new_local64 env "dst" in
+      StableMem.get_mem_size env ^^
+      compile_shl64_const (Int64.of_int page_size_bits) ^^
+      compile_add64_const 4L ^^ (* `N` is now on the stack *)
+      set_dst ^^
+
+      get_dst ^^
+      extend64 get_len ^^
+      StableMem.ensure env ^^
+
+      get_token ^^
+      get_dst ^^
+      get_dst ^^ extend64 get_len ^^
+      G.i (Binary (Wasm.Values.I64 I64Op.Add)) ^^
+      E.call_import env "rts" "stream_stable_dest"
+
+    let ptr64_field env =
+      let offset = 1l in (* see invariant in `stream.rs` *)
+      Int32.add (Blob.len_field env) offset (* see invariant in `stream.rs`, padding for 64-bit after Stream header *)
+
+    let terminate env get_token get_data_size header_size =
+      get_token ^^
+      E.call_import env "rts" "stream_shutdown" ^^
+      compile_unboxed_zero ^^ (* no need to write *)
+      get_token ^^
+      Tagged.load_field64_unskewed env (ptr64_field env) ^^
+      StableMem.get_mem_size env ^^
+      compile_shl64_const (Int64.of_int page_size_bits) ^^
+      G.i (Binary (Wasm.Values.I64 I64Op.Sub)) ^^
+      compile_sub64_const 4L ^^  (* `N` is now subtracted *)
+      G.i (Convert (Wasm.Values.I32 I32Op.WrapI64))
 
-      (* clear all words *)
-      from_0_to_n env (fun get_i ->
-        get_ptr ^^
-        compile_unboxed_const 0l ^^
-        store_unskewed_ptr ^^
-        get_ptr ^^
-        compile_add_const Heap.word_size ^^
-        set_ptr))
+    let finalize_buffer _ = G.nop (* everything is outputted already *)
+
+    (* Returns a 32-bit unsigned int that is the number of bytes that would
+       have been written to stable memory if flushed. The difference
+       of two such numbers will always be an exact byte distance. *)
+    let absolute_offset env get_token =
+      let start64_field = Int32.add (ptr64_field env) 2l in (* see invariant in `stream.rs` *)
+      absolute_offset env get_token ^^
+      get_token ^^
+      Tagged.load_field64_unskewed env (ptr64_field env) ^^
+      get_token ^^
+      Tagged.load_field64_unskewed env start64_field ^^
+      G.i (Binary (Wasm.Values.I64 I64Op.Sub)) ^^
+      G.i (Convert (Wasm.Values.I32 I32Op.WrapI64)) ^^
+      G.i (Binary (Wasm.Values.I32 I32Op.Add))
+  end
+
+  module Externalization = MakeSerialization(StableMemoryStream)
+
+  let stabilize env t =
+    let (set_dst, get_dst) = new_local env "dst" in
+    let (set_len, get_len) = new_local env "len" in
+
+    (if !Flags.gc_strategy = Flags.Incremental then
+      E.call_import env "rts" "stop_gc_on_upgrade"
+    else
+      G.nop) ^^
+
+
+    Externalization.serialize env [t] ^^
+    set_len ^^
+    set_dst ^^
+
+    StableMem.get_mem_size env ^^
+    G.i (Test (Wasm.Values.I64 I64Op.Eqz)) ^^
+    G.if0
+      begin
+        (* assert StableMem.get_version() == StableMem.version_no_stable_memory *)
+        StableMem.get_version env ^^
+        compile_eq_const StableMem.version_no_stable_memory ^^
+        E.else_trap_with env "StableMem.get_version() != version_no_stable_memory" ^^
+
+        (* Case-true: Stable variables only --
+           no use of either regions or experimental API. *)
+        (* ensure [0,..,3,...len+4) *)
+        compile_const_64 0L ^^
+        extend64 get_len ^^
+        compile_add64_const 4L ^^  (* reserve one word for size *)
+        StableMem.ensure env ^^
+
+        (* write len to initial word of stable memory*)
+        compile_const_64 0L ^^
+        get_len ^^
+        StableMem.write_word32 env ^^
+
+        (* copy data to following stable memory *)
+        Externalization.Strm.finalize_buffer
+          begin
+            compile_const_64 4L ^^
+            extend64 get_dst ^^
+            extend64 get_len ^^
+            StableMem.stable64_write env
+          end
+      end
+      begin
+        (* Case-false: Either regions or experimental API. *)
+        let (set_N, get_N) = new_local64 env "N" in
+
+        (* let N = !size * page_size *)
+        StableMem.get_mem_size env ^^
+        compile_shl64_const (Int64.of_int page_size_bits) ^^
+        set_N ^^
+
+        (* grow mem to page including address
+           N + 4 + len + 4 + 4 + 4 = N + len + 16
+        *)
+        get_N ^^
+        extend64 get_len ^^
+        compile_add64_const 16L ^^
+        StableMem.ensure env ^^
+
+        get_N ^^
+        get_len ^^
+        StableMem.write_word32 env ^^
+
+        (* copy data to following stable memory *)
+        Externalization.Strm.finalize_buffer
+          begin
+            get_N ^^
+            compile_add64_const 4L ^^
+            extend64 get_dst ^^
+            extend64 get_len ^^
+            StableMem.stable64_write env
+          end ^^
 
-  let old_destabilize env ty save_version =
+        (* let M = pagesize * ic0.stable64_size() - 1 *)
+        (* M is beginning of last page *)
+        let (set_M, get_M) = new_local64 env "M" in
+        StableMem.stable64_size env ^^
+        compile_sub64_const 1L ^^
+        compile_shl64_const (Int64.of_int page_size_bits) ^^
+        set_M ^^
+
+        (* store mem_size at M + (pagesize - 12) *)
+        get_M ^^
+        compile_add64_const (Int64.sub page_size64 12L) ^^
+        StableMem.get_mem_size env ^^
+        G.i (Convert (Wasm.Values.I32 I32Op.WrapI64)) ^^
+        (* TODO: write word64 *)
+        StableMem.write_word32 env ^^
+
+        (* save first word at M + (pagesize - 8);
+           mark first word as 0 *)
+        get_M ^^
+        compile_add64_const (Int64.sub page_size64 8L) ^^
+        compile_const_64 0L ^^
+        StableMem.read_and_clear_word32 env ^^
+        StableMem.write_word32 env ^^
+
+        (* save version at M + (pagesize - 4) *)
+        get_M ^^
+        compile_add64_const (Int64.sub page_size64 4L) ^^
+
+        (* assert StableMem.get_version() > StableMem.version_no_stable_memory *)
+        StableMem.get_version env ^^
+        compile_rel_const I32Op.GtU StableMem.version_no_stable_memory ^^
+        E.else_trap_with env "StableMem.get_version() == version_no_stable_memory" ^^
+
+        (* assert StableMem.get_version() <= StableMem.version_max *)
+        StableMem.get_version env ^^
+        compile_rel_const I32Op.LeU StableMem.version_max ^^
+        E.else_trap_with env "StableMem.get_version() > version_max" ^^
+
+        (* record the version *)
+        StableMem.get_version env ^^
+        StableMem.write_word32 env
+
+      end
+
+  let destabilize env ty save_version =
     match E.mode env with
     | Flags.ICMode | Flags.RefMode ->
       let (set_pages, get_pages) = new_local64 env "pages" in
@@ -8274,8 +8678,8 @@ module OldStabilization = struct
           StableMem.get_mem_size env ^^
           G.i (Test (Wasm.Values.I64 I64Op.Eqz)) ^^
           E.else_trap_with env "StableMem.mem_size non-zero" ^^
-          compile_unboxed_const StableMem.version_stable_heap_no_regions ^^
-          save_version ^^
+          compile_unboxed_const 0l ^^
+          StableMem.set_version env ^^
           Object.lit_raw env fs'
         end
         begin
@@ -8284,7 +8688,7 @@ module OldStabilization = struct
           let (set_len, get_len) = new_local env "len" in
           let (set_offset, get_offset) = new_local64 env "offset" in
           compile_const_64 0L ^^
-          read_and_clear_word32 env ^^
+          StableMem.read_and_clear_word32 env ^^
           set_marker ^^
 
           get_marker ^^
@@ -8305,7 +8709,7 @@ module OldStabilization = struct
               (* read version *)
               get_M ^^
               compile_add64_const (Int64.sub page_size64 4L) ^^
-              read_and_clear_word32 env ^^
+              StableMem.read_and_clear_word32 env ^^
               set_version ^^
               get_version ^^
               save_version ^^
@@ -8322,13 +8726,13 @@ module OldStabilization = struct
               compile_const_64 0L ^^
               get_M ^^
               compile_add64_const (Int64.sub page_size64 8L) ^^
-              read_and_clear_word32 env ^^
-              write_word32 env ^^
+              StableMem.read_and_clear_word32 env ^^
+              StableMem.write_word32 env ^^
 
               (* restore mem_size *)
               get_M ^^
               compile_add64_const (Int64.sub page_size64 12L) ^^
-              extend64 (read_and_clear_word32 env) ^^ (*TODO: use 64 bits *)
+              extend64 (StableMem.read_and_clear_word32 env) ^^ (*TODO: use 64 bits *)
               StableMem.set_mem_size env ^^
 
               StableMem.get_mem_size env ^^
@@ -8337,7 +8741,7 @@ module OldStabilization = struct
 
               (* set len *)
               get_N ^^
-              read_and_clear_word32 env ^^
+              StableMem.read_and_clear_word32 env ^^
               set_len ^^
 
               (* set offset *)
@@ -8382,7 +8786,7 @@ module OldStabilization = struct
 
           (* clear blob contents *)
           get_blob ^^
-          blob_clear env ^^
+          Blob.clear env ^^
 
           (* copy zeros from blob to stable memory *)
           get_offset ^^
@@ -8396,215 +8800,21 @@ module OldStabilization = struct
     | _ -> assert false
 end
 
-(* New stable memory layout with new version.
-   Prevents forward compatibility of old compiled programs that rely on deserialization.
-  If size == 0: empty
-  let end = physical size * page_size
-  If logical size N > 0:
-    [0..4)          0 (first word is backed up at `end-8`)
-    [4..N)          <stable memory>
-            <zero padding>
-    [end-16..end-8) <size N>
-    [end-8..end-4)  <first word>
-    [end-4..end)   <new version>
-  ending at page boundary
-  Note: The first word must be empty to distinguish this version from the Candid legacy version 0 (which has first word != 0).
-*)
-module NewStableMemory = struct
-  let physical_size env =
-    IC.system_call env "stable64_size" ^^
-    compile_shl64_const (Int64.of_int page_size_bits)
-
-  let store_at_end env offset typ get_value =
-    physical_size env ^^
-    compile_sub64_const offset ^^
-    get_value ^^
-    match typ with
-    | I32Type -> StableMem.write_word32 env
-    | I64Type -> StableMem.write_word64 env
-    | _ -> assert false
-
-  let read_from_end env offset typ =
-    physical_size env ^^
-    compile_sub64_const offset ^^
-    match typ with
-    | I32Type -> StableMem.read_word32 env
-    | I64Type -> StableMem.read_word64 env
-    | _ -> assert false
-
-  let clear_at_end env offset typ =
-    store_at_end env offset typ 
-    (match typ with
-    | I32Type -> compile_unboxed_const 0l
-    | I64Type -> compile_const_64 0L
-    | _ -> assert false
-    )
-
-  let logical_size_offset = 16L
-  let first_word_backup_offset = 8L
-  let version_offset = 4L
-
-  let upgrade_version env =
-    StableMem.set_version env ^^
-    StableMem.get_version env ^^
-    compile_eq_const StableMem.legacy_version_no_stable_memory ^^
-    StableMem.get_version env ^^
-    compile_eq_const StableMem.legacy_version_some_stable_memory ^^
-    G.i (Binary (Wasm.Values.I32 I32Op.Or)) ^^
-    (G.if0
-      (compile_unboxed_const StableMem.version_stable_heap_no_regions ^^
-      StableMem.set_version env)
-      G.nop) ^^
-    StableMem.get_version env ^^
-    compile_eq_const StableMem.legacy_version_regions ^^
-    (G.if0
-      (compile_unboxed_const StableMem.version_stable_heap_regions ^^
-      StableMem.set_version env)
-      G.nop)
-      
-  let grow_size env amount =
-    StableMem.get_mem_size env ^^
-    compile_shl64_const (Int64.of_int page_size_bits) ^^
-    compile_const_64 amount ^^
-    StableMem.ensure env
-
-  let backup env =
-    let (set_first_word, get_first_word) = new_local env "first_word" in
-    physical_size env ^^
-    G.i (Test (Wasm.Values.I64 I64Op.Eqz)) ^^
-    G.if0
-      G.nop
-      begin
-        (* read and clear first word *)
-        compile_const_64 0L ^^ StableMem.read_word32 env ^^ set_first_word ^^
-        compile_const_64 0L ^^ compile_unboxed_const 0l ^^ StableMem.write_word32 env ^^
-
-        grow_size env logical_size_offset ^^
-
-        (* backup logical size *)
-        store_at_end env logical_size_offset I64Type (StableMem.get_mem_size env) ^^
-
-        (* backup first word *)
-        store_at_end env first_word_backup_offset I32Type get_first_word ^^
-
-        (* store the version *)
-        store_at_end env version_offset I32Type (StableMem.get_version env)
-      end
+module GCRoots = struct
+  let register env static_roots =
 
-  let restore env =
-    let (set_first_word, get_first_word) = new_local env "first_word" in
-    physical_size env ^^
-    G.i (Test (Wasm.Values.I64 I64Op.Eqz)) ^^
-    G.if0
-      begin
-        compile_const_64 0L ^^ StableMem.set_mem_size env
-      end
-      begin
-        (* check the version *)
-        read_from_end env version_offset I32Type ^^
-        StableMem.set_version env ^^
-        StableMem.get_version env ^^
-        compile_eq_const StableMem.version_stable_heap_no_regions ^^
-        StableMem.get_version env ^^
-        compile_eq_const StableMem.version_stable_heap_regions ^^
-        G.i (Binary (Wasm.Values.I32 I32Op.Or)) ^^
-        E.else_trap_with env (Printf.sprintf
-          "unsupported stable memory version (expected %s or %s)"
-           (Int32.to_string StableMem.version_stable_heap_no_regions)
-           (Int32.to_string StableMem.version_stable_heap_regions)) ^^
-
-        (* read first word *)
-        read_from_end env first_word_backup_offset I32Type ^^
-        set_first_word ^^
-        
-        (* restore logical size *)
-        read_from_end env logical_size_offset I64Type ^^
-        StableMem.set_mem_size env ^^
-
-        (* clear size and version *)
-        clear_at_end env logical_size_offset I64Type ^^
-        clear_at_end env first_word_backup_offset I32Type ^^
-        clear_at_end env version_offset I32Type ^^
-
-        (* restore first word *)
-        compile_const_64 0L ^^ get_first_word ^^ StableMem.write_word32 env
-      end
-end
+    let get_static_roots = E.add_fun env "get_static_roots" (Func.of_body env [] [I32Type] (fun env ->
+      compile_unboxed_const static_roots
+    )) in
 
-module Persistence = struct
-  let load_stable_actor env = E.call_import env "rts" "load_stable_actor"
-    
-  let save_stable_actor env = E.call_import env "rts" "save_stable_actor"
-
-  let free_stable_actor env = E.call_import env "rts" "free_stable_actor"
-
-  let register_stable_type env actor_type =
-    let (candid_type_desc, type_offsets, type_indices) = Serialization.(type_desc env Persistence [actor_type]) in
-    let serialized_offsets = StaticBytes.(as_bytes [i32s (List.map Int32.of_int type_offsets)]) in
-    assert (type_indices = [0l]);
-    Blob.lit env Tagged.B candid_type_desc ^^
-    Blob.lit env Tagged.B serialized_offsets ^^
-    E.call_import env "rts" "register_stable_type"
-
-  let create_actor env actor_type get_field_value =
-    let (_, field_declarations) = Type.as_obj actor_type in
-    let field_initializers = List.map
-      (fun field -> (field.Type.lab, fun () -> (get_field_value field)))
-      field_declarations
-    in
-    Object.lit_raw env field_initializers
+    E.add_export env (nr {
+      name = Lib.Utf8.decode "get_static_roots";
+      edesc = nr (FuncExport (nr get_static_roots))
+    })
 
-  let recover_actor env actor_type =
-    let load_old_field env field =
-      if field.Type.typ = Type.(Opt Any) then
-        (* A stable variable may have been promoted to type `Any`: Therefore, drop its former content. *)
-        Opt.inject env (Tuple.compile_unit env)
-      else
-        (load_stable_actor env ^^ Object.load_idx_raw env field.Type.lab) in
-    let recover_field field = 
-      load_stable_actor env ^^
-      Object.contains_field env field.Type.lab ^^
-      (G.if1 I32Type
-        (load_old_field env field)
-        (Opt.null_lit env)
-      ) in
-    create_actor env actor_type recover_field ^^
-    free_stable_actor env
-
-  let save env actor_type =
-    save_stable_actor env ^^
-    NewStableMemory.backup env ^^
-    UpgradeStatistics.set_instructions env
-
-  let load env actor_type =
-    register_stable_type env actor_type ^^
-    load_stable_actor env ^^
-    G.i (Test (Wasm.Values.I32 I32Op.Eqz)) ^^
-    (G.if1 I32Type
-      begin
-        OldStabilization.old_destabilize env actor_type (NewStableMemory.upgrade_version env)
-      end
-      begin
-        recover_actor env actor_type ^^
-        NewStableMemory.restore env
-      end) ^^
-    StableMem.region_init env ^^
-    UpgradeStatistics.add_instructions env
-end
+  let store_static_roots env =
+    Arr.vanilla_lit env Tagged.M (E.get_static_roots env)
 
-module GCRoots = struct
-  let register_static_variables env =
-    E.(env.object_pool.frozen) := true;
-    Func.share_code0 Func.Always env "initialize_root_array" [] (fun env ->
-      let length = Int32.of_int (E.object_pool_size env) in
-      compile_unboxed_const length ^^
-      E.call_import env "rts" "initialize_static_variables" ^^
-      E.iterate_object_pool env (fun index allocation ->
-        compile_unboxed_const (Int32.of_int index) ^^
-        allocation env ^^
-        E.call_import env "rts" "set_static_variable"
-      )
-    )
 end (* GCRoots *)
 
 module StackRep = struct
@@ -8685,38 +8895,49 @@ module StackRep = struct
     | UnboxedTuple n -> G.table n (fun _ -> G.i Drop)
     | Const _ | Unreachable -> G.nop
 
-  let rec build_constant env = function
-  | Const.Lit (Const.Vanilla value) -> E.Vanilla value
-  | Const.Lit (Const.Bool number) -> E.Vanilla (Bool.vanilla_lit number)
-  | Const.Lit (Const.Text payload) -> Blob.constant env Tagged.T payload
-  | Const.Lit (Const.Blob payload) -> Blob.constant env Tagged.B payload
-  | Const.Lit (Const.Null) -> E.Vanilla Opt.null_vanilla_lit
-  | Const.Lit (Const.BigInt number) -> BigNum.constant env number
-  | Const.Lit (Const.Word32 (pty, number)) -> BoxedSmallWord.constant env pty number
-  | Const.Lit (Const.Word64 (pty, number)) -> BoxedWord64.constant env pty number
-  | Const.Lit (Const.Float64 number) -> Float.constant env number
-  | Const.Opt value -> Opt.constant env (build_constant env value)
-  | Const.Fun (_, get_fi, _) -> Closure.constant env get_fi
-  | Const.Message _ -> assert false
-  | Const.Unit -> E.Vanilla (Tuple.unit_vanilla_lit env)
-  | Const.Tag (tag, value) ->
-      let payload = build_constant env value in
-      Tagged.shared_object env (fun env ->
-        let materialized_payload = Tagged.materialize_shared_value env payload in
-        Variant.inject env tag materialized_payload
-      )
-  | Const.Array elements -> 
-      let constant_elements = List.map (build_constant env) elements in
-      Arr.constant env Tagged.I constant_elements
-  | Const.Tuple elements -> 
-      let constant_elements = List.map (build_constant env) elements in
-      Arr.constant env Tagged.T constant_elements
-  | Const.Obj fields ->
-      let constant_fields = List.map (fun (name, value) -> (name, build_constant env value)) fields in
-      Object.constant env constant_fields
-
-  let materialize_constant env value =
-    Tagged.materialize_shared_value env (build_constant env value)
+  (* Materializes a Const.lit: If necessary, puts
+     bytes into static memory, and returns a vanilla value.
+  *)
+  let materialize_lit env (lit : Const.lit) : int32 =
+    match lit with
+    | Const.Vanilla n  -> n
+    | Const.Bool n     -> Bool.vanilla_lit n
+    | Const.BigInt n   -> BigNum.vanilla_lit env n
+    | Const.Word32 (pty, n) -> BoxedSmallWord.vanilla_lit env pty n
+    | Const.Word64 (pty, n) -> BoxedWord64.vanilla_lit env pty n
+    | Const.Float64 f  -> Float.vanilla_lit env f
+    | Const.Text t -> Blob.vanilla_lit env Tagged.T t
+    | Const.Blob t -> Blob.vanilla_lit env Tagged.B t
+    | Const.Null       -> Opt.null_vanilla_lit env
+
+  let rec materialize_const_t env (p, cv) : int32 =
+    Lib.Promise.lazy_value p (fun () -> materialize_const_v env cv)
+
+  and materialize_const_v env = function
+    | Const.Fun (get_fi, _) -> Closure.static_closure env (get_fi ())
+    | Const.Message fi -> assert false
+    | Const.Obj fs ->
+      let fs' = List.map (fun (n, c) -> (n, materialize_const_t env c)) fs in
+      Object.vanilla_lit env fs'
+    | Const.Unit -> Tuple.unit_vanilla_lit env
+    | Const.Array cs ->
+      let ptrs = List.map (materialize_const_t env) cs in
+      Arr.vanilla_lit env Tagged.I ptrs
+    | Const.Tuple cs ->
+      let ptrs = List.map (materialize_const_t env) cs in
+      Arr.vanilla_lit env Tagged.T ptrs
+    | Const.Tag (i, c) ->
+      let ptr = materialize_const_t env c in
+      Variant.vanilla_lit env i ptr
+    | Const.Lit l -> materialize_lit env l
+    | Const.Opt c ->
+      let rec kernel = Const.(function
+        | (_, Lit Null) -> None
+        | (_, Opt c) -> kernel c
+        | (_, other) -> Some (materialize_const_v env other)) in
+      match kernel c with
+      | Some ptr -> ptr
+      | None -> Opt.vanilla_lit env (materialize_const_t env c)
 
   let adjust env (sr_in : t) sr_out =
     if eq sr_in sr_out
@@ -8753,20 +8974,20 @@ module StackRep = struct
     | UnboxedFloat64, Vanilla -> Float.box env
     | Vanilla, UnboxedFloat64 -> Float.unbox env
 
-    | Const value, Vanilla -> 
-        materialize_constant env value
-    | Const Const.Lit (Const.Vanilla n), UnboxedWord32 ty ->
-        compile_unboxed_const n ^^
-        TaggedSmallWord.untag env ty
-    | Const Const.Lit (Const.Word32 (ty1, n)), UnboxedWord32 ty2 when ty1 = ty2 -> 
-        compile_unboxed_const n
-    | Const Const.Lit (Const.Word64 (ty1, n)), UnboxedWord64 ty2 when ty1 = ty2 -> 
-        compile_const_64 n
-    | Const Const.Lit (Const.Float64 f), UnboxedFloat64 -> Float.compile_unboxed_const f
+    | Const (_, Const.Lit (Const.Bool b)), Vanilla -> Bool.lit b
+    | Const c, Vanilla -> compile_unboxed_const (materialize_const_t env c)
+    | Const (_, Const.Lit (Const.Vanilla n)), UnboxedWord32 ty ->
+       compile_unboxed_const n ^^
+       TaggedSmallWord.untag env ty
+    | Const (_, Const.Lit (Const.Word32 (ty1, n))), UnboxedWord32 ty2 when ty1 = ty2 ->
+       compile_unboxed_const n
+    | Const (_, Const.Lit (Const.Word64 (ty1, n))), UnboxedWord64 ty2 when ty1 = ty2 ->
+       compile_const_64 n
+    | Const (_, Const.Lit (Const.Float64 f)), UnboxedFloat64 -> Float.compile_unboxed_const f
     | Const c, UnboxedTuple 0 -> G.nop
-    | Const Const.Tuple cs, UnboxedTuple n ->
+    | Const (_, Const.Tuple cs), UnboxedTuple n ->
       assert (n = List.length cs);
-      G.concat_map (fun c -> materialize_constant env c) cs
+      G.concat_map (fun c -> compile_unboxed_const (materialize_const_t env c)) cs
     | _, _ ->
       Printf.eprintf "Unknown stack_rep conversion %s -> %s\n"
         (to_string sr_in) (to_string sr_out);
@@ -8785,18 +9006,18 @@ module VarEnv = struct
     (* A Wasm Local of the current function, that points to memory location,
        which is a MutBox.  Used for mutable captured data *)
     | HeapInd of int32
-    (* A static variable accessed by an index via the runtime system, refers to a MutBox,
-       belonging to the GC root set *)
-    | Static of int32
-    (* Constant literals can reside in dynamic heap *)
-    | Const of Const.v
+    (* A static mutable memory location (static address of a MutBox object) *)
+    (* TODO: Do we need static immutable? *)
+    | HeapStatic of int32
+    (* Not materialized (yet), statically known constant, static location on demand *)
+    | Const of Const.t
     (* public method *)
     | PublicMethod of int32 * string
 
   let is_non_local : varloc -> bool = function
     | Local _
     | HeapInd _ -> false
-    | Static _
+    | HeapStatic _
     | PublicMethod _
     | Const _ -> true
 
@@ -8856,8 +9077,8 @@ module VarEnv = struct
       E.add_local_name env i name;
       ({ ae with vars = NameEnv.add name ((HeapInd i), typ) ae.vars }, i)
 
-  let add_static_variable (ae : t) name index typ =
-      { ae with vars = NameEnv.add name ((Static index), typ) ae.vars }
+  let add_local_heap_static (ae : t) name ptr typ =
+      { ae with vars = NameEnv.add name ((HeapStatic ptr), typ) ae.vars }
 
   let add_local_public_method (ae : t) name (fi, exported_name) typ =
       { ae with vars = NameEnv.add name ((PublicMethod (fi, exported_name) : varloc), typ) ae.vars }
@@ -8882,9 +9103,9 @@ module VarEnv = struct
         E.add_local_name env i name;
         let ae' = { ae with vars = NameEnv.add name ((Local (SR.Vanilla, i)), typ) ae.vars } in
         add_arguments env ae' as_local remainder
-      else
-        let index = MutBox.add_global_mutbox env in
-        let ae' = add_static_variable ae name index typ in
+      else (* needs to go to static memory *)
+        let ptr = MutBox.static env in
+        let ae' = add_local_heap_static ae name ptr typ in
         add_arguments env ae' as_local remainder
 
   let add_argument_locals env (ae : t) =
@@ -8926,36 +9147,54 @@ module Var = struct
 
   (* Returns desired stack representation, preparation code and code to consume
      the value onto the stack *)
-  let set_val env ae var : G.t * SR.t * G.t = match VarEnv.lookup ae var with
-    | Some ((Local (sr, i)), _) ->
+  let set_val env ae var : G.t * SR.t * G.t = match (VarEnv.lookup ae var, !Flags.gc_strategy) with
+    | (Some ((Local (sr, i)), _), _) ->
       G.nop,
       sr,
       G.i (LocalSet (nr i))
-    | Some ((HeapInd i), typ) when potential_pointer typ ->
+    | (Some ((HeapInd i), typ), Flags.Generational) when potential_pointer typ ->
+      G.i (LocalGet (nr i)),
+      SR.Vanilla,
+      MutBox.store_field env ^^
+      G.i (LocalGet (nr i)) ^^
+      Tagged.load_forwarding_pointer env ^^ (* not needed for this GC, but only for forward pointer sanity checks *)
+      compile_add_const ptr_unskew ^^
+      compile_add_const (Int32.mul (MutBox.field env) Heap.word_size) ^^
+      E.call_import env "rts" "post_write_barrier"
+    | (Some ((HeapInd i), typ), Flags.Incremental) when potential_pointer typ ->
       G.i (LocalGet (nr i)) ^^
       Tagged.load_forwarding_pointer env ^^
       compile_add_const ptr_unskew ^^
-      compile_add_const (Int32.mul MutBox.field Heap.word_size),
+      compile_add_const (Int32.mul (MutBox.field env) Heap.word_size),
       SR.Vanilla,
       Tagged.write_with_barrier env
-    | Some ((HeapInd i), typ) ->
+    | (Some ((HeapInd i), typ), _) ->
       G.i (LocalGet (nr i)),
       SR.Vanilla,
       MutBox.store_field env
-    | Some ((Static index), typ) when potential_pointer typ ->
-      Heap.get_static_variable env index ^^
+    | (Some ((HeapStatic ptr), typ), Flags.Generational) when potential_pointer typ ->
+      compile_unboxed_const ptr,
+      SR.Vanilla,
+      MutBox.store_field env ^^
+      compile_unboxed_const ptr ^^
+      Tagged.load_forwarding_pointer env ^^ (* not needed for this GC, but only for forward pointer sanity checks *)
+      compile_add_const ptr_unskew ^^
+      compile_add_const (Int32.mul (MutBox.field env) Heap.word_size) ^^
+      E.call_import env "rts" "post_write_barrier"
+    | (Some ((HeapStatic ptr), typ), Flags.Incremental) when potential_pointer typ ->
+      compile_unboxed_const ptr ^^
       Tagged.load_forwarding_pointer env ^^
       compile_add_const ptr_unskew ^^
-      compile_add_const (Int32.mul MutBox.field Heap.word_size),
+      compile_add_const (Int32.mul (MutBox.field env) Heap.word_size),
       SR.Vanilla,
       Tagged.write_with_barrier env
-    | Some ((Static index), typ) ->
-      Heap.get_static_variable env index,
+    | (Some ((HeapStatic ptr), typ), _) ->
+      compile_unboxed_const ptr,
       SR.Vanilla,
       MutBox.store_field env
-    | Some ((Const _), _) -> fatal "set_val: %s is const" var
-    | Some ((PublicMethod _), _) -> fatal "set_val: %s is PublicMethod" var
-    | None -> fatal "set_val: %s missing" var
+    | (Some ((Const _), _), _) -> fatal "set_val: %s is const" var
+    | (Some ((PublicMethod _), _), _) -> fatal "set_val: %s is PublicMethod" var
+    | (None, _)   -> fatal "set_val: %s missing" var
 
   (* Stores the payload. Returns stack preparation code, and code that consumes the values from the stack *)
   let set_val_vanilla env ae var : G.t * G.t =
@@ -8981,10 +9220,8 @@ module Var = struct
       sr, G.i (LocalGet (nr i))
     | Some (HeapInd i) ->
       SR.Vanilla, G.i (LocalGet (nr i)) ^^ MutBox.load_field env
-    | Some (Static index) ->
-      SR.Vanilla, 
-      Heap.get_static_variable env index ^^
-      MutBox.load_field env
+    | Some (HeapStatic i) ->
+      SR.Vanilla, compile_unboxed_const i ^^ MutBox.load_field env
     | Some (Const c) ->
       SR.Const c, G.nop
     | Some (PublicMethod (_, name)) ->
@@ -9025,12 +9262,12 @@ module Var = struct
      In the IR, mutable fields of objects are pre-allocated as MutBox objects,
      to allow the async/await.
      So we expect the variable to be in a HeapInd (pointer to MutBox on the heap),
-     or Static (static variable represented as a MutBox that is accessed via the 
-     runtime system) and we use the pointer.
+     or HeapStatic (statically known MutBox in the static memory) and we use
+     the pointer.
   *)
   let get_aliased_box env ae var = match VarEnv.lookup_var ae var with
     | Some (HeapInd i) -> G.i (LocalGet (nr i))
-    | Some (Static index) -> Heap.get_static_variable env index
+    | Some (HeapStatic i) -> compile_unboxed_const i
     | _ -> assert false
 
   let capture_aliased_box env ae var = match VarEnv.lookup_var ae var with
@@ -9047,7 +9284,7 @@ end (* Var *)
 module Internals = struct
   let call_prelude_function env ae var =
     match VarEnv.lookup_var ae var with
-    | Some (VarEnv.Const Const.Fun (_, mk_fi, _)) ->
+    | Some (VarEnv.Const (_, Const.Fun (mk_fi, _))) ->
        compile_unboxed_zero ^^ (* A dummy closure *)
        G.i (Call (nr (mk_fi ())))
     | _ -> assert false
@@ -9154,14 +9391,13 @@ module FuncDec = struct
     if Type.is_shared_sort sort
     then begin
       let (fi, fill) = E.reserve_fun pre_env name in
-      ( Const.Message fi, fun env ae ->
+      ( Const.t_of_v (Const.Message fi), fun env ae ->
         fill (compile_const_message env ae sort control args mk_body ret_tys at)
       )
     end else begin
       assert (control = Type.Returns);
       let lf = E.make_lazy_function pre_env name in
-      let fun_id = E.get_constant_function_id pre_env in
-      ( Const.Fun (fun_id, (fun () -> Lib.AllocOnUse.use lf), fun_rhs), fun env ae ->
+      ( Const.t_of_v (Const.Fun ((fun () -> Lib.AllocOnUse.use lf), fun_rhs)), fun env ae ->
         let restore_no_env _env ae _ = ae, unmodified in
         Lib.AllocOnUse.def lf (lazy (compile_local_function env ae restore_no_env args mk_body ret_tys at))
       )
@@ -9206,18 +9442,18 @@ module FuncDec = struct
 
       let code =
         (* Allocate a heap object for the closure *)
-        Tagged.alloc env (Int32.add Closure.header_size len) Tagged.Closure ^^
+        Tagged.alloc env (Int32.add (Closure.header_size env) len) Tagged.Closure ^^
         set_clos ^^
 
         (* Store the function pointer number: *)
         get_clos ^^
         compile_unboxed_const (E.add_fun_ptr env fi) ^^
-        Tagged.store_field env Closure.funptr_field ^^
+        Tagged.store_field env (Closure.funptr_field env) ^^
 
         (* Store the length *)
         get_clos ^^
         compile_unboxed_const len ^^
-        Tagged.store_field env Closure.len_field ^^
+        Tagged.store_field env (Closure.len_field env) ^^
 
         (* Store all captured values *)
         store_env ^^
@@ -9536,7 +9772,7 @@ module FuncDec = struct
         *)
         (* Instead, just ignore the argument and
            send a *statically* allocated, nullary reply *)
-        Blob.lit_ptr_len env Tagged.B "DIDL\x00\x00" ^^
+        Blob.lit_ptr_len env "DIDL\x00\x00" ^^
         IC.reply_with_data env ^^
         (* Finally, act like
         message_cleanup env (Type.Shared Type.Write)
@@ -9760,7 +9996,7 @@ module AllocHow = struct
   let how_of_ae ae : allocHow =
     M.map (fun (l, _) -> match l with
     | VarEnv.Const _        -> (Const : how)
-    | VarEnv.Static _       -> StoreStatic
+    | VarEnv.HeapStatic _   -> StoreStatic
     | VarEnv.HeapInd _      -> StoreHeap
     | VarEnv.Local (sr, _)  -> LocalMut sr (* conservatively assume mutable *)
     | VarEnv.PublicMethod _ -> LocalMut SR.Vanilla
@@ -9794,8 +10030,8 @@ module AllocHow = struct
       let alloc_code = MutBox.alloc env ^^ G.i (LocalSet (nr i)) in
       (ae1, alloc_code)
     | StoreStatic ->
-      let index = MutBox.add_global_mutbox env in
-      let ae1 = VarEnv.add_static_variable ae name index typ in
+      let ptr = MutBox.static env in
+      let ae1 = VarEnv.add_local_heap_static ae name ptr typ in
       (ae1, G.nop)
 
   let add_local_for_alias env ae how name typ : VarEnv.t * G.t =
@@ -9843,7 +10079,7 @@ let const_lit_of_lit : Ir.lit -> Const.lit = function
   | FloatLit f    -> Const.Float64 f
 
 let const_of_lit lit =
-  Const.Lit (const_lit_of_lit lit)
+  Const.t_of_v (Const.Lit (const_lit_of_lit lit))
 
 let compile_lit lit =
   SR.Const (const_of_lit lit), G.nop
@@ -10463,25 +10699,46 @@ let compile_load_field env typ name =
 *)
 let rec compile_lexp (env : E.t) ae lexp : G.t * SR.t * G.t =
   (fun (code, sr, fill_code) -> G.(with_region lexp.at code, sr, with_region lexp.at fill_code)) @@
-  match lexp.it with
-  | VarLE var -> Var.set_val env ae var
-  | IdxLE (e1, e2) when potential_pointer (Arr.element_type env e1.note.Note.typ) ->
+  match lexp.it, !Flags.gc_strategy with
+  | VarLE var, _ -> Var.set_val env ae var
+  | IdxLE (e1, e2), Flags.Generational when potential_pointer (Arr.element_type env e1.note.Note.typ) ->
+    let (set_field, get_field) = new_local env "field" in
+    compile_array_index env ae e1 e2 ^^
+    set_field ^^ (* peepholes to tee *)
+    get_field,
+    SR.Vanilla,
+    store_ptr ^^
+    get_field ^^
+    compile_add_const ptr_unskew ^^
+    E.call_import env "rts" "post_write_barrier"
+  | IdxLE (e1, e2), Flags.Incremental when potential_pointer (Arr.element_type env e1.note.Note.typ) ->
     compile_array_index env ae e1 e2 ^^
     compile_add_const ptr_unskew,
     SR.Vanilla,
     Tagged.write_with_barrier env
-  | IdxLE (e1, e2) ->
+  | IdxLE (e1, e2), _ ->
     compile_array_index env ae e1 e2,
     SR.Vanilla,
     store_ptr
-  | DotLE (e, n) when potential_pointer (Object.field_type env e.note.Note.typ n) ->
+  | DotLE (e, n), Flags.Generational when potential_pointer (Object.field_type env e.note.Note.typ n) ->
+    let (set_field, get_field) = new_local env "field" in
+    compile_exp_vanilla env ae e ^^
+    Object.idx env e.note.Note.typ n ^^
+    set_field ^^ (* peepholes to tee *)
+    get_field,
+    SR.Vanilla,
+    store_ptr ^^
+    get_field ^^
+    compile_add_const ptr_unskew ^^
+    E.call_import env "rts" "post_write_barrier"
+  | DotLE (e, n), Flags.Incremental when potential_pointer (Object.field_type env e.note.Note.typ n) ->
     compile_exp_vanilla env ae e ^^
     (* Only real objects have mutable fields, no need to branch on the tag *)
     Object.idx env e.note.Note.typ n ^^
     compile_add_const ptr_unskew,
     SR.Vanilla,
     Tagged.write_with_barrier env
-  | DotLE (e, n) ->
+  | DotLE (e, n), _ ->
     compile_exp_vanilla env ae e ^^
     (* Only real objects have mutable fields, no need to branch on the tag *)
     Object.idx env e.note.Note.typ n,
@@ -10514,7 +10771,7 @@ and compile_prim_invocation (env : E.t) ae p es at =
 
     (* we duplicate this pattern match to emulate pattern guards *)
     let call_as_prim = match fun_sr, sort with
-      | SR.Const Const.Fun (_, mk_fi, Const.PrimWrapper prim), _ ->
+      | SR.Const (_, Const.Fun (mk_fi, Const.PrimWrapper prim)), _ ->
          begin match n_args, e2.it with
          | 0, _ -> true
          | 1, _ -> true
@@ -10524,7 +10781,7 @@ and compile_prim_invocation (env : E.t) ae p es at =
       | _ -> false in
 
     begin match fun_sr, sort with
-      | SR.Const Const.Fun (_, mk_fi, Const.PrimWrapper prim), _ when call_as_prim ->
+      | SR.Const (_, Const.Fun (mk_fi, Const.PrimWrapper prim)), _ when call_as_prim ->
          assert (sort = Type.Local);
          (* Handle argument tuples *)
          begin match n_args, e2.it with
@@ -10543,7 +10800,7 @@ and compile_prim_invocation (env : E.t) ae p es at =
            (* ugly case; let's just call this as a function for now *)
            raise (Invalid_argument "call_as_prim was true?")
          end
-      | SR.Const Const.Fun (_, mk_fi, _), _ ->
+      | SR.Const (_, Const.Fun (mk_fi, _)), _ ->
          assert (sort = Type.Local);
          StackRep.of_arity return_arity,
 
@@ -10624,7 +10881,7 @@ and compile_prim_invocation (env : E.t) ae p es at =
   | DotPrim name, [e] ->
     let sr, code1 = compile_exp env ae e in
     begin match sr with
-    | SR.Const Const.Obj fs ->
+    | SR.Const (_, Const.Obj fs) ->
       let c = List.assoc name fs in
       SR.Const c, code1
     | _ ->
@@ -10672,9 +10929,9 @@ and compile_prim_invocation (env : E.t) ae p es at =
        fields, effectively arriving at the desired element *)
     G.i (Binary (Wasm.Values.I32 I32Op.Add)) ^^
     (* Not using Tagged.load_field since it is not a proper pointer to the array start *)
-    Heap.load_field Arr.header_size (* loads the element at the byte offset *)
+    Heap.load_field (Arr.header_size env) (* loads the element at the byte offset *)
   | GetLastArrayOffset, [e] ->
-    assert (BitTagged.can_tag_const Type.Int (Int64.of_int32 (Int32.sub Arr.max_array_size 1l)));
+    assert (BitTagged.can_tag_const Type.Int (Int64.of_int32 (Int32.sub (Arr.max_array_size env) 1l)));
     SR.Vanilla,
     compile_exp_vanilla env ae e ^^ (* array *)
     Arr.len env ^^
@@ -11006,8 +11263,14 @@ and compile_prim_invocation (env : E.t) ae p es at =
     GC.collect_garbage env
 
   | ICStableSize t, [e] ->
-    SR.UnboxedWord64 Type.Nat64,
-    E.trap_with env "Deprecated with enhanced orthogonal persistence"
+    SR.UnboxedWord64  Type.Nat64,
+    let (tydesc, _, _) = Serialization.type_desc env [t] in
+    let tydesc_len = Int32.of_int (String.length tydesc) in
+    compile_exp_vanilla env ae e ^^
+    Serialization.buffer_size env t ^^
+    G.i Drop ^^
+    compile_add_const tydesc_len ^^
+    G.i (Convert (Wasm.Values.I64 I64Op.ExtendUI32))
 
   (* Other prims, unary *)
 
@@ -11230,10 +11493,6 @@ and compile_prim_invocation (env : E.t) ae p es at =
     SR.Vanilla,
     GC.get_collector_instructions env ^^ BigNum.from_word64 env
 
-  | OtherPrim "rts_upgrade_instructions", [] ->
-    SR.Vanilla,
-    UpgradeStatistics.get_upgrade_instructions env ^^ BigNum.from_word64 env
-
   | OtherPrim "rts_stable_memory_size", [] ->
     SR.Vanilla,
     StableMem.stable64_size env ^^ BigNum.from_word64 env
@@ -11270,7 +11529,8 @@ and compile_prim_invocation (env : E.t) ae p es at =
     compile_exp_as env ae SR.Vanilla e0 ^^
     compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
     compile_exp_as env ae SR.Vanilla e2 ^^
-    BigNum.to_word32_with env (Blob.lit env Tagged.T "Blob size out of bounds") ^^
+    Blob.lit env Tagged.T "Blob size out of bounds" ^^
+    BigNum.to_word32_with env ^^
     Region.load_blob env
 
   | OtherPrim ("regionStoreBlob"), [e0; e1; e2] ->
@@ -11616,7 +11876,8 @@ and compile_prim_invocation (env : E.t) ae p es at =
     SR.Vanilla,
     compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
     compile_exp_as env ae SR.Vanilla e2 ^^
-    BigNum.to_word32_with env (Blob.lit env Tagged.T "Blob size out of bounds") ^^
+    Blob.lit env Tagged.T "Blob size out of bounds" ^^
+    BigNum.to_word32_with env ^^
     StableMemoryInterface.load_blob env
 
   | OtherPrim "stableMemoryStoreBlob", [e1; e2] ->
@@ -11777,12 +12038,23 @@ and compile_prim_invocation (env : E.t) ae p es at =
     SR.Vanilla, IC.method_name env
 
   | ICStableRead ty, [] ->
+    (*
+      * On initial install:
+        1. return record of nulls
+      * On upgrade:
+        1. deserialize stable store to v : ty,
+        2. possibly run region manager initialization logic.
+        3. return v
+    *)
     SR.Vanilla,
-    Persistence.load env ty
-  | ICStableWrite ty, [e] ->
+    Stabilization.destabilize env ty (StableMem.set_version env) ^^
+    compile_unboxed_const (if !Flags.use_stable_regions then 1l else 0l) ^^
+    E.call_import env "rts" "region_init"
+
+  | ICStableWrite ty, [] ->
     SR.unit,
-    compile_exp_vanilla env ae e ^^
-    Persistence.save env ty
+    IC.get_actor_to_persist env ^^
+    Stabilization.stabilize env ty
 
   (* Cycles *)
   | SystemCyclesBalancePrim, [] ->
@@ -12087,7 +12359,8 @@ enabled mutual recursion.
 and compile_lit_pat env l =
   match l with
   | NullLit ->
-    Opt.is_null env
+    compile_lit_as env SR.Vanilla l ^^
+    G.i (Compare (Wasm.Values.I32 I32Op.Eq))
   | BoolLit true ->
     G.nop
   | BoolLit false ->
@@ -12292,7 +12565,7 @@ and compile_dec env pre_ae how v2en dec : VarEnv.t * G.t * (VarEnv.t -> scope_wr
   | LetD ({it = VarP v; _}, e) when E.NameEnv.mem v v2en ->
     let (const, fill) = compile_const_exp env pre_ae e in
     let fi = match const with
-      | Const.Message fi -> fi
+      | (_, Const.Message fi) -> fi
       | _ -> assert false in
     let pre_ae1 = VarEnv.add_local_public_method pre_ae v (fi, (E.NameEnv.find v v2en)) e.note.Note.typ in
     G.( pre_ae1, nop, (fun ae -> fill env ae; nop), unmodified)
@@ -12362,7 +12635,7 @@ and compile_decs env ae decs captured_in_body : VarEnv.t * scope_wrap =
 (* This compiles expressions determined to be const as per the analysis in
    ir_passes/const.ml. See there for more details.
 *)
-and compile_const_exp env pre_ae exp : Const.v * (E.t -> VarEnv.t -> unit) =
+and compile_const_exp env pre_ae exp : Const.t * (E.t -> VarEnv.t -> unit) =
   match exp.it with
   | FuncE (name, sort, control, typ_binds, args, res_tys, e) ->
     let fun_rhs =
@@ -12418,37 +12691,37 @@ and compile_const_exp env pre_ae exp : Const.v * (E.t -> VarEnv.t -> unit) =
             | _ -> fatal "compile_const_exp/ObjE: \"%s\" not found" f.it.var
           in f.it.name, st) fs
     in
-    (Const.Obj static_fs), fun _ _ -> ()
+    (Const.t_of_v (Const.Obj static_fs), fun _ _ -> ())
   | PrimE (DotPrim name, [e]) ->
     let (object_ct, fill) = compile_const_exp env pre_ae e in
     let fs = match object_ct with
-      | Const.Obj fs -> fs
+      | _, Const.Obj fs -> fs
       | _ -> fatal "compile_const_exp/DotE: not a static object" in
     let member_ct = List.assoc name fs in
     (member_ct, fill)
   | PrimE (ProjPrim i, [e]) ->
     let (object_ct, fill) = compile_const_exp env pre_ae e in
     let cs = match object_ct with
-      | Const.Tuple cs -> cs
+      | _, Const.Tuple cs -> cs
       | _ -> fatal "compile_const_exp/ProjE: not a static tuple" in
     (List.nth cs i, fill)
-  | LitE l -> Const.(Lit (const_lit_of_lit l)), (fun _ _ -> ())
-  | PrimE (TupPrim, []) -> Const.Unit, (fun _ _ -> ())
+  | LitE l -> Const.(t_of_v (Lit (const_lit_of_lit l))), (fun _ _ -> ())
+  | PrimE (TupPrim, []) -> Const.t_of_v Const.Unit, (fun _ _ -> ())
   | PrimE (ArrayPrim (Const, _), es) ->
     let (cs, fills) = List.split (List.map (compile_const_exp env pre_ae) es) in
-    (Const.Array cs),
+    Const.(t_of_v (Array cs)),
     (fun env ae -> List.iter (fun fill -> fill env ae) fills)
   | PrimE (TupPrim, es) ->
     let (cs, fills) = List.split (List.map (compile_const_exp env pre_ae) es) in
-    (Const.Tuple cs),
+    Const.(t_of_v (Tuple cs)),
     (fun env ae -> List.iter (fun fill -> fill env ae) fills)
   | PrimE (TagPrim i, [e]) ->
     let (arg_ct, fill) = compile_const_exp env pre_ae e in
-    (Const.Tag (i, arg_ct)),
+    Const.(t_of_v (Tag (i, arg_ct))),
     fill
   | PrimE (OptPrim, [e]) ->
     let (arg_ct, fill) = compile_const_exp env pre_ae e in
-    (Const.Opt arg_ct),
+    Const.(t_of_v (Opt arg_ct)),
     fill
 
   | _ -> assert false
@@ -12474,7 +12747,7 @@ and destruct_const_pat ae pat const : VarEnv.t option = match pat.it with
   | WildP -> Some ae
   | VarP v -> Some (VarEnv.add_local_const ae v const pat.note)
   | ObjP pfs ->
-    let fs = match const with Const.Obj fs -> fs | _ -> assert false in
+    let fs = match const with (_, Const.Obj fs) -> fs | _ -> assert false in
     List.fold_left (fun ae (pf : pat_field) ->
       match ae, List.find_opt (fun (n, _) -> pf.it.name = n) fs with
       | None, _ -> None
@@ -12486,26 +12759,26 @@ and destruct_const_pat ae pat const : VarEnv.t option = match pat.it with
     if l = None then destruct_const_pat ae p2 const
     else l
   | TupP ps ->
-    let cs = match const with Const.Tuple cs -> cs | Const.Unit -> [] | _ -> assert false in
+    let cs = match const with (_, Const.Tuple cs) -> cs | (_, Const.Unit) -> [] | _ -> assert false in
     let go ae p c = match ae with
       | Some ae -> destruct_const_pat ae p c
       | _ -> None in
     List.fold_left2 go (Some ae) ps cs
   | LitP lp ->
     begin match const with
-    | Const.Lit lc when Const.lit_eq (const_lit_of_lit lp) lc -> Some ae
+    | (_, Const.Lit lc) when Const.lit_eq (const_lit_of_lit lp, lc) -> Some ae
     | _ -> None
     end
   | OptP p ->
     begin match const with
-      | Const.Opt c -> destruct_const_pat ae p c
-      | Const.(Lit Null) -> None
+      | (_, Const.Opt c) -> destruct_const_pat ae p c
+      | (_, Const.(Lit Null)) -> None
       | _ -> assert false
     end
   | TagP (i, p) ->
      match const with
-     | Const.Tag (ic, c) when i = ic -> destruct_const_pat ae p c
-     | Const.Tag _ -> None
+     | (_, Const.Tag (ic, c)) when i = ic -> destruct_const_pat ae p c
+     | (_, Const.Tag _) -> None
      | _ -> assert false
 
 and compile_const_dec env pre_ae dec : (VarEnv.t -> VarEnv.t) * (E.t -> VarEnv.t -> unit) =
@@ -12534,7 +12807,7 @@ and compile_init_func mod_env ((cu, flavor) : Ir.prog) =
       let _ae, codeW = compile_decs env VarEnv.empty_ae ds Freevars.S.empty in
       codeW G.nop
     )
-  | ActorU (as_opt, ds, fs, up, _t) ->
+  | ActorU (as_opt, ds, fs, up, t) ->
     main_actor as_opt mod_env ds fs up
 
 and export_actor_field env  ae (f : Ir.field) =
@@ -12562,6 +12835,7 @@ and export_actor_field env  ae (f : Ir.field) =
 
 (* Main actor *)
 and main_actor as_opt mod_env ds fs up =
+  let build_stable_actor = up.stable_record in
   Func.define_built_in mod_env "init" [] [] (fun env ->
     let ae0 = VarEnv.empty_ae in
 
@@ -12620,6 +12894,11 @@ and main_actor as_opt mod_env ds fs up =
        IC.export_inspect env;
     end;
 
+    (* Helper function to build the stable actor wrapper *)
+    Func.define_built_in mod_env IC.get_actor_to_persist_function_name [] [I32Type] (fun env ->
+      compile_exp_as env ae2 SR.Vanilla build_stable_actor
+    );
+
     (* Export metadata *)
     env.E.stable_types := metadata "motoko:stable-types" up.meta.sig_;
     env.E.service := metadata "candid:service" up.meta.candid.service;
@@ -12665,7 +12944,9 @@ and conclude_module env set_serialization_globals start_fi_o =
   FuncDec.export_gc_trigger_method env;
 
   (* See Note [Candid subtype checks] *)
-  Serialization.create_global_type_descriptor env set_serialization_globals;
+  Serialization.set_delayed_globals env set_serialization_globals;
+
+  let static_roots = GCRoots.store_static_roots env in
 
   (* declare before building GC *)
 
@@ -12675,15 +12956,14 @@ and conclude_module env set_serialization_globals start_fi_o =
   E.export_global env "__heap_base";
 
   Heap.register env;
+  GCRoots.register env static_roots;
   IC.register env;
 
-  let dynamic_heap_start = Lifecycle.end_ () in
-  set_heap_base dynamic_heap_start;
+  set_heap_base (E.get_end_of_static_memory env);
 
   (* Wrap the start function with the RTS initialization *)
   let rts_start_fi = E.add_fun env "rts_start" (Func.of_body env [] [] (fun env1 ->
-    E.call_import env "rts" ("initialize_incremental_gc") ^^
-    GCRoots.register_static_variables env ^^
+    E.call_import env "rts" ("initialize_" ^ E.gc_strategy_name !Flags.gc_strategy ^ "_gc") ^^
     match start_fi_o with
     | Some fi ->
       G.i (Call fi)
@@ -12699,15 +12979,17 @@ and conclude_module env set_serialization_globals start_fi_o =
 
   let other_imports = E.get_other_imports env in
 
-  let initial_memory_pages = Int32.(add (div dynamic_heap_start page_size) 1l) in
-  let memories = E.get_memories env initial_memory_pages in
+  let memories = E.get_memories env in
 
   let funcs = E.get_funcs env in
 
-  let datas = List.map (fun (dinit) -> nr {
+  let datas = List.map (fun (offset, dinit) -> nr {
     dinit;
-    dmode = (nr Wasm_exts.Ast.Passive);
-    }) (E.get_data_segments env) in
+    dmode = (nr (Wasm_exts.Ast.Active {
+        index = nr 0l;
+        offset = nr (G.to_instr_list (compile_unboxed_const offset));
+      }));
+    }) (E.get_static_memory env) in
 
   let elems = List.map (fun (fi, fp) -> nr {
     index = nr 0l;
@@ -12741,9 +13023,9 @@ and conclude_module env set_serialization_globals start_fi_o =
       motoko = {
         labels = E.get_labs env;
         stable_types = !(env.E.stable_types);
-        compiler = metadata "motoko:compiler" (Lib.Option.get Source_id.release Source_id.id);
+        compiler = metadata "motoko:compiler" (Lib.Option.get Source_id.release Source_id.id)
       };
-      enhanced_orthogonal_persistence = Some (false, "32-bit, layout version 1");
+      enhanced_orthogonal_persistence = None;
       candid = {
         args = !(env.E.args);
         service = !(env.E.service);
@@ -12757,8 +13039,7 @@ and conclude_module env set_serialization_globals start_fi_o =
   | Some rts -> Linking.LinkModule.link emodule "rts" rts
 
 let compile mode rts (prog : Ir.prog) : Wasm_exts.CustomModule.extended_module =
-  assert !Flags.rtti; (* orthogonal persistence requires a fixed layout. *)
-  let env = E.mk_global mode rts IC.trap_with in
+  let env = E.mk_global mode rts IC.trap_with (Lifecycle.end_ ()) in
 
   IC.register_globals env;
   Stack.register_globals env;
@@ -12769,8 +13050,7 @@ let compile mode rts (prog : Ir.prog) : Wasm_exts.CustomModule.extended_module =
 
   (* See Note [Candid subtype checks] *)
   let set_serialization_globals = Serialization.register_delayed_globals env in
-  Serialization.reserve_global_type_descriptor env;
-  
+
   IC.system_imports env;
   RTS.system_imports env;
 
diff --git a/src/codegen/compile.mli b/src/codegen/compile_classical.mli
similarity index 100%
rename from src/codegen/compile.mli
rename to src/codegen/compile_classical.mli
diff --git a/src/codegen/compile_enhanced.ml b/src/codegen/compile_enhanced.ml
new file mode 100644
index 00000000000..080f1acfb7d
--- /dev/null
+++ b/src/codegen/compile_enhanced.ml
@@ -0,0 +1,13273 @@
+(*
+This module is the backend of the Motoko compiler. It takes a program in
+the intermediate representation (ir.ml), and produces a WebAssembly module,
+with Internet Computer extensions (customModule.ml). An important helper module is
+instrList.ml, which provides a more convenient way of assembling WebAssembly
+instruction lists, as it takes care of (1) source locations and (2) labels.
+
+This file is split up in a number of modules, purely for namespacing and
+grouping. Every module has a high-level prose comment explaining the concept;
+this keeps documentation close to the code (a lesson learned from Simon PJ).
+*)
+
+open Ir_def
+open Mo_values
+open Mo_types
+open Mo_config
+
+open Wasm_exts.Ast
+open Wasm_exts.Types
+open Source
+
+(* Re-shadow Source.(@@), to get Stdlib.(@@) *)
+let (@@) = Stdlib.(@@)
+
+module G = InstrList
+let (^^) = G.(^^) (* is this how we import a single operator from a module that we otherwise use qualified? *)
+
+(* WebAssembly pages are 64kb. *)
+let page_size = Int64.of_int (64 * 1024)
+let page_size_bits = 16
+
+(* Our code depends on OCaml int having at least 32 bits *)
+let _ = assert (Sys.int_size >= 32)
+
+(* Scalar Tagging Scheme *)
+
+(* Rationale:
+   Scalar tags are variable length LSBs.
+   A tag (in binary) is either
+   * 10 for Int (leaving 30 bits payload)
+   * 01(0+)0 for unsigned, e.g 0100 for Nat64
+   * 11(0+)0 for signed,   e.g.1100 for Int64
+   Types must be distinguished by tag.
+   LSB must always be 0.
+   Decoding the type of scalar is easy using `ctz` to count the trailing zeros, then
+   switching on the MSB of the tag for sign (if any).
+   We use the *longest* tag that accommodates the required payload bits, to allow room
+   for any future tags that may require more payload bits,
+   e.g. 01(0^14) for Nat8, 11(0^14) for Int8
+   01(0^30) is used for the unit tag (the payload is a trivial zero-length bit string).
+*)
+
+module TaggingScheme = struct
+
+  (*
+     Enable for development only to sanity check value tags and
+     locate unexpected tag errors to compile.ml source lines.
+     Flags.sanity_check will check tags, but not further locate them.
+  *)
+
+  let debug = false (* should never be true in master! *)
+
+  type bit = I | O
+  let _ = (I,O) (* silence warning on unused constructors *)
+
+  type _tag =
+    TBool
+  | TRef
+  | TNum
+  | TNat64 | TInt64
+  | TNat32 | TInt32
+  | TChar
+  | TNat8 | TInt8
+  | TNat16 | TInt16
+  | TUnit
+  | TUnused
+
+  (* Leverage OCaml pattern match compilation to check tagging scheme is injective *)
+  (* OCaml generates stack overflow for _decode:
+  let _decode u64 =
+    match u64 with
+    | ((O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O)) -> TBool (* false *)
+    | ((O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,I)) -> TBool (* true *)
+    | ((_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,_,I,I)) -> TRef  (* 62 bit *)
+    | ((_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,_,I,O)) -> TNum  (* 62 bit *)
+    | ((_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,O,I,O,O)) -> TNat64 (* 60 bit *)
+    | ((_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,I,I,O,O)) -> TInt64
+    | ((_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (O,I,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O)) -> TNat32
+    | ((_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (I,I,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O)) -> TInt32
+    | ((_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (_,_,_,_,_,O,I,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O)) -> TChar
+    | ((_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (O,I,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O)) -> TNat16
+    | ((_,_,_,_,_,_,_,_), (_,_,_,_,_,_,_,_), (I,I,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O)) -> TInt16
+    | ((_,_,_,_,_,_,_,_), (O,I,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O)) -> TNat8
+    | ((_,_,_,_,_,_,_,_), (I,I,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O)) -> TInt8
+    | ((O,I,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O), (O,O,O,O,O,O,O,O)) -> TUnit
+    | _                                                                                                                                                        -> TUnused
+  *)
+
+  let tag_of_typ pty = Type.(
+  if !Flags.rtti then
+    match pty with
+    | Nat
+    | Int ->                                                                        0b10L
+    | Nat64 ->                                                                    0b0100L
+    | Int64 ->                                                                    0b1100L
+    | Nat32 ->                                     0b01000000_00000000_00000000_00000000L
+    | Int32 ->                                     0b11000000_00000000_00000000_00000000L
+    | Char  ->                        0b010_00000000_00000000_00000000_00000000_00000000L
+    | Nat16 ->                   0b01000000_00000000_00000000_00000000_00000000_00000000L
+    | Int16 ->                   0b11000000_00000000_00000000_00000000_00000000_00000000L
+    | Nat8  ->          0b01000000_00000000_00000000_00000000_00000000_00000000_00000000L
+    | Int8  ->          0b11000000_00000000_00000000_00000000_00000000_00000000_00000000L
+    | _  -> assert false
+  else
+    (* no tag *)
+    match pty with
+    | Nat
+    | Int
+    | Nat64
+    | Int64
+    | Nat32
+    | Int32
+    | Char
+    | Nat16
+    | Int16
+    | Nat8
+    | Int8 -> 0L
+    | _  -> assert false)
+
+  let unit_tag = 
+    if !Flags.rtti then
+      (* all tag, no payload (none needed) *)
+      0b01000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000L
+    else
+      (* no tag *)
+      0L
+
+  (* Number of payload bits in compact representation, including any sign *)
+  let ubits_of pty = Type.(
+    if !Flags.rtti then
+      match pty with
+      | Nat | Int     -> 62
+      | Nat64 | Int64 -> 60
+      | Nat32 | Int32 -> 32
+      | Char          -> 21 (* suffices for 21-bit UTF8 codepoints *)
+      | Nat16 | Int16 -> 16
+      | Nat8  | Int8  ->  8
+      | _ -> assert false
+    else
+      match pty with
+      | Nat   | Int   -> 63
+      | Nat64 | Int64 -> 63
+      | Nat32 | Int32 -> 32
+      | Char          -> 21 (* suffices for 21-bit UTF8 codepoints *)
+      | Nat16 | Int16 -> 16
+      | Nat8  | Int8  ->  8
+      | _ -> assert false)
+
+end
+
+(*
+Pointers are skewed (translated) -1 relative to the actual offset.
+See documentation of module BitTagged for more detail.
+*)
+let ptr_skew = -1L
+
+let ptr_unskew = 1L
+
+(* Generating function names for functions parametrized by prim types *)
+let prim_fun_name p stem = Printf.sprintf "%s<%s>" stem (Type.string_of_prim p)
+
+(* Helper functions to produce annotated terms (Wasm.AST) *)
+let nr x = Wasm.Source.{ it = x; at = no_region }
+
+let todo fn se x = Printf.eprintf "%s: %s" fn (Wasm.Sexpr.to_string 80 se); x
+
+exception CodegenError of string
+let fatal fmt = Printf.ksprintf (fun s -> raise (CodegenError s)) fmt
+
+module StaticBytes = struct
+  (* A very simple DSL to describe static memory *)
+
+  type t_ =
+    | I32 of int32
+    | I64 of int64
+    | Seq of t
+    | Bytes of string
+
+  and t = t_ list
+
+  let i64s is = Seq (List.map (fun i -> I64 i) is)
+
+  let rec add : Buffer.t -> t_ -> unit = fun buf -> function
+    | I32 i -> Buffer.add_int32_le buf i
+    | I64 i -> Buffer.add_int64_le buf i
+    | Seq xs -> List.iter (add buf) xs
+    | Bytes b -> Buffer.add_string buf b
+
+  let as_bytes : t -> string = fun xs ->
+    let buf = Buffer.create 32 in
+    List.iter (add buf) xs;
+    Buffer.contents buf
+
+  let as_words static_bytes =
+    let rec convert_to_words binary index = 
+      assert (index <= (Bytes.length binary));
+      if (Bytes.length binary) = index then 
+        []
+      else 
+        let number = Bytes.get_int64_le binary index in
+        let next_index = Int.add index 8 in
+        [number] @ (convert_to_words binary next_index)
+    in
+    convert_to_words (Bytes.of_string (as_bytes static_bytes)) 0
+
+end (* StaticBytes *)
+
+module Const = struct
+
+  (* Literals, as used in constant values. This is a projection of Ir.Lit,
+     combining cases whose details we no longer care about.
+     Should be still precise enough to map to the cases supported by SR.t.
+
+     In other words: It is the smallest type that allows these three functions:
+
+       (* projection of Ir.list. NB: pure, no access to env *)
+       const_lit_of_lit : Ir.lit -> Const.lit (* NB: pure, no access to env *)
+
+       (* creates vanilla representation (e.g. to put in static data structures *)
+       vanilla_lit : E.env -> Const.lit -> i64
+
+       (* creates efficient stack representation *)
+       compile_lit : E.env -> Const.lit -> (SR.t, code)
+
+  *)
+
+  type lit =
+    | Vanilla of int64 (* small words, no static data, already in vanilla format *)
+    | BigInt of Big_int.big_int
+    | Bool of bool
+    | Word64 of Type.prim * int64
+    | Float64 of Numerics.Float.t
+    | Text of string
+    | Blob of string
+    | Null
+
+  let lit_eq l1 l2 = match l1, l2 with
+    | Vanilla i, Vanilla j -> i = j
+    | BigInt i, BigInt j -> Big_int.eq_big_int i j
+    | Word64 (tyi, i), Word64 (tyj, j) -> tyi = tyj && i = j
+    | Float64 i, Float64 j -> i = j
+    | Bool i, Bool j -> i = j
+    | Text s, Text t
+    | Blob s, Blob t -> s = t
+    | Null, Null -> true
+    | _ -> false
+
+  (* Inlineable functions
+
+     The prelude/prim.mo is full of functions simply wrapping a prim, e.g.
+
+        func int64ToNat64(n : Int64) : Nat64 = (prim "num_wrap_Int64_Nat64" : Int64 -> Nat64) n;
+
+     generating a Wasm function for them and calling them is absurdly expensive
+     when the prim is just a simple Wasm instruction. Also, it requires boxing
+     and unboxing arguments and results.
+
+     So we recognize such functions when creating the `const` summary, and use the prim
+     directly when calling such function.
+
+     Can be extended to cover more forms of inlineable functions.
+  *)
+  type fun_rhs =
+    | Complicated (* no inlining possible *)
+    | PrimWrapper of Ir.prim
+
+  (* Constant known values.
+
+     These are values that
+     * are completely known constantly
+     * do not require Wasm code to be executed (e.g. in `start`)
+     * can be used directly (e.g. Call, not CallIndirect)
+     * can be turned into Vanilla heap data on demand
+
+     See ir_passes/const.ml for what precisely we can compile as const now.
+  *)
+
+  type v =
+    | Fun of int32 * (unit -> int32) * fun_rhs (* function pointer calculated upon first use *)
+    | Message of int32 (* anonymous message, only temporary *)
+    | Obj of (string * v) list
+    | Unit
+    | Array of v list (* immutable arrays *)
+    | Tuple of v list (* non-nullary tuples *)
+    | Tag of (string * v)
+    | Opt of v
+    | Lit of lit
+
+  let rec eq v1 v2 = match v1, v2 with
+    | Fun (id1, _, _), Fun (id2, _, _) -> id1 = id2
+    | Message fi1, Message fi2 -> fi1 = fi2
+    | Obj fields1, Obj fields2 ->
+      let equal_fields (name1, field_value1) (name2, field_value2) = (name1 = name2) && (eq field_value1 field_value2) in
+      List.for_all2 equal_fields fields1 fields2
+    | Unit, Unit -> true
+    | Array elements1, Array elements2 ->
+      List.for_all2 eq elements1 elements2
+    | Tuple elements1, Tuple elements2 ->
+      List.for_all2 eq elements1 elements2
+    | Tag (name1, tag_value1), Tag (name2, tag_value2) ->
+      (name1 = name2) && (eq tag_value1 tag_value2)
+    | Opt opt_value1, Opt opt_value2 -> eq opt_value1 opt_value2
+    | Lit l1, Lit l2 -> lit_eq l1 l2
+    | Fun _, _ | Message _, _ | Obj _, _ | Unit, _ 
+    | Array _, _ | Tuple _, _ | Tag _, _ | Opt _, _ 
+    | Lit _, _ -> false
+
+end (* Const *)
+
+module SR = struct
+  (* This goes with the StackRep module, but we need the types earlier *)
+
+  (* Value representation on the stack:
+
+     Compiling an expression means putting its value on the stack. But
+     there are various ways of putting a value onto the stack -- unboxed,
+     tupled etc.
+   *)
+  type t =
+    | Vanilla
+    | UnboxedTuple of int
+    | UnboxedWord64 of Type.prim
+    | UnboxedFloat64
+    | Unreachable
+    | Const of Const.v
+
+  let unit = UnboxedTuple 0
+
+  let bool = Vanilla
+
+  (* Because t contains Const.t, and that contains Const.v, and that contains
+     Const.lit, and that contains Big_int, we cannot just use normal `=`. So we
+     have to write our own equality.
+  *)
+  let eq (t1 : t) (t2 : t) = match t1, t2 with
+    | Const c1, Const c2 -> Const.eq c1 c2
+    | _ -> t1 = t2
+
+  let to_var_type : t -> value_type = function
+    | Vanilla -> I64Type
+    | UnboxedWord64 _ -> I64Type
+    | UnboxedFloat64 -> F64Type
+    | UnboxedTuple n -> fatal "to_var_type: UnboxedTuple"
+    | Const _ -> fatal "to_var_type: Const"
+    | Unreachable -> fatal "to_var_type: Unreachable"
+
+end (* SR *)
+
+(*
+
+** The compiler environment.
+
+Of course, as we go through the code we have to track a few things; these are
+put in the compiler environment, type `E.t`. Some fields are valid globally, some
+only make sense locally, i.e. within a single function (but we still put them
+in one big record, for convenience).
+
+The fields fall into the following categories:
+
+ 1. Static global fields. Never change.
+    Example: whether we are compiling with -no-system-api
+
+ 2. Mutable global fields. Change only monotonically.
+    These are used to register things like functions. This should be monotone
+    in the sense that entries are only added, and that the order should not
+    matter in a significant way. In some instances, the list contains futures
+    so that we can reserve and know the _position_ of the thing before we have
+    to actually fill it in.
+
+ 3. Static local fields. Never change within a function.
+    Example: number of parameters and return values
+
+ 4. Mutable local fields. See above
+    Example: Name and type of locals.
+
+**)
+
+(* Before we can define the environment, we need some auxillary types *)
+
+module E = struct
+
+  (* Utilities, internal to E *)
+  let reg (ref : 'a list ref) (x : 'a) : int32 =
+      let i = Wasm.I32.of_int_u (List.length !ref) in
+      ref := !ref @ [ x ];
+      i
+
+  let reserve_promise (ref : 'a Lib.Promise.t list ref) _s : (int32 * ('a -> unit)) =
+      let p = Lib.Promise.make () in (* For debugging with named promises, use s here *)
+      let i = Wasm.I32.of_int_u (List.length !ref) in
+      ref := !ref @ [ p ];
+      (i, Lib.Promise.fulfill p)
+
+
+  (* The environment type *)
+  module NameEnv = Env.Make(String)
+  module StringEnv = Env.Make(String)
+  module LabSet = Set.Make(String)
+  module FeatureSet = Set.Make(String)
+
+  module FunEnv = Env.Make(Int32)
+  type local_names = (int32 * string) list (* For the debug section: Names of locals *)
+  type func_with_names = func * local_names
+  type lazy_function = (int32, func_with_names) Lib.AllocOnUse.t
+  type type_descriptor = {
+    candid_data_segment : int32;
+    type_offsets_segment : int32;
+    idl_types_segment : int32;
+  }
+  (* Object allocation code. *)
+  type object_allocation = t -> G.t
+  (* Pool of shared objects.
+     Alllocated in the dynamic heap on program initialization/upgrade.
+     Identified by the index position in this list and accessed via the runtime system.
+     Registered as GC root set and replaced on program upgrade. 
+  *)
+  and object_pool = {
+    objects: object_allocation list ref;
+    frozen: bool ref;
+  }
+  and t = {
+    (* Global fields *)
+    (* Static *)
+    mode : Flags.compile_mode;
+    rts : Wasm_exts.CustomModule.extended_module option; (* The rts. Re-used when compiling actors *)
+    trap_with : t -> string -> G.t;
+      (* Trap with message; in the env for dependency injection *)
+
+    (* Per module fields (only valid/used inside a module) *)
+    (* Immutable *)
+
+    (* Mutable *)
+    func_types : func_type list ref;
+    func_imports : import list ref;
+    other_imports : import list ref;
+    exports : export list ref;
+    funcs : (func * string * local_names) Lib.Promise.t list ref;
+    func_ptrs : int32 FunEnv.t ref;
+    end_of_table : int32 ref;
+    globals : (global Lib.Promise.t * string) list ref;
+    global_names : int32 NameEnv.t ref;
+    named_imports : int32 NameEnv.t ref;
+    built_in_funcs : lazy_function NameEnv.t ref;
+    static_strings : int32 StringEnv.t ref;
+    data_segments : string list ref; (* Passive data segments *)
+    object_pool : object_pool;
+      
+    (* Types accumulated in global typtbl (for candid subtype checks)
+       See Note [Candid subtype checks]
+    *)
+    typtbl_typs : Type.typ list ref;
+
+    (* Metadata *)
+    args : (bool * string) option ref;
+    service : (bool * string) option ref;
+    stable_types : (bool * string) option ref;
+    labs : LabSet.t ref; (* Used labels (fields and variants),
+                            collected for Motoko custom section 0 *)
+
+    (* Local fields (only valid/used inside a function) *)
+    (* Static *)
+    n_param : int32; (* Number of parameters (to calculate indices of locals) *)
+    return_arity : int; (* Number of return values (for type of Return) *)
+
+    (* Mutable *)
+    locals : value_type list ref; (* Types of locals *)
+    local_names : (int32 * string) list ref; (* Names of locals *)
+
+    features : FeatureSet.t ref; (* Wasm features using wasmtime naming *)
+
+    (* requires stable memory (and emulation on wasm targets) *)
+    requires_stable_memory : bool ref;
+
+    (* Type descriptor of current program version, created on `conclude_module`. *)
+    global_type_descriptor : type_descriptor option ref;
+
+    (* Counter for deriving a unique id per constant function. *)
+    constant_functions : int32 ref;
+  }
+
+  (* Compile-time-known value, either a plain vanilla constant or a shared object. *)
+  type shared_value = 
+  | Vanilla of int64
+  | SharedObject of int64 (* index in object pool *)
+
+  (* The initial global environment *)
+  let mk_global mode rts trap_with : t = {
+    mode;
+    rts;
+    trap_with;
+    func_types = ref [];
+    func_imports = ref [];
+    other_imports = ref [];
+    exports = ref [];
+    funcs = ref [];
+    func_ptrs = ref FunEnv.empty;
+    end_of_table = ref 0l;
+    globals = ref [];
+    global_names = ref NameEnv.empty;
+    named_imports = ref NameEnv.empty;
+    built_in_funcs = ref NameEnv.empty;
+    static_strings = ref StringEnv.empty;
+    data_segments = ref [];
+    object_pool = { objects = ref []; frozen = ref false };
+    typtbl_typs = ref [];
+    (* Metadata *)
+    args = ref None;
+    service = ref None;
+    stable_types = ref None;
+    labs = ref LabSet.empty;
+    (* Actually unused outside mk_fun_env: *)
+    n_param = 0l;
+    return_arity = 0;
+    locals = ref [];
+    local_names = ref [];
+    features = ref FeatureSet.empty;
+    requires_stable_memory = ref false;
+    global_type_descriptor = ref None;
+    constant_functions = ref 0l;
+  }
+
+  (* This wraps Mo_types.Hash.hash to also record which labels we have seen,
+      so that that data can be put in a custom section, useful for debugging.
+      Thus Mo_types.Hash.hash should not be called directly!
+   *)
+  let hash (env : t) lab =
+    env.labs := LabSet.add lab (!(env.labs));
+    Wasm.I64_convert.extend_i32_u (Mo_types.Hash.hash lab)
+
+  let get_labs env = LabSet.elements (!(env.labs))
+
+  let mk_fun_env env n_param return_arity =
+    { env with
+      n_param;
+      return_arity;
+      locals = ref [];
+      local_names = ref [];
+    }
+
+  (* We avoid accessing the fields of t directly from outside of E, so here are a
+     bunch of accessors. *)
+
+  let mode (env : t) = env.mode
+
+  let add_anon_local (env : t) ty =
+    let i = reg env.locals ty in
+    Wasm.I32.add env.n_param i
+
+  let add_local_name (env : t) li name =
+    let _ = reg env.local_names (li, name) in ()
+
+  let get_locals (env : t) = !(env.locals)
+  let get_local_names (env : t) : (int32 * string) list = !(env.local_names)
+
+  let _add_other_import (env : t) m =
+    ignore (reg env.other_imports m)
+
+  let add_export (env : t) e =
+    ignore (reg env.exports e)
+
+  let add_global (env : t) name g =
+    assert (not (NameEnv.mem name !(env.global_names)));
+    let gi = reg env.globals (g, name) in
+    env.global_names := NameEnv.add name gi !(env.global_names)
+
+  let add_global64_delayed (env : t) name mut : int64 -> unit =
+    let p = Lib.Promise.make () in
+    add_global env name p;
+    (fun init ->
+      Lib.Promise.fulfill p (nr {
+        gtype = GlobalType (I64Type, mut);
+        value = nr (G.to_instr_list (G.i (Const (nr (Wasm_exts.Values.I64 init)))))
+      })
+    )
+  let add_global64 (env : t) name mut init =
+    add_global64_delayed env name mut init
+
+  let get_global (env : t) name : int32 =
+    match NameEnv.find_opt name !(env.global_names) with
+    | Some gi -> gi
+    | None -> raise (Invalid_argument (Printf.sprintf "No global named %s declared" name))
+
+  let get_global64_lazy (env : t) name mut init : int32 =
+    match NameEnv.find_opt name !(env.global_names) with
+    | Some gi -> gi
+    | None -> add_global64 env name mut init; get_global env name
+
+  let export_global env name =
+    add_export env (nr {
+      name = Lib.Utf8.decode name;
+      edesc = nr (GlobalExport (nr (get_global env name)))
+    })
+
+  let get_globals (env : t) = List.map (fun (g,n) -> Lib.Promise.value g) !(env.globals)
+
+  let reserve_fun (env : t) name =
+    let (j, fill) = reserve_promise env.funcs name in
+    let n = Int32.of_int (List.length !(env.func_imports)) in
+    let fi = Int32.add j n in
+    let fill_ (f, local_names) = fill (f, name, local_names) in
+    (fi, fill_)
+
+  let add_fun (env : t) name (f, local_names) =
+    let (fi, fill) = reserve_fun env name in
+    fill (f, local_names);
+    fi
+
+  let make_lazy_function env name : lazy_function =
+    Lib.AllocOnUse.make (fun () -> reserve_fun env name)
+
+  let get_constant_function_id (env : t) : int32 =
+    let id = !(env.constant_functions) in
+    env.constant_functions := (Int32.add id 1l);
+    id
+
+  let lookup_built_in (env : t) name : lazy_function =
+    match NameEnv.find_opt name !(env.built_in_funcs) with
+    | None ->
+      let lf = make_lazy_function env name in
+      env.built_in_funcs := NameEnv.add name lf !(env.built_in_funcs);
+      lf
+    | Some lf -> lf
+
+  let built_in (env : t) name : int32 =
+    Lib.AllocOnUse.use (lookup_built_in env name)
+
+  let define_built_in (env : t) name mk_fun : unit =
+    Lib.AllocOnUse.def  (lookup_built_in env name) mk_fun
+
+  let get_return_arity (env : t) = env.return_arity
+
+  let get_func_imports (env : t) = !(env.func_imports)
+  let get_other_imports (env : t) = !(env.other_imports)
+  let get_exports (env : t) = !(env.exports)
+  let get_funcs (env : t) = List.map Lib.Promise.value !(env.funcs)
+
+  let func_type (env : t) ty =
+    let rec go i = function
+      | [] -> env.func_types := !(env.func_types) @ [ ty ]; Int32.of_int i
+      | ty'::tys when ty = ty' -> Int32.of_int i
+      | _ :: tys -> go (i+1) tys
+       in
+    go 0 !(env.func_types)
+
+  let get_types (env : t) = !(env.func_types)
+
+  let add_func_import (env : t) modname funcname arg_tys ret_tys =
+    if !(env.funcs) <> [] then
+      raise (CodegenError "Add all imports before all functions!");
+
+    let i = {
+      module_name = Lib.Utf8.decode modname;
+      item_name = Lib.Utf8.decode funcname;
+      idesc = nr (FuncImport (nr (func_type env (FuncType (arg_tys, ret_tys)))))
+    } in
+    let fi = reg env.func_imports (nr i) in
+    let name = modname ^ "." ^ funcname in
+    assert (not (NameEnv.mem name !(env.named_imports)));
+    env.named_imports := NameEnv.add name fi !(env.named_imports)
+
+  let call_import (env : t) modname funcname =
+    let name = modname ^ "." ^ funcname in
+    match NameEnv.find_opt name !(env.named_imports) with
+      | Some fi -> G.i (Call (nr fi))
+      | _ ->
+        raise (Invalid_argument (Printf.sprintf "Function import not declared: %s\n" name))
+
+  let reuse_import (env : t) modname funcname =
+    let name = modname ^ "." ^ funcname in
+    match NameEnv.find_opt name !(env.named_imports) with
+      | Some fi -> fi
+      | _ ->
+        raise (Invalid_argument (Printf.sprintf "Function import not declared: %s\n" name))
+
+  let get_rts (env : t) = env.rts
+
+  let as_block_type env : stack_type -> block_type = function
+    | [] -> ValBlockType None
+    | [t] -> ValBlockType (Some t)
+    | ts -> VarBlockType (nr (func_type env (FuncType ([], ts))))
+
+
+  let prepare_branch_condition =
+    G.i (Convert (Wasm_exts.Values.I32 I32Op.WrapI64))
+  let if0 then_block else_block =
+    prepare_branch_condition ^^
+    G.if0 then_block else_block
+  let if1 return_type then_block else_block =
+    prepare_branch_condition ^^
+    G.if1 return_type then_block else_block
+
+  let if_ env tys thn els = prepare_branch_condition ^^ G.if_ (as_block_type env tys) thn els
+  let block_ env tys bdy = G.block_ (as_block_type env tys) bdy
+
+
+  let trap_with env msg = env.trap_with env msg
+  let then_trap_with env msg = if0 (trap_with env msg) G.nop
+  let else_trap_with env msg = if0 G.nop (trap_with env msg)
+
+  let add_data_segment (env : t) data : int32 =
+    let index = List.length !(env.data_segments) in
+    env.data_segments := !(env.data_segments) @ [ data ];
+    Int32.of_int index
+
+  let add_fun_ptr (env : t) fi : int32 =
+    match FunEnv.find_opt fi !(env.func_ptrs) with
+    | Some fp -> fp
+    | None ->
+      let fp = !(env.end_of_table) in
+      env.func_ptrs := FunEnv.add fi fp !(env.func_ptrs);
+      env.end_of_table := Int32.add !(env.end_of_table) 1l;
+      fp
+
+  let get_elems env =
+    FunEnv.bindings !(env.func_ptrs)
+
+  let get_end_of_table env : int32 =
+    !(env.end_of_table)
+
+  let add_static (env : t) (data : StaticBytes.t) : int32 =
+    let b = StaticBytes.as_bytes data in
+    match StringEnv.find_opt b !(env.static_strings)  with
+    | Some segment_index -> segment_index
+    | None ->
+      let segment_index = add_data_segment env b  in
+      env.static_strings := StringEnv.add b segment_index !(env.static_strings);
+      segment_index
+
+  let replace_data_segment (env : t) (segment_index : int32) (data : StaticBytes.t) : int64 =
+    let new_value = StaticBytes.as_bytes data in
+    let segment_index = Int32.to_int segment_index in
+    assert (segment_index < List.length !(env.data_segments));
+    env.data_segments := List.mapi (fun index old_value -> 
+      if index = segment_index then
+        (assert (old_value = "");
+        new_value)
+      else 
+        old_value
+      ) !(env.data_segments);
+    Int64.of_int (String.length new_value)
+
+  let get_data_segments (env : t) =
+    !(env.data_segments)
+
+  let object_pool_add (env : t) (allocation : t -> G.t) : int64 =
+    if !(env.object_pool.frozen) then raise (Invalid_argument "Object pool frozen");
+    let index = List.length !(env.object_pool.objects) in
+    env.object_pool.objects := !(env.object_pool.objects) @ [ allocation ];
+    Int64.of_int index
+
+  let object_pool_size (env : t) : int =
+    List.length !(env.object_pool.objects)
+
+  let iterate_object_pool (env : t) f =
+    G.concat_mapi f !(env.object_pool.objects)
+
+  let collect_garbage env force =
+    let name = "incremental_gc" in
+    let gc_fn = if force || !Flags.force_gc then name else "schedule_" ^ name in
+    call_import env "rts" gc_fn
+
+  (* See Note [Candid subtype checks] *)
+  (* NB: we don't bother detecting duplicate registrations here because the code sharing machinery
+     ensures that `add_typtbl_typ t` is called at most once for any `t` with a distinct type hash *)
+  let add_typtbl_typ (env : t) ty : Int32.t =
+    reg env.typtbl_typs ty
+
+  let get_typtbl_typs (env : t) : Type.typ list =
+    !(env.typtbl_typs)
+
+  let add_feature (env : t) f =
+    env.features := FeatureSet.add f (!(env.features))
+
+  let get_features (env : t) = FeatureSet.elements (!(env.features))
+
+  let require_stable_memory (env : t)  =
+    if not !(env.requires_stable_memory)
+    then
+      (env.requires_stable_memory := true;
+       match mode env with
+       | Flags.ICMode | Flags.RefMode ->
+          ()
+       | Flags.WASIMode | Flags.WasmMode ->
+          add_feature env "bulk-memory";
+          add_feature env "multi-memory")
+
+  let requires_stable_memory (env : t) =
+    !(env.requires_stable_memory)
+
+  let get_memories (env : t) initial_memory_pages =
+    nr {mtype = MemoryType ({min = initial_memory_pages; max = None}, I64IndexType)}
+    ::
+    match mode env with
+    | Flags.WASIMode | Flags.WasmMode when !(env.requires_stable_memory) ->
+      [ nr {mtype = MemoryType ({min = Int64.zero; max = None}, I64IndexType)} ]
+    | _ -> []
+end
+
+
+(* General code generation functions:
+   Rule of thumb: Here goes stuff that independent of the Motoko AST.
+*)
+
+(* Function called compile_* return a list of instructions (and maybe other stuff) *)
+
+
+let compile_comparison rel = 
+  G.i (Compare (Wasm_exts.Values.I64 rel)) ^^
+  G.i (Convert (Wasm_exts.Values.I64 I64Op.ExtendUI32))
+let compile_comparison_32 rel = 
+  G.i (Compare (Wasm_exts.Values.I32 rel)) ^^
+  G.i (Convert (Wasm_exts.Values.I64 I64Op.ExtendUI32))
+let compile_test op =
+  G.i (Test (Wasm_exts.Values.I64 op)) ^^
+  G.i (Convert (Wasm_exts.Values.I64 I64Op.ExtendUI32))
+let compile_comparison_f64 rel = 
+  G.i (Compare (Wasm_exts.Values.F64 rel)) ^^
+  G.i (Convert (Wasm_exts.Values.I64 I64Op.ExtendUI32))
+
+let compile_unboxed_const i = G.i (Const (nr (Wasm_exts.Values.I64 i)))
+let compile_const_32 i = G.i (Const (nr (Wasm_exts.Values.I32 i)))
+let compile_unboxed_zero = compile_unboxed_const 0L
+let compile_unboxed_one = compile_unboxed_const 1L
+
+(* Some common arithmetic, used for pointer and index arithmetic *)
+let compile_op_const op i =
+    compile_unboxed_const i ^^
+    G.i (Binary (Wasm_exts.Values.I64 op))
+let compile_add_const = compile_op_const I64Op.Add
+let compile_sub_const = compile_op_const I64Op.Sub
+let compile_mul_const = compile_op_const I64Op.Mul
+let compile_divU_const = compile_op_const I64Op.DivU
+let compile_shrU_const = compile_op_const I64Op.ShrU
+let compile_shrS_const = compile_op_const I64Op.ShrS
+let compile_shl_const = compile_op_const I64Op.Shl
+let compile_rotl_const = compile_op_const I64Op.Rotl
+let compile_rotr_const = compile_op_const I64Op.Rotr
+let compile_bitand_const = compile_op_const I64Op.And
+let compile_bitor_const = function
+  | 0L -> G.nop | n -> compile_op_const I64Op.Or n
+let compile_xor_const = function
+  | 0L -> G.nop | n -> compile_op_const I64Op.Xor n
+let compile_rel_const rel i =
+  compile_unboxed_const i ^^
+  compile_comparison rel
+let compile_eq_const = function
+  | 0L -> compile_test I64Op.Eqz
+  | i -> compile_rel_const I64Op.Eq i
+
+let compile_op32_const op i =
+    compile_const_32 i ^^
+    G.i (Binary (Wasm_exts.Values.I32 op))
+let compile_add32_const = compile_op32_const I32Op.Add
+let _compile_sub32_const = compile_op32_const I32Op.Sub
+let _compile_mul32_const = compile_op32_const I32Op.Mul
+let _compile_divU32_const = compile_op32_const I32Op.DivU
+let _compile_shrU32_const = function
+  | 0l -> G.nop | n -> compile_op32_const I32Op.ShrU n
+let _compile_shrS32_const = function
+  | 0l -> G.nop | n -> compile_op32_const I32Op.ShrS n
+let _compile_shl32_const = function
+  | 0l -> G.nop | n -> compile_op32_const I32Op.Shl n
+let compile_eq32_const i =
+  compile_const_32 i ^^
+  compile_comparison_32 I32Op.Eq
+
+(* Analogous to Lib.Uint32.compare *)
+let compare_uint64 i1 i2 =
+  if i1 < 0L && i2 >= 0L then 1
+  else if i1 >= 0L && i2 < 0L then -1
+  else Int64.compare i1 i2
+
+(* A common variant of todo *)
+
+let todo_trap env fn se = todo fn se (E.trap_with env ("TODO: " ^ fn))
+let _todo_trap_SR env fn se = todo fn se (SR.Unreachable, E.trap_with env ("TODO: " ^ fn))
+
+(* Locals *)
+
+let new_local_ env t name =
+  let i = E.add_anon_local env t in
+  E.add_local_name env i name;
+  ( G.i (LocalSet (nr i))
+  , G.i (LocalGet (nr i))
+  , i
+  )
+
+let new_local env name =
+  let (set_i, get_i, _) = new_local_ env I64Type name
+  in (set_i, get_i)
+
+let new_local32 env name =
+  let (set_i, get_i, _) = new_local_ env I32Type name
+  in (set_i, get_i)
+
+(* Some common code macros *)
+
+(* Iterates while cond is true. *)
+let compile_while env cond body =
+    G.loop0 (
+      cond ^^ E.if0 (body ^^ G.i (Br (nr 1l))) G.nop
+    )
+
+(* Expects a number n on the stack. Iterates from m to below that number. *)
+let from_m_to_n env m mk_body =
+    let (set_n, get_n) = new_local env "n" in
+    let (set_i, get_i) = new_local env "i" in
+    set_n ^^
+    compile_unboxed_const m ^^
+    set_i ^^
+
+    compile_while env
+      ( get_i ^^
+        get_n ^^
+        compile_comparison I64Op.LtU
+      ) (
+        mk_body get_i ^^
+
+        get_i ^^
+        compile_add_const 1L ^^
+        set_i
+      )
+
+(* Expects a number on the stack. Iterates from zero to below that number. *)
+let from_0_to_n env mk_body = from_m_to_n env 0L mk_body
+
+(* Pointer reference and dereference  *)
+
+let load_unskewed_ptr : G.t =
+  G.i (Load {ty = I64Type; align = 3; offset = 0L; sz = None})
+
+let store_unskewed_ptr : G.t =
+  G.i (Store {ty = I64Type; align = 3; offset = 0L; sz = None})
+  
+let load_ptr : G.t =
+  G.i (Load {ty = I64Type; align = 3; offset = ptr_unskew; sz = None})
+
+let store_ptr : G.t =
+  G.i (Store {ty = I64Type; align = 3; offset = ptr_unskew; sz = None})
+
+let narrow_to_32 env get_value =
+  get_value ^^
+  compile_unboxed_const 0xffff_ffffL ^^
+  compile_comparison I64Op.LeU ^^
+  E.else_trap_with env "cannot narrow to 32 bit" ^^ (* Note: If narrow fails during print, the trap print leads to an infinite recursion and a stack overflow *)
+  get_value ^^
+  G.i (Convert (Wasm_exts.Values.I32 I32Op.WrapI64))
+
+module FakeMultiVal = struct
+  (* For some use-cases (e.g. processing the compiler output with analysis
+     tools) it is useful to avoid the multi-value extension.
+
+     This module provides mostly transparent wrappers that put multiple values
+     in statically allocated globals and pull them off again.
+
+     So far only does I64Type (but that could be changed).
+
+     If the multi_value flag is on, these do not do anything.
+  *)
+  let ty tys =
+    if !Flags.multi_value || List.length tys <= 1
+    then tys
+    else []
+
+  let global env i =
+    E.get_global64_lazy env (Printf.sprintf "multi_val_%d" i) Mutable 0L
+
+  let store env tys =
+    if !Flags.multi_value || List.length tys <= 1 then G.nop else
+    G.concat_mapi (fun i ty ->
+      assert(ty = I64Type);
+      G.i (GlobalSet (nr (global env i)))
+    ) tys
+
+  let load env tys =
+    if !Flags.multi_value || List.length tys <= 1 then G.nop else
+    let n = List.length tys - 1 in
+    G.concat_mapi (fun i ty ->
+      assert(ty = I64Type);
+      G.i (GlobalGet (nr (global env (n - i))))
+    ) tys
+
+  (* A drop-in replacement for E.if_ *)
+  let if_ env bt thn els =
+    E.if_ env (ty bt) (thn ^^ store env bt) (els ^^ store env bt) ^^
+    load env bt
+
+  (* A block that can be exited from *)
+  let block_ env bt body =
+    E.block_ env (ty bt) (G.with_current_depth (fun depth ->
+      body (store env bt ^^ G.branch_to_ depth)
+    )) ^^
+    load env bt
+
+end (* FakeMultiVal *)
+
+module Func = struct
+  (* This module contains basic bookkeeping functionality to define functions,
+     in particular creating the environment, and finally adding it to the environment.
+  *)
+
+
+  let of_body env params retty mk_body =
+    let env1 = E.mk_fun_env env (Int32.of_int (List.length params)) (List.length retty) in
+    List.iteri (fun i (n,_t) -> E.add_local_name env1 (Int32.of_int i) n) params;
+    let ty = FuncType (List.map snd params, FakeMultiVal.ty retty) in
+    let body = G.to_instr_list (
+      mk_body env1 ^^ FakeMultiVal.store env1 retty
+    ) in
+    (nr { ftype = nr (E.func_type env ty);
+          locals = E.get_locals env1;
+          body }
+    , E.get_local_names env1)
+
+  let define_built_in env name params retty mk_body =
+    E.define_built_in env name (lazy (of_body env params retty mk_body))
+
+  type sharing =
+    Always (* i.e. never inline *)
+  | Never  (* i.e. always inline *)
+
+  (* (Almost) transparently lift code into a function and call this function,
+     unless sharing = Never and not (!Flags.share_code) in which case the code
+     is inlined.
+     NB: inlined code must not be recursive nor `return`.
+  *)
+  (* Also add a hack to support multiple return values *)
+  let share_code sharing env name params retty mk_body =
+    if sharing = Always || !Flags.share_code
+    then
+      let getters =
+        List.mapi
+          (fun i (n, t) -> (G.i (LocalGet (nr (Int32.of_int i)))))
+          params
+      in
+      define_built_in env name params retty (fun env -> mk_body env getters);
+      G.i (Call (nr (E.built_in env name))) ^^
+      FakeMultiVal.load env retty
+    else begin
+      assert (sharing = Never);
+      let locals =
+        List.map
+           (fun (n, t) -> new_local_ env t n)
+           params
+      in
+      let set_locals = List.fold_right (fun (set, get, _) is-> is ^^ set) locals G.nop in
+      let getters = List.map (fun (set, get, _) -> get) locals in
+      set_locals ^^
+      mk_body env getters ^^ FakeMultiVal.store env retty ^^
+      FakeMultiVal.load env retty
+   end
+
+  (* Shorthands for various arities *)
+  let [@warning "-8"] share_code0 sharing env name retty mk_body =
+    share_code sharing env name [] retty (fun env [] -> mk_body env)
+  let [@warning "-8"] share_code1 sharing env name p1 retty mk_body =
+    share_code sharing env name [p1] retty (fun env [g1] -> mk_body env
+        g1
+    )
+  let [@warning "-8"] share_code2 sharing env name (p1,p2) retty mk_body =
+    share_code sharing env name [p1; p2] retty (fun env [g1; g2] -> mk_body env
+      g1
+      g2
+    )
+  let [@warning "-8"] share_code3 sharing env name (p1, p2, p3) retty mk_body =
+    share_code sharing env name [p1; p2; p3] retty (fun env [g1; g2; g3] -> mk_body env
+      g1
+      g2
+      g3
+    )
+  let [@warning "-8"] _share_code4 sharing env name (p1, p2, p3, p4) retty mk_body =
+    share_code sharing env name [p1; p2; p3; p4] retty (fun env [g1; g2; g3; g4]-> mk_body env
+      g1
+      g2
+      g3
+      g4
+    )
+  let [@warning "-8"] _share_code6 sharing env name (p1, p2, p3, p4, p5, p6) retty mk_body =
+    share_code sharing env name [p1; p2; p3; p4; p5; p6] retty (fun env [g1; g2; g3; g4; g5; g6] -> mk_body env
+      g1
+      g2
+      g3
+      g4
+      g5
+      g6
+    )
+  let [@warning "-8"] _share_code7 sharing env name (p1, p2, p3, p4, p5, p6, p7) retty mk_body =
+    share_code sharing env name [p1; p2; p3; p4; p5; p6; p7] retty (fun env [g1; g2; g3; g4; g5; g6; g7] -> mk_body env
+      g1
+      g2
+      g3
+      g4
+      g5
+      g6
+      g7
+    )
+
+  let [@warning "-8"] _share_code9 sharing env name (p1, p2, p3, p4, p5, p6, p7, p8, p9) retty mk_body =
+    share_code sharing env name [p1; p2; p3; p4; p5; p6; p7; p8; p9] retty (fun env [g1; g2; g3; g4; g5; g6; g7; g8; g9] -> mk_body env
+      g1
+      g2
+      g3
+      g4
+      g5
+      g6
+      g7
+      g8
+      g9
+    )
+
+
+end (* Func *)
+
+module RTS = struct
+  (* The connection to the C and Rust parts of the RTS *)
+  let system_imports env =
+    E.add_func_import env "rts" "initialize_incremental_gc" [] [];
+    E.add_func_import env "rts" "schedule_incremental_gc" [] [];
+    E.add_func_import env "rts" "incremental_gc" [] [];
+    E.add_func_import env "rts" "write_with_barrier" [I64Type; I64Type] [];
+    E.add_func_import env "rts" "allocation_barrier" [I64Type] [I64Type];
+    E.add_func_import env "rts" "running_gc" [] [I32Type];
+    E.add_func_import env "rts" "register_stable_type" [I64Type; I64Type] [];
+    E.add_func_import env "rts" "load_stable_actor" [] [I64Type];
+    E.add_func_import env "rts" "save_stable_actor" [I64Type] [];
+    E.add_func_import env "rts" "free_stable_actor" [] [];
+    E.add_func_import env "rts" "contains_field" [I64Type; I64Type] [I32Type];
+    E.add_func_import env "rts" "initialize_static_variables" [I64Type] [];
+    E.add_func_import env "rts" "get_static_variable" [I64Type] [I64Type];
+    E.add_func_import env "rts" "set_static_variable" [I64Type; I64Type] [];
+    E.add_func_import env "rts" "set_upgrade_instructions" [I64Type] [];
+    E.add_func_import env "rts" "get_upgrade_instructions" [] [I64Type];
+    E.add_func_import env "rts" "memcpy" [I64Type; I64Type; I64Type] [I64Type]; (* standard libc memcpy *)
+    E.add_func_import env "rts" "memcmp" [I64Type; I64Type; I64Type] [I32Type];
+    E.add_func_import env "rts" "version" [] [I64Type];
+    E.add_func_import env "rts" "parse_idl_header" [I32Type; I64Type; I64Type; I64Type; I64Type] [];
+    E.add_func_import env "rts" "idl_alloc_typtbl" [I64Type; I64Type; I64Type; I64Type; I64Type] [];
+    E.add_func_import env "rts" "idl_sub_buf_words" [I64Type; I64Type] [I64Type];
+    E.add_func_import env "rts" "idl_sub_buf_init" [I64Type; I64Type; I64Type] [];
+    E.add_func_import env "rts" "idl_sub"
+      [I64Type; I64Type; I64Type; I64Type; I64Type; I64Type; I64Type; I32Type; I32Type] [I32Type];
+    E.add_func_import env "rts" "leb128_decode" [I64Type] [I64Type];
+    E.add_func_import env "rts" "sleb128_decode" [I64Type] [I64Type];
+    E.add_func_import env "rts" "bigint_to_word32_wrap" [I64Type] [I32Type];
+    E.add_func_import env "rts" "bigint_of_word64" [I64Type] [I64Type];
+    E.add_func_import env "rts" "bigint_of_int64" [I64Type] [I64Type];
+    E.add_func_import env "rts" "bigint_of_float64" [F64Type] [I64Type];
+    E.add_func_import env "rts" "bigint_to_float64" [I64Type] [F64Type];
+    E.add_func_import env "rts" "bigint_to_word64_wrap" [I64Type] [I64Type];
+    E.add_func_import env "rts" "bigint_to_word64_trap" [I64Type] [I64Type];
+    E.add_func_import env "rts" "bigint_to_word64_trap_with" [I64Type; I64Type] [I64Type];
+    E.add_func_import env "rts" "bigint_eq" [I64Type; I64Type] [I32Type];
+    E.add_func_import env "rts" "bigint_isneg" [I64Type] [I32Type];
+    E.add_func_import env "rts" "bigint_count_bits" [I64Type] [I64Type];
+    E.add_func_import env "rts" "bigint_2complement_bits" [I64Type] [I64Type];
+    E.add_func_import env "rts" "bigint_lt" [I64Type; I64Type] [I32Type];
+    E.add_func_import env "rts" "bigint_gt" [I64Type; I64Type] [I32Type];
+    E.add_func_import env "rts" "bigint_le" [I64Type; I64Type] [I32Type];
+    E.add_func_import env "rts" "bigint_ge" [I64Type; I64Type] [I32Type];
+    E.add_func_import env "rts" "bigint_add" [I64Type; I64Type] [I64Type];
+    E.add_func_import env "rts" "bigint_sub" [I64Type; I64Type] [I64Type];
+    E.add_func_import env "rts" "bigint_mul" [I64Type; I64Type] [I64Type];
+    E.add_func_import env "rts" "bigint_rem" [I64Type; I64Type] [I64Type];
+    E.add_func_import env "rts" "bigint_div" [I64Type; I64Type] [I64Type];
+    E.add_func_import env "rts" "bigint_pow" [I64Type; I64Type] [I64Type];
+    E.add_func_import env "rts" "bigint_neg" [I64Type] [I64Type];
+    E.add_func_import env "rts" "bigint_lsh" [I64Type; I64Type] [I64Type];
+    E.add_func_import env "rts" "bigint_rsh" [I64Type; I64Type] [I64Type];
+    E.add_func_import env "rts" "bigint_abs" [I64Type] [I64Type];
+    E.add_func_import env "rts" "bigint_leb128_size" [I64Type] [I64Type];
+    E.add_func_import env "rts" "bigint_leb128_encode" [I64Type; I64Type] [];
+    E.add_func_import env "rts" "bigint_leb128_decode" [I64Type] [I64Type];
+    E.add_func_import env "rts" "bigint_leb128_decode_word64" [I64Type; I64Type; I64Type] [I64Type];
+    E.add_func_import env "rts" "bigint_sleb128_size" [I64Type] [I64Type];
+    E.add_func_import env "rts" "bigint_sleb128_encode" [I64Type; I64Type] [];
+    E.add_func_import env "rts" "bigint_sleb128_decode" [I64Type] [I64Type];
+    E.add_func_import env "rts" "bigint_sleb128_decode_word64" [I64Type; I64Type; I64Type] [I64Type];
+    E.add_func_import env "rts" "leb128_encode" [I64Type; I64Type] [];
+    E.add_func_import env "rts" "sleb128_encode" [I64Type; I64Type] [];
+    E.add_func_import env "rts" "utf8_valid" [I64Type; I64Type] [I32Type];
+    E.add_func_import env "rts" "utf8_validate" [I64Type; I64Type] [];
+    E.add_func_import env "rts" "skip_leb128" [I64Type] [];
+    E.add_func_import env "rts" "skip_any" [I64Type; I64Type; I32Type; I32Type] [];
+    E.add_func_import env "rts" "find_field" [I64Type; I64Type; I64Type; I32Type; I64Type] [I32Type];
+    E.add_func_import env "rts" "skip_fields" [I64Type; I64Type; I64Type; I64Type] [];
+    E.add_func_import env "rts" "remember_continuation" [I64Type] [I64Type];
+    E.add_func_import env "rts" "recall_continuation" [I64Type] [I64Type];
+    E.add_func_import env "rts" "peek_future_continuation" [I64Type] [I64Type];
+    E.add_func_import env "rts" "continuation_count" [] [I64Type];
+    E.add_func_import env "rts" "continuation_table_size" [] [I64Type];
+    E.add_func_import env "rts" "blob_of_text" [I64Type] [I64Type];
+    E.add_func_import env "rts" "text_compare" [I64Type; I64Type] [I64Type];
+    E.add_func_import env "rts" "text_concat" [I64Type; I64Type] [I64Type];
+    E.add_func_import env "rts" "text_iter_done" [I64Type] [I64Type];
+    E.add_func_import env "rts" "text_iter" [I64Type] [I64Type];
+    E.add_func_import env "rts" "text_iter_next" [I64Type] [I32Type];
+    E.add_func_import env "rts" "text_len" [I64Type] [I64Type];
+    E.add_func_import env "rts" "text_of_ptr_size" [I64Type; I64Type] [I64Type];
+    E.add_func_import env "rts" "text_singleton" [I32Type] [I64Type];
+    E.add_func_import env "rts" "text_size" [I64Type] [I64Type];
+    E.add_func_import env "rts" "text_to_buf" [I64Type; I64Type] [];
+    E.add_func_import env "rts" "text_lowercase" [I64Type] [I64Type];
+    E.add_func_import env "rts" "text_uppercase" [I64Type] [I64Type];
+    E.add_func_import env "rts" "region_init" [I64Type] [];
+    E.add_func_import env "rts" "alloc_region" [I64Type; I64Type; I64Type] [I64Type];
+    E.add_func_import env "rts" "init_region" [I64Type; I64Type; I64Type; I64Type] [];
+    E.add_func_import env "rts" "region_new" [] [I64Type];
+    E.add_func_import env "rts" "region_id" [I64Type] [I64Type];
+    E.add_func_import env "rts" "region_page_count" [I64Type] [I64Type];
+    E.add_func_import env "rts" "region_vec_pages" [I64Type] [I64Type];
+    E.add_func_import env "rts" "region_size" [I64Type] [I64Type];
+    E.add_func_import env "rts" "region_grow" [I64Type; I64Type] [I64Type];
+    E.add_func_import env "rts" "region_load_blob" [I64Type; I64Type; I64Type] [I64Type];
+    E.add_func_import env "rts" "region_store_blob" [I64Type; I64Type; I64Type] [];
+    E.add_func_import env "rts" "region_load_word8" [I64Type; I64Type] [I32Type];
+    E.add_func_import env "rts" "region_store_word8" [I64Type; I64Type; I32Type] [];
+    E.add_func_import env "rts" "region_load_word16" [I64Type; I64Type] [I32Type];
+    E.add_func_import env "rts" "region_store_word16" [I64Type; I64Type; I32Type] [];
+    E.add_func_import env "rts" "region_load_word32" [I64Type; I64Type] [I32Type];
+    E.add_func_import env "rts" "region_store_word32" [I64Type; I64Type; I32Type] [];
+    E.add_func_import env "rts" "region_load_word64" [I64Type; I64Type] [I64Type];
+    E.add_func_import env "rts" "region_store_word64" [I64Type; I64Type; I64Type] [];
+    E.add_func_import env "rts" "region_load_float64" [I64Type; I64Type] [F64Type];
+    E.add_func_import env "rts" "region_store_float64" [I64Type; I64Type; F64Type] [];
+    E.add_func_import env "rts" "region0_get" [] [I64Type];
+    E.add_func_import env "rts" "blob_of_principal" [I64Type] [I64Type];
+    E.add_func_import env "rts" "principal_of_blob" [I64Type] [I64Type];
+    E.add_func_import env "rts" "compute_crc32" [I64Type] [I32Type];
+    E.add_func_import env "rts" "blob_iter_done" [I64Type] [I64Type];
+    E.add_func_import env "rts" "blob_iter" [I64Type] [I64Type];
+    E.add_func_import env "rts" "blob_iter_next" [I64Type] [I64Type];
+    E.add_func_import env "rts" "pow" [F64Type; F64Type] [F64Type]; (* musl *)
+    E.add_func_import env "rts" "sin" [F64Type] [F64Type]; (* musl *)
+    E.add_func_import env "rts" "cos" [F64Type] [F64Type]; (* musl *)
+    E.add_func_import env "rts" "tan" [F64Type] [F64Type]; (* musl *)
+    E.add_func_import env "rts" "asin" [F64Type] [F64Type]; (* musl *)
+    E.add_func_import env "rts" "acos" [F64Type] [F64Type]; (* musl *)
+    E.add_func_import env "rts" "atan" [F64Type] [F64Type]; (* musl *)
+    E.add_func_import env "rts" "atan2" [F64Type; F64Type] [F64Type]; (* musl *)
+    E.add_func_import env "rts" "exp" [F64Type] [F64Type]; (* musl *)
+    E.add_func_import env "rts" "log" [F64Type] [F64Type]; (* musl *)
+    E.add_func_import env "rts" "fmod" [F64Type; F64Type] [F64Type]; (* remainder, musl *)
+    E.add_func_import env "rts" "float_fmt" [F64Type; I64Type; I64Type] [I64Type];
+    E.add_func_import env "rts" "char_to_upper" [I32Type] [I32Type];
+    E.add_func_import env "rts" "char_to_lower" [I32Type] [I32Type];
+    E.add_func_import env "rts" "char_is_whitespace" [I32Type] [I32Type];
+    E.add_func_import env "rts" "char_is_lowercase" [I32Type] [I32Type];
+    E.add_func_import env "rts" "char_is_uppercase" [I32Type] [I32Type];
+    E.add_func_import env "rts" "char_is_alphabetic" [I32Type] [I32Type];
+    E.add_func_import env "rts" "get_max_live_size" [] [I64Type];
+    E.add_func_import env "rts" "get_reclaimed" [] [I64Type];
+    E.add_func_import env "rts" "alloc_words" [I64Type] [I64Type];
+    E.add_func_import env "rts" "get_total_allocations" [] [I64Type];
+    E.add_func_import env "rts" "get_heap_size" [] [I64Type];
+    E.add_func_import env "rts" "alloc_blob" [I64Type; I64Type] [I64Type];
+    E.add_func_import env "rts" "alloc_array" [I64Type; I64Type] [I64Type];
+    E.add_func_import env "rts" "read_persistence_version" [] [I64Type];
+    E.add_func_import env "rts" "stop_gc_before_stabilization" [] [];
+    E.add_func_import env "rts" "start_gc_after_destabilization" [] [];
+    E.add_func_import env "rts" "is_graph_stabilization_started" [] [I32Type];
+    E.add_func_import env "rts" "start_graph_stabilization" [I64Type; I64Type; I64Type] [];
+    E.add_func_import env "rts" "graph_stabilization_increment" [] [I32Type];
+    E.add_func_import env "rts" "start_graph_destabilization" [I64Type; I64Type] [];
+    E.add_func_import env "rts" "graph_destabilization_increment" [] [I32Type];
+    E.add_func_import env "rts" "get_graph_destabilized_actor" [] [I64Type];
+    E.add_func_import env "rts" "buffer_in_32_bit_range" [] [I64Type];
+    ()
+
+end (* RTS *)
+
+module GC = struct
+  (* Record mutator/gc instructions counts *)
+
+  let instruction_counter env =
+    compile_const_32 0l ^^
+    E.call_import env "ic0" "performance_counter"
+
+  let register_globals env =
+    E.add_global64 env "__mutator_instructions" Mutable 0L;
+    E.add_global64 env "__collector_instructions" Mutable 0L
+
+  let get_mutator_instructions env =
+    G.i (GlobalGet (nr (E.get_global env "__mutator_instructions")))
+  let set_mutator_instructions env =
+    G.i (GlobalSet (nr (E.get_global env "__mutator_instructions")))
+
+  let get_collector_instructions env =
+    G.i (GlobalGet (nr (E.get_global env "__collector_instructions")))
+  let set_collector_instructions env =
+    G.i (GlobalSet (nr (E.get_global env "__collector_instructions")))
+
+  let record_mutator_instructions env =
+    match E.mode env with
+    | Flags.(ICMode | RefMode)  ->
+      instruction_counter env ^^
+      set_mutator_instructions env
+    | _ -> G.nop
+
+  let record_collector_instructions env =
+    match E.mode env with
+    | Flags.(ICMode | RefMode)  ->
+      instruction_counter env ^^
+      get_mutator_instructions env ^^
+      G.i (Binary (Wasm_exts.Values.I64 I64Op.Sub)) ^^
+      set_collector_instructions env
+    | _ -> G.nop
+
+  let collect_garbage env =
+    record_mutator_instructions env ^^
+    E.collect_garbage env false ^^
+    record_collector_instructions env
+
+end (* GC *)
+
+module Heap = struct
+  (* General heap object functionality (allocation, setting fields, reading fields) *)
+
+  (* Memory addresses are 64 bit (I64Type). *)
+  let word_size = 8L
+
+
+  (* The heap base global can only be used late, see conclude_module
+     and GHC.register *)
+  let get_heap_base env =
+    G.i (GlobalGet (nr (E.get_global env "__heap_base")))
+
+  let get_total_allocation env =
+    E.call_import env "rts" "get_total_allocations"
+
+  let get_reclaimed env =
+    E.call_import env "rts" "get_reclaimed"
+
+  let get_memory_size =
+    G.i MemorySize ^^
+    compile_mul_const page_size
+
+  let get_max_live_size env =
+    E.call_import env "rts" "get_max_live_size"
+
+  (* Static allocation (always words)
+     (uses dynamic allocation for smaller and more readable code) *)
+  let alloc env (n : int64) : G.t =
+    compile_unboxed_const n ^^
+    E.call_import env "rts" "alloc_words"
+
+  (* Heap objects *)
+
+  (* At this level of abstraction, heap objects are just flat arrays of words *)
+
+  let load_field (i : int64) : G.t =
+    let offset = Int64.(add (mul word_size i) ptr_unskew) in
+    G.i (Load {ty = I64Type; align = 3; offset; sz = None})
+
+  let store_field (i : int64) : G.t =
+    let offset = Int64.(add (mul word_size i) ptr_unskew) in
+    G.i (Store {ty = I64Type; align = 3; offset; sz = None})
+
+  (* Or even as a single 64 bit float *)
+
+  let load_field_float64 (i : int64) : G.t =
+    let offset = Int64.(add (mul word_size i) ptr_unskew) in
+    G.i (Load {ty = F64Type; align = 3; offset; sz = None})
+
+  let store_field_float64 (i : int64) : G.t =
+    let offset = Int64.(add (mul word_size i) ptr_unskew) in
+    G.i (Store {ty = F64Type; align = 3; offset; sz = None})
+
+  (* Convenience functions related to memory *)
+  (* Copying bytes (works on unskewed memory addresses) *)
+  let memcpy env = E.call_import env "rts" "memcpy" ^^ G.i Drop
+  (* Comparing bytes (works on unskewed memory addresses) *)
+  let memcmp env = E.call_import env "rts" "memcmp" ^^ G.i (Convert (Wasm_exts.Values.I64 I64Op.ExtendUI32))
+
+  let register env =
+    let get_heap_base_fn = E.add_fun env "get_heap_base" (Func.of_body env [] [I64Type] (fun env ->
+      get_heap_base env
+    )) in
+
+    E.add_export env (nr {
+      name = Lib.Utf8.decode "get_heap_base";
+      edesc = nr (FuncExport (nr get_heap_base_fn))
+    })
+
+  let get_heap_size env =
+    E.call_import env "rts" "get_heap_size"
+
+  let get_static_variable env index = 
+    compile_unboxed_const index ^^
+    E.call_import env "rts" "get_static_variable"
+
+end (* Heap *)
+
+module Stack = struct
+  (* The RTS includes C code which requires a shadow stack in linear memory.
+     We reserve some space for it at the beginning of memory space (just like
+     wasm-l would), this way stack overflow would cause out-of-memory, and not
+     just overwrite static data.
+
+     We sometimes use the stack space if we need small amounts of scratch space.
+
+     All pointers here are unskewed.
+
+     (We report logical stack overflow as "RTS Stack underflow" as the stack
+     grows downwards.)
+  *)
+
+  (* Predefined constant stack size of 4MB, according to the persistent memory layout. *)
+  let stack_size = 4 * 1024 * 1024
+
+  let end_ () = Int64.of_int stack_size 
+
+  let register_globals env =
+    (* stack pointer *)
+    E.add_global64 env "__stack_pointer" Mutable (end_());
+    (* frame pointer *)
+    E.add_global64 env "__frame_pointer" Mutable (end_());
+    (* low watermark *)
+    if !Flags.measure_rts_stack then
+      E.add_global64 env "__stack_min" Mutable (end_());
+    E.export_global env "__stack_pointer"
+
+  let get_stack_ptr env =
+    G.i (GlobalGet (nr (E.get_global env "__stack_pointer")))
+  let set_stack_ptr env =
+    G.i (GlobalSet (nr (E.get_global env "__stack_pointer")))
+
+  let get_min env =
+    G.i (GlobalGet (nr (E.get_global env "__stack_min")))
+  let set_min env =
+    G.i (GlobalSet (nr (E.get_global env "__stack_min")))
+
+  let get_max_stack_size env =
+    if !Flags.measure_rts_stack then
+      compile_unboxed_const (end_()) ^^
+      get_min env ^^
+      G.i (Binary (Wasm_exts.Values.I64 I64Op.Sub))
+    else (* report max available *)
+      compile_unboxed_const (end_())
+
+  let update_stack_min env =
+    if !Flags.measure_rts_stack then
+    get_stack_ptr env ^^
+    get_min env ^^
+    compile_comparison I64Op.LtU ^^
+    (E.if0
+       (get_stack_ptr env ^^
+        set_min env)
+      G.nop)
+    else G.nop
+
+  let stack_overflow env =
+    Func.share_code0 Func.Never env "stack_overflow" [] (fun env ->
+      (* read last word of reserved page to force trap *)
+      compile_unboxed_const 0xFFFF_FFFF_FFFF_FFFCL ^^
+      G.i (Load {ty = I64Type; align = 3; offset = 0L; sz = None}) ^^
+      G.i Unreachable
+    )
+
+  let alloc_words env n =
+    let n_bytes = Int64.mul n Heap.word_size in
+    (* avoid absurd allocations *)
+    assert (Int64.(to_int n_bytes) < stack_size);
+    (* alloc words *)
+    get_stack_ptr env ^^
+    compile_unboxed_const n_bytes ^^
+    G.i (Binary (Wasm_exts.Values.I64 I64Op.Sub)) ^^
+    set_stack_ptr env ^^
+    update_stack_min env ^^
+    get_stack_ptr env ^^
+    (* check for stack overflow, if necessary *)
+    if n_bytes >= page_size then
+      get_stack_ptr env ^^
+      G.i (Unary (Wasm_exts.Values.I64 I64Op.Clz)) ^^
+      E.if0
+        G.nop (* we found leading zeros, i.e. no wraparound *)
+        (stack_overflow env)
+    else
+      G.nop
+
+  let free_words env n =
+    get_stack_ptr env ^^
+    compile_unboxed_const (Int64.mul n Heap.word_size) ^^
+    G.i (Binary (Wasm_exts.Values.I64 I64Op.Add)) ^^
+    set_stack_ptr env
+
+  (* TODO: why not just remember and reset the stack pointer, instead of calling free_words? Also below *)
+  let with_words env name n f =
+    let (set_x, get_x) = new_local env name in
+    alloc_words env n ^^ set_x ^^
+    f get_x ^^
+    free_words env n
+
+  let dynamic_alloc_words env get_n =
+    get_stack_ptr env ^^
+    compile_divU_const Heap.word_size ^^
+    get_n ^^
+    compile_comparison I64Op.LtU ^^
+    (E.if0
+      (stack_overflow env)
+      G.nop) ^^
+    get_stack_ptr env ^^
+    get_n ^^
+    compile_mul_const Heap.word_size ^^
+    G.i (Binary (Wasm_exts.Values.I64 I64Op.Sub)) ^^
+    set_stack_ptr env ^^
+    update_stack_min env ^^
+    get_stack_ptr env
+
+  let dynamic_free_words env get_n =
+    get_stack_ptr env ^^
+    get_n ^^
+    compile_mul_const Heap.word_size ^^
+    G.i (Binary (Wasm_exts.Values.I64 I64Op.Add)) ^^
+    set_stack_ptr env
+
+  (* TODO: why not just remember and reset the stack pointer, instead of calling free_words? Also above*)
+  let dynamic_with_words env name f =
+    let (set_n, get_n) = new_local env "n" in
+    let (set_x, get_x) = new_local env name in
+    set_n ^^
+    dynamic_alloc_words env get_n ^^ set_x ^^
+    f get_x ^^
+    dynamic_free_words env get_n
+
+  let dynamic_with_bytes env name f =
+    (* round up to nearest wordsize *)
+    compile_add_const (Int64.sub Heap.word_size 1L) ^^
+    compile_divU_const Heap.word_size ^^
+    dynamic_with_words env name f
+
+  (* Stack Frames *)
+
+  (* Traditional frame pointer for accessing statically allocated locals/args (all words)
+     Used (sofar) only in serialization to compress Wasm stack
+     at cost of expanding Rust/C Stack (whose size we control)*)
+  let get_frame_ptr env =
+    G.i (GlobalGet (nr (E.get_global env "__frame_pointer")))
+  let set_frame_ptr env =
+    G.i (GlobalSet (nr (E.get_global env "__frame_pointer")))
+
+  (* Frame pointer operations *)
+
+  (* Enter/exit a new frame of `n` words, saving and restoring prev frame pointer *)
+  let with_frame env name n f =
+    (* reserve space for n words + saved frame_ptr *)
+    alloc_words env (Int64.add n 1L) ^^
+    (* store the current frame_ptr at offset 0 *)
+    get_frame_ptr env ^^
+    G.i (Store {ty = I64Type; align = 3; offset = 0L; sz = None}) ^^
+    get_stack_ptr env ^^
+    (* set_frame_ptr to stack_ptr *)
+    set_frame_ptr env ^^
+    (* do as f *)
+    f () ^^
+    (* assert frame_ptr == stack_ptr *)
+    get_frame_ptr env ^^
+    get_stack_ptr env ^^
+    compile_comparison I64Op.Eq ^^
+    E.else_trap_with env "frame_ptr <> stack_ptr" ^^
+    (* restore the saved frame_ptr *)
+    get_frame_ptr env ^^
+    G.i (Load {ty = I64Type; align = 3; offset = 0L; sz = None}) ^^
+    set_frame_ptr env ^^
+    (* free the frame *)
+    free_words env (Int64.add n 1L)
+
+  (* read local n of current frame *)
+  let get_local env n =
+    let offset = Int64.mul (Int64.add n 1L) Heap.word_size in
+    get_frame_ptr env ^^
+      G.i (Load { ty = I64Type; align = 3; offset; sz = None})
+
+  (* read local n of previous frame *)
+  let get_prev_local env n =
+    let offset = Int64.mul (Int64.add n 1L) Heap.word_size in
+    (* indirect through save frame_ptr at offset 0 *)
+    get_frame_ptr env ^^
+    G.i (Load { ty = I64Type; align = 3; offset = 0L; sz = None}) ^^
+    G.i (Load { ty = I64Type; align = 3; offset; sz = None})
+
+  (* set local n of current frame *)
+  let set_local env n =
+    let offset = Int64.mul (Int64.add n 1L) Heap.word_size in
+    Func.share_code1 Func.Never env ("set_local %i" ^ Int64.to_string n) ("val", I64Type) []
+      (fun env get_val ->
+         get_frame_ptr env ^^
+         get_val ^^
+         G.i (Store { ty = I64Type; align = 3; offset; sz = None}))
+
+end (* Stack *)
+
+
+module ContinuationTable = struct
+  (* See rts/motoko-rts/src/closure_table.rs *)
+  let remember env : G.t = E.call_import env "rts" "remember_continuation"
+  let recall env : G.t = E.call_import env "rts" "recall_continuation"
+  let peek_future env : G.t = E.call_import env "rts" "peek_future_continuation"
+  let count env : G.t = E.call_import env "rts" "continuation_count"
+  let size env : G.t = E.call_import env "rts" "continuation_table_size"
+end (* ContinuationTable *)
+
+module Bool = struct
+  (* Boolean literals are either 0 or non-zero (e.g. if they origin from RTS or external API).
+     They need not be shifted before put in the heap,
+     because the "zero page" never contains GC-ed objects
+  *)
+
+  let vanilla_lit = function
+    | false -> 0L
+    | true -> 1L (* or any other non-zero value *)
+
+  let lit b = compile_unboxed_const (vanilla_lit b)
+  
+  let lit_rts_int32 b = compile_const_32 (Int64.to_int32 (vanilla_lit b))
+  
+  let neg = compile_test I64Op.Eqz
+
+  let from_rts_int32 = 
+    G.i (Convert (Wasm_exts.Values.I64 I64Op.ExtendUI32))
+
+  let to_rts_int32 =
+    G.i (Convert (Wasm_exts.Values.I32 I32Op.WrapI64))
+
+  let from_int64 =
+    compile_unboxed_const 0L ^^
+    compile_comparison I64Op.Ne
+
+end (* Bool *)
+
+module BitTagged = struct
+
+  (* This module takes care of pointer tagging:
+
+     A pointer to an object at offset `i` on the heap is represented as
+     `i-1`, so the low two bits of the pointer are always set (0b…11).
+     We call `i-1` a *skewed* pointer, in a feeble attempt to avoid the term
+     shifted, which may sound like a logical shift.
+
+     We use the constants ptr_skew and ptr_unskew to change a pointer as a
+     signpost where we switch between raw pointers to skewed ones.
+
+     This means we can store a small unboxed scalar x as (x `lsl` 1), and still
+     tell it apart from a pointer by looking at the last bits: if set, it is a
+     pointer.
+
+     Small here means:
+
+     * 0 ≤ x < 2^(ubits ty) for an unsigned type ty with (ubits ty) payload bits
+     * -2^sbits ≤ x < 2^sbits, for a signed type ty with (sbits ty) (= (ubits ty) - 1) payload bits
+       (i.e. excluding sign bit),
+     with the exception that compact Nat is regarded as signed to support subtyping.
+
+     Tagging needs to happen with a
+     * shift left by (32-ubits ty) for a signed or unsigned type ty; then
+     * a logical or of the (variable length) tag bits for ty.
+
+     Untagging needs to happen with an
+     * logical right shift (for unsigned type ty in Nat{8,16,32,64}, Char).
+     * _arithmetic_ right shift (for signed type ty Int{8,16,32,64}, Int but also Nat).
+       This is the right thing to do for signed numbers.
+       Nat is treated as signed to allow coercion-free subtyping.
+
+     The low bits 32 - (ubits ty) store the tag bits of the value.
+
+     Boolean false is a non-pointer by construction.
+     Boolean true (1) needs not be shifted as GC will not consider it.
+
+     Summary:
+
+       0b…11: A pointer
+       0b…x0: A shifted scalar
+       0b000: `false`
+       0b001: `true`
+
+     Note that {Nat,Int}{8,16,32} and compact {Int,Nat}64 and compact Int, Nat are explicitly tagged.
+     The bits are stored in the _most_ significant bits of the `i64`,
+     with the lower bits storing the variable length tag.
+
+     {Int,Nat}64 are stored in signed and unsigned forms.
+
+     Compact {Int,Nat} are (both) stored in signed form to support coercion free subtyping of Nat < Int.
+     That means that one bit, the highest bit, of the compact Nat representation is unused and the
+     representable range for both compact Int and Nat values is -2^(sbits Int) ≤ x < 2^(sbits Int).
+
+     This describes the vanilla representation of small and compact scalars,
+     used as the uniform representation of values and when stored in heap structures.
+
+     See module TaggedSmallWord.
+
+     The stack representation of a small scalars, UnboxedWord64 {Int,Nat}{8,16,32},
+     on the other hand, always has all tag bits cleared, with the payload in the high bits of the word.
+
+     The stack representation of compact or unboxed scalars or UnboxedWord64 {Int,Nat}64, 
+     on the other hand, is the natural (unpadded) machine representation.
+
+     All arithmetic is implemented directly on the stack (not vanilla) representation of scalars.
+     Proper tags bits are removed/added when loading from vanilla or storing to vanilla representation.
+
+  *)
+  let is_true_literal env =
+    compile_eq_const 1L
+
+  (* Note: `true` is not handled here, needs specific check where needed. *)
+  let if_tagged_scalar env retty is1 is2 =
+    compile_bitand_const 0x1L ^^
+    E.if_ env retty is2 is1
+
+  (* With two bit-tagged pointers on the stack, decide
+     whether both are scalars and invoke is1 (the fast path)
+     if so, and otherwise is2 (the slow path).
+     Note: `true` is not handled here, needs specific check where needed.
+  *)
+  let if_both_tagged_scalar env retty is1 is2 =
+    G.i (Binary (Wasm_exts.Values.I64 I64Op.Or)) ^^
+    compile_bitand_const 0x1L ^^
+    E.if_ env retty is2 is1
+
+  let ubits_of pty = TaggingScheme.ubits_of pty
+
+  let sbits_of pty = (ubits_of pty) - 1
+
+  (* 64 bit numbers *)
+
+  (* static *)
+  let can_tag_const pty (n : int64) = Type.(
+    match pty with
+    | Nat | Int | Int64 | Int32 ->
+      let sbits = sbits_of pty in
+      let lower_bound = Int64.(neg (shift_left 1L sbits)) in
+      let upper_bound = Int64.shift_left 1L sbits in
+      lower_bound <= n && n < upper_bound
+    | Nat64 | Nat32 ->
+      let ubits = ubits_of pty in
+      let upper_bound = Int64.shift_left 1L ubits in
+      0L <= n && n < upper_bound
+    | _ -> assert false)
+
+  let tag_const pty i = Type.(
+    match pty with
+    |  Nat | Int | Int64 | Int32
+    |  Nat64 | Nat32 ->
+      Int64.shift_left i (64 - ubits_of pty)
+      (* tag *)
+      |> Int64.logor (TaggingScheme.tag_of_typ pty)
+    | _ -> assert false)
+
+  (* dynamic *)
+  let sanity_check_can_tag_signed env pty get_x =
+    if TaggingScheme.debug || !Flags.sanity then
+      get_x ^^
+      Func.share_code2 Func.Always env (prim_fun_name pty "check_can_tag_i64") (("res", I64Type), ("x", I64Type)) [I64Type]
+        (fun env get_res get_x -> Type.(
+          match pty with
+          | Nat | Int | Int64 | Int32 ->
+            let sbits = sbits_of pty in
+            let lower_bound = Int64.(neg (shift_left 1L sbits)) in
+            let upper_bound = Int64.shift_left 1L sbits in
+            (* lower_bound <= x < upper_bound *)
+            compile_unboxed_const lower_bound ^^
+            get_x ^^
+            compile_comparison I64Op.LeS ^^
+            get_x ^^ compile_unboxed_const upper_bound ^^
+            compile_comparison I64Op.LtS ^^
+            G.i (Binary (Wasm_exts.Values.I64 I64Op.And))
+         | Nat64 | Nat32 ->
+            let ubits = ubits_of pty in
+            let upper_bound = Int64.shift_left 1L ubits in
+            (* 0 <= x < upper_bound *)
+            get_x ^^ compile_unboxed_const upper_bound ^^
+            compile_comparison I64Op.LtU
+         | _ ->
+            assert false) ^^
+         get_res ^^
+         compile_comparison I64Op.Eq ^^
+         E.else_trap_with env (prim_fun_name pty "check_can_tag_i64") ^^
+         get_res)
+    else
+      G.nop
+
+  let if_can_tag_signed env pty retty is1 is2 = Type.(
+    match pty with
+    | Nat | Int | Int64 ->
+      Func.share_code1 Func.Never env
+        (prim_fun_name pty "if_can_tag_i64") ("x", I64Type) [I64Type] (fun env get_x ->
+        (* checks that all but the low sbits are either all 0 or all 1 *)
+        get_x ^^
+        get_x ^^ compile_shrS_const (Int64.of_int ((64 - sbits_of pty))) ^^
+        G.i (Binary (Wasm_exts.Values.I64 I32Op.Xor)) ^^
+        compile_shrU_const (Int64.of_int (sbits_of pty)) ^^
+        compile_test I64Op.Eqz ^^
+        sanity_check_can_tag_signed env pty get_x) ^^
+      E.if_ env retty is1 is2
+    | Nat64 ->
+      Func.share_code1 Func.Never env
+         (prim_fun_name pty "if_can_tag_i64") ("x", I64Type) [I64Type] (fun env get_x ->
+          (* checks that all but the low ubits are 0 *)
+          get_x ^^ compile_shrU_const (Int64.of_int (ubits_of pty)) ^^
+          compile_test I64Op.Eqz ^^
+          sanity_check_can_tag_signed env pty get_x) ^^
+      E.if_ env retty is1 is2
+     | _ -> assert false)
+
+  let if_can_tag_unsigned env pty retty is1 is2 = Type.(
+    match pty with
+    |  Nat | Int | Int64 ->
+      let sbitsL = Int64.of_int (sbits_of pty) in
+      compile_shrU_const sbitsL ^^
+      compile_test I64Op.Eqz ^^
+      E.if_ env retty is1 is2
+    | Nat64 ->
+      let ubitsL = Int64.of_int (ubits_of pty) in
+      compile_shrU_const ubitsL ^^
+      E.if_ env retty is2 is1 (* NB: swapped branches *)
+    | _ -> assert false)
+
+  let tag env pty = (* TBR *)
+    let ubitsl = Int64.of_int (ubits_of pty) in
+    compile_shl_const (Int64.sub 64L ubitsl) ^^
+    (* tag *)
+    compile_bitor_const (TaggingScheme.tag_of_typ pty)
+
+  let sanity_check_tag line env ty =
+    if TaggingScheme.debug || !(Flags.sanity) then
+      let name =
+        (prim_fun_name ty "sanity_check_tag") ^
+          (if TaggingScheme.debug then Int.to_string line else "")
+      in
+      let tag_mask = Int64.(sub (shift_left 1L (64 - TaggingScheme.ubits_of ty)) one) in
+      (Func.share_code1 Func.Always env name ("v", I64Type) [I64Type] (fun env get_n ->
+         get_n ^^
+         compile_bitand_const tag_mask ^^
+         compile_eq_const (TaggingScheme.tag_of_typ ty) ^^
+         E.else_trap_with env "unexpected tag" ^^
+         get_n))
+    else G.nop
+
+  let untag line env pty = Type.(match pty with
+    | Nat | Int | Int64 | Int32 | Int16 | Int8 ->
+      let ubitsl = Int64.of_int (ubits_of pty) in
+      sanity_check_tag line env pty ^^
+      compile_shrS_const (Int64.sub 64L ubitsl)
+    | Nat64 | Nat32 | Nat16 | Nat8 ->
+      let ubitsl = Int64.of_int (ubits_of pty) in
+      sanity_check_tag line env pty ^^
+      compile_shrU_const (Int64.sub 64L ubitsl)
+    | _ -> assert false)
+
+  let clear_tag env pty =
+    if TaggingScheme.tag_of_typ pty <> 0L then
+      let shift_amount = 64 - ubits_of pty in
+      let mask = Int64.(lognot (sub (shift_left one shift_amount) one)) in
+      compile_bitand_const mask
+    else G.nop
+
+end (* BitTagged *)
+
+module Tagged = struct
+  (* Tagged objects all have an object header consisting of a tag and a forwarding pointer.
+     The tag is to describe their runtime type and serves to traverse the heap
+     (serialization, GC), but also for objectification of arrays.
+
+     The tag is a word at the beginning of the object.
+
+     The (skewed) forwarding pointer supports object moving in the incremental garbage collection.
+
+         obj header
+     ┌──────┬─────────┬──
+     │ tag  │ fwd ptr │ ...
+     └──────┴─────────┴──
+
+     Attention: This mapping is duplicated in these places
+       * here
+       * motoko-rts/src/types.rs
+       * motoko-rts/src/text.rs
+       * motoko-rts/src/memory.rs
+       * motoko-rts/src/bigint.rs
+       * motoko-rts/src/blob-iter.rs
+       * motoko-rts/src/static-checks.rs
+       * In all GC implementations in motoko-rts/src/gc/
+     so update all!
+   *)
+
+  type bits_sort =
+    | U (* signed *)
+    | S (* unsigned *)
+    | F (* float *)
+  type array_sort =
+    | I (* [ T ] *)
+    | M (* [var T ] *)
+    | T (* (T,+) *)
+    | S (* shared ... -> ... *)
+  type blob_sort =
+    | B (* Blob *)
+    | T (* Text *)
+    | P (* Principal *)
+    | A (* actor { ... } *)
+
+  type [@warning "-37"] tag  =
+    | Object
+    | Array of array_sort (* Also a tuple *)
+    | Bits64 of bits_sort (* Contains a 64 bit number *)
+    | MutBox (* used for mutable heap-allocated variables *)
+    | Closure
+    | Some (* For opt *)
+    | Variant
+    | Blob of blob_sort
+    | Indirection (* Only used by the GC *)
+    | BigInt
+    | Concat (* String concatenation, used by rts/text.c *)
+    | OneWordFiller (* Only used by the RTS *)
+    | FreeSpace (* Only used by the RTS *)
+    | Region
+    | ArraySliceMinimum (* Used by the GC for incremental array marking *)
+    | StableSeen (* Marker that we have seen this thing before *)
+    | CoercionFailure (* Used in the Candid decoder. Static singleton! *)
+
+  (* Tags needs to have the lowest bit set, to allow distinguishing object
+     headers from heap locations (object or field addresses).
+
+     (Reminder: objects and fields are word-aligned so will have the lowest two
+     bits unset) *)
+  let int_of_tag = function
+    | Object -> 1L
+    | Array I -> 3L
+    | Array M -> 5L
+    | Array T -> 7L
+    | Array S -> 9L
+    | Bits64 U -> 11L
+    | Bits64 S -> 13L
+    | Bits64 F -> 15L
+    | MutBox -> 17L
+    | Closure -> 19L
+    | Some -> 21L
+    | Variant -> 23L
+    | Blob B -> 25L
+    | Blob T -> 27L
+    | Blob P -> 29L
+    | Blob A -> 31L
+    | Indirection -> 33L
+    | BigInt -> 35L
+    | Concat -> 37L
+    | Region -> 39L
+    | OneWordFiller -> 41L
+    | FreeSpace -> 43L
+    | ArraySliceMinimum -> 44L
+    (* Next two tags won't be seen by the GC, so no need to set the lowest bit
+       for `CoercionFailure` and `StableSeen` *)
+    | CoercionFailure -> 0xffff_ffff_ffff_fffeL
+    | StableSeen -> 0xffff_ffff_ffff_ffffL
+
+  (*
+     The null pointer is the sentinel `0xffff_ffff_ffff_fffbL` (skewed representation).
+    
+     This serves for efficient null tests by using direct pointer comparison.
+     The null pointer must not be dereferenced.
+     Null tests are possible without resolving the forwarding pointer of a non-null comparand.
+  *)
+
+  let null_vanilla_pointer = 0xffff_ffff_ffff_fffbL (* skewed, pointing to last unallocated Wasm page *)
+  let null_pointer = compile_unboxed_const null_vanilla_pointer
+
+  let is_null env = compile_eq_const null_vanilla_pointer
+
+  let not_null env =
+    (* null test works without forwarding pointer resolution of a non-null comparand *)
+    null_pointer ^^
+    compile_comparison I64Op.Ne
+
+  let header_size = 2L
+  
+  (* The tag *)
+  let tag_field = 0L
+  let forwarding_pointer_field = 1L
+
+  (* Note: post-allocation barrier must be applied after initialization *)
+  let alloc env size tag =
+    assert (size > 1L);
+    let name = Printf.sprintf "alloc_size<%d>_tag<%d>" (Int64.to_int size) (Int64.to_int (int_of_tag tag)) in
+
+    Func.share_code0 Func.Never env name [I64Type] (fun env ->
+      let set_object, get_object = new_local env "new_object" in
+      Heap.alloc env size ^^
+      set_object ^^ get_object ^^
+      compile_unboxed_const (int_of_tag tag) ^^
+      Heap.store_field tag_field ^^
+      get_object ^^ (* object pointer *)
+      get_object ^^ (* forwarding pointer *)
+      Heap.store_field forwarding_pointer_field ^^
+      get_object
+    )
+
+  let load_forwarding_pointer env =
+    Heap.load_field forwarding_pointer_field
+
+  let store_tag env tag =
+    load_forwarding_pointer env ^^
+    compile_unboxed_const (int_of_tag tag) ^^
+    Heap.store_field tag_field
+
+  let load_tag env =
+    load_forwarding_pointer env ^^
+    Heap.load_field tag_field
+
+  let sanity_check_tag line env tag =
+    let tag = int_of_tag tag in
+    let name = "sanity_check_tag_" ^ Int64.to_string tag ^
+                 (if TaggingScheme.debug then Int.to_string line else "")
+    in
+    if TaggingScheme.debug || !Flags.sanity then
+      Func.share_code1 Func.Always env name ("obj", I64Type) [I64Type]
+        (fun env get_obj ->
+         get_obj ^^
+         load_tag env  ^^
+         compile_unboxed_const tag ^^
+         compile_comparison I64Op.Eq ^^
+         E.else_trap_with env name ^^
+         get_obj)
+    else
+      G.nop
+
+  let check_forwarding env unskewed =
+    let name = "check_forwarding_" ^ if unskewed then "unskewed" else "skewed" in
+    Func.share_code1 Func.Always env name ("object", I64Type) [I64Type] (fun env get_object ->
+      let set_object = G.setter_for get_object in
+      (if unskewed then
+        get_object ^^
+        compile_unboxed_const ptr_skew ^^
+        G.i (Binary (Wasm_exts.Values.I64 I64Op.Add)) ^^
+        set_object
+      else G.nop) ^^
+      get_object ^^
+      load_forwarding_pointer env ^^
+      get_object ^^
+      compile_comparison I64Op.Eq ^^
+      E.else_trap_with env "missing object forwarding" ^^
+      get_object ^^
+      (if unskewed then
+        compile_unboxed_const ptr_unskew ^^
+        G.i (Binary (Wasm_exts.Values.I64 I64Op.Add))
+      else G.nop))
+
+  let check_forwarding_for_store env typ =
+    let (set_value, get_value, _) = new_local_ env typ "value" in
+    set_value ^^ check_forwarding env false ^^ get_value
+
+  let load_field env index =
+    (if !Flags.sanity then check_forwarding env false else G.nop) ^^
+    Heap.load_field index
+
+  let store_field env index =
+    (if !Flags.sanity then check_forwarding_for_store env I64Type else G.nop) ^^
+    Heap.store_field index
+
+  let load_field_float64 env index =
+    (if !Flags.sanity then check_forwarding env false else G.nop) ^^
+    Heap.load_field_float64 index
+
+  let store_field_float64 env index =
+    (if !Flags.sanity then check_forwarding_for_store env F64Type else G.nop) ^^
+    Heap.store_field_float64 index
+
+  (* Branches based on the tag of the object pointed to,
+     leaving the object on the stack afterwards. *)
+  let branch_default env retty def (cases : (tag * G.t) list) : G.t =
+    let (set_tag, get_tag) = new_local env "tag" in
+
+    let rec go = function
+      | [] -> def
+      | ((tag, code) :: cases) ->
+        get_tag ^^
+        compile_eq_const (int_of_tag tag) ^^
+        E.if_ env retty code (go cases)
+    in
+    load_tag env ^^
+    set_tag ^^
+    go cases
+
+  let allocation_barrier env =
+    E.call_import env "rts" "allocation_barrier"
+
+  let write_with_barrier env =
+    let (set_value, get_value) = new_local env "written_value" in
+    let (set_location, get_location) = new_local env "write_location" in
+    set_value ^^ set_location ^^
+    (* performance gain by first checking the GC state *)
+    E.call_import env "rts" "running_gc" ^^
+    Bool.from_rts_int32 ^^
+    E.if0 (
+      get_location ^^ get_value ^^
+      E.call_import env "rts" "write_with_barrier"
+    ) (
+      get_location ^^ get_value ^^
+      store_unskewed_ptr
+    )
+
+  let obj env tag element_instructions : G.t =
+    let n = List.length element_instructions in
+    let size = (Int64.add (Wasm.I64.of_int_u n) header_size) in
+    let (set_object, get_object) = new_local env "new_object" in
+    alloc env size tag ^^
+    set_object ^^
+    let init_elem idx instrs : G.t =
+      get_object ^^
+      instrs ^^
+      Heap.store_field (Int64.add (Wasm.I64.of_int_u idx) header_size)
+    in
+    G.concat_mapi init_elem element_instructions ^^
+    get_object ^^
+    allocation_barrier env
+
+  let shared_object env allocation =
+    let index = E.object_pool_add env allocation in
+    E.SharedObject index
+
+  let materialize_shared_value env = function
+  | E.Vanilla vanilla -> compile_unboxed_const vanilla
+  | E.SharedObject index -> Heap.get_static_variable env index
+
+  let share env allocation =
+    materialize_shared_value env (shared_object env allocation)
+
+end (* Tagged *)
+
+module MutBox = struct
+  (*
+      Mutable heap objects
+
+       ┌──────┬─────┬─────────┐
+       │ obj header │ payload │
+       └──────┴─────┴─────────┘
+
+     The object header includes the obj tag (MutBox) and the forwarding pointer.
+  *)
+
+  let field = Tagged.header_size
+
+  let alloc env =
+    Tagged.obj env Tagged.MutBox [ compile_unboxed_zero ]
+
+  let load_field env =
+    Tagged.load_forwarding_pointer env ^^
+    Tagged.load_field env field
+
+  let store_field env =
+    let (set_mutbox_value, get_mutbox_value) = new_local env "mutbox_value" in
+    set_mutbox_value ^^
+    Tagged.load_forwarding_pointer env ^^
+    get_mutbox_value ^^
+    Tagged.store_field env field
+  
+  let add_global_mutbox env =
+    E.object_pool_add env alloc
+end
+
+
+module Opt = struct
+  (* The Option type. Optional values are represented as
+
+    1. The null literal being the sentinel null pointer value, see above.
+       
+    2. ┌──────┬─────────┐
+       │ some │ payload │
+       └──────┴─────────┘
+
+       A heap-allocated box for `?v` values. Should only ever contain null or
+       another such box.
+
+    3. Anything else (pointer or unboxed scalar): Constituent value, implicitly
+       injected into the opt type.
+
+    This way, `?t` is represented without allocation, with the only exception of
+    the value `?ⁿnull` for n>0.
+
+    NB: `?ⁿnull` is essentially represented by the unary encoding of the number
+    of n. This could be optimized further, by storing `n` in the Some payload,
+    instead of a pointer, but unlikely worth it.
+
+  *)
+
+  let some_payload_field = Tagged.header_size
+
+  let null_vanilla_lit = Tagged.null_vanilla_pointer
+  let null_lit env = Tagged.null_pointer
+
+  let is_null = Tagged.is_null
+  let is_some = Tagged.not_null
+
+  let alloc_some env get_payload =
+    Tagged.obj env Tagged.Some [ get_payload ]
+
+  let inject env e =
+    e ^^
+    Func.share_code1 Func.Never env "opt_inject" ("x", I64Type) [I64Type] (fun env get_x ->
+      get_x ^^ BitTagged.if_tagged_scalar env [I64Type]
+        ( get_x ) (* scalar, no wrapping *)
+        ( get_x ^^ BitTagged.is_true_literal env ^^ (* exclude true literal since `branch_default` follows the forwarding pointer *)
+          E.if_ env [I64Type]
+            ( get_x ) (* true literal, no wrapping *)
+            ( get_x ^^ is_some env ^^
+              E.if_ env [I64Type]
+                ( get_x ^^ Tagged.branch_default env [I64Type]
+                  ( get_x ) (* default tag, no wrapping *)
+                  [ Tagged.Some, alloc_some env get_x ]
+                )
+                ( alloc_some env get_x ) (* ?ⁿnull for n > 0 *)
+            )
+        )
+    )
+
+  let constant env = function
+  | E.Vanilla value when value = null_vanilla_lit -> Tagged.shared_object env (fun env -> alloc_some env (null_lit env)) (* ?ⁿnull for n > 0 *)
+  | E.Vanilla value -> E.Vanilla value (* not null and no `Opt` object *)
+  | shared_value ->
+    Tagged.shared_object env (fun env -> 
+      let materialized_value = Tagged.materialize_shared_value env shared_value in  
+      inject env materialized_value (* potentially wrap in new `Opt` *)
+    )
+
+  (* This function is used where conceptually, Opt.inject should be used, but
+  we know for sure that it wouldn’t do anything anyways, except dereferencing the forwarding pointer *)
+  let inject_simple env e =
+    e ^^ Tagged.load_forwarding_pointer env
+
+  let load_some_payload_field env =
+    Tagged.load_forwarding_pointer env ^^
+    Tagged.load_field env some_payload_field
+
+  let project env =
+    Func.share_code1 Func.Never env "opt_project" ("x", I64Type) [I64Type] (fun env get_x ->
+      get_x ^^ BitTagged.if_tagged_scalar env [I64Type]
+        ( get_x ) (* scalar, no wrapping *)
+        ( get_x ^^ BitTagged.is_true_literal env ^^ (* exclude true literal since `branch_default` follows the forwarding pointer *)
+          E.if_ env [I64Type]
+            ( get_x ) (* true literal, no wrapping *)
+            ( get_x ^^ Tagged.branch_default env [I64Type]
+              ( get_x ) (* default tag, no wrapping *)
+              [ Tagged.Some, get_x ^^ load_some_payload_field env ]
+            )
+        )
+    )
+
+end (* Opt *)
+
+module Variant = struct
+  (* The Variant type. We store the variant tag in a first word; we can later
+     optimize and squeeze it in the Tagged tag. We can also later support unboxing
+     variants with an argument of type ().
+
+       ┌──────┬─────┬────────────┬─────────┐
+       │ obj header │ varianttag │ payload │
+       └──────┴─────┴────────────┴─────────┘
+
+     The object header includes the obj tag (TAG_VARIANT) and the forwarding pointer.
+  *)
+
+  let variant_tag_field = Tagged.header_size
+  let payload_field = Int64.add variant_tag_field 1L
+
+  let hash_variant_label env : Mo_types.Type.lab -> int64 =
+    E.hash env
+
+  let inject env l e =
+    Tagged.obj env Tagged.Variant [compile_unboxed_const (hash_variant_label env l); e]
+
+  let get_variant_tag env =
+    Tagged.load_forwarding_pointer env ^^
+    Tagged.load_field env variant_tag_field
+
+  let project env =
+    Tagged.load_forwarding_pointer env ^^
+    Tagged.load_field env payload_field
+
+  (* Test if the top of the stack points to a variant with this label *)
+  let test_is env l =
+    get_variant_tag env ^^
+    compile_eq_const (hash_variant_label env l)
+
+end (* Variant *)
+
+
+module Closure = struct
+  (* In this module, we deal with closures, i.e. functions that capture parts
+     of their environment.
+
+     The structure of a closure is:
+
+       ┌──────┬─────┬───────┬──────┬──────────────┐
+       │ obj header │ funid │ size │ captured ... │
+       └──────┴─────┴───────┴──────┴──────────────┘
+
+     The object header includes the object tag (TAG_CLOSURE) and the forwarding pointer.
+  *)
+  let header_size = Int64.add Tagged.header_size 2L
+
+  let funptr_field = Tagged.header_size
+  let len_field = Int64.add 1L Tagged.header_size
+
+  let load_data env i =
+    Tagged.load_forwarding_pointer env ^^
+    Tagged.load_field env (Int64.add header_size i)
+
+  let store_data env i =
+    let (set_closure_data, get_closure_data) = new_local env "closure_data" in
+    set_closure_data ^^
+    Tagged.load_forwarding_pointer env ^^
+    get_closure_data ^^
+    Tagged.store_field env (Int64.add header_size i)
+
+  let prepare_closure_call env =
+    Tagged.load_forwarding_pointer env
+
+  (* Expect on the stack
+     * the function closure (using prepare_closure_call)
+     * and arguments (n-ary!)
+     * the function closure again!
+  *)
+  let call_closure env n_args n_res =
+    (* Calculate the wasm type for a given calling convention.
+       An extra first argument for the closure! *)
+    let ty = E.func_type env (FuncType (
+      I64Type :: Lib.List.make n_args I64Type,
+      FakeMultiVal.ty (Lib.List.make n_res I64Type))) in
+    (* get the table index *)
+    Tagged.load_forwarding_pointer env ^^
+    Tagged.load_field env funptr_field ^^
+    G.i (Convert (Wasm_exts.Values.I32 I32Op.WrapI64)) ^^
+    (* All done: Call! *)
+    G.i (CallIndirect (nr ty)) ^^
+    FakeMultiVal.load env (Lib.List.make n_res I64Type)
+
+  let constant env get_fi =
+    let fi = Wasm.I64_convert.extend_i32_u (E.add_fun_ptr env (get_fi ())) in
+    Tagged.shared_object env (fun env -> Tagged.obj env Tagged.Closure [
+      compile_unboxed_const fi;
+      compile_unboxed_const 0L
+    ])
+
+end (* Closure *)
+
+
+module BoxedWord64 = struct
+  (* We store large word64s, nat64s and int64s in immutable boxed 64bit heap objects.
+
+     Small values are stored unboxed, tagged, see BitTagged. The bit-tagging logic is
+     contained in BitTagged; here we just do the boxing.
+
+     The heap layout of a BoxedWord64 is:
+
+       ┌──────┬─────┬─────┐
+       │ obj header │ i64 │
+       └──────┴─────┴─────┘
+
+     The object header includes the object tag (Bits64) and the forwarding pointer.
+  *)
+
+  let payload_field = Tagged.header_size
+
+  let heap_tag env pty =
+    match pty with
+    | Type.Nat64 -> Tagged.(Bits64 U)
+    | Type.Int64 -> Tagged.(Bits64 S)
+    | _ -> assert false
+
+  let compile_box env pty compile_elem : G.t =
+    let (set_i, get_i) = new_local env "boxed_i64" in
+    let size = 4L in
+    Tagged.alloc env size (heap_tag env pty) ^^
+    set_i ^^
+    get_i ^^ compile_elem ^^ Tagged.store_field env payload_field ^^
+    get_i ^^
+    Tagged.allocation_barrier env
+
+  let constant env pty i =
+    if BitTagged.can_tag_const pty i
+    then 
+      E.Vanilla (BitTagged.tag_const pty i)
+    else
+      Tagged.shared_object env (fun env -> compile_box env pty (compile_unboxed_const i))
+
+  let box env pty = 
+    Func.share_code1 Func.Never env 
+      (prim_fun_name pty "box64") ("n", I64Type) [I64Type] (fun env get_n ->
+      get_n ^^ BitTagged.if_can_tag_signed env pty [I64Type]
+        (get_n ^^ BitTagged.tag env pty)
+        (compile_box env pty get_n)
+    )
+
+  let unbox env pty = 
+    Func.share_code1 Func.Never env 
+      (prim_fun_name pty "unbox64") ("n", I64Type) [I64Type] (fun env get_n ->
+      get_n ^^
+      BitTagged.if_tagged_scalar env [I64Type]
+        (get_n ^^ BitTagged.untag __LINE__ env pty)
+        (get_n ^^
+         Tagged.load_forwarding_pointer env ^^
+         Tagged.(sanity_check_tag __LINE__ env (heap_tag env pty)) ^^
+         Tagged.load_field env payload_field)
+    )
+end (* BoxedWord64 *)
+
+module Word64 = struct
+
+  let compile_add env = G.i (Binary (Wasm_exts.Values.I64 I64Op.Add))
+  let compile_signed_sub env = G.i (Binary (Wasm_exts.Values.I64 I64Op.Sub))
+  let compile_mul env = G.i (Binary (Wasm_exts.Values.I64 I64Op.Mul))
+  let compile_signed_div env = G.i (Binary (Wasm_exts.Values.I64 I64Op.DivS))
+  let compile_signed_mod env = G.i (Binary (Wasm_exts.Values.I64 I64Op.RemS))
+  let compile_unsigned_div env = G.i (Binary (Wasm_exts.Values.I64 I64Op.DivU))
+  let compile_unsigned_rem env = G.i (Binary (Wasm_exts.Values.I64 I64Op.RemU))
+  let compile_unsigned_sub env =
+    Func.share_code2 Func.Never env "nat_sub" (("n1", I64Type), ("n2", I64Type)) [I64Type] (fun env get_n1 get_n2 ->
+      get_n1 ^^ get_n2 ^^ compile_comparison I64Op.LtU ^^
+      E.then_trap_with env "Natural subtraction underflow" ^^
+      get_n1 ^^ get_n2 ^^ G.i (Binary (Wasm_exts.Values.I64 I64Op.Sub))
+    )
+
+  let compile_unsigned_pow env =
+    let name = prim_fun_name Type.Nat64 "wpow_nat" in
+    Func.share_code2 Func.Always env name (("n", I64Type), ("exp", I64Type)) [I64Type]
+      (fun env get_n get_exp ->
+        let set_n = G.setter_for get_n in
+        let set_exp = G.setter_for get_exp in
+        let (set_acc, get_acc) = new_local env "acc" in
+
+        (* start with result = 1 *)
+        compile_unboxed_const 1L ^^ set_acc ^^
+
+        (* handle exp == 0 *)
+        get_exp ^^ compile_test I64Op.Eqz ^^
+        E.if1 I64Type get_acc (* done *)
+        begin
+          G.loop0 begin
+            (* Are we done? *)
+            get_exp ^^ compile_unboxed_const 1L ^^ compile_comparison I64Op.LeU ^^
+            E.if0 G.nop (* done *)
+            begin
+              (* Check low bit of exp to see if we need to multiply *)
+              get_exp ^^ compile_shl_const 63L ^^ compile_test I64Op.Eqz ^^
+              E.if0 G.nop
+              begin
+                (* Multiply! *)
+                get_acc ^^ get_n ^^ G.i (Binary (Wasm_exts.Values.I64 I64Op.Mul)) ^^ set_acc
+              end ^^
+              (* Square n, and shift exponent *)
+              get_n ^^ get_n ^^ G.i (Binary (Wasm_exts.Values.I64 I64Op.Mul)) ^^ set_n ^^
+              get_exp ^^ compile_shrU_const 1L ^^ set_exp ^^
+              (* And loop *)
+              G.i (Br (nr 1l))
+            end
+          end ^^
+          (* Multiply a last time *)
+          get_acc ^^ get_n ^^ G.i (Binary (Wasm_exts.Values.I64 I64Op.Mul))
+        end
+      )
+
+
+  let compile_signed_wpow env =
+    Func.share_code2 Func.Never env "wrap_pow_Int64" (("n", I64Type), ("exp", I64Type)) [I64Type]
+      (fun env get_n get_exp ->
+        get_exp ^^
+        compile_unboxed_const 0L ^^
+        compile_comparison I64Op.GeS ^^
+        E.else_trap_with env "negative power" ^^
+        get_n ^^ get_exp ^^ compile_unsigned_pow env
+      )
+
+  let _compile_eq env = compile_comparison I64Op.Eq
+  let compile_relop env i64op = compile_comparison i64op
+
+  let btst_kernel env =
+    let (set_b, get_b) = new_local env "b" in
+    set_b ^^ compile_unboxed_const 1L ^^ get_b ^^ G.i (Binary (Wasm_exts.Values.I64 I64Op.Shl)) ^^
+    G.i (Binary (Wasm_exts.Values.I64 I64Op.And))
+
+end (* BoxedWord64 *)
+
+module TaggedSmallWord = struct
+  (* While smaller-than-64bit words are treated as i64 from the WebAssembly
+     perspective, there are certain differences that are type based. This module
+     provides helpers to abstract over those.
+
+     Caution: Some functions here are also used for unboxed Nat64/Int64, while others
+     are _only_ used for the small ones. Check call-sites!
+  *)
+
+  let toNat = Type.(function
+    | Int8 | Nat8 -> Nat8
+    | Int16 | Nat16 -> Nat16
+    | Int32 | Nat32 -> Nat32
+    | Int64 | Nat64 -> Nat64
+    | _ -> assert false)
+
+  let bits_of_type = Type.(function
+    | Int8 | Nat8 -> 8
+    | Int16 | Nat16 -> 16
+    | Char -> 21
+    | Nat32 | Int32 -> 32
+    (* unboxed on stack *)
+    | Nat64 | Int64 -> 64
+    | _  -> assert false)
+
+  let tag_of_type pty = Type.(match pty with
+    | Int8 | Nat8
+    | Int16 | Nat16
+    | Int32 | Nat32
+    | Char ->
+      TaggingScheme.tag_of_typ pty
+    (* unboxed on stack *)
+    | Int64 | Nat64 -> 0L
+    | _ -> assert false)
+
+  let shift_of_type ty = Int64.of_int (64 - bits_of_type ty)
+
+  let bitwidth_mask_of_type = function
+    | Type.(Int8|Nat8) -> 0b111L
+    | Type.(Int16|Nat16) -> 0b1111L
+    | Type.(Int32|Nat32) -> 0b11111L
+    | p -> todo "bitwidth_mask_of_type" (Arrange_type.prim p) 0L
+
+  let const_of_type ty n = Int64.(shift_left n (to_int (shift_of_type ty)))
+
+  let padding_of_type ty = Int64.(sub (const_of_type ty 1L) one)
+
+  let mask_of_type ty = Int64.lognot (padding_of_type ty)
+
+  (* Makes sure that we only shift/rotate the maximum number of bits available in the word. *)
+  let clamp_shift_amount = function
+    | Type.(Nat64|Int64) -> G.nop
+    | ty -> compile_bitand_const (bitwidth_mask_of_type ty)
+
+  let shift_leftWordNtoI64 = compile_shl_const
+
+  (* Makes sure that the word payload (e.g. shift/rotate amount) is in the LSB bits of the word. *)
+  let lsb_adjust = function
+    | Type.(Int64|Nat64) -> G.nop
+    | Type.(Nat8|Nat16|Nat32) as ty -> compile_shrU_const (shift_of_type ty)
+    | Type.(Int8|Int16|Int32) as ty -> compile_shrS_const (shift_of_type ty)
+    | Type.Char as ty -> compile_shrU_const (shift_of_type ty)
+    | _ -> assert false
+
+  (* Makes sure that the word payload (e.g. operation result) is in the MSB bits of the word. *)
+  let msb_adjust = function
+    | Type.(Int64|Nat64) -> G.nop
+    | ty -> shift_leftWordNtoI64 (shift_of_type ty)
+
+  (* Makes sure that the word representation invariant is restored. *)
+  let sanitize_word_result = function
+    | Type.(Nat64|Int64) -> G.nop
+    | ty -> compile_bitand_const (mask_of_type ty)
+
+  (* Sets the number (according to the type's word invariant) of LSBs. *)
+  let compile_word_padding = function
+    | Type.(Nat64|Int64) -> G.nop
+    | ty -> compile_bitor_const (padding_of_type ty)
+
+  (* Kernel for counting leading zeros, according to the word invariant. *)
+  let clz_kernel ty =
+    compile_word_padding ty ^^
+    G.i (Unary (Wasm_exts.Values.I64 I64Op.Clz)) ^^
+    msb_adjust ty
+
+  (* Kernel for counting trailing zeros, according to the word invariant. *)
+  let ctz_kernel ty =
+    compile_word_padding ty ^^
+    compile_rotr_const (shift_of_type ty) ^^
+    G.i (Unary (Wasm_exts.Values.I64 I64Op.Ctz)) ^^
+    msb_adjust ty
+
+  (* Kernel for testing a bit position, according to the word invariant. *)
+  let btst_kernel env ty =
+    let (set_b, get_b) = new_local env "b"
+    in lsb_adjust ty ^^ set_b ^^ lsb_adjust ty ^^
+       compile_unboxed_one ^^ get_b ^^ clamp_shift_amount ty ^^
+       G.i (Binary (Wasm_exts.Values.I64 I64Op.Shl)) ^^
+       G.i (Binary (Wasm_exts.Values.I64 I64Op.And)) ^^
+       msb_adjust ty
+
+  (* Code points occupy 21 bits, so can always be tagged scalars *)
+  let lsb_adjust_codepoint env = lsb_adjust Type.Char
+  let msb_adjust_codepoint = msb_adjust Type.Char
+
+  (* Checks (n < 0xD800 || 0xE000 ≤ n ≤ 0x10FFFF),
+     ensuring the codepoint range and the absence of surrogates. *)
+  let check_and_msb_adjust_codepoint env =
+    Func.share_code1 Func.Always env "Nat32->Char" ("n", I64Type) [I64Type] (fun env get_n ->
+      get_n ^^ compile_unboxed_const 0xD800L ^^
+      compile_comparison I64Op.GeU ^^
+      get_n ^^ compile_unboxed_const 0xE000L ^^
+      compile_comparison I64Op.LtU ^^
+      G.i (Binary (Wasm_exts.Values.I64 I64Op.And)) ^^
+      get_n ^^ compile_unboxed_const 0x10FFFFL ^^
+      compile_comparison I64Op.GtU ^^
+      G.i (Binary (Wasm_exts.Values.I64 I64Op.Or)) ^^
+      E.then_trap_with env "codepoint out of range" ^^
+      get_n ^^ msb_adjust_codepoint
+    )
+
+  let vanilla_lit ty v =
+    Int64.(shift_left (of_int v) (to_int (shift_of_type ty)))
+    |> Int64.logor (tag_of_type ty)
+
+  (* Wrapping implementation for multiplication and exponentiation. *)
+
+  let compile_word_mul env ty =
+    lsb_adjust ty ^^
+    G.i (Binary (Wasm_exts.Values.I64 I64Op.Mul))
+
+  let compile_nat_power env ty =
+    let name = prim_fun_name ty "wpow_nat" in
+    (* Square- and multiply exponentiation *)
+    Func.share_code2 Func.Always env name (("n", I64Type), ("exp", I64Type)) [I64Type]
+      (fun env get_n get_exp ->
+        let set_n = G.setter_for get_n in
+        let set_exp = G.setter_for get_exp in
+        let (set_acc, get_acc) = new_local env "acc" in
+
+        (* unshift arguments *)
+        get_exp ^^ compile_shrU_const (shift_of_type ty) ^^ set_exp ^^
+        get_n ^^ compile_shrU_const (shift_of_type ty) ^^ set_n ^^
+
+        (* The accumulator starts with and stays shifted, so no other shifts needed. *)
+        compile_unboxed_const (const_of_type ty 1L) ^^ set_acc ^^
+
+        (* handle exp == 0 *)
+        get_exp ^^ compile_test I64Op.Eqz ^^
+        E.if1 I64Type get_acc (* done *)
+        begin
+          G.loop0 begin
+            (* Are we done? *)
+            get_exp ^^ compile_unboxed_const 1L ^^ compile_comparison I64Op.LeU ^^
+            E.if0 G.nop (* done *)
+            begin
+              (* Check low bit of exp to see if we need to multiply *)
+              get_exp ^^ compile_shl_const 63L ^^ compile_test I64Op.Eqz ^^
+              E.if0 G.nop
+              begin
+                (* Multiply! *)
+                get_acc ^^ get_n ^^ G.i (Binary (Wasm_exts.Values.I64 I64Op.Mul)) ^^ set_acc
+              end ^^
+              (* Square n, and shift exponent *)
+              get_n ^^ get_n ^^ G.i (Binary (Wasm_exts.Values.I64 I64Op.Mul)) ^^ set_n ^^
+              get_exp ^^ compile_shrU_const 1L ^^ set_exp ^^
+              (* And loop *)
+              G.i (Br (nr 1l))
+            end
+          end ^^
+          (* Multiply a last time *)
+          get_acc ^^ get_n ^^ G.i (Binary (Wasm_exts.Values.I64 I64Op.Mul))
+          (* Accumulator was shifted, so no further shift needed here *)
+        end
+      )
+
+  let compile_int_power env ty =
+    let name = prim_fun_name ty "wpow_int" in
+    Func.share_code2 Func.Never env name (("n", I64Type), ("exp", I64Type)) [I64Type]
+      (fun env get_n get_exp ->
+        get_exp ^^
+        compile_unboxed_const 0L ^^
+        compile_comparison I64Op.GeS ^^
+        E.else_trap_with env "negative power" ^^
+        get_n ^^ get_exp ^^ compile_nat_power env (toNat ty))
+
+  (* To rotate, first rotate a copy by bits_of_type into the other direction *)
+  let rotl env ty =
+     Func.share_code2 Func.Never env (prim_fun_name ty "rotl") (("n", I64Type), ("by", I64Type)) [I64Type]
+       (fun env get_n get_by ->
+        let open Wasm_exts.Values in
+        let beside_adjust = compile_rotr_const (Int64.of_int (bits_of_type ty)) in
+        get_n ^^ get_n ^^ beside_adjust ^^ G.i (Binary (I64 I64Op.Or)) ^^
+        get_by ^^ lsb_adjust ty ^^ clamp_shift_amount ty ^^ G.i (Binary (I64 I64Op.Rotl)) ^^
+        sanitize_word_result ty
+       )
+
+  let rotr env ty =
+     Func.share_code2 Func.Never env (prim_fun_name ty "rotr") (("n", I64Type), ("by", I64Type)) [I64Type]
+       (fun env get_n get_by ->
+        let open Wasm_exts.Values in
+        let beside_adjust = compile_rotl_const (Int64.of_int (bits_of_type ty)) in
+        get_n ^^ get_n ^^ beside_adjust ^^ G.i (Binary (I64 I64Op.Or)) ^^
+        get_by ^^ lsb_adjust ty ^^ clamp_shift_amount ty ^^ G.i (Binary (I64 I64Op.Rotr)) ^^
+        sanitize_word_result ty
+       )
+
+  let tag env pty =
+    match pty with
+    | Type.(Nat8 | Int8 | Nat16 | Int16 | Nat32 | Int32 | Char) ->
+      (* TODO:  could sanity check low bits clear *)
+      (* add tag *)
+      compile_bitor_const (tag_of_type pty)
+    | _ -> assert false
+
+  let untag env pty =
+    match pty with
+    | Type.(Nat8 | Int8 | Nat16 | Int16 | Nat32 | Int32 | Char) ->
+       (* check tag *)
+       BitTagged.sanity_check_tag __LINE__ env pty ^^
+       (* clear tag *)
+       BitTagged.clear_tag env pty
+    | _ -> assert false
+
+end (* TaggedSmallWord *)
+
+
+module Float = struct
+  (* We store floats (C doubles) in immutable boxed 64bit heap objects.
+
+     The heap layout of a Float is:
+
+       ┌──────┬─────┬─────┐
+       │ obj header │ f64 │
+       └──────┴─────┴─────┘
+
+     For now the tag stored is that of a Bits64, because the payload is
+     treated opaquely by the RTS. We'll introduce a separate tag when the need of
+     debug inspection (or GC representation change) arises.
+
+     The object header includes the object tag (Bits64) and the forwarding pointer.
+  *)
+
+  let payload_field = Tagged.header_size
+
+  let compile_unboxed_const f = G.i (Const (nr (Wasm_exts.Values.F64 f)))
+
+  let box env = Func.share_code1 Func.Never env "box_f64" ("f", F64Type) [I64Type] (fun env get_f ->
+    let (set_i, get_i) = new_local env "boxed_f64" in
+    let size = Int64.add Tagged.header_size 2L in
+    Tagged.alloc env size Tagged.(Bits64 F) ^^
+    set_i ^^
+    get_i ^^ get_f ^^ Tagged.store_field_float64 env payload_field ^^
+    get_i ^^
+    Tagged.allocation_barrier env
+  )
+
+  let unbox env = 
+    Tagged.load_forwarding_pointer env ^^ 
+    Tagged.(sanity_check_tag __LINE__ env (Bits64 F)) ^^
+    Tagged.load_field_float64 env payload_field
+
+  let constant env f = Tagged.shared_object env (fun env -> 
+    compile_unboxed_const f ^^ 
+    box env)
+
+end (* Float *)
+
+
+module ReadBuf = struct
+  (*
+  Combinators to safely read from a dynamic buffer.
+
+  We represent a buffer by a pointer to two words in memory (usually allocated
+  on the shadow stack): The first is a pointer to the current position of the buffer,
+  the second one a pointer to the end (to check out-of-bounds).
+
+  Code that reads from this buffer will update the former, i.e. it is mutable.
+
+  The format is compatible with C (pointer to a struct) and avoids the need for the
+  multi-value extension that we used before to return both parse result _and_
+  updated pointer.
+
+  All pointers here are unskewed!
+
+  This module is mostly for serialization, but because there are bits of
+  serialization code in the BigNumType implementations, we put it here.
+  *)
+
+  let get_ptr get_buf =
+    get_buf ^^ G.i (Load {ty = I64Type; align = 3; offset = 0L; sz = None})
+  let get_end get_buf =
+    get_buf ^^ G.i (Load {ty = I64Type; align = 3; offset = Heap.word_size; sz = None})
+  let set_ptr get_buf new_val =
+    get_buf ^^ new_val ^^ G.i (Store {ty = I64Type; align = 3; offset = 0L; sz = None})
+  let set_end get_buf new_val =
+    get_buf ^^ new_val ^^ G.i (Store {ty = I64Type; align = 3; offset = Heap.word_size; sz = None})
+  let set_size get_buf get_size =
+    set_end get_buf
+      (get_ptr get_buf ^^ get_size ^^ G.i (Binary (Wasm_exts.Values.I64 I64Op.Add)))
+
+  let alloc env f = Stack.with_words env "buf" 2L f
+
+  let advance get_buf get_delta =
+    set_ptr get_buf (get_ptr get_buf ^^ get_delta ^^ G.i (Binary (Wasm_exts.Values.I64 I64Op.Add)))
+
+  let read_leb128 env get_buf =
+    get_buf ^^ E.call_import env "rts" "leb128_decode"
+
+  let read_sleb128 env get_buf =
+    get_buf ^^ E.call_import env "rts" "sleb128_decode"
+
+  let check_space env get_buf get_delta =
+    get_delta ^^
+    get_end get_buf ^^ get_ptr get_buf ^^ G.i (Binary (Wasm_exts.Values.I64 I64Op.Sub)) ^^
+    compile_comparison I64Op.LeU ^^
+    E.else_trap_with env "IDL error: out of bounds read"
+
+  let check_page_end env get_buf incr_delta =
+    get_ptr get_buf ^^ compile_bitand_const 0xFFFFL ^^
+    incr_delta ^^
+    compile_shrU_const 16L
+
+  let is_empty env get_buf =
+    get_end get_buf ^^ get_ptr get_buf ^^
+    compile_comparison I64Op.Eq
+
+  let read_byte env get_buf =
+    check_space env get_buf (compile_unboxed_const 1L) ^^
+    get_ptr get_buf ^^
+    G.i (Load {ty = I32Type; align = 0; offset = 0L; sz = Some Wasm_exts.Types.(Pack8, ZX)}) ^^
+    G.i (Convert (Wasm_exts.Values.I64 I64Op.ExtendUI32)) ^^
+    advance get_buf (compile_unboxed_const 1L)
+
+  let read_word16 env get_buf =
+    check_space env get_buf (compile_unboxed_const 2L) ^^
+    get_ptr get_buf ^^
+    G.i (Load {ty = I32Type; align = 0; offset = 0L; sz = Some Wasm_exts.Types.(Pack16, ZX)}) ^^
+    G.i (Convert (Wasm_exts.Values.I64 I64Op.ExtendUI32)) ^^
+    advance get_buf (compile_unboxed_const 2L)
+
+  let read_word32 env get_buf =
+    check_space env get_buf (compile_unboxed_const 4L) ^^
+    get_ptr get_buf ^^
+    G.i (Load {ty = I32Type; align = 0; offset = 0L; sz = None}) ^^
+    G.i (Convert (Wasm_exts.Values.I64 I64Op.ExtendUI32)) ^^
+    advance get_buf (compile_unboxed_const 4L)
+
+  let read_signed_word32 env get_buf =
+    check_space env get_buf (compile_unboxed_const 4L) ^^
+    get_ptr get_buf ^^
+    G.i (Load {ty = I32Type; align = 0; offset = 0L; sz = None}) ^^
+    G.i (Convert (Wasm_exts.Values.I64 I64Op.ExtendSI32)) ^^
+    advance get_buf (compile_unboxed_const 4L)
+
+  let speculative_read_word64 env get_buf =
+    check_page_end env get_buf (compile_add_const 8L) ^^
+    E.if1 I64Type
+      (compile_unboxed_const (-1L))
+      begin
+        get_ptr get_buf ^^
+        G.i (Load {ty = I64Type; align = 0; offset = 0L; sz = None})
+      end
+
+  let read_word64 env get_buf =
+    check_space env get_buf (compile_unboxed_const 8L) ^^
+    get_ptr get_buf ^^
+    G.i (Load {ty = I64Type; align = 0; offset = 0L; sz = None}) ^^
+    advance get_buf (compile_unboxed_const 8L)
+
+  let read_float64 env get_buf =
+    check_space env get_buf (compile_unboxed_const 8L) ^^
+    get_ptr get_buf ^^
+    G.i (Load {ty = F64Type; align = 0; offset = 0L; sz = None}) ^^
+    advance get_buf (compile_unboxed_const 8L)
+
+  let read_blob env get_buf get_len =
+    check_space env get_buf get_len ^^
+    (* Already has destination address on the stack *)
+    get_ptr get_buf ^^
+    get_len ^^
+    Heap.memcpy env ^^
+    advance get_buf get_len
+
+end (* Buf *)
+
+
+type comparator = Lt | Le | Ge | Gt
+
+module type BigNumType =
+sig
+  (* word from SR.Vanilla, trapping, unsigned semantics *)
+  val to_word64 : E.t -> G.t
+  val to_word64_with : E.t -> G.t -> G.t (* with error message on stack (ptr/len) *)
+
+  (* word from SR.Vanilla, lossy, raw bits *)
+  val truncate_to_word32 : E.t -> G.t
+  val truncate_to_word64 : E.t -> G.t
+
+  (* unsigned word to SR.Vanilla *)
+  val from_word64 : E.t -> G.t
+
+  (* signed word to SR.Vanilla *)
+  val from_signed_word_compact : E.t -> G.t
+  val from_signed_word64 : E.t -> G.t
+
+  (* buffers *)
+  (* given a numeric object on stack (vanilla),
+     push the number (i64) of bytes necessary
+     to externalize the numeric object *)
+  val compile_data_size_signed : E.t -> G.t
+  val compile_data_size_unsigned : E.t -> G.t
+  (* given on stack
+     - numeric object (vanilla, TOS)
+     - data buffer
+    store the binary representation of the numeric object into the data buffer,
+    and push the number (i64) of bytes stored onto the stack
+   *)
+  val compile_store_to_data_buf_signed : E.t -> G.t
+  val compile_store_to_data_buf_unsigned : E.t -> G.t
+  (* given a ReadBuf on stack, consume bytes from it,
+     deserializing to a numeric object
+     and leave it on the stack (vanilla).
+     The boolean argument is true if the value to be read is signed.
+   *)
+  val compile_load_from_data_buf : E.t -> G.t -> bool -> G.t
+
+  (* constant *)
+  val constant : E.t -> Big_int.big_int -> E.shared_value
+
+  (* arithmetic *)
+  val compile_abs : E.t -> G.t
+  val compile_neg : E.t -> G.t
+  val compile_add : E.t -> G.t
+  val compile_signed_sub : E.t -> G.t
+  val compile_unsigned_sub : E.t -> G.t
+  val compile_mul : E.t -> G.t
+  val compile_signed_div : E.t -> G.t
+  val compile_signed_mod : E.t -> G.t
+  val compile_unsigned_div : E.t -> G.t
+  val compile_unsigned_rem : E.t -> G.t
+  val compile_unsigned_pow : E.t -> G.t
+  val compile_lsh : E.t -> G.t
+  val compile_rsh : E.t -> G.t
+
+  (* comparisons *)
+  val compile_eq : E.t -> G.t
+  val compile_is_negative : E.t -> G.t
+  val compile_relop : E.t -> comparator -> G.t
+
+  (* representation checks *)
+  (* given a numeric object on the stack as skewed pointer, check whether
+     it can be faithfully stored in N bits, including a leading sign bit
+     leaves boolean result on the stack
+     N must be 2..64
+   *)
+  val fits_signed_bits : E.t -> int -> G.t
+  (* given a numeric object on the stack as skewed pointer, check whether
+     it can be faithfully stored in N unsigned bits
+     leaves boolean result on the stack
+     N must be 1..64
+   *)
+  val fits_unsigned_bits : E.t -> int -> G.t
+end
+
+let i64op_from_relop = function
+  | Lt -> I64Op.LtS
+  | Le -> I64Op.LeS
+  | Ge -> I64Op.GeS
+  | Gt -> I64Op.GtS
+
+let name_from_relop = function
+  | Lt -> "B_lt"
+  | Le -> "B_le"
+  | Ge -> "B_ge"
+  | Gt -> "B_gt"
+
+(* helper, measures the dynamics of the unsigned i64, returns (64 - effective bits) *)
+let unsigned_dynamics get_x =
+  get_x ^^
+  G.i (Unary (Wasm_exts.Values.I64 I64Op.Clz))
+
+(* helper, measures the dynamics of the signed i64, returns (64 - effective bits) *)
+let signed_dynamics get_x =
+  get_x ^^ compile_shl_const 1L ^^
+  get_x ^^
+  G.i (Binary (Wasm_exts.Values.I64 I64Op.Xor)) ^^
+  G.i (Unary (Wasm_exts.Values.I64 I64Op.Clz))
+
+module I32Leb = struct
+  let compile_size dynamics get_x =
+    get_x ^^ Bool.from_int64 ^^
+    E.if1 I64Type
+      begin
+        (* Add (7-1) to prepare division by 7 that is rounded up *)
+        compile_unboxed_const (Int64.of_int (Int.add 64 (Int.sub 7 1))) ^^
+        dynamics get_x ^^
+        G.i (Binary (Wasm_exts.Values.I64 I64Op.Sub)) ^^
+        compile_divU_const 7L
+      end
+      (compile_unboxed_const 1L)
+
+  let compile_leb128_size get_x = compile_size unsigned_dynamics get_x
+  let compile_sleb128_size get_x = compile_size signed_dynamics get_x
+
+  let compile_store_to_data_buf_unsigned env get_x get_buf =
+    get_x ^^ get_buf ^^ 
+    E.call_import env "rts" "leb128_encode" ^^
+    compile_leb128_size get_x
+
+  let compile_store_to_data_buf_signed env get_x get_buf =
+    get_x ^^ get_buf ^^ 
+    E.call_import env "rts" "sleb128_encode" ^^
+    compile_sleb128_size get_x
+end
+
+module MakeCompact (Num : BigNumType) : BigNumType = struct
+
+  (* Compact BigNums are a representation of signed BitTagged.ubit-bignums (of the
+     underlying boxed representation `Num`), that fit into an i64 as per the
+     BitTagged representation.
+
+     Many arithmetic operations can be be performed on this right-zero-padded
+     representation directly. For some operations (e.g. multiplication) the
+     second argument needs to be furthermore right-shifted to avoid overflow.
+     Similarly, for division the result must be left-shifted.
+
+     Generally all operations begin with checking whether both arguments are
+     already tagged scalars. If so, the arithmetic can be performed in machine
+     registers (fast path). Otherwise one or both arguments need boxing and the
+     arithmetic needs to be carried out on the underlying boxed bignum
+     representation (slow path).
+
+     The result appears as a boxed number in the latter case, so a check is
+     performed if it can be a tagged scalar. Conversely in the former case the
+     64-bit result can either be a tagged scalar or needs to be boxed.
+
+     Manipulation of the result is unnecessary for the comparison predicates.
+
+     For the `pow` operation the check that both arguments are tagged scalars
+     is not sufficient. Here we count and multiply effective bitwidths to
+     figure out whether the operation will overflow 64 bits, and if so, we fall
+     back to the slow path.
+   *)
+
+  (* TODO: There is some unnecessary result shifting when the div result needs
+     to be boxed. Is this possible at all to happen? With (/-1) maybe! *)
+
+  (* TODO: Does the result of the rem/mod fast path ever needs boxing? *)
+
+  (* examine the skewed pointer and determine if number fits into ubits *)
+  let fits_in_vanilla env = Num.fits_signed_bits env (BitTagged.ubits_of Type.Int)
+
+  let clear_tag env = BitTagged.clear_tag env Type.Int
+
+  (* A variant of BitTagged.can_tag that works on signed i64 *)
+  let if_can_tag env retty is1 is2 =
+    let ubitsL = Int64.of_int(BitTagged.ubits_of Type.Int) in
+    compile_shrS_const (Int64.sub 64L ubitsL) ^^ BitTagged.if_can_tag_signed env Type.Int retty is1 is2
+
+  let apply_tag env =
+    compile_bitor_const (TaggingScheme.tag_of_typ Type.Int)
+
+  let can_use_fath_path env get_a get_b =
+    (* Check whether both arguments `a` and `b` are scalars that fit within 32 bit.
+        This is to guarantee overflow-free 64-bit arithmetics, such as `add`, `sub`, or `mul`.
+        However, this does not work for `pow` as it can overflow for smaller arguments. *)
+    (* check with a combined bit mask that:
+       - (and `0x1`) Both arguments are scalars, none a skewed pointers
+       - (and `0xFFFF_FFFF_0000_0000`) Both arguments fit in 32-bit
+    TODO: Precise tag for Int has 2 bits -> 
+       Check if we could permit one or two more bits in the `0xFFFF_FFFF_0000_0000` bit mask. *)
+    get_a ^^ get_b ^^
+    G.i (Binary (Wasm_exts.Values.I64 I64Op.Or)) ^^
+    compile_bitand_const 0xFFFF_FFFF_0000_0001L ^^
+    compile_eq_const 0x0L
+    
+  (* creates a boxed bignum from a signed i64 *)
+  let box env =
+    let ubitsL = Int64.of_int(BitTagged.ubits_of Type.Int) in
+    compile_shrS_const (Int64.sub 64L ubitsL) ^^ Num.from_signed_word64 env
+
+  (* check if both arguments are tagged scalars,
+     if so, perform the fast path.
+     Otherwise make sure that both arguments are in heap representation,
+     and run the slow path on them.
+     In both cases bring the results into normal form.
+   *)
+  let try_unbox2 name fast slow env =
+    Func.share_code2 Func.Always env name (("a", I64Type), ("b", I64Type)) [I64Type]
+      (fun env get_a get_b ->
+        let set_res, get_res = new_local env "res" in
+        can_use_fath_path env get_a get_b ^^
+        E.if1 I64Type
+          begin
+            get_a ^^ clear_tag env ^^
+            get_b ^^ clear_tag env ^^
+            fast env ^^ set_res ^^
+            get_res ^^
+            if_can_tag env [I64Type]
+              (get_res ^^ apply_tag env)
+              (get_res ^^ box env)
+          end
+          begin
+            get_a ^^ BitTagged.if_tagged_scalar env [I64Type]
+              (get_a ^^ box env)
+              get_a ^^
+            get_b ^^ BitTagged.if_tagged_scalar env [I64Type]
+              (get_b ^^ box env)
+              get_b ^^
+            slow env ^^ set_res ^^ get_res ^^
+            fits_in_vanilla env ^^
+            E.if1 I64Type
+              (get_res ^^ Num.truncate_to_word64 env ^^ BitTagged.tag env Type.Int)
+              get_res
+          end
+      )
+
+  let compile_add = try_unbox2 "B_add" Word64.compile_add Num.compile_add
+
+  let adjust_arg2 code env =
+    compile_shrS_const (Int64.of_int (64 - BitTagged.ubits_of Type.Int)) ^^
+    code env (* TBR *)
+  let adjust_result code env =
+    code env ^^
+    compile_shl_const (Int64.of_int (64 - BitTagged.ubits_of Type.Int))
+
+  let compile_mul = try_unbox2 "B_mul" (adjust_arg2 Word64.compile_mul) Num.compile_mul
+  let compile_signed_sub = try_unbox2 "B+sub" Word64.compile_signed_sub Num.compile_signed_sub
+  let compile_signed_div = try_unbox2 "B+div" (adjust_result Word64.compile_signed_div) Num.compile_signed_div
+  let compile_signed_mod = try_unbox2 "B_mod" Word64.compile_signed_mod Num.compile_signed_mod
+  let compile_unsigned_div = try_unbox2 "B_div" (adjust_result Word64.compile_unsigned_div) Num.compile_unsigned_div
+  let compile_unsigned_rem = try_unbox2 "B_rem" Word64.compile_unsigned_rem Num.compile_unsigned_rem
+  let compile_unsigned_sub = try_unbox2 "B_sub" Word64.compile_unsigned_sub Num.compile_unsigned_sub
+
+  let compile_unsigned_pow env =
+    Func.share_code2 Func.Always env "B_pow" (("a", I64Type), ("b", I64Type)) [I64Type]
+    (fun env get_a get_b ->
+    let set_res, get_res = new_local env "res" in
+    get_a ^^ get_b ^^
+    BitTagged.if_both_tagged_scalar env [I64Type]
+      begin
+        let set_a = G.setter_for get_a in
+        let set_b = G.setter_for get_b in
+        (* Convert to plain Word64 *)
+        get_a ^^ BitTagged.untag __LINE__ env Type.Int ^^ set_a ^^
+        get_b ^^ BitTagged.untag __LINE__ env Type.Int ^^ set_b ^^
+
+        get_a ^^ Num.from_signed_word64 env ^^
+        get_b ^^ Num.from_signed_word64 env ^^
+        Num.compile_unsigned_pow env ^^ set_res ^^
+        get_res ^^ fits_in_vanilla env ^^
+        E.if1 I64Type
+          (get_res ^^ Num.truncate_to_word64 env ^^ BitTagged.tag env Type.Int)
+          get_res
+      end
+      begin
+        get_a ^^ BitTagged.if_tagged_scalar env [I64Type]
+          (get_a ^^ box env)
+          get_a ^^
+        get_b ^^ BitTagged.if_tagged_scalar env [I64Type]
+          (get_b ^^ box env)
+          get_b ^^
+        Num.compile_unsigned_pow env ^^ set_res ^^
+        get_res ^^ fits_in_vanilla env ^^
+        E.if1 I64Type
+          (get_res ^^ Num.truncate_to_word64 env ^^ BitTagged.tag env Type.Int)
+          get_res
+      end)
+
+  (*
+    Note [left shifting compact Nat]
+    For compact Nats with a number fitting in 32 bits (in scalar value representation) and a shift amount of 
+    less or equal 32, we perform a fast shift. Otherwise, the bignum shift via RTS is applied.
+   *)
+  let compile_lsh env =
+    Func.share_code2 Func.Always env "B_lsh" (("n", I64Type), ("amount", I64Type)) [I64Type]
+    (fun env get_n get_amount ->
+      let set_n = G.setter_for get_n in
+      get_amount ^^ TaggedSmallWord.lsb_adjust Type.Nat32 ^^ G.setter_for get_amount ^^
+      get_n ^^
+      BitTagged.if_tagged_scalar env [I64Type]
+      begin
+        (* see Note [left shifting compact Nat] *)
+        get_n ^^ BitTagged.untag __LINE__ env Type.Int ^^ set_n ^^
+        get_n ^^
+        compile_bitand_const 0xFFFF_FFFF_0000_0000L ^^
+        compile_eq_const 0L ^^
+        get_amount ^^ compile_rel_const I64Op.LeU 32L ^^
+        G.i (Binary (Wasm_exts.Values.I64 I64Op.And)) ^^
+        E.if1 I64Type
+        begin
+          get_n ^^ 
+          get_amount ^^ 
+          G.i (Binary (Wasm_exts.Values.I64 I64Op.Shl)) ^^
+          BitTagged.tag env Type.Int
+        end
+        begin
+          get_n ^^ Num.from_word64 env ^^ 
+          get_amount ^^ 
+          Num.compile_lsh env
+        end
+      end
+      begin
+        get_n ^^ get_amount ^^ Num.compile_lsh env
+      end)
+
+  let compile_rsh env =
+    Func.share_code2 Func.Always env "B_rsh" (("n", I64Type), ("amount", I64Type)) [I64Type]
+    (fun env get_n get_amount ->
+      get_amount ^^ TaggedSmallWord.lsb_adjust Type.Nat32 ^^ G.setter_for get_amount ^^
+      get_n ^^
+      BitTagged.if_tagged_scalar env [I64Type]
+        begin
+          get_n ^^ clear_tag env ^^
+          get_amount ^^
+          G.i (Binary (Wasm_exts.Values.I64 I64Op.ShrU)) ^^
+          compile_bitand_const Int64.(shift_left minus_one (64 - BitTagged.ubits_of Type.Int)) ^^
+          get_amount ^^ compile_rel_const I64Op.LeU (Int64.of_int (BitTagged.ubits_of Type.Int))^^
+          G.i (Binary (Wasm_exts.Values.I64 I64Op.Mul)) (* branch-free `if` *) ^^
+          (* tag *)
+          apply_tag env
+        end
+        begin
+          get_n ^^ get_amount ^^ Num.compile_rsh env ^^
+          let set_res, get_res = new_local env "res" in
+          set_res ^^ get_res ^^
+          fits_in_vanilla env ^^
+          E.if1 I64Type
+            (get_res ^^ Num.truncate_to_word64 env ^^ BitTagged.tag env Type.Int)
+            get_res
+        end)
+
+  let compile_is_negative env =
+    let set_n, get_n = new_local env "n" in
+    set_n ^^ get_n ^^
+    BitTagged.if_tagged_scalar env [I64Type]
+      (get_n ^^ clear_tag env ^^ compile_unboxed_const 0L ^^ compile_comparison I64Op.LtS)
+      (get_n ^^ Num.compile_is_negative env)
+
+  let constant env = function
+    | n when Big_int.is_int_big_int n && BitTagged.can_tag_const Type.Int (Big_int.int64_of_big_int n) ->
+      E.Vanilla (BitTagged.tag_const Type.Int (Big_int.int64_of_big_int n))
+    | n -> Num.constant env n
+
+  let compile_neg env =
+    let sminl = Int64.shift_left 1L (BitTagged.sbits_of Type.Int) in
+    let sminl_shifted = Int64.shift_left sminl (64 - BitTagged.ubits_of Type.Int) in
+    Func.share_code1 Func.Always env "B_neg" ("n", I64Type) [I64Type] (fun env get_n ->
+      get_n ^^ BitTagged.if_tagged_scalar env [I64Type]
+        begin
+          get_n ^^ clear_tag env ^^ compile_eq_const sminl_shifted ^^ (* -2^sbits, shifted ubits *)
+          E.if1 I64Type
+            (compile_unboxed_const sminl ^^ Num.from_word64 env)
+            begin
+              compile_unboxed_const 0L ^^
+              get_n ^^ clear_tag env ^^
+              G.i (Binary (Wasm_exts.Values.I64 I64Op.Sub)) ^^
+              (* tag the result *)
+              clear_tag env ^^
+              apply_tag env
+            end
+        end
+        (get_n ^^ Num.compile_neg env)
+    )
+
+  let try_comp_unbox2 name fast slow env =
+    Func.share_code2 Func.Always env name (("a", I64Type), ("b", I64Type)) [I64Type]
+      (fun env get_a get_b ->
+        get_a ^^ get_b ^^
+        BitTagged.if_both_tagged_scalar env [I64Type]
+          begin
+            get_a ^^ clear_tag env ^^
+            get_b ^^ clear_tag env ^^
+            fast env
+          end
+          begin
+            get_a ^^ BitTagged.if_tagged_scalar env [I64Type]
+              (get_a ^^ box env)
+              get_a ^^
+            get_b ^^ BitTagged.if_tagged_scalar env [I64Type]
+              (get_b ^^ box env)
+              get_b ^^
+            slow env
+          end)
+
+  let compile_eq env =
+    Func.share_code2 Func.Always env "B_eq" (("a", I64Type), ("b", I64Type)) [I64Type]
+      (fun env get_a get_b ->
+        get_a ^^ get_b ^^
+        compile_comparison I64Op.Eq ^^
+        E.if1 I64Type
+          (Bool.lit true)
+          (get_a ^^ get_b ^^
+           BitTagged.if_both_tagged_scalar env [I64Type]
+             (Bool.lit false)
+             begin
+               get_a ^^ BitTagged.if_tagged_scalar env [I64Type]
+                 (get_a ^^ box env)
+                 get_a ^^
+               get_b ^^ BitTagged.if_tagged_scalar env [I64Type]
+                 (get_b ^^ box env)
+                 get_b ^^
+               Num.compile_eq env
+             end))
+
+  let compile_relop env bigintop =
+    try_comp_unbox2 (name_from_relop bigintop)
+      (fun env' -> Word64.compile_relop env' (i64op_from_relop bigintop))
+      (fun env' -> Num.compile_relop env' bigintop)
+      env
+
+  let try_unbox iN fast slow env =
+    let set_a, get_a = new_local env "a" in
+    set_a ^^ get_a ^^
+    BitTagged.if_tagged_scalar env [iN]
+      (get_a ^^ fast env)
+      (get_a ^^ slow env)
+
+  let fits_unsigned_bits env n =
+    try_unbox I64Type (fun _ -> match n with
+        | 64 -> G.i Drop ^^ Bool.lit true
+        | 8 | 16 | 32 ->
+          (* use shifting to test that the payload including the tag fits the desired bit width. 
+              E.g. this is now n + 2 for Type.Int. *)
+          compile_bitand_const Int64.(shift_left minus_one (n + (64 - BitTagged.ubits_of Type.Int))) ^^
+          compile_test I64Op.Eqz
+        | _ -> assert false
+      )
+      (fun env -> Num.fits_unsigned_bits env n)
+      env
+
+  let sanity_check_fits_signed_bits env n get_a =
+     if TaggingScheme.debug || !Flags.sanity then
+     get_a ^^
+     Func.share_code2 Func.Always env ("check_fits_signed_bits_"^Int.to_string n) (("res", I64Type), ("a", I64Type)) [I64Type]
+      (fun env get_res get_a ->
+         let lower_bound = Int64.(neg (shift_left 1L (n-1))) in
+         let upper_bound = Int64.shift_left 1L (n-1) in
+         let set_a = G.setter_for get_a in
+         get_a ^^
+         compile_shrS_const (Int64.of_int (64 - BitTagged.ubits_of Type.Int)) ^^
+         set_a ^^
+         compile_unboxed_const lower_bound ^^
+         get_a ^^
+         compile_comparison I64Op.LeS ^^
+         get_a ^^ compile_unboxed_const upper_bound ^^
+         compile_comparison I64Op.LtS ^^
+         G.i (Binary (Wasm_exts.Values.I64 I64Op.And)) ^^
+         get_res ^^
+         compile_comparison I64Op.Eq ^^
+         E.else_trap_with env ("fit_signed_bits failure_"^Int.to_string n) ^^
+         get_res)
+     else G.nop
+
+  let fits_signed_bits env n =
+    let set_a, get_a = new_local env "a" in
+    try_unbox I64Type (fun _ -> match n with
+        | 64 -> G.i Drop ^^ Bool.lit true
+        | 8 | 16 | 32 ->
+           set_a ^^
+           get_a ^^ get_a ^^ compile_shrS_const 1L ^^
+           G.i (Binary (Wasm_exts.Values.I64 I64Op.Xor)) ^^
+           compile_bitand_const
+             Int64.(shift_left minus_one ((n-1) + (64 - BitTagged.ubits_of Type.Int))) ^^
+           compile_test I64Op.Eqz ^^
+           sanity_check_fits_signed_bits env n get_a
+        | _ -> assert false
+      )
+      (fun env -> Num.fits_signed_bits env n)
+      env
+
+  let compile_abs env =
+    let sminl = Int64.shift_left 1L (BitTagged.sbits_of Type.Int) in
+    let sminl_shifted = Int64.shift_left sminl (64 - BitTagged.ubits_of Type.Int) in
+    try_unbox I64Type
+      begin
+        fun _ ->
+        let set_a, get_a = new_local env "a" in
+        clear_tag env ^^
+        set_a ^^
+        get_a ^^ compile_unboxed_const 0L ^^ compile_comparison I64Op.LtS ^^
+        E.if1 I64Type
+          begin
+            get_a ^^
+            (* -2^sbits is small enough for compact representation, but 2^sbits isn't *)
+            compile_eq_const sminl_shifted ^^ (* i.e. -2^sbits shifted *)
+            E.if1 I64Type
+              (compile_unboxed_const sminl ^^ Num.from_word64 env)
+              begin
+                (* absolute value works directly on shifted representation *)
+                compile_unboxed_const 0L ^^
+                get_a ^^
+                G.i (Binary (Wasm_exts.Values.I64 I64Op.Sub)) ^^
+                apply_tag env
+              end
+          end
+          begin
+            get_a ^^
+            compile_bitor_const (TaggingScheme.tag_of_typ Type.Int)
+          end
+      end
+      Num.compile_abs
+      env
+
+  let compile_load_from_word64 env get_data_buf = function
+    | false -> get_data_buf ^^ E.call_import env "rts" "bigint_leb128_decode_word64"
+    | true -> get_data_buf ^^ E.call_import env "rts" "bigint_sleb128_decode_word64"
+
+  let compile_load_from_data_buf env get_data_buf signed =
+    (* see Note [speculating for short (S)LEB encoded bignums] *)
+    ReadBuf.speculative_read_word64 env get_data_buf ^^
+    let set_a, get_a = new_local env "a" in
+    set_a ^^ get_a ^^
+    compile_xor_const (-1L) ^^
+    compile_bitand_const 0x8080_8080_8080_8080L ^^
+    let set_eom, get_eom = new_local env "eom" in
+    set_eom ^^ get_eom ^^
+    compile_test I64Op.Eqz ^^
+    E.if1 I64Type
+      begin
+        Num.compile_load_from_data_buf env get_data_buf signed
+      end
+      begin
+        get_a ^^
+        get_eom ^^ G.i (Unary (Wasm_exts.Values.I64 I64Op.Ctz)) ^^
+        compile_load_from_word64 env get_data_buf signed
+      end
+
+  let compile_store_to_data_buf_unsigned env =
+    let set_x, get_x = new_local env "x" in
+    let set_buf, get_buf = new_local env "buf" in
+    set_x ^^ set_buf ^^
+    get_x ^^
+    try_unbox I64Type
+      (fun env ->
+        BitTagged.untag __LINE__ env Type.Int ^^ set_x ^^
+        I32Leb.compile_store_to_data_buf_unsigned env get_x get_buf
+      )
+      (fun env ->
+        G.i Drop ^^
+        get_buf ^^ get_x ^^ Num.compile_store_to_data_buf_unsigned env)
+      env
+
+  let compile_store_to_data_buf_signed env =
+    let set_x, get_x = new_local env "x" in
+    let set_buf, get_buf = new_local env "buf" in
+    set_x ^^ set_buf ^^
+    get_x ^^
+    try_unbox I64Type
+      (fun env ->
+        BitTagged.untag __LINE__ env Type.Int ^^ set_x ^^
+        I32Leb.compile_store_to_data_buf_signed env get_x get_buf
+      )
+      (fun env ->
+        G.i Drop ^^
+        get_buf ^^ get_x ^^ Num.compile_store_to_data_buf_signed env)
+      env
+
+  let compile_data_size_unsigned env =
+    try_unbox I64Type
+      (fun _ ->
+        let set_x, get_x = new_local env "x" in
+        BitTagged.untag __LINE__ env Type.Int ^^ set_x ^^
+        I32Leb.compile_leb128_size get_x
+      )
+      (fun env -> Num.compile_data_size_unsigned env)
+      env
+
+  let compile_data_size_signed env =
+    try_unbox I64Type
+      (fun _ ->
+        let set_x, get_x = new_local env "x" in
+        BitTagged.untag __LINE__ env Type.Int ^^ set_x ^^
+        I32Leb.compile_sleb128_size get_x
+      )
+      (fun env -> Num.compile_data_size_signed env)
+      env
+
+  let from_signed_word64 env =
+    let set_a, get_a = new_local env "a" in
+    set_a ^^
+    get_a ^^ BitTagged.if_can_tag_signed env Type.Int [I64Type]
+      (get_a ^^ BitTagged.tag env Type.Int)
+      (get_a ^^ Num.from_signed_word64 env)
+
+  let from_signed_word_compact env =
+    begin
+      if TaggingScheme.debug || !(Flags.sanity)
+      then
+      let set_a, get_a = new_local env "a" in
+      set_a ^^
+      get_a ^^ BitTagged.if_can_tag_signed env Type.Int [I64Type]
+        get_a
+        (E.trap_with env "from_signed_word_compact")
+      else G.nop
+    end ^^
+    BitTagged.tag env Type.Int
+
+  let from_word64 env =
+    let set_a, get_a = new_local env "a" in
+    set_a ^^
+    get_a ^^ BitTagged.if_can_tag_unsigned env Type.Int [I64Type]
+      (get_a ^^ BitTagged.tag env Type.Int)
+      (get_a ^^ Num.from_word64 env)
+
+  let truncate_to_word64 env =
+    let set_a, get_a = new_local env "a" in
+    set_a ^^ get_a ^^
+    BitTagged.if_tagged_scalar env [I64Type]
+      (get_a ^^ BitTagged.untag __LINE__ env Type.Int)
+      (get_a ^^ Num.truncate_to_word64 env)
+
+  let truncate_to_word32 env =
+    let set_a, get_a = new_local env "a" in
+    set_a ^^ get_a ^^
+    BitTagged.if_tagged_scalar env [I64Type]
+      (get_a ^^ BitTagged.untag __LINE__ env Type.Int)
+      (get_a ^^ Num.truncate_to_word32 env)
+
+  let to_word64 env =
+    let set_a, get_a = new_local env "a" in
+    set_a ^^ get_a ^^
+    BitTagged.if_tagged_scalar env [I64Type]
+      (get_a ^^ BitTagged.untag __LINE__ env Type.Int)
+      (get_a ^^ Num.to_word64 env)
+
+  let to_word64_with env get_err_msg =
+    let set_a, get_a = new_local env "a" in
+    set_a ^^ get_a ^^
+    BitTagged.if_tagged_scalar env [I64Type]
+      (get_a ^^ BitTagged.untag __LINE__ env Type.Int)
+      (get_a ^^ Num.to_word64_with env get_err_msg)
+end
+
+module BigNumLibtommath : BigNumType = struct
+
+  let to_word64 env = E.call_import env "rts" "bigint_to_word64_trap"
+  let to_word64_with env get_err_msg = get_err_msg ^^ E.call_import env "rts" "bigint_to_word64_trap_with"
+
+  let truncate_to_word32 env = E.call_import env "rts" "bigint_to_word32_wrap" ^^ G.i (Convert (Wasm_exts.Values.I64 I64Op.ExtendUI32))
+  let truncate_to_word64 env = E.call_import env "rts" "bigint_to_word64_wrap"
+
+  let from_signed_word_compact env = E.call_import env "rts" "bigint_of_int64"
+  let from_word64 env = E.call_import env "rts" "bigint_of_word64"
+  let from_signed_word64 env = E.call_import env "rts" "bigint_of_int64"
+
+  let compile_data_size_unsigned env = E.call_import env "rts" "bigint_leb128_size"
+  let compile_data_size_signed env = E.call_import env "rts" "bigint_sleb128_size"
+
+  let compile_store_to_data_buf_unsigned env =
+    let (set_buf, get_buf) = new_local env "buf" in
+    let (set_n, get_n) = new_local env "n" in
+    set_n ^^ set_buf ^^
+    get_n ^^ get_buf ^^ E.call_import env "rts" "bigint_leb128_encode" ^^
+    get_n ^^ E.call_import env "rts" "bigint_leb128_size"
+
+  let compile_store_to_data_buf_signed env =
+    let (set_buf, get_buf) = new_local env "buf" in
+    let (set_n, get_n) = new_local env "n" in
+    set_n ^^ set_buf ^^
+    get_n ^^ get_buf ^^ E.call_import env "rts" "bigint_sleb128_encode" ^^
+    get_n ^^ E.call_import env "rts" "bigint_sleb128_size"
+
+  let compile_load_from_data_buf env get_data_buf = function
+    | false -> get_data_buf ^^ E.call_import env "rts" "bigint_leb128_decode"
+    | true -> get_data_buf ^^ E.call_import env "rts" "bigint_sleb128_decode"
+
+  let constant env n =
+    (* See enum mp_sign *)
+    let sign = if Big_int.sign_big_int n >= 0 then 0l else 1l in
+
+    let n = Big_int.abs_big_int n in
+
+    let limbs =
+      (* see MP_DIGIT_BIT for MP_64BIT *)
+      let twoto60 = Big_int.power_int_positive_int 2 60 in
+      let rec go n =
+        if Big_int.sign_big_int n = 0
+        then []
+        else
+          let (a, b) = Big_int.quomod_big_int n twoto60 in
+          StaticBytes.[ I64 (Big_int.int64_of_big_int b) ] @ go a
+      in go n
+    in
+
+    (* how many 64 bit digits *)
+    let size = Int32.of_int (List.length limbs) in  
+
+    (* cf. mp_int in tommath.h *)
+    (* Tom's math library is compiled with 64-bit `mp_digit` size. *)
+    let payload = StaticBytes.[
+      I32 size; (* used *)
+      I32 size; (* size; relying on Heap.word_size == size_of(mp_digit) *)
+      I32 sign;
+      I32 0l; (* padding because of 64-bit alignment of subsequent pointer *)
+      I64 0L; (* dp; this will be patched in BigInt::mp_int_ptr in the RTS when used *)
+    ] @ limbs
+    in
+
+    Tagged.shared_object env (fun env ->
+      let instructions = 
+        let words = StaticBytes.as_words payload in
+        List.map compile_unboxed_const words in
+      Tagged.obj env Tagged.BigInt instructions
+    )
+
+  let assert_nonneg env =
+    Func.share_code1 Func.Never env "assert_nonneg" ("n", I64Type) [I64Type] (fun env get_n ->
+      get_n ^^
+      E.call_import env "rts" "bigint_isneg" ^^ Bool.from_rts_int32 ^^
+      E.then_trap_with env "Natural subtraction underflow" ^^
+      get_n
+    )
+
+  let compile_abs env = E.call_import env "rts" "bigint_abs"
+  let compile_neg env = E.call_import env "rts" "bigint_neg"
+  let compile_add env = E.call_import env "rts" "bigint_add"
+  let compile_mul env = E.call_import env "rts" "bigint_mul"
+  let compile_signed_sub env = E.call_import env "rts" "bigint_sub"
+  let compile_signed_div env = E.call_import env "rts" "bigint_div"
+  let compile_signed_mod env = E.call_import env "rts" "bigint_rem"
+  let compile_unsigned_sub env = E.call_import env "rts" "bigint_sub" ^^ assert_nonneg env
+  let compile_unsigned_rem env = E.call_import env "rts" "bigint_rem"
+  let compile_unsigned_div env = E.call_import env "rts" "bigint_div"
+  let compile_unsigned_pow env = E.call_import env "rts" "bigint_pow"
+  let compile_lsh env = E.call_import env "rts" "bigint_lsh"
+  let compile_rsh env = E.call_import env "rts" "bigint_rsh"
+
+  let compile_eq env = E.call_import env "rts" "bigint_eq" ^^ Bool.from_rts_int32
+  let compile_is_negative env = E.call_import env "rts" "bigint_isneg" ^^ Bool.from_rts_int32
+  let compile_relop env = function
+      | Lt -> E.call_import env "rts" "bigint_lt" ^^ Bool.from_rts_int32
+      | Le -> E.call_import env "rts" "bigint_le" ^^ Bool.from_rts_int32
+      | Ge -> E.call_import env "rts" "bigint_ge" ^^ Bool.from_rts_int32
+      | Gt -> E.call_import env "rts" "bigint_gt" ^^ Bool.from_rts_int32
+
+  let fits_signed_bits env bits =
+    E.call_import env "rts" "bigint_2complement_bits" ^^
+    compile_unboxed_const (Int64.of_int bits) ^^
+    compile_comparison I64Op.LeU
+  let fits_unsigned_bits env bits =
+    E.call_import env "rts" "bigint_count_bits" ^^
+    compile_unboxed_const (Int64.of_int bits) ^^
+    compile_comparison I64Op.LeU
+
+end (* BigNumLibtommath *)
+
+module BigNum = MakeCompact(BigNumLibtommath)
+
+(* Primitive functions *)
+module Prim = struct
+  (* The {Nat,Int}{8,16,32} bits sit in the MSBs of the i64, in this manner
+     we can perform almost all operations, with the exception of
+     - Mul (needs shr of one operand)
+     - Shr (needs masking of result)
+     - Rot (needs duplication into LSBs, masking of amount and masking of result)
+     - ctz (needs shr of operand or sub from result)
+
+     Both {Nat,Int}{8,16,32} fit into the vanilla stackrep, so no boxing is necessary.
+     This MSB-stored schema is also essentially what the interpreter is using.
+  *)
+  let prim_word64toNat = BigNum.from_word64
+  let prim_shiftWordNtoUnsigned env b =
+    compile_shrU_const b ^^
+    prim_word64toNat env
+  let prim_word64toInt = BigNum.from_signed_word64
+  let prim_shiftWordNtoSigned env b =
+    compile_shrS_const b ^^
+    prim_word64toInt env
+  let prim_intToWord64 = BigNum.truncate_to_word64
+  let prim_intToWordNShifted env b =
+    prim_intToWord64 env ^^
+    TaggedSmallWord.shift_leftWordNtoI64 b
+end (* Prim *)
+
+module Blob = struct
+  (* The layout of a blob object is
+
+     ┌──────┬─────┬─────────┬──────────────────┐
+     │ obj header │ n_bytes │ bytes (padded) … │
+     └──────┴─────┴─────────┴──────────────────┘
+
+    The object header includes the object tag (Blob) and the forwarding pointer.
+
+    This heap object is used for various kinds of binary, non-pointer data.
+
+    When used for Text values, the bytes are UTF-8 encoded code points from
+    Unicode.
+  *)
+
+  let header_size = Int64.add Tagged.header_size 1L
+  let len_field = Int64.add Tagged.header_size 0L
+
+  let len env =
+    Tagged.load_forwarding_pointer env ^^
+    Tagged.load_field env len_field
+
+  let len_nat env =
+    Func.share_code1 Func.Never env "blob_len" ("text", I64Type) [I64Type] (fun env get ->
+      get ^^
+      len env ^^
+      BigNum.from_word64 env
+    )
+
+  let alloc env sort len =
+    compile_unboxed_const Tagged.(int_of_tag (Blob sort)) ^^
+    len ^^
+    E.call_import env "rts" "alloc_blob" ^^
+    (* uninitialized blob payload is allowed by the barrier *)
+    Tagged.allocation_barrier env
+
+  let unskewed_payload_offset env = Int64.(add ptr_unskew (mul Heap.word_size header_size))
+  
+  let payload_ptr_unskewed env =
+    Tagged.load_forwarding_pointer env ^^
+    compile_add_const (unskewed_payload_offset env)
+
+  let load_data_segment env sort segment_index data_length =
+    let (set_blob, get_blob) = new_local env "data_segment_blob" in
+    alloc env sort data_length ^^ set_blob ^^
+    get_blob ^^ payload_ptr_unskewed env ^^ (* target address *)
+    compile_const_32 0l ^^ (* data offset *)
+    data_length ^^ G.i (Convert (Wasm_exts.Values.I32 I32Op.WrapI64)) ^^
+    G.i (MemoryInit (nr segment_index)) ^^
+    get_blob
+
+  let constant env sort payload =
+    Tagged.shared_object env (fun env -> 
+      let blob_length = Int64.of_int (String.length payload) in
+      let segment_index = E.add_static env StaticBytes.[Bytes payload] in
+      load_data_segment env sort segment_index (compile_unboxed_const blob_length)
+    )
+
+  let lit env sort payload =
+    Tagged.materialize_shared_value env (constant env sort payload)
+
+  let as_ptr_len env = Func.share_code1 Func.Never env "as_ptr_size" ("x", I64Type) [I64Type; I64Type] (
+    fun env get_x ->
+      get_x ^^ payload_ptr_unskewed env ^^
+      get_x ^^ len env
+    )
+
+  let lit_ptr_len env sort s =
+    lit env sort s ^^
+    as_ptr_len env
+
+  let load_data_segment env sort segment_index data_length =
+    let (set_blob, get_blob) = new_local env "data_segment_blob" in
+    alloc env sort data_length ^^ set_blob ^^
+    get_blob ^^ payload_ptr_unskewed env ^^ (* target address *)
+    compile_const_32 0l ^^ (* data offset *)
+    data_length ^^ G.i (Convert (Wasm_exts.Values.I32 I32Op.WrapI64)) ^^
+    G.i (MemoryInit (nr segment_index)) ^^
+    get_blob
+  
+  let of_ptr_size env = Func.share_code2 Func.Always env "blob_of_ptr_size" (("ptr", I64Type), ("size" , I64Type)) [I64Type] (
+    fun env get_ptr get_size ->
+      let (set_x, get_x) = new_local env "x" in
+      alloc env Tagged.B get_size ^^ set_x ^^
+      get_x ^^ payload_ptr_unskewed env ^^
+      get_ptr ^^
+      get_size ^^
+      Heap.memcpy env ^^
+      get_x
+    )
+
+  let copy env src_sort dst_sort =
+    let name = Printf.sprintf "blob_copy_%s_%s"
+                 (Int64.to_string (Tagged.int_of_tag (Tagged.Blob src_sort)))
+                 (Int64.to_string (Tagged.int_of_tag (Tagged.Blob dst_sort)))
+    in
+    Func.share_code1 Func.Never env name ("src", I64Type) [I64Type] (
+      fun env get_src ->
+       let (set_dst, get_dst) = new_local env "dst" in
+       alloc env dst_sort (get_src ^^ len env) ^^ set_dst ^^
+       get_dst ^^ payload_ptr_unskewed env ^^
+       get_src ^^ Tagged.sanity_check_tag __LINE__ env (Tagged.Blob src_sort) ^^
+       as_ptr_len env ^^
+       Heap.memcpy env ^^
+       get_dst
+    )
+
+  let of_size_copy env sort get_size_fun copy_fun offset_fun =
+    let (set_len, get_len) = new_local env "len" in
+    let (set_blob, get_blob) = new_local env "blob" in
+    get_size_fun env ^^ set_len ^^
+
+    alloc env sort get_len ^^ set_blob ^^
+    get_blob ^^ payload_ptr_unskewed env ^^
+    offset_fun env ^^
+    get_len ^^
+    copy_fun env ^^
+
+    get_blob
+
+  (* Lexicographic blob comparison. Expects two blobs on the stack.
+     Either specialized to a specific comparison operator, and returns a boolean,
+     or implements the generic comparison, returning -1, 0 or 1 as Int64.
+  *)
+  let rec compare env op =
+    (* return convention for the generic comparison function *)
+    let is_lt = compile_unboxed_const (-1L) in
+    let is_gt = compile_unboxed_const 1L in
+    let is_eq = compile_unboxed_const 0L in
+    let open Operator in
+    let name = match op with
+        | Some LtOp -> "Blob.compare_lt"
+        | Some LeOp -> "Blob.compare_le"
+        | Some GeOp -> "Blob.compare_ge"
+        | Some GtOp -> "Blob.compare_gt"
+        | Some EqOp -> "Blob.compare_eq"
+        | Some NeqOp -> "Blob.compare_neq"
+        | None -> "Blob.compare" in
+    Func.share_code2 Func.Always env name (("x", I64Type), ("y", I64Type)) [I64Type] (fun env get_x get_y ->
+      match op with
+        (* Some operators can be reduced to the negation of other operators *)
+        | Some LtOp -> get_x ^^ get_y ^^ compare env (Some GeOp) ^^ Bool.neg
+        | Some GtOp -> get_x ^^ get_y ^^ compare env (Some LeOp) ^^ Bool.neg
+        | Some NeqOp -> get_x ^^ get_y ^^ compare env (Some EqOp) ^^ Bool.neg
+        | _ ->
+      begin
+        let set_x = G.setter_for get_x in
+        let set_y = G.setter_for get_y in
+        get_x ^^ Tagged.load_forwarding_pointer env ^^ set_x ^^
+        get_y ^^ Tagged.load_forwarding_pointer env ^^ set_y ^^
+
+        let (set_len1, get_len1) = new_local env "len1" in
+        let (set_len2, get_len2) = new_local env "len2" in
+        let (set_len, get_len) = new_local env "len" in
+        let (set_a, get_a) = new_local env "a" in
+        let (set_b, get_b) = new_local env "b" in
+
+        get_x ^^ len env ^^ set_len1 ^^
+        get_y ^^ len env ^^ set_len2 ^^
+
+        (* Find minimum length *)
+        begin if op = Some EqOp then
+          (* Early exit for equality *)
+          get_len1 ^^ get_len2 ^^ compile_comparison I64Op.Eq ^^
+          E.if0 G.nop (Bool.lit false ^^ G.i Return) ^^
+
+          get_len1 ^^ set_len
+        else
+          get_len1 ^^ get_len2 ^^ compile_comparison I64Op.LeU ^^
+          E.if0
+            (get_len1 ^^ set_len)
+            (get_len2 ^^ set_len)
+        end ^^
+
+        (* We could do word-wise comparisons if we know that the trailing bytes
+           are zeroed *)
+        get_len ^^
+        from_0_to_n env (fun get_i ->
+          get_x ^^
+          payload_ptr_unskewed env ^^
+          get_i ^^
+          G.i (Binary (Wasm_exts.Values.I64 I64Op.Add)) ^^
+          G.i (Load {ty = I64Type; align = 0; offset = 0L; sz = Some Wasm_exts.Types.(Pack8, ZX)}) ^^
+          set_a ^^
+
+          get_y ^^
+          payload_ptr_unskewed env ^^
+          get_i ^^
+          G.i (Binary (Wasm_exts.Values.I64 I64Op.Add)) ^^
+          G.i (Load {ty = I64Type; align = 0; offset = 0L; sz = Some Wasm_exts.Types.(Pack8, ZX)}) ^^
+          set_b ^^
+
+          get_a ^^ get_b ^^ compile_comparison I64Op.Eq ^^
+          E.if0 G.nop (
+            (* first non-equal elements *)
+            begin match op with
+            | Some LeOp -> get_a ^^ get_b ^^ compile_comparison I64Op.LeU
+            | Some GeOp -> get_a ^^ get_b ^^ compile_comparison I64Op.GeU
+            | Some EqOp -> Bool.lit false
+            | None -> get_a ^^ get_b ^^ compile_comparison I64Op.LtU ^^
+                      E.if1 I64Type is_lt is_gt
+            | _ -> assert false
+            end ^^
+            G.i Return
+          )
+        ) ^^
+        (* Common prefix is same *)
+        match op with
+        | Some LeOp -> get_len1 ^^ get_len2 ^^ compile_comparison I64Op.LeU
+        | Some GeOp -> get_len1 ^^ get_len2 ^^ compile_comparison I64Op.GeU
+        | Some EqOp -> Bool.lit true (* NB: Different length handled above *)
+        | None ->
+            get_len1 ^^ get_len2 ^^ compile_comparison I64Op.LtU ^^
+            E.if1 I64Type is_lt (
+              get_len1 ^^ get_len2 ^^ compile_comparison I64Op.GtU ^^
+              E.if1 I64Type is_gt is_eq
+            )
+        | _ -> assert false
+      end
+  )
+
+  let iter env =
+    E.call_import env "rts" "blob_iter"
+  let iter_done env =
+    E.call_import env "rts" "blob_iter_done"
+  let iter_next env =
+    E.call_import env "rts" "blob_iter_next" ^^
+    TaggedSmallWord.msb_adjust Type.Nat8
+
+  let dyn_alloc_scratch env =
+    let (set_len, get_len) = new_local env "len" in
+    set_len ^^
+    alloc env Tagged.B get_len ^^ payload_ptr_unskewed env
+
+end (* Blob *)
+
+module Object = struct
+  (* An object with a mutable field1 and immutable field 2 has the following
+     heap layout:
+ 
+     ┌──────┬─────┬──────────┬─────────┬─────────────┬───┐
+     │ obj header │ hash_ptr │ ind_ptr │ field2_data │ … │
+     └──────┴─────┴┬─────────┴┬────────┴─────────────┴───┘
+          ┌────────┘          │
+          │   ┌───────────────┘
+          │   ↓
+          │  ╶─┬────────┬─────────────┐
+          │    │ MutBox │ field1_data │
+          ↓    └────────┴─────────────┘
+          ┌─────────────┬─────────────┬─────────────┬───┐
+          │ blob header │ field1_hash │ field2_hash │ … │
+          └─────────────┴─────────────┴─────────────┴───┘        
+ 
+     The object header includes the object tag (Object) and the forwarding pointer.
+     The size of the object (number of fields) can be derived from the hash blob via `hash_ptr`.
+
+     The field hashes reside in a blob inside the dynamic heap.
+     The hash blob needs to be tracked by the GC, but not the content of the hash blob.
+     This is because the hash values are plain numbers that would look like skewed pointers.ters.
+     The hash_ptr is skewed.
+ 
+     The field2_data for immutable fields is a vanilla word.
+ 
+     The field1_data for mutable fields are pointers to a MutBox. This indirection 
+     is a consequence of how we compile object literals with `await` instructions, 
+     as these mutable fields need to be able to alias local mutable variables, e.g.
+     `{ public let f = 1; await async (); public let var v = 2}`.
+     Other use cases are object constructors with public and private mutable fields, 
+     where the physical record only wraps the public fields.
+     Moreover, closures can selectively capture the individual fields instead of 
+     the containing object.
+     Finally, classical Candid stabilization/destabilization also relies on the 
+     indirection of mutable fields, to reserve and store alias information in those 
+     locations.
+ 
+     We could alternatively switch to an allocate-first approach in the
+     await-translation of objects, and get rid of this indirection -- if it were
+     not for the implementing of sharing of mutable stable values.
+   *)
+ 
+  let header_size = Int64.add Tagged.header_size 1L
+ 
+  let hash_ptr_field = Int64.add Tagged.header_size 0L
+ 
+  module FieldEnv = Env.Make(String)
+
+  (* This is for non-recursive objects. *)
+  (* The instructions in the field already create the indirection if needed *)
+  let object_builder env (fs : (string * (E.t -> G.t)) list ) =
+    let name_pos_map =
+      fs |>
+        (* We could store only public fields in the object, but
+          then we need to allocate separate boxes for the non-public ones:
+          List.filter (fun (_, vis, f) -> vis.it = Public) |>
+        *)
+        List.map (fun (n,_) -> (E.hash env n, n)) |>
+        List.sort compare |>
+        List.mapi (fun i (_h,n) -> (n,Int64.of_int i)) |>
+        List.fold_left (fun m (n,i) -> FieldEnv.add n i m) FieldEnv.empty in
+
+      let sz = Int64.of_int (FieldEnv.cardinal name_pos_map) in
+
+      (* Create hash blob *)
+      let hashes = fs |>
+        List.map (fun (n,_) -> E.hash env n) |>
+        List.sort compare in
+      let hash_blob =
+        let hash_payload = StaticBytes.[ i64s hashes ] in
+        Blob.constant env Tagged.B (StaticBytes.as_bytes hash_payload)
+      in
+      
+      (fun env -> 
+        (* Allocate memory *)
+        let (set_ri, get_ri, ri) = new_local_ env I64Type "obj" in
+        Tagged.alloc env (Int64.add header_size sz) Tagged.Object ^^
+        set_ri ^^
+
+        (* Set hash_ptr *)
+        get_ri ^^
+        Tagged.materialize_shared_value env hash_blob ^^
+        Tagged.store_field env hash_ptr_field ^^
+
+        (* Write all the fields *)
+        let init_field (name, generate_value) : G.t =
+          (* Write the pointer to the indirection *)
+          get_ri ^^
+          generate_value env ^^
+          let i = FieldEnv.find name name_pos_map in
+          let offset = Int64.add header_size i in
+          Tagged.store_field env offset
+        in
+        G.concat_map init_field fs ^^
+
+        (* Return the pointer to the object *)
+        get_ri ^^
+        Tagged.allocation_barrier env
+      )
+
+  let constant env (fs : (string * E.shared_value) list) =
+    let materialize_fields = List.map (fun (name, value) -> (name, fun env -> Tagged.materialize_shared_value env value)) fs in
+    let allocation = object_builder env materialize_fields in
+    Tagged.shared_object env allocation
+
+  (* This is for non-recursive objects, i.e. ObjNewE *)
+  (* The instructions in the field already create the indirection if needed *)
+  let lit_raw env (fs : (string * (unit -> G.t)) list ) =
+    let materialize_fields = List.map (fun (name, generate_value) -> (name, (fun env -> generate_value ()))) fs in
+    let allocation = object_builder env materialize_fields in
+    allocation env
+
+  (* Reflection used by orthogonal persistence: 
+     Check whether an (actor) object contains a specific field *)
+  let contains_field env field =
+    compile_unboxed_const (E.hash env field) ^^
+    E.call_import env "rts" "contains_field" ^^
+    Bool.from_rts_int32
+ 
+  (* Returns a pointer to the object field (without following the field indirection) *)
+  let idx_hash_raw env low_bound =
+    let name = Printf.sprintf "obj_idx<%d>" low_bound  in
+    Func.share_code2 Func.Always env name (("x", I64Type), ("hash", I64Type)) [I64Type] (fun env get_x get_hash ->
+      let set_x = G.setter_for get_x in
+      let set_h_ptr, get_h_ptr = new_local env "h_ptr" in
+
+      get_x ^^ Tagged.load_forwarding_pointer env ^^ set_x ^^
+
+      get_x ^^ Tagged.load_field env hash_ptr_field ^^
+      Blob.payload_ptr_unskewed env ^^
+
+      (* Linearly scan through the fields (binary search can come later) *)
+      (* unskew h_ptr and advance both to low bound *)
+      compile_add_const Int64.(mul Heap.word_size (of_int low_bound)) ^^
+      set_h_ptr ^^
+      get_x ^^
+      compile_add_const Int64.(mul Heap.word_size (add header_size (of_int low_bound))) ^^
+      set_x ^^
+      G.loop0 (
+          get_h_ptr ^^ load_unskewed_ptr ^^
+          get_hash ^^ compile_comparison I64Op.Eq ^^
+          E.if0
+            (get_x ^^ G.i Return)
+            (get_h_ptr ^^ compile_add_const Heap.word_size ^^ set_h_ptr ^^
+            get_x ^^ compile_add_const Heap.word_size ^^ set_x ^^
+            G.i (Br (nr 1l)))
+        ) ^^
+      G.i Unreachable
+    )
+
+  (* Returns a pointer to the object field (possibly following the indirection) *)
+  let idx_hash env low_bound indirect =
+    if indirect
+    then
+      let name = Printf.sprintf "obj_idx_ind<%d>" low_bound in
+      Func.share_code2 Func.Never env name (("x", I64Type), ("hash", I64Type)) [I64Type] (fun env get_x get_hash ->
+      get_x ^^ get_hash ^^
+      idx_hash_raw env low_bound ^^
+      load_ptr ^^ Tagged.load_forwarding_pointer env ^^
+      compile_add_const (Int64.mul MutBox.field Heap.word_size)
+    )
+    else idx_hash_raw env low_bound
+
+  let field_type env obj_type s =
+    let _, fields = Type.as_obj_sub [s] obj_type in
+    Type.lookup_val_field s fields
+
+  (* Determines whether the field is mutable (and thus needs an indirection) *)
+  let is_mut_field env obj_type s =
+    let _, fields = Type.as_obj_sub [s] obj_type in
+    Type.is_mut (Type.lookup_val_field s fields)
+
+  (* Computes a lower bound for the positional index of a field in an object *)
+  let field_lower_bound env obj_type s =
+    let open Type in
+    let _, fields = as_obj_sub [s] obj_type in
+    List.iter (function {typ = Typ _; _} -> assert false | _ -> ()) fields;
+    let sorted_by_hash =
+      List.sort
+        (fun (h1, _) (h2, _) -> compare_uint64 h1 h2)
+        (List.map (fun f -> E.hash env f.lab, f) fields) in
+    match Lib.List.index_of s (List.map (fun (_, {lab; _}) -> lab) sorted_by_hash) with
+    | Some i -> i
+    | _ -> assert false
+
+  (* Returns a pointer to the object field (without following the indirection) *)
+  let idx_raw env f =
+    compile_unboxed_const (E.hash env f) ^^
+    idx_hash_raw env 0
+
+  (* Returns a pointer to the object field (possibly following the indirection) *)
+  let idx env obj_type f =
+    compile_unboxed_const (E.hash env f) ^^
+    idx_hash env (field_lower_bound env obj_type f) (is_mut_field env obj_type f)
+
+  (* load the value (or the mutbox) *)
+  let load_idx_raw env f =
+    idx_raw env f ^^
+    load_ptr
+
+  (* load the actual value (dereferencing the mutbox) *)
+  let load_idx env obj_type f =
+    idx env obj_type f ^^
+    load_ptr
+ 
+end (* Object *) 
+
+module Region = struct
+  (*
+    See rts/motoko-rts/src/region.rs
+   *)
+
+  (* Object layout:
+
+     ┌─────┬──────────┬──────────────────┬─────────────────┐
+     │ tag │ id_field │ page_count_field │ vec_pages_field │
+     └─────┴──────────┴──────────────────┴─────────────────┘
+            (unboxed, low 16 bits, rest 0-initialized padding)
+                        unboxed u32
+                                          Blob
+  *)
+
+  let alloc_region env =
+    E.call_import env "rts" "alloc_region"
+
+  let init_region env =
+    E.call_import env "rts" "init_region"
+
+  (* field accessors *)
+  (* NB: all these opns must resolve forwarding pointers here or in RTS *)
+  let id env =
+    E.call_import env "rts" "region_id"
+
+  let page_count env =
+    E.call_import env "rts" "region_page_count"
+
+  let vec_pages env =
+    E.call_import env "rts" "region_vec_pages"
+
+  let new_ env =
+    E.require_stable_memory env;
+    E.call_import env "rts" "region_new"
+
+  let size env =
+    E.require_stable_memory env;
+    E.call_import env "rts" "region_size"
+
+  let grow env =
+    E.require_stable_memory env;
+    E.call_import env "rts" "region_grow"
+
+  let load_blob env =
+    E.require_stable_memory env;
+    E.call_import env "rts" "region_load_blob"
+  let store_blob env =
+    E.require_stable_memory env;
+    E.call_import env "rts" "region_store_blob"
+
+  let load_word8 env =
+    E.require_stable_memory env;
+    E.call_import env "rts" "region_load_word8"
+  let store_word8 env =
+    E.require_stable_memory env;
+    E.call_import env "rts" "region_store_word8"
+
+  let load_word16 env =
+    E.require_stable_memory env;
+    E.call_import env "rts" "region_load_word16"
+  let store_word16 env =
+    E.require_stable_memory env;
+    E.call_import env "rts" "region_store_word16"
+
+  let load_word32 env =
+    E.require_stable_memory env;
+    E.call_import env "rts" "region_load_word32"
+  let store_word32 env =
+    E.require_stable_memory env;
+    E.call_import env "rts" "region_store_word32"
+
+  let load_word64 env =
+    E.require_stable_memory env;
+    E.call_import env "rts" "region_load_word64"
+  let store_word64 env =
+    E.require_stable_memory env;
+    E.call_import env "rts" "region_store_word64"
+
+  let load_float64 env =
+    E.require_stable_memory env;
+    E.call_import env "rts" "region_load_float64"
+  let store_float64 env =
+    E.require_stable_memory env;
+    E.call_import env "rts" "region_store_float64"
+
+end
+
+module Text = struct
+  (*
+  Most of the heavy lifting around text values is in rts/motoko-rts/src/text.rs
+  *)
+
+  (* The layout of a concatenation node is
+
+     ┌──────┬─────┬─────────┬───────┬───────┐
+     │ obj header │ n_bytes │ text1 │ text2 │
+     └──────┴─────┴─────────┴───────┴───────┘
+
+    The object header includes the object tag (TAG_CONCAT defined in rts/types.rs) and the forwarding pointer
+
+    This is internal to rts/text.c, with the exception of GC-related code.
+  *)
+
+  let of_ptr_size env =
+    E.call_import env "rts" "text_of_ptr_size"
+  let concat env =
+    E.call_import env "rts" "text_concat"
+  let size env =
+    E.call_import env "rts" "text_size"
+  let to_buf env =
+    E.call_import env "rts" "text_to_buf"
+  let len_nat env =
+    Func.share_code1 Func.Never env "text_len" ("text", I64Type) [I64Type] (fun env get ->
+      get ^^
+      E.call_import env "rts" "text_len" ^^
+      BigNum.from_word64 env
+    )
+  let prim_showChar env =
+    TaggedSmallWord.lsb_adjust_codepoint env ^^
+    G.i (Convert (Wasm_exts.Values.I32 I32Op.WrapI64)) ^^
+    E.call_import env "rts" "text_singleton"
+  let to_blob env = E.call_import env "rts" "blob_of_text"
+
+  let lowercase env = E.call_import env "rts" "text_lowercase"
+  let uppercase env = E.call_import env "rts" "text_uppercase"
+
+  let of_blob env =
+    let (set_blob, get_blob) = new_local env "blob" in
+    set_blob ^^
+    get_blob ^^ Blob.as_ptr_len env ^^
+    E.call_import env "rts" "utf8_valid" ^^
+    Bool.from_rts_int32 ^^
+    E.if1 I64Type
+      (get_blob ^^ Blob.copy env Tagged.B Tagged.T ^^
+       set_blob ^^
+       Opt.inject_simple env get_blob)
+      (Opt.null_lit env)
+
+  let iter env =
+    E.call_import env "rts" "text_iter"
+  let iter_done env =
+    E.call_import env "rts" "text_iter_done"
+  let iter_next env =
+    E.call_import env "rts" "text_iter_next" ^^ Bool.from_rts_int32 ^^
+    TaggedSmallWord.msb_adjust_codepoint
+
+  let compare env op =
+    let open Operator in
+    let name = match op with
+        | LtOp -> "Text.compare_lt"
+        | LeOp -> "Text.compare_le"
+        | GeOp -> "Text.compare_ge"
+        | GtOp -> "Text.compare_gt"
+        | EqOp -> "Text.compare_eq"
+        | NeqOp -> assert false in
+    Func.share_code2 Func.Never env name (("x", I64Type), ("y", I64Type)) [I64Type] (fun env get_x get_y ->
+      get_x ^^ Tagged.load_forwarding_pointer env ^^
+      get_y ^^ Tagged.load_forwarding_pointer env ^^
+      E.call_import env "rts" "text_compare" ^^
+      compile_unboxed_const 0L ^^
+      match op with
+        | LtOp -> compile_comparison I64Op.LtS
+        | LeOp -> compile_comparison I64Op.LeS
+        | GtOp -> compile_comparison I64Op.GtS
+        | GeOp -> compile_comparison I64Op.GeS
+        | EqOp -> compile_comparison I64Op.Eq
+        | NeqOp -> assert false
+    )
+
+
+end (* Text *)
+
+module Arr = struct
+  (* Object layout:
+
+     ┌──────┬─────┬──────────┬────────┬───┐
+     │ obj header │ n_fields │ field1 │ … │
+     └──────┴─────┴──────────┴────────┴───┘
+
+     The object  header includes the object tag (Array) and the forwarding pointer.
+
+     No difference between mutable and immutable arrays.
+  *)
+
+  (* NB max_array_size must agree with limit 2^61 imposed by RTS alloc_array() *)
+  let max_array_size = Int64.shift_left 1L 61 (* inclusive *)
+
+  let header_size = Int64.add Tagged.header_size 1L
+  let element_size = 8L
+  let len_field = Int64.add Tagged.header_size 0L
+
+  let len env =
+    Tagged.load_forwarding_pointer env ^^
+    Tagged.load_field env len_field
+
+  (* Static array access. No checking *)
+  let load_field env n =
+    Tagged.load_forwarding_pointer env ^^
+    Tagged.load_field env Int64.(add n header_size)
+
+  (* Dynamic array access. Returns the address (not the value) of the field.
+     Does no bounds checking *)
+  let unsafe_idx env =
+    Func.share_code2 Func.Never env "Array.unsafe_idx" (("array", I64Type), ("idx", I64Type)) [I64Type] (fun env get_array get_idx ->
+      get_idx ^^
+      compile_add_const header_size ^^
+      compile_mul_const element_size ^^
+      get_array ^^
+      Tagged.load_forwarding_pointer env ^^
+      G.i (Binary (Wasm_exts.Values.I64 I64Op.Add))
+    )
+
+  (* Dynamic array access. Returns the address (not the value) of the field.
+     Does bounds checking *)
+  let idx env =
+    Func.share_code2 Func.Never env "Array.idx" (("array", I64Type), ("idx", I64Type)) [I64Type] (fun env get_array get_idx ->
+      (* No need to check the lower bound, we interpret idx as unsigned *)
+      (* Check the upper bound *)
+      get_idx ^^
+      get_array ^^ len env ^^
+      compile_comparison I64Op.LtU ^^
+      E.else_trap_with env "Array index out of bounds" ^^
+
+      get_idx ^^
+      compile_add_const header_size ^^
+      compile_mul_const element_size ^^
+      get_array ^^
+      Tagged.load_forwarding_pointer env ^^
+      G.i (Binary (Wasm_exts.Values.I64 I64Op.Add))
+    )
+
+  (* As above, but taking a bigint (Nat), and reporting overflow as out of bounds *)
+  let idx_bigint env =
+    Func.share_code2 Func.Never env "Array.idx_bigint" (("array", I64Type), ("idx", I64Type)) [I64Type] (fun env get_array get_idx ->
+      get_array ^^
+      get_idx ^^
+      BigNum.to_word64_with env (Blob.lit env Tagged.T "Array index out of bounds") ^^
+      idx env
+  )
+
+  let element_type env typ = match Type.promote typ with
+     | Type.Array element_type -> element_type
+     | _ -> assert false
+
+  (* Compile an array literal. *)
+  let lit env sort element_instructions =
+    Tagged.obj env Tagged.(Array sort)
+     ([ compile_unboxed_const (Wasm.I64.of_int_u (List.length element_instructions))
+      ] @ element_instructions)
+
+  let constant env sort elements =
+    Tagged.shared_object env (fun env ->
+      let materialized_elements = List.map (fun element -> Tagged.materialize_shared_value env element) elements in
+      lit env sort materialized_elements
+    )
+
+  (* Does not initialize the fields! *)
+  (* Note: Post allocation barrier must be applied after initialization *)
+  let alloc env array_sort len =
+    compile_unboxed_const Tagged.(int_of_tag (Array array_sort)) ^^
+    len ^^
+    E.call_import env "rts" "alloc_array"
+
+  let iterate env get_array body =
+    let (set_boundary, get_boundary) = new_local env "boundary" in
+    let (set_pointer, get_pointer) = new_local env "pointer" in
+    let set_array = G.setter_for get_array in
+
+    get_array ^^ Tagged.load_forwarding_pointer env ^^ set_array ^^
+
+    (* Initial element pointer, skewed *)
+    compile_unboxed_const header_size ^^
+    compile_mul_const element_size ^^
+    get_array ^^
+    G.i (Binary (Wasm_exts.Values.I64 I64Op.Add)) ^^
+    set_pointer ^^
+
+    (* Upper pointer boundary, skewed *)
+    get_array ^^
+    Tagged.load_field env len_field ^^
+    compile_mul_const element_size ^^
+    get_pointer ^^
+    G.i (Binary (Wasm_exts.Values.I64 I64Op.Add)) ^^
+    set_boundary ^^
+
+    (* Loop through all elements *)
+    compile_while env
+    ( get_pointer ^^
+      get_boundary ^^
+      compile_comparison I64Op.LtU
+    ) (
+      body get_pointer ^^
+
+      (* Next element pointer, skewed *)
+      get_pointer ^^
+      compile_add_const element_size ^^
+      set_pointer
+    )
+
+  (* The primitive operations *)
+  (* No need to wrap them in RTS functions: They occur only once, in the prelude. *)
+  let init env =
+    let (set_x, get_x) = new_local env "x" in
+    let (set_r, get_r) = new_local env "r" in
+    set_x ^^
+
+    (* Allocate *)
+    BigNum.to_word64 env ^^
+    set_r ^^
+    alloc env Tagged.M get_r ^^
+    set_r ^^
+
+    (* Write elements *)
+    iterate env get_r (fun get_pointer ->
+      get_pointer ^^
+      get_x ^^
+      store_ptr
+    ) ^^
+
+    get_r ^^
+    Tagged.allocation_barrier env
+
+
+  let tabulate env =
+    let (set_f, get_f) = new_local env "f" in
+    let (set_r, get_r) = new_local env "r" in
+    let (set_i, get_i) = new_local env "i" in
+    set_f ^^
+
+    (* Allocate *)
+    BigNum.to_word64 env ^^
+    set_r ^^
+    alloc env Tagged.I get_r ^^
+    set_r ^^
+
+    (* Initial index *)
+    compile_unboxed_const 0L ^^
+    set_i ^^
+
+    (* Write elements *)
+    iterate env get_r (fun get_pointer ->
+      get_pointer ^^
+      (* The closure *)
+      get_f ^^
+      Closure.prepare_closure_call env ^^
+      (* The arg *)
+      get_i ^^
+      BigNum.from_word64 env ^^
+      (* The closure again *)
+      get_f ^^
+      (* Call *)
+      Closure.call_closure env 1 1 ^^
+      store_ptr ^^
+
+      (* Increment index *)
+      get_i ^^
+      compile_add_const 1L ^^
+      set_i
+    ) ^^
+    get_r ^^
+    Tagged.allocation_barrier env
+
+  let ofBlob env sort =
+    let name = Tagged.(match sort with I -> "Arr.ofBlob" | M -> "Arr.ofBlobMut" | _ -> assert false) in
+    Func.share_code1 Func.Always env name ("blob", I64Type) [I64Type] (fun env get_blob ->
+      let (set_len, get_len) = new_local env "len" in
+      let (set_r, get_r) = new_local env "r" in
+
+      get_blob ^^ Blob.len env ^^ set_len ^^
+
+      alloc env sort get_len ^^ set_r ^^
+
+      get_len ^^ from_0_to_n env (fun get_i ->
+        get_r ^^ get_i ^^ unsafe_idx env ^^
+        get_blob ^^ Blob.payload_ptr_unskewed env ^^
+        get_i ^^ G.i (Binary (Wasm_exts.Values.I64 I64Op.Add)) ^^
+        G.i (Load {ty = I64Type; align = 0; offset = 0L; sz = Some Wasm_exts.Types.(Pack8, ZX)}) ^^
+        TaggedSmallWord.msb_adjust Type.Nat8 ^^
+        TaggedSmallWord.tag env Type.Nat8 ^^
+        store_ptr
+      ) ^^
+      get_r ^^
+      Tagged.allocation_barrier env
+    )
+
+  let toBlob env =
+    Func.share_code1 Func.Always env "Arr.toBlob" ("array", I64Type) [I64Type] (fun env get_a ->
+      let (set_len, get_len) = new_local env "len" in
+      let (set_r, get_r) = new_local env "r" in
+
+      get_a ^^ len env ^^ set_len ^^
+
+      Blob.alloc env Tagged.B get_len ^^ set_r ^^
+
+      get_len ^^ from_0_to_n env (fun get_i ->
+        get_r ^^ Blob.payload_ptr_unskewed env ^^
+        get_i ^^ G.i (Binary (Wasm_exts.Values.I64 I64Op.Add)) ^^
+        get_a ^^ get_i ^^ unsafe_idx env ^^
+        load_ptr ^^
+        TaggedSmallWord.lsb_adjust Type.Nat8 ^^
+        G.i (Store {ty = I64Type; align = 0; offset = 0L; sz = Some Wasm_exts.Types.Pack8})
+      ) ^^
+
+      get_r
+    )
+
+end (* Array *)
+
+module Tuple = struct
+  (* Tuples use the same object representation (and same tag) as arrays.
+     Even though we know the size statically, we still need the size
+     information for the GC.
+
+     One could introduce tags for small tuples, to save one word.
+  *)
+
+  (* We represent the boxed empty tuple as the unboxed scalar 0, i.e. simply as
+     number (but really anything is fine, we never look at this) *)
+  let unit_vanilla_lit env = TaggingScheme.unit_tag  (* all tag, trivial payload *)
+  let compile_unit env = compile_unboxed_const (unit_vanilla_lit ())
+
+  (* Expects on the stack the pointer to the array. *)
+  let load_n env n =
+    Tagged.load_forwarding_pointer env ^^
+    Tagged.(sanity_check_tag __LINE__ env (Array T)) ^^
+    Tagged.load_field env (Int64.add Arr.header_size n)
+
+  (* Takes n elements of the stack and produces an argument tuple *)
+  let from_stack env n =
+    if n = 0 then compile_unit env
+    else
+      let name = Printf.sprintf "to_%i_tuple" n in
+      let args = Lib.List.table n (fun i -> Printf.sprintf "arg%i" i, I64Type) in
+      Func.share_code Func.Never env name args [I64Type] (fun env getters ->
+        Arr.lit env Tagged.T (Lib.List.table n (fun i -> List.nth getters i))
+      )
+
+  (* Takes an argument tuple and puts the elements on the stack: *)
+  let to_stack env n =
+    if n = 0 then G.i Drop else
+    begin
+      let name = Printf.sprintf "from_%i_tuple" n in
+      let retty = Lib.List.make n I64Type in
+      Func.share_code1 Func.Never env name ("tup", I64Type) retty (fun env get_tup ->
+        G.table n (fun i -> get_tup ^^ load_n env (Int64.of_int i))
+      )
+    end
+
+end (* Tuple *)
+
+module Lifecycle = struct
+  (*
+  This module models the life cycle of a canister as a very simple state machine,
+  keeps track of the current state of the canister, and traps noisily if an
+  unexpected transition happens. Such a transition would either be a bug in the
+  underlying system, or in our RTS.
+  *)
+
+  type state =
+    | PreInit
+  (* We do not use the (start) function when compiling canisters, so skip
+     these two:
+    | InStart
+    | Started (* (start) has run *)
+  *)
+    | InInit (* canister_init *)
+    | Idle (* basic steady state *)
+    | InUpdate
+    | InQuery
+    | PostQuery (* an invalid state *)
+    | InPreUpgrade
+    | PostPreUpgrade (* an invalid state *)
+    | InPostUpgrade
+    | InComposite
+    | InStabilization (* stabilization before upgrade *)
+    | InDestabilization (* destabilization after upgrade *)
+
+  let string_of_state state = match state with
+    | PreInit -> "PreInit"
+    | InInit -> "InInit"
+    | Idle -> "Idle"
+    | InUpdate -> "InUpdate"
+    | InQuery -> "InQuery"
+    | PostQuery -> "PostQuery"
+    | InPreUpgrade -> "InPreUpgrade"
+    | PostPreUpgrade -> "PostPreUpgrade"
+    | InPostUpgrade -> "InPostUpgrade"
+    | InComposite -> "InComposite"
+    | InStabilization -> "InStabilization"
+    | InDestabilization -> "InDestabilization"
+
+  let int_of_state = function
+    | PreInit -> 0L (* Automatically null *)
+    (*
+    | InStart -> 1L
+    | Started -> 2L
+    *)
+    | InInit -> 3L
+    | Idle -> 4L
+    | InUpdate -> 5L
+    | InQuery -> 6L
+    | PostQuery -> 7L
+    | InPreUpgrade -> 8L
+    | PostPreUpgrade -> 9L
+    | InPostUpgrade -> 10L
+    | InComposite -> 11L
+    | InStabilization -> 12L
+    | InDestabilization -> 13L
+
+  let ptr () = Stack.end_ ()
+  let end_ () = Int64.add (Stack.end_ ()) Heap.word_size
+
+  (* Which states may come before this *)
+  let pre_states = function
+    | PreInit -> []
+    (*
+    | InStart -> [PreInit]
+    | Started -> [InStart]
+    *)
+    | InInit -> [PreInit]
+    | Idle -> [InInit; InUpdate; InPostUpgrade; InComposite; InDestabilization]
+    | InUpdate -> [Idle]
+    | InQuery -> [Idle]
+    | PostQuery -> [InQuery]
+    | InPreUpgrade -> [Idle; InStabilization]
+    | PostPreUpgrade -> [InPreUpgrade]
+    | InPostUpgrade -> [InInit; InDestabilization]
+    | InComposite -> [Idle; InComposite]
+    | InStabilization -> [Idle; InStabilization]
+    | InDestabilization -> [InInit]
+
+  let get env =
+    compile_unboxed_const (ptr ()) ^^
+    load_unskewed_ptr
+
+  let set env new_state =
+    compile_unboxed_const (ptr ()) ^^
+    compile_unboxed_const (int_of_state new_state) ^^
+    store_unskewed_ptr
+
+  let during_explicit_upgrade env =
+    get env ^^
+    compile_eq_const (int_of_state InStabilization) ^^
+    get env ^^
+    compile_eq_const (int_of_state InDestabilization) ^^
+    G.i (Binary (Wasm_exts.Values.I64 I64Op.Or))
+
+  let trans env new_state =
+    let name = "trans_state" ^ Int64.to_string (int_of_state new_state) in
+    Func.share_code0 Func.Always env name [] (fun env ->
+      G.block0 (
+        let rec go = function
+        | [] -> 
+          during_explicit_upgrade env ^^
+          E.if0
+            (E.trap_with env "Messages are blocked during stabilization")
+            (E.trap_with env
+              ("internal error: unexpected state entering " ^ string_of_state new_state))
+        | (s::ss) ->
+          get env ^^ compile_eq_const (int_of_state s) ^^
+          E.if0 (G.i (Br (nr 1l))) G.nop ^^
+          go ss
+        in go (pre_states new_state)
+        ) ^^
+      set env new_state
+    )
+
+  let is_in env state =
+    get env ^^
+    compile_eq_const (int_of_state state)
+
+end (* Lifecycle *)
+
+
+module IC = struct
+
+  (* IC-specific stuff: System imports, databufs etc. *)
+
+  let register_globals env =
+    (* result of last ic0.call_perform  *)
+    E.add_global64 env "__call_perform_status" Mutable 0L;
+    E.add_global64 env "__call_perform_message" Mutable 0L;
+    E.add_global64 env "__run_post_upgrade" Mutable 0L
+    (* NB: __call_perform_message is not a root so text contents *must* be static *)
+
+  let get_call_perform_status env =
+    G.i (GlobalGet (nr (E.get_global env "__call_perform_status")))
+  let set_call_perform_status env =
+    G.i (GlobalSet (nr (E.get_global env "__call_perform_status")))
+  let get_call_perform_message env =
+    G.i (GlobalGet (nr (E.get_global env "__call_perform_message")))
+  let set_call_perform_message env =
+    G.i (GlobalSet (nr (E.get_global env "__call_perform_message")))
+  let get_run_post_upgrade env =
+    G.i (GlobalGet (nr (E.get_global env "__run_post_upgrade")))
+  let set_run_post_upgrade env =
+    G.i (GlobalSet (nr (E.get_global env "__run_post_upgrade")))
+
+  let init_globals env =
+    Blob.lit env Tagged.T "" ^^
+    set_call_perform_message env
+
+  let i64s n = Lib.List.make n I64Type
+
+  let import_ic0 env =
+      E.add_func_import env "ic0" "accept_message" [] [];
+      E.add_func_import env "ic0" "call_data_append" (i64s 2) [];
+      E.add_func_import env "ic0" "call_cycles_add128" (i64s 2) [];
+      E.add_func_import env "ic0" "call_new" (i64s 8) [];
+      E.add_func_import env "ic0" "call_perform" [] [I32Type];
+      E.add_func_import env "ic0" "call_on_cleanup" (i64s 2) [];
+      E.add_func_import env "ic0" "canister_cycle_balance128" [I64Type] [];
+      E.add_func_import env "ic0" "canister_self_copy" (i64s 3) [];
+      E.add_func_import env "ic0" "canister_self_size" [] [I64Type];
+      E.add_func_import env "ic0" "canister_status" [] [I32Type];
+      E.add_func_import env "ic0" "canister_version" [] [I64Type];
+      E.add_func_import env "ic0" "is_controller" (i64s 2) [I32Type];
+      E.add_func_import env "ic0" "debug_print" (i64s 2) [];
+      E.add_func_import env "ic0" "msg_arg_data_copy" (i64s 3) [];
+      E.add_func_import env "ic0" "msg_arg_data_size" [] [I64Type];
+      E.add_func_import env "ic0" "msg_caller_copy" (i64s 3) [];
+      E.add_func_import env "ic0" "msg_caller_size" [] [I64Type];
+      E.add_func_import env "ic0" "msg_cycles_available128" [I64Type] [];
+      E.add_func_import env "ic0" "msg_cycles_refunded128" [I64Type] [];
+      E.add_func_import env "ic0" "msg_cycles_accept128" (i64s 3) [];
+      E.add_func_import env "ic0" "certified_data_set" (i64s 2) [];
+      E.add_func_import env "ic0" "data_certificate_present" [] [I32Type];
+      E.add_func_import env "ic0" "data_certificate_size" [] [I64Type];
+      E.add_func_import env "ic0" "data_certificate_copy" (i64s 3) [];
+      E.add_func_import env "ic0" "msg_method_name_size" [] [I64Type];
+      E.add_func_import env "ic0" "msg_method_name_copy" (i64s 3) [];
+      E.add_func_import env "ic0" "msg_reject_code" [] [I32Type];
+      E.add_func_import env "ic0" "msg_reject_msg_size" [] [I64Type];
+      E.add_func_import env "ic0" "msg_reject_msg_copy" (i64s 3) [];
+      E.add_func_import env "ic0" "msg_reject" (i64s 2) [];
+      E.add_func_import env "ic0" "msg_reply_data_append" (i64s 2) [];
+      E.add_func_import env "ic0" "msg_reply" [] [];
+      E.add_func_import env "ic0" "performance_counter" [I32Type] [I64Type];
+      E.add_func_import env "ic0" "trap" (i64s 2) [];
+      E.add_func_import env "ic0" "stable64_write" (i64s 3) [];
+      E.add_func_import env "ic0" "stable64_read" (i64s 3) [];
+      E.add_func_import env "ic0" "stable64_size" [] [I64Type];
+      E.add_func_import env "ic0" "stable64_grow" [I64Type] [I64Type];
+      E.add_func_import env "ic0" "time" [] [I64Type];
+      if !Flags.global_timer then
+        E.add_func_import env "ic0" "global_timer_set" [I64Type] [I64Type];
+      ()
+
+  let system_imports env =
+    match E.mode env with
+    | Flags.ICMode ->
+      import_ic0 env
+    | Flags.RefMode  ->
+      import_ic0 env
+    | Flags.WASIMode ->
+      (* Wasi function is still 32-bit based *)
+      E.add_func_import env "wasi_snapshot_preview1" "fd_write" [I32Type; I32Type; I32Type; I32Type] [I32Type];
+    | Flags.WasmMode -> ()
+
+  let system_call env funcname = E.call_import env "ic0" funcname
+
+  let register env =
+      let min env first second = 
+        first ^^
+        second ^^
+        compile_comparison I64Op.LtU ^^
+        E.if1 I64Type (first) (second) in
+
+      Func.define_built_in env "print_ptr" [("ptr", I64Type); ("len", I64Type)] [] (fun env ->
+        match E.mode env with
+        | Flags.WasmMode -> G.i Nop
+        | Flags.ICMode | Flags.RefMode ->
+          G.i (LocalGet (nr 0l)) ^^
+          G.i (LocalGet (nr 1l)) ^^
+          system_call env "debug_print"
+        | Flags.WASIMode -> begin
+          (* Since the wasmtime `fd_write` function still only supports 32-bit pointers in 64-bit mode, 
+             we use a static buffer for the text output that resides in the 32-bit space.
+             This buffer is reserved is limited to 512 bytes and is managed in the RTS, see `buffer_in_32_bit_range()`. *)
+          let get_ptr = G.i (LocalGet (nr 0l)) in
+          let get_len = G.i (LocalGet (nr 1l)) in
+
+          Stack.with_words env "io_vec" 6L (fun get_iovec_ptr ->
+            let buffer_length = 512 in
+            let buffer_ptr = E.call_import env "rts" "buffer_in_32_bit_range" in
+
+            (* Truncate the text if it does not fit into the buffer **)
+            min env (compile_unboxed_const (Int64.of_int buffer_length)) get_len ^^
+            G.setter_for get_len ^^
+
+            (* Copy the text to the static buffer in 32-bit space *)
+            buffer_ptr ^^
+            get_ptr ^^
+            get_len ^^
+            Heap.memcpy env ^^
+
+            (* We use the iovec functionality to append a newline *)
+            get_iovec_ptr ^^
+            narrow_to_32 env buffer_ptr ^^ (* This is safe because the buffer resides in 32-bit space *)
+            G.i (Store {ty = I32Type; align = 2; offset = 0L; sz = None}) ^^
+
+            get_iovec_ptr ^^
+            narrow_to_32 env get_len ^^
+            G.i (Store {ty = I32Type; align = 2; offset = 4L; sz = None}) ^^
+
+            get_iovec_ptr ^^
+            narrow_to_32 env get_iovec_ptr ^^ (* The stack pointer should always be in the 32-bit space *)
+            compile_add32_const 16l ^^
+            G.i (Store {ty = I32Type; align = 2; offset = 8L; sz = None}) ^^
+
+            get_iovec_ptr ^^
+            compile_const_32 1l ^^
+            G.i (Store {ty = I32Type; align = 2; offset = 12L; sz = None}) ^^
+
+            get_iovec_ptr ^^
+            compile_const_32 (Int32.of_int (Char.code '\n')) ^^
+            G.i (Store {ty = I32Type; align = 0; offset = 16L; sz = Some Wasm_exts.Types.Pack8}) ^^
+
+            (* Call fd_write twice to work around
+               https://github.com/bytecodealliance/wasmtime/issues/629
+            *)
+
+            compile_const_32 1l (* stdout *) ^^
+            narrow_to_32 env get_iovec_ptr ^^
+            compile_const_32 1l (* one string segment (2 doesn't work) *) ^^
+            narrow_to_32 env get_iovec_ptr ^^
+            compile_add32_const 20l ^^ (* out for bytes written, we ignore that *)
+            E.call_import env "wasi_snapshot_preview1" "fd_write" ^^
+            G.i Drop ^^
+
+            compile_const_32 1l (* stdout *) ^^
+            narrow_to_32 env get_iovec_ptr ^^
+            compile_add32_const 8l ^^
+            compile_const_32 1l (* one string segment *) ^^
+            narrow_to_32 env get_iovec_ptr ^^
+            compile_add32_const 20l ^^ (* out for bytes written, we ignore that *)
+            E.call_import env "wasi_snapshot_preview1" "fd_write" ^^
+            G.i Drop)
+          end);
+
+      E.add_export env (nr {
+        name = Lib.Utf8.decode "print_ptr";
+        edesc = nr (FuncExport (nr (E.built_in env "print_ptr")))
+      })
+
+
+  let ic_system_call call env =
+    match E.mode env with
+    | Flags.(ICMode | RefMode) ->
+      system_call env call
+    | _ ->
+      E.trap_with env Printf.(sprintf "cannot get %s when running locally" call)
+
+  let performance_counter env = 
+    G.i (Convert (Wasm_exts.Values.I32 I32Op.WrapI64)) ^^
+    ic_system_call "performance_counter" env
+
+  let is_controller env =
+    ic_system_call "is_controller" env ^^ 
+    G.i (Convert (Wasm_exts.Values.I64 I64Op.ExtendUI32))
+
+  let canister_version env = ic_system_call "canister_version" env
+
+  let print_ptr_len env = G.i (Call (nr (E.built_in env "print_ptr")))
+
+  let print_text env =
+    Func.share_code1 Func.Never env "print_text" ("str", I64Type) [] (fun env get_str ->
+      let (set_blob, get_blob) = new_local env "blob" in
+      get_str ^^ Text.to_blob env ^^ set_blob ^^
+      get_blob ^^ Blob.payload_ptr_unskewed env ^^
+      get_blob ^^ Blob.len env ^^
+      print_ptr_len env
+    )
+
+  (* For debugging *)
+  let _compile_static_print env s =
+    Blob.lit_ptr_len env Tagged.T s ^^ print_ptr_len env
+
+  let ic_trap env =
+    Func.share_code2 Func.Always env "ic_trap" (("ptr", I64Type), ("len", I64Type)) [] (fun env get_ptr get_length ->
+      get_ptr ^^
+      get_length ^^
+      system_call env "trap"
+    )
+
+  let trap_ptr_len env =
+    match E.mode env with
+    | Flags.WasmMode -> G.i Unreachable
+    | Flags.WASIMode -> print_ptr_len env ^^ G.i Unreachable
+    | Flags.ICMode | Flags.RefMode -> ic_trap env ^^ G.i Unreachable
+
+  let trap_with env s =
+    Blob.lit_ptr_len env Tagged.T s ^^ trap_ptr_len env
+
+  let trap_text env  =
+    Text.to_blob env ^^ Blob.as_ptr_len env ^^ trap_ptr_len env
+
+  let default_exports env =
+    (* these exports seem to be wanted by the hypervisor/v8 *)
+    E.add_export env (nr {
+      name = Lib.Utf8.decode (
+        match E.mode env with
+        | Flags.WASIMode -> "memory"
+        | _  -> "mem"
+      );
+      edesc = nr (MemoryExport (nr 0l))
+    });
+    E.add_export env (nr {
+      name = Lib.Utf8.decode "table";
+      edesc = nr (TableExport (nr 0l))
+    })
+
+  let export_init env =
+    assert (E.mode env = Flags.ICMode || E.mode env = Flags.RefMode);
+    let empty_f = Func.of_body env [] [] (fun env ->
+      Lifecycle.trans env Lifecycle.InInit ^^
+      G.i (Call (nr (E.built_in env "init")))
+      (* Stay in `InInit` state for asynchronous destabilization after upgrade. *)
+      (* Garbage collection is not yet activated. *)
+
+    ) in
+    let fi = E.add_fun env "canister_init" empty_f in
+    E.add_export env (nr {
+      name = Lib.Utf8.decode "canister_init";
+      edesc = nr (FuncExport (nr fi))
+      })
+
+  let export_heartbeat env =
+    assert (E.mode env = Flags.ICMode || E.mode env = Flags.RefMode);
+    let fi = E.add_fun env "canister_heartbeat"
+      (Func.of_body env [] [] (fun env ->
+        G.i (Call (nr (E.built_in env "heartbeat_exp"))) ^^
+        GC.collect_garbage env))
+    in
+    E.add_export env (nr {
+      name = Lib.Utf8.decode "canister_heartbeat";
+      edesc = nr (FuncExport (nr fi))
+    })
+
+  let export_timer env =
+    assert !Flags.global_timer;
+    assert (E.mode env = Flags.ICMode || E.mode env = Flags.RefMode);
+    let fi = E.add_fun env "canister_global_timer"
+      (Func.of_body env [] [] (fun env ->
+        G.i (Call (nr (E.built_in env "timer_exp"))) ^^
+        GC.collect_garbage env))
+    in
+    E.add_export env (nr {
+      name = Lib.Utf8.decode "canister_global_timer";
+      edesc = nr (FuncExport (nr fi))
+    })
+
+  let export_inspect env =
+    assert (E.mode env = Flags.ICMode || E.mode env = Flags.RefMode);
+    let fi = E.add_fun env "canister_inspect_message"
+      (Func.of_body env [] [] (fun env ->
+        G.i (Call (nr (E.built_in env "inspect_exp"))) ^^
+        system_call env "accept_message" (* assumes inspect_exp traps to reject *)
+        (* no need to GC !*)))
+    in
+    E.add_export env (nr {
+      name = Lib.Utf8.decode "canister_inspect_message";
+      edesc = nr (FuncExport (nr fi))
+    })
+
+  let initialize_main_actor_function_name = "@initialize_main_actor"
+
+  let initialize_main_actor env =
+    G.i (Call (nr (E.built_in env initialize_main_actor_function_name))) ^^
+    get_run_post_upgrade env ^^
+    (E.if0 
+      begin
+        Lifecycle.trans env Lifecycle.InPostUpgrade ^^
+        G.i (Call (nr (E.built_in env "post_exp"))) 
+      end
+      G.nop)
+
+  let get_actor_to_persist_function_name = "@get_actor_to_persist"
+
+  let get_actor_to_persist env =
+    G.i (Call (nr (E.built_in env get_actor_to_persist_function_name)))
+
+  let export_wasi_start env =
+    assert (E.mode env = Flags.WASIMode);
+    let fi = E.add_fun env "_start" (Func.of_body env [] [] (fun env1 ->
+      Lifecycle.trans env Lifecycle.InInit ^^
+      G.i (Call (nr (E.built_in env "init"))) ^^
+      (if !Flags.sanity then
+        (* also test the GC in WASI mode if sanity checks are enabled *)
+        GC.collect_garbage env
+      else
+        G.nop) ^^
+      Lifecycle.trans env Lifecycle.Idle
+    )) in
+    E.add_export env (nr {
+      name = Lib.Utf8.decode "_start";
+      edesc = nr (FuncExport (nr fi))
+      })
+
+  let export_upgrade_methods env =
+    if E.mode env = Flags.ICMode || E.mode env = Flags.RefMode then
+    let status_stopped = 3l in
+    let pre_upgrade_fi = E.add_fun env "pre_upgrade" (Func.of_body env [] [] (fun env ->
+      Lifecycle.trans env Lifecycle.InPreUpgrade ^^
+      (* check status is stopped or trap on outstanding callbacks *)
+      system_call env "canister_status" ^^ compile_eq32_const status_stopped ^^
+      E.if0
+       (G.nop)
+       (ContinuationTable.count env ^^
+          E.then_trap_with env "canister_pre_upgrade attempted with outstanding message callbacks (try stopping the canister before upgrade)") ^^
+      (* call pre_upgrade expression & any system method *)
+      (G.i (Call (nr (E.built_in env "pre_exp")))) ^^
+      Lifecycle.trans env Lifecycle.PostPreUpgrade
+    )) in
+
+    let post_upgrade_fi = E.add_fun env "post_upgrade" (Func.of_body env [] [] (fun env ->
+      compile_unboxed_one ^^ set_run_post_upgrade env ^^
+      Lifecycle.trans env Lifecycle.InInit ^^
+      G.i (Call (nr (E.built_in env "init")))
+      (* The post upgrade hook is called later after the completed destabilization, 
+         that may require additional explicit destabilization messages after upgrade. *)
+    )) in
+
+    E.add_export env (nr {
+      name = Lib.Utf8.decode "canister_pre_upgrade";
+      edesc = nr (FuncExport (nr pre_upgrade_fi))
+    });
+
+    E.add_export env (nr {
+      name = Lib.Utf8.decode "canister_post_upgrade";
+      edesc = nr (FuncExport (nr post_upgrade_fi))
+    })
+
+
+  let get_self_reference env =
+    match E.mode env with
+    | Flags.ICMode | Flags.RefMode ->
+      Func.share_code0 Func.Never env "canister_self" [I64Type] (fun env ->
+        Blob.of_size_copy env Tagged.A
+          (fun env -> 
+            system_call env "canister_self_size")
+          (fun env ->
+            system_call env "canister_self_copy")
+          (fun env -> compile_unboxed_const 0L)
+      )
+    | _ ->
+      E.trap_with env "cannot get self-actor-reference when running locally"
+
+  let get_system_time env =
+    match E.mode env with
+    | Flags.ICMode | Flags.RefMode ->
+      system_call env "time"
+    | _ ->
+      E.trap_with env "cannot get system time when running locally"
+
+  let caller env =
+    match E.mode env with
+    | Flags.ICMode | Flags.RefMode ->
+      Blob.of_size_copy env Tagged.P
+        (fun env -> 
+          system_call env "msg_caller_size")
+        (fun env -> 
+          system_call env "msg_caller_copy")
+        (fun env -> compile_unboxed_const 0L)
+    | _ ->
+      E.trap_with env (Printf.sprintf "cannot get caller when running locally")
+
+  let method_name env =
+    match E.mode env with
+    | Flags.ICMode | Flags.RefMode ->
+      Blob.of_size_copy env Tagged.T
+        (fun env -> 
+          system_call env "msg_method_name_size")
+        (fun env ->
+          system_call env "msg_method_name_copy")
+        (fun env -> compile_unboxed_const 0L)
+    | _ ->
+      E.trap_with env (Printf.sprintf "cannot get method_name when running locally")
+
+  let arg_data env =
+    match E.mode env with
+    | Flags.ICMode | Flags.RefMode ->
+      Blob.of_size_copy env Tagged.B
+        (fun env -> 
+          system_call env "msg_arg_data_size")
+        (fun env -> 
+          system_call env "msg_arg_data_copy")
+        (fun env -> compile_unboxed_const 0L)
+    | _ ->
+      E.trap_with env (Printf.sprintf "cannot get arg_data when running locally")
+
+  let reject env arg_instrs =
+    match E.mode env with
+    | Flags.ICMode | Flags.RefMode ->
+      arg_instrs ^^
+      Text.to_blob env ^^
+      Blob.as_ptr_len env ^^
+      system_call env "msg_reject"
+    | _ ->
+      E.trap_with env (Printf.sprintf "cannot reject when running locally")
+
+  let error_code env =
+     Func.share_code0 Func.Always env "error_code" [I64Type] (fun env ->
+      let (set_code, get_code) = new_local env "code" in
+      system_call env "msg_reject_code" ^^ 
+      G.i (Convert (Wasm_exts.Values.I64 I64Op.ExtendUI32)) ^^
+      set_code ^^
+      List.fold_right (fun (tag, const) code ->
+        get_code ^^ compile_unboxed_const const ^^
+        compile_comparison I64Op.Eq ^^
+        E.if1 I64Type
+          (Variant.inject env tag (Tuple.compile_unit env))
+          code)
+        ["system_fatal", 1L;
+         "system_transient", 2L;
+         "destination_invalid", 3L;
+         "canister_reject", 4L;
+         "canister_error", 5L]
+        (Variant.inject env "future" (get_code ^^ BitTagged.tag env Type.Nat32)))
+
+  let error_message env =
+    Func.share_code0 Func.Never env "error_message" [I64Type] (fun env ->
+      Blob.of_size_copy env Tagged.T
+        (fun env -> system_call env "msg_reject_msg_size")
+        (fun env ->
+          system_call env "msg_reject_msg_copy")
+        (fun env -> compile_unboxed_const 0L)
+    )
+
+  let error_value env =
+    Func.share_code0 Func.Never env "error_value" [I64Type] (fun env ->
+      error_code env ^^
+      error_message env ^^
+      Tuple.from_stack env 2
+    )
+
+  let reply_with_data env =
+    Func.share_code2 Func.Never env "reply_with_data" (("start", I64Type), ("size", I64Type)) [] (
+      fun env get_data_start get_data_size ->
+        get_data_start ^^
+        get_data_size ^^
+        system_call env "msg_reply_data_append" ^^
+        system_call env "msg_reply"
+   )
+  
+  let static_nullary_reply env =
+    Blob.lit_ptr_len env Tagged.B "DIDL\x00\x00" ^^
+    reply_with_data env
+
+  (* Actor reference on the stack *)
+  let actor_public_field env name =
+    (* simply tuple canister name and function name *)
+    Tagged.(sanity_check_tag __LINE__ env (Blob A)) ^^
+    Blob.lit env Tagged.T name ^^
+    Func.share_code2 Func.Never env "actor_public_field" (("actor", I64Type), ("func", I64Type)) [] (
+      fun env get_actor get_func ->
+      Arr.lit env Tagged.S [get_actor; get_func]
+   )
+
+
+  let fail_assert env at =
+    let open Source in
+    let at = {
+        left = {at.left with file = Filename.basename at.left.file};
+        right = {at.right with file = Filename.basename at.right.file}
+      }
+    in
+    E.trap_with env (Printf.sprintf "assertion failed at %s" (string_of_region at))
+
+  let async_method_name = Type.(motoko_async_helper_fld.lab)
+  let gc_trigger_method_name = Type.(motoko_gc_trigger_fld.lab)
+ 
+  let is_self_call env =
+    let (set_len_self, get_len_self) = new_local env "len_self" in
+    let (set_len_caller, get_len_caller) = new_local env "len_caller" in
+    system_call env "canister_self_size" ^^ set_len_self ^^
+    system_call env "msg_caller_size" ^^ set_len_caller ^^
+    get_len_self ^^ get_len_caller ^^ compile_comparison I64Op.Eq ^^
+    E.if1 I64Type
+      begin
+        get_len_self ^^ Stack.dynamic_with_bytes env "str_self" (fun get_str_self ->
+          get_len_caller ^^ Stack.dynamic_with_bytes env "str_caller" (fun get_str_caller ->
+            get_str_caller ^^ compile_unboxed_const 0L ^^ get_len_caller ^^
+            system_call env "msg_caller_copy" ^^
+            get_str_self ^^ compile_unboxed_const 0L ^^ get_len_self ^^
+            system_call env "canister_self_copy" ^^
+            get_str_self ^^ get_str_caller ^^ get_len_self ^^ Heap.memcmp env ^^
+            compile_eq_const 0L))
+      end
+      begin
+        compile_unboxed_const 0L
+      end
+
+  let assert_caller_self env =
+    is_self_call env ^^
+    E.else_trap_with env "not a self-call"
+
+  let is_controller_call env =
+    let (set_len_caller, get_len_caller) = new_local env "len_caller" in
+    system_call env "msg_caller_size" ^^ set_len_caller ^^
+    get_len_caller ^^ Stack.dynamic_with_bytes env "str_caller" (fun get_str_caller ->
+      get_str_caller ^^ compile_unboxed_const 0L ^^ get_len_caller ^^
+      system_call env "msg_caller_copy" ^^
+      get_str_caller ^^ get_len_caller ^^ is_controller env)
+
+  let assert_caller_self_or_controller env =
+    is_self_call env ^^
+    is_controller_call env ^^
+    G.i (Binary (Wasm_exts.Values.I64 I64Op.Or)) ^^
+    E.else_trap_with env "not a self-call or call from controller"
+
+  (* Cycles *)
+
+  let cycle_balance env =
+    match E.mode env with
+    | Flags.ICMode
+    | Flags.RefMode ->
+      system_call env "canister_cycle_balance128"
+    | _ ->
+      E.trap_with env "cannot read balance when running locally"
+
+  let cycles_add env =
+    match E.mode env with
+    | Flags.ICMode
+    | Flags.RefMode ->
+      system_call env "call_cycles_add128"
+    | _ ->
+      E.trap_with env "cannot accept cycles when running locally"
+
+  let cycles_accept env =
+    match E.mode env with
+    | Flags.ICMode
+    | Flags.RefMode ->
+      system_call env "msg_cycles_accept128"
+    | _ ->
+      E.trap_with env "cannot accept cycles when running locally"
+
+  let cycles_available env =
+    match E.mode env with
+    | Flags.ICMode
+    | Flags.RefMode ->
+      system_call env "msg_cycles_available128"
+    | _ ->
+      E.trap_with env "cannot get cycles available when running locally"
+
+  let cycles_refunded env =
+    match E.mode env with
+    | Flags.ICMode
+    | Flags.RefMode ->
+      system_call env "msg_cycles_refunded128"
+    | _ ->
+      E.trap_with env "cannot get cycles refunded when running locally"
+
+  let set_certified_data env =
+    match E.mode env with
+    | Flags.ICMode
+    | Flags.RefMode ->
+      Blob.as_ptr_len env ^^
+      system_call env "certified_data_set"
+    | _ ->
+      E.trap_with env "cannot set certified data when running locally"
+
+  let get_certificate env =
+    match E.mode env with
+    | Flags.ICMode
+    | Flags.RefMode ->
+      system_call env "data_certificate_present" ^^
+      Bool.from_rts_int32 ^^
+      E.if1 I64Type
+      begin
+        Opt.inject_simple env (
+          Blob.of_size_copy env Tagged.B
+            (fun env -> 
+              system_call env "data_certificate_size")
+            (fun env -> 
+              system_call env "data_certificate_copy")
+            (fun env -> compile_unboxed_const 0L)
+        )
+      end (Opt.null_lit env)
+    | _ ->
+      E.trap_with env "cannot get certificate when running locally"
+
+end (* IC *)
+
+module Cycles = struct
+
+  let from_word128_ptr env = Func.share_code1 Func.Never env "from_word128_ptr" ("ptr", I64Type) [I64Type]
+    (fun env get_ptr ->
+     let set_lower, get_lower = new_local env "lower" in
+     get_ptr ^^
+     G.i (Load {ty = I64Type; align = 0; offset = 0L; sz = None }) ^^
+     BigNum.from_word64 env ^^
+     set_lower ^^
+     get_ptr ^^
+     G.i (Load {ty = I64Type; align = 0; offset = 8L; sz = None }) ^^
+     compile_test I64Op.Eqz ^^
+     E.if1 I64Type
+       get_lower
+       begin
+         get_lower ^^
+         get_ptr ^^
+         G.i (Load {ty = I64Type; align = 0; offset = 8L; sz = None }) ^^
+         BigNum.from_word64 env ^^
+         (* shift left 64 bits *)
+         compile_unboxed_const 64L ^^
+         TaggedSmallWord.msb_adjust Type.Nat32 ^^
+         BigNum.compile_lsh env ^^
+         BigNum.compile_add env
+       end)
+
+  (* takes a bignum from the stack, traps if ≥2^128, and leaves two 64bit words on the stack *)
+  (* only used twice, so ok to not use share_code1; that would require I64Type support in FakeMultiVal *)
+  let to_two_word64 env =
+    let (set_val, get_val) = new_local env "cycles" in
+    set_val ^^
+    get_val ^^
+    Tagged.materialize_shared_value env (BigNum.constant env (Big_int.power_int_positive_int 2 128)) ^^
+    BigNum.compile_relop env Lt ^^
+    E.else_trap_with env "cycles out of bounds" ^^
+
+    get_val ^^
+    (* shift right 64 bits *)
+    compile_unboxed_const 64L ^^
+    TaggedSmallWord.msb_adjust Type.Nat32 ^^
+    BigNum.compile_rsh env ^^
+    BigNum.truncate_to_word64 env ^^
+
+    get_val ^^
+    BigNum.truncate_to_word64 env
+
+  let balance env =
+    Func.share_code0 Func.Always env "cycle_balance" [I64Type] (fun env ->
+      Stack.with_words env "dst" 4L (fun get_dst ->
+        get_dst ^^
+        IC.cycle_balance env ^^
+        get_dst ^^
+        from_word128_ptr env
+      )
+    )
+
+  let add env =
+    Func.share_code1 Func.Always env "cycle_add" ("cycles", I64Type) [] (fun env get_x ->
+      get_x ^^
+      to_two_word64 env ^^
+      IC.cycles_add env
+    )
+
+  let accept env =
+    Func.share_code1 Func.Always env "cycle_accept" ("cycles", I64Type) [I64Type] (fun env get_x ->
+      Stack.with_words env "dst" 4L (fun get_dst ->
+        get_x ^^
+        to_two_word64 env ^^
+        get_dst ^^
+        IC.cycles_accept env ^^
+        get_dst ^^
+        from_word128_ptr env
+      )
+    )
+
+  let available env =
+    Func.share_code0 Func.Always env "cycle_available" [I64Type] (fun env ->
+      Stack.with_words env "dst" 4L (fun get_dst ->
+        get_dst ^^
+        IC.cycles_available env ^^
+        get_dst ^^
+        from_word128_ptr env
+      )
+    )
+
+  let refunded env =
+    Func.share_code0 Func.Always env "cycle_refunded" [I64Type] (fun env ->
+      Stack.with_words env "dst" 4L (fun get_dst ->
+        get_dst ^^
+        IC.cycles_refunded env ^^
+        get_dst ^^
+        from_word128_ptr env
+      )
+    )
+
+end (* Cycles *)
+
+(* Low-level, almost raw access to IC stable memory.
+   Essentially a virtual page allocator
+   * enforcing limit --max-stable-pages not exceeded
+   * tracking virtual page count, ignoring physical pages added for stable variable serialization (global`__stable_mem_size`)
+   * recording current format of contents (global `__stable_version`)
+   Used to implement stable variable serialization, (experimental) stable memory library and Region type (see region.rs)
+*)
+module StableMem = struct
+
+
+  (* Raw stable memory API,
+     using ic0.stable64_xxx or
+     emulating via (for now) 64-bit memory 1
+  *)
+  let stable64_grow env =
+    E.require_stable_memory env;
+    match E.mode env with
+    | Flags.ICMode | Flags.RefMode ->
+       IC.system_call env "stable64_grow"
+    | _ ->
+       Func.share_code1 Func.Always env "stable64_grow" ("pages", I64Type) [I64Type]
+         (fun env get_pages ->
+          let set_old_pages, get_old_pages = new_local env "old_pages" in
+          get_pages ^^
+          G.i StableGrow ^^
+          set_old_pages ^^
+          get_old_pages ^^
+          compile_unboxed_const (-1L) ^^
+          compile_comparison I64Op.Eq ^^
+          E.if1 I64Type
+            begin
+             compile_unboxed_const (-1L)
+            end
+            begin
+              get_old_pages
+            end)
+
+  let stable64_size env =
+    E.require_stable_memory env;
+    match E.mode env with
+    | Flags.ICMode | Flags.RefMode ->
+       IC.system_call env "stable64_size"
+    | _ ->
+       Func.share_code0 Func.Always env "stable64_size" [I64Type]
+         (fun env ->
+          G.i StableSize)
+
+  let stable64_read env =
+    E.require_stable_memory env;
+    match E.mode env with
+    | Flags.ICMode | Flags.RefMode ->
+       IC.system_call env "stable64_read"
+    | _ ->
+       Func.share_code3 Func.Always env "stable64_read"
+         (("dst", I64Type), ("offset", I64Type), ("size", I64Type)) []
+         (fun env get_dst get_offset get_size ->
+          get_dst ^^
+          get_offset ^^
+          get_size ^^
+          G.i StableRead)
+
+  let stable64_write env =
+    E.require_stable_memory env;
+    match E.mode env with
+    | Flags.ICMode | Flags.RefMode ->
+       IC.system_call env "stable64_write"
+    | _ ->
+       Func.share_code3 Func.Always env "stable64_write"
+         (("offset", I64Type), ("src", I64Type), ("size", I64Type)) []
+         (fun env get_offset get_src get_size ->
+          get_offset ^^
+          get_src ^^
+          get_size ^^
+          G.i StableWrite)
+
+
+  (* Versioning (c.f. Region.rs) *)
+  (* NB: these constants must agree with the constants in Region.rs *)
+  let legacy_version_no_stable_memory = Int64.of_int 0 (* never manifest in serialized form *)
+  let legacy_version_some_stable_memory = Int64.of_int 1
+  let legacy_version_regions = Int64.of_int 2
+  let version_graph_copy_no_regions = Int64.of_int 3
+  let version_graph_copy_regions = Int64.of_int 4
+  let version_stable_heap_no_regions = Int64.of_int 5
+  let version_stable_heap_regions = Int64.of_int 6
+  let version_max = version_stable_heap_regions
+
+  let register_globals env =
+    (* size (in pages) *)
+    E.add_global64 env "__stablemem_size" Mutable 0L;
+    E.add_global64 env "__stablemem_version" Mutable version_stable_heap_no_regions
+
+  let get_mem_size env =
+    G.i (GlobalGet (nr (E.get_global env "__stablemem_size")))
+
+  let set_mem_size env =
+    G.i (GlobalSet (nr (E.get_global env "__stablemem_size")))
+
+  let get_version env =
+    G.i (GlobalGet (nr (E.get_global env "__stablemem_version")))
+
+  let set_version env =
+    G.i (GlobalSet (nr (E.get_global env "__stablemem_version")))
+
+  let region_init env =
+    compile_unboxed_const (if !Flags.use_stable_regions then 1L else 0L) ^^
+    E.call_import env "rts" "region_init"
+
+  (* stable memory bounds check *)
+  let guard env =
+       get_mem_size env ^^
+       compile_unboxed_const (Int64.of_int page_size_bits) ^^
+       G.i (Binary (Wasm_exts.Values.I64 I64Op.Shl)) ^^
+       compile_comparison I64Op.GeU ^^
+       E.then_trap_with env "StableMemory offset out of bounds"
+
+  (* check both offset and [offset,.., offset + size) within bounds *)
+  (* c.f. region.rs check_relative_range *)
+  (* TODO: specialize on size *)
+  let guard_range env =
+      Func.share_code2 Func.Always env "__stablemem_guard_range"
+        (("offset", I64Type), ("size", I64Type)) []
+        (fun env get_offset get_size ->
+          get_size ^^
+          compile_unboxed_one ^^
+          compile_comparison I64Op.LeU ^^
+          E.if0 begin
+            get_offset ^^
+            guard env
+          end
+          begin
+            compile_unboxed_const (Int64.minus_one) ^^
+            get_size ^^
+            G.i (Binary (Wasm_exts.Values.I64 I64Op.Sub)) ^^
+            get_offset ^^
+            compile_comparison I64Op.LtU ^^
+            E.then_trap_with env "StableMemory range overflow" ^^
+            get_offset ^^
+            get_size ^^
+            G.i (Binary (Wasm_exts.Values.I64 I64Op.Add)) ^^
+            get_mem_size env ^^
+            compile_unboxed_const (Int64.of_int page_size_bits) ^^
+            G.i (Binary (Wasm_exts.Values.I64 I64Op.Shl)) ^^
+            compile_comparison I64Op.GtU ^^
+            E.then_trap_with env "StableMemory range out of bounds"
+          end)
+
+  let add_guard env guarded get_offset bytes =
+    if guarded then
+     (get_offset ^^
+      if bytes = 1L then
+        guard env
+      else
+        compile_unboxed_const bytes ^^
+        guard_range env)
+    else G.nop
+
+  (* TODO: crusso in read/write could avoid stack allocation by reserving and re-using scratch memory instead *)
+  let read env guarded name typ bytes load =
+      Func.share_code1 Func.Never env (Printf.sprintf "__stablemem_%sread_%s" (if guarded then "guarded_" else "") name)
+        ("offset", I64Type) [typ]
+        (fun env get_offset ->
+          let words = Int64.div (Int64.add bytes 3L) 4L in
+          add_guard env guarded get_offset bytes ^^
+          Stack.with_words env "temp_ptr" words (fun get_temp_ptr ->
+            get_temp_ptr ^^
+            get_offset ^^
+            compile_unboxed_const bytes ^^
+            stable64_read env ^^
+            get_temp_ptr ^^ load))
+
+  let write env guarded name typ bytes store =
+      Func.share_code2 Func.Never env (Printf.sprintf "__stablemem_%swrite_%s" (if guarded then "guarded_" else "") name)
+        (("offset", I64Type), ("value", typ)) []
+        (fun env get_offset get_value ->
+          let words = Int64.div (Int64.add bytes 3L) 4L in
+          add_guard env guarded get_offset bytes ^^
+          Stack.with_words env "temp_ptr" words (fun get_temp_ptr ->
+            get_temp_ptr ^^ get_value ^^ store ^^
+            get_offset ^^
+            get_temp_ptr ^^
+            compile_unboxed_const bytes ^^
+            stable64_write env))
+
+  let load_word32 = G.i (Load {ty = I32Type; align = 0; offset = 0L; sz = None})
+  let store_word32 : G.t = G.i (Store {ty = I32Type; align = 0; offset = 0L; sz = None})  
+
+  let write_word32 env =
+    write env false "word32" I32Type 4L store_word32
+
+  let write_word64 env =
+    write env false "word64" I64Type 8L store_unskewed_ptr
+
+  let read_word32 env =
+    read env false "word32" I32Type 4L load_word32
+  
+  let read_word64 env =
+    read env false "word64" I64Type 8L load_unskewed_ptr
+  
+  (* ensure_pages : ensure at least num pages allocated,
+     growing (real) stable memory if needed *)
+  let ensure_pages env =
+      Func.share_code1 Func.Always env "__stablemem_ensure_pages"
+        ("pages", I64Type) [I64Type]
+        (fun env get_pages ->
+          let (set_size, get_size) = new_local env "size" in
+          let (set_pages_needed, get_pages_needed) = new_local env "pages_needed" in
+
+          stable64_size env ^^
+          set_size ^^
+
+          get_pages ^^
+          get_size ^^
+          G.i (Binary (Wasm_exts.Values.I64 I64Op.Sub)) ^^
+          set_pages_needed ^^
+
+          get_pages_needed ^^
+          compile_unboxed_const 0L ^^
+          compile_comparison I64Op.GtS ^^
+          E.if1 I64Type
+            (get_pages_needed ^^
+             stable64_grow env)
+            get_size)
+
+      (* ensure stable memory includes [offset..offset+size), assumes size > 0 *)
+  let ensure env =
+      Func.share_code2 Func.Always env "__stablemem_ensure"
+        (("offset", I64Type), ("size", I64Type)) []
+        (fun env get_offset get_size ->
+          let (set_sum, get_sum) = new_local env "sum" in
+          get_offset ^^
+          get_size ^^
+          G.i (Binary (Wasm_exts.Values.I64 I64Op.Add)) ^^
+          set_sum ^^
+          (* check for overflow *)
+          get_sum ^^
+          get_offset ^^
+          compile_comparison I64Op.LtU ^^
+          E.then_trap_with env "Range overflow" ^^
+          (* ensure page *)
+          get_sum ^^
+          compile_unboxed_const (Int64.of_int page_size_bits) ^^
+          G.i (Binary (Wasm_exts.Values.I64 I64Op.ShrU)) ^^
+          compile_add_const 1L ^^
+          ensure_pages env ^^
+          (* Check result *)
+          compile_unboxed_const 0L ^^
+          compile_comparison I64Op.LtS ^^
+          E.then_trap_with env "Out of stable memory.")
+
+  (* low-level grow, respecting --max-stable-pages *)
+  let grow env =
+      Func.share_code1 Func.Always env "__stablemem_grow"
+        ("pages", I64Type) [I64Type] (fun env get_pages ->
+          let (set_size, get_size) = new_local env "size" in
+          get_mem_size env ^^
+          set_size ^^
+
+          (* check within --max-stable-pages *)
+          get_size ^^
+          get_pages ^^
+          G.i (Binary (Wasm_exts.Values.I64 I64Op.Add)) ^^
+          compile_unboxed_const (Int64.of_int (!Flags.max_stable_pages)) ^^
+          compile_comparison I64Op.GtU ^^
+          E.if1 I64Type
+            begin
+             compile_unboxed_const (-1L) ^^
+             G.i Return
+            end
+            begin
+              let (set_new_size, get_new_size) = new_local env "new_size" in
+              get_size ^^
+              get_pages ^^
+              G.i (Binary (Wasm_exts.Values.I64 I64Op.Add)) ^^
+              set_new_size ^^
+
+              (* physical grow if necessary *)
+              let (set_ensured, get_ensured) = new_local env "ensured" in
+              get_new_size ^^
+              ensure_pages env ^^
+              set_ensured ^^
+
+              (* Check result *)
+              get_ensured ^^
+              compile_unboxed_const 0L ^^
+              compile_comparison I64Op.LtS ^^
+              E.if1 I64Type
+                ((* propagate failure -1; preserve logical size *)
+                 get_ensured)
+                ((* update logical size *)
+                 get_new_size ^^
+                 set_mem_size env ^^
+                 (* return old logical size *)
+                 get_size)
+            end)
+
+  let load_word32 env =
+    read env true "word32" I32Type 4L
+      (G.i (Load {ty = I32Type; align = 0; offset = 0L; sz = None }))
+  let store_word32 env =
+    write env true "word32" I32Type 4L
+      (G.i (Store {ty = I32Type; align = 0; offset = 0L; sz = None}))
+
+  let load_word8 env =
+    read env true "word8" I32Type 1L
+      (G.i (Load {ty = I32Type; align = 0; offset = 0L; sz = Some Wasm_exts.Types.(Pack8, ZX)}))
+  let store_word8 env =
+    write env true "word8" I32Type 1L
+      (G.i (Store {ty = I32Type; align = 0; offset = 0L; sz = None}))
+
+  let load_word16 env =
+    read env true "word16" I32Type 2L
+      (G.i (Load {ty = I32Type; align = 0; offset = 0L; sz = Some Wasm_exts.Types.(Pack16, ZX)}))
+  let store_word16 env =
+    write env true "word16" I32Type 2L
+      (G.i (Store {ty = I32Type; align = 0; offset = 0L; sz = None}))
+
+  let load_word64 env =
+    read env true "word64" I64Type 8L load_unskewed_ptr
+  let store_word64 env =
+    write env true "word64" I64Type 8L store_unskewed_ptr
+
+  let load_float64 env =
+    read env true "float64" F64Type 8L
+      (G.i (Load {ty = F64Type; align = 0; offset = 0L; sz = None }))
+  let store_float64 env =
+    write env true "float64" F64Type 8L
+      (G.i (Store {ty = F64Type; align = 0; offset = 0L; sz = None}))
+
+  let load_blob env =
+      Func.share_code2 Func.Always env "__stablemem_load_blob"
+        (("offset", I64Type), ("len", I64Type)) [I64Type]
+        (fun env get_offset get_len ->
+          let (set_blob, get_blob) = new_local env "blob" in
+          get_offset ^^
+          get_len ^^
+          guard_range env ^^
+          Blob.alloc env Tagged.B get_len ^^ set_blob ^^
+          get_blob ^^ Blob.payload_ptr_unskewed env ^^
+          get_offset ^^
+          get_len ^^
+          stable64_read env ^^
+          get_blob)
+
+  let store_blob env =
+      Func.share_code2 Func.Always env "__stablemem_store_blob"
+        (("offset", I64Type), ("blob", I64Type)) []
+        (fun env get_offset get_blob ->
+         let (set_len, get_len) = new_local env "len" in
+          get_blob ^^ Blob.len env ^^ set_len ^^
+          get_offset ^^
+          get_len ^^
+          guard_range env ^^
+          get_offset ^^
+          get_blob ^^ Blob.payload_ptr_unskewed env ^^
+          get_len ^^
+          stable64_write env)
+
+end (* StableMem *)
+
+(* StableMemoryInterface *)
+(* Core, legacy interface to IC stable memory, used to implement prims `stableMemoryXXX` of
+   library `ExperimentalStableMemory.mo`.
+   Each operation dispatches on the state of `StableMem.get_version()`.
+   * StableMem.version_stable_heap_no_regions
+     * use StableMem directly.
+   * StableMem.version_stable_heap_regions: use Region.mo
+*)
+module StableMemoryInterface = struct
+
+  (* Helpers *)
+  let get_region0 env = E.call_import env "rts" "region0_get"
+
+  let if_regions env args tys is1 is2 =
+    StableMem.get_version env ^^
+    compile_unboxed_const StableMem.version_stable_heap_regions ^^
+    compile_comparison I64Op.Eq ^^
+    E.if_ env tys
+      (get_region0 env ^^ args ^^ is1 env)
+      (args ^^ is2 env)
+
+  (* Prims *)
+  let size env =
+    E.require_stable_memory env;
+    Func.share_code0 Func.Always env "__stablememory_size" [I64Type]
+      (fun env ->
+        if_regions env
+          G.nop
+          [I64Type]
+          Region.size
+          StableMem.get_mem_size)
+
+  let grow env =
+    E.require_stable_memory env;
+    Func.share_code1 Func.Always env "__stablememory_grow" ("pages", I64Type) [I64Type]
+      (fun env get_pages ->
+        if_regions env
+          get_pages
+          [I64Type]
+          Region.grow
+          (fun env ->
+            (* logical grow *)
+            StableMem.grow env))
+
+  let load_blob env =
+    E.require_stable_memory env;
+    Func.share_code2 Func.Never env "__stablememory_load_blob"
+      (("offset", I64Type), ("len", I64Type)) [I64Type]
+      (fun env offset len ->
+        if_regions env
+          (offset ^^ len)
+          [I64Type]
+          Region.load_blob
+          StableMem.load_blob)
+  let store_blob env =
+    E.require_stable_memory env;
+    Func.share_code2 Func.Never env "__stablememory_store_blob"
+      (("offset", I64Type), ("blob", I64Type)) []
+      (fun env offset blob ->
+        if_regions env
+          (offset ^^ blob)
+          []
+          Region.store_blob
+          StableMem.store_blob)
+
+  let load_word8 env =
+    E.require_stable_memory env;
+    Func.share_code1 Func.Never env "__stablememory_load_word8"
+      ("offset", I64Type) [I32Type]
+      (fun env offset ->
+        if_regions env
+          offset
+          [I32Type]
+          Region.load_word8
+          StableMem.load_word8)
+  let store_word8 env =
+    E.require_stable_memory env;
+    Func.share_code2 Func.Never env "__stablememory_store_word8"
+      (("offset", I64Type), ("value", I32Type)) []
+      (fun env offset value ->
+        if_regions env
+          (offset ^^ value)
+          []
+          Region.store_word8
+          StableMem.store_word8)
+
+  let load_word16 env =
+    E.require_stable_memory env;
+    Func.share_code1 Func.Never env "__stablememory_load_word16"
+      ("offset", I64Type) [I32Type]
+      (fun env offset->
+        if_regions env
+          offset
+          [I32Type]
+          Region.load_word16
+          StableMem.load_word16)
+  let store_word16 env =
+    E.require_stable_memory env;
+    Func.share_code2 Func.Never env "__stablememory_store_word16"
+      (("offset", I64Type), ("value", I32Type)) []
+      (fun env offset value ->
+        if_regions env
+          (offset ^^ value)
+          []
+          Region.store_word16
+          StableMem.store_word16)
+
+  let load_word32 env =
+    E.require_stable_memory env;
+    Func.share_code1 Func.Never env "__stablememory_load_word32"
+      ("offset", I64Type) [I32Type]
+      (fun env offset ->
+        if_regions env
+          offset
+          [I32Type]
+          Region.load_word32
+          StableMem.load_word32)
+  let store_word32 env =
+    E.require_stable_memory env;
+    Func.share_code2 Func.Never env "__stablememory_store_word32"
+      (("offset", I64Type), ("value", I32Type)) []
+      (fun env offset value ->
+        if_regions env
+          (offset ^^ value)
+          []
+          Region.store_word32
+          StableMem.store_word32)
+
+  let load_word64 env =
+    E.require_stable_memory env;
+    Func.share_code1 Func.Never env "__stablememory_load_word64" ("offset", I64Type) [I64Type]
+      (fun env offset ->
+        if_regions env
+          offset
+          [I64Type]
+          Region.load_word64
+          StableMem.load_word64)
+  let store_word64 env =
+    E.require_stable_memory env;
+    Func.share_code2 Func.Never env "__stablememory_store_word64"
+      (("offset", I64Type), ("value", I64Type)) []
+      (fun env offset value ->
+        if_regions env
+          (offset ^^ value)
+          []
+          Region.store_word64
+          StableMem.store_word64)
+
+  let load_float64 env =
+    E.require_stable_memory env;
+    Func.share_code1 Func.Never env "__stablememory_load_float64"
+      ("offset", I64Type) [F64Type]
+      (fun env offset ->
+        if_regions env
+          offset
+          [F64Type]
+          Region.load_float64
+          StableMem.load_float64)
+  let store_float64 env =
+    Func.share_code2 Func.Never env "__stablememory_store_float64"
+      (("offset", I64Type), ("value", F64Type)) []
+      (fun env offset value ->
+        if_regions env
+          (offset ^^ value)
+          []
+          Region.store_float64
+          StableMem.store_float64)
+
+end
+
+module UpgradeStatistics = struct
+  let get_upgrade_instructions env =
+    E.call_import env "rts" "get_upgrade_instructions"
+  let set_upgrade_instructions env =
+    E.call_import env "rts" "set_upgrade_instructions"
+
+  let add_instructions env =
+    get_upgrade_instructions env ^^
+    GC.instruction_counter env ^^
+    G.i (Binary (Wasm_exts.Values.I64 I64Op.Add)) ^^
+    set_upgrade_instructions env
+
+  let set_instructions env =
+    GC.instruction_counter env ^^
+    set_upgrade_instructions env
+end
+
+module RTS_Exports = struct
+  (* Must be called late, after main codegen, to ensure correct generation of
+     of functioning or unused-but-trapping stable memory exports (as required)
+   *)
+  let system_exports env =
+
+    (* Value constructors *)
+
+    let int_from_i64_fi = E.add_fun env "int_from_i64" (
+      Func.of_body env ["v", I64Type] [I64Type] (fun env ->
+        let get_v = G.i (LocalGet (nr 0l)) in
+        get_v ^^ BigNum.from_signed_word64 env
+      )
+    ) in
+    E.add_export env (nr {
+      name = Lib.Utf8.decode "int_from_i64";
+      edesc = nr (FuncExport (nr int_from_i64_fi))
+    });
+
+    (* Traps *)
+
+    let bigint_trap_fi = E.add_fun env "bigint_trap" (
+      Func.of_body env [] [] (fun env ->
+        E.trap_with env "bigint function error"
+      )
+    ) in
+    E.add_export env (nr {
+      name = Lib.Utf8.decode "bigint_trap";
+      edesc = nr (FuncExport (nr bigint_trap_fi))
+    });
+
+    (* Keep a memory reserve when in update or init state.
+       This reserve can be used by queries, composite queries, and upgrades. *)
+    let keep_memory_reserve_fi = E.add_fun env "keep_memory_reserve" (
+      Func.of_body env [] [I32Type] (fun env ->
+        Lifecycle.get env ^^
+        compile_eq_const Lifecycle.(int_of_state InUpdate) ^^
+        Lifecycle.get env ^^
+        compile_eq_const Lifecycle.(int_of_state InInit) ^^
+        G.i (Binary (Wasm_exts.Values.I64 I64Op.Or)) ^^
+        Bool.to_rts_int32
+      )
+    ) in
+    E.add_export env (nr {
+      name = Lib.Utf8.decode "keep_memory_reserve";
+      edesc = nr (FuncExport (nr keep_memory_reserve_fi))
+    });
+
+    let rts_trap_fi = E.add_fun env "rts_trap" (
+      (* `libc` still uses 32-bit length parameter for `rts_trap` *)
+      Func.of_body env ["str", I64Type; "len", I32Type] [] (fun env ->
+        let get_str = G.i (LocalGet (nr 0l)) in
+        let get_len = G.i (LocalGet (nr 1l)) in
+        get_str ^^ 
+        get_len ^^ 
+        G.i (Convert (Wasm_exts.Values.I64 I64Op.ExtendUI32)) ^^
+        IC.trap_ptr_len env
+      )
+    ) in
+    E.add_export env (nr {
+      name = Lib.Utf8.decode "rts_trap";
+      edesc = nr (FuncExport (nr rts_trap_fi))
+    });
+
+    let ic0_performance_counter_fi =
+      if E.mode env = Flags.WASIMode then
+        E.add_fun env "ic0_performance_counter" (
+            Func.of_body env ["number", I32Type] [I64Type]
+              (fun env ->
+                E.trap_with env "ic0_performance_counter is not supposed to be called in WASI"
+              )
+          )
+      else E.reuse_import env "ic0" "performance_counter" in
+    E.add_export env (nr {
+      name = Lib.Utf8.decode "ic0_performance_counter";
+      edesc = nr (FuncExport (nr ic0_performance_counter_fi))
+    });
+
+    (* Keep a memory reserve when in update or init state. 
+    This reserve can be used by queries, composite queries, and (graph-copy) upgrades. *)
+    let keep_memory_reserve_fi = E.add_fun env "keep_memory_reserve" (
+      Func.of_body env [] [I32Type] (fun env ->
+        Lifecycle.(is_in int_of_state InUpdate) ^^
+        Lifecycle.(is_in int_of_state InInit) ^^
+        G.i (Binary (Wasm_exts.Values.I64 I64Op.Or)) ^^
+        Bool.to_rts_int32
+      )
+    ) in
+    E.add_export env (nr {
+      name = Lib.Utf8.decode "keep_memory_reserve";
+      edesc = nr (FuncExport (nr keep_memory_reserve_fi))
+    });
+
+    let when_stable_memory_required_else_trap env code =
+      if E.requires_stable_memory env then
+        code() else
+        E.trap_with env "unreachable" in
+
+    let ic0_stable64_write_fi =
+      match E.mode env with
+      | Flags.ICMode | Flags.RefMode ->
+        E.reuse_import env "ic0" "stable64_write"
+      | Flags.WASIMode | Flags.WasmMode ->
+        E.add_fun env "ic0_stable64_write" (
+          Func.of_body env ["offset", I64Type; "src", I64Type; "size", I64Type] []
+            (fun env ->
+              when_stable_memory_required_else_trap env (fun () ->
+               let get_offset = G.i (LocalGet (nr 0l)) in
+               let get_src = G.i (LocalGet (nr 1l)) in
+               let get_size = G.i (LocalGet (nr 2l)) in
+               get_offset ^^
+               get_src ^^
+               get_size ^^
+               StableMem.stable64_write env))
+          )
+    in
+    E.add_export env (nr {
+      name = Lib.Utf8.decode "ic0_stable64_write";
+      edesc = nr (FuncExport (nr ic0_stable64_write_fi))
+    });
+
+    let ic0_stable64_read_fi =
+      match E.mode env with
+      | Flags.ICMode | Flags.RefMode ->
+        E.reuse_import env "ic0" "stable64_read"
+      | Flags.WASIMode | Flags.WasmMode ->
+        E.add_fun env "ic0_stable64_read" (
+          Func.of_body env ["dst", I64Type; "offset", I64Type; "size", I64Type] []
+            (fun env ->
+              when_stable_memory_required_else_trap env (fun () ->
+              let get_dst = G.i (LocalGet (nr 0l)) in
+              let get_offset = G.i (LocalGet (nr 1l)) in
+              let get_size = G.i (LocalGet (nr 2l)) in
+              get_dst ^^
+              get_offset ^^
+              get_size ^^
+              StableMem.stable64_read env))
+          )
+    in
+    E.add_export env (nr {
+      name = Lib.Utf8.decode "ic0_stable64_read";
+      edesc = nr (FuncExport (nr ic0_stable64_read_fi))
+    });
+
+    let ic0_stable64_size_fi =
+      match E.mode env with
+      | Flags.ICMode | Flags.RefMode ->
+        E.reuse_import env "ic0" "stable64_size"
+      | Flags.WASIMode | Flags.WasmMode ->
+        E.add_fun env "ic0_stable64_size" (
+          Func.of_body env [] [I64Type]
+            (fun env ->
+              if E.requires_stable_memory env then
+                StableMem.stable64_size env
+              else
+                (* The RTS also checks the persistence mode on Wasi without stable memory support *)
+                compile_unboxed_const 0L
+            )
+          )
+    in
+    E.add_export env (nr {
+      name = Lib.Utf8.decode "ic0_stable64_size";
+      edesc = nr (FuncExport (nr ic0_stable64_size_fi))
+    });
+
+    let ic0_stable64_grow_fi =
+      match E.mode env with
+      | Flags.ICMode | Flags.RefMode ->
+        E.reuse_import env "ic0" "stable64_grow"
+      | Flags.WASIMode | Flags.WasmMode ->
+        E.add_fun env "ic0_stable64_grow" (
+          Func.of_body env ["newPages", I64Type] [I64Type]
+            (fun env ->
+              when_stable_memory_required_else_trap env (fun () ->
+                G.i (LocalGet (nr 0l)) ^^
+                StableMem.stable64_grow env))
+          )
+    in
+    E.add_export env (nr {
+      name = Lib.Utf8.decode "ic0_stable64_grow";
+      edesc = nr (FuncExport (nr ic0_stable64_grow_fi))
+    });
+
+    let moc_stable_mem_grow_fi =
+      E.add_fun env "moc_stable_mem_grow" (
+        Func.of_body env ["newPages", I64Type] [I64Type]
+          (fun env ->
+            when_stable_memory_required_else_trap env (fun () ->
+            G.i (LocalGet (nr 0l)) ^^
+            StableMem.grow env))
+        )
+    in
+    E.add_export env (nr {
+      name = Lib.Utf8.decode "moc_stable_mem_grow";
+      edesc = nr (FuncExport (nr moc_stable_mem_grow_fi))
+    });
+
+    let moc_stable_mem_get_size_fi =
+      E.add_fun env "moc_stable_mem_get_size" (
+        Func.of_body env [] [I64Type]
+          (fun env ->
+             when_stable_memory_required_else_trap env (fun () ->
+             StableMem.get_mem_size env))
+        )
+    in
+    E.add_export env (nr {
+      name = Lib.Utf8.decode "moc_stable_mem_get_size";
+      edesc = nr (FuncExport (nr moc_stable_mem_get_size_fi))
+    });
+
+    let moc_stable_mem_set_size_fi =
+      E.add_fun env "moc_stable_mem_set_size" (
+        Func.of_body env ["pages", I64Type] []
+          (fun env ->
+            match E.mode env with
+            | Flags.ICMode | Flags.RefMode ->
+               G.i (LocalGet (nr 0l)) ^^
+               StableMem.set_mem_size env
+            | _ ->
+               E.trap_with env "moc_stable_mem_set_size is not supposed to be called in WASI" (* improve me *)
+          )
+        )
+    in
+    E.add_export env (nr {
+      name = Lib.Utf8.decode "moc_stable_mem_set_size";
+      edesc = nr (FuncExport (nr moc_stable_mem_set_size_fi))
+    });
+
+    let moc_stable_mem_get_version_fi =
+      E.add_fun env "moc_stable_mem_get_version" (
+        Func.of_body env [] [I64Type]
+          (fun env ->
+             StableMem.get_version env)
+        )
+    in
+    E.add_export env (nr {
+      name = Lib.Utf8.decode "moc_stable_mem_get_version";
+      edesc = nr (FuncExport (nr moc_stable_mem_get_version_fi))
+    });
+
+    let moc_stable_mem_set_version_fi =
+      E.add_fun env "moc_stable_mem_set_version" (
+        Func.of_body env ["version", I64Type] []
+          (fun env ->
+             G.i (LocalGet (nr 0l)) ^^
+             StableMem.set_version env
+          )
+        )
+    in
+    E.add_export env (nr {
+      name = Lib.Utf8.decode "moc_stable_mem_set_version";
+      edesc = nr (FuncExport (nr moc_stable_mem_set_version_fi))
+      });
+
+    E.add_export env (nr {
+        name = Lib.Utf8.decode "idl_limit_check";
+        edesc = nr (FuncExport (nr (E.built_in env "idl_limit_check")))
+      })
+
+end (* RTS_Exports *)
+
+module Serialization = struct
+  (*
+    The general serialization strategy is as follows:
+    * We statically generate the IDL type description header.
+    * We traverse the data to calculate the size needed for the data buffer and the
+      reference buffer.
+    * We allocate memory for the data buffer and the reference buffer
+      (this memory area is not referenced, so will be dead with the next GC)
+    * We copy the IDL type header to the data buffer.
+    * We traverse the data and serialize it into the data buffer.
+      This is type driven, and we use the `share_code` machinery and names that
+      properly encode the type to resolve loops in a convenient way.
+    * We externalize all that new data space into a databuf
+    * We externalize the reference space into a elembuf
+    * We pass both databuf and elembuf to shared functions
+      (this mimicks the future system API)
+
+    The deserialization is analogous:
+    * We allocate some scratch space, and internalize the databuf and elembuf into it.
+    * We parse the data, in a type-driven way, using normal construction and
+      allocation, while keeping tabs on the type description header for subtyping.
+    * At the end, the scratch space is a hole in the heap, and will be reclaimed
+      by the next GC.
+  *)
+
+  module Strm = struct
+    (* Creates a fresh stream with header, storing stream token. *)
+    let create env get_data_size set_data_buf get_data_buf header =
+      let header_size = Int64.of_int (String.length header) in
+      get_data_size ^^ compile_add_const header_size ^^
+      Blob.dyn_alloc_scratch env ^^ set_data_buf ^^
+      get_data_buf ^^
+      Blob.lit env Tagged.B header ^^ Blob.payload_ptr_unskewed env ^^
+      compile_unboxed_const header_size ^^
+      Heap.memcpy env ^^
+      get_data_buf ^^ compile_add_const header_size ^^ set_data_buf
+
+    (* Checks the stream's filling, traps if unexpected *)
+    let check_filled env get_data_buf get_data_size =
+      get_data_buf ^^ get_data_size ^^ G.i (Binary (Wasm_exts.Values.I64 I64Op.Add)) ^^
+      compile_comparison I64Op.Eq ^^
+      E.else_trap_with env "data buffer not filled"
+
+    (* Finishes the stream, performing consistency checks. 
+      Returns payload address and size including the header. *)
+    let terminate env get_data_buf get_data_size header_size =
+      get_data_buf ^^ compile_sub_const header_size ^^
+      get_data_size ^^ compile_add_const header_size
+
+    (* Builds a unique name for a name seed and a type. *)
+    let name_for fn_name ts = "@" ^ fn_name ^ "<" ^ Typ_hash.typ_seq_hash ts ^ ">"
+
+    let advance_data_buf get_data_buf =
+      get_data_buf ^^ G.i (Binary (Wasm_exts.Values.I64 I64Op.Add)) ^^ G.setter_for get_data_buf
+
+    (* Pushes the stream's current absolute byte offset on stack.
+      The requirement is that the difference between two uses
+      of this method must give a correct _relative_ offset. *)
+    let absolute_offset _env get_data_buf = get_data_buf
+
+    (* Opportunity to flush or update the token. Stream token is on stack. *)
+    let checkpoint _env get_data_buf = G.setter_for get_data_buf
+
+    (* Reserve a small fixed number of bytes in the stream and return an
+       address to it. The address is invalidated by a GC, and as such must
+       be written to in the next few instructions. *)
+    let reserve _env get_data_buf bytes =
+      get_data_buf ^^ get_data_buf ^^ compile_add_const bytes ^^ G.setter_for get_data_buf
+
+    let write_word_leb env get_data_buf code =
+      let set_word, get_word = new_local env "word" in
+      code ^^ set_word ^^
+      I32Leb.compile_store_to_data_buf_unsigned env get_word get_data_buf ^^
+      advance_data_buf get_data_buf
+
+    let write_word_32 env get_data_buf code =
+      let word32_size = 4L in
+      get_data_buf ^^ code ^^ G.i (Convert (Wasm_exts.Values.I32 I32Op.WrapI64)) ^^
+      G.i (Store {ty = I32Type; align = 0; offset = 0L; sz = None}) ^^
+      compile_unboxed_const word32_size ^^ 
+      advance_data_buf get_data_buf
+
+    let write_byte _env get_data_buf code =
+      get_data_buf ^^ code ^^ G.i (Convert (Wasm_exts.Values.I32 I32Op.WrapI64)) ^^    
+      G.i (Store {ty = I32Type; align = 0; offset = 0L; sz = Some Wasm_exts.Types.Pack8}) ^^
+      compile_unboxed_const 1L ^^ advance_data_buf get_data_buf
+
+    let write_blob env get_data_buf get_x =
+      let set_len, get_len = new_local env "len" in
+      get_x ^^ Blob.len env ^^ set_len ^^
+      write_word_leb env get_data_buf get_len ^^
+      get_data_buf ^^
+      get_x ^^ Blob.payload_ptr_unskewed env ^^
+      get_len ^^
+      Heap.memcpy env ^^
+      get_len ^^ advance_data_buf get_data_buf
+
+    let write_text env get_data_buf get_x =
+      let set_len, get_len = new_local env "len" in
+      get_x ^^ Text.size env ^^ set_len ^^
+      write_word_leb env get_data_buf get_len ^^
+      get_x ^^ get_data_buf ^^ Text.to_buf env ^^
+      get_len ^^ advance_data_buf get_data_buf
+
+    let write_bignum_leb env get_data_buf get_x =
+      get_data_buf ^^
+      get_x ^^
+      BigNum.compile_store_to_data_buf_unsigned env ^^
+      advance_data_buf get_data_buf
+
+    let write_bignum_sleb env get_data_buf get_x =
+      get_data_buf ^^
+      get_x ^^
+      BigNum.compile_store_to_data_buf_signed env ^^
+      advance_data_buf get_data_buf
+  end (* Strm *)
+  (* Globals recording known Candid types
+    See Note [Candid subtype checks]
+  *)
+
+  let register_delayed_globals env =
+    (E.add_global64_delayed env "__candid_data_length" Immutable,
+    E.add_global64_delayed env "__type_offsets_length" Immutable,
+    E.add_global64_delayed env "__idl_types_length" Immutable)
+
+  let get_candid_data_length env =
+    G.i (GlobalGet (nr (E.get_global env "__candid_data_length")))
+  let get_type_offsets_length env =
+    G.i (GlobalGet (nr (E.get_global env "__type_offsets_length")))
+  let get_idl_types_length env =
+    G.i (GlobalGet (nr (E.get_global env "__idl_types_length")))
+
+  let candid_type_offset_size = 8L
+
+  let get_global_type_descriptor env =
+    match !(E.(env.global_type_descriptor)) with
+    | Some descriptor -> descriptor
+    | None -> assert false
+
+  let get_global_candid_data env =
+    Tagged.share env (fun env -> 
+      let descriptor = get_global_type_descriptor env in
+      Blob.load_data_segment env Tagged.B E.(descriptor.candid_data_segment) (get_candid_data_length env)
+    )
+
+  let get_global_type_offsets env =
+    Tagged.share env (fun env -> 
+      let descriptor = get_global_type_descriptor env in
+      Blob.load_data_segment env Tagged.B E.(descriptor.type_offsets_segment) (get_type_offsets_length env)
+    )
+
+  let get_global_idl_types env =
+    Tagged.share env (fun env -> 
+      let descriptor = get_global_type_descriptor env in
+      Blob.load_data_segment env Tagged.B E.(descriptor.idl_types_segment) (get_idl_types_length env)
+    )
+      
+  module Registers = struct
+
+    (* interval for checking instruction counter *)
+    let idl_value_numerator = 1L
+    let idl_value_denominator = 1L
+    let idl_value_bias = 1024L
+
+    let register_globals env =
+      E.add_global64 env "@@rel_buf_opt" Mutable 0L;
+      E.add_global64 env "@@data_buf" Mutable 0L;
+      E.add_global64 env "@@ref_buf" Mutable 0L;
+      E.add_global64 env "@@typtbl" Mutable 0L;
+      E.add_global64 env "@@typtbl_end" Mutable 0L;
+      E.add_global64 env "@@typtbl_size" Mutable 0L;
+      E.add_global64 env "@@global_typtbl" Mutable 0L;
+      E.add_global64 env "@@global_typtbl_end" Mutable 0L;
+      E.add_global64 env "@@global_typtbl_size" Mutable 0L;
+      E.add_global64 env "@@value_denominator" Mutable idl_value_denominator;
+      E.add_global64 env "@@value_numerator" Mutable idl_value_numerator;
+      E.add_global64 env "@@value_bias" Mutable idl_value_bias;
+      E.add_global64 env "@@value_quota" Mutable 0L
+
+    let get_rel_buf_opt env =
+      G.i (GlobalGet (nr (E.get_global env "@@rel_buf_opt")))
+    let set_rel_buf_opt env =
+      G.i (GlobalSet (nr (E.get_global env "@@rel_buf_opt")))
+
+    let get_data_buf env =
+      G.i (GlobalGet (nr (E.get_global env "@@data_buf")))
+    let set_data_buf env =
+      G.i (GlobalSet (nr (E.get_global env "@@data_buf")))
+
+    let get_ref_buf env =
+      G.i (GlobalGet (nr (E.get_global env "@@ref_buf")))
+    let set_ref_buf env =
+      G.i (GlobalSet (nr (E.get_global env "@@ref_buf")))
+
+    let get_typtbl env =
+      G.i (GlobalGet (nr (E.get_global env "@@typtbl")))
+    let set_typtbl env =
+      G.i (GlobalSet (nr (E.get_global env "@@typtbl")))
+
+    let get_typtbl_end env =
+      G.i (GlobalGet (nr (E.get_global env "@@typtbl_end")))
+    let set_typtbl_end env =
+      G.i (GlobalSet (nr (E.get_global env "@@typtbl_end")))
+
+    let get_typtbl_size env =
+      G.i (GlobalGet (nr (E.get_global env "@@typtbl_size")))
+    let set_typtbl_size env =
+      G.i (GlobalSet (nr (E.get_global env "@@typtbl_size")))
+
+    let get_global_typtbl env =
+      G.i (GlobalGet (nr (E.get_global env "@@global_typtbl")))
+    let set_global_typtbl env =
+      G.i (GlobalSet (nr (E.get_global env "@@global_typtbl")))
+
+    let get_global_typtbl_end env =
+      G.i (GlobalGet (nr (E.get_global env "@@global_typtbl_end")))
+    let set_global_typtbl_end env =
+      G.i (GlobalSet (nr (E.get_global env "@@global_typtbl_end")))
+
+    let get_global_typtbl_size env =
+      G.i (GlobalGet (nr (E.get_global env "@@global_typtbl_size")))
+    let set_global_typtbl_size env =
+      G.i (GlobalSet (nr (E.get_global env "@@global_typtbl_size")))
+
+    (* Used as safety guard that no temporary pointers remain in the registers across GC increments. *)
+    let clear_registers env =
+      compile_unboxed_const 0L ^^ set_rel_buf_opt env ^^
+      compile_unboxed_const 0L ^^ set_data_buf env ^^
+      compile_unboxed_const 0L ^^ set_ref_buf env ^^
+      compile_unboxed_const 0L ^^ set_typtbl env ^^
+      compile_unboxed_const 0L ^^ set_typtbl_end env ^^
+      compile_unboxed_const 0L ^^ set_typtbl_size env ^^ (* also reset for symmetry, even if no pointer *)
+      compile_unboxed_const 0L ^^ set_global_typtbl env ^^
+      compile_unboxed_const 0L ^^ set_global_typtbl_end env ^^
+      compile_unboxed_const 0L ^^ set_global_typtbl_size env (* also reset for symmetry, even if no pointer *)
+
+    let get_value_quota env =
+      G.i (GlobalGet (nr (E.get_global env "@@value_quota")))
+    let set_value_quota env =
+      G.i (GlobalSet (nr (E.get_global env "@@value_quota")))
+
+    let get_value_numerator env =
+      G.i (GlobalGet (nr (E.get_global env "@@value_numerator")))
+    let set_value_numerator env =
+      G.i (GlobalSet (nr (E.get_global env "@@value_numerator")))
+
+    let get_value_denominator env =
+      G.i (GlobalGet (nr (E.get_global env "@@value_denominator")))
+    let set_value_denominator env =
+      G.i (GlobalSet (nr (E.get_global env "@@value_denominator")))
+
+    let get_value_bias env =
+      G.i (GlobalGet (nr (E.get_global env "@@value_bias")))
+    let set_value_bias env =
+      G.i (GlobalSet (nr (E.get_global env "@@value_bias")))
+
+    let reset_value_limit env get_blob get_rel_buf_opt =
+      get_rel_buf_opt ^^
+      E.if0
+      begin (* Candid deserialization *)
+        (* Set instruction limit *)
+        let (set_product, get_product) = new_local env "product" in
+        let (set_len, get_len) = new_local env "len" in
+        get_blob ^^
+        Blob.len env ^^
+        set_len ^^
+
+        get_len ^^
+        get_value_numerator env ^^
+        G.i (Binary (Wasm_exts.Values.I64 I64Op.Mul)) ^^
+        get_value_denominator env ^^
+        G.i (Binary (Wasm_exts.Values.I64 I64Op.DivU)) ^^
+        set_product ^^
+
+        get_value_numerator env ^^ (* check overflow for non-zero numerator *)
+        (E.if0 begin
+          (* Saturate multiplication `len * idl_value_numerator` on overflow.
+             Ignore `idl_value_denomminator` on overflow. *)  
+          compile_unboxed_const (-1L) ^^ (* u64::MAX *)
+          get_value_numerator env ^^ (* non-zero! *)
+          G.i (Binary (Wasm_exts.Values.I64 I64Op.DivU)) ^^
+          get_len ^^
+          compile_comparison I64Op.LtU ^^
+          (E.if0 begin
+            compile_unboxed_const (-1L) ^^ (* u64::MAX *)
+            set_product
+          end
+            G.nop)
+        end
+          G.nop) ^^
+
+        get_product ^^
+        get_value_bias env ^^
+        G.i (Binary (Wasm_exts.Values.I64 I64Op.Add)) ^^
+        set_value_quota env ^^
+
+        (* Saturate value_quota on overflow *)
+        get_value_quota env ^^
+        get_product ^^
+        compile_comparison I64Op.LtU ^^
+        E.if0 begin
+          compile_unboxed_const (-1L) ^^ (* u64::MAX *)
+          set_value_quota env
+        end
+          G.nop
+      end
+      begin (* Extended candid/ Destabilization *)
+        G.nop
+      end
+
+    let define_idl_limit_check env =
+      Func.define_built_in env "idl_limit_check"
+        [("decrement", I32Type); ("count", I64Type)] [] (fun env ->
+        get_rel_buf_opt env ^^
+        E.if0 begin (* Candid deserialization *)
+          get_value_quota env ^^
+          G.i (LocalGet (nr 1l)) ^^ (* Count of values *)
+          compile_comparison I64Op.LtU ^^
+          E.then_trap_with env "IDL error: exceeded value limit" ^^
+          (* if (decrement) quota -= count *)
+          G.i (LocalGet (nr 0l)) ^^
+          Bool.from_rts_int32 ^^
+          E.if0 begin
+             get_value_quota env ^^
+             G.i (LocalGet (nr 1l)) ^^
+             G.i (Binary (Wasm_exts.Values.I64 I64Op.Sub)) ^^
+             set_value_quota env
+           end
+             G.nop
+        end begin (* Extended Candid/Destabilization *)
+          G.nop
+        end)
+
+    let idl_limit_check env =
+      G.i (Call (nr (E.built_in env "idl_limit_check")))
+
+  end
+
+  open Typ_hash
+
+  let sort_by_hash fs =
+    List.sort
+      (fun (h1,_) (h2,_) -> Lib.Uint32.compare h1 h2)
+      (List.map (fun f -> (Idllib.Escape.unescape_hash f.Type.lab, f)) fs)
+
+  (* The IDL serialization prefaces the data with a type description.
+     We can statically create the type description in Ocaml code,
+     store it in the program, and just copy it to the beginning of the message.
+
+     At some point this can be factored into a function from Motoko type to IDL,
+     type and a function like this for IDL types. But due to recursion handling
+     it is easier to start like this.
+  *)
+
+  module TM = Map.Make (Type.Ord)
+
+  type mode =
+    | Candid
+    | Persistence
+
+  let to_idl_prim mode = let open Type in function
+    | Prim Null | Tup [] -> Some 1l
+    | Prim Bool -> Some 2l
+    | Prim Nat -> Some 3l
+    | Prim Int -> Some 4l
+    | Prim Nat8 -> Some 5l
+    | Prim Nat16 -> Some 6l
+    | Prim (Nat32|Char) -> Some 7l
+    | Prim Nat64 -> Some 8l
+    | Prim Int8 -> Some 9l
+    | Prim Int16 -> Some 10l
+    | Prim Int32 -> Some 11l
+    | Prim Int64 -> Some 12l
+    | Prim Float -> Some 14l
+    | Prim Text -> Some 15l
+    (* NB: Prim Blob does not map to a primitive IDL type *)
+    | Any -> Some 16l
+    | Non -> Some 17l
+    | Prim Principal -> Some 24l
+    | Prim Region -> Some 128l
+    (* only used for memory compatibility checks *)
+    | Prim Blob -> 
+      (match mode with
+      | Candid -> None
+      | Persistence -> Some 129l)
+    | _ -> None
+
+  (* some constants, also see rts/idl.c *)
+  let idl_opt       = -18l
+  let idl_vec       = -19l
+  let idl_record    = -20l
+  let idl_variant   = -21l
+  let idl_func      = -22l
+  let idl_service   = -23l
+  let idl_alias     = 1l (* see Note [mutable stable values] *)
+  
+  (* only used for memory compatibility checks *)
+  let idl_tuple     = -130l
+
+  (* TODO: use record *)
+  let type_desc env mode ts :
+     string * int list * int32 list  (* type_desc, (relative offsets), indices of ts *)
+    =
+    let open Type in
+
+    (* Type traversal *)
+    (* We do a first traversal to find out the indices of non-primitive types *)
+    let (typs, idx) =
+      let typs = ref [] in
+      let idx = ref TM.empty in
+      let rec go t =
+        let t = Type.normalize t in
+        if to_idl_prim mode t <> None then () else
+        if TM.mem t !idx then () else begin
+          idx := TM.add t (Lib.List32.length !typs) !idx;
+          typs := !typs @ [ t ];
+          match t with
+          | Tup ts -> List.iter go ts
+          | Obj (_, fs) ->
+            List.iter (fun f -> go f.typ) fs
+          | Array (Mut t) -> go (Array t)
+          | Array t -> go t
+          | Opt t -> go t
+          | Variant vs -> List.iter (fun f -> go f.typ) vs
+          | Func (s, c, tbs, ts1, ts2) ->
+            List.iter go ts1; List.iter go ts2
+          | Prim Blob -> ()
+          | Mut t -> go t
+          | _ ->
+            Printf.eprintf "type_desc: unexpected type %s\n" (string_of_typ t);
+            assert false
+        end
+      in
+      List.iter go ts;
+      (!typs, !idx)
+    in
+
+    (* buffer utilities *)
+    let buf = Buffer.create 16 in
+
+    let add_u8 i =
+      Buffer.add_char buf (Char.chr (i land 0xff)) in
+
+    let rec add_leb128_32 (i : Lib.Uint32.t) =
+      let open Lib.Uint32 in
+      let b = logand i (of_int32 0x7fl) in
+      if of_int32 0l <= i && i < of_int32 128l
+      then add_u8 (to_int b)
+      else begin
+        add_u8 (to_int (logor b (of_int32 0x80l)));
+        add_leb128_32 (shift_right_logical i 7)
+      end in
+
+    let add_leb128 i =
+      assert (i >= 0);
+      add_leb128_32 (Lib.Uint32.of_int i) in
+
+    let rec add_sleb128 (i : int32) =
+      let open Int32 in
+      let b = logand i 0x7fl in
+      if -64l <= i && i < 64l
+      then add_u8 (to_int b)
+      else begin
+        add_u8 (to_int (logor b 0x80l));
+        add_sleb128 (shift_right i 7)
+      end in
+
+    (* Actual binary data *)
+
+    let add_idx t =
+      let t = Type.normalize t in
+      match to_idl_prim mode t with
+      | Some i -> add_sleb128 (Int32.neg i)
+      | None -> add_sleb128 (TM.find (normalize t) idx) in
+
+    let idx t =
+      let t = Type.normalize t in
+      match to_idl_prim mode t with
+      | Some i -> Int32.neg i
+      | None -> TM.find (normalize t) idx in
+
+    let rec add_typ t =
+      match t with
+      | Non -> assert false
+      | Prim Blob ->
+        assert (mode = Candid);
+        add_typ Type.(Array (Prim Nat8))
+      | Prim Region ->
+        add_sleb128 idl_alias; add_idx t
+      | Prim _ -> assert false
+      | Tup ts ->
+        add_sleb128 (match mode with
+        | Candid -> idl_record
+        | Persistence -> idl_tuple);
+        add_leb128 (List.length ts);
+        List.iteri (fun i t ->
+          add_leb128 i;
+          add_idx t;
+        ) ts
+      | Obj ((Object | Memory), fs) ->
+        add_sleb128 idl_record;
+        add_leb128 (List.length fs);
+        List.iter (fun (h, f) ->
+          add_leb128_32 h;
+          add_idx f.typ
+        ) (sort_by_hash fs)
+      | Array (Mut t) ->
+        add_sleb128 idl_alias; add_idx (Array t)
+      | Array t ->
+        add_sleb128 idl_vec; add_idx t
+      | Opt t ->
+        add_sleb128 idl_opt; add_idx t
+      | Variant vs ->
+        add_sleb128 idl_variant;
+        add_leb128 (List.length vs);
+        List.iter (fun (h, f) ->
+          add_leb128_32 h;
+          add_idx f.typ
+        ) (sort_by_hash vs)
+      | Func (s, c, tbs, ts1, ts2) ->
+        assert (Type.is_shared_sort s);
+        add_sleb128 idl_func;
+        add_leb128 (List.length ts1);
+        List.iter add_idx ts1;
+        add_leb128 (List.length ts2);
+        List.iter add_idx ts2;
+        begin match s, c with
+          | _, Returns ->
+            add_leb128 1; add_u8 2; (* oneway *)
+          | Shared Write, _ ->
+            add_leb128 0; (* no annotation *)
+          | Shared Query, _ ->
+            add_leb128 1; add_u8 1; (* query *)
+          | Shared Composite, _ ->
+            add_leb128 1; add_u8 3; (* composite *)
+          | _ -> assert false
+        end
+      | Obj (Actor, fs) ->
+        add_sleb128 idl_service;
+        add_leb128 (List.length fs);
+        List.iter (fun f ->
+          add_leb128 (String.length f.lab);
+          Buffer.add_string buf f.lab;
+          add_idx f.typ
+        ) fs
+      | Mut t ->
+        add_sleb128 idl_alias; add_idx t
+      | _ -> assert false in
+
+    Buffer.add_string buf "DIDL";
+    add_leb128 (List.length typs);
+    let offsets = List.map (fun typ ->
+      let offset = Buffer.length buf in
+      add_typ typ;
+      offset)
+      typs
+    in
+    add_leb128 (List.length ts);
+    List.iter add_idx ts;
+    (Buffer.contents buf,
+     offsets,
+     List.map idx ts)
+
+  (* See Note [Candid subtype checks] *)
+  let reserve_global_type_descriptor (env : E.t) =
+    let candid_data_segment = E.add_data_segment env "" in
+    let type_offsets_segment = E.add_data_segment env "" in
+    let idl_types_segment = E.add_data_segment env "" in
+    E.(env.global_type_descriptor := Some {
+      candid_data_segment;
+      type_offsets_segment;
+      idl_types_segment;
+    })
+
+  let create_global_type_descriptor (env : E.t) (set_candid_data_length, set_type_offsets_length, set_idl_types_length) =
+    let descriptor = get_global_type_descriptor env in
+    let candid_data, type_offsets, idl_types = type_desc env Candid (E.get_typtbl_typs env) in
+    let candid_data_binary = [StaticBytes.Bytes candid_data] in
+    let candid_data_length = E.replace_data_segment env E.(descriptor.candid_data_segment) candid_data_binary in
+    set_candid_data_length candid_data_length;
+    let type_offsets_binary = [StaticBytes.i64s (List.map Int64.of_int type_offsets)] in
+    let type_offsets_length = E.replace_data_segment env E.(descriptor.type_offsets_segment) type_offsets_binary in
+    set_type_offsets_length type_offsets_length;
+    let idl_types_64 = List.map Wasm.I64_convert.extend_i32_u idl_types in
+    let idl_types_binary = [StaticBytes.i64s idl_types_64] in
+    let idl_types_length = E.replace_data_segment env E.(descriptor.idl_types_segment) idl_types_binary in
+    set_idl_types_length idl_types_length
+
+  (* Returns data (in bytes) and reference buffer size (in entries) needed *)
+  let rec buffer_size env t =
+    let open Type in
+    let t = Type.normalize t in
+    let name = "@buffer_size<" ^ typ_hash t ^ ">" in
+    Func.share_code1 Func.Always env name ("x", I64Type) [I64Type; I64Type]
+    (fun env get_x ->
+
+      (* Some combinators for writing values *)
+      let (set_data_size, get_data_size) = new_local env "data_size" in
+      let (set_ref_size, get_ref_size) = new_local env "ref_size" in
+      compile_unboxed_const 0L ^^ set_data_size ^^
+      compile_unboxed_const 0L ^^ set_ref_size ^^
+
+      let inc_data_size code =
+        get_data_size ^^
+        code ^^
+        G.i (Binary (Wasm_exts.Values.I64 I64Op.Add)) ^^
+        set_data_size
+      in
+
+      let size_word env code =
+        let (set_word, get_word) = new_local env "word" in
+        code ^^ set_word ^^
+        inc_data_size (I32Leb.compile_leb128_size get_word)
+      in
+
+      let size env t =
+        let (set_inc, get_inc) = new_local env "inc" in
+        buffer_size env t ^^
+        get_ref_size ^^ G.i (Binary (Wasm_exts.Values.I64 I64Op.Add)) ^^ set_ref_size ^^
+        set_inc ^^ inc_data_size get_inc
+      in
+
+      (* the incremental GC leaves array slice information in tag,
+         the slice information can be removed and the tag reset to array
+         as the GC can resume marking from the array beginning *)
+      let clear_array_slicing =
+        let (set_temp, get_temp) = new_local env "temp" in
+        set_temp ^^
+        get_temp ^^ compile_unboxed_const Tagged.(int_of_tag StableSeen) ^^
+        compile_comparison I64Op.Ne ^^
+        get_temp ^^ compile_unboxed_const Tagged.(int_of_tag CoercionFailure) ^^
+        compile_comparison I64Op.Ne ^^
+        G.i (Binary (Wasm_exts.Values.I64 I64Op.And)) ^^
+        get_temp ^^ compile_unboxed_const Tagged.(int_of_tag ArraySliceMinimum) ^^
+        compile_comparison I64Op.GeU ^^
+        G.i (Binary (Wasm_exts.Values.I64 I64Op.And)) ^^
+        E.if1 I64Type begin
+          (compile_unboxed_const Tagged.(int_of_tag (Array M)))
+        end begin
+          get_temp
+        end
+      in
+
+      let size_alias size_thing =
+        (* see Note [mutable stable values] *)
+        let (set_tag, get_tag) = new_local env "tag" in
+        get_x ^^ Tagged.load_tag env ^^ clear_array_slicing ^^ set_tag ^^
+        (* Sanity check *)
+        get_tag ^^ compile_eq_const Tagged.(int_of_tag StableSeen) ^^
+        get_tag ^^ compile_eq_const Tagged.(int_of_tag MutBox) ^^
+        G.i (Binary (Wasm_exts.Values.I64 I64Op.Or)) ^^
+        get_tag ^^ compile_eq_const Tagged.(int_of_tag (Array M)) ^^
+        G.i (Binary (Wasm_exts.Values.I64 I64Op.Or)) ^^
+        get_tag ^^ compile_eq_const Tagged.(int_of_tag Region) ^^
+        G.i (Binary (Wasm_exts.Values.I64 I64Op.Or)) ^^
+        E.else_trap_with env "object_size/Mut: Unexpected tag." ^^
+        (* Check if we have seen this before *)
+        get_tag ^^ compile_eq_const Tagged.(int_of_tag StableSeen) ^^
+        E.if0 begin
+          (* Seen before *)
+          (* One byte marker, one word offset *)
+          (* TODO: Support 64-bit pointer in serialization *)
+          inc_data_size (compile_unboxed_const 5L)
+        end begin
+          (* Not yet seen *)
+          (* One byte marker, two words scratch space *)
+          inc_data_size (compile_unboxed_const 9L) ^^
+          (* Mark it as seen *)
+          get_x ^^ Tagged.(store_tag env StableSeen) ^^
+          (* and descend *)
+          size_thing ()
+        end
+      in
+
+      (* Now the actual type-dependent code *)
+      begin match t with
+      | Prim Nat -> inc_data_size (get_x ^^ BigNum.compile_data_size_unsigned env)
+      | Prim Int -> inc_data_size (get_x ^^ BigNum.compile_data_size_signed env)
+      | Prim (Int8|Nat8) -> inc_data_size (compile_unboxed_const 1L)
+      | Prim (Int16|Nat16) -> inc_data_size (compile_unboxed_const 2L)
+      | Prim (Int32|Nat32|Char) -> inc_data_size (compile_unboxed_const 4L)
+      | Prim (Int64|Nat64|Float) -> inc_data_size (compile_unboxed_const 8L)
+      | Prim Bool -> inc_data_size (compile_unboxed_const 1L)
+      | Prim Null -> G.nop
+      | Any -> G.nop
+      | Tup [] -> G.nop (* e(()) = null *)
+      | Tup ts ->
+        G.concat_mapi (fun i t ->
+          get_x ^^ Tuple.load_n env (Int64.of_int i) ^^
+          size env t
+          ) ts
+      | Obj ((Object | Memory), fs) ->
+        G.concat_map (fun (_h, f) ->
+          get_x ^^ Object.load_idx_raw env f.Type.lab ^^
+          size env f.typ
+          ) (sort_by_hash fs)
+      | Array (Mut t) ->
+        size_alias (fun () -> get_x ^^ size env (Array t))
+      | Array t ->
+        size_word env (get_x ^^ Arr.len env) ^^
+        get_x ^^ Arr.len env ^^
+        from_0_to_n env (fun get_i ->
+          get_x ^^ get_i ^^ Arr.unsafe_idx env ^^ load_ptr ^^
+          size env t
+        )
+      | Prim Blob ->
+        let (set_len, get_len) = new_local env "len" in
+        get_x ^^ Blob.len env ^^ set_len ^^
+        size_word env get_len ^^
+        inc_data_size get_len
+      | Prim Text ->
+        let (set_len, get_len) = new_local env "len" in
+        get_x ^^ Text.size env ^^ set_len ^^
+        size_word env get_len ^^
+        inc_data_size get_len
+      | Opt t ->
+        inc_data_size (compile_unboxed_const 1L) ^^ (* one byte tag *)
+        get_x ^^ Opt.is_some env ^^
+        E.if0 (get_x ^^ Opt.project env ^^ size env t) G.nop
+      | Variant vs ->
+        List.fold_right (fun (i, {lab = l; typ = t; _}) continue ->
+            get_x ^^
+            Variant.test_is env l ^^
+            E.if0
+              ( size_word env (compile_unboxed_const (Int64.of_int i)) ^^
+                get_x ^^ Variant.project env ^^ size env t
+              ) continue
+          )
+          ( List.mapi (fun i (_h, f) -> (i,f)) (sort_by_hash vs) )
+          ( E.trap_with env "buffer_size: unexpected variant" )
+      | Func _ ->
+        inc_data_size (compile_unboxed_const 1L) ^^ (* one byte tag *)
+        get_x ^^ Arr.load_field env 0L ^^ size env (Obj (Actor, [])) ^^
+        get_x ^^ Arr.load_field env 1L ^^ size env (Prim Text)
+      | Obj (Actor, _) | Prim Principal ->
+        inc_data_size (compile_unboxed_const 1L) ^^ (* one byte tag *)
+        get_x ^^ size env (Prim Blob)
+      | Non ->
+        E.trap_with env "buffer_size called on value of type None"
+      | Prim Region ->
+         size_alias (fun () ->
+          inc_data_size (compile_unboxed_const 12L) ^^ (* |id| + |page_count| = 8 + 4 *)
+          get_x ^^ Region.vec_pages env ^^ size env (Prim Blob))
+      | Mut t ->
+        size_alias (fun () -> get_x ^^ MutBox.load_field env ^^ size env t)
+      | _ -> todo "buffer_size" (Arrange_ir.typ t) G.nop
+      end ^^
+      (* Check 32-bit overflow of buffer_size *)
+      (* TODO: Support 64-bit buffer *)
+      get_data_size ^^
+      compile_shrU_const 32L ^^
+      compile_test I64Op.Eqz ^^
+      E.else_trap_with env "buffer_size overflow" ^^
+      get_data_size ^^
+      get_ref_size
+    )
+
+  (* TODO: Change serialization version because format changes with 64-bit *)
+  (* Copies x to the data_buffer, storing references after ref_count entries in ref_base *)
+  let rec serialize_go env t =
+    let open Type in
+    let t = Type.normalize t in
+    let name = Strm.name_for "serialize_go" [t] in
+    Func.share_code3 Func.Always env name (("x", I64Type), ("data_buffer", I64Type), ("ref_buffer", I64Type)) [I64Type; I64Type]
+    (fun env get_x get_data_buf get_ref_buf ->
+      let set_ref_buf = G.setter_for get_ref_buf in
+
+      (* Some combinators for writing values *)
+      let open Strm in
+
+      let write env t =
+        get_data_buf ^^
+        get_ref_buf ^^
+        serialize_go env t ^^
+        set_ref_buf ^^
+        checkpoint env get_data_buf
+      in
+
+      let write_alias write_thing =
+        (* see Note [mutable stable values] *)
+        (* Check heap tag *)
+        let (set_tag, get_tag) = new_local env "tag" in
+        get_x ^^ Tagged.load_tag env ^^ set_tag ^^
+        get_tag ^^ compile_eq_const Tagged.(int_of_tag StableSeen) ^^
+        E.if0
+        begin
+          (* This is the real data *)
+          write_byte env get_data_buf (compile_unboxed_const 0L) ^^
+          (* Remember the current offset in the tag word *)
+          get_x ^^ Tagged.load_forwarding_pointer env ^^ Strm.absolute_offset env get_data_buf ^^
+          Tagged.store_field env Tagged.tag_field ^^
+          (* Leave space in the output buffer for the decoder's bookkeeping *)
+          (* For compatibility, this is still in 32-bit format, but not useful in 64-bit *)
+          write_word_32 env get_data_buf (compile_unboxed_const 0L) ^^
+          write_word_32 env get_data_buf (compile_unboxed_const 0L) ^^
+          (* Now the data, following the object field mutbox indirection *)
+          write_thing ()
+        end
+        begin
+          (* This is a reference *)
+          write_byte env get_data_buf (compile_unboxed_const 1L) ^^
+          (* Sanity Checks *)
+          get_tag ^^ compile_eq_const Tagged.(int_of_tag MutBox) ^^
+          E.then_trap_with env "unvisited mutable data in serialize_go (MutBox)" ^^
+          get_tag ^^ compile_eq_const Tagged.(int_of_tag (Array M)) ^^
+          E.then_trap_with env "unvisited mutable data in serialize_go (Array)" ^^
+          get_tag ^^ compile_eq_const Tagged.(int_of_tag Region) ^^
+          E.then_trap_with env "unvisited mutable data in serialize_go (Region)" ^^
+          (* Second time we see this *)
+          (* Calculate relative offset *)
+          let set_offset, get_offset = new_local env "offset" in
+          get_tag ^^ Strm.absolute_offset env get_data_buf ^^ G.i (Binary (Wasm_exts.Values.I64 I64Op.Sub)) ^^
+          set_offset ^^
+          (* A sanity check *)
+          get_offset ^^ compile_unboxed_const 0L ^^
+          compile_comparison I64Op.LtS ^^
+          E.else_trap_with env "Odd offset" ^^
+          (* TODO: Support serialization beyond 32-bit *)
+          get_offset ^^ compile_unboxed_const 0xffff_ffff_0000_0000L ^^
+          compile_comparison I64Op.GeS ^^
+          E.else_trap_with env "64-bit offsets not yet supported during serialization" ^^
+          (* Write the offset to the output buffer *)
+          write_word_32 env get_data_buf get_offset
+        end
+      in
+
+      (* Now the actual serialization *)
+
+      begin match t with
+      | Prim Nat ->
+        write_bignum_leb env get_data_buf get_x
+      | Prim Int ->
+        write_bignum_sleb env get_data_buf get_x
+      | Prim Float ->
+        reserve env get_data_buf 8L ^^
+        get_x ^^ Float.unbox env ^^
+        G.i (Store {ty = F64Type; align = 0; offset = 0L; sz = None})
+      | Prim ((Int64|Nat64) as pty) ->
+        reserve env get_data_buf 8L ^^
+        get_x ^^ BoxedWord64.unbox env pty ^^
+        G.i (Store {ty = I64Type; align = 0; offset = 0L; sz = None})
+      | Prim ((Int32|Nat32) as ty) ->
+        write_word_32 env get_data_buf (get_x ^^ TaggedSmallWord.lsb_adjust ty)
+      | Prim Char ->
+        write_word_32 env get_data_buf (get_x ^^ TaggedSmallWord.lsb_adjust_codepoint env)
+      | Prim ((Int16|Nat16) as ty) ->
+        reserve env get_data_buf 2L ^^
+        get_x ^^ TaggedSmallWord.lsb_adjust ty ^^ G.i (Convert (Wasm_exts.Values.I32 I32Op.WrapI64)) ^^
+        G.i (Store {ty = I32Type; align = 0; offset = 0L; sz = Some Wasm_exts.Types.Pack16})
+      | Prim ((Int8|Nat8) as ty) ->
+        write_byte env get_data_buf (get_x ^^ TaggedSmallWord.lsb_adjust ty)
+      | Prim Bool ->
+        write_byte env get_data_buf get_x
+      | Tup [] -> (* e(()) = null *)
+        G.nop
+      | Tup ts ->
+        G.concat_mapi (fun i t ->
+          get_x ^^ Tuple.load_n env (Int64.of_int i) ^^
+          write env t
+        ) ts
+      | Obj ((Object | Memory), fs) ->
+        G.concat_map (fun (_h, f) ->
+          get_x ^^ Object.load_idx_raw env f.Type.lab ^^
+          write env f.typ
+        ) (sort_by_hash fs)
+      | Array (Mut t) ->
+        write_alias (fun () -> get_x ^^ write env (Array t))
+      | Prim Region ->
+        write_alias (fun () ->
+          reserve env get_data_buf 8L ^^
+          get_x ^^ Region.id env ^^
+          G.i (Store {ty = I64Type; align = 0; offset = 0L; sz = None}) ^^
+          write_word_32 env get_data_buf (get_x ^^ Region.page_count env) ^^
+          write_blob env get_data_buf (get_x ^^ Region.vec_pages env)
+        )
+      | Array t ->
+        write_word_leb env get_data_buf (get_x ^^ Arr.len env) ^^
+        get_x ^^ Arr.len env ^^
+        from_0_to_n env (fun get_i ->
+          get_x ^^ get_i ^^ Arr.unsafe_idx env ^^ load_ptr ^^
+          write env t
+        )
+      | Prim Null -> G.nop
+      | Any -> G.nop
+      | Opt t ->
+        get_x ^^
+        Opt.is_some env ^^
+        E.if0
+          (write_byte env get_data_buf (compile_unboxed_const 1L) ^^ get_x ^^ Opt.project env ^^ write env t)
+          (write_byte env get_data_buf (compile_unboxed_const 0L))
+      | Variant vs ->
+        List.fold_right (fun (i, {lab = l; typ = t; _}) continue ->
+            get_x ^^
+            Variant.test_is env l ^^
+            E.if0
+              ( write_word_leb env get_data_buf (compile_unboxed_const (Int64.of_int i)) ^^
+                get_x ^^ Variant.project env ^^ write env t)
+              continue
+          )
+          ( List.mapi (fun i (_h, f) -> (i,f)) (sort_by_hash vs) )
+          ( E.trap_with env "serialize_go: unexpected variant" )
+      | Prim Blob ->
+        write_blob env get_data_buf get_x
+      | Prim Text ->
+        write_text env get_data_buf get_x
+      | Func _ ->
+        write_byte env get_data_buf (compile_unboxed_const 1L) ^^
+        get_x ^^ Arr.load_field env 0L ^^ write env (Obj (Actor, [])) ^^
+        get_x ^^ Arr.load_field env 1L ^^ write env (Prim Text)
+      | Obj (Actor, _) | Prim Principal ->
+        write_byte env get_data_buf (compile_unboxed_const 1L) ^^
+        get_x ^^ write env (Prim Blob)
+      | Non ->
+        E.trap_with env "serializing value of type None"
+      | Mut t ->
+        write_alias (fun () ->
+          get_x ^^ MutBox.load_field env ^^ write env t
+        )
+      | _ -> todo "serialize" (Arrange_ir.typ t) G.nop
+      end ^^
+      get_data_buf ^^
+      get_ref_buf
+    )
+
+  (* This value is returned by deserialize_go if deserialization fails in a way
+     that should be recoverable by opt parsing.
+     It is an (invalid) sentinel pointer value (in skewed format) and can be used for pointer comparison.
+     It will be never placed on the heap and must not be dereferenced.
+     If unskewed, it refers to the unallocated last Wasm memory page.
+  *)
+  let coercion_error_value env = 0xffff_ffff_ffff_fffdL
+
+  (* See Note [Candid subtype checks] *)
+  let with_rel_buf_opt env extended get_typtbl_size1 get_typtbl_size2 f =
+    if extended then
+      f (compile_unboxed_const 0L)
+    else
+      get_typtbl_size1 ^^ get_typtbl_size2 ^^
+      E.call_import env "rts" "idl_sub_buf_words" ^^
+      Stack.dynamic_with_words env "rel_buf" (fun get_ptr ->
+        get_ptr ^^ get_typtbl_size1 ^^ get_typtbl_size2 ^^
+        E.call_import env "rts" "idl_sub_buf_init" ^^
+        f get_ptr)
+
+  (* See Note [Candid subtype checks] *)
+  let idl_sub env t2 =
+    let idx = Wasm.I64_convert.extend_i32_u (E.add_typtbl_typ env t2) in
+    get_global_idl_types env ^^
+    Blob.payload_ptr_unskewed env ^^
+    G.i (Load {ty = I64Type; align = 0; offset = Int64.mul idx candid_type_offset_size (*!*); sz = None}) ^^
+    Func.share_code2 Func.Always env ("idl_sub")
+      (("idltyp1", I64Type),
+       ("idltyp2", I64Type)
+      )
+      [I64Type]
+      (fun env get_idltyp1 get_idltyp2 ->
+        Registers.get_rel_buf_opt env ^^
+        E.else_trap_with env "null rel_buf" ^^
+        Registers.get_rel_buf_opt env ^^
+        Registers.get_typtbl env ^^
+        Registers.get_global_typtbl env ^^
+        Registers.get_typtbl_end env ^^
+        Registers.get_global_typtbl_end env ^^
+        Registers.get_typtbl_size env ^^
+        Registers.get_global_typtbl_size env ^^
+        get_idltyp1 ^^
+        G.i (Convert (Wasm_exts.Values.I32 I32Op.WrapI64)) ^^
+        get_idltyp2 ^^
+        G.i (Convert (Wasm_exts.Values.I32 I32Op.WrapI64)) ^^
+        E.call_import env "rts" "idl_sub" ^^
+        G.i (Convert (Wasm_exts.Values.I64 I64Op.ExtendUI32))
+        )
+
+  (* The main deserialization function, generated once per type hash.
+
+     We use a combination of RTS stack locals and registers (Wasm globals) for
+     recursive parameter passing to avoid exhausting the Wasm stack, which is instead
+     used solely for return values and (implicit) return addresses.
+
+     Its RTS stack parameters are (c.f. module Stack):
+
+       * idltyp:      The idl type (prim type or table index) to decode now
+       * depth:       Recursion counter; reset when we make progres on the value
+       * can_recover: Whether coercion errors are recoverable, see coercion_failed below
+
+     Its register parameters are (c.f. Registers):
+       * rel_buf_opt: The optional subtype check memoization table
+          (non-null for untrusted Candid but null for trusted de-stablization (see `with_rel_buf_opt`).)
+       * data_buffer: The current position of the input data buffer
+       * ref_buffer:  The current position of the input references buffer
+       * typtbl:      The type table, as returned by parse_idl_header
+       * typtbl_size: The size of the type table, used to limit recursion
+
+     It returns the value of type t (vanilla representation) or coercion_error_value,
+     It advances the data_buffer past the decoded value (even if it returns coercion_error_value!)
+
+  *)
+
+  (* symbolic names for arguments passed on RTS stack *)
+  module StackArgs = struct
+    let idltyp = 0L
+    let depth = 1L
+    let can_recover = 2L
+  end
+
+  let rec deserialize_go env t =
+    let open Type in
+    let t = Type.normalize t in
+    let name = "@deserialize_go<" ^ typ_hash t ^ ">" in
+    Func.share_code0 Func.Always env name
+      [I64Type]
+      (fun env  ->
+      let get_idltyp = Stack.get_local env StackArgs.idltyp in
+      let get_depth = Stack.get_local env StackArgs.depth in
+      let get_can_recover = Stack.get_local env StackArgs.can_recover in
+      let get_rel_buf_opt = Registers.get_rel_buf_opt env in
+      let get_data_buf = Registers.get_data_buf env in
+      let _get_ref_buf = Registers.get_ref_buf env in
+      let get_typtbl = Registers.get_typtbl env in
+      let _get_typtbl_end = Registers.get_typtbl_end env in
+      let get_typtbl_size = Registers.get_typtbl_size env in
+
+      (* Decrement and check idl quota *)
+      Bool.lit_rts_int32 true ^^
+      compile_unboxed_const 1L ^^
+      Registers.idl_limit_check env ^^
+
+      (* Check recursion depth (protects against empty record etc.) *)
+      (* Factor 2 because at each step, the expected type could go through one
+         level of opt that is not present in the value type
+      *)
+      get_depth ^^
+      get_typtbl_size ^^ compile_add_const 1L ^^ compile_mul_const 2L ^^
+      compile_comparison I64Op.LeU ^^
+      E.else_trap_with env ("IDL error: circular record read") ^^
+
+      (* Remember data buffer position, to detect progress *)
+      let (set_old_pos, get_old_pos) = new_local env "old_pos" in
+      ReadBuf.get_ptr get_data_buf ^^ set_old_pos ^^
+
+      let go' can_recover env t =
+        (* assumes idltyp on stack *)
+        Stack.with_frame env "frame_ptr" 3L (fun () ->
+          Stack.set_local env StackArgs.idltyp ^^
+          (* set up frame arguments *)
+          ( (* Reset depth counter if we made progress *)
+            ReadBuf.get_ptr get_data_buf ^^ get_old_pos ^^
+            compile_comparison I64Op.Eq ^^
+            E.if1 I64Type
+              (Stack.get_prev_local env 1L ^^ compile_add_const 1L)
+              (compile_unboxed_const 0L)
+            ) ^^
+          Stack.set_local env StackArgs.depth ^^
+          (if can_recover
+             then compile_unboxed_const 1L
+             else Stack.get_prev_local env 2L) ^^
+          Stack.set_local env StackArgs.can_recover ^^
+          deserialize_go env t)
+      in
+
+      let go = go' false in
+      let go_can_recover = go' true in
+
+      let skip get_typ =
+        get_data_buf ^^ get_typtbl ^^ get_typ ^^  G.i (Convert (Wasm_exts.Values.I32 I32Op.WrapI64)) ^^ compile_const_32 0l ^^
+        E.call_import env "rts" "skip_any"
+      in
+
+      (* This flag is set to return a coercion error at the very end
+         We cannot use (G.i Return) for early exit, or we’d leak stack space,
+         as Stack.with_words is used to allocate scratch space.
+      *)
+      let (set_failed, get_failed) = new_local env "failed" in
+      let set_failure = compile_unboxed_const 1L ^^ set_failed in
+      let when_failed f = get_failed ^^ E.if0 f G.nop in
+
+      (* This looks at a value and if it is coercion_error_value, sets the failure flag.
+         This propagates the error out of arrays, records, etc.
+       *)
+      let remember_failure get_val =
+          get_val ^^ compile_eq_const (coercion_error_value env) ^^
+          E.if0 set_failure G.nop
+      in
+
+      (* This sets the failure flag and puts coercion_error_value on the stack *)
+      let coercion_failed msg =
+        (* If we know that there is no backtracking `opt t` around, then just trap.
+           This gives a better error message
+        *)
+        get_can_recover ^^ E.else_trap_with env msg ^^
+        set_failure ^^ compile_unboxed_const (coercion_error_value env) in
+
+      (* returns true if we are looking at primitive type with this id *)
+      let check_prim_typ t =
+        get_idltyp ^^
+        compile_eq_const (Wasm.I64_convert.extend_i32_s (Int32.neg (Option.get (to_idl_prim Candid t))))
+      in
+
+      let with_prim_typ t f =
+        check_prim_typ t ^^
+        E.if1 I64Type f
+          ( skip get_idltyp ^^
+            coercion_failed ("IDL error: unexpected IDL type when parsing " ^ string_of_typ t)
+          )
+      in
+
+      let read_byte_tagged = function
+        | [code0; code1] ->
+          ReadBuf.read_byte env get_data_buf ^^
+          let (set_b, get_b) = new_local env "b" in
+          set_b ^^
+          get_b ^^
+          compile_eq_const 0L ^^
+          E.if1 I64Type
+          begin code0
+          end begin
+            get_b ^^ compile_eq_const 1L ^^
+            E.else_trap_with env "IDL error: byte tag not 0 or 1" ^^
+            code1
+          end
+        | _ -> assert false; (* can be generalized later as needed *)
+      in
+
+      let read_blob () =
+        let (set_len, get_len) = new_local env "len" in
+        let (set_x, get_x) = new_local env "x" in
+        ReadBuf.read_leb128 env get_data_buf ^^ set_len ^^
+
+        Blob.alloc env Tagged.B get_len ^^ set_x ^^
+        get_x ^^ Blob.payload_ptr_unskewed env ^^
+        ReadBuf.read_blob env get_data_buf get_len ^^
+        get_x
+      in
+
+      let read_principal sort () =
+        let (set_len, get_len) = new_local env "len" in
+        let (set_x, get_x) = new_local env "x" in
+        ReadBuf.read_leb128 env get_data_buf ^^ set_len ^^
+
+        (* at most 29 bytes, according to
+           https://sdk.dfinity.org/docs/interface-spec/index.html#principal
+        *)
+        get_len ^^ compile_unboxed_const 29L ^^ compile_comparison I64Op.LeU ^^
+        E.else_trap_with env "IDL error: principal too long" ^^
+
+        Blob.alloc env sort get_len ^^ set_x ^^
+        get_x ^^ Blob.payload_ptr_unskewed env ^^
+        ReadBuf.read_blob env get_data_buf get_len ^^
+        get_x
+      in
+
+      let read_text () =
+        let (set_len, get_len) = new_local env "len" in
+        ReadBuf.read_leb128 env get_data_buf ^^ set_len ^^
+        let (set_ptr, get_ptr) = new_local env "x" in
+        ReadBuf.get_ptr get_data_buf ^^ set_ptr ^^
+        ReadBuf.advance get_data_buf get_len ^^
+        (* validate *)
+        get_ptr ^^ get_len ^^ E.call_import env "rts" "utf8_validate" ^^
+        (* copy *)
+        get_ptr ^^ get_len ^^ Text.of_ptr_size env
+      in
+
+      let read_actor_data () =
+        read_byte_tagged
+          [ E.trap_with env "IDL error: unexpected actor reference"
+          ; read_principal Tagged.A ()
+          ]
+      in
+
+      (* returns true if get_arg_typ is a composite type of this id *)
+      let check_composite_typ get_arg_typ idl_tycon_id =
+        get_arg_typ ^^
+        compile_unboxed_const 0L ^^ compile_comparison I64Op.GeS ^^
+        E.if1 I64Type
+        begin
+          ReadBuf.alloc env (fun get_typ_buf ->
+            (* Update typ_buf *)
+            ReadBuf.set_ptr get_typ_buf (
+              get_typtbl ^^
+              get_arg_typ ^^ compile_mul_const Heap.word_size ^^
+              G.i (Binary (Wasm_exts.Values.I64 I64Op.Add)) ^^
+              load_unskewed_ptr
+            ) ^^
+            ReadBuf.set_end get_typ_buf (ReadBuf.get_end get_data_buf) ^^
+            (* read sleb128 *)
+            ReadBuf.read_sleb128 env get_typ_buf ^^
+            (* Check it is the expected value *)
+            compile_eq_const (Wasm.I64_convert.extend_i32_s idl_tycon_id)
+          )
+        end
+        (compile_unboxed_const 0L)
+      in
+
+
+      (* checks that arg_typ is positive, looks it up in the table,
+         creates a fresh typ_buf pointing into the type description,
+         reads the type constructor index and traps or fails if it is the wrong one.
+         and passes the typ_buf to a subcomputation to read the type arguments *)
+      let with_composite_arg_typ get_arg_typ idl_tycon_id f =
+        (* make sure index is not negative *)
+        get_arg_typ ^^
+        compile_unboxed_const 0L ^^ compile_comparison I64Op.GeS ^^
+        E.if1 I64Type
+        begin
+          ReadBuf.alloc env (fun get_typ_buf ->
+            (* Update typ_buf *)
+            ReadBuf.set_ptr get_typ_buf (
+              get_typtbl ^^
+              get_arg_typ ^^ compile_mul_const Heap.word_size ^^
+              G.i (Binary (Wasm_exts.Values.I64 I64Op.Add)) ^^
+              load_unskewed_ptr
+            ) ^^
+            ReadBuf.set_end get_typ_buf (ReadBuf.get_end get_data_buf) ^^
+            (* read sleb128 *)
+            ReadBuf.read_sleb128 env get_typ_buf ^^
+            (* Check it is the expected type constructor *)
+            compile_eq_const (Wasm.I64_convert.extend_i32_s idl_tycon_id) ^^
+            E.if1 I64Type
+            begin
+              f get_typ_buf
+            end
+            begin
+              skip get_arg_typ ^^
+              coercion_failed ("IDL error: unexpected IDL type when parsing " ^ string_of_typ t)
+            end
+          )
+        end
+        begin
+          skip get_arg_typ ^^
+          coercion_failed ("IDL error: unexpected IDL type when parsing " ^ string_of_typ t)
+        end
+      in
+
+      let with_alias_typ get_arg_typ =
+        get_arg_typ ^^
+        compile_unboxed_const 0L ^^ compile_comparison I64Op.GeS ^^
+        E.if1 I64Type
+        begin
+            with_composite_arg_typ get_arg_typ idl_alias (ReadBuf.read_sleb128 env)
+        end
+        begin
+          (* sanity check *)
+          get_arg_typ ^^
+          compile_eq_const (Wasm.I64_convert.extend_i32_s (Int32.neg (Option.get (to_idl_prim Candid (Prim Region))))) ^^
+          E.else_trap_with env "IDL error: unexpecting primitive alias type" ^^
+          get_arg_typ
+        end
+      in
+
+      let with_composite_typ idl_tycon_id f =
+        with_composite_arg_typ get_idltyp idl_tycon_id f
+      in
+
+      let with_record_typ f = with_composite_typ idl_record (fun get_typ_buf ->
+        Stack.with_words env "get_n_ptr" 1L (fun get_n_ptr ->
+          get_n_ptr ^^
+          ReadBuf.read_leb128 env get_typ_buf ^^
+          store_unskewed_ptr ^^
+          f get_typ_buf get_n_ptr
+        )
+      ) in
+
+      let with_blob_typ env f =
+        with_composite_typ idl_vec (fun get_typ_buf ->
+          ReadBuf.read_sleb128 env get_typ_buf ^^
+          compile_eq_const (-5L) (* Nat8 *) ^^
+          E.if1 I64Type
+            f
+            begin
+              skip get_idltyp ^^
+              coercion_failed "IDL error: blob not a vector of nat8"
+            end
+        )
+      in
+
+      let store_word32 =
+        G.i (Convert (Wasm_exts.Values.I32 I32Op.WrapI64)) ^^
+        G.i (Store {ty = I32Type; align = 0; offset = 0L; sz = None}) in
+
+      (* See comment on 64-bit destabilization on Note [mutable stable values] *)
+      let pointer_compression_shift = 3L in (* log2(word_size), 3 unused lower bits with 64-bit alignment *)
+      
+      let write_compressed_pointer env =
+        let (set_pointer, get_pointer) = new_local env "pointer" in
+        compile_add_const ptr_unskew ^^
+        compile_shrU_const pointer_compression_shift ^^
+        compile_add_const ptr_skew ^^
+        set_pointer ^^ get_pointer ^^
+        compile_unboxed_const 0xffff_ffffL ^^
+        compile_comparison I64Op.LeU ^^
+        E.else_trap_with env "Pointer cannot be compressed to 32 bit" ^^  
+        get_pointer ^^
+        store_word32
+      in
+
+      let read_compressed_pointer env get_buf =
+        let (set_pointer, get_pointer) = new_local env "pointer" in
+        ReadBuf.read_word32 env get_buf ^^
+        set_pointer ^^ get_pointer ^^
+        compile_eq_const 0L ^^
+        E.if1 I64Type
+          begin
+            get_pointer
+          end
+          begin
+            get_pointer ^^
+            compile_add_const ptr_unskew ^^
+            compile_shl_const pointer_compression_shift ^^
+            compile_add_const ptr_skew
+          end
+      in
+
+      let read_alias env t read_thing =
+        (* see Note [mutable stable values] *)
+        let (set_is_ref, get_is_ref) = new_local env "is_ref" in
+        let (set_result, get_result) = new_local env "result" in
+        let (set_cur, get_cur) = new_local env "cur" in
+        let (set_memo, get_memo) = new_local env "memo" in
+
+        let (set_arg_typ, get_arg_typ) = new_local env "arg_typ" in
+
+        with_alias_typ get_idltyp ^^ set_arg_typ ^^
+
+        (* Find out if it is a reference or not *)
+        ReadBuf.read_byte env get_data_buf ^^ set_is_ref ^^
+
+        (* If it is a reference, temporarily set the read buffer to that place *)
+        get_is_ref ^^
+        E.if0 begin
+          let (set_offset, get_offset) = new_local env "offset" in
+          ReadBuf.read_signed_word32 env get_data_buf ^^ 
+          set_offset ^^
+          (* A sanity check *)
+          get_offset ^^ compile_unboxed_const 0L ^^
+          compile_comparison I64Op.LtS ^^
+          E.else_trap_with env "Odd offset" ^^
+
+          ReadBuf.get_ptr get_data_buf ^^ set_cur ^^
+          ReadBuf.advance get_data_buf (get_offset ^^ compile_add_const (-4L))
+        end G.nop ^^
+
+        (* Remember location of ptr *)
+        ReadBuf.get_ptr get_data_buf ^^ set_memo ^^
+        (* Did we decode this already? *)
+        read_compressed_pointer env get_data_buf ^^ 
+        set_result ^^
+        get_result ^^ compile_eq_const 0L ^^
+        E.if0 begin
+          (* No, not yet decoded *)
+          (* Skip over type hash field *)
+          ReadBuf.read_word32 env get_data_buf ^^ compile_eq_const 0L ^^
+          E.else_trap_with env "Odd: Type hash scratch space not empty" ^^
+
+          (* Read the content *)
+          read_thing get_arg_typ (fun get_thing ->
+            (* This is called after allocation, but before descending
+               We update the memo location here so that loops work
+            *)
+            get_thing ^^ set_result ^^
+            get_memo ^^ get_result ^^ write_compressed_pointer env ^^
+            get_memo ^^ compile_add_const 4L ^^ Blob.lit env Tagged.B (typ_hash t) ^^ write_compressed_pointer env
+          )
+          end begin
+          (* Decoded before. Check type hash *)
+          read_compressed_pointer env get_data_buf ^^ Blob.lit env Tagged.B (typ_hash t) ^^
+          Blob.compare env (Some Operator.EqOp) ^^
+          E.else_trap_with env ("Stable memory error: Aliased at wrong type, expected: " ^ typ_hash t)
+        end ^^
+
+        (* If this was a reference, reset read buffer *)
+        get_is_ref ^^
+        E.if0 (ReadBuf.set_ptr get_data_buf get_cur) G.nop ^^
+
+        get_result
+      in
+
+
+      (* Now the actual deserialization *)
+      begin match t with
+      (* Primitive types *)
+      | Prim Nat ->
+        with_prim_typ t
+        begin
+          BigNum.compile_load_from_data_buf env get_data_buf false
+        end
+      | Prim Int ->
+        (* Subtyping with nat *)
+        check_prim_typ (Prim Nat) ^^
+        E.if1 I64Type
+          begin
+            BigNum.compile_load_from_data_buf env get_data_buf false
+          end
+          begin
+            with_prim_typ t
+            begin
+              BigNum.compile_load_from_data_buf env get_data_buf true
+            end
+          end
+      | Prim Float ->
+        with_prim_typ t
+        begin
+          ReadBuf.read_float64 env get_data_buf ^^
+          Float.box env
+        end
+      | Prim ((Int64|Nat64) as pty) ->
+        with_prim_typ t
+        begin
+          ReadBuf.read_word64 env get_data_buf ^^
+          BoxedWord64.box env pty
+        end
+      | Prim ((Int32|Nat32) as ty) ->
+        with_prim_typ t
+        begin
+          ReadBuf.read_word32 env get_data_buf ^^
+          TaggedSmallWord.msb_adjust ty ^^
+          TaggedSmallWord.tag env ty
+        end
+      | Prim Char ->
+        with_prim_typ t
+        begin
+          ReadBuf.read_word32 env get_data_buf ^^
+          TaggedSmallWord.check_and_msb_adjust_codepoint env ^^
+          TaggedSmallWord.tag env Char
+        end
+      | Prim ((Int16|Nat16) as ty) ->
+        with_prim_typ t
+        begin
+          ReadBuf.read_word16 env get_data_buf ^^
+          TaggedSmallWord.msb_adjust ty ^^
+          TaggedSmallWord.tag env ty
+        end
+      | Prim ((Int8|Nat8) as ty) ->
+        with_prim_typ t
+        begin
+          ReadBuf.read_byte env get_data_buf ^^
+          TaggedSmallWord.msb_adjust ty ^^
+          TaggedSmallWord.tag env ty
+        end
+      | Prim Bool ->
+        with_prim_typ t
+        begin
+          read_byte_tagged
+            [ Bool.lit false
+            ; Bool.lit true
+            ]
+        end
+      | Prim Null ->
+        with_prim_typ t (Opt.null_lit env)
+      | Any ->
+        skip get_idltyp ^^
+        (* Any vanilla value works here *)
+        Opt.null_lit env
+      | Prim Blob ->
+        with_blob_typ env (read_blob ())
+      | Prim Principal ->
+        with_prim_typ t
+        begin
+          read_byte_tagged
+            [ E.trap_with env "IDL error: unexpected principal reference"
+            ; read_principal Tagged.P ()
+            ]
+        end
+      | Prim Text ->
+        with_prim_typ t (read_text ())
+      | Tup [] -> (* e(()) = null *)
+        with_prim_typ t (Tuple.from_stack env 0)
+      (* Composite types *)
+      | Tup ts ->
+        with_record_typ (fun get_typ_buf get_n_ptr ->
+          let (set_val, get_val) = new_local env "val" in
+
+          G.concat_mapi (fun i t ->
+            (* skip all possible intermediate extra fields *)
+            get_typ_buf ^^ get_data_buf ^^ get_typtbl ^^ compile_const_32 (Int32.of_int i) ^^ get_n_ptr ^^
+            E.call_import env "rts" "find_field" ^^
+            Bool.from_rts_int32 ^^
+            E.if1 I64Type
+              begin
+                ReadBuf.read_sleb128 env get_typ_buf ^^
+                go env t ^^ set_val ^^
+                remember_failure get_val ^^
+                get_val
+              end
+              begin
+                match normalize t with
+                | Prim Null | Opt _ | Any -> Opt.null_lit env
+                | _ -> coercion_failed "IDL error: did not find tuple field in record"
+              end
+          ) ts ^^
+
+          (* skip all possible trailing extra fields *)
+          get_typ_buf ^^ get_data_buf ^^ get_typtbl ^^ get_n_ptr ^^
+          E.call_import env "rts" "skip_fields" ^^
+
+          Tuple.from_stack env (List.length ts)
+        )
+      | Obj ((Object | Memory), fs) ->
+        with_record_typ (fun get_typ_buf get_n_ptr ->
+          let (set_val, get_val) = new_local env "val" in
+
+          Object.lit_raw env (List.map (fun (h,f) ->
+            f.Type.lab, fun () ->
+              (* skip all possible intermediate extra fields *)
+              get_typ_buf ^^ get_data_buf ^^ get_typtbl ^^ compile_const_32 (Lib.Uint32.to_int32 h) ^^ get_n_ptr ^^
+              E.call_import env "rts" "find_field" ^^
+              Bool.from_rts_int32 ^^
+              E.if1 I64Type
+                begin
+                  ReadBuf.read_sleb128 env get_typ_buf ^^
+                  go env f.typ ^^ set_val ^^
+                  remember_failure get_val ^^
+                  get_val
+                  end
+                begin
+                  match normalize f.typ with
+                  | Prim Null | Opt _ | Any -> Opt.null_lit env
+                  | _ -> coercion_failed (Printf.sprintf "IDL error: did not find field %s in record" f.lab)
+                end
+          ) (sort_by_hash fs)) ^^
+
+          (* skip all possible trailing extra fields *)
+          get_typ_buf ^^ get_data_buf ^^ get_typtbl ^^ get_n_ptr ^^
+          E.call_import env "rts" "skip_fields"
+          )
+      | Array (Mut t) ->
+        read_alias env (Array (Mut t)) (fun get_array_typ on_alloc ->
+          let (set_len, get_len) = new_local env "len" in
+          let (set_x, get_x) = new_local env "x" in
+          let (set_val, get_val) = new_local env "val" in
+          let (set_arg_typ, get_arg_typ) = new_local env "arg_typ" in
+          (* TODO: if possible refactor to match new Array t code,
+             (perhaps too risky and unnecessary for extended candid due to lack of fancy opt subtyping, see #4243)
+          *)
+          with_composite_arg_typ get_array_typ idl_vec (ReadBuf.read_sleb128 env) ^^ set_arg_typ ^^
+          ReadBuf.read_leb128 env get_data_buf ^^ set_len ^^
+          Arr.alloc env Tagged.M get_len ^^ set_x ^^
+          on_alloc get_x ^^
+          get_len ^^ from_0_to_n env (fun get_i ->
+            get_x ^^ get_i ^^ Arr.unsafe_idx env ^^
+            get_arg_typ ^^ go env t ^^ set_val ^^
+            remember_failure get_val ^^
+            get_val ^^ store_ptr
+          ) ^^
+          get_x ^^
+          Tagged.allocation_barrier env ^^
+          G.i Drop
+        )
+      | Prim Region ->
+         read_alias env (Prim Region) (fun get_region_typ on_alloc ->
+          let (set_region, get_region) = new_local env "region" in
+          (* sanity check *)
+          get_region_typ ^^
+          compile_eq_const (Wasm.I64_convert.extend_i32_s (Int32.neg (Option.get (to_idl_prim Candid (Prim Region))))) ^^
+          E.else_trap_with env "deserialize_go (Region): unexpected idl_typ" ^^
+          (* pre-allocate a region object, with dummy fields *)
+          compile_unboxed_const 0L ^^ (* id *)
+          compile_unboxed_const 0L ^^ (* pagecount *)
+          Blob.lit env Tagged.B "" ^^ (* vec_pages *)
+          Region.alloc_region env ^^
+          set_region ^^
+          on_alloc get_region ^^
+          (* read and initialize the region's fields *)
+          get_region ^^
+          ReadBuf.read_word64 env get_data_buf ^^ (* id *)
+          ReadBuf.read_word32 env get_data_buf ^^ (* pagecount *)
+          read_blob () ^^ (* vec_pages *)
+          Region.init_region env
+        )
+      | Array t ->
+        let (set_len, get_len) = new_local env "len" in
+        let (set_x, get_x) = new_local env "x" in
+        let (set_val, get_val) = new_local env "val" in
+        let (set_arg_typ, get_arg_typ) = new_local env "arg_typ" in
+        with_composite_typ idl_vec (fun get_typ_buf ->
+          ReadBuf.read_sleb128 env get_typ_buf ^^
+          set_arg_typ ^^
+          ReadBuf.read_leb128 env get_data_buf ^^ set_len ^^
+          (* Don't decrement just check quota *)
+          Bool.lit_rts_int32 false ^^
+          get_len ^^
+          Registers.idl_limit_check env ^^
+          Arr.alloc env Tagged.I get_len ^^ set_x ^^
+          get_len ^^ from_0_to_n env (fun get_i ->
+          get_x ^^ get_i ^^ Arr.unsafe_idx env ^^
+          get_arg_typ ^^ go env t ^^ set_val ^^
+          remember_failure get_val ^^
+          get_val ^^ store_ptr
+        ) ^^
+        get_x ^^
+        Tagged.allocation_barrier env)
+      | Opt t ->
+        check_prim_typ (Prim Null) ^^
+        E.if1 I64Type (Opt.null_lit env)
+        begin
+          check_prim_typ Any ^^ (* reserved *)
+          E.if1 I64Type (Opt.null_lit env)
+          begin
+            check_composite_typ get_idltyp idl_opt ^^
+            E.if1 I64Type
+            begin
+              let (set_arg_typ, get_arg_typ) = new_local env "arg_typ" in
+              with_composite_typ idl_opt (ReadBuf.read_sleb128 env) ^^ set_arg_typ ^^
+              read_byte_tagged
+                [ Opt.null_lit env
+                ; let (set_val, get_val) = new_local env "val" in
+                  get_arg_typ ^^ go_can_recover env t ^^ set_val ^^
+                  get_val ^^ compile_eq_const (coercion_error_value env) ^^
+                  E.if1 I64Type
+                    (* decoding failed, but this is opt, so: return null *)
+                    (Opt.null_lit env)
+                    (* decoding succeeded, return opt value *)
+                    (Opt.inject env get_val)
+                ]
+            end
+            begin
+              (* this check corresponds to `not (null <: <t>)` in the spec *)
+              match normalize t with
+              | Prim Null | Opt _ | Any ->
+                (* Ignore and return null *)
+                skip get_idltyp ^^
+                Opt.null_lit env
+              | _ ->
+                (* Try constituent type *)
+                let (set_val, get_val) = new_local env "val" in
+                get_idltyp ^^ go_can_recover env t ^^ set_val ^^
+                get_val ^^ compile_eq_const (coercion_error_value env) ^^
+                E.if1 I64Type
+                  (* decoding failed, but this is opt, so: return null *)
+                  (Opt.null_lit env)
+                  (* decoding succeeded, return opt value *)
+                  (Opt.inject env get_val)
+            end
+          end
+        end
+      | Variant vs ->
+        let (set_val, get_val) = new_local env "val" in
+        with_composite_typ idl_variant (fun get_typ_buf ->
+          (* Find the tag *)
+          let (set_n, get_n) = new_local env "len" in
+          ReadBuf.read_leb128 env get_typ_buf ^^ set_n ^^
+
+          let (set_tagidx, get_tagidx) = new_local env "tagidx" in
+          ReadBuf.read_leb128 env get_data_buf ^^ set_tagidx ^^
+
+          get_tagidx ^^ get_n ^^
+          compile_comparison I64Op.LtU ^^
+          E.else_trap_with env "IDL error: variant index out of bounds" ^^
+
+          (* Zoom past the previous entries *)
+          get_tagidx ^^ from_0_to_n env (fun _ ->
+            get_typ_buf ^^ E.call_import env "rts" "skip_leb128" ^^
+            get_typ_buf ^^ E.call_import env "rts" "skip_leb128"
+          ) ^^
+
+          (* Now read the tag *)
+          let (set_tag, get_tag) = new_local env "tag" in
+          ReadBuf.read_leb128 env get_typ_buf ^^ set_tag ^^
+          let (set_arg_typ, get_arg_typ) = new_local env "arg_typ" in
+          ReadBuf.read_sleb128 env get_typ_buf ^^ set_arg_typ ^^
+
+          List.fold_right (fun (h, {lab = l; typ = t; _}) continue ->
+              get_tag ^^ compile_eq_const (Wasm.I64_convert.extend_i32_u (Lib.Uint32.to_int32 h)) ^^
+              E.if1 I64Type
+                ( Variant.inject env l (
+                  get_arg_typ ^^ go env t ^^ set_val ^^
+                  remember_failure get_val ^^
+                  get_val
+                ))
+                continue
+            )
+            ( sort_by_hash vs )
+            ( skip get_arg_typ ^^
+              coercion_failed "IDL error: unexpected variant tag" )
+        )
+      | Func _ ->
+        (* See Note [Candid subtype checks] *)
+        get_rel_buf_opt ^^
+        E.if1 I64Type
+          begin
+            get_idltyp ^^
+            idl_sub env t
+          end
+          (Bool.lit true) ^^ (* if we don't have a subtype memo table, assume the types are ok *)
+        E.if1 I64Type
+          (with_composite_typ idl_func (fun _get_typ_buf ->
+            read_byte_tagged
+              [ E.trap_with env "IDL error: unexpected function reference"
+              ; let (set_actor, get_actor) = new_local env "actor" in
+                let (set_func, get_func) = new_local env "func" in
+                read_actor_data () ^^ set_actor ^^
+                read_text () ^^ set_func ^^
+                Arr.lit env Tagged.S [get_actor; get_func]
+              ]))
+          (skip get_idltyp ^^
+           coercion_failed "IDL error: incompatible function type")
+      | Obj (Actor, _) ->
+        (* See Note [Candid subtype checks] *)
+        get_rel_buf_opt ^^
+        E.if1 I64Type
+          begin
+            get_idltyp ^^
+            idl_sub env t
+          end
+          (Bool.lit true) ^^
+        E.if1 I64Type
+          (with_composite_typ idl_service
+             (fun _get_typ_buf -> read_actor_data ()))
+          (skip get_idltyp ^^
+           coercion_failed "IDL error: incompatible actor type")
+      | Mut t ->
+        read_alias env (Mut t) (fun get_arg_typ on_alloc ->
+          let (set_result, get_result) = new_local env "result" in
+          MutBox.alloc env ^^ set_result ^^
+          on_alloc get_result ^^
+          get_result ^^
+          get_arg_typ ^^ go env t ^^
+          MutBox.store_field env
+        )
+      | Non ->
+        skip get_idltyp ^^
+        coercion_failed "IDL error: deserializing value of type None"
+      | _ -> todo_trap env "deserialize" (Arrange_ir.typ t)
+      end ^^
+      (* Parsed value on the stack, return that, unless the failure flag is set *)
+      when_failed (compile_unboxed_const (coercion_error_value env) ^^ G.i Return)
+    )
+
+  let serialize env ts : G.t =
+    let name = Strm.name_for "serialize" ts in
+    (* returns data/length pointers (will be GC’ed next time!) *)
+    Func.share_code1 Func.Always env name ("x", I64Type) [I64Type; I64Type] (fun env get_x ->
+      let (set_data_size, get_data_size) = new_local env "data_size" in
+      let (set_refs_size, get_refs_size) = new_local env "refs_size" in
+
+      let (tydesc, _offsets, _idltyps) = type_desc env Candid ts in
+      let tydesc_len = Int64.of_int (String.length tydesc) in
+
+      (* Get object sizes *)
+      get_x ^^
+      buffer_size env (Type.seq ts) ^^
+      set_refs_size ^^
+      set_data_size ^^
+      (* check for overflow *)
+      get_data_size ^^
+      compile_add_const tydesc_len ^^
+      compile_unboxed_const tydesc_len ^^
+      compile_comparison I64Op.LtU ^^
+      E.then_trap_with env "serialization overflow" ^^
+
+      let (set_data_start, get_data_start) = new_local env "data_start" in
+      let (set_refs_start, get_refs_start) = new_local env "refs_start" in
+
+      (* Create a stream with suitable capacity and given header *)
+      Strm.create env get_data_size set_data_start get_data_start tydesc ^^
+      get_refs_size ^^ compile_mul_const Heap.word_size ^^ Blob.dyn_alloc_scratch env ^^ set_refs_start ^^
+
+      (* Serialize x into the buffer *)
+      get_x ^^
+      get_data_start ^^
+      get_refs_start ^^
+      serialize_go env (Type.seq ts) ^^
+
+      (* Sanity check: Did we fill exactly the buffer *)
+      get_refs_start ^^ get_refs_size ^^ compile_mul_const Heap.word_size ^^ G.i (Binary (Wasm_exts.Values.I64 I64Op.Add)) ^^
+      compile_comparison I64Op.Eq ^^
+      E.else_trap_with env "reference buffer not filled" ^^
+
+      (* Verify that the stream is correctly filled *)
+      Strm.check_filled env get_data_start get_data_size ^^
+      get_refs_size ^^
+      compile_eq_const 0L ^^
+      E.else_trap_with env "cannot send references on IC System API" ^^
+
+      (* Extract the payload if possible *)
+      Strm.terminate env get_data_start get_data_size tydesc_len
+    )
+
+
+  let deserialize_from_blob extended env ts =
+    let ts_name = typ_seq_hash ts in
+    let name =
+      (* TODO(#3185): this specialization on `extended` seems redundant,
+         removing it might simplify things *and* share more code in binaries.
+         The only tricky bit might be the conditional Stack.dynamic_with_words bit... *)
+      if extended
+      then "@deserialize_extended<" ^ ts_name ^ ">"
+      else "@deserialize<" ^ ts_name ^ ">" in
+    Func.share_code2 Func.Always env name (("blob", I64Type), ("can_recover", I64Type)) (List.map (fun _ -> I64Type) ts) (fun env get_blob get_can_recover ->
+      let (set_data_size, get_data_size) = new_local env "data_size" in
+      let (set_refs_size, get_refs_size) = new_local env "refs_size" in
+      let (set_data_start, get_data_start) = new_local env "data_start" in
+      let (set_refs_start, get_refs_start) = new_local env "refs_start" in
+      let (set_arg_count, get_arg_count) = new_local env "arg_count" in
+      let (set_val, get_val) = new_local env "val" in
+
+      get_blob ^^ Blob.len env ^^ set_data_size ^^
+      get_blob ^^ Blob.payload_ptr_unskewed env ^^ set_data_start ^^
+
+      (* Allocate space for the reference buffer and copy it *)
+      compile_unboxed_const 0L ^^ set_refs_size (* none yet *) ^^
+
+      (* Allocate space for out parameters of parse_idl_header *)
+      Stack.with_words env "get_typtbl_size_ptr" 1L (fun get_typtbl_size_ptr ->
+      Stack.with_words env "get_typtbl_ptr" 1L (fun get_typtbl_ptr ->
+      Stack.with_words env "get_maintyps_ptr" 1L (fun get_maintyps_ptr ->
+
+      (* Allocate space for out parameters of idl_alloc_typtbl *)
+      Stack.with_words env "get_global_typtbl_ptr" 1L (fun get_global_typtbl_ptr ->
+      Stack.with_words env "get_global_typtbl_end_ptr" 1L (fun get_global_typtbl_end_ptr ->
+      Stack.with_words env "get_global_typtbl_size_ptr" 1L (fun get_global_typtbl_size_ptr ->
+
+      (* Set up read buffers *)
+      ReadBuf.alloc env (fun get_data_buf -> ReadBuf.alloc env (fun get_ref_buf ->
+
+      ReadBuf.set_ptr get_data_buf get_data_start ^^
+      ReadBuf.set_size get_data_buf get_data_size ^^
+      ReadBuf.set_ptr get_ref_buf get_refs_start ^^
+      ReadBuf.set_size get_ref_buf (get_refs_size ^^ compile_mul_const Heap.word_size) ^^
+
+      (* Go! *)
+      Bool.lit extended ^^ Bool.to_rts_int32 ^^ get_data_buf ^^ get_typtbl_ptr ^^ get_typtbl_size_ptr ^^ get_maintyps_ptr ^^
+      E.call_import env "rts" "parse_idl_header" ^^
+
+      (* Allocate global type type, if necessary for subtype checks *)
+      (if extended then
+         G.nop
+       else begin
+         get_global_candid_data env ^^
+         get_global_type_offsets env ^^
+         get_global_typtbl_ptr ^^ get_global_typtbl_end_ptr ^^ get_global_typtbl_size_ptr ^^
+         E.call_import env "rts" "idl_alloc_typtbl"
+      end) ^^
+
+      (* Allocate memo table, if necessary *)
+      with_rel_buf_opt env extended
+        (get_typtbl_size_ptr ^^ load_unskewed_ptr)
+        (get_global_typtbl_size_ptr ^^ load_unskewed_ptr)
+        (fun get_rel_buf_opt ->
+      begin
+        (* set up invariant register arguments *)
+        get_rel_buf_opt ^^ Registers.set_rel_buf_opt env ^^
+        get_data_buf ^^ Registers.set_data_buf env ^^
+        get_ref_buf ^^ Registers.set_ref_buf env ^^
+        get_typtbl_ptr ^^ load_unskewed_ptr ^^ Registers.set_typtbl env ^^
+        get_maintyps_ptr ^^ load_unskewed_ptr ^^ Registers.set_typtbl_end env ^^
+        get_typtbl_size_ptr ^^ load_unskewed_ptr ^^ Registers.set_typtbl_size env ^^
+        get_global_typtbl_ptr ^^ load_unskewed_ptr ^^ Registers.set_global_typtbl env ^^
+        get_global_typtbl_end_ptr ^^ load_unskewed_ptr ^^ Registers.set_global_typtbl_end env ^^
+        get_global_typtbl_size_ptr ^^ load_unskewed_ptr ^^ Registers.set_global_typtbl_size env ^^
+        Registers.reset_value_limit env get_blob get_rel_buf_opt
+      end ^^
+
+      (* set up a dedicated read buffer for the list of main types *)
+      ReadBuf.alloc env (fun get_main_typs_buf ->
+        ReadBuf.set_ptr get_main_typs_buf (get_maintyps_ptr ^^ load_unskewed_ptr) ^^
+        ReadBuf.set_end get_main_typs_buf (ReadBuf.get_end get_data_buf) ^^
+        ReadBuf.read_leb128 env get_main_typs_buf ^^ set_arg_count ^^
+
+        G.concat_map (fun t ->
+          let can_recover, default_or_trap = Type.(
+            match normalize t with
+            | Prim Null | Opt _ | Any ->
+              (Bool.lit true, fun msg -> Opt.null_lit env)
+            | _ ->
+              (get_can_recover, fun msg ->
+                get_can_recover ^^
+                E.if1 I64Type
+                   (compile_unboxed_const (coercion_error_value env))
+                   (E.trap_with env msg)))
+          in
+          get_arg_count ^^
+          compile_eq_const 0L ^^
+          E.if1 I64Type
+           (default_or_trap ("IDL error: too few arguments " ^ ts_name))
+           (begin
+              (* set up variable frame arguments *)
+              Stack.with_frame env "frame_ptr" 3L (fun () ->
+                (* idltyp *)
+                ReadBuf.read_sleb128 env get_main_typs_buf ^^
+                Stack.set_local env StackArgs.idltyp ^^
+                (* depth *)
+                compile_unboxed_const 0L ^^
+                Stack.set_local env StackArgs.depth ^^
+                (* recovery mode *)
+                can_recover ^^
+                Stack.set_local env StackArgs.can_recover ^^
+                deserialize_go env t
+             )
+             ^^ set_val ^^
+             get_arg_count ^^ compile_sub_const 1L ^^ set_arg_count ^^
+             get_val ^^ compile_eq_const (coercion_error_value env) ^^
+             (E.if1 I64Type
+               (default_or_trap "IDL error: coercion failure encountered")
+               get_val)
+            end)
+        ) ts ^^
+
+        (* Skip any extra arguments *)
+        compile_while env
+         (get_arg_count ^^ compile_rel_const I64Op.GtU 0L)
+         begin
+           get_data_buf ^^
+           get_typtbl_ptr ^^ load_unskewed_ptr ^^
+           ReadBuf.read_sleb128 env get_main_typs_buf ^^
+           G.i (Convert (Wasm_exts.Values.I32 I32Op.WrapI64)) ^^
+           compile_const_32 0l ^^
+           E.call_import env "rts" "skip_any" ^^
+           get_arg_count ^^ compile_sub_const 1L ^^ set_arg_count
+         end ^^
+
+        ReadBuf.is_empty env get_data_buf ^^
+        E.else_trap_with env ("IDL error: left-over bytes " ^ ts_name) ^^
+        ReadBuf.is_empty env get_ref_buf ^^
+        E.else_trap_with env ("IDL error: left-over references " ^ ts_name) ^^
+
+        (* Safety guard: The temporary pointers in the registers must no longer be used when a GC increment runs. *)
+        Registers.clear_registers env
+      )))))))))
+
+    ))
+
+  let deserialize env ts =
+    IC.arg_data env ^^
+    Bool.lit false ^^ (* can't recover *)
+    deserialize_from_blob false env ts
+
+(*
+Note [speculating for short (S)LEB encoded bignums]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+#3098 highlighted that a lot of heap garbage can be generated while reading in
+(S)LEB-encoded bignums. To make heap consumption optimal for every compactly
+representable `Int`, we resort to speculatively reading a 64-byte chunk from
+the `ReadBuf`. We call it speculative, because it may read past the end of the
+buffer (and thus end up containing junk bytes) or even fail because reading
+across Wasm page boundaries could cause trapping. (Consider the buffer ending
+3 bytes before the last-memory-page boundary and issuing a speculative 64-bit read for the
+address 2 bytes less than buffer end.) In case of failure to read data, `-1`
+(a sentinel) is returned. (The sentinel could be use-case specific when later
+the need arises.)
+
+In most cases the speculative read will come back with valid bytes. How many
+of those are relevant, can be judged by consulting the buffer-end pointer or
+analysing the 64-bit word directly. In the case of (S)LEB, the continuation and
+termination bits can be filtered and thus the encoding's last byte detected when
+present in the 64-bit word.
+
+If such a LEB boundary is detected, avenues open up for a much faster (than
+bytewise-sequential) parsing.
+
+After the data is interpreted, it's the client's responsibility to adjust the
+current buffer position.
+
+ *)
+
+(*
+Note [mutable stable values]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+We currently use a Candid derivative to serialize stable values. In addition to
+storing sharable data, we can also store mutable data (records with mutable
+fields and mutable arrays), and we need to preserve aliasing.
+
+To that end we extend Candid with a type constructor `alias t`.
+
+In the type table, alias t is represented by type code 1. All Candid type constructors
+are represented by negative numbers, so this cannot clash with anything and,
+conveniently, makes such values illegal Candid.
+
+The values of `alias t` are either
+
+ * i8(0) 0x00000000 0x00000000 M(v)
+   for one (typically the first) occurrence of v
+   The first 0x00000000 is the “memo field”, the second is the “type hash field”.
+   Both are scratch spaces for the benefit of the decoder.
+   We use **pointer compression** to store 64-bit pointer that are potentially larger
+   than 4GB but small enough to fit into 32-bit with the compressed representation.
+   Pointers are expected to refer to at most 8GB as the memory representation may grow
+   up to two times by switching from 32-bit to 64-bit.
+
+or
+
+ * i8(1) i32(offset) M(v)
+   for all other occurrences of v, where offset is the relative position of the
+   above occurrences from this reference.
+
+We map Motoko types to this as follows:
+
+  e([var t]) = alias e([t]) = alias vec e(t)
+  e({var field : t}) = record { field : alias e(t) }
+
+Why different? Because we need to alias arrays as a whole (we can’t even alias
+their fields, as they are manifestly part of the array heap structure), but
+aliasing records does not work, as aliased record values may appear at
+different types (due to subtyping), and Candid serialization is type-driven.
+Luckily records put all mutable fields behind an indirection (MutBox), so this
+works.
+
+The type-driven code in this module treats `Type.Mut` to always refer to an
+`MutBox`; for arrays the mutable case is handled directly.
+
+To detect and preserve aliasing, these steps are taken:
+
+ * In `buffer_size`, when we see a mutable thing (`Array` or `MutBox`), the
+   first time, we mark it by setting the heap tag to `StableSeen`.
+   This way, when we see it a second time, we can skip the value in the size
+   calculation.
+ * In `serialize`, when we see it a first time (tag still `StableSeen`),
+   we serialize it (first form above), and remember the absolute position
+   in the output buffer, abusing the heap tag here.
+   (Invariant: This absolute position is never `StableSeen`)
+   Upon a second visit (tag not `StableSeen`), we can thus fetch that absolute
+   position and calculate the offset.
+ * In `deserialize`, when we come across a `alias t`, we follow the offset (if
+   needed) to find the content.
+
+   If the memo field is still `0x00000000`, this is the first time we read
+   this, so we deserialize to the Motoko heap, and remember the **compressed**
+   64-bit vanilla pointer by overwriting the memo field.
+   We also store the **compressed** pointer to a blob with the type hash of 
+   the type we are serializing at in the type hash field.
+
+   NOTE for 64-bit destabilization: The Candid destabilization format historically 
+   only reserves 32-bit space for remembering addresses of aliases. However, when 
+   upgrading from old Candid destabilization to new enhanced orthogonal persistence, 
+   the deserialized objects may occupy larger object space (worst case the double space), 
+   such that pointers may be larger than 4GB. Therefore, we use pointer compression to 
+   safely narrow 64-bit addresses into 32-bit Candid(ish) memo space. The compression 
+   relies on the property that the 3 lower bits of the unskewed pointer are zero due 
+   to the 8-bit (64-bit) object alignment.
+
+   If it is not `0x00000000` then we can simply read the **compressed** pointer 
+   from there, after checking the type hash field to make sure we are aliasing at 
+   the same type.
+
+ *)
+
+(*
+Note [Candid subtype checks]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Deserializing Candid values requires a Candid subtype check when
+deserializing values of reference types (actors and functions).
+
+The subtype test is performed directly on the expected and actual
+candid type tables using RTS functions `idl_sub_buf_words`,
+`idl_sub_buf_init` and `idl_sub`. One type table and vector of types
+is generated statically from the list of statically known types
+encountered during code generation, the other is determined
+dynamically by, e.g. message payload. The latter will vary with
+each payload to decode.
+
+The static type table and a type descriptor are stored in passive 
+data segments. Instead of absolute memory addresses, the static type 
+table in the data segment only contains relative offsets into type 
+descriptor. When loaded, these offsets are patched by static addresses 
+that point into the type descriptor.
+
+The known Motoko types are accumulated in a global list as required
+and then, in a final compilation step, encoded to global type table
+and the type descriptor (sequence of type indices). The encoding is 
+stored in passive data segments referenced (by way of segment indices) 
+from dedicated wasm globals so that we can generate code that 
+references the globals before their final definitions are known.
+
+Deserializing a proper (not extended) Candid value stack allocates a
+mutable word buffer, of size determined by `idl_sub_buf_words`.
+The word buffer is used to initialize and provide storage for a
+Rust memo table (see bitrel.rs) memoizing the result of sub and
+super type tests performed during deserialization of a given Candid
+value sequence. The memo table is initialized once, using `idl_sub_buf_init`,
+then shared between recursive calls to deserialize, by threading the (possibly
+null) wasm address of the word buffer as an optional argument. The
+word buffer is stack allocated in generated code, not Rust, because
+it's size is dynamic and Rust doesn't seem to support dynamically-sized
+stack allocation.
+
+Currently, we only perform Candid subtype checks when decoding proper
+(not extended) Candid values. Extended values are required for
+stable variables only: we can omit the check, because compatibility
+should already be enforced by the static signature compatibility
+check. We use the `null`-ness of the word buffer pointer to
+dynamically determine whether to omit or perform Candid subtype checks.
+
+NB: Extending `idl_sub` to support extended, "stable" types (with mutable,
+invariant type constructors) would require extending the polarity argument
+from a Boolean to a three-valued argument to efficiently check equality for
+invariant type constructors in a single pass.
+*)
+
+end (* Serialization *)
+
+(* OldStabilization as migration code: 
+  Deserializing a last time from Candid-serialized stable objects into the stable heap:
+   * stable variables; and
+   * virtual stable memory.
+   c.f.
+   * ../../design/Stable.md
+   * ../../design/StableMemory.md
+*)
+module OldStabilization = struct
+  let load_word32 = G.i (Load {ty = I32Type; align = 0; offset = 0L; sz = None})
+  let store_word32 = G.i (Store {ty = I32Type; align = 0; offset = 0L; sz = None})
+  let write_word32 env = StableMem.write env false "word32" I32Type 4L store_word32
+
+  (* read and clear word32 from stable mem offset on stack *)
+  let read_and_clear_word32 env =
+    match E.mode env with
+    | Flags.ICMode | Flags.RefMode ->
+      Func.share_code1 Func.Always env "__stablemem_read_and_clear_word32"
+        ("offset", I64Type) [I64Type]
+        (fun env get_offset ->
+          Stack.with_words env "temp_ptr" 1L (fun get_temp_ptr ->
+            let (set_word, get_word) = new_local32 env "word" in
+            (* read word *)
+            get_temp_ptr ^^
+            get_offset ^^
+            compile_unboxed_const 4L ^^
+            StableMem.stable64_read env ^^
+            get_temp_ptr ^^ load_word32 ^^
+            set_word ^^
+            (* write 0 *)
+            get_temp_ptr ^^ compile_const_32 0l ^^ store_word32 ^^
+            get_offset ^^
+            get_temp_ptr ^^
+            compile_unboxed_const 4L ^^
+            StableMem.stable64_write env ^^
+            (* return word *)
+            get_word ^^
+            G.i (Convert (Wasm_exts.Values.I64 I64Op.ExtendUI32))
+        ))
+    | _ -> assert false
+
+  (* TODO: rewrite using MemoryFill *)
+  let blob_clear env =
+    Func.share_code1 Func.Always env "blob_clear" ("x", I64Type) [] (fun env get_x ->
+      let (set_ptr, get_ptr) = new_local env "ptr" in
+      let (set_len, get_len) = new_local env "len" in
+      get_x ^^
+      Blob.as_ptr_len env ^^
+      set_len ^^
+      set_ptr ^^
+
+      (* round to word size *)
+      get_len ^^
+      compile_add_const (Int64.sub Heap.word_size 1L) ^^
+      compile_divU_const Heap.word_size ^^
+
+      (* clear all words *)
+      from_0_to_n env (fun get_i ->
+        get_ptr ^^
+        compile_unboxed_const 0L ^^
+        store_unskewed_ptr ^^
+        get_ptr ^^
+        compile_add_const Heap.word_size ^^
+        set_ptr))
+
+  let candid_destabilize env ty save_version =
+    match E.mode env with
+    | Flags.ICMode | Flags.RefMode ->
+      let (set_pages, get_pages) = new_local env "pages" in
+      StableMem.stable64_size env ^^
+      set_pages ^^
+
+      get_pages ^^
+      compile_test I64Op.Eqz ^^
+      E.if1 I64Type
+        begin
+          (* Case: Size zero ==> Nothing in stable memory,
+             so result becomes the nil-valued record. *)
+          let (_, fs) = Type.as_obj ty in
+          let fs' = List.map
+           (fun f -> (f.Type.lab, fun () -> Opt.null_lit env))
+           fs
+          in
+          StableMem.get_mem_size env ^^
+          compile_test I64Op.Eqz ^^
+          E.else_trap_with env "StableMem.mem_size non-zero" ^^
+          compile_unboxed_const StableMem.version_stable_heap_no_regions ^^
+          save_version ^^
+          Object.lit_raw env fs'
+        end
+        begin
+          (* Case: Non-zero size. *)
+          let (set_marker, get_marker) = new_local env "marker" in
+          let (set_len, get_len) = new_local env "len" in
+          let (set_offset, get_offset) = new_local env "offset" in
+          compile_unboxed_const 0L ^^
+          read_and_clear_word32 env ^^
+          set_marker ^^
+
+          get_marker ^^
+          compile_test I64Op.Eqz ^^
+          E.if0
+            begin
+              (* Sub-Case: version 1 or 2:
+                 Regions/Experimental API and stable vars. *)
+              let (set_M, get_M) = new_local env "M" in
+              let (set_version, get_version) = new_local env "version" in
+              let (set_N, get_N) = new_local env "N" in
+
+              StableMem.stable64_size env ^^
+              compile_sub_const 1L ^^
+              compile_shl_const (Int64.of_int page_size_bits) ^^
+              set_M ^^
+
+              (* read version *)
+              get_M ^^
+              compile_add_const (Int64.sub page_size 4L) ^^
+              read_and_clear_word32 env ^^
+              set_version ^^
+              get_version ^^
+              save_version ^^
+
+              (* check version *)
+              get_version ^^
+              compile_unboxed_const (StableMem.version_max) ^^
+              compile_comparison I64Op.GtU ^^
+              E.then_trap_with env (Printf.sprintf
+                "higher stable memory version (expected 1..%s)"
+                (Int64.to_string StableMem.version_max)) ^^
+
+              (* restore StableMem bytes [0..4) *)
+              compile_unboxed_const 0L ^^
+              get_M ^^
+              compile_add_const (Int64.sub page_size 8L) ^^
+              read_and_clear_word32 env ^^
+              G.i (Convert (Wasm_exts.Values.I32 I32Op.WrapI64)) ^^
+              write_word32 env ^^
+
+              (* restore mem_size *)
+              get_M ^^
+              compile_add_const (Int64.sub page_size 12L) ^^
+              read_and_clear_word32 env ^^ (*TODO: use 64 bits *)
+              StableMem.set_mem_size env ^^
+
+              StableMem.get_mem_size env ^^
+              compile_shl_const (Int64.of_int page_size_bits) ^^
+              set_N ^^
+
+              (* set len *)
+              get_N ^^
+              read_and_clear_word32 env ^^
+              set_len ^^
+
+              (* set offset *)
+              get_N ^^
+              compile_add_const 4L ^^
+              set_offset
+            end
+            begin
+              (* Sub-Case: Version 0.
+                 Stable vars with NO Regions/Experimental API. *)
+              (* assert mem_size == 0 *)
+              StableMem.get_mem_size env ^^
+              compile_test I64Op.Eqz ^^
+              E.else_trap_with env "unexpected, non-zero stable memory size" ^^
+
+              (* set len *)
+              get_marker ^^
+              set_len ^^
+
+              (* set offset *)
+              compile_unboxed_const 4L ^^
+              set_offset ^^
+
+              compile_unboxed_const (Int64.of_int 0) ^^
+              save_version
+            end ^^ (* if_ *)
+
+          let (set_blob, get_blob) = new_local env "blob" in
+          (* read blob from stable memory *)
+          Blob.alloc env Tagged.B get_len ^^ set_blob ^^
+          get_blob ^^ Blob.payload_ptr_unskewed env ^^
+          get_offset ^^
+          get_len ^^
+          StableMem.stable64_read env ^^
+
+          let (set_val, get_val) = new_local env "val" in
+          (* deserialize blob to val *)
+          get_blob ^^
+          Bool.lit false ^^ (* can't recover *)
+          Serialization.deserialize_from_blob true env [ty] ^^
+          set_val ^^
+
+          (* clear blob contents *)
+          get_blob ^^
+          blob_clear env ^^
+
+          (* copy zeros from blob to stable memory *)
+          get_offset ^^
+          get_blob ^^ Blob.payload_ptr_unskewed env ^^
+          get_blob ^^ Blob.len env ^^
+          StableMem.stable64_write env ^^
+
+          (* return val *)
+          get_val
+        end
+    | _ -> assert false
+
+  let load env actor_type upgrade_version =
+    candid_destabilize env actor_type upgrade_version ^^
+    UpgradeStatistics.add_instructions env
+end
+
+(* New stable memory layout with dedicated version for enhanced orthogonal persistence.
+   This prevents unwanted forward compatibility of old compiled programs that rely on Candid destabilization.
+   This also helps to detect graph-copy-based destabilization that has priority over enhanced orthogonal persistence.
+  If size == 0: empty
+  let end = physical size * page_size
+  If logical size N > 0:
+    [0..4)          0 (first word is backed up at `end-8`)
+    [4..N)          <stable memory>
+            <zero padding>
+    [end-16..end-8) <size N>
+    [end-8..end-4)  <first word>
+    [end-4..end)   <new version>
+  ending at page boundary
+  Note: The first word must be empty to distinguish this version from the Candid legacy version 0 (which has first word != 0).
+*)
+module NewStableMemory = struct
+  let physical_size env =
+    IC.system_call env "stable64_size" ^^
+    compile_shl_const (Int64.of_int page_size_bits)
+
+  let store_at_end env offset typ get_value =
+    physical_size env ^^
+    compile_sub_const offset ^^
+    get_value ^^
+    match typ with
+    | I32Type -> StableMem.write_word32 env
+    | I64Type -> StableMem.write_word64 env
+    | _ -> assert false
+
+  let read_from_end env offset typ =
+    physical_size env ^^
+    compile_sub_const offset ^^
+    match typ with
+    | I32Type -> StableMem.read_word32 env
+    | I64Type -> StableMem.read_word64 env
+    | _ -> assert false
+
+  let clear_at_end env offset typ =
+    store_at_end env offset typ 
+    (match typ with
+    | I32Type -> compile_const_32 0l
+    | I64Type -> compile_unboxed_const 0L
+    | _ -> assert false
+    )
+
+  let logical_size_offset = 16L
+  let first_word_backup_offset = 8L
+  let version_offset = 4L
+
+  let upgrade_version_from_candid env =
+    StableMem.set_version env ^^
+    StableMem.get_version env ^^
+    compile_eq_const StableMem.legacy_version_no_stable_memory ^^
+    StableMem.get_version env ^^
+    compile_eq_const StableMem.legacy_version_some_stable_memory ^^
+    G.i (Binary (Wasm_exts.Values.I64 I64Op.Or)) ^^
+    E.if1 I64Type
+    begin
+      compile_unboxed_const StableMem.version_stable_heap_no_regions
+    end
+    begin
+      StableMem.get_version env ^^
+      compile_eq_const StableMem.legacy_version_regions ^^
+      E.else_trap_with env "Unsupported stable memory version when upgrading from Candid stabilization" ^^
+      compile_unboxed_const StableMem.version_stable_heap_regions
+    end ^^
+    StableMem.set_version env
+    
+  
+  let upgrade_version_from_graph_stabilization env =
+    StableMem.get_version env ^^
+    compile_eq_const StableMem.version_graph_copy_no_regions ^^
+    E.if1 I64Type
+    begin
+      compile_unboxed_const StableMem.version_stable_heap_no_regions
+    end
+    begin
+      StableMem.get_version env ^^
+      compile_eq_const StableMem.version_graph_copy_regions ^^
+      E.else_trap_with env "Unsupported stable memory version when upgrading from graph-copy-based stabilization" ^^
+      compile_unboxed_const StableMem.version_stable_heap_regions
+    end ^^
+    StableMem.set_version env
+
+  let grow_size env amount =
+    StableMem.get_mem_size env ^^
+    compile_shl_const (Int64.of_int page_size_bits) ^^
+    compile_unboxed_const amount ^^
+    StableMem.ensure env
+
+  let backup env =
+    let (set_first_word, get_first_word) = new_local32 env "first_word" in
+    physical_size env ^^
+    compile_test I64Op.Eqz ^^
+    E.if0
+      G.nop
+      begin
+        (* read and clear first word *)
+        compile_unboxed_const 0L ^^ StableMem.read_word32 env ^^ set_first_word ^^
+        compile_unboxed_const 0L ^^ compile_const_32 0l ^^ StableMem.write_word32 env ^^
+
+        grow_size env logical_size_offset ^^
+
+        (* backup logical size *)
+        store_at_end env logical_size_offset I64Type (StableMem.get_mem_size env) ^^
+
+        (* backup first word *)
+        store_at_end env first_word_backup_offset I32Type get_first_word ^^
+
+        (* store the version *)
+        store_at_end env version_offset I32Type (StableMem.get_version env ^^ G.i (Convert (Wasm_exts.Values.I32 I32Op.WrapI64)))
+      end
+
+  let restore env =
+    let (set_first_word, get_first_word) = new_local32 env "first_word" in
+    physical_size env ^^
+    compile_test I64Op.Eqz ^^
+    E.if0
+      begin
+        compile_unboxed_const 0L ^^ StableMem.set_mem_size env
+      end
+      begin
+        (* check the version *)
+        read_from_end env version_offset I32Type ^^
+        G.i (Convert (Wasm_exts.Values.I64 I64Op.ExtendUI32)) ^^
+        StableMem.set_version env ^^
+        StableMem.get_version env ^^
+        compile_eq_const StableMem.version_stable_heap_no_regions ^^
+        StableMem.get_version env ^^
+        compile_eq_const StableMem.version_stable_heap_regions ^^
+        G.i (Binary (Wasm_exts.Values.I64 I64Op.Or)) ^^
+        E.else_trap_with env (Printf.sprintf
+          "unsupported stable memory version (expected %s or %s)"
+           (Int64.to_string StableMem.version_stable_heap_no_regions)
+           (Int64.to_string StableMem.version_stable_heap_regions)) ^^
+
+        (* read first word *)
+        read_from_end env first_word_backup_offset I32Type ^^
+        set_first_word ^^
+        
+        (* restore logical size *)
+        read_from_end env logical_size_offset I64Type ^^
+        StableMem.set_mem_size env ^^
+
+        (* clear size and version *)
+        clear_at_end env logical_size_offset I64Type ^^
+        clear_at_end env first_word_backup_offset I32Type ^^
+        clear_at_end env version_offset I32Type ^^
+
+        (* restore first word *)
+        compile_unboxed_const 0L ^^ get_first_word ^^ StableMem.write_word32 env
+      end
+end
+
+(* Enhanced orthogonal persistence *)
+module EnhancedOrthogonalPersistence = struct
+  let load_stable_actor env = E.call_import env "rts" "load_stable_actor"
+    
+  let save_stable_actor env = E.call_import env "rts" "save_stable_actor"
+
+  let free_stable_actor env = E.call_import env "rts" "free_stable_actor"
+
+  let create_type_descriptor env actor_type =
+    let (candid_type_desc, type_offsets, type_indices) = Serialization.(type_desc env Persistence [actor_type]) in
+    let serialized_offsets = StaticBytes.(as_bytes [i64s (List.map Int64.of_int type_offsets)]) in
+    assert (type_indices = [0l]);
+    Blob.lit env Tagged.B candid_type_desc ^^
+    Blob.lit env Tagged.B serialized_offsets
+
+  let register_stable_type env actor_type =
+    create_type_descriptor env actor_type ^^
+    E.call_import env "rts" "register_stable_type"
+
+  let load_old_field env field get_old_actor =
+    if field.Type.typ = Type.(Opt Any) then
+      (* A stable variable may have been promoted to type `Any`: Therefore, drop its former content. *)
+      Opt.inject env (Tuple.compile_unit env)
+    else
+      (get_old_actor ^^ Object.load_idx_raw env field.Type.lab)
+
+  let empty_actor env actor_type =
+    let (_, field_declarations) = Type.as_obj actor_type in
+    let field_initializers = List.map
+      (fun field -> (field.Type.lab, fun () -> Opt.null_lit env))
+      field_declarations
+    in
+    Object.lit_raw env field_initializers
+
+  (* Support additional fields in an upgraded actor. *)
+  let upgrade_actor env actor_type =
+    let set_old_actor, get_old_actor = new_local env "old_actor" in
+    let get_field_value field = 
+      get_old_actor ^^
+      Object.contains_field env field.Type.lab ^^
+      (E.if1 I64Type
+        (load_old_field env field get_old_actor)
+        (Opt.null_lit env)
+      ) in
+    let (_, field_declarations) = Type.as_obj actor_type in
+    let field_initializers = List.map
+      (fun field -> (field.Type.lab, fun () -> (get_field_value field)))
+      field_declarations
+    in
+    set_old_actor ^^
+    Object.lit_raw env field_initializers
+
+  let recover_actor env actor_type =
+    load_stable_actor env ^^
+    upgrade_actor env actor_type ^^
+    free_stable_actor env
+
+  let save env actor_type =
+    IC.get_actor_to_persist env ^^
+    save_stable_actor env ^^
+    NewStableMemory.backup env ^^
+    UpgradeStatistics.set_instructions env
+
+  let load env actor_type =
+    register_stable_type env actor_type ^^
+    load_stable_actor env ^^
+    compile_test I64Op.Eqz ^^
+    (E.if1 I64Type
+      (empty_actor env actor_type)
+      (recover_actor env actor_type)
+    ) ^^
+    NewStableMemory.restore env ^^
+    UpgradeStatistics.add_instructions env
+
+  let initialize env actor_type =
+    register_stable_type env actor_type
+end (* EnhancedOrthogonalPersistence *)
+
+(* As fallback when doing persistent memory layout changes. *)
+module GraphCopyStabilization = struct
+  let is_graph_stabilization_started env =
+    E.call_import env "rts" "is_graph_stabilization_started" ^^ Bool.from_rts_int32
+
+  let start_graph_stabilization env actor_type =
+    EnhancedOrthogonalPersistence.create_type_descriptor env actor_type ^^
+    E.call_import env "rts" "start_graph_stabilization"
+
+  let graph_stabilization_increment env =
+    E.call_import env "rts" "graph_stabilization_increment" ^^ Bool.from_rts_int32
+
+  let start_graph_destabilization env actor_type =
+    EnhancedOrthogonalPersistence.create_type_descriptor env actor_type ^^
+    E.call_import env "rts" "start_graph_destabilization"
+
+  let graph_destabilization_increment env =
+    E.call_import env "rts" "graph_destabilization_increment" ^^ Bool.from_rts_int32
+
+  let get_graph_destabilized_actor env actor_type =
+    E.call_import env "rts" "get_graph_destabilized_actor" ^^
+    EnhancedOrthogonalPersistence.upgrade_actor env actor_type
+end
+
+module GCRoots = struct
+  let register_static_variables env = 
+    E.(env.object_pool.frozen) := true;
+    Func.share_code0 Func.Always env "initialize_root_array" [] (fun env ->
+      let length = Int64.of_int (E.object_pool_size env) in
+      compile_unboxed_const length ^^
+      E.call_import env "rts" "initialize_static_variables" ^^
+      E.iterate_object_pool env (fun index allocation ->
+        compile_unboxed_const (Int64.of_int index) ^^
+        allocation env ^^
+        E.call_import env "rts" "set_static_variable"
+      )
+    )
+end (* GCRoots *)
+
+module StackRep = struct
+  open SR
+
+  (*
+     Most expressions have a “preferred”, most optimal, form. Hence,
+     compile_exp put them on the stack in that form, and also returns
+     the form it chose.
+
+     But the users of compile_exp usually want a specific form as well.
+     So they use compile_exp_as, indicating the form they expect.
+     compile_exp_as then does the necessary coercions.
+   *)
+
+  let of_arity n =
+    if n = 1 then Vanilla else UnboxedTuple n
+
+  (* The stack rel of a primitive type, i.e. what the binary operators expect *)
+  let of_type t =
+    let open Type in
+    match normalize t with
+    | Prim Bool -> SR.bool
+    | Prim (Nat | Int) -> Vanilla
+    | Prim ((Nat8 | Nat16 | Nat32 | Nat64 | Int8 | Int16 | Int32 | Int64 | Char) as pty) -> UnboxedWord64 pty
+    | Prim (Text | Blob | Principal) -> Vanilla
+    | Prim Float -> UnboxedFloat64
+    | Obj (Actor, _) -> Vanilla
+    | Func (Shared _, _, _, _, _) -> Vanilla
+    | p -> todo "StackRep.of_type" (Arrange_ir.typ p) Vanilla
+
+  (* The env looks unused, but will be needed once we can use multi-value, to register
+     the complex types in the environment.
+     For now, multi-value block returns are handled via FakeMultiVal. *)
+  let to_block_type env = function
+    | Vanilla -> [I64Type]
+    | UnboxedWord64 _ -> [I64Type]
+    | UnboxedFloat64 -> [F64Type]
+    | UnboxedTuple n -> Lib.List.make n I64Type
+    | Const _ -> []
+    | Unreachable -> []
+
+  let to_string = function
+    | Vanilla -> "Vanilla"
+    | UnboxedWord64 pty -> prim_fun_name pty "UnboxedWord64"
+    | UnboxedFloat64 -> "UnboxedFloat64"
+    | UnboxedTuple n -> Printf.sprintf "UnboxedTuple %d" n
+    | Unreachable -> "Unreachable"
+    | Const _ -> "Const"
+
+  let join (sr1 : t) (sr2 : t) = match sr1, sr2 with
+    | _, _ when SR.eq sr1 sr2 -> sr1
+    | Unreachable, sr2 -> sr2
+    | sr1, Unreachable -> sr1
+
+    | Const _, Const _ -> Vanilla
+    | Const _, sr2_ -> sr2
+    | sr1, Const _ -> sr1
+
+    | _, Vanilla -> Vanilla
+    | Vanilla, _ -> Vanilla
+
+    | UnboxedTuple n, UnboxedTuple m when n = m -> sr1
+
+    | _, _ ->
+      Printf.eprintf "Invalid stack rep join (%s, %s)\n"
+        (to_string sr1) (to_string sr2); sr1
+
+  let joins = List.fold_left join Unreachable
+
+  let drop env (sr_in : t) =
+    match sr_in with
+    | Vanilla | UnboxedWord64 _ | UnboxedFloat64 -> G.i Drop
+    | UnboxedTuple n -> G.table n (fun _ -> G.i Drop)
+    | Const _ | Unreachable -> G.nop
+
+  let rec build_constant env = function
+  | Const.Lit (Const.Vanilla value) -> E.Vanilla value
+  | Const.Lit (Const.Bool number) -> E.Vanilla (Bool.vanilla_lit number)
+  | Const.Lit (Const.Text payload) -> Blob.constant env Tagged.T payload
+  | Const.Lit (Const.Blob payload) -> Blob.constant env Tagged.B payload
+  | Const.Lit (Const.Null) -> E.Vanilla Opt.null_vanilla_lit
+  | Const.Lit (Const.BigInt number) -> BigNum.constant env number
+  | Const.Lit (Const.Word64 (pty, number)) -> BoxedWord64.constant env pty number
+  | Const.Lit (Const.Float64 number) -> Float.constant env number
+  | Const.Opt value -> Opt.constant env (build_constant env value)
+  | Const.Fun (_, get_fi, _) -> Closure.constant env get_fi
+  | Const.Message _ -> assert false
+  | Const.Unit -> E.Vanilla (Tuple.unit_vanilla_lit env)
+  | Const.Tag (tag, value) ->
+      let payload = build_constant env value in
+      Tagged.shared_object env (fun env ->
+        let materialized_payload = Tagged.materialize_shared_value env payload in
+        Variant.inject env tag materialized_payload
+      )
+  | Const.Array elements -> 
+      let constant_elements = List.map (build_constant env) elements in
+      Arr.constant env Tagged.I constant_elements
+  | Const.Tuple elements -> 
+      let constant_elements = List.map (build_constant env) elements in
+      Arr.constant env Tagged.T constant_elements
+  | Const.Obj fields ->
+      let constant_fields = List.map (fun (name, value) -> (name, build_constant env value)) fields in
+      Object.constant env constant_fields
+
+  let materialize_constant env value =
+    Tagged.materialize_shared_value env (build_constant env value)
+
+  let adjust env (sr_in : t) sr_out =
+    if eq sr_in sr_out
+    then G.nop
+    else match sr_in, sr_out with
+    | Unreachable, Unreachable -> G.nop
+    | Unreachable, _ -> G.i Unreachable
+
+    | UnboxedTuple n, Vanilla -> Tuple.from_stack env n
+    | Vanilla, UnboxedTuple n -> Tuple.to_stack env n
+
+    (* BoxedWord64 types *)
+    | UnboxedWord64 (Type.(Int64 | Nat64) as pty), Vanilla ->
+      BoxedWord64.box env pty
+    | Vanilla, UnboxedWord64 (Type.(Int64 | Nat64) as pty) -> 
+      BoxedWord64.unbox env pty
+
+    (* TaggedSmallWord types *)
+    | UnboxedWord64 (Type.(Int8 | Nat8 | Int16 | Nat16 | Int32 | Nat32 | Char) as pty), Vanilla ->
+      TaggedSmallWord.tag env pty
+    | Vanilla, UnboxedWord64 (Type.(Nat8 | Int8 | Nat16 | Int16 | Int32 | Nat32 | Char) as pty) ->
+      TaggedSmallWord.untag env pty
+
+    | UnboxedFloat64, Vanilla -> Float.box env
+    | Vanilla, UnboxedFloat64 -> Float.unbox env
+
+    | Const value, Vanilla -> 
+        materialize_constant env value
+    | Const Const.Lit (Const.Vanilla n), UnboxedWord64 ty ->
+        compile_unboxed_const n ^^
+        TaggedSmallWord.untag env ty
+    | Const Const.Lit (Const.Word64 (ty1, n)), UnboxedWord64 ty2 when ty1 = ty2 -> 
+        compile_unboxed_const n
+    | Const Const.Lit (Const.Float64 f), UnboxedFloat64 -> Float.compile_unboxed_const f
+    | Const c, UnboxedTuple 0 -> G.nop
+    | Const Const.Tuple cs, UnboxedTuple n ->
+      assert (n = List.length cs);
+      G.concat_map (fun c -> materialize_constant env c) cs
+    | _, _ ->
+      Printf.eprintf "Unknown stack_rep conversion %s -> %s\n"
+        (to_string sr_in) (to_string sr_out);
+      assert false
+
+end (* StackRep *)
+
+module VarEnv = struct
+
+  (* A type to record where Motoko names are stored. *)
+  type varloc =
+    (* A Wasm Local of the current function, directly containing the value,
+       in the given stackrep (Vanilla, UnboxedWord64, …) so far
+       Used for immutable and mutable, non-captured data *)
+    | Local of SR.t * int32
+    (* A Wasm Local of the current function, that points to memory location,
+       which is a MutBox.  Used for mutable captured data *)
+    | HeapInd of int32
+    (* A static variable accessed by an index via the runtime system, refers to a MutBox,
+       belonging to the GC root set *)
+    | Static of int64
+    (* Constant literals can reside in dynamic heap *)
+    | Const of Const.v
+    (* public method *)
+    | PublicMethod of int32 * string
+
+  let is_non_local : varloc -> bool = function
+    | Local _
+    | HeapInd _ -> false
+    | Static _
+    | PublicMethod _
+    | Const _ -> true
+
+  type lvl = TopLvl | NotTopLvl
+
+  (*
+  The source variable environment:
+   - Whether we are on the top level
+   - In-scope variables
+   - scope jump labels
+  *)
+
+
+  module NameEnv = Env.Make(String)
+  type t = {
+    lvl : lvl;
+    vars : (varloc * Type.typ) NameEnv.t; (* variables ↦ their location and type *)
+    labels : G.depth NameEnv.t; (* jump label ↦ their depth *)
+  }
+
+  let empty_ae = {
+    lvl = TopLvl;
+    vars = NameEnv.empty;
+    labels = NameEnv.empty;
+  }
+
+  (* Creating a local environment, resetting the local fields,
+     and removing bindings for local variables (unless they are at global locations)
+  *)
+
+  let mk_fun_ae ae = { ae with
+    lvl = NotTopLvl;
+    vars = NameEnv.filter (fun v (l, _) ->
+      let non_local = is_non_local l in
+      (* For debugging, enable this:
+      (if not non_local then Printf.eprintf "VarEnv.mk_fun_ae: Removing %s\n" v);
+      *)
+      non_local
+    ) ae.vars;
+  }
+  let lookup ae var =
+    match NameEnv.find_opt var ae.vars with
+      | Some e -> Some e
+      | None   -> Printf.eprintf "Could not find %s\n" var; None
+
+  let lookup_var ae var =
+    match lookup ae var with
+      | Some (l, _) -> Some l
+      | None -> None
+
+  let needs_capture ae var = match lookup_var ae var with
+    | Some l -> not (is_non_local l)
+    | None -> assert false
+
+  let add_local_with_heap_ind env (ae : t) name typ =
+      let i = E.add_anon_local env I64Type in
+      E.add_local_name env i name;
+      ({ ae with vars = NameEnv.add name ((HeapInd i), typ) ae.vars }, i)
+
+  let add_static_variable (ae : t) name index typ =
+      { ae with vars = NameEnv.add name ((Static index), typ) ae.vars }
+
+  let add_local_public_method (ae : t) name (fi, exported_name) typ =
+      { ae with vars = NameEnv.add name ((PublicMethod (fi, exported_name) : varloc), typ) ae.vars }
+
+  let add_local_const (ae : t) name cv typ =
+      { ae with vars = NameEnv.add name ((Const cv : varloc), typ) ae.vars }
+
+  let add_local_local env (ae : t) name sr i typ =
+      { ae with vars = NameEnv.add name ((Local (sr, i)), typ) ae.vars }
+
+  let add_direct_local env (ae : t) name sr typ =
+      let i = E.add_anon_local env (SR.to_var_type sr) in
+      E.add_local_name env i name;
+      (add_local_local env ae name sr i typ, i)
+
+  (* Adds the names to the environment and returns a list of setters *)
+  let rec add_arguments env (ae : t) as_local = function
+    | [] -> ae
+    | ((name, typ) :: remainder) ->
+      if as_local name then
+        let i = E.add_anon_local env I64Type in
+        E.add_local_name env i name;
+        let ae' = { ae with vars = NameEnv.add name ((Local (SR.Vanilla, i)), typ) ae.vars } in
+        add_arguments env ae' as_local remainder
+      else
+        let index = MutBox.add_global_mutbox env in
+        let ae' = add_static_variable ae name index typ in
+        add_arguments env ae' as_local remainder
+
+  let add_argument_locals env (ae : t) =
+    add_arguments env ae (fun _ -> true)
+
+  let add_label (ae : t) name (d : G.depth) =
+      { ae with labels = NameEnv.add name d ae.labels }
+
+  let get_label_depth (ae : t) name : G.depth  =
+    match NameEnv.find_opt name ae.labels with
+      | Some d -> d
+      | None   -> raise (CodegenError (Printf.sprintf "Could not find %s\n" name))
+
+end (* VarEnv *)
+
+(* type for wrapping code with context, context is establishment
+   of (pattern) binding, argument is the code using the binding,
+   result is e.g. the code for `case p e`. *)
+type scope_wrap = G.t -> G.t
+
+let unmodified : scope_wrap = fun code -> code
+
+let rec can_be_pointer typ nested_optional =
+  Type.(match normalize typ with
+  | Mut t -> (can_be_pointer t nested_optional)
+  | Opt t -> (if nested_optional then true else (can_be_pointer t true))
+  | Prim (Null| Bool | Char | Nat8 | Nat16 | Int8 | Int16) | Non | Tup [] -> false
+  | _ -> true)
+
+let potential_pointer typ : bool =
+  (* must not eliminate nested optional types as they refer to a heap object for ??null, ???null etc. *)
+  can_be_pointer typ false
+
+module Var = struct
+  (* This module is all about looking up Motoko variables in the environment,
+     and dealing with mutable variables *)
+
+  open VarEnv
+
+  (* Returns desired stack representation, preparation code and code to consume
+     the value onto the stack *)
+  let set_val env ae var : G.t * SR.t * G.t = match VarEnv.lookup ae var with
+    | Some ((Local (sr, i)), _) ->
+      G.nop,
+      sr,
+      G.i (LocalSet (nr i))
+    | Some ((HeapInd i), typ) when potential_pointer typ ->
+      G.i (LocalGet (nr i)) ^^
+      Tagged.load_forwarding_pointer env ^^
+      compile_add_const ptr_unskew ^^
+      compile_add_const (Int64.mul MutBox.field Heap.word_size),
+      SR.Vanilla,
+      Tagged.write_with_barrier env
+    | Some ((HeapInd i), typ) ->
+      G.i (LocalGet (nr i)),
+      SR.Vanilla,
+      MutBox.store_field env
+    | Some ((Static index), typ) when potential_pointer typ ->
+      Heap.get_static_variable env index ^^
+      Tagged.load_forwarding_pointer env ^^
+      compile_add_const ptr_unskew ^^
+      compile_add_const (Int64.mul MutBox.field Heap.word_size),
+      SR.Vanilla,
+      Tagged.write_with_barrier env
+    | Some ((Static index), typ) ->
+      Heap.get_static_variable env index,
+      SR.Vanilla,
+      MutBox.store_field env
+    | Some ((Const _), _) -> fatal "set_val: %s is const" var
+    | Some ((PublicMethod _), _) -> fatal "set_val: %s is PublicMethod" var
+    | None -> fatal "set_val: %s missing" var
+
+  (* Stores the payload. Returns stack preparation code, and code that consumes the values from the stack *)
+  let set_val_vanilla env ae var : G.t * G.t =
+    let pre_code, sr, code = set_val env ae var in
+    pre_code, StackRep.adjust env SR.Vanilla sr ^^ code
+
+  (* Stores the payload (which is found on the stack, in Vanilla stackrep) *)
+  let set_val_vanilla_from_stack env ae var : G.t =
+    let pre_code, code = set_val_vanilla env ae var in
+    if G.is_nop pre_code
+    then code
+    else
+      (* Need to shuffle the stack entries *)
+      let (set_x, get_x) = new_local env "var_scrut" in
+      set_x ^^
+      pre_code ^^
+      get_x ^^
+      code
+
+  (* Returns the payload (optimized representation) *)
+  let get_val (env : E.t) (ae : VarEnv.t) var = match VarEnv.lookup_var ae var with
+    | Some (Local (sr, i)) ->
+      sr, G.i (LocalGet (nr i))
+    | Some (HeapInd i) ->
+      SR.Vanilla, G.i (LocalGet (nr i)) ^^ MutBox.load_field env
+    | Some (Static index) ->
+      SR.Vanilla, 
+      Heap.get_static_variable env index ^^
+      MutBox.load_field env
+    | Some (Const c) ->
+      SR.Const c, G.nop
+    | Some (PublicMethod (_, name)) ->
+      SR.Vanilla,
+      IC.get_self_reference env ^^
+      IC.actor_public_field env name
+    | None -> assert false
+
+  (* Returns the payload (vanilla representation) *)
+  let get_val_vanilla (env : E.t) (ae : VarEnv.t) var =
+    let sr, code = get_val env ae var in
+    code ^^ StackRep.adjust env sr SR.Vanilla
+
+  (* Returns the value to put in the closure,
+     and code to restore it, including adding to the environment
+  *)
+  let capture old_env ae0 var : G.t * (E.t -> VarEnv.t -> VarEnv.t * scope_wrap) =
+    match VarEnv.lookup ae0 var with
+    | Some ((Local (sr, i)), typ) ->
+      ( G.i (LocalGet (nr i)) ^^ StackRep.adjust old_env sr SR.Vanilla
+      , fun new_env ae1 ->
+        (* we use SR.Vanilla in the restored environment. We could use sr;
+           like for parameters hard to predict what’s better *)
+        let ae2, j = VarEnv.add_direct_local new_env ae1 var SR.Vanilla typ in
+        let restore_code = G.i (LocalSet (nr j))
+        in ae2, fun body -> restore_code ^^ body
+      )
+    | Some ((HeapInd i), typ) ->
+      ( G.i (LocalGet (nr i))
+      , fun new_env ae1 ->
+        let ae2, j = VarEnv.add_local_with_heap_ind new_env ae1 var typ in
+        let restore_code = G.i (LocalSet (nr j))
+        in ae2, fun body -> restore_code ^^ body
+      )
+    | _ -> assert false
+
+  (* This is used when putting a mutable field into an object.
+     In the IR, mutable fields of objects are pre-allocated as MutBox objects,
+     to allow the async/await.
+     So we expect the variable to be in a HeapInd (pointer to MutBox on the heap),
+     or Static (static variable represented as a MutBox that is accessed via the 
+     runtime system) and we use the pointer.
+  *)
+  let get_aliased_box env ae var = match VarEnv.lookup_var ae var with
+    | Some (HeapInd i) -> G.i (LocalGet (nr i))
+    | Some (Static index) -> Heap.get_static_variable env index
+    | _ -> assert false
+
+  let capture_aliased_box env ae var = match VarEnv.lookup_var ae var with
+    | Some (HeapInd i) ->
+      G.i (LocalSet (nr i))
+    | _ -> assert false
+
+end (* Var *)
+
+(* Calling well-known prelude functions *)
+(* FIXME: calling into the prelude will not work if we ever need to compile a program
+   that requires top-level cps conversion;
+   use new prims instead *)
+module Internals = struct
+  let call_prelude_function env ae var =
+    match VarEnv.lookup_var ae var with
+    | Some (VarEnv.Const Const.Fun (_, mk_fi, _)) ->
+       compile_unboxed_zero ^^ (* A dummy closure *)
+       G.i (Call (nr (mk_fi())))
+    | _ -> assert false
+
+  let add_cycles env ae = call_prelude_function env ae "@add_cycles"
+  let reset_cycles env ae = call_prelude_function env ae "@reset_cycles"
+  let reset_refund env ae = call_prelude_function env ae "@reset_refund"
+end
+
+(* This comes late because it also deals with messages *)
+module FuncDec = struct
+  let bind_args env ae0 first_arg args =
+    let rec go i ae = function
+    | [] -> ae
+    | a::args ->
+      (* Function arguments are always vanilla, due to subtyping and uniform representation.
+         We keep them as such here for now. We _could_ always unpack those that can be unpacked
+         (Nat32 etc.). It is generally hard to predict which strategy is better. *)
+      let ae' = VarEnv.add_local_local env ae a.it SR.Vanilla (Int32.of_int i) a.note in
+      go (i+1) ae' args in
+    go first_arg ae0 args
+
+  (* Create a WebAssembly func from a pattern (for the argument) and the body.
+   Parameter `captured` should contain the, well, captured local variables that
+   the function will find in the closure. *)
+  let compile_local_function outer_env outer_ae restore_env args mk_body ret_tys at =
+    let arg_names = List.map (fun a -> a.it, I64Type) args in
+    let return_arity = List.length ret_tys in
+    let retty = Lib.List.make return_arity I64Type in
+    let ae0 = VarEnv.mk_fun_ae outer_ae in
+    Func.of_body outer_env (["clos", I64Type] @ arg_names) retty (fun env -> G.with_region at (
+      let get_closure = G.i (LocalGet (nr 0l)) ^^ Tagged.load_forwarding_pointer env in
+
+      let ae1, closure_codeW = restore_env env ae0 get_closure in
+
+      (* Add arguments to the environment (shifted by 1) *)
+      let ae2 = bind_args env ae1 1 args in
+
+      closure_codeW (mk_body env ae2)
+    ))
+
+  let message_start env sort = match sort with
+      | Type.(Shared Write) ->
+        Lifecycle.(trans env InUpdate)
+      | Type.(Shared Query) ->
+        Lifecycle.(trans env InQuery)
+      | Type.(Shared Composite) ->
+        Lifecycle.(trans env InComposite)
+      | _ -> assert false
+
+  let message_cleanup env sort = match sort with
+      | Type.(Shared Write) ->
+        Lifecycle.get env ^^
+        compile_eq_const (Lifecycle.(int_of_state InStabilization)) ^^
+        Lifecycle.get env ^^
+        compile_eq_const (Lifecycle.(int_of_state InDestabilization)) ^^
+        G.i (Binary (Wasm_exts.Values.I64 I64Op.Or)) ^^
+        E.if0
+          G.nop
+          begin
+            GC.collect_garbage env ^^
+            Lifecycle.(trans env Idle)
+          end
+      | Type.Shared Type.Query ->
+        Lifecycle.(trans env PostQuery)
+      | Type.Shared Type.Composite ->
+        (* Stay in composite query state such that callbacks of 
+        composite queries can also use the memory reserve. 
+        The state is isolated since memory changes of queries 
+        are rolled back by the IC runtime system. *)
+        Lifecycle.(trans env InComposite)
+      | _ -> assert false
+
+  let callback_start env =
+    Lifecycle.(is_in env InComposite) ^^
+    E.if0
+      (G.nop)
+      (message_start env Type.(Shared Write))
+
+  let callback_cleanup env =
+    Lifecycle.(is_in env InComposite) ^^
+    E.if0
+      (G.nop)
+      (message_cleanup env (Type.Shared Type.Write))
+
+  let compile_const_message outer_env outer_ae sort control args mk_body ret_tys at : E.func_with_names =
+    let ae0 = VarEnv.mk_fun_ae outer_ae in
+    Func.of_body outer_env [] [] (fun env -> G.with_region at (
+      message_start env sort ^^
+      (* cycles *)
+      Internals.reset_cycles env outer_ae ^^
+      Internals.reset_refund env outer_ae ^^
+      (* reply early for a oneway *)
+      (if control = Type.Returns
+       then
+         Tuple.compile_unit env ^^
+         Serialization.serialize env [] ^^
+         IC.reply_with_data env
+       else G.nop) ^^
+      (* Deserialize argument and add params to the environment *)
+      let arg_list = List.map (fun a -> (a.it, a.note)) args in
+      let arg_names = List.map (fun a -> a.it) args in
+      let arg_tys = List.map (fun a -> a.note) args in
+      let ae1 = VarEnv.add_argument_locals env ae0 arg_list in
+      Serialization.deserialize env arg_tys ^^
+      G.concat_map (Var.set_val_vanilla_from_stack env ae1) (List.rev arg_names) ^^
+      mk_body env ae1 ^^
+      message_cleanup env sort
+    ))
+
+  (* Compile a closed function declaration (captures no local variables) *)
+  let closed pre_env sort control name args mk_body fun_rhs ret_tys at =
+    if Type.is_shared_sort sort
+    then begin
+      let (fi, fill) = E.reserve_fun pre_env name in
+      ( Const.Message fi, fun env ae ->
+        fill (compile_const_message env ae sort control args mk_body ret_tys at)
+      )
+    end else begin
+      assert (control = Type.Returns);
+      let lf = E.make_lazy_function pre_env name in
+      let fun_id = E.get_constant_function_id pre_env in
+      ( Const.Fun (fun_id, (fun () -> Lib.AllocOnUse.use lf), fun_rhs), fun env ae ->
+        let restore_no_env _env ae _ = ae, unmodified in
+        Lib.AllocOnUse.def lf (lazy (compile_local_function env ae restore_no_env args mk_body ret_tys at))
+      )
+    end
+
+  (* Compile a closure declaration (captures local variables) *)
+  let closure env ae sort control name captured args mk_body ret_tys at =
+      let is_local = sort = Type.Local in
+
+      let set_clos, get_clos = new_local env (name ^ "_clos") in
+
+      let len = Wasm.I64.of_int_u (List.length captured) in
+      let store_env, restore_env =
+        let rec go i = function
+          | [] -> (G.nop, fun _env ae1 _ -> ae1, unmodified)
+          | (v::vs) ->
+              let store_rest, restore_rest = go (i + 1) vs in
+              let store_this, restore_this = Var.capture env ae v in
+              let store_env =
+                get_clos ^^
+                store_this ^^
+                Closure.store_data env (Wasm.I64.of_int_u i) ^^
+                store_rest in
+              let restore_env env ae1 get_env =
+                let ae2, codeW = restore_this env ae1 in
+                let ae3, code_restW = restore_rest env ae2 get_env in
+                (ae3,
+                 fun body ->
+                 get_env ^^
+                 Closure.load_data env (Wasm.I64.of_int_u i) ^^
+                 codeW (code_restW body)
+                )
+              in store_env, restore_env in
+        go 0 captured in
+
+      let f =
+        if is_local
+        then compile_local_function env ae restore_env args mk_body ret_tys at
+        else assert false (* no first class shared functions yet *) in
+
+      let fi = E.add_fun env name f in
+
+      let code =
+        (* Allocate a heap object for the closure *)
+        Tagged.alloc env (Int64.add Closure.header_size len) Tagged.Closure ^^
+        set_clos ^^
+
+        (* Store the function pointer number: *)
+        get_clos ^^
+        compile_unboxed_const (Wasm.I64_convert.extend_i32_u (E.add_fun_ptr env fi)) ^^
+        Tagged.store_field env Closure.funptr_field ^^
+
+        (* Store the length *)
+        get_clos ^^
+        compile_unboxed_const len ^^
+        Tagged.store_field env Closure.len_field ^^
+
+        (* Store all captured values *)
+        store_env ^^
+
+        get_clos ^^
+        Tagged.allocation_barrier env ^^
+        G.i Drop
+      in
+
+      if is_local
+      then
+        SR.Vanilla,
+        code ^^
+        get_clos
+      else assert false (* no first class shared functions *)
+
+  let lit env ae name sort control free_vars args mk_body ret_tys at =
+    let captured = List.filter (VarEnv.needs_capture ae) free_vars in
+
+    if ae.VarEnv.lvl = VarEnv.TopLvl then assert (captured = []);
+
+    if captured = []
+    then
+      let (ct, fill) = closed env sort control name args mk_body Const.Complicated ret_tys at in
+      fill env ae;
+      (SR.Const ct, G.nop)
+    else closure env ae sort control name captured args mk_body ret_tys at
+
+  (* Returns a closure corresponding to a future (async block) *)
+  let async_body env ae ts free_vars mk_body at =
+    (* We compile this as a local, returning function, so set return type to [] *)
+    let sr, code = lit env ae "anon_async" Type.Local Type.Returns free_vars [] mk_body [] at in
+    code ^^
+    StackRep.adjust env sr SR.Vanilla
+
+  (* Takes the reply and reject callbacks, tuples them up (with administrative extras),
+     adds them to the continuation table, and returns the two callbacks expected by
+     ic.call_new.
+
+     The tupling is necessary because we want to free _both_/_all_ closures
+     when the call is answered.
+
+     The reply callback function exists once per type (as it has to do
+     deserialization); the reject callback function is unique.
+  *)
+
+  let closures_to_reply_reject_callbacks_aux env ts_opt =
+    let arity, reply_name, from_arg_data =
+      match ts_opt with
+      | Some ts ->
+        (List.length ts,
+         "@callback<" ^ Typ_hash.typ_hash (Type.Tup ts) ^ ">",
+         fun env -> Serialization.deserialize env ts)
+      | None ->
+        (1,
+         "@callback",
+         (fun env ->
+           Blob.of_size_copy env Tagged.B
+           (fun env -> 
+            IC.system_call env "msg_arg_data_size")
+           (fun env -> 
+            IC.system_call env "msg_arg_data_copy")
+           (fun env -> compile_unboxed_const 0L)))
+    in
+    Func.define_built_in env reply_name ["env", I64Type] [] (fun env ->
+        callback_start env ^^
+        (* Look up continuation *)
+        let (set_closure, get_closure) = new_local env "closure" in
+        G.i (LocalGet (nr 0l)) ^^
+        ContinuationTable.recall env ^^
+        Arr.load_field env 0L ^^ (* get the reply closure *)
+        set_closure ^^
+        get_closure ^^
+        Closure.prepare_closure_call env ^^
+
+        (* Deserialize/Blobify reply arguments  *)
+        from_arg_data env ^^
+
+        get_closure ^^
+        Closure.call_closure env arity 0 ^^
+
+        callback_cleanup env
+      );
+
+    let reject_name = "@reject_callback" in
+    Func.define_built_in env reject_name ["env", I64Type] [] (fun env ->
+        callback_start env ^^
+        (* Look up continuation *)
+        let (set_closure, get_closure) = new_local env "closure" in
+        G.i (LocalGet (nr 0l)) ^^
+        ContinuationTable.recall env ^^
+        Arr.load_field env 1L ^^ (* get the reject closure *)
+        set_closure ^^
+        get_closure ^^
+        Closure.prepare_closure_call env ^^
+        (* Synthesize value of type `Text`, the error message
+           (The error code is fetched via a prim)
+        *)
+        IC.error_value env ^^
+
+        get_closure ^^
+        Closure.call_closure env 1 0 ^^
+
+        callback_cleanup env
+      );
+
+    (* result is a function that accepts a list of closure getters, from which
+       the first and second must be the reply and reject continuations. *)
+    fun closure_getters ->
+      let set_cb_index, get_cb_index = new_local env "cb_index" in
+      Arr.lit env Tagged.T closure_getters ^^
+      ContinuationTable.remember env ^^
+      set_cb_index ^^
+
+      (* return arguments for the ic.call *)
+      compile_unboxed_const (Wasm.I64_convert.extend_i32_u (E.add_fun_ptr env (E.built_in env reply_name))) ^^
+      get_cb_index ^^
+      compile_unboxed_const (Wasm.I64_convert.extend_i32_u (E.add_fun_ptr env (E.built_in env reject_name))) ^^
+      get_cb_index
+
+  let closures_to_reply_reject_callbacks env ts =
+    closures_to_reply_reject_callbacks_aux env (Some ts)
+  let closures_to_raw_reply_reject_callbacks env  =
+    closures_to_reply_reject_callbacks_aux env None
+
+  let ignoring_callback env =
+    (* for one-way calls, we use an invalid table entry as the callback. this
+       way, the callback, when it comes back, will (safely) trap, even if the
+       module has completely changed in between. This way, one-way calls do not
+       get in the way of safe instantaneous upgrades *)
+    compile_unboxed_const 0xFFFF_FFFFL (* IC does not support -1 in 64-bit, thus use zero-extended 32-bit -1 *)
+
+  let cleanup_callback env =
+    let name = "@cleanup_callback" in
+    Func.define_built_in env name ["env", I64Type] [] (fun env ->
+        G.i (LocalGet (nr 0l)) ^^
+        ContinuationTable.recall env ^^
+        Arr.load_field env 2L ^^ (* get the cleanup closure *)
+        let set_closure, get_closure = new_local env "closure" in
+        set_closure ^^ get_closure ^^
+        Closure.prepare_closure_call env ^^
+        get_closure ^^
+        Closure.call_closure env 0 0);
+    compile_unboxed_const (Wasm.I64_convert.extend_i32_u (E.add_fun_ptr env (E.built_in env name)))
+
+  let ic_call_threaded env purpose get_meth_pair push_continuations
+    add_data add_cycles =
+    match E.mode env with
+    | Flags.ICMode
+    | Flags.RefMode ->
+      let message = Printf.sprintf "could not perform %s" purpose in
+      let (set_cb_index, get_cb_index) = new_local env "cb_index" in
+      (* The callee *)
+      get_meth_pair ^^ Arr.load_field env 0L ^^ Blob.as_ptr_len env ^^
+      (* The method name *)
+      get_meth_pair ^^ Arr.load_field env 1L ^^ Blob.as_ptr_len env ^^
+      (* The reply and reject callback *)
+      push_continuations ^^
+      set_cb_index ^^ get_cb_index ^^
+      (* initiate call *)
+      IC.system_call env "call_new" ^^
+      cleanup_callback env ^^ 
+      get_cb_index ^^
+      IC.system_call env "call_on_cleanup" ^^
+      (* the data *)
+      add_data get_cb_index ^^
+      IC.system_call env "call_data_append" ^^
+      (* the cycles *)
+      add_cycles ^^
+      (* done! *)
+      IC.system_call env "call_perform" ^^
+      G.i (Convert (Wasm_exts.Values.I64 I64Op.ExtendUI32)) ^^
+      IC.set_call_perform_status env ^^
+      Blob.lit env Tagged.T message ^^
+      IC.set_call_perform_message env ^^
+      IC.get_call_perform_status env ^^
+      compile_unboxed_const 0L ^^
+      compile_comparison I64Op.Ne ^^
+      (* save error code, cleanup on error *)
+      E.if0
+      begin (* send failed *)
+        if !Flags.trap_on_call_error then
+          E.trap_with env message
+        else
+        (* Recall (don't leak) continuations *)
+        get_cb_index ^^
+        ContinuationTable.recall env ^^
+        G.i Drop
+      end
+      begin (* send succeeded *)
+        G.nop
+      end
+    | _ ->
+      E.trap_with env (Printf.sprintf "cannot perform %s when running locally" purpose)
+
+  let ic_call env ts1 ts2 get_meth_pair get_arg get_k get_r get_c =
+    ic_call_threaded
+      env
+      "remote call"
+      get_meth_pair
+      (closures_to_reply_reject_callbacks env ts2 [get_k; get_r; get_c])
+      (fun _ -> get_arg ^^ Serialization.serialize env ts1)
+
+  let ic_call_raw env get_meth_pair get_arg get_k get_r get_c =
+    ic_call_threaded
+      env
+      "raw call"
+      get_meth_pair
+      (closures_to_raw_reply_reject_callbacks env [get_k; get_r; get_c])
+      (fun _ -> get_arg ^^ Blob.as_ptr_len env)
+
+  let ic_self_call env ts get_meth_pair get_future get_k get_r get_c =
+    ic_call_threaded
+      env
+      "self call"
+      get_meth_pair
+      (* Storing the tuple away, future_array_index = 3, keep in sync with rts/continuation_table.rs *)
+      (closures_to_reply_reject_callbacks env ts [get_k; get_r; get_c; get_future])
+      (fun get_cb_index ->
+        get_cb_index ^^
+        TaggedSmallWord.msb_adjust Type.Nat32 ^^
+        Serialization.serialize env Type.[Prim Nat32])
+
+  let ic_call_one_shot env ts get_meth_pair get_arg add_cycles =
+    match E.mode env with
+    | Flags.ICMode
+    | Flags.RefMode ->
+      (* The callee *)
+      get_meth_pair ^^ Arr.load_field env 0L ^^ Blob.as_ptr_len env ^^
+      (* The method name *)
+      get_meth_pair ^^ Arr.load_field env 1L ^^ Blob.as_ptr_len env ^^
+      (* The reply callback *)
+      ignoring_callback env ^^
+      compile_unboxed_const 0L ^^
+      (* The reject callback *)
+      ignoring_callback env ^^
+      compile_unboxed_const 0L ^^
+      IC.system_call env "call_new" ^^
+      (* the data *)
+      get_arg ^^ Serialization.serialize env ts ^^
+      IC.system_call env "call_data_append" ^^
+      (* the cycles *)
+      add_cycles ^^
+      IC.system_call env "call_perform" ^^
+      G.i (Convert (Wasm_exts.Values.I64 I64Op.ExtendUI32)) ^^
+      (* This is a one-shot function: just remember error code *)
+      (if !Flags.trap_on_call_error then
+         (* legacy: discard status, proceed as if all well *)
+         G.i Drop ^^
+         compile_unboxed_zero ^^
+         IC.set_call_perform_status env ^^
+         Blob.lit env Tagged.T "" ^^
+         IC.set_call_perform_message env
+       else
+         IC.set_call_perform_status env ^^
+         Blob.lit env Tagged.T "could not perform oneway" ^^
+         IC.set_call_perform_message env)
+
+    | _ -> assert false
+
+  let equate_msgref env =
+    let (set_meth_pair1, get_meth_pair1) = new_local env "meth_pair1" in
+    let (set_meth_pair2, get_meth_pair2) = new_local env "meth_pair2" in
+    set_meth_pair2 ^^ set_meth_pair1 ^^
+    get_meth_pair1 ^^ Arr.load_field env 0L ^^
+    get_meth_pair2 ^^ Arr.load_field env 0L ^^
+    Blob.compare env (Some Operator.EqOp) ^^
+    E.if1 I64Type
+    begin
+      get_meth_pair1 ^^ Arr.load_field env 1L ^^
+      get_meth_pair2 ^^ Arr.load_field env 1L ^^
+      Blob.compare env (Some Operator.EqOp)
+    end
+    begin
+      Bool.lit false
+    end
+
+  let export_async_method env =
+    let name = IC.async_method_name in
+    begin match E.mode env with
+    | Flags.ICMode | Flags.RefMode ->
+      Func.define_built_in env name [] [] (fun env ->
+        let (set_closure, get_closure) = new_local env "closure" in
+
+        message_start env (Type.Shared Type.Write) ^^
+
+        (* Check that we are calling this *)
+        IC.assert_caller_self env ^^
+
+        (* Deserialize and look up continuation argument *)
+        Serialization.deserialize env Type.[Prim Nat32] ^^
+        TaggedSmallWord.lsb_adjust Type.Nat32 ^^
+        ContinuationTable.peek_future env ^^
+        set_closure ^^
+        get_closure ^^
+        Closure.prepare_closure_call env ^^
+        get_closure ^^
+        Closure.call_closure env 0 0 ^^
+        message_cleanup env (Type.Shared Type.Write)
+      );
+
+      let fi = E.built_in env name in
+      E.add_export env (nr {
+        name = Lib.Utf8.decode ("canister_update " ^ name);
+        edesc = nr (FuncExport (nr fi))
+      })
+    | _ -> ()
+    end
+
+  let export_gc_trigger_method env =
+    let name = IC.gc_trigger_method_name in
+    begin match E.mode env with
+    | Flags.ICMode | Flags.RefMode ->
+      Func.define_built_in env name [] [] (fun env ->
+        (* THe GC trigger is also blocked during incremental (de)stabilization. 
+           This is checked in `Lifecycle.trans` being called by `message_start` *)
+        message_start env (Type.Shared Type.Write) ^^
+        (* Check that we are called from this or a controller, w/o allocation *)
+        IC.assert_caller_self_or_controller env ^^
+        (* To avoid more failing allocation, don't deserialize args nor serialize reply,
+           i.e. don't even try to do this:
+        Serialization.deserialize env [] ^^
+        Tuple.compile_unit env ^^
+        Serialization.serialize env [] ^^
+        *)
+        (* Instead, just ignore the argument and
+           send a *statically* allocated, nullary reply *)
+        IC.static_nullary_reply env ^^
+        (* Finally, act like
+        message_cleanup env (Type.Shared Type.Write)
+           but *force* collection *)
+        GC.record_mutator_instructions env ^^
+        E.collect_garbage env true ^^
+        GC.record_collector_instructions env ^^
+        Lifecycle.trans env Lifecycle.Idle
+      );
+
+      let fi = E.built_in env name in
+      E.add_export env (nr {
+        name = Lib.Utf8.decode ("canister_update " ^ name);
+        edesc = nr (FuncExport (nr fi))
+      })
+    | _ -> ()
+    end
+
+  let export_stabilization_limits env =
+    let moc_stabilization_instruction_limit_fi = 
+      E.add_fun env "moc_stabilization_instruction_limit" (
+        Func.of_body env [] [I64Type] (fun env ->
+          (* To use the instruction budget well during upgrade, 
+             offer the entire upgrade instruction limit for the destabilization, 
+             since the stabilization can also be run before the upgrade. *)
+          Lifecycle.during_explicit_upgrade env ^^
+          E.if1 I64Type
+            (compile_unboxed_const (Int64.of_int Flags.(!stabilization_instruction_limit.update_call)))
+            (compile_unboxed_const (Int64.of_int Flags.(!stabilization_instruction_limit.upgrade)))
+        )
+      ) in
+    E.add_export env (nr {
+      name = Lib.Utf8.decode "moc_stabilization_instruction_limit";
+      edesc = nr (FuncExport (nr moc_stabilization_instruction_limit_fi))
+    });
+    let moc_stable_memory_access_limit_fi = 
+      E.add_fun env "moc_stable_memory_access_limit" (
+        Func.of_body env [] [I64Type] (fun env ->
+          Lifecycle.during_explicit_upgrade env ^^
+          E.if1 I64Type
+            (compile_unboxed_const (Int64.of_int Flags.(!stable_memory_access_limit.update_call)))
+            (compile_unboxed_const (Int64.of_int Flags.(!stable_memory_access_limit.upgrade)))
+        )
+      ) in
+    E.add_export env (nr {
+      name = Lib.Utf8.decode "moc_stable_memory_access_limit";
+      edesc = nr (FuncExport (nr moc_stable_memory_access_limit_fi))
+    }) 
+
+end (* FuncDec *)
+
+module IncrementalGraphStabilization = struct
+  let register_globals env =
+    E.add_global64 env "__stabilization_completed" Mutable 0L;
+    E.add_global64 env "__destabilized_actor" Mutable 0L
+
+  let is_stabilization_completed env =
+    G.i (GlobalGet (nr (E.get_global env "__stabilization_completed")))
+  let set_stabilization_completed env =
+    G.i (GlobalSet (nr (E.get_global env "__stabilization_completed")))
+
+  let get_destabilized_actor env =
+    G.i (GlobalGet (nr (E.get_global env "__destabilized_actor")))
+  let set_destabilized_actor env =
+    G.i (GlobalSet (nr (E.get_global env "__destabilized_actor")))
+
+  let async_stabilization_method_name = "@motoko_async_stabilization"
+
+  let async_stabilization_reply_callback_name = "@async_stabilization_reply_callback"
+  let async_stabilization_reply_callback env =
+    Int64.of_int32 (E.add_fun_ptr env (E.built_in env async_stabilization_reply_callback_name))
+
+  let async_stabilization_reject_callback_name = "@async_stabilization_reject_callback"
+  let async_stabilization_reject_callback env =
+    Int64.of_int32 (E.add_fun_ptr env (E.built_in env async_stabilization_reject_callback_name))
+
+  let call_async_stabilization env =
+    IC.get_self_reference env ^^ Blob.as_ptr_len env ^^
+    Blob.lit_ptr_len env Tagged.T async_stabilization_method_name ^^
+    compile_unboxed_const (async_stabilization_reply_callback env) ^^ compile_unboxed_const 0L ^^
+    compile_unboxed_const (async_stabilization_reject_callback env) ^^ compile_unboxed_const 0L ^^
+    IC.system_call env "call_new" ^^
+    IC.system_call env "call_perform" ^^
+    G.i (Convert (Wasm_exts.Values.I64 I64Op.ExtendUI32)) ^^
+    E.then_trap_with env "Async stabilization increment call failed" 
+
+  let define_async_stabilization_reply_callback env =
+    Func.define_built_in env async_stabilization_reply_callback_name ["env", I64Type] [] (fun env ->
+      is_stabilization_completed env ^^
+      E.if0
+        begin
+          (* Sucessful completion of the async stabilization sequence. *)
+          IC.static_nullary_reply env
+          (* Skip garbage collection. *)
+          (* Stay in lifecycle state `InStabilization`. *)
+        end
+        begin
+          (* Trigger next async stabilization increment. *)
+          call_async_stabilization env
+        end)
+  
+  let define_async_stabilization_reject_callback env =
+    Func.define_built_in env async_stabilization_reject_callback_name ["env", I64Type] [] (fun env ->
+      IC.error_message env ^^
+      Blob.as_ptr_len env ^^
+      IC.system_call env "msg_reject")
+
+  let export_async_stabilization_method env =
+    let name = async_stabilization_method_name in
+    begin match E.mode env with
+    | Flags.ICMode | Flags.RefMode ->
+      Func.define_built_in env name [] [] (fun env ->
+        IC.assert_caller_self_or_controller env ^^
+        (* All messages are blocked except this method and the upgrade. *)
+        Lifecycle.trans env Lifecycle.InStabilization ^^
+        (* Skip argument deserialization to avoid allocations. *)
+        GraphCopyStabilization.graph_stabilization_increment env ^^
+        set_stabilization_completed env ^^
+        IC.static_nullary_reply env
+        (* Skip garbage collection. *)
+        (* Stay in lifecycle state `InStabilization`. *)
+      );
+
+      let fi = E.built_in env name in
+      E.add_export env (nr {
+        name = Lib.Utf8.decode ("canister_update " ^ name);
+        edesc = nr (FuncExport (nr fi))
+      })
+    | _ -> ()
+    end
+
+  let start_graph_stabilization env actor_type =
+    GraphCopyStabilization.is_graph_stabilization_started env ^^
+    (E.if0
+      G.nop
+      begin
+        (* Extra safety measure stopping the GC during incremental stabilization, 
+           although it should not be called in lifecycle state `InStabilization`. *)
+        E.call_import env "rts" "stop_gc_before_stabilization" ^^
+        IC.get_actor_to_persist env ^^
+        GraphCopyStabilization.start_graph_stabilization env actor_type
+      end)
+
+  let export_stabilize_before_upgrade_method env actor_type =
+    let name = "__motoko_stabilize_before_upgrade" in
+    begin match E.mode env with
+    | Flags.ICMode | Flags.RefMode ->
+      Func.define_built_in env name [] [] (fun env ->
+        IC.assert_caller_self_or_controller env ^^
+        (* All messages are blocked except this method and the upgrade. *)
+        Lifecycle.trans env Lifecycle.InStabilization ^^
+        start_graph_stabilization env actor_type ^^
+        call_async_stabilization env
+        (* Stay in lifecycle state `InStabilization`. *)
+      );
+
+      let fi = E.built_in env name in
+      E.add_export env (nr {
+        name = Lib.Utf8.decode ("canister_update " ^ name);
+        edesc = nr (FuncExport (nr fi))
+      })
+    | _ -> ()
+    end
+
+  let complete_stabilization_on_upgrade env actor_type =
+    start_graph_stabilization env actor_type ^^
+    G.loop0
+    begin
+      GraphCopyStabilization.graph_stabilization_increment env ^^
+      E.if0 
+        G.nop
+        (G.i (Br (nr 1l)))
+    end
+  
+  let async_destabilization_method_name = "@motoko_async_destabilization"
+
+  let async_destabilization_reply_callback_name = "@async_destabilization_reply_callback"
+  let async_destabilization_reply_callback env =
+    Int64.of_int32 (E.add_fun_ptr env (E.built_in env async_destabilization_reply_callback_name))
+
+  let async_destabilization_reject_callback_name = "@async_destabilization_reject_callback"
+  let async_destabilization_reject_callback env =
+    Int64.of_int32 (E.add_fun_ptr env (E.built_in env async_destabilization_reject_callback_name))
+
+  let call_async_destabilization env =
+    IC.get_self_reference env ^^ Blob.as_ptr_len env ^^
+    Blob.lit_ptr_len env Tagged.T async_destabilization_method_name ^^
+    compile_unboxed_const (async_destabilization_reply_callback env) ^^ compile_unboxed_const 0L ^^
+    compile_unboxed_const (async_destabilization_reject_callback env) ^^ compile_unboxed_const 0L ^^
+    IC.system_call env "call_new" ^^
+    IC.system_call env "call_perform" ^^
+    G.i (Convert (Wasm_exts.Values.I64 I64Op.ExtendUI32)) ^^
+    E.then_trap_with env "Async destabilization increment call failed"
+
+  let complete_graph_destabilization env = 
+    IC.initialize_main_actor env ^^
+    (* Allow other messages and allow garbage collection. *)
+    E.call_import env "rts" "start_gc_after_destabilization" ^^
+    Lifecycle.trans env Lifecycle.Idle
+
+  let define_async_destabilization_reply_callback env =
+    Func.define_built_in env async_destabilization_reply_callback_name ["env", I64Type] [] (fun env ->
+      get_destabilized_actor env ^^
+      compile_test I64Op.Eqz ^^
+      E.if0
+        begin
+          (* Trigger next async destabilization increment. *)
+          call_async_destabilization env
+        end
+        begin
+          (* Send static reply of sucessful async destabilization sequence. *)
+          IC.static_nullary_reply env
+          (* Stay in lifecycle state `InDestabilization`. *)
+        end)
+  
+  let define_async_destabilization_reject_callback env =
+    Func.define_built_in env async_destabilization_reject_callback_name ["env", I64Type] [] (fun env ->
+      IC.error_message env ^^
+      Blob.as_ptr_len env ^^
+      IC.system_call env "msg_reject")
+
+  let destabilization_increment env actor_type =
+    get_destabilized_actor env ^^
+    compile_test I64Op.Eqz ^^
+    (E.if0
+      begin
+        GraphCopyStabilization.graph_destabilization_increment env ^^
+        (E.if0
+          begin
+            GraphCopyStabilization.get_graph_destabilized_actor env actor_type ^^
+            set_destabilized_actor env ^^
+            complete_graph_destabilization env
+          end
+          G.nop)
+      end
+      G.nop)
+
+  let export_async_destabilization_method env actor_type =
+    let name = async_destabilization_method_name in
+    begin match E.mode env with
+    | Flags.ICMode | Flags.RefMode ->
+      Func.define_built_in env name [] [] (fun env ->
+        IC.assert_caller_self_or_controller env ^^
+        (* Stay in lifecycle state `InDestabilization` if not yet completed. *)
+        destabilization_increment env actor_type ^^
+        IC.static_nullary_reply env
+      );
+
+      let fi = E.built_in env name in
+      E.add_export env (nr {
+        name = Lib.Utf8.decode ("canister_update " ^ name);
+        edesc = nr (FuncExport (nr fi))
+      })
+    | _ -> ()
+    end
+
+  let partial_destabilization_on_upgrade env actor_type =
+    (* TODO: Verify that the post_upgrade hook cannot be directly called by the IC *)
+    (* Garbage collection is disabled in `start_graph_destabilization` until destabilization has completed. *)
+    GraphCopyStabilization.start_graph_destabilization env actor_type ^^
+    get_destabilized_actor env ^^
+    compile_test I64Op.Eqz ^^
+    E.if0
+      begin
+        destabilization_increment env actor_type ^^
+        get_destabilized_actor env ^^
+        (E.if0
+          G.nop
+          begin
+            (* All messages remain blocked except this method. *)
+            Lifecycle.trans env Lifecycle.InDestabilization
+            (* Since the canister initialization cannot perform async calls, the destabilization 
+               needs to be explicitly continued by calling `__motoko_destabilize_after_upgrade`. *)
+          end)
+      end
+      G.nop
+
+  let export_destabilize_after_upgrade_method env =
+    let name = "__motoko_destabilize_after_upgrade" in
+    begin match E.mode env with
+    | Flags.ICMode | Flags.RefMode ->
+      Func.define_built_in env name [] [] (fun env ->
+        (* All messages are blocked except this method. *)
+        IC.assert_caller_self_or_controller env ^^
+        (* Skip argument deserialization to avoid allocations. *)
+        call_async_destabilization env
+        (* Stay in lifecycle state `InDestabilization`. *)
+      );
+
+      let fi = E.built_in env name in
+      E.add_export env (nr {
+        name = Lib.Utf8.decode ("canister_update " ^ name);
+        edesc = nr (FuncExport (nr fi))
+      })
+    | _ -> ()
+    end
+  
+  let load env =
+    get_destabilized_actor env ^^
+    compile_test I64Op.Eqz ^^
+    E.then_trap_with env "Destabilization is not yet completed: Call __motoko_destabilize_after_upgrade" ^^
+    get_destabilized_actor env
+    (* Upgrade costs are already record in RTS for graph-copy-based (de-)stabilization. *)
+
+  let define_methods env actor_type =
+    define_async_stabilization_reply_callback env;
+    define_async_stabilization_reject_callback env;
+    export_async_stabilization_method env;
+    export_stabilize_before_upgrade_method env actor_type;
+    define_async_destabilization_reply_callback env;
+    define_async_destabilization_reject_callback env;
+    export_async_destabilization_method env actor_type;
+    export_destabilize_after_upgrade_method env;
+
+end (* IncrementalGraphStabilization *)
+
+module Persistence = struct
+  (* Stable memory version at the time of the canister upgrade or initialization.
+     This version can be different to `StableMem.get_version` because the upgrade logic
+     may update the stable memory version, e.g. lift to enhanced orthogonal persistence. *)
+  let register_globals env =
+    E.add_global64 env "__persistence_version" Mutable 0L;
+    E.add_global64 env "__init_message_payload" Mutable 0L
+
+  let get_persistence_version env =
+    G.i (GlobalGet (nr (E.get_global env "__persistence_version")))
+  let set_persistence_version env =
+    G.i (GlobalSet (nr (E.get_global env "__persistence_version")))
+
+  (* No GC running during destabilization while this global blob reference is used. *)
+  let get_init_message_payload env =
+    G.i (GlobalGet (nr (E.get_global env "__init_message_payload")))
+  let set_init_message_payload env =
+    G.i (GlobalSet (nr (E.get_global env "__init_message_payload")))
+
+  let use_candid_destabilization env =
+    get_persistence_version env ^^
+    compile_unboxed_const StableMem.legacy_version_regions ^^ (* Version 0 to 2 *)
+    compile_comparison I64Op.LeU
+
+  let use_graph_destabilization env =
+    get_persistence_version env ^^
+    compile_eq_const StableMem.version_graph_copy_no_regions ^^
+    get_persistence_version env ^^
+    compile_eq_const StableMem.version_graph_copy_regions ^^
+    G.i (Binary (Wasm_exts.Values.I64 I64Op.Or))
+
+  let use_enhanced_orthogonal_persistence env =
+    get_persistence_version env ^^
+    compile_eq_const StableMem.version_stable_heap_no_regions ^^
+    get_persistence_version env ^^
+    compile_eq_const StableMem.version_stable_heap_regions ^^
+    G.i (Binary (Wasm_exts.Values.I64 I64Op.Or))
+
+  let initialize env actor_type =
+    E.call_import env "rts" "read_persistence_version" ^^
+    set_persistence_version env ^^
+    use_graph_destabilization env ^^
+    E.if0
+      begin
+        IncrementalGraphStabilization.partial_destabilization_on_upgrade env actor_type
+        (* Potentially stay in lifecycle state `InDestabilization` *)
+      end
+      begin
+        IC.initialize_main_actor env ^^
+        Lifecycle.trans env Lifecycle.Idle
+      end
+
+  let load env actor_type =
+    use_enhanced_orthogonal_persistence env ^^
+    (E.if1 I64Type
+      (EnhancedOrthogonalPersistence.load env actor_type)
+      begin
+        use_graph_destabilization env ^^
+        E.if1 I64Type
+          begin
+            IncrementalGraphStabilization.load env ^^
+            NewStableMemory.upgrade_version_from_graph_stabilization env ^^
+            EnhancedOrthogonalPersistence.initialize env actor_type 
+          end
+          begin
+            use_candid_destabilization env ^^
+            E.else_trap_with env "Unsupported persistence version. Use newer Motoko compiler version." ^^
+            OldStabilization.load env actor_type (NewStableMemory.upgrade_version_from_candid env) ^^
+            EnhancedOrthogonalPersistence.initialize env actor_type
+          end
+      end) ^^
+    StableMem.region_init env
+
+  let save env actor_type =
+    GraphCopyStabilization.is_graph_stabilization_started env ^^
+    E.if0
+      (IncrementalGraphStabilization.complete_stabilization_on_upgrade env actor_type)
+      (EnhancedOrthogonalPersistence.save env actor_type)
+end (* Persistence *)
+
+module PatCode = struct
+  (* Pattern failure code on demand.
+
+  Patterns in general can fail, so we want a block around them with a
+  jump-label for the fail case. But many patterns cannot fail, in particular
+  function arguments that are simple variables. In these cases, we do not want
+  to create the block and the (unused) jump label. So we first generate the
+  code, either as plain code (CannotFail) or as code with hole for code to run
+  in case of failure (CanFail).
+  *)
+
+  type patternCode =
+    | CannotFail of G.t
+    | CanFail of (G.t -> G.t)
+
+  let definiteFail = CanFail (fun fail -> fail)
+
+  let (^^^) : patternCode -> patternCode -> patternCode = function
+    | CannotFail is1 ->
+      begin function
+      | CannotFail is2 -> CannotFail (is1 ^^ is2)
+      | CanFail is2 -> CanFail (fun k -> is1 ^^ is2 k)
+      end
+    | CanFail is1 ->
+      begin function
+      | CannotFail is2 -> CanFail (fun k ->  is1 k ^^ is2)
+      | CanFail is2 -> CanFail (fun k -> is1 k ^^ is2 k)
+      end
+
+  let with_fail (fail_code : G.t) : patternCode -> G.t = function
+    | CannotFail is -> is
+    | CanFail is -> is fail_code
+
+  let orElse : patternCode -> patternCode -> patternCode = function
+    | CannotFail is1 -> fun _ -> CannotFail is1
+    | CanFail is1 -> function
+      | CanFail is2 -> CanFail (fun fail_code ->
+          let inner_fail = G.new_depth_label () in
+          let inner_fail_code = Bool.lit false ^^ G.branch_to_ inner_fail in
+          G.labeled_block1 I64Type inner_fail (is1 inner_fail_code ^^ Bool.lit true) ^^
+          E.if0 G.nop (is2 fail_code)
+        )
+      | CannotFail is2 -> CannotFail (
+          let inner_fail = G.new_depth_label () in
+          let inner_fail_code = Bool.lit false ^^ G.branch_to_ inner_fail in
+          G.labeled_block1 I64Type inner_fail (is1 inner_fail_code ^^ Bool.lit true) ^^
+          E.if0 G.nop is2
+        )
+
+  let orElses : patternCode list -> patternCode -> patternCode =
+    List.fold_right orElse
+
+  let patternFailTrap env = E.trap_with env "pattern failed"
+
+  let orPatternFailure env pcode =
+    with_fail (patternFailTrap env) pcode
+
+  let orsPatternFailure env pcodes =
+    orPatternFailure env (orElses pcodes definiteFail)
+
+  let with_region at = function
+    | CannotFail is -> CannotFail (G.with_region at is)
+    | CanFail is -> CanFail (fun k -> G.with_region at (is k))
+
+end (* PatCode *)
+open PatCode
+
+(* All the code above is independent of the IR *)
+open Ir
+
+module AllocHow = struct
+  (*
+  When compiling a (recursive) block, we need to do a dependency analysis, to
+  find out how the things are allocated. The options are:
+  - const:  completely known, constant, not stored anywhere (think static function)
+            (no need to mention in a closure)
+  - local:  only needed locally, stored in a Wasm local, immutable
+            (can be copied into a closure by value)
+  - local mutable: only needed locally, stored in a Wasm local, mutable
+            (cannot be copied into a closure)
+  - heap allocated: stored on the dynamic heap, address in Wasm local
+            (can be copied into a closure by reference)
+  - static heap: stored on the static heap, address known statically
+            (no need to mention in a closure)
+
+  The goal is to avoid dynamic allocation where possible (and use locals), and
+  to avoid turning function references into closures.
+
+  The rules are:
+  - functions are const, unless they capture something that is not a const
+    function or a static heap allocation.
+    in particular, top-level functions are always const
+  - everything that is captured on the top-level needs to be statically
+    heap-allocated
+  - everything that is captured before it is defined, or is captured and mutable
+    needs to be dynamically heap-allocated
+  - the rest can be local
+  *)
+
+  module M = Freevars.M
+  module S = Freevars.S
+
+  (*
+  We represent this as a lattice as follows:
+  *)
+  type how = Const | LocalImmut of SR.t | LocalMut of SR.t | StoreHeap | StoreStatic
+  type allocHow = how M.t
+
+  let disjoint_union : allocHow -> allocHow -> allocHow =
+    M.union (fun v _ _ -> fatal "AllocHow.disjoint_union: %s" v)
+
+  let join : allocHow -> allocHow -> allocHow =
+    M.union (fun _ x y -> Some (match x, y with
+      | StoreStatic, StoreHeap | StoreHeap, StoreStatic
+      ->  fatal "AllocHow.join: cannot join StoreStatic and StoreHeap"
+
+      | _, StoreHeap     | StoreHeap,      _ -> StoreHeap
+      | _, StoreStatic   | StoreStatic,    _ -> StoreStatic
+      | _, LocalMut sr   | LocalMut sr,    _ -> LocalMut sr
+      | _, LocalImmut sr | LocalImmut sr,  _ -> LocalImmut sr
+
+      | Const, Const -> Const
+    ))
+  let joins = List.fold_left join M.empty
+
+  let map_of_set = Freevars.map_of_set
+  let set_of_map = Freevars.set_of_map
+
+  (* Various filters used in the set operations below *)
+  let is_local_mut _ = function
+    | LocalMut _ -> true
+    | _ -> false
+
+  let is_local _ = function
+    | LocalImmut _ | LocalMut _ -> true
+    | _ -> false
+
+  let how_captured lvl how seen captured =
+    (* What to do so that we can capture something?
+       * For local blocks, put on the dynamic heap:
+         - mutable things
+         - not yet defined things
+       * For top-level blocks, put on the static heap:
+         - everything that is non-static (i.e. still in locals)
+    *)
+    match lvl with
+    | VarEnv.NotTopLvl ->
+      map_of_set StoreHeap (S.union
+        (S.inter (set_of_map (M.filter is_local_mut how)) captured)
+        (S.inter (set_of_map (M.filter is_local how)) (S.diff captured seen))
+      )
+    | VarEnv.TopLvl ->
+      map_of_set StoreStatic
+        (S.inter (set_of_map (M.filter is_local how)) captured)
+
+  (* A bit like StackRep.of_type, but only for those types and stackreps that
+     we support in local variables *)
+  let stackrep_of_type t =
+    let open Type in
+    match normalize t with
+    | Prim ((Nat64 | Int64 | Nat32 | Int32 | Nat16 | Int16 | Nat8 | Int8 | Char) as pty) ->
+       SR.UnboxedWord64 pty
+    | Prim Float -> SR.UnboxedFloat64
+    | _ -> SR.Vanilla
+
+  let dec lvl how_outer (seen, how0) dec =
+    let how_all = disjoint_union how_outer how0 in
+
+    let (f,d) = Freevars.dec dec in
+    let captured = S.inter (set_of_map how0) (Freevars.captured_vars f) in
+
+    (* Which allocation is required for the things defined here? *)
+    let how1 = match dec.it with
+      (* Mutable variables are, well, mutable *)
+      | VarD _ ->
+        M.map (fun t -> LocalMut (stackrep_of_type t)) d
+
+      (* Constant expressions (trusting static_vals.ml) *)
+      | LetD (_, e) when e.note.Note.const ->
+        M.map (fun _ -> (Const : how)) d
+
+      (* References to mutboxes *)
+      | RefD _ ->
+        M.map (fun _ -> StoreHeap) d
+
+      (* Everything else needs at least a local *)
+      | _ ->
+        M.map (fun t -> LocalImmut (stackrep_of_type t)) d in
+
+    (* Which allocation does this require for its captured things? *)
+    let how2 = how_captured lvl how_all seen captured in
+
+    let how = joins [how0; how1; how2] in
+    let seen' = S.union seen (set_of_map d)
+    in (seen', how)
+
+  (* find the allocHow for the variables currently in scope *)
+  (* we assume things are mutable, as we do not know better here *)
+  let how_of_ae ae : allocHow =
+    M.map (fun (l, _) -> match l with
+    | VarEnv.Const _        -> (Const : how)
+    | VarEnv.Static _       -> StoreStatic
+    | VarEnv.HeapInd _      -> StoreHeap
+    | VarEnv.Local (sr, _)  -> LocalMut sr (* conservatively assume mutable *)
+    | VarEnv.PublicMethod _ -> LocalMut SR.Vanilla
+    ) ae.VarEnv.vars
+
+  let decs (ae : VarEnv.t) decs captured_in_body : allocHow =
+    let lvl = ae.VarEnv.lvl in
+    let how_outer = how_of_ae ae in
+    let defined_here = snd (Freevars.decs decs) in (* TODO: implement gather_decs more directly *)
+    let how_outer = Freevars.diff how_outer defined_here in (* shadowing *)
+    let how0 = M.map (fun _t -> (Const : how)) defined_here in
+    let captured = S.inter (set_of_map defined_here) captured_in_body in
+    let rec go how =
+      let seen, how1 = List.fold_left (dec lvl how_outer) (S.empty, how) decs in
+      assert (S.equal seen (set_of_map defined_here));
+      let how2 = how_captured lvl how1 seen captured in
+      let how' = join how1 how2 in
+      if M.equal (=) how how' then how' else go how' in
+    go how0
+
+  (* Functions to extend the environment (and possibly allocate memory)
+     based on how we want to store them. *)
+  let add_local env ae how name typ : VarEnv.t * G.t =
+    match M.find name how with
+    | (Const : how) -> (ae, G.nop)
+    | LocalImmut sr | LocalMut sr ->
+      let ae1, _ = VarEnv.add_direct_local env ae name sr typ in
+      (ae1, G.nop)
+    | StoreHeap ->
+      let ae1, i = VarEnv.add_local_with_heap_ind env ae name typ in
+      let alloc_code = MutBox.alloc env ^^ G.i (LocalSet (nr i)) in
+      (ae1, alloc_code)
+    | StoreStatic ->
+      let index = MutBox.add_global_mutbox env in
+      let ae1 = VarEnv.add_static_variable ae name index typ in
+      (ae1, G.nop)
+
+  let add_local_for_alias env ae how name typ : VarEnv.t * G.t =
+    match M.find name how with
+    | StoreHeap ->
+      let ae1, _ = VarEnv.add_local_with_heap_ind env ae name typ in
+      ae1, G.nop
+    | _ -> assert false
+
+end (* AllocHow *)
+
+(* The actual compiler code that looks at the AST *)
+
+(* wraps a bigint in range [0…2^64-1] into range [-2^63…2^63-1] *)
+let nat64_to_int64 n =
+  let open Big_int in
+  if ge_big_int n (power_int_positive_int 2 63)
+  then sub_big_int n (power_int_positive_int 2 64)
+  else n
+
+let const_lit_of_lit : Ir.lit -> Const.lit = function
+  | BoolLit b     -> Const.Bool b
+  | IntLit n
+  | NatLit n      -> Const.BigInt (Numerics.Nat.to_big_int n)
+  | Int8Lit n     -> Const.Vanilla (TaggedSmallWord.vanilla_lit Type.Int8 (Numerics.Int_8.to_int n))
+  | Nat8Lit n     -> Const.Vanilla (TaggedSmallWord.vanilla_lit Type.Nat8 (Numerics.Nat8.to_int n))
+  | Int16Lit n    -> Const.Vanilla (TaggedSmallWord.vanilla_lit Type.Int16 (Numerics.Int_16.to_int n))
+  | Nat16Lit n    -> Const.Vanilla (TaggedSmallWord.vanilla_lit Type.Nat16 (Numerics.Nat16.to_int n))
+  | Int32Lit n    -> Const.Vanilla (TaggedSmallWord.vanilla_lit Type.Int32 (Numerics.Int_32.to_int n))
+  | Nat32Lit n    -> Const.Vanilla (TaggedSmallWord.vanilla_lit Type.Nat32 (Numerics.Nat32.to_int n))
+  | Int64Lit n    -> Const.Word64 (Type.Int64, (Big_int.int64_of_big_int (Numerics.Int_64.to_big_int n)))
+  | Nat64Lit n    -> Const.Word64 (Type.Nat64, (Big_int.int64_of_big_int (nat64_to_int64 (Numerics.Nat64.to_big_int n))))
+  | CharLit c     -> Const.Vanilla (TaggedSmallWord.vanilla_lit Type.Char c)
+  | NullLit       -> Const.Null
+  | TextLit t     -> Const.Text t
+  | BlobLit t     -> Const.Blob t
+  | FloatLit f    -> Const.Float64 f
+
+let const_of_lit lit =
+  Const.Lit (const_lit_of_lit lit)
+
+let compile_lit lit =
+  SR.Const (const_of_lit lit), G.nop
+
+let compile_lit_as env sr_out lit =
+  let sr_in, code = compile_lit lit in
+  code ^^ StackRep.adjust env sr_in sr_out
+
+(* helper, traps with message *)
+let then_arithmetic_overflow env =
+  E.then_trap_with env "arithmetic overflow"
+
+(* The first returned StackRep is for the arguments (expected), the second for the results (produced) *)
+let compile_unop env t op =
+  let open Operator in
+  match op, t with
+  | _, Type.Non ->
+    SR.Vanilla, SR.Unreachable, G.i Unreachable
+  | NegOp, Type.(Prim Int) ->
+    SR.Vanilla, SR.Vanilla,
+    BigNum.compile_neg env
+  | NegOp, Type.(Prim ((Int8 | Int16 | Int32 | Int64) as p)) ->
+    StackRep.of_type t, StackRep.of_type t,
+    Func.share_code1 Func.Never env (prim_fun_name p "neg_trap") ("n", I64Type) [I64Type] (fun env get_n ->
+      get_n ^^
+      compile_eq_const 0x8000_0000_0000_0000L ^^
+      then_arithmetic_overflow env ^^
+      compile_unboxed_zero ^^
+      get_n ^^
+      G.i (Binary (Wasm_exts.Values.I64 I64Op.Sub))
+    )
+  | NegOp, Type.(Prim Float) ->
+    SR.UnboxedFloat64, SR.UnboxedFloat64,
+    G.i (Unary (Wasm_exts.Values.F64 F64Op.Neg))
+  | NotOp, Type.(Prim (Nat64|Int64 as p)) ->
+     SR.UnboxedWord64 p, SR.UnboxedWord64 p,
+     compile_xor_const (-1L)
+  | NotOp, Type.(Prim (Nat8|Nat16|Nat32|Int8|Int16|Int32 as ty)) ->
+     StackRep.of_type t, StackRep.of_type t,
+     compile_unboxed_const (TaggedSmallWord.mask_of_type ty) ^^
+     G.i (Binary (Wasm_exts.Values.I64 I64Op.Xor))
+  | _ ->
+    todo "compile_unop"
+      (Wasm.Sexpr.Node ("BinOp", [ Arrange_ops.unop op ]))
+      (SR.Vanilla, SR.Unreachable, E.trap_with env "TODO: compile_unop")
+
+(* Logarithmic helpers for deciding whether we can carry out operations in constant bitwidth *)
+
+(* helper, traps with message *)
+let else_arithmetic_overflow env =
+  E.else_trap_with env "arithmetic overflow"
+
+(* helpers to decide if Int64 arithmetic can be carried out on the fast path *)
+let additiveInt64_shortcut fast env get_a get_b slow =
+  get_a ^^ get_a ^^ compile_shl_const 1L ^^ G.i (Binary (Wasm_exts.Values.I64 I64Op.Xor)) ^^ compile_shrU_const 63L ^^
+  get_b ^^ get_b ^^ compile_shl_const 1L ^^ G.i (Binary (Wasm_exts.Values.I64 I64Op.Xor)) ^^ compile_shrU_const 63L ^^
+  G.i (Binary (Wasm_exts.Values.I64 I64Op.Or)) ^^
+  compile_test I64Op.Eqz ^^
+  E.if1 I64Type
+    (get_a ^^ get_b ^^ fast)
+    slow
+
+let mulInt64_shortcut fast env get_a get_b slow =
+  get_a ^^ get_a ^^ compile_shl_const 1L ^^ G.i (Binary (Wasm_exts.Values.I64 I64Op.Xor)) ^^ G.i (Unary (Wasm_exts.Values.I64 I64Op.Clz)) ^^
+  get_b ^^ get_b ^^ compile_shl_const 1L ^^ G.i (Binary (Wasm_exts.Values.I64 I64Op.Xor)) ^^ G.i (Unary (Wasm_exts.Values.I64 I64Op.Clz)) ^^
+  G.i (Binary (Wasm_exts.Values.I64 I64Op.Add)) ^^
+  compile_unboxed_const 65L ^^ compile_comparison I64Op.GeU ^^
+  E.if1 I64Type
+    (get_a ^^ get_b ^^ fast)
+    slow
+
+let powInt64_shortcut fast env get_a get_b slow =
+  get_b ^^ compile_test I64Op.Eqz ^^
+  E.if1 I64Type
+    (compile_unboxed_const 1L) (* ^0 *)
+    begin (* ^(1+n) *)
+      get_a ^^ compile_unboxed_const (-1L) ^^ compile_comparison I64Op.Eq ^^
+      E.if1 I64Type
+        begin (* -1 ** (1+exp) == if even (1+exp) then 1 else -1 *)
+          get_b ^^ compile_unboxed_const 1L ^^
+          G.i (Binary (Wasm_exts.Values.I64 I64Op.And)) ^^ compile_test I64Op.Eqz ^^
+          E.if1 I64Type
+            (compile_unboxed_const 1L)
+            get_a
+        end
+        begin
+          get_a ^^ compile_shrS_const 1L ^^
+          compile_test I64Op.Eqz ^^
+          E.if1 I64Type
+            get_a (* {0,1}^(1+n) *)
+            begin
+              get_b ^^ compile_unboxed_const 64L ^^
+              compile_comparison I64Op.GeU ^^ then_arithmetic_overflow env ^^
+              get_a ^^ get_a ^^ compile_shl_const 1L ^^ G.i (Binary (Wasm_exts.Values.I64 I64Op.Xor)) ^^
+              G.i (Unary (Wasm_exts.Values.I64 I64Op.Clz)) ^^ compile_sub_const 63L ^^
+              get_b ^^ G.i (Binary (Wasm_exts.Values.I64 I64Op.Mul)) ^^
+              compile_unboxed_const (-63L) ^^ compile_comparison I64Op.GeS ^^
+              E.if1 I64Type
+                (get_a ^^ get_b ^^ fast)
+                slow
+            end
+        end
+    end
+
+
+(* kernel for Int64 arithmetic, invokes estimator for fast path *)
+let compile_Int64_kernel env name op shortcut =
+  Func.share_code2 Func.Always env (prim_fun_name Type.Int64 name)
+    (("a", I64Type), ("b", I64Type)) [I64Type]
+    BigNum.(fun env get_a get_b ->
+    shortcut
+      env
+      get_a
+      get_b
+      begin
+        let (set_res, get_res) = new_local env "res" in
+        get_a ^^ from_signed_word64 env ^^
+        get_b ^^ from_signed_word64 env ^^
+        op env ^^
+        set_res ^^ get_res ^^
+        fits_signed_bits env 64 ^^
+        else_arithmetic_overflow env ^^
+        get_res ^^ truncate_to_word64 env
+      end)
+
+
+(* helpers to decide if Nat64 arithmetic can be carried out on the fast path *)
+let additiveNat64_shortcut fast env get_a get_b slow =
+  get_a ^^ compile_shrU_const 62L ^^
+  get_b ^^ compile_shrU_const 62L ^^
+  G.i (Binary (Wasm_exts.Values.I64 I64Op.Or)) ^^
+  compile_test I64Op.Eqz ^^
+  E.if1 I64Type
+    (get_a ^^ get_b ^^ fast)
+    slow
+
+let mulNat64_shortcut fast env get_a get_b slow =
+  get_a ^^ G.i (Unary (Wasm_exts.Values.I64 I64Op.Clz)) ^^
+  get_b ^^ G.i (Unary (Wasm_exts.Values.I64 I64Op.Clz)) ^^
+  G.i (Binary (Wasm_exts.Values.I64 I64Op.Add)) ^^
+  compile_unboxed_const 64L ^^ compile_comparison I64Op.GeU ^^
+  E.if1 I64Type
+    (get_a ^^ get_b ^^ fast)
+    slow
+
+let powNat64_shortcut fast env get_a get_b slow =
+  get_b ^^ compile_test I64Op.Eqz ^^
+  E.if1 I64Type
+    (compile_unboxed_const 1L) (* ^0 *)
+    begin (* ^(1+n) *)
+      get_a ^^ compile_shrU_const 1L ^^
+      compile_test I64Op.Eqz ^^
+      E.if1 I64Type
+        get_a (* {0,1}^(1+n) *)
+        begin
+          get_b ^^ compile_unboxed_const 64L ^^ compile_comparison I64Op.GeU ^^ then_arithmetic_overflow env ^^
+          get_a ^^ G.i (Unary (Wasm_exts.Values.I64 I64Op.Clz)) ^^ compile_sub_const 64L ^^
+          get_b ^^ G.i (Binary (Wasm_exts.Values.I64 I64Op.Mul)) ^^ compile_unboxed_const (-64L) ^^ compile_comparison I64Op.GeS ^^
+          E.if1 I64Type
+            (get_a ^^ get_b ^^ fast)
+            slow
+        end
+    end
+
+
+(* kernel for Nat64 arithmetic, invokes estimator for fast path *)
+let compile_Nat64_kernel env name op shortcut =
+  Func.share_code2 Func.Always env (prim_fun_name Type.Nat64 name)
+    (("a", I64Type), ("b", I64Type)) [I64Type]
+    BigNum.(fun env get_a get_b ->
+    shortcut
+      env
+      get_a
+      get_b
+      begin
+        let (set_res, get_res) = new_local env "res" in
+        get_a ^^ from_word64 env ^^
+        get_b ^^ from_word64 env ^^
+        op env ^^
+        set_res ^^ get_res ^^
+        fits_unsigned_bits env 64 ^^
+        else_arithmetic_overflow env ^^
+        get_res ^^ truncate_to_word64 env
+      end)
+
+
+(* Compiling Int/Nat32 ops by conversion to/from i64. *)
+
+(* helper, expects i64 on stack *)
+let enforce_32_unsigned_bits env =
+  compile_bitand_const 0xFFFF_FFFF_0000_0000L ^^
+  compile_test I64Op.Eqz ^^
+  else_arithmetic_overflow env
+
+(* helper, expects two identical i64s on stack *)
+let enforce_32_signed_bits env =
+  compile_shl_const 1L ^^
+  G.i (Binary (Wasm_exts.Values.I64 I64Op.Xor)) ^^
+  enforce_32_unsigned_bits env
+
+(* TODO: Combine this with `compile_smallInt_kernel`, to support `Int32`, `Int16`, and `Int8` at once. *)
+let compile_Int32_kernel env name op =
+     Func.share_code2 Func.Always env (prim_fun_name Type.Int32 name)
+       (("a", I64Type), ("b", I64Type)) [I64Type]
+       (fun env get_a get_b ->
+         let (set_res, get_res) = new_local env "res" in
+         get_a ^^ compile_shrS_const 32L ^^
+         get_b ^^ compile_shrS_const 32L ^^
+         G.i (Binary (Wasm_exts.Values.I64 op)) ^^
+         set_res ^^ get_res ^^ get_res ^^
+         enforce_32_signed_bits env ^^
+         get_res ^^ compile_shl_const 32L)
+
+(* TODO: Combine this with `compile_smallInt_kernel`, to support `Nat32`, `Nat16`, and `Nat8` at once. *)
+let compile_Nat32_kernel env name op =
+     Func.share_code2 Func.Always env (prim_fun_name Type.Nat32 name)
+       (("a", I64Type), ("b", I64Type)) [I64Type]
+       (fun env get_a get_b ->
+         let (set_res, get_res) = new_local env "res" in
+         get_a ^^ compile_shrU_const 32L ^^
+         get_b ^^ compile_shrU_const 32L ^^
+         G.i (Binary (Wasm_exts.Values.I64 op)) ^^
+         set_res ^^ get_res ^^
+         enforce_32_unsigned_bits env ^^
+         get_res ^^ compile_shl_const 32L)
+
+(* Customisable kernels for 8/16bit arithmetic via 64 bits. *)
+(* TODO: Include the support for 32bit which is now also compact on 64-bit. 
+   Eventually, `compile_Int32_kernel` and `compile_Nat32_kernel` can be removed. *)
+
+(* helper, expects i64 on stack *)
+let enforce_unsigned_bits env n =
+  compile_bitand_const Int64.(shift_left minus_one n) ^^
+  compile_test I64Op.Eqz ^^
+  else_arithmetic_overflow env
+
+let enforce_16_unsigned_bits env = enforce_unsigned_bits env 16
+
+(* helper, expects two identical i64s on stack *)
+let enforce_signed_bits env n =
+  compile_shl_const 1L ^^ 
+  G.i (Binary (Wasm_exts.Values.I64 I64Op.Xor)) ^^
+  enforce_unsigned_bits env n
+
+let enforce_16_signed_bits env = enforce_signed_bits env 16
+
+let compile_smallInt_kernel' env ty name op =
+  Func.share_code2 Func.Always env (prim_fun_name ty name)
+    (("a", I64Type), ("b", I64Type)) [I64Type]
+    (fun env get_a get_b ->
+      let (set_res, get_res) = new_local env "res" in
+      get_a ^^ compile_shrS_const 48L ^^
+      get_b ^^ compile_shrS_const 48L ^^
+      op ^^
+      set_res ^^ get_res ^^ get_res ^^
+      enforce_16_signed_bits env ^^
+      get_res ^^ compile_shl_const 48L)
+
+let compile_smallInt_kernel env ty name op =
+  compile_smallInt_kernel' env ty name (G.i (Binary (Wasm_exts.Values.I64 op)))
+
+let compile_smallNat_kernel' env ty name op =
+  Func.share_code2 Func.Always env (prim_fun_name ty name)
+    (("a", I64Type), ("b", I64Type)) [I64Type]
+    (fun env get_a get_b ->
+      let (set_res, get_res) = new_local env "res" in
+      get_a ^^ compile_shrU_const 48L ^^
+      get_b ^^ compile_shrU_const 48L ^^
+      op ^^
+      set_res ^^ get_res ^^
+      enforce_16_unsigned_bits env ^^
+      get_res ^^ compile_shl_const 48L)
+
+let compile_smallNat_kernel env ty name op =
+  compile_smallNat_kernel' env ty name (G.i (Binary (Wasm_exts.Values.I64 op)))
+
+(* The first returned StackRep is for the arguments (expected), the second for the results (produced) *)
+let compile_binop env t op : SR.t * SR.t * G.t =
+  if t = Type.Non then SR.Vanilla, SR.Unreachable, G.i Unreachable else
+  StackRep.of_type t,
+  StackRep.of_type t,
+  Operator.(match t, op with
+  | Type.(Prim (Nat | Int)),                  AddOp -> BigNum.compile_add env
+  | Type.(Prim (Nat64|Int64)),                WAddOp -> G.i (Binary (Wasm_exts.Values.I64 I64Op.Add))
+  | Type.(Prim Int64),                        AddOp ->
+    compile_Int64_kernel env "add" BigNum.compile_add
+      (additiveInt64_shortcut (G.i (Binary (Wasm_exts.Values.I64 I64Op.Add))))
+  | Type.(Prim Nat64),                        AddOp ->
+    compile_Nat64_kernel env "add" BigNum.compile_add
+      (additiveNat64_shortcut (G.i (Binary (Wasm_exts.Values.I64 I64Op.Add))))
+  | Type.(Prim Nat),                          SubOp -> BigNum.compile_unsigned_sub env
+  | Type.(Prim Int),                          SubOp -> BigNum.compile_signed_sub env
+  | Type.(Prim (Nat | Int)),                  MulOp -> BigNum.compile_mul env
+  | Type.(Prim (Nat64|Int64)),                WMulOp -> G.i (Binary (Wasm_exts.Values.I64 I64Op.Mul))
+  | Type.(Prim Int64),                        MulOp ->
+    compile_Int64_kernel env "mul" BigNum.compile_mul
+      (mulInt64_shortcut (G.i (Binary (Wasm_exts.Values.I64 I64Op.Mul))))
+  | Type.(Prim Nat64),                        MulOp ->
+    compile_Nat64_kernel env "mul" BigNum.compile_mul
+      (mulNat64_shortcut (G.i (Binary (Wasm_exts.Values.I64 I64Op.Mul))))
+  | Type.(Prim Nat64),                        DivOp -> G.i (Binary (Wasm_exts.Values.I64 I64Op.DivU))
+  | Type.(Prim Nat64) ,                       ModOp -> G.i (Binary (Wasm_exts.Values.I64 I64Op.RemU))
+  | Type.(Prim Int64),                        DivOp -> G.i (Binary (Wasm_exts.Values.I64 I64Op.DivS))
+  | Type.(Prim Int64) ,                       ModOp -> G.i (Binary (Wasm_exts.Values.I64 I64Op.RemS))
+  | Type.(Prim Nat),                          DivOp -> BigNum.compile_unsigned_div env
+  | Type.(Prim Nat),                          ModOp -> BigNum.compile_unsigned_rem env
+  | Type.(Prim (Nat64|Int64)),                WSubOp -> G.i (Binary (Wasm_exts.Values.I64 I64Op.Sub))
+  | Type.(Prim Int64),                        SubOp ->
+    compile_Int64_kernel env "sub" BigNum.compile_signed_sub
+      (additiveInt64_shortcut (G.i (Binary (Wasm_exts.Values.I64 I64Op.Sub))))
+  | Type.(Prim Nat64),                        SubOp ->
+    compile_Nat64_kernel env "sub" BigNum.compile_unsigned_sub
+      (fun env get_a get_b ->
+        additiveNat64_shortcut
+          (compile_comparison I64Op.GeU ^^
+           else_arithmetic_overflow env ^^
+           get_a ^^ get_b ^^ G.i (Binary (Wasm_exts.Values.I64 I64Op.Sub)))
+          env get_a get_b)
+  | Type.(Prim Int),                          DivOp -> BigNum.compile_signed_div env
+  | Type.(Prim Int),                          ModOp -> BigNum.compile_signed_mod env
+
+  | Type.Prim Type.(Nat8|Nat16|Nat32|Int8|Int16|Int32),
+                                              WAddOp -> G.i (Binary (Wasm_exts.Values.I64 I64Op.Add))
+  | Type.(Prim Int32),                        AddOp -> compile_Int32_kernel env "add" I64Op.Add
+  | Type.Prim Type.(Int8 | Int16 as ty),      AddOp -> compile_smallInt_kernel env ty "add" I64Op.Add
+  | Type.(Prim Nat32),                        AddOp -> compile_Nat32_kernel env "add" I64Op.Add
+  | Type.Prim Type.(Nat8 | Nat16 as ty),      AddOp -> compile_smallNat_kernel env ty "add" I64Op.Add
+  | Type.(Prim Float),                        AddOp -> G.i (Binary (Wasm_exts.Values.F64 F64Op.Add))
+  | Type.Prim Type.(Nat8|Nat16|Nat32|Int8|Int16|Int32),
+                                              WSubOp -> G.i (Binary (Wasm_exts.Values.I64 I64Op.Sub))
+  | Type.(Prim Int32),                        SubOp -> compile_Int32_kernel env "sub" I64Op.Sub
+  | Type.(Prim (Int8|Int16 as ty)),           SubOp -> compile_smallInt_kernel env ty "sub" I64Op.Sub
+  | Type.(Prim Nat32),                        SubOp -> compile_Nat32_kernel env "sub" I64Op.Sub
+  | Type.(Prim (Nat8|Nat16 as ty)),           SubOp -> compile_smallNat_kernel env ty "sub" I64Op.Sub
+  | Type.(Prim Float),                        SubOp -> G.i (Binary (Wasm_exts.Values.F64 F64Op.Sub))
+  | Type.Prim Type.(Nat8|Nat16|Nat32|Int8|Int16|Int32 as ty),
+                                              WMulOp -> TaggedSmallWord.compile_word_mul env ty
+  | Type.(Prim Int32),                        MulOp -> compile_Int32_kernel env "mul" I64Op.Mul
+  | Type.(Prim Int16),                        MulOp -> compile_smallInt_kernel env Type.Int16 "mul" I64Op.Mul
+  | Type.(Prim Int8),                         MulOp -> compile_smallInt_kernel' env Type.Int8 "mul"
+                                                         (compile_shrS_const 8L ^^ G.i (Binary (Wasm_exts.Values.I64 I64Op.Mul)))
+  | Type.(Prim Nat32),                        MulOp -> compile_Nat32_kernel env "mul" I64Op.Mul
+  | Type.(Prim Nat16),                        MulOp -> compile_smallNat_kernel env Type.Nat16 "mul" I64Op.Mul
+  | Type.(Prim Nat8),                         MulOp -> compile_smallNat_kernel' env Type.Nat8 "mul"
+                                                         (compile_shrU_const 8L ^^ G.i (Binary (Wasm_exts.Values.I64 I64Op.Mul)))
+  | Type.(Prim Float),                        MulOp -> G.i (Binary (Wasm_exts.Values.F64 F64Op.Mul))
+  | Type.(Prim (Nat8|Nat16|Nat32 as ty)),     DivOp -> G.i (Binary (Wasm_exts.Values.I64 I64Op.DivU)) ^^
+                                                       TaggedSmallWord.msb_adjust ty
+  | Type.(Prim (Nat8|Nat16|Nat32)),           ModOp -> G.i (Binary (Wasm_exts.Values.I64 I64Op.RemU))
+  | Type.(Prim (Int8|Int16|Int32 as ty)),           DivOp ->
+    Func.share_code2 Func.Always env (prim_fun_name ty "div")
+      (("a", I64Type), ("b", I64Type)) [I64Type]
+      (fun env get_a get_b ->
+        let (set_res, get_res) = new_local env "res" in
+        get_a ^^ get_b ^^ G.i (Binary (Wasm_exts.Values.I64 I64Op.DivS)) ^^
+        TaggedSmallWord.msb_adjust ty ^^ set_res ^^
+        get_a ^^ compile_eq_const 0x8000_0000_0000_0000L ^^
+        E.if_ env [I64Type]
+          begin
+            get_b ^^ TaggedSmallWord.lsb_adjust ty ^^ compile_eq_const (-1L) ^^
+            E.if_ env [I64Type]
+              (G.i Unreachable)
+              get_res
+          end
+          get_res)
+  | Type.(Prim Float),                        DivOp -> G.i (Binary (Wasm_exts.Values.F64 F64Op.Div))
+  | Type.(Prim Float),                        ModOp -> E.call_import env "rts" "fmod" (* musl *)
+  | Type.(Prim (Int8|Int16|Int32)),           ModOp -> G.i (Binary (Wasm_exts.Values.I64 I64Op.RemS))
+  | Type.(Prim (Nat8|Nat16|Nat32 as ty)),     WPowOp -> TaggedSmallWord.compile_nat_power env ty
+  | Type.(Prim (Int8|Int16|Int32 as ty)),     WPowOp -> TaggedSmallWord.compile_int_power env ty
+  | Type.(Prim ((Nat8|Nat16|Nat32) as ty)),         PowOp ->
+    Func.share_code2 Func.Always env (prim_fun_name ty "pow")
+      (("n", I64Type), ("exp", I64Type)) [I64Type]
+      (fun env get_n get_exp ->
+        let (set_res, get_res) = new_local env "res" in
+        let bits = TaggedSmallWord.bits_of_type ty in
+        let set_n = G.setter_for get_n in
+        let set_exp = G.setter_for get_exp in
+        get_n ^^ TaggedSmallWord.lsb_adjust ty ^^ set_n ^^
+        get_exp ^^ TaggedSmallWord.lsb_adjust ty ^^ set_exp ^^
+        get_exp ^^ Bool.from_int64 ^^
+        E.if1 I64Type
+          begin
+            get_n ^^ compile_shrU_const 1L ^^
+            Bool.from_int64 ^^
+            E.if1 I64Type
+              begin
+                let overflow_type = match ty with
+                | Type.Nat32 -> Type.Nat64 
+                | Type.(Nat8 | Nat16) -> Type.Nat32 
+                | _ -> assert false in
+                let overflow_type_bits = TaggedSmallWord.bits_of_type overflow_type in
+                let overflow_boundary = -Int.(sub (mul overflow_type_bits 2) 2) in
+                get_exp ^^ compile_unboxed_const 64L ^^
+                compile_comparison I64Op.GeU ^^ then_arithmetic_overflow env ^^
+                unsigned_dynamics get_n ^^ compile_sub_const (Int64.of_int bits) ^^
+                get_exp ^^ G.i (Binary (Wasm_exts.Values.I64 I64Op.Mul)) ^^
+                compile_unboxed_const (Int64.of_int overflow_boundary) ^^
+                compile_comparison I64Op.LtS ^^ then_arithmetic_overflow env ^^
+                get_n ^^ get_exp ^^
+                TaggedSmallWord.compile_nat_power env Type.Nat64 ^^ set_res ^^
+                get_res ^^ enforce_unsigned_bits env bits ^^
+                get_res ^^ TaggedSmallWord.msb_adjust ty
+              end
+              (get_n ^^ TaggedSmallWord.msb_adjust ty) (* n@{0,1} ** (1+exp) == n *)
+          end
+          (compile_unboxed_one ^^ TaggedSmallWord.msb_adjust ty)) (* x ** 0 == 1 *)
+  | Type.(Prim ((Int8|Int16|Int32) as ty)),         PowOp ->
+    Func.share_code2 Func.Always env (prim_fun_name ty "pow")
+      (("n", I64Type), ("exp", I64Type)) [I64Type]
+      (fun env get_n get_exp ->
+        let (set_res, get_res) = new_local env "res" in
+        let bits = TaggedSmallWord.bits_of_type ty in
+        let set_n = G.setter_for get_n in
+        let set_exp = G.setter_for get_exp in
+        get_n ^^ TaggedSmallWord.lsb_adjust ty ^^ set_n ^^
+        get_exp ^^ TaggedSmallWord.lsb_adjust ty ^^ set_exp ^^
+        get_exp ^^ compile_unboxed_zero ^^
+        compile_comparison I64Op.LtS ^^ E.then_trap_with env "negative power" ^^
+        get_exp ^^ Bool.from_int64 ^^
+        E.if1 I64Type
+          begin
+            get_n ^^ compile_unboxed_one ^^ compile_comparison I64Op.LeS ^^
+            get_n ^^ compile_unboxed_const (-1L) ^^ compile_comparison I64Op.GeS ^^
+            G.i (Binary (Wasm_exts.Values.I64 I64Op.And)) ^^
+            E.if1 I64Type
+              begin
+                get_n ^^ compile_unboxed_zero ^^ compile_comparison I64Op.LtS ^^
+                E.if1 I64Type
+                  begin
+                    (* -1 ** (1+exp) == if even (1+exp) then 1 else -1 *)
+                    get_exp ^^ compile_unboxed_one ^^ G.i (Binary (Wasm_exts.Values.I64 I64Op.And)) ^^
+                    E.if1 I64Type
+                      (get_n ^^ TaggedSmallWord.msb_adjust ty)
+                      (compile_unboxed_const
+                        Int64.(shift_left one (to_int (TaggedSmallWord.shift_of_type ty))))
+                  end
+                  (get_n ^^ TaggedSmallWord.msb_adjust ty) (* n@{0,1} ** (1+exp) == n *)
+              end
+              begin
+                let overflow_type = match ty with
+                | Type.Int32 -> Type.Int64 
+                | Type.(Int8 | Int16) -> Type.Int32 
+                | _ -> assert false in
+                let overflow_type_bits = TaggedSmallWord.bits_of_type overflow_type in
+                let overflow_boundary = -Int.(sub (mul overflow_type_bits 2) 2) in
+                get_exp ^^ compile_unboxed_const 64L ^^
+                compile_comparison I64Op.GeU ^^ then_arithmetic_overflow env ^^
+                signed_dynamics get_n ^^ compile_sub_const (Int64.of_int (Int.sub bits 1)) ^^
+                get_exp ^^
+                G.i (Binary (Wasm_exts.Values.I64 I64Op.Mul)) ^^
+                compile_unboxed_const (Int64.of_int overflow_boundary) ^^
+                compile_comparison I64Op.LtS ^^ then_arithmetic_overflow env ^^
+                get_n ^^ get_exp ^^
+                TaggedSmallWord.compile_nat_power env Type.Nat64 ^^ set_res ^^ 
+                get_res ^^ get_res ^^ enforce_signed_bits env bits ^^
+                get_res ^^ TaggedSmallWord.msb_adjust ty
+              end
+          end
+          (compile_unboxed_one ^^ TaggedSmallWord.msb_adjust ty)) (* x ** 0 == 1 *)
+  | Type.(Prim Int),                          PowOp ->
+    let pow = BigNum.compile_unsigned_pow env in
+    let (set_n, get_n) = new_local env "n" in
+    let (set_exp, get_exp) = new_local env "exp" in
+    set_exp ^^ set_n ^^
+    get_exp ^^ BigNum.compile_is_negative env ^^
+    E.then_trap_with env "negative power" ^^
+    get_n ^^ get_exp ^^ pow
+  | Type.(Prim Nat64),                        WPowOp -> Word64.compile_unsigned_pow env
+  | Type.(Prim Int64),                        WPowOp -> Word64.compile_signed_wpow env
+  | Type.(Prim Nat64),                        PowOp ->
+    compile_Nat64_kernel env "pow"
+      BigNum.compile_unsigned_pow
+      (powNat64_shortcut (Word64.compile_unsigned_pow env))
+  | Type.(Prim Int64),                        PowOp ->
+    let (set_exp, get_exp) = new_local env "exp" in
+    set_exp ^^ get_exp ^^
+    compile_unboxed_const 0L ^^
+    compile_comparison I64Op.LtS ^^
+    E.then_trap_with env "negative power" ^^
+    get_exp ^^
+    compile_Int64_kernel
+      env "pow" BigNum.compile_unsigned_pow
+      (powInt64_shortcut (Word64.compile_unsigned_pow env))
+  | Type.(Prim Nat),                          PowOp -> BigNum.compile_unsigned_pow env
+  | Type.(Prim Float),                        PowOp -> E.call_import env "rts" "pow" (* musl *)
+  | Type.(Prim (Nat8|Nat16|Nat32|Nat64|Int8|Int16|Int32|Int64)),
+                                              AndOp -> G.i (Binary (Wasm_exts.Values.I64 I64Op.And))
+  | Type.(Prim (Nat8|Nat16|Nat32|Nat64|Int8|Int16|Int32|Int64)),
+                                              OrOp  -> G.i (Binary (Wasm_exts.Values.I64 I64Op.Or))
+  | Type.(Prim (Nat8|Nat16|Nat32|Nat64|Int8|Int16|Int32|Int64)),
+                                              XorOp -> G.i (Binary (Wasm_exts.Values.I64 I64Op.Xor))
+  | Type.(Prim (Nat64|Int64)),                ShLOp -> G.i (Binary (Wasm_exts.Values.I64 I64Op.Shl))
+  | Type.(Prim (Nat8|Nat16|Nat32|Int8|Int16|Int32 as ty)),
+                                              ShLOp -> TaggedSmallWord.(
+     lsb_adjust ty ^^ clamp_shift_amount ty ^^
+     G.i (Binary (Wasm_exts.Values.I64 I64Op.Shl)))
+  | Type.(Prim Nat64),                        ShROp -> G.i (Binary (Wasm_exts.Values.I64 I64Op.ShrU))
+  | Type.(Prim (Nat8|Nat16|Nat32 as ty)),     ShROp -> TaggedSmallWord.(
+     lsb_adjust ty ^^ clamp_shift_amount ty ^^
+     G.i (Binary (Wasm_exts.Values.I64 I64Op.ShrU)) ^^
+     sanitize_word_result ty)
+  | Type.(Prim Int64),                        ShROp -> G.i (Binary (Wasm_exts.Values.I64 I64Op.ShrS))
+  | Type.(Prim (Int8|Int16|Int32 as ty)),     ShROp -> TaggedSmallWord.(
+     lsb_adjust ty ^^ clamp_shift_amount ty ^^
+     G.i (Binary (Wasm_exts.Values.I64 I64Op.ShrS)) ^^
+     sanitize_word_result ty)
+  | Type.(Prim (Nat64|Int64)),                RotLOp -> G.i (Binary (Wasm_exts.Values.I64 I64Op.Rotl))
+  | Type.(Prim (Nat8|Nat16|Nat32|Int8|Int16|Int32 as ty)),
+                                              RotLOp -> TaggedSmallWord.rotl env ty
+  | Type.(Prim (Nat64|Int64)),                RotROp -> G.i (Binary (Wasm_exts.Values.I64 I64Op.Rotr))
+  | Type.(Prim (Nat8|Nat16|Nat32|Int8|Int16|Int32 as ty)),
+                                              RotROp -> TaggedSmallWord.rotr env ty
+  | Type.(Prim Text), CatOp -> Text.concat env
+  | Type.Non, _ -> G.i Unreachable
+  | _ -> todo_trap env "compile_binop" (Wasm.Sexpr.Node ("BinOp", [ Arrange_ops.binop op; Arrange_type.typ t]))
+  )
+
+let compile_eq env =
+  let open Type in
+  function
+  | Prim Text -> Text.compare env Operator.EqOp
+  | Prim (Blob|Principal) | Obj (Actor, _) -> Blob.compare env (Some Operator.EqOp)
+  | Func (Shared _, _, _, _, _) -> FuncDec.equate_msgref env
+  | Prim (Nat | Int) -> BigNum.compile_eq env
+  | Prim (Bool | Int8 | Nat8 | Int16 | Nat16 | Int32 | Nat32 | Int64 | Nat64 | Char) ->
+    compile_comparison I64Op.Eq
+  | Non -> G.i Unreachable
+  | Prim Float -> compile_comparison_f64 F64Op.Eq
+  | t -> todo_trap env "compile_eq" (Arrange_type.typ t)
+
+let get_relops = Operator.(function
+  | GeOp -> Ge, I64Op.GeU, I64Op.GeS
+  | GtOp -> Gt, I64Op.GtU, I64Op.GtS
+  | LeOp -> Le, I64Op.LeU, I64Op.LeS
+  | LtOp -> Lt, I64Op.LtU, I64Op.LtS
+  | NeqOp -> assert false
+  | _ -> failwith "uncovered relop")
+
+let compile_comparison_op env t op =
+  let bigintop, u64op, s64op = get_relops op in
+  let open Type in
+  match t with
+    | Nat | Int -> BigNum.compile_relop env bigintop
+    | Nat8 | Nat16 | Nat32 | Nat64 | Char -> compile_comparison u64op
+    | Int8 | Int16 | Int32 | Int64 -> compile_comparison s64op
+    | _ -> todo_trap env "compile_comparison" (Arrange_type.prim t)
+
+let compile_relop env t op =
+  if t = Type.Non then SR.Vanilla, G.i Unreachable else
+  StackRep.of_type t,
+  let open Operator in
+  match t, op with
+  | Type.(Prim Text), _ -> Text.compare env op
+  | Type.(Prim (Blob|Principal)), _ -> Blob.compare env (Some op)
+  | _, EqOp -> compile_eq env t
+  | Type.(Prim (Nat | Nat8 | Nat16 | Nat32 | Nat64 | Int | Int8 | Int16 | Int32 | Int64 | Char as t1)), op1 ->
+    compile_comparison_op env t1 op1
+  | Type.(Prim Float), GtOp -> compile_comparison_f64 F64Op.Gt
+  | Type.(Prim Float), GeOp -> compile_comparison_f64 F64Op.Ge
+  | Type.(Prim Float), LeOp -> compile_comparison_f64 F64Op.Le
+  | Type.(Prim Float), LtOp -> compile_comparison_f64 F64Op.Lt
+  | _ -> todo_trap env "compile_relop" (Arrange_ops.relop op)
+
+let compile_load_field env typ name =
+  Object.load_idx env typ name
+
+
+(* compile_lexp is used for expressions on the left of an assignment operator.
+   Produces
+   * preparation code, to run first
+   * an expected stack rep
+   * code that expects the value to be written in that stackrep, and consumes it
+*)
+let rec compile_lexp (env : E.t) ae lexp : G.t * SR.t * G.t =
+  (fun (code, sr, fill_code) -> G.(with_region lexp.at code, sr, with_region lexp.at fill_code)) @@
+  match lexp.it with
+  | VarLE var -> Var.set_val env ae var
+  | IdxLE (e1, e2) when potential_pointer (Arr.element_type env e1.note.Note.typ) ->
+    compile_array_index env ae e1 e2 ^^
+    compile_add_const ptr_unskew,
+    SR.Vanilla,
+    Tagged.write_with_barrier env
+  | IdxLE (e1, e2) ->
+    compile_array_index env ae e1 e2,
+    SR.Vanilla,
+    store_ptr
+  | DotLE (e, n) when potential_pointer (Object.field_type env e.note.Note.typ n) ->
+    compile_exp_vanilla env ae e ^^
+    (* Only real objects have mutable fields, no need to branch on the tag *)
+    Object.idx env e.note.Note.typ n ^^
+    compile_add_const ptr_unskew,
+    SR.Vanilla,
+    Tagged.write_with_barrier env
+  | DotLE (e, n) ->
+    compile_exp_vanilla env ae e ^^
+    (* Only real objects have mutable fields, no need to branch on the tag *)
+    Object.idx env e.note.Note.typ n,
+    SR.Vanilla,
+    store_ptr
+
+(* Common code for a[e] as lexp and as exp.
+Traps or pushes the pointer to the element on the stack
+*)
+and compile_array_index env ae e1 e2 =
+    compile_exp_vanilla env ae e1 ^^ (* offset to array *)
+    compile_exp_vanilla env ae e2 ^^ (* idx *)
+    Arr.idx_bigint env
+
+and compile_prim_invocation (env : E.t) ae p es at =
+  (* for more concise code when all arguments and result use the same sr *)
+  let const_sr sr inst = sr, G.concat_map (compile_exp_as env ae sr) es ^^ inst in
+
+  begin match p, es with
+  (* Calls *)
+  | CallPrim _, [e1; e2] ->
+    let sort, control, _, arg_tys, ret_tys = Type.(as_func (promote e1.note.Note.typ)) in
+    let n_args = List.length arg_tys in
+    let return_arity = match control with
+      | Type.Returns -> List.length ret_tys
+      | Type.Replies -> 0
+      | Type.Promises -> assert false in
+
+    let fun_sr, code1 = compile_exp env ae e1 in
+
+    (* we duplicate this pattern match to emulate pattern guards *)
+    let call_as_prim = match fun_sr, sort with
+      | SR.Const Const.Fun (_, mk_fi, Const.PrimWrapper prim), _ ->
+         begin match n_args, e2.it with
+         | 0, _ -> true
+         | 1, _ -> true
+         | n, PrimE (TupPrim, es) when List.length es = n -> true
+         | _, _ -> false
+         end
+      | _ -> false in
+
+    begin match fun_sr, sort with
+      | SR.Const Const.Fun (_, mk_fi, Const.PrimWrapper prim), _ when call_as_prim ->
+         assert (sort = Type.Local);
+         (* Handle argument tuples *)
+         begin match n_args, e2.it with
+         | 0, _ ->
+           let sr, code2 = compile_prim_invocation env ae prim [] at in
+           sr,
+           code1 ^^
+           compile_exp_as env ae (StackRep.of_arity 0) e2 ^^
+           code2
+         | 1, _ ->
+           compile_prim_invocation env ae prim [e2] at
+         | n, PrimE (TupPrim, es) ->
+           assert (List.length es = n);
+           compile_prim_invocation env ae prim es at
+         | _, _ ->
+           (* ugly case; let's just call this as a function for now *)
+           raise (Invalid_argument "call_as_prim was true?")
+         end
+      | SR.Const Const.Fun (_, mk_fi, _), _ ->
+         assert (sort = Type.Local);
+         StackRep.of_arity return_arity,
+
+         code1 ^^
+         compile_unboxed_zero ^^ (* A dummy closure *)
+         compile_exp_as env ae (StackRep.of_arity n_args) e2 ^^ (* the args *)
+         G.i (Call (nr (mk_fi()))) ^^
+         FakeMultiVal.load env (Lib.List.make return_arity I64Type)
+      | _, Type.Local ->
+         let (set_clos, get_clos) = new_local env "clos" in
+
+         StackRep.of_arity return_arity,
+         code1 ^^ StackRep.adjust env fun_sr SR.Vanilla ^^
+         set_clos ^^
+         get_clos ^^
+         Closure.prepare_closure_call env ^^
+         compile_exp_as env ae (StackRep.of_arity n_args) e2 ^^
+         get_clos ^^
+         Closure.call_closure env n_args return_arity
+      | _, Type.Shared _ ->
+         (* Non-one-shot functions have been rewritten in async.ml *)
+         assert (control = Type.Returns);
+
+         let (set_meth_pair, get_meth_pair) = new_local env "meth_pair" in
+         let (set_arg, get_arg) = new_local env "arg" in
+         let _, _, _, ts, _ = Type.as_func e1.note.Note.typ in
+         let add_cycles = Internals.add_cycles env ae in
+
+         StackRep.of_arity return_arity,
+         code1 ^^ StackRep.adjust env fun_sr SR.Vanilla ^^
+         set_meth_pair ^^
+         compile_exp_vanilla env ae e2 ^^ set_arg ^^
+
+         FuncDec.ic_call_one_shot env ts get_meth_pair get_arg add_cycles
+    end
+
+  (* Operators *)
+  | UnPrim (_, Operator.PosOp), [e1] -> compile_exp env ae e1
+  | UnPrim (t, op), [e1] ->
+    let sr_in, sr_out, code = compile_unop env t op in
+    sr_out,
+    compile_exp_as env ae sr_in e1 ^^
+    code
+  | BinPrim (t, op), [e1;e2] ->
+    let sr_in, sr_out, code = compile_binop env t op in
+    sr_out,
+    compile_exp_as env ae sr_in e1 ^^
+    compile_exp_as env ae sr_in e2 ^^
+    code
+  (* special case: recognize negation *)
+  | RelPrim (Type.(Prim Bool), Operator.EqOp), [e1; {it = LitE (BoolLit false); _}] ->
+    SR.bool,
+    compile_exp_as_test env ae e1 ^^
+    compile_test I64Op.Eqz
+  | RelPrim (t, op), [e1;e2] ->
+    let sr, code = compile_relop env t op in
+    SR.bool,
+    compile_exp_as env ae sr e1 ^^
+    compile_exp_as env ae sr e2 ^^
+    code
+
+  (* Tuples *)
+  | TupPrim, es ->
+    SR.UnboxedTuple (List.length es),
+    G.concat_map (compile_exp_vanilla env ae) es
+  | ProjPrim n, [e1] ->
+    SR.Vanilla,
+    compile_exp_vanilla env ae e1 ^^ (* offset to tuple (an array) *)
+    Tuple.load_n env (Int64.of_int n)
+
+  | OptPrim, [e] ->
+    SR.Vanilla,
+    Opt.inject env (compile_exp_vanilla env ae e)
+  | TagPrim l, [e] ->
+    SR.Vanilla,
+    Variant.inject env l (compile_exp_vanilla env ae e)
+
+  | DotPrim name, [e] ->
+    let sr, code1 = compile_exp env ae e in
+    begin match sr with
+    | SR.Const Const.Obj fs ->
+      let c = List.assoc name fs in
+      SR.Const c, code1
+    | _ ->
+      SR.Vanilla,
+      code1 ^^ StackRep.adjust env sr SR.Vanilla ^^
+      Object.load_idx env e.note.Note.typ name
+    end
+  | ActorDotPrim name, [e] ->
+    SR.Vanilla,
+    compile_exp_vanilla env ae e ^^
+    IC.actor_public_field env name
+
+  | ArrayPrim (m, t), es ->
+    SR.Vanilla,
+    Arr.lit env Tagged.(if m = Ir.Var then M else I) (List.map (compile_exp_vanilla env ae) es)
+  | IdxPrim, [e1; e2] ->
+    SR.Vanilla,
+    compile_array_index env ae e1 e2 ^^
+    load_ptr
+  (* NB: all these operations assume a valid array offset fits in a compact bignum *)
+  | NextArrayOffset, [e] ->
+    let one_untagged = Int64.shift_left 1L (64 - BitTagged.ubits_of Type.Int) in
+    SR.Vanilla,
+    compile_exp_vanilla env ae e ^^ (* previous byte offset to array *)
+    compile_add_const one_untagged (* preserving the tag in low bits *)
+  | EqArrayOffset, [e1; e2] ->
+    SR.bool,
+    compile_exp_vanilla env ae e1 ^^
+    BitTagged.sanity_check_tag __LINE__ env Type.Int ^^
+    compile_exp_vanilla env ae e2 ^^
+    BitTagged.sanity_check_tag __LINE__ env Type.Int ^^
+    (* equate (without untagging) *)
+    compile_comparison I64Op.Eq
+  | DerefArrayOffset, [e1; e2] ->
+    SR.Vanilla,
+    (* NB: no bounds check on index *)
+    compile_exp_vanilla env ae e1 ^^ (* skewed pointer to array *)
+    Tagged.load_forwarding_pointer env ^^
+    compile_exp_vanilla env ae e2 ^^ (* byte offset *)
+    BitTagged.untag __LINE__ env Type.Int ^^
+    (* TODO: Refactor 3L to use word_size *)
+    compile_shl_const 3L ^^ (* effectively a multiplication by word_size *)
+    (* Note: the below two lines compile to `i64.add; i64.load offset=OFFSET`
+       with `OFFSET = Arr.header_size * word_size + ptr_unskew`,
+       thus together also unskewing the pointer and skipping administrative
+       fields, effectively arriving at the desired element *)
+    G.i (Binary (Wasm_exts.Values.I64 I64Op.Add)) ^^
+    (* Not using Tagged.load_field since it is not a proper pointer to the array start *)
+    Heap.load_field Arr.header_size (* loads the element at the byte offset *)
+  | GetLastArrayOffset, [e] ->
+    assert (BitTagged.can_tag_const Type.Int (Int64.sub Arr.max_array_size 1L));
+    SR.Vanilla,
+    compile_exp_vanilla env ae e ^^ (* array *)
+    Arr.len env ^^
+    compile_sub_const 1L ^^
+    BigNum.from_signed_word_compact env
+
+  | BreakPrim name, [e] ->
+    let d = VarEnv.get_label_depth ae name in
+    SR.Unreachable,
+    compile_exp_vanilla env ae e ^^
+    G.branch_to_ d
+  | AssertPrim, [e1] ->
+    SR.unit,
+    compile_exp_as env ae SR.bool e1 ^^
+    E.if0 G.nop (IC.fail_assert env at)
+  | RetPrim, [e] ->
+    SR.Unreachable,
+    compile_exp_as env ae (StackRep.of_arity (E.get_return_arity env)) e ^^
+    FakeMultiVal.store env (Lib.List.make (E.get_return_arity env) I64Type) ^^
+    G.i Return
+
+  (* Numeric conversions *)
+  | NumConvWrapPrim (t1, t2), [e] -> begin
+    let open Type in
+    match t1, t2 with
+    | (Nat|Int), (Nat8|Nat16|Nat32|Int8|Int16|Int32) ->
+      SR.UnboxedWord64 t2, (* ! *)
+      compile_exp_vanilla env ae e ^^
+      Prim.prim_intToWordNShifted env (TaggedSmallWord.shift_of_type t2)
+
+    | (Nat|Int), ((Nat64|Int64) as p) ->
+      SR.UnboxedWord64 p,
+      compile_exp_vanilla env ae e ^^
+      BigNum.truncate_to_word64 env
+
+    | Nat64, Int64 | Int64, Nat64 ->
+      SR.UnboxedWord64 t2,
+      compile_exp_as env ae (SR.UnboxedWord64 t1) e
+    | Nat32, Int32 | Int32, Nat32 ->
+      SR.UnboxedWord64 t2,
+      compile_exp_as env ae (SR.UnboxedWord64 t1) e
+    | Nat16, Int16 | Int16, Nat16
+    | Nat8, Int8 | Int8, Nat8 ->
+      SR.UnboxedWord64 t2,
+      compile_exp_as env ae (SR.UnboxedWord64 t1) e
+    | Char, Nat32 ->
+      SR.UnboxedWord64 Nat32,
+      compile_exp_as env ae (SR.UnboxedWord64 t1) e ^^
+      TaggedSmallWord.lsb_adjust_codepoint env ^^
+      TaggedSmallWord.msb_adjust Nat32
+
+    | _ -> SR.Unreachable, todo_trap env "compile_prim_invocation" (Arrange_ir.prim p)
+    end
+
+  | NumConvTrapPrim (t1, t2), [e] -> begin
+    let open Type in
+    match t1, t2 with
+
+    | Int, Int64 ->
+      SR.UnboxedWord64 Int64,
+      compile_exp_vanilla env ae e ^^
+      Func.share_code1 Func.Never env "Int->Int64" ("n", I64Type) [I64Type] (fun env get_n ->
+        get_n ^^
+        BigNum.fits_signed_bits env 64 ^^
+        E.else_trap_with env "losing precision" ^^
+        get_n ^^
+        BigNum.truncate_to_word64 env)
+
+    | Int, (Int8|Int16|Int32 as pty) ->
+      StackRep.of_type (Prim pty),
+      compile_exp_vanilla env ae e ^^
+      Func.share_code1 Func.Never env (prim_fun_name pty "Int->") ("n", I64Type) [I64Type] (fun env get_n ->
+        get_n ^^
+        BigNum.fits_signed_bits env (TaggedSmallWord.bits_of_type pty) ^^
+        E.else_trap_with env "losing precision" ^^
+        get_n ^^
+        BigNum.truncate_to_word32 env ^^
+        TaggedSmallWord.msb_adjust pty)
+
+    | Nat, Nat64 ->
+      SR.UnboxedWord64 Nat64,
+      compile_exp_vanilla env ae e ^^
+      Func.share_code1 Func.Never env "Nat->Nat64" ("n", I64Type) [I64Type] (fun env get_n ->
+        get_n ^^
+        BigNum.fits_unsigned_bits env 64 ^^
+        E.else_trap_with env "losing precision" ^^
+        get_n ^^
+        BigNum.truncate_to_word64 env)
+
+    | Nat, (Nat8|Nat16|Nat32 as pty) ->
+      StackRep.of_type (Prim pty),
+      compile_exp_vanilla env ae e ^^
+      Func.share_code1 Func.Never env (prim_fun_name pty "Nat->") ("n", I64Type) [I64Type] (fun env get_n ->
+        get_n ^^
+        BigNum.fits_unsigned_bits env (TaggedSmallWord.bits_of_type pty) ^^
+        E.else_trap_with env "losing precision" ^^
+        get_n ^^
+        BigNum.truncate_to_word32 env ^^
+        TaggedSmallWord.msb_adjust pty)
+
+    | (Nat8|Nat16|Nat32), Nat ->
+      SR.Vanilla,
+      compile_exp_as env ae (SR.UnboxedWord64 t1) e ^^
+      Prim.prim_shiftWordNtoUnsigned env (TaggedSmallWord.shift_of_type t1)
+
+    | (Int8|Int16|Int32), Int ->
+      SR.Vanilla,
+      compile_exp_as env ae (SR.UnboxedWord64 t1) e ^^
+      Prim.prim_shiftWordNtoSigned env (TaggedSmallWord.shift_of_type t1)
+
+    | Nat64, Nat ->
+      SR.Vanilla,
+      compile_exp_as env ae (SR.UnboxedWord64 Nat64) e ^^
+      BigNum.from_word64 env
+
+    | Int64, Int ->
+      SR.Vanilla,
+      compile_exp_as env ae (SR.UnboxedWord64 Int64) e ^^
+      BigNum.from_signed_word64 env
+
+    | Nat32, Char ->
+      SR.UnboxedWord64 Type.Char, (* ! *)
+      compile_exp_as env ae (SR.UnboxedWord64 Nat32) e ^^
+      TaggedSmallWord.lsb_adjust Nat32 ^^
+      TaggedSmallWord.check_and_msb_adjust_codepoint env (* TBR *)
+
+    | Float, Int ->
+      SR.Vanilla,
+      compile_exp_as env ae SR.UnboxedFloat64 e ^^
+      E.call_import env "rts" "bigint_of_float64"
+
+    | Int, Float ->
+      SR.UnboxedFloat64,
+      compile_exp_vanilla env ae e ^^
+      let set_b, get_b = new_local env "b" in
+      set_b ^^
+      get_b ^^
+      BitTagged.if_tagged_scalar env [F64Type]
+        (get_b ^^
+         BitTagged.untag __LINE__ env Type.Int ^^
+         G.i (Convert (Wasm_exts.Values.F64 F64Op.ConvertSI64)))
+        (get_b ^^
+         E.call_import env "rts" "bigint_to_float64")
+
+    | Float, Int64 ->
+      SR.UnboxedWord64 Int64,
+      compile_exp_as env ae SR.UnboxedFloat64 e ^^
+      G.i (Convert (Wasm_exts.Values.I64 I64Op.TruncSF64))
+
+    | Int64, Float ->
+      SR.UnboxedFloat64,
+      compile_exp_as env ae (SR.UnboxedWord64 Int64) e ^^
+      G.i (Convert (Wasm_exts.Values.F64 F64Op.ConvertSI64))
+    | (Nat8 as from_typ), (Nat16 as to_typ)
+    | (Nat16 as from_typ), (Nat32 as to_typ)
+    | (Nat32 as from_typ), (Nat64 as to_typ) ->
+      SR.UnboxedWord64 to_typ,
+      compile_exp_as env ae (SR.UnboxedWord64 from_typ) e ^^
+      TaggedSmallWord.lsb_adjust from_typ ^^
+      TaggedSmallWord.msb_adjust to_typ
+    | (Nat16 as from_typ), (Nat8 as to_typ)
+    | (Nat32 as from_typ), (Nat16 as to_typ)
+    | (Nat64 as from_typ), (Nat32 as to_typ) ->
+      SR.UnboxedWord64 to_typ,
+      let num_bits = (TaggedSmallWord.bits_of_type to_typ) in
+      let set_val, get_val = new_local env "convertee" in
+      compile_exp_as env ae (SR.UnboxedWord64 from_typ) e ^^
+      set_val ^^
+      get_val ^^
+      compile_shrU_const (Int64.of_int (64 - num_bits)) ^^
+      E.then_trap_with env "losing precision" ^^
+      get_val ^^
+      compile_shl_const (Int64.of_int num_bits)
+    | (Int8 as from_typ), (Int16 as to_typ)
+    | (Int16 as from_typ), (Int32 as to_typ)
+    | (Int32 as from_typ), (Int64 as to_typ) ->
+      SR.UnboxedWord64 to_typ,
+      compile_exp_as env ae (SR.UnboxedWord64 from_typ) e ^^
+      TaggedSmallWord.lsb_adjust from_typ ^^
+      TaggedSmallWord.msb_adjust to_typ
+    | (Int16 as from_typ), (Int8 as to_typ)
+    | (Int32 as from_typ), (Int16 as to_typ)
+    | (Int64 as from_typ), (Int32 as to_typ) ->
+      SR.UnboxedWord64 to_typ,
+      let num_bits = (TaggedSmallWord.bits_of_type to_typ) in
+      let set_val, get_val = new_local env "convertee" in
+      compile_exp_as env ae (SR.UnboxedWord64 from_typ)  e ^^
+      set_val ^^
+      get_val ^^
+      compile_shl_const (Int64.of_int num_bits) ^^
+      compile_shrS_const (Int64.of_int num_bits) ^^
+      get_val ^^
+      compile_eq env Type.(Prim from_typ) ^^
+      E.else_trap_with env "losing precision" ^^
+      get_val ^^
+      compile_shl_const (Int64.of_int num_bits)
+    | _ -> SR.Unreachable, todo_trap env "compile_prim_invocation" (Arrange_ir.prim p)
+    end
+
+  | SerializePrim ts, [e] ->
+    SR.Vanilla,
+    compile_exp_vanilla env ae e ^^
+    Serialization.serialize env ts ^^
+    Blob.of_ptr_size env
+
+  | DeserializePrim ts, [e] ->
+    StackRep.of_arity (List.length ts),
+    compile_exp_vanilla env ae e ^^
+    Bool.lit false ^^ (* can't recover *)
+    Serialization.deserialize_from_blob false env ts
+
+  | DeserializeOptPrim ts, [e] ->
+    SR.Vanilla,
+    compile_exp_vanilla env ae e ^^
+    Bool.lit true ^^ (* can (!) recover *)
+    Serialization.deserialize_from_blob false env ts ^^
+    begin match ts with
+    | [] ->
+      (* return some () *)
+      Opt.inject env (Tuple.compile_unit env)
+    | [t] ->
+      (* save to local, propagate error as null or return some value *)
+      let (set_val, get_val) = new_local env "val" in
+      set_val ^^
+      get_val ^^
+      compile_eq_const (Serialization.coercion_error_value env) ^^
+      E.if1 I64Type
+        (Opt.null_lit env)
+        (Opt.inject env get_val)
+    | ts ->
+      (* propagate any errors as null or return some tuples using shared code *)
+      let n = List.length ts in
+      let name = Printf.sprintf "to_opt_%i_tuple" n in
+      let args = Lib.List.table n (fun i -> (Printf.sprintf "arg%i" i, I64Type)) in
+      Func.share_code Func.Always env name args [I64Type] (fun env getters ->
+        let locals =
+          Lib.List.table n (fun i -> List.nth getters i) in
+        let rec go ls =
+          match ls with
+          | get_val::ls' ->
+            get_val ^^
+            compile_eq_const (Serialization.coercion_error_value env) ^^
+            E.if1 I64Type
+              (Opt.null_lit env)
+              (go ls')
+          | [] ->
+            Opt.inject env (Arr.lit env Tagged.T locals)
+        in
+        go locals)
+    end
+
+  | ICPerformGC, [] ->
+    SR.unit,
+    GC.collect_garbage env
+
+  | ICStableSize t, [e] ->
+    SR.UnboxedWord64 Type.Nat64,
+    E.trap_with env "Deprecated with enhanced orthogonal persistence"
+
+  (* Other prims, unary *)
+
+  | OtherPrim "array_len", [e] ->
+    SR.Vanilla,
+    compile_exp_vanilla env ae e ^^
+    Arr.len env ^^
+    BigNum.from_word64 env
+
+  | OtherPrim "text_len", [e] ->
+    SR.Vanilla, compile_exp_vanilla env ae e ^^ Text.len_nat env
+  | OtherPrim "text_iter", [e] ->
+    SR.Vanilla, compile_exp_vanilla env ae e ^^ Text.iter env
+  | OtherPrim "text_iter_done", [e] ->
+    SR.bool, compile_exp_vanilla env ae e ^^ Text.iter_done env
+  | OtherPrim "text_iter_next", [e] ->
+    SR.UnboxedWord64 Type.Char, compile_exp_vanilla env ae e ^^ Text.iter_next env
+  | OtherPrim "text_compare", [e1; e2] ->
+    SR.UnboxedWord64 Type.Int8,
+    compile_exp_vanilla env ae e1 ^^
+    compile_exp_vanilla env ae e2 ^^
+    E.call_import env "rts" "text_compare" ^^
+    TaggedSmallWord.msb_adjust Type.Int8
+  | OtherPrim "blob_compare", [e1; e2] ->
+    SR.UnboxedWord64 Type.Int8,
+    compile_exp_vanilla env ae e1 ^^
+    compile_exp_vanilla env ae e2 ^^
+    Blob.compare env None ^^
+    TaggedSmallWord.msb_adjust Type.Int8
+
+  | OtherPrim "blob_size", [e] ->
+    SR.Vanilla, compile_exp_vanilla env ae e ^^ Blob.len_nat env
+  | OtherPrim "blob_vals_iter", [e] ->
+    SR.Vanilla, compile_exp_vanilla env ae e ^^ Blob.iter env
+  | OtherPrim "blob_iter_done", [e] ->
+    SR.bool, compile_exp_vanilla env ae e ^^ Blob.iter_done env
+  | OtherPrim "blob_iter_next", [e] ->
+    SR.UnboxedWord64 Type.Nat8, (* ! *)
+    compile_exp_vanilla env ae e ^^ Blob.iter_next env
+
+  | OtherPrim "lsh_Nat", [e1; e2] ->
+    SR.Vanilla,
+    compile_exp_vanilla env ae e1 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat32) e2 ^^
+    BigNum.compile_lsh env
+
+  | OtherPrim "rsh_Nat", [e1; e2] ->
+    SR.Vanilla,
+    compile_exp_vanilla env ae e1 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat32) e2 ^^
+    BigNum.compile_rsh env
+
+  | OtherPrim "abs", [e] ->
+    SR.Vanilla,
+    compile_exp_vanilla env ae e ^^
+    BigNum.compile_abs env
+
+  | OtherPrim "fabs", [e] ->
+    SR.UnboxedFloat64,
+    compile_exp_as env ae SR.UnboxedFloat64 e ^^
+    G.i (Unary (Wasm_exts.Values.F64 F64Op.Abs))
+
+  | OtherPrim "fsqrt", [e] ->
+    SR.UnboxedFloat64,
+    compile_exp_as env ae SR.UnboxedFloat64 e ^^
+    G.i (Unary (Wasm_exts.Values.F64 F64Op.Sqrt))
+
+  | OtherPrim "fceil", [e] ->
+    SR.UnboxedFloat64,
+    compile_exp_as env ae SR.UnboxedFloat64 e ^^
+    G.i (Unary (Wasm_exts.Values.F64 F64Op.Ceil))
+
+  | OtherPrim "ffloor", [e] ->
+    SR.UnboxedFloat64,
+    compile_exp_as env ae SR.UnboxedFloat64 e ^^
+    G.i (Unary (Wasm_exts.Values.F64 F64Op.Floor))
+
+  | OtherPrim "ftrunc", [e] ->
+    SR.UnboxedFloat64,
+    compile_exp_as env ae SR.UnboxedFloat64 e ^^
+    G.i (Unary (Wasm_exts.Values.F64 F64Op.Trunc))
+
+  | OtherPrim "fnearest", [e] ->
+    SR.UnboxedFloat64,
+    compile_exp_as env ae SR.UnboxedFloat64 e ^^
+    G.i (Unary (Wasm_exts.Values.F64 F64Op.Nearest))
+
+  | OtherPrim "fmin", [e; f] ->
+    SR.UnboxedFloat64,
+    compile_exp_as env ae SR.UnboxedFloat64 e ^^
+    compile_exp_as env ae SR.UnboxedFloat64 f ^^
+    G.i (Binary (Wasm_exts.Values.F64 F64Op.Min))
+
+  | OtherPrim "fmax", [e; f] ->
+    SR.UnboxedFloat64,
+    compile_exp_as env ae SR.UnboxedFloat64 e ^^
+    compile_exp_as env ae SR.UnboxedFloat64 f ^^
+    G.i (Binary (Wasm_exts.Values.F64 F64Op.Max))
+
+  | OtherPrim "fcopysign", [e; f] ->
+    SR.UnboxedFloat64,
+    compile_exp_as env ae SR.UnboxedFloat64 e ^^
+    compile_exp_as env ae SR.UnboxedFloat64 f ^^
+    G.i (Binary (Wasm_exts.Values.F64 F64Op.CopySign))
+
+  | OtherPrim "Float->Text", [e] ->
+    SR.Vanilla,
+    compile_exp_as env ae SR.UnboxedFloat64 e ^^
+    compile_unboxed_const (TaggedSmallWord.vanilla_lit Type.Nat8 6) ^^
+    compile_unboxed_const (TaggedSmallWord.vanilla_lit Type.Nat8 0) ^^
+    E.call_import env "rts" "float_fmt"
+
+  | OtherPrim "fmtFloat->Text", [f; prec; mode] ->
+    SR.Vanilla,
+    compile_exp_as env ae SR.UnboxedFloat64 f ^^
+    compile_exp_vanilla env ae prec ^^
+    compile_exp_vanilla env ae mode ^^
+    E.call_import env "rts" "float_fmt"
+
+  | OtherPrim "fsin", [e] ->
+    SR.UnboxedFloat64,
+    compile_exp_as env ae SR.UnboxedFloat64 e ^^
+    E.call_import env "rts" "sin" (* musl *)
+
+  | OtherPrim "fcos", [e] ->
+    SR.UnboxedFloat64,
+    compile_exp_as env ae SR.UnboxedFloat64 e ^^
+    E.call_import env "rts" "cos" (* musl *)
+
+  | OtherPrim "ftan", [e] ->
+    SR.UnboxedFloat64,
+    compile_exp_as env ae SR.UnboxedFloat64 e ^^
+    E.call_import env "rts" "tan" (* musl *)
+
+  | OtherPrim "fasin", [e] ->
+    SR.UnboxedFloat64,
+    compile_exp_as env ae SR.UnboxedFloat64 e ^^
+    E.call_import env "rts" "asin" (* musl *)
+
+  | OtherPrim "facos", [e] ->
+    SR.UnboxedFloat64,
+    compile_exp_as env ae SR.UnboxedFloat64 e ^^
+    E.call_import env "rts" "acos" (* musl *)
+
+  | OtherPrim "fatan", [e] ->
+    SR.UnboxedFloat64,
+    compile_exp_as env ae SR.UnboxedFloat64 e ^^
+    E.call_import env "rts" "atan" (* musl *)
+
+  | OtherPrim "fatan2", [y; x] ->
+    SR.UnboxedFloat64,
+    compile_exp_as env ae SR.UnboxedFloat64 y ^^
+    compile_exp_as env ae SR.UnboxedFloat64 x ^^
+    E.call_import env "rts" "atan2" (* musl *)
+
+  | OtherPrim "fexp", [e] ->
+    SR.UnboxedFloat64,
+    compile_exp_as env ae SR.UnboxedFloat64 e ^^
+    E.call_import env "rts" "exp" (* musl *)
+
+  | OtherPrim "flog", [e] ->
+    SR.UnboxedFloat64,
+    compile_exp_as env ae SR.UnboxedFloat64 e ^^
+    E.call_import env "rts" "log" (* musl *)
+
+  (* Other prims, nullary *)
+
+  | SystemTimePrim, [] ->
+    SR.UnboxedWord64 Type.Nat64,
+    IC.get_system_time env
+
+  | OtherPrim "call_perform_status", [] ->
+    SR.UnboxedWord64 Type.Nat32,
+    IC.get_call_perform_status env ^^
+    TaggedSmallWord.msb_adjust Type.Nat32
+
+  | OtherPrim "call_perform_message", [] ->
+    SR.Vanilla,
+    IC.get_call_perform_message env
+
+  | OtherPrim "rts_version", [] ->
+    SR.Vanilla,
+    E.call_import env "rts" "version"
+
+  | OtherPrim "rts_heap_size", [] ->
+    SR.Vanilla,
+    Heap.get_heap_size env ^^ Prim.prim_word64toNat env
+
+  | OtherPrim "rts_memory_size", [] ->
+    SR.Vanilla,
+    Heap.get_memory_size ^^ BigNum.from_word64 env
+
+  | OtherPrim "rts_total_allocation", [] ->
+    SR.Vanilla,
+    Heap.get_total_allocation env ^^ BigNum.from_word64 env
+
+  | OtherPrim "rts_reclaimed", [] ->
+    SR.Vanilla,
+    Heap.get_reclaimed env ^^ BigNum.from_word64 env
+
+  | OtherPrim "rts_max_live_size", [] ->
+    SR.Vanilla,
+    Heap.get_max_live_size env ^^ BigNum.from_word64 env
+
+  | OtherPrim "rts_max_stack_size", [] ->
+    SR.Vanilla,
+    Stack.get_max_stack_size env ^^ Prim.prim_word64toNat env
+
+  | OtherPrim "rts_callback_table_count", [] ->
+    SR.Vanilla,
+    ContinuationTable.count env ^^ Prim.prim_word64toNat env
+
+  | OtherPrim "rts_callback_table_size", [] ->
+    SR.Vanilla,
+    ContinuationTable.size env ^^ Prim.prim_word64toNat env
+
+  | OtherPrim "rts_mutator_instructions", [] ->
+    SR.Vanilla,
+    GC.get_mutator_instructions env ^^ BigNum.from_word64 env
+
+  | OtherPrim "rts_collector_instructions", [] ->
+    SR.Vanilla,
+    GC.get_collector_instructions env ^^ BigNum.from_word64 env
+
+  | OtherPrim "rts_upgrade_instructions", [] ->
+    SR.Vanilla,
+    UpgradeStatistics.get_upgrade_instructions env ^^ BigNum.from_word64 env
+
+  | OtherPrim "rts_stable_memory_size", [] ->
+    SR.Vanilla,
+    StableMem.stable64_size env ^^ BigNum.from_word64 env
+
+  | OtherPrim "rts_logical_stable_memory_size", [] ->
+    SR.Vanilla,
+    StableMem.get_mem_size env ^^ BigNum.from_word64 env
+
+  (* Regions *)
+
+  | OtherPrim "regionNew", [] ->
+    SR.Vanilla,
+    Region.new_ env
+
+  | OtherPrim "regionId", [e0] ->
+     SR.Vanilla,
+     compile_exp_as env ae SR.Vanilla e0 ^^
+     Region.id env ^^
+     BigNum.from_word64 env
+
+  | OtherPrim ("regionGrow"), [e0; e1] ->
+    SR.UnboxedWord64 Type.Nat64,
+    compile_exp_as env ae SR.Vanilla e0 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
+    Region.grow env
+
+  | OtherPrim "regionSize", [e0] ->
+    SR.UnboxedWord64 Type.Nat64,
+    compile_exp_as env ae SR.Vanilla e0 ^^
+    Region.size env
+
+  | OtherPrim ("regionLoadBlob"), [e0; e1; e2] ->
+    SR.Vanilla,
+    compile_exp_as env ae SR.Vanilla e0 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
+    compile_exp_as env ae SR.Vanilla e2 ^^
+    BigNum.to_word64_with env (Blob.lit env Tagged.T "Blob size out of bounds") ^^
+    Region.load_blob env
+
+  | OtherPrim ("regionStoreBlob"), [e0; e1; e2] ->
+    SR.unit,
+    compile_exp_as env ae SR.Vanilla e0 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
+    compile_exp_as env ae SR.Vanilla e2 ^^
+    Region.store_blob env
+
+  | OtherPrim (("regionLoadNat8" | "regionLoadInt8" as p)), [e0; e1] ->
+    let ty = Type.(if p = "regionLoadNat8" then Nat8 else Int8) in
+    SR.UnboxedWord64 ty,
+    compile_exp_as env ae SR.Vanilla e0 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
+    Region.load_word8 env ^^
+    G.i (Convert (Wasm_exts.Values.I64 I64Op.(if ty = Type.Nat8 then ExtendUI32 else ExtendSI32))) ^^
+    TaggedSmallWord.msb_adjust ty
+
+  | OtherPrim (("regionStoreNat8" | "regionStoreInt8") as p), [e0; e1; e2] ->
+    let ty = Type.(if p = "regionStoreNat8" then Nat8 else Int8) in
+    SR.unit,
+    compile_exp_as env ae SR.Vanilla e0 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 ty) e2 ^^
+    TaggedSmallWord.lsb_adjust ty ^^
+    G.i (Convert (Wasm_exts.Values.I32 I32Op.WrapI64)) ^^
+    Region.store_word8 env
+
+  | OtherPrim (("regionLoadNat16" | "regionLoadInt16") as p), [e0; e1] ->
+    let ty = Type.(if p = "regionLoadNat16" then Nat16 else Int16) in
+    SR.UnboxedWord64 ty,
+    compile_exp_as env ae SR.Vanilla e0 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
+    Region.load_word16 env ^^
+    G.i (Convert (Wasm_exts.Values.I64 I64Op.(if ty = Type.Nat16 then ExtendUI32 else ExtendSI32))) ^^
+    TaggedSmallWord.msb_adjust ty
+
+  | OtherPrim (("regionStoreNat16" | "regionStoreInt16") as p), [e0; e1; e2] ->
+    let ty = Type.(if p = "regionStoreNat16" then Nat16 else Int16) in
+    SR.unit,
+    compile_exp_as env ae SR.Vanilla e0 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 ty) e2 ^^
+    TaggedSmallWord.lsb_adjust ty ^^
+    G.i (Convert (Wasm_exts.Values.I32 I32Op.WrapI64)) ^^
+    Region.store_word16 env
+
+  | OtherPrim (("regionLoadNat32" | "regionLoadInt32") as p), [e0; e1] ->
+    let ty = Type.(if p = "regionLoadNat32" then Nat32 else Int32) in
+    SR.UnboxedWord64 ty,
+    compile_exp_as env ae SR.Vanilla e0 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
+    Region.load_word32 env ^^
+    G.i (Convert (Wasm_exts.Values.I64 I64Op.(if ty = Type.Nat32 then ExtendUI32 else ExtendSI32))) ^^
+    TaggedSmallWord.msb_adjust ty
+
+  | OtherPrim (("regionStoreNat32" | "regionStoreInt32") as p), [e0; e1; e2] ->
+    let ty = Type.(if p = "regionStoreNat32" then Nat32 else Int32) in
+    SR.unit,
+    compile_exp_as env ae SR.Vanilla e0 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 ty) e2 ^^
+    TaggedSmallWord.lsb_adjust ty ^^
+    G.i (Convert (Wasm_exts.Values.I32 I32Op.WrapI64)) ^^
+    Region.store_word32 env
+
+  | OtherPrim (("regionLoadNat64" | "regionLoadInt64") as p), [e0; e1] ->
+    let ty = Type.(if p = "regionLoadNat64" then Nat64 else Int64) in
+    SR.UnboxedWord64 ty,
+    compile_exp_as env ae SR.Vanilla e0 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
+    Region.load_word64 env
+
+  | OtherPrim (("regionStoreNat64" | "regionStoreInt64") as p), [e0; e1; e2] ->
+    let ty = Type.(if p = "regionStoreNat64" then Nat64 else Int64) in
+    SR.unit,
+    compile_exp_as env ae SR.Vanilla e0 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 ty) e2 ^^
+    Region.store_word64 env
+
+  | OtherPrim ("regionLoadFloat"), [e0; e1] ->
+    SR.UnboxedFloat64,
+    compile_exp_as env ae SR.Vanilla e0 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
+    Region.load_float64 env
+
+  | OtherPrim ("regionStoreFloat"), [e0; e1; e2] ->
+    SR.unit,
+    compile_exp_as env ae SR.Vanilla e0 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
+    compile_exp_as env ae SR.UnboxedFloat64 e2 ^^
+    Region.store_float64 env
+
+  (* Other prims, unary *)
+
+  | OtherPrim "global_timer_set", [e] ->
+    SR.UnboxedWord64 Type.Nat64,
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e ^^
+    IC.system_call env "global_timer_set"
+
+  | OtherPrim "is_controller", [e] ->
+    SR.Vanilla,
+    let set_principal, get_principal = new_local env "principal" in
+    compile_exp_vanilla env ae e ^^
+    set_principal ^^ get_principal ^^
+    Blob.payload_ptr_unskewed env ^^
+    get_principal ^^
+    Blob.len env ^^
+    IC.is_controller env
+
+  | OtherPrim "canister_version", [] ->
+    SR.UnboxedWord64 Type.Nat64,
+    IC.canister_version env
+
+  | OtherPrim "crc32Hash", [e] ->
+    SR.UnboxedWord64 Type.Nat32,
+    compile_exp_vanilla env ae e ^^
+    E.call_import env "rts" "compute_crc32" ^^
+    G.i (Convert (Wasm_exts.Values.I64 I64Op.ExtendUI32)) ^^
+    TaggedSmallWord.msb_adjust Type.Nat32
+
+  | OtherPrim "idlHash", [e] ->
+    SR.Vanilla,
+    E.trap_with env "idlHash only implemented in interpreter"
+
+
+  | OtherPrim "popcnt8", [e] ->
+    SR.UnboxedWord64 Type.Nat8,
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat8) e ^^
+    G.i (Unary (Wasm_exts.Values.I64 I64Op.Popcnt)) ^^
+    TaggedSmallWord.msb_adjust Type.Nat8
+  | OtherPrim "popcnt16", [e] ->
+    SR.UnboxedWord64 Type.Nat16,
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat16) e ^^
+    G.i (Unary (Wasm_exts.Values.I64 I64Op.Popcnt)) ^^
+    TaggedSmallWord.msb_adjust Type.Nat16
+  | OtherPrim "popcntInt8", [e] ->
+    SR.UnboxedWord64 Type.Int8,
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Int8) e ^^
+    G.i (Unary (Wasm_exts.Values.I64 I64Op.Popcnt)) ^^
+    TaggedSmallWord.msb_adjust Type.Int8
+  | OtherPrim "popcntInt16", [e] ->
+    SR.UnboxedWord64 Type.Int16,
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Int16) e ^^
+    G.i (Unary (Wasm_exts.Values.I64 I64Op.Popcnt)) ^^
+    TaggedSmallWord.msb_adjust Type.Int16
+  | OtherPrim "popcnt32", [e] ->
+     SR.UnboxedWord64 Type.Nat32,
+     compile_exp_as env ae (SR.UnboxedWord64 Type.Nat32) e ^^
+     G.i (Unary (Wasm_exts.Values.I64 I64Op.Popcnt)) ^^
+     TaggedSmallWord.msb_adjust Type.Nat32
+  | OtherPrim "popcntInt32", [e] ->
+     SR.UnboxedWord64 Type.Int32,
+     compile_exp_as env ae (SR.UnboxedWord64 Type.Int32) e ^^
+     G.i (Unary (Wasm_exts.Values.I64 I64Op.Popcnt))^^
+     TaggedSmallWord.msb_adjust Type.Int32
+  | OtherPrim "popcnt64", [e] ->
+     SR.UnboxedWord64 Type.Nat64,
+     compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e ^^
+     G.i (Unary (Wasm_exts.Values.I64 I64Op.Popcnt))
+  | OtherPrim "popcntInt64", [e] ->
+     SR.UnboxedWord64 Type.Int64,
+     compile_exp_as env ae (SR.UnboxedWord64 Type.Int64) e ^^
+     G.i (Unary (Wasm_exts.Values.I64 I64Op.Popcnt))
+  | OtherPrim "clz8", [e] ->
+     SR.UnboxedWord64 Type.Nat8,
+     compile_exp_as env ae (SR.UnboxedWord64 Type.Nat8) e ^^
+     TaggedSmallWord.clz_kernel Type.Nat8
+  | OtherPrim "clz16", [e] ->
+     SR.UnboxedWord64 Type.Nat16,
+     compile_exp_as env ae (SR.UnboxedWord64 Type.Nat16) e ^^
+     TaggedSmallWord.clz_kernel Type.Nat16
+  | OtherPrim "clzInt8", [e] ->
+     SR.UnboxedWord64 Type.Int8,
+     compile_exp_as env ae (SR.UnboxedWord64 Type.Int8) e ^^
+     TaggedSmallWord.clz_kernel Type.Int8
+  | OtherPrim "clzInt16", [e] ->
+     SR.UnboxedWord64 Type.Int16,
+     compile_exp_as env ae (SR.UnboxedWord64 Type.Int16) e ^^
+     TaggedSmallWord.clz_kernel Type.Int16
+  | OtherPrim "clz32", [e] ->
+     SR.UnboxedWord64 Type.Nat32,
+     compile_exp_as env ae (SR.UnboxedWord64 Type.Nat32) e ^^ 
+     TaggedSmallWord.clz_kernel Type.Nat32
+  | OtherPrim "clzInt32", [e] ->
+     SR.UnboxedWord64 Type.Int32,
+     compile_exp_as env ae (SR.UnboxedWord64 Type.Int32) e ^^ 
+     TaggedSmallWord.clz_kernel Type.Int32
+  | OtherPrim "clz64", [e] ->
+     SR.UnboxedWord64 Type.Nat64,
+     compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e ^^ 
+     G.i (Unary (Wasm_exts.Values.I64 I64Op.Clz))
+  | OtherPrim "clzInt64", [e] ->
+     SR.UnboxedWord64 Type.Int64,
+     compile_exp_as env ae (SR.UnboxedWord64 Type.Int64) e ^^ 
+     G.i (Unary (Wasm_exts.Values.I64 I64Op.Clz))
+  | OtherPrim "ctz8", [e] ->
+     SR.UnboxedWord64 Type.Nat8,
+     compile_exp_as env ae (SR.UnboxedWord64 Type.Nat8) e ^^
+     TaggedSmallWord.ctz_kernel Type.Nat8
+  | OtherPrim "ctz16", [e] ->
+     SR.UnboxedWord64 Type.Nat16,
+     compile_exp_as env ae (SR.UnboxedWord64 Type.Nat16) e ^^
+     TaggedSmallWord.ctz_kernel Type.Nat16
+  | OtherPrim "ctzInt8", [e] ->
+     SR.UnboxedWord64 Type.Int8,
+     compile_exp_as env ae (SR.UnboxedWord64 Type.Int8) e ^^
+     TaggedSmallWord.ctz_kernel Type.Int8
+  | OtherPrim "ctzInt16", [e] ->
+     SR.UnboxedWord64 Type.Int16,
+     compile_exp_as env ae (SR.UnboxedWord64 Type.Int16) e ^^
+     TaggedSmallWord.ctz_kernel Type.Int16
+  | OtherPrim "ctz32", [e] ->
+    SR.UnboxedWord64 Type.Nat32,
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat32) e ^^ 
+    TaggedSmallWord.ctz_kernel Type.Nat32
+  | OtherPrim "ctzInt32", [e] ->
+    SR.UnboxedWord64 Type.Int32,
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Int32) e ^^ 
+    TaggedSmallWord.ctz_kernel Type.Int32
+  | OtherPrim "ctz64", [e] ->
+    SR.UnboxedWord64 Type.Nat64,
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e ^^ 
+    G.i (Unary (Wasm_exts.Values.I64 I64Op.Ctz))
+  | OtherPrim "ctzInt64", [e] ->
+    SR.UnboxedWord64 Type.Int64,
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Int64) e ^^ 
+    G.i (Unary (Wasm_exts.Values.I64 I64Op.Ctz))
+
+  | OtherPrim "conv_Char_Text", [e] ->
+    SR.Vanilla,
+    compile_exp_vanilla env ae e ^^
+    Text.prim_showChar env
+
+  | OtherPrim "char_to_upper", [e] ->
+    compile_char_to_char_rts env ae e "char_to_upper"
+
+  | OtherPrim "char_to_lower", [e] ->
+    compile_char_to_char_rts env ae e "char_to_lower"
+
+  | OtherPrim "char_is_whitespace", [e] ->
+    compile_char_to_bool_rts env ae e "char_is_whitespace"
+
+  | OtherPrim "char_is_lowercase", [e] ->
+    compile_char_to_bool_rts env ae e "char_is_lowercase"
+
+  | OtherPrim "char_is_uppercase", [e] ->
+    compile_char_to_bool_rts env ae e "char_is_uppercase"
+
+  | OtherPrim "char_is_alphabetic", [e] ->
+    compile_char_to_bool_rts env ae e "char_is_alphabetic"
+
+  | OtherPrim "print", [e] ->
+    SR.unit,
+    compile_exp_vanilla env ae e ^^
+    IC.print_text env
+
+  | OtherPrim "text_lowercase", [e] ->
+    SR.Vanilla,
+    compile_exp_vanilla env ae e ^^
+    Text.lowercase env
+
+  | OtherPrim "text_uppercase", [e] ->
+    SR.Vanilla,
+    compile_exp_vanilla env ae e ^^
+    Text.uppercase env
+
+  | OtherPrim "performanceCounter", [e] ->
+    (SR.UnboxedWord64 Type.Nat64),
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat32) e ^^
+    IC.performance_counter env
+
+  | OtherPrim "trap", [e] ->
+    SR.Unreachable,
+    compile_exp_vanilla env ae e ^^
+    IC.trap_text env
+
+  | OtherPrim "principalOfBlob", e ->
+    const_sr SR.Vanilla (Blob.copy env Tagged.B Tagged.P)
+  | OtherPrim "blobOfPrincipal", e ->
+    const_sr SR.Vanilla (Blob.copy env Tagged.P Tagged.B)
+  | OtherPrim "principalOfActor", e ->
+    const_sr SR.Vanilla (Blob.copy env Tagged.A Tagged.P)
+
+  | OtherPrim "blobToArray", e ->
+    const_sr SR.Vanilla (Arr.ofBlob env Tagged.I)
+  | OtherPrim "blobToArrayMut", e ->
+    const_sr SR.Vanilla (Arr.ofBlob env Tagged.M)
+
+  | OtherPrim ("arrayToBlob" | "arrayMutToBlob"), e ->
+    const_sr SR.Vanilla (Arr.toBlob env)
+
+  | OtherPrim (("stableMemoryLoadNat32" | "stableMemoryLoadInt32") as p), [e] ->
+    let ty = Type.(if p = "stableMemoryLoadNat32" then Nat32 else Int32) in
+    SR.UnboxedWord64 ty,
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e ^^
+    StableMemoryInterface.load_word32 env ^^
+    G.i (Convert (Wasm_exts.Values.I64 I64Op.(if ty = Type.Nat32 then ExtendUI32 else ExtendSI32))) ^^
+    TaggedSmallWord.msb_adjust ty
+
+  | OtherPrim (("stableMemoryStoreNat32" | "stableMemoryStoreInt32") as p), [e1; e2] ->
+    let ty = Type.(if p = "stableMemoryStoreNat32" then Nat32 else Int32) in
+    SR.unit,
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 ty) e2 ^^
+    TaggedSmallWord.lsb_adjust ty ^^
+    G.i (Convert (Wasm_exts.Values.I32 I32Op.WrapI64)) ^^
+    StableMemoryInterface.store_word32 env
+
+  | OtherPrim (("stableMemoryLoadNat8" | "stableMemoryLoadInt8") as p), [e] ->
+    let ty = Type.(if p = "stableMemoryLoadNat8" then Nat8 else Int8) in
+    SR.UnboxedWord64 ty,
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e ^^
+    StableMemoryInterface.load_word8 env ^^
+    G.i (Convert (Wasm_exts.Values.I64 I64Op.(if ty = Type.Nat8 then ExtendUI32 else ExtendSI32))) ^^
+    TaggedSmallWord.msb_adjust ty
+
+  (* Other prims, binary *)
+
+  | OtherPrim (("stableMemoryStoreNat8" | "stableMemoryStoreInt8") as p), [e1; e2] ->
+    let ty = Type.(if p = "stableMemoryStoreNat8" then Nat8 else Int8) in
+    SR.unit,
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 ty) e2 ^^
+    TaggedSmallWord.lsb_adjust ty ^^
+    G.i (Convert (Wasm_exts.Values.I32 I32Op.WrapI64)) ^^
+    StableMemoryInterface.store_word8 env
+
+  | OtherPrim (("stableMemoryLoadNat16" | "stableMemoryLoadInt16") as p), [e] ->
+    let ty = Type.(if p = "stableMemoryLoadNat16" then Nat16 else Int16) in
+    SR.UnboxedWord64 ty,
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e ^^
+    StableMemoryInterface.load_word16 env ^^
+    G.i (Convert (Wasm_exts.Values.I64 I64Op.(if ty = Type.Nat16 then ExtendUI32 else ExtendSI32))) ^^
+    TaggedSmallWord.msb_adjust ty
+
+  | OtherPrim (("stableMemoryStoreNat16" | "stableMemoryStoreInt16") as p), [e1; e2] ->
+    let ty = Type.(if p = "stableMemoryStoreNat16" then Nat16 else Int16) in
+    SR.unit,
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 ty) e2 ^^
+    TaggedSmallWord.lsb_adjust ty ^^
+    G.i (Convert (Wasm_exts.Values.I32 I32Op.WrapI64)) ^^
+    StableMemoryInterface.store_word16 env
+
+  | OtherPrim (("stableMemoryLoadNat64" | "stableMemoryLoadInt64") as p), [e] ->
+    let ty = Type.(if p = "stableMemoryLoadNat64" then Nat64 else Int64) in
+    SR.UnboxedWord64 ty,
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e ^^
+    StableMemoryInterface.load_word64 env
+
+  | OtherPrim (("stableMemoryStoreNat64" | "stableMemoryStoreInt64") as p), [e1; e2] ->
+    let ty = Type.(if p = "stableMemoryStoreNat64" then Nat64 else Int64) in
+    SR.unit,
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
+    compile_exp_as env ae (SR.UnboxedWord64 ty) e2 ^^
+    StableMemoryInterface.store_word64 env
+
+  | OtherPrim "stableMemoryLoadFloat", [e] ->
+    SR.UnboxedFloat64,
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e ^^
+    StableMemoryInterface.load_float64 env
+
+  | OtherPrim "stableMemoryStoreFloat", [e1; e2] ->
+    SR.unit,
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
+    compile_exp_as env ae SR.UnboxedFloat64 e2 ^^
+    StableMemoryInterface.store_float64 env
+
+  | OtherPrim "stableMemoryLoadBlob", [e1; e2] ->
+    SR.Vanilla,
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
+    compile_exp_as env ae SR.Vanilla e2 ^^
+    BigNum.to_word64_with env (Blob.lit env Tagged.T "Blob size out of bounds") ^^
+    StableMemoryInterface.load_blob env
+
+  | OtherPrim "stableMemoryStoreBlob", [e1; e2] ->
+    SR.unit,
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e1 ^^
+    compile_exp_as env ae SR.Vanilla e2 ^^
+    StableMemoryInterface.store_blob env
+
+  | OtherPrim "stableMemorySize", [] ->
+    SR.UnboxedWord64 Type.Nat64,
+    StableMemoryInterface.size env
+
+  | OtherPrim "stableMemoryGrow", [e] ->
+    SR.UnboxedWord64 Type.Nat64,
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat64) e ^^
+    StableMemoryInterface.grow env
+
+  | OtherPrim "stableVarQuery", [] ->
+    SR.Vanilla,
+    IC.get_self_reference env ^^
+    IC.actor_public_field env Type.(motoko_stable_var_info_fld.lab)
+
+  (* Other prims, binary*)
+  | OtherPrim "Array.init", [_;_] ->
+    const_sr SR.Vanilla (Arr.init env)
+  | OtherPrim "Array.tabulate", [_;_] ->
+    const_sr SR.Vanilla (Arr.tabulate env)
+  | OtherPrim "btst8", [_;_] ->
+    (* TODO: btstN returns Bool, not a small value *)
+    const_sr (SR.UnboxedWord64 Type.Nat8) (TaggedSmallWord.btst_kernel env Type.Nat8)
+  | OtherPrim "btst16", [_;_] ->
+    const_sr (SR.UnboxedWord64 Type.Nat16) (TaggedSmallWord.btst_kernel env Type.Nat16)
+  | OtherPrim "btstInt8", [_;_] ->
+    const_sr (SR.UnboxedWord64 Type.Int8) (TaggedSmallWord.btst_kernel env Type.Int8)
+  | OtherPrim "btstInt16", [_;_] ->
+    const_sr (SR.UnboxedWord64 Type.Int16) (TaggedSmallWord.btst_kernel env Type.Int16)
+  | OtherPrim "btst32", [_;_] ->
+     const_sr (SR.UnboxedWord64 Type.Nat32) (TaggedSmallWord.btst_kernel env Type.Nat32)
+  | OtherPrim "btstInt32", [_;_] ->
+     const_sr (SR.UnboxedWord64 Type.Int32) (TaggedSmallWord.btst_kernel env Type.Int32) (* ! *)
+  | OtherPrim "btst64", [_;_] ->
+    const_sr (SR.UnboxedWord64 Type.Nat64) (Word64.btst_kernel env)
+  | OtherPrim "btstInt64", [_;_] ->
+    const_sr (SR.UnboxedWord64 Type.Int64) (Word64.btst_kernel env)
+
+  | OtherPrim "setCandidLimits", [e1; e2; e3] ->
+    SR.unit,
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat32) e1 ^^
+    TaggedSmallWord.lsb_adjust Type.Nat32 ^^
+    Serialization.Registers.set_value_numerator env ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat32) e2 ^^
+    TaggedSmallWord.lsb_adjust Type.Nat32 ^^
+    Serialization.Registers.set_value_denominator env ^^
+    Serialization.Registers.get_value_denominator env ^^
+    E.else_trap_with env "Candid limit denominator cannot be zero" ^^
+    compile_exp_as env ae (SR.UnboxedWord64 Type.Nat32) e3 ^^
+    TaggedSmallWord.lsb_adjust Type.Nat32 ^^
+    Serialization.Registers.set_value_bias env
+
+  | OtherPrim "getCandidLimits", [] ->
+    SR.UnboxedTuple 3,
+    Serialization.Registers.get_value_numerator env ^^
+    TaggedSmallWord.msb_adjust Type.Nat32 ^^
+    TaggedSmallWord.tag env Type.Nat32 ^^
+    Serialization.Registers.get_value_denominator env ^^
+    TaggedSmallWord.msb_adjust Type.Nat32 ^^
+    TaggedSmallWord.tag env Type.Nat32 ^^
+    Serialization.Registers.get_value_bias env ^^
+    TaggedSmallWord.msb_adjust Type.Nat32 ^^
+    TaggedSmallWord.tag env Type.Nat32
+
+  (* Coercions for abstract types *)
+  | CastPrim (_,_), [e] ->
+    compile_exp env ae e
+
+  | DecodeUtf8, [_] ->
+    const_sr SR.Vanilla (Text.of_blob env)
+  | EncodeUtf8, [_] ->
+    const_sr SR.Vanilla (Text.to_blob env)
+
+  (* textual to bytes *)
+  | BlobOfIcUrl, [_] ->
+    const_sr SR.Vanilla (E.call_import env "rts" "blob_of_principal")
+  (* The other direction *)
+  | IcUrlOfBlob, [_] ->
+    const_sr SR.Vanilla (E.call_import env "rts" "principal_of_blob")
+
+  (* Actor ids are blobs in the RTS *)
+  | ActorOfIdBlob _, [e] ->
+    SR.Vanilla,
+    let (set_blob, get_blob) = new_local env "blob" in
+    compile_exp_vanilla env ae e ^^
+    set_blob ^^
+    get_blob ^^
+    Blob.len env ^^
+    compile_unboxed_const 29L ^^
+    compile_comparison I64Op.LeU ^^
+    E.else_trap_with env "blob too long for actor principal" ^^
+    get_blob ^^
+    Blob.copy env Tagged.B Tagged.A
+
+  | SelfRef _, [] ->
+    SR.Vanilla, IC.get_self_reference env
+
+  | ICArgDataPrim, [] ->
+    SR.Vanilla, IC.arg_data env
+
+  | ICReplyPrim ts, [e] ->
+    SR.unit, begin match E.mode env with
+    | Flags.ICMode | Flags.RefMode ->
+      compile_exp_vanilla env ae e ^^
+      (* TODO: We can try to avoid the boxing and pass the arguments to
+        serialize individually *)
+      Serialization.serialize env ts ^^
+      IC.reply_with_data env
+    | _ ->
+      E.trap_with env (Printf.sprintf "cannot reply when running locally")
+    end
+
+  | ICRejectPrim, [e] ->
+    SR.unit, IC.reject env (compile_exp_vanilla env ae e)
+
+  | ICCallerPrim, [] ->
+    SR.Vanilla, IC.caller env
+
+  | ICCallPrim, [f;e;k;r;c] ->
+    SR.unit, begin
+    (* TBR: Can we do better than using the notes? *)
+    let _, _, _, ts1, _ = Type.as_func f.note.Note.typ in
+    let _, _, _, ts2, _ = Type.as_func k.note.Note.typ in
+    let (set_meth_pair, get_meth_pair) = new_local env "meth_pair" in
+    let (set_arg, get_arg) = new_local env "arg" in
+    let (set_k, get_k) = new_local env "k" in
+    let (set_r, get_r) = new_local env "r" in
+    let (set_c, get_c) = new_local env "c" in
+    let add_cycles = Internals.add_cycles env ae in
+    compile_exp_vanilla env ae f ^^ set_meth_pair ^^
+    compile_exp_vanilla env ae e ^^ set_arg ^^
+    compile_exp_vanilla env ae k ^^ set_k ^^
+    compile_exp_vanilla env ae r ^^ set_r ^^
+    compile_exp_vanilla env ae c ^^ set_c ^^
+    FuncDec.ic_call env ts1 ts2 get_meth_pair get_arg get_k get_r get_c add_cycles
+    end
+  | ICCallRawPrim, [p;m;a;k;r;c] ->
+    SR.unit, begin
+    let set_meth_pair, get_meth_pair = new_local env "meth_pair" in
+    let set_arg, get_arg = new_local env "arg" in
+    let set_k, get_k = new_local env "k" in
+    let set_r, get_r = new_local env "r" in
+    let set_c, get_c = new_local env "c" in
+    let add_cycles = Internals.add_cycles env ae in
+    compile_exp_vanilla env ae p ^^
+    compile_exp_vanilla env ae m ^^ Text.to_blob env ^^
+    Tagged.load_forwarding_pointer env ^^
+    Tuple.from_stack env 2 ^^ set_meth_pair ^^
+    compile_exp_vanilla env ae a ^^ set_arg ^^
+    compile_exp_vanilla env ae k ^^ set_k ^^
+    compile_exp_vanilla env ae r ^^ set_r ^^
+    compile_exp_vanilla env ae c ^^ set_c ^^
+    FuncDec.ic_call_raw env get_meth_pair get_arg get_k get_r get_c add_cycles
+    end
+
+  | ICMethodNamePrim, [] ->
+    SR.Vanilla, IC.method_name env
+
+  | ICStableRead ty, [] ->
+    SR.Vanilla,
+    Persistence.load env ty
+  | ICStableWrite ty, [] ->
+    SR.unit,
+    Persistence.save env ty
+
+  (* Cycles *)
+  | SystemCyclesBalancePrim, [] ->
+    SR.Vanilla, Cycles.balance env
+  | SystemCyclesAddPrim, [e1] ->
+    SR.unit, compile_exp_vanilla env ae e1 ^^ Cycles.add env
+  | SystemCyclesAcceptPrim, [e1] ->
+    SR.Vanilla, compile_exp_vanilla env ae e1 ^^ Cycles.accept env
+  | SystemCyclesAvailablePrim, [] ->
+    SR.Vanilla, Cycles.available env
+  | SystemCyclesRefundedPrim, [] ->
+    SR.Vanilla, Cycles.refunded env
+
+  | SetCertifiedData, [e1] ->
+    SR.unit, compile_exp_vanilla env ae e1 ^^ IC.set_certified_data env
+  | GetCertificate, [] ->
+    SR.Vanilla,
+    IC.get_certificate env
+
+  (* Unknown prim *)
+  | _ -> SR.Unreachable, todo_trap env "compile_prim_invocation" (Arrange_ir.prim p)
+  end
+
+(* Compile, infer and return stack representation *)
+and compile_exp (env : E.t) ae exp =
+  compile_exp_with_hint env ae None exp
+
+(* Compile to given stack representation *)
+and compile_exp_as env ae sr_out e =
+  let sr_in, code = compile_exp_with_hint env ae (Some sr_out) e in
+  code ^^ StackRep.adjust env sr_in sr_out
+
+and single_case e (cs : Ir.case list) =
+  match cs, e.note.Note.typ with
+  | [{it={pat={it=TagP (l, _);_}; _}; _}], Type.(Variant [{lab; _}]) -> l = lab
+  | _ -> false
+
+and known_tag_pat p = TagP ("", p)
+
+and simplify_cases e (cs : Ir.case list) =
+  match cs, e.note.Note.typ with
+  (* for a 2-cased variant type, the second comparison can be omitted when the first pattern
+     (with irrefutable subpattern) didn't match, and the pattern types line up *)
+  | [{it={pat={it=TagP (l1, ip); _}; _}; _} as c1; {it={pat={it=TagP (l2, pat'); _} as pat2; exp}; _} as c2], Type.(Variant [{lab=el1; _}; {lab=el2; _}])
+       when Ir_utils.is_irrefutable ip
+            && (l1 = el1 || l1 = el2)
+            && (l2 = el1 || l2 = el2) ->
+     [c1; {c2 with it = {exp; pat = {pat2 with it = known_tag_pat pat'}}}]
+  | _ -> cs
+
+(* Compile, infer and return stack representation, taking the hint into account *)
+and compile_exp_with_hint (env : E.t) ae sr_hint exp =
+  (fun (sr,code) -> (sr, G.with_region exp.at code)) @@
+  if exp.note.Note.const
+  then let (c, fill) = compile_const_exp env ae exp in fill env ae; (SR.Const c, G.nop)
+  else match exp.it with
+  | PrimE (p, es) when List.exists (fun e -> Type.is_non e.note.Note.typ) es ->
+    (* Handle dead code separately, so that we can rely on useful type
+       annotations below *)
+    SR.Unreachable,
+    G.concat_map (compile_exp_ignore env ae) es ^^
+    G.i Unreachable
+
+  | PrimE (p, es) ->
+    compile_prim_invocation (env : E.t) ae p es exp.at
+  | VarE (_, var) ->
+    Var.get_val env ae var
+  | AssignE (e1,e2) ->
+    SR.unit,
+    let (prepare_code, sr, store_code) = compile_lexp env ae e1 in
+    prepare_code ^^
+    compile_exp_as env ae sr e2 ^^
+    store_code
+  | LitE l ->
+    compile_lit l
+  | IfE (scrut, e1, e2) ->
+    let code_scrut = compile_exp_as_test env ae scrut in
+    let sr1, code1 = compile_exp_with_hint env ae sr_hint e1 in
+    let sr2, code2 = compile_exp_with_hint env ae sr_hint e2 in
+    (* Use the expected stackrep, if given, else infer from the branches *)
+    let sr = match sr_hint with
+      | Some sr -> sr
+      | None -> StackRep.join sr1 sr2
+    in
+    sr,
+    code_scrut ^^
+    FakeMultiVal.if_ env
+      (StackRep.to_block_type env sr)
+      (code1 ^^ StackRep.adjust env sr1 sr)
+      (code2 ^^ StackRep.adjust env sr2 sr)
+  | BlockE (decs, exp) ->
+    let captured = Freevars.captured_vars (Freevars.exp exp) in
+    let ae', codeW1 = compile_decs env ae decs captured in
+    let (sr, code2) = compile_exp_with_hint env ae' sr_hint exp in
+    (sr, codeW1 code2)
+  | LabelE (name, _ty, e) ->
+    (* The value here can come from many places -- the expression,
+       or any of the nested returns. Hard to tell which is the best
+       stack representation here.
+       So let’s go with Vanilla. *)
+    SR.Vanilla,
+    E.block_ env (StackRep.to_block_type env SR.Vanilla) (
+      G.with_current_depth (fun depth ->
+        let ae1 = VarEnv.add_label ae name depth in
+        compile_exp_vanilla env ae1 e
+      )
+    )
+  | LoopE e ->
+    SR.Unreachable,
+    let ae' = VarEnv.{ ae with lvl = NotTopLvl } in
+    G.loop0 (compile_exp_unit env ae' e ^^ G.i (Br (nr 0l))
+    )
+    ^^
+   G.i Unreachable
+
+  | SwitchE (e, cs) when single_case e cs ->
+    let code1 = compile_exp_vanilla env ae e in
+    let [@warning "-8"] [{it={pat={it=TagP (_, pat');_} as pat; exp}; _}] = cs in
+    let ae1, pat_code = compile_pat_local env ae {pat with it = known_tag_pat pat'} in
+    let sr, rhs_code = compile_exp_with_hint env ae1 sr_hint exp in
+
+    (* Use the expected stackrep, if given, else infer from the branches *)
+    let final_sr = match sr_hint with
+      | Some sr -> sr
+      | None -> sr
+    in
+
+    final_sr,
+    (* Run rest in block to exit from *)
+    FakeMultiVal.block_ env (StackRep.to_block_type env final_sr) (fun branch_code ->
+       orsPatternFailure env (List.map (fun (sr, c) ->
+          c ^^^ CannotFail (StackRep.adjust env sr final_sr ^^ branch_code)
+       ) [sr, CannotFail code1 ^^^ pat_code ^^^ CannotFail rhs_code]) ^^
+       G.i Unreachable (* We should always exit using the branch_code *)
+    )
+
+  | SwitchE (e, cs) ->
+    let code1 = compile_exp_vanilla env ae e in
+    let (set_i, get_i) = new_local env "switch_in" in
+
+    (* compile subexpressions and collect the provided stack reps *)
+    let codes = List.map (fun {it={pat; exp=e}; _} ->
+      let (ae1, pat_code) = compile_pat_local env ae pat in
+      let (sr, rhs_code) = compile_exp_with_hint env ae1 sr_hint e in
+      (sr, CannotFail get_i ^^^ pat_code ^^^ CannotFail rhs_code)
+      ) (simplify_cases e cs) in
+
+    (* Use the expected stackrep, if given, else infer from the branches *)
+    let final_sr = match sr_hint with
+      | Some sr -> sr
+      | None -> StackRep.joins (List.map fst codes)
+    in
+
+    final_sr,
+    (* Run scrut *)
+    code1 ^^ set_i ^^
+    (* Run rest in block to exit from *)
+    FakeMultiVal.block_ env (StackRep.to_block_type env final_sr) (fun branch_code ->
+       orsPatternFailure env (List.map (fun (sr, c) ->
+          c ^^^ CannotFail (StackRep.adjust env sr final_sr ^^ branch_code)
+       ) codes) ^^
+       G.i Unreachable (* We should always exit using the branch_code *)
+    )
+  (* Async-wait lowering support features *)
+  | DeclareE (name, typ, e) ->
+    let ae1, i = VarEnv.add_local_with_heap_ind env ae name typ in
+    let sr, code = compile_exp env ae1 e in
+    sr,
+    MutBox.alloc env ^^ G.i (LocalSet (nr i)) ^^
+    code
+  | DefineE (name, _, e) ->
+    SR.unit,
+    let pre_code, sr, code = Var.set_val env ae name in
+    pre_code ^^
+    compile_exp_as env ae sr e ^^
+    code
+  | FuncE (x, sort, control, typ_binds, args, res_tys, e) ->
+    let captured = Freevars.captured exp in
+    let return_tys = match control with
+      | Type.Returns -> res_tys
+      | Type.Replies -> []
+      | Type.Promises -> assert false in
+    let return_arity = List.length return_tys in
+    let mk_body env1 ae1 = compile_exp_as env1 ae1 (StackRep.of_arity return_arity) e in
+    FuncDec.lit env ae x sort control captured args mk_body return_tys exp.at
+  | SelfCallE (ts, exp_f, exp_k, exp_r, exp_c) ->
+    SR.unit,
+    let (set_future, get_future) = new_local env "future" in
+    let (set_k, get_k) = new_local env "k" in
+    let (set_r, get_r) = new_local env "r" in
+    let (set_c, get_c) = new_local env "c" in
+    let mk_body env1 ae1 = compile_exp_as env1 ae1 SR.unit exp_f in
+    let captured = Freevars.captured exp_f in
+    let add_cycles = Internals.add_cycles env ae in
+    FuncDec.async_body env ae ts captured mk_body exp.at ^^
+    Tagged.load_forwarding_pointer env ^^
+    set_future ^^
+
+    compile_exp_vanilla env ae exp_k ^^ set_k ^^
+    compile_exp_vanilla env ae exp_r ^^ set_r ^^
+    compile_exp_vanilla env ae exp_c ^^ set_c ^^
+
+    FuncDec.ic_self_call env ts
+      IC.(get_self_reference env ^^
+          actor_public_field env async_method_name)
+      get_future
+      get_k
+      get_r
+      get_c
+      add_cycles
+  | ActorE (ds, fs, _, _) ->
+    fatal "Local actors not supported by backend"
+  | NewObjE (Type.(Object | Module | Memory) as _sort, fs, _) ->
+    (*
+    We can enable this warning once we treat everything as static that
+    mo_frontend/static.ml accepts, including _all_ literals.
+    if sort = Type.Module then Printf.eprintf "%s" "Warning: Non-static module\n";
+    *)
+    SR.Vanilla,
+    let fs' = fs |> List.map
+      (fun (f : Ir.field) -> (f.it.name, fun () ->
+        if Type.is_mut f.note
+        then Var.get_aliased_box env ae f.it.var
+        else Var.get_val_vanilla env ae f.it.var)) in
+    Object.lit_raw env fs'
+  | _ -> SR.unit, todo_trap env "compile_exp" (Arrange_ir.exp exp)
+
+and compile_exp_ignore env ae e =
+  let sr, code = compile_exp env ae e in
+  code ^^ StackRep.drop env sr
+
+and compile_exp_as_opt env ae sr_out_o e =
+  let sr_in, code = compile_exp_with_hint env ae sr_out_o e in
+  G.with_region e.at (
+    code ^^
+    match sr_out_o with
+    | None -> StackRep.drop env sr_in
+    | Some sr_out -> StackRep.adjust env sr_in sr_out
+  )
+
+and compile_exp_vanilla (env : E.t) ae exp =
+  compile_exp_as env ae SR.Vanilla exp
+
+and compile_exp_unit (env : E.t) ae exp =
+  compile_exp_as env ae SR.unit exp
+
+(* compiles to something that works with IfE or Eqz
+   (SR.UnboxedWord64 or SR.Vanilla are _both_ ok)
+*)
+and compile_exp_as_test env ae e =
+  let sr, code = compile_exp env ae e in
+  code ^^
+  (if sr != SR.bool then StackRep.adjust env sr SR.Vanilla else G.nop)
+
+(* Compile a prim of type Char -> Char to a RTS call. *)
+and compile_char_to_char_rts env ae exp rts_fn =
+  SR.UnboxedWord64 Type.Char,
+  compile_exp_as env ae (SR.UnboxedWord64 Type.Char) exp ^^
+  TaggedSmallWord.lsb_adjust_codepoint env ^^
+  G.i (Convert (Wasm_exts.Values.I32 I32Op.WrapI64)) ^^
+  E.call_import env "rts" rts_fn ^^
+  G.i (Convert (Wasm_exts.Values.I64 I64Op.ExtendUI32)) ^^
+  TaggedSmallWord.msb_adjust_codepoint
+
+
+(* Compile a prim of type Char -> Bool to a RTS call. The RTS function should
+   have type int32_t -> int32_t where the return value is 0 for 'false' and 1
+   for 'true'. *)
+and compile_char_to_bool_rts (env : E.t) (ae : VarEnv.t) exp rts_fn =
+  SR.bool,
+  compile_exp_as env ae (SR.UnboxedWord64 Type.Char) exp ^^
+  TaggedSmallWord.lsb_adjust_codepoint env ^^
+  G.i (Convert (Wasm_exts.Values.I32 I32Op.WrapI64)) ^^
+  (* The RTS function returns Motoko True/False values (which are represented as
+     1 and 0, respectively) so we don't need any marshalling *)
+  E.call_import env "rts" rts_fn ^^
+  Bool.from_rts_int32
+
+(*
+The compilation of declarations (and patterns!) needs to handle mutual recursion.
+This requires conceptually three passes:
+ 1. First we need to collect all names bound in a block,
+    and find locations for then (which extends the environment).
+    The environment is extended monotonically: The type-checker ensures that
+    a Block does not bind the same name twice.
+    We would not need to pass in the environment, just out ... but because
+    it is bundled in the E.t type, threading it through is also easy.
+
+ 2. We need to allocate memory for them, and store the pointer in the
+    WebAssembly local, so that they can be captured by closures.
+
+ 3. We go through the declarations, generate the actual code and fill the
+    allocated memory.
+    This includes creating the actual closure references.
+
+We could do this in separate functions, but I chose to do it in one
+ * it means all code related to one constructor is in one place and
+ * when generating the actual code, we still “know” the id of the local that
+   has the memory location, and don’t have to look it up in the environment.
+
+The first phase works with the `pre_env` passed to `compile_dec`,
+while the third phase is a function that expects the final environment. This
+enabled mutual recursion.
+*)
+
+
+and compile_lit_pat env l =
+  match l with
+  | NullLit ->
+    Opt.is_null env
+  | BoolLit true ->
+    G.nop
+  | BoolLit false ->
+    compile_test I64Op.Eqz
+  | (NatLit _ | IntLit _) ->
+    compile_lit_as env SR.Vanilla l ^^
+    BigNum.compile_eq env
+  | Nat8Lit _ ->
+    compile_lit_as env SR.Vanilla l ^^
+    compile_eq env Type.(Prim Nat8)
+  | Nat16Lit _ ->
+    compile_lit_as env SR.Vanilla l ^^
+    compile_eq env Type.(Prim Nat16)
+  | Nat32Lit _ ->
+    compile_lit_as env SR.Vanilla l ^^
+    compile_eq env Type.(Prim Nat32)
+  | Nat64Lit _ ->
+    BoxedWord64.unbox env Type.Nat64 ^^
+    compile_lit_as env (SR.UnboxedWord64 Type.Nat64) l ^^
+    compile_eq env Type.(Prim Nat64)
+  | Int8Lit _ ->
+    compile_lit_as env SR.Vanilla l ^^
+    compile_eq env Type.(Prim Int8)
+  | Int16Lit _ ->
+    compile_lit_as env SR.Vanilla l ^^
+    compile_eq env Type.(Prim Int16)
+  | Int32Lit _ ->
+    compile_lit_as env SR.Vanilla l ^^
+    compile_eq env Type.(Prim Int32)
+  | Int64Lit _ ->
+    BoxedWord64.unbox env Type.Int64 ^^
+    compile_lit_as env (SR.UnboxedWord64 Type.Int64) l ^^
+    compile_eq env Type.(Prim Int64)
+  | CharLit _ ->
+    compile_lit_as env SR.Vanilla l ^^
+    compile_eq env Type.(Prim Char)
+  | TextLit t ->
+    compile_lit_as env SR.Vanilla l ^^
+    Text.compare env Operator.EqOp
+  | BlobLit t ->
+    compile_lit_as env SR.Vanilla l ^^
+    Blob.compare env (Some Operator.EqOp)
+  | FloatLit _ ->
+    todo_trap env "compile_lit_pat" (Arrange_ir.lit l)
+
+and fill_pat env ae pat : patternCode =
+  PatCode.with_region pat.at @@
+  match pat.it with
+  | _ when Ir_utils.is_irrefutable_nonbinding pat -> CannotFail (G.i Drop)
+  | WildP -> assert false (* matched above *)
+  | OptP p when Ir_utils.is_irrefutable_nonbinding p ->
+      CanFail (fun fail_code ->
+        Opt.is_some env ^^
+        E.if0 G.nop fail_code)
+  | OptP p ->
+      let (set_x, get_x) = new_local env "opt_scrut" in
+      CanFail (fun fail_code ->
+        set_x ^^
+        get_x ^^
+        Opt.is_some env ^^
+        E.if0
+          ( get_x ^^
+            Opt.project env ^^
+            with_fail fail_code (fill_pat env ae p)
+          )
+          fail_code
+      )
+  | TagP ("", p) -> (* these only come from known_tag_pat *)
+    if Ir_utils.is_irrefutable_nonbinding p
+    then CannotFail (G.i Drop)
+    else CannotFail (Variant.project env) ^^^ fill_pat env ae p
+  | TagP (l, p) when Ir_utils.is_irrefutable_nonbinding p ->
+      CanFail (fun fail_code ->
+        Variant.test_is env l ^^
+        E.if0 G.nop fail_code)
+  | TagP (l, p) ->
+      let (set_x, get_x) = new_local env "tag_scrut" in
+      CanFail (fun fail_code ->
+        set_x ^^
+        get_x ^^
+        Variant.test_is env l ^^
+        E.if0
+          ( get_x ^^
+            Variant.project env ^^
+            with_fail fail_code (fill_pat env ae p)
+          )
+          fail_code
+      )
+  | LitP l ->
+      CanFail (fun fail_code ->
+        compile_lit_pat env l ^^
+        E.if0 G.nop fail_code)
+  | VarP name ->
+      CannotFail (Var.set_val_vanilla_from_stack env ae name)
+  | TupP ps ->
+      let (set_i, get_i) = new_local env "tup_scrut" in
+      let rec go i = function
+        | [] -> CannotFail G.nop
+        | p::ps ->
+          let code1 = fill_pat env ae p in
+          let code2 = go (Int64.add i 1L) ps in
+          CannotFail (get_i ^^ Tuple.load_n env i) ^^^ code1 ^^^ code2 in
+      CannotFail set_i ^^^ go 0L ps
+  | ObjP pfs ->
+      let project = compile_load_field env pat.note in
+      let (set_i, get_i) = new_local env "obj_scrut" in
+      let rec go = function
+        | [] -> CannotFail G.nop
+        | {it={name; pat}; _}::pfs' ->
+          let code1 = fill_pat env ae pat in
+          let code2 = go pfs' in
+          CannotFail (get_i ^^ project name) ^^^ code1 ^^^ code2 in
+      CannotFail set_i ^^^ go pfs
+  | AltP (p1, p2) ->
+      let code1 = fill_pat env ae p1 in
+      let code2 = fill_pat env ae p2 in
+      let (set_i, get_i) = new_local env "alt_scrut" in
+      CannotFail set_i ^^^
+      orElse (CannotFail get_i ^^^ code1)
+             (CannotFail get_i ^^^ code2)
+
+and alloc_pat_local env ae pat =
+  let d = Freevars.pat pat in
+  AllocHow.M.fold (fun v typ ae ->
+    let (ae1, _i) = VarEnv.add_direct_local env ae v SR.Vanilla typ
+    in ae1
+  ) d ae
+
+and alloc_pat env ae how pat : VarEnv.t * G.t  =
+  (fun (ae, code) -> (ae, G.with_region pat.at code)) @@
+  let d = Freevars.pat pat in
+  AllocHow.M.fold (fun v typ (ae, code0) ->
+    let ae1, code1 = AllocHow.add_local env ae how v typ
+    in (ae1, code0 ^^ code1)
+  ) d (ae, G.nop)
+
+and compile_pat_local env ae pat : VarEnv.t * patternCode =
+  (* It returns:
+     - the extended environment
+     - the patternCode to do the pattern matching.
+       This expects the  undestructed value is on top of the stack,
+       consumes it, and fills the heap.
+       If the pattern matches, execution continues (with nothing on the stack).
+       If the pattern does not match, it fails (in the sense of PatCode.CanFail)
+  *)
+  let ae1 = alloc_pat_local env ae pat in
+  let fill_code = fill_pat env ae1 pat in
+  (ae1, fill_code)
+
+(* Used for let patterns:
+   If the pattern can consume its scrutinee in a better form than vanilla (e.g.
+   unboxed tuple, unboxed 32/64), lets do that.
+*)
+and compile_unboxed_pat env ae how pat
+  : VarEnv.t * G.t * G.t * SR.t option * G.t =
+  (* It returns:
+     - the extended environment
+     - the code to allocate memory
+     - the code to prepare the stack (e.g. push destination addresses)
+       before the scrutinee is pushed
+     - the desired stack rep. None means: Do not even push the scrutinee.
+     - the code to do the pattern matching.
+       This expects the undestructed value is on top of the stack,
+       consumes it, and fills the heap
+       If the pattern does not match, it traps with pattern failure
+  *)
+  let (ae1, alloc_code) = alloc_pat env ae how pat in
+  let pre_code, sr, fill_code = match pat.it with
+    (* Nothing to match: Do not even put something on the stack *)
+    | WildP -> G.nop, None, G.nop
+    (* Tuple patterns *)
+    | TupP ps when List.length ps <> 1 ->
+      G.nop,
+      Some (SR.UnboxedTuple (List.length ps)),
+      (* We have to fill the pattern in reverse order, to take things off the
+         stack. This is only ok as long as patterns have no side effects.
+      *)
+      G.concat_mapi (fun i p -> orPatternFailure env (fill_pat env ae1 p)) (List.rev ps)
+    (* Variable patterns *)
+    | VarP name ->
+      let pre_code, sr, code = Var.set_val env ae1 name in
+      pre_code, Some sr, code
+    (* The general case: Create a single value, match that. *)
+    | _ ->
+      G.nop,
+      Some SR.Vanilla,
+      orPatternFailure env (fill_pat env ae1 pat) in
+  let pre_code = G.with_region pat.at pre_code in
+  let fill_code = G.with_region pat.at fill_code in
+  (ae1, alloc_code, pre_code, sr, fill_code)
+
+and compile_dec env pre_ae how v2en dec : VarEnv.t * G.t * (VarEnv.t -> scope_wrap) =
+  (fun (pre_ae, alloc_code, mk_code, wrap) ->
+       G.(pre_ae, with_region dec.at alloc_code, fun ae body_code ->
+          with_region dec.at (mk_code ae) ^^ wrap body_code)) @@
+
+  match dec.it with
+  (* A special case for public methods *)
+  (* This relies on the fact that in the top-level mutually recursive group, no shadowing happens. *)
+  | LetD ({it = VarP v; _}, e) when E.NameEnv.mem v v2en ->
+    let (const, fill) = compile_const_exp env pre_ae e in
+    let fi = match const with
+      | Const.Message fi -> fi
+      | _ -> assert false in
+    let pre_ae1 = VarEnv.add_local_public_method pre_ae v (fi, (E.NameEnv.find v v2en)) e.note.Note.typ in
+    G.( pre_ae1, nop, (fun ae -> fill env ae; nop), unmodified)
+
+  (* A special case for constant expressions *)
+  | LetD (p, e) when e.note.Note.const ->
+    (* constant expression matching with patterns is fully decidable *)
+    if const_exp_matches_pat env pre_ae p e then (* not refuted *)
+      let extend, fill = compile_const_dec env pre_ae dec in
+      G.(extend pre_ae, nop, (fun ae -> fill env ae; nop), unmodified)
+    else (* refuted *)
+      (pre_ae, G.nop, (fun _ -> PatCode.patternFailTrap env), unmodified)
+
+  | LetD (p, e) ->
+    let (pre_ae1, alloc_code, pre_code, sr, fill_code) = compile_unboxed_pat env pre_ae how p in
+    ( pre_ae1, alloc_code,
+      (fun ae -> pre_code ^^ compile_exp_as_opt env ae sr e ^^ fill_code),
+      unmodified
+    )
+
+  | VarD (name, content_typ, e) ->
+    assert AllocHow.(match M.find_opt name how with
+                     | Some (LocalMut _ | StoreHeap | StoreStatic) -> true
+                     | _ -> false);
+    let var_typ = Type.Mut content_typ in
+    let pre_ae1, alloc_code = AllocHow.add_local env pre_ae how name var_typ in
+    ( pre_ae1,
+      alloc_code,
+      (fun ae -> let pre_code, sr, code = Var.set_val env ae name in
+                 pre_code ^^ compile_exp_as env ae sr e ^^ code),
+      unmodified
+    )
+
+  | RefD (name, typ, { it = DotLE (e, n); _ }) ->
+    let pre_ae1, alloc_code = AllocHow.add_local_for_alias env pre_ae how name typ in
+
+    ( pre_ae1,
+      alloc_code,
+      (fun ae ->
+        compile_exp_vanilla env ae e ^^
+        Object.load_idx_raw env n ^^
+        Var.capture_aliased_box env ae name),
+      unmodified
+    )
+  | RefD _ -> assert false
+
+and compile_decs_public env pre_ae decs v2en captured_in_body : VarEnv.t * scope_wrap =
+  let how = AllocHow.decs pre_ae decs captured_in_body in
+  let rec go pre_ae = function
+    | []        -> (pre_ae, G.nop, fun _ -> unmodified)
+    | [dec]     -> compile_dec env pre_ae how v2en dec
+    | dec::decs ->
+        let (pre_ae1, alloc_code1, mk_codeW1) = compile_dec env pre_ae how v2en dec in
+        let (pre_ae2, alloc_code2, mk_codeW2) = go              pre_ae1 decs in
+        ( pre_ae2,
+          alloc_code1 ^^ alloc_code2,
+          fun ae -> let codeW1 = mk_codeW1 ae in
+                    let codeW2 = mk_codeW2 ae in
+                    fun body_code -> codeW1 (codeW2 body_code)
+        ) in
+  let (ae1, alloc_code, mk_codeW) = go pre_ae decs in
+  (ae1, fun body_code -> alloc_code ^^ mk_codeW ae1 body_code)
+
+and compile_decs env ae decs captured_in_body : VarEnv.t * scope_wrap =
+  compile_decs_public env ae decs E.NameEnv.empty captured_in_body
+
+(* This compiles expressions determined to be const as per the analysis in
+   ir_passes/const.ml. See there for more details.
+*)
+and compile_const_exp env pre_ae exp : Const.v * (E.t -> VarEnv.t -> unit) =
+  match exp.it with
+  | FuncE (name, sort, control, typ_binds, args, res_tys, e) ->
+    let fun_rhs =
+
+      (* a few prims cannot be safely inlined *)
+      let inlineable_prim = function
+      | RetPrim -> false
+      | BreakPrim _ -> false
+      | ThrowPrim -> fatal "internal error: left-over ThrowPrim"
+      | _ -> true in
+
+      match sort, control, typ_binds, e.it with
+      (* Special cases for prim-wrapping functions *)
+
+      | Type.Local, Type.Returns, [], PrimE (prim, prim_args) when
+          inlineable_prim prim &&
+          List.length args = List.length prim_args &&
+          List.for_all2 (fun p a -> a.it = VarE (Const, p.it)) args prim_args ->
+        Const.PrimWrapper prim
+      | _, _, _, _ -> Const.Complicated
+    in
+    let return_tys = match control with
+      | Type.Returns -> res_tys
+      | Type.Replies -> []
+      | Type.Promises -> assert false in
+    let mk_body env ae =
+      List.iter (fun v ->
+        if not (VarEnv.NameEnv.mem v ae.VarEnv.vars)
+        then fatal "internal error: const \"%s\": captures \"%s\", not found in static environment\n" name v
+      ) (Freevars.M.keys (Freevars.exp e));
+      compile_exp_as env ae (StackRep.of_arity (List.length return_tys)) e in
+    FuncDec.closed env sort control name args mk_body fun_rhs return_tys exp.at
+  | BlockE (decs, e) ->
+    let (extend, fill1) = compile_const_decs env pre_ae decs in
+    let ae' = extend pre_ae in
+    let (c, fill2) = compile_const_exp env ae' e in
+    (c, fun env ae ->
+      let ae' = extend ae in
+      fill1 env ae';
+      fill2 env ae')
+  | VarE (_, v) ->
+    let c =
+      match VarEnv.lookup_var pre_ae v with
+      | Some (VarEnv.Const c) -> c
+      | _ -> fatal "compile_const_exp/VarE: \"%s\" not found" v
+    in
+    (c, fun _ _ -> ())
+  | NewObjE (Type.(Object | Module | Memory), fs, _) ->
+    let static_fs = List.map (fun f ->
+          let st =
+            match VarEnv.lookup_var pre_ae f.it.var with
+            | Some (VarEnv.Const c) -> c
+            | _ -> fatal "compile_const_exp/ObjE: \"%s\" not found" f.it.var
+          in f.it.name, st) fs
+    in
+    (Const.Obj static_fs), fun _ _ -> ()
+  | PrimE (DotPrim name, [e]) ->
+    let (object_ct, fill) = compile_const_exp env pre_ae e in
+    let fs = match object_ct with
+      | Const.Obj fs -> fs
+      | _ -> fatal "compile_const_exp/DotE: not a static object" in
+    let member_ct = List.assoc name fs in
+    (member_ct, fill)
+  | PrimE (ProjPrim i, [e]) ->
+    let (object_ct, fill) = compile_const_exp env pre_ae e in
+    let cs = match object_ct with
+      | Const.Tuple cs -> cs
+      | _ -> fatal "compile_const_exp/ProjE: not a static tuple" in
+    (List.nth cs i, fill)
+  | LitE l -> Const.(Lit (const_lit_of_lit l)), (fun _ _ -> ())
+  | PrimE (TupPrim, []) -> Const.Unit, (fun _ _ -> ())
+  | PrimE (ArrayPrim (Const, _), es) ->
+    let (cs, fills) = List.split (List.map (compile_const_exp env pre_ae) es) in
+    (Const.Array cs),
+    (fun env ae -> List.iter (fun fill -> fill env ae) fills)
+  | PrimE (TupPrim, es) ->
+    let (cs, fills) = List.split (List.map (compile_const_exp env pre_ae) es) in
+    (Const.Tuple cs),
+    (fun env ae -> List.iter (fun fill -> fill env ae) fills)
+  | PrimE (TagPrim i, [e]) ->
+    let (arg_ct, fill) = compile_const_exp env pre_ae e in
+    (Const.Tag (i, arg_ct)),
+    fill
+  | PrimE (OptPrim, [e]) ->
+    let (arg_ct, fill) = compile_const_exp env pre_ae e in
+    (Const.Opt arg_ct),
+    fill
+
+  | _ -> assert false
+
+and compile_const_decs env pre_ae decs : (VarEnv.t -> VarEnv.t) * (E.t -> VarEnv.t -> unit) =
+  let rec go pre_ae = function
+    | []          -> (fun ae -> ae), (fun _ _ -> ())
+    | [dec]       -> compile_const_dec env pre_ae dec
+    | (dec::decs) ->
+        let (extend1, fill1) = compile_const_dec env pre_ae dec in
+        let pre_ae1 = extend1 pre_ae in
+        let (extend2, fill2) = go                    pre_ae1 decs in
+        (fun ae -> extend2 (extend1 ae)),
+        (fun env ae -> fill1 env ae; fill2 env ae) in
+  go pre_ae decs
+
+and const_exp_matches_pat env ae pat exp : bool =
+  assert exp.note.Note.const;
+  let c, _ = compile_const_exp env ae exp in
+  match destruct_const_pat VarEnv.empty_ae pat c with Some _ -> true | _ -> false
+
+and destruct_const_pat ae pat const : VarEnv.t option = match pat.it with
+  | WildP -> Some ae
+  | VarP v -> Some (VarEnv.add_local_const ae v const pat.note)
+  | ObjP pfs ->
+    let fs = match const with Const.Obj fs -> fs | _ -> assert false in
+    List.fold_left (fun ae (pf : pat_field) ->
+      match ae, List.find_opt (fun (n, _) -> pf.it.name = n) fs with
+      | None, _ -> None
+      | Some ae, Some (_, c) -> destruct_const_pat ae pf.it.pat c
+      | _, None -> assert false
+    ) (Some ae) pfs
+  | AltP (p1, p2) ->
+    let l = destruct_const_pat ae p1 const in
+    if l = None then destruct_const_pat ae p2 const
+    else l
+  | TupP ps ->
+    let cs = match const with Const.Tuple cs -> cs | Const.Unit -> [] | _ -> assert false in
+    let go ae p c = match ae with
+      | Some ae -> destruct_const_pat ae p c
+      | _ -> None in
+    List.fold_left2 go (Some ae) ps cs
+  | LitP lp ->
+    begin match const with
+    | Const.Lit lc when Const.lit_eq (const_lit_of_lit lp) lc -> Some ae
+    | _ -> None
+    end
+  | OptP p ->
+    begin match const with
+      | Const.Opt c -> destruct_const_pat ae p c
+      | Const.(Lit Null) -> None
+      | _ -> assert false
+    end
+  | TagP (i, p) ->
+     match const with
+     | Const.Tag (ic, c) when i = ic -> destruct_const_pat ae p c
+     | Const.Tag _ -> None
+     | _ -> assert false
+
+and compile_const_dec env pre_ae dec : (VarEnv.t -> VarEnv.t) * (E.t -> VarEnv.t -> unit) =
+  (* This returns a _function_ to extend the VarEnv, instead of doing it, because
+  it needs to be extended twice: Once during the pass that gets the outer, static values
+  (no forward references), and then to implement the `fill`, which compiles the bodies
+  of functions (may contain forward references.) *)
+  match dec.it with
+  (* This should only contain constants (cf. is_const_exp) *)
+  | LetD (p, e) ->
+    let (const, fill) = compile_const_exp env pre_ae e in
+    (fun ae -> match destruct_const_pat ae p const with Some ae -> ae | _ -> assert false),
+    (fun env ae -> fill env ae)
+  | VarD _ | RefD _ -> fatal "compile_const_dec: Unexpected VarD/RefD"
+
+and compile_init_func mod_env ((cu, flavor) : Ir.prog) =
+  assert (not flavor.has_typ_field);
+  assert (not flavor.has_poly_eq);
+  assert (not flavor.has_show);
+  assert (not flavor.has_await);
+  assert (not flavor.has_async_typ);
+  match cu with
+  | LibU _ -> fatal "compile_start_func: Cannot compile library"
+  | ProgU ds ->
+    Func.define_built_in mod_env "init" [] [] (fun env ->
+      let _ae, codeW = compile_decs env VarEnv.empty_ae ds Freevars.S.empty in
+      codeW G.nop
+    )
+  | ActorU (as_opt, ds, fs, up, t) ->
+    main_actor as_opt mod_env ds fs up
+
+and export_actor_field env  ae (f : Ir.field) =
+  (* A public actor field is guaranteed to be compiled as a PublicMethod *)
+  let fi =
+    match VarEnv.lookup_var ae f.it.var with
+    | Some (VarEnv.PublicMethod (fi, _)) -> fi
+    | _ -> assert false in
+
+  E.add_export env (nr {
+    name = Lib.Utf8.decode (match E.mode env with
+      | Flags.ICMode | Flags.RefMode ->
+        Mo_types.Type.(
+        match normalize f.note with
+        |  Func(Shared sort,_,_,_,_) ->
+           (match sort with
+            | Write -> "canister_update " ^ f.it.name
+            | Query -> "canister_query " ^ f.it.name
+            | Composite -> "canister_composite_query " ^ f.it.name
+           )
+        | _ -> assert false)
+      | _ -> assert false);
+    edesc = nr (FuncExport (nr fi))
+  })
+
+(* Main actor *)
+and main_actor as_opt mod_env ds fs up =
+  let stable_actor_type = up.stable_type in
+  let build_stable_actor = up.stable_record in
+  IncrementalGraphStabilization.define_methods mod_env stable_actor_type;
+
+  (* Export metadata *)
+  mod_env.E.stable_types := metadata "motoko:stable-types" up.meta.sig_;
+  mod_env.E.service := metadata "candid:service" up.meta.candid.service;
+  mod_env.E.args := metadata "candid:args" up.meta.candid.args;
+
+  Func.define_built_in mod_env IC.initialize_main_actor_function_name [] [] (fun env ->
+    let ae0 = VarEnv.empty_ae in
+    let captured = Freevars.captured_vars (Freevars.actor ds fs up) in
+    (* Add any params to the environment *)
+    (* Captured ones need to go into static memory, the rest into locals *)
+    let args = match as_opt with None -> [] | Some as_ -> as_ in
+    let arg_list = List.map (fun a -> (a.it, a.note)) args in
+    let arg_names = List.map (fun a -> a.it) args in
+    let arg_tys = List.map (fun a -> a.note) args in
+    let as_local n = not (Freevars.S.mem n captured) in
+    let ae1 = VarEnv.add_arguments env ae0 as_local arg_list in
+
+    (* Reverse the fs, to a map from variable to exported name *)
+    let v2en = E.NameEnv.from_list (List.map (fun f -> (f.it.var, f.it.name)) fs) in
+
+    (* Compile the declarations *)
+    let ae2, decls_codeW = compile_decs_public env ae1 ds v2en
+      Freevars.(captured_vars (system up))
+    in
+
+    (* Export the public functions *)
+    List.iter (export_actor_field env ae2) fs;
+
+    (* Export upgrade hooks *)
+    Func.define_built_in env "pre_exp" [] [] (fun env ->
+      compile_exp_as env ae2 SR.unit up.preupgrade);
+    Func.define_built_in env "post_exp" [] [] (fun env ->
+      compile_exp_as env ae2 SR.unit up.postupgrade);
+    IC.export_upgrade_methods env;
+
+    (* Export heartbeat (but only when required) *)
+    begin match up.heartbeat.it with
+     | Ir.PrimE (Ir.TupPrim, []) -> ()
+     | _ ->
+       Func.define_built_in env "heartbeat_exp" [] [] (fun env ->
+         compile_exp_as env ae2 SR.unit up.heartbeat);
+       IC.export_heartbeat env;
+    end;
+
+    (* Export timer (but only when required) *)
+    begin match up.timer.it with
+     | Ir.PrimE (Ir.TupPrim, []) -> ()
+     | _ ->
+       Func.define_built_in env "timer_exp" [] [] (fun env ->
+         compile_exp_as env ae2 SR.unit up.timer);
+       IC.export_timer env;
+    end;
+
+    (* Export inspect (but only when required) *)
+    begin match up.inspect.it with
+     | Ir.PrimE (Ir.TupPrim, []) -> ()
+     | _ ->
+       Func.define_built_in env "inspect_exp" [] [] (fun env ->
+         compile_exp_as env ae2 SR.unit up.inspect);
+       IC.export_inspect env;
+    end;
+
+    (* Helper function to build the stable actor wrapper *)
+    Func.define_built_in mod_env IC.get_actor_to_persist_function_name [] [I64Type] (fun env ->
+      compile_exp_as env ae2 SR.Vanilla build_stable_actor
+    );
+
+    (* Deserialize the init arguments *)
+    begin match as_opt with
+      | None
+      | Some [] ->
+        (* Liberally accept empty as well as unit argument *)
+        assert (arg_tys = []);
+        Persistence.get_init_message_payload env ^^
+        Blob.len env ^^
+        compile_eq_const 0L ^^
+        E.if0
+          G.nop
+          begin
+            (* Only validate the message payload. *)
+            Persistence.get_init_message_payload env ^^
+            Bool.lit false ^^ (* cannot recover *)
+            Serialization.deserialize_from_blob false env arg_tys
+          end
+      | Some (_ :: _) ->
+        Persistence.get_init_message_payload env ^^
+        Bool.lit false ^^ (* cannot recover *)
+        Serialization.deserialize_from_blob false env arg_tys ^^
+        G.concat_map (Var.set_val_vanilla_from_stack env ae1) (List.rev arg_names)
+    end ^^
+    begin
+      if up.timer.at <> no_region then
+        (* initiate a timer pulse *)
+        compile_unboxed_const 1L ^^
+        IC.system_call env "global_timer_set" ^^
+        G.i Drop
+      else
+        G.nop
+    end ^^
+
+    decls_codeW G.nop
+  );
+
+  Func.define_built_in mod_env "init" [] [] (fun env ->
+    IC.init_globals env ^^
+    (* Save the init message payload for later deserializtion. *)
+    IC.arg_data env ^^
+    Persistence.set_init_message_payload env ^^
+    Persistence.initialize env stable_actor_type
+  )
+
+and metadata name value =
+  if List.mem name !Flags.omit_metadata_names then None
+  else Some (
+           List.mem name !Flags.public_metadata_names,
+           value)
+
+and conclude_module env set_serialization_globals start_fi_o =
+
+  RTS_Exports.system_exports env;
+
+  FuncDec.export_async_method env;
+  FuncDec.export_gc_trigger_method env;
+  FuncDec.export_stabilization_limits env;
+  
+  (* See Note [Candid subtype checks] *)
+  Serialization.create_global_type_descriptor env set_serialization_globals;
+
+  (* declare before building GC *)
+
+  (* add beginning-of-heap pointer, may be changed by linker *)
+  (* needs to happen here now that we know the size of static memory *)
+  let set_heap_base = E.add_global64_delayed env "__heap_base" Immutable in
+  E.export_global env "__heap_base";
+
+  Heap.register env;
+  IC.register env;
+
+  let dynamic_heap_start = Lifecycle.end_ () in
+  set_heap_base dynamic_heap_start;
+
+  (* Wrap the start function with the RTS initialization *)
+  let rts_start_fi = E.add_fun env "rts_start" (Func.of_body env [] [] (fun env1 ->
+    E.call_import env "rts" ("initialize_incremental_gc") ^^
+    GCRoots.register_static_variables env ^^
+    match start_fi_o with
+    | Some fi ->
+      G.i (Call fi)
+    | None ->
+      Lifecycle.set env Lifecycle.PreInit
+  )) in
+
+  IC.default_exports env;
+
+  let func_imports = E.get_func_imports env in
+  let ni = List.length func_imports in
+  let ni' = Int32.of_int ni in
+
+  let other_imports = E.get_other_imports env in
+
+  let initial_memory_pages = Int64.(add (div dynamic_heap_start page_size) 1L) in
+  let memories = E.get_memories env initial_memory_pages in
+
+  let funcs = E.get_funcs env in
+
+  let datas = List.map (fun (dinit) -> nr {
+    dinit;
+    dmode = (nr Wasm_exts.Ast.Passive);
+    }) (E.get_data_segments env) in
+
+  let elems = List.map (fun (fi, fp) -> nr {
+    index = nr 0l;
+    offset = nr (G.to_instr_list (compile_const_32 fp));
+    init = [ nr fi ];
+    }) (E.get_elems env) in
+
+  let table_sz = E.get_end_of_table env in
+
+  let module_ = {
+      types = List.map nr (E.get_types env);
+      funcs = List.map (fun (f,_,_) -> f) funcs;
+      tables = [ nr { ttype = TableType ({min = table_sz; max = Some table_sz}, FuncRefType) } ];
+      elems;
+      start = Some (nr rts_start_fi);
+      globals = E.get_globals env;
+      memories;
+      imports = func_imports @ other_imports;
+      exports = E.get_exports env;
+      datas
+    } in
+
+  let emodule =
+    let open Wasm_exts.CustomModule in
+    { module_;
+      dylink = None;
+      name = { empty_name_section with function_names =
+                 List.mapi (fun i (f,n,_) -> Int32.(add ni' (of_int i), n)) funcs;
+               locals_names =
+                 List.mapi (fun i (f,_,ln) -> Int32.(add ni' (of_int i), ln)) funcs; };
+      motoko = {
+        labels = E.get_labs env;
+        stable_types = !(env.E.stable_types);
+        compiler = metadata "motoko:compiler" (Lib.Option.get Source_id.release Source_id.id);
+      };
+      enhanced_orthogonal_persistence = Some (false, "64-bit, layout version 1");
+      candid = {
+        args = !(env.E.args);
+        service = !(env.E.service);
+      };
+      source_mapping_url = None;
+      wasm_features = E.get_features env;
+    } in
+
+  match E.get_rts env with
+  | None -> emodule
+  | Some rts -> Linking.LinkModule.link emodule "rts" rts
+
+let compile mode rts (prog : Ir.prog) : Wasm_exts.CustomModule.extended_module =
+  (* Enhanced orthogonal persistence requires a fixed layout. *)
+  assert !Flags.rtti; (* Use precise tagging for graph copy. *)
+  assert (!Flags.gc_strategy = Flags.Incremental); (* Define heap layout with the incremental GC. *)
+  let env = E.mk_global mode rts IC.trap_with in
+
+  IC.register_globals env;
+  Stack.register_globals env;
+  GC.register_globals env;
+  StableMem.register_globals env;
+  Serialization.Registers.register_globals env;
+  Serialization.Registers.define_idl_limit_check env;
+  IncrementalGraphStabilization.register_globals env;
+  Persistence.register_globals env;
+  
+  (* See Note [Candid subtype checks] *)
+  let set_serialization_globals = Serialization.register_delayed_globals env in
+  Serialization.reserve_global_type_descriptor env;
+  
+  IC.system_imports env;
+  RTS.system_imports env;
+
+  compile_init_func env prog;
+  let start_fi_o = match E.mode env with
+    | Flags.ICMode | Flags.RefMode ->
+      IC.export_init env;
+      None
+    | Flags.WASIMode ->
+      IC.export_wasi_start env;
+      None
+    | Flags.WasmMode ->
+      Some (nr (E.built_in env "init"))
+  in
+
+  conclude_module env set_serialization_globals start_fi_o
diff --git a/src/codegen/compile_enhanced.mli b/src/codegen/compile_enhanced.mli
new file mode 100644
index 00000000000..165bd4d8061
--- /dev/null
+++ b/src/codegen/compile_enhanced.mli
@@ -0,0 +1,3 @@
+open Ir_def
+
+val compile : Mo_config.Flags.compile_mode -> Wasm_exts.CustomModule.extended_module option -> Ir.prog -> Wasm_exts.CustomModule.extended_module
diff --git a/src/codegen/die.ml b/src/codegen/die.ml
index 48f1bff083b..d52a2005c88 100644
--- a/src/codegen/die.ml
+++ b/src/codegen/die.ml
@@ -219,10 +219,10 @@ and prim_type_ref (prim : Type.prim) : die list * int =
           (dw_attrs [name; Bit_size 29; Data_bit_offset 8; Encoding dw_ATE_UTF])
       | Type.(Int | Nat) ->
         with_referencable_tags add dw_TAG_base_type
-          (dw_attrs [name; Bit_size 32; Data_bit_offset 0(*FIXME: for now*); Encoding dw_ATE_signed])
+          (dw_attrs [name; Bit_size 64; Data_bit_offset 0(*FIXME: for now*); Encoding dw_ATE_signed])
       | Type.Text -> (* FIXME: should be dynamic, like Any *)
         with_referencable_tags add dw_TAG_base_type
-          (dw_attrs [name; Bit_size 32; Data_bit_offset 0(*FIXME: for now*); Encoding dw_ATE_UTF])
+          (dw_attrs [name; Bit_size 64; Data_bit_offset 0(*FIXME: for now*); Encoding dw_ATE_UTF])
       | Type.(Int8|Int16|Int32) ->
         with_referencable_tags add dw_TAG_base_type
           (dw_attrs [name; Bit_size 32; Data_bit_offset 0(*FIXME: for now*); Encoding dw_ATE_signed])
diff --git a/src/codegen/instrList.ml b/src/codegen/instrList.ml
index fbfd0d35edc..886a103cdd1 100644
--- a/src/codegen/instrList.ml
+++ b/src/codegen/instrList.ml
@@ -9,7 +9,7 @@ features are
 
 open Wasm_exts.Ast
 open Wasm.Source
-open Wasm.Values
+open Wasm_exts.Values
 
 let combine_shifts const op = function
   | I32 opl, ({it = I32 l'; _} as cl), I32 opr, I32 r' when opl = opr ->
@@ -17,6 +17,11 @@ let combine_shifts const op = function
     if (l >= 0 && l < 32 && r >= 0 && r < 32 && l + r < 32) then
       Some [{const with it = Const {cl with it = I32 (Int32.add l' r')}}; {op with it = Binary (I32 opl)}]
     else None
+  | I64 opl, ({it = I64 l'; _} as cl), I64 opr, I64 r' when opl = opr ->
+    let l, r = Int64.(to_int l', to_int r') in
+    if (l >= 0 && l < 64 && r >= 0 && r < 64 && l + r < 64) then
+      Some [{const with it = Const {cl with it = I64 (Int64.add l' r')}}; {op with it = Binary (I64 opl)}]
+    else None
   | _ -> None
 
 (* Some simple peephole optimizations, to make the output code look less stupid *)
@@ -91,6 +96,8 @@ let optimize : instr list -> instr list = fun is ->
     (* LSBit masking before `If` is `Ctz` and switched `If` legs *)
     | ({ it = Binary (I32 I32Op.And); _} as a) :: { it = Const {it = I32 1l; _}; _} :: l', ({it = If (res,then_,else_); _} as i) :: r' ->
       go ({a with it = Unary (I32 I32Op.Ctz)} :: l') ({i with it = If (res,else_,then_)} :: r')
+    | ({ it = Binary (I64 I64Op.And); _} as a) :: { it = Const {it = I64 1L; _}; _} :: l', ({it = If (res,then_,else_); _} as i) :: r' ->
+      go ({a with it = Unary (I64 I64Op.Ctz)} :: l') ({i with it = If (res,else_,then_)} :: r')
     (* `If` blocks after pushed constants are simplifiable *)
     | { it = Const {it = I32 0l; _}; _} :: l', ({it = If (res,_,else_); _} as i) :: r' ->
       go l' ({i with it = Block (res, else_)} :: r')
@@ -114,9 +121,33 @@ let optimize : instr list -> instr list = fun is ->
       ({it = Const cr; _} as const) :: ({it = Binary opr; _} as op) :: r'
         when Option.is_some (combine_shifts const op (opl, cl, opr, cr.it)) ->
       go l' (Option.get (combine_shifts const op (opl, cl, opr, cr.it)) @ r')
+    | {it = Binary (I64 I64Op.(Shl|ShrS|ShrU) as opl); _} :: {it = Const cl; _} :: l',
+      ({it = Const cr; _} as const) :: ({it = Binary opr; _} as op) :: r'
+        when Option.is_some (combine_shifts const op (opl, cl, opr, cr.it)) ->
+      go l' (Option.get (combine_shifts const op (opl, cl, opr, cr.it)) @ r')
     (* Null shifts can be eliminated *)
     | l', {it = Const {it = I32 0l; _}; _} :: {it = Binary (I32 I32Op.(Shl|ShrS|ShrU)); _} :: r' ->
       go l' r'
+    | l', {it = Const {it = I64 0L; _}; _} :: {it = Binary (I64 I64Op.(Shl|ShrS|ShrU)); _} :: r' ->
+      go l' r'
+    (* Widen followed by narrow is pointless - but not the opposite! *)
+    | {it = Convert (I64 I64Op.(ExtendSI32 | ExtendUI32)); _} :: l', {it = Convert (I32 I32Op.WrapI64); _} :: r' -> 
+      go l' r'
+    (* Constant bitwise `and` evaluation *)
+    | l', {it = Const {it = I64 cl; _}; _} :: {it = Const {it = I64 cr; _}; _} :: {it = Binary (I64 I64Op.And); at} :: r' ->
+      let combined = {it = Const {it = I64 (Int64.logand cl cr); at}; at} in
+      go l' (combined :: r')
+    (* Constant bitwise `or` evaluation *)
+    | l', {it = Const {it = I64 cl; _}; _} :: {it = Const {it = I64 cr; _}; _} :: {it = Binary (I64 I64Op.Or); at} :: r' ->
+      let combined = {it = Const {it = I64 (Int64.logor cl cr); at}; at} in
+      go l' (combined :: r')
+    (* Widen followed by I64.Eqz can be simplified to I32.Eqz *)
+    | l', {it = Convert (I64 I64Op.(ExtendSI32 | ExtendUI32)); _} :: {it = Test (I64 I64Op.Eqz); at} :: r' ->
+      go l' ({it = Test (I32 I32Op.Eqz); at} :: r')
+    (* Narrow a constant *)
+    | l', {it = Const {it = I64 c; _}; at} :: {it = Convert (I32 I32Op.WrapI64); _} :: r' ->
+      let narrowed = {it = Const {it = I32 (Int64.to_int32 c); at}; at} in
+      go l' (narrowed :: r')
     (* Look further *)
     | _, i::r' -> go (i::l) r'
     (* Done looking *)
diff --git a/src/exes/candid_tests.ml b/src/exes/candid_tests.ml
index bddd6aae3dd..6c43abda5f9 100644
--- a/src/exes/candid_tests.ml
+++ b/src/exes/candid_tests.ml
@@ -14,7 +14,7 @@ let name = "candid-tests"
 let version = "0.1"
 let banner = "Candid test suite runner " ^ version ^ ""
 let usage = "Usage: " ^ name ^ " [ -i path/to/candid/test ]"
-let _WASMTIME_OPTIONS_ = "--disable-cache --enable-cranelift-nan-canonicalization --wasm-features multi-memory,bulk-memory"
+let _WASMTIME_OPTIONS_ = "--disable-cache --enable-cranelift-nan-canonicalization --wasm-features=memory64,multi-memory,bulk-memory"
 
 (* Argument handling *)
 
diff --git a/src/exes/moc.ml b/src/exes/moc.ml
index 16dca39a53b..9b81a6fcb4b 100644
--- a/src/exes/moc.ml
+++ b/src/exes/moc.ml
@@ -147,6 +147,22 @@ let argspec = [
     Flags.use_stable_regions := true),
       " force eager initialization of stable regions metadata (for testing purposes); consumes between 386KiB or 8MiB of additional physical stable memory, depending on current use of ExperimentalStableMemory library";
 
+  "--generational-gc",
+  Arg.Unit (fun () -> Flags.gc_strategy := Mo_config.Flags.Generational),
+  " use generational GC (only available with classical persistence)";
+
+  "--incremental-gc",
+  Arg.Unit (fun () -> Flags.gc_strategy := Mo_config.Flags.Incremental),
+  " use incremental GC (default with enhanced orthogonal persistence)";
+
+  "--compacting-gc",
+  Arg.Unit (fun () -> Flags.gc_strategy := Mo_config.Flags.MarkCompact),
+  " use compacting GC (only available with classical persistence)";
+
+  "--copying-gc",
+  Arg.Unit (fun () -> Flags.gc_strategy := Mo_config.Flags.Copying),
+  " use copying GC (default and only available with classical persistence)";
+
   "--force-gc",
   Arg.Unit (fun () -> Flags.force_gc := true),
   " disable GC scheduling, always do GC after an update message (for testing)";
@@ -163,10 +179,37 @@ let argspec = [
   Arg.Unit (fun () -> Flags.experimental_field_aliasing := true),
   " enable experimental support for aliasing of var fields";
 
+  "--experimental-rtti",
+  Arg.Unit (fun () -> Flags.rtti := true),
+  " enable experimental support for precise runtime type information (default with enhanced orthogonal persistence)";
+
+  "--rts-stack-pages",
+  Arg.Int (fun pages -> Flags.rts_stack_pages := Some pages),
+  "<n>  set maximum number of pages available for runtime system stack (default " ^ (Int.to_string Flags.rts_stack_pages_default) ^ ", only available with classical persistence)";
+
   "--trap-on-call-error",
   Arg.Unit (fun () -> Flags.trap_on_call_error := true),
   " Trap, don't throw an `Error`, when an IC call fails due to destination queue full or freezing threshold is crossed. Emulates behaviour of moc versions < 0.8.0.";
 
+  (* persistence *)
+  "--enhanced-orthogonal-persistence",
+  Arg.Unit (fun () -> Flags.enhanced_orthogonal_persistence := true),
+  " Use enhanced orthogonal persistence (experimental): Scalable and fast upgrades using a persistent 64-bit main memory.";
+
+  "--stabilization-instruction-limit",
+  Arg.Int (fun limit -> Flags.(stabilization_instruction_limit := {
+    upgrade = limit; 
+    update_call = limit;
+  })),
+  "<n>  set instruction limit for incremental graph-copy-based stabilization and destabilization (for testing)";
+
+  "--stable-memory-access-limit",
+  Arg.Int (fun limit -> Flags.(stable_memory_access_limit := {
+    upgrade = limit; 
+    update_call = limit;
+  })),
+  "<n>  set stable memory access limit for incremental graph-copy-based stabilization and destabilization (for testing)";
+
   (* optimizations *)
   "-fno-shared-code",
   Arg.Unit (fun () -> Flags.share_code := false),
diff --git a/src/ir_def/arrange_ir.ml b/src/ir_def/arrange_ir.ml
index 54a6056b981..d476aa83ec7 100644
--- a/src/ir_def/arrange_ir.ml
+++ b/src/ir_def/arrange_ir.ml
@@ -35,13 +35,15 @@ let rec exp e = match e.it with
   | TryE (e, cs, None) -> "TryE" $$ [exp e] @ List.map case cs
   | TryE (e, cs, Some (i, _)) -> "TryE" $$ [exp e] @ List.map case cs @ Atom ";" :: [id i]
 
-and system { meta; preupgrade; postupgrade; heartbeat; timer; inspect} = (* TODO: show meta? *)
+and system { meta; preupgrade; postupgrade; heartbeat; timer; inspect; stable_record; stable_type} = (* TODO: show meta? *)
   "System" $$ [
       "Pre" $$ [exp preupgrade];
       "Post" $$ [exp postupgrade];
       "Heartbeat" $$ [exp heartbeat];
       "Timer" $$ [exp timer];
       "Inspect" $$ [exp inspect];
+      "StableRecord" $$ [exp stable_record];
+      "StableType" $$ [typ stable_type]
     ]
 
 and lexp le = match le.it with
diff --git a/src/ir_def/check_ir.ml b/src/ir_def/check_ir.ml
index 121a60ca3c4..a70c10f47d1 100644
--- a/src/ir_def/check_ir.ml
+++ b/src/ir_def/check_ir.ml
@@ -631,10 +631,9 @@ let rec check_exp env (exp:Ir.exp) : unit =
       check_typ env t1;
       check (store_typ t1) "Invalid type argument to ICStableRead";
       t1 <: t
-    | ICStableWrite t1, [exp1] ->
+    | ICStableWrite t1, [] ->
       check_typ env t1;
       check (store_typ t1) "Invalid type argument to ICStableWrite";
-      typ exp1 <: t1;
       T.unit <: t
     | NumConvWrapPrim (p1, p2), [e] ->
       (* we should check if this conversion is supported *)
@@ -816,7 +815,7 @@ let rec check_exp env (exp:Ir.exp) : unit =
     typ exp_r <: T.(Construct.err_contT unit);
     typ exp_c <: Construct.clean_contT;
   | ActorE (ds, fs,
-      { preupgrade; postupgrade; meta; heartbeat; timer; inspect }, t0) ->
+      { preupgrade; postupgrade; meta; heartbeat; timer; inspect; stable_record; stable_type }, t0) ->
     (* TODO: check meta *)
     let env' = { env with async = None } in
     let scope1 = gather_block_decs env' ds in
@@ -827,11 +826,13 @@ let rec check_exp env (exp:Ir.exp) : unit =
     check_exp env'' heartbeat;
     check_exp env'' timer;
     check_exp env'' inspect;
+    check_exp env'' stable_record;
     typ preupgrade <: T.unit;
     typ postupgrade <: T.unit;
     typ heartbeat <: T.unit;
     typ timer <: T.unit;
     typ inspect <: T.unit;
+    typ stable_record <: stable_type;
     check (T.is_obj t0) "bad annotation (object type expected)";
     let (s0, tfs0) = T.as_obj t0 in
     let val_tfs0 = List.filter (fun tf -> not (T.is_typ tf.T.typ)) tfs0 in
@@ -1157,7 +1158,7 @@ let check_comp_unit env = function
     let env' = adjoin env scope in
     check_decs env' ds
   | ActorU (as_opt, ds, fs,
-      { preupgrade; postupgrade; meta; heartbeat; timer; inspect }, t0) ->
+      { preupgrade; postupgrade; meta; heartbeat; timer; inspect; stable_type; stable_record }, t0) ->
     let check p = check env no_region p in
     let (<:) t1 t2 = check_sub env no_region t1 t2 in
     let env' = match as_opt with
@@ -1175,11 +1176,13 @@ let check_comp_unit env = function
     check_exp env'' heartbeat;
     check_exp env'' timer;
     check_exp env'' inspect;
+    check_exp env'' stable_record;
     typ preupgrade <: T.unit;
     typ postupgrade <: T.unit;
     typ heartbeat <: T.unit;
     typ timer <: T.unit;
     typ inspect <: T.unit;
+    typ stable_record <: stable_type;
     check (T.is_obj t0) "bad annotation (object type expected)";
     let (s0, tfs0) = T.as_obj t0 in
     let val_tfs0 = List.filter (fun tf -> not (T.is_typ tf.T.typ)) tfs0 in
diff --git a/src/ir_def/construct.ml b/src/ir_def/construct.ml
index 2a92c9ca3ea..5de2e5ef0a7 100644
--- a/src/ir_def/construct.ml
+++ b/src/ir_def/construct.ml
@@ -90,10 +90,10 @@ let primE prim es =
     | ICReplyPrim _
     | ICRejectPrim -> T.Non
     | ICCallerPrim -> T.caller
+    | ICStableWrite _ -> T.unit
     | ICStableRead t -> t
     | ICMethodNamePrim -> T.text
     | ICPerformGC
-    | ICStableWrite _ -> T.unit
     | ICStableSize _ -> T.nat64
     | IdxPrim
     | DerefArrayOffset -> T.(as_immut (as_array_sub (List.hd es).note.Note.typ))
diff --git a/src/ir_def/freevars.ml b/src/ir_def/freevars.ml
index bb1fbaa41f8..ae8d8309cf5 100644
--- a/src/ir_def/freevars.ml
+++ b/src/ir_def/freevars.ml
@@ -123,12 +123,13 @@ let rec exp e : f = match e.it with
 
 and actor ds fs u = close (decs ds +++ fields fs +++ system u)
 
-and system {meta; preupgrade; postupgrade; heartbeat; timer; inspect} =
+and system {meta; preupgrade; postupgrade; heartbeat; timer; inspect; stable_record; _} =
   under_lambda (exp preupgrade) ++
   under_lambda (exp postupgrade) ++
   under_lambda (exp heartbeat) ++
   under_lambda (exp timer) ++
-  under_lambda (exp inspect)
+  under_lambda (exp inspect) ++
+  under_lambda (exp stable_record)
 
 and exps es : f = unions exp es
 
diff --git a/src/ir_def/ir.ml b/src/ir_def/ir.ml
index 58419ef92ad..413b56506dd 100644
--- a/src/ir_def/ir.ml
+++ b/src/ir_def/ir.ml
@@ -56,6 +56,7 @@ type arg = (string, Type.typ) Source.annotated_phrase
 (* Expressions *)
 
 type exp = exp' phrase
+
 and exp' =
   | PrimE of (prim * exp list)                 (* primitive *)
   | VarE of mut * id                           (* variable *)
@@ -83,7 +84,9 @@ and system = {
   postupgrade : exp;
   heartbeat : exp;
   timer : exp; (* TODO: use an option type: (Default of exp | UserDefined of exp) option *)
-  inspect : exp
+  inspect : exp;
+  stable_record: exp;
+  stable_type: Type.typ;
 }
 
 and candid = {
@@ -232,6 +235,13 @@ let full_flavor () : flavor = {
   has_poly_eq = true;
 }
 
+type actor_type = {
+  (* original actor type, including all actor fields *)
+  transient_actor_type: Type.typ;
+  (* record of stable actor fields used for persistence,
+     the fields are without mutability distinctions *)
+  stable_actor_type: Type.typ
+}
 
 (* Program *)
 
@@ -239,6 +249,7 @@ type comp_unit =
   | LibU of dec list * exp
   | ProgU of dec list
   | ActorU of arg list option * dec list * field list * system * Type.typ (* actor (class) *)
+     
 
 type prog = comp_unit * flavor
 
@@ -313,4 +324,3 @@ let map_prim t_typ t_id p =
   | ICStableWrite t -> ICStableWrite (t_typ t)
   | ICStableRead t -> ICStableRead (t_typ t)
   | ICStableSize t -> ICStableSize (t_typ t)
-
diff --git a/src/ir_def/rename.ml b/src/ir_def/rename.ml
index 4a4580877b1..f97594fba41 100644
--- a/src/ir_def/rename.ml
+++ b/src/ir_def/rename.ml
@@ -33,7 +33,7 @@ and exp' rho = function
   | VarE (m, i)         -> VarE (m, id rho i)
   | LitE _ as e         -> e
   | PrimE (p, es)       -> PrimE (prim rho p, List.map (exp rho) es)
-  | ActorE (ds, fs, { meta; preupgrade; postupgrade; heartbeat; timer; inspect }, t) ->
+  | ActorE (ds, fs, { meta; preupgrade; postupgrade; heartbeat; timer; inspect; stable_record; stable_type}, t) ->
     let ds', rho' = decs rho ds in
     ActorE
       (ds',
@@ -44,8 +44,11 @@ and exp' rho = function
         heartbeat = exp rho' heartbeat;
         timer = exp rho' timer;
         inspect = exp rho' inspect;
+        stable_type = stable_type;
+        stable_record = exp rho' stable_record;
        },
        t)
+
   | AssignE (e1, e2)    -> AssignE (lexp rho e1, exp rho e2)
   | BlockE (ds, e1)     -> let ds', rho' = decs rho ds
                            in BlockE (ds', exp rho' e1)
@@ -197,7 +200,7 @@ let comp_unit rho cu = match cu with
   | LibU (ds, e) ->
     let ds', rho' = decs rho ds
     in LibU (ds', exp rho' e)
-  | ActorU (as_opt, ds, fs, { meta; preupgrade; postupgrade; heartbeat; timer; inspect }, t) ->
+  | ActorU (as_opt, ds, fs, { meta; preupgrade; postupgrade; heartbeat; timer; inspect; stable_record; stable_type }, t) ->
     let as_opt', rho' = match as_opt with
       | None -> None, rho
       | Some as_ ->
@@ -212,4 +215,6 @@ let comp_unit rho cu = match cu with
         heartbeat = exp rho'' heartbeat;
         timer = exp rho'' timer;
         inspect = exp rho'' inspect;
+        stable_record = exp rho'' stable_record;
+        stable_type = stable_type;
       }, t)
diff --git a/src/ir_interpreter/interpret_ir.ml b/src/ir_interpreter/interpret_ir.ml
index cc74c355774..b3e1b79139b 100644
--- a/src/ir_interpreter/interpret_ir.ml
+++ b/src/ir_interpreter/interpret_ir.ml
@@ -462,8 +462,6 @@ and interpret_exp_mut env exp (k : V.value V.cont) =
           V.Env.empty tfs
         in
         k (V.Obj ve)
-      | ICStableWrite _, [v1] ->
-        k V.unit (* faking it *)
       | SelfRef _, [] ->
         k (V.Blob env.self)
       | SystemTimePrim, [] ->
diff --git a/src/ir_passes/async.ml b/src/ir_passes/async.ml
index d0a9db70c43..b3b52989e7a 100644
--- a/src/ir_passes/async.ml
+++ b/src/ir_passes/async.ml
@@ -442,15 +442,18 @@ let transform prog =
             | (Returns | Replies), _ -> assert false
           end
       end
-    | ActorE (ds, fs, {meta; preupgrade; postupgrade; heartbeat; timer; inspect}, typ) ->
+    | ActorE (ds, fs, {meta; preupgrade; postupgrade; heartbeat; timer; inspect; stable_record; stable_type}, typ) ->
       ActorE (t_decs ds, t_fields fs,
         {meta;
          preupgrade = t_exp preupgrade;
          postupgrade = t_exp postupgrade;
          heartbeat = t_exp heartbeat;
          timer = t_exp timer;
-         inspect = t_exp inspect
-        }, t_typ typ)
+         inspect = t_exp inspect;
+         stable_record = t_exp stable_record;
+         stable_type = t_typ stable_type;
+        },
+        t_typ typ)
     | NewObjE (sort, ids, t) ->
       NewObjE (sort, t_fields ids, t_typ t)
     | SelfCallE _ -> assert false
@@ -520,15 +523,18 @@ let transform prog =
   and t_comp_unit = function
     | LibU _ -> raise (Invalid_argument "cannot compile library")
     | ProgU ds -> ProgU (t_decs ds)
-    | ActorU (args_opt, ds, fs, {meta; preupgrade; postupgrade; heartbeat; timer; inspect}, t) ->
+    | ActorU (args_opt, ds, fs, {meta; preupgrade; postupgrade; heartbeat; timer; inspect; stable_record; stable_type}, t) ->
       ActorU (Option.map t_args args_opt, t_decs ds, t_fields fs,
         { meta;
           preupgrade = t_exp preupgrade;
           postupgrade = t_exp postupgrade;
           heartbeat = t_exp heartbeat;
           timer = t_exp timer;
-          inspect = t_exp inspect
-        }, t_typ t)
+          inspect = t_exp inspect;
+          stable_record = t_exp stable_record;
+          stable_type = t_typ stable_type;
+        },
+        t_typ t)
 
   and t_prog (cu, flavor) = (t_comp_unit cu, { flavor with has_async_typ = false } )
 in
diff --git a/src/ir_passes/await.ml b/src/ir_passes/await.ml
index 4072af11c75..84a2170a8d2 100644
--- a/src/ir_passes/await.ml
+++ b/src/ir_passes/await.ml
@@ -181,14 +181,16 @@ and t_exp' context exp =
     assert (not (T.is_shared_func (typ exp)));
     let context' = LabelEnv.singleton Return Label in
     FuncE (x, s, c, typbinds, pat, typs, t_exp context' exp1)
-  | ActorE (ds, ids, { meta; preupgrade; postupgrade; heartbeat; timer; inspect}, t) ->
+  | ActorE (ds, ids, { meta; preupgrade; postupgrade; heartbeat; timer; inspect; stable_record; stable_type}, t) ->
     ActorE (t_decs context ds, ids,
       { meta;
         preupgrade = t_exp LabelEnv.empty preupgrade;
         postupgrade = t_exp LabelEnv.empty postupgrade;
         heartbeat = t_ignore_throw LabelEnv.empty heartbeat;
         timer = t_ignore_throw LabelEnv.empty timer;
-        inspect = t_exp LabelEnv.empty inspect
+        inspect = t_exp LabelEnv.empty inspect;
+        stable_record = t_exp LabelEnv.empty stable_record;
+        stable_type;
       },
       t)
   | NewObjE (sort, ids, typ) -> exp.it
@@ -645,7 +647,7 @@ and t_comp_unit context = function
           expD (c_block context' ds (tupE []) (meta (T.unit) (fun v1 -> tupE [])))
         ]
     end
-  | ActorU (as_opt, ds, ids, { meta = m; preupgrade; postupgrade; heartbeat; timer; inspect}, t) ->
+  | ActorU (as_opt, ds, ids, { meta = m; preupgrade; postupgrade; heartbeat; timer; inspect; stable_record; stable_type}, t) ->
     ActorU (as_opt, t_decs context ds, ids,
       { meta = m;
         preupgrade = t_exp LabelEnv.empty preupgrade;
@@ -653,6 +655,8 @@ and t_comp_unit context = function
         heartbeat = t_ignore_throw LabelEnv.empty heartbeat;
         timer = t_ignore_throw LabelEnv.empty timer;
         inspect = t_exp LabelEnv.empty inspect;
+        stable_record = t_exp LabelEnv.empty stable_record;
+        stable_type;
       },
       t)
 
diff --git a/src/ir_passes/const.ml b/src/ir_passes/const.ml
index f258084d5ac..9bc4591cad1 100644
--- a/src/ir_passes/const.ml
+++ b/src/ir_passes/const.ml
@@ -164,7 +164,7 @@ let rec exp lvl (env : env) e : Lbool.t =
       surely_false
     | NewObjE _ -> (* mutable objects *)
       surely_false
-    | ActorE (ds, fs, {meta; preupgrade; postupgrade; heartbeat; timer; inspect}, _typ) ->
+    | ActorE (ds, fs, {meta; preupgrade; postupgrade; heartbeat; timer; inspect; stable_record; stable_type}, _typ) ->
       (* this may well be “the” top-level actor, so don’t update lvl here *)
       let (env', _) = decs lvl env ds in
       exp_ lvl env' preupgrade;
@@ -172,6 +172,7 @@ let rec exp lvl (env : env) e : Lbool.t =
       exp_ lvl env' heartbeat;
       exp_ lvl env' timer;
       exp_ lvl env' inspect;
+      exp_ lvl env' stable_record;
       surely_false
   in
   set_lazy_const e lb;
@@ -227,7 +228,7 @@ and block lvl env (ds, body) =
 and comp_unit = function
   | LibU _ -> raise (Invalid_argument "cannot compile library")
   | ProgU ds -> decs_ TopLvl M.empty ds
-  | ActorU (as_opt, ds, fs, {meta; preupgrade; postupgrade; heartbeat; timer; inspect}, typ) ->
+  | ActorU (as_opt, ds, fs, {meta; preupgrade; postupgrade; heartbeat; timer; inspect; stable_record; stable_type}, typ) ->
     let env = match as_opt with
       | None -> M.empty
       | Some as_ -> args TopLvl M.empty as_
@@ -237,7 +238,8 @@ and comp_unit = function
     exp_ TopLvl env' postupgrade;
     exp_ TopLvl env' heartbeat;
     exp_ TopLvl env' timer;
-    exp_ TopLvl env' inspect
+    exp_ TopLvl env' inspect;
+    exp_ TopLvl env' stable_record
 
 let analyze ((cu, _flavor) : prog) =
   ignore (comp_unit cu)
diff --git a/src/ir_passes/eq.ml b/src/ir_passes/eq.ml
index d0916e3ef5c..52486abcf4b 100644
--- a/src/ir_passes/eq.ml
+++ b/src/ir_passes/eq.ml
@@ -249,7 +249,7 @@ and t_exp' env = function
     NewObjE (sort, ids, t)
   | SelfCallE (ts, e1, e2, e3, e4) ->
     SelfCallE (ts, t_exp env e1, t_exp env e2, t_exp env e3, t_exp env e4)
-  | ActorE (ds, fields, {meta; preupgrade; postupgrade; heartbeat; timer; inspect}, typ) ->
+  | ActorE (ds, fields, {meta; preupgrade; postupgrade; heartbeat; timer; inspect; stable_record; stable_type}, typ) ->
     (* Until Actor expressions become their own units,
        we repeat what we do in `comp_unit` below *)
     let env1 = empty_env () in
@@ -259,6 +259,7 @@ and t_exp' env = function
     let heartbeat' = t_exp env1 heartbeat in
     let timer' = t_exp env1 timer in
     let inspect' = t_exp env1 inspect in
+    let stable_record' = t_exp env1 stable_record in
     let decls = eq_decls !(env1.params) in
     ActorE (decls @ ds', fields,
       {meta;
@@ -266,8 +267,12 @@ and t_exp' env = function
        postupgrade = postupgrade';
        heartbeat = heartbeat';
        timer = timer';
-       inspect = inspect'
-      }, typ)
+       inspect = inspect';
+       stable_record = stable_record';
+       stable_type;
+      },
+      typ
+      )
 
 and t_lexp env (e : Ir.lexp) = { e with it = t_lexp' env e.it }
 and t_lexp' env = function
@@ -296,7 +301,7 @@ and t_comp_unit = function
     let ds' = t_decs env ds in
     let decls = eq_decls !(env.params) in
     ProgU (decls @ ds')
-  | ActorU (as_opt, ds, fields, {meta; preupgrade; postupgrade; heartbeat; timer; inspect}, typ) ->
+  | ActorU (as_opt, ds, fields, {meta; preupgrade; postupgrade; heartbeat; timer; inspect; stable_record; stable_type}, typ) ->
     let env = empty_env () in
     let ds' = t_decs env ds in
     let preupgrade' = t_exp env preupgrade in
@@ -304,6 +309,7 @@ and t_comp_unit = function
     let heartbeat' = t_exp env heartbeat in
     let timer' = t_exp env timer in
     let inspect' = t_exp env inspect in
+    let stable_record' = t_exp env stable_record in
     let decls = eq_decls !(env.params) in
     ActorU (as_opt, decls @ ds', fields,
       {meta;
@@ -311,7 +317,9 @@ and t_comp_unit = function
        postupgrade = postupgrade';
        heartbeat = heartbeat';
        timer = timer';
-       inspect = inspect'
+       inspect = inspect';
+       stable_record = stable_record';
+       stable_type;
       }, typ)
 
 (* Entry point for the program transformation *)
diff --git a/src/ir_passes/erase_typ_field.ml b/src/ir_passes/erase_typ_field.ml
index 9ba4550e7c6..2b5daf75d70 100644
--- a/src/ir_passes/erase_typ_field.ml
+++ b/src/ir_passes/erase_typ_field.ml
@@ -126,7 +126,7 @@ let transform prog =
       DefineE (id, mut, t_exp exp1)
     | FuncE (x, s, c, typbinds, args, ret_tys, exp) ->
       FuncE (x, s, c, t_typ_binds typbinds, t_args args, List.map t_typ ret_tys, t_exp exp)
-    | ActorE (ds, fs, {meta; preupgrade; postupgrade; heartbeat; timer; inspect}, typ) ->
+    | ActorE (ds, fs, {meta; preupgrade; postupgrade; heartbeat; timer; inspect; stable_record; stable_type}, typ) ->
       ActorE (t_decs ds, t_fields fs,
        {meta;
         preupgrade = t_exp preupgrade;
@@ -134,7 +134,11 @@ let transform prog =
         heartbeat = t_exp heartbeat;
         timer = t_exp timer;
         inspect = t_exp inspect;
-       }, t_typ typ)
+        stable_record = t_exp stable_record;
+        stable_type = t_typ stable_type;
+       },
+       t_typ typ)
+
     | NewObjE (sort, ids, t) ->
       NewObjE (sort, t_fields ids, t_typ t)
     | SelfCallE _ -> assert false
@@ -207,7 +211,7 @@ let transform prog =
   and t_comp_unit = function
     | LibU _ -> raise (Invalid_argument "cannot compile library")
     | ProgU ds -> ProgU (t_decs ds)
-    | ActorU (args_opt, ds, fs, {meta; preupgrade; postupgrade; heartbeat; timer; inspect}, t) ->
+    | ActorU (args_opt, ds, fs, {meta; preupgrade; postupgrade; heartbeat; timer; inspect; stable_record; stable_type}, t) ->
       ActorU (Option.map t_args args_opt, t_decs ds, t_fields fs,
         { meta;
           preupgrade = t_exp preupgrade;
@@ -215,7 +219,10 @@ let transform prog =
           heartbeat = t_exp heartbeat;
           timer = t_exp timer;
           inspect = t_exp inspect;
-        }, t_typ t)
+          stable_record = t_exp stable_record;
+          stable_type = t_typ stable_type;
+        },
+        t_typ t)
   and t_prog (cu, flavor) = (t_comp_unit cu, { flavor with has_typ_field = false } )
 in
   t_prog prog
diff --git a/src/ir_passes/show.ml b/src/ir_passes/show.ml
index ef100707878..23f195220d7 100644
--- a/src/ir_passes/show.ml
+++ b/src/ir_passes/show.ml
@@ -291,7 +291,7 @@ and t_exp' env = function
     NewObjE (sort, ids, t)
   | SelfCallE (ts, e1, e2, e3, e4) ->
     SelfCallE (ts, t_exp env e1, t_exp env e2, t_exp env e3, t_exp env e4)
-  | ActorE (ds, fields, {meta; preupgrade; postupgrade; heartbeat; timer; inspect}, typ) ->
+  | ActorE (ds, fields, {meta; preupgrade; postupgrade; heartbeat; timer; inspect; stable_record; stable_type}, typ) ->
     (* Until Actor expressions become their own units,
        we repeat what we do in `comp_unit` below *)
     let env1 = empty_env () in
@@ -301,6 +301,7 @@ and t_exp' env = function
     let heartbeat' = t_exp env1 heartbeat in
     let timer' = t_exp env1 timer in
     let inspect' = t_exp env1 inspect in
+    let stable_record' = t_exp env1 stable_record in
     let decls = show_decls !(env1.params) in
     ActorE (decls @ ds', fields,
       { meta;
@@ -308,8 +309,11 @@ and t_exp' env = function
         postupgrade = postupgrade';
         heartbeat = heartbeat';
         timer = timer';
-        inspect = inspect'
-      }, typ)
+        inspect = inspect';
+        stable_record = stable_record';
+        stable_type;
+      },
+      typ)
 
 and t_lexp env (e : Ir.lexp) = { e with it = t_lexp' env e.it }
 and t_lexp' env = function
@@ -338,7 +342,7 @@ and t_comp_unit = function
     let ds' = t_decs env ds in
     let decls = show_decls !(env.params) in
     ProgU (decls @ ds')
-  | ActorU (as_opt, ds, fields, {meta; preupgrade; postupgrade; heartbeat; timer; inspect}, typ) ->
+  | ActorU (as_opt, ds, fields, {meta; preupgrade; postupgrade; heartbeat; timer; inspect; stable_record; stable_type}, typ) ->
     let env = empty_env () in
     let ds' = t_decs env ds in
     let preupgrade' = t_exp env preupgrade in
@@ -346,6 +350,7 @@ and t_comp_unit = function
     let heartbeat' = t_exp env heartbeat in
     let timer' = t_exp env timer in
     let inspect' = t_exp env inspect in
+    let stable_record' = t_exp env stable_record in
     let decls = show_decls !(env.params) in
     ActorU (as_opt, decls @ ds', fields,
       { meta;
@@ -354,6 +359,8 @@ and t_comp_unit = function
         heartbeat = heartbeat';
         timer = timer';
         inspect = inspect';
+        stable_record = stable_record';
+        stable_type
       }, typ)
 
 (* Entry point for the program transformation *)
diff --git a/src/ir_passes/tailcall.ml b/src/ir_passes/tailcall.ml
index 42bb99dddee..48fb2631f9a 100644
--- a/src/ir_passes/tailcall.ml
+++ b/src/ir_passes/tailcall.ml
@@ -128,7 +128,8 @@ and exp' env e  : exp' = match e.it with
     let exp4' = exp env exp4 in
     SelfCallE (ts, exp1', exp2', exp3', exp4')
   | ActorE (ds, fs, u, t) ->
-    let u = { u with preupgrade = exp env u.preupgrade; postupgrade = exp env u.postupgrade } in
+    (* TODO: tco other upgrade fields? *)
+    let u = { u with preupgrade = exp env u.preupgrade; postupgrade = exp env u.postupgrade; stable_record = exp env u.stable_record } in
     ActorE (snd (decs env ds), fs, u, t)
   | NewObjE (s,is,t)    -> NewObjE (s, is, t)
   | PrimE (p, es)       -> PrimE (p, List.map (exp env) es)
@@ -258,7 +259,12 @@ and comp_unit env = function
   | LibU _ -> raise (Invalid_argument "cannot compile library")
   | ProgU ds -> ProgU (snd (decs env ds))
   | ActorU (as_opt, ds, fs, u, t)  ->
-    let u = { u with preupgrade = exp env u.preupgrade; postupgrade = exp env u.postupgrade } in
+    (* TODO: tco other fields of u? *)
+    let u = { u with
+              preupgrade = exp env u.preupgrade;
+              postupgrade = exp env u.postupgrade;
+              stable_record = exp env u.stable_record;
+            } in
     ActorU (as_opt, snd (decs env ds), fs, u, t)
 
 and prog (cu, flavor) =
diff --git a/src/linking/linkModule.ml b/src/linking/linkModule.ml
index 403e9aa14a3..6adf1535312 100644
--- a/src/linking/linkModule.ml
+++ b/src/linking/linkModule.ml
@@ -6,6 +6,7 @@ plus the dylink section.
 open Wasm_exts.Ast
 open Wasm.Source
 open Wasm_exts.CustomModule
+module I64_convert = Wasm.I64_convert
 
 (*
 This module is a first stab that should be functionally working, but will go
@@ -91,6 +92,8 @@ and resolving.
 *)
 
 (* Linking *)
+exception LinkError of string
+exception TooLargeDataSegments of string
 
 type imports = (int32 * name) list
 
@@ -99,6 +102,18 @@ let phrase f x = { x with it = f x.it }
 let map_module f (em : extended_module) = { em with module_ = f em.module_ }
 let map_name_section f (em : extended_module) = { em with name = f em.name }
 
+(* Distinction between Memory64 and Memory32 *)
+
+let uses_memory64 (m: module_') : bool =
+  let open Wasm_exts.Types in
+  let MemoryType(_, index_type) = match m.memories with
+  | [] -> raise (LinkError "Expect at least one memory in module")
+  | memory::_ -> memory.it.mtype
+  in
+  match index_type with
+  | I64IndexType -> true
+  | I32IndexType -> false
+
 (* Generic functions about import and export lists *)
 
 let get_import is_thing j m =
@@ -188,7 +203,7 @@ let is_global_export = function
   | _ -> None
 
 
-let get_fun_typ i m : Wasm.Types.func_type =
+let get_fun_typ i m : Wasm_exts.Types.func_type =
   let imports_n = count_imports is_fun_import m in
   let tyvar =
     if i < imports_n
@@ -202,7 +217,7 @@ let get_fun_typ i m : Wasm.Types.func_type =
     in
   (Lib.List32.nth m.types tyvar).it
 
-let get_global_typ i m : Wasm.Types.global_type =
+let get_global_typ i m : Wasm_exts.Types.global_type =
   let imports_n = count_imports is_global_import m in
   if i < imports_n
   then
@@ -273,9 +288,6 @@ let remove_non_ic_exports (em : extended_module) : extended_module =
 
 (* Generic linking logic *)
 
-exception LinkError of string
-exception TooLargeDataSegments of string
-
 type renumbering = int32 -> int32
 
 let resolve imports exports : (int32 * int32) list =
@@ -405,22 +417,28 @@ let set_global global value = fun m ->
   let rec go i = function
     | [] -> assert false
     | g::gs when i = Int32.to_int global ->
-      let open Wasm.Types in
-      assert (g.it.gtype = GlobalType (I32Type, Immutable));
+      let open Wasm_exts.Types in
+      let global_value = if uses_memory64 m then
+        (assert (g.it.gtype = GlobalType (I64Type, Immutable));
+        Wasm_exts.Values.I64 (Int64.of_int32 value))
+      else
+        (assert (g.it.gtype = GlobalType (I32Type, Immutable));
+        Wasm_exts.Values.I32 value)
+      in
       let g = phrase (fun g' ->
-        { g' with value = [Const (Wasm.Values.I32 value @@ g.at) @@ g.at] @@ g.at }
+        { g' with value = [Const (global_value @@ g.at) @@ g.at] @@ g.at }
       ) g in
       g :: gs
     | g::gs -> g :: go (i+1) gs
   in
   { m with globals = go 0 m.globals }
 
-let fill_global (global : int32) (value : int32) : module_' -> module_' = fun m ->
+let fill_global (global : int32) (value : Wasm_exts.Values.value) (uses_memory64 : bool) : module_' -> module_' = fun m ->
   let rec instr' = function
     | Block (ty, is) -> Block (ty, instrs is)
     | Loop (ty, is) -> Loop (ty, instrs is)
     | If (ty, is1, is2) -> If (ty, instrs is1, instrs is2)
-    | GlobalGet v when v.it = global -> Const (Wasm.Values.I32 value @@ v.at)
+    | GlobalGet v when v.it = global -> Const (value @@ v.at)
     | GlobalSet v when v.it = global -> assert false
     | i -> i
   and instr i = phrase instr' i
@@ -432,11 +450,25 @@ let fill_global (global : int32) (value : int32) : module_' -> module_' = fun m
 
   let const = phrase instrs in
 
+  (* For 64-bit, convert the constant expression of the table segment offset to 32-bit. *)
+  let const_instr_to_32' = function
+    | Const { it = (Wasm_exts.Values.I64 number); at } -> Const ((Wasm_exts.Values.I32 (Int64.to_int32 number)) @@ at)
+    | GlobalGet v -> GlobalGet v
+    | _ -> assert false
+  in
+  let const_instr_to_32 i = phrase const_instr_to_32' i in
+  let convert_const_to_32' = List.map const_instr_to_32 in
+  let convert_const_to_32 = phrase convert_const_to_32' in
+  let table_const offset = 
+    let expr = const offset in
+    if uses_memory64 then convert_const_to_32 expr else expr
+  in
+
   let global' g = { g with value = const g.value } in
   let global = phrase global' in
   let globals = List.map global in
 
-  let table_segment' (s : var list segment') = { s with offset = const s.offset; } in
+  let table_segment' (s : var list segment') = { s with offset = table_const s.offset; } in
   let table_segment = phrase (table_segment') in
   let table_segments = List.map table_segment in
 
@@ -514,15 +546,19 @@ let rename_types rn m =
 let read_global gi (m : module_') : int32 =
   let n_impo = count_imports is_global_import m in
   let g = List.nth m.globals (Int32.(to_int (sub gi n_impo))) in
-  let open Wasm.Types in
-  assert (g.it.gtype = GlobalType (I32Type, Immutable));
-  match g.it.value.it with
-  | [{ it = Const {it = Wasm.Values.I32 i;_}; _}] -> i
+  let open Wasm_exts.Types in
+  match uses_memory64 m, g.it.value.it with
+  | true, [{ it = Const {it = Wasm_exts.Values.I64 i;_}; _}] -> 
+    assert (g.it.gtype = GlobalType (I64Type, Immutable));
+    Int64.to_int32 i
+  | false, [{ it = Const {it = Wasm_exts.Values.I32 i;_}; _}] ->
+    assert (g.it.gtype = GlobalType (I32Type, Immutable));
+    i
   | _ -> assert false
 
 let read_table_size (m : module_') : int32 =
   (* Assumes there is one table *)
-  let open Wasm.Types in
+  let open Wasm_exts.Types in
   match m.tables with
   | [t] ->
     let TableType ({min;max}, _) = t.it.ttype in
@@ -532,26 +568,27 @@ let read_table_size (m : module_') : int32 =
   | _ -> raise (LinkError "Expect one table in first module")
 
 let set_memory_size new_size_bytes : module_' -> module_' = fun m ->
-  let open Wasm.Types in
-  let page_size = Int32.of_int (64*1024) in
-  let new_size_pages = Int32.(add (div new_size_bytes page_size) 1l) in
+  let open Wasm_exts.Types in
+  let page_size = Int64.of_int (64*1024) in
+  let new_size_pages = Int64.(add (div new_size_bytes page_size) 1L) in
+  let index_type = if uses_memory64 m then I64IndexType else I32IndexType in
   match m.memories with
   | [t;t1] ->
     { m with
       memories = [(phrase (fun m ->
-        { mtype = MemoryType ({min = new_size_pages; max = None}) }
+        { mtype = MemoryType ({min = new_size_pages; max = None}, index_type) }
         ) t); t1]
     }
   | [t] ->
     { m with
       memories = [phrase (fun m ->
-        { mtype = MemoryType ({min = new_size_pages; max = None}) }
+        { mtype = MemoryType ({min = new_size_pages; max = None}, index_type) }
       ) t]
     }
   | _ -> raise (LinkError "Expect one memory in first module")
 
 let set_table_size new_size : module_' -> module_' = fun m ->
-  let open Wasm.Types in
+  let open Wasm_exts.Types in
   match m.tables with
   | [t] ->
     { m with
@@ -563,7 +600,7 @@ let set_table_size new_size : module_' -> module_' = fun m ->
   | _ -> raise (LinkError "Expect one table in first module")
 
 
-let fill_item_import module_name item_name new_base (m : module_') : module_' =
+let fill_item_import module_name item_name new_base uses_memory64 (m : module_') : module_' =
   (* We need to find the right import,
      replace all uses of get_global of that import with the constant,
      and finally rename all globals
@@ -582,7 +619,13 @@ let fill_item_import module_name item_name new_base (m : module_') : module_' =
           go i is
     in go 0 m.imports in
 
-    m |> fill_global base_global new_base
+    let new_base_value = if uses_memory64 then
+      Wasm_exts.Values.I64 (I64_convert.extend_i32_u new_base)
+    else
+      Wasm_exts.Values.I32 new_base
+    in
+
+    m |> fill_global base_global new_base_value uses_memory64
       |> remove_imports is_global_import [base_global, base_global]
       |> rename_globals Int32.(fun i ->
           if i < base_global then i
@@ -590,18 +633,21 @@ let fill_item_import module_name item_name new_base (m : module_') : module_' =
           else sub i one
         )
 
-let fill_memory_base_import new_base : module_' -> module_' =
-  fill_item_import "env" "__memory_base" new_base
-
-let fill_table_base_import new_base : module_' -> module_' =
-  fill_item_import "env" "__table_base" new_base
-
+let fill_memory_base_import new_base uses_memory64 : module_' -> module_' =
+  fill_item_import "env" "__memory_base" new_base uses_memory64
 
+let fill_table_base_import new_base uses_memory64 : module_' -> module_' = fun m ->
+  let m = fill_item_import "env" "__table_base" new_base uses_memory64 m in
+  if uses_memory64 then
+    fill_item_import "env" "__table_base32" new_base uses_memory64 m
+  else
+    m
+   
 (* Concatenation of modules *)
 
 let join_modules
       (em1 : extended_module) (m2 : module_') (ns2 : name_section)
-      (type_indices : (Wasm.Types.func_type, int32) Hashtbl.t) : extended_module =
+      (type_indices : (Wasm_exts.Types.func_type, int32) Hashtbl.t) : extended_module =
   let m1 = em1.module_ in
   let joined = 
     { em1 with
@@ -630,7 +676,7 @@ let join_modules
      we'll have the unit function in the type section already. *)
   match m2.start with
   | None -> joined
-  | Some fi -> prepend_to_start fi.it (Hashtbl.find type_indices (Wasm.Types.FuncType ([], []))) joined
+  | Some fi -> prepend_to_start fi.it (Hashtbl.find type_indices (Wasm_exts.Types.FuncType ([], []))) joined
 
 (* The main linking function *)
 
@@ -649,12 +695,12 @@ let check_typ is_thing get_typ string_of m1 m2 (i1, i2) =
     raise (LinkError msg)
 
 let check_fun_typ =
-  check_typ is_fun_import get_fun_typ Wasm.Types.string_of_func_type
+  check_typ is_fun_import get_fun_typ Wasm_exts.Types.string_of_func_type
 let check_global_typ =
-  check_typ is_global_import get_global_typ Wasm.Types.string_of_global_type
+  check_typ is_global_import get_global_typ Wasm_exts.Types.string_of_global_type
 
 
-let align p n =
+let align_i32 p n =
   let open Int32 in
   let p = to_int p in
   shift_left (shift_right_logical (add n (sub (shift_left 1l p) 1l)) p) p
@@ -691,10 +737,10 @@ let add_globals (globals0 : global list) (insert0 : (int32 * global') list) : gl
   go 0l globals0 insert0
 
 let mk_i32_const (i : int32) =
-  Const (Wasm.Values.I32 i @@ no_region) @@ no_region
+  Const (Wasm_exts.Values.I32 i @@ no_region) @@ no_region
 
 let mk_i32_global (i : int32) =
-  { gtype = Wasm.Types.GlobalType (Wasm.Types.I32Type, Wasm.Types.Immutable);
+  { gtype = Wasm_exts.Types.GlobalType (Wasm_exts.Types.I32Type, Wasm_exts.Types.Immutable);
     value = [mk_i32_const i] @@ no_region }
 
 (* Generate (global index, function index) pairs for GOT.func imports of a
@@ -784,27 +830,32 @@ let link (em1 : extended_module) libname (em2 : extended_module) =
 
   (* Beginning of unused space *)
   let old_heap_start = read_global heap_global em1.module_ in
-  let lib_heap_start = align dylink.memory_alignment old_heap_start in
-  let new_heap_start = align 4l (Int32.add lib_heap_start dylink.memory_size) in
-
-  (* The RTs data segments must fit below 4.5MB according to the persistent heap layout. 
-     The first 4MB are reserved for the Rust call stack such that RTS data segments are limited to 512KB. *)
-  let max_rts_stack_size = 4 * 1024 * 1024 in
-  let max_rts_data_segment_size = 512 * 1024 in
-  (if (Int32.to_int new_heap_start) > max_rts_stack_size + max_rts_data_segment_size then
-    (raise (TooLargeDataSegments (Printf.sprintf "The Wasm data segment size exceeds the supported maxmimum of %nMB." max_rts_data_segment_size)))
-  else
-    ()
-  );
+  let lib_heap_start = align_i32 dylink.memory_alignment old_heap_start in
+  let new_heap_start = align_i32 8l (Int32.add lib_heap_start dylink.memory_size) in
+
+  if uses_memory64 em1.module_ then
+  begin
+    (* The RTS data segments must fit below 4.5MB according to the persistent heap layout. 
+      The first 4MB are reserved for the Rust call stack such that RTS data segments are limited to 512KB. *)
+    let max_rts_stack_size = 4 * 1024 * 1024 in
+    let max_rts_data_segment_size = 512 * 1024 in
+    (if (Int32.to_int new_heap_start) > max_rts_stack_size + max_rts_data_segment_size then
+      (raise (TooLargeDataSegments (Printf.sprintf "The Wasm data segment size exceeds the supported maxmimum of %nMB." max_rts_data_segment_size)))
+    else
+      ()
+    )
+  end else ();
 
   let old_table_size = read_table_size em1.module_ in
-  let lib_table_start = align dylink.table_alignment old_table_size in
+  let lib_table_start = align_i32 dylink.table_alignment old_table_size in
+
+  let uses_memory64 = uses_memory64 em1.module_ in
 
   (* Fill in memory and table base pointers *)
   let dm2 = em2.module_
-    |> fill_memory_base_import lib_heap_start
-    |> fill_table_base_import lib_table_start in
-
+    |> fill_memory_base_import lib_heap_start uses_memory64
+    |> fill_table_base_import lib_table_start uses_memory64 in
+    
   let got_func_imports = collect_got_func_imports dm2 in
 
   (* Link functions *)
@@ -848,11 +899,11 @@ let link (em1 : extended_module) libname (em2 : extended_module) =
   (* Rename types in both modules to eliminate duplicate types. *)
 
   (* Maps function types to their indices in the new module we're creating *)
-  let type_indices : (Wasm.Types.func_type, int32) Hashtbl.t = Hashtbl.create 100 in
+  let type_indices : (Wasm_exts.Types.func_type, int32) Hashtbl.t = Hashtbl.create 100 in
 
   (* Get index of a function type. Creates a new one if we haven't added this
      type yet. *)
-  let add_or_get_ty (ty : Wasm.Types.func_type) =
+  let add_or_get_ty (ty : Wasm_exts.Types.func_type) =
     match Hashtbl.find_opt type_indices ty with
     | None ->
       let idx = Int32.of_int (Hashtbl.length type_indices) in
@@ -863,25 +914,28 @@ let link (em1 : extended_module) libname (em2 : extended_module) =
   in
 
   (* Rename a type in a module. First argument is the list of types in the module. *)
-  let ty_renamer (tys : Wasm.Types.func_type phrase list) (t : int32) : int32 =
+  let ty_renamer (tys : Wasm_exts.Types.func_type phrase list) (t : int32) : int32 =
     let fun_ty = List.nth tys (Int32.to_int t) in
     add_or_get_ty fun_ty.it
   in
 
-  (* Check that the first module generated by the compiler backend does not use 
-     active data segments. *)
   let is_active data_segment = match data_segment.it.dmode.it with
   | Active _ -> true
   | _ -> false
   in
   let em1_active_data_segments = List.filter is_active em1.module_.datas in
-  assert ((List.length em1_active_data_segments) = 0);
-  
   let is_passive data_segment = match data_segment.it.dmode.it with 
   | Passive -> true
   | _ -> false
   in
   let em1_passive_data_segments = List.filter is_passive em1.module_.datas in
+  
+  (* Check that the first module generated by the compiler backend does not use 
+     active data segments. *)
+  if uses_memory64 then
+    assert ((List.length em1_active_data_segments) = 0)
+  else ();
+  
   let dm2_data_segment_offset = List.length em1_passive_data_segments in
 
   (* Rename types in first module *)
@@ -906,7 +960,7 @@ let link (em1 : extended_module) libname (em2 : extended_module) =
   let add_call_ctors =
     match NameMap.find_opt (Lib.Utf8.decode "__wasm_call_ctors") fun_exports2 with
     | None -> fun em -> em
-    | Some fi -> prepend_to_start (funs2 fi) (add_or_get_ty (Wasm.Types.FuncType ([], [])))
+    | Some fi -> prepend_to_start (funs2 fi) (add_or_get_ty (Wasm_exts.Types.FuncType ([], [])))
   in
 
   let new_table_size =
@@ -914,7 +968,8 @@ let link (em1 : extended_module) libname (em2 : extended_module) =
   in
 
   (* Rust generates active data segments for the runtime system code that are not supported with orthogonal persistence.
-     Therefore, make the data segments passive and load them on initialization to their reserved static space. 
+     Therefore, for enhanced orthogonal persistence, make the data segments passive and load them on initialization to 
+     their reserved static space.
      Note: If Rust would also use passive data segments in future, the segment load indices need to be renumbered. *)
   let make_rts_data_segments_passive : module_' -> module_' = fun m ->
     let segment_mode' (dmode : segment_mode') = 
@@ -942,7 +997,7 @@ let link (em1 : extended_module) libname (em2 : extended_module) =
   
       let load_passive_segment index data_segment =
         let segment_index = Int32.of_int (Int.add index numbering_offset) in
-        let compile_const_i32 value = Const (Wasm.Values.I32 value @@ no_region) @@ no_region in
+        let compile_const_i32 value = Const (Wasm_exts.Values.I32 value @@ no_region) @@ no_region in
         let data_target = match data_segment.it.dmode.it with
           | Active { offset; _ } -> offset.it
           | _ -> raise (LinkError "Passive data segments are not yet supported in the RTS module")
@@ -979,11 +1034,11 @@ let link (em1 : extended_module) libname (em2 : extended_module) =
     |> rename_funcs_extended funs1
     |> rename_globals_extended globals1
     |> map_module (set_global heap_global new_heap_start)
-    |> map_module (set_memory_size new_heap_start)
+    |> map_module (set_memory_size (I64_convert.extend_i32_u new_heap_start))
     |> map_module (set_table_size new_table_size)
     )
     ( dm2
-    |> make_rts_data_segments_passive
+    |> (if uses_memory64 then make_rts_data_segments_passive else (fun m -> m))
     |> remove_imports is_fun_import fun_resolved21
     |> remove_imports is_global_import global_resolved21
     |> remove_imports is_memory_import [0l, 0l]
@@ -999,7 +1054,7 @@ let link (em1 : extended_module) libname (em2 : extended_module) =
     type_indices
   |> add_call_ctors
   |> remove_non_ic_exports (* only sane if no additional files get linked in *)
-  |> map_module (load_rts_data_segments dm2_data_segment_offset dm2.datas)
+  |> (if uses_memory64 then map_module (load_rts_data_segments dm2_data_segment_offset dm2.datas) else (fun m -> m))
   in
 
   (* Rename global and function indices in GOT.func stuff *)
diff --git a/src/lowering/desugar.ml b/src/lowering/desugar.ml
index 8e22d11fa89..9c498035d41 100644
--- a/src/lowering/desugar.ml
+++ b/src/lowering/desugar.ml
@@ -474,7 +474,12 @@ and export_runtime_information self_id =
   let bind2 = typ_arg scope_con2 Scope scope_bound in
   let gc_strategy = 
     let open Mo_config in
-    let strategy = "incremental" in
+    let strategy = match !Flags.gc_strategy with
+    | Flags.Default -> "default"
+    | Flags.MarkCompact -> "compacting"
+    | Flags.Copying -> "copying"
+    | Flags.Generational -> "generational"
+    | Flags.Incremental -> "incremental" in
     if !Flags.force_gc then (Printf.sprintf "%s force" strategy) else strategy
   in
   let prim_call function_name = primE (I.OtherPrim function_name) [] in
@@ -564,7 +569,7 @@ and build_actor at ts self_id es obj_typ =
     let vs = fresh_vars "v" (List.map (fun f -> f.T.typ) fields) in
     blockE
       ((match call_system_func_opt "preupgrade" es obj_typ with
-        | Some call -> [ expD (primE (I.ICPerformGC) []); expD call]
+        | Some call -> [ expD call]
         | None -> []) @
          [letP (seqP (List.map varP vs)) (* dereference any mutable vars, option 'em all *)
             (seqE (List.map (fun (i,t) -> optE (varE (var i t))) ids))])
@@ -580,7 +585,7 @@ and build_actor at ts self_id es obj_typ =
   let runtime_info_d, runtime_info_f = export_runtime_information self_id in
   I.(ActorE (footprint_d @ runtime_info_d @ ds', footprint_f @ runtime_info_f @ fs,
      { meta;
-       preupgrade = with_stable_vars (fun e -> primE (I.ICStableWrite ty) [e]);
+       preupgrade = (primE (I.ICStableWrite ty) []);
        postupgrade =
          (match call_system_func_opt "postupgrade" es obj_typ with
           | Some call -> call
@@ -600,11 +605,12 @@ and build_actor at ts self_id es obj_typ =
        inspect =
          (match call_system_func_opt "inspect" es obj_typ with
           | Some call -> call
-          | None -> tupE [])
+          | None -> tupE []);
+       stable_record = with_stable_vars (fun e -> e);
+       stable_type = ty;
      },
      obj_typ))
 
-
 and stabilize stab_opt d =
   let s = match stab_opt with None -> S.Flexible | Some s -> s.it  in
   match s, d.it with
@@ -1030,7 +1036,7 @@ let import_compiled_class (lib : S.comp_unit) wasm : import_declaration =
   let c', _ = T.as_con (List.hd cs') in
   let install_actor_helper = var "@install_actor_helper"
     T.(Func (Local, Returns, [scope_bind],
-      [install_arg_typ; blob; blob],
+      [install_arg_typ; bool; blob; blob],
       [Async(Cmp, Var (default_scope_var, 0), principal)]))
   in
   let wasm_blob = fresh_var "wasm_blob" T.blob in
@@ -1050,6 +1056,7 @@ let import_compiled_class (lib : S.comp_unit) wasm : import_declaration =
           (callE (varE install_actor_helper) cs'
             (tupE [
               install_arg;
+              boolE ((!Mo_config.Flags.enhanced_orthogonal_persistence)); 
               varE wasm_blob;
               primE (Ir.SerializePrim ts1') [seqE (List.map varE vs)]])))
         (primE (Ir.CastPrim (T.principal, t_actor)) [varE principal]))
@@ -1121,18 +1128,22 @@ let transform_unit_body (u : S.comp_unit_body) : Ir.comp_unit =
         T.promote rng
       | _ -> assert false
     in
+    let actor_expression = build_actor u.at ts (Some self_id) fields obj_typ in
     let e = wrap {
-       it = build_actor u.at ts (Some self_id) fields obj_typ;
+       it = actor_expression;
        at = no_region;
        note = Note.{ def with typ = obj_typ } }
     in
     begin match e.it with
-    | I.ActorE(ds, fs, u, t) -> I.ActorU (Some args, ds, fs, u, t)
+    | I.ActorE(ds, fs, u, t) ->
+      I.ActorU (Some args, ds, fs, u, t)
     | _ -> assert false
     end
   | S.ActorU (self_id, fields) ->
-    begin match build_actor u.at [] self_id fields u.note.S.note_typ with
-    | I.ActorE (ds, fs, u, t) -> I.ActorU (None, ds, fs, u, t)
+    let actor_expression = build_actor u.at [] self_id fields u.note.S.note_typ in
+    begin match actor_expression with
+    | I.ActorE (ds, fs, u, t) ->
+        I.ActorU (None, ds, fs, u, t)
     | _ -> assert false
     end
 
diff --git a/src/mo_config/flags.ml b/src/mo_config/flags.ml
index bc7011895c9..2b92d84b80e 100644
--- a/src/mo_config/flags.ml
+++ b/src/mo_config/flags.ml
@@ -4,6 +4,13 @@ module M = Map.Make(String)
 
 type compile_mode = WasmMode | ICMode | RefMode | WASIMode
 
+type gc_strategy = Default | MarkCompact | Copying | Generational | Incremental
+
+type instruction_limits = {
+  upgrade: int;
+  update_call: int;
+}
+
 let trace = ref false
 let verbose = ref false
 let print_warnings = ref true
@@ -38,13 +45,28 @@ let omit_metadata_names : string list ref = ref []
 let compiled = ref false
 let error_detail = ref 2
 let sanity = ref false
+let gc_strategy = ref Default
 let force_gc = ref false
 let global_timer = ref true
 let experimental_field_aliasing = ref false
 let ocaml_js = ref false
-let rtti = ref true
+let rts_stack_pages_default = 32 (* 2MB *)
+let rts_stack_pages : int option ref = ref None
+let rtti = ref false
 let trap_on_call_error = ref false
 let use_stable_regions = ref false
+let enhanced_orthogonal_persistence = ref false
 let share_code = ref false
+let stabilization_instruction_limit_default = {
+  upgrade = 180_000_000_000; (* 200 billion limit with 10% reserve *)
+  update_call = 18_000_000_000; (* 20 billion limit with 10% reserve *)
+}
+let stabilization_instruction_limit = ref stabilization_instruction_limit_default
+let stable_memory_access_limit_default = 
+  let gigabyte = 1024 * 1024 * 1024 in {
+  upgrade = 6 * gigabyte; (* 8 GB limit with 2 GB reserves *)
+  update_call = 1 * gigabyte; (* 2 GB limit with 1 GB reserve *)
+}
+let stable_memory_access_limit = ref stable_memory_access_limit_default
 let experimental_stable_memory_default = 0 (* _ < 0: error; _ = 0: warn, _ > 0: allow *)
 let experimental_stable_memory = ref experimental_stable_memory_default
diff --git a/src/pipeline/pipeline.ml b/src/pipeline/pipeline.ml
index 23e9a5c649a..d24ebee6b14 100644
--- a/src/pipeline/pipeline.ml
+++ b/src/pipeline/pipeline.ml
@@ -678,14 +678,47 @@ let ir_passes mode prog_ir name =
 (* Compilation *)
 
 let load_as_rts () =
-  let rts = match !Flags.sanity with
-    | false -> Rts.wasm_release
-    | true -> Rts.wasm_debug
+  let rts = match (!Flags.enhanced_orthogonal_persistence, !Flags.sanity, !Flags.gc_strategy) with
+    | (true, false, Flags.Incremental) -> Rts.wasm_eop_release
+    | (true, true, Flags.Incremental) -> Rts.wasm_eop_debug
+    | (false, false, Flags.Copying) 
+    | (false, false, Flags.MarkCompact)
+    | (false, false, Flags.Generational) -> Rts.wasm_non_incremental_release
+    | (false, true, Flags.Copying)
+    | (false, true, Flags.MarkCompact)
+    | (false, true, Flags.Generational) -> Rts.wasm_non_incremental_debug
+    | (false, false, Flags.Incremental) -> Rts.wasm_incremental_release
+    | (false, true, Flags.Incremental) -> Rts.wasm_incremental_debug
+    | _ -> assert false
   in
   Wasm_exts.CustomModuleDecode.decode "rts.wasm" (Lazy.force rts)
 
 type compile_result = (Idllib.Syntax.prog * Wasm_exts.CustomModule.extended_module) Diag.result
 
+let invalid_flag message =
+  builtin_error "compile" (Printf.sprintf "Invalid compiler flag combination: %s" message) []
+
+let adjust_flags () =
+  if !Flags.enhanced_orthogonal_persistence then
+    begin
+      (match !Flags.gc_strategy with
+      | Flags.Default | Flags.Incremental -> Flags.gc_strategy := Flags.Incremental;
+      | Flags.Copying -> invalid_flag "--copying-gc is not supported with --enhanced-orthogonal-persistence"
+      | Flags.MarkCompact -> invalid_flag "--compacting-gc is not supported with --enhanced-orthogonal-persistence"
+      | Flags.Generational -> invalid_flag "--generational-gc is not supported with --enhanced-orthogonal-persistence");
+      (if !Flags.rts_stack_pages <> None then invalid_flag "--rts-stack-pages is not supported with --enhanced-orthogonal-persistence");
+      Flags.rtti := true
+    end
+  else
+    begin
+      (if !Flags.gc_strategy = Flags.Default then Flags.gc_strategy := Flags.Copying);
+      (if !Flags.rts_stack_pages = None then Flags.rts_stack_pages := Some Flags.rts_stack_pages_default);
+      (if !Flags.stabilization_instruction_limit <> Flags.stabilization_instruction_limit_default then
+        invalid_flag "--stabilization-instruction-limit is only supported with --enhanced-orthogonal-persistence");
+      (if !Flags.stable_memory_access_limit <> Flags.stable_memory_access_limit_default then
+        invalid_flag "--stable-memory-access-limit is only supported with --enhanced-orthogonal-persistence")
+    end
+
 (* This transforms the flat list of libs (some of which are classes)
    into a list of imported libs and (compiled) classes *)
 let rec compile_libs mode libs : Lowering.Desugar.import_declaration =
@@ -707,8 +740,12 @@ and compile_unit mode do_link imports u : Wasm_exts.CustomModule.extended_module
   let prog_ir = desugar_unit imports u name in
   let prog_ir = ir_passes mode prog_ir name in
   phase "Compiling" name;
+  adjust_flags ();
   let rts = if do_link then Some (load_as_rts ()) else None in
-  Codegen.Compile.compile mode rts prog_ir
+  if !Flags.enhanced_orthogonal_persistence then
+    Codegen.Compile_enhanced.compile mode rts prog_ir
+  else
+    Codegen.Compile_classical.compile mode rts prog_ir
 
 and compile_unit_to_wasm mode imports (u : Syntax.comp_unit) : string =
   let wasm_mod = compile_unit mode true imports u in
diff --git a/src/prelude/internals.mo b/src/prelude/internals.mo
index b6116f27731..d5aff87983d 100644
--- a/src/prelude/internals.mo
+++ b/src/prelude/internals.mo
@@ -436,8 +436,10 @@ func @install_actor_helper(
       #upgrade : actor {} ;
       #upgrade_with_persistence : { wasm_memory_persistence: WasmMemoryPersistence; canister: actor {} };
     },
+    enhanced_orthogonal_persistence : Bool,
     wasm_module : Blob,
-    arg : Blob)
+    arg : Blob,
+    )
   : async* Principal = async* {
   let (mode, canister_id) =
     switch install_arg {
@@ -457,8 +459,13 @@ func @install_actor_helper(
         (#reinstall, (prim "principalOfActor" : (actor {}) -> Principal) actor1)
       };
       case (#upgrade actor2) {
+        let wasm_memory_persistence = if enhanced_orthogonal_persistence { 
+          ?(#Keep) 
+        } else { 
+          null 
+        };
         let upgradeOptions = {
-          wasm_memory_persistence = ?(#Keep);
+          wasm_memory_persistence;
         };
         ((#upgrade (?upgradeOptions)), (prim "principalOfActor" : (actor {}) -> Principal) actor2)
       };
@@ -668,5 +675,5 @@ func @cancelTimer(id : Nat) {
   }
 };
 
-func @set_global_timer(time : Nat64) = ignore (prim "global_timer_set" : Nat64 -> Nat64) time;
 
+func @set_global_timer(time : Nat64) = ignore (prim "global_timer_set" : Nat64 -> Nat64) time;
diff --git a/src/rts/gen.sh b/src/rts/gen.sh
index 513d2df5b52..34624d62f5f 100755
--- a/src/rts/gen.sh
+++ b/src/rts/gen.sh
@@ -11,5 +11,11 @@ if [ -z "$1" ]; then
   exit 1
 fi
 
-perl -0777 -ne 'print "let wasm_release = lazy \""; printf "\\x%02x", $_ for unpack("C*", $_); print "\"\n";' "$1/mo-rts.wasm" > "$file"
-perl -0777 -ne 'print "let wasm_debug = lazy \""; printf "\\x%02x", $_ for unpack("C*", $_); print "\"";' "$1/mo-rts-debug.wasm" >> "$file"
+perl -0777 -ne 'print "let wasm_non_incremental_release = lazy \""; printf "\\x%02x", $_ for unpack("C*", $_); print "\"\n";' "$1/mo-rts-non-incremental.wasm" > "$file"
+perl -0777 -ne 'print "let wasm_non_incremental_debug = lazy \""; printf "\\x%02x", $_ for unpack("C*", $_); print "\"";' "$1/mo-rts-non-incremental-debug.wasm" >> "$file"
+
+perl -0777 -ne 'print "let wasm_incremental_release = lazy \""; printf "\\x%02x", $_ for unpack("C*", $_); print "\"\n";' "$1/mo-rts-incremental.wasm" >> "$file"
+perl -0777 -ne 'print "let wasm_incremental_debug = lazy \""; printf "\\x%02x", $_ for unpack("C*", $_); print "\"";' "$1/mo-rts-incremental-debug.wasm" >> "$file"
+
+perl -0777 -ne 'print "let wasm_eop_release = lazy \""; printf "\\x%02x", $_ for unpack("C*", $_); print "\"\n";' "$1/mo-rts-eop.wasm" >> "$file"
+perl -0777 -ne 'print "let wasm_eop_debug = lazy \""; printf "\\x%02x", $_ for unpack("C*", $_); print "\"";' "$1/mo-rts-eop-debug.wasm" >> "$file"
diff --git a/src/rts/rts.ml b/src/rts/rts.ml
index 39fff73cb41..f62381a16aa 100644
--- a/src/rts/rts.ml
+++ b/src/rts/rts.ml
@@ -1,8 +1,8 @@
 (*
-This source file loads the RTS (`mo-rts.wasm` etc.) via the environment
+This source file loads the RTS Wasm files via the environment
 variables. This is for local development (e.g. inside `nix-shell`). The nix
 build of `moc` will statically replace this file with one that just embeds
-`mo-rts.wasm` etc. as a static string, to produce a fully self-contained `moc`
+RTS Wasm files as static strings, to produce a fully self-contained `moc`
 binary for distribution.
 *)
 
@@ -19,5 +19,11 @@ let load_file env =
     Printf.eprintf "Environment variable %s not set. Please run moc via the bin/moc wrapper (which should be in your PATH in the nix-shell)." env;
     exit 1
 
-let wasm_release : string Lazy.t = lazy (load_file "MOC_RELEASE_RTS")
-let wasm_debug : string Lazy.t = lazy (load_file "MOC_DEBUG_RTS")
+let wasm_non_incremental_release : string Lazy.t = lazy (load_file "MOC_NON_INCREMENTAL_RELEASE_RTS")
+let wasm_non_incremental_debug : string Lazy.t = lazy (load_file "MOC_NON_INCREMENTAL_DEBUG_RTS")
+
+let wasm_incremental_release : string Lazy.t = lazy (load_file "MOC_INCREMENTAL_RELEASE_RTS")
+let wasm_incremental_debug : string Lazy.t = lazy (load_file "MOC_INCREMENTAL_DEBUG_RTS")
+
+let wasm_eop_release : string Lazy.t = lazy (load_file "MOC_EOP_RELEASE_RTS")
+let wasm_eop_debug : string Lazy.t = lazy (load_file "MOC_EOP_DEBUG_RTS")
diff --git a/src/rts/rts.mli b/src/rts/rts.mli
index 27b30301429..5b9cdbacb96 100644
--- a/src/rts/rts.mli
+++ b/src/rts/rts.mli
@@ -1,2 +1,9 @@
-val wasm_release : string Lazy.t
-val wasm_debug : string Lazy.t
+val wasm_non_incremental_release : string Lazy.t
+val wasm_non_incremental_debug : string Lazy.t
+
+val wasm_incremental_release : string Lazy.t
+val wasm_incremental_debug : string Lazy.t
+
+(* eop = enhanced orthogonal persistence *)
+val wasm_eop_release : string Lazy.t
+val wasm_eop_debug : string Lazy.t
diff --git a/src/wasm-exts/ast.ml b/src/wasm-exts/ast.ml
index 60b4d161d3f..35b8d74537a 100644
--- a/src/wasm-exts/ast.ml
+++ b/src/wasm-exts/ast.ml
@@ -5,6 +5,7 @@ reference implementation.
 Base revision: WebAssembly/spec@a7a1856.
 
 The changes are:
+ * Manual selective support for bulk-memory operations `memory_copy` and `memory_fill` (WebAssembly/spec@7fa2f20).
  * Pseudo-instruction Meta for debug information
  * StableMemory, StableGrow, StableRead, StableWrite instructions.
  * Support for passive data segments (incl. `MemoryInit`).
@@ -31,9 +32,7 @@ easily apply diffs from the original code (possibly manually).
  * These conventions mostly follow standard practice in language semantics.
  *)
 
-open Wasm.Types
-module Values = Wasm.Values
-module Memory = Wasm.Memory
+open Types
 open Wasm.Source
 
 
@@ -112,7 +111,13 @@ and instr' =
   | Store of storeop                  (* write memory at address *)
   | MemorySize                        (* size of linear memory *)
   | MemoryGrow                        (* grow linear memory *)
+  (* Manual extension for bulk memory operations *)
+  | MemoryFill                        (* fill memory range with value *)
+  | MemoryCopy                        (* copy memory ranges *)
+  (* End of manual extension *)
+  (* Manual extension for passive data segments *)
   | MemoryInit of var                 (* initialize memory range from segment *)
+  (* End of manual extension *)
   | Const of literal                  (* constant *)
   | Test of testop                    (* numeric test *)
   | Compare of relop                  (* numeric comparison *)
diff --git a/src/wasm-exts/customModuleDecode.ml b/src/wasm-exts/customModuleDecode.ml
index 39db6267709..905c1b23a6a 100644
--- a/src/wasm-exts/customModuleDecode.ml
+++ b/src/wasm-exts/customModuleDecode.ml
@@ -1,9 +1,11 @@
 (*
-This module originated as a copy of interpreter/binary/encode.ml in the
+This module originated as a copy of interpreter/binary/decode.ml in the
 reference implementation.
+With adjustments from memory64.
 
 The changes are:
  * Support for additional custom sections
+ * Manual selective support for bulk-memory operations `memory_copy` and `memory_fill` (WebAssembly/spec@7fa2f20).
  * Support for passive data segments (incl. `MemoryInit`).
 
 The code is otherwise as untouched as possible, so that we can relatively
@@ -18,14 +20,13 @@ TODO:
 
 module Error = Wasm.Error
 module Source = Wasm.Source
-module I32 = Wasm.I32
-module I64 = Wasm.I64
 module F32 = Wasm.F32
 module F64 = Wasm.F64
 module I32_convert = Wasm.I32_convert
 module I64_convert = Wasm.I64_convert
 module Utf8 = Lib.Utf8
 open CustomModule
+open Types
 
 (* Decoding stream *)
 
@@ -125,8 +126,8 @@ let rec vsN n s =
   then (if b land 0x40 = 0 then x else Int64.(logor x (logxor (-1L) 0x7fL)))
   else Int64.(logor x (shift_left (vsN (n - 7) s) 7))
 
-let vu1 s = Int64.to_int (vuN 1 s)
 let vu32 s = Int64.to_int32 (vuN 32 s)
+let vu64 s = vuN 64 s
 let vs7 s = Int64.to_int (vsN 7 s)
 let vs32 s = Int64.to_int32 (vsN 32 s)
 let vs33 s = I32_convert.wrap_i64 (vsN 33 s)
@@ -140,7 +141,6 @@ let len32 s =
   if I32.le_u n (Int32.of_int (len s)) then Int32.to_int n else
     error s pos "length out of bounds"
 
-let bool s = (vu1 s = 1)
 let string s = let n = len32 s in get_string n s
 let rec list f n s = if n = 0 then [] else let x = f s in x :: list f (n - 1) s
 let opt f b s = if b then Some (f s) else None
@@ -161,7 +161,7 @@ let sized (f : int -> stream -> 'a) (s : stream) =
 
 (* Types *)
 
-open Wasm.Types
+open Types
 
 let value_type s =
   match vs7 s with
@@ -186,19 +186,23 @@ let func_type s =
   | _ -> error s (pos s - 1) "malformed function type"
 
 let limits vu s =
-  let has_max = bool s in
+  let flags = u8 s in
+  require (flags land 0xfa = 0) s (pos s - 1) "malformed limits flags";
+  let has_max = (flags land 1 = 1) in
+  let is64 = (flags land 4 = 4) in
   let min = vu s in
   let max = opt vu has_max s in
-  {min; max}
+  {min; max}, is64
 
 let table_type s =
   let t = elem_type s in
-  let lim = limits vu32 s in
+  let lim, is64 = limits vu32 s in
+  require (not is64) s (pos s - 1) "tables cannot have 64-bit indices";
   TableType (lim, t)
 
 let memory_type s =
-  let lim = limits vu32 s in
-  MemoryType lim
+  let lim, is64 = limits vu64 s in
+  MemoryType (lim, if is64 then I64IndexType else I32IndexType)
 
 let mutability s =
   match u8 s with
@@ -226,7 +230,7 @@ let zero s = expect 0x00 s "zero byte expected"
 let memop s =
   let align = vu32 s in
   require (I32.le_u align 32l) s (pos s - 1) "malformed memop flags";
-  let offset = vu32 s in
+  let offset = vu64 s in
   Int32.to_int align, offset
 
 let block_type s =
@@ -246,6 +250,10 @@ let math_prefix s =
   | 0x05 -> i64_trunc_sat_f32_u
   | 0x06 -> i64_trunc_sat_f64_s
   | 0x07 -> i64_trunc_sat_f64_u
+  (* Manual extension for specific bulk-memory operations *)
+  | 0x0a -> zero s; zero s; memory_copy
+  | 0x0b -> zero s; memory_fill
+  (* End of manual extension *)
   (* Manual extension for passive data segments *)
   | 0x08 ->
     let x = at var s in
diff --git a/src/wasm-exts/customModuleEncode.ml b/src/wasm-exts/customModuleEncode.ml
index bad8e6782c3..1c2625139f7 100644
--- a/src/wasm-exts/customModuleEncode.ml
+++ b/src/wasm-exts/customModuleEncode.ml
@@ -1,10 +1,12 @@
 (*
 This module originated as a copy of interpreter/binary/encode.ml in the
 reference implementation.
+With adjustments from memory64.
 
 The changes are:
  * Support for writing out a source map for the Code parts
  * Support for additional custom sections
+ * Manual selective support for bulk-memory operations `memory_copy` and `memory_fill` (WebAssembly/spec@7fa2f20).
  * Support for passive data segments (incl. `MemoryInit`).
 
 The code is otherwise as untouched as possible, so that we can relatively
@@ -300,7 +302,6 @@ let encode (em : extended_module) =
       if -64L <= i && i < 64L then u8 b
       else (u8 (b lor 0x80); vs64 (Int64.shift_right i 7))
 
-    let vu1 i = vu64 Int64.(logand (of_int i) 1L)
     let vu32 i = vu64 Int64.(logand (of_int32 i) 0xffffffffL)
     let vs7 i = vs64 (Int64.of_int i)
     let vs32 i = vs64 (Int64.of_int32 i)
@@ -308,13 +309,14 @@ let encode (em : extended_module) =
     let f32 x = u32 (Wasm.F32.to_bits x)
     let f64 x = u64 (Wasm.F64.to_bits x)
 
+    let flag b i = if b then 1 lsl i else 0
+
     let len i =
       if Int32.to_int (Int32.of_int i) <> i then
         Code.error Wasm.Source.no_region
           "cannot encode length with more than 32 bit";
       vu32 (Int32.of_int i)
 
-    let bool b = vu1 (if b then 1 else 0)
     let string bs = len (String.length bs); put_string s bs
     let name n = string (Lib.Utf8.encode n)
     let list f xs = List.iter f xs
@@ -334,7 +336,7 @@ let encode (em : extended_module) =
 
     (* Types *)
 
-    open Wasm.Types
+    open Types
 
     let value_type = function
       | I32Type -> vs7 (-0x01)
@@ -349,14 +351,15 @@ let encode (em : extended_module) =
     let func_type = function
       | FuncType (ins, out) -> vs7 (-0x20); stack_type ins; stack_type out
 
-    let limits vu {min; max} =
-      bool (max <> None); vu min; opt vu max
+    let limits vu {min; max} it =
+      let flags = flag (max <> None) 0 + flag (it = I64IndexType) 2 in
+      u8 flags; vu min; opt vu max
 
     let table_type = function
-      | TableType (lim, t) -> elem_type t; limits vu32 lim
+      | TableType (lim, t) -> elem_type t; limits vu32 lim I32IndexType
 
     let memory_type = function
-      | MemoryType lim -> limits vu32 lim
+      | MemoryType (lim, it) -> limits vu64 lim it
 
     let mutability = function
       | Immutable -> u8 0
@@ -369,12 +372,12 @@ let encode (em : extended_module) =
 
     open Wasm.Source
     open Ast
-    open Wasm.Values
+    open Values
 
     let op n = u8 n
     let end_ () = op 0x0b
 
-    let memop {align; offset; _} = vu32 (Int32.of_int align); vu32 offset
+    let memop {align; offset; _} = vu32 (Int32.of_int align); vu64 offset
 
     let var x = vu32 x.it
 
@@ -472,6 +475,10 @@ let encode (em : extended_module) =
       | MemorySize -> op 0x3f; u8 0x00
       | MemoryGrow -> op 0x40; u8 0x00
 
+      (* Manual extension for bulk-memory operations *)
+      | MemoryFill -> op 0xfc; vu32 0x0bl; u8 0x00
+      | MemoryCopy -> op 0xfc; vu32 0x0al; u8 0x00; u8 0x00
+      (* End of manual extension *)
       (* Manual extension for passive data segments *)
       | MemoryInit x -> op 0xfc; vu32 0x08l; var x; u8 0x00
       (* End of manual extension *)
diff --git a/src/wasm-exts/memory.ml b/src/wasm-exts/memory.ml
new file mode 100644
index 00000000000..6f45d90293b
--- /dev/null
+++ b/src/wasm-exts/memory.ml
@@ -0,0 +1,155 @@
+(*
+This module originated as a copy of interpreter/runtime/memory.ml in the
+reference implementation.
+With adjustments from memory64.
+*)
+
+open Bigarray
+open Lib.Bigarray
+open Types
+open Values
+module I64_convert = Wasm.I64_convert
+
+type size = int64  (* number of pages *)
+type address = int64
+type offset = int64
+
+type memory' = (int, int8_unsigned_elt, c_layout) Array1.t
+type memory = {mutable content : memory'; max : size option; it : index_type}
+type t = memory
+
+exception Type
+exception Bounds
+exception SizeOverflow
+exception SizeLimit
+exception OutOfMemory
+
+let page_size = 0x10000L (* 64 KiB *)
+
+let within_limits n = function
+  | None -> true
+  | Some max -> I64.le_u n max
+
+let create n it =
+  if I64.gt_u n 0x10000L && it = I32IndexType then raise SizeOverflow else
+  try
+    let size = Int64.(mul n page_size) in
+    let mem = Array1_64.create Int8_unsigned C_layout size in
+    Array1.fill mem 0;
+    mem
+  with Out_of_memory -> raise OutOfMemory
+
+let alloc (MemoryType ({min; max}, it)) =
+  assert (within_limits min max);
+  {content = create min it; max; it}
+
+let bound mem =
+  Array1_64.dim mem.content
+
+let size mem =
+  Int64.(div (bound mem) page_size)
+
+let type_of mem =
+  MemoryType ({min = size mem; max = mem.max}, mem.it)
+
+let index_of mem = mem.it
+
+let value_of_address it x =
+  if it = I64IndexType then I64 (x) else I32 (Int64.to_int32 x)
+
+let address_of_value x =
+  match x with
+  | I64 i -> i
+  | I32 i -> I64_convert.extend_i32_u i
+  | _ -> raise Type
+
+let grow mem delta =
+  let old_size = size mem in
+  let new_size = Int64.add old_size delta in
+  if I64.gt_u old_size new_size then raise SizeOverflow else
+  if not (within_limits new_size mem.max) then raise SizeLimit else
+  let after = create new_size mem.it in
+  let dim = Array1_64.dim mem.content in
+  Array1.blit (Array1_64.sub mem.content 0L dim) (Array1_64.sub after 0L dim);
+  mem.content <- after
+
+let load_byte mem a =
+  try Array1_64.get mem.content a with Invalid_argument _ -> raise Bounds
+
+let store_byte mem a b =
+  try Array1_64.set mem.content a b with Invalid_argument _ -> raise Bounds
+
+let load_bytes mem a n =
+  let buf = Buffer.create n in
+  for i = 0 to n - 1 do
+    Buffer.add_char buf (Char.chr (load_byte mem Int64.(add a (of_int i))))
+  done;
+  Buffer.contents buf
+
+let store_bytes mem a bs =
+  for i = String.length bs - 1 downto 0 do
+    store_byte mem Int64.(add a (of_int i)) (Char.code bs.[i])
+  done
+
+let effective_address a o =
+  let ea = Int64.(add a o) in
+  if I64.lt_u ea a then raise Bounds;
+  ea
+
+let loadn mem a o n =
+  assert (n > 0 && n <= 8);
+  let rec loop a n =
+    if n = 0 then 0L else begin
+      let x = Int64.(shift_left (loop (add a 1L) (n - 1)) 8) in
+      Int64.logor (Int64.of_int (load_byte mem a)) x
+    end
+  in loop (effective_address a o) n
+
+let storen mem a o n x =
+  assert (n > 0 && n <= 8);
+  let rec loop a n x =
+    if n > 0 then begin
+      Int64.(loop (effective_address a 1L) (n - 1) (shift_right x 8));
+      store_byte mem a (Int64.to_int x land 0xff)
+    end
+  in loop (effective_address a o) n x
+
+let load_value mem a o t =
+  let n = loadn mem a o (Types.size t) in
+  match t with
+  | I32Type -> I32 (Int64.to_int32 n)
+  | I64Type -> I64 n
+  | F32Type -> F32 (F32.of_bits (Int64.to_int32 n))
+  | F64Type -> F64 (F64.of_bits n)
+
+let store_value mem a o v =
+  let x =
+    match v with
+    | I32 x -> Int64.of_int32 x
+    | I64 x -> x
+    | F32 x -> Int64.of_int32 (F32.to_bits x)
+    | F64 x -> F64.to_bits x
+  in storen mem a o (Types.size (Values.type_of v)) x
+
+let extend x n = function
+  | ZX -> x
+  | SX -> let sh = 64 - 8 * n in Int64.(shift_right (shift_left x sh) sh)
+
+let load_packed sz ext mem a o t =
+  assert (packed_size sz <= Types.size t);
+  let n = packed_size sz in
+  let x = extend (loadn mem a o n) n ext in
+  match t with
+  | I32Type -> I32 (Int64.to_int32 x)
+  | I64Type -> I64 x
+  | _ -> raise Type
+
+let store_packed sz mem a o v =
+  assert (packed_size sz <= Types.size (Values.type_of v));
+  let n = packed_size sz in
+  let x =
+    match v with
+    | I32 x -> Int64.of_int32 x
+    | I64 x -> x
+    | _ -> raise Type
+  in storen mem a o n x
diff --git a/src/wasm-exts/memory.mli b/src/wasm-exts/memory.mli
new file mode 100644
index 00000000000..01da46c7c22
--- /dev/null
+++ b/src/wasm-exts/memory.mli
@@ -0,0 +1,49 @@
+(*
+This module originated as a copy of interpreter/runtime/memory.mli in the
+reference implementation.
+With adjustments from memory64.
+*)
+
+open Types
+open Values
+
+type memory
+type t = memory
+
+type size = int64  (* number of pages *)
+type address = int64
+type offset = int64
+
+exception Type
+exception Bounds
+exception SizeOverflow
+exception SizeLimit
+exception OutOfMemory
+
+val page_size : int64
+
+val alloc : memory_type -> memory (* raises SizeOverflow, OutOfMemory *)
+val type_of : memory -> memory_type
+val index_of : memory -> index_type
+val size : memory -> size
+val bound : memory -> address
+val value_of_address : index_type -> address -> value
+val address_of_value : value -> address
+val grow : memory -> size -> unit
+  (* raises SizeLimit, SizeOverflow, OutOfMemory *)
+
+val load_byte : memory -> address -> int (* raises Bounds *)
+val store_byte : memory -> address -> int -> unit (* raises Bounds *)
+val load_bytes : memory -> address -> int -> string (* raises Bounds *)
+val store_bytes : memory -> address -> string -> unit (* raises Bounds *)
+
+val load_value :
+  memory -> address -> offset -> value_type -> value (* raises Bounds *)
+val store_value :
+  memory -> address -> offset -> value -> unit (* raises Bounds *)
+val load_packed :
+  pack_size -> extension -> memory -> address -> offset -> value_type -> value
+    (* raises Type, Bounds *)
+val store_packed :
+  pack_size -> memory -> address -> offset -> value -> unit
+    (* raises Type, Bounds *)
diff --git a/src/wasm-exts/operators.ml b/src/wasm-exts/operators.ml
index 7e000e1ae91..2fda88ebd76 100644
--- a/src/wasm-exts/operators.ml
+++ b/src/wasm-exts/operators.ml
@@ -7,6 +7,7 @@ that it got basically replicated into the customModuleDecode.ml file.
 Base revision: WebAssembly/spec@a7a1856.
 
 The changes are:
+  * Manual selective support for bulk-memory operations `memory_copy` and `memory_fill` (WebAssembly/spec@7fa2f20).
   * Support for passive data segments (incl. `MemoryInit`).
 
 The code is otherwise as untouched as possible, so that we can relatively
@@ -14,8 +15,8 @@ easily apply diffs from the original code (possibly manually).
 *)
 
 open Wasm.Source
-open Wasm.Types
-open Wasm.Values
+open Types
+open Values
 open Ast
 
 
@@ -230,6 +231,10 @@ let f64_reinterpret_i64 = Convert (F64 F64Op.ReinterpretInt)
 let memory_size = MemorySize
 let memory_grow = MemoryGrow
 
+(* Manual extension for specific bulk-memory operations *)
+let memory_fill = MemoryFill
+let memory_copy = MemoryCopy
+(* End of manual extension *)
 (* Manual extension for passive data segments *)
 let memory_init x = MemoryInit x
 (* End of manual extension *)
diff --git a/src/wasm-exts/types.ml b/src/wasm-exts/types.ml
new file mode 100644
index 00000000000..6e7ebcd37f8
--- /dev/null
+++ b/src/wasm-exts/types.ml
@@ -0,0 +1,140 @@
+(*
+This module originated as a copy of interpreter/syntax/types.ml in the
+reference implementation.
+With adjustments from memory 64.
+*)
+
+module I32 = Wasm.I32
+module I64 = Wasm.I64
+
+let rec map_filter f = function
+| [] -> []
+| x::xs ->
+  match f x with
+  | None -> map_filter f xs
+  | Some y -> y :: map_filter f xs
+
+(* Types *)
+
+type value_type = I32Type | I64Type | F32Type | F64Type
+type index_type = I32IndexType | I64IndexType
+type elem_type = FuncRefType
+type stack_type = value_type list
+type func_type = FuncType of stack_type * stack_type
+
+type 'a limits = {min : 'a; max : 'a option}
+type mutability = Immutable | Mutable
+type table_type = TableType of Int32.t limits * elem_type
+type memory_type = MemoryType of Int64.t limits * index_type
+type global_type = GlobalType of value_type * mutability
+type extern_type =
+  | ExternFuncType of func_type
+  | ExternTableType of table_type
+  | ExternMemoryType of memory_type
+  | ExternGlobalType of global_type
+
+type pack_size = Pack8 | Pack16 | Pack32
+type extension = SX | ZX
+
+
+(* Attributes *)
+
+let size = function
+  | I32Type | F32Type -> 4
+  | I64Type | F64Type -> 8
+
+let packed_size = function
+  | Pack8 -> 1
+  | Pack16 -> 2
+  | Pack32 -> 4
+
+let value_type_of_index_type = function
+  | I32IndexType -> I32Type
+  | I64IndexType -> I64Type
+
+
+(* Subtyping *)
+
+let match_limits ge lim1 lim2 =
+  ge lim1.min lim2.min &&
+  match lim1.max, lim2.max with
+  | _, None -> true
+  | None, Some _ -> false
+  | Some i, Some j -> ge j i
+
+let match_func_type ft1 ft2 =
+  ft1 = ft2
+
+let match_table_type (TableType (lim1, et1)) (TableType (lim2, et2)) =
+  et1 = et2 && match_limits I32.ge_u lim1 lim2
+
+let match_memory_type (MemoryType (lim1, it1)) (MemoryType (lim2, it2)) =
+  it1 = it2 && match_limits I64.ge_u lim1 lim2
+
+let match_global_type gt1 gt2 =
+  gt1 = gt2
+
+let match_extern_type et1 et2 =
+  match et1, et2 with
+  | ExternFuncType ft1, ExternFuncType ft2 -> match_func_type ft1 ft2
+  | ExternTableType tt1, ExternTableType tt2 -> match_table_type tt1 tt2
+  | ExternMemoryType mt1, ExternMemoryType mt2 -> match_memory_type mt1 mt2
+  | ExternGlobalType gt1, ExternGlobalType gt2 -> match_global_type gt1 gt2
+  | _, _ -> false
+
+
+(* Filters *)
+
+let funcs =
+  map_filter (function ExternFuncType t -> Some t | _ -> None)
+let tables =
+  map_filter (function ExternTableType t -> Some t | _ -> None)
+let memories =
+  map_filter (function ExternMemoryType t -> Some t | _ -> None)
+let globals =
+  map_filter (function ExternGlobalType t -> Some t | _ -> None)
+
+(* String conversion *)
+
+let string_of_value_type = function
+  | I32Type -> "i32"
+  | I64Type -> "i64"
+  | F32Type -> "f32"
+  | F64Type -> "f64"
+
+let string_of_value_types = function
+  | [t] -> string_of_value_type t
+  | ts -> "[" ^ String.concat " " (List.map string_of_value_type ts) ^ "]"
+
+let string_of_elem_type = function
+  | FuncRefType -> "funcref"
+
+let string_of_limits to_string {min; max} =
+  to_string min ^
+  (match max with None -> "" | Some n -> " " ^ to_string n)
+
+let string_of_memory_type = function
+  | MemoryType (lim, it) ->
+    string_of_value_type (value_type_of_index_type it) ^
+    " " ^ string_of_limits I64.to_string_u lim
+
+
+let string_of_table_type = function
+  | TableType (lim, t) -> string_of_limits I32.to_string_u lim ^ " " ^
+                          string_of_elem_type t
+
+let string_of_global_type = function
+  | GlobalType (t, Immutable) -> string_of_value_type t
+  | GlobalType (t, Mutable) -> "(mut " ^ string_of_value_type t ^ ")"
+
+let string_of_stack_type ts =
+  "[" ^ String.concat " " (List.map string_of_value_type ts) ^ "]"
+
+let string_of_func_type (FuncType (ins, out)) =
+  string_of_stack_type ins ^ " -> " ^ string_of_stack_type out
+
+let string_of_extern_type = function
+  | ExternFuncType ft -> "func " ^ string_of_func_type ft
+  | ExternTableType tt -> "table " ^ string_of_table_type tt
+  | ExternMemoryType mt -> "memory " ^ string_of_memory_type mt
+  | ExternGlobalType gt -> "global " ^ string_of_global_type gt
diff --git a/src/wasm-exts/values.ml b/src/wasm-exts/values.ml
new file mode 100644
index 00000000000..fc14357b019
--- /dev/null
+++ b/src/wasm-exts/values.ml
@@ -0,0 +1,86 @@
+(*
+This module originated as a copy of interpreter/syntax/values.ml in the
+reference implementation.
+No adjustments.
+*)
+
+open Types
+module F32 = Wasm.F32
+module F64 = Wasm.F64
+
+(* Values and operators *)
+
+type ('i32, 'i64, 'f32, 'f64) op =
+  I32 of 'i32 | I64 of 'i64 | F32 of 'f32 | F64 of 'f64
+
+type value = (I32.t, I64.t, F32.t, F64.t) op
+
+
+(* Typing *)
+
+let type_of = function
+  | I32 _ -> I32Type
+  | I64 _ -> I64Type
+  | F32 _ -> F32Type
+  | F64 _ -> F64Type
+
+let default_value = function
+  | I32Type -> I32 I32.zero
+  | I64Type -> I64 I64.zero
+  | F32Type -> F32 F32.zero
+  | F64Type -> F64 F64.zero
+
+
+(* Conversion *)
+
+let value_of_bool b = I32 (if b then 1l else 0l)
+
+let string_of_value = function
+  | I32 i -> I32.to_string_s i
+  | I64 i -> I64.to_string_s i
+  | F32 z -> F32.to_string z
+  | F64 z -> F64.to_string z
+
+let string_of_values = function
+  | [v] -> string_of_value v
+  | vs -> "[" ^ String.concat " " (List.map string_of_value vs) ^ "]"
+
+
+(* Injection & projection *)
+
+exception Value of value_type
+
+module type ValueType =
+sig
+  type t
+  val to_value : t -> value
+  val of_value : value -> t (* raise Value *)
+end
+
+module I32Value =
+struct
+  type t = I32.t
+  let to_value i = I32 i
+  let of_value = function I32 i -> i | _ -> raise (Value I32Type)
+end
+
+module I64Value =
+struct
+  type t = I64.t
+  let to_value i = I64 i
+  let of_value = function I64 i -> i | _ -> raise (Value I64Type)
+end
+
+module F32Value =
+struct
+  type t = F32.t
+  let to_value i = F32 i
+  let of_value = function F32 z -> z | _ -> raise (Value F32Type)
+end
+
+module F64Value =
+struct
+  type t = F64.t
+  let to_value i = F64 i
+  let of_value = function F64 z -> z | _ -> raise (Value F64Type)
+end
diff --git a/test/Makefile b/test/Makefile
index d5a94aa2003..df6238aa4b5 100644
--- a/test/Makefile
+++ b/test/Makefile
@@ -1,4 +1,5 @@
-QUICK_DIRS = cmp fail idl ld mo-idl repl run
+# TODO: Include ld when it supports Wasm64 
+QUICK_DIRS = cmp fail idl mo-idl repl run
 OTHER_DIRS = bench perf run-deser run-drun trap
 TEST_DIRS = $(QUICK_DIRS) $(OTHER_DIRS)
 SOURCE_PATHS ?= ../src # will be overridden when building coverage report with nix
diff --git a/test/bench/heap-64.mo b/test/bench/heap-64.mo
new file mode 100644
index 00000000000..32fd57e259d
--- /dev/null
+++ b/test/bench/heap-64.mo
@@ -0,0 +1,55 @@
+// allocate 2 big arrays with a 10^5 entries each, and populate them
+// with Int64s and Nat64s (somewhat randomly)
+import { Array_tabulate; performanceCounter; intToNat64Wrap; intToInt64Wrap; rts_heap_size; debugPrint } = "mo:⛔";
+
+actor Tagged {
+
+    func arrNat64(seed : Nat) : ([Nat64], Nat) {
+        var state = seed;
+        let cutoff = 9223372036854775805;
+        var taggable = 0;
+        (Array_tabulate<Nat64>(
+            100_000,
+            func _ {
+                state := (state + 17) * 57 % cutoff;
+                let wrapped = intToNat64Wrap state;
+                let bits = (wrapped >> 60) & 3;
+                if (bits == 0 or bits == 3)
+                   taggable += 1;
+                   wrapped
+            })
+         , taggable)
+    };
+
+    func arrInt64(seed : Nat) : ([Int64], Nat) {
+        var state = seed;
+        let cutoff = 18446744073709551631;
+        var taggable = 0;
+        (Array_tabulate<Int64>(
+            100_000,
+            func _ {
+                state := (state + 17) * 57 % cutoff;
+                let wrapped = intToInt64Wrap state;
+                let bits = (wrapped >> 60) & 3;
+                if (bits == 0 or bits == 3)
+                   taggable += 1;
+                   wrapped
+            }), taggable)
+    };
+
+    func counters() : (Int, Nat64) = (rts_heap_size(), performanceCounter(0));
+
+    public func go() : async () {
+        let (m0, n0) = counters();
+        let (_, nt) = arrNat64(7);
+        let (m1, n1) = counters();
+        debugPrint(debug_show (nt, m1 - m0, n1 - n0));
+
+        let (i0, j0) = counters();
+        let (_, it) = arrInt64(13);
+        let (i1, j1) = counters();
+        debugPrint(debug_show (it, i1 - i0, j1 - j0))
+    }
+}
+
+//CALL ingress go 0x4449444C0000
diff --git a/test/bench/ok/alloc.drun-run.ok b/test/bench/ok/alloc.drun-run.ok
index e8bb0b9613a..027d9bd722a 100644
--- a/test/bench/ok/alloc.drun-run.ok
+++ b/test/bench/ok/alloc.drun-run.ok
@@ -1,8 +1,8 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_613_740_069)
+debug.print: (+268_435_456, 3_071_963_514)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_613_737_156)
+debug.print: (+268_435_456, 3_070_488_954)
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (+335_544_320, 4_613_737_171)
+debug.print: (+268_435_456, 3_070_488_954)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/bignum.drun-run.ok b/test/bench/ok/bignum.drun-run.ok
index d7497c87ad5..55f31d9ab4e 100644
--- a/test/bench/ok/bignum.drun-run.ok
+++ b/test/bench/ok/bignum.drun-run.ok
@@ -1,6 +1,6 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 2_626_820; size = +60_128}
+debug.print: {cycles = 2_619_967; size = +59_652}
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 107_960_874; size = +1_826_952}
+debug.print: {cycles = 107_892_482; size = +1_817_872}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/candid-subtype-cost.drun-run.ok b/test/bench/ok/candid-subtype-cost.drun-run.ok
index d67cf3fef1f..9daf0b8e774 100644
--- a/test/bench/ok/candid-subtype-cost.drun-run.ok
+++ b/test/bench/ok/candid-subtype-cost.drun-run.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {cycles = 1_027_001; heap_bytes = +16_936}
+debug.print: {cycles = 982_245; heap_bytes = +12_564}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/heap-32.drun-run.ok b/test/bench/ok/heap-32.drun-run.ok
index 305210a061e..2ad4c135852 100644
--- a/test/bench/ok/heap-32.drun-run.ok
+++ b/test/bench/ok/heap-32.drun-run.ok
@@ -1,5 +1,5 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (50_227, +37_379_412, 870_764_655)
-debug.print: (50_070, +38_903_788, 905_085_904)
+debug.print: (50_227, +29_863_068, 769_836_717)
+debug.print: (50_070, +32_992_212, 831_339_788)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/heap-64.drun-run.ok b/test/bench/ok/heap-64.drun-run.ok
new file mode 100644
index 00000000000..d2f53614912
--- /dev/null
+++ b/test/bench/ok/heap-64.drun-run.ok
@@ -0,0 +1,5 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+debug.print: (49_965, +47_942_744, 1_027_584_937)
+debug.print: (49_806, +47_960_000, 1_036_639_548)
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/nat16.drun-run.ok b/test/bench/ok/nat16.drun-run.ok
index 9bb141f2499..8febef52370 100644
--- a/test/bench/ok/nat16.drun-run.ok
+++ b/test/bench/ok/nat16.drun-run.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (0, 55_575_377)
+debug.print: (0, 51_380_880)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/palindrome.drun-run.ok b/test/bench/ok/palindrome.drun-run.ok
index 6356d04b55b..4861a7b69fe 100644
--- a/test/bench/ok/palindrome.drun-run.ok
+++ b/test/bench/ok/palindrome.drun-run.ok
@@ -1,9 +1,9 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: (true, +1_464, 19_881)
-debug.print: (false, +1_464, 18_808)
-debug.print: (false, +1_464, 19_858)
-debug.print: (true, +1_092, 18_713)
-debug.print: (false, +1_080, 17_101)
-debug.print: (false, +1_080, 18_571)
+debug.print: (true, +1_188, 13_154)
+debug.print: (false, +1_188, 12_203)
+debug.print: (false, +1_188, 13_133)
+debug.print: (true, +868, 13_262)
+debug.print: (false, +868, 11_725)
+debug.print: (false, +868, 13_633)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/region-mem.drun-run.ok b/test/bench/ok/region-mem.drun-run.ok
index 996b7e106eb..b99bc582edf 100644
--- a/test/bench/ok/region-mem.drun-run.ok
+++ b/test/bench/ok/region-mem.drun-run.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 8_380_219_796}
+debug.print: {heap_diff = 0; instr_diff = 5_964_300_649}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/region0-mem.drun-run.ok b/test/bench/ok/region0-mem.drun-run.ok
index e0f81d95884..bf527929218 100644
--- a/test/bench/ok/region0-mem.drun-run.ok
+++ b/test/bench/ok/region0-mem.drun-run.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 8_279_556_500}
+debug.print: {heap_diff = 0; instr_diff = 6_392_119_657}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/bench/ok/stable-mem.drun-run.ok b/test/bench/ok/stable-mem.drun-run.ok
index b64bd840aaf..5e3eeec3bce 100644
--- a/test/bench/ok/stable-mem.drun-run.ok
+++ b/test/bench/ok/stable-mem.drun-run.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {heap_diff = 0; instr_diff = 4_454_351_252}
+debug.print: {heap_diff = 0; instr_diff = 3_875_537_257}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/ld/Makefile b/test/ld/Makefile
index b342e7e88ec..7e8bf4a3119 100644
--- a/test/ld/Makefile
+++ b/test/ld/Makefile
@@ -14,26 +14,26 @@ WASM_LD?=wasm-ld-13
 MO_LD?=../../src/mo-ld
 
 _out/%.lib.o: %.c | _out
-	$(WASM_CLANG) --compile -fPIC --target=wasm32-emscripten --optimize=3 \
-		-fno-builtin -Wall \
+	$(WASM_CLANG) --compile -fpic --target=wasm64-emscripten --optimize=3 \
+		-fno-builtin -ffreestanding \
 		$< --output $@
 
 _out/%.lib.wasm: _out/%.lib.o | _out
-	$(WASM_LD) --import-memory --shared --no-entry --gc-sections \
+	$(WASM_LD) -mwasm64 --import-memory --shared --no-entry --gc-sections \
 		--export=__wasm_call_ctors \
 		$< -o $@
 
 _out/%.base.wasm: %.wat | _out
-	wat2wasm --debug-names $< -o $@
+	wat2wasm --enable-memory64 --debug-names $< -o $@
 
 _out/%.linked.wasm: _out/%.base.wasm _out/%.lib.wasm
 	$(MO_LD) -b _out/$*.base.wasm -l _out/$*.lib.wasm -o _out/$*.linked.wasm
 
 _out/%.wat: _out/%.wasm
-	wasm2wat $< -o $@
+	wasm2wat --enable-memory64 $< -o $@
 
 _out/%.valid: _out/%.wasm
-	wasm-validate $< > $@ 2>&1 || true
+	wasm-validate --enable-memory64 $< > $@ 2>&1 || true
 
 
 include ../*.mk
diff --git a/test/ld/fun-ptr.c b/test/ld/fun-ptr.c
index 83d84a8ef9b..1b077e8ef6a 100644
--- a/test/ld/fun-ptr.c
+++ b/test/ld/fun-ptr.c
@@ -4,14 +4,20 @@ int f0(int x, int y)
     return x + y;
 }
 
+// Clang/LLVM bug for Wasm64: &f0 generates a 32-bit value that is incompatible to void*
+void* result_f1 = (void*)1; // &f0
+
 __attribute__ ((visibility("default")))
 int (*f1(void)) (int x, int y)
 {
-    return &f0;
+    return result_f1;
 }
 
+// Clang/LLVM bug for Wasm64: &f0 generates a 32-bit value that is incompatible to void*
+void* result_f2 = (void*)2; // &f1
+
 __attribute__ ((visibility("default")))
-void *f2()
+void* f2()
 {
-    return &f1;
+    return result_f2;
 }
diff --git a/test/ld/fun-ptr.wat b/test/ld/fun-ptr.wat
index 15d5b483ea8..929cdeeaa43 100644
--- a/test/ld/fun-ptr.wat
+++ b/test/ld/fun-ptr.wat
@@ -1,14 +1,17 @@
 (module
-  (type (;0;) (func (result i32)))
+  (type (;0;) (func (result i64)))
   (type (;1;) (func (param i32) (param i32) (result i32)))
-  (import "rts" "f2" (func $f2 (result i32)))
+  (type (;2;) (func (result i32)))
+  (import "rts" "f2" (func $f2 (result i64)))
   (table (;0;) 1 1 funcref)
-  (memory (;0;) 2)
-  (global $heap_base i32 (i32.const 65536))
+  (memory (;0;) i64 2)
+  (global $heap_base i64 (i64.const 65536))
   (export "__heap_base" (global $heap_base))
-  (func $call_imported (type 0)
+  (func $call_imported (type 2)
     call $f2
+    i32.wrap_i64
     call_indirect (type 0)
+    i32.wrap_i64
     i32.const 3
     i32.const 5
     call_indirect (type 1)))
diff --git a/test/ld/ok/fun-ptr.linked.wat.ok b/test/ld/ok/fun-ptr.linked.wat.ok
index 1dc8da14ab2..e950eabfc3a 100644
--- a/test/ld/ok/fun-ptr.linked.wat.ok
+++ b/test/ld/ok/fun-ptr.linked.wat.ok
@@ -1,30 +1,41 @@
 (module
-  (type (;0;) (func (result i32)))
+  (type (;0;) (func (result i64)))
   (type (;1;) (func (param i32 i32) (result i32)))
-  (type (;2;) (func))
-  (func $call_imported (type 0) (result i32)
+  (type (;2;) (func (result i32)))
+  (type (;3;) (func))
+  (func $call_imported (type 2) (result i32)
     call $f2
+    i32.wrap_i64
     call_indirect (type 0)
+    i32.wrap_i64
     i32.const 3
     i32.const 5
     call_indirect (type 1))
-  (func $__wasm_call_ctors (type 2)
+  (func $__wasm_call_ctors (type 3)
     call $__wasm_apply_data_relocs)
-  (func $__wasm_apply_data_relocs (type 2))
+  (func $__wasm_apply_data_relocs (type 3))
   (func $f0 (type 1) (param i32 i32) (result i32)
     local.get 1
     local.get 0
     i32.add)
-  (func $f1 (type 0) (result i32)
-    global.get 0)
-  (func $f2 (type 0) (result i32)
-    global.get 1)
-  (func $link_start (type 2)
+  (func $f1 (type 0) (result i64)
+    i64.const 65536
+    i64.const 0
+    i64.add
+    i64.load)
+  (func $f2 (type 0) (result i64)
+    i64.const 65536
+    i64.const 8
+    i64.add
+    i64.load)
+  (func $link_start (type 3)
+    i64.const 65536
+    i32.const 0
+    i32.const 16
+    memory.init 0
     call $__wasm_call_ctors)
-  (table (;0;) 3 3 funcref)
-  (memory (;0;) 2)
-  (global (;0;) i32 (i32.const 1))
-  (global (;1;) i32 (i32.const 2))
-  (global (;2;) i32 (i32.const 65536))
+  (table (;0;) 1 1 funcref)
+  (memory (;0;) i64 2)
+  (global (;0;) i64 (i64.const 65792))
   (start $link_start)
-  (elem (;0;) (i32.const 1) func $f0 $f1))
+  (data (;0;) "\01\00\00\00\00\00\00\00\02\00\00\00\00\00\00\00"))
diff --git a/test/ld/ok/representative.linked.wat.ok b/test/ld/ok/representative.linked.wat.ok
index f0cd781fd47..bcf3c073ec9 100644
--- a/test/ld/ok/representative.linked.wat.ok
+++ b/test/ld/ok/representative.linked.wat.ok
@@ -23,6 +23,6 @@
   (func $link_start (type 0)
     call $__wasm_call_ctors)
   (table (;0;) 0 0 funcref)
-  (memory (;0;) 2)
-  (global (;0;) i32 (i32.const 65536))
+  (memory (;0;) i64 2)
+  (global (;0;) i64 (i64.const 65536))
   (start $link_start))
diff --git a/test/ld/representative.c b/test/ld/representative.c
index 3d6990a0db8..fae7fc5e626 100644
--- a/test/ld/representative.c
+++ b/test/ld/representative.c
@@ -9,4 +9,3 @@ export int square(int i) {
   unresolved_import();
   return i * i;
 }
-
diff --git a/test/ld/representative.wat b/test/ld/representative.wat
index f2da5cb0f9c..a47428a2afb 100644
--- a/test/ld/representative.wat
+++ b/test/ld/representative.wat
@@ -4,8 +4,8 @@
   (import "rts" "square" (func $square (param i32) (result i32)))
   (import "rts" "not_yet_imported2" (func $not_yet_imported2))
   (table (;0;) 0 0 funcref)
-  (memory (;0;) 2)
-  (global $heap_base i32 (i32.const 65536))
+  (memory (;0;) i64 2)
+  (global $heap_base i64 (i64.const 65536))
   (export "__heap_base" (global $heap_base))
   (export "resolved_import" (func $resolved_export))
   (func $call_imported (type 0)
diff --git a/test/ld/wrong-type.c b/test/ld/wrong-type.c
index 7d4359154af..909400a22d4 100644
--- a/test/ld/wrong-type.c
+++ b/test/ld/wrong-type.c
@@ -1,3 +1,2 @@
 #define export __attribute__ ((visibility("default")))
 export int exported() { return 42; }
-
diff --git a/test/ld/wrong-type.wat b/test/ld/wrong-type.wat
index 7c01f9caaff..563f11565f3 100644
--- a/test/ld/wrong-type.wat
+++ b/test/ld/wrong-type.wat
@@ -2,8 +2,8 @@
   (type (;0;) (func))
   (import "rts" "exported" (func $exported (param i32)))
   (table (;0;) 0 0 funcref)
-  (memory (;0;) 2)
-  (global $heap_base i32 (i32.const 65536))
+  (memory (;0;) i64 2)
+  (global $heap_base i64 (i64.const 65536))
   (export "__heap_base" (global $heap_base))
   (func $call_imported (type 0)
     i32.const 42
diff --git a/test/random/Embedder.hs b/test/random/Embedder.hs
index 77c79fb2d84..a4695a56c75 100644
--- a/test/random/Embedder.hs
+++ b/test/random/Embedder.hs
@@ -36,7 +36,7 @@ addCompilerArgs (WasmTime _) = ("-wasi-system-api" :)
 addCompilerArgs Drun = id
 
 addEmbedderArgs Reference = id
-addEmbedderArgs (WasmTime _) = \args -> ["-C", "cache=n", "-W", "nan-canonicalization=y", "-W", "multi-memory", "-W", "bulk-memory"] <> args
+addEmbedderArgs (WasmTime _) = \args -> ["-C", "cache=n", "-W", "nan-canonicalization=y", "-W", "memory64", "-W", "multi-memory", "-W", "bulk-memory"] <> args
 addEmbedderArgs Drun = ("--extra-batches" :) . ("10" :)
 
 embedderInvocation :: Embedder -> [Text] -> [Text]
diff --git a/test/random/Main.hs b/test/random/Main.hs
index 25dfa003cd6..03b96286105 100644
--- a/test/random/Main.hs
+++ b/test/random/Main.hs
@@ -57,7 +57,7 @@ main = do
   let tests :: TestTree
       tests = testGroup "Motoko tests" . concat
                $ [ [arithProps, conversionProps, utf8Props, matchingProps] | good ]
-              <> [ [encodingProps] | goodDrun ]
+               <> [ [encodingProps] | goodDrun ]
 
   if not (good || goodDrun)
   then putStrLn "No embedder available for testing. Done..."
diff --git a/test/random/README.md b/test/random/README.md
index c5368ba2c9e..f4a5253b130 100644
--- a/test/random/README.md
+++ b/test/random/README.md
@@ -35,7 +35,7 @@ With this piece of information you can run the identical test locally,
 using the following `nix-build` invocation from your `motoko`
 directory:
 ``` shell
-$ nix-build -A tests --arg replay 232458
+$ nix-build -A tests.qc --arg replay 232458
 ```
 
 ## Running in `moc` and `wasm-interp`
diff --git a/test/run-drun-non-ci/actor64.mo b/test/run-drun-non-ci/actor64.mo
new file mode 100644
index 00000000000..6ca39e6750d
--- /dev/null
+++ b/test/run-drun-non-ci/actor64.mo
@@ -0,0 +1,66 @@
+// Only works with incremental GC. 
+// Use:
+// ```
+// export EXTRA_MOC_ARGS="--incremental-gc"
+// ../run.sh -d actor64.drun
+// ```
+import Prim "mo:prim";
+
+actor {
+    let MB = 1024 * 1024;
+    let GB = 1024 * MB;
+
+    Prim.debugPrint("Hello Wasm64 Motoko on IC!");
+
+    func trace() {
+        Prim.debugPrint("Heap size: " # debug_show (Prim.rts_heap_size() / GB) # " GB");
+    };
+
+    type Node = ?{ value : [var Nat]; next : Node };
+    var first : Node = null;
+
+    public func allocate() : async () {
+        let value = Prim.Array_init<Nat>(128 * MB, 0);
+        first := ?{ value; next = first };
+        trace();
+    };
+};
+
+//SKIP run
+//SKIP run-low
+//SKIP run-ir
+// too slow on ic-ref-run:
+//SKIP comp-ref
+
+//CALL ingress allocate "DIDL\x00\x00"
+//CALL ingress allocate "DIDL\x00\x00"
+//CALL ingress allocate "DIDL\x00\x00"
+//CALL ingress allocate "DIDL\x00\x00"
+//CALL ingress allocate "DIDL\x00\x00"
+//CALL ingress allocate "DIDL\x00\x00"
+//CALL ingress allocate "DIDL\x00\x00"
+//CALL ingress allocate "DIDL\x00\x00"
+//CALL ingress allocate "DIDL\x00\x00"
+//CALL ingress allocate "DIDL\x00\x00"
+//CALL ingress allocate "DIDL\x00\x00"
+//CALL ingress allocate "DIDL\x00\x00"
+//CALL ingress allocate "DIDL\x00\x00"
+//CALL ingress allocate "DIDL\x00\x00"
+//CALL ingress allocate "DIDL\x00\x00"
+//CALL ingress allocate "DIDL\x00\x00"
+//CALL ingress allocate "DIDL\x00\x00"
+//CALL ingress allocate "DIDL\x00\x00"
+//CALL ingress allocate "DIDL\x00\x00"
+//CALL ingress allocate "DIDL\x00\x00"
+//CALL ingress allocate "DIDL\x00\x00"
+//CALL ingress allocate "DIDL\x00\x00"
+//CALL ingress allocate "DIDL\x00\x00"
+//CALL ingress allocate "DIDL\x00\x00"
+//CALL ingress allocate "DIDL\x00\x00"
+//CALL ingress allocate "DIDL\x00\x00"
+//CALL ingress allocate "DIDL\x00\x00"
+//CALL ingress allocate "DIDL\x00\x00"
+//CALL ingress allocate "DIDL\x00\x00"
+//CALL ingress allocate "DIDL\x00\x00"
+//CALL ingress allocate "DIDL\x00\x00"
+//CALL ingress allocate "DIDL\x00\x00"
diff --git a/test/run-drun-non-ci/memory-reserve-composite.drun b/test/run-drun-non-ci/memory-reserve-composite.drun
deleted file mode 100644
index 1da30f6357b..00000000000
--- a/test/run-drun-non-ci/memory-reserve-composite.drun
+++ /dev/null
@@ -1,5 +0,0 @@
-# SKIP ic-ref-run
-install $ID memory-reserve-composite/memory-reserve-composite.mo ""
-ingress $ID prepare1 "DIDL\x00\x00"
-ingress $ID prepare2 "DIDL\x00\x00"
-query $ID allocateInCompositeQuery "DIDL\x00\x00"
diff --git a/test/run-drun-non-ci/memory-reserve-composite/memory-reserve-composite.mo b/test/run-drun-non-ci/memory-reserve-composite/memory-reserve-composite.mo
deleted file mode 100644
index d1238e382f8..00000000000
--- a/test/run-drun-non-ci/memory-reserve-composite/memory-reserve-composite.mo
+++ /dev/null
@@ -1,39 +0,0 @@
-import Prim "mo:⛔";
-actor {
-    stable var stableData = Prim.Array_tabulate<Nat>(1024 * 1024, func(index) { index });
-    var array0 : [var Nat] = [var];
-    var array1 : [var Nat] = [var];
-    var array2 : [var Nat] = [var];
-    var array3 : [var Nat] = [var];
-    Prim.debugPrint("Initialized " # debug_show (Prim.rts_memory_size()));
-
-    public func prepare1() : async () {
-        array0 := Prim.Array_init<Nat>(256 * 1024 * 1024, 0); // 1GB
-        array1 := Prim.Array_init<Nat>(256 * 1024 * 1024, 1); // 2GB
-        Prim.debugPrint("Prepared1 " # debug_show (Prim.rts_memory_size()));
-    };
-
-    public func prepare2() : async () {
-        array2 := Prim.Array_init<Nat>(256 * 1024 * 1024, 2); // 3GB
-        array3 := Prim.Array_init<Nat>(150 * 1024 * 1024, 3); // around 3.75GB
-        Prim.debugPrint("Prepared2 " # debug_show (Prim.rts_memory_size()));
-    };
-
-    public composite query func allocateInCompositeQuery() : async () {
-        ignore Prim.Array_init<Nat>(50 * 1024 * 1024, 4);
-        Prim.debugPrint("Composite query call " # debug_show (Prim.rts_memory_size()));
-        assert (Prim.rts_memory_size() > 3840 * 1024 * 1024);
-        await nestedQuery();
-        ignore Prim.Array_init<Nat>(5 * 1024 * 1024, 4);
-        Prim.debugPrint("Composite query callback " # debug_show (Prim.rts_memory_size()));
-        assert (Prim.rts_memory_size() > 3840 * 1024 * 1024);
-    };
-
-    public query func nestedQuery() : async () {
-        Prim.debugPrint("Nested query " # debug_show (Prim.rts_memory_size()));
-    };
-};
-
-//SKIP run
-//SKIP run-ir
-//SKIP run-low
diff --git a/test/run-drun-non-ci/memory-reserve-query.drun b/test/run-drun-non-ci/memory-reserve-query.drun
deleted file mode 100644
index f7956e7ab96..00000000000
--- a/test/run-drun-non-ci/memory-reserve-query.drun
+++ /dev/null
@@ -1,5 +0,0 @@
-# SKIP ic-ref-run
-install $ID memory-reserve-query/memory-reserve-query.mo ""
-ingress $ID prepare1 "DIDL\x00\x00"
-ingress $ID prepare2 "DIDL\x00\x00"
-query $ID allocateInQuery "DIDL\x00\x00"
diff --git a/test/run-drun-non-ci/memory-reserve-query/memory-reserve-query.mo b/test/run-drun-non-ci/memory-reserve-query/memory-reserve-query.mo
deleted file mode 100644
index b50b802cb6c..00000000000
--- a/test/run-drun-non-ci/memory-reserve-query/memory-reserve-query.mo
+++ /dev/null
@@ -1,31 +0,0 @@
-import Prim "mo:⛔";
-actor {
-    stable var stableData = Prim.Array_tabulate<Nat>(1024 * 1024, func(index) { index });
-    var array0 : [var Nat] = [var];
-    var array1 : [var Nat] = [var];
-    var array2 : [var Nat] = [var];
-    var array3 : [var Nat] = [var];
-    Prim.debugPrint("Initialized " # debug_show (Prim.rts_memory_size()));
-
-    public func prepare1() : async () {
-        array0 := Prim.Array_init<Nat>(256 * 1024 * 1024, 0); // 1GB
-        array1 := Prim.Array_init<Nat>(256 * 1024 * 1024, 1); // 2GB
-        Prim.debugPrint("Prepared1 " # debug_show (Prim.rts_memory_size()));
-    };
-
-    public func prepare2() : async () {
-        array2 := Prim.Array_init<Nat>(256 * 1024 * 1024, 2); // 3GB
-        array3 := Prim.Array_init<Nat>(150 * 1024 * 1024, 3); // around 3.75GB
-        Prim.debugPrint("Prepared2 " # debug_show (Prim.rts_memory_size()));
-    };
-
-    public query func allocateInQuery() : async () {
-        ignore Prim.Array_init<Nat>(50 * 1024 * 1024, 4);
-        Prim.debugPrint("Query call " # debug_show (Prim.rts_memory_size()));
-        assert (Prim.rts_memory_size() > 3840 * 1024 * 1024);
-    };
-};
-
-//SKIP run
-//SKIP run-ir
-//SKIP run-low
diff --git a/test/run-drun-non-ci/memory-reserve-update.drun b/test/run-drun-non-ci/memory-reserve-update.drun
deleted file mode 100644
index 00296d68dab..00000000000
--- a/test/run-drun-non-ci/memory-reserve-update.drun
+++ /dev/null
@@ -1,5 +0,0 @@
-# SKIP ic-ref-run
-install $ID memory-reserve-update/memory-reserve-update.mo ""
-ingress $ID prepare1 "DIDL\x00\x00"
-ingress $ID prepare2 "DIDL\x00\x00"
-ingress $ID allocateInUpdate "DIDL\x00\x00"
diff --git a/test/run-drun-non-ci/memory-reserve-update/memory-reserve-update.mo b/test/run-drun-non-ci/memory-reserve-update/memory-reserve-update.mo
deleted file mode 100644
index cc8f3aaeb38..00000000000
--- a/test/run-drun-non-ci/memory-reserve-update/memory-reserve-update.mo
+++ /dev/null
@@ -1,30 +0,0 @@
-import Prim "mo:⛔";
-actor {
-    stable var stableData = Prim.Array_tabulate<Nat>(1024 * 1024, func(index) { index });
-    var array0 : [var Nat] = [var];
-    var array1 : [var Nat] = [var];
-    var array2 : [var Nat] = [var];
-    var array3 : [var Nat] = [var];
-    Prim.debugPrint("Initialized " # debug_show (Prim.rts_memory_size()));
-
-    public func prepare1() : async () {
-        array0 := Prim.Array_init<Nat>(256 * 1024 * 1024, 0); // 1GB
-        array1 := Prim.Array_init<Nat>(256 * 1024 * 1024, 1); // 2GB
-        Prim.debugPrint("Prepared1 " # debug_show (Prim.rts_memory_size()));
-    };
-
-    public func prepare2() : async () {
-        array2 := Prim.Array_init<Nat>(256 * 1024 * 1024, 2); // 3GB
-        array3 := Prim.Array_init<Nat>(150 * 1024 * 1024, 3); // around 3.75GB
-        Prim.debugPrint("Prepared2 " # debug_show (Prim.rts_memory_size()));
-    };
-
-    public func allocateInUpdate() : async () {
-        Prim.debugPrint("Update call " # debug_show (Prim.rts_memory_size()));
-        ignore Prim.Array_init<Nat>(50 * 1024 * 1024, 4);
-    };
-};
-
-//SKIP run
-//SKIP run-ir
-//SKIP run-low
diff --git a/test/run-drun-non-ci/memory-reserve-upgrade.drun b/test/run-drun-non-ci/memory-reserve-upgrade.drun
deleted file mode 100644
index 77c3762f6d5..00000000000
--- a/test/run-drun-non-ci/memory-reserve-upgrade.drun
+++ /dev/null
@@ -1,5 +0,0 @@
-# SKIP ic-ref-run
-install $ID memory-reserve-upgrade/memory-reserve-upgrade.mo ""
-ingress $ID prepare1 "DIDL\x00\x00"
-ingress $ID prepare2 "DIDL\x00\x00"
-upgrade $ID memory-reserve-upgrade/memory-reserve-upgrade.mo ""
diff --git a/test/run-drun-non-ci/memory-reserve-upgrade/memory-reserve-upgrade.mo b/test/run-drun-non-ci/memory-reserve-upgrade/memory-reserve-upgrade.mo
deleted file mode 100644
index 85cef10b07c..00000000000
--- a/test/run-drun-non-ci/memory-reserve-upgrade/memory-reserve-upgrade.mo
+++ /dev/null
@@ -1,25 +0,0 @@
-import Prim "mo:⛔";
-actor {
-    stable var stableData = Prim.Array_tabulate<Nat>(1024 * 1024, func(index) { index });
-    var array0 : [var Nat] = [var];
-    var array1 : [var Nat] = [var];
-    var array2 : [var Nat] = [var];
-    var array3 : [var Nat] = [var];
-    Prim.debugPrint("Initialized " # debug_show (Prim.rts_memory_size()));
-
-    public func prepare1() : async () {
-        array0 := Prim.Array_init<Nat>(256 * 1024 * 1024, 0); // 1GB
-        array1 := Prim.Array_init<Nat>(256 * 1024 * 1024, 1); // 2GB
-        Prim.debugPrint("Prepared1 " # debug_show (Prim.rts_memory_size()));
-    };
-
-    public func prepare2() : async () {
-        array2 := Prim.Array_init<Nat>(256 * 1024 * 1024, 2); // 3GB
-        array3 := Prim.Array_init<Nat>(150 * 1024 * 1024, 3); // around 3.75GB
-        Prim.debugPrint("Prepared2 " # debug_show (Prim.rts_memory_size()));
-    };
-};
-
-//SKIP run
-//SKIP run-ir
-//SKIP run-low
diff --git a/test/run-drun-non-ci/ok/actor64.drun-run.ok b/test/run-drun-non-ci/ok/actor64.drun-run.ok
new file mode 100644
index 00000000000..9a123c0edbf
--- /dev/null
+++ b/test/run-drun-non-ci/ok/actor64.drun-run.ok
@@ -0,0 +1,67 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+debug.print: Hello Wasm64 Motoko on IC!
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Heap size: 1 GB
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Heap size: 2 GB
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Heap size: 3 GB
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Heap size: 4 GB
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Heap size: 5 GB
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Heap size: 6 GB
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Heap size: 7 GB
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Heap size: 8 GB
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Heap size: 9 GB
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Heap size: 10 GB
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Heap size: 11 GB
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Heap size: 12 GB
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Heap size: 13 GB
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Heap size: 14 GB
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Heap size: 15 GB
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Heap size: 16 GB
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Heap size: 17 GB
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Heap size: 18 GB
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Heap size: 19 GB
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Heap size: 20 GB
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Heap size: 21 GB
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Heap size: 22 GB
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Heap size: 23 GB
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Heap size: 24 GB
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Heap size: 25 GB
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Heap size: 26 GB
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Heap size: 27 GB
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Heap size: 28 GB
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Heap size: 29 GB
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Heap size: 30 GB
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Heap size: 31 GB
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Heap size: 32 GB
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/actor-class-mgmt-enhanced.mo b/test/run-drun/actor-class-mgmt-enhanced.mo
new file mode 100644
index 00000000000..17a82939001
--- /dev/null
+++ b/test/run-drun/actor-class-mgmt-enhanced.mo
@@ -0,0 +1,156 @@
+//ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+import Prim "mo:⛔";
+import Cycles = "cycles/cycles";
+import Cs "actor-class-mgmt/C";
+
+actor a {
+  type Change_origin = {
+      #from_user : {
+          user_id : Principal;
+      };
+      #from_canister : {
+          canister_id : Principal;
+          canister_version : ?Nat64;
+      };
+  };
+
+  type Change_details = {
+      #creation : { controllers : [Principal] };
+      #code_uninstall;
+      #code_deployment : {
+          mode : { #install; #reinstall; #upgrade};
+          // module_hash : Blob; // introduces non-determinism when codegen improves
+      };
+      #controllers_change : {
+          controllers : [Principal];
+      };
+  };
+
+  type Change = {
+      // timestamp_nanos : Nat64; // just omit this
+      canister_version : Nat64;
+      origin : Change_origin;
+      details : Change_details;
+  };
+
+  let ic00 = actor "aaaaa-aa" :
+    actor {
+      create_canister : {
+        settings : ? {
+          controllers : ?[Principal];
+          compute_allocation: ?Nat;
+          memory_allocation: ?Nat;
+        freezing_threshold: ?Nat;
+       }
+     } -> async { canister_id : Principal };
+
+      canister_info : {
+          canister_id : Principal;
+          num_requested_changes : ?Nat64;
+      } -> async {
+          total_num_changes : Nat64;
+          recent_changes : [Change];
+          // module_hash : ?Blob;
+          controllers : [Principal];
+      };
+   };
+
+  let default_settings = { settings = null };
+  // same as default but explicit
+  let settings = { settings = ? {
+     controllers = null;
+     compute_allocation = null;
+     freezing_threshold = null;
+     memory_allocation = null;
+    };
+  };
+
+  type IncrementalStabilization = actor {
+    __motoko_stabilize_before_upgrade : () -> async ();
+    __motoko_destabilize_after_upgrade : () -> async ();
+  };
+
+  func useIncrementalStabilization(a : actor {}) : IncrementalStabilization {
+    actor (debug_show (Prim.principalOfActor(a))) : IncrementalStabilization;
+  };
+
+  public func go () : async () {
+    // To get lots of cycles in both drun and ic-ref-run
+    if (Cycles.balance() == 0)
+      await Cycles.provisional_top_up_actor(a, 100_000_000_000_000);
+
+    do {
+      Cycles.add<system>(2_000_000_000_000);
+      let c0 = await
+        Cs.C (0, ?(Prim.principalOfActor a));
+      assert ({args = 0; upgrades = 0} == (await c0.observe()));
+
+      Cycles.add<system>(2_000_000_000_000);
+      let c1 = await
+        (system Cs.C)(#new default_settings)(1, null);
+      assert ({args = 1; upgrades = 0} == (await c1.observe()));
+      assert (c1 != c0);
+
+      Cycles.add<system>(2_000_000_000_000);
+      let c2 = await
+        (system Cs.C)(#new settings)(2, null);
+      assert ({args = 2; upgrades = 0} == (await c2.observe()));
+      assert (c2 != c1);
+
+      Cycles.add<system>(2_000_000_000_000);
+      let {canister_id = p} = await
+         ic00.create_canister default_settings;
+      // no need to add cycles
+      let c3 = await
+        (system Cs.C)(#install p)(3, null);
+      assert ({args = 3; upgrades = 0} == (await c3.observe()));
+      assert (Prim.principalOfActor c3 == p);
+      assert (c3 != c2);
+
+      // no need to add cycles
+      // upgrade by using enhanced orthogonal persistence
+      let c4 = await
+        (system Cs.C)(#upgrade c3)(4, null);
+      assert ({args = 4; upgrades = 1} == (await c4.observe()));
+      assert (c4 == c3);
+
+      // upgrade by using graph-copy-based stabilization
+      await useIncrementalStabilization(c4).__motoko_stabilize_before_upgrade();
+      let c5 = await
+        (system Cs.C)(#upgrade c4)(5, null);
+      await useIncrementalStabilization(c5).__motoko_destabilize_after_upgrade();
+      assert ({args = 5; upgrades = 2} == (await c5.observe()));
+      assert (c5 == c4);
+
+      let c6 = await
+        (system Cs.C)(#upgrade_with_persistence { wasm_memory_persistence = #Keep ; canister = c5 })(6, null);
+      assert ({args = 6; upgrades = 3} == (await c6.observe()));
+      assert (c6 == c5);
+
+      // no need to add cycles
+      let c7 = await
+        (system Cs.C)(#reinstall c6)(7, null);
+      assert ({args = 7; upgrades = 0} == (await c7.observe()));
+      assert (c7 == c6);
+
+      // no need to add cycles
+      let c8 = await
+        (system Cs.C)(#upgrade_with_persistence { wasm_memory_persistence = #Replace ; canister = c7 })(8, null);
+      assert ({args = 8; upgrades = 0} == (await c8.observe()));
+      assert (c8 == c7);
+
+      let info = await ic00.canister_info {
+          canister_id = p;
+          num_requested_changes = ?4
+      };
+
+      Prim.debugPrint (debug_show info);
+    };
+  };
+
+}
+
+//CALL ingress go "DIDL\x00\x00"
+//SKIP run
+//SKIP run-ir
+//SKIP run-low
diff --git a/test/run-drun/actor-class-mgmt.mo b/test/run-drun/actor-class-mgmt.mo
index a3234d32557..8f11a38d773 100644
--- a/test/run-drun/actor-class-mgmt.mo
+++ b/test/run-drun/actor-class-mgmt.mo
@@ -105,22 +105,10 @@ actor a {
 
       // no need to add cycles
       let c5 = await
-        (system Cs.C)(#upgrade_with_persistence { wasm_memory_persistence = #Keep ; canister = c4 })(5, null);
-      assert ({args = 5; upgrades = 2} == (await c5.observe()));
+        (system Cs.C)(#reinstall c4)(5, null);
+      assert ({args = 5; upgrades = 0} == (await c5.observe()));
       assert (c5 == c4);
 
-      // no need to add cycles
-      let c6 = await
-        (system Cs.C)(#reinstall c5)(6, null);
-      assert ({args = 6; upgrades = 0} == (await c6.observe()));
-      assert (c6 == c5);
-
-      // no need to add cycles
-      let c7 = await
-        (system Cs.C)(#upgrade_with_persistence { wasm_memory_persistence = #Replace ; canister = c6 })(7, null);
-      assert ({args = 7; upgrades = 0} == (await c7.observe()));
-      assert (c7 == c6);
-
       let info = await ic00.canister_info {
           canister_id = p;
           num_requested_changes = ?4
diff --git a/test/run-drun/any-stabilization.drun b/test/run-drun/any-stabilization.drun
new file mode 100644
index 00000000000..57e1298eeec
--- /dev/null
+++ b/test/run-drun/any-stabilization.drun
@@ -0,0 +1,11 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+# SKIP ic-ref-run
+install $ID any-stabilization/version0.mo ""
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x01\x7d\x0F"
+upgrade $ID any-stabilization/version0.mo ""
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x01\x7d\x0F"
+upgrade $ID any-stabilization/version1.mo ""
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x01\x7d\x0F"
+upgrade $ID any-stabilization/version1.mo ""
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x01\x7d\x0F"
+upgrade $ID any-stabilization/version2.mo ""
diff --git a/test/run-drun/any-stabilization/version0.mo b/test/run-drun/any-stabilization/version0.mo
new file mode 100644
index 00000000000..abfec2de7c4
--- /dev/null
+++ b/test/run-drun/any-stabilization/version0.mo
@@ -0,0 +1,3 @@
+actor {
+   stable var value : Any = 123;
+};
diff --git a/test/run-drun/any-stabilization/version1.mo b/test/run-drun/any-stabilization/version1.mo
new file mode 100644
index 00000000000..5a85d0618c3
--- /dev/null
+++ b/test/run-drun/any-stabilization/version1.mo
@@ -0,0 +1,3 @@
+actor {
+   stable var value : Any = "TEST";
+};
diff --git a/test/run-drun/any-stabilization/version2.mo b/test/run-drun/any-stabilization/version2.mo
new file mode 100644
index 00000000000..58d2382656c
--- /dev/null
+++ b/test/run-drun/any-stabilization/version2.mo
@@ -0,0 +1,3 @@
+actor {
+   stable var value = "TEST";
+};
diff --git a/test/run-drun/any-upgrades.drun b/test/run-drun/any-upgrades.drun
index 0417a9cc91c..294c2e4ae1e 100644
--- a/test/run-drun/any-upgrades.drun
+++ b/test/run-drun/any-upgrades.drun
@@ -1,3 +1,4 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
 # SKIP ic-ref-run
 install $ID any-upgrades/version0.mo ""
 upgrade $ID any-upgrades/version0.mo ""
diff --git a/test/run-drun/array-stabilization.drun b/test/run-drun/array-stabilization.drun
new file mode 100644
index 00000000000..22af3de7f8e
--- /dev/null
+++ b/test/run-drun/array-stabilization.drun
@@ -0,0 +1,29 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+# SKIP ic-ref-run
+install $ID array-stabilization/version0.mo ""
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID array-stabilization/version0.mo ""
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID array-stabilization/version1.mo ""
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID array-stabilization/version1.mo ""
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID array-stabilization/version2.mo ""
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID array-stabilization/version3.mo ""
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID array-stabilization/version4.mo ""
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID array-stabilization/version4.mo ""
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID array-stabilization/version0.mo ""
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID array-stabilization/version0.mo ""
+ingress $ID print "DIDL\x00\x00"
diff --git a/test/run-drun/array-stabilization/version0.mo b/test/run-drun/array-stabilization/version0.mo
new file mode 100644
index 00000000000..a6f4dee2e9d
--- /dev/null
+++ b/test/run-drun/array-stabilization/version0.mo
@@ -0,0 +1,16 @@
+import Prim "mo:prim";
+
+// Compatible upgrade
+actor {
+    type RecursiveArray = ?[RecursiveArray];
+
+    stable var simpleArray = [var 1.0, 2.0, 3.0, 4.0];
+    stable var nestedArray = [[1, 2, 3], [4, 5, 6]];
+    stable var recursiveArray = ?[null, ?[], ?[?[null, null], null]] : RecursiveArray;
+
+    public func print() : async () {
+        Prim.debugPrint(debug_show (simpleArray));
+        Prim.debugPrint(debug_show (nestedArray));
+        Prim.debugPrint(debug_show (recursiveArray));
+    };
+};
diff --git a/test/run-drun/array-stabilization/version1.mo b/test/run-drun/array-stabilization/version1.mo
new file mode 100644
index 00000000000..2798f73c73e
--- /dev/null
+++ b/test/run-drun/array-stabilization/version1.mo
@@ -0,0 +1,16 @@
+import Prim "mo:prim";
+
+// Compatible upgrade
+actor {
+    type RecursiveArray = ?[RecursiveArray];
+
+    stable var simpleArray: [var Float] = [var];
+    stable var nestedArray: [[Nat]] = [];
+    stable var recursiveArray = ?[] : RecursiveArray;
+
+    public func print() : async () {
+        Prim.debugPrint(debug_show (simpleArray));
+        Prim.debugPrint(debug_show (nestedArray));
+        Prim.debugPrint(debug_show (recursiveArray));
+    };
+};
diff --git a/test/run-drun/array-stabilization/version2.mo b/test/run-drun/array-stabilization/version2.mo
new file mode 100644
index 00000000000..28f951e4100
--- /dev/null
+++ b/test/run-drun/array-stabilization/version2.mo
@@ -0,0 +1,16 @@
+import Prim "mo:prim";
+
+// Incompatible upgrade
+actor {
+    type RecursiveArray = ?[RecursiveArray];
+
+    stable var simpleArray: [Float] = [];
+    stable var nestedArray: [Nat] = [];
+    stable var recursiveArray = ?[] : RecursiveArray;
+
+    public func print() : async () {
+        Prim.debugPrint(debug_show (simpleArray));
+        Prim.debugPrint(debug_show (nestedArray));
+        Prim.debugPrint(debug_show (recursiveArray));
+    };
+};
diff --git a/test/run-drun/array-stabilization/version3.mo b/test/run-drun/array-stabilization/version3.mo
new file mode 100644
index 00000000000..2c20e0e875f
--- /dev/null
+++ b/test/run-drun/array-stabilization/version3.mo
@@ -0,0 +1,16 @@
+import Prim "mo:prim";
+
+// Incompatible upgrade
+actor {
+    type RecursiveArray = ?[RecursiveArray];
+
+    stable var simpleArray: [var Float] = [var];
+    stable var nestedArray: [Nat] = [];
+    stable var recursiveArray = ?[] : RecursiveArray;
+
+    public func print() : async () {
+        Prim.debugPrint(debug_show (simpleArray));
+        Prim.debugPrint(debug_show (nestedArray));
+        Prim.debugPrint(debug_show (recursiveArray));
+    };
+};
diff --git a/test/run-drun/array-stabilization/version4.mo b/test/run-drun/array-stabilization/version4.mo
new file mode 100644
index 00000000000..3bd43d15b77
--- /dev/null
+++ b/test/run-drun/array-stabilization/version4.mo
@@ -0,0 +1,15 @@
+import Prim "mo:prim";
+
+// Compatible upgrade
+actor {
+    type ArrayStructure = ?[AliasName];
+    type AliasName = ArrayStructure;
+
+    stable var simpleArray: [var Float] = [var];
+    stable var recursiveArray = ?[] : ArrayStructure;
+
+    public func print() : async () {
+        Prim.debugPrint(debug_show (simpleArray));
+        Prim.debugPrint(debug_show (recursiveArray));
+    };
+};
diff --git a/test/run-drun/array-upgrades.drun b/test/run-drun/array-upgrades.drun
index acdc7558306..97ae0b98a85 100644
--- a/test/run-drun/array-upgrades.drun
+++ b/test/run-drun/array-upgrades.drun
@@ -1,3 +1,4 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
 # SKIP ic-ref-run
 install $ID array-upgrades/version0.mo ""
 ingress $ID print "DIDL\x00\x00"
diff --git a/test/run-drun/blob-array-mismatch.drun b/test/run-drun/blob-array-mismatch.drun
index 140a273175a..d0adf02e7ce 100644
--- a/test/run-drun/blob-array-mismatch.drun
+++ b/test/run-drun/blob-array-mismatch.drun
@@ -1,3 +1,4 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
 install $ID blob-array-mismatch/version0.mo ""
 upgrade $ID blob-array-mismatch/version0.mo ""
 upgrade $ID blob-array-mismatch/version1.mo ""
diff --git a/test/run-drun/blob-stabilization.mo b/test/run-drun/blob-stabilization.mo
new file mode 100644
index 00000000000..1397984bca9
--- /dev/null
+++ b/test/run-drun/blob-stabilization.mo
@@ -0,0 +1,24 @@
+//ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+import Prim "mo:prim";
+
+actor {
+    let blobSize = 32 * 1024 * 1024;
+    let stablePageSize = 64 * 1024;
+    ignore Prim.stableMemoryGrow(Prim.natToNat64(blobSize / stablePageSize));
+
+    stable let blob = Prim.stableMemoryLoadBlob(0, blobSize);
+    stable let small = (123_456_789_123_456_789, "TEST");
+
+    public query func check() : async () {
+        assert (blob.size() == blobSize);
+        assert (small == (123_456_789_123_456_789, "TEST"));
+    };
+};
+//SKIP run
+//SKIP run-ir
+//SKIP run-low
+//CALL ingress check "DIDL\x00\x00"
+//CALL ingress __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+//CALL upgrade
+//CALL ingress check "DIDL\x00\x00"
+
diff --git a/test/run-drun/blob-upgrade.mo b/test/run-drun/blob-upgrade.mo
new file mode 100644
index 00000000000..c606e0d7783
--- /dev/null
+++ b/test/run-drun/blob-upgrade.mo
@@ -0,0 +1,22 @@
+import Prim "mo:prim";
+
+actor {
+    let blobSize = 32 * 1024 * 1024;
+    let stablePageSize = 64 * 1024;
+    ignore Prim.stableMemoryGrow(Prim.natToNat64(blobSize / stablePageSize));
+
+    stable let blob = Prim.stableMemoryLoadBlob(0, blobSize);
+    stable let small = (123_456_789_123_456_789, "TEST");
+
+    public query func check() : async () {
+        assert (blob.size() == blobSize);
+        assert (small == (123_456_789_123_456_789, "TEST"));
+    };
+};
+//SKIP run
+//SKIP run-ir
+//SKIP run-low
+//CALL ingress check "DIDL\x00\x00"
+//CALL upgrade
+//CALL ingress check "DIDL\x00\x00"
+
diff --git a/test/run-drun/class-import.mo b/test/run-drun/class-import.mo
index 7ce67345fb8..e69e6d37ee9 100644
--- a/test/run-drun/class-import.mo
+++ b/test/run-drun/class-import.mo
@@ -29,7 +29,7 @@ actor a {
    // test non-trapping install
    try {
      Cycles.add<system>(2_000_000_000_000);
-     let trap : M3.Trap = await M3.Trap(false);
+     let _trap : M3.Trap = await M3.Trap(false);
    }
    catch _ {
      assert false;
@@ -38,7 +38,7 @@ actor a {
    // test trapping install
    try {
      Cycles.add<system>(2_000_000_000_000);
-     let trap : M3.Trap = await M3.Trap(true);
+     let _trap : M3.Trap = await M3.Trap(true);
      assert false;
    }
    catch _ {
diff --git a/test/run-drun/destabilization-crash.drun b/test/run-drun/destabilization-crash.drun
new file mode 100644
index 00000000000..c68d0da438e
--- /dev/null
+++ b/test/run-drun/destabilization-crash.drun
@@ -0,0 +1,4 @@
+# CLASSICAL-PERSISTENCE-ONLY
+# SKIP ic-ref-run
+install $ID destabilization-crash/destabilization-crash.mo ""
+upgrade $ID destabilization-crash/destabilization-crash.mo ""
diff --git a/test/run-drun/destabilization-crash/destabilization-crash.mo b/test/run-drun/destabilization-crash/destabilization-crash.mo
new file mode 100644
index 00000000000..5f3272e5ab2
--- /dev/null
+++ b/test/run-drun/destabilization-crash/destabilization-crash.mo
@@ -0,0 +1,44 @@
+import Prim = "mo:prim";
+
+// test destabilization of stable variables, without rts stack overflow
+actor a {
+
+   stable let x = Prim.stableMemoryGrow(1);
+   assert Prim.stableMemorySize() == 1;
+
+   type List<T> = ?(T, List<T>);
+
+   stable var map : List<(Blob, Blob)> = null;
+
+   var count : Nat32 = 0;
+
+   func fillMB(mb : Nat) : () {
+     var c = 1024;
+     while (c > 0) {
+       count += 1;
+       Prim.stableMemoryStoreNat32(0, count);
+       var k = Prim.stableMemoryLoadBlob(0, 32);
+       var v = Prim.stableMemoryLoadBlob(0, 65536);
+       map := ?((k,v), map);
+       c -= 1;
+     };
+     if (Prim.rts_heap_size() < mb * 1024 * 1024) {
+      // Difference between incremental and non-incremental GC (due to different object header lengths).
+      let toleranceMB = 4;
+      Prim.debugPrint(debug_show({heap_MB = Prim.rts_heap_size()/1024/1024/toleranceMB*toleranceMB}));
+      fillMB(mb);
+     }
+   };
+
+   system func preupgrade() {
+     Prim.debugPrint "preupgrade!";
+     fillMB(500); // Reduce because `drun` otherwise fails with `Ingress message did not finish executing within 10000 batches`.
+   };
+
+   system func postupgrade() {
+     // if we get here, destabilization has succeeded
+     Prim.debugPrint "postupgrade!";
+     assert false; // trap to avoid saving state to disk
+   }
+
+}
diff --git a/test/run-drun/double-sharing-benchmark.mo b/test/run-drun/double-sharing-benchmark.mo
new file mode 100644
index 00000000000..cb248c49939
--- /dev/null
+++ b/test/run-drun/double-sharing-benchmark.mo
@@ -0,0 +1,41 @@
+//ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+import Prim "mo:prim";
+
+actor {
+    type Node<T> = {
+        value : T;
+        left : ?Node<T>;
+        right : ?Node<T>;
+    };
+
+    stable var root : ?Node<Nat> = null;
+
+    func double(value : Nat) {
+        root := ?{
+            value;
+            left = root;
+            right = root;
+        };
+    };
+
+
+    public func run() : async () {
+        var size = 0;
+        while (size < 25) {
+            double(size);
+            size += 1;
+        };
+    };
+
+    system func postupgrade() {
+        Prim.debugPrint("Upgraded!");
+    };
+};
+
+//CALL ingress run "DIDL\x00\x00"
+//CALL ingress __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+//CALL upgrade ""
+
+//SKIP run-low
+//SKIP run
+//SKIP run-ir
diff --git a/test/run-drun/empty-actor.mo b/test/run-drun/empty-actor-classical.mo
similarity index 83%
rename from test/run-drun/empty-actor.mo
rename to test/run-drun/empty-actor-classical.mo
index 31684809b4f..564bf9d4ddd 100644
--- a/test/run-drun/empty-actor.mo
+++ b/test/run-drun/empty-actor-classical.mo
@@ -1,3 +1,4 @@
+//CLASSICAL-PERSISTENCE-ONLY
 actor {};
 
 // The prelude should not require any code (besides maybe a call to collect) at runtime
@@ -9,7 +10,7 @@ actor {};
 // CHECK-NEXT:    i32.const 0
 // CHECK-NEXT:    call 32
 // CHECK-NEXT:    global.set 4
-// CHECK-NEXT:    call $incremental_gc
+// CHECK-NEXT:    call ${{copying_gc|compacting_gc|generational_gc|incremental_gc}}
 // CHECK-NEXT:    i32.const 0
 // CHECK-NEXT:    call 32
 // CHECK-NEXT:    global.get 4
@@ -18,5 +19,3 @@ actor {};
 // CHECK-NEXT:    call $trans_state
 
 // CHECK:  (export "canister_init" (func $canister_init))
-
-
diff --git a/test/run-drun/empty-actor-enhanced.mo b/test/run-drun/empty-actor-enhanced.mo
new file mode 100644
index 00000000000..582ff41098a
--- /dev/null
+++ b/test/run-drun/empty-actor-enhanced.mo
@@ -0,0 +1,18 @@
+//ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+actor {};
+
+// The prelude should not require any code (besides maybe a call to collect) at runtime
+// DON'TCHECK: (func $init (type 4))
+
+// CHECK:  (func $@motoko_async_destabilization (type 0)
+// CHECK:         call $trans_state10 
+// CHECK:         call $post_exp
+// CHECK:         call $start_gc_after_destabilization
+// CHECK:         call $trans_state4
+// CHECK:         call $@initialize_main_actor
+
+// CHECK:  (func $canister_init
+// CHECK-NEXT:    call $trans_state
+// CHECK-NEXT:    call $init
+
+// CHECK:  (export "canister_init" (func $canister_init))
diff --git a/test/run-drun/free-callbacks.mo b/test/run-drun/free-callbacks.mo
index ce026670046..c2805a01c12 100644
--- a/test/run-drun/free-callbacks.mo
+++ b/test/run-drun/free-callbacks.mo
@@ -29,7 +29,7 @@ actor a {
     // Checks that GC correctly discards or retains the arrays.
     // Using --forced-gc and allowing young collection for generational GC.
     // It allows for some wiggle room
-    let reserve = 9_000;
+    let reserve = 20_000;
     assert (+s1-s0 < reserve);
     assert (+s2-s0 > 4 * +length - reserve);
   };
diff --git a/test/run-drun/function-stabilization.drun b/test/run-drun/function-stabilization.drun
new file mode 100644
index 00000000000..035d90993f2
--- /dev/null
+++ b/test/run-drun/function-stabilization.drun
@@ -0,0 +1,16 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+install $ID function-stabilization/version0.mo ""
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x01\x7d\x0F"
+upgrade $ID function-stabilization/version0.mo ""
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x01\x7d\x0F"
+upgrade $ID function-stabilization/version1.mo ""
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x01\x7d\x0F"
+upgrade $ID function-stabilization/version1.mo ""
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x01\x7d\x0F"
+upgrade $ID function-stabilization/version2.mo ""
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x01\x7d\x0F"
+upgrade $ID function-stabilization/version3.mo ""
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x01\x7d\x0F"
+upgrade $ID function-stabilization/version4.mo ""
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x01\x7d\x0F"
+upgrade $ID function-stabilization/version1.mo ""
diff --git a/test/run-drun/function-stabilization/version0.mo b/test/run-drun/function-stabilization/version0.mo
new file mode 100644
index 00000000000..6e55e9c0b4c
--- /dev/null
+++ b/test/run-drun/function-stabilization/version0.mo
@@ -0,0 +1,14 @@
+actor {
+   public shared query func f0() : async () { loop {} };
+   stable let x0 = f0;
+
+   public shared composite query func f1(_ : Nat, _ : Bool) : async (Nat, Bool) {
+      loop {};
+   };
+   stable let x1 = f1;
+
+   public shared func f2(_ : {#one; #two}, _ : { oldField : Nat }) : async { oldField : Text } {
+      loop {};
+   };
+   stable let x2 = f2;
+};
diff --git a/test/run-drun/function-stabilization/version1.mo b/test/run-drun/function-stabilization/version1.mo
new file mode 100644
index 00000000000..c951177bfbb
--- /dev/null
+++ b/test/run-drun/function-stabilization/version1.mo
@@ -0,0 +1,14 @@
+actor {
+   public shared query func f0() : async () { loop {} };
+   stable let x0 = f0;
+
+   public shared composite query func f1(_ : Nat, _ : Bool) : async (Nat, Bool) {
+      loop {};
+   };
+   stable let x1 = f1;
+
+   public shared func f2(_ : {#one}, _ : { oldField : Nat; newField: Text }) : async { } {
+      loop {};
+   };
+   stable let x2 = f2;
+};
diff --git a/test/run-drun/function-stabilization/version2.mo b/test/run-drun/function-stabilization/version2.mo
new file mode 100644
index 00000000000..2f1da5cc8b7
--- /dev/null
+++ b/test/run-drun/function-stabilization/version2.mo
@@ -0,0 +1,6 @@
+actor {
+   public shared func f2(_ : {#one; #three}, _ : { oldField : Nat; newField: Text }) : async { } {
+      loop {};
+   };
+   stable let x2 = f2;
+};
diff --git a/test/run-drun/function-stabilization/version3.mo b/test/run-drun/function-stabilization/version3.mo
new file mode 100644
index 00000000000..6fe5a3ac75c
--- /dev/null
+++ b/test/run-drun/function-stabilization/version3.mo
@@ -0,0 +1,6 @@
+actor {
+   public shared func f2(_ : {#one}, _ : { newField: Text }) : async { } {
+      loop {};
+   };
+   stable let x2 = f2;
+};
diff --git a/test/run-drun/function-stabilization/version4.mo b/test/run-drun/function-stabilization/version4.mo
new file mode 100644
index 00000000000..0503260205c
--- /dev/null
+++ b/test/run-drun/function-stabilization/version4.mo
@@ -0,0 +1,6 @@
+actor {
+   public shared func f2(_ : {#one}, _ : { oldField : Nat; newField: Text }) : async { newField: Bool } {
+      loop {};
+   };
+   stable let x2 = f2;
+};
diff --git a/test/run-drun/function-upgrades.drun b/test/run-drun/function-upgrades.drun
index cd83b4859e0..4b93b14ba55 100644
--- a/test/run-drun/function-upgrades.drun
+++ b/test/run-drun/function-upgrades.drun
@@ -1,3 +1,4 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
 install $ID function-upgrades/version0.mo ""
 upgrade $ID function-upgrades/version0.mo ""
 upgrade $ID function-upgrades/version1.mo ""
diff --git a/test/run-drun/gc-trigger.mo b/test/run-drun/gc-trigger.mo
index 8ffe61788c8..fc39006a963 100644
--- a/test/run-drun/gc-trigger.mo
+++ b/test/run-drun/gc-trigger.mo
@@ -2,10 +2,11 @@
 import Prim "mo:prim";
 
 actor {
-    let retained = Prim.Array_init<Nat>(5 * 1024 * 1024, 0);
+    let retained = Prim.Array_init<Nat>(6 * 1024 * 1024, 0);
     // GC is triggered during initialization
 
-    var heapSizeWithGarbage = 0;
+    let heapSizeWithoutGarbage = Prim.rts_heap_size();
+    var heapSizeWithGarbage = heapSizeWithoutGarbage;
 
     public func createGarbage(): async() {
         ignore Prim.Array_init<Nat>(1024 * 1024, 0);
@@ -15,12 +16,13 @@ actor {
     };
 
     public query func checkBeforeGC(): async() {
-        assert(Prim.rts_heap_size() >= heapSizeWithGarbage);
+        assert(Prim.rts_heap_size() >= heapSizeWithoutGarbage);
     };
 
     public query func checkAfterGC(): async() {
         assert(retained.size() > 0); // ensures that the array is not collected
-        assert(Prim.rts_heap_size() < heapSizeWithGarbage);
+        let tolerance = 100_000;
+        assert(Prim.rts_heap_size() < heapSizeWithGarbage + tolerance);
     };
 };
 //SKIP run
diff --git a/test/run-drun/hashBlob.mo b/test/run-drun/hashBlob.mo
new file mode 100644
index 00000000000..63e8a028cc1
--- /dev/null
+++ b/test/run-drun/hashBlob.mo
@@ -0,0 +1,12 @@
+import Prim "mo:⛔";
+
+actor a {
+  public shared ({ caller }) func test() : async Nat32 {
+    let value = Prim.hashBlob(Prim.blobOfPrincipal caller);
+    Prim.debugPrint(debug_show (value));
+    Prim.debugPrint(debug_show (value + 1));
+    value;
+  };
+};
+
+ignore a.test(); //OR-CALL ingress test 0x4449444C0000
diff --git a/test/run-drun/incremental-actor-class-stabilization.mo b/test/run-drun/incremental-actor-class-stabilization.mo
new file mode 100644
index 00000000000..eec2ab594f9
--- /dev/null
+++ b/test/run-drun/incremental-actor-class-stabilization.mo
@@ -0,0 +1,51 @@
+//ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+//MOC-FLAG --stabilization-instruction-limit=10000
+
+import Prim "mo:⛔";
+import Cycles = "cycles/cycles";
+import TestActor "incremental-actor-class-stabilization/test-actor";
+
+actor a {
+  type IncrementalStabilization = actor {
+    __motoko_stabilize_before_upgrade : () -> async ();
+    __motoko_destabilize_after_upgrade : () -> async ();
+  };
+
+  func useIncrementalStabilization(a : actor {}) : IncrementalStabilization {
+    actor (debug_show (Prim.principalOfActor(a))) : IncrementalStabilization;
+  };
+
+  public func run() : async () {
+    if (Cycles.balance() == 0) {
+      await Cycles.provisional_top_up_actor(a, 100_000_000_000_000);
+    };
+
+    Cycles.add<system>(2_000_000_000_000);
+    let testActor = await TestActor.TestActor(1234567890123456789012345678901234567890, "Test actor", Prim.Array_tabulate<Nat>(100_000, func(index) { index }));
+    let testStabilization = useIncrementalStabilization(testActor);
+    await testActor.print();
+    await testStabilization.__motoko_stabilize_before_upgrade();
+    try {
+      await testActor.print();
+      assert false;
+    } catch (e) {
+      Prim.debugPrint(Prim.errorMessage(e));
+    };
+    Prim.debugPrint("Upgrade");
+    let upgraded = await (system TestActor.TestActor)(#upgrade testActor)(0, "", []);
+    assert (testActor == upgraded);
+    try {
+      await testActor.print();
+      assert false;
+    } catch (e) {
+      Prim.debugPrint(Prim.errorMessage(e));
+    };
+    await testStabilization.__motoko_destabilize_after_upgrade();
+    await testActor.print();
+  };
+};
+
+//CALL ingress run "DIDL\x00\x00"
+//SKIP run
+//SKIP run-ir
+//SKIP run-low
diff --git a/test/run-drun/incremental-actor-class-stabilization/test-actor.mo b/test/run-drun/incremental-actor-class-stabilization/test-actor.mo
new file mode 100644
index 00000000000..b3829bc411b
--- /dev/null
+++ b/test/run-drun/incremental-actor-class-stabilization/test-actor.mo
@@ -0,0 +1,26 @@
+import Prim "mo:⛔";
+
+actor class TestActor(number : Nat, text : Text, array : [Nat]) {
+  stable var stableNat = number;
+  stable var stableInt = -number;
+  stable var stableText = text;
+  stable var stableArray = array;
+
+  public func print() : async () {
+    Prim.debugPrint(debug_show (number));
+    Prim.debugPrint(debug_show (text));
+    Prim.debugPrint(debug_show (array.size()));
+    Prim.debugPrint(debug_show (stableNat));
+    Prim.debugPrint(debug_show (stableInt));
+    Prim.debugPrint(debug_show (stableText));
+    Prim.debugPrint(debug_show (stableArray.size()));
+  };
+
+  system func preupgrade() {
+    Prim.debugPrint("PRE-UPGRADE HOOK!");
+  };
+
+  system func postupgrade() {
+    Prim.debugPrint("POST-UPGRADE HOOK!");
+  };
+};
diff --git a/test/run-drun/incremental-stabilization.mo b/test/run-drun/incremental-stabilization.mo
new file mode 100644
index 00000000000..32c9cd020c6
--- /dev/null
+++ b/test/run-drun/incremental-stabilization.mo
@@ -0,0 +1,69 @@
+//ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+//MOC-FLAG --stabilization-instruction-limit=10000
+
+import Prim "mo:prim";
+
+actor {
+    let flexibleNat = do {
+        Prim.debugPrint("Initialize flexible Nat");
+        1
+    };
+    stable var stableNat = do {
+        Prim.debugPrint("Initialize stable Nat");
+        12345678901234567890123456789012345678901234567890123456789012345678901234567890;
+    };
+    stable var stableInt = do {
+        Prim.debugPrint("Initialize stable Int");
+        -2345678901234567890123456789012345678901234567890123456789012345678901234567890;
+    };
+    stable var stableText = do {
+        Prim.debugPrint("Initialize stable text");
+        "Motoko incremental graph-copy-based upgrade test";
+    };
+    stable var stableArray = do {
+        Prim.debugPrint("Initialize stable array");
+        Prim.Array_tabulate<Nat>(100, func (index) { index });
+    };
+    stable var stableObject = do {
+        Prim.debugPrint("Initialize stable object");
+        { stableNat; stableInt; stableText; stableArray; }
+    };
+    let flexibleText = do {
+        Prim.debugPrint("Initialize flexible text");
+        "Flexible text"
+    };
+    // To trigger incremental serialization/deserialization
+    stable var _largeStableArray = do {
+         Prim.Array_tabulate<Nat>(100_000, func (index) { index });
+    };
+
+    public func print() : async () {
+        Prim.debugPrint(debug_show (flexibleNat));
+        Prim.debugPrint(debug_show (flexibleText));
+        Prim.debugPrint(debug_show (stableNat));
+        Prim.debugPrint(debug_show (stableInt));
+        Prim.debugPrint(debug_show (stableText));
+        Prim.debugPrint(debug_show (stableArray));
+        Prim.debugPrint(debug_show (stableObject));
+    };
+
+    system func preupgrade() {
+        Prim.debugPrint("PRE-UPGRADE HOOK!");
+    };
+
+    system func postupgrade() {
+        Prim.debugPrint("POST-UPGRADE HOOK!");
+    };
+};
+
+//CALL ingress print "DIDL\x00\x00"
+//CALL ingress __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+//CALL ingress print "DIDL\x00\x00"
+//CALL upgrade ""
+//CALL ingress print "DIDL\x00\x00"
+//CALL ingress __motoko_destabilize_after_upgrade "DIDL\x00\x00"
+//CALL ingress print "DIDL\x00\x00"
+
+//SKIP run
+//SKIP run-ir
+//SKIP run-low
diff --git a/test/run-drun/large-destabilization.drun b/test/run-drun/large-destabilization.drun
index 069817462cb..bb0712bcb5e 100644
--- a/test/run-drun/large-destabilization.drun
+++ b/test/run-drun/large-destabilization.drun
@@ -1,3 +1,4 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
 # SKIP ic-ref-run
 install $ID large-destabilization/large-destabilization.mo ""
 upgrade $ID large-destabilization/large-destabilization.mo ""
diff --git a/test/run-drun/map-mixed-upgrades.drun b/test/run-drun/map-mixed-upgrades.drun
new file mode 100644
index 00000000000..35d435cbdec
--- /dev/null
+++ b/test/run-drun/map-mixed-upgrades.drun
@@ -0,0 +1,36 @@
+# CLASSICAL-PERSISTENCE-ONLY
+# DEFAULT-GC-ONLY
+# SKIP ic-ref-run
+install $ID map-mixed-upgrades/map0.mo ""
+ingress $ID go "DIDL\x00\x00"
+upgrade $ID map-mixed-upgrades/map0.mo ""
+ingress $ID upgradeNodes "DIDL\x00\x00"
+# This succeeeds:
+ingress $ID upgradeNodesReplaceMainMemory "DIDL\x00\x00"
+# This fails:
+ingress $ID upgradeNodesKeepMainMemory "DIDL\x00\x00"
+ingress $ID go "DIDL\x00\x00"
+upgrade $ID map-mixed-upgrades/map1.mo ""
+ingress $ID upgradeNodes "DIDL\x00\x00"
+ingress $ID go "DIDL\x00\x00"
+upgrade $ID map-mixed-upgrades/map1.mo ""
+ingress $ID upgradeNodes "DIDL\x00\x00"
+ingress $ID go "DIDL\x00\x00"
+# This succeeeds:
+ingress $ID upgradeNodesKeepMainMemory "DIDL\x00\x00"
+ingress $ID go "DIDL\x00\x00"
+# Use stabilization and keep main memory:
+ingress $ID stabilizeNodes "DIDL\x00\x00"
+ingress $ID upgradeNodesKeepMainMemory "DIDL\x00\x00"
+ingress $ID go "DIDL\x00\x00"
+# Use stabilization, but reset main memory:
+ingress $ID stabilizeNodes "DIDL\x00\x00"
+ingress $ID upgradeNodesReplaceMainMemory "DIDL\x00\x00"
+ingress $ID go "DIDL\x00\x00"
+# This fails (downgrade EOP to classical persistence)
+upgrade $ID map-mixed-upgrades/map0.mo ""
+ingress $ID upgradeNodes "DIDL\x00\x00"
+ingress $ID go "DIDL\x00\x00"
+# This drops the memory, state will be lost:
+ingress $ID upgradeNodesReplaceMainMemory "DIDL\x00\x00"
+ingress $ID go "DIDL\x00\x00"
diff --git a/test/run-drun/map-mixed-upgrades/map0.mo b/test/run-drun/map-mixed-upgrades/map0.mo
new file mode 100644
index 00000000000..96ac9dea3a9
--- /dev/null
+++ b/test/run-drun/map-mixed-upgrades/map0.mo
@@ -0,0 +1,107 @@
+// Start with classical persistence, see `map-mixed-upgrades.drun`.
+import Prim "mo:⛔";
+import Cycles = "../cycles/cycles";
+import Lib "node0";
+
+// A naive, distributed map from Nat to Text.
+// Illustrates dynamic installation of imported actor classes.
+// Uses a fixed number of nodes, dynamically installed on demand
+// .. and upgraded with a call to upgradeNodes() (without data loss)
+
+actor a {
+
+  type Key = Nat;
+  type Value = Text;
+
+  // Number of Nodes
+  let n = 8;
+
+  type Node = Lib.Node;
+
+  stable let savedNodes : [var ?(actor{})] = Prim.Array_init(n, null);
+
+  let nodes : [var ?Node] = Prim.Array_init(n, null);
+
+  // Would be nice if these were both tail calls on the platform
+  public func lookup(k : Key) : async ?Value {
+    switch (nodes[k % n]) {
+      case null null;
+      case (?node) await node.lookup(k);
+    };
+  };
+
+  public func insert(k : Key, v : Value) : async () {
+    let i = k % n;
+    let node = switch (nodes[i]) {
+      case null {
+        Cycles.add(2_000_000_000_000);
+        let n = await Lib.Node(i); // dynamically install a new Node
+        nodes[i] := ?n;
+        n;
+      };
+      case (?node) node;
+    };
+    await node.insert(k, v);
+  };
+
+  system func preupgrade () {
+     for (i in nodes.keys()) {
+       savedNodes[i] := nodes[i];
+     }
+  };
+
+  public func upgradeNodes() : async () {
+    for(i in savedNodes.keys()) {
+       switch (savedNodes[i]) {
+         case null {};
+         case (?n) {
+           nodes[i] :=
+             ? (await (system Lib.Node)(#upgrade n)(i)); // upgrade!
+         }
+       }
+    }
+  };
+
+  public func upgradeNodesKeepMainMemory() : async () {
+    for(i in savedNodes.keys()) {
+       switch (savedNodes[i]) {
+         case null {};
+         case (?n) {
+           nodes[i] :=
+             ? (await (system Lib.Node)(#upgrade_with_persistence { wasm_memory_persistence = #Keep; canister = n })(i)); // upgrade!
+         }
+       }
+    }
+  };
+
+  public func upgradeNodesReplaceMainMemory() : async () {
+    for(i in savedNodes.keys()) {
+       switch (savedNodes[i]) {
+         case null {};
+         case (?n) {
+           nodes[i] :=
+             ? (await (system Lib.Node)(#upgrade_with_persistence { wasm_memory_persistence = #Replace; canister = n })(i)); // upgrade!
+         }
+       }
+    }
+  };
+
+  stable var k = 0;
+  // add 2 next keys on each call
+  public func go() : async () {
+    // To get lots of cycles in both drun and ic-ref-run
+    if (Cycles.balance() == 0)
+      await Cycles.provisional_top_up_actor(a, 100_000_000_000_000);
+
+    var i = 0;
+    while (i < 2) {
+      k += 1;
+      let t = debug_show(k);
+      assert (null == (await lookup(k)));
+      await insert(k, t);
+      assert (?t == (await lookup(k)));
+      i += 1;
+    };
+  };
+
+};
diff --git a/test/run-drun/map-mixed-upgrades/map1.mo b/test/run-drun/map-mixed-upgrades/map1.mo
new file mode 100644
index 00000000000..f85e7439064
--- /dev/null
+++ b/test/run-drun/map-mixed-upgrades/map1.mo
@@ -0,0 +1,143 @@
+//MOC-FLAG --enhanced-orthogonal-persistence
+import Prim "mo:⛔";
+import Cycles = "../cycles/cycles";
+import Lib "node1"; // new version!
+import Lib0 "node0"; // old version!
+
+// A naive, distributed map from Nat to Text.
+// Illustrates dynamic installation of imported actor classes.
+// Uses a fixed number of nodes, dynamically installed on demand
+// .. and upgraded with a call to upgradeNodes() (without data loss)
+
+actor a {
+
+  type Key = Nat;
+  type Value = Text;
+
+  // Number of Nodes
+  let n = 8;
+
+  type Node = Lib.Node;
+
+  stable let savedNodes : [var ?(actor{})] = Prim.Array_init(n, null);
+
+  let nodes : [var ?Node] = Prim.Array_init(n, null);
+
+  // Would be nice if these were both tail calls on the platform
+  public func lookup(k : Key) : async ?Value {
+    switch (nodes[k % n]) {
+      case null null;
+      case (?node) await node.lookup(k);
+    };
+  };
+
+  public func insert(k : Key, v : Value) : async () {
+    let i = k % n;
+    let node = switch (nodes[i]) {
+      case null {
+        Cycles.add(2_000_000_000_000);
+        let n = await Lib.Node(i); // dynamically install a new Node
+        nodes[i] := ?n;
+        n;
+      };
+      case (?node) node;
+    };
+    await node.insert(k, v);
+  };
+
+  public func remove(k : Key) : async () {
+    let i = k % n;
+    let node = switch (nodes[i]) {
+      case null { };
+      case (?node) {
+        await node.remove(k);
+      }
+    };
+  };
+
+  system func preupgrade () {
+     for (i in nodes.keys()) {
+       savedNodes[i] := nodes[i];
+     }
+  };
+
+  public func upgradeNodes() : async () {
+    for(i in savedNodes.keys()) {
+       switch (savedNodes[i]) {
+         case null {};
+         case (?n) {
+           nodes[i] :=
+             ? (await (system Lib.Node)(#upgrade n)(i)); // upgrade!
+         }
+       }
+    }
+  };
+
+  public func upgradeNodesKeepMainMemory() : async () {
+    for(i in savedNodes.keys()) {
+       switch (savedNodes[i]) {
+         case null {};
+         case (?n) {
+           nodes[i] :=
+             ? (await (system Lib.Node)(#upgrade_with_persistence { wasm_memory_persistence = #Keep; canister = n })(i)); // upgrade!
+         }
+       }
+    }
+  };
+
+  public func upgradeNodesReplaceMainMemory() : async () {
+    for(i in savedNodes.keys()) {
+       switch (savedNodes[i]) {
+         case null {};
+         case (?n) {
+           nodes[i] :=
+             ? (await (system Lib.Node)(#upgrade_with_persistence { wasm_memory_persistence = #Replace; canister = n })(i)); // upgrade!
+         }
+       }
+    }
+  };
+
+  type IncrementalStabilization = actor {
+    __motoko_stabilize_before_upgrade : () -> async ();
+    __motoko_destabilize_after_upgrade : () -> async ();
+  };
+
+  func useIncrementalStabilization(a : actor {}) : IncrementalStabilization {
+    actor (debug_show (Prim.principalOfActor(a))) : IncrementalStabilization;
+  };
+
+  public func stabilizeNodes() : async () {
+    for(i in savedNodes.keys()) {
+       switch (savedNodes[i]) {
+         case null {};
+         case (?n) {
+           let a = useIncrementalStabilization(n);
+           await a.__motoko_stabilize_before_upgrade();
+         }
+       }
+    }
+  };
+
+  stable var k = 0;
+  // add 2 next keys on each call
+  public func go() : async () {
+    // To get lots of cycles in both drun and ic-ref-run
+    if (Cycles.balance() == 0)
+      await Cycles.provisional_top_up_actor(a, 100_000_000_000_000);
+
+    var i = 0;
+    while (i < 2) {
+      k += 1;
+      let t = debug_show(k);
+      assert (null == (await lookup(k)));
+      await insert(k, t);
+      assert (?t == (await lookup(k)));
+      await remove(k);
+      assert (null == (await lookup(k)));
+      await insert(k, t);
+      assert (?t == (await lookup(k)));
+      i += 1;
+    };
+  };
+
+};
diff --git a/test/run-drun/map-mixed-upgrades/node0.mo b/test/run-drun/map-mixed-upgrades/node0.mo
new file mode 100644
index 00000000000..4816bed5ea8
--- /dev/null
+++ b/test/run-drun/map-mixed-upgrades/node0.mo
@@ -0,0 +1,42 @@
+import Prim "mo:⛔";
+actor class Node(i : Nat) {
+
+  stable var upgrades = 0;
+
+  type Key = Nat;
+  type Value = Text;
+
+  type List = ?(Key, Value, List);
+
+  stable var map : List = null;
+
+  Prim.debugPrint(debug_show {node = i; upgrades = upgrades; state = map});
+
+  public func lookup(k : Key) : async ? Value {
+    Prim.debugPrint(debug_show i # ": lookup " # debug_show k);
+    var m = map;
+    loop {
+      switch m {
+        case (?(k1, v, m1)) {
+          if (k == k1) { return ?v }
+          else {
+            m := m1;
+          };
+        };
+        case null {
+          return null;
+        }
+      }
+    }
+  };
+
+  system func preupgrade () {
+    upgrades += 1;
+  };
+
+  public func insert(k : Key, v : Value) : async () {
+    Prim.debugPrint(debug_show i # ": insert " # debug_show (k,v));
+    map := ?(k, v, map);
+  };
+
+};
diff --git a/test/run-drun/map-mixed-upgrades/node1.mo b/test/run-drun/map-mixed-upgrades/node1.mo
new file mode 100644
index 00000000000..97f0f81ccbf
--- /dev/null
+++ b/test/run-drun/map-mixed-upgrades/node1.mo
@@ -0,0 +1,64 @@
+import Prim "mo:⛔";
+actor class Node(i : Nat) {
+
+  stable var upgrades = 0;
+
+  type Key = Nat;
+  type Value = Text;
+
+  type List = ?(Key, Value, List);
+
+  stable var map : List = null;
+
+  Prim.debugPrint(debug_show {node = i; upgrades = upgrades; state = map});
+
+  public func lookup(k : Key) : async ? Value {
+    Prim.debugPrint(debug_show i # ": lookup " # debug_show k);
+    var m = map;
+    loop {
+      switch m {
+        case (?(k1, v, m1)) {
+          if (k == k1) { return ?v }
+          else {
+            m := m1;
+          };
+        };
+        case null {
+          return null;
+        }
+      }
+    }
+  };
+
+  system func preupgrade () {
+    upgrades += 1;
+  };
+
+  public func insert(k : Key, v : Value) : async () {
+    Prim.debugPrint(debug_show i # ": insert " # debug_show (k,v));
+    map := ?(k, v, map);
+  };
+
+  func rem(k : Key, l : List) : List {
+    switch l {
+      case (?(k1, v1, l1)) {
+        if (k == k1) {
+          rem(k, l1)
+        }
+        else {
+          ?(k1, v1, rem(k, l1))
+        };
+      };
+      case null {
+        return null;
+      }
+    }
+  };
+
+  public func remove(k : Key) : async () {
+    Prim.debugPrint(debug_show i # ": remove " # debug_show (k));
+    map := rem(k, map);
+  };
+
+
+};
diff --git a/test/run-drun/map-stabilization.drun b/test/run-drun/map-stabilization.drun
new file mode 100644
index 00000000000..b6aa1838639
--- /dev/null
+++ b/test/run-drun/map-stabilization.drun
@@ -0,0 +1,15 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+install $ID map-stabilization/map0.mo ""
+ingress $ID go "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID map-stabilization/map0.mo ""
+ingress $ID upgradeNodes "DIDL\x00\x00"
+ingress $ID go "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID map-stabilization/map1.mo ""
+ingress $ID upgradeNodes "DIDL\x00\x00"
+ingress $ID go "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID map-stabilization/map1.mo ""
+ingress $ID upgradeNodes "DIDL\x00\x00"
+ingress $ID go "DIDL\x00\x00"
diff --git a/test/run-drun/map-stabilization/map0.mo b/test/run-drun/map-stabilization/map0.mo
new file mode 100644
index 00000000000..afb067f7935
--- /dev/null
+++ b/test/run-drun/map-stabilization/map0.mo
@@ -0,0 +1,82 @@
+import Prim "mo:⛔";
+import Cycles = "../cycles/cycles";
+import Lib "node0";
+
+// A naive, distributed map from Nat to Text.
+// Illustrates dynamic installation of imported actor classes.
+// Uses a fixed number of nodes, dynamically installed on demand
+// .. and upgraded with a call to upgradeNodes() (without data loss)
+
+actor a {
+
+  type Key = Nat;
+  type Value = Text;
+
+  // Number of Nodes
+  let n = 8;
+
+  type Node = Lib.Node;
+
+  stable let savedNodes : [var ?(actor{})] = Prim.Array_init(n, null);
+
+  let nodes : [var ?Node] = Prim.Array_init(n, null);
+
+  // Would be nice if these were both tail calls on the platform
+  public func lookup(k : Key) : async ?Value {
+    switch (nodes[k % n]) {
+      case null null;
+      case (?node) await node.lookup(k);
+    };
+  };
+
+  public func insert(k : Key, v : Value) : async () {
+    let i = k % n;
+    let node = switch (nodes[i]) {
+      case null {
+        Cycles.add(2_000_000_000_000);
+        let n = await Lib.Node(i); // dynamically install a new Node
+        nodes[i] := ?n;
+        n;
+      };
+      case (?node) node;
+    };
+    await node.insert(k, v);
+  };
+
+  system func preupgrade () {
+     for (i in nodes.keys()) {
+       savedNodes[i] := nodes[i];
+     }
+  };
+
+  public func upgradeNodes() : async () {
+    for(i in savedNodes.keys()) {
+       switch (savedNodes[i]) {
+         case null {};
+         case (?n) {
+           nodes[i] :=
+             ? (await (system Lib.Node)(#upgrade n)(i)); // upgrade!
+         }
+       }
+    }
+  };
+
+  stable var k = 0;
+  // add 2 next keys on each call
+  public func go() : async () {
+    // To get lots of cycles in both drun and ic-ref-run
+    if (Cycles.balance() == 0)
+      await Cycles.provisional_top_up_actor(a, 100_000_000_000_000);
+
+    var i = 0;
+    while (i < 2) {
+      k += 1;
+      let t = debug_show(k);
+      assert (null == (await lookup(k)));
+      await insert(k, t);
+      assert (?t == (await lookup(k)));
+      i += 1;
+    };
+  };
+
+};
diff --git a/test/run-drun/map-stabilization/map1.mo b/test/run-drun/map-stabilization/map1.mo
new file mode 100644
index 00000000000..3356ce3d59d
--- /dev/null
+++ b/test/run-drun/map-stabilization/map1.mo
@@ -0,0 +1,96 @@
+import Prim "mo:⛔";
+import Cycles = "../cycles/cycles";
+import Lib "node1"; // new version!
+
+// A naive, distributed map from Nat to Text.
+// Illustrates dynamic installation of imported actor classes.
+// Uses a fixed number of nodes, dynamically installed on demand
+// .. and upgraded with a call to upgradeNodes() (without data loss)
+
+actor a {
+
+  type Key = Nat;
+  type Value = Text;
+
+  // Number of Nodes
+  let n = 8;
+
+  type Node = Lib.Node;
+
+  stable let savedNodes : [var ?(actor{})] = Prim.Array_init(n, null);
+
+  let nodes : [var ?Node] = Prim.Array_init(n, null);
+
+  // Would be nice if these were both tail calls on the platform
+  public func lookup(k : Key) : async ?Value {
+    switch (nodes[k % n]) {
+      case null null;
+      case (?node) await node.lookup(k);
+    };
+  };
+
+  public func insert(k : Key, v : Value) : async () {
+    let i = k % n;
+    let node = switch (nodes[i]) {
+      case null {
+        Cycles.add(2_000_000_000_000);
+        let n = await Lib.Node(i); // dynamically install a new Node
+        nodes[i] := ?n;
+        n;
+      };
+      case (?node) node;
+    };
+    await node.insert(k, v);
+  };
+
+  public func remove(k : Key) : async () {
+    let i = k % n;
+    let node = switch (nodes[i]) {
+      case null { };
+      case (?node) {
+        await node.remove(k);
+      }
+    };
+  };
+
+  system func preupgrade () {
+     for (i in nodes.keys()) {
+       savedNodes[i] := nodes[i];
+     }
+  };
+
+  public func upgradeNodes() : async () {
+    for(i in savedNodes.keys()) {
+       switch (savedNodes[i]) {
+         case null {};
+         case (?n) {
+           nodes[i] :=
+             ? (await (system Lib.Node)(#upgrade n)(i)); // upgrade!
+         }
+       }
+    }
+  };
+
+  stable var k = 0;
+  // add 2 next keys on each call
+  public func go() : async () {
+    // To get lots of cycles in both drun and ic-ref-run
+    if (Cycles.balance() == 0)
+      await Cycles.provisional_top_up_actor(a, 100_000_000_000_000);
+
+    var i = 0;
+    while (i < 2) {
+      k += 1;
+      let t = debug_show(k);
+      assert (null == (await lookup(k)));
+      await insert(k, t);
+      assert (?t == (await lookup(k)));
+      await remove(k);
+      assert (null == (await lookup(k)));
+      await insert(k, t);
+      assert (?t == (await lookup(k)));
+      i += 1;
+    };
+  };
+
+};
diff --git a/test/run-drun/map-stabilization/node0.mo b/test/run-drun/map-stabilization/node0.mo
new file mode 100644
index 00000000000..4816bed5ea8
--- /dev/null
+++ b/test/run-drun/map-stabilization/node0.mo
@@ -0,0 +1,42 @@
+import Prim "mo:⛔";
+actor class Node(i : Nat) {
+
+  stable var upgrades = 0;
+
+  type Key = Nat;
+  type Value = Text;
+
+  type List = ?(Key, Value, List);
+
+  stable var map : List = null;
+
+  Prim.debugPrint(debug_show {node = i; upgrades = upgrades; state = map});
+
+  public func lookup(k : Key) : async ? Value {
+    Prim.debugPrint(debug_show i # ": lookup " # debug_show k);
+    var m = map;
+    loop {
+      switch m {
+        case (?(k1, v, m1)) {
+          if (k == k1) { return ?v }
+          else {
+            m := m1;
+          };
+        };
+        case null {
+          return null;
+        }
+      }
+    }
+  };
+
+  system func preupgrade () {
+    upgrades += 1;
+  };
+
+  public func insert(k : Key, v : Value) : async () {
+    Prim.debugPrint(debug_show i # ": insert " # debug_show (k,v));
+    map := ?(k, v, map);
+  };
+
+};
diff --git a/test/run-drun/map-stabilization/node1.mo b/test/run-drun/map-stabilization/node1.mo
new file mode 100644
index 00000000000..97f0f81ccbf
--- /dev/null
+++ b/test/run-drun/map-stabilization/node1.mo
@@ -0,0 +1,64 @@
+import Prim "mo:⛔";
+actor class Node(i : Nat) {
+
+  stable var upgrades = 0;
+
+  type Key = Nat;
+  type Value = Text;
+
+  type List = ?(Key, Value, List);
+
+  stable var map : List = null;
+
+  Prim.debugPrint(debug_show {node = i; upgrades = upgrades; state = map});
+
+  public func lookup(k : Key) : async ? Value {
+    Prim.debugPrint(debug_show i # ": lookup " # debug_show k);
+    var m = map;
+    loop {
+      switch m {
+        case (?(k1, v, m1)) {
+          if (k == k1) { return ?v }
+          else {
+            m := m1;
+          };
+        };
+        case null {
+          return null;
+        }
+      }
+    }
+  };
+
+  system func preupgrade () {
+    upgrades += 1;
+  };
+
+  public func insert(k : Key, v : Value) : async () {
+    Prim.debugPrint(debug_show i # ": insert " # debug_show (k,v));
+    map := ?(k, v, map);
+  };
+
+  func rem(k : Key, l : List) : List {
+    switch l {
+      case (?(k1, v1, l1)) {
+        if (k == k1) {
+          rem(k, l1)
+        }
+        else {
+          ?(k1, v1, rem(k, l1))
+        };
+      };
+      case null {
+        return null;
+      }
+    }
+  };
+
+  public func remove(k : Key) : async () {
+    Prim.debugPrint(debug_show i # ": remove " # debug_show (k));
+    map := rem(k, map);
+  };
+
+
+};
diff --git a/test/run-drun/map-upgrades.drun b/test/run-drun/map-upgrades.drun
index 95fac3cb58d..db5be5e7bb8 100644
--- a/test/run-drun/map-upgrades.drun
+++ b/test/run-drun/map-upgrades.drun
@@ -15,4 +15,3 @@ ingress $ID go "DIDL\x00\x00"
 upgrade $ID map-upgrades/map1.mo ""
 ingress $ID upgradeNodes "DIDL\x00\x00"
 ingress $ID go "DIDL\x00\x00"
-
diff --git a/test/run-drun/max-stack-variant.mo b/test/run-drun/max-stack-variant.mo
index 2b0f8160473..a9e011df8e1 100644
--- a/test/run-drun/max-stack-variant.mo
+++ b/test/run-drun/max-stack-variant.mo
@@ -2,7 +2,7 @@
 import { errorMessage; debugPrint; setCandidLimits} = "mo:⛔";
 
 actor {
-    let expectedMinimumSize = 31_000;
+    let expectedMinimumSize = 29_000;
     setCandidLimits<system>{ numerator = 0;
                              denominator = 1;
                              bias = 1_000_000 };
diff --git a/test/run-drun/migrate-candid-sharing.drun b/test/run-drun/migrate-candid-sharing.drun
new file mode 100644
index 00000000000..3731294c9cb
--- /dev/null
+++ b/test/run-drun/migrate-candid-sharing.drun
@@ -0,0 +1,7 @@
+# CLASSICAL-PERSISTENCE-ONLY
+# DEFAULT-GC-ONLY
+# SKIP ic-ref-run
+install $ID migrate-candid-sharing/old-stabilization.mo ""
+upgrade $ID migrate-candid-sharing/new-stabilization.mo ""
+upgrade $ID migrate-candid-sharing/new-stabilization.mo ""
+upgrade $ID migrate-candid-sharing/old-stabilization.mo ""
diff --git a/test/run-drun/migrate-candid-sharing/new-stabilization.mo b/test/run-drun/migrate-candid-sharing/new-stabilization.mo
new file mode 100644
index 00000000000..47d145d496c
--- /dev/null
+++ b/test/run-drun/migrate-candid-sharing/new-stabilization.mo
@@ -0,0 +1,13 @@
+//MOC-FLAG --enhanced-orthogonal-persistence
+import Prim "mo:prim";
+
+actor {
+   type Data = { field1 : Text; field2 : Nat; var field3: ?Data; };
+
+   stable var sharedObject : Data = { field1 = "Test"; field2 = 12345; var field3 = null };
+   sharedObject.field3 := ?sharedObject;
+
+   stable var array : [var Data] = Prim.Array_init<Data>(100, sharedObject);
+
+   Prim.debugPrint("INITIALIZED: " # debug_show (array.size()));
+};
diff --git a/test/run-drun/migrate-candid-sharing/old-stabilization.mo b/test/run-drun/migrate-candid-sharing/old-stabilization.mo
new file mode 100644
index 00000000000..07aecef0f65
--- /dev/null
+++ b/test/run-drun/migrate-candid-sharing/old-stabilization.mo
@@ -0,0 +1,13 @@
+// Uses classical persistence, see `migrate-candid-sharing.drun`.
+import Prim "mo:prim";
+
+actor {
+   type Data = { field1 : Text; field2 : Nat; var field3: ?Data; };
+
+   stable var sharedObject : Data = { field1 = "Test"; field2 = 12345; var field3 = null };
+   sharedObject.field3 := ?sharedObject;
+
+   stable var array : [var Data] = Prim.Array_init<Data>(100, sharedObject);
+
+   Prim.debugPrint("INITIALIZED: " # debug_show (array.size()));
+};
diff --git a/test/run-drun/migrate-stabilization.drun b/test/run-drun/migrate-stabilization.drun
index 884157d7a91..4a7365e2121 100644
--- a/test/run-drun/migrate-stabilization.drun
+++ b/test/run-drun/migrate-stabilization.drun
@@ -1,8 +1,10 @@
+# CLASSICAL-PERSISTENCE-ONLY
+# DEFAULT-GC-ONLY
 # SKIP ic-ref-run
-install $ID migrate-stabilization/old-stabilization.wasm ""
+install $ID migrate-stabilization/old-stabilization.mo ""
 ingress $ID populate "DIDL\x00\x00"
 ingress $ID print "DIDL\x00\x00"
-upgrade $ID migrate-stabilization/old-stabilization.wasm ""
+upgrade $ID migrate-stabilization/old-stabilization.mo ""
 ingress $ID populate "DIDL\x00\x00"
 ingress $ID print "DIDL\x00\x00"
 upgrade $ID migrate-stabilization/new-stabilization.mo ""
@@ -11,4 +13,4 @@ ingress $ID print "DIDL\x00\x00"
 upgrade $ID migrate-stabilization/new-stabilization.mo ""
 ingress $ID populate "DIDL\x00\x00"
 ingress $ID print "DIDL\x00\x00"
-upgrade $ID migrate-stabilization/old-stabilization.wasm ""
+upgrade $ID migrate-stabilization/old-stabilization.mo ""
diff --git a/test/run-drun/migrate-stabilization/new-stabilization.mo b/test/run-drun/migrate-stabilization/new-stabilization.mo
index c941993cb8f..5291a3c08ed 100644
--- a/test/run-drun/migrate-stabilization/new-stabilization.mo
+++ b/test/run-drun/migrate-stabilization/new-stabilization.mo
@@ -1,3 +1,4 @@
+//MOC-FLAG --enhanced-orthogonal-persistence
 import Prim "mo:prim";
 
 actor {
diff --git a/test/run-drun/migrate-stabilization/old-stabilization-source.txt b/test/run-drun/migrate-stabilization/old-stabilization-source.txt
deleted file mode 100644
index 1f243b469a0..00000000000
--- a/test/run-drun/migrate-stabilization/old-stabilization-source.txt
+++ /dev/null
@@ -1 +0,0 @@
-old-destabilization.wasm is compiled from `new-destabilzation.mo` with old `moc` compiler using `--sanity-checks`.
diff --git a/test/run-drun/migrate-stabilization/old-stabilization.mo b/test/run-drun/migrate-stabilization/old-stabilization.mo
new file mode 100644
index 00000000000..7ac4752eec2
--- /dev/null
+++ b/test/run-drun/migrate-stabilization/old-stabilization.mo
@@ -0,0 +1,51 @@
+// Uses classical persistence, see `migrate-stabilization.drun`.
+import Prim "mo:prim";
+
+actor {
+   type Node<K, V> = ?{ key : K; value : V; var next : Node<K, V> };
+   type List<K, V> = {
+      var first : Node<K, V>;
+      var last : Node<K, V>;
+   };
+   stable let list : List<Nat, Text> = {
+      var first = null;
+      var last = null;
+   };
+   stable var counter = 0;
+
+   Prim.debugPrint("INITIALIZED: " # debug_show(counter));
+
+   func insert<K, V>(list : List<K, V>, key : K, value : V) {
+      let node : Node<K, V> = ?{ key; value; var next = null };
+      switch (list.last) {
+         case null {
+            list.first := node;
+         };
+         case (?previous) {
+            previous.next := node;
+         };
+      };
+      list.last := node;
+   };
+
+   public func populate() : async () {
+      let limit = counter + 10;
+      while (counter < limit) {
+         insert(list, counter, debug_show (counter));
+         counter += 1;
+      };
+   };
+
+   public func print() : async () {
+      var current = list.first;
+      loop {
+         switch current {
+            case null return;
+            case (?node) {
+               Prim.debugPrint(debug_show (node.key) # " " # node.value);
+               current := node.next;
+            };
+         };
+      };
+   };
+};
diff --git a/test/run-drun/migrate-stabilization/old-stabilization.wasm b/test/run-drun/migrate-stabilization/old-stabilization.wasm
deleted file mode 100644
index 4ae5850831a4da754aeb86bb515104dfe363a393..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 599897
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

diff --git a/test/run-drun/migration-paths.drun b/test/run-drun/migration-paths.drun
new file mode 100644
index 00000000000..026f98ab1cd
--- /dev/null
+++ b/test/run-drun/migration-paths.drun
@@ -0,0 +1,26 @@
+# CLASSICAL-PERSISTENCE-ONLY
+# DEFAULT-GC-ONLY
+# SKIP ic-ref-run
+
+# Start with classical persistence
+install $ID migration-paths/old-installer.mo ""
+ingress $ID install "DIDL\x00\x00"
+ingress $ID upgrade "DIDL\x00\x00"
+ingress $ID upgrade_replace_main_memory "DIDL\x00\x00"
+# This fails:
+ingress $ID upgrade_keep_main_memory "DIDL\x00\x00"
+
+# Now, upgrade to enhanced orthogonal persistence
+upgrade $ID migration-paths/new-installer.mo ""
+# Try wrong upgrade option: RTS detects and handles this.
+ingress $ID upgrade_keep_main_memory "DIDL\x00\x00"
+# Initiate graph copy
+ingress $ID initiate_graph_copy "DIDL\x00\x00"
+# Discard EOP main memory, but retain state of graph copy
+ingress $ID upgrade_replace_main_memory "DIDL\x00\x00"
+# Initiate graph copy
+ingress $ID initiate_graph_copy "DIDL\x00\x00"
+ingress $ID upgrade_keep_main_memory "DIDL\x00\x00"
+
+# Try to downgrade. This will fail:
+upgrade $ID migration-paths/old-installer.mo ""
diff --git a/test/run-drun/migration-paths/new-installer.mo b/test/run-drun/migration-paths/new-installer.mo
new file mode 100644
index 00000000000..de73aae5e23
--- /dev/null
+++ b/test/run-drun/migration-paths/new-installer.mo
@@ -0,0 +1,57 @@
+//MOC-FLAG --enhanced-orthogonal-persistence
+import Prim "mo:⛔";
+import TestCanister "test_canister";
+
+actor {
+    stable var testCanister : ?TestCanister.TestCanister = null;
+
+    public func upgrade() : async () {
+        switch testCanister {
+            case null Prim.trap("null canister");
+            case (?canister) {
+                ignore await (system TestCanister.TestCanister)(#upgrade canister)();
+                Prim.debugPrint("Upgraded (default)");
+            };
+        };
+    };
+
+    public func upgrade_keep_main_memory() : async () {
+        switch testCanister {
+            case null Prim.trap("null canister");
+            case (?canister) {
+                ignore await (system TestCanister.TestCanister)(#upgrade_with_persistence { wasm_memory_persistence = #Keep; canister })();
+                Prim.debugPrint("Upgraded (keep main memory)");
+            };
+        };
+    };
+
+    public func upgrade_replace_main_memory() : async () {
+        switch testCanister {
+            case null Prim.trap("null canister");
+            case (?canister) {
+                ignore await (system TestCanister.TestCanister)(#upgrade_with_persistence { wasm_memory_persistence = #Replace; canister })();
+                Prim.debugPrint("Upgraded (replace main memory)");
+            };
+        };
+    };
+
+    type GraphCopy = actor {
+        __motoko_stabilize_before_upgrade : () -> async ();
+    };
+
+    func getGraphCopy(a : actor {}) : GraphCopy {
+        let graphCopy = actor (debug_show (Prim.principalOfActor(a))) : GraphCopy;
+        graphCopy;
+    };
+
+    public func initiate_graph_copy() : async () {
+        switch testCanister {
+            case null Prim.trap("null canister");
+            case (?canister) {
+                let graphCopy = getGraphCopy(canister);
+                await graphCopy.__motoko_stabilize_before_upgrade();
+                Prim.debugPrint("Graph copy");
+            };
+        };
+    };
+};
diff --git a/test/run-drun/migration-paths/old-installer.mo b/test/run-drun/migration-paths/old-installer.mo
new file mode 100644
index 00000000000..461e2f459e7
--- /dev/null
+++ b/test/run-drun/migration-paths/old-installer.mo
@@ -0,0 +1,49 @@
+// Uses classical persistence, see `migrations-path.drun`.
+import Prim "mo:⛔";
+import Cycles = "../cycles/cycles";
+import TestCanister "test_canister";
+
+actor installer {
+    stable var testCanister: ?TestCanister.TestCanister = null;
+
+    public func install() : async () {
+        if (Cycles.balance() == 0) {
+            await Cycles.provisional_top_up_actor(installer, 100_000_000_000_000);
+        };
+
+        Cycles.add<system>(2_000_000_000_000);
+        testCanister := ?(await TestCanister.TestCanister());
+
+        Prim.debugPrint("Installed");
+    };
+
+    public func upgrade() : async () {
+         switch testCanister {
+            case null Prim.trap("null canister");
+            case (?canister) {
+                ignore await (system TestCanister.TestCanister)(#upgrade canister)();
+                Prim.debugPrint("Upgraded (default)");
+            }
+         }
+    };
+
+    public func upgrade_keep_main_memory() : async () {
+         switch testCanister {
+            case null Prim.trap("null canister");
+            case (?canister) {
+                ignore await (system TestCanister.TestCanister)(#upgrade_with_persistence { wasm_memory_persistence =  #Keep; canister })();
+                Prim.debugPrint("Upgraded (keep main memory)");
+            }
+         }
+    };
+
+    public func upgrade_replace_main_memory() : async () {
+         switch testCanister {
+            case null Prim.trap("null canister");
+            case (?canister) {
+                ignore await (system TestCanister.TestCanister)(#upgrade_with_persistence { wasm_memory_persistence = #Replace; canister })();
+                Prim.debugPrint("Upgraded (replace main memory)");
+            }
+         }
+    };
+};
diff --git a/test/run-drun/migration-paths/test_canister.mo b/test/run-drun/migration-paths/test_canister.mo
new file mode 100644
index 00000000000..25f99873d8d
--- /dev/null
+++ b/test/run-drun/migration-paths/test_canister.mo
@@ -0,0 +1,18 @@
+import Prim "mo:prim";
+
+actor class TestCanister() {
+   let length = 8 * 1024 * 1024;
+   func initialize() : [var Nat] {
+      let array = Prim.Array_init<Nat>(length, 0xfff_ffff);
+      Prim.debugPrint("array initialized");
+      array;
+   };
+
+   stable var array = initialize();
+
+   stable var version = 0;
+   version += 1;
+
+   assert (array.size() == length);
+   Prim.debugPrint("version: " # debug_show (version));
+};
diff --git a/test/run-drun/more-function-stabilization.drun b/test/run-drun/more-function-stabilization.drun
new file mode 100644
index 00000000000..77489af1e0a
--- /dev/null
+++ b/test/run-drun/more-function-stabilization.drun
@@ -0,0 +1,8 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+install $ID more-function-stabilization/version0.mo ""
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x01\x7d\x0F"
+upgrade $ID more-function-stabilization/version0.mo ""
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x01\x7d\x0F"
+upgrade $ID more-function-stabilization/version1.mo ""
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x01\x7d\x0F"
+upgrade $ID more-function-stabilization/version2.mo ""
diff --git a/test/run-drun/more-function-stabilization/version0.mo b/test/run-drun/more-function-stabilization/version0.mo
new file mode 100644
index 00000000000..3111aae3f70
--- /dev/null
+++ b/test/run-drun/more-function-stabilization/version0.mo
@@ -0,0 +1,4 @@
+actor {
+   public shared query func test(x: ?Nat) : async () { loop {} };
+   stable let shared_function = test;
+};
diff --git a/test/run-drun/more-function-stabilization/version1.mo b/test/run-drun/more-function-stabilization/version1.mo
new file mode 100644
index 00000000000..49cef225a0e
--- /dev/null
+++ b/test/run-drun/more-function-stabilization/version1.mo
@@ -0,0 +1,4 @@
+actor {
+   public shared query func test() : async () { loop {} };
+   stable let shared_function = test;
+};
diff --git a/test/run-drun/more-function-stabilization/version2.mo b/test/run-drun/more-function-stabilization/version2.mo
new file mode 100644
index 00000000000..bc44cee409d
--- /dev/null
+++ b/test/run-drun/more-function-stabilization/version2.mo
@@ -0,0 +1,4 @@
+actor {
+   public shared query func test(x: ?Nat) : async ?Int { loop {} };
+   stable let shared_function = test;
+};
diff --git a/test/run-drun/more-function-upgrades.drun b/test/run-drun/more-function-upgrades.drun
index 4e4e1c30411..8015bf728f7 100644
--- a/test/run-drun/more-function-upgrades.drun
+++ b/test/run-drun/more-function-upgrades.drun
@@ -1,3 +1,4 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
 install $ID more-function-upgrades/version0.mo ""
 upgrade $ID more-function-upgrades/version0.mo ""
 upgrade $ID more-function-upgrades/version1.mo ""
diff --git a/test/run-drun/non-incremental-stabilization.mo b/test/run-drun/non-incremental-stabilization.mo
new file mode 100644
index 00000000000..89f2189f707
--- /dev/null
+++ b/test/run-drun/non-incremental-stabilization.mo
@@ -0,0 +1,39 @@
+//ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+import Prim "mo:prim";
+
+actor {
+    stable var stableNat = 12345678901234567890123456789012345678901234567890123456789012345678901234567890;
+    stable var stableInt = -2345678901234567890123456789012345678901234567890123456789012345678901234567890;
+    stable var stableText = "Motoko graph-copy-based upgrade test";
+    
+    public func print() : async () {
+        Prim.debugPrint(debug_show (stableNat));
+        Prim.debugPrint(debug_show (stableInt));
+        Prim.debugPrint(debug_show (stableText));
+    };
+
+    system func preupgrade() {
+        Prim.debugPrint("PRE-UPGRADE HOOK!");
+    };
+
+    system func postupgrade() {
+        Prim.debugPrint("POST-UPGRADE HOOK!");
+    };
+};
+
+// Testing different invalid and correct combinations of explicit (de)stabilization calls
+
+//CALL ingress print "DIDL\x00\x00"
+//CALL ingress __motoko_destabilize_after_upgrade "DIDL\x00\x00"
+//CALL upgrade ""
+//CALL ingress __motoko_destabilize_after_upgrade "DIDL\x00\x00"
+//CALL ingress print "DIDL\x00\x00"
+//CALL ingress __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+//CALL ingress __motoko_destabilize_after_upgrade "DIDL\x00\x00"
+//CALL ingress print "DIDL\x00\x00"
+//CALL upgrade ""
+//CALL ingress print "DIDL\x00\x00"
+
+//SKIP run
+//SKIP run-ir
+//SKIP run-low
diff --git a/test/run-drun/ok/actor-arg.drun.ok b/test/run-drun/ok/actor-arg.drun.ok
index 8ecc4b9a562..2bc6bd6a9ab 100644
--- a/test/run-drun/ok/actor-arg.drun.ok
+++ b/test/run-drun/ok/actor-arg.drun.ok
@@ -1,4 +1,5 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: missing magic bytes
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: missing magic bytes.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/actor-class-mgmt-enhanced.drun-run.ok b/test/run-drun/ok/actor-class-mgmt-enhanced.drun-run.ok
new file mode 100644
index 00000000000..794156f8f4a
--- /dev/null
+++ b/test/run-drun/ok/actor-class-mgmt-enhanced.drun-run.ok
@@ -0,0 +1,4 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {controllers = [rwlgt-iiaaa-aaaaa-aaaaa-cai]; recent_changes = [{canister_version = 8; details = #code_deployment({mode = #upgrade}); origin = #from_canister({canister_id = rwlgt-iiaaa-aaaaa-aaaaa-cai; canister_version = ?27})}, {canister_version = 13; details = #code_deployment({mode = #upgrade}); origin = #from_canister({canister_id = rwlgt-iiaaa-aaaaa-aaaaa-cai; canister_version = ?32})}, {canister_version = 15; details = #code_deployment({mode = #reinstall}); origin = #from_canister({canister_id = rwlgt-iiaaa-aaaaa-aaaaa-cai; canister_version = ?36})}, {canister_version = 17; details = #code_deployment({mode = #upgrade}); origin = #from_canister({canister_id = rwlgt-iiaaa-aaaaa-aaaaa-cai; canister_version = ?40})}]; total_num_changes = 7}
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/actor-class-mgmt.drun-run.ok b/test/run-drun/ok/actor-class-mgmt.drun-run.ok
index bddc341e0a0..ff06ef84fef 100644
--- a/test/run-drun/ok/actor-class-mgmt.drun-run.ok
+++ b/test/run-drun/ok/actor-class-mgmt.drun-run.ok
@@ -1,4 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {controllers = [rwlgt-iiaaa-aaaaa-aaaaa-cai]; recent_changes = [{canister_version = 3; details = #code_deployment({mode = #upgrade}); origin = #from_canister({canister_id = rwlgt-iiaaa-aaaaa-aaaaa-cai; canister_version = ?22})}, {canister_version = 5; details = #code_deployment({mode = #upgrade}); origin = #from_canister({canister_id = rwlgt-iiaaa-aaaaa-aaaaa-cai; canister_version = ?26})}, {canister_version = 7; details = #code_deployment({mode = #reinstall}); origin = #from_canister({canister_id = rwlgt-iiaaa-aaaaa-aaaaa-cai; canister_version = ?30})}, {canister_version = 9; details = #code_deployment({mode = #upgrade}); origin = #from_canister({canister_id = rwlgt-iiaaa-aaaaa-aaaaa-cai; canister_version = ?34})}]; total_num_changes = 6}
+debug.print: {controllers = [rwlgt-iiaaa-aaaaa-aaaaa-cai]; recent_changes = [{canister_version = 0; details = #creation({controllers = [rwlgt-iiaaa-aaaaa-aaaaa-cai]}); origin = #from_canister({canister_id = rwlgt-iiaaa-aaaaa-aaaaa-cai; canister_version = null})}, {canister_version = 1; details = #code_deployment({mode = #install}); origin = #from_canister({canister_id = rwlgt-iiaaa-aaaaa-aaaaa-cai; canister_version = ?18})}, {canister_version = 3; details = #code_deployment({mode = #upgrade}); origin = #from_canister({canister_id = rwlgt-iiaaa-aaaaa-aaaaa-cai; canister_version = ?22})}, {canister_version = 5; details = #code_deployment({mode = #reinstall}); origin = #from_canister({canister_id = rwlgt-iiaaa-aaaaa-aaaaa-cai; canister_version = ?26})}]; total_num_changes = 4}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/actor-reference-bad.drun-run.ok b/test/run-drun/ok/actor-reference-bad.drun-run.ok
index f08ed5ad9b6..c79f5ed4741 100644
--- a/test/run-drun/ok/actor-reference-bad.drun-run.ok
+++ b/test/run-drun/ok/actor-reference-bad.drun-run.ok
@@ -2,13 +2,18 @@ ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a000000000000000001
 ingress Completed: Reply: 0x4449444c0000
 debug.print: "bfozs-kwa73-7nadi":
 debug.print: "":
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: blob_of_principal: principal too short
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: blob_of_principal: principal too short.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: "BFOZS-KWA73-7NADI":
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: blob_of_principal: invalid principal
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: blob_of_principal: invalid principal.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: "bfozskwa737nadi":
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: blob_of_principal: invalid principal
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: blob_of_principal: invalid principal.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: "vpgq":
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: blob_of_principal: principal too short
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: blob_of_principal: principal too short.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: "5h74t-uga73-7nadi":
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: blob_of_principal: invalid principal
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: blob_of_principal: invalid principal.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/any-stabilization.drun.ok b/test/run-drun/ok/any-stabilization.drun.ok
new file mode 100644
index 00000000000..0cbc240bd2c
--- /dev/null
+++ b/test/run-drun/ok/any-stabilization.drun.ok
@@ -0,0 +1,11 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/any-upgrades.drun.ok b/test/run-drun/ok/any-upgrades.drun.ok
index 74612ec48fa..345ab75ad08 100644
--- a/test/run-drun/ok/any-upgrades.drun.ok
+++ b/test/run-drun/ok/any-upgrades.drun.ok
@@ -3,4 +3,5 @@ ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/array-out-of-bounds.drun-run.ok b/test/run-drun/ok/array-out-of-bounds.drun-run.ok
index 816618bf79c..5b9360e8005 100644
--- a/test/run-drun/ok/array-out-of-bounds.drun-run.ok
+++ b/test/run-drun/ok/array-out-of-bounds.drun-run.ok
@@ -1,4 +1,6 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: Array index out of bounds
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: Array index out of bounds
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: Array index out of bounds.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: Array index out of bounds.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/array-stabilization.drun.ok b/test/run-drun/ok/array-stabilization.drun.ok
new file mode 100644
index 00000000000..222390f1a45
--- /dev/null
+++ b/test/run-drun/ok/array-stabilization.drun.ok
@@ -0,0 +1,52 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+debug.print: [var 1.000000, 2.000000, 3.000000, 4.000000]
+debug.print: [[1, 2, 3], [4, 5, 6]]
+debug.print: ?[null, ?[], ?[?[null, null], null]]
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: [var 1.000000, 2.000000, 3.000000, 4.000000]
+debug.print: [[1, 2, 3], [4, 5, 6]]
+debug.print: ?[null, ?[], ?[?[null, null], null]]
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: [var 1.000000, 2.000000, 3.000000, 4.000000]
+debug.print: [[1, 2, 3], [4, 5, 6]]
+debug.print: ?[null, ?[], ?[?[null, null], null]]
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: [var 1.000000, 2.000000, 3.000000, 4.000000]
+debug.print: [[1, 2, 3], [4, 5, 6]]
+debug.print: ?[null, ?[], ?[?[null, null], null]]
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: [var 1.000000, 2.000000, 3.000000, 4.000000]
+debug.print: ?[null, ?[], ?[?[null, null], null]]
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: [var 1.000000, 2.000000, 3.000000, 4.000000]
+debug.print: ?[null, ?[], ?[?[null, null], null]]
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: [var 1.000000, 2.000000, 3.000000, 4.000000]
+debug.print: [[1, 2, 3], [4, 5, 6]]
+debug.print: ?[null, ?[], ?[?[null, null], null]]
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: [var 1.000000, 2.000000, 3.000000, 4.000000]
+debug.print: [[1, 2, 3], [4, 5, 6]]
+debug.print: ?[null, ?[], ?[?[null, null], null]]
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/array-upgrades.drun.ok b/test/run-drun/ok/array-upgrades.drun.ok
index 05e09719101..b190539f514 100644
--- a/test/run-drun/ok/array-upgrades.drun.ok
+++ b/test/run-drun/ok/array-upgrades.drun.ok
@@ -19,8 +19,10 @@ debug.print: [var 1.000000, 2.000000, 3.000000, 4.000000]
 debug.print: [[1, 2, 3], [4, 5, 6]]
 debug.print: ?[null, ?[], ?[?[null, null], null]]
 ingress Completed: Reply: 0x4449444c0000
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 ingress Completed: Reply: 0x4449444c0000
 debug.print: [var 1.000000, 2.000000, 3.000000, 4.000000]
 debug.print: ?[null, ?[], ?[?[null, null], null]]
diff --git a/test/run-drun/ok/assert.drun-run.ok b/test/run-drun/ok/assert.drun-run.ok
index 2cdc44a51bd..8d426cd2f92 100644
--- a/test/run-drun/ok/assert.drun-run.ok
+++ b/test/run-drun/ok/assert.drun-run.ok
@@ -1,3 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: assertion failed at Lib.mo:3.27-5.4
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: assertion failed at Lib.mo:3.27-5.4.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/basic-cycles.drun-run.ok b/test/run-drun/ok/basic-cycles.drun-run.ok
index 113bff7f0bb..26919df4a8e 100644
--- a/test/run-drun/ok/basic-cycles.drun-run.ok
+++ b/test/run-drun/ok/basic-cycles.drun-run.ok
@@ -1,9 +1,12 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: cannot add more than 2^128 cycles
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: cannot add more than 2^128 cycles.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: ok
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: cannot add more than 2^128 cycles
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: cycles out of bounds
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: cannot add more than 2^128 cycles.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: cycles out of bounds.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {balance = 100_000_000_000_000}
 debug.print: {topped_up_balance = 100_000_000_000_000}
 debug.print: {added = 0}
diff --git a/test/run-drun/ok/blob-array-mismatch.drun.ok b/test/run-drun/ok/blob-array-mismatch.drun.ok
index f5f49f31f1f..171e156ee98 100644
--- a/test/run-drun/ok/blob-array-mismatch.drun.ok
+++ b/test/run-drun/ok/blob-array-mismatch.drun.ok
@@ -1,7 +1,9 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/blob-stabilization.drun-run.ok b/test/run-drun/ok/blob-stabilization.drun-run.ok
new file mode 100644
index 00000000000..9eece096afc
--- /dev/null
+++ b/test/run-drun/ok/blob-stabilization.drun-run.ok
@@ -0,0 +1,6 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/blob-stabilization.tc.ok b/test/run-drun/ok/blob-stabilization.tc.ok
new file mode 100644
index 00000000000..46bad68cc47
--- /dev/null
+++ b/test/run-drun/ok/blob-stabilization.tc.ok
@@ -0,0 +1,2 @@
+blob-stabilization.mo:7.12-7.33: warning [M0199], this code is (or uses) the deprecated library `ExperimentalStableMemory`.
+Please use the `Region` library instead: https://internetcomputer.org/docs/current/motoko/main/stable-memory/stable-regions/#the-region-library or compile with flag `--experimental-stable-memory 1` to suppress this message.
diff --git a/test/run-drun/ok/blob-upgrade.drun-run.ok b/test/run-drun/ok/blob-upgrade.drun-run.ok
new file mode 100644
index 00000000000..a36906b5b9e
--- /dev/null
+++ b/test/run-drun/ok/blob-upgrade.drun-run.ok
@@ -0,0 +1,5 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/blob-upgrade.tc.ok b/test/run-drun/ok/blob-upgrade.tc.ok
new file mode 100644
index 00000000000..8569349f63e
--- /dev/null
+++ b/test/run-drun/ok/blob-upgrade.tc.ok
@@ -0,0 +1,2 @@
+blob-upgrade.mo:6.12-6.33: warning [M0199], this code is (or uses) the deprecated library `ExperimentalStableMemory`.
+Please use the `Region` library instead: https://internetcomputer.org/docs/current/motoko/main/stable-memory/stable-regions/#the-region-library or compile with flag `--experimental-stable-memory 1` to suppress this message.
diff --git a/test/run-drun/ok/call-async-method.drun-run.ok b/test/run-drun/ok/call-async-method.drun-run.ok
index 701434a8d92..a25b6a42feb 100644
--- a/test/run-drun/ok/call-async-method.drun-run.ok
+++ b/test/run-drun/ok/call-async-method.drun-run.ok
@@ -1,3 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: not a self-call
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: not a self-call.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/call-raw-candid.drun-run.ok b/test/run-drun/ok/call-raw-candid.drun-run.ok
index f01abb9e600..cebd7fe8635 100644
--- a/test/run-drun/ok/call-raw-candid.drun-run.ok
+++ b/test/run-drun/ok/call-raw-candid.drun-run.ok
@@ -4,7 +4,9 @@ debug.print: unit!
 debug.print: ("int", +1)
 debug.print: ("text", "hello")
 debug.print: ("text", (1, true, 'a'))
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: unexpected IDL type when parsing Nat
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: ohoh
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: unexpected IDL type when parsing Nat.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: ohoh.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: supercalifragilisticexpialidocious
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/call-raw.drun-run.ok b/test/run-drun/ok/call-raw.drun-run.ok
index 13c391738f9..94f1004cf6b 100644
--- a/test/run-drun/ok/call-raw.drun-run.ok
+++ b/test/run-drun/ok/call-raw.drun-run.ok
@@ -9,6 +9,7 @@ debug.print: ("int", +1)
 debug.print: ("int", +2)
 debug.print: ("text", "hello")
 debug.print: ("text", (1, true, 'a'))
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: ohoh
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: ohoh.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: supercalifragilisticexpialidocious
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/callback-trap-upgrade.drun-run.ok b/test/run-drun/ok/callback-trap-upgrade.drun-run.ok
index 1f69dcb02b3..c1d415ad2d7 100644
--- a/test/run-drun/ok/callback-trap-upgrade.drun-run.ok
+++ b/test/run-drun/ok/callback-trap-upgrade.drun-run.ok
@@ -6,7 +6,8 @@ ingress Completed: Reply: 0x4449444c0000
 debug.print: In go(), outstanding callbacks: 0
 debug.print: In ping(), outstanding callbacks: 1
 debug.print: In go() again, outstanding callbacks: 0
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: assertion failed at callback-trap-upgrade.mo:13.5-13.18
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: assertion failed at callback-trap-upgrade.mo:13.5-13.18.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: In stats(), outstanding callbacks: 0
 ingress Completed: Reply: 0x4449444c0000
 debug.print: init'ed
diff --git a/test/run-drun/ok/class-import.tc.ok b/test/run-drun/ok/class-import.tc.ok
deleted file mode 100644
index 543b6ceb683..00000000000
--- a/test/run-drun/ok/class-import.tc.ok
+++ /dev/null
@@ -1,2 +0,0 @@
-class-import.mo:32.10-32.14: warning [M0194], unused identifier trap (delete or rename to wildcard `_` or `_trap`)
-class-import.mo:41.10-41.14: warning [M0194], unused identifier trap (delete or rename to wildcard `_` or `_trap`)
diff --git a/test/run-drun/ok/destabilization-crash.drun.ok b/test/run-drun/ok/destabilization-crash.drun.ok
new file mode 100644
index 00000000000..ea58742ce4f
--- /dev/null
+++ b/test/run-drun/ok/destabilization-crash.drun.ok
@@ -0,0 +1,13 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+debug.print: preupgrade!
+debug.print: {heap_MB = 64}
+debug.print: {heap_MB = 128}
+debug.print: {heap_MB = 192}
+debug.print: {heap_MB = 256}
+debug.print: {heap_MB = 320}
+debug.print: {heap_MB = 384}
+debug.print: {heap_MB = 448}
+debug.print: postupgrade!
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: assertion failed at destabilization-crash.mo:41.6-41.18.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/divide-by-zero.drun-run.ok b/test/run-drun/ok/divide-by-zero.drun-run.ok
index 12b27047055..161fd48b034 100644
--- a/test/run-drun/ok/divide-by-zero.drun-run.ok
+++ b/test/run-drun/ok/divide-by-zero.drun-run.ok
@@ -1,2 +1,3 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
-ingress Err: IC0502: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped: integer division by 0
+ingress Err: IC0502: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister trapped: integer division by 0.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped
diff --git a/test/run-drun/ok/double-sharing-benchmark.drun-run.ok b/test/run-drun/ok/double-sharing-benchmark.drun-run.ok
new file mode 100644
index 00000000000..0b97c74f0b1
--- /dev/null
+++ b/test/run-drun/ok/double-sharing-benchmark.drun-run.ok
@@ -0,0 +1,6 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Upgraded!
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/empty-actor.drun-run.ok b/test/run-drun/ok/empty-actor-classical.drun-run.ok
similarity index 100%
rename from test/run-drun/ok/empty-actor.drun-run.ok
rename to test/run-drun/ok/empty-actor-classical.drun-run.ok
diff --git a/test/run-drun/ok/empty-actor-enhanced.drun-run.ok b/test/run-drun/ok/empty-actor-enhanced.drun-run.ok
new file mode 100644
index 00000000000..a6f776f43c6
--- /dev/null
+++ b/test/run-drun/ok/empty-actor-enhanced.drun-run.ok
@@ -0,0 +1,2 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/error-codes.drun-run.ok b/test/run-drun/ok/error-codes.drun-run.ok
index fb116c037b8..ec52f8f344a 100644
--- a/test/run-drun/ok/error-codes.drun-run.ok
+++ b/test/run-drun/ok/error-codes.drun-run.ok
@@ -1,5 +1,6 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
 debug.print: canister_reject:ball
-debug.print: canister_error:IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: assertion failed at error-codes.mo:10.33-10.50
+debug.print: canister_error:IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: assertion failed at error-codes.mo:10.33-10.50.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/explicit-trap.drun-run.ok b/test/run-drun/ok/explicit-trap.drun-run.ok
index 587ab4d85f6..822bcbea212 100644
--- a/test/run-drun/ok/explicit-trap.drun-run.ok
+++ b/test/run-drun/ok/explicit-trap.drun-run.ok
@@ -1,3 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: This is an explicit trap
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: This is an explicit trap.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/function-stabilization.drun.ok b/test/run-drun/ok/function-stabilization.drun.ok
new file mode 100644
index 00000000000..821b4dd65a9
--- /dev/null
+++ b/test/run-drun/ok/function-stabilization.drun.ok
@@ -0,0 +1,19 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/function-upgrades.drun.ok b/test/run-drun/ok/function-upgrades.drun.ok
index 60b4b27b770..b6f010cec85 100644
--- a/test/run-drun/ok/function-upgrades.drun.ok
+++ b/test/run-drun/ok/function-upgrades.drun.ok
@@ -3,7 +3,10 @@ ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/gc-trigger-acl.drun-run.ok b/test/run-drun/ok/gc-trigger-acl.drun-run.ok
index 52609530b06..c9b6f351cfc 100644
--- a/test/run-drun/ok/gc-trigger-acl.drun-run.ok
+++ b/test/run-drun/ok/gc-trigger-acl.drun-run.ok
@@ -2,5 +2,6 @@ ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a000000000000000001
 ingress Completed: Reply: 0x4449444c0000
 debug.print: Self.gc_trigger()
 debug.print: controlee.gc_trigger()
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: not a self-call or call from controller
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: not a self-call or call from controller.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/hashBlob.drun-run.ok b/test/run-drun/ok/hashBlob.drun-run.ok
new file mode 100644
index 00000000000..a0e0ba258ac
--- /dev/null
+++ b/test/run-drun/ok/hashBlob.drun-run.ok
@@ -0,0 +1,5 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 3_580_832_660
+debug.print: 3_580_832_661
+ingress Completed: Reply: 0x4449444c000179942b6fd5
diff --git a/test/run-drun/ok/hashBlob.run-ir.ok b/test/run-drun/ok/hashBlob.run-ir.ok
new file mode 100644
index 00000000000..9a4a410d26e
--- /dev/null
+++ b/test/run-drun/ok/hashBlob.run-ir.ok
@@ -0,0 +1,2 @@
+3_015_377_762
+3_015_377_763
diff --git a/test/run-drun/ok/hashBlob.run-low.ok b/test/run-drun/ok/hashBlob.run-low.ok
new file mode 100644
index 00000000000..9a4a410d26e
--- /dev/null
+++ b/test/run-drun/ok/hashBlob.run-low.ok
@@ -0,0 +1,2 @@
+3_015_377_762
+3_015_377_763
diff --git a/test/run-drun/ok/hashBlob.run.ok b/test/run-drun/ok/hashBlob.run.ok
new file mode 100644
index 00000000000..9a4a410d26e
--- /dev/null
+++ b/test/run-drun/ok/hashBlob.run.ok
@@ -0,0 +1,2 @@
+3_015_377_762
+3_015_377_763
diff --git a/test/run-drun/ok/idl-any-stable.drun-run.ok b/test/run-drun/ok/idl-any-stable.drun-run.ok
index 5b97455c400..711e36d55bf 100644
--- a/test/run-drun/ok/idl-any-stable.drun-run.ok
+++ b/test/run-drun/ok/idl-any-stable.drun-run.ok
@@ -1,3 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: illegal type table
+Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: illegal type table.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/idl-bad.drun-run.ok b/test/run-drun/ok/idl-bad.drun-run.ok
index f00ef5f4d99..46940dc2aae 100644
--- a/test/run-drun/ok/idl-bad.drun-run.ok
+++ b/test/run-drun/ok/idl-bad.drun-run.ok
@@ -1,3 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: missing magic bytes
+Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: missing magic bytes.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/idl-bool.drun-run.ok b/test/run-drun/ok/idl-bool.drun-run.ok
index 51793f447eb..ad760913944 100644
--- a/test/run-drun/ok/idl-bool.drun-run.ok
+++ b/test/run-drun/ok/idl-bool.drun-run.ok
@@ -2,4 +2,5 @@ ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a000000000000000001
 ingress Completed: Reply: 0x4449444c0000
 Ok: Reply: 0x4449444c00017e01
 Ok: Reply: 0x4449444c00017e00
-Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: byte tag not 0 or 1
+Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: byte tag not 0 or 1.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/idl-candid-config.drun-run.ok b/test/run-drun/ok/idl-candid-config.drun-run.ok
index 748fc2deaad..d0243b82771 100644
--- a/test/run-drun/ok/idl-candid-config.drun-run.ok
+++ b/test/run-drun/ok/idl-candid-config.drun-run.ok
@@ -1,2 +1,3 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: Candid limit denominator cannot be zero
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: Candid limit denominator cannot be zero.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/idl-large-principal.drun-run.ok b/test/run-drun/ok/idl-large-principal.drun-run.ok
index 6bb159959f3..60430f3be92 100644
--- a/test/run-drun/ok/idl-large-principal.drun-run.ok
+++ b/test/run-drun/ok/idl-large-principal.drun-run.ok
@@ -1,8 +1,11 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
 Ok: Reply: 0x4449444c0000
-Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: principal too long
+Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: principal too long.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 Ok: Reply: 0x4449444c0000
-Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: principal too long
+Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: principal too long.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 Ok: Reply: 0x4449444c0000
-Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: principal too long
+Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: principal too long.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/idl-nary.drun-run.ok b/test/run-drun/ok/idl-nary.drun-run.ok
index 302f030d3f9..4218d474335 100644
--- a/test/run-drun/ok/idl-nary.drun-run.ok
+++ b/test/run-drun/ok/idl-nary.drun-run.ok
@@ -8,6 +8,8 @@ Ok: Reply: 0x4449444c016c0400710171027103710100034f6e650354776f05546872656504466
 Ok: Reply: 0x4449444c016c0400710171027103710100034f6e650354776f05546872656504466f7572
 Ok: Reply: 0x4449444c016c0400710171027103710100034f6e650354776f05546872656504466f7572
 Ok: Reply: 0x4449444c016c0400710171027103710100034f6e650354776f05546872656504466f7572
-Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: too few arguments ttt
-Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: left-over bytes ttt
+Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: too few arguments ttt.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: left-over bytes ttt.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 Ok: Reply: 0x4449444c000471717171034f6e650354776f05546872656504466f7572
diff --git a/test/run-drun/ok/idl-record.drun-run.ok b/test/run-drun/ok/idl-record.drun-run.ok
index f5c618e1f21..3da3c149be1 100644
--- a/test/run-drun/ok/idl-record.drun-run.ok
+++ b/test/run-drun/ok/idl-record.drun-run.ok
@@ -8,4 +8,5 @@ debug.print: ok: +25
 Ok: Reply: 0x4449444c0000
 debug.print: ok:  Hey! +25
 Ok: Reply: 0x4449444c00017719
-Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: did not find field extra in record
+Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: did not find field extra in record.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/idl-spacebomb.drun-run.ok b/test/run-drun/ok/idl-spacebomb.drun-run.ok
index ba492848d38..c7ab165837e 100644
--- a/test/run-drun/ok/idl-spacebomb.drun-run.ok
+++ b/test/run-drun/ok/idl-spacebomb.drun-run.ok
@@ -1,73 +1,108 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
 debug.print: {function = "vec_null_extra_argument"; hex = "4449444C016D7F01008094EBDC03"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {function = "vec_reserved_extra_argument"; hex = "4449444C016D7001008094EBDC03"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {function = "zero_sized_record_extra_argument"; hex = "4449444C046C03007F010102026C0100706C006D0001038094EBDC03"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {function = "vec_vec_null_extra_argument"; hex = "4449444C026D016D7F010005FFFF3FFFFF3FFFFF3FFFFF3FFFFF3F"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {function = "vec_record_emp_extra_argument"; hex = "4449444C026D016C00010080ADE204"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {function = "vec_opt_record_with_2_20_null_extra_argument"; hex = "4449444C176C02017F027F6C02010002006C02000101016C02000201026C02000301036C02000401046C02000501056C02000601066C02000701076C02000801086C02000901096C02000A010A6C02000B010B6C02000C010C6C02000D020D6C02000E010E6C02000F010F6C02001001106C02001101116C02001201126C02001301136E146D150116050101010101"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {function = "vec_null_not_ignored"; hex = "4449444C016D7F01008094EBDC03"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {function = "vec_null_not_ignored"; hex = "4449444C016D7F010080ADE204"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {function = "vec_null_not_ignored"; hex = "4449444C016D7F0100FFFF3F"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {function = "vec_null_not_ignored"; hex = "4449444C016D7F010080BF18"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {function = "vec_reserved_not_ignored"; hex = "4449444C016D7001008094EBDC03"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {function = "vec_reserved_not_ignored"; hex = "4449444C016D70010080ADE204"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {function = "vec_reserved_not_ignored"; hex = "4449444C016D700100FFFF3F"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {function = "vec_reserved_not_ignored"; hex = "4449444C016D70010080BF18"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {function = "zero_sized_record_not_ignored"; hex = "4449444C046C03007F010102026C0100706C006D0001038094EBDC03"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {function = "zero_sized_record_not_ignored"; hex = "4449444C046C03007F010102026C0100706C006D00010380ADE204"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {function = "zero_sized_record_not_ignored"; hex = "4449444C046C03007F010102026C0100706C006D000103FFFF3F"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {function = "zero_sized_record_not_ignored"; hex = "4449444C046C03007F010102026C0100706C006D00010380B518"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {function = "vec_vec_null_not_ignored"; hex = "4449444C026D016D7F010005FFFF3FFFFF3FFFFF3FFFFF3FFFFF3F"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {function = "vec_record_emp_not_ignored"; hex = "4449444C026D016C00010080ADE204"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {function = "vec_null_subtyping"; hex = "4449444C016D7F01008094EBDC03"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {function = "vec_null_subtyping"; hex = "4449444C016D7F010080ADE204"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {function = "vec_null_subtyping"; hex = "4449444C016D7F0100FFFF3F"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {function = "vec_null_subtyping"; hex = "4449444C016D7F010080BF18"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {function = "vec_reserved_subtyping"; hex = "4449444C016D7001008094EBDC03"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {function = "vec_reserved_subtyping"; hex = "4449444C016D70010080ADE204"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {function = "vec_reserved_subtyping"; hex = "4449444C016D700100FFFF3F"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {function = "vec_reserved_subtyping"; hex = "4449444C016D70010080BF18"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {function = "zero_sized_record_subtyping"; hex = "4449444C046C03007F010102026C0100706C006D0001038094EBDC03"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {function = "zero_sized_record_subtyping"; hex = "4449444C046C03007F010102026C0100706C006D00010380ADE204"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {function = "zero_sized_record_subtyping"; hex = "4449444C046C03007F010102026C0100706C006D000103FFFF3F"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {function = "zero_sized_record_subtyping"; hex = "4449444C046C03007F010102026C0100706C006D00010380B518"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {function = "vec_vec_null_subtyping"; hex = "4449444C026D016D7F010005FFFF3FFFFF3FFFFF3FFFFF3FFFFF3F"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {function = "vec_record_emp_subtyping"; hex = "4449444C026D016C00010080ADE204"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {function = "vec_opt_record_with_2_20_null_subtyping"; hex = "4449444C176C02017F027F6C02010002006C02000101016C02000201026C02000301036C02000401046C02000501056C02000601066C02000701076C02000801086C02000901096C02000A010A6C02000B010B6C02000C010C6C02000D020D6C02000E010E6C02000F010F6C02001001106C02001101116C02001201126C02001301136E146D150116050101010101"}
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/idl-sub-rec.drun-run.ok b/test/run-drun/ok/idl-sub-rec.drun-run.ok
index 88b93db6860..99e1c0ce8d0 100644
--- a/test/run-drun/ok/idl-sub-rec.drun-run.ok
+++ b/test/run-drun/ok/idl-sub-rec.drun-run.ok
@@ -10,13 +10,15 @@ debug.print: ok f0
 debug.print: ok_3
 debug.print: ok f0
 debug.print: ok_4
-debug.print: ok 5:IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: incompatible function type
+debug.print: ok 5:IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: incompatible function type.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: ok f1
 debug.print: ok_6
 debug.print: ok f1
 debug.print: ok f1
 debug.print: ok_8
-debug.print: ok_9IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: incompatible function type
+debug.print: ok_9IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: incompatible function type.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: ok f4
 debug.print: ok_10
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/idl-sub-variant.drun-run.ok b/test/run-drun/ok/idl-sub-variant.drun-run.ok
index 0eac0de659e..3a989f62591 100644
--- a/test/run-drun/ok/idl-sub-variant.drun-run.ok
+++ b/test/run-drun/ok/idl-sub-variant.drun-run.ok
@@ -2,5 +2,6 @@ ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a000000000000000001
 ingress Completed: Reply: 0x4449444c0000
 debug.print: pass1
 debug.print: pass1
-debug.print: pass3: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: unexpected variant tag
+debug.print: pass3: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: unexpected variant tag.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/idl-tuple.drun-run.ok b/test/run-drun/ok/idl-tuple.drun-run.ok
index 2ea2f0c2dbc..2d213abf3b7 100644
--- a/test/run-drun/ok/idl-tuple.drun-run.ok
+++ b/test/run-drun/ok/idl-tuple.drun-run.ok
@@ -5,5 +5,6 @@ Ok: Reply: 0x4449444c00037c7c7c050581848c20
 Ok: Reply: 0x4449444c00037c7c7c050581848c20
 Ok: Reply: 0x4449444c00037c7c7c050581848c20
 Ok: Reply: 0x4449444c00037c7c7c050581848c20
-Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: did not find tuple field in record
+Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: did not find tuple field in record.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 Ok: Reply: 0x4449444c00037c7c7c050581848c20
diff --git a/test/run-drun/ok/incremental-actor-class-stabilization.drun-run.ok b/test/run-drun/ok/incremental-actor-class-stabilization.drun-run.ok
new file mode 100644
index 00000000000..12c4878bd73
--- /dev/null
+++ b/test/run-drun/ok/incremental-actor-class-stabilization.drun-run.ok
@@ -0,0 +1,24 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 1_234_567_890_123_456_789_012_345_678_901_234_567_890
+debug.print: "Test actor"
+debug.print: 100_000
+debug.print: 1_234_567_890_123_456_789_012_345_678_901_234_567_890
+debug.print: -1_234_567_890_123_456_789_012_345_678_901_234_567_890
+debug.print: "Test actor"
+debug.print: 100_000
+debug.print: PRE-UPGRADE HOOK!
+debug.print: IC0503: Error from Canister rrkah-fqaaa-aaaaa-aaaaq-cai: Canister called `ic0.trap` with message: Messages are blocked during stabilization.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+debug.print: Upgrade
+debug.print: IC0503: Error from Canister rrkah-fqaaa-aaaaa-aaaaq-cai: Canister called `ic0.trap` with message: Messages are blocked during stabilization.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+debug.print: POST-UPGRADE HOOK!
+debug.print: 0
+debug.print: ""
+debug.print: 0
+debug.print: 1_234_567_890_123_456_789_012_345_678_901_234_567_890
+debug.print: -1_234_567_890_123_456_789_012_345_678_901_234_567_890
+debug.print: "Test actor"
+debug.print: 100_000
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/incremental-stabilization.drun-run.ok b/test/run-drun/ok/incremental-stabilization.drun-run.ok
new file mode 100644
index 00000000000..3179b2b3666
--- /dev/null
+++ b/test/run-drun/ok/incremental-stabilization.drun-run.ok
@@ -0,0 +1,36 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+debug.print: Initialize flexible Nat
+debug.print: Initialize stable Nat
+debug.print: Initialize stable Int
+debug.print: Initialize stable text
+debug.print: Initialize stable array
+debug.print: Initialize stable object
+debug.print: Initialize flexible text
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 1
+debug.print: "Flexible text"
+debug.print: 12_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890
+debug.print: -2_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890
+debug.print: "Motoko incremental graph-copy-based upgrade test"
+debug.print: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
+debug.print: {stableArray = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]; stableInt = -2_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890; stableNat = 12_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890; stableText = "Motoko incremental graph-copy-based upgrade test"}
+ingress Completed: Reply: 0x4449444c0000
+debug.print: PRE-UPGRADE HOOK!
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: Messages are blocked during stabilization.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: Messages are blocked during stabilization.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+debug.print: Initialize flexible Nat
+debug.print: Initialize flexible text
+debug.print: POST-UPGRADE HOOK!
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 1
+debug.print: "Flexible text"
+debug.print: 12_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890
+debug.print: -2_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890
+debug.print: "Motoko incremental graph-copy-based upgrade test"
+debug.print: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
+debug.print: {stableArray = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]; stableInt = -2_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890; stableNat = 12_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890; stableText = "Motoko incremental graph-copy-based upgrade test"}
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/issue-1847.drun-run.ok b/test/run-drun/ok/issue-1847.drun-run.ok
index e72ff1ec5dd..94acfc6ba06 100644
--- a/test/run-drun/ok/issue-1847.drun-run.ok
+++ b/test/run-drun/ok/issue-1847.drun-run.ok
@@ -1,2 +1,3 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: empty input. Expected Candid-encoded argument, but received a zero-length argument
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: empty input. Expected Candid-encoded argument, but received a zero-length argument.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/issue-4229.drun-run.ok b/test/run-drun/ok/issue-4229.drun-run.ok
index f179b049f47..c8eea548cae 100644
--- a/test/run-drun/ok/issue-4229.drun-run.ok
+++ b/test/run-drun/ok/issue-4229.drun-run.ok
@@ -1,3 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 debug.print: "\44\49\44\4C\00\01\7F"
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: invalid type argument
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: invalid type argument.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/let-else-actor.drun-run.ok b/test/run-drun/ok/let-else-actor.drun-run.ok
index 6cc3b10e250..05b47775126 100644
--- a/test/run-drun/ok/let-else-actor.drun-run.ok
+++ b/test/run-drun/ok/let-else-actor.drun-run.ok
@@ -1,2 +1,3 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: x was null
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: x was null.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/live-upgrade.drun.ok b/test/run-drun/ok/live-upgrade.drun.ok
index 8480025fc17..42c2bcf5848 100644
--- a/test/run-drun/ok/live-upgrade.drun.ok
+++ b/test/run-drun/ok/live-upgrade.drun.ok
@@ -14,4 +14,5 @@ ingress Completed: Reply: 0x4449444c0000
 debug.print: {version = 2}
 ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
-Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: assertion failed at live-upgrade.mo:11.49-13.4
+Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: assertion failed at live-upgrade.mo:11.49-13.4.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/map-mixed-upgrades.drun.ok b/test/run-drun/ok/map-mixed-upgrades.drun.ok
new file mode 100644
index 00000000000..56fd3f61a0b
--- /dev/null
+++ b/test/run-drun/ok/map-mixed-upgrades.drun.ok
@@ -0,0 +1,181 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {node = 1; state = null; upgrades = 0}
+debug.print: 1: insert (1, "1")
+debug.print: 1: lookup 1
+debug.print: {node = 2; state = null; upgrades = 0}
+debug.print: 2: insert (2, "2")
+debug.print: 2: lookup 2
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {node = 1; state = ?(1, "1", null); upgrades = 1}
+debug.print: {node = 2; state = ?(2, "2", null); upgrades = 1}
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {node = 1; state = ?(1, "1", null); upgrades = 2}
+debug.print: {node = 2; state = ?(2, "2", null); upgrades = 2}
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reject: Invalid upgrade option: The `wasm_memory_persistence: opt Keep` upgrade option requires that the new canister module supports enhanced orthogonal persistence.
+debug.print: {node = 3; state = null; upgrades = 0}
+debug.print: 3: insert (3, "3")
+debug.print: 3: lookup 3
+debug.print: {node = 4; state = null; upgrades = 0}
+debug.print: 4: insert (4, "4")
+debug.print: 4: lookup 4
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {node = 1; state = ?(1, "1", null); upgrades = 3}
+debug.print: {node = 2; state = ?(2, "2", null); upgrades = 3}
+debug.print: {node = 3; state = ?(3, "3", null); upgrades = 1}
+debug.print: {node = 4; state = ?(4, "4", null); upgrades = 1}
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {node = 5; state = null; upgrades = 0}
+debug.print: 5: insert (5, "5")
+debug.print: 5: lookup 5
+debug.print: 5: remove 5
+debug.print: 5: lookup 5
+debug.print: 5: insert (5, "5")
+debug.print: 5: lookup 5
+debug.print: {node = 6; state = null; upgrades = 0}
+debug.print: 6: insert (6, "6")
+debug.print: 6: lookup 6
+debug.print: 6: remove 6
+debug.print: 6: lookup 6
+debug.print: 6: insert (6, "6")
+debug.print: 6: lookup 6
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {node = 1; state = ?(1, "1", null); upgrades = 4}
+debug.print: {node = 2; state = ?(2, "2", null); upgrades = 4}
+debug.print: {node = 3; state = ?(3, "3", null); upgrades = 2}
+debug.print: {node = 4; state = ?(4, "4", null); upgrades = 2}
+debug.print: {node = 5; state = ?(5, "5", null); upgrades = 1}
+debug.print: {node = 6; state = ?(6, "6", null); upgrades = 1}
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {node = 7; state = null; upgrades = 0}
+debug.print: 7: insert (7, "7")
+debug.print: 7: lookup 7
+debug.print: 7: remove 7
+debug.print: 7: lookup 7
+debug.print: 7: insert (7, "7")
+debug.print: 7: lookup 7
+debug.print: {node = 0; state = null; upgrades = 0}
+debug.print: 0: insert (8, "8")
+debug.print: 0: lookup 8
+debug.print: 0: remove 8
+debug.print: 0: lookup 8
+debug.print: 0: insert (8, "8")
+debug.print: 0: lookup 8
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {node = 1; state = ?(1, "1", null); upgrades = 5}
+debug.print: {node = 2; state = ?(2, "2", null); upgrades = 5}
+debug.print: {node = 3; state = ?(3, "3", null); upgrades = 3}
+debug.print: {node = 4; state = ?(4, "4", null); upgrades = 3}
+debug.print: {node = 5; state = ?(5, "5", null); upgrades = 2}
+debug.print: {node = 6; state = ?(6, "6", null); upgrades = 2}
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 1: lookup 9
+debug.print: 1: insert (9, "9")
+debug.print: 1: lookup 9
+debug.print: 1: remove 9
+debug.print: 1: lookup 9
+debug.print: 1: insert (9, "9")
+debug.print: 1: lookup 9
+debug.print: 2: lookup 10
+debug.print: 2: insert (10, "10")
+debug.print: 2: lookup 10
+debug.print: 2: remove 10
+debug.print: 2: lookup 10
+debug.print: 2: insert (10, "10")
+debug.print: 2: lookup 10
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {node = 1; state = ?(9, "9", ?(1, "1", null)); upgrades = 6}
+debug.print: {node = 2; state = ?(10, "10", ?(2, "2", null)); upgrades = 6}
+debug.print: {node = 3; state = ?(3, "3", null); upgrades = 4}
+debug.print: {node = 4; state = ?(4, "4", null); upgrades = 4}
+debug.print: {node = 5; state = ?(5, "5", null); upgrades = 3}
+debug.print: {node = 6; state = ?(6, "6", null); upgrades = 3}
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 3: lookup 11
+debug.print: 3: insert (11, "11")
+debug.print: 3: lookup 11
+debug.print: 3: remove 11
+debug.print: 3: lookup 11
+debug.print: 3: insert (11, "11")
+debug.print: 3: lookup 11
+debug.print: 4: lookup 12
+debug.print: 4: insert (12, "12")
+debug.print: 4: lookup 12
+debug.print: 4: remove 12
+debug.print: 4: lookup 12
+debug.print: 4: insert (12, "12")
+debug.print: 4: lookup 12
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {node = 1; state = ?(9, "9", ?(1, "1", null)); upgrades = 7}
+debug.print: {node = 2; state = ?(10, "10", ?(2, "2", null)); upgrades = 7}
+debug.print: {node = 3; state = ?(11, "11", ?(3, "3", null)); upgrades = 5}
+debug.print: {node = 4; state = ?(12, "12", ?(4, "4", null)); upgrades = 5}
+debug.print: {node = 5; state = ?(5, "5", null); upgrades = 4}
+debug.print: {node = 6; state = ?(6, "6", null); upgrades = 4}
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 5: lookup 13
+debug.print: 5: insert (13, "13")
+debug.print: 5: lookup 13
+debug.print: 5: remove 13
+debug.print: 5: lookup 13
+debug.print: 5: insert (13, "13")
+debug.print: 5: lookup 13
+debug.print: 6: lookup 14
+debug.print: 6: insert (14, "14")
+debug.print: 6: lookup 14
+debug.print: 6: remove 14
+debug.print: 6: lookup 14
+debug.print: 6: insert (14, "14")
+debug.print: 6: lookup 14
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0504: Missing upgrade option: Enhanced orthogonal persistence requires the `wasm_memory_persistence` upgrade option.
+debug.print: {node = 1; state = ?(9, "9", ?(1, "1", null)); upgrades = 8}
+debug.print: {node = 2; state = ?(10, "10", ?(2, "2", null)); upgrades = 8}
+debug.print: {node = 3; state = ?(11, "11", ?(3, "3", null)); upgrades = 6}
+debug.print: {node = 4; state = ?(12, "12", ?(4, "4", null)); upgrades = 6}
+debug.print: {node = 5; state = ?(13, "13", ?(5, "5", null)); upgrades = 5}
+debug.print: {node = 6; state = ?(14, "14", ?(6, "6", null)); upgrades = 5}
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 7: lookup 15
+debug.print: 7: insert (15, "15")
+debug.print: 7: lookup 15
+debug.print: 7: remove 15
+debug.print: 7: lookup 15
+debug.print: 7: insert (15, "15")
+debug.print: 7: lookup 15
+debug.print: 0: lookup 16
+debug.print: 0: insert (16, "16")
+debug.print: 0: lookup 16
+debug.print: 0: remove 16
+debug.print: 0: lookup 16
+debug.print: 0: insert (16, "16")
+debug.print: 0: lookup 16
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {node = 1; state = null; upgrades = 0}
+debug.print: {node = 2; state = null; upgrades = 0}
+debug.print: {node = 3; state = null; upgrades = 0}
+debug.print: {node = 4; state = null; upgrades = 0}
+debug.print: {node = 5; state = null; upgrades = 0}
+debug.print: {node = 6; state = null; upgrades = 0}
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 1: lookup 17
+debug.print: 1: insert (17, "17")
+debug.print: 1: lookup 17
+debug.print: 1: remove 17
+debug.print: 1: lookup 17
+debug.print: 1: insert (17, "17")
+debug.print: 1: lookup 17
+debug.print: 2: lookup 18
+debug.print: 2: insert (18, "18")
+debug.print: 2: lookup 18
+debug.print: 2: remove 18
+debug.print: 2: lookup 18
+debug.print: 2: insert (18, "18")
+debug.print: 2: lookup 18
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/map-stabilization.drun.ok b/test/run-drun/ok/map-stabilization.drun.ok
new file mode 100644
index 00000000000..ae61f06bb3d
--- /dev/null
+++ b/test/run-drun/ok/map-stabilization.drun.ok
@@ -0,0 +1,67 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {node = 1; state = null; upgrades = 0}
+debug.print: 1: insert (1, "1")
+debug.print: 1: lookup 1
+debug.print: {node = 2; state = null; upgrades = 0}
+debug.print: 2: insert (2, "2")
+debug.print: 2: lookup 2
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {node = 1; state = ?(1, "1", null); upgrades = 1}
+debug.print: {node = 2; state = ?(2, "2", null); upgrades = 1}
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {node = 3; state = null; upgrades = 0}
+debug.print: 3: insert (3, "3")
+debug.print: 3: lookup 3
+debug.print: {node = 4; state = null; upgrades = 0}
+debug.print: 4: insert (4, "4")
+debug.print: 4: lookup 4
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {node = 1; state = ?(1, "1", null); upgrades = 2}
+debug.print: {node = 2; state = ?(2, "2", null); upgrades = 2}
+debug.print: {node = 3; state = ?(3, "3", null); upgrades = 1}
+debug.print: {node = 4; state = ?(4, "4", null); upgrades = 1}
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {node = 5; state = null; upgrades = 0}
+debug.print: 5: insert (5, "5")
+debug.print: 5: lookup 5
+debug.print: 5: remove 5
+debug.print: 5: lookup 5
+debug.print: 5: insert (5, "5")
+debug.print: 5: lookup 5
+debug.print: {node = 6; state = null; upgrades = 0}
+debug.print: 6: insert (6, "6")
+debug.print: 6: lookup 6
+debug.print: 6: remove 6
+debug.print: 6: lookup 6
+debug.print: 6: insert (6, "6")
+debug.print: 6: lookup 6
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {node = 1; state = ?(1, "1", null); upgrades = 3}
+debug.print: {node = 2; state = ?(2, "2", null); upgrades = 3}
+debug.print: {node = 3; state = ?(3, "3", null); upgrades = 2}
+debug.print: {node = 4; state = ?(4, "4", null); upgrades = 2}
+debug.print: {node = 5; state = ?(5, "5", null); upgrades = 1}
+debug.print: {node = 6; state = ?(6, "6", null); upgrades = 1}
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {node = 7; state = null; upgrades = 0}
+debug.print: 7: insert (7, "7")
+debug.print: 7: lookup 7
+debug.print: 7: remove 7
+debug.print: 7: lookup 7
+debug.print: 7: insert (7, "7")
+debug.print: 7: lookup 7
+debug.print: {node = 0; state = null; upgrades = 0}
+debug.print: 0: insert (8, "8")
+debug.print: 0: lookup 8
+debug.print: 0: remove 8
+debug.print: 0: lookup 8
+debug.print: 0: insert (8, "8")
+debug.print: 0: lookup 8
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/max-stack-variant.drun-run.ok b/test/run-drun/ok/max-stack-variant.drun-run.ok
index 62b1197b109..01975521fe6 100644
--- a/test/run-drun/ok/max-stack-variant.drun-run.ok
+++ b/test/run-drun/ok/max-stack-variant.drun-run.ok
@@ -1,9 +1,11 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: IC0502: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped: stack overflow
+debug.print: IC0502: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister trapped: stack overflow.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped
 debug.print: serialized
 ingress Completed: Reply: 0x4449444c0000
-debug.print: IC0502: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped: stack overflow
+debug.print: IC0502: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister trapped: stack overflow.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped
 debug.print: serialized
 debug.print: deserialized
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/max-stack.drun-run.ok b/test/run-drun/ok/max-stack.drun-run.ok
index 62b1197b109..01975521fe6 100644
--- a/test/run-drun/ok/max-stack.drun-run.ok
+++ b/test/run-drun/ok/max-stack.drun-run.ok
@@ -1,9 +1,11 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: IC0502: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped: stack overflow
+debug.print: IC0502: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister trapped: stack overflow.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped
 debug.print: serialized
 ingress Completed: Reply: 0x4449444c0000
-debug.print: IC0502: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped: stack overflow
+debug.print: IC0502: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister trapped: stack overflow.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped
 debug.print: serialized
 debug.print: deserialized
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/migrate-candid-sharing.drun.ok b/test/run-drun/ok/migrate-candid-sharing.drun.ok
new file mode 100644
index 00000000000..f2cb75352e9
--- /dev/null
+++ b/test/run-drun/ok/migrate-candid-sharing.drun.ok
@@ -0,0 +1,8 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+debug.print: INITIALIZED: 100
+ingress Completed: Reply: 0x4449444c0000
+debug.print: INITIALIZED: 100
+ingress Completed: Reply: 0x4449444c0000
+debug.print: INITIALIZED: 100
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0504: Missing upgrade option: Enhanced orthogonal persistence requires the `wasm_memory_persistence` upgrade option.
diff --git a/test/run-drun/ok/migration-paths.drun.ok b/test/run-drun/ok/migration-paths.drun.ok
new file mode 100644
index 00000000000..4c171e8e096
--- /dev/null
+++ b/test/run-drun/ok/migration-paths.drun.ok
@@ -0,0 +1,28 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+debug.print: array initialized
+debug.print: version: 1
+debug.print: Installed
+ingress Completed: Reply: 0x4449444c0000
+debug.print: version: 2
+debug.print: Upgraded (default)
+ingress Completed: Reply: 0x4449444c0000
+debug.print: version: 3
+debug.print: Upgraded (replace main memory)
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reject: Invalid upgrade option: The `wasm_memory_persistence: opt Keep` upgrade option requires that the new canister module supports enhanced orthogonal persistence.
+ingress Completed: Reply: 0x4449444c0000
+debug.print: version: 4
+debug.print: Upgraded (keep main memory)
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Graph copy
+ingress Completed: Reply: 0x4449444c0000
+debug.print: version: 5
+debug.print: Upgraded (replace main memory)
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Graph copy
+ingress Completed: Reply: 0x4449444c0000
+debug.print: version: 6
+debug.print: Upgraded (keep main memory)
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0504: Missing upgrade option: Enhanced orthogonal persistence requires the `wasm_memory_persistence` upgrade option.
diff --git a/test/run-drun/ok/more-function-stabilization.drun.ok b/test/run-drun/ok/more-function-stabilization.drun.ok
new file mode 100644
index 00000000000..3f0c0c7fc33
--- /dev/null
+++ b/test/run-drun/ok/more-function-stabilization.drun.ok
@@ -0,0 +1,10 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/more-function-upgrades.drun.ok b/test/run-drun/ok/more-function-upgrades.drun.ok
index c46182ff707..e565700968b 100644
--- a/test/run-drun/ok/more-function-upgrades.drun.ok
+++ b/test/run-drun/ok/more-function-upgrades.drun.ok
@@ -1,5 +1,7 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/non-incremental-stabilization.drun-run.ok b/test/run-drun/ok/non-incremental-stabilization.drun-run.ok
new file mode 100644
index 00000000000..be4895eb527
--- /dev/null
+++ b/test/run-drun/ok/non-incremental-stabilization.drun-run.ok
@@ -0,0 +1,29 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 12_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890
+debug.print: -2_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890
+debug.print: "Motoko graph-copy-based upgrade test"
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reject: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: No destabilization needed.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+debug.print: PRE-UPGRADE HOOK!
+debug.print: POST-UPGRADE HOOK!
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reject: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: No destabilization needed.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+debug.print: 12_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890
+debug.print: -2_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890
+debug.print: "Motoko graph-copy-based upgrade test"
+ingress Completed: Reply: 0x4449444c0000
+debug.print: PRE-UPGRADE HOOK!
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reject: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: No destabilization needed.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: Messages are blocked during stabilization.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+debug.print: POST-UPGRADE HOOK!
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 12_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890
+debug.print: -2_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890
+debug.print: "Motoko graph-copy-based upgrade test"
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/oneshot-callbacks.drun-run.ok b/test/run-drun/ok/oneshot-callbacks.drun-run.ok
index 0655d78547d..2b16903da1c 100644
--- a/test/run-drun/ok/oneshot-callbacks.drun-run.ok
+++ b/test/run-drun/ok/oneshot-callbacks.drun-run.ok
@@ -49,7 +49,8 @@ debug.print: ping! 1
 debug.print: go 1: 1
 debug.print: ping-async! 1
 debug.print: go 2: 1
-ingress Err: IC0502: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped: integer division by 0
+ingress Err: IC0502: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister trapped: integer division by 0.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped
 debug.print: go 0: 0
 debug.print: ping! 1
 debug.print: go 1: 1
@@ -61,4 +62,5 @@ debug.print: ping! 1
 debug.print: go 1: 1
 debug.print: ping-async! 1
 debug.print: go 2: 1
-ingress Err: IC0502: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped: integer division by 0
+ingress Err: IC0502: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister trapped: integer division by 0.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped
diff --git a/test/run-drun/ok/query-footprint-overflow.drun-run.ok b/test/run-drun/ok/query-footprint-overflow.drun-run.ok
index c12bbde1992..6ea5f745be5 100644
--- a/test/run-drun/ok/query-footprint-overflow.drun-run.ok
+++ b/test/run-drun/ok/query-footprint-overflow.drun-run.ok
@@ -1,3 +1,4 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-ingress Completed: Reject: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: Deprecated with enhanced orthogonal persistence
+ingress Completed: Reject: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: buffer_size overflow.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/query-footprint-overflow.tc.ok b/test/run-drun/ok/query-footprint-overflow.tc.ok
index 83fd068bb6b..a366394a522 100644
--- a/test/run-drun/ok/query-footprint-overflow.tc.ok
+++ b/test/run-drun/ok/query-footprint-overflow.tc.ok
@@ -1 +1 @@
-query-footprint-overflow.mo:21.16-21.20: warning [M0194], unused identifier expl (delete or rename to wildcard `_` or `_expl`)
+query-footprint-overflow.mo:22.16-22.20: warning [M0194], unused identifier expl (delete or rename to wildcard `_` or `_expl`)
diff --git a/test/run-drun/ok/query-footprint.drun-run.ok b/test/run-drun/ok/query-footprint.drun-run.ok
index e29028fdae6..e9dfaac3f24 100644
--- a/test/run-drun/ok/query-footprint.drun-run.ok
+++ b/test/run-drun/ok/query-footprint.drun-run.ok
@@ -1,6 +1,6 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: Deprecated with enhanced orthogonal persistence
-Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: Deprecated with enhanced orthogonal persistence
-ingress Completed: Reject: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: Deprecated with enhanced orthogonal persistence
-ingress Completed: Reject: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: Deprecated with enhanced orthogonal persistence
+ingress Completed: Reply: 0x4449444c016c01c1c1cee2047801005118000000000000
+Ok: Reply: 0x4449444c016c01c1c1cee2047801005118000000000000
+ingress Completed: Reply: 0x4449444c0001785118000000000000
+ingress Completed: Reply: 0x4449444c0001785118000000000000
diff --git a/test/run-drun/ok/query-footprint.tc.ok b/test/run-drun/ok/query-footprint.tc.ok
index 32739f36f76..165902e9fc5 100644
--- a/test/run-drun/ok/query-footprint.tc.ok
+++ b/test/run-drun/ok/query-footprint.tc.ok
@@ -1,3 +1,3 @@
-query-footprint.mo:4.16-4.17: warning [M0194], unused identifier s (delete or rename to wildcard `_` or `_s`)
-query-footprint.mo:6.9-6.13: warning [M0194], unused identifier lost (delete or rename to wildcard `_` or `_lost`)
-query-footprint.mo:18.16-18.20: warning [M0194], unused identifier expl (delete or rename to wildcard `_` or `_expl`)
+query-footprint.mo:5.16-5.17: warning [M0194], unused identifier s (delete or rename to wildcard `_` or `_s`)
+query-footprint.mo:7.9-7.13: warning [M0194], unused identifier lost (delete or rename to wildcard `_` or `_lost`)
+query-footprint.mo:19.16-19.20: warning [M0194], unused identifier expl (delete or rename to wildcard `_` or `_expl`)
diff --git a/test/run-drun/ok/query-size-overflow.drun-run.ok b/test/run-drun/ok/query-size-overflow.drun-run.ok
index dacdff32217..5592415675d 100644
--- a/test/run-drun/ok/query-size-overflow.drun-run.ok
+++ b/test/run-drun/ok/query-size-overflow.drun-run.ok
@@ -1,4 +1,6 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: buffer_size overflow
-Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: buffer_size overflow
+Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: buffer_size overflow.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: buffer_size overflow.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/region-test.drun-run.ok b/test/run-drun/ok/region-test.drun-run.ok
index 52c2beae4df..e29b620dec0 100644
--- a/test/run-drun/ok/region-test.drun-run.ok
+++ b/test/run-drun/ok/region-test.drun-run.ok
@@ -9,4 +9,5 @@ debug.print: Int32
 debug.print: Int64
 debug.print: Float
 debug.print: Blob
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: Done (rolling back changes with trap)
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: Done (rolling back changes with trap).
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/region0-overflow.drun-run.ok b/test/run-drun/ok/region0-overflow.drun-run.ok
index 2048ea0a7e3..17b7b9aa288 100644
--- a/test/run-drun/ok/region0-overflow.drun-run.ok
+++ b/test/run-drun/ok/region0-overflow.drun-run.ok
@@ -1,9 +1,15 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: StableMemory offset out of bounds
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: StableMemory range out of bounds
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: StableMemory range out of bounds
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: StableMemory range out of bounds
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: StableMemory offset out of bounds
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: StableMemory offset out of bounds
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: StableMemory offset out of bounds.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: StableMemory range out of bounds.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: StableMemory range out of bounds.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: StableMemory range out of bounds.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: StableMemory offset out of bounds.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: StableMemory offset out of bounds.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/region0-rts-stats.drun-run.ok b/test/run-drun/ok/region0-rts-stats.drun-run.ok
index 9f22d7475b0..15fae421812 100644
--- a/test/run-drun/ok/region0-rts-stats.drun-run.ok
+++ b/test/run-drun/ok/region0-rts-stats.drun-run.ok
@@ -1,10 +1,13 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
-debug.print: {l1 = 6; s1 = 6}
+debug.print: Ignore Diff: (ignored)
 debug.print: {l2 = 144; s2 = 144}
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {l1 = 144; s1 = 145}
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: pattern failed
-debug.print: {l1 = 144; s1 = 145}
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: pattern failed
-debug.print: {l1 = 144; s1 = 145}
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: pattern failed
+debug.print: Ignore Diff: (ignored)
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: pattern failed.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+debug.print: Ignore Diff: (ignored)
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: pattern failed.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+debug.print: Ignore Diff: (ignored)
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: pattern failed.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/region0-rts-stats.tc.ok b/test/run-drun/ok/region0-rts-stats.tc.ok
index e2aaac24ac8..14c6603b4cd 100644
--- a/test/run-drun/ok/region0-rts-stats.tc.ok
+++ b/test/run-drun/ok/region0-rts-stats.tc.ok
@@ -1,7 +1,7 @@
 stable-mem/StableMemory.mo:5.21-5.42: warning [M0199], this code is (or uses) the deprecated library `ExperimentalStableMemory`.
 Please use the `Region` library instead: https://internetcomputer.org/docs/current/motoko/main/stable-memory/stable-regions/#the-region-library or compile with flag `--experimental-stable-memory 1` to suppress this message.
-region0-rts-stats.mo:8.7-8.8: warning [M0145], this pattern of type
+region0-rts-stats.mo:10.7-10.8: warning [M0145], this pattern of type
   Nat64
 does not cover value
   1 or 2 or _
-region0-rts-stats.mo:9.14-9.15: warning [M0194], unused identifier v (delete or rename to wildcard `_` or `_v`)
+region0-rts-stats.mo:11.14-11.15: warning [M0194], unused identifier v (delete or rename to wildcard `_` or `_v`)
diff --git a/test/run-drun/ok/rts-stats2.drun-run.ok b/test/run-drun/ok/rts-stats2-classical.drun-run.ok
similarity index 100%
rename from test/run-drun/ok/rts-stats2.drun-run.ok
rename to test/run-drun/ok/rts-stats2-classical.drun-run.ok
diff --git a/test/run-drun/ok/rts-stats2-enhanced.drun-run.ok b/test/run-drun/ok/rts-stats2-enhanced.drun-run.ok
new file mode 100644
index 00000000000..6fd260403f7
--- /dev/null
+++ b/test/run-drun/ok/rts-stats2-enhanced.drun-run.ok
@@ -0,0 +1,16 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Ignore Diff: (ignored)
+debug.print: Ignore Diff: (ignored)
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Ignore Diff: (ignored)
+debug.print: Ignore Diff: (ignored)
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Ignore Diff: (ignored)
+debug.print: Ignore Diff: (ignored)
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Ignore Diff: (ignored)
+debug.print: Ignore Diff: (ignored)
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/runtime-info-acl.drun-run.ok b/test/run-drun/ok/runtime-info-acl.drun-run.ok
index 2dfb0fa9811..886d1085fbf 100644
--- a/test/run-drun/ok/runtime-info-acl.drun-run.ok
+++ b/test/run-drun/ok/runtime-info-acl.drun-run.ok
@@ -2,5 +2,6 @@ ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a000000000000000001
 ingress Completed: Reply: 0x4449444c0000
 debug.print: Self information okay
 debug.print: Controllee information okay
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: Unauthorized call of __motoko_runtime_information
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: Unauthorized call of __motoko_runtime_information.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/selftail.drun-run.ok b/test/run-drun/ok/selftail.drun-run.ok
index a8e082b05bf..51df7f8b742 100644
--- a/test/run-drun/ok/selftail.drun-run.ok
+++ b/test/run-drun/ok/selftail.drun-run.ok
@@ -1,4 +1,5 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 debug.print: ok1
 debug.print: ok2
-ingress Err: IC0502: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped: stack overflow
+ingress Err: IC0502: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister trapped: stack overflow.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped
diff --git a/test/run-drun/ok/send-failure-example-trap.drun-run.ok b/test/run-drun/ok/send-failure-example-trap.drun-run.ok
index ec016e3da5a..6be0e978269 100644
--- a/test/run-drun/ok/send-failure-example-trap.drun-run.ok
+++ b/test/run-drun/ok/send-failure-example-trap.drun-run.ok
@@ -1,8 +1,10 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: could not perform remote call
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: could not perform remote call.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {count = 0}
 ingress Completed: Reply: 0x4449444c00017d00
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: could not perform remote call
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: could not perform remote call.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {count = 0}
 ingress Completed: Reply: 0x4449444c00017d00
diff --git a/test/run-drun/ok/stabilization-authorization.drun-run.ok b/test/run-drun/ok/stabilization-authorization.drun-run.ok
new file mode 100644
index 00000000000..2099eaba76e
--- /dev/null
+++ b/test/run-drun/ok/stabilization-authorization.drun-run.ok
@@ -0,0 +1,17 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Test __motoko_stabilize_before_upgrade
+debug.print: IC0503: Error from Canister rrkah-fqaaa-aaaaa-aaaaq-cai: Canister called `ic0.trap` with message: not a self-call or call from controller.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+debug.print: Test __motoko_stabilize_after_upgrade
+debug.print: IC0503: Error from Canister rrkah-fqaaa-aaaaa-aaaaq-cai: Canister called `ic0.trap` with message: not a self-call or call from controller.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+debug.print: Test upgrade
+debug.print: PRE-UPGRADE HOOK!
+debug.print: Test __motoko_stabilize_before_upgrade
+debug.print: IC0503: Error from Canister rrkah-fqaaa-aaaaa-aaaaq-cai: Canister called `ic0.trap` with message: not a self-call or call from controller.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+debug.print: Test __motoko_stabilize_after_upgrade
+debug.print: IC0503: Error from Canister rrkah-fqaaa-aaaaa-aaaaq-cai: Canister called `ic0.trap` with message: not a self-call or call from controller.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/stabilization-instructions.drun-run.ok b/test/run-drun/ok/stabilization-instructions.drun-run.ok
new file mode 100644
index 00000000000..2938d96fdea
--- /dev/null
+++ b/test/run-drun/ok/stabilization-instructions.drun-run.ok
@@ -0,0 +1,15 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+debug.print: Ignore Diff: (ignored)
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Ignore Diff: (ignored)
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Ignore Diff: (ignored)
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Ignore Diff: (ignored)
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/stabilization-upgrade-hooks.drun.ok b/test/run-drun/ok/stabilization-upgrade-hooks.drun.ok
new file mode 100644
index 00000000000..3f85370202b
--- /dev/null
+++ b/test/run-drun/ok/stabilization-upgrade-hooks.drun.ok
@@ -0,0 +1,33 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+debug.print: init'ed
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: init'ed 0
+debug.print: postupgrade 0
+ingress Completed: Reply: 0x4449444c0000
+debug.print: a
+Ok: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: aa
+Ok: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: preupgrade 0
+ingress Completed: Reply: 0x4449444c0000
+debug.print: init'ed 1
+debug.print: postupgrade 1
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 3
+debug.print: aaa
+Ok: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 4
+debug.print: aaa
+Ok: Reply: 0x4449444c0000
+debug.print: preupgrade 1
+ingress Completed: Reply: 0x4449444c0000
+debug.print: init'ed 2
+debug.print: postupgrade 2
+ingress Completed: Reply: 0x4449444c0000
+Ok: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+Ok: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/stabilize-beyond-stable-limit.drun-run.ok b/test/run-drun/ok/stabilize-beyond-stable-limit.drun-run.ok
new file mode 100644
index 00000000000..59abbe37c68
--- /dev/null
+++ b/test/run-drun/ok/stabilize-beyond-stable-limit.drun-run.ok
@@ -0,0 +1,19 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+debug.print: growing stable memory
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 65_536
+ingress Completed: Reply: 0x4449444c0000
+debug.print: PRE-UPGRADE HOOK!
+ingress Completed: Reply: 0x4449444c0000
+debug.print: POST-UPGRADE HOOK!
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 65_536
+ingress Completed: Reply: 0x4449444c0000
+debug.print: PRE-UPGRADE HOOK!
+ingress Completed: Reply: 0x4449444c0000
+debug.print: POST-UPGRADE HOOK!
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 65_536
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/stabilize-beyond-stable-limit.tc.ok b/test/run-drun/ok/stabilize-beyond-stable-limit.tc.ok
new file mode 100644
index 00000000000..d660c81190b
--- /dev/null
+++ b/test/run-drun/ok/stabilize-beyond-stable-limit.tc.ok
@@ -0,0 +1,2 @@
+stabilize-beyond-stable-limit.mo:13.9-13.30: warning [M0199], this code is (or uses) the deprecated library `ExperimentalStableMemory`.
+Please use the `Region` library instead: https://internetcomputer.org/docs/current/motoko/main/stable-memory/stable-regions/#the-region-library or compile with flag `--experimental-stable-memory 1` to suppress this message.
diff --git a/test/run-drun/ok/stabilize-bignat-bigint.drun.ok b/test/run-drun/ok/stabilize-bignat-bigint.drun.ok
new file mode 100644
index 00000000000..5782de05de5
--- /dev/null
+++ b/test/run-drun/ok/stabilize-bignat-bigint.drun.ok
@@ -0,0 +1,31 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 12_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_891
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 12_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_892
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 12_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_893
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: +12_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_891
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: +12_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_889
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: +12_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_887
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/stabilize-bignums.drun-run.ok b/test/run-drun/ok/stabilize-bignums.drun-run.ok
new file mode 100644
index 00000000000..119f3e25520
--- /dev/null
+++ b/test/run-drun/ok/stabilize-bignums.drun-run.ok
@@ -0,0 +1,29 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 12_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890
+debug.print: -12_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 24_691_357_802_469_135_780_246_913_578_024_691_357_802_469_135_780_246_913_578_024_691_357_802_469_135_781
+debug.print: -24_691_357_802_469_135_780_246_913_578_024_691_357_802_469_135_780_246_913_578_024_691_357_802_469_135_781
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 49_382_715_604_938_271_560_493_827_156_049_382_715_604_938_271_560_493_827_156_049_382_715_604_938_271_563
+debug.print: -49_382_715_604_938_271_560_493_827_156_049_382_715_604_938_271_560_493_827_156_049_382_715_604_938_271_563
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 49_382_715_604_938_271_560_493_827_156_049_382_715_604_938_271_560_493_827_156_049_382_715_604_938_271_563
+debug.print: -49_382_715_604_938_271_560_493_827_156_049_382_715_604_938_271_560_493_827_156_049_382_715_604_938_271_563
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 49_382_715_604_938_271_560_493_827_156_049_382_715_604_938_271_560_493_827_156_049_382_715_604_938_271_563
+debug.print: -49_382_715_604_938_271_560_493_827_156_049_382_715_604_938_271_560_493_827_156_049_382_715_604_938_271_563
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/stabilize-blob-iter.drun.ok b/test/run-drun/ok/stabilize-blob-iter.drun.ok
new file mode 100644
index 00000000000..224f84257a0
--- /dev/null
+++ b/test/run-drun/ok/stabilize-blob-iter.drun.ok
@@ -0,0 +1,21 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Err: IC0537: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Attempted to execute a message, but the canister contains no Wasm module..
+Please install code to this canister before calling it. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#wasm-module-not-found
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {stableField = "Version 0"}
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {stableField = "Version 0"}
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {}
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {}
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/stabilize-boxed-numbers.drun-run.ok b/test/run-drun/ok/stabilize-boxed-numbers.drun-run.ok
new file mode 100644
index 00000000000..6b50312c8d9
--- /dev/null
+++ b/test/run-drun/ok/stabilize-boxed-numbers.drun-run.ok
@@ -0,0 +1,27 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 4_294_967_295
+debug.print: -2_147_483_648
+debug.print: 18_446_744_073_709_551_614
+debug.print: -9_223_372_036_854_775_808
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 4_294_967_295
+debug.print: -2_147_483_648
+debug.print: 18_446_744_073_709_551_614
+debug.print: -9_223_372_036_854_775_808
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 4_294_967_295
+debug.print: -2_147_483_648
+debug.print: 18_446_744_073_709_551_614
+debug.print: -9_223_372_036_854_775_808
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 4_294_967_295
+debug.print: -2_147_483_648
+debug.print: 18_446_744_073_709_551_614
+debug.print: -9_223_372_036_854_775_808
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/stabilize-generics.drun.ok b/test/run-drun/ok/stabilize-generics.drun.ok
new file mode 100644
index 00000000000..d748a1a6c39
--- /dev/null
+++ b/test/run-drun/ok/stabilize-generics.drun.ok
@@ -0,0 +1,29 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+debug.print: (([0], [+1]), true)
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: (([0], [+1]), true)
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: (([0], [+1]), true)
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: (([0], [+1]), true)
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: (([0], [+1]), true)
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: (([0], [+1]), true)
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: (([0], [+1]), true)
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/stabilize-large-array.drun-run.ok b/test/run-drun/ok/stabilize-large-array.drun-run.ok
new file mode 100644
index 00000000000..7cab37352e1
--- /dev/null
+++ b/test/run-drun/ok/stabilize-large-array.drun-run.ok
@@ -0,0 +1,11 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Array of length 100_000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: PRE-UPGRADE HOOK!
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: POST-UPGRADE HOOK!
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Array of length 100_000
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/stabilize-mutable-array.drun.ok b/test/run-drun/ok/stabilize-mutable-array.drun.ok
new file mode 100644
index 00000000000..99aa98c27bb
--- /dev/null
+++ b/test/run-drun/ok/stabilize-mutable-array.drun.ok
@@ -0,0 +1,14 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+debug.print: firstField=0
+debug.print: secondField=0
+debug.print: thirdField=0
+debug.print: firstField=0
+debug.print: secondField=0
+debug.print: thirdField=0
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: Messages are blocked during stabilization.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/stabilize-mutable-service.drun.ok b/test/run-drun/ok/stabilize-mutable-service.drun.ok
new file mode 100644
index 00000000000..b1142cd4271
--- /dev/null
+++ b/test/run-drun/ok/stabilize-mutable-service.drun.ok
@@ -0,0 +1,30 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: original test0
+debug.print: original test1
+debug.print: original test2
+debug.print: original test3
+debug.print: original test0
+debug.print: original test1
+debug.print: original test2
+debug.print: original test3
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: original test0
+debug.print: original test1
+debug.print: original test2
+debug.print: original test3
+debug.print: original test0
+debug.print: original test1
+debug.print: original test2
+debug.print: original test3
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: Messages are blocked during stabilization.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: Messages are blocked during stabilization.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/stabilize-mutable-variant.drun.ok b/test/run-drun/ok/stabilize-mutable-variant.drun.ok
new file mode 100644
index 00000000000..32ba42ac451
--- /dev/null
+++ b/test/run-drun/ok/stabilize-mutable-variant.drun.ok
@@ -0,0 +1,10 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+debug.print: instance=[var #Option1]
+debug.print: alias=[var #Option1]
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: Messages are blocked during stabilization.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/stabilize-mutable.drun.ok b/test/run-drun/ok/stabilize-mutable.drun.ok
new file mode 100644
index 00000000000..13c7629be32
--- /dev/null
+++ b/test/run-drun/ok/stabilize-mutable.drun.ok
@@ -0,0 +1,20 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: [var {key = 2; value = "2"}]
+debug.print: [var {key = 2; value = "2"}]
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: [var {key = 2; value = "2"}]
+debug.print: [var {key = 2; value = "2"}]
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: [var {key = 2; value = "2"}]
+debug.print: [var {key = 2; value = "2"}]
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/stabilize-nat-to-int.drun.ok b/test/run-drun/ok/stabilize-nat-to-int.drun.ok
new file mode 100644
index 00000000000..c4fc6ba9378
--- /dev/null
+++ b/test/run-drun/ok/stabilize-nat-to-int.drun.ok
@@ -0,0 +1,25 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Err: IC0537: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Attempted to execute a message, but the canister contains no Wasm module..
+Please install code to this canister before calling it. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#wasm-module-not-found
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 1
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 2
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 0
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: -2
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/stabilize-non-stable.drun.ok b/test/run-drun/ok/stabilize-non-stable.drun.ok
new file mode 100644
index 00000000000..224f84257a0
--- /dev/null
+++ b/test/run-drun/ok/stabilize-non-stable.drun.ok
@@ -0,0 +1,21 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Err: IC0537: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Attempted to execute a message, but the canister contains no Wasm module..
+Please install code to this canister before calling it. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#wasm-module-not-found
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {stableField = "Version 0"}
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {stableField = "Version 0"}
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {}
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {}
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/stabilize-optional.drun.ok b/test/run-drun/ok/stabilize-optional.drun.ok
new file mode 100644
index 00000000000..ac8ab0ae77c
--- /dev/null
+++ b/test/run-drun/ok/stabilize-optional.drun.ok
@@ -0,0 +1,26 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Err: IC0537: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Attempted to execute a message, but the canister contains no Wasm module..
+Please install code to this canister before calling it. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#wasm-module-not-found
+ingress Completed: Reply: 0x4449444c0000
+debug.print: ?(?null)
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: ?(?null)
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: ?(?null)
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: ?(?null)
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: ?(?null)
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/stabilize-primitive-types.drun-run.ok b/test/run-drun/ok/stabilize-primitive-types.drun-run.ok
new file mode 100644
index 00000000000..88d23cd7dc7
--- /dev/null
+++ b/test/run-drun/ok/stabilize-primitive-types.drun-run.ok
@@ -0,0 +1,85 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+debug.print: Initialized
+ingress Completed: Reply: 0x4449444c0000
+debug.print: null
+debug.print: false
+debug.print: 1_234_567_890_123_456_789_012_345_678_901_234_567_890
+debug.print: 123
+debug.print: 12_345
+debug.print: 1_234_567_890
+debug.print: 123_456_789_012_345
+debug.print: -1_234_567_890_123_456_789_012_345_678_901_234_567_890
+debug.print: -123
+debug.print: -12_345
+debug.print: -1_234_567_890
+debug.print: -123_456_789_012_345
+debug.print: 1.234568
+debug.print: '!'
+debug.print: ""TEST""
+debug.print: "\61\62\63"
+debug.print: un4fu-tqaaa-aaaab-qadjq-cai
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Initialized
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: null
+debug.print: true
+debug.print: 1_234_567_890_123_456_789_012_345_678_901_234_567_891
+debug.print: 124
+debug.print: 12_346
+debug.print: 1_234_567_891
+debug.print: 123_456_789_012_346
+debug.print: -1_234_567_890_123_456_789_012_345_678_901_234_567_890
+debug.print: -123
+debug.print: -12_345
+debug.print: -1_234_567_890
+debug.print: -123_456_789_012_345
+debug.print: 1.334568
+debug.print: '?'
+debug.print: ""TEST" "TEST""
+debug.print: "\61\62\63"
+debug.print: un4fu-tqaaa-aaaab-qadjq-cai
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Initialized
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: null
+debug.print: false
+debug.print: 1_234_567_890_123_456_789_012_345_678_901_234_567_892
+debug.print: 125
+debug.print: 12_347
+debug.print: 1_234_567_892
+debug.print: 123_456_789_012_347
+debug.print: -1_234_567_890_123_456_789_012_345_678_901_234_567_890
+debug.print: -123
+debug.print: -12_345
+debug.print: -1_234_567_890
+debug.print: -123_456_789_012_345
+debug.print: 1.434568
+debug.print: '!'
+debug.print: ""TEST" "TEST" "TEST""
+debug.print: "\61\62\63"
+debug.print: un4fu-tqaaa-aaaab-qadjq-cai
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Initialized
+ingress Completed: Reply: 0x4449444c0000
+debug.print: null
+debug.print: false
+debug.print: 1_234_567_890_123_456_789_012_345_678_901_234_567_892
+debug.print: 125
+debug.print: 12_347
+debug.print: 1_234_567_892
+debug.print: 123_456_789_012_347
+debug.print: -1_234_567_890_123_456_789_012_345_678_901_234_567_890
+debug.print: -123
+debug.print: -12_345
+debug.print: -1_234_567_890
+debug.print: -123_456_789_012_345
+debug.print: 1.434568
+debug.print: '!'
+debug.print: ""TEST" "TEST" "TEST""
+debug.print: "\61\62\63"
+debug.print: un4fu-tqaaa-aaaab-qadjq-cai
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/stabilize-recursive-type.drun.ok b/test/run-drun/ok/stabilize-recursive-type.drun.ok
new file mode 100644
index 00000000000..81634d69248
--- /dev/null
+++ b/test/run-drun/ok/stabilize-recursive-type.drun.ok
@@ -0,0 +1,24 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: CHECK 1
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: CHECK 2
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: Messages are blocked during stabilization.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: Messages are blocked during stabilization.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: Messages are blocked during stabilization.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: Messages are blocked during stabilization.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/stabilize-remove-add-fields.drun.ok b/test/run-drun/ok/stabilize-remove-add-fields.drun.ok
new file mode 100644
index 00000000000..9fc4586be34
--- /dev/null
+++ b/test/run-drun/ok/stabilize-remove-add-fields.drun.ok
@@ -0,0 +1,38 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: firstField=1
+debug.print: secondField=1
+debug.print: thirdField=1
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: firstField=2
+debug.print: secondField=2
+debug.print: thirdField=2
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: secondField=3
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: secondField=4
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: Messages are blocked during stabilization.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: Messages are blocked during stabilization.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: Messages are blocked during stabilization.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: Messages are blocked during stabilization.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/stabilize-service.drun.ok b/test/run-drun/ok/stabilize-service.drun.ok
new file mode 100644
index 00000000000..f6143445dd1
--- /dev/null
+++ b/test/run-drun/ok/stabilize-service.drun.ok
@@ -0,0 +1,25 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: original test1
+debug.print: original test2
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: original test1
+debug.print: original test2
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: reduced test1
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: reduced test1
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: Messages are blocked during stabilization.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/stabilize-text-iter.drun.ok b/test/run-drun/ok/stabilize-text-iter.drun.ok
new file mode 100644
index 00000000000..224f84257a0
--- /dev/null
+++ b/test/run-drun/ok/stabilize-text-iter.drun.ok
@@ -0,0 +1,21 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Err: IC0537: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Attempted to execute a message, but the canister contains no Wasm module..
+Please install code to this canister before calling it. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#wasm-module-not-found
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {stableField = "Version 0"}
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {stableField = "Version 0"}
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {}
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: {}
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/stabilize-to-any.drun.ok b/test/run-drun/ok/stabilize-to-any.drun.ok
new file mode 100644
index 00000000000..308aea92c20
--- /dev/null
+++ b/test/run-drun/ok/stabilize-to-any.drun.ok
@@ -0,0 +1,20 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+debug.print: Version 0
+debug.print: Initialize first variable
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Version 1
+debug.print: Initialize second variable
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Version 2
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: Version 2
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/stabilize-variant.drun.ok b/test/run-drun/ok/stabilize-variant.drun.ok
new file mode 100644
index 00000000000..9c54f0ee325
--- /dev/null
+++ b/test/run-drun/ok/stabilize-variant.drun.ok
@@ -0,0 +1,23 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: #two({key = 1; name = "TEST TEST"})
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: #two({key = 1; name = "TEST TEST TEST"})
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: #two({key = 1; name = "TEST TEST TEST TEST"})
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: #two({key = 1; name = "TEST TEST TEST TEST TEST"})
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/stable-mem-rts-stats.drun-run.ok b/test/run-drun/ok/stable-mem-rts-stats.drun-run.ok
index 79bb9d774dd..e1c59369d2d 100644
--- a/test/run-drun/ok/stable-mem-rts-stats.drun-run.ok
+++ b/test/run-drun/ok/stable-mem-rts-stats.drun-run.ok
@@ -1,10 +1,13 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
-debug.print: {l1 = 0; s1 = 0}
+debug.print: Ignore Diff: (ignored)
 debug.print: {l2 = 16; s2 = 16}
 ingress Completed: Reply: 0x4449444c0000
-debug.print: {l1 = 16; s1 = 17}
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: pattern failed
-debug.print: {l1 = 16; s1 = 17}
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: pattern failed
-debug.print: {l1 = 16; s1 = 17}
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: pattern failed
+debug.print: Ignore Diff: (ignored)
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: pattern failed.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+debug.print: Ignore Diff: (ignored)
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: pattern failed.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+debug.print: Ignore Diff: (ignored)
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: pattern failed.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/stable-mem-rts-stats.tc.ok b/test/run-drun/ok/stable-mem-rts-stats.tc.ok
index b87d82199c0..24c9117a96f 100644
--- a/test/run-drun/ok/stable-mem-rts-stats.tc.ok
+++ b/test/run-drun/ok/stable-mem-rts-stats.tc.ok
@@ -1,7 +1,7 @@
 stable-mem/StableMemory.mo:5.21-5.42: warning [M0199], this code is (or uses) the deprecated library `ExperimentalStableMemory`.
 Please use the `Region` library instead: https://internetcomputer.org/docs/current/motoko/main/stable-memory/stable-regions/#the-region-library or compile with flag `--experimental-stable-memory 1` to suppress this message.
-stable-mem-rts-stats.mo:7.7-7.8: warning [M0145], this pattern of type
+stable-mem-rts-stats.mo:9.7-9.8: warning [M0145], this pattern of type
   Nat64
 does not cover value
   1 or 2 or _
-stable-mem-rts-stats.mo:8.14-8.15: warning [M0194], unused identifier v (delete or rename to wildcard `_` or `_v`)
+stable-mem-rts-stats.mo:10.14-10.15: warning [M0194], unused identifier v (delete or rename to wildcard `_` or `_v`)
diff --git a/test/run-drun/ok/stable-memory-test.drun-run.ok b/test/run-drun/ok/stable-memory-test.drun-run.ok
index 52c2beae4df..e29b620dec0 100644
--- a/test/run-drun/ok/stable-memory-test.drun-run.ok
+++ b/test/run-drun/ok/stable-memory-test.drun-run.ok
@@ -9,4 +9,5 @@ debug.print: Int32
 debug.print: Int64
 debug.print: Float
 debug.print: Blob
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: Done (rolling back changes with trap)
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: Done (rolling back changes with trap).
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/stable-overflow.drun-run.ok b/test/run-drun/ok/stable-overflow.drun-run.ok
index 2048ea0a7e3..17b7b9aa288 100644
--- a/test/run-drun/ok/stable-overflow.drun-run.ok
+++ b/test/run-drun/ok/stable-overflow.drun-run.ok
@@ -1,9 +1,15 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: StableMemory offset out of bounds
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: StableMemory range out of bounds
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: StableMemory range out of bounds
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: StableMemory range out of bounds
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: StableMemory offset out of bounds
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: StableMemory offset out of bounds
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: StableMemory offset out of bounds.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: StableMemory range out of bounds.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: StableMemory range out of bounds.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: StableMemory range out of bounds.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: StableMemory offset out of bounds.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: StableMemory offset out of bounds.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/stable-regions-new-each-stabilization.drun-run.ok b/test/run-drun/ok/stable-regions-new-each-stabilization.drun-run.ok
new file mode 100644
index 00000000000..beb13fc4b33
--- /dev/null
+++ b/test/run-drun/ok/stable-regions-new-each-stabilization.drun-run.ok
@@ -0,0 +1,31 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+debug.print: sanity check. n=0
+ingress Completed: Reply: 0x4449444c0000
+debug.print: upgrading... calling Region.new(), n=0
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: sanity check. n=1
+debug.print:  unwrapping. i=0
+debug.print: 16
+ingress Completed: Reply: 0x4449444c0000
+debug.print: upgrading... calling Region.new(), n=1
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: sanity check. n=2
+debug.print:  unwrapping. i=0
+debug.print: 16
+debug.print:  unwrapping. i=1
+debug.print: 17
+ingress Completed: Reply: 0x4449444c0000
+debug.print: upgrading... calling Region.new(), n=2
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: sanity check. n=3
+debug.print:  unwrapping. i=0
+debug.print: 16
+debug.print:  unwrapping. i=1
+debug.print: 17
+debug.print:  unwrapping. i=2
+debug.print: 18
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/stable-regions-stabilization.drun-run.ok b/test/run-drun/ok/stable-regions-stabilization.drun-run.ok
new file mode 100644
index 00000000000..b1eb2a90aba
--- /dev/null
+++ b/test/run-drun/ok/stable-regions-stabilization.drun-run.ok
@@ -0,0 +1,13 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+debug.print: grow three big regions (including region0).
+debug.print: grow three big regions: done.
+ingress Completed: Reply: 0x4449444c0000
+debug.print: sanity check. n=0
+ingress Completed: Reply: 0x4449444c0000
+debug.print: upgrading... n=0
+ingress Completed: Reply: 0x4449444c0000
+debug.print: grow three big regions (including region0).
+debug.print: grow three big regions: done.
+ingress Completed: Reply: 0x4449444c0000
+debug.print: sanity check. n=1
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/stable-regions-stabilization.tc.ok b/test/run-drun/ok/stable-regions-stabilization.tc.ok
new file mode 100644
index 00000000000..4c1a57bfe2b
--- /dev/null
+++ b/test/run-drun/ok/stable-regions-stabilization.tc.ok
@@ -0,0 +1,2 @@
+stable-mem/StableMemory.mo:5.21-5.42: warning [M0199], this code is (or uses) the deprecated library `ExperimentalStableMemory`.
+Please use the `Region` library instead: https://internetcomputer.org/docs/current/motoko/main/stable-memory/stable-regions/#the-region-library or compile with flag `--experimental-stable-memory 1` to suppress this message.
diff --git a/test/run-drun/ok/stable-size-overflow.drun-run.ok b/test/run-drun/ok/stable-size-overflow.drun-run.ok
new file mode 100644
index 00000000000..4ffc76fe28a
--- /dev/null
+++ b/test/run-drun/ok/stable-size-overflow.drun-run.ok
@@ -0,0 +1,5 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+debug.print: upgrading...
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: buffer_size overflow.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/stable-size-overflow.tc.ok b/test/run-drun/ok/stable-size-overflow.tc.ok
index 11562f3059c..4c1a57bfe2b 100644
--- a/test/run-drun/ok/stable-size-overflow.tc.ok
+++ b/test/run-drun/ok/stable-size-overflow.tc.ok
@@ -1,3 +1,2 @@
 stable-mem/StableMemory.mo:5.21-5.42: warning [M0199], this code is (or uses) the deprecated library `ExperimentalStableMemory`.
 Please use the `Region` library instead: https://internetcomputer.org/docs/current/motoko/main/stable-memory/stable-regions/#the-region-library or compile with flag `--experimental-stable-memory 1` to suppress this message.
-stable-size-overflow.mo:12.7-12.8: warning [M0194], unused identifier a (delete or rename to wildcard `_` or `_a`)
diff --git a/test/run-drun/ok/trap-on-async-failure.drun-run.ok b/test/run-drun/ok/trap-on-async-failure.drun-run.ok
index 3ec84b5fb7d..e0970d9cd01 100644
--- a/test/run-drun/ok/trap-on-async-failure.drun-run.ok
+++ b/test/run-drun/ok/trap-on-async-failure.drun-run.ok
@@ -1,7 +1,9 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
 debug.print: test1:
-debug.print: test1: (#canister_error, "IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: could not perform self call")
+debug.print: test1: (#canister_error, "IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: could not perform self call.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly")
 debug.print: test2:
-debug.print: test2: (#canister_error, "IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: could not perform self call")
+debug.print: test2: (#canister_error, "IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: could not perform self call.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly")
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/trap-on-await-failure.drun-run.ok b/test/run-drun/ok/trap-on-await-failure.drun-run.ok
index 3ec84b5fb7d..e0970d9cd01 100644
--- a/test/run-drun/ok/trap-on-await-failure.drun-run.ok
+++ b/test/run-drun/ok/trap-on-await-failure.drun-run.ok
@@ -1,7 +1,9 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
 debug.print: test1:
-debug.print: test1: (#canister_error, "IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: could not perform self call")
+debug.print: test1: (#canister_error, "IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: could not perform self call.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly")
 debug.print: test2:
-debug.print: test2: (#canister_error, "IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: could not perform self call")
+debug.print: test2: (#canister_error, "IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: could not perform self call.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly")
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/trap-on-call-raw-failure.drun-run.ok b/test/run-drun/ok/trap-on-call-raw-failure.drun-run.ok
index d944cbd3e38..a9d8332e9e6 100644
--- a/test/run-drun/ok/trap-on-call-raw-failure.drun-run.ok
+++ b/test/run-drun/ok/trap-on-call-raw-failure.drun-run.ok
@@ -1,7 +1,9 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
 debug.print: test1:
-debug.print: test1: (#canister_error, "IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: could not perform raw call")
+debug.print: test1: (#canister_error, "IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: could not perform raw call.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly")
 debug.print: test2:
-debug.print: test2: (#canister_error, "IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: could not perform raw call")
+debug.print: test2: (#canister_error, "IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: could not perform raw call.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly")
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/trap-on-local-failure.drun-run.ok b/test/run-drun/ok/trap-on-local-failure.drun-run.ok
index 3ec84b5fb7d..e0970d9cd01 100644
--- a/test/run-drun/ok/trap-on-local-failure.drun-run.ok
+++ b/test/run-drun/ok/trap-on-local-failure.drun-run.ok
@@ -1,7 +1,9 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
 debug.print: test1:
-debug.print: test1: (#canister_error, "IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: could not perform self call")
+debug.print: test1: (#canister_error, "IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: could not perform self call.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly")
 debug.print: test2:
-debug.print: test2: (#canister_error, "IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: could not perform self call")
+debug.print: test2: (#canister_error, "IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: could not perform self call.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly")
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/trap-on-send-failure.drun-run.ok b/test/run-drun/ok/trap-on-send-failure.drun-run.ok
index f3d0b9a517c..8aa23a39118 100644
--- a/test/run-drun/ok/trap-on-send-failure.drun-run.ok
+++ b/test/run-drun/ok/trap-on-send-failure.drun-run.ok
@@ -1,7 +1,9 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
 debug.print: test1:
-debug.print: test1: (#canister_error, "IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: could not perform remote call")
+debug.print: test1: (#canister_error, "IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: could not perform remote call.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly")
 debug.print: test2:
-debug.print: test2: (#canister_error, "IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: could not perform remote call")
+debug.print: test2: (#canister_error, "IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: could not perform remote call.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly")
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/try-finally-trap-stop.drun-run.ok b/test/run-drun/ok/try-finally-trap-stop.drun-run.ok
index 4c4e1f684ba..315e50d1606 100644
--- a/test/run-drun/ok/try-finally-trap-stop.drun-run.ok
+++ b/test/run-drun/ok/try-finally-trap-stop.drun-run.ok
@@ -5,7 +5,8 @@ debug.print: trap in finally!
 debug.print: trap in finally!
 debug.print: {rts_callback_table_count = 1}
 debug.print: canister running
-debug.print: Canister rrkah-fqaaa-aaaaa-aaaaq-cai trapped explicitly: canister_pre_upgrade attempted with outstanding message callbacks (try stopping the canister before upgrade)
+debug.print: Error from Canister rrkah-fqaaa-aaaaa-aaaaq-cai: Canister called `ic0.trap` with message: canister_pre_upgrade attempted with outstanding message callbacks (try stopping the canister before upgrade).
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: canister stopped
 debug.print: canister upgraded
 debug.print: {rts_callback_table_count = 0}
diff --git a/test/run-drun/ok/try-finally-trap.drun.ok b/test/run-drun/ok/try-finally-trap.drun.ok
index 721b03b1999..80205580c08 100644
--- a/test/run-drun/ok/try-finally-trap.drun.ok
+++ b/test/run-drun/ok/try-finally-trap.drun.ok
@@ -2,13 +2,14 @@ ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a000000000000000001
 ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
 debug.print: trap in finally!
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: assertion failed at try-finally-trap.mo:8.7-8.19
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: assertion failed at try-finally-trap.mo:8.7-8.19
 
 call_on_cleanup also failed:
 
-Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: assertion failed at try-finally-trap.mo:12.7-12.19
+Canister called `ic0.trap` with message: assertion failed at try-finally-trap.mo:12.7-12.19
 debug.print: {rts_callback_table_count = 1}
 ingress Completed: Reply: 0x4449444c0000
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: canister_pre_upgrade attempted with outstanding message callbacks (try stopping the canister before upgrade)
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: canister_pre_upgrade attempted with outstanding message callbacks (try stopping the canister before upgrade).
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: {rts_callback_table_count = 1}
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/try-finally.drun-run.ok b/test/run-drun/ok/try-finally.drun-run.ok
index 38c1da2134d..6b78c6f9228 100644
--- a/test/run-drun/ok/try-finally.drun-run.ok
+++ b/test/run-drun/ok/try-finally.drun-run.ok
@@ -93,8 +93,10 @@ debug.print: InnerIN8t
 debug.print: OUT8t
 debug.print: OTHER SIDE
 debug.print: OTHER SIDE: CLEANING UP
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: assertion failed at try-finally.mo:324.17-324.29
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: assertion failed at try-finally.mo:330.25-330.41
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: assertion failed at try-finally.mo:324.17-324.29.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: assertion failed at try-finally.mo:330.25-330.41.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: OUTER CAUGHT: foo
 debug.print: BEFORE7
 debug.print: IN7
@@ -104,7 +106,9 @@ debug.print: InnerLIVESTILL7
 debug.print: InnerOUT7
 debug.print: OUT7
 debug.print: It's over
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: assertion failed at try-finally.mo:238.17-238.29
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: assertion failed at try-finally.mo:238.17-238.29.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: go2
 debug.print: It's so over
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: assertion failed at try-finally.mo:350.13-350.25
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: assertion failed at try-finally.mo:350.13-350.25.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/tuple-record-mismatch.drun.ok b/test/run-drun/ok/tuple-record-mismatch.drun.ok
index c46182ff707..e565700968b 100644
--- a/test/run-drun/ok/tuple-record-mismatch.drun.ok
+++ b/test/run-drun/ok/tuple-record-mismatch.drun.ok
@@ -1,5 +1,7 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/tuple-stabilization.drun.ok b/test/run-drun/ok/tuple-stabilization.drun.ok
new file mode 100644
index 00000000000..ba49d013d91
--- /dev/null
+++ b/test/run-drun/ok/tuple-stabilization.drun.ok
@@ -0,0 +1,50 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+debug.print: (1, 2)
+debug.print: (0, "Test", 1.230000, {key = 5; value = '_'}, [-1, +2, -3])
+debug.print: ?(2, ?(1, null, null), ?(4, ?(3, null, null), ?(5, null, null)))
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: (1, 2)
+debug.print: (0, "Test", 1.230000, {key = 5; value = '_'}, [-1, +2, -3])
+debug.print: ?(2, ?(1, null, null), ?(4, ?(3, null, null), ?(5, null, null)))
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: ()
+debug.print: (1, 2)
+debug.print: (0, "Test", 1.230000, {key = 5; value = '_'}, [-1, +2, -3])
+debug.print: ?(2, ?(1, null, null), ?(4, ?(3, null, null), ?(5, null, null)))
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: ()
+debug.print: (1, 2)
+debug.print: (0, "Test", 1.230000, {key = 5; value = '_'}, [-1, +2, -3])
+debug.print: ?(2, ?(1, null, null), ?(4, ?(3, null, null), ?(5, null, null)))
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Completed: Reply: 0x4449444c0000
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: (1, 2)
+debug.print: (0, "Test", 1.230000, {key = 5; value = '_'}, [-1, +2, -3])
+debug.print: ?(2, ?(1, null, null), ?(4, ?(3, null, null), ?(5, null, null)))
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: (1, 2)
+debug.print: (0, "Test", 1.230000, {key = 5; value = '_'}, [-1, +2, -3])
+debug.print: ?(2, ?(1, null, null), ?(4, ?(3, null, null), ?(5, null, null)))
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/tuple-upgrades.drun.ok b/test/run-drun/ok/tuple-upgrades.drun.ok
index b154425ced1..53462fc28d1 100644
--- a/test/run-drun/ok/tuple-upgrades.drun.ok
+++ b/test/run-drun/ok/tuple-upgrades.drun.ok
@@ -21,10 +21,14 @@ debug.print: (1, 2)
 debug.print: (0, "Test", 1.230000, {key = 5; value = '_'}, [-1, +2, -3])
 debug.print: ?(2, ?(1, null, null), ?(4, ?(3, null, null), ?(5, null, null)))
 ingress Completed: Reply: 0x4449444c0000
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 ingress Completed: Reply: 0x4449444c0000
 debug.print: (1, 2)
 debug.print: (0, "Test", 1.230000, {key = 5; value = '_'}, [-1, +2, -3])
diff --git a/test/run-drun/ok/upgrade-bignat-bigint.drun.ok b/test/run-drun/ok/upgrade-bignat-bigint.drun.ok
index be20fcc0751..7c4347a98de 100644
--- a/test/run-drun/ok/upgrade-bignat-bigint.drun.ok
+++ b/test/run-drun/ok/upgrade-bignat-bigint.drun.ok
@@ -15,4 +15,5 @@ ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
 debug.print: +12_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_888
 ingress Completed: Reply: 0x4449444c0000
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/upgrade-bignums.drun-run.ok b/test/run-drun/ok/upgrade-bignums.drun-run.ok
new file mode 100644
index 00000000000..c2ad671724d
--- /dev/null
+++ b/test/run-drun/ok/upgrade-bignums.drun-run.ok
@@ -0,0 +1,15 @@
+ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 12_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890
+debug.print: -12_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 24_691_357_802_469_135_780_246_913_578_024_691_357_802_469_135_780_246_913_578_024_691_357_802_469_135_781
+debug.print: -24_691_357_802_469_135_780_246_913_578_024_691_357_802_469_135_780_246_913_578_024_691_357_802_469_135_781
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+ingress Completed: Reply: 0x4449444c0000
+debug.print: 49_382_715_604_938_271_560_493_827_156_049_382_715_604_938_271_560_493_827_156_049_382_715_604_938_271_563
+debug.print: -49_382_715_604_938_271_560_493_827_156_049_382_715_604_938_271_560_493_827_156_049_382_715_604_938_271_563
+ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/upgrade-generics.drun.ok b/test/run-drun/ok/upgrade-generics.drun.ok
index 136ec2202df..a0fb0b59e0b 100644
--- a/test/run-drun/ok/upgrade-generics.drun.ok
+++ b/test/run-drun/ok/upgrade-generics.drun.ok
@@ -11,7 +11,8 @@ ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
 debug.print: (([0], [+1]), true)
 ingress Completed: Reply: 0x4449444c0000
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 ingress Completed: Reply: 0x4449444c0000
 debug.print: (([0], [+1]), true)
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/upgrade-mutable-array.drun.ok b/test/run-drun/ok/upgrade-mutable-array.drun.ok
index 4c7859d1354..5bcd7316c48 100644
--- a/test/run-drun/ok/upgrade-mutable-array.drun.ok
+++ b/test/run-drun/ok/upgrade-mutable-array.drun.ok
@@ -7,7 +7,8 @@ debug.print: firstField=0
 debug.print: secondField=0
 debug.print: thirdField=0
 ingress Completed: Reply: 0x4449444c0000
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: firstField=0
 debug.print: secondField=0
 debug.print: thirdField=0
diff --git a/test/run-drun/ok/upgrade-mutable-service.drun.ok b/test/run-drun/ok/upgrade-mutable-service.drun.ok
index 45933d721fe..2bcb96f77bf 100644
--- a/test/run-drun/ok/upgrade-mutable-service.drun.ok
+++ b/test/run-drun/ok/upgrade-mutable-service.drun.ok
@@ -20,7 +20,8 @@ debug.print: original test1
 debug.print: original test2
 debug.print: original test3
 ingress Completed: Reply: 0x4449444c0000
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 ingress Completed: Reply: 0x4449444c0000
 debug.print: original test0
 debug.print: original test1
diff --git a/test/run-drun/ok/upgrade-mutable-variant.drun.ok b/test/run-drun/ok/upgrade-mutable-variant.drun.ok
index 09d407cb897..b59108bd8c2 100644
--- a/test/run-drun/ok/upgrade-mutable-variant.drun.ok
+++ b/test/run-drun/ok/upgrade-mutable-variant.drun.ok
@@ -3,7 +3,8 @@ ingress Completed: Reply: 0x4449444c0000
 debug.print: instance=[var #Option1]
 debug.print: alias=[var #Option1]
 ingress Completed: Reply: 0x4449444c0000
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: instance=[var #Option1]
 debug.print: alias=[var #Option1]
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/upgrade-mutable.drun.ok b/test/run-drun/ok/upgrade-mutable.drun.ok
index 160a60b06d0..ef90288ad93 100644
--- a/test/run-drun/ok/upgrade-mutable.drun.ok
+++ b/test/run-drun/ok/upgrade-mutable.drun.ok
@@ -9,4 +9,5 @@ ingress Completed: Reply: 0x4449444c0000
 debug.print: [var {key = 2; value = "2"}]
 debug.print: [var {key = 2; value = "2"}]
 ingress Completed: Reply: 0x4449444c0000
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/upgrade-nat-to-int.drun.ok b/test/run-drun/ok/upgrade-nat-to-int.drun.ok
index 481c689f56d..f5d7ac918e7 100644
--- a/test/run-drun/ok/upgrade-nat-to-int.drun.ok
+++ b/test/run-drun/ok/upgrade-nat-to-int.drun.ok
@@ -15,4 +15,5 @@ ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
 debug.print: -2
 ingress Completed: Reply: 0x4449444c0000
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/upgrade-non-stable.drun.ok b/test/run-drun/ok/upgrade-non-stable.drun.ok
index ce9825f8ad1..26f680be00a 100644
--- a/test/run-drun/ok/upgrade-non-stable.drun.ok
+++ b/test/run-drun/ok/upgrade-non-stable.drun.ok
@@ -11,4 +11,5 @@ ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
 debug.print: {}
 ingress Completed: Reply: 0x4449444c0000
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/upgrade-recursive-type.drun.ok b/test/run-drun/ok/upgrade-recursive-type.drun.ok
index c1bfca7bfc9..f577925ce09 100644
--- a/test/run-drun/ok/upgrade-recursive-type.drun.ok
+++ b/test/run-drun/ok/upgrade-recursive-type.drun.ok
@@ -7,11 +7,13 @@ ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
 debug.print: CHECK 2
 ingress Completed: Reply: 0x4449444c0000
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 ingress Completed: Reply: 0x4449444c0000
 debug.print: CHECK 3
 ingress Completed: Reply: 0x4449444c0000
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 ingress Completed: Reply: 0x4449444c0000
 debug.print: CHECK 4
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/upgrade-remove-add-fields.drun.ok b/test/run-drun/ok/upgrade-remove-add-fields.drun.ok
index e95999ccf86..21a27f7116b 100644
--- a/test/run-drun/ok/upgrade-remove-add-fields.drun.ok
+++ b/test/run-drun/ok/upgrade-remove-add-fields.drun.ok
@@ -19,11 +19,13 @@ ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
 debug.print: secondField=4
 ingress Completed: Reply: 0x4449444c0000
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 ingress Completed: Reply: 0x4449444c0000
 debug.print: secondField=5
 ingress Completed: Reply: 0x4449444c0000
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 ingress Completed: Reply: 0x4449444c0000
 debug.print: secondField=6
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/upgrade-service.drun.ok b/test/run-drun/ok/upgrade-service.drun.ok
index 9706bca1b6f..263e8d433d8 100644
--- a/test/run-drun/ok/upgrade-service.drun.ok
+++ b/test/run-drun/ok/upgrade-service.drun.ok
@@ -15,6 +15,7 @@ ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
 debug.print: reduced test1
 ingress Completed: Reply: 0x4449444c0000
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 debug.print: reduced test1
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/ok/variant-upgrades.drun.ok b/test/run-drun/ok/variant-upgrades.drun.ok
index cd317ed4b8d..7ed13fc3fa3 100644
--- a/test/run-drun/ok/variant-upgrades.drun.ok
+++ b/test/run-drun/ok/variant-upgrades.drun.ok
@@ -15,5 +15,7 @@ ingress Completed: Reply: 0x4449444c0000
 ingress Completed: Reply: 0x4449444c0000
 debug.print: #two({key = 1; name = "TEST TEST TEST TEST TEST"})
 ingress Completed: Reply: 0x4449444c0000
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
-ingress Err: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: RTS error: Memory-incompatible program upgrade
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
+ingress Err: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: RTS error: Memory-incompatible program upgrade.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
diff --git a/test/run-drun/ok/vec-any-bomb.drun-run.ok b/test/run-drun/ok/vec-any-bomb.drun-run.ok
index 9b1905ecaaa..83ddcd511ed 100644
--- a/test/run-drun/ok/vec-any-bomb.drun-run.ok
+++ b/test/run-drun/ok/vec-any-bomb.drun-run.ok
@@ -1,4 +1,5 @@
 ingress Completed: Reply: 0x4449444c016c01b3c4b1f204680100010a00000000000000000101
 ingress Completed: Reply: 0x4449444c0000
-debug.print: IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: IDL error: exceeded value limit
+debug.print: IC0503: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister called `ic0.trap` with message: IDL error: exceeded value limit.
+Consider gracefully handling failures from this canister or altering the canister to handle exceptions. See documentation: http://internetcomputer.org/docs/current/references/execution-errors#trapped-explicitly
 ingress Completed: Reply: 0x4449444c0000
diff --git a/test/run-drun/oneshot-callbacks.mo b/test/run-drun/oneshot-callbacks.mo
index b75366aab04..20e9a149717 100644
--- a/test/run-drun/oneshot-callbacks.mo
+++ b/test/run-drun/oneshot-callbacks.mo
@@ -1,3 +1,4 @@
+//MOC-NO-FORCE-GC
 import Prim "mo:⛔";
 
 actor a {
diff --git a/test/run-drun/query-footprint-overflow.mo b/test/run-drun/query-footprint-overflow.mo
index 195c5f19def..9f8017eee1a 100644
--- a/test/run-drun/query-footprint-overflow.mo
+++ b/test/run-drun/query-footprint-overflow.mo
@@ -1,3 +1,4 @@
+//CLASSICAL-PERSISTENCE-ONLY
 import { Array_tabulate; stableVarQuery } = "mo:⛔"
 
 actor footprint = {
diff --git a/test/run-drun/query-footprint.mo b/test/run-drun/query-footprint.mo
index 9836dd4a7b5..0331b086f4f 100644
--- a/test/run-drun/query-footprint.mo
+++ b/test/run-drun/query-footprint.mo
@@ -1,3 +1,4 @@
+//CLASSICAL-PERSISTENCE-ONLY
 import { stableVarQuery } "mo:⛔";
 
 actor footprint = {
diff --git a/test/run-drun/region0-rts-stats.mo b/test/run-drun/region0-rts-stats.mo
index 8224f9123c8..a61d07291fc 100644
--- a/test/run-drun/region0-rts-stats.mo
+++ b/test/run-drun/region0-rts-stats.mo
@@ -4,7 +4,9 @@ import StableMemory "stable-mem/StableMemory";
 actor {
   let s1 = P.rts_stable_memory_size();
   let l1 = P.rts_logical_stable_memory_size();
-  P.debugPrint (debug_show({s1;l1}));
+  assert (s1 == 6 or s1 == 145 or s1 == 146);
+  assert (l1 == 6 or l1 == 144);
+  P.debugPrint ("Ignore Diff: "# debug_show({s1;l1}));
   let 0 = StableMemory.grow(16);
   stable var v = StableMemory.loadBlob(0, 65536);
   let s2 = P.rts_stable_memory_size();
diff --git a/test/run-drun/rts-stats.mo b/test/run-drun/rts-stats.mo
index 3290a5654c8..57d7a0cb891 100644
--- a/test/run-drun/rts-stats.mo
+++ b/test/run-drun/rts-stats.mo
@@ -9,9 +9,9 @@ let a1 = Prim.rts_total_allocation();
 // Prim.debugPrint("Size and allocation before: " # debug_show (s0, a0));
 // Prim.debugPrint("Size and allocation after:  " # debug_show (s1, a1));
 
-// Differences between incremental and non-incremental GC (additional forwarding header field)
-assert (+s1-s0 == 10008 or +s1-s0 == 10012);
-assert (+a1-a0 == 10008 or +a1-a0 == 10012);
+// Differences between classical persistence (incremental and non-incremental GC) and enhanced orthogonal persistence:
+assert (+s1-s0 == 10008 or +s1-s0 == 10012 or +s1-s0 == 20024);
+assert (+a1-a0 == 10008 or +a1-a0 == 10012 or +a1-a0 == 20024);
 
 assert(Prim.rts_memory_size() > Prim.rts_heap_size());
 
diff --git a/test/run-drun/rts-stats2.mo b/test/run-drun/rts-stats2-classical.mo
similarity index 96%
rename from test/run-drun/rts-stats2.mo
rename to test/run-drun/rts-stats2-classical.mo
index 6c6c9922918..d6d2829ba21 100644
--- a/test/run-drun/rts-stats2.mo
+++ b/test/run-drun/rts-stats2-classical.mo
@@ -1,3 +1,4 @@
+//CLASSICAL-PERSISTENCE-ONLY
 import Prim "mo:⛔";
 actor a {
   func runGC(): async() {
@@ -51,4 +52,4 @@ actor a {
 //CALL ingress check_A "DIDL\x00\x00"
 //CALL ingress bar "DIDL\x00\x00"
 //CALL ingress check_B "DIDL\x00\x00"
-//CALL ingress check_B "DIDL\x00\x00"
+//CALL ingress check_B "DIDL\x00\x00"
\ No newline at end of file
diff --git a/test/run-drun/rts-stats2-enhanced.mo b/test/run-drun/rts-stats2-enhanced.mo
new file mode 100644
index 00000000000..719a291e3f8
--- /dev/null
+++ b/test/run-drun/rts-stats2-enhanced.mo
@@ -0,0 +1,55 @@
+//ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+import Prim "mo:⛔";
+actor a {
+  func runGC(): async() {
+    var count = 0;
+    // run multiple GC increments for the incremental GC
+    while (count < 3) {
+      await async();
+      count += 1;
+    }
+  };
+
+  let length = 8 * 1024 * 1024; 
+  public func foo(): async() {
+    ignore(Prim.Array_init<()>(length, ())); 
+    await runGC();
+  };
+  public func check_A() {
+    Prim.debugPrint("Ignore Diff: Reclaimed: " # debug_show Prim.rts_reclaimed());
+    assert (Prim.rts_reclaimed() > 8 * length);
+    // Generational GC has additional remembered set that is discarded on each GC run
+    // Debug mode for generational GC also produces additional memory snapshots for sanity checks
+    assert (Prim.rts_reclaimed() < 10 * length);
+
+    Prim.debugPrint("Ignore Diff: Live size: " # debug_show Prim.rts_max_live_size());
+    assert (Prim.rts_max_live_size() < 500_000);
+  };
+  flexible var v : [var ()] = [var];
+  public func bar(): async() {
+    v := Prim.Array_init<()>(length, ()); // larger amount to trigger incremental GC
+    await runGC();
+  };
+  public func check_B() {
+    Prim.debugPrint("Ignore Diff: Reclaimed: " # debug_show Prim.rts_reclaimed());
+    assert (Prim.rts_reclaimed() > 8 * length);
+    // Generational GC has additional remembered set that is discarded on each GC run
+    // Debug mode for generational GC also produces additional memory snapshots for sanity checks
+    assert (Prim.rts_reclaimed() < 16 * length);
+
+    Prim.debugPrint("Ignore Diff: Live size: " # debug_show Prim.rts_max_live_size());
+    assert (Prim.rts_max_live_size() > 8 * length);
+    assert (Prim.rts_max_live_size() < 10 * length);
+  };
+}
+// no point running these in the interpreter
+//SKIP run
+//SKIP run-low
+//SKIP run-ir
+
+//CALL ingress foo "DIDL\x00\x00"
+//CALL ingress check_A "DIDL\x00\x00"
+//CALL ingress check_A "DIDL\x00\x00"
+//CALL ingress bar "DIDL\x00\x00"
+//CALL ingress check_B "DIDL\x00\x00"
+//CALL ingress check_B "DIDL\x00\x00"
diff --git a/test/run-drun/runtime-info.mo b/test/run-drun/runtime-info.mo
index 4fcf8c4f389..eb139d8da83 100644
--- a/test/run-drun/runtime-info.mo
+++ b/test/run-drun/runtime-info.mo
@@ -10,7 +10,7 @@ actor Self {
     };
 
     func validGC(strategy : Text) : Bool {
-        for (name in ["copying", "compacting", "generational", "incremental"].vals()) {
+        for (name in ["copying", "compacting", "generational", "incremental", "default"].vals()) {
             if (strategy == name # " force") {
                 return true;
             };
diff --git a/test/run-drun/stabilization-authorization.mo b/test/run-drun/stabilization-authorization.mo
new file mode 100644
index 00000000000..f63a46c2e26
--- /dev/null
+++ b/test/run-drun/stabilization-authorization.mo
@@ -0,0 +1,43 @@
+//ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+//MOC-FLAG --stabilization-instruction-limit=10000
+
+import Prim "mo:⛔";
+import Cycles = "cycles/cycles";
+import UpgradeTarget "stabilization-authorization/upgrade-target";
+import AccessTester "stabilization-authorization/access-tester";
+
+actor a {
+  type IncrementalStabilization = actor {
+    __motoko_stabilize_before_upgrade : () -> async ();
+    __motoko_destabilize_after_upgrade : () -> async ();
+  };
+
+  func useIncrementalStabilization(a : actor {}) : IncrementalStabilization {
+    actor (debug_show (Prim.principalOfActor(a))) : IncrementalStabilization;
+  };
+
+  public func run() : async () {
+    if (Cycles.balance() == 0) {
+      await Cycles.provisional_top_up_actor(a, 100_000_000_000_000);
+    };
+
+    Cycles.add<system>(2_000_000_000_000);
+    let upgradeTarget = await UpgradeTarget.UpgradeTarget();
+    let testStabilization = useIncrementalStabilization(upgradeTarget);
+
+    Cycles.add<system>(2_000_000_000_000);
+    let accessTester = await AccessTester.AccessTester(testStabilization);
+    await accessTester.test();
+
+    Prim.debugPrint("Test upgrade");
+    await testStabilization.__motoko_stabilize_before_upgrade();
+    ignore await (system UpgradeTarget.UpgradeTarget)(#upgrade upgradeTarget)();
+
+    await accessTester.test();
+  };
+};
+
+//CALL ingress run "DIDL\x00\x00"
+//SKIP run
+//SKIP run-ir
+//SKIP run-low
diff --git a/test/run-drun/stabilization-authorization/access-tester.mo b/test/run-drun/stabilization-authorization/access-tester.mo
new file mode 100644
index 00000000000..d74d7671d34
--- /dev/null
+++ b/test/run-drun/stabilization-authorization/access-tester.mo
@@ -0,0 +1,23 @@
+import Prim "mo:⛔";
+
+actor class AccessTester(
+    other : actor {
+        __motoko_stabilize_before_upgrade : () -> async ();
+        __motoko_destabilize_after_upgrade : () -> async ();
+    }
+) {
+    public func test() : async () {
+        Prim.debugPrint("Test __motoko_stabilize_before_upgrade");
+        try {
+            await other.__motoko_stabilize_before_upgrade();
+        } catch (e) {
+            Prim.debugPrint(Prim.errorMessage(e));
+        };
+        try {
+            Prim.debugPrint("Test __motoko_stabilize_after_upgrade");
+            await other.__motoko_destabilize_after_upgrade();
+        } catch (e) {
+            Prim.debugPrint(Prim.errorMessage(e));
+        };
+    };
+};
diff --git a/test/run-drun/stabilization-authorization/upgrade-target.mo b/test/run-drun/stabilization-authorization/upgrade-target.mo
new file mode 100644
index 00000000000..ab617d92a52
--- /dev/null
+++ b/test/run-drun/stabilization-authorization/upgrade-target.mo
@@ -0,0 +1,13 @@
+import Prim "mo:⛔";
+
+actor class UpgradeTarget() {
+  stable var _stableArray = Prim.Array_tabulate<Nat>(100_000, func(index) { index });
+
+  system func preupgrade() {
+    Prim.debugPrint("PRE-UPGRADE HOOK!");
+  };
+
+  system func postupgrade() {
+    Prim.debugPrint("POST-UPGRADE HOOK!");
+  };
+};
diff --git a/test/run-drun/stabilization-instructions.mo b/test/run-drun/stabilization-instructions.mo
new file mode 100644
index 00000000000..b028ac44f16
--- /dev/null
+++ b/test/run-drun/stabilization-instructions.mo
@@ -0,0 +1,44 @@
+//ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+import Prim "mo:prim";
+
+actor {
+  stable var lastInstructions = 0;
+  stable var length = 0;
+  stable var stableArray : [Nat] = [];
+
+  if (length > 0) {
+    assert (Prim.rts_upgrade_instructions() >= lastInstructions);
+    lastInstructions := Prim.rts_upgrade_instructions();
+    assert(lastInstructions > 0);
+  };
+  Prim.debugPrint("Ignore Diff: Upgrade instructions: " # debug_show (Prim.rts_upgrade_instructions()));
+
+  public func increase() : async () {
+    if (length == 0) {
+      length := 1_000;
+    } else {
+      length *= 10;
+    };
+    let newArray = Prim.Array_tabulate<Nat>(
+      length,
+      func(index) {
+        index * index;
+      },
+    );
+    stableArray := newArray;
+  };
+};
+
+//SKIP run
+//SKIP run-ir
+//SKIP run-low
+
+//CALL ingress increase "DIDL\x00\x00"
+//CALL ingress __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+//CALL upgrade ""
+//CALL ingress increase "DIDL\x00\x00"
+//CALL ingress __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+//CALL upgrade ""
+//CALL ingress increase "DIDL\x00\x00"
+//CALL ingress __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+//CALL upgrade ""
diff --git a/test/run-drun/stabilization-upgrade-hooks.drun b/test/run-drun/stabilization-upgrade-hooks.drun
new file mode 100644
index 00000000000..498d17c7543
--- /dev/null
+++ b/test/run-drun/stabilization-upgrade-hooks.drun
@@ -0,0 +1,18 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+install $ID stabilization-upgrade-hooks/upgrade-hook.mo ""
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilization-upgrade-hooks/upgrade-hook0.mo ""
+query $ID check "DIDL\x00\x01\x7d\x01"
+ingress $ID inc "DIDL\x00\x00"
+query $ID check "DIDL\x00\x01\x7d\x02"
+ingress $ID inc "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilization-upgrade-hooks/upgrade-hook1.mo ""
+query $ID check "DIDL\x00\x01\x7d\x03"
+ingress $ID inc "DIDL\x00\x00"
+query $ID check "DIDL\x00\x01\x7d\x04"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilization-upgrade-hooks/upgrade-hook2.mo ""
+query $ID check "DIDL\x00\x01\x7d\x04"
+ingress $ID inc "DIDL\x00\x00"
+query $ID check "DIDL\x00\x01\x7d\x05"
diff --git a/test/run-drun/stabilization-upgrade-hooks/upgrade-hook.mo b/test/run-drun/stabilization-upgrade-hooks/upgrade-hook.mo
new file mode 100644
index 00000000000..9ac1aee64a2
--- /dev/null
+++ b/test/run-drun/stabilization-upgrade-hooks/upgrade-hook.mo
@@ -0,0 +1,4 @@
+import Prim "mo:⛔";
+actor {
+  Prim.debugPrint ("init'ed");
+}
diff --git a/test/run-drun/stabilization-upgrade-hooks/upgrade-hook0.mo b/test/run-drun/stabilization-upgrade-hooks/upgrade-hook0.mo
new file mode 100644
index 00000000000..288c2b0ced6
--- /dev/null
+++ b/test/run-drun/stabilization-upgrade-hooks/upgrade-hook0.mo
@@ -0,0 +1,20 @@
+import Prim "mo:⛔";
+actor {
+  Prim.debugPrint ("init'ed 0");
+  stable var c = "a";
+  var d = c; // unstable cached state
+  public func inc() { d #= "a"; };
+  public query func check(n : Int) : async () {
+    Prim.debugPrint(d);
+    assert (d.size() == n);
+  };
+  system func preupgrade(){
+    Prim.debugPrint("preupgrade 0");
+    c := d;
+  };
+  system func postupgrade(){
+    Prim.debugPrint("postupgrade 0");
+    d := c;
+  };
+}
+
diff --git a/test/run-drun/stabilization-upgrade-hooks/upgrade-hook1.mo b/test/run-drun/stabilization-upgrade-hooks/upgrade-hook1.mo
new file mode 100644
index 00000000000..b930003ed11
--- /dev/null
+++ b/test/run-drun/stabilization-upgrade-hooks/upgrade-hook1.mo
@@ -0,0 +1,25 @@
+import Prim "mo:⛔";
+actor {
+  Prim.debugPrint ("init'ed 1");
+  stable let c = "a";
+  stable var i : Nat = c.size();
+  var j = 0; // unstable cached state
+  public func inc() { j += 1; };
+  public query func check(n : Int) : async () {
+    Prim.debugPrintNat(j);
+    Prim.debugPrint(c);
+    assert (j == n);
+    assert (c.size() == 3);
+    assert (c.size() <= j);
+  };
+  system func preupgrade(){
+    Prim.debugPrint("preupgrade 1");
+    i := j; // save cache
+  };
+  system func postupgrade(){
+    j := i; // restore cache
+    Prim.debugPrint("postupgrade 1");
+  };
+
+}
+
diff --git a/test/run-drun/stabilization-upgrade-hooks/upgrade-hook2.mo b/test/run-drun/stabilization-upgrade-hooks/upgrade-hook2.mo
new file mode 100644
index 00000000000..980b5ae35a9
--- /dev/null
+++ b/test/run-drun/stabilization-upgrade-hooks/upgrade-hook2.mo
@@ -0,0 +1,21 @@
+import Prim "mo:⛔";
+actor {
+  Prim.debugPrint ("init'ed 2");
+  stable let c : Text = do { assert false; loop {}};
+  stable var i : Nat = do { assert false; loop {}};
+  var j = i; // cached state
+  public func inc() { j += 1; };
+  public query func check(n : Int) : async () {
+    assert (c.size() == 3);
+    assert (j == n);
+  };
+  system func preupgrade(){
+    Prim.debugPrint("preupgrade 2");
+    i := j; // save cache
+  };
+  system func postupgrade(){
+    Prim.debugPrint("postupgrade 2");
+    j := i; // restore cache
+  };
+
+}
diff --git a/test/run-drun/stabilize-beyond-stable-limit.mo b/test/run-drun/stabilize-beyond-stable-limit.mo
new file mode 100644
index 00000000000..a6eb9b42cdc
--- /dev/null
+++ b/test/run-drun/stabilize-beyond-stable-limit.mo
@@ -0,0 +1,46 @@
+//ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+//MOC-FLAG --stabilization-instruction-limit=100000 --max-stable-pages 16
+
+// This test fails because the stabilization code is using virtual stablemem_grow, which caps growth to max-stable-pages (default is 65536, but lowered below). It should be using physical ic0_stable64_grow (and _size) instead.
+
+// Unfixed, the bug would prevent a user relying on defaults from serializing more than 4GB of heap data, even in 64-bit mode.
+
+import Prim "mo:prim";
+
+actor {
+
+    let pages : Nat64 = 16;
+    if (Prim.stableMemorySize() == 0) {
+      Prim.debugPrint("growing stable memory");
+      ignore Prim.stableMemoryGrow(pages);
+    };
+    assert Prim.stableMemorySize() == pages;
+    stable let blob = Prim.stableMemoryLoadBlob(0,65536);
+
+    public func check() : async () {
+        Prim.debugPrint(debug_show (blob.size()))
+    };
+
+    system func preupgrade() {
+        Prim.debugPrint("PRE-UPGRADE HOOK!");
+    };
+
+    system func postupgrade() {
+        Prim.debugPrint("POST-UPGRADE HOOK!");
+    };
+};
+
+//CALL ingress check "DIDL\x00\x00"
+//CALL ingress __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+//CALL upgrade ""
+//CALL ingress __motoko_destabilize_after_upgrade "DIDL\x00\x00"
+//CALL ingress check "DIDL\x00\x00"
+//CALL ingress __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+//CALL upgrade ""
+//CALL ingress __motoko_destabilize_after_upgrade "DIDL\x00\x00"
+//CALL ingress check "DIDL\x00\x00"
+
+//SKIP run
+//SKIP run-ir
+//SKIP run-low
+
diff --git a/test/run-drun/stabilize-bignat-bigint.drun b/test/run-drun/stabilize-bignat-bigint.drun
new file mode 100644
index 00000000000..5cc7dda54b6
--- /dev/null
+++ b/test/run-drun/stabilize-bignat-bigint.drun
@@ -0,0 +1,31 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+# SKIP ic-ref-run
+install $ID stabilize-bignat-bigint/version0.mo ""
+ingress $ID modify "DIDL\x00\x00"
+ingress $ID print "DIDL\x00\x00"
+# Enhanced Orthogonal Persistence
+upgrade $ID stabilize-bignat-bigint/version0.mo ""
+ingress $ID modify "DIDL\x00\x00"
+ingress $ID print "DIDL\x00\x00"
+# Graph-Copy-Based Stabilization
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-bignat-bigint/version0.mo ""
+ingress $ID modify "DIDL\x00\x00"
+ingress $ID print "DIDL\x00\x00"
+# Graph-Copy-Based Stabilization
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-bignat-bigint/version1.mo ""
+ingress $ID modify "DIDL\x00\x00"
+ingress $ID print "DIDL\x00\x00"
+# Graph-Copy-Based Stabilization
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-bignat-bigint/version1.mo ""
+ingress $ID modify "DIDL\x00\x00"
+ingress $ID print "DIDL\x00\x00"
+# Enhanced Orthogonal Persistence
+upgrade $ID stabilize-bignat-bigint/version1.mo ""
+ingress $ID modify "DIDL\x00\x00"
+ingress $ID print "DIDL\x00\x00"
+# Graph-Copy-Based Stabilization
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-bignat-bigint/version0.mo ""
diff --git a/test/run-drun/stabilize-bignat-bigint/version0.mo b/test/run-drun/stabilize-bignat-bigint/version0.mo
new file mode 100644
index 00000000000..a8ad79fdf36
--- /dev/null
+++ b/test/run-drun/stabilize-bignat-bigint/version0.mo
@@ -0,0 +1,13 @@
+import Prim "mo:prim";
+
+actor {
+   stable var number : Nat = 12345678901234567890123456789012345678901234567890123456789012345678901234567890;
+
+   public func modify() : async () {
+      number += 1;
+   };
+
+   public func print() : async () {
+      Prim.debugPrint(debug_show (number));
+   };
+};
diff --git a/test/run-drun/stabilize-bignat-bigint/version1.mo b/test/run-drun/stabilize-bignat-bigint/version1.mo
new file mode 100644
index 00000000000..c7afbe089ff
--- /dev/null
+++ b/test/run-drun/stabilize-bignat-bigint/version1.mo
@@ -0,0 +1,13 @@
+import Prim "mo:prim";
+
+actor {
+   stable var number : Int = -1;
+
+   public func modify() : async () {
+      number -= 2;
+   };
+
+   public func print() : async () {
+      Prim.debugPrint(debug_show (number));
+   };
+};
diff --git a/test/run-drun/stabilize-bignums.mo b/test/run-drun/stabilize-bignums.mo
new file mode 100644
index 00000000000..266d96468cd
--- /dev/null
+++ b/test/run-drun/stabilize-bignums.mo
@@ -0,0 +1,36 @@
+//ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+//MOC-FLAG --stabilization-instruction-limit=10000
+import Prim "mo:prim";
+
+actor {
+    stable var unsigned : Nat = 12345678901234567890123456789012345678901234567890123456789012345678901234567890;
+    stable var signed : Int = -12345678901234567890123456789012345678901234567890123456789012345678901234567890;
+
+    public func modify() : async () {
+        unsigned := 2 * unsigned + 1;
+        signed := 2 * signed - 1;
+    };
+
+    public func print() : async () {
+        Prim.debugPrint(debug_show (unsigned));
+        Prim.debugPrint(debug_show (signed));
+    };
+};
+
+//CALL ingress print "DIDL\x00\x00"
+//CALL ingress modify "DIDL\x00\x00"
+//CALL ingress __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+//CALL upgrade ""
+//CALL ingress __motoko_destabilize_after_upgrade "DIDL\x00\x00"
+//CALL ingress print "DIDL\x00\x00"
+//CALL ingress modify "DIDL\x00\x00"
+//CALL ingress __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+//CALL upgrade ""
+//CALL ingress __motoko_destabilize_after_upgrade "DIDL\x00\x00"
+//CALL ingress print "DIDL\x00\x00"
+//CALL upgrade ""
+//CALL ingress print "DIDL\x00\x00"
+//CALL ingress __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+//CALL upgrade ""
+//CALL ingress __motoko_destabilize_after_upgrade "DIDL\x00\x00"
+//CALL ingress print "DIDL\x00\x00"
diff --git a/test/run-drun/stabilize-blob-iter.drun b/test/run-drun/stabilize-blob-iter.drun
new file mode 100644
index 00000000000..91a66b3d918
--- /dev/null
+++ b/test/run-drun/stabilize-blob-iter.drun
@@ -0,0 +1,16 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+# SKIP ic-ref-run
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+install $ID stabilize-blob-iter/version0.mo ""
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-blob-iter/version0.mo ""
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-blob-iter/version1.mo ""
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-blob-iter/version1.mo ""
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-blob-iter/version0.mo ""
diff --git a/test/run-drun/stabilize-blob-iter/version0.mo b/test/run-drun/stabilize-blob-iter/version0.mo
new file mode 100644
index 00000000000..68bcb70a02c
--- /dev/null
+++ b/test/run-drun/stabilize-blob-iter/version0.mo
@@ -0,0 +1,27 @@
+import Prim "mo:prim";
+
+actor {
+  let temporary = 1;
+
+  let blobiter = ("hello" : Blob).vals();
+
+  stable let value : {
+    stableField : Text;
+  } = {
+    stableField = "Version 0";
+    nonStableField = blobiter;
+    unreachableField = -123;
+  };
+
+  stable let any : Any = blobiter;
+  stable let tuple : (Int, Any) = (0, blobiter);
+  stable let variant : { #tag : Any } = #tag blobiter;
+  stable let record : { lab : Any } = { lab = blobiter };
+  stable let vector : [Any] = [blobiter];
+  stable let array : [var Any] = [var blobiter];
+  stable let opt : ?Any = ?blobiter;
+
+  public func print() : async () {
+    Prim.debugPrint(debug_show (value));
+  };
+};
diff --git a/test/run-drun/stabilize-blob-iter/version1.mo b/test/run-drun/stabilize-blob-iter/version1.mo
new file mode 100644
index 00000000000..38770680751
--- /dev/null
+++ b/test/run-drun/stabilize-blob-iter/version1.mo
@@ -0,0 +1,19 @@
+import Prim "mo:prim";
+
+actor {
+  stable let value : {} = {
+    stableField = "Version 1";
+  };
+
+  stable let any : Any = null;
+  stable let tuple : (Int, Any) = (0, null);
+  stable let variant : { #tag : Any } = #tag null;
+  stable let record : { lab : Any } = { lab = null };
+  stable let vector : [Any] = [null];
+  stable let array : [var Any] = [var null];
+  stable let opt : ?Any = null;
+
+  public func print() : async () {
+    Prim.debugPrint(debug_show (value));
+  };
+};
diff --git a/test/run-drun/stabilize-boxed-numbers.mo b/test/run-drun/stabilize-boxed-numbers.mo
new file mode 100644
index 00000000000..b0e6790563f
--- /dev/null
+++ b/test/run-drun/stabilize-boxed-numbers.mo
@@ -0,0 +1,26 @@
+//ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+import Prim "mo:prim";
+
+actor {
+  stable let boxedNat32 : Nat32 = 4294967295;
+  stable let boxedInt32 : Int32 = -2147483648;
+  stable let boxedNat64 : Nat64 = 18446744073709551614;
+  stable let boxedInt64 : Int64 = -9223372036854775808;
+
+  public func print() : async () {
+    Prim.debugPrint(debug_show (boxedNat32));
+    Prim.debugPrint(debug_show (boxedInt32));
+    Prim.debugPrint(debug_show (boxedNat64));
+    Prim.debugPrint(debug_show (boxedInt64));
+  };
+};
+
+//CALL ingress print "DIDL\x00\x00"
+//CALL ingress __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+//CALL upgrade ""
+//CALL ingress print "DIDL\x00\x00"
+//CALL ingress __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+//CALL upgrade ""
+//CALL ingress print "DIDL\x00\x00"
+//CALL upgrade ""
+//CALL ingress print "DIDL\x00\x00"
diff --git a/test/run-drun/stabilize-generics.drun b/test/run-drun/stabilize-generics.drun
new file mode 100644
index 00000000000..f148ea4dff8
--- /dev/null
+++ b/test/run-drun/stabilize-generics.drun
@@ -0,0 +1,22 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+# SKIP ic-ref-run
+install $ID stabilize-generics/version0.mo ""
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-generics/version0.mo ""
+ingress $ID print "DIDL\x00\x01\x7d\x0F"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-generics/version1.mo ""
+ingress $ID print "DIDL\x00\x01\x7d\x0F"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-generics/version1.mo ""
+ingress $ID print "DIDL\x00\x01\x7d\x0F"
+upgrade $ID stabilize-generics/version1.mo ""
+ingress $ID print "DIDL\x00\x01\x7d\x0F"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-generics/version2.mo ""
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-generics/version0.mo ""
+ingress $ID print "DIDL\x00\x01\x7d\x0F"
+upgrade $ID stabilize-generics/version0.mo ""
+ingress $ID print "DIDL\x00\x01\x7d\x0F"
diff --git a/test/run-drun/stabilize-generics/version0.mo b/test/run-drun/stabilize-generics/version0.mo
new file mode 100644
index 00000000000..b64c5ca0fe0
--- /dev/null
+++ b/test/run-drun/stabilize-generics/version0.mo
@@ -0,0 +1,15 @@
+import Prim "mo:prim";
+
+actor {
+
+  type B<T> = [T];
+  type A<T, U> = (B<T>, B<U>);
+  module X = { public type A<U> = U };
+  type T = (A<Nat, Int>, X.A<Bool>);
+
+  stable var value = (([0], [1]), true) : T;
+
+  public func print() : async () {
+    Prim.debugPrint(debug_show (value));
+  };
+};
diff --git a/test/run-drun/stabilize-generics/version1.mo b/test/run-drun/stabilize-generics/version1.mo
new file mode 100644
index 00000000000..ef501febe2d
--- /dev/null
+++ b/test/run-drun/stabilize-generics/version1.mo
@@ -0,0 +1,15 @@
+import Prim "mo:prim";
+
+// Compatible change
+actor {
+
+  type B<T0> = [T0];
+  type A<T1, T2> = (B<T1>, B<T2>);
+  type T = (A<Nat, Int>, Bool);
+
+  stable var value = (([0], [1]), true) : T;
+
+  public func print() : async () {
+    Prim.debugPrint(debug_show (value));
+  };
+};
diff --git a/test/run-drun/stabilize-generics/version2.mo b/test/run-drun/stabilize-generics/version2.mo
new file mode 100644
index 00000000000..7199827d23c
--- /dev/null
+++ b/test/run-drun/stabilize-generics/version2.mo
@@ -0,0 +1,15 @@
+import Prim "mo:prim";
+
+// Incompatible change
+actor {
+
+  type B<T0> = [T0];
+  type A<T1, T2> = (B<T2>, B<T1>);
+  type T = (A<Nat, Int>, Bool);
+
+  stable var value = (([0], [1]), true) : T;
+
+  public func print() : async () {
+    Prim.debugPrint(debug_show (value));
+  };
+};
diff --git a/test/run-drun/stabilize-large-array.mo b/test/run-drun/stabilize-large-array.mo
new file mode 100644
index 00000000000..8a1d50bee0c
--- /dev/null
+++ b/test/run-drun/stabilize-large-array.mo
@@ -0,0 +1,35 @@
+//ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+//MOC-FLAG --stabilization-instruction-limit=10000
+
+import Prim "mo:prim";
+
+actor {
+    stable var largeArray = Prim.Array_tabulate<Nat>(100_000, func(index) { index });
+
+    public func check() : async () {
+        Prim.debugPrint("Array of length " # debug_show (largeArray.size()));
+        var index = 0;
+        while (index < largeArray.size()) {
+            assert (largeArray[index] == index);
+            index += 1;
+        };
+    };
+
+    system func preupgrade() {
+        Prim.debugPrint("PRE-UPGRADE HOOK!");
+    };
+
+    system func postupgrade() {
+        Prim.debugPrint("POST-UPGRADE HOOK!");
+    };
+};
+
+//CALL ingress check "DIDL\x00\x00"
+//CALL ingress __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+//CALL upgrade ""
+//CALL ingress __motoko_destabilize_after_upgrade "DIDL\x00\x00"
+//CALL ingress check "DIDL\x00\x00"
+
+//SKIP run
+//SKIP run-ir
+//SKIP run-low
diff --git a/test/run-drun/stabilize-mutable-array.drun b/test/run-drun/stabilize-mutable-array.drun
new file mode 100644
index 00000000000..8eda948b7c7
--- /dev/null
+++ b/test/run-drun/stabilize-mutable-array.drun
@@ -0,0 +1,7 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+# SKIP ic-ref-run
+install $ID stabilize-mutable-array/version0.mo ""
+ingress $ID test "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-mutable-array/version1.mo ""
+ingress $ID test "DIDL\x00\x00"
diff --git a/test/run-drun/stabilize-mutable-array/version0.mo b/test/run-drun/stabilize-mutable-array/version0.mo
new file mode 100644
index 00000000000..52f1b329629
--- /dev/null
+++ b/test/run-drun/stabilize-mutable-array/version0.mo
@@ -0,0 +1,22 @@
+import Prim "mo:prim";
+
+actor {
+    stable let instance = [
+        var {
+            firstField = 0;
+            secondField = 0;
+            thirdField = 0;
+        }
+    ];
+
+    stable let alias = instance;
+
+    public func test() : async () {
+        Prim.debugPrint("firstField=" # debug_show (instance[0].firstField));
+        Prim.debugPrint("secondField=" # debug_show (instance[0].secondField));
+        Prim.debugPrint("thirdField=" # debug_show (instance[0].thirdField));
+        Prim.debugPrint("firstField=" # debug_show (alias[0].firstField));
+        Prim.debugPrint("secondField=" # debug_show (alias[0].secondField));
+        Prim.debugPrint("thirdField=" # debug_show (alias[0].thirdField));
+    };
+};
diff --git a/test/run-drun/stabilize-mutable-array/version1.mo b/test/run-drun/stabilize-mutable-array/version1.mo
new file mode 100644
index 00000000000..6d134e47568
--- /dev/null
+++ b/test/run-drun/stabilize-mutable-array/version1.mo
@@ -0,0 +1,28 @@
+import Prim "mo:prim";
+
+actor {
+    stable let instance = [
+        var {
+            secondField = 1;
+        }
+    ];
+
+    stable let alias = [
+        var {
+            firstField = 1;
+            secondField = 1;
+            thirdField = 1;
+        }
+    ];
+
+    public func test() : async () {
+        // This would break type safety if memory compatibility check does not prevent upgrade.
+        instance[0] := { secondField = 2 };
+        // alias[0] would no longer have the firstField and thirdField.
+
+        Prim.debugPrint("secondField=" # debug_show (instance[0].secondField));
+        Prim.debugPrint("firstField=" # debug_show (alias[0].firstField));
+        Prim.debugPrint("secondField=" # debug_show (alias[0].secondField));
+        Prim.debugPrint("thirdField=" # debug_show (alias[0].thirdField));
+    };
+};
diff --git a/test/run-drun/stabilize-mutable-service.drun b/test/run-drun/stabilize-mutable-service.drun
new file mode 100644
index 00000000000..6100e272cc9
--- /dev/null
+++ b/test/run-drun/stabilize-mutable-service.drun
@@ -0,0 +1,12 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+# SKIP ic-ref-run
+install $ID stabilize-mutable-service/version0.mo ""
+ingress $ID initialize "DIDL\x00\x00"
+ingress $ID test "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-mutable-service/version0.mo ""
+ingress $ID test "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-mutable-service/version1.mo ""
+ingress $ID initialize "DIDL\x00\x01\x7d\x0F"
+ingress $ID test "DIDL\x00\x00"
diff --git a/test/run-drun/stabilize-mutable-service/original-service.mo b/test/run-drun/stabilize-mutable-service/original-service.mo
new file mode 100644
index 00000000000..5cfefeb2ef3
--- /dev/null
+++ b/test/run-drun/stabilize-mutable-service/original-service.mo
@@ -0,0 +1,19 @@
+import Prim "mo:prim";
+
+actor class OriginalActor() {
+    public func test0() : async () {
+        Prim.debugPrint("original test0");
+    };
+
+    public func test1() : async () {
+        Prim.debugPrint("original test1");
+    };
+
+    public func test2() : async () {
+        Prim.debugPrint("original test2");
+    };
+    
+    public func test3() : async () {
+        Prim.debugPrint("original test3");
+    };
+};
diff --git a/test/run-drun/stabilize-mutable-service/reduced-service.mo b/test/run-drun/stabilize-mutable-service/reduced-service.mo
new file mode 100644
index 00000000000..b274c09b3ae
--- /dev/null
+++ b/test/run-drun/stabilize-mutable-service/reduced-service.mo
@@ -0,0 +1,11 @@
+import Prim "mo:prim";
+
+actor class ReducedActor() {
+    public func test1() : async () {
+        Prim.debugPrint("reduced test1");
+    };
+
+    public func test3() : async () {
+        Prim.debugPrint("reduced test3");
+    };
+};
diff --git a/test/run-drun/stabilize-mutable-service/version0.mo b/test/run-drun/stabilize-mutable-service/version0.mo
new file mode 100644
index 00000000000..eef8f85d250
--- /dev/null
+++ b/test/run-drun/stabilize-mutable-service/version0.mo
@@ -0,0 +1,42 @@
+import Prim "mo:prim";
+import Cycles = "../cycles/cycles";
+import OriginalService "original-service";
+
+actor this {
+    type OriginalActor = actor {
+        test0() : async ();
+        test1() : async ();
+        test2() : async ();
+        test3() : async ();
+    };
+
+    stable var instance = [var null : ?OriginalActor];
+    stable var alias = instance;
+
+    public func initialize() : async () {
+        await Cycles.provisional_top_up_actor(this, 100_000_000_000_000);
+        Cycles.add<system>(2_000_000_000_000);
+        instance[0] := ?(await OriginalService.OriginalActor());
+    };
+
+    public func test() : async () {
+        switch (instance[0]) {
+            case (?instance) {
+                await instance.test0();
+                await instance.test1();
+                await instance.test2();
+                await instance.test3();
+            };
+            case null Prim.trap("Null");
+        };
+        switch (alias[0]) {
+            case (?alias) {
+                await alias.test0();
+                await alias.test1();
+                await alias.test2();
+                await alias.test3();
+            };
+            case null Prim.trap("Null");
+        };
+    };
+};
diff --git a/test/run-drun/stabilize-mutable-service/version1.mo b/test/run-drun/stabilize-mutable-service/version1.mo
new file mode 100644
index 00000000000..17f3f968008
--- /dev/null
+++ b/test/run-drun/stabilize-mutable-service/version1.mo
@@ -0,0 +1,44 @@
+import Prim "mo:prim";
+import Cycles = "../cycles/cycles";
+import ReducedService "reduced-service";
+
+actor this {
+    type OriginalActor = actor {
+        test0() : async ();
+        test1() : async ();
+        test2() : async ();
+        test3() : async ();
+    };
+
+    type ReducedActor = actor {
+        test1() : async ();
+        test3() : async ();
+    };
+
+    stable var instance = [var null : ?ReducedActor];
+    stable var alias = [var null : ?OriginalActor];
+
+    public func initialize() : async () {
+        Cycles.add<system>(2_000_000_000_000);
+        instance[0] := ?(await ReducedService.ReducedActor());
+    };
+
+    public func test() : async () {
+        switch (instance[0]) {
+            case (?instance) {
+                await instance.test1();
+                await instance.test3();
+            };
+            case null Prim.trap("Null");
+        };
+        switch (alias[0]) {
+            case (?alias) {
+                await alias.test0();
+                await alias.test1();
+                await alias.test2();
+                await alias.test3();
+            };
+            case null Prim.trap("Null");
+        };
+    };
+};
diff --git a/test/run-drun/stabilize-mutable-variant.drun b/test/run-drun/stabilize-mutable-variant.drun
new file mode 100644
index 00000000000..af30b520348
--- /dev/null
+++ b/test/run-drun/stabilize-mutable-variant.drun
@@ -0,0 +1,7 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+# SKIP ic-ref-run
+install $ID stabilize-mutable-variant/version0.mo ""
+ingress $ID test "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-mutable-variant/version1.mo ""
+ingress $ID test "DIDL\x00\x00"
diff --git a/test/run-drun/stabilize-mutable-variant/version0.mo b/test/run-drun/stabilize-mutable-variant/version0.mo
new file mode 100644
index 00000000000..00a90693ae9
--- /dev/null
+++ b/test/run-drun/stabilize-mutable-variant/version0.mo
@@ -0,0 +1,16 @@
+import Prim "mo:prim";
+
+actor {
+    type OriginalVariant = {
+        #Option1;
+        #Option2;
+    };
+
+    stable let instance = [ var #Option1: OriginalVariant ];
+    stable let alias = instance;
+
+    public func test() : async () {
+        Prim.debugPrint("instance=" # debug_show (instance));
+        Prim.debugPrint("alias=" # debug_show (alias));
+    };
+};
diff --git a/test/run-drun/stabilize-mutable-variant/version1.mo b/test/run-drun/stabilize-mutable-variant/version1.mo
new file mode 100644
index 00000000000..241a83ab89b
--- /dev/null
+++ b/test/run-drun/stabilize-mutable-variant/version1.mo
@@ -0,0 +1,26 @@
+import Prim "mo:prim";
+
+actor {
+    type OriginalVariant = {
+        #Option1;
+        #Option2;
+    };
+
+    type ExtendedVariant = {
+        #Option0;
+        #Option1;
+        #Option2;
+    };
+
+    stable let instance = [ var #Option1: OriginalVariant ];
+    stable let alias = [ var #Option1: ExtendedVariant ];
+
+    public func test() : async () {
+        // Would break type safety if not rejected by the memory compatibility check of the upgrade.
+        alias[0] := #Option0;
+        // instance would observe invalid enum value.
+
+        Prim.debugPrint("instance=" # debug_show (instance));
+        Prim.debugPrint("alias=" # debug_show (alias));
+    };
+};
diff --git a/test/run-drun/stabilize-mutable.drun b/test/run-drun/stabilize-mutable.drun
new file mode 100644
index 00000000000..567ba7662db
--- /dev/null
+++ b/test/run-drun/stabilize-mutable.drun
@@ -0,0 +1,14 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+# SKIP ic-ref-run
+install $ID stabilize-mutable/version0.mo ""
+ingress $ID modify "DIDL\x00\x00"
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-mutable/version0.mo ""
+ingress $ID modify "DIDL\x00\x00"
+ingress $ID print "DIDL\x00\x00"
+upgrade $ID stabilize-mutable/version0.mo ""
+ingress $ID modify "DIDL\x00\x00"
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-mutable/version1.mo ""
diff --git a/test/run-drun/stabilize-mutable/version0.mo b/test/run-drun/stabilize-mutable/version0.mo
new file mode 100644
index 00000000000..058768fbd04
--- /dev/null
+++ b/test/run-drun/stabilize-mutable/version0.mo
@@ -0,0 +1,18 @@
+import Prim "mo:prim";
+
+actor {
+   type Entry = { key: Nat; value: Text; };
+   stable var array1: [var Entry] = [ var { key = 1; value = "1" }];
+   stable var array2: [var Entry] = array1;
+   
+   public func modify() : async () {
+      array1[0] := { key = 2; value = "2" };
+      assert(array2[0].key == 2);
+      assert(array2[0].value == "2");
+   };
+
+   public func print() : async () {
+      Prim.debugPrint(debug_show(array1));
+      Prim.debugPrint(debug_show(array2));
+   };
+};
diff --git a/test/run-drun/stabilize-mutable/version1.mo b/test/run-drun/stabilize-mutable/version1.mo
new file mode 100644
index 00000000000..be9424f3d7e
--- /dev/null
+++ b/test/run-drun/stabilize-mutable/version1.mo
@@ -0,0 +1,20 @@
+import Prim "mo:prim";
+
+actor {
+   type Entry = { key : Nat; value : Text };
+   type SubEntry = { key : Nat; };
+   
+   stable var array1 : [var Entry] = [var { key = 1; value = "1" }];
+   stable var array2 : [var SubEntry] = [var];
+
+   public func modify() : async () {
+      array2[0] := { key = 3; };
+      assert (array1[0].key == 3);
+      Prim.debugPrint(array1[0].value);
+   };
+
+   public func print() : async () {
+      Prim.debugPrint(debug_show (array1));
+      Prim.debugPrint(debug_show (array2));
+   };
+};
diff --git a/test/run-drun/stabilize-nat-to-int.drun b/test/run-drun/stabilize-nat-to-int.drun
new file mode 100644
index 00000000000..50468c57cc6
--- /dev/null
+++ b/test/run-drun/stabilize-nat-to-int.drun
@@ -0,0 +1,20 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+# SKIP ic-ref-run
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+install $ID stabilize-nat-to-int/version0.mo ""
+ingress $ID modify "DIDL\x00\x00"
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-nat-to-int/version0.mo ""
+ingress $ID modify "DIDL\x00\x00"
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-nat-to-int/version1.mo ""
+ingress $ID modify "DIDL\x00\x00"
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-nat-to-int/version1.mo ""
+ingress $ID modify "DIDL\x00\x00"
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-nat-to-int/version0.mo ""
diff --git a/test/run-drun/stabilize-nat-to-int/version0.mo b/test/run-drun/stabilize-nat-to-int/version0.mo
new file mode 100644
index 00000000000..53f13ea1874
--- /dev/null
+++ b/test/run-drun/stabilize-nat-to-int/version0.mo
@@ -0,0 +1,13 @@
+import Prim "mo:prim";
+
+actor {
+   stable var number : Nat = 0;
+
+   public func modify() : async () {
+      number += 1;
+   };
+
+   public func print() : async () {
+      Prim.debugPrint(debug_show (number));
+   };
+};
diff --git a/test/run-drun/stabilize-nat-to-int/version1.mo b/test/run-drun/stabilize-nat-to-int/version1.mo
new file mode 100644
index 00000000000..0c20ef697c4
--- /dev/null
+++ b/test/run-drun/stabilize-nat-to-int/version1.mo
@@ -0,0 +1,13 @@
+import Prim "mo:prim";
+
+actor {
+   stable var number : Int = -123;
+
+   public func modify() : async () {
+      number -= 2;
+   };
+
+   public func print() : async () {
+      Prim.debugPrint(debug_show (number));
+   };
+};
diff --git a/test/run-drun/stabilize-non-stable.drun b/test/run-drun/stabilize-non-stable.drun
new file mode 100644
index 00000000000..56140eb8e0c
--- /dev/null
+++ b/test/run-drun/stabilize-non-stable.drun
@@ -0,0 +1,16 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+# SKIP ic-ref-run
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+install $ID stabilize-non-stable/version0.mo ""
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-non-stable/version0.mo ""
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-non-stable/version1.mo ""
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-non-stable/version1.mo ""
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-non-stable/version0.mo ""
diff --git a/test/run-drun/stabilize-non-stable/version0.mo b/test/run-drun/stabilize-non-stable/version0.mo
new file mode 100644
index 00000000000..87a49e87f0c
--- /dev/null
+++ b/test/run-drun/stabilize-non-stable/version0.mo
@@ -0,0 +1,29 @@
+import Prim "mo:prim";
+
+actor {
+  let temporary = 1;
+
+  func f() {
+    Prim.debugPrint(debug_show (temporary));
+  };
+
+  stable let value : {
+    stableField : Text;
+  } = {
+    stableField = "Version 0";
+    nonStableField = f;
+    unreachableField = -123;
+  };
+
+  stable let any : Any = f;
+  stable let tuple : (Int, Any) = (0, f);
+  stable let variant : { #tag : Any } = #tag f;
+  stable let record : { lab : Any } = { lab = f };
+  stable let vector : [Any] = [f];
+  stable let array : [var Any] = [var f];
+  stable let opt : ?Any = ?f;
+
+  public func print() : async () {
+    Prim.debugPrint(debug_show (value));
+  };
+};
diff --git a/test/run-drun/stabilize-non-stable/version1.mo b/test/run-drun/stabilize-non-stable/version1.mo
new file mode 100644
index 00000000000..38770680751
--- /dev/null
+++ b/test/run-drun/stabilize-non-stable/version1.mo
@@ -0,0 +1,19 @@
+import Prim "mo:prim";
+
+actor {
+  stable let value : {} = {
+    stableField = "Version 1";
+  };
+
+  stable let any : Any = null;
+  stable let tuple : (Int, Any) = (0, null);
+  stable let variant : { #tag : Any } = #tag null;
+  stable let record : { lab : Any } = { lab = null };
+  stable let vector : [Any] = [null];
+  stable let array : [var Any] = [var null];
+  stable let opt : ?Any = null;
+
+  public func print() : async () {
+    Prim.debugPrint(debug_show (value));
+  };
+};
diff --git a/test/run-drun/stabilize-optional.drun b/test/run-drun/stabilize-optional.drun
new file mode 100644
index 00000000000..0da7c2d55df
--- /dev/null
+++ b/test/run-drun/stabilize-optional.drun
@@ -0,0 +1,21 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+# SKIP ic-ref-run
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+install $ID stabilize-optional/version0.mo ""
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-optional/version0.mo ""
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-optional/version1.mo ""
+upgrade $ID stabilize-optional/version2.mo ""
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-optional/version2.mo ""
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-optional/version2.mo ""
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-optional/version2.mo ""
+upgrade $ID stabilize-optional/version2.mo ""
\ No newline at end of file
diff --git a/test/run-drun/stabilize-optional/version0.mo b/test/run-drun/stabilize-optional/version0.mo
new file mode 100644
index 00000000000..51958e571ab
--- /dev/null
+++ b/test/run-drun/stabilize-optional/version0.mo
@@ -0,0 +1,9 @@
+import Prim "mo:prim";
+
+actor {
+  stable let value: ???{} = ??null;
+
+  public func print() : async () {
+    Prim.debugPrint(debug_show (value));
+  };
+};
diff --git a/test/run-drun/stabilize-optional/version1.mo b/test/run-drun/stabilize-optional/version1.mo
new file mode 100644
index 00000000000..880646e7ede
--- /dev/null
+++ b/test/run-drun/stabilize-optional/version1.mo
@@ -0,0 +1,9 @@
+import Prim "mo:prim";
+
+actor {
+  stable let value: ???{} = ?null;
+
+  public func print() : async () {
+    Prim.debugPrint(debug_show (value));
+  };
+};
diff --git a/test/run-drun/stabilize-optional/version2.mo b/test/run-drun/stabilize-optional/version2.mo
new file mode 100644
index 00000000000..d0437c6ad8b
--- /dev/null
+++ b/test/run-drun/stabilize-optional/version2.mo
@@ -0,0 +1,9 @@
+import Prim "mo:prim";
+
+actor {
+  stable let value: ???{} = null;
+
+  public func print() : async () {
+    Prim.debugPrint(debug_show (value));
+  };
+};
diff --git a/test/run-drun/stabilize-primitive-types.mo b/test/run-drun/stabilize-primitive-types.mo
new file mode 100644
index 00000000000..c0277c8a47c
--- /dev/null
+++ b/test/run-drun/stabilize-primitive-types.mo
@@ -0,0 +1,73 @@
+//ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+import Prim "mo:prim";
+
+actor {
+    stable var nullVariable = null;
+    stable var boolVariable = false;
+    stable var natVariable = 1234567890123456789012345678901234567890;
+    stable var nat8Variable = 123: Nat8;
+    stable var nat16Variable = 12345: Nat16;
+    stable var nat32Variable = 1234567890: Nat32;
+    stable var nat64Variable = 123456789012345: Nat64;
+    stable var intVariable = -1234567890123456789012345678901234567890;
+    stable var int8Variable = -123: Int8;
+    stable var int16Variable = -12345: Int16;
+    stable var int32Variable = -1234567890: Int32;
+    stable var int64Variable = -123456789012345: Int64;
+    stable var floatVariable = 1.234567890;
+    stable var charVariable = '!';
+    stable var textVariable = "\"TEST\"";
+    stable var blobVariable = "abc": Blob;
+    stable var principalVariable = Prim.principalOfBlob ("\00\00\00\00\00\30\00\D3\01\01": Blob);
+
+    Prim.debugPrint("Initialized");
+
+    public func increase() : async () {
+        nullVariable := null;
+        boolVariable := not boolVariable;
+        natVariable += 1;
+        nat8Variable += 1;
+        nat16Variable += 1;
+        nat32Variable += 1;
+        nat64Variable += 1;
+        floatVariable += 0.1;
+        charVariable := if (charVariable == '!') { '?' } else { '!' };
+        textVariable #= " \"TEST\"";
+    };
+
+    public func print() : async () {
+        Prim.debugPrint(debug_show(nullVariable));
+        Prim.debugPrint(debug_show(boolVariable));
+        Prim.debugPrint(debug_show(natVariable));
+        Prim.debugPrint(debug_show(nat8Variable));
+        Prim.debugPrint(debug_show(nat16Variable));
+        Prim.debugPrint(debug_show(nat32Variable));
+        Prim.debugPrint(debug_show(nat64Variable));
+        Prim.debugPrint(debug_show(intVariable));
+        Prim.debugPrint(debug_show(int8Variable));
+        Prim.debugPrint(debug_show(int16Variable));
+        Prim.debugPrint(debug_show(int32Variable));
+        Prim.debugPrint(debug_show(int64Variable));
+        Prim.debugPrint(debug_show(floatVariable));
+        Prim.debugPrint(debug_show(charVariable));
+        Prim.debugPrint(debug_show(textVariable));
+        Prim.debugPrint(debug_show(blobVariable));
+        Prim.debugPrint(debug_show(principalVariable));
+    };
+}
+
+//SKIP run
+//SKIP run-low
+//SKIP run-ir
+//SKIP comp-ref
+//CALL ingress print "DIDL\x00\x00"
+//CALL ingress __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+//CALL upgrade ""
+//CALL ingress increase "DIDL\x00\x00"
+//CALL ingress print "DIDL\x00\x00"
+//CALL ingress __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+//CALL upgrade ""
+//CALL ingress increase "DIDL\x00\x00"
+//CALL ingress print "DIDL\x00\x00"
+//CALL upgrade ""
+//CALL ingress print "DIDL\x00\x00"
diff --git a/test/run-drun/stabilize-recursive-type.drun b/test/run-drun/stabilize-recursive-type.drun
new file mode 100644
index 00000000000..e6658c62742
--- /dev/null
+++ b/test/run-drun/stabilize-recursive-type.drun
@@ -0,0 +1,17 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+# SKIP ic-ref-run
+install $ID stabilize-recursive-type/version0.mo ""
+ingress $ID increase "DIDL\x00\x01\x7d\x0F"
+ingress $ID check "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x01\x7d\x0F"
+upgrade $ID stabilize-recursive-type/version0.mo ""
+ingress $ID increase "DIDL\x00\x01\x7d\x0F"
+ingress $ID check "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x01\x7d\x0F"
+upgrade $ID stabilize-recursive-type/version1.mo ""
+ingress $ID increase "DIDL\x00\x01\x7d\x0F"
+ingress $ID check "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x01\x7d\x0F"
+upgrade $ID stabilize-recursive-type/version1.mo ""
+ingress $ID increase "DIDL\x00\x01\x7d\x0F"
+ingress $ID check "DIDL\x00\x00"
diff --git a/test/run-drun/stabilize-recursive-type/version0.mo b/test/run-drun/stabilize-recursive-type/version0.mo
new file mode 100644
index 00000000000..84d95f3aa18
--- /dev/null
+++ b/test/run-drun/stabilize-recursive-type/version0.mo
@@ -0,0 +1,31 @@
+import Prim "mo:prim";
+
+actor {
+    type Node = {
+        var value : Nat;
+        var next : ?Node;
+        var test : Nat;
+    };
+
+    let node = { var value = 0; var next = null : ?Node; var test = 0 };
+    node.next := ?node;
+
+    stable var root = node;
+
+    public func increase() : async () {
+        root.value += 1;
+        root.test := root.value;
+    };
+
+    public func check() : async () {
+        Prim.debugPrint("CHECK " # debug_show (root.value));
+        assert (root.value == root.test);
+        switch (root.next) {
+            case null Prim.trap("");
+            case (?next) {
+                assert (next.value == root.value);
+                assert (next.value == root.test);
+            };
+        };
+    };
+};
diff --git a/test/run-drun/stabilize-recursive-type/version1.mo b/test/run-drun/stabilize-recursive-type/version1.mo
new file mode 100644
index 00000000000..a840ea723d8
--- /dev/null
+++ b/test/run-drun/stabilize-recursive-type/version1.mo
@@ -0,0 +1,25 @@
+import Prim "mo:prim";
+
+// Incompatible change (mutable invariance).
+actor {
+    type Node = {
+        var value : Nat;
+        var next : ?Node;
+    };
+
+    stable var root = { var value = 0; var next = null : ?Node };
+
+    public func increase() : async () {
+        root.value += 1;
+    };
+
+    public func check() : async () {
+        Prim.debugPrint("CHECK " # debug_show (root.value));
+        switch (root.next) {
+            case null Prim.trap("");
+            case (?next) {
+                assert (next.value == root.value);
+            };
+        };
+    };
+};
diff --git a/test/run-drun/stabilize-remove-add-fields.drun b/test/run-drun/stabilize-remove-add-fields.drun
new file mode 100644
index 00000000000..a72e38b3aba
--- /dev/null
+++ b/test/run-drun/stabilize-remove-add-fields.drun
@@ -0,0 +1,25 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+# SKIP ic-ref-run
+install $ID stabilize-remove-add-fields/version0.mo ""
+ingress $ID increase "DIDL\x00\x01\x7d\x0F"
+ingress $ID show "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x01\x7d\x0F"
+upgrade $ID stabilize-remove-add-fields/version0.mo ""
+ingress $ID increase "DIDL\x00\x01\x7d\x0F"
+ingress $ID show "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x01\x7d\x0F"
+upgrade $ID stabilize-remove-add-fields/version1.mo ""
+ingress $ID increase "DIDL\x00\x01\x7d\x0F"
+ingress $ID show "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x01\x7d\x0F"
+upgrade $ID stabilize-remove-add-fields/version1.mo ""
+ingress $ID increase "DIDL\x00\x01\x7d\x0F"
+ingress $ID show "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x01\x7d\x0F"
+upgrade $ID stabilize-remove-add-fields/version2.mo ""
+ingress $ID increase "DIDL\x00\x01\x7d\x0F"
+ingress $ID show "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x01\x7d\x0F"
+upgrade $ID stabilize-remove-add-fields/version2.mo ""
+ingress $ID increase "DIDL\x00\x01\x7d\x0F"
+ingress $ID show "DIDL\x00\x00"
diff --git a/test/run-drun/stabilize-remove-add-fields/version0.mo b/test/run-drun/stabilize-remove-add-fields/version0.mo
new file mode 100644
index 00000000000..cc7330c63bd
--- /dev/null
+++ b/test/run-drun/stabilize-remove-add-fields/version0.mo
@@ -0,0 +1,21 @@
+import Prim "mo:prim";
+
+actor {
+    stable var instance = {
+        var firstField = 0;
+        var secondField = 0;
+        var thirdField = 0;
+    };
+
+    public func increase() : async () {
+        instance.firstField += 1;
+        instance.secondField += 1;
+        instance.thirdField += 1;
+    };
+
+    public func show() : async () {
+        Prim.debugPrint("firstField=" # debug_show (instance.firstField));
+        Prim.debugPrint("secondField=" # debug_show (instance.secondField));
+        Prim.debugPrint("thirdField=" # debug_show (instance.thirdField));
+    };
+};
diff --git a/test/run-drun/stabilize-remove-add-fields/version1.mo b/test/run-drun/stabilize-remove-add-fields/version1.mo
new file mode 100644
index 00000000000..6a21d341207
--- /dev/null
+++ b/test/run-drun/stabilize-remove-add-fields/version1.mo
@@ -0,0 +1,15 @@
+import Prim "mo:prim";
+
+actor {
+    stable var instance = {
+        var secondField = 0;
+    };
+
+    public func increase() : async () {
+        instance.secondField += 1;
+    };
+
+    public func show() : async () {
+        Prim.debugPrint("secondField=" # debug_show (instance.secondField));
+    };
+};
diff --git a/test/run-drun/stabilize-remove-add-fields/version2.mo b/test/run-drun/stabilize-remove-add-fields/version2.mo
new file mode 100644
index 00000000000..fe72a1fdc7f
--- /dev/null
+++ b/test/run-drun/stabilize-remove-add-fields/version2.mo
@@ -0,0 +1,18 @@
+import Prim "mo:prim";
+
+actor {
+    stable var instance = {
+        var secondField = 0;
+        var newField = 0;
+    };
+
+    public func increase() : async () {
+        instance.secondField += 1;
+        instance.newField += 1;
+    };
+
+    public func show() : async () {
+        Prim.debugPrint("secondField=" # debug_show (instance.secondField));
+        Prim.debugPrint("newField=" # debug_show (instance.newField));
+    };
+};
diff --git a/test/run-drun/stabilize-service.drun b/test/run-drun/stabilize-service.drun
new file mode 100644
index 00000000000..47db80d5e82
--- /dev/null
+++ b/test/run-drun/stabilize-service.drun
@@ -0,0 +1,18 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+# SKIP ic-ref-run
+install $ID stabilize-service/version0.mo ""
+ingress $ID initialize "DIDL\x00\x00"
+ingress $ID test "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-service/version0.mo ""
+ingress $ID test "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-service/version1.mo ""
+ingress $ID initialize "DIDL\x00\x01\x7d\x0F"
+ingress $ID test "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-service/version1.mo ""
+ingress $ID test "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-service/version0.mo ""
+ingress $ID test "DIDL\x00\x00"
diff --git a/test/run-drun/stabilize-service/original-service.mo b/test/run-drun/stabilize-service/original-service.mo
new file mode 100644
index 00000000000..a1f18a67e07
--- /dev/null
+++ b/test/run-drun/stabilize-service/original-service.mo
@@ -0,0 +1,11 @@
+import Prim "mo:prim";
+
+actor class OriginalActor() {
+    public func test1() : async () {
+        Prim.debugPrint("original test1");
+    };
+
+    public func test2() : async () {
+        Prim.debugPrint("original test2");
+    };
+};
diff --git a/test/run-drun/stabilize-service/reduced-service.mo b/test/run-drun/stabilize-service/reduced-service.mo
new file mode 100644
index 00000000000..400a36c5373
--- /dev/null
+++ b/test/run-drun/stabilize-service/reduced-service.mo
@@ -0,0 +1,7 @@
+import Prim "mo:prim";
+
+actor class ReducedActor() {
+    public func test1() : async () {
+        Prim.debugPrint("reduced test1");
+    };
+};
diff --git a/test/run-drun/stabilize-service/version0.mo b/test/run-drun/stabilize-service/version0.mo
new file mode 100644
index 00000000000..b20a14d49bb
--- /dev/null
+++ b/test/run-drun/stabilize-service/version0.mo
@@ -0,0 +1,28 @@
+import Prim "mo:prim";
+import Cycles = "../cycles/cycles";
+import OriginalService "original-service";
+
+actor this {
+    type OriginalActor = actor {
+        test1() : async ();
+        test2() : async ();
+    };
+
+    stable var instance : ?OriginalActor = null;
+
+    public func initialize() : async () {
+        await Cycles.provisional_top_up_actor(this, 100_000_000_000_000);
+        Cycles.add<system>(2_000_000_000_000);
+        instance := ?(await OriginalService.OriginalActor());
+    };
+
+    public func test() : async () {
+        switch instance {
+            case (?instance) {
+                await instance.test1();
+                await instance.test2();
+            };
+            case null Prim.trap("Null");
+        };
+    };
+};
diff --git a/test/run-drun/stabilize-service/version1.mo b/test/run-drun/stabilize-service/version1.mo
new file mode 100644
index 00000000000..a48bc474128
--- /dev/null
+++ b/test/run-drun/stabilize-service/version1.mo
@@ -0,0 +1,30 @@
+import Prim "mo:prim";
+import Cycles = "../cycles/cycles";
+import ReducedService "reduced-service";
+
+actor this {
+    type OriginalActor = actor {
+        test1() : async ();
+        test2() : async ();
+    };
+
+    type ReducedActor = actor {
+        test1() : async ();
+    };
+
+    stable var instance : ?ReducedActor = null;
+
+    public func initialize() : async () {
+        Cycles.add<system>(2_000_000_000_000);
+        instance := ?(await ReducedService.ReducedActor());
+    };
+
+    public func test() : async () {
+        switch instance {
+            case (?instance) {
+                await instance.test1();
+            };
+            case null Prim.trap("Null");
+        };
+    };
+};
diff --git a/test/run-drun/stabilize-text-iter.drun b/test/run-drun/stabilize-text-iter.drun
new file mode 100644
index 00000000000..ed94b6f96df
--- /dev/null
+++ b/test/run-drun/stabilize-text-iter.drun
@@ -0,0 +1,16 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+# SKIP ic-ref-run
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+install $ID stabilize-text-iter/version0.mo ""
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-text-iter/version0.mo ""
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-text-iter/version1.mo ""
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-text-iter/version1.mo ""
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-text-iter/version0.mo ""
diff --git a/test/run-drun/stabilize-text-iter/version0.mo b/test/run-drun/stabilize-text-iter/version0.mo
new file mode 100644
index 00000000000..3cb3dabcbe5
--- /dev/null
+++ b/test/run-drun/stabilize-text-iter/version0.mo
@@ -0,0 +1,27 @@
+import Prim "mo:prim";
+
+actor {
+  let temporary = 1;
+
+  let textiter = "hello".chars();
+
+  stable let value : {
+    stableField : Text;
+  } = {
+    stableField = "Version 0";
+    nonStableField = textiter;
+    unreachableField = -123;
+  };
+
+  stable let any : Any = textiter;
+  stable let tuple : (Int, Any) = (0, textiter);
+  stable let variant : { #tag : Any } = #tag textiter;
+  stable let record : { lab : Any } = { lab = textiter };
+  stable let vector : [Any] = [textiter];
+  stable let array : [var Any] = [var textiter];
+  stable let opt : ?Any = ?textiter;
+
+  public func print() : async () {
+    Prim.debugPrint(debug_show (value));
+  };
+};
diff --git a/test/run-drun/stabilize-text-iter/version1.mo b/test/run-drun/stabilize-text-iter/version1.mo
new file mode 100644
index 00000000000..38770680751
--- /dev/null
+++ b/test/run-drun/stabilize-text-iter/version1.mo
@@ -0,0 +1,19 @@
+import Prim "mo:prim";
+
+actor {
+  stable let value : {} = {
+    stableField = "Version 1";
+  };
+
+  stable let any : Any = null;
+  stable let tuple : (Int, Any) = (0, null);
+  stable let variant : { #tag : Any } = #tag null;
+  stable let record : { lab : Any } = { lab = null };
+  stable let vector : [Any] = [null];
+  stable let array : [var Any] = [var null];
+  stable let opt : ?Any = null;
+
+  public func print() : async () {
+    Prim.debugPrint(debug_show (value));
+  };
+};
diff --git a/test/run-drun/stabilize-to-any.drun b/test/run-drun/stabilize-to-any.drun
new file mode 100644
index 00000000000..e06d4771999
--- /dev/null
+++ b/test/run-drun/stabilize-to-any.drun
@@ -0,0 +1,15 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+# SKIP ic-ref-run
+install $ID stabilize-to-any/version0.mo ""
+ingress $ID check "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-to-any/version1.mo ""
+ingress $ID __motoko_gc_trigger "DIDL\x00\x00"
+ingress $ID check "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-to-any/version2.mo ""
+ingress $ID __motoko_gc_trigger "DIDL\x00\x00"
+ingress $ID check "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID stabilize-to-any/version2.mo ""
+ingress $ID check "DIDL\x00\x00"
diff --git a/test/run-drun/stabilize-to-any/version0.mo b/test/run-drun/stabilize-to-any/version0.mo
new file mode 100644
index 00000000000..5763645a096
--- /dev/null
+++ b/test/run-drun/stabilize-to-any/version0.mo
@@ -0,0 +1,23 @@
+import Prim "mo:prim";
+
+actor {
+   Prim.debugPrint("Version 0");
+
+   let allocationSize = 64 * 1024 * 1024;
+
+   func largeAllocation(name: Text): [var Nat] {
+      Prim.debugPrint("Initialize " # name);
+      Prim.Array_init<Nat>(allocationSize / 8, 0);
+   };
+
+   stable var firstVariable : [var Nat] = largeAllocation("first variable");
+
+   public func check(): async() {
+      // Extra GC increments.
+      await async {};
+      await async {};
+      await async {};
+      // Check that first variable has been cleared and the first array has been reclaimed.
+      assert(Prim.rts_heap_size() >= allocationSize);
+   };
+};
diff --git a/test/run-drun/stabilize-to-any/version1.mo b/test/run-drun/stabilize-to-any/version1.mo
new file mode 100644
index 00000000000..7eb6eb1d543
--- /dev/null
+++ b/test/run-drun/stabilize-to-any/version1.mo
@@ -0,0 +1,25 @@
+import Prim "mo:prim";
+
+actor {
+   Prim.debugPrint("Version 1");
+
+   let allocationSize = 64 * 1024 * 1024;
+
+   func largeAllocation(name: Text): [var Nat] {
+      Prim.debugPrint("Initialize " # name);
+      Prim.Array_init<Nat>(allocationSize / 8, 0);
+   };
+
+   stable var firstVariable : Any = largeAllocation("first variable");
+   stable var secondVariable : Any = largeAllocation("second variable");
+   
+   public func check(): async() {
+      // Extra GC increments.
+      await async {};
+      await async {};
+      await async {};
+      // Check that first variable has been cleared and the first array has been reclaimed.
+      assert(Prim.rts_heap_size() >= allocationSize);
+      assert(Prim.rts_heap_size() < 2 * allocationSize);
+   };
+};
diff --git a/test/run-drun/stabilize-to-any/version2.mo b/test/run-drun/stabilize-to-any/version2.mo
new file mode 100644
index 00000000000..4fe5c28804e
--- /dev/null
+++ b/test/run-drun/stabilize-to-any/version2.mo
@@ -0,0 +1,23 @@
+import Prim "mo:prim";
+
+actor {
+   Prim.debugPrint("Version 2");
+
+   let allocationSize = 64 * 1024 * 1024;
+
+   func largeAllocation(name: Text): [var Nat] {
+      Prim.trap("Should not be called");
+   };
+
+   stable var firstVariable : Any = largeAllocation("first variable");
+   stable var secondVariable : Any = largeAllocation("second variable");
+
+   public func check(): async() {
+      // Extra GC increments.
+      await async {};
+      await async {};
+      await async {};
+      // Check that both variables have been cleared and both arrays have been reclaimed.
+      assert(Prim.rts_heap_size() < allocationSize);
+   }
+};
diff --git a/test/run-drun/stabilize-variant.drun b/test/run-drun/stabilize-variant.drun
new file mode 100644
index 00000000000..b572cc59e33
--- /dev/null
+++ b/test/run-drun/stabilize-variant.drun
@@ -0,0 +1,19 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+# SKIP ic-ref-run
+install $ID stabilize-variant/version0.mo ""
+ingress $ID modify "DIDL\x00\x01\x7d\x0F"
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x01\x7d\x0F"
+upgrade $ID stabilize-variant/version0.mo ""
+ingress $ID modify "DIDL\x00\x01\x7d\x0F"
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x01\x7d\x0F"
+upgrade $ID stabilize-variant/version1.mo ""
+ingress $ID modify "DIDL\x00\x01\x7d\x0F"
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x01\x7d\x0F"
+upgrade $ID stabilize-variant/version1.mo ""
+ingress $ID modify "DIDL\x00\x01\x7d\x0F"
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x01\x7d\x0F"
+upgrade $ID stabilize-variant/version2.mo ""
diff --git a/test/run-drun/stabilize-variant/version0.mo b/test/run-drun/stabilize-variant/version0.mo
new file mode 100644
index 00000000000..212799e10c5
--- /dev/null
+++ b/test/run-drun/stabilize-variant/version0.mo
@@ -0,0 +1,21 @@
+import Prim "mo:prim";
+
+actor {
+  type Variant = {
+    #one : Nat;
+    #two : { key : Nat; var name : Text };
+  };
+
+  stable var root : Variant = #two { key = 1; var name = "TEST" };
+
+  public func modify() : async () {
+    switch root {
+      case (#two record) record.name #= " TEST";
+      case _ assert false;
+    };
+  };
+
+  public func print() : async () {
+    Prim.debugPrint(debug_show (root));
+  };
+};
diff --git a/test/run-drun/stabilize-variant/version1.mo b/test/run-drun/stabilize-variant/version1.mo
new file mode 100644
index 00000000000..49843a2510a
--- /dev/null
+++ b/test/run-drun/stabilize-variant/version1.mo
@@ -0,0 +1,23 @@
+import Prim "mo:prim";
+
+// Compatible upgrade
+actor {
+  type Variant = {
+    #two : { key : Nat; var name : Text };
+    #one : Nat;
+    #three : Text;
+  };
+
+  stable var root : Variant = #three "ERROR";
+
+  public func modify() : async () {
+    switch root {
+      case (#two record) record.name #= " TEST";
+      case _ assert false;
+    };
+  };
+
+  public func print() : async () {
+    Prim.debugPrint(debug_show (root));
+  };
+};
diff --git a/test/run-drun/stabilize-variant/version2.mo b/test/run-drun/stabilize-variant/version2.mo
new file mode 100644
index 00000000000..0911e8508a5
--- /dev/null
+++ b/test/run-drun/stabilize-variant/version2.mo
@@ -0,0 +1,22 @@
+import Prim "mo:prim";
+
+// Incompatible upgrade
+actor {
+  type Variant = {
+    #two : { key : Nat; var name : Text };
+    #one : Nat;
+  };
+
+  stable var root: Variant = #one 0;
+
+  public func modify() : async () {
+    switch root {
+      case (#two record) record.name #= " TEST";
+      case _ assert false;
+    };
+  };
+
+  public func print() : async () {
+    Prim.debugPrint(debug_show(root));
+  };
+};
diff --git a/test/run-drun/stable-mem-rts-stats.mo b/test/run-drun/stable-mem-rts-stats.mo
index 5d8da6368c7..8e784eb7576 100644
--- a/test/run-drun/stable-mem-rts-stats.mo
+++ b/test/run-drun/stable-mem-rts-stats.mo
@@ -3,7 +3,9 @@ import StableMemory "stable-mem/StableMemory";
 actor {
   let s1 = P.rts_stable_memory_size();
   let l1 = P.rts_logical_stable_memory_size();
-  P.debugPrint (debug_show({s1;l1}));
+  assert (s1 == 0 or s1 == 17 or s1 == 18);
+  assert (l1 == 0 or l1 == 16);
+  P.debugPrint ("Ignore Diff:" # debug_show({s1;l1}));
   let 0 = StableMemory.grow(16);
   stable var v = StableMemory.loadBlob(0, 65536);
   let s2 = P.rts_stable_memory_size();
diff --git a/test/run-drun/stable-regions-new-each-stabilization.mo b/test/run-drun/stable-regions-new-each-stabilization.mo
new file mode 100644
index 00000000000..595a8d279c2
--- /dev/null
+++ b/test/run-drun/stable-regions-new-each-stabilization.mo
@@ -0,0 +1,46 @@
+//ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+//MOC-FLAG --stable-regions
+//MOC-ENV MOC_UNLOCK_PRIM=yesplease
+
+import P "mo:⛔";
+import Region "stable-region/Region";
+
+actor {
+  stable var n = 0;
+  stable let regions : [var ?Region] = [var null, null, null];
+  
+  system func preupgrade() {
+    P.debugPrint("upgrading... calling Region.new(), n=" # debug_show n);
+    regions[n] := ?Region.new();
+    n += 1;
+  };
+  func unwrap(i : Nat, ro : ?Region) : Region {
+      P.debugPrint(" unwrapping. i=" # debug_show i);      
+      switch ro {
+      case null { assert false; loop { } };
+      case (?r) r;
+      }
+  };
+  public func sanityTest() {
+    P.debugPrint("sanity check. n=" # debug_show n);
+    if (n > 0) { P.debugPrint(debug_show Region.id(unwrap(0, regions[0]))) };
+    if (n > 1) { P.debugPrint(debug_show Region.id(unwrap(1, regions[1]))) };
+    if (n > 2) { P.debugPrint(debug_show Region.id(unwrap(2, regions[2]))) };
+  };
+}
+
+//SKIP run
+//SKIP run-low
+//SKIP run-ir
+// too slow on ic-ref-run:
+//SKIP comp-ref
+//CALL ingress sanityTest "DIDL\x00\x00"
+//CALL ingress __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+//CALL upgrade ""
+//CALL ingress sanityTest "DIDL\x00\x00"
+//CALL ingress __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+//CALL upgrade ""
+//CALL ingress sanityTest "DIDL\x00\x00"
+//CALL ingress __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+//CALL upgrade ""
+//CALL ingress sanityTest "DIDL\x00\x00"
diff --git a/test/run-drun/stable-regions-stabilization.mo b/test/run-drun/stable-regions-stabilization.mo
new file mode 100644
index 00000000000..77f3beb2432
--- /dev/null
+++ b/test/run-drun/stable-regions-stabilization.mo
@@ -0,0 +1,52 @@
+//ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+//MOC-FLAG --stable-regions
+//MOC-ENV MOC_UNLOCK_PRIM=yesplease
+
+import P "mo:⛔";
+import Region "stable-region/Region";
+import StableMemory "stable-mem/StableMemory";
+
+actor {
+  stable var n = 0;
+  stable var r1 = Region.new();
+  stable var r2 = Region.new();
+
+  let block_size_in_pages = 128 : Nat64;
+
+  P.debugPrint "grow three big regions (including region0).";
+  // Interleave growing regions by a block each:
+  do {
+    ignore StableMemory.grow(block_size_in_pages);
+    ignore Region.grow(r1, block_size_in_pages);
+    ignore Region.grow(r2, block_size_in_pages);
+
+    ignore StableMemory.grow(block_size_in_pages);
+    ignore Region.grow(r1, block_size_in_pages);
+    ignore Region.grow(r2, block_size_in_pages);
+
+    ignore StableMemory.grow(block_size_in_pages);
+    ignore Region.grow(r1, block_size_in_pages);
+    ignore Region.grow(r2, block_size_in_pages);
+  };
+  P.debugPrint "grow three big regions: done.";
+
+  system func preupgrade() {
+    P.debugPrint("upgrading... n=" # debug_show n);
+    n += 1;
+  };
+  public func sanityTest() {
+    P.debugPrint("sanity check. n=" # debug_show n);
+    assert Region.id(r1) == 16;
+    assert Region.id(r2) == 17;
+  };
+}
+
+//SKIP run
+//SKIP run-low
+//SKIP run-ir
+// too slow on ic-ref-run:
+//SKIP comp-ref
+//CALL ingress sanityTest "DIDL\x00\x00"
+//CALL ingress __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+//CALL upgrade ""
+//CALL ingress sanityTest "DIDL\x00\x00"
diff --git a/test/run-drun/stable-size-no-overflow.mo b/test/run-drun/stable-size-no-overflow.mo
index 7c697fef11d..bad01118990 100644
--- a/test/run-drun/stable-size-no-overflow.mo
+++ b/test/run-drun/stable-size-no-overflow.mo
@@ -1,3 +1,4 @@
+//ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
 import P "mo:⛔";
 import SM "stable-mem/StableMemory";
 
diff --git a/test/run-drun/stable-size-overflow.mo b/test/run-drun/stable-size-overflow.mo
new file mode 100644
index 00000000000..a544987089c
--- /dev/null
+++ b/test/run-drun/stable-size-overflow.mo
@@ -0,0 +1,25 @@
+//CLASSICAL-PERSISTENCE-ONLY
+import P "mo:⛔";
+import SM "stable-mem/StableMemory";
+
+actor {
+
+  ignore SM.grow(1);
+
+  let page : Blob = SM.loadBlob(0,65536);
+  assert (page.size() == 65536);
+
+  stable
+  let _a : [Blob] = P.Array_tabulate<Blob>(65536,func _ { page });
+
+  system func preupgrade() {
+   P.debugPrint("upgrading...");
+  };
+}
+
+//SKIP run
+//SKIP run-low
+//SKIP run-ir
+
+//CALL upgrade ""
+
diff --git a/test/run-drun/tuple-record-mismatch.drun b/test/run-drun/tuple-record-mismatch.drun
index 729eea35083..125a6d03d89 100644
--- a/test/run-drun/tuple-record-mismatch.drun
+++ b/test/run-drun/tuple-record-mismatch.drun
@@ -1,3 +1,4 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
 install $ID tuple-record-mismatch/version0.mo ""
 upgrade $ID tuple-record-mismatch/version0.mo ""
 upgrade $ID tuple-record-mismatch/version1.mo ""
diff --git a/test/run-drun/tuple-stabilization.drun b/test/run-drun/tuple-stabilization.drun
new file mode 100644
index 00000000000..6f13b2cf801
--- /dev/null
+++ b/test/run-drun/tuple-stabilization.drun
@@ -0,0 +1,27 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+# SKIP ic-ref-run
+install $ID tuple-stabilization/version0.mo ""
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID tuple-stabilization/version0.mo ""
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID tuple-stabilization/version1.mo ""
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID tuple-stabilization/version1.mo ""
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID tuple-stabilization/version2.mo ""
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID tuple-stabilization/version3.mo ""
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID tuple-stabilization/version4.mo ""
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID tuple-stabilization/version5.mo ""
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID tuple-stabilization/version0.mo ""
+ingress $ID print "DIDL\x00\x00"
+ingress $ID __motoko_stabilize_before_upgrade "DIDL\x00\x00"
+upgrade $ID tuple-stabilization/version0.mo ""
+ingress $ID print "DIDL\x00\x00"
diff --git a/test/run-drun/tuple-stabilization/version0.mo b/test/run-drun/tuple-stabilization/version0.mo
new file mode 100644
index 00000000000..695f6230a75
--- /dev/null
+++ b/test/run-drun/tuple-stabilization/version0.mo
@@ -0,0 +1,15 @@
+import Prim "mo:prim";
+
+actor {
+    type TreeType = ?(Nat, TreeType, TreeType);
+
+    stable var pair = (1, 2);
+    stable var largerTuple = (0, "Test", 1.23, { key = 5; value = '_' }, [-1, 2, -3]);
+    stable var tree: TreeType = ?(2, ?(1, null: TreeType, null: TreeType), ?(4, ?(3, null: TreeType, null: TreeType), ?(5, null: TreeType, null: TreeType)));
+
+    public func print() : async () {
+        Prim.debugPrint(debug_show (pair));
+        Prim.debugPrint(debug_show (largerTuple));
+        Prim.debugPrint(debug_show (tree));
+    };
+};
diff --git a/test/run-drun/tuple-stabilization/version1.mo b/test/run-drun/tuple-stabilization/version1.mo
new file mode 100644
index 00000000000..dac99f913d6
--- /dev/null
+++ b/test/run-drun/tuple-stabilization/version1.mo
@@ -0,0 +1,18 @@
+import Prim "mo:prim";
+
+// Compatible upgrade
+actor {
+    type TreeType = ?(Nat, TreeType, TreeType);
+
+    stable var unit = ();
+    stable var pair = (1, 2);
+    stable var largerTuple = (0, "Test", 1.23, { key = 5; value = '_' }, [-1, 2, -3]);
+    stable var tree: TreeType = ?(2, ?(1, null: TreeType, null: TreeType), ?(4, ?(3, null: TreeType, null: TreeType), ?(5, null: TreeType, null: TreeType)));
+
+    public func print() : async () {
+        Prim.debugPrint(debug_show (unit));
+        Prim.debugPrint(debug_show (pair));
+        Prim.debugPrint(debug_show (largerTuple));
+        Prim.debugPrint(debug_show (tree));
+    };
+};
diff --git a/test/run-drun/tuple-stabilization/version2.mo b/test/run-drun/tuple-stabilization/version2.mo
new file mode 100644
index 00000000000..21501f4bd7a
--- /dev/null
+++ b/test/run-drun/tuple-stabilization/version2.mo
@@ -0,0 +1,10 @@
+import Prim "mo:prim";
+
+// Incompatible upgrade
+actor {
+    stable var unit = (1);
+    
+    public func print() : async () {
+        Prim.debugPrint(debug_show (unit));
+    };
+};
diff --git a/test/run-drun/tuple-stabilization/version3.mo b/test/run-drun/tuple-stabilization/version3.mo
new file mode 100644
index 00000000000..f9a1cebc680
--- /dev/null
+++ b/test/run-drun/tuple-stabilization/version3.mo
@@ -0,0 +1,10 @@
+import Prim "mo:prim";
+
+// Incompatible upgrade
+actor {
+    stable var pair = (1);
+    
+    public func print() : async () {
+        Prim.debugPrint(debug_show (pair));
+    };
+};
diff --git a/test/run-drun/tuple-stabilization/version4.mo b/test/run-drun/tuple-stabilization/version4.mo
new file mode 100644
index 00000000000..06deb846566
--- /dev/null
+++ b/test/run-drun/tuple-stabilization/version4.mo
@@ -0,0 +1,10 @@
+import Prim "mo:prim";
+
+// Incompatible upgrade
+actor {
+    stable var largerTuple = ("Test", 0, 1.23, { key = 5; value = '_' }, [-1, 2, -3]);
+
+    public func print() : async () {
+        Prim.debugPrint(debug_show (largerTuple));
+    };
+};
diff --git a/test/run-drun/tuple-stabilization/version5.mo b/test/run-drun/tuple-stabilization/version5.mo
new file mode 100644
index 00000000000..50ed4bc5e9b
--- /dev/null
+++ b/test/run-drun/tuple-stabilization/version5.mo
@@ -0,0 +1,16 @@
+import Prim "mo:prim";
+
+// Incompatible update
+actor {
+    type TreeType = ?(Nat, TreeType, Null);
+
+    stable var pair = (1, 2);
+    stable var largerTuple = (0, "Test", 1.23, { key = 5; value = '_' }, [-1, 2, -3]);
+    stable var tree: TreeType = ?(2, ?(1, null: TreeType, null), null);
+
+    public func print() : async () {
+        Prim.debugPrint(debug_show (pair));
+        Prim.debugPrint(debug_show (largerTuple));
+        Prim.debugPrint(debug_show (tree));
+    };
+};
diff --git a/test/run-drun/tuple-upgrades.drun b/test/run-drun/tuple-upgrades.drun
index 6591e7ccda3..010b1fcadaf 100644
--- a/test/run-drun/tuple-upgrades.drun
+++ b/test/run-drun/tuple-upgrades.drun
@@ -1,3 +1,4 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
 # SKIP ic-ref-run
 install $ID tuple-upgrades/version0.mo ""
 ingress $ID print "DIDL\x00\x00"
diff --git a/test/run-drun/upgrade-bignat-bigint.drun b/test/run-drun/upgrade-bignat-bigint.drun
index 941ef0cf16c..eafa49c6c13 100644
--- a/test/run-drun/upgrade-bignat-bigint.drun
+++ b/test/run-drun/upgrade-bignat-bigint.drun
@@ -1,3 +1,4 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
 # SKIP ic-ref-run
 install $ID upgrade-bignat-bigint/version0.mo ""
 ingress $ID modify "DIDL\x00\x00"
diff --git a/test/run-drun/upgrade-bignums.mo b/test/run-drun/upgrade-bignums.mo
new file mode 100644
index 00000000000..baa33696edb
--- /dev/null
+++ b/test/run-drun/upgrade-bignums.mo
@@ -0,0 +1,24 @@
+import Prim "mo:prim";
+
+actor {
+    stable var unsigned : Nat = 12345678901234567890123456789012345678901234567890123456789012345678901234567890;
+    stable var signed : Int = -12345678901234567890123456789012345678901234567890123456789012345678901234567890;
+
+    public func modify() : async () {
+        unsigned := 2 * unsigned + 1;
+        signed := 2 * signed - 1;
+    };
+
+    public func print() : async () {
+        Prim.debugPrint(debug_show (unsigned));
+        Prim.debugPrint(debug_show (signed));
+    };
+};
+
+//CALL ingress print "DIDL\x00\x00"
+//CALL ingress modify "DIDL\x00\x00"
+//CALL upgrade ""
+//CALL ingress print "DIDL\x00\x00"
+//CALL ingress modify "DIDL\x00\x00"
+//CALL upgrade ""
+//CALL ingress print "DIDL\x00\x00"
diff --git a/test/run-drun/upgrade-generics.drun b/test/run-drun/upgrade-generics.drun
index a74b6226b64..f2227fc85b6 100644
--- a/test/run-drun/upgrade-generics.drun
+++ b/test/run-drun/upgrade-generics.drun
@@ -1,3 +1,4 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
 # SKIP ic-ref-run
 install $ID upgrade-generics/version0.mo ""
 ingress $ID print "DIDL\x00\x00"
diff --git a/test/run-drun/upgrade-instructions.mo b/test/run-drun/upgrade-instructions.mo
index 38489a31a36..0649918d857 100644
--- a/test/run-drun/upgrade-instructions.mo
+++ b/test/run-drun/upgrade-instructions.mo
@@ -1,3 +1,4 @@
+//ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
 import Prim "mo:prim";
 
 actor {
diff --git a/test/run-drun/upgrade-mutable-array.drun b/test/run-drun/upgrade-mutable-array.drun
index 6249be67613..55ca16e235d 100644
--- a/test/run-drun/upgrade-mutable-array.drun
+++ b/test/run-drun/upgrade-mutable-array.drun
@@ -1,3 +1,4 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
 # SKIP ic-ref-run
 install $ID upgrade-mutable-array/version0.mo ""
 ingress $ID test "DIDL\x00\x00"
diff --git a/test/run-drun/upgrade-mutable-service.drun b/test/run-drun/upgrade-mutable-service.drun
index 21a1a6c172e..bbae78a28e3 100644
--- a/test/run-drun/upgrade-mutable-service.drun
+++ b/test/run-drun/upgrade-mutable-service.drun
@@ -1,3 +1,4 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
 # SKIP ic-ref-run
 install $ID upgrade-mutable-service/version0.mo ""
 ingress $ID initialize "DIDL\x00\x00"
diff --git a/test/run-drun/upgrade-mutable-variant.drun b/test/run-drun/upgrade-mutable-variant.drun
index 76601ff8da5..347fcc0b91e 100644
--- a/test/run-drun/upgrade-mutable-variant.drun
+++ b/test/run-drun/upgrade-mutable-variant.drun
@@ -1,3 +1,4 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
 # SKIP ic-ref-run
 install $ID upgrade-mutable-variant/version0.mo ""
 ingress $ID test "DIDL\x00\x00"
diff --git a/test/run-drun/upgrade-mutable.drun b/test/run-drun/upgrade-mutable.drun
index f66bffb052d..9053937824b 100644
--- a/test/run-drun/upgrade-mutable.drun
+++ b/test/run-drun/upgrade-mutable.drun
@@ -1,3 +1,4 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
 # SKIP ic-ref-run
 install $ID upgrade-mutable/version0.mo ""
 ingress $ID modify "DIDL\x00\x00"
diff --git a/test/run-drun/upgrade-nat-to-int.drun b/test/run-drun/upgrade-nat-to-int.drun
index 916b550f9da..498b6bfe685 100644
--- a/test/run-drun/upgrade-nat-to-int.drun
+++ b/test/run-drun/upgrade-nat-to-int.drun
@@ -1,3 +1,4 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
 # SKIP ic-ref-run
 install $ID upgrade-nat-to-int/version0.mo ""
 ingress $ID modify "DIDL\x00\x00"
diff --git a/test/run-drun/upgrade-non-stable.drun b/test/run-drun/upgrade-non-stable.drun
index cd320e88413..1462d50c47a 100644
--- a/test/run-drun/upgrade-non-stable.drun
+++ b/test/run-drun/upgrade-non-stable.drun
@@ -1,3 +1,4 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
 # SKIP ic-ref-run
 install $ID upgrade-non-stable/version0.mo ""
 ingress $ID print "DIDL\x00\x00"
diff --git a/test/run-drun/upgrade-non-stable/version0.mo b/test/run-drun/upgrade-non-stable/version0.mo
index 7dd6de3c5e3..87a49e87f0c 100644
--- a/test/run-drun/upgrade-non-stable/version0.mo
+++ b/test/run-drun/upgrade-non-stable/version0.mo
@@ -3,16 +3,26 @@ import Prim "mo:prim";
 actor {
   let temporary = 1;
 
+  func f() {
+    Prim.debugPrint(debug_show (temporary));
+  };
+
   stable let value : {
     stableField : Text;
   } = {
     stableField = "Version 0";
-    nonStableField = func() {
-      Prim.debugPrint(debug_show (temporary));
-    };
+    nonStableField = f;
     unreachableField = -123;
   };
 
+  stable let any : Any = f;
+  stable let tuple : (Int, Any) = (0, f);
+  stable let variant : { #tag : Any } = #tag f;
+  stable let record : { lab : Any } = { lab = f };
+  stable let vector : [Any] = [f];
+  stable let array : [var Any] = [var f];
+  stable let opt : ?Any = ?f;
+
   public func print() : async () {
     Prim.debugPrint(debug_show (value));
   };
diff --git a/test/run-drun/upgrade-non-stable/version1.mo b/test/run-drun/upgrade-non-stable/version1.mo
index 93f6116c0a1..38770680751 100644
--- a/test/run-drun/upgrade-non-stable/version1.mo
+++ b/test/run-drun/upgrade-non-stable/version1.mo
@@ -1,11 +1,18 @@
 import Prim "mo:prim";
 
 actor {
-  stable let value : {
-  } = {
+  stable let value : {} = {
     stableField = "Version 1";
   };
 
+  stable let any : Any = null;
+  stable let tuple : (Int, Any) = (0, null);
+  stable let variant : { #tag : Any } = #tag null;
+  stable let record : { lab : Any } = { lab = null };
+  stable let vector : [Any] = [null];
+  stable let array : [var Any] = [var null];
+  stable let opt : ?Any = null;
+
   public func print() : async () {
     Prim.debugPrint(debug_show (value));
   };
diff --git a/test/run-drun/upgrade-recursive-type.drun b/test/run-drun/upgrade-recursive-type.drun
index b7260ae98bc..f655e9fb9eb 100644
--- a/test/run-drun/upgrade-recursive-type.drun
+++ b/test/run-drun/upgrade-recursive-type.drun
@@ -1,3 +1,4 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
 # SKIP ic-ref-run
 install $ID upgrade-recursive-type/version0.mo ""
 ingress $ID increase "DIDL\x00\x01\x7d\x0F"
diff --git a/test/run-drun/upgrade-remove-add-fields.drun b/test/run-drun/upgrade-remove-add-fields.drun
index c9fa228534a..9b2b4c4a47d 100644
--- a/test/run-drun/upgrade-remove-add-fields.drun
+++ b/test/run-drun/upgrade-remove-add-fields.drun
@@ -1,3 +1,4 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
 # SKIP ic-ref-run
 install $ID upgrade-remove-add-fields/version0.mo ""
 ingress $ID increase "DIDL\x00\x01\x7d\x0F"
diff --git a/test/run-drun/upgrade-service.drun b/test/run-drun/upgrade-service.drun
index 5879eacc822..7a279360aaa 100644
--- a/test/run-drun/upgrade-service.drun
+++ b/test/run-drun/upgrade-service.drun
@@ -1,3 +1,4 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
 # SKIP ic-ref-run
 install $ID upgrade-service/version0.mo ""
 ingress $ID initialize "DIDL\x00\x00"
diff --git a/test/run-drun/upgrade-to-any.drun b/test/run-drun/upgrade-to-any.drun
index ea5756edae1..693fc5709d0 100644
--- a/test/run-drun/upgrade-to-any.drun
+++ b/test/run-drun/upgrade-to-any.drun
@@ -1,3 +1,4 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
 # SKIP ic-ref-run
 install $ID upgrade-to-any/version0.mo ""
 ingress $ID check "DIDL\x00\x00"
diff --git a/test/run-drun/upgrade-to-any/version0.mo b/test/run-drun/upgrade-to-any/version0.mo
index 2d2d80d943a..5763645a096 100644
--- a/test/run-drun/upgrade-to-any/version0.mo
+++ b/test/run-drun/upgrade-to-any/version0.mo
@@ -3,11 +3,11 @@ import Prim "mo:prim";
 actor {
    Prim.debugPrint("Version 0");
 
-   let allocationSize = 40_000_000;
+   let allocationSize = 64 * 1024 * 1024;
 
    func largeAllocation(name: Text): [var Nat] {
       Prim.debugPrint("Initialize " # name);
-      Prim.Array_init<Nat>(allocationSize / 4, 0);
+      Prim.Array_init<Nat>(allocationSize / 8, 0);
    };
 
    stable var firstVariable : [var Nat] = largeAllocation("first variable");
@@ -16,6 +16,7 @@ actor {
       // Extra GC increments.
       await async {};
       await async {};
+      await async {};
       // Check that first variable has been cleared and the first array has been reclaimed.
       assert(Prim.rts_heap_size() >= allocationSize);
    };
diff --git a/test/run-drun/upgrade-to-any/version1.mo b/test/run-drun/upgrade-to-any/version1.mo
index bf0f251ca60..6532ded262b 100644
--- a/test/run-drun/upgrade-to-any/version1.mo
+++ b/test/run-drun/upgrade-to-any/version1.mo
@@ -3,11 +3,11 @@ import Prim "mo:prim";
 actor {
    Prim.debugPrint("Version 1");
 
-   let allocationSize = 40_000_000;
+   let allocationSize = 64 * 1024 * 1024;
 
    func largeAllocation(name: Text): [var Nat] {
       Prim.debugPrint("Initialize " # name);
-      Prim.Array_init<Nat>(allocationSize / 4, 0);
+      Prim.Array_init<Nat>(allocationSize / 8, 0);
    };
 
    stable var firstVariable : Any = largeAllocation("first variable");
@@ -17,6 +17,7 @@ actor {
       // Extra GC increments.
       await async {};
       await async {};
+      await async {};
       // Check that first variable has been cleared and the first array has been reclaimed.
       assert(Prim.rts_heap_size() >= allocationSize);
       assert(Prim.rts_heap_size() < 2 * allocationSize);
diff --git a/test/run-drun/upgrade-to-any/version2.mo b/test/run-drun/upgrade-to-any/version2.mo
index 9051e2fd5cf..4fe5c28804e 100644
--- a/test/run-drun/upgrade-to-any/version2.mo
+++ b/test/run-drun/upgrade-to-any/version2.mo
@@ -3,7 +3,7 @@ import Prim "mo:prim";
 actor {
    Prim.debugPrint("Version 2");
 
-   let allocationSize = 40_000_000;
+   let allocationSize = 64 * 1024 * 1024;
 
    func largeAllocation(name: Text): [var Nat] {
       Prim.trap("Should not be called");
@@ -16,6 +16,7 @@ actor {
       // Extra GC increments.
       await async {};
       await async {};
+      await async {};
       // Check that both variables have been cleared and both arrays have been reclaimed.
       assert(Prim.rts_heap_size() < allocationSize);
    }
diff --git a/test/run-drun/variant-upgrades.drun b/test/run-drun/variant-upgrades.drun
index b27a021eb78..e4239420556 100644
--- a/test/run-drun/variant-upgrades.drun
+++ b/test/run-drun/variant-upgrades.drun
@@ -1,3 +1,4 @@
+# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
 # SKIP ic-ref-run
 install $ID variant-upgrades/version0.mo ""
 ingress $ID modify "DIDL\x00\x01\x7d\x0F"
diff --git a/test/run.sh b/test/run.sh
index 5ef2deae36b..b0713334276 100755
--- a/test/run.sh
+++ b/test/run.sh
@@ -26,7 +26,7 @@ DTESTS=no
 IDL=no
 PERF=no
 VIPER=no
-WASMTIME_OPTIONS="-C cache=n -W nan-canonicalization=y -W multi-memory -W bulk-memory"
+WASMTIME_OPTIONS="-C cache=n -W nan-canonicalization=y -W memory64 -W multi-memory -W bulk-memory"
 WRAP_drun=$(realpath $(dirname $0)/drun-wrapper.sh)
 WRAP_ic_ref_run=$(realpath $(dirname $0)/ic-ref-run-wrapper.sh)
 SKIP_RUNNING=${SKIP_RUNNING:-no}
@@ -227,7 +227,7 @@ then
       HAVE_drun=no
     fi
   fi
-  # ic-wasm does not yet support passive data segments
+  # TODO: Re-enable when ic_wasm supports Wasm64 and passive data segments
   # if ic-wasm --help >& /dev/null
   # then
   #   HAVE_ic_wasm=yes
@@ -306,6 +306,22 @@ do
     else
       TEST_MOC_ARGS=$EXTRA_MOC_ARGS
     fi
+    if grep -q "//ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY" $base.mo
+    then
+      if [[ $EXTRA_MOC_ARGS != *"--enhanced-orthogonal-persistence"* ]]
+      then
+        $ECHO " Skipped (not applicable to classical orthogonal persistence)"
+        continue
+      fi
+    fi
+    if grep -q "//CLASSICAL-PERSISTENCE-ONLY" $base.mo
+    then
+      if [[ $EXTRA_MOC_ARGS == *"--enhanced-orthogonal-persistence"* ]]
+      then
+        $ECHO " Skipped (not applicable to enhanced persistence)"
+        continue
+      fi
+    fi
     if [ $VIPER = 'yes' ]
     then
       TEST_MOC_ARGS="$TEST_MOC_ARGS --package base pkg/base"
@@ -408,8 +424,8 @@ do
 
         if [ "$SKIP_VALIDATE" != yes ]
         then
-          run_if wasm valid wasm-validate --enable-multi-memory $out/$base.wasm
-          run_if ref.wasm valid-ref wasm-validate --enable-multi-memory $out/$base.ref.wasm
+          run_if wasm valid wasm-validate --enable-memory64 --enable-multi-memory $out/$base.wasm
+          run_if ref.wasm valid-ref wasm-validate --enable-memory64 --enable-multi-memory $out/$base.ref.wasm
         fi
 
         if [ -e $out/$base.wasm ]
@@ -420,7 +436,7 @@ do
             if grep -F -q CHECK $mangled
             then
               $ECHO -n " [FileCheck]"
-              wasm2wat --enable-multi-memory --no-check $out/$base.wasm > $out/$base.wat
+              wasm2wat --enable-memory64 --enable-multi-memory --no-check $out/$base.wasm > $out/$base.wat
               cat $out/$base.wat | FileCheck $mangled > $out/$base.filecheck 2>&1
               diff_files="$diff_files $base.filecheck"
             fi
@@ -484,7 +500,28 @@ do
       then
         continue
       fi
-
+      if grep -q "# ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY" $(basename $file)
+      then
+        if [[ $EXTRA_MOC_ARGS != *"--enhanced-orthogonal-persistence"* ]]
+        then
+          continue
+        fi
+      fi
+      if grep -q "# CLASSICAL-PERSISTENCE-ONLY" $(basename $file)
+      then
+        if [[ $EXTRA_MOC_ARGS == *"--enhanced-orthogonal-persistence"* ]]
+        then
+          continue
+        fi
+      fi
+      if grep -q "# DEFAULT-GC-ONLY" $(basename $file)
+      then
+        if [[ $EXTRA_MOC_ARGS == *"--copying-gc"* ]] || [[ $EXTRA_MOC_ARGS == *"--compacting-gc"* ]] || [[ $EXTRA_MOC_ARGS == *"--generational-gc"* ]] || [[ $EXTRA_MOC_ARGS == *"--incremental-gc"* ]]
+        then
+          continue
+        fi
+      fi
+      
       have_var_name="HAVE_${runner//-/_}"
       if [ ${!have_var_name} != yes ]
       then
@@ -536,7 +573,7 @@ do
 
     if [ -e $out/$base.linked.wasm ]
     then
-        run wasm2wat wasm2wat $out/$base.linked.wasm -o $out/$base.linked.wat
+        run wasm2wat wasm2wat --enable-memory64 $out/$base.linked.wasm -o $out/$base.linked.wat
         diff_files="$diff_files $base.linked.wat"
     fi
   ;;
diff --git a/test/run/beyond-4GB.mo b/test/run/beyond-4GB.mo
new file mode 100644
index 00000000000..26a927b70d4
--- /dev/null
+++ b/test/run/beyond-4GB.mo
@@ -0,0 +1,23 @@
+//ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+// test allocation beyond the 32-bit address space
+import P "mo:⛔";
+do {
+
+  let expectedSize = 5 * 1024 * 1024 * 1024; // 10 GB
+  var c = 5;
+
+  while(c > 0) {
+    ignore P.Array_init<Nat8>(1024*1024*1024/8, 0xFF);
+    c -= 1;
+  };
+
+  
+  assert(P.rts_memory_size() > expectedSize);
+  assert(P.rts_heap_size() > expectedSize);
+}
+
+//SKIP run
+//SKIP run-low
+//SKIP run-ir
+
+
diff --git a/test/run/compact-float.mo b/test/run/compact-float.mo
new file mode 100644
index 00000000000..268195bfa46
--- /dev/null
+++ b/test/run/compact-float.mo
@@ -0,0 +1,21 @@
+import Prim "mo:prim";
+
+let maxCompactFloat32 = 1073741823.0;
+Prim.debugPrint(debug_show (Prim.floatToInt(maxCompactFloat32)));
+Prim.debugPrint(debug_show (Prim.floatToInt(maxCompactFloat32 - 1)));
+Prim.debugPrint(debug_show (Prim.floatToInt(maxCompactFloat32 + 1)));
+
+let minCompactFloat32 = -1073741824.0;
+Prim.debugPrint(debug_show (Prim.floatToInt(minCompactFloat32)));
+Prim.debugPrint(debug_show (Prim.floatToInt(minCompactFloat32 - 1)));
+Prim.debugPrint(debug_show (Prim.floatToInt(minCompactFloat32 + 1)));
+
+let maxCompactFloat64 = 4611686018427387400.0;
+let minNonCompactFloat64 = 4611686018427388000.0;
+Prim.debugPrint(debug_show (Prim.floatToInt(maxCompactFloat64)));
+Prim.debugPrint(debug_show (Prim.floatToInt(minNonCompactFloat64)));
+
+let minCompactFloat64 = -4611686018427387400.0;
+let maxNonCompactFloat64 = -4611686018427388000.0;
+Prim.debugPrint(debug_show (Prim.floatToInt(minCompactFloat64)));
+Prim.debugPrint(debug_show (Prim.floatToInt(maxNonCompactFloat64)));
diff --git a/test/run/empty-if.mo b/test/run/empty-if-classical.mo
similarity index 88%
rename from test/run/empty-if.mo
rename to test/run/empty-if-classical.mo
index e1d22c03bb5..867c15193e6 100644
--- a/test/run/empty-if.mo
+++ b/test/run/empty-if-classical.mo
@@ -1,3 +1,4 @@
+//CLASSICAL-PERSISTENCE-ONLY
 var a = 'N';
 
 func foo() = if (a == 'Y') {} else {};
diff --git a/test/run/empty-if-eop.mo b/test/run/empty-if-eop.mo
new file mode 100644
index 00000000000..05ed3f756e3
--- /dev/null
+++ b/test/run/empty-if-eop.mo
@@ -0,0 +1,17 @@
+//ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+var a = 'N';
+
+func foo() = if (a == 'Y') {} else {};
+func barX() = if (a == 'Y') {} else {};
+
+barX();
+foo();
+
+// CHECK: func $foo
+// CHECK: i64.eq
+// CHECK-NEXT: drop
+// CHECK: func $barX
+
+//SKIP run
+//SKIP run-ir
+//SKIP run-low
diff --git a/test/run/float-fmt.mo b/test/run/float-fmt-classical.mo
similarity index 98%
rename from test/run/float-fmt.mo
rename to test/run/float-fmt-classical.mo
index 264e5a1cee8..2c1103babc8 100644
--- a/test/run/float-fmt.mo
+++ b/test/run/float-fmt-classical.mo
@@ -1,3 +1,4 @@
+//CLASSICAL-PERSISTENCE-ONLY
 import Prim "mo:⛔";
 
 let pi = 3.141592653589793238;
diff --git a/test/run/float-fmt-eop.mo b/test/run/float-fmt-eop.mo
new file mode 100644
index 00000000000..e165628a973
--- /dev/null
+++ b/test/run/float-fmt-eop.mo
@@ -0,0 +1,41 @@
+//ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+import Prim "mo:⛔";
+
+let pi = 3.141592653589793238;
+
+Prim.debugPrint "fixed Float";
+Prim.debugPrint(Prim.floatToFormattedText(pi, 0, 0));
+Prim.debugPrint(Prim.floatToFormattedText(pi, 1, 0));
+Prim.debugPrint(Prim.floatToFormattedText(pi, 4, 0));
+Prim.debugPrint(Prim.floatToFormattedText(pi, 9, 0));
+Prim.debugPrint(Prim.floatToFormattedText(pi, 16, 0));
+Prim.debugPrint(Prim.floatToFormattedText(pi, 17, 0));
+Prim.debugPrint(Prim.floatToFormattedText(pi, 20, 0));
+
+Prim.debugPrint "exponential Float";
+Prim.debugPrint(Prim.floatToFormattedText(pi, 0, 1));
+Prim.debugPrint(Prim.floatToFormattedText(pi, 1, 1));
+Prim.debugPrint(Prim.floatToFormattedText(pi, 4, 1));
+Prim.debugPrint(Prim.floatToFormattedText(pi, 9, 1));
+Prim.debugPrint(Prim.floatToFormattedText(pi, 16, 1));
+Prim.debugPrint(Prim.floatToFormattedText(pi, 17, 1));
+Prim.debugPrint(Prim.floatToFormattedText(pi, 20, 1));
+
+Prim.debugPrint "generic Float";
+Prim.debugPrint(Prim.floatToFormattedText(pi, 0, 2));
+Prim.debugPrint(Prim.floatToFormattedText(pi, 1, 2));
+Prim.debugPrint(Prim.floatToFormattedText(pi, 4, 2));
+Prim.debugPrint(Prim.floatToFormattedText(pi, 9, 2));
+Prim.debugPrint(Prim.floatToFormattedText(pi, 16, 2));
+Prim.debugPrint(Prim.floatToFormattedText(pi, 17, 2));
+Prim.debugPrint(Prim.floatToFormattedText(pi, 20, 2));
+
+// TODO: Support for 64-bit
+// Prim.debugPrint "hex Float";
+// Prim.debugPrint(Prim.floatToFormattedText(pi, 0, 3));
+// Prim.debugPrint(Prim.floatToFormattedText(pi, 1, 3));
+// Prim.debugPrint(Prim.floatToFormattedText(pi, 4, 3));
+// Prim.debugPrint(Prim.floatToFormattedText(pi, 9, 3));
+// Prim.debugPrint(Prim.floatToFormattedText(pi, 16, 3));
+// Prim.debugPrint(Prim.floatToFormattedText(pi, 17, 3));
+// Prim.debugPrint(Prim.floatToFormattedText(pi, 20, 3));
diff --git a/test/run/float-ops.mo b/test/run/float-ops.mo
index 71cd2793557..3819d498b78 100644
--- a/test/run/float-ops.mo
+++ b/test/run/float-ops.mo
@@ -29,8 +29,9 @@ assert (not isNegative(positiveNaN));
 assert (isNegative(negativeNaN));
 assert (isNegative(negate(positiveNaN)));
 assert (not isNegative(negate(negativeNaN)));
-Prim.debugPrint(debug_show(positiveNaN));
-Prim.debugPrint(debug_show(negativeNaN));
+// Difference between 32-bit and 64-bit version. 64-bit is even more accurate (with correct sign bit on `nan`).
+// Prim.debugPrint(debug_show(positiveNaN));
+// Prim.debugPrint(debug_show(negativeNaN));
 
 assert (Prim.floatAbs(9.7) == 9.7);
 assert (Prim.floatAbs(-9.7) == 9.7);
diff --git a/test/run/idl-ops.mo b/test/run/idl-ops.mo
index ebcb10a4f0c..0650d2e373a 100644
--- a/test/run/idl-ops.mo
+++ b/test/run/idl-ops.mo
@@ -50,7 +50,7 @@ assert((?arrayNat) == deserArrayInt (serArrayInt arrayNat));
 assert(null == deserArrayNat (serArrayInt arrayInt));
 assert((?arrayInt) == deserArrayInt (serArrayInt arrayInt));
 let heapDifference = Prim.rts_heap_size() : Int - started_with;
-assert(heapDifference <= 40_000);
+assert(heapDifference <= 50_000);
 
 //SKIP run
 //SKIP run-ir
diff --git a/test/run/idl.mo b/test/run/idl.mo
index 83ad7aae6ab..5e9d777999c 100644
--- a/test/run/idl.mo
+++ b/test/run/idl.mo
@@ -45,7 +45,9 @@ assert(arrayNat == deserArrayInt (serArrayNat arrayNat));
 assert(arrayNat == deserArrayInt (serArrayInt arrayNat));
 assert(arrayInt == deserArrayInt (serArrayInt arrayInt));
 let heapDifference = Prim.rts_heap_size() : Int - started_with;
-assert(heapDifference == 5_388);
+
+// Difference between enhanced orthogonal persistence and classical persistence (with and without incremental GC).
+assert(heapDifference == 2_816 or heapDifference == 4_488 or heapDifference == 4_888);
 
 //SKIP run
 //SKIP run-ir
diff --git a/test/run/if-swap.mo b/test/run/if-swap.mo
deleted file mode 100644
index e68e76f5903..00000000000
--- a/test/run/if-swap.mo
+++ /dev/null
@@ -1,12 +0,0 @@
-func wantSeeSwap(x : Bool) : Nat =
-    if (not x) 42 else 25;
-
-ignore(wantSeeSwap(true));
-
-// FHECK-LABEL: (func $wantSeeSwap
-// FHECK-NEXT: local.get $x
-// FHECK-NEXT: if (result i32)
-// FHECK-NEXT: i32.const 50
-// FHECK-NEXT: else
-// FHECK-NEXT: i32.const 84
-
diff --git a/test/run/inc-oom.mo b/test/run/inc-oom.mo
deleted file mode 100644
index 0af9c152ea2..00000000000
--- a/test/run/inc-oom.mo
+++ /dev/null
@@ -1,18 +0,0 @@
-// test incremental oom by allocating 5 GB, one GB at a time
-import P "mo:⛔";
-do {
-
-  var c = 5;
-
-  while(c > 0) {
-    let a : [var Nat8] = P.Array_init<Nat8>(1024*1024*1024/4, 0xFF);
-    c -= 1;
-  };
-
-}
-
-//SKIP run
-//SKIP run-low
-//SKIP run-ir
-
-
diff --git a/test/run/issue1356.mo b/test/run/issue1356-classical.mo
similarity index 98%
rename from test/run/issue1356.mo
rename to test/run/issue1356-classical.mo
index 1e03d16e41b..334be5dc1af 100644
--- a/test/run/issue1356.mo
+++ b/test/run/issue1356-classical.mo
@@ -1,3 +1,4 @@
+//CLASSICAL-PERSISTENCE-ONLY
 // FHECK-LABEL: (func $init
 
 func matchNat(n : Nat) : Bool =
diff --git a/test/run/issue1356-enhanced.mo b/test/run/issue1356-enhanced.mo
new file mode 100644
index 00000000000..70c75b4f036
--- /dev/null
+++ b/test/run/issue1356-enhanced.mo
@@ -0,0 +1,39 @@
+//ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+// CHECK-LABEL: (func $init
+
+func matchNat(n : Nat) : Bool =
+         switch n { case 1073741823 true
+                  ; case _ false };
+// CHECK-LABEL: (func $matchNat
+// CHECK:        local.get $switch_in
+// CHECK-NEXT:   i64.const 4294967294
+// CHECK-NEXT:   call $B_eq
+
+func matchInt(n : Int) : Bool =
+         switch n { case (-1073741824) true
+                  ; case 1073741823 true
+                  ; case _ false };
+// CHECK-LABEL: (func $matchInt
+// CHECK:        local.get $switch_in
+// CHECK-NEXT:   i64.const -4294967294
+// CHECK-NEXT:   $B_eq
+// CHECK:        local.get $switch_in
+// CHECK-NEXT:   i64.const 4294967294
+// CHECK-NEXT:   $B_eq
+
+func match8(n : Nat8) : Bool = switch n { case 42 true; case _ false };
+// CHECK-LABEL: (func $match8
+// CHECK:        i64.const 3044433348102455296
+// CHECK-NEXT:   i64.eq
+
+func match16(n : Nat16) : Bool = switch n { case 42 true; case _ false };
+// CHECK-LABEL: (func $match16
+// CHECK:        i64.const 11892317766025216
+// CHECK-NEXT:   i64.eq
+
+// NB: reverse order, so that things appear in order
+assert (match16(42));
+assert (match8(42));
+assert (matchInt(1073741823));
+assert (matchInt(-1073741824));
+assert (matchNat(1073741823));
diff --git a/test/run/leb-random.mo b/test/run/leb-random.mo
new file mode 100644
index 00000000000..0c37e82ddcb
--- /dev/null
+++ b/test/run/leb-random.mo
@@ -0,0 +1,44 @@
+object Random {
+    let max = 0xF_FFFF_FFFF_FFFF_FFFF;
+    let seed = 4711;
+    var number = seed;
+
+    public func nextInt() : Int {
+        let number = +nextNat();
+        let sign = if (number % 2 == 0) { -1 } else { +1 };
+        number * sign;
+    };
+
+    public func nextNat() : Nat {
+        number := (123138118391 * number + 133489131) % 9_999_999;
+        (number * number) % max;
+    };
+};
+
+func serializeInt(a : [Int]) : Blob = to_candid (a);
+func deserialzeInt(b : Blob) : ?[Int] = from_candid (b);
+
+func serializeNat(a : [Nat]) : Blob = to_candid (a);
+func deserialzeNat(b : Blob) : ?[Nat] = from_candid (b);
+
+let rounds = 100000;
+
+var count = 0;
+while (count < rounds) {
+    let number = Random.nextInt();
+    assert ((?[number]) == deserialzeInt(serializeInt([number])));
+    count += 1;
+};
+
+
+count := 0;
+while (count < rounds) {
+    let number = Random.nextNat();
+    assert ((?[number]) == deserialzeNat(serializeNat([number])));
+    count += 1;
+};
+
+
+//SKIP run
+//SKIP run-ir
+//SKIP run-low
diff --git a/test/run/ok/compact-float.run-ir.ok b/test/run/ok/compact-float.run-ir.ok
new file mode 100644
index 00000000000..ca791e80734
--- /dev/null
+++ b/test/run/ok/compact-float.run-ir.ok
@@ -0,0 +1,10 @@
++1_073_741_823
++1_073_741_822
++1_073_741_824
+-1_073_741_824
+-1_073_741_825
+-1_073_741_823
++4_611_686_018_427_387_392
++4_611_686_018_427_387_904
+-4_611_686_018_427_387_392
+-4_611_686_018_427_387_904
diff --git a/test/run/ok/compact-float.run-low.ok b/test/run/ok/compact-float.run-low.ok
new file mode 100644
index 00000000000..ca791e80734
--- /dev/null
+++ b/test/run/ok/compact-float.run-low.ok
@@ -0,0 +1,10 @@
++1_073_741_823
++1_073_741_822
++1_073_741_824
+-1_073_741_824
+-1_073_741_825
+-1_073_741_823
++4_611_686_018_427_387_392
++4_611_686_018_427_387_904
+-4_611_686_018_427_387_392
+-4_611_686_018_427_387_904
diff --git a/test/run/ok/compact-float.run.ok b/test/run/ok/compact-float.run.ok
new file mode 100644
index 00000000000..ca791e80734
--- /dev/null
+++ b/test/run/ok/compact-float.run.ok
@@ -0,0 +1,10 @@
++1_073_741_823
++1_073_741_822
++1_073_741_824
+-1_073_741_824
+-1_073_741_825
+-1_073_741_823
++4_611_686_018_427_387_392
++4_611_686_018_427_387_904
+-4_611_686_018_427_387_392
+-4_611_686_018_427_387_904
diff --git a/test/run/ok/compact-float.wasm-run.ok b/test/run/ok/compact-float.wasm-run.ok
new file mode 100644
index 00000000000..ca791e80734
--- /dev/null
+++ b/test/run/ok/compact-float.wasm-run.ok
@@ -0,0 +1,10 @@
++1_073_741_823
++1_073_741_822
++1_073_741_824
+-1_073_741_824
+-1_073_741_825
+-1_073_741_823
++4_611_686_018_427_387_392
++4_611_686_018_427_387_904
+-4_611_686_018_427_387_392
+-4_611_686_018_427_387_904
diff --git a/test/run/ok/float-fmt.run-ir.ok b/test/run/ok/float-fmt-classical.run-ir.ok
similarity index 100%
rename from test/run/ok/float-fmt.run-ir.ok
rename to test/run/ok/float-fmt-classical.run-ir.ok
diff --git a/test/run/ok/float-fmt.run-low.ok b/test/run/ok/float-fmt-classical.run-low.ok
similarity index 100%
rename from test/run/ok/float-fmt.run-low.ok
rename to test/run/ok/float-fmt-classical.run-low.ok
diff --git a/test/run/ok/float-fmt.run.ok b/test/run/ok/float-fmt-classical.run.ok
similarity index 100%
rename from test/run/ok/float-fmt.run.ok
rename to test/run/ok/float-fmt-classical.run.ok
diff --git a/test/run/ok/float-fmt.wasm-run.ok b/test/run/ok/float-fmt-classical.wasm-run.ok
similarity index 100%
rename from test/run/ok/float-fmt.wasm-run.ok
rename to test/run/ok/float-fmt-classical.wasm-run.ok
diff --git a/test/run/ok/float-fmt-eop.run-ir.ok b/test/run/ok/float-fmt-eop.run-ir.ok
new file mode 100644
index 00000000000..36f28f6951f
--- /dev/null
+++ b/test/run/ok/float-fmt-eop.run-ir.ok
@@ -0,0 +1,24 @@
+fixed Float
+3
+3.1
+3.1416
+3.141592654
+3.1415926535897931
+3.14159265358979312
+3.14159265358979311600
+exponential Float
+3e+00
+3.1e+00
+3.1416e+00
+3.141592654e+00
+3.1415926535897931e+00
+3.14159265358979312e+00
+3.14159265358979311600e+00
+generic Float
+3
+3
+3.142
+3.14159265
+3.141592653589793
+3.1415926535897931
+3.141592653589793116
diff --git a/test/run/ok/float-fmt-eop.run-low.ok b/test/run/ok/float-fmt-eop.run-low.ok
new file mode 100644
index 00000000000..36f28f6951f
--- /dev/null
+++ b/test/run/ok/float-fmt-eop.run-low.ok
@@ -0,0 +1,24 @@
+fixed Float
+3
+3.1
+3.1416
+3.141592654
+3.1415926535897931
+3.14159265358979312
+3.14159265358979311600
+exponential Float
+3e+00
+3.1e+00
+3.1416e+00
+3.141592654e+00
+3.1415926535897931e+00
+3.14159265358979312e+00
+3.14159265358979311600e+00
+generic Float
+3
+3
+3.142
+3.14159265
+3.141592653589793
+3.1415926535897931
+3.141592653589793116
diff --git a/test/run/ok/float-fmt-eop.run.ok b/test/run/ok/float-fmt-eop.run.ok
new file mode 100644
index 00000000000..36f28f6951f
--- /dev/null
+++ b/test/run/ok/float-fmt-eop.run.ok
@@ -0,0 +1,24 @@
+fixed Float
+3
+3.1
+3.1416
+3.141592654
+3.1415926535897931
+3.14159265358979312
+3.14159265358979311600
+exponential Float
+3e+00
+3.1e+00
+3.1416e+00
+3.141592654e+00
+3.1415926535897931e+00
+3.14159265358979312e+00
+3.14159265358979311600e+00
+generic Float
+3
+3
+3.142
+3.14159265
+3.141592653589793
+3.1415926535897931
+3.141592653589793116
diff --git a/test/run/ok/float-fmt-eop.wasm-run.ok b/test/run/ok/float-fmt-eop.wasm-run.ok
new file mode 100644
index 00000000000..35b1b5e1dcc
--- /dev/null
+++ b/test/run/ok/float-fmt-eop.wasm-run.ok
@@ -0,0 +1,24 @@
+fixed Float
+3
+3.1
+3.1416
+3.141592654
+3.1415926535897931
+3.14159265358979312
+3.14159265358979311600
+exponential Float
+3e0
+3.1e0
+3.1416e0
+3.141592654e0
+3.1415926535897931e0
+3.14159265358979312e0
+3.14159265358979311600e0
+generic Float
+3
+3.1
+3.1416
+3.141592654
+3.1415926535897931
+3.14159265358979312
+3.14159265358979311600
diff --git a/test/run/ok/float-ops.run-ir.ok b/test/run/ok/float-ops.run-ir.ok
index 72525491b63..743650b9509 100644
--- a/test/run/ok/float-ops.run-ir.ok
+++ b/test/run/ok/float-ops.run-ir.ok
@@ -1,7 +1,5 @@
 0
 -0
-nan:0x8_0000_0000_0000
--nan:0x8_0000_0000_0000
 2.099_999_999_999_999_6
 -2.099_999_999_999_999_6
 2.099_999_999_999_999_6
diff --git a/test/run/ok/float-ops.run-low.ok b/test/run/ok/float-ops.run-low.ok
index 72525491b63..743650b9509 100644
--- a/test/run/ok/float-ops.run-low.ok
+++ b/test/run/ok/float-ops.run-low.ok
@@ -1,7 +1,5 @@
 0
 -0
-nan:0x8_0000_0000_0000
--nan:0x8_0000_0000_0000
 2.099_999_999_999_999_6
 -2.099_999_999_999_999_6
 2.099_999_999_999_999_6
diff --git a/test/run/ok/float-ops.run.ok b/test/run/ok/float-ops.run.ok
index 72525491b63..743650b9509 100644
--- a/test/run/ok/float-ops.run.ok
+++ b/test/run/ok/float-ops.run.ok
@@ -1,7 +1,5 @@
 0
 -0
-nan:0x8_0000_0000_0000
--nan:0x8_0000_0000_0000
 2.099_999_999_999_999_6
 -2.099_999_999_999_999_6
 2.099_999_999_999_999_6
diff --git a/test/run/ok/float-ops.wasm-run.ok b/test/run/ok/float-ops.wasm-run.ok
index b494bc41734..5fd0adfa58d 100644
--- a/test/run/ok/float-ops.wasm-run.ok
+++ b/test/run/ok/float-ops.wasm-run.ok
@@ -1,7 +1,5 @@
 0.000000
 -0.000000
-nan
--nan
 2.100000
 -2.100000
 2.100000
diff --git a/test/run/ok/inc-oom.wasm-run.ok b/test/run/ok/inc-oom.wasm-run.ok
deleted file mode 100644
index 9187596c5be..00000000000
--- a/test/run/ok/inc-oom.wasm-run.ok
+++ /dev/null
@@ -1 +0,0 @@
-RTS error: Cannot grow memory
diff --git a/test/run/ok/optimise-for-array.run-ir.ok b/test/run/ok/optimise-for-array-classical.run-ir.ok
similarity index 100%
rename from test/run/ok/optimise-for-array.run-ir.ok
rename to test/run/ok/optimise-for-array-classical.run-ir.ok
diff --git a/test/run/ok/optimise-for-array.run-low.ok b/test/run/ok/optimise-for-array-classical.run-low.ok
similarity index 100%
rename from test/run/ok/optimise-for-array.run-low.ok
rename to test/run/ok/optimise-for-array-classical.run-low.ok
diff --git a/test/run/ok/optimise-for-array.run.ok b/test/run/ok/optimise-for-array-classical.run.ok
similarity index 100%
rename from test/run/ok/optimise-for-array.run.ok
rename to test/run/ok/optimise-for-array-classical.run.ok
diff --git a/test/run/ok/optimise-for-array-classical.tc.ok b/test/run/ok/optimise-for-array-classical.tc.ok
new file mode 100644
index 00000000000..76302a414fd
--- /dev/null
+++ b/test/run/ok/optimise-for-array-classical.tc.ok
@@ -0,0 +1 @@
+optimise-for-array-classical.mo:124.6-124.8: warning [M0194], unused identifier f9 (delete or rename to wildcard `_` or `_f9`)
diff --git a/test/run/ok/optimise-for-array.wasm-run.ok b/test/run/ok/optimise-for-array-classical.wasm-run.ok
similarity index 100%
rename from test/run/ok/optimise-for-array.wasm-run.ok
rename to test/run/ok/optimise-for-array-classical.wasm-run.ok
diff --git a/test/run/ok/optimise-for-array-enhanced.run-ir.ok b/test/run/ok/optimise-for-array-enhanced.run-ir.ok
new file mode 100644
index 00000000000..7a4990793f9
--- /dev/null
+++ b/test/run/ok/optimise-for-array-enhanced.run-ir.ok
@@ -0,0 +1,12 @@
+hello
+world
+hello
+mutable
+world
+hello
+mutable
+world
+hello
+immutable
+world
+want to see you
diff --git a/test/run/ok/optimise-for-array-enhanced.run-low.ok b/test/run/ok/optimise-for-array-enhanced.run-low.ok
new file mode 100644
index 00000000000..7a4990793f9
--- /dev/null
+++ b/test/run/ok/optimise-for-array-enhanced.run-low.ok
@@ -0,0 +1,12 @@
+hello
+world
+hello
+mutable
+world
+hello
+mutable
+world
+hello
+immutable
+world
+want to see you
diff --git a/test/run/ok/optimise-for-array-enhanced.run.ok b/test/run/ok/optimise-for-array-enhanced.run.ok
new file mode 100644
index 00000000000..7a4990793f9
--- /dev/null
+++ b/test/run/ok/optimise-for-array-enhanced.run.ok
@@ -0,0 +1,12 @@
+hello
+world
+hello
+mutable
+world
+hello
+mutable
+world
+hello
+immutable
+world
+want to see you
diff --git a/test/run/ok/optimise-for-array-enhanced.tc.ok b/test/run/ok/optimise-for-array-enhanced.tc.ok
new file mode 100644
index 00000000000..2bf3ae6232f
--- /dev/null
+++ b/test/run/ok/optimise-for-array-enhanced.tc.ok
@@ -0,0 +1 @@
+optimise-for-array-enhanced.mo:124.6-124.8: warning [M0194], unused identifier f9 (delete or rename to wildcard `_` or `_f9`)
diff --git a/test/run/ok/optimise-for-array-enhanced.wasm-run.ok b/test/run/ok/optimise-for-array-enhanced.wasm-run.ok
new file mode 100644
index 00000000000..7a4990793f9
--- /dev/null
+++ b/test/run/ok/optimise-for-array-enhanced.wasm-run.ok
@@ -0,0 +1,12 @@
+hello
+world
+hello
+mutable
+world
+hello
+mutable
+world
+hello
+immutable
+world
+want to see you
diff --git a/test/run/ok/optimise-for-array.tc.ok b/test/run/ok/optimise-for-array.tc.ok
deleted file mode 100644
index 837540a7c42..00000000000
--- a/test/run/ok/optimise-for-array.tc.ok
+++ /dev/null
@@ -1 +0,0 @@
-optimise-for-array.mo:123.6-123.8: warning [M0194], unused identifier f9 (delete or rename to wildcard `_` or `_f9`)
diff --git a/test/run/ok/stable-memory-beyond-4GB.tc.ok b/test/run/ok/stable-memory-beyond-4GB.tc.ok
new file mode 100644
index 00000000000..fa980983c7a
--- /dev/null
+++ b/test/run/ok/stable-memory-beyond-4GB.tc.ok
@@ -0,0 +1,2 @@
+stable-memory-beyond-4GB.mo:9.36-9.57: warning [M0199], this code is (or uses) the deprecated library `ExperimentalStableMemory`.
+Please use the `Region` library instead: https://internetcomputer.org/docs/current/motoko/main/stable-memory/stable-regions/#the-region-library or compile with flag `--experimental-stable-memory 1` to suppress this message.
diff --git a/test/run/ok/stable-memory-beyond-4GB.wasm-run.ok b/test/run/ok/stable-memory-beyond-4GB.wasm-run.ok
new file mode 100644
index 00000000000..6840afd1af6
--- /dev/null
+++ b/test/run/ok/stable-memory-beyond-4GB.wasm-run.ok
@@ -0,0 +1,4 @@
+{size = 0}
+{size = 65_537}
+{read = 0}
+{read = 123}
diff --git a/test/run/ok/stable-region-beyond-4GB.tc.ok b/test/run/ok/stable-region-beyond-4GB.tc.ok
new file mode 100644
index 00000000000..3d1aa3648a9
--- /dev/null
+++ b/test/run/ok/stable-region-beyond-4GB.tc.ok
@@ -0,0 +1,2 @@
+stable-region-beyond-4GB.mo:9.36-9.57: warning [M0199], this code is (or uses) the deprecated library `ExperimentalStableMemory`.
+Please use the `Region` library instead: https://internetcomputer.org/docs/current/motoko/main/stable-memory/stable-regions/#the-region-library or compile with flag `--experimental-stable-memory 1` to suppress this message.
diff --git a/test/run/ok/stable-region-beyond-4GB.wasm-run.ok b/test/run/ok/stable-region-beyond-4GB.wasm-run.ok
new file mode 100644
index 00000000000..6840afd1af6
--- /dev/null
+++ b/test/run/ok/stable-region-beyond-4GB.wasm-run.ok
@@ -0,0 +1,4 @@
+{size = 0}
+{size = 65_537}
+{read = 0}
+{read = 123}
diff --git a/test/run/ok/words.run-ir.ok b/test/run/ok/words-classical.run-ir.ok
similarity index 100%
rename from test/run/ok/words.run-ir.ok
rename to test/run/ok/words-classical.run-ir.ok
diff --git a/test/run/ok/words.run-low.ok b/test/run/ok/words-classical.run-low.ok
similarity index 100%
rename from test/run/ok/words.run-low.ok
rename to test/run/ok/words-classical.run-low.ok
diff --git a/test/run/ok/words.run.ok b/test/run/ok/words-classical.run.ok
similarity index 100%
rename from test/run/ok/words.run.ok
rename to test/run/ok/words-classical.run.ok
diff --git a/test/run/ok/words.wasm-run.ok b/test/run/ok/words-classical.wasm-run.ok
similarity index 100%
rename from test/run/ok/words.wasm-run.ok
rename to test/run/ok/words-classical.wasm-run.ok
diff --git a/test/run/ok/words-enhanced.run-ir.ok b/test/run/ok/words-enhanced.run-ir.ok
new file mode 100644
index 00000000000..dea7e52cf7a
--- /dev/null
+++ b/test/run/ok/words-enhanced.run-ir.ok
@@ -0,0 +1,94 @@
+8_912_765
+18_446_744_073_700_638_850
+8_917_332
+8_908_198
+31_969
+652
+2_548
+20_857_489
+4_437
+8_912_895
+8_908_458
+584_576
+35
+-326_582_449_863_721_025
+-2
+-326_582_449_863_721_025
+1_140_833_920
+18_014_398_509_482_053_630
++61
+49
+5
+set
+clear
+set
+8_912_765
+4_286_054_530
+8_917_332
+8_908_198
+31_969
+652
+2_548
+20_857_489
+4_437
+8_912_895
+8_908_458
+584_576
+35
+-76_038_403
+-2
+-76_038_403
+1_140_833_920
+4_194_373_630
++29
+17
+5
+set
+clear
+set
+55_734
+9_801
+60_301
+51_167
+31_969
+652
+930
+17_041
+4_502
+55_799
+51_297
+60_288
+35
+8_190
+-2
+56_172
+28_083
++13
+1
+5
+set
+clear
+set
+34
+221
+101
+223
+213
+9
+34
+137
+2
+99
+97
+128
+0
+30
+-2
+17
+68
++5
+0
+3
+set
+clear
+set
diff --git a/test/run/ok/words-enhanced.run-low.ok b/test/run/ok/words-enhanced.run-low.ok
new file mode 100644
index 00000000000..dea7e52cf7a
--- /dev/null
+++ b/test/run/ok/words-enhanced.run-low.ok
@@ -0,0 +1,94 @@
+8_912_765
+18_446_744_073_700_638_850
+8_917_332
+8_908_198
+31_969
+652
+2_548
+20_857_489
+4_437
+8_912_895
+8_908_458
+584_576
+35
+-326_582_449_863_721_025
+-2
+-326_582_449_863_721_025
+1_140_833_920
+18_014_398_509_482_053_630
++61
+49
+5
+set
+clear
+set
+8_912_765
+4_286_054_530
+8_917_332
+8_908_198
+31_969
+652
+2_548
+20_857_489
+4_437
+8_912_895
+8_908_458
+584_576
+35
+-76_038_403
+-2
+-76_038_403
+1_140_833_920
+4_194_373_630
++29
+17
+5
+set
+clear
+set
+55_734
+9_801
+60_301
+51_167
+31_969
+652
+930
+17_041
+4_502
+55_799
+51_297
+60_288
+35
+8_190
+-2
+56_172
+28_083
++13
+1
+5
+set
+clear
+set
+34
+221
+101
+223
+213
+9
+34
+137
+2
+99
+97
+128
+0
+30
+-2
+17
+68
++5
+0
+3
+set
+clear
+set
diff --git a/test/run/ok/words-enhanced.run.ok b/test/run/ok/words-enhanced.run.ok
new file mode 100644
index 00000000000..dea7e52cf7a
--- /dev/null
+++ b/test/run/ok/words-enhanced.run.ok
@@ -0,0 +1,94 @@
+8_912_765
+18_446_744_073_700_638_850
+8_917_332
+8_908_198
+31_969
+652
+2_548
+20_857_489
+4_437
+8_912_895
+8_908_458
+584_576
+35
+-326_582_449_863_721_025
+-2
+-326_582_449_863_721_025
+1_140_833_920
+18_014_398_509_482_053_630
++61
+49
+5
+set
+clear
+set
+8_912_765
+4_286_054_530
+8_917_332
+8_908_198
+31_969
+652
+2_548
+20_857_489
+4_437
+8_912_895
+8_908_458
+584_576
+35
+-76_038_403
+-2
+-76_038_403
+1_140_833_920
+4_194_373_630
++29
+17
+5
+set
+clear
+set
+55_734
+9_801
+60_301
+51_167
+31_969
+652
+930
+17_041
+4_502
+55_799
+51_297
+60_288
+35
+8_190
+-2
+56_172
+28_083
++13
+1
+5
+set
+clear
+set
+34
+221
+101
+223
+213
+9
+34
+137
+2
+99
+97
+128
+0
+30
+-2
+17
+68
++5
+0
+3
+set
+clear
+set
diff --git a/test/run/ok/words-enhanced.wasm-run.ok b/test/run/ok/words-enhanced.wasm-run.ok
new file mode 100644
index 00000000000..dea7e52cf7a
--- /dev/null
+++ b/test/run/ok/words-enhanced.wasm-run.ok
@@ -0,0 +1,94 @@
+8_912_765
+18_446_744_073_700_638_850
+8_917_332
+8_908_198
+31_969
+652
+2_548
+20_857_489
+4_437
+8_912_895
+8_908_458
+584_576
+35
+-326_582_449_863_721_025
+-2
+-326_582_449_863_721_025
+1_140_833_920
+18_014_398_509_482_053_630
++61
+49
+5
+set
+clear
+set
+8_912_765
+4_286_054_530
+8_917_332
+8_908_198
+31_969
+652
+2_548
+20_857_489
+4_437
+8_912_895
+8_908_458
+584_576
+35
+-76_038_403
+-2
+-76_038_403
+1_140_833_920
+4_194_373_630
++29
+17
+5
+set
+clear
+set
+55_734
+9_801
+60_301
+51_167
+31_969
+652
+930
+17_041
+4_502
+55_799
+51_297
+60_288
+35
+8_190
+-2
+56_172
+28_083
++13
+1
+5
+set
+clear
+set
+34
+221
+101
+223
+213
+9
+34
+137
+2
+99
+97
+128
+0
+30
+-2
+17
+68
++5
+0
+3
+set
+clear
+set
diff --git a/test/run/optimise-for-array.mo b/test/run/optimise-for-array-classical.mo
similarity index 90%
rename from test/run/optimise-for-array.mo
rename to test/run/optimise-for-array-classical.mo
index 45f46d115fb..703071a5a9b 100644
--- a/test/run/optimise-for-array.mo
+++ b/test/run/optimise-for-array-classical.mo
@@ -1,3 +1,4 @@
+//CLASSICAL-PERSISTENCE-ONLY
 //MOC-FLAG -fshared-code
 import Prim "mo:⛔";
 
@@ -6,13 +7,13 @@ import Prim "mo:⛔";
 // FHECK: (local $check0 i32)
 
 // FHECK-NOT:  call $@immut_array_size
-// DON'TFHECK: i32.load offset=9
+// DON'TFHECK: i32.load offset=(5 or 9) 
 // FHECK:      i32.load offset= 
 // FHECK:      i32.const 2
 // FHECK:      i32.shl
 // FHECK:      i32.lt_u
 // FHECK:      i32.add
-// DON'TFHECK: i32.load offset=13
+// DON'TFHECK: i32.load offset=(9 or 13)
 // FHECK:      local.tee $check0
 // FHECK-NEXT: call $print_text
 // FHECK:      i32.const 4
@@ -21,13 +22,13 @@ for (check0 in ["hello", "world"].vals()) { Prim.debugPrint check0 };
 
 
 // FHECK-NOT:  call $@mut_array_size
-// DON'TFHECK: i32.load offset=9
+// DON'TFHECK: i32.load offset=(5 or 9)
 // FHECK:      i32.load offset=
 // FHECK:      i32.const 2
 // FHECK-NEXT: i32.shl
 // FHECK:      i32.lt_u
 // FHECK:      i32.add
-// DON'TFHECK: i32.load offset=13
+// DON'TFHECK: i32.load offset=(9 or 13)
 // FHECK:      i32.load offset=
 // FHECK-NEXT: local.tee $check1
 // FHECK-NEXT: call $print_text
@@ -36,7 +37,7 @@ for (check1 in [var "hello", "mutable", "world"].vals()) { Prim.debugPrint check
 let array = [var "hello", "remutable", "world"];
 array[1] := "mutable";
 // FHECK-NOT:   call $@immut_array_size
-// DON'TFHECK:  i32.load offset=9
+// DON'TFHECK:  i32.load offset=(5 or 9)
 // FHECK:       i32.load offset=
 // FHECK:       i32.const 2
 // FHECK:       i32.shl
@@ -48,13 +49,13 @@ array[1] := "mutable";
 for (check2 in array.vals()) { Prim.debugPrint check2 };
 
 // FHECK-NOT:  call $@immut_array_size
-// DON'TFHECK: i32.load offset=9
+// DON'TFHECK: i32.load offset=(5 or 9)
 // FHECK:      i32.load offset=
 // FHECK:      i32.const 2
 // FHECK:      i32.shl
 // FHECK:      i32.lt_u
 // FHECK:      i32.add
-// DON'TFHECK: i32.load offset=13
+// DON'TFHECK: i32.load offset=(9 or 13)
 // FHECK:      i32.load offset=
 // FHECK-NEXT: local.tee $check3
 // interfering parentheses don't disturb us
@@ -95,7 +96,7 @@ check6[1] := "mutable";
 // this passes the IR type check, which demonstrates that no name capture happens
 for (check6 in check6.vals()) { ignore check6 };
 
-// DON'TFHECK: i32.load offset=9
+// DON'TFHECK: i32.load offset=(5 or 9)
 // FHECK:      i32.load offset=
 // FHECK:      i32.const 2
 // FHECK:      i32.shl
@@ -104,7 +105,7 @@ for (check7 in [].vals(Prim.debugPrint "want to see you")) { };
 
 // FHECK:      local.set $num8
 // FHECK-NOT:  call $@immut_array_size
-// DON'TFHECK: i32.load offset=9
+// DON'TFHECK: i32.load offset=(5 or 9)
 // FHECK:      i32.load offset=
 // FHECK:      i32.const 1
 // FHECK:      i32.shl
diff --git a/test/run/optimise-for-array-enhanced.mo b/test/run/optimise-for-array-enhanced.mo
new file mode 100644
index 00000000000..e7ef94a27d8
--- /dev/null
+++ b/test/run/optimise-for-array-enhanced.mo
@@ -0,0 +1,131 @@
+//ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+//MOC-FLAG -fshared-code
+import Prim "mo:⛔";
+
+// CHECK: (local $check0 i64)
+
+// CHECK-NOT:  call $@immut_array_size
+// DON'TCHECK: i64.load offset=17
+// CHECK:      i64.load offset= 
+// CHECK:      i64.const 2
+// CHECK:      i64.shr_s
+// CHECK-NEXT: i64.const 3
+// CHECK-NEXT: i64.shl
+// CHECK-NEXT: i64.add
+// CHECK:      local.tee $check0
+// CHECK:      i64.const 4
+// CHECK:      i64.add
+for (check0 in ["hello", "world"].vals()) { Prim.debugPrint check0 };
+
+
+// CHECK-NOT:  call $@mut_array_size
+// DON'TCHECK: i64.load offset=17
+// FIX-CHECK:      i64.const 2
+// FIX-CHECK:      i64.shr_s
+// FIX-CHECK:      i64.const 3
+// FIX-CHECK:      i64.shl
+// FIX-CHECK:      i64.add
+// DON'TCHECK: i64.load offset=25
+// CHECK:      i64.load offset=
+// CHECK:      local.tee $check1
+// CHECK:      call $print_ptr
+// CHECK:      i64.const 4
+// CHECK:      i64.add
+for (check1 in [var "hello", "mutable", "world"].vals()) { Prim.debugPrint check1 };
+
+let array = [var "hello", "remutable", "world"];
+array[1] := "mutable";
+// FIX-CHECK-NOT:   call $@immut_array_size
+// DON'TCHECK:  i64.load offset=17
+// FIX-CHECK:       i64.load offset=
+// FIX-CHECK:       i64.const 2
+// FIX-CHECK:       i64.shr_s
+// DON'T-CHECK: i64.lt_u
+// DON'T-CHECK: local.get $array
+// DON'T-CHECK: local.set $check2
+// `arr` being a `VarE` already (but we rebind anyway, otherwise we open a can of worms)
+// later when we have path compression for variables in the backend, we can bring this back
+for (check2 in array.vals()) { Prim.debugPrint check2 };
+
+// FIX-CHECK-NOT:  call $@immut_array_size
+// DON'TCHECK: i64.load offset=17
+// FIX-CHECK:      i64.load offset=
+// FIX-CHECK:      i64.const 2
+// FIX-CHECK-NEXT: i64.shr_s
+// FIX-CHECK:      i64.lt_u
+// FIX-CHECK:      i64.add
+// DON'TCHECK: i64.load offset=25
+// FIX-CHECK:      local.tee $check3
+// interfering parentheses don't disturb us
+for (check3 in (((["hello", "immutable", "world"].vals())))) { Prim.debugPrint check3 };
+
+
+// FIX-CHECK:      i64.const 170
+// FIX-CHECK:      call $B_add
+// FIX-CHECK-NEXT: call $B_eq
+// FIX-CHECK-NEXT: i32.wrap_i64
+// FIX-CHECK-NEXT: if
+// FIX-CHECK-NEXT: loop
+// FIX-CHECK-NEXT: br 0
+// FIX-CHECK-NEXT: end
+// FIX-CHECK-NEXT: unreachable
+// FIX-CHECK-NEXT: else
+// bottom iteration expression is treated fairly
+var c = 42;
+if (c == c + 1) {
+    for (check4 in (loop {}).vals()) { Prim.debugPrint check4 }
+};
+
+// FIX-CHECK:      call $B_add
+// FIX-CHECK-NEXT: call $B_eq
+// FIX-CHECK-NEXT: i32.wrap_i64
+// FIX-CHECK-NEXT: if
+// FIX-CHECK-NEXT: loop
+// FIX-CHECK-NEXT: br 0
+// FIX-CHECK-NEXT: end
+// FIX-CHECK-NEXT: unreachable
+// FIX-CHECK-NEXT: else
+// typed bottom iteration expression is treated fairly
+if (c == c + 1) {
+    for (check5 in ((loop {}) : [Text]).vals()) { Prim.debugPrint check5 }
+};
+
+let check6 = [var "hello", "immutable", "world"];
+check6[1] := "mutable";
+// `check6` being a `VarE` already and iteration variable is named identically
+// this passes the IR type check, which demonstrates that no name capture happens
+for (check6 in check6.vals()) { ignore check6 };
+
+// DON'TCHECK: i64.load offset=17
+// FIX-CHECK:      i64.load offset=
+// FIX-CHECK:      i64.const 3
+// FIX-CHECK:      i64.shl
+// argument to vals can have an effect too, expect it
+for (check7 in [].vals(Prim.debugPrint "want to see you")) { };
+
+// FIX-CHECK:      local.set $num8
+// FIX-CHECK-NOT:  call $@immut_array_size
+// CON'TFHECK: i64.load offset=17
+// FIX-CHECK:      i64.load offset=
+// FIX-CHECK:      i64.const 2
+// FIX-CHECK:      i64.shr_s
+// FIX-CHECK:      i64.lt_u
+// FIX-CHECK-NOT:  i64.add
+// FIX-CHECK:      local.tee $check8
+// FIX-CHECK-NEXT: local.get $num8
+// FIX-CHECK-NEXT: call $B_add
+var num8 = 42;
+num8 := 25;
+// `keys` is even easier to rewrite, as the "indexing expression" is just the
+// indexing variable itself
+for (check8 in ["hello", "keyed", "world"].keys()) { ignore (check8 + num8) };
+
+// polymorphic arrays should still work
+func f9<A>(array : [A]) {
+  for (check9 in array.keys()) { }
+};
+
+// make sure that one-byte-sized elements still work
+var sum10 : Nat8 = 0;
+for (check10 in ([3, 5, 7, 11] : [Nat8]).vals()) { sum10 += check10 };
+assert sum10 == 26
diff --git a/test/run/refuted-const-float.mo b/test/run/refuted-const-float.mo
index aed68a0adac..8e2e839c321 100644
--- a/test/run/refuted-const-float.mo
+++ b/test/run/refuted-const-float.mo
@@ -1,11 +1,5 @@
 // a failing pattern match that can be compiled to a trap
 let 0.67 = 3.14;
 
-// CHECK: (func $init (type
-// CHECK: call $blob_of_principal
-// CHECK: i32.const 14
-// CHECK: call $print_ptr
-// CHECK-NEXT: unreachable)
-
 //SKIP run-low
 //SKIP run-ir
diff --git a/test/run/refuted-const-option-null.mo b/test/run/refuted-const-option-null.mo
index 68f285a6fc8..ccc65afd6c9 100644
--- a/test/run/refuted-const-option-null.mo
+++ b/test/run/refuted-const-option-null.mo
@@ -1,11 +1,5 @@
 // a failing pattern match that can be compiled to a trap
 let ?b = null;
 
-// CHECK: (func $init (type
-// CHECK: call $blob_of_principal
-// CHECK: i32.const 14
-// CHECK: call $print_ptr
-// CHECK-NEXT: unreachable)
-
 //SKIP run-low
 //SKIP run-ir
diff --git a/test/run/refuted-const-option.mo b/test/run/refuted-const-option.mo
index e47f347854f..37e944c1f19 100644
--- a/test/run/refuted-const-option.mo
+++ b/test/run/refuted-const-option.mo
@@ -1,11 +1,5 @@
 // a failing pattern match that can be compiled to a trap
 let null = ?42;
 
-// CHECK: (func $init (type
-// CHECK: call $blob_of_principal
-// CHECK: i32.const 14
-// CHECK: call $print_ptr
-// CHECK-NEXT: unreachable)
-
 //SKIP run-low
 //SKIP run-ir
diff --git a/test/run/refuted-const-variant.mo b/test/run/refuted-const-variant.mo
index 90fc698290f..161d096126c 100644
--- a/test/run/refuted-const-variant.mo
+++ b/test/run/refuted-const-variant.mo
@@ -1,11 +1,5 @@
 // a failing pattern match that can be compiled to a trap
 let (#const b) = #bummer;
 
-// CHECK: (func $init (type
-// CHECK: call $blob_of_principal
-// CHECK: i32.const 14
-// CHECK: call $print_ptr
-// CHECK-NEXT: unreachable)
-
 //SKIP run-low
 //SKIP run-ir
diff --git a/test/run/stable-memory-beyond-4GB.mo b/test/run/stable-memory-beyond-4GB.mo
new file mode 100644
index 00000000000..cd737c8e74c
--- /dev/null
+++ b/test/run/stable-memory-beyond-4GB.mo
@@ -0,0 +1,25 @@
+//ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+//MOC-FLAG --max-stable-pages=1000000
+import Prim "mo:prim";
+
+let size: Nat64 = 4 * 1024 * 1024 * 1024 + 1; // 5 GB
+let wasmPageSize: Nat64 = 64 * 1024; // 64 KB
+let numberOfPages: Nat64 = (size + wasmPageSize - 1) / wasmPageSize;
+
+Prim.debugPrint(debug_show {size = Prim.stableMemorySize()});
+let result = Prim.stableMemoryGrow(numberOfPages);
+assert(result == 0);
+Prim.debugPrint(debug_show {size = Prim.stableMemorySize()});
+let location = size - 1;
+let initial = Prim.stableMemoryLoadNat8(location);
+assert(initial == 0);
+Prim.debugPrint(debug_show {read = Prim.stableMemoryLoadNat8(location)});
+let testValue: Nat8 = 123;
+Prim.stableMemoryStoreNat8(location, testValue);
+Prim.debugPrint(debug_show {read = Prim.stableMemoryLoadNat8(location)});
+let actual = Prim.stableMemoryLoadNat8(location);
+assert(actual == testValue);
+
+//SKIP run-low
+//SKIP run
+//SKIP run-ir
diff --git a/test/run/stable-region-beyond-4GB.mo b/test/run/stable-region-beyond-4GB.mo
new file mode 100644
index 00000000000..88dd581d2fa
--- /dev/null
+++ b/test/run/stable-region-beyond-4GB.mo
@@ -0,0 +1,26 @@
+//ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+//MOC-FLAG --max-stable-pages=1000000
+import Prim "mo:prim";
+
+let size: Nat64 = 4 * 1024 * 1024 * 1024 + 1; // 5 GB
+let wasmPageSize: Nat64 = 64 * 1024; // 64 KB
+let numberOfPages: Nat64 = (size + wasmPageSize - 1) / wasmPageSize;
+
+Prim.debugPrint(debug_show {size = Prim.stableMemorySize()});
+let r1 = Prim.regionNew();
+let result = Prim.regionGrow(r1, numberOfPages);
+assert(result == 0);
+Prim.debugPrint(debug_show {size = Prim.regionSize(r1)});
+let location = size - 1;
+let initial = Prim.regionLoadNat8(r1, location);
+assert(initial == 0);
+Prim.debugPrint(debug_show {read = Prim.regionLoadNat8(r1, location)});
+let testValue: Nat8 = 123;
+Prim.regionStoreNat8(r1, location, testValue);
+Prim.debugPrint(debug_show {read = Prim.regionLoadNat8(r1, location)});
+let actual = Prim.regionLoadNat8(r1, location);
+assert(actual == testValue);
+
+//SKIP run-low
+//SKIP run
+//SKIP run-ir
diff --git a/test/run/unboxed-let.mo b/test/run/unboxed-let.mo
index 2831ad26d93..3167083c4eb 100644
--- a/test/run/unboxed-let.mo
+++ b/test/run/unboxed-let.mo
@@ -35,69 +35,39 @@ func goFloat() {
 };
 goFloat();
 
-// This just checks that the above CHECK-NOT: box_i32 is up-to-date
-// (If that function gets renamed the test above could yeild false successes
-func goValidNat32(x : Nat32) { assert (x *% x == 4); }; goValidNat32(2);
+// This just checks that the above CHECK-NOT: box_i64 is up-to-date
+// (If that function gets renamed the test above could yield false successes
 func goValidNat64(x : Nat64) { assert (x *% x == 4); }; goValidNat64(2);
 func goValidFloat(x : Float) { assert (x * x == 4); }; goValidFloat(2);
 
 // We have to do the filechecks in reverse order:
 
-// FHECK: func $goValidFloat
-// FHECK: f64.load
-// FHECK: unreachable
+// CHECK: func $goValidFloat
+// CHECK: f64.load
+// CHECK: unreachable
 
-// FHECK: func $goValidNat64
-// FHECK: unbox_i64
-// FHECK: unreachable
+// CHECK: func $goValidNat64
+// CHECK: unbox64
+// CHECK: unreachable
 
-// FHECK: func $goValidNat32
-// FHECK: unbox_i32
-// FHECK: unreachable
+// CHECK: func $goFloat
+// CHECK-NOT: f64.load
+// CHECK-STORE: f64.load
+// CHECK: unreachable
 
-// FHECK: func $goFloat
-// FHECK-NOT: f64.load
-// FHECK-STORE: f64.load
-// FHECK: unreachable
-
-// FHECK: func $goInt64
-// FHECK-NOT: box_i64
-// FHECK-NOT: unbox_i64
-// FHECK: unreachable
-
-// FHECK: func $goNat64
-// FHECK-NOT: box_i64
-// FHECK-NOT: unbox_i64
-// FHECK: unreachable
-
-// FHECK: func $goInt32
-// FHECK-NOT: box_i32
-// FHECK-NOT: unbox_i32
-// FHECK: unreachable
-
-// FHECK: func $goNat32
-// FHECK-NOT: box_i32
-// FHECK-NOT: unbox_i32
-// FHECK: unreachable
+// CHECK: func $goInt64
+// CHECK-NOT: box64
+// CHECK-NOT: unbox64
+// CHECK: unreachable
 
+// CHECK: func $goNat64
+// CHECK-NOT: box64
+// CHECK-NOT: unbox64
+// CHECK: unreachable
 
 
 // Also test that the value is included in a closure properly
 
-func goCaptureNat32() : () -> () {
- let x : Nat32 = 1 +% 1;
- var y : Nat32 = 1 +% 1;
- return func() { assert(x == 2); assert(y == 2)};
-};
-goCaptureNat32()();
-
-func goCaptureInt32() : () -> () {
- let x : Int32 = 1 +% 1;
- var y : Int32 = 1 +% 1;
- return func() { assert(x == 2); assert(y == 2)};
-};
-goCaptureInt32()();
-
 func goCaptureNat64() : () -> () {
  let x : Nat64 = 1 +% 1;
  var y : Nat64 = 1 +% 1;
diff --git a/test/run/variant-specials.mo b/test/run/variant-specials.mo
index 74d717ec9ea..822f4be805a 100644
--- a/test/run/variant-specials.mo
+++ b/test/run/variant-specials.mo
@@ -15,13 +15,13 @@ func specials(one : { #one : Nat }, two : { #c0; #c1 }) {
 specials(#one 42, #c1)
 
 //CHECK: func $specials
-//CHECK-NOT: i32.const 5544550
+//CHECK-NOT: {{i32|i64}}.const 5544550
 //CHECK: local.set $count
 
-//CHECK: i32.const 22125
+//CHECK: {{i32|i64}}.const 22125
 //CHECK: local.set $count
 
-//CHECK-NOT: i32.const 22126
+//CHECK-NOT: {{i32|i64}}.const 22126
 //CHECK: local.set $count
 
-//CHECK: i32.const 494
+//CHECK: {{i32.const 246|i64.const 494}}
diff --git a/test/run/words.mo b/test/run/words-classical.mo
similarity index 99%
rename from test/run/words.mo
rename to test/run/words-classical.mo
index 15a68eef250..bff3b65ef75 100644
--- a/test/run/words.mo
+++ b/test/run/words-classical.mo
@@ -1,3 +1,4 @@
+//CLASSICAL-PERSISTENCE-ONLY
 //MOC-FLAG -fshared-code
 import Prim "mo:⛔";
 
diff --git a/test/run/words-enhanced.mo b/test/run/words-enhanced.mo
new file mode 100644
index 00000000000..7e828e2da0d
--- /dev/null
+++ b/test/run/words-enhanced.mo
@@ -0,0 +1,340 @@
+//ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+//MOC-FLAG -fshared-code
+import Prim "mo:⛔";
+
+// CHECK: func $init
+
+// CHECK: i64.const 424242
+assert not (424242 : Nat64 == 1);
+assert not (3 : Nat64 == 0);
+assert (0 : Nat64 == 0);
+// CHECK: i64.const 424342
+assert not (424342 : Nat64 == 1);
+
+// CHECK: i64.const {{1823394005778432|1823395079520256}}
+assert not (424542 : Nat32 == 1);
+assert not (3 : Nat32 == 0);
+assert (0 : Nat32 == 0);
+// CHECK: i64.const {{1824682495967232|1824683569709056}}
+assert not (424842 : Nat32 == 1);
+
+func printBit(a : Bool) { Prim.debugPrint(if a "set" else "clear") };
+
+
+func checkpointAlpha() { assert true; };
+func checkpointBravo() { assert true; };
+func checkpointCharlie() { assert true; };
+func checkpointDelta() { assert true; };
+func checkpointEcho() { assert true; };
+func checkpointFoxtrot() { assert true; };
+func checkpointGolf() { assert true; };
+func checkpointHotel() { assert true; };
+func checkpointIndia() { assert true; };
+func checkpointJuliett() { assert true; };
+
+// Nat64 operations
+do {
+    func printN64ln(w : Nat64) {
+      Prim.debugPrintNat(Prim.nat64ToNat w);
+    };
+    func printI64ln(w : Int64) {
+      Prim.debugPrintInt(Prim.int64ToInt w);
+    };
+
+    let a : Nat64 = 4567;
+    let b : Nat64 = 7;
+    let c : Nat64 = 8912765;
+    let d : Int64 = -15;
+    let e : Nat64 = 20000;
+
+// this is the value of c
+// CHECK: i64.const 142604244
+// CHECK-NOT: call $box64
+// CHECK: call $printN64ln
+    printN64ln(c);
+    printN64ln(^c);
+    printN64ln(a +% c);
+    printN64ln(c -% a);
+
+// CHECK: call $checkpointAlpha
+    checkpointAlpha();
+// This is a native Wasm i64 multiplication, there should be no shift involved!
+// CHECK-NOT: i64.shr_u
+// CHECK: call $printN64ln
+    printN64ln(a * b);
+
+    printN64ln(a / b);
+    printN64ln(c % a);
+    printN64ln(a ** 2);
+
+    printN64ln(a & c);
+    printN64ln(a | c);
+    printN64ln(a ^ c);
+    printN64ln(a << b);
+    printN64ln(a >> b);
+    printI64ln(-5225319197819536385 >> 4); // 0b1011011101111011111011111101111111011111111011111111101111111111L == -5225319197819536385L --> 826339054743125951L
+    printI64ln(d >> 3);
+    printI64ln(-5225319197819536385 >> 4); // 0b1011011101111011111011111101111111011111111011111111101111111111L == -5225319197819536385L --> -326582449863721025L
+
+    printN64ln(c <<> b);
+    printN64ln(c <>> b);
+    printI64ln(Prim.popcntInt64 d); // -15 = 0xfffffffffffffff1 = 0b1111_..._1111_1111_0001 (population = 61)
+    printN64ln(Prim.clzNat64 e); // 20000 = 0x0000000000004e20 (leading zeros = 49)
+    printN64ln(Prim.ctzNat64 e); // 20000 = 0x0000000000004e20 (trailing zeros = 5)
+    printBit(Prim.btstNat64(e, 5 : Nat64)); // 20000 = 0x0000000000004e20 (result = true)
+    printBit(Prim.btstNat64(e, 63 : Nat64)); // 20000 = 0x0000000000004e20 (result = false)
+    printBit(Prim.btstNat64(e, 69 : Nat64)); // 20000 = 0x0000000000004e20 (mod 64, result = true)
+
+    assert (3 : Nat64 ** (4 : Nat64) == (81 : Nat64));
+    assert (3 : Nat64 ** (7 : Nat64) == (2187 : Nat64));
+    assert (3 : Nat64 ** (14 : Nat64) == (4782969 : Nat64));
+    assert (3 : Nat64 ** (20 : Nat64) == (3486784401 : Nat64));
+};
+
+
+
+// Nat32 operations
+do {
+    func printN32ln(w : Nat32) {
+      Prim.debugPrintNat(Prim.nat32ToNat w);
+    };
+    func printI32ln(w : Int32) {
+      Prim.debugPrintInt(Prim.int32ToInt w);
+    };
+
+    let a : Nat32 = 4567;
+    let b : Nat32 = 7;
+    let c : Nat32 = 8912765;
+    let d : Int32 = -15;
+    let e : Nat32 = 20000;
+
+// CHECK: call $checkpointBravo
+    checkpointBravo();
+// this is the value of c
+// CHECK: i64.const 38280035265675264
+// CHECK-NOT: call $box64
+// CHECK: call $printN32ln
+    printN32ln(c);
+    printN32ln(^c);
+    printN32ln(a + c);
+    printN32ln(c - a);
+
+// CHECK: call $checkpointCharlie
+    checkpointCharlie();
+// This is a native Wasm i64 multiplication, there should be no shift involved!
+// CHECK-NOT: i64.shr_u
+// CHECK: call $printN32ln
+    printN32ln(a * b);
+    printN32ln(a / b);
+    printN32ln(c % a);
+    printN32ln(a ** 2);
+
+    printN32ln(a & c);
+    printN32ln(a | c);
+    printN32ln(a ^ c);
+    printN32ln(a << b);
+    printN32ln(a >> b);
+    printI32ln(-1216614433 >> 4); // 0b10110111011110111110111111011111l == -1216614433l --> 192397053l
+    printI32ln(d >> 3);
+    printI32ln(-1216614433 >> 4); // 0b10110111011110111110111111011111l == -1216614433l --> -76038403
+    printN32ln(c <<> b);
+    printN32ln(c <>> b);
+    printI32ln(Prim.popcntInt32 d); // -15 = 0xfffffff1 = 0b1111_1111_1111_1111_1111_1111_1111_0001 (population = 29)
+    printN32ln(Prim.clzNat32 e); // 20000 = 0x00004e20 (leading zeros = 17)
+    printN32ln(Prim.ctzNat32 e); // 20000 = 0x00004e20 (trailing zeros = 5)
+    printBit(Prim.btstNat32(e, 5 : Nat32)); // 20000 = 0x00004e20 (result = true)
+    printBit(Prim.btstNat32(e, 31 : Nat32)); // 20000 = 0x00004e20 (result = false)
+    printBit(Prim.btstNat32(e, 37 : Nat32)); // 20000 = 0x00004e20 (mod 32, result = true)
+
+    assert (3 : Nat32 ** (4 : Nat32) == (81 : Nat32));
+    assert (3 : Nat32 ** (7 : Nat32) == (2187 : Nat32));
+    assert (3 : Nat32 ** (14 : Nat32) == (4782969 : Nat32));
+    assert (3 : Nat32 ** (20 : Nat32) == (3486784401 : Nat32));
+};
+
+// Nat16 operations
+do {
+    func printN16ln(w : Nat16) {
+      Prim.debugPrintNat(Prim.nat16ToNat w);
+    };
+    func printI16ln(w : Int16) {
+      Prim.debugPrintInt(Prim.int16ToInt w);
+    };
+
+    let a : Nat16 = 4567;
+    let b : Nat16 = 7;
+    let c : Nat16 = 55734;
+    let d : Int16 = -15;
+    let e : Nat16 = 20000;
+
+
+    printN16ln(c);
+    printN16ln(^c);
+    printN16ln(a +% c);
+    printN16ln(c -% a);
+
+// CHECK: call $checkpointDelta
+    checkpointDelta();
+// this is the value of a
+// CHECK: i64.const {{1285496218637565952|1285566587381743616}}
+// this is the value of b
+// CHECK: i64.const {{1970324836974592|2040693581152256}}
+// This is not a native Wasm i64 multiplication, we need to shift one of the args left by 16 bits!
+// CHECK: i64.const 48
+// CHECK-NEXT: i64.shr_u
+// CHECK-NEXT: i64.mul
+// CHECK-NEXT: i64.const 70368744177664
+// CHECK-NEXT: i64.or
+// CHECK-NEXT: call $printN16ln
+    printN16ln(a *% b);
+    printN16ln(a / b);
+    printN16ln(c % a);
+    printN16ln(a **% 2);
+
+    printN16ln(a & c);
+    printN16ln(a | c);
+    printN16ln(a ^ c);
+    printN16ln(a << b);
+
+// CHECK: call $checkpointEcho
+   checkpointEcho();
+// this is the value of b
+// CHECK: i64.const {{1970324836974592|2040693581152256}}
+// This is not a native Wasm i32 left shift, we need to shift the second arg left by 16 bits and clamp it to 4 bits!
+// CHECK: i64.const 48
+// CHECK-NEXT: i64.shr_u
+// CHECK-NEXT: i64.const 15
+// CHECK-NEXT: i64.and
+// CHECK-NEXT: i64.shr_u
+// Then the result must be sanitised.
+// CHECK-NEXT: i64.const -281474976710656
+// CHECK-NEXT: i64.and
+// CHECK-NEXT: i64.const 70368744177664
+// CHECK-NEXT: i64.or
+// CHECK-NEXT: call $printN16ln
+    printN16ln(a >> b);
+    printN16ln(Prim.int16ToNat16(d) >> 3); // -15 = 0xfff1 = 0b1111_1111_1111_0001 (shifted = 0b0001_1111_1111_1110 = 8190)
+    printI16ln(d >> 3); // -15 = 0xfff1 = 0b1111_1111_1111_0001 (shifted = 0b1111_1111_1111_1110 = -2)
+
+// CHECK: call $checkpointFoxtrot
+   checkpointFoxtrot();
+// this is the value of b
+// CHECK: i64.const {{1970324836974592|2040693581152256}}
+// CHECK: call $printN16ln
+    printN16ln(c <<> b);
+
+// CHECK: call $checkpointGolf
+   checkpointGolf();
+// this is the value of b
+// CHECK: i64.const {{1970324836974592|2040693581152256}}
+// CHECK: i64.rotr
+    printN16ln(c <>> b);
+    printI16ln(Prim.popcntInt16 d); // -15 = 0xfff1 = 0b1111_1111_1111_0001 (population = 13)
+    printN16ln(Prim.clzNat16 e); // 20000 = 0x4e20 (leading zeros = 1)
+    printN16ln(Prim.ctzNat16 e); // 20000 = 0x4e20 (trailing zeros = 5)
+    printBit(Prim.btstNat16(e, 5 : Nat16)); // 20000 = 0x4e20 (result = true)
+    printBit(Prim.btstNat16(e, 15 : Nat16)); // 20000 = 0x4e20 (result = false)
+    printBit(Prim.btstNat16(e, 21 : Nat16)); // 20000 = 0x4e20 (mod 16, result = true)
+
+
+    assert (3 : Nat16 ** (0 : Nat16) == (1 : Nat16));
+    assert (3 : Nat16 ** (1 : Nat16) == (3 : Nat16));
+    assert (3 : Nat16 ** (4 : Nat16) == (81 : Nat16));
+    assert (3 : Nat16 ** (7 : Nat16) == (2187 : Nat16));
+};
+
+// Nat8 operations
+do {
+    func printN8ln(w : Nat8) {
+      Prim.debugPrintNat(Prim.nat8ToNat w);
+    };
+    func printI8ln(w : Int8) {
+      Prim.debugPrintInt(Prim.int8ToInt w);
+    };
+
+    let a : Nat8 = 67;
+    let b : Nat8 = 7;
+    let c : Nat8 = 34;
+    let d : Int8 = -15;
+    let e : Nat8 = 200;
+
+
+    printN8ln(c);
+    printN8ln(^c);
+    printN8ln(a + c);
+    printN8ln(c -% a);
+// CHECK: call $checkpointHotel
+    checkpointHotel();
+// this is the value of b
+// CHECK: i64.const {{504403158265495552|522417556774977536}}
+// This is not a native Wasm i64 multiplication, we need to shift one of the args left by 56 bits!
+// CHECK: i64.const 56
+// CHECK-NEXT: i64.shr_u
+// CHECK-NEXT: i64.mul
+// CHECK: call $printN8ln
+    printN8ln(a *% b);
+    printN8ln(a / b);
+    printN8ln(c % a);
+    printN8ln(a **% 2);
+
+    printN8ln(a & c);
+    printN8ln(a | c);
+    printN8ln(a ^ c);
+    printN8ln(a << b);
+
+// CHECK: call $checkpointIndia
+    checkpointIndia();
+// this is the value of b
+// CHECK: i64.const {{504403158265495552|522417556774977536}}
+// This is not a native Wasm i64 left shift, we need to shift the second arg left by 56 bits and clamp it to 3 bits!
+// CHECK: i64.const 56
+// CHECK-NEXT: i64.shr_u
+// CHECK-NEXT: i64.const 7
+// CHECK-NEXT: i64.and
+// CHECK-NEXT: i64.shr_u
+// Then the result must be sanitised.
+// CHECK-NEXT: i64.const -72057594037927936
+// CHECK-NEXT: i64.and
+// CHECK-NEXT: i64.const 18014398509481984
+// CHECK-NEXT: i64.or
+// CHECK-NEXT: call $printN8ln
+    printN8ln(a >> b);
+    printN8ln(Prim.int8ToNat8(d) >> 3); // -15 = 0xf1 = 0b1111_0001 (shifted = 0b0001_1110 = 30)
+    printI8ln(d >> 3); // -15 = 0xf1 = 0b1111_0001 (shifted = 0b1111_1110 = -2)
+
+// CHECK: call $checkpointJuliett
+    checkpointJuliett();
+// this is the value of b
+// CHECK: i64.const {{504403158265495552|522417556774977536}}
+// CHECK: call $printN8ln
+    printN8ln(c <<> b);
+// this is the value of b
+// CHECK: i64.const {{504403158265495552|522417556774977536}}
+// CHECK: call $printN8ln
+    printN8ln(c <>> b);
+    printI8ln(Prim.popcntInt8 d); // -15 = 0xf1 = 0b1111_0001 (population = 5)
+    printN8ln(Prim.clzNat8 e); // 200 = 0xC8 (leading zeros = 0)
+    printN8ln(Prim.ctzNat8 e); // 200 = 0xC8 (trailing zeros = 3)
+    printBit(Prim.btstNat8(e, 3 : Nat8)); // 200 = 0xC8 (result = true)
+    printBit(Prim.btstNat8(e, 5 : Nat8)); // 200 = 0xC8 (result = false)
+    printBit(Prim.btstNat8(e, 11 : Nat8)); // 200 = 0xC8 (mod 8, result = true)
+
+    assert (3 : Nat8 ** (0 : Nat8) == (1 : Nat8));
+    assert (3 : Nat8 ** (3 : Nat8) == (27 : Nat8));
+    assert (3 : Nat8 ** (4 : Nat8) == (81 : Nat8));
+    assert (3 : Nat8 ** (5 : Nat8) == (243 : Nat8));
+};
+
+
+// check whether patterns work
+
+func w8 (n : Nat8) = assert (switch n { case 0 false; case 1 false; case 42 true; case _ false });
+func w16 (n : Nat16) = assert (switch n { case 0 false; case 1 false; case 65000 true; case _ false });
+func w32 (n : Nat32) = assert (switch n { case 0 false; case 1 false; case 4_294_967_295 true; case _ false });
+func w64 (n : Nat64) = assert (switch n { case 0 false; case 1 false; case 42 true; case _ false });
+
+
+w8 42;
+w16 65000;
+w32 4_294_967_295;
+w64 42;
diff --git a/test/trap/divInt32.mo b/test/trap/divInt32-classical.mo
similarity index 72%
rename from test/trap/divInt32.mo
rename to test/trap/divInt32-classical.mo
index e0eb97d7590..b55c0c177f2 100644
--- a/test/trap/divInt32.mo
+++ b/test/trap/divInt32-classical.mo
@@ -1,2 +1,3 @@
+//CLASSICAL-PERSISTENCE-ONLY
 import Prim "mo:⛔";
 let _ = Prim.intToInt32 (-0x80000000) / (-1 : Int32)
diff --git a/test/trap/divInt32-enhanced.mo b/test/trap/divInt32-enhanced.mo
new file mode 100644
index 00000000000..5a2a62c261a
--- /dev/null
+++ b/test/trap/divInt32-enhanced.mo
@@ -0,0 +1,3 @@
+//ENHANCED-ORTHOGONAL-PERSISTENCE-ONLY
+import Prim "mo:⛔";
+let _ = Prim.intToInt32 (-0x80000000) / (-1 : Int32)
diff --git a/test/trap/mulInt8-upper.mo b/test/trap/mulInt8-upper.mo
index e9173faf73e..c536889dd3a 100644
--- a/test/trap/mulInt8-upper.mo
+++ b/test/trap/mulInt8-upper.mo
@@ -1,6 +1,5 @@
 let _ = (16 : Int8) * (8 : Int8)
 // There should be only one shift per operand
 // CHECK: mul<Int8>
-// CHECK: i32.shr_s
-// CHECK: i32.const 24
-// CHECK-NEXT: i32.shr_s
+// CHECK: {{i32.const 24|i64.const 48}}
+// CHECK-NEXT: {{i32|i64}}.shr_s
diff --git a/test/trap/mulNat8.mo b/test/trap/mulNat8.mo
index f3569e6fb5e..64c7ba8266c 100644
--- a/test/trap/mulNat8.mo
+++ b/test/trap/mulNat8.mo
@@ -1,6 +1,5 @@
 let _ = (16 : Nat8) * (16 : Nat8)
 // There should be only one shift per operand
 // CHECK: (func $mul<Nat8>
-// CHECK: i32.shr_u
-// CHECK: i32.const 24
-// CHECK-NEXT: i32.shr_u
+// CHECK: {{i32.const 24|i64.const 48}}
+// CHECK-NEXT: {{i32|i64}}.shr_u
diff --git a/test/trap/ok/divInt32-classical.run-ir.ok b/test/trap/ok/divInt32-classical.run-ir.ok
new file mode 100644
index 00000000000..2e173c5cdba
--- /dev/null
+++ b/test/trap/ok/divInt32-classical.run-ir.ok
@@ -0,0 +1 @@
+divInt32-classical.mo:3.9-3.53: execution error, arithmetic overflow
diff --git a/test/trap/ok/divInt32-classical.run-low.ok b/test/trap/ok/divInt32-classical.run-low.ok
new file mode 100644
index 00000000000..2e173c5cdba
--- /dev/null
+++ b/test/trap/ok/divInt32-classical.run-low.ok
@@ -0,0 +1 @@
+divInt32-classical.mo:3.9-3.53: execution error, arithmetic overflow
diff --git a/test/trap/ok/divInt32-classical.run.ok b/test/trap/ok/divInt32-classical.run.ok
new file mode 100644
index 00000000000..2e173c5cdba
--- /dev/null
+++ b/test/trap/ok/divInt32-classical.run.ok
@@ -0,0 +1 @@
+divInt32-classical.mo:3.9-3.53: execution error, arithmetic overflow
diff --git a/test/trap/ok/divInt32.run.ret.ok b/test/trap/ok/divInt32-classical.run.ret.ok
similarity index 100%
rename from test/trap/ok/divInt32.run.ret.ok
rename to test/trap/ok/divInt32-classical.run.ret.ok
diff --git a/test/trap/ok/divInt32.wasm-run.ok b/test/trap/ok/divInt32-classical.wasm-run.ok
similarity index 72%
rename from test/trap/ok/divInt32.wasm-run.ok
rename to test/trap/ok/divInt32-classical.wasm-run.ok
index 56abb509ee0..6a787db9429 100644
--- a/test/trap/ok/divInt32.wasm-run.ok
+++ b/test/trap/ok/divInt32-classical.wasm-run.ok
@@ -1,4 +1,4 @@
-Error: failed to run main module `_out/divInt32.wasm`
+Error: failed to run main module `_out/divInt32-classical.wasm`
 
 Caused by:
     0: failed to invoke command default
diff --git a/test/run/ok/inc-oom.wasm-run.ret.ok b/test/trap/ok/divInt32-classical.wasm-run.ret.ok
similarity index 100%
rename from test/run/ok/inc-oom.wasm-run.ret.ok
rename to test/trap/ok/divInt32-classical.wasm-run.ret.ok
diff --git a/test/trap/ok/divInt32-enhanced.run-ir.ok b/test/trap/ok/divInt32-enhanced.run-ir.ok
new file mode 100644
index 00000000000..564c44d9f0c
--- /dev/null
+++ b/test/trap/ok/divInt32-enhanced.run-ir.ok
@@ -0,0 +1 @@
+divInt32-enhanced.mo:3.9-3.53: execution error, arithmetic overflow
diff --git a/test/trap/ok/divInt32-enhanced.run-low.ok b/test/trap/ok/divInt32-enhanced.run-low.ok
new file mode 100644
index 00000000000..564c44d9f0c
--- /dev/null
+++ b/test/trap/ok/divInt32-enhanced.run-low.ok
@@ -0,0 +1 @@
+divInt32-enhanced.mo:3.9-3.53: execution error, arithmetic overflow
diff --git a/test/trap/ok/divInt32-enhanced.run.ok b/test/trap/ok/divInt32-enhanced.run.ok
new file mode 100644
index 00000000000..564c44d9f0c
--- /dev/null
+++ b/test/trap/ok/divInt32-enhanced.run.ok
@@ -0,0 +1 @@
+divInt32-enhanced.mo:3.9-3.53: execution error, arithmetic overflow
diff --git a/test/trap/ok/divInt32-enhanced.run.ret.ok b/test/trap/ok/divInt32-enhanced.run.ret.ok
new file mode 100644
index 00000000000..69becfa16f9
--- /dev/null
+++ b/test/trap/ok/divInt32-enhanced.run.ret.ok
@@ -0,0 +1 @@
+Return code 1
diff --git a/test/trap/ok/divInt32-enhanced.wasm-run.ok b/test/trap/ok/divInt32-enhanced.wasm-run.ok
new file mode 100644
index 00000000000..42bff533a92
--- /dev/null
+++ b/test/trap/ok/divInt32-enhanced.wasm-run.ok
@@ -0,0 +1,9 @@
+Error: failed to run main module `_out/divInt32-enhanced.wasm`
+
+Caused by:
+    0: failed to invoke command default
+    1: error while executing at wasm backtrace:
+         0: div<Int32>
+         1: init
+         2: _start
+    2: wasm trap: unreachable
diff --git a/test/trap/ok/divInt32.wasm-run.ret.ok b/test/trap/ok/divInt32-enhanced.wasm-run.ret.ok
similarity index 100%
rename from test/trap/ok/divInt32.wasm-run.ret.ok
rename to test/trap/ok/divInt32-enhanced.wasm-run.ret.ok
diff --git a/test/trap/ok/divInt32.run-ir.ok b/test/trap/ok/divInt32.run-ir.ok
deleted file mode 100644
index a22bc719adc..00000000000
--- a/test/trap/ok/divInt32.run-ir.ok
+++ /dev/null
@@ -1 +0,0 @@
-divInt32.mo:2.9-2.53: execution error, arithmetic overflow
diff --git a/test/trap/ok/divInt32.run-low.ok b/test/trap/ok/divInt32.run-low.ok
deleted file mode 100644
index a22bc719adc..00000000000
--- a/test/trap/ok/divInt32.run-low.ok
+++ /dev/null
@@ -1 +0,0 @@
-divInt32.mo:2.9-2.53: execution error, arithmetic overflow
diff --git a/test/trap/ok/divInt32.run.ok b/test/trap/ok/divInt32.run.ok
deleted file mode 100644
index a22bc719adc..00000000000
--- a/test/trap/ok/divInt32.run.ok
+++ /dev/null
@@ -1 +0,0 @@
-divInt32.mo:2.9-2.53: execution error, arithmetic overflow

From b4e036d7e194b9db9f8d5311c5278929b82876f7 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 26 Aug 2024 16:52:38 +0200
Subject: [PATCH 257/260] Update change log

---
 Changelog.md | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/Changelog.md b/Changelog.md
index 73280cf738c..b3efc5a4a31 100644
--- a/Changelog.md
+++ b/Changelog.md
@@ -2,6 +2,37 @@
 
 * motoko (`moc`)
 
+  * **For beta testing:** Support __enhanced orthogonal persistence__, enabled with new moc flag `--enhanced-orthogonal-persistence` (#4193).
+
+    This implements scalable and efficient orthogonal persistence (stable variables) for Motoko:
+    * The Wasm main memory (heap) is retained on upgrade with new program versions directly picking up this state.
+    * The Wasm main memory has been extended to 64-bit to scale as large as stable memory in the future.
+    * The runtime system checks that data changes of new program versions are compatible with the old state.
+    
+    Implications:
+    * Upgrades become extremely fast, only depending on the number of types, not on the number of heap objects.
+    * Upgrades will no longer hit the IC instruction limit, even for maximum heap usage.
+    * The change to 64-bit increases the memory demand on the heap, in worst case by a factor of two.
+    * For step-wise release handling, the IC initially only offers a limited capacity of the 64-bit space (e.g. 4GB or 6GB), that will be gradually increased in future to the capacity of stable memory.
+    * There is moderate performance regression of around 10% for normal execution due to combined related features (precise tagging, change to incremental GC, and handling of compile-time-known data).
+    * The garbage collector is fixed to incremental GC and cannot be chosen.
+    * `Float.format(#hex prec, x)` is no longer supported (expected to be very rarely used in practice).
+    * The debug print format of `NaN` changes (originally `nan`).
+    
+    To activate enhanced orthogonal persistence under `dfx`, the following command-line argument needs to be specified in `dfx.json`:
+
+    ```
+    ...
+      "type" : "motoko"
+      ...
+      "args" : "--enhanced-orthogonal-persistence"
+    ...
+    ```
+
+    For more information, see:
+    * The Motoko design documentation `design/OrthogonalPersistence.md`
+    * The Motoko user documentation `doc/md/canister-maintenance//upgrades.md`.
+
   * Candid decoding: impose an upper limit on the number of values decoded or skipped in a single candid payload,
     as a linear function, `max_values`, of binary payload size.
 

From f609bda7e3b1cade574554c32487434bc94bdfd8 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 26 Aug 2024 17:12:27 +0200
Subject: [PATCH 258/260] Refine documentation

---
 design/OrthogonalPersistence.md                | 15 +++++++++++----
 .../orthogonal-persistence/enhanced.md         | 18 ++++++++++++------
 2 files changed, 23 insertions(+), 10 deletions(-)

diff --git a/design/OrthogonalPersistence.md b/design/OrthogonalPersistence.md
index e1b971fffdb..1a8c1b8c17e 100644
--- a/design/OrthogonalPersistence.md
+++ b/design/OrthogonalPersistence.md
@@ -7,6 +7,11 @@ This implements the vision of **enhanced orthogonal persistence** in Motoko that
 
 As a result, the use of secondary storage (explicit stable memory, dedicated stable data structures, DB-like storage abstractions) will no longer be necessary: Motoko developers can directly work on their normal object-oriented program structures that are automatically persisted and retained across program version changes.
 
+## Activation
+Enhanced orthogonal persistence is offered for **beta testing** via the compiler flag `--enhanced-orthogonal-persistence`.
+Classical persistence with 32-bit main memory and Candid stabilization currently remains the default mode.
+See `design/PersistenceModes.md` for more information.
+
 ## Advantages
 Compared to the existing orthogonal persistence in Motoko, this design offers:
 * **Performance**: New program versions directly resume from the existing main memory and have access to the memory-compatible data.
@@ -24,10 +29,12 @@ The enhanced orthogonal persistence is based on the following main properties:
 * A fast memory compatibility check performed on each canister upgrade.
 * Incremental garbage collection using a partitioned heap.
 
-### Integration with Classical Persistence
-Enhanced orthogonal persistence is offered for **beta testing** via the compiler flag `--enhanced-orthogonal-persistence`.
-Classical persistence with 32-bit main memory and Candid stabilization currently remains the default mode.
-See `design/PersistenceModes.md` for more information.
+## IC Main Memory Retention
+
+The IC introduces a new upgrade option `wasm_memory_persistence` to control the retention of the canister's Wasm main memory.
+* `wasm_memory_persistence = opt keep` retains the Wasm main memory and is required for Motoko's enhanced orthogonal persistence. The IC prevents using this options for canisters with classical persistence.
+* `wasm_memory_persistence = null` uses the classical persistence, replacing the main memory. However, a safety check is implemented to prevent that main memory is not accidentally dropped for enhanced orthogonal persistence.
+* The other option `replace` is not recommended as it drops main memory, even for enhanced orthogonal persistence.
 
 ### Memory Layout
 In a co-design between the compiler and the runtime system, the main memory is arranged in the following structure, invariant of the compiled program version:
diff --git a/doc/md/canister-maintenance/orthogonal-persistence/enhanced.md b/doc/md/canister-maintenance/orthogonal-persistence/enhanced.md
index 5b46305e6bd..a7d4d86fbf6 100644
--- a/doc/md/canister-maintenance/orthogonal-persistence/enhanced.md
+++ b/doc/md/canister-maintenance/orthogonal-persistence/enhanced.md
@@ -31,7 +31,7 @@ Moreover, it is advised to have a backup possibility for rescuing data even when
 [Classical orthogonal persistence](classical.md) with 32-bit main memory and Candid stabilization currently remains the default mode.
 See [orthogonal persistence modes](modes.md) for a comparison.
 
-## Advantages
+## Design
 Compared to the existing orthogonal persistence in Motoko, this design offers:
 * **Performance**: New program versions directly resume from the existing main memory and have access to the memory-compatible data.
 * **Scalability**: The upgrade mechanism scales with larger heaps and in contrast to serialization, does not hit IC instruction limits.
@@ -40,7 +40,6 @@ Compared to the explicit use of stable memory, this design improves:
 * **Simplicity**: Developers do not need to deal with explicit stable memory.
 * **Performance**: No copying to and from the separate stable memory is necessary.
 
-## Design
 The enhanced orthogonal persistence is based on the following main properties:
 * Extension of the IC to retain main memory on upgrades.
 * Supporting 64-bit main memory on the IC.
@@ -48,7 +47,7 @@ The enhanced orthogonal persistence is based on the following main properties:
 * A fast memory compatibility check performed on each canister upgrade.
 * Incremental garbage collection using a partitioned heap.
 
-### Compatibility Check
+### Compatibility check
 Upgrades are only permitted if the new program version is compatible with the old version, such that the runtime system guarantees a compatible memory structure.
 
 Compatible changes for immutable types are largely analogous to the allowed Motoko subtype relation modulo some flexibility for actor fields, i.e.
@@ -64,10 +63,10 @@ The runtime system checks checks migration compatibility on upgrade, and if not
 
 Any more complex change can be performed with programmatic instruction, see [explicit migration](../upgrades.md#explicit-migration).
 
-### Migration Path
+### Migration path
 When migrating from the old serialization-based stabilization to the new persistent heap, the old data is deserialized one last time from stable memory and then placed in the new persistent heap layout. Once operating on the persistent heap, the system should prevent downgrade attempts to the old serialization-based persistence. 
 
-#### Graph-Copy-Based Stabilization
+#### Graph-copy-based stabilization
 Assuming that the persistent memory layout needs to be changed in the future, the runtime system supports serialization and deserialization to and from stable memory in a defined data format using graph-copy-based stabilization. Arbitrarily large data can be serialized and deserialized beyond the instruction and working set limit of upgrades: Large data serialization and deserialization is split in multiple messages, running before and/or after the IC upgrade to migrate large heaps. Of course, other messages will be blocked during this process and only the canister owner or the canister controllers are permitted to initiate this process. 
 
 This will only be needed in rare situation when Motoko's implementation changes its internal memory layout. Users will then be instructed to explicitly initiate this migration.
@@ -97,5 +96,12 @@ Remarks:
 * When receiving the `dfx` error "The request timed out." during explicit stabilization, upgrade, or destabilization, one can simply repeat the call until it completes.
 * Steps 3 (explicit destabilization) may not be needed if the corresponding operation fits into the upgrade message.
 
-### Old Stable Memory
+### Old stable memory
 The old stable memory remains equally accessible as secondary (legacy) memory with the new support. Therefore, stable regions can be combined with orthogonal persistence.
+
+## IC main memory retention
+
+The IC introduces a new upgrade option `wasm_memory_persistence` to control the retention of the canister's Wasm main memory.
+* `wasm_memory_persistence = opt keep` retains the Wasm main memory and is required for Motoko's enhanced orthogonal persistence. The IC prevents using this options for canisters with classical persistence.
+* `wasm_memory_persistence = null` uses the classical persistence, replacing the main memory. However, a safety check is implemented to prevent that main memory is not accidentally dropped for enhanced orthogonal persistence.
+* The other option `replace` is not recommended as it drops Wasm main memory, even for enhanced orthogonal persistence, leading to potential data loss.

From 71384a305613e003576c4ba640fcbac430c49ae4 Mon Sep 17 00:00:00 2001
From: luc-blaeser <luc.blaeser@dfinity.org>
Date: Mon, 26 Aug 2024 17:17:03 +0200
Subject: [PATCH 259/260] Fix documentation

---
 doc/md/canister-maintenance/orthogonal-persistence/enhanced.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/md/canister-maintenance/orthogonal-persistence/enhanced.md b/doc/md/canister-maintenance/orthogonal-persistence/enhanced.md
index a7d4d86fbf6..d5098b398b9 100644
--- a/doc/md/canister-maintenance/orthogonal-persistence/enhanced.md
+++ b/doc/md/canister-maintenance/orthogonal-persistence/enhanced.md
@@ -19,7 +19,7 @@ To activate enhanced orthogonal persistence under `dfx`, the following command-l
 ...
     "type" : "motoko"
     ...
-    "args" : "--incremental-gc"
+    "args" : "--enhanced-orthogonal-persistence"
 ...
 ```
 

From ce4fec0096ff2487f0c3f4d749b1f710b7a971c7 Mon Sep 17 00:00:00 2001
From: Luc Blaeser <112870813+luc-blaeser@users.noreply.github.com>
Date: Mon, 26 Aug 2024 18:39:44 +0200
Subject: [PATCH 260/260] Documentation improvement

Co-authored-by: Jessie Mongeon <133128541+jessiemongeon1@users.noreply.github.com>
---
 doc/md/canister-maintenance/compatibility.md  | 20 +++++++-------
 .../orthogonal-persistence/classical.md       | 10 +++----
 .../orthogonal-persistence/enhanced.md        | 18 ++++++-------
 .../orthogonal-persistence/modes.md           |  4 +--
 doc/md/canister-maintenance/upgrades.md       | 26 +++++++++----------
 doc/md/reference/compiler-ref.md              |  4 +--
 doc/md/stable-memory/stable-regions.md        |  2 +-
 7 files changed, 42 insertions(+), 42 deletions(-)

diff --git a/doc/md/canister-maintenance/compatibility.md b/doc/md/canister-maintenance/compatibility.md
index 957bdf64924..97d511d7821 100644
--- a/doc/md/canister-maintenance/compatibility.md
+++ b/doc/md/canister-maintenance/compatibility.md
@@ -56,7 +56,7 @@ An upgrade from `v1` to `v2`'s stable types consumes a [`Nat`](../base/Int.md) a
 
 ## Evolving the Candid interface
 
-In this extension of our interface, old clients remain satisfied, while new ones get extra features such as the `decrement` function and the `read` query in this example.
+In this extension of the interface, old clients remain satisfied, while new ones get extra features such as the `decrement` function and the `read` query in this example.
 
 ``` motoko no-repl file=../examples/count-v3.mo
 ```
@@ -108,7 +108,7 @@ Let's take a look at another example where the counter's type is again changed,
 ``` motoko no-repl file=../examples/count-v4.mo
 ```
 
-This version is neither compatible to Candid interface nor to the stable type declarations.
+This version is neither compatible to the Candid interface nor to the stable type declarations.
 - Since `Float </: Int`, the new type of `state` is not compatible to the old type.
 - The return type change of `read` is also not valid.
 
@@ -134,14 +134,14 @@ For this purpose, a user-instructed migration can be done in three steps:
 1. Introduce new variables of the desired types, while keeping the old declarations.
 2. Write logic to copy the state from the old variables to the new variables on upgrade.
 
-    While the previous attempt of changing state from [`Int`](../base/Int.md) to [`Nat`](../base/Float.md) was invalid, we now can realize the desired change as follows:
+    While the previous attempt of changing state from [`Int`](../base/Int.md) to [`Nat`](../base/Float.md) was invalid, you now can realize the desired change as follows:
 
     ``` motoko no-repl file=../examples/count-v5.mo
     ```
 
     To also keep the Candid interface, the `readFloat` has been added, while the old `read` is retired by keeping its declaration and raising a trap internally.
 
-3. Drop the old declarations, once all data has been migrated:
+3. Drop the old declarations once all data has been migrated:
 
     ``` motoko no-repl file=../examples/count-v6.mo
     ```
@@ -178,7 +178,7 @@ cannot be consumed at new type
 With [enhanced orthogonal persistence](orthogonal-persistence/enhanced.md), compatibility errors of stable variables are always detected in the runtime system and if failing, the upgrade is safely rolled back.
 
 :::danger
-With [classical orthogonal persistence](orthogonal-persistence/classical.md), however, an upgrade attempt from `v2.wasm` to `v3.wasm` is unpredictable and may lead to partial or complete data loss, if the `dfx` warning is ignored.
+With [classical orthogonal persistence](orthogonal-persistence/classical.md), however, an upgrade attempt from `v2.wasm` to `v3.wasm` is unpredictable and may lead to partial or complete data loss if the `dfx` warning is ignored.
 :::
 
 ## Adding record fields
@@ -226,15 +226,15 @@ Do you want to proceed? yes/No
 It is recommended not to continue, as you will lose the state in older versions of Motoko that use [classical orthogonal persistence](orthogonal-persistence/classical.md). 
 Upgrading with [enhanced orthogonal persistence](orthogonal-persistence/enhanced.md) will trap and roll back, keeping the old state.
 
-Adding a new record field to the type of existing stable variable is not supported. The reason is simple: The upgrade would need to supply values for the new field out of thin air. In this example, the upgrade would need to conjure up some value for the  `description` field of every existing `card` in `map`. Moreover, allowing to add optional fields is also a problem, as a record can be shared from various variables with different static types, some of them already declaring the added field or adding a same-named optional field with a potentially different type (and/or different semantics).
+Adding a new record field to the type of existing stable variable is not supported. The reason is simple: The upgrade would need to supply values for the new field out of thin air. In this example, the upgrade would need to conjure up some value for the `description` field of every existing `card` in `map`. Moreover, allowing adding optional fields is also a problem, as a record can be shared from various variables with different static types, some of them already declaring the added field or adding a same-named optional field with a potentially different type (and/or different semantics).
 
 ### Solution
 
-To resolve this issue, again, an [explicit](#explicit-migration) is needed:
+To resolve this issue, an [explicit](#explicit-migration) is needed:
 
-1. We keep the old variable `map` with the same structural type. However, we are allowed to change type alias name (`Card` to `OldCard`).
-2. We introduce a new variable `newMap` and copy the old state to the new one, initializing the new field as needed.
-3. We upgrade to this new version.
+1. You must keep the old variable `map` with the same structural type. However, you are allowed to change type alias name (`Card` to `OldCard`).
+2. You can introduce a new variable `newMap` and copy the old state to the new one, initializing the new field as needed.
+3. Then, upgrade to this new version.
 
 ``` motoko no-repl
 import Array "mo:base/Array";
diff --git a/doc/md/canister-maintenance/orthogonal-persistence/classical.md b/doc/md/canister-maintenance/orthogonal-persistence/classical.md
index fe14a8c8a5f..34776ce5507 100644
--- a/doc/md/canister-maintenance/orthogonal-persistence/classical.md
+++ b/doc/md/canister-maintenance/orthogonal-persistence/classical.md
@@ -4,15 +4,15 @@ sidebar_position: 3
 
 # Classical orthogonal persistence
 
-Classical orthogonal persistence is the old implementation of Motoko's orthogonal persistence. It is currently still the default option, as enhanced orthogonal persistence is in beta-testing stage.
+Classical orthogonal persistence is the old implementation of Motoko's orthogonal persistence. It is currently still the default option, as enhanced orthogonal persistence is in the beta-testing stage.
 
-On an upgrade, the classical orthogonal persistence mechanism serializes all stable data to the stable memory and then again deserializes it back to the main memory. This has several downsides:
+On an upgrade, the classical orthogonal persistence mechanism serializes all stable data to the stable memory and then deserializes it back to the main memory. This has several downsides:
 
-* At maximum, 2 GB of heap data can be persisted across upgrades. This is because of an implementation restriction, first copying the stable data back in main memory and then deserializing it from there. Note that in practice, the supported amount of stable data can be way lower. 
+* At maximum, 2 GiB of heap data can be persisted across upgrades. This is because of an implementation restriction. Note that in practice, the supported amount of stable data can be way lower. 
 * Shared immutable heap objects can duplicated, leading to potential state explosion on upgrades.
 * Deeply nested structures can lead to a call stack overflow.
 * The serialization and deserialization is expensive and can hit IC's instruction limits.
-* There is no inbuilt stable compatibility check in the runtime system. If users ignore the `dfx` upgrade warning, data may be lost or upgrade fails.
+* There is no inbuilt stable compatibility check in the runtime system. If users ignore the `dfx` upgrade warning, data may be lost or an upgrade fails.
 
 :::danger
 All these issues can lead to a stuck canister that can no longer be upgraded.
@@ -20,4 +20,4 @@ It is therefore absolutely necessary to thoroughly test how much data an upgrade
 Moreover, it is good to have a backup possibility to rescue data even if upgrades fail, e.g. by controller-privileged data query calls.
 :::
 
-These issues will be solved by [enhanced orthogonal persistence](enhanced.md).
+These issues are solved by [enhanced orthogonal persistence](enhanced.md).
diff --git a/doc/md/canister-maintenance/orthogonal-persistence/enhanced.md b/doc/md/canister-maintenance/orthogonal-persistence/enhanced.md
index d5098b398b9..28d1f310f5a 100644
--- a/doc/md/canister-maintenance/orthogonal-persistence/enhanced.md
+++ b/doc/md/canister-maintenance/orthogonal-persistence/enhanced.md
@@ -4,9 +4,9 @@ sidebar_position: 2
 
 # Enhanced orthogonal persistence
 
-This implements the vision of efficient and scalable orthogonal persistence in Motoko that combines:
-* **Stable heap**: Persisting the program main memory across canister upgrades.
-* **64-bit heap**: Extending the main memory to 64-bit for large-scaled persistence.
+Enhanced orthogonal persistence implements the vision of efficient and scalable orthogonal persistence in Motoko that combines:
+* **Stable heap**: Persisting the program's main memory across canister upgrades.
+* **64-bit heap**: Extending the main memory to 64-bit for large-scale persistence.
 
 As a result, the use of secondary storage (explicit stable memory, dedicated stable data structures, DB-like storage abstractions) will no longer be necessary: Motoko developers can directly work on their normal object-oriented program structures that are automatically persisted and retained across program version changes.
 
@@ -44,7 +44,7 @@ The enhanced orthogonal persistence is based on the following main properties:
 * Extension of the IC to retain main memory on upgrades.
 * Supporting 64-bit main memory on the IC.
 * A long-term memory layout that is invariant to new compiled program versions.
-* A fast memory compatibility check performed on each canister upgrade.
+* A fast memory compatibility check that is performed on each canister upgrade.
 * Incremental garbage collection using a partitioned heap.
 
 ### Compatibility check
@@ -56,10 +56,10 @@ Compatible changes for immutable types are largely analogous to the allowed Moto
 * Removing object fields.
 * Adding variant fields.
 * Changing `Nat` to `Int`.
-* Supporting hared function parameter contravariance and return type covariance.
+* Supporting shared function parameter contravariance and return type covariance.
 * Any other change according to Motoko's subtyping rule.
 
-The runtime system checks checks migration compatibility on upgrade, and if not fulfilled, rolls back the upgrade. This compatibility check serves as an additional safety measure on top of the `dfx` warning that can be bypassed by users.
+The runtime system checks migration compatibility on upgrade, and if not fulfilled, rolls back the upgrade. This compatibility check serves as an additional safety measure on top of the `dfx` warning that can be bypassed by users.
 
 Any more complex change can be performed with programmatic instruction, see [explicit migration](../upgrades.md#explicit-migration).
 
@@ -67,9 +67,9 @@ Any more complex change can be performed with programmatic instruction, see [exp
 When migrating from the old serialization-based stabilization to the new persistent heap, the old data is deserialized one last time from stable memory and then placed in the new persistent heap layout. Once operating on the persistent heap, the system should prevent downgrade attempts to the old serialization-based persistence. 
 
 #### Graph-copy-based stabilization
-Assuming that the persistent memory layout needs to be changed in the future, the runtime system supports serialization and deserialization to and from stable memory in a defined data format using graph-copy-based stabilization. Arbitrarily large data can be serialized and deserialized beyond the instruction and working set limit of upgrades: Large data serialization and deserialization is split in multiple messages, running before and/or after the IC upgrade to migrate large heaps. Of course, other messages will be blocked during this process and only the canister owner or the canister controllers are permitted to initiate this process. 
+Assuming that the persistent memory layout needs to be changed in the future, the runtime system supports serialization and deserialization to and from stable memory in a defined data format using graph-copy-based stabilization. Arbitrarily large data can be serialized and deserialized beyond the instruction and working set limit of upgrades. Large data serialization and deserialization is split in multiple messages, running before and/or after the IC upgrade to migrate large heaps. Other messages will be blocked during this process and only the canister owner or the canister controllers are permitted to initiate this process. 
 
-This will only be needed in rare situation when Motoko's implementation changes its internal memory layout. Users will then be instructed to explicitly initiate this migration.
+This will only be needed in rare situations when Motoko's implementation changes its internal memory layout. Users will then be instructed to explicitly initiate this migration.
 
 #### Usage
 Graph-copy-based stabilization can be performed in three steps:
@@ -94,7 +94,7 @@ dfx canister call CANISTER_ID __motoko_destabilize_after_upgrade "()"
 
 Remarks:
 * When receiving the `dfx` error "The request timed out." during explicit stabilization, upgrade, or destabilization, one can simply repeat the call until it completes.
-* Steps 3 (explicit destabilization) may not be needed if the corresponding operation fits into the upgrade message.
+* Step 3 (explicit destabilization) may not be needed if the corresponding operation fits into the upgrade message.
 
 ### Old stable memory
 The old stable memory remains equally accessible as secondary (legacy) memory with the new support. Therefore, stable regions can be combined with orthogonal persistence.
diff --git a/doc/md/canister-maintenance/orthogonal-persistence/modes.md b/doc/md/canister-maintenance/orthogonal-persistence/modes.md
index 0af9f7b680f..d723af9341e 100644
--- a/doc/md/canister-maintenance/orthogonal-persistence/modes.md
+++ b/doc/md/canister-maintenance/orthogonal-persistence/modes.md
@@ -6,6 +6,6 @@ sidebar_position: 1
 
 Motoko features two implementations for orthogonal persistence:
 
-* [Enhanced orthogonal persistence](enhanced.md), currently in beta stage, provides very fast upgrades, scaling independently of the heap size: This is realized by retaining the Wasm entire main memory on an upgrade and simply performing a type-driven upgrade safety check. By using 64-bit address space, it is designed to scale beyond 4 GB and in future, offer the same capacity like stable memory.
+* [Enhanced orthogonal persistence](enhanced.md), currently in beta stage, provides very fast upgrades, scaling independently of the heap size. This is realized by retaining the entire Wasm main memory on an upgrade and simply performing a type-driven upgrade safety check. By using 64-bit address space, it is designed to scale beyond 4 GiB and in the future, offer the same capacity like stable memory.
 
-* [Classical orthogonal persistence](classical.md) is the old implementation of orthogonal persistence that will be superseded by enhanced orthogonal persistence. On upgrade, the runtime system first serializes the persistent data to stable memory and then deserializes it back again to main memory. While this is both inefficient and unscalable, it exhibits problems on shared immutable data (potentially leading to state explosion), deep structures (call stack overflow) and larger heaps (the implementation limits the stable data to at most 2 GB).
+* [Classical orthogonal persistence](classical.md) is the old implementation of orthogonal persistence that will be superseded by enhanced orthogonal persistence. On an upgrade, the runtime system first serializes the persistent data to stable memory and then deserializes it back again to main memory. While this is both inefficient and unscalable, it exhibits problems on shared immutable data (potentially leading to state explosion), deep structures (call stack overflow) and larger heaps (the implementation limits the stable data to at most 2 GiB).
diff --git a/doc/md/canister-maintenance/upgrades.md b/doc/md/canister-maintenance/upgrades.md
index 5e1d89e3bf1..acb6d408c8f 100644
--- a/doc/md/canister-maintenance/upgrades.md
+++ b/doc/md/canister-maintenance/upgrades.md
@@ -6,15 +6,15 @@ sidebar_position: 3
 
 ## Overview
 
-One key feature of Motoko is its ability to automatically persist the program's state without explicit user instruction, called **orthogonal persistence**. This not only covers persistence across transactions but also includes canister upgrades. For this purpose, Motoko features a bespoke compiler and runtime system that manages upgrades in a sophisticated way such that a new program version can pick of the state left behind by a previous program version. As a result, Motoko data persistence is not simple, but also prevents data corruption and loss and is efficient at the same time. No database, stable memory API, or stable data structure is required to retain state across upgrades. Instead, a simple `stable` keyword is sufficient declare an data structure of arbitrary shape persistent, even if the structure uses sharing, has a deep complexity, or contains cycles.
+One key feature of Motoko is its ability to automatically persist the program's state without explicit user instruction, called **orthogonal persistence**. This not only covers persistence across transactions but also includes canister upgrades. For this purpose, Motoko features a bespoke compiler and runtime system that manages upgrades in a sophisticated way such that a new program version can pick up the state left behind by a previous program version. As a result, Motoko data persistence is not simple but also prevents data corruption or loss, while being efficient at the same time. No database, stable memory API, or stable data structure is required to retain state across upgrades. Instead, a simple `stable` keyword is sufficient to declare an data structure of arbitrary shape persistent, even if the structure uses sharing, has a deep complexity, or contains cycles.
 
-This is substantially different to other languages supported on the IC, which use off-the-shelf language implementations that are not designed for orthogonal persistence in mind: They rearrange memory structures in an uncontrolled manner on re-compilation or at runtime. As an alternative, in other languages, programmers have to explicilty use stable memory or special stable data structures to rescue their data between upgrades. Contrary to Motoko, this approach is not only cumbersome, but also unsafe and inefficient. Compared to using stable data structures, Motoko's orthogonal persistence allows more natural data modeling and significantly faster data accesses, eventually resulting in way more efficient programs.
+This is substantially different to other languages supported on the IC, which use off-the-shelf language implementations that are not designed for orthogonal persistence in mind: They rearrange memory structures in an uncontrolled manner on re-compilation or at runtime. As an alternative, in other languages, programmers have to explicilty use stable memory or special stable data structures to rescue their data between upgrades. Contrary to Motoko, this approach is not only cumbersome, but also unsafe and inefficient. Compared to using stable data structures, Motoko's orthogonal persistence allows more natural data modeling and significantly faster data access, eventually resulting in more efficient programs.
 
 ## Declaring stable variables
 
 In an actor, you can configure which part of the program is considered to be persistent, i.e. survives upgrades, and which part are ephemeral, i.e. are reset on upgrades.
 
-More precisely, each `let` and `var` variable declaration in an actor can specify whether the variable is `stable` or `flexible`. If you don’t provide a modifier, the variable is  assumed to be `flexible` by default.
+More precisely, each `let` and `var` variable declaration in an actor can specify whether the variable is `stable` or `flexible`. If you don’t provide a modifier, the variable is assumed to be `flexible` by default.
 
 The semantics of the modifiers is as follows:
 * `stable` means that all values directly or indirectly reachable from that stable actor variable are considered persistent and automatically retained across upgrades. This is the primary choice for most of the program's state.
@@ -92,7 +92,7 @@ actor {
 };
 ```
 
-3. __Not recommended__: [Pre- and post-upgrade hooks](#preupgrade-and-postupgrade-system-methods) allow to copy non-stable types to stable types during upgrades.
+3. __Not recommended__: [Pre- and post-upgrade hooks](#preupgrade-and-postupgrade-system-methods) allow copying non-stable types to stable types during upgrades.
 The downside of this approach is that it is error-prone and does not scale for large data. 
 Conceptually, it also does not align well with the idea of orthogonal persistence.
 
@@ -165,17 +165,17 @@ You can check valid Candid subtyping between two services described in `.did` fi
 
 After you have deployed a Motoko actor with the appropriate `stable` variables, you can use the `dfx deploy` command to upgrade an already deployed version. For information about upgrading a deployed canister, see [upgrade a canister smart contract](/docs/current/developer-docs/smart-contracts/maintain/upgrade).
 
-`dfx deploy` checks that the interface is compatible, and if not, show this message and ask if you want to continue:
+`dfx deploy` checks that the interface is compatible, and if not, shows this message and asks if you want to continue:
 
 ```
 You are making a BREAKING change. Other canisters or frontend clients relying on your canister may stop working.
 ```
 
-In addition, Motoko with enhanced orthogonal persistence implements extra safe guard in the runtime system to ensure that the stable data is compatible, to exclude any data corruption or misinterpretation. Moreover, `dfx` also warns about dropping of stable variables.
+In addition, Motoko with enhanced orthogonal persistence implements extra safe guard in the runtime system to ensure that the stable data is compatible, to exclude any data corruption or misinterpretation. Moreover, `dfx` also warns about dropping stable variables.
 
 ## Data migration
 
-Often, the data representation changes with a new program version. For orthogonal persistence, it is important the language is able to allow flexible data migration to the new version.
+Often, data representation changes with a new program version. For orthogonal persistence, it is important the language is able to allow flexible data migration to the new version.
 
 Motoko supports two kinds of data migrations: Implicit migration and explicit migration.
 
@@ -199,7 +199,7 @@ Any more complex migration is possible by user-defined functionality.
 For this purpose, a three step approach is taken:
 1. Introduce new variables of the desired types, while keeping the old declarations.
 2. Write logic to copy the state from the old variables to the new variables on upgrade.
-3. Drop the old declarations, once all data has been migrated.
+3. Drop the old declarations once all data has been migrated.
 
 For more information, see the [example of explicit migration](compatibility.md#explicit-migration).
 
@@ -209,20 +209,20 @@ The following aspects are retained for historical reasons and backwards compatib
 
 ### Preupgrade and postupgrade system methods
 
-This is only advanced functionality that is not recommended for standard cases, as it is error-prone and can render the canister unusable.
+This is an advanced functionality that is not recommended for standard cases, as it is error-prone and can render the canister unusable.
 
-Motoko supports user-defined upgrade hooks that run immediately before and after an upgrade. These upgrade hooks allow to trigger additional logic on upgrade. 
+Motoko supports user-defined upgrade hooks that run immediately before and after an upgrade. These upgrade hooks allow triggering additional logic on upgrade. 
 These hooks are declared as `system` functions with special names, `preugrade` and `postupgrade`. Both functions must have type `: () → ()`.
 
 :::danger
-If `preupgrade` raises a trap or hits the instruction limit or another IC computing limit, the upgrade cannot no longer succeed and the canister is stuck with the existing version.
+If `preupgrade` raises a trap, hits the instruction limit, or hits another IC computing limit, the upgrade can no longer succeed and the canister is stuck with the existing version.
 :::
 
 :::tip
-`postupgrade` is not needed as the equal effect can be achieved by introducing initializing expressions in the actor, e.g. non-stable let expressions or expression statements.
+`postupgrade` is not needed as the equal effect can be achieved by introducing initializing expressions in the actor, e.g. non-stable `let` expressions or expression statements.
 :::
 
-### Stable Memory and stable regions
+### Stable memory and stable regions
 
 Stable memory was introduced on the IC to allow upgrades in languages that do not implement orthogonal persistence of the main memory. This is the case with Motoko's classical persistence as well as other languages besides Motoko.
 
diff --git a/doc/md/reference/compiler-ref.md b/doc/md/reference/compiler-ref.md
index f98aad255d0..b921353d9b8 100644
--- a/doc/md/reference/compiler-ref.md
+++ b/doc/md/reference/compiler-ref.md
@@ -39,12 +39,12 @@ You can use the following options with the `moc` command.
 | `--error-detail <n>`                      | Set level of error message detail for syntax errors, n in \[0..3\] (default 2).                                                                       |
 | `--experimental-stable-memory <n>`        | Select support for the deprecated `ExperimentalStableMemory.mo` library (n < 0: error, n = 0: warn, n > 0: allow) (default 0).                        |
 | `-fno-shared-code`                        | Do not share low-level utility code: larger code size but decreased cycle consumption (default).                                                      |
-| `--generational-gc`                       | Use generational GC (not supported with enhanced orthogonal persistence)                                                                              |
+| `--generational-gc`                       | Use generational GC (not supported with enhanced orthogonal persistence).                                                                              |
 | `-fshared-code`                           | Do share low-level utility code: smaller code size but increased cycle consumption.                                                                   |
 | `-help`,`--help`                          | Displays usage information.                                                                                                                           |
 | `--hide-warnings`                         | Hides compiler warnings.                                                                                                                              |
 | `-Werror`                                 | Treat warnings as errors.                                                                                                                             |
-| `--incremental-gc`                        | Use incremental GC (default of enhanced orthogonal persistence, also available for classical persistence)                                             |
+| `--incremental-gc`                        | Use incremental GC (default of enhanced orthogonal persistence, also available for classical persistence).                                             |
 | `--idl`                                   | Compile binary and emit Candid IDL specification to `.did` file.                                                                                      |
 | `-i`                                      | Runs the compiler in an interactive read–eval–print loop (REPL) shell so you can evaluate program execution (implies -r).                             |
 | `--map`                                   | Outputs a JavaScript source map.                                                                                                                      |
diff --git a/doc/md/stable-memory/stable-regions.md b/doc/md/stable-memory/stable-regions.md
index 9b6c8b0ddf1..7a24ea4667a 100644
--- a/doc/md/stable-memory/stable-regions.md
+++ b/doc/md/stable-memory/stable-regions.md
@@ -8,7 +8,7 @@ sidebar_position: 1
 
 The `Region` library provides low-level access to ICP stable memory feature.
 
-Stable regions were historically introduced with [classical orthogonal persistence](../canister-maintenance/orthogonal-persistence/classical.md) to allow larger scaled data to be retained across upgrades. For this purpose, programmers could explicitly store persistent data in stable memory, with regions helping to isolate different instances using stable memory.
+Stable regions were originally introduced with [classical orthogonal persistence](../canister-maintenance/orthogonal-persistence/classical.md) to allow larger scaled data to be retained across upgrades. For this purpose, programmers could explicitly store persistent data in stable memory, with regions helping to isolate different instances using stable memory.
 
 This is superseded by [enhanced orthogonal persistence](../canister-maintenance/orthogonal-persistence/enhanced.md). Nevertheless, regions are still offered for backwards-compatibility and for specific use cases where developers prefer to manage data explicitly in a persistent linear memory.