Included support for code auto generation from header files

This is achieved by using bindgen. Support for bindgen has been
integrated into the existing Makefiles. To use bindgen define the
variables `RUST_FFI_HEADER` and `RUST_FFI_TYPES` in your modules
Makefile. Bindgen will then generate Rust code for the given types from
the given header file. The generated code can be used in your crate by
adding `mod ffi;` to your `lib.rs` file.

The GPIO wrapper has been refactored to use bindgen, types are now
generated with bindgen. This is useful because RIOTs header files use a
lot of `#ifdefs` and bindgen is able to parse them for us. Bindings for
extern functions are currently not generated with bindgen even though
that would theoretically be possible.

Fixes RIOT-OS#34

.gitignore

@@ -29,6 +29,9 @@ tags
 # GDB initialization scripts
 .gdbinit
 
+# Symlink to /dev/stdin for rust bindgen hack
+ffi.rs
+
 # Eclipse symbol file (output from make eclipsesym)
 eclipsesym.xml
 /toolchain

Makefile.base

@@ -40,7 +40,8 @@ ifeq ($(strip $(RUSTSRC)),)
         CRATE_TYPE = lib
     endif
 
-    RUSTSRC = $(wildcard *.rs)
+    # ffi.rs is a symlink to /dev/stdin. Don't track it.
+    RUSTSRC = $(filter-out ffi.rs,$(wildcard *.rs))
 endif
 ifeq ($(strip $(ASMSRC)),)
     ASMSRC := $(wildcard *.s)
@@ -85,6 +86,16 @@ $(OBJCXX): $(BINDIR)/$(MODULE)/%.o: %.cpp $(RIOTBUILD_CONFIG_HEADER_C)
 ifdef CRATE_TYPE
 include $(RIOTBASE)/Makefile.rust
 
+ifneq (,$(RUST_FFI_HEADER))
+BINDGEN_CFLAGS = -include $(RIOTBUILD_CONFIG_HEADER_C) \
+	$(INCLUDES)
+
+ifneq ($(TOOLCHAIN),llvm)
+include $(RIOTCPU)/Makefile.include.llvm_common
+BINDGEN_CFLAGS += $(GCC_C_INCLUDES)
+endif
+endif
+
 ifeq (1,$(RUST_FFI))
 RUST_FFI_LIB = $(BINDIR)/$(MODULE)/libffi.a
 $(RUST_FFI_LIB): $(OBJ)
@@ -99,8 +110,14 @@ $(BINDIR)/$(MODULE).a: $(RUSTOBJ)
 	$(Q)$(AR) $(ARFLAGS) $@ $<
 else ifeq ($(CRATE_TYPE),lib)
 LIBNAME = $(MODULE:rust/%=rust/lib%)
-$(BINDIR)/$(LIBNAME).rlib: $(RUSTSRC) | $(BINDIR)/$(MODULE)/ $(RUST_FFI_LIB) ${DIRS:%=ALL--%}
+$(BINDIR)/$(LIBNAME).rlib: $(RUSTSRC) $(RUST_FFI_HEADER) | $(BINDIR)/$(MODULE)/ $(RUST_FFI_LIB) ${DIRS:%=ALL--%}
+ifneq (,$(RUST_FFI_HEADER))
+	$(Q)ln -fs /dev/stdin ffi.rs
+	$(Q)bindgen $(BINDGEN_FLAGS) $(RUST_FFI_HEADER) -- $(BINDGEN_CFLAGS) | \
+		rustc $(RUSTC_FLAGS) --emit link,dep-info --out-dir $(shell dirname $@) lib.rs
+else
 	$(Q)rustc $(RUSTC_FLAGS) --emit link,dep-info --out-dir $(shell dirname $@) lib.rs
+endif
 $(BINDIR)/$(MODULE).a: $(BINDIR)/$(LIBNAME).rlib
 	$(Q)ln -fs $< $@
 else

Makefile.rust

