initial Rust support

Makefile.include

@@ -264,7 +264,7 @@ ifeq (,$(RIOTNOLINK))
 ifeq ($(BUILDOSXNATIVE),1)
 	$(AD)$(if $(CPPMIX),$(CXX),$(LINK)) $(UNDEF) -o $(ELFFILE) $$(find $(BASELIBS) -size +8c) $(LINKFLAGS) $(LINKFLAGPREFIX)-no_pie
 else
-	$(AD)$(if $(CPPMIX),$(CXX),$(LINK)) $(UNDEF) -o $(ELFFILE) $(LINKFLAGPREFIX)--start-group $(BASELIBS) -lm $(LINKFLAGPREFIX)--end-group  $(LINKFLAGPREFIX)-Map=$(BINDIR)/$(APPLICATION).map $(LINKFLAGPREFIX)--cref $(LINKFLAGS)
+	$(AD)$(if $(CPPMIX),$(CXX),$(LINK)) $(UNDEF) -o $(ELFFILE) $(LINKFLAGPREFIX)--start-group $(BASELIBS) -lm $$(test -d $(BINDIR)/_extra_libs && find $(BINDIR)/_extra_libs -name '*.a') $(LINKFLAGPREFIX)--end-group  $(LINKFLAGPREFIX)-Map=$(BINDIR)/$(APPLICATION).map $(LINKFLAGPREFIX)--cref $(LINKFLAGS)
 endif
 	$(AD)$(SIZE) $(ELFFILE)
 	$(AD)$(OBJCOPY) $(OFLAGS) $(ELFFILE) $(HEXFILE)
@@ -521,3 +521,7 @@ endif
 CFLAGS := $(patsubst -D%,,$(CFLAGS))
 CFLAGS := $(patsubst -U%,,$(CFLAGS))
 CFLAGS += -include '$(RIOTBUILD_CONFIG_HEADER_C)'
+
+ifeq (1,$(CARGO_BUILD))
+    include $(RIOTBASE)/Makefile.rust
+endif

Makefile.rust

@@ -0,0 +1,28 @@
+# RIOT rust support makefile
+
+# make RIOT's linker hook path known to rustc
+export RUST_TARGET_PATH ?= $(RIOTBASE)/dist/rust/targets
+
+# (unfortunately with this set, Cargo somehow fails. Thus we need to keep
+# Cargo's build directory in ./target)
+#export CARGO_TARGET_DIR ?= $(BINDIR)/_cargo
+
+# the rust riot crate depends on fmt
+USEMODULE += fmt
+
+ifneq (,$(filter $(CPU_ARCH), cortex-m0plus cortex-m4f))
+	RUST_TARGET=$(CPU_ARCH)
+else ifeq ($(CPU_ARCH),native)
+$(error Makefile.rust: RIOT rust on native is currently broken.)
+	RUST_TARGET=i586-unknown-linux-gnu
+endif
+
+ifeq (, $(RUST_TARGET))
+$(error Makefile.rust: cannot determine rust target triple!)
+endif
+
+all: xargo
+
+xargo:
+	@mkdir -p $(BINDIR)/_extra_libs
+	@PATH=$${PATH}:$(RIOTBASE)/dist/rust xargo build --target $(RUST_TARGET) ${CARGO_FLAGS}

cpu/Makefile.include.cortexm_common

@@ -95,6 +95,9 @@ include $(RIOTCPU)/cortexm_common/Makefile.include
 USEMODULE += newlib_nano
 export USE_NANO_SPECS = 1
 
+# all Cortex-M are supported by RIOT's Rust integration
+FEATURES_PROVIDED += rust_support
+
 # Avoid overriding the default rule:
 all:
 

dist/rust/riot-rust-linker-hook

