Merge pull request #165 from cardoe/support-for-rustbuild

Switch to using rustbuild

classes/cargo.bbclass

@@ -1,13 +1,13 @@
-# add crate fetch support
+##
-inherit crate-fetch
+## Purpose:
-inherit rust-common
+## This class is used by any recipes that are built using
+## Cargo.
+
+inherit cargo_common
 
 # the binary we will use
 CARGO = "cargo"
 
-# Where we download our registry and dependencies to
-export CARGO_HOME = "${WORKDIR}/cargo_home"
-
 # We need cargo to compile for the target
 BASEDEPENDS_append = " cargo-native"
 
@@ -22,38 +22,6 @@ B = "${S}"
 # where the issue occured
 export RUST_BACKTRACE = "1"
 
-# The pkg-config-rs library used by cargo build scripts disables itself when
-# cross compiling unless this is defined. We set up pkg-config appropriately
-# for cross compilation, so tell it we know better than it.
-export PKG_CONFIG_ALLOW_CROSS = "1"
-
-cargo_do_configure () {
-	mkdir -p ${CARGO_HOME}
-	echo "paths = [" > ${CARGO_HOME}/config
-
-	for p in ${EXTRA_OECARGO_PATHS}; do
-		printf "\"%s\"\n" "$p"
-	done | sed -e 's/$/,/' >> ${CARGO_HOME}/config
-	echo "]" >> ${CARGO_HOME}/config
-
-	# Point cargo at our local mirror of the registry
-	cat <<- EOF >> ${CARGO_HOME}/config
-	[source.bitbake]
-	directory = "${CARGO_HOME}/bitbake"
-
-	[source.crates-io]
-	replace-with = "bitbake"
-	local-registry = "/nonexistant"
-	EOF
-
-	echo "[target.${HOST_SYS}]" >> ${CARGO_HOME}/config
-	echo "linker = '${RUST_TARGET_CCLD}'" >> ${CARGO_HOME}/config
-	if [ "${HOST_SYS}" != "${BUILD_SYS}" ]; then
-		echo "[target.${BUILD_SYS}]" >> ${CARGO_HOME}/config
-		echo "linker = '${RUST_BUILD_CCLD}'" >> ${CARGO_HOME}/config
-	fi
-}
-
 RUSTFLAGS ??= ""
 CARGO_BUILD_FLAGS = "-v --target ${HOST_SYS} --release"
 RUST_TARGET_PATH = "${STAGING_LIBDIR_NATIVE}/rustlib"
@@ -70,23 +38,6 @@ oe_cargo_build () {
 	"${CARGO}" build ${CARGO_BUILD_FLAGS} "$@"
 }
 