@@ -12,6 +12,12 @@ else
 	RUST_TARGET=$(CPU_ARCH)
 endif
 
+# Flags to pass to bindgen
+BINDGEN_FLAGS := --use-core --generate types \
+		 --ctypes-prefix ::cpu::libc \
+		 --no-doc-comments \
+		 $(RUST_FFI_TYPES:%=--whitelist-type %)
+
 # Enable some compiler optimizations
 RUSTC_FLAGS += -C opt-level=s
 ifeq (bin,$(CRATE_TYPE))

cpu/Makefile.include.llvm_common

@@ -0,0 +1,56 @@
+# Clang on Linux uses GCC's C++ headers and libstdc++ (installed with GCC)
+# Ubuntu and Debian use /etc/alternatives/gcc-$(TARGET_ARCH)-include/c++/$(GCC_VERSION)
+# Arch uses /usr/$(TARGET_ARCH)/include/c++/$(GCC_VERSION)
+# Gentoo uses /usr/lib/gcc/$(TARGET_ARCH)/$(GCC_VERSION)/include/g++-v5
+GCC_CXX_INCLUDE_PATTERNS ?= \
+  /etc/alternatives/gcc-$(TARGET_ARCH)-include/c++/*/ \
+  /usr/$(TARGET_ARCH)/include/c++/*/ \
+  /usr/lib/gcc/$(TARGET_ARCH)/*/include/g++-v5 \
+  #
+
+# Try to find the proper multilib directory using GCC, this may fail if a cross-
+# GCC is not installed.
+ifeq ($(GCC_MULTI_DIR),)
+  GCC_MULTI_DIR := $(shell $(PREFIX)gcc -print-multi-directory $(CFLAGS) 2>/dev/null)
+endif
+
+# Use the wildcard Makefile function to search for existing directories matching
+# the patterns above. We use the -isystem gcc/clang argument to add the include
+# directories as system include directories, which means they will not be
+# searched until after all the project specific include directories (-I/path)
+# We sort the list of found directories and take the last one, it will likely be
+# the most recent GCC version. This avoids using old headers left over from
+# previous tool chain installations.
+GCC_CXX_INCLUDES ?= \
+    $(addprefix \
+        -isystem $(lastword $(sort \
+            $(foreach pat, $(GCC_CXX_INCLUDE_PATTERNS), $(wildcard $(pat))))), \
+        /. /$(TARGET_ARCH)/$(GCC_MULTI_DIR) /backward \
+    )
+
+# If nothing was found we will try to fall back to searching for a cross-gcc in
+# the current PATH and use a relative path for the includes
+ifeq (,$(GCC_CXX_INCLUDES))
+  GCC_CXX_INCLUDES := $(addprefix -isystem ,$(wildcard $(dir $(shell which $(PREFIX)gcc))../$(TARGET_TRIPLE)/include))
+endif
+
+# Pass the includes to the C++ compilation rule in Makefile.base
+export CXXINCLUDES += $(GCC_CXX_INCLUDES)
+
+# Some C headers (e.g. limits.h) are located with the GCC libraries
+GCC_C_INCLUDE_PATTERNS ?= \
+  /usr/lib/gcc/$(TARGET_TRIPLE)/*/ \
+  #
+
+GCC_C_INCLUDES ?= \
+    $(addprefix -isystem ,$(wildcard $(addprefix \
+        $(lastword $(sort \
+            $(foreach pat, $(GCC_C_INCLUDE_PATTERNS), $(wildcard $(pat))))), \
+        include include-fixed) \
+    ))
+
+# If nothing was found we will try to fall back to searching for the libgcc used
+# by an installed cross-GCC and use its headers.
+ifeq (,$(GCC_C_INCLUDES))
+  GCC_C_INCLUDES := $(addprefix -isystem ,$(wildcard $(addprefix $(dir $(shell $(PREFIX)gcc -print-libgcc-file-name)), include include-fixed)))
+endif

drivers/rust/periph/Makefile

@@ -0,0 +1,10 @@
+# Auto generate an ffi.rs file from a C header.
+RUST_FFI_HEADER = $(RIOTBASE)/drivers/include/periph/gpio.h
+
+# Types from the headers to autogenerate bindings for.
+RUST_FFI_TYPES = gpio_t gpio_mode_t gpio_isr_ctx_t
+
+# Build libffi.a to wrap C Macros.
+RUST_FFI = 1
+
+include $(RIOTBASE)/drivers/rust/Makefile.crate

drivers/rust/gpio/lib.rs → drivers/rust/periph/gpio.rs

@@ -1,21 +1,16 @@
-#![no_std]
-
-extern crate cpu;
-
+use cpu::libc::c_int;
 use core::option::Option;
 
-use cpu::periph_cpu::gpio_mode;
-use cpu::periph_cpu::gpio_t;
-
-use cpu::libc::c_int;
+pub use ::ffi::gpio_t;
+pub use ::ffi::gpio_mode_t;
 
 /// Struct representing a GPIO pin.
 pub struct Pin {
     num: gpio_t,
 }
 
 extern {
-    fn gpio_init(pin: gpio_t, mode: gpio_mode) -> c_int;
+    fn gpio_init(pin: gpio_t, mode: gpio_mode_t) -> c_int;
     fn gpio_read(pin: gpio_t) -> c_int;
     fn gpio_write(pin: gpio_t, val: c_int);
     fn gpio_pin(x: c_int, y: c_int) -> gpio_t;
@@ -40,7 +35,7 @@ impl Pin {
     }
 
     /// Initialize the pin as a general purpose input or output.
-    pub fn init(&self, mode: gpio_mode) -> Option<()> {
+    pub fn init(&self, mode: gpio_mode_t) -> Option<()> {
         let r = unsafe {
             gpio_init(self.num, mode)
         };

drivers/rust/periph/lib.rs

@@ -0,0 +1,9 @@
+#![no_std]
+#![allow(bad_style)]
+#![allow(dead_code)]
+#![feature(untagged_unions)]
+
+extern crate cpu;
+
+mod ffi;
+pub mod gpio;

examples/rust/README.md

@@ -12,11 +12,22 @@ crates to map RIOTs API to Rust are available.
 
 Since building binary packages with `#![no_std]` is currently not
 supported by the rust stable channel you need a nightly rust toolchain.
-
-After installing the nightly rust toolchain you should be good to go.
 The nightly version is needed because it is currently the only version
 supporting builds without the standard library for bin crates.
 
+Besides you need to install
+[bindgen](https://github.com/servo/rust-bindgen). Bindgen is needed to
+automatically generated Rust code from C header files. To install
+bindgen you can simply use cargo:
+
+    $ cargo install bindgen
+
+Afterwards verify that bindgen works as expected by running:
+
+    $ bindgen --help
+
+If you don't see any error message you should be good to go.
+
 # Upgrading
 
 As explained above we can't use libstd and instead rely on the smaller
@@ -31,6 +42,6 @@ afterwards.
 
 As always,
 
-    # make BOARD=native all term
+    $ make BOARD=native all term
 
 is all you need.

examples/rust/blinky/Makefile

@@ -14,6 +14,6 @@ FEATURES_REQUIRED += rust_support
 BOARD ?= native
 
 # Depend on the rust/fmt wrapper for the fmt module.
-USEMODULE += rust/gpio rust/xtimer
+USEMODULE += rust/xtimer rust/periph
 
 include $(RIOTBASE)/Makefile.include

examples/rust/blinky/main.rs

@@ -10,10 +10,10 @@ mod lang_items {
     fn eh_personality() {}
 }
 
-extern crate gpio;
+extern crate periph;
 extern crate xtimer;
 
-use gpio::Pin;
+use periph::gpio::Pin;
 use xtimer::Duration::Seconds;
 
 #[no_mangle]