@@ -0,0 +1,21 @@
+#!/bin/bash
+
+[ -z "$BINDIR" ] && {
+    echo "$0: BINDIR not defined!" 1&>2
+    exit 1
+}
+
+_EXTRA_LIBS=${BINDIR}/_extra_libs
+mkdir -p ${_EXTRA_LIBS}
+
+while true; do
+    [ -z "$1" ] && exit 0
+    [ -f "$1" ] && {
+        if [[ "$1" == *.o ]]; then
+            ${AR} r ${_EXTRA_LIBS}/_objects.a $1
+        elif [[ "$1" == *.rlib ]]; then
+            cp $1 ${_EXTRA_LIBS}/$(basename $1).a
+        fi
+    }
+    shift
+done

dist/rust/targets/cortex-m0.json

@@ -0,0 +1,14 @@
+{
+    "arch": "arm",
+    "cpu": "cortex-m0",
+    "data-layout": "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64",
+    "executables": true,
+    "linker": "riot-rust-linker-hook",
+    "llvm-target": "thumbv6m-none-eabi",
+    "no-compiler-rt": true,
+    "os": "none",
+    "pre-link-args": [],
+    "relocation-model": "static",
+    "target-endian": "little",
+    "target-pointer-width": "32"
+}

dist/rust/targets/cortex-m0plus.json

@@ -0,0 +1,14 @@
+{
+    "arch": "arm",
+    "cpu": "cortex-m0plus",
+    "data-layout": "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64",
+    "executables": true,
+    "linker": "riot-rust-linker-hook",
+    "llvm-target": "thumbv6m-none-eabi",
+    "no-compiler-rt": true,
+    "os": "none",
+    "pre-link-args": [ ],
+    "relocation-model": "static",
+    "target-endian": "little",
+    "target-pointer-width": "32"
+}

dist/rust/targets/cortex-m1.json

@@ -0,0 +1,14 @@
+{
+    "arch": "arm",
+    "cpu": "cortex-m1",
+    "data-layout": "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64",
+    "executables": true,
+    "linker": "riot-rust-linker-hook",
+    "llvm-target": "thumbv6m-none-eabi",
+    "no-compiler-rt": true,
+    "os": "none",
+    "pre-link-args": [],
+    "relocation-model": "static",
+    "target-endian": "little",
+    "target-pointer-width": "32"
+}

dist/rust/targets/cortex-m3.json

@@ -0,0 +1,14 @@
+{
+    "arch": "arm",
+    "cpu": "cortex-m3",
+    "data-layout": "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64",
+    "executables": true,
+    "linker": "riot-rust-linker-hook",
+    "llvm-target": "thumbv7m-none-eabi",
+    "no-compiler-rt": true,
+    "os": "none",
+    "pre-link-args": [],
+    "relocation-model": "static",
+    "target-endian": "little",
+    "target-pointer-width": "32"
+}

dist/rust/targets/cortex-m4.json

@@ -0,0 +1,15 @@
+{
+    "arch": "arm",
+    "cpu": "cortex-m4",
+    "data-layout": "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64",
+    "executables": true,
+    "features": "+soft-float",
+    "linker": "riot-rust-linker-hook",
+    "llvm-target": "thumbv7em-none-eabi",
+    "no-compiler-rt": true,
+    "os": "none",
+    "pre-link-args": [],
+    "relocation-model": "static",
+    "target-endian": "little",
+    "target-pointer-width": "32"
+}

dist/rust/targets/cortex-m4f.json

@@ -0,0 +1,14 @@
+{
+    "arch": "arm",
+    "cpu": "cortex-m4",
+    "data-layout": "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64",
+    "executables": true,
+    "linker": "riot-rust-linker-hook",
+    "llvm-target": "thumbv7em-none-eabi",
+    "no-compiler-rt": true,
+    "os": "none",
+    "pre-link-args": [],
+    "relocation-model": "static",
+    "target-endian": "little",
+    "target-pointer-width": "32"
+}

dist/rust/targets/cortex-m7.json

@@ -0,0 +1,15 @@
+{
+    "arch": "arm",
+    "cpu": "cortex-m7",
+    "data-layout": "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64",
+    "executables": true,
+    "features": "+soft-float",
+    "linker": "riot-rust-linker-hook",
+    "llvm-target": "thumbv7em-none-eabi",
+    "no-compiler-rt": true,
+    "os": "none",
+    "pre-link-args": [],
+    "relocation-model": "static",
+    "target-endian": "little",
+    "target-pointer-width": "32"
+}

dist/rust/targets/cortex-m7f-sp.json

@@ -0,0 +1,15 @@
+{
+    "arch": "arm",
+    "cpu": "cortex-m7",
+    "data-layout": "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64",
+    "executables": true,
+    "features": "+fp-only-sp",
+    "linker": "riot-rust-linker-hook",
+    "llvm-target": "thumbv7em-none-eabi",
+    "no-compiler-rt": true,
+    "os": "none",
+    "pre-link-args": [],
+    "relocation-model": "static",
+    "target-endian": "little",
+    "target-pointer-width": "32"
+}

dist/rust/targets/cortex-m7f.json

@@ -0,0 +1,14 @@
+{
+    "arch": "arm",
+    "cpu": "cortex-m7",
+    "data-layout": "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64",
+    "executables": true,
+    "linker": "riot-rust-linker-hook",
+    "llvm-target": "thumbv7em-none-eabi",
+    "no-compiler-rt": true,
+    "os": "none",
+    "pre-link-args": [],
+    "relocation-model": "static",
+    "target-endian": "little",
+    "target-pointer-width": "32"
+}

examples/rust/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "app"
+version = "0.1.0"
+authors = ["Kaspar Schleiser <[email protected]>"]
+
+[dependencies]
+riot = "0.1.1"
+
+[profile.release]
+panic = "abort"
+lto = true
+opt-level = "s"

examples/rust/Makefile

@@ -0,0 +1,23 @@
+# name of your application
+APPLICATION = rust
+
+# This has to be the absolute path to the RIOT base directory:
+RIOTBASE ?= $(CURDIR)/../..
+
+# Change this to 0 show compiler invocation lines by default:
+QUIET ?= 1
+
+#
+FEATURES_REQUIRED += rust_support
+
+# If no BOARD is found in the environment, use this default:
+BOARD ?= samr21-xpro
+
+# use this to enable rust support.
+# the current directory will be built using xargo.
+CARGO_BUILD=1
+
+# set extra flags if needed
+#CARGO_FLAGS += --release
+
+include $(RIOTBASE)/Makefile.include

examples/rust/README.md

@@ -0,0 +1,41 @@
+# Introduction
+
+"Rust is a systems programming language that runs blazingly fast, prevents
+segfaults, and guarantees thread safety."
+
+This example shows how to write a RIOT application using Rust.
+
+# Status
+
+As Rust's libstd is too fat for our little MCUs, it is currently only possible
+to write Rust applications using ```#![no_std]```.
+There's a crate on crate.io trying to map RIOT's API to rust, but that is in
+very early stages.
+
+# Prerequisites
+
+You'll need a Rust nightly toolchain and xargo.
+
+This should get you started:
+
+    # curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain=nightly
+    # . ~/.cargo/env
+    # cargo install xargo
+
+# Trying the example
+
+As always,
+
+    # BOARD=samr21-xpro make clean all flash term
+
+is all you need.
+
+# Internals
+
+RIOT's make system intercepts cargo's linking step and just copies the objects
+and archives cargo tries to link into RIOT's build dir, then just links
+everything together.
+
+# Known issues
+
+- currently this works only for Cortex-M platforms

examples/rust/src/main.rs

@@ -0,0 +1,20 @@
+#![feature(lang_items)]
+#![no_main]
+#![no_std]
+
+mod lang_items {
+    #[lang = "panic_fmt"]
+    extern fn panic_fmt() {}
+
+    #[lang = "eh_personality"]
+    fn eh_personality() {}
+}
+
+// user code starts here
+
+extern crate riot;
+
+#[no_mangle]
+pub fn main() {
+    riot::fmt::print("Hello from RUST!\n");
+}