Use Rust nightly

Author: osa1

default.nix

@@ -22,8 +22,9 @@ let
   rtsBuildInputs = [
     nixpkgs.clang_10 # for native/wasm building
     nixpkgs.lld_10 # for wasm building
-    nixpkgs.rustc
-    nixpkgs.cargo
+    nixpkgs.rustc-nightly
+    nixpkgs.cargo-nightly
+    nixpkgs.xargo
   ];
 
   llvmEnv = ''
@@ -331,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,21 +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
-            );
-          });
-        })
+        # (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

@@ -156,22 +156,20 @@ _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/motoko_rts.o
-_build/wasm/motoko_rts.o: | _build/wasm
-	cd motoko-rts && \
-	  cargo rustc --target=wasm32-unknown-emscripten --release -v -- -Crelocation-model=pic --emit=obj
-	cp motoko-rts/target/wasm32-unknown-emscripten/release/deps/motoko_rts*.o $@
-
-.PHONY: _build/native/motoko_rts.o
-_build/native/motoko_rts.o: | _build/native
-	cd motoko-rts && \
-	  cargo rustc --release -v -- -Crelocation-model=pic --emit=obj
-	cp motoko-rts/target/release/deps/motoko_rts*.o $@
+.PHONY: _build/wasm/libmotoko_rts.a
+_build/wasm/libmotoko_rts.a: | _build/wasm
+	cd motoko-rts && cargo build --target=wasm32-unknown-emscripten --release
+	cp motoko-rts/target/wasm32-unknown-emscripten/release/libmotoko_rts.a $@
+
+.PHONY: _build/native/libmotoko_rts.a
+_build/native/libmotoko_rts.a: | _build/native
+	cd motoko-rts && cargo build --release
+	cp motoko-rts/target/release/libmotoko_rts.a $@
 
 RTS_WASM_O=$(RTSFILES:%=_build/wasm/%.o)
 RTS_NATIVE_O=$(RTSFILES:%=_build/native/%.o)
-RTS_RUST_WASM_O=_build/wasm/motoko_rts.o
-RTS_RUST_NATIVE_O=_build/native/motoko_rts.o
+RTS_RUST_WASM_O=_build/wasm/libmotoko_rts.a
+RTS_RUST_NATIVE_O=_build/native/libmotoko_rts.a
 
 #
 # The actual RTS, as we ship it with the compiler

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

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

@@ -4,4 +4,11 @@ version = "0.1.0"
 authors = ["Ömer Sinan Ağacan <[email protected]>"]
 edition = "2018"
 
-[dependencies]
+[lib]
+crate-type = ["staticlib"]
+
+[profile.dev]
+panic = "abort"
+
+[profile.release]
+panic = "abort"

rts/motoko-rts/src/common.rs

@@ -1,3 +1,57 @@
 extern "C" {
     pub fn rts_trap_with(msg: *const u8) -> !;
 }
+
+#[cfg(target_arch = "wasm32")]
+mod ic0 {
+    // NB: The #[link(...)] line below really needs to be before `extern "C"` part, we can't move
+    // it inside the extern block, it doesn't work.
+    #[link(wasm_import_module = "ic0")]
+    extern "C" {
+        #[no_mangle]
+        pub fn debug_print(msg: *const u8, len: u32);
+    }
+}
+
+#[cfg(target_arch = "wasm32")]
+pub unsafe fn debug_print(s: &str) {
+    ic0::debug_print(s.as_ptr(), s.len() as u32)
+}
+
+pub struct Wrapper<'a> {
+    buf: &'a mut [u8],
+    offset: usize,
+}
+
+impl<'a> Wrapper<'a> {
+    pub fn new(buf: &'a mut [u8]) -> Self {
+        Wrapper {
+            buf: buf,
+            offset: 0,
+        }
+    }
+}
+
+use core::fmt;
+
+impl<'a> fmt::Write for Wrapper<'a> {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        let bytes = s.as_bytes();
+
+        // Skip over already-copied data
+        let remainder = &mut self.buf[self.offset..];
+        // Check if there is space remaining (return error instead of panicking)
+        if remainder.len() < bytes.len() {
+            return Err(core::fmt::Error);
+        }
+        // Make the two slices the same length
+        let remainder = &mut remainder[..bytes.len()];
+        // Copy
+        remainder.copy_from_slice(bytes);
+
+        // Update offset to avoid overwriting
+        self.offset += bytes.len();
+
+        Ok(())
+    }
+}

rts/motoko-rts/src/gc.rs

@@ -6,9 +6,10 @@
 // TODO: inconsistent use of size vs. len
 
 use core::arch::wasm32;
+use core::fmt::Write;
 
 use crate::array::array_idx_unchecked;
-use crate::common::rts_trap_with;
+use crate::common::{debug_print, rts_trap_with, Wrapper};
 use crate::types::*;
 
 extern "C" {
@@ -413,6 +414,8 @@ unsafe fn evac_static_roots(
 
 #[no_mangle]
 pub unsafe extern "C" fn rust_collect_garbage() {
+    debug_print("### GC begins");
+
     let static_roots = get_static_roots();
 
     // Beginning of tospace = end of fromspace
@@ -421,8 +424,21 @@ pub unsafe extern "C" fn rust_collect_garbage() {
     let begin_to_space = end_from_space;
     let mut end_to_space = begin_to_space;
 
+    debug_print("### Evacuating roots");
+
+    let mut buf = [0 as u8; 100];
+    let _ = write!(
+        Wrapper::new(&mut buf),
+        "### begin_from_space={}",
+        begin_from_space.unskew()
+    );
+    
+
     // Evacuate roots
     end_to_space = evac_static_roots(begin_from_space, begin_to_space, end_to_space, static_roots);
+
+    debug_print("### Evacuated static roots");
+
     end_to_space = evacuate(
         begin_from_space.unskew(),
         begin_to_space.unskew(),
@@ -458,4 +474,6 @@ pub unsafe extern "C" fn rust_collect_garbage() {
     set_hp(skew(
         begin_from_space.unskew() + (end_to_space.unskew() - begin_to_space.unskew()),
     ));
+
+    debug_print("### GC finished");
 }

rts/motoko-rts/src/lib.rs

@@ -9,3 +9,15 @@ pub mod types;
 
 #[cfg(target_arch = "wasm32")]
 pub mod gc;
+
+#[cfg(target_arch = "wasm32")]
+#[panic_handler]
+fn panic(_info: &core::panic::PanicInfo) -> ! {
+    unsafe { ::core::arch::wasm32::unreachable() }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+#[panic_handler]
+fn panic(_info: &core::panic::PanicInfo) -> ! {
+    loop {}
+}