-oe_cargo_fix_env () {
-	export CC="${RUST_TARGET_CC}"
-	export CXX="${RUST_TARGET_CXX}"
-	export CFLAGS="${CFLAGS}"
-	export AR="${AR}"
-	export TARGET_CC="${RUST_TARGET_CC}"
-	export TARGET_CXX="${RUST_TARGET_CXX}"
-	export TARGET_CFLAGS="${CFLAGS}"
-	export TARGET_AR="${AR}"
-	export HOST_CC="${RUST_BUILD_CC}"
-	export HOST_CXX="${RUST_BUILD_CXX}"
-	export HOST_CFLAGS="${BUILD_CFLAGS}"
-	export HOST_AR="${BUILD_AR}"
-}
-
-EXTRA_OECARGO_PATHS ??= ""
-
 cargo_do_compile () {
 	oe_cargo_fix_env
 	oe_cargo_build
@@ -110,4 +61,4 @@ cargo_do_install () {
 	fi
 }
 
-EXPORT_FUNCTIONS do_configure do_compile do_install
+EXPORT_FUNCTIONS do_compile do_install

classes/cargo_common.bbclass

@@ -0,0 +1,70 @@
+##
+## Purpose:
+## This class is to support building with cargo. It
+## must be different than cargo.bbclass because Rust
+## now builds with Cargo but cannot use cargo.bbclass
+## due to dependencies and assumptions in cargo.bbclass
+## that Rust & Cargo are already installed. So this
+## is used by cargo.bbclass and Rust
+##
+
+# add crate fetch support
+inherit crate-fetch
+inherit rust-common
+
+# Where we download our registry and dependencies to
+export CARGO_HOME = "${WORKDIR}/cargo_home"
+
+# The pkg-config-rs library used by cargo build scripts disables itself when
+# cross compiling unless this is defined. We set up pkg-config appropriately
+# for cross compilation, so tell it we know better than it.
+export PKG_CONFIG_ALLOW_CROSS = "1"
+
+cargo_common_do_configure () {
+	mkdir -p ${CARGO_HOME}
+	echo "paths = [" > ${CARGO_HOME}/config
+
+	for p in ${EXTRA_OECARGO_PATHS}; do
+		printf "\"%s\"\n" "$p"
+	done | sed -e 's/$/,/' >> ${CARGO_HOME}/config
+	echo "]" >> ${CARGO_HOME}/config
+
+	# Point cargo at our local mirror of the registry
+	cat <<- EOF >> ${CARGO_HOME}/config
+	[source.bitbake]
+	directory = "${CARGO_HOME}/bitbake"
+
+	[source.crates-io]
+	replace-with = "bitbake"
+	local-registry = "/nonexistant"
+	EOF
+
+	echo "[target.${HOST_SYS}]" >> ${CARGO_HOME}/config
+	echo "linker = '${RUST_TARGET_CCLD}'" >> ${CARGO_HOME}/config
+	if [ "${HOST_SYS}" != "${BUILD_SYS}" ]; then
+		echo "[target.${BUILD_SYS}]" >> ${CARGO_HOME}/config
+		echo "linker = '${RUST_BUILD_CCLD}'" >> ${CARGO_HOME}/config
+	fi
+}
+
+oe_cargo_fix_env () {
+	export CC="${RUST_TARGET_CC}"
+	export CXX="${RUST_TARGET_CXX}"
+	export CFLAGS="${CFLAGS}"
+	export CXXFLAGS="${CXXFLAGS}"
+	export AR="${AR}"
+	export TARGET_CC="${RUST_TARGET_CC}"
+	export TARGET_CXX="${RUST_TARGET_CXX}"
+	export TARGET_CFLAGS="${CFLAGS}"
+	export TARGET_CFLAGS="${CXXFLAGS}"
+	export TARGET_AR="${AR}"
+	export HOST_CC="${RUST_BUILD_CC}"
+	export HOST_CXX="${RUST_BUILD_CXX}"
+	export HOST_CFLAGS="${BUILD_CFLAGS}"
+	export HOST_CXXFLAGS="${BUILD_CXXFLAGS}"
+	export HOST_AR="${BUILD_AR}"
+}
+
+EXTRA_OECARGO_PATHS ??= ""
+
+EXPORT_FUNCTIONS do_configure

classes/rust-common.bbclass

@@ -5,7 +5,7 @@ FILES_${PN}-dev += "${rustlibdir}/*.rlib"
 FILES_${PN}-dbg += "${rustlibdir}/.debug"
 
 RUSTLIB = "-L ${STAGING_LIBDIR}/rust"
-RUSTFLAGS += "-C rpath ${RUSTLIB}"
+RUSTFLAGS += "${RUSTLIB}"
 RUSTLIB_DEP ?= "libstd-rs"
 
 # Responsible for taking Yocto triples and converting it to Rust triples

recipes-devtools/cargo/cargo-0.16.0.inc

@@ -0,0 +1,11 @@
+CARGO_SNAPSHOT = "2016-09-01/cargo-nightly-x86_64-unknown-linux-gnu.tar.gz;downloadfilename=cargo-nightly-x86_64-unknown-linux-gnu-2016-09-01.tar.gz"
+SRC_URI[cargo-snapshot.md5sum] = "d41ebf79290a7c9c9e5df87cb27e5091"
+SRC_URI[cargo-snapshot.sha256sum] = "365e5cad79512d244b8ced32f8e5b86a710fc6c17f0d0f5f744b8058ef6dc756"
+
+SRC_URI += "\
+	https://static.rust-lang.org/cargo-dist/${CARGO_SNAPSHOT};name=cargo-snapshot \
+"
+
+# When building cargo-native we don't have a built cargo to use so we must use
+# the snapshot to bootstrap the build of cargo
+CARGO_class-native = "${WORKDIR}/cargo-nightly-${RUST_BUILD_SYS}/cargo/bin/cargo"

recipes-devtools/cargo/cargo-snapshot.inc

@@ -1,4 +0,0 @@
-
-CARGO_SNAPSHOT = "2016-09-01/cargo-nightly-x86_64-unknown-linux-gnu.tar.gz;downloadfilename=cargo-nightly-x86_64-unknown-linux-gnu-2016-09-01.tar.gz"
-SRC_URI[md5sum] = "d41ebf79290a7c9c9e5df87cb27e5091"
-SRC_URI[sha256sum] = "365e5cad79512d244b8ced32f8e5b86a710fc6c17f0d0f5f744b8058ef6dc756"

recipes-devtools/cargo/cargo.inc

@@ -1,23 +1,12 @@
-require cargo-snapshot.inc
-
 SECTION = "devel"
 
 DEPENDS = "openssl zlib libgit2 curl ca-certificates libssh2"
 
-SRC_URI += "\
-	http://static-rust-lang-org.s3.amazonaws.com/cargo-dist/${CARGO_SNAPSHOT} \
-"
-
 LIC_FILES_CHKSUM += " \
-file://LICENSE-APACHE;md5=1836efb2eb779966696f473ee8540542 \
 file://LICENSE-THIRD-PARTY;md5=892ea68b169e69cfe75097fc38a15b56 \
 "
 
 # Used in libgit2-sys's build.rs, needed for pkg-config to be used
 export LIBGIT2_SYS_USE_PKG_CONFIG = "1"
 
-# When building cargo-native we don't have a built cargo to use so we must use
-# the snapshot to bootstrap the build of cargo
-CARGO_class-native = "${WORKDIR}/cargo-nightly-${RUST_BUILD_SYS}/cargo/bin/cargo"
-
 BBCLASSEXTEND = "native"

recipes-devtools/cargo/cargo_0.16.0.bb

@@ -1,4 +1,4 @@
-# Auto-Generated by cargo-bitbake 0.3.6
+# Auto-Generated by cargo-bitbake 0.3.8
 #
 inherit cargo
 
@@ -89,6 +89,7 @@ crate://crates.io/ws2_32-sys/0.2.1 \
 
 LIC_FILES_CHKSUM=" \
 file://LICENSE-MIT;md5=362255802eb5aa87810d12ddf3cfedb4 \
+file://LICENSE-APACHE;md5=1836efb2eb779966696f473ee8540542 \
 "
 
 SUMMARY = "Cargo, a package manager for Rust."
@@ -98,4 +99,5 @@ LICENSE = "MIT | Apache-2.0"
 # includes this file if it exists but does not fail
 # this is useful for anything you may want to override from
 # what cargo-bitbake generates.
+include cargo-${PV}.inc
 include cargo.inc

recipes-devtools/rust/libstd-rs.inc

@@ -2,7 +2,7 @@ SUMMARY = "Rust standard libaries"
 HOMEPAGE = "http://www.rust-lang.org"
 SECTION = "devel"
 LICENSE = "MIT | Apache-2.0"
-LIC_FILES_CHKSUM ="file://COPYRIGHT;md5=43e1f1fb9c0ee3af66693d8c4fecafa8"
+LIC_FILES_CHKSUM ="file://../../COPYRIGHT;md5=43e1f1fb9c0ee3af66693d8c4fecafa8"
 
 RUSTLIB_DEP = ""
 inherit cargo
@@ -10,16 +10,16 @@ inherit cargo
 # Needed so cargo can find libbacktrace
 RUSTFLAGS += "-L ${STAGING_LIBDIR}"
 
+S = "${RUSTSRC}/src/libstd"
+
 do_compile_prepend () {
-    cd ${S}/src/rustc/std_shim
     export CARGO_TARGET_DIR="${B}"
-    # For Rust 1.12.1 and lower
-    export RUSTC_BOOTSTRAP_KEY="${RS_KEY}"
     # For Rust 1.13.0 and newer
     export RUSTC_BOOTSTRAP="1"
 }
 
 do_install () {
     mkdir -p ${D}${rustlibdir}
+
     cp ${B}/${TARGET_SYS}/release/deps/* ${D}${rustlibdir}
 }

recipes-devtools/rust/libstd-rs_1.15.1.bb

@@ -1,9 +1,9 @@
 require rust-source-${PV}.inc
 require libstd-rs.inc
 
-EXTRA_OECONF = "--disable-rustbuild"
+# Don't use jemalloc as it doesn't work for many targets.
-
+# https://github.com/rust-lang/rust/pull/37392
-CARGO_BUILD_FLAGS += "--features 'jemalloc panic-unwind'"
+CARGO_BUILD_FLAGS += "--features 'panic-unwind'"
 
 SRC_URI += "\
 	crate://crates.io/cmake/0.1.18 \

recipes-devtools/rust/rust-cross_1.15.1.bb

@@ -1,2 +1,3 @@
 require rust-cross.inc
 require rust-source-${PV}.inc
+require rust-snapshot-${PV}.inc

recipes-devtools/rust/rust-snapshot-1.15.1.inc

@@ -0,0 +1,30 @@
+# Specifics for Rust 1.15.1
+
+## This is information on the rust-snapshot (binary) used to build our current release.
+## snapshot info is taken from rust/src/stage0.txt
+## TODO: find a way to add additional SRC_URIs based on the contents of an
+##       earlier SRC_URI.
+RS_VERSION = "1.14.0"
+
+RUST_STD_SNAPSHOT = "rust-std-${RS_VERSION}-${RUST_BUILD_SYS}"
+RUSTC_SNAPSHOT = "rustc-${RS_VERSION}-${RUST_BUILD_SYS}"
+CARGO_REV = "fbeea902d2c9a5be6d99cc35681565d8f7832592"
+CARGO_SNAPSHOT = "cargo-nightly-${RUST_BUILD_SYS}"
+
+SRC_URI += " \
+	https://static.rust-lang.org/dist/${RUST_STD_SNAPSHOT}.tar.gz;name=rust-std-snapshot;subdir=rust-snapshot-components \
+	https://static.rust-lang.org/dist/${RUSTC_SNAPSHOT}.tar.gz;name=rustc-snapshot;subdir=rust-snapshot-components \
+"
+
+# Downloaded cargo tarballs must be named differently to distinguish between versions.
+SRC_URI += " \
+	https://s3.amazonaws.com/rust-lang-ci/cargo-builds/${CARGO_REV}/${CARGO_SNAPSHOT}.tar.gz;name=cargo-snapshot;subdir=rust-snapshot-components;downloadfilename=${CARGO_SNAPSHOT}-${CARGO_REV}.tar.gz \
+"
+
+# These are x86_64-unknown-linux-gnu hashes, how can we add more?
+SRC_URI[rustc-snapshot.md5sum] = "f178d9d6aad0f87c451f4b2f93170633"
+SRC_URI[rustc-snapshot.sha256sum] = "0eeec4211aa872f24c220200a0c2b095bbfc9c0f737c1c5df2555967c8f36787"
+SRC_URI[rust-std-snapshot.md5sum] = "518e492fc3d50d8c678056eb788bd0e7"
+SRC_URI[rust-std-snapshot.sha256sum] = "3a609bfe9572c742d71199faad578ee76abe9067cd8df698bda6e3ef5caf6ec4"
+SRC_URI[cargo-snapshot.md5sum] = "59bc24d15c393de364dadb3f4e3c9a5a"
+SRC_URI[cargo-snapshot.sha256sum] = "0e052514ee88f236153a0d6c6f38f66d691eb4cf1ac09e6040d96e5101d57800"

recipes-devtools/rust/rust-source-1.15.1.inc

@@ -1,17 +1,5 @@
 # Specifics for Rust 1.15.1
 
-## This is information on the rust-snapshot (binary) used to build our current release.
-## snapshot info is taken from rust/src/stage0.txt
-## TODO: find a way to add additional SRC_URIs based on the contents of an
-##       earlier SRC_URI.
-RS_VERSION = "1.14.0"
-
-RUST_SNAPSHOT = "rustc-${RS_VERSION}-${RUST_BUILD_SYS}"
-
-# These are x86_64-unknown-linux-gnu hashes, how can we add more?
-SRC_URI[rust-snapshot.md5sum] = "f178d9d6aad0f87c451f4b2f93170633"
-SRC_URI[rust-snapshot.sha256sum] = "0eeec4211aa872f24c220200a0c2b095bbfc9c0f737c1c5df2555967c8f36787"
-
 SRC_URI += "\
 	https://static.rust-lang.org/dist/rustc-${PV}-src.tar.gz;name=rust \
     "

recipes-devtools/rust/rust.inc

@@ -5,18 +5,26 @@ LICENSE = "MIT | Apache-2.0"
 LIC_FILES_CHKSUM ="file://COPYRIGHT;md5=43e1f1fb9c0ee3af66693d8c4fecafa8"
 
 inherit rust
+inherit cargo_common
 
-SRC_URI = "\
+DEPENDS += "file-native python-native"
-	https://static.rust-lang.org/dist/${RUST_SNAPSHOT}.tar.gz;name=rust-snapshot \
-    "
-
-DEPENDS += "file-native"
 
 # We generate local targets, and need to be able to locate them
 export RUST_TARGET_PATH="${WORKDIR}/targets/"
 
 export FORCE_CRATE_HASH="${BB_TASKHASH}"
 
+setup_cargo_environment () {
+    # The first step is to build bootstrap and some early stage tools,
+    # these are build for the same target as the snapshot, e.g.
+    # x86_64-unknown-linux-gnu.
+    # Later stages are build for the native target (i.e. target.x86_64-linux)
+    cargo_common_do_configure
+
+    echo "[target.${RUST_BUILD_SYS}]" >> ${CARGO_HOME}/config
+    echo "linker = '${RUST_TARGET_CCLD}'" >> ${CARGO_HOME}/config
+}
+
 # Right now this is focused on arm-specific tune features.
 # We get away with this for now as one can only use x86-64 as the build host
 # (not arm).
@@ -115,6 +123,7 @@ DATA_LAYOUT[arm] = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
 LLVM_TARGET[arm] = "${RUST_TARGET_SYS}"
 TARGET_ENDIAN[arm] = "little"
 TARGET_POINTER_WIDTH[arm] = "32"
+MAX_ATOMIC_WIDTH[arm] = "64"
 FEATURES[arm] = "+v6,+vfp2"
 
 ## aarch64-unknown-linux-gnu
@@ -122,24 +131,28 @@ DATA_LAYOUT[aarch64] = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
 LLVM_TARGET[aarch64] = "aarch64-unknown-linux-gnu"
 TARGET_ENDIAN[aarch64] = "little"
 TARGET_POINTER_WIDTH[aarch64] = "64"
+MAX_ATOMIC_WIDTH[aarch64] = "128"
 
 ## x86_64-unknown-linux-gnu
 DATA_LAYOUT[x86_64] = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 LLVM_TARGET[x86_64] = "x86_64-unknown-linux-gnu"
 TARGET_ENDIAN[x86_64] = "little"
 TARGET_POINTER_WIDTH[x86_64] = "64"
+MAX_ATOMIC_WIDTH[x86_64] = "64"
 
 ## i686-unknown-linux-gnu
 DATA_LAYOUT[i686] = "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128"
 LLVM_TARGET[i686] = "i686-unknown-linux-gnu"
 TARGET_ENDIAN[i686] = "little"
 TARGET_POINTER_WIDTH[i686] = "32"
+MAX_ATOMIC_WIDTH[i686] = "64"
 
 ## XXX: a bit of a hack so qemux86 builds, clone of i686-unknown-linux-gnu above
 DATA_LAYOUT[i586] = "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128"
 LLVM_TARGET[i586] = "i586-unknown-linux-gnu"
 TARGET_ENDIAN[i586] = "little"
 TARGET_POINTER_WIDTH[i586] = "32"
+MAX_ATOMIC_WIDTH[i586] = "64"
 
 def arch_for(d, thing):
     return d.getVar('{}_ARCH'.format(thing))
@@ -150,21 +163,6 @@ def sys_for(d, thing):
 def prefix_for(d, thing):
     return d.getVar('{}_PREFIX'.format(thing))
 
-## Note: TOOLCHAIN_OPTIONS is set to "" by native.bbclass and cross.bbclass,
-## which prevents us from grabbing them when building a cross compiler (native doesn't matter).
-## We workaround this in internal-rust-cross.bbclass.
-def cflags_for(d, thing):
-    cc_arch = d.getVar('{}_CC_ARCH'.format(thing)) or ""
-    flags = d.getVar('{}_CFLAGS'.format(thing)) or ""
-    tc = d.getVar('TOOLCHAIN_OPTIONS') or ""
-    return ' '.join([cc_arch, flags, tc])
-
-def cxxflags_for(d, thing):
-    cc_arch = d.getVar('{}_CC_ARCH'.format(thing)) or ""
-    flags = d.getVar('{}_CXXFLAGS'.format(thing)) or ""
-    tc = d.getVar('TOOLCHAIN_OPTIONS') or ""
-    return ' '.join([cc_arch, flags, tc])
-
 # Convert a normal arch (HOST_ARCH, TARGET_ARCH, BUILD_ARCH, etc) to something
 # rust's internals won't choke on.
 def arch_to_rust_target_arch(arch):
@@ -215,29 +213,35 @@ def rust_gen_target(d, thing, wd):
     tspec = {}
     tspec['llvm-target'] = d.getVarFlag('LLVM_TARGET', arch)
     tspec['data-layout'] = d.getVarFlag('DATA_LAYOUT', arch)
+    tspec['max-atomic-width'] = d.getVarFlag('MAX_ATOMIC_WIDTH', arch)
     tspec['target-pointer-width'] = d.getVarFlag('TARGET_POINTER_WIDTH', arch)
-    tspec['target-word-size'] = tspec['target-pointer-width']
     tspec['target-endian'] = d.getVarFlag('TARGET_ENDIAN', arch)
     tspec['arch'] = arch_to_rust_target_arch(arch)
     tspec['os'] = "linux"
     tspec['env'] = "gnu"
+    tspec['vendor'] = "unknown"
+    tspec['target-family'] = "unix"
     tspec['linker'] = "{}{}gcc".format(d.getVar('CCACHE'), prefix)
-    tspec['objcopy'] = "{}objcopy".format(prefix)
     tspec['ar'] = "{}ar".format(prefix)
     tspec['cpu'] = cpu
     if features is not "":
         tspec['features'] = features
     tspec['dynamic-linking'] = True
     tspec['executables'] = True
-    tspec['morestack'] = True
     tspec['linker-is-gnu'] = True
+    tspec['linker-flavor'] = "gcc"
     tspec['has-rpath'] = True
     tspec['has-elf-tls'] = True
     tspec['position-independent-executables'] = True
 
+    # Don't use jemalloc as it doesn't work for many targets.
+    # https://github.com/rust-lang/rust/pull/37392
+    tspec['exe-allocation-crate'] = "alloc_system"
+    tspec['lib-allocation-crate'] = "alloc_system"
+
     # write out the target spec json file
     with open(wd + sys + '.json', 'w') as f:
-        json.dump(tspec, f)
+        json.dump(tspec, f, indent=4)
 
 
 python do_rust_gen_targets () {
@@ -252,128 +256,86 @@ python do_rust_gen_targets () {
 addtask rust_gen_targets after do_patch before do_compile
 do_rust_gen_targets[dirs] += "${WORKDIR}/targets"
 
-def rust_gen_mk_cfg(d, thing):
-    ''''
-    Rust's build system adds support for new archs via 2 things:
-     1. a file in mk/cfg which defines how the runtime libraries are built
-     2. and rustc arch definition either built into the compiler or supplied as a .json file
 
-    This generates a new #1 for the given 'thing' (one of HOST, TARGET, BUILD)
+do_rust_setup_snapshot () {
-    using a "similar" config that rust already supplies as a template.
+    for installer in "${WORKDIR}/rust-snapshot-components/"*"/install.sh"; do
+        "${installer}" --prefix="${WORKDIR}/rust-snapshot" --disable-ldconfig
+    done
 
-    Note that the configure process also depends on the existence of #1, so we
+    # Some versions of rust (e.g. 1.18.0) tries to find cargo in stage0/bin/cargo
-    have to run this before do_configure
+    # and fail without it there.
-    '''
+    mkdir -p ${RUSTSRC}/build/${BUILD_SYS}
-    import os
+    ln -s ${WORKDIR}/rust-snapshot/ ${RUSTSRC}/build/${BUILD_SYS}/stage0
-    import subprocess
-
-    rust_base_sys = rust_base_triple(d, thing)
-    arch = arch_for(d, thing)
-    sys = sys_for(d, thing)
-    prefix = prefix_for(d, thing)
-    llvm_target = d.getVarFlag('LLVM_TARGET', arch)
-    ldflags = d.getVar('LDFLAGS') + d.getVar('HOST_CC_ARCH') + d.getVar('TOOLCHAIN_OPTIONS')
-
-    b = os.path.join(d.getVar('S'), 'mk', 'cfg')
-    o = open(os.path.join(b, sys_for(d, thing) + '.mk'), 'w')
-    i = open(os.path.join(b, rust_base_sys + '.mk'), 'r')
-
-    r = subprocess.call(['sed',
-        # CFLAGS, LDFLAGS, CXXFLAGS, CPPFLAGS are used by rust's build for a
-        # wide range of targets (not just HOST). Yocto's settings for them will
-        # be inappropriate, avoid having random targets try to use them, we'll
-        # add as needed.
-        '-e', 's/$(CFLAGS)//',
-        '-e', 's/$(CXXFLAGS)//',
-        '-e', 's/$(CPPFLAGS)//',
-        '-e', 's/$(LDFLAGS)//',
-
-        # update all triplets to the new one
-        '-e', 's/{}/{}/g'.format(rust_base_sys, sys),
-
-        # Replace tools with our own (CROSS_PREFIX is appended to all tools
-        # by rust's build system). We delete and then insert this because not
-        # all targets define it.
-        '-e', 's/^CROSS_PREFIX_{}.*$//'.format(sys),
-        '-e', '2 a CROSS_PREFIX_{} := {}'.format(sys, prefix),
-        '-e', 's/^CFG_LLVM_TARGET_.*$//',
-        '-e', '2 a CFG_LLVM_TARGET_{} := {}'.format(sys, llvm_target),
-        '-e', 's/^CC_{}=.*$/CC_{} := gcc/'.format(sys, sys),
-        '-e', 's/^CXX_{}.*$/CXX_{} := g++/'.format(sys, sys),
-        '-e', 's/^CPP_{}.*$/CPP_{} := gcc -E/'.format(sys, sys),
-        '-e', 's/^AR_{}.*$/AR_{} := ar/'.format(sys, sys),
-
-        # Some targets don't have LINK even though it is required to build.
-        '-e', 's/^LINK_{}.*$//'.format(sys),
-        '-e', '2 a LINK_{} := gcc'.format(sys),
-
-        # Append our flags to the existing ones
-        '-e', '/^CFG_JEMALLOC_CFLAGS/ s;$; {};'.format(cflags_for(d, thing)),
-        '-e', '/^CFG_GCCISH_CFLAGS/ s;$; {};'.format(cflags_for(d, thing)),
-        '-e', '/^CFG_GCCISH_CXXFLAGS/ s;$; {};'.format(cxxflags_for(d, thing)),
-        '-e', '/^CFG_GCCISH_LINK_FLAGS/ s;$; {};'.format(ldflags),
-
-        # May need to add: CFG_LLC_FLAGS_{}
-        ], stdout=o, stdin=i)
-    if r:
-        raise Exception
-    o.write("OBJCOPY_{} := {}objcopy\n".format(sys, prefix))
-    # Note: this isn't how this variable is supposed to be used, but for
-    # non-msvc platforms nothing else touches it.
-    # These are the only extra flags passed to the rustllvm (c++ code) build.
-    # These are only used for host (even though we emit them for all targets)
-    # Without this, there are link failures due to GLIBC_CXX11_ABI issues in
-    # certain setups.
-    o.write("EXTRA_RUSTLLVM_CXXFLAGS_{} := {}\n".format(sys, cxxflags_for(d, thing)))
-    o.close()
-    i.close()
-
-python do_rust_arch_fixup () {
-    for thing in ['BUILD', 'HOST', 'TARGET']:
-        bb.debug(1, "rust_gen_mk_cfg for " + thing)
-        rust_gen_mk_cfg(d, thing)
 }
-addtask rust_arch_fixup before do_configure after do_patch
+addtask rust_setup_snapshot after do_unpack before do_configure
-do_rust_arch_fixup[dirs] += "${S}/mk/cfg"
+do_rust_setup_snapshot[dirs] += "${WORKDIR}/rust-snapshot"
 
-# prevent the rust-installer scripts from calling ldconfig
-export CFG_DISABLE_LDCONFIG="notempty"
 
-# rust's configure doesn't recognize --disable-static, so remove it.
+python do_configure() {
-DISABLE_STATIC = ""
+    import json
+    try:
+        import configparser
+    except ImportError:
+        import ConfigParser as configparser
 
-do_configure () {
+    # toml is rather similar to standard ini like format except it likes values
-    # FIXME: target_prefix vs prefix, see cross.bbclass
+    # that look more JSON like. So for our purposes simply escaping all values
+    # as JSON seem to work fine.
 
-    # - rpath is required otherwise rustc fails to resolve symbols
+    e = lambda s: json.dumps(s)
-    # - submodule management is done by bitbake's fetching
+
-    ${S}/configure                          \
+    config = configparser.RawConfigParser()
-        "--enable-rpath"                    \
+
-        "--disable-docs"                    \
+    # [target.ARCH-poky-linux]
-        "--disable-manage-submodules"       \
+    target_section = "target.{}".format(d.getVar('TARGET_SYS', True))
-        "--disable-debug"                   \
+    config.add_section(target_section)
-        "--enable-optimize"                 \
+
-        "--enable-optimize-cxx"             \
+    llvm_config = d.expand("${STAGING_DIR_NATIVE}${bindir_native}/llvm-config")
-        "--disable-llvm-version-check"      \
+    config.set(target_section, "llvm-config", e(llvm_config))
-        "--llvm-root=${STAGING_DIR_NATIVE}/${prefix_native}" \
+
-        "--enable-optimize-tests"           \
+    config.set(target_section, "cxx", e(d.expand("${RUST_TARGET_CXX}")))
-        "--release-channel=stable"          \
+    config.set(target_section, "cc", e(d.expand("${RUST_TARGET_CC}")))
-        "--prefix=${prefix}"                \
+
-        "--target=${TARGET_SYS}"            \
+    # [rust]
-        "--host=${HOST_SYS}"                \
+    config.add_section("rust")
-        "--build=${BUILD_SYS}"              \
+    config.set("rust", "rpath", e(True))
-        "--localstatedir=${localstatedir}"  \
+    config.set("rust", "channel", e("stable"))
-        "--sysconfdir=${sysconfdir}"        \
+
-        "--datadir=${datadir}"              \
+    # Don't use jemalloc as it doesn't work for many targets.
-        "--infodir=${infodir}"              \
+    # https://github.com/rust-lang/rust/pull/37392
-        "--mandir=${mandir}"                \
+    config.set("rust", "use-jemalloc", e(False))
-        "--libdir=${libdir}"                \
+
-        "--enable-local-rust"               \
+    # Whether or not to optimize the compiler and standard library
-        "--local-rust-root=${WORKDIR}/${RUST_SNAPSHOT}/rustc" \
+    config.set("rust", "optimize", e(True))
-        ${EXTRA_OECONF}
+
+    # [build]
+    config.add_section("build")
+    config.set("build", "submodules", e(False))
+    config.set("build", "docs", e(False))
+
+    rustc = d.expand("${WORKDIR}/rust-snapshot/bin/rustc")
+    config.set("build", "rustc", e(rustc))
+
+    cargo = d.expand("${WORKDIR}/rust-snapshot/bin/cargo")
+    config.set("build", "cargo", e(cargo))
+
+    targets = [d.getVar("TARGET_SYS", True)]
+    config.set("build", "target", e(targets))
+
+    hosts = [d.getVar("HOST_SYS", True)]
+    config.set("build", "host", e(targets))
+
+    config.set("build", "build", e(d.getVar("BUILD_SYS", True)))
+
+    with open("config.toml", "w") as f:
+        config.write(f)
+
+    # set up ${WORKDIR}/cargo_home
+    bb.build.exec_func("setup_cargo_environment", d)
 }
 
-rust_runmake () {
+
+rust_runx () {
     echo "COMPILE ${PN}" "$@"
 
     # CFLAGS, LDFLAGS, CXXFLAGS, CPPFLAGS are used by rust's build for a
@@ -384,15 +346,27 @@ rust_runmake () {
     unset CXXFLAGS
     unset CPPFLAGS
 
-    oe_runmake "VERBOSE=1" "$@"
+    oe_cargo_fix_env
+
+    python src/bootstrap/bootstrap.py "$@" --verbose
 }
 
+
 do_compile () {
-    rust_runmake
+    rust_runx build
 }
 
-rust_do_install () {
+
-    rust_runmake DESTDIR="${D}" install
+rust_do_dist_install () {
+    rust_runx dist
+
+    for installer in "build/tmp/dist/rustc"*"/install.sh"; do
+        "${installer}" --destdir="${D}" --prefix="${prefix}" --disable-ldconfig
+    done
+
+    for installer in "build/tmp/dist/rust-std"*"/install.sh"; do
+        "${installer}" --destdir="${D}" --prefix="${prefix}" --disable-ldconfig
+    done
 
     # Install our custom target.json files
     local td="${D}${libdir}/rustlib/"
@@ -401,10 +375,6 @@ rust_do_install () {
         install -m 0644 "$tgt" "$td"
     done
 
-    # Remove any files directly installed into libdir to avoid
-    # conflicts between cross and native
-    rm -f ${D}${libdir}/lib*.so
-
     # cleanup after rust-installer since we don't need these bits
     rm ${D}/${libdir}/rustlib/install.log
     rm ${D}/${libdir}/rustlib/rust-installer-version
@@ -412,7 +382,8 @@ rust_do_install () {
     rm ${D}/${libdir}/rustlib/components
 }
 
+
 do_install () {
-    rust_do_install
+    rust_do_dist_install
 }
 # ex: sts=4 et sw=4 ts=8

recipes-devtools/rust/rust_1.15.1.bb

@@ -1,12 +1,25 @@
 require rust.inc
 require rust-source-${PV}.inc
-
+require rust-snapshot-${PV}.inc
-EXTRA_OECONF = "--disable-rustbuild"
 
 SRC_URI += " \
         file://rust-${PV}/0003-std-thread_local-workaround-for-NULL-__dso_handle.patch \
         "
 
+# These are extracted from rustc/src/bootstrap/Cargo.toml.
+SRC_URI += " \
+	crate://crates.io/cmake/0.1.18 \
+	crate://crates.io/env_logger/0.3.5 \
+	crate://crates.io/filetime/0.1.10 \
+	crate://crates.io/gcc/0.3.40 \
+	crate://crates.io/getopts/0.2.14 \
+	crate://crates.io/libc/0.2.17 \
+	crate://crates.io/log/0.3.6 \
+	crate://crates.io/num_cpus/0.2.13 \
+	crate://crates.io/rustc-serialize/0.3.19 \
+	crate://crates.io/toml/0.1.30 \
+"
+
 DEPENDS += "rust-llvm (=${PV})"
 
 # Otherwise we'll depend on what we provide

scripts/containerize.sh

@@ -1,7 +1,7 @@
 #!/bin/bash
 
 # what container are we using to build this
-CONTAINER="starlabio/yocto:1.5"
+CONTAINER="cardoe/yocto:pyro"
 
 einfo() {
 	echo "$*" >&2