Implement the GC in Rust

This implements the current garbage collector in Rust. No changes were
made to the GC design -- it's just ports the one implemented in code
generator to Rust.

The goals are:

- Evaluate Rust for Motoko's RTS implementation
- Make the collector easier to read, understand, modify, and extend.

Currently passes the tests locally. We can't run this branch on CI yet
as it needs to download rustc nightly and xargo and the domains are not
allowed on the CI. I think in the final version we'll have to build
rustc outselves instead of downloading.

(Nightly rustc is needed as "core" distributed with rustc is not built
with PIC relocation model on wam32, so we can't use it to generate a
shared wasm32 library)

Main changes:

- New Rust crate "motoko-rts" introduced, which currently implements the
  garbage collector. It also has some utilities for printing the heap or
  individual objects, to be used when debugging.

- Nix files updated to download rustc and xargo. These are used to build
  Rust's "core" library with PIC relocation model for wasm32.

- We no longer build memset and memcpy of musl as those are provided by
  Rust's "core" now.

The main algorithm is in `gc.rs`. Rest of the Rust files are helpers,
mainly for debugging.

Other changes:

- I had to update lots of ic-ref-run outputs. See #1854 for the details.

Remaining work and issues:

- Figure out how to use rustc nightly (with PIC wasm32 libraries) in CI.

Note to reviewers:

- The main algorithm is in `gc.rs`, everything else is helpers. Start
  reading from `gc.rs`.

Author: osa1

.gitignore

@@ -3,6 +3,7 @@
 _out
 _output
 _build
+target
 
 **/*~
 /result*

default.nix

@@ -19,16 +19,19 @@ let haskellPackages = nixpkgs.haskellPackages.override {
       overrides = import nix/haskell-packages.nix nixpkgs subpath;
     }; in
 let
-  llvmBuildInputs = [
+  rtsBuildInputs = [
     nixpkgs.clang_10 # for native/wasm building
     nixpkgs.lld_10 # for wasm building
+    nixpkgs.rustc-nightly
+    nixpkgs.cargo-nightly
+    nixpkgs.xargo
   ];
 
-  # When compiling natively, we want to use `clang` (which is a nixpkgs
-  # provided wrapper that sets various include paths etc).
-  # But for some reason it does not handle building for Wasm well, so
-  # there we use plain clang-10. There is no stdlib there anyways.
   llvmEnv = ''
+    # When compiling natively, we want to use `clang` (which is a nixpkgs
+    # provided wrapper that sets various include paths etc).
+    # But for some reason it does not handle building for Wasm well, so
+    # there we use plain clang-10. There is no stdlib there anyways.
     export CLANG="${nixpkgs.clang_10}/bin/clang"
     export WASM_CLANG="clang-10"
     export WASM_LD=wasm-ld
@@ -126,7 +129,7 @@ rec {
     src = subpath ./rts;
     nativeBuildInputs = [ nixpkgs.makeWrapper ];
 
-    buildInputs = llvmBuildInputs;
+    buildInputs = rtsBuildInputs;
 
     preBuild = ''
       ${llvmEnv}
@@ -200,7 +203,7 @@ rec {
             wasmtime
             nixpkgs.sources.esm
           ] ++
-          llvmBuildInputs;
+          rtsBuildInputs;
 
         checkPhase = ''
             patchShebangs .
@@ -329,6 +332,7 @@ rec {
     [ { name = "bin/FileCheck"; path = "${nixpkgs.llvm}/bin/FileCheck";} ];
   wabt = nixpkgs.wabt;
   wasmtime = nixpkgs.wasmtime;
+  xargo = nixpkgs.xargo;
   wasm = nixpkgs.wasm;
 
   overview-slides = stdenv.mkDerivation {

nix/default.nix

@@ -10,7 +10,30 @@ let
     import nixpkgs_src {
       inherit system;
       overlays = [
-        (self: super: { sources = import sourcesnix { sourcesFile = ./sources.json; pkgs = super; }; })
+        # rust nightly
+        (self: super: let
+          moz_overlay = import (self.fetchzip {
+            url = https://github.com/mozilla/nixpkgs-mozilla/archive/efda5b357451dbb0431f983cca679ae3cd9b9829.tar.gz;
+            sha256 = "11wqrg86g3qva67vnk81ynvqyfj0zxk83cbrf0p9hsvxiwxs8469";
+          }) self super;
+          rust-channel = moz_overlay.rustChannelOf { date = "2020-07-22"; channel = "nightly"; };
+        in rec {
+          rustc-nightly = rust-channel.rust.override {
+            targets = [ "wasm32-unknown-unknown" "wasm32-unknown-emscripten" ];
+            extensions = ["rust-src"];
+          };
+          cargo-nightly = rustc-nightly;
+          rustPlatform-nightly = pkgs.makeRustPlatform {
+            rustc = rustc-nightly;
+            cargo = cargo-nightly;
+          };
+        })
+
+        # add nix/sources.json
+        (self: super: {
+           sources = import sourcesnix { sourcesFile = ./sources.json; pkgs = super; };
+        })
+
         # Selecting the ocaml version
         # (self: super: { ocamlPackages = super.ocamlPackages; })
         (
@@ -30,10 +53,21 @@ let
                 inherit (self) ocamlPackages;
               };
             };
-            # wasmtime
             wasmtime = self.callPackage ./wasmtime.nix {};
+            xargo = self.callPackage ./xargo.nix {};
           }
         )
+        # nixpkgs's rustc does not include the wasm32-unknown-unknown target, so
+        # lets add it here.
+        # (self: super: {
+        #   rustc = super.rustc.overrideAttrs (old: {
+        #     configureFlags = self.lib.lists.forEach old.configureFlags (flag:
+        #       if self.lib.strings.hasPrefix "--target=" flag
+        #       then flag + ",wasm32-unknown-unknown,wasm32-unknown-emscripten"
+        #       else flag
+        #     );
+        #   });
+        # })
       ];
     };
 in

nix/xargo.nix

@@ -0,0 +1,42 @@
+# xargo is used to build motoko-rts for wasm32. We need to make a shared Wasm
+# library for the RTS (that's what moc-ld supports) but Rust ships wasm32
+# libraries (core and std) without PIC relocation model, so we use xargo to make
+# PIC versions of core and std.
+
+{ rustPlatform-nightly, fetchFromGitHub, lib, python, cmake, llvmPackages, clang, stdenv, darwin, zlib }:
+
+rustPlatform-nightly.buildRustPackage rec {
+  name = "xargo";
+
+  src = fetchFromGitHub {
+    owner = "japaric";
+    repo = "${name}";
+    rev = "16035a7c401262824edcb87e1401fe4b05a5ccc0";
+    sha256 = "0m1dg7vwmmlpqp20p219gsm7zbnnii6lik6hc2vvfsdmnygf271l";
+    fetchSubmodules = true;
+  };
+
+  cargoSha256 = "0zzksgi2prgw01m6r4bqjjz902h5g5ich0h3xvb60w4sshlss891";
+
+  # nativeBuildInputs = [ python cmake clang ];
+  # buildInputs = [ llvmPackages.libclang ] ++
+  #  lib.optionals stdenv.isDarwin [ darwin.apple_sdk.frameworks.Security ];
+  # LIBCLANG_PATH = "${llvmPackages.libclang}/lib";
+
+  doCheck = false;
+  # error: couldn't lock thumbv6m-panic_abort-eabi's sysroot as read-only
+  USER = "nobody"; # for xargo tests (if we would run them)
+
+  meta = with lib; {
+    description = "The sysroot manager that lets you build and customize std";
+    homepage = "https://github.com/japaric/xargo";
+    license = licenses.mit;
+    maintainers = [ {
+      email = "[email protected]";
+      github = "osa1";
+      githubId = 123123;
+      name = "Ömer Sinan Ağacan";
+    } ];
+    platforms = platforms.unix;
+  };
+}

rts/Makefile

@@ -1,3 +1,5 @@
+SHELL:=bash -O globstar
+
 CLANG ?= clang-10
 WASM_CLANG ?= clang-10
 WASM_LD ?= wasm-ld-10
@@ -19,7 +21,7 @@ TOMMATHFILES = \
 MUSLFILES = \
   pow pow_data sin cos tan asin acos atan atan2 exp exp_data log log_data fmod \
   towctrans iswspace iswupper iswlower iswalpha wcschr wcslen \
-  floor scalbn frexp strnlen memchr memset memcpy snprintf vsnprintf vfprintf \
+  floor scalbn frexp strnlen memchr snprintf vsnprintf vfprintf \
   __math_oflow __math_uflow __math_xflow __math_divzero __math_invalid \
   __rem_pio2 __rem_pio2_large __sin __cos __tan \
   stubs
@@ -154,17 +156,28 @@ _build/native/tommath_%.o: %.c rts.h buf.h | _build/native
 _build/wasm/musl_%.o: %.c | _build/wasm
 	$(WASM_CLANG) $(CLANG_FLAGS) $(WASM_FLAGS) $(MUSL_FLAGS) $< --output $@
 
+.PHONY: _build/wasm/libmotoko_rts.a
+_build/wasm/libmotoko_rts.a: | _build/wasm
+	# NB. codegen-units=1 is to make debugging easier, not strictly
+	# necessary
+	cd motoko-rts && \
+	    xargo rustc --target=wasm32-unknown-emscripten --release -- \
+		-Crelocation-model=pic -Ccodegen-units=1
+	cp motoko-rts/target/wasm32-unknown-emscripten/release/libmotoko_rts.a $@
+
 RTS_WASM_O=$(RTSFILES:%=_build/wasm/%.o)
 RTS_NATIVE_O=$(RTSFILES:%=_build/native/%.o)
+RTS_RUST_WASM_O=_build/wasm/libmotoko_rts.a
 
 #
 # The actual RTS, as we ship it with the compiler
 #
 
-mo-rts.wasm: $(RTS_WASM_O) $(TOMMATH_WASM_O) $(MUSL_WASM_O)
+mo-rts.wasm: $(RTS_WASM_O) $(RTS_RUST_WASM_O) $(TOMMATH_WASM_O) $(MUSL_WASM_O)
 	$(WASM_LD) -o $@ \
 		--import-memory --shared --no-entry --gc-sections \
 		--export=__wasm_call_ctors \
+		--whole-archive \
 		$+
 
 #
@@ -178,5 +191,4 @@ test_leb128: test_leb128.c $(RTS_NATIVE_O) $(TOMMATH_NATIVE_O)
 	$(CLANG) -o $@ $+
 
 clean:
-	rm -rf _build mo-rts.wasm test_rts test_leb128
-
+	rm -rf _build mo-rts.wasm test_rts test_leb128 motoko-rts/target

rts/motoko-rts/.cargo/config

@@ -0,0 +1,4 @@
+# NB. codegen-units=1 is not necessary, but it generates less .o files for core,
+# std, and compiler_builtins and makes it easier to find symbols.
+[build]
+rustflags = ["-Crelocation-model=pic", "-Ccodegen-units=1"]

rts/motoko-rts/.vim/coc-settings.json

@@ -0,0 +1,8 @@
+// https://github.com/rust-analyzer/rust-analyzer/blob/master/editors/code/package.json
+{
+    "rust-analyzer.cargo.target": "wasm32-unknown-emscripten",
+
+    // 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.
+    "rust-analyzer.checkOnSave.allTargets": false
+}

rts/motoko-rts/Cargo.lock

@@ -0,0 +1,17 @@
+[package]
+name = "motoko-rts"
+version = "0.1.0"
+authors = ["Ömer Sinan Ağacan <[email protected]>"]
+edition = "2018"
+
+[dependencies]
+libc = "0.2.73"
+
+[lib]
+crate-type = ["staticlib"]
+
+[profile.dev]
+panic = "abort"
+
+[profile.release]
+panic = "abort"

rts/motoko-rts/Cargo.toml

@@ -0,0 +1,41 @@
+//! Implements allocation routines used by the generated code and the GC.
+
+use core::arch::wasm32;
+
+use crate::gc;
+use crate::rts_trap_with;
+use crate::types::*;
+
+#[no_mangle]
+pub unsafe extern "C" fn alloc_bytes(n: Bytes<u32>) -> SkewedPtr {
+    alloc_words(bytes_to_words(n))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn alloc_words(n: Words<u32>) -> SkewedPtr {
+    let bytes = words_to_bytes(n);
+    // Update ALLOCATED
+    gc::ALLOCATED.0 += bytes.0 as u64;
+
+    // Update heap pointer
+    let old_hp = gc::get_hp();
+    let new_hp = old_hp + bytes.0 as usize;
+    gc::set_hp(new_hp);
+
+    // Grow memory if needed
+    grow_memory(new_hp);
+
+    skew(old_hp)
+}
+
+/// Page allocation. Ensures that the memory up to the given pointer is allocated.
+pub(crate) unsafe fn grow_memory(ptr: usize) {
+    let total_pages_needed = ((ptr / 65536) + 1) as i32;
+    let current_pages = wasm32::memory_size(0) as i32;
+    let new_pages_needed = total_pages_needed - current_pages;
+    if new_pages_needed > 0 {
+        if wasm32::memory_grow(0, new_pages_needed as usize) == core::usize::MAX {
+            rts_trap_with("Cannot grow memory\0".as_ptr());
+        }
+    }
+}