Merge pull request #153 from cardoe/rust-1.15-morty

Rust 1.15.1 for morty

.github/workflows/main.yml

@@ -1,33 +0,0 @@
-on: [pull_request]
-jobs:
-  build:
-    env:
-      YOCTO_VERSION: 3.3.2
-      YOCTO_BRANCH: hardknott
-    runs-on: self-hosted
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          path: 'meta-rust'
-      - name: Fetch poky
-        run: |
-          mv poky/build/sstate-cache . || true
-          rm -rf poky meta-openembedded
-          git clone -b $YOCTO_BRANCH --single-branch git://git.yoctoproject.org/poky
-          git clone -b $YOCTO_BRANCH --single-branch git://git.openembedded.org/meta-openembedded
-      - name: Configure build
-        run: |
-          cd poky
-          . oe-init-build-env
-          mv ../../sstate-cache . || true
-          bitbake-layers add-layer ../../meta-openembedded/meta-oe
-          bitbake-layers add-layer ../../meta-rust
-          echo 'PARALLEL_MAKE:pn-rust-llvm-native = "-j2"' >> conf/local.conf
-          echo 'TOOLCHAIN_HOST_TASK:append = " packagegroup-rust-cross-canadian-${MACHINE}"' >> conf/local.conf
-          echo 'PREFERRED_PROVIDER_virtual/kernel = "linux-dummy"' >> conf/local.conf
-          echo 'INHERIT_remove = "uninative"' >> conf/local.conf
-      - name: Run bitbake
-        run: |
-          cd poky
-          . oe-init-build-env
-          bitbake rust-hello-world

Jenkinsfile

@@ -1,4 +1,4 @@
-def targets = [ 'qemux86', 'qemux86-64', 'qemuarm', 'qemuarm64', 'qemumips' ]
+def targets = [ 'qemux86', 'qemux86-64', 'qemuarm', 'qemuarm64' ]
 
 def machine_builds = [:]
 
@@ -15,7 +15,7 @@ for (int i = 0; i < targets.size(); i++) {
                     sh "./scripts/setup-env.sh"
                 }
                 stage("fetch $machine") {
-                    sh "GIT_LOCAL_REF_DIR=/srv/git-cache/ ./scripts/fetch.sh master"
+                    sh "GIT_LOCAL_REF_DIR=/srv/git-cache/ ./scripts/fetch.sh morty"
                 }
                 stage("build $machine") {
                     sh "MACHINE=${machine} ./scripts/build.sh"
@@ -25,7 +25,7 @@ for (int i = 0; i < targets.size(); i++) {
                 throw e
             } finally {
                 stage("push build cache $machine") {
-                    sh "./scripts/publish-build-cache.sh master"
+                    sh "./scripts/publish-build-cache.sh morty"
                 }
                 stage("cleanup $machine") {
                     sh "./scripts/cleanup-env.sh"

README.md

@@ -13,7 +13,7 @@ This OpenEmbedded layer provides the rust compiler, tools for building packages
 ## What doesn't:
 
  - Using anything but x86_64 as the build environment
- - rust (built for target) [issue #81](https://github.com/meta-rust/meta-rust/issues/81)
+ - rust (built for target) issue #81
 
 ## What's untested:
 
@@ -27,7 +27,7 @@ rust packages do), then it's especially easy.  Otherwise you should probably
 get the code building in cargo first.
 
 Once your package builds in cargo, you can use
-[cargo-bitbake](https://github.com/meta-rust/cargo-bitbake) to generate a bitbake
+[cargo-bitbake](https://github.com/cardoe/cargo-bitbake) to generate a bitbake
 recipe for it.  This allows bitbake to fetch all the necessary dependent
 crates, as well as a pegged version of the crates.io index, to ensure maximum
 reproducibility.
@@ -39,7 +39,7 @@ contained within it
 
 ## Pitfalls
 
- - TARGET_SYS _must_ be different from BUILD_SYS. This is due to the way Rust configuration options are tracked for different targets. This is the reason we use the Yocto triples instead of the native Rust triples. See [rust-lang/cargo#3349](https://github.com/rust-lang/cargo/issues/3349).
+ - TARGET_SYS _must_ be different from BUILD_SYS. This is due to the way Rust configuration options are tracked for different targets. This is the reason we use the Yocto triples instead of the native Rust triples. See rust-lang/cargo#3349.
 
 ## Dependencies
 
@@ -59,7 +59,7 @@ The master branch supports the latest master of poky. When poky creates releases
 
 All new patches against rust, rust-llvm, and cargo must have referenced
 upstream issues or PRs opened or an explanation why the patch cannot be
-upstreamed. This corresponds to the OpenEmbedded policy for other meta layers.
+upstreamed. This cooresponds to the OpenEmbedded policy for other meta layers.
 
 More info can be seen on the wiki.
 

classes/cargo.bbclass

@@ -1,52 +1,87 @@
-##
-## Purpose:
-## This class is used by any recipes that are built using
-## Cargo.
-
-inherit cargo_common
+# add crate fetch support
+inherit crate-fetch
+inherit rust-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"
+BASEDEPENDS_append = " cargo-native"
 
 # Ensure we get the right rust variant
-DEPENDS:append:class-target = " virtual/${TARGET_PREFIX}rust ${RUSTLIB_DEP}"
-DEPENDS:append:class-native = " rust-native"
+DEPENDS_append_class-target = " virtual/${TARGET_PREFIX}rust ${RUSTLIB_DEP}"
+DEPENDS_append_class-native = " rust-native"
 
-# Enable build separation
-B = "${WORKDIR}/build"
+# Cargo only supports in-tree builds at the moment
+B = "${S}"
 
 # In case something fails in the build process, give a bit more feedback on
 # where the issue occured
 export RUST_BACKTRACE = "1"
 
-# The directory of the Cargo.toml relative to the root directory, per default
-# assume there's a Cargo.toml directly in the root directory
-CARGO_SRC_DIR ??= ""
+# 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"
 
-# The actual path to the Cargo.toml
-MANIFEST_PATH ??= "${S}/${CARGO_SRC_DIR}/Cargo.toml"
+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 ??= ""
-BUILD_MODE = "${@['--release', ''][d.getVar('DEBUG_BUILD') == '1']}"
-CARGO_BUILD_FLAGS = "-v --target ${HOST_SYS} ${BUILD_MODE} --manifest-path=${MANIFEST_PATH}"
+CARGO_BUILD_FLAGS = "-v --target ${HOST_SYS} --release"
 
 # This is based on the content of CARGO_BUILD_FLAGS and generally will need to
 # change if CARGO_BUILD_FLAGS changes.
-BUILD_DIR = "${@['release', 'debug'][d.getVar('DEBUG_BUILD') == '1']}"
-CARGO_TARGET_SUBDIR="${HOST_SYS}/${BUILD_DIR}"
+CARGO_TARGET_SUBDIR="${HOST_SYS}/release"
 oe_cargo_build () {
 	export RUSTFLAGS="${RUSTFLAGS}"
-	export RUST_TARGET_PATH="${RUST_TARGET_PATH}"
-	bbnote "cargo = $(which ${CARGO})"
-	bbnote "rustc = $(which ${RUSTC})"
+	bbnote "cargo = $(which cargo)"
+	bbnote "rustc = $(which rustc)"
 	bbnote "${CARGO} build ${CARGO_BUILD_FLAGS} $@"
 	"${CARGO}" build ${CARGO_BUILD_FLAGS} "$@"
 }
 
-do_compile[progress] = "outof:\s+(\d+)/(\d+)"
+oe_cargo_fix_env () {
+	export CC="${RUST_TARGET_CC}"
+	export CFLAGS="${CFLAGS}"
+	export AR="${AR}"
+	export TARGET_CC="${RUST_TARGET_CC}"
+	export TARGET_CFLAGS="${CFLAGS}"
+	export TARGET_AR="${AR}"
+	export HOST_CC="${RUST_BUILD_CC}"
+	export HOST_CFLAGS="${BUILD_CFLAGS}"
+	export HOST_AR="${BUILD_AR}"
+}
+
+EXTRA_OECARGO_PATHS ??= ""
+
 cargo_do_compile () {
 	oe_cargo_fix_env
 	oe_cargo_build
@@ -55,35 +90,19 @@ cargo_do_compile () {
 cargo_do_install () {
 	local have_installed=false
 	for tgt in "${B}/target/${CARGO_TARGET_SUBDIR}/"*; do
-		case $tgt in
-		*.so|*.rlib)
+		if [[ $tgt == *.so || $tgt == *.rlib ]]; then
 			install -d "${D}${rustlibdir}"
 			install -m755 "$tgt" "${D}${rustlibdir}"
 			have_installed=true
-			;;
-		*examples)
-			if [ -d "$tgt" ]; then
-				for example in "$tgt/"*; do
-					if [ -f "$example" ] && [ -x "$example" ]; then
-						install -d "${D}${bindir}"
-						install -m755 "$example" "${D}${bindir}"
-						have_installed=true
-					fi
-				done
-			fi
-			;;
-		*)
-			if [ -f "$tgt" ] && [ -x "$tgt" ]; then
-				install -d "${D}${bindir}"
-				install -m755 "$tgt" "${D}${bindir}"
-				have_installed=true
-			fi
-			;;
-		esac
+		elif [ -f "$tgt" ] && [ -x "$tgt" ]; then
+			install -d "${D}${bindir}"
+			install -m755 "$tgt" "${D}${bindir}"
+			have_installed=true
+		fi
 	done
 	if ! $have_installed; then
 		die "Did not find anything to install"
 	fi
 }
 
-EXPORT_FUNCTIONS do_compile do_install
+EXPORT_FUNCTIONS do_configure do_compile do_install

classes/cargo_common.bbclass

@@ -1,129 +0,0 @@
-##
-## 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"
-
-# Don't instruct cargo to use crates downloaded by bitbake. Some rust packages,
-# for example the rust compiler itself, come with their own vendored sources.
-# Specifying two [source.crates-io] will not work.
-CARGO_DISABLE_BITBAKE_VENDORING ?= "0"
-
-# Used by libstd-rs to point to the vendor dir included in rustc src
-CARGO_VENDORING_DIRECTORY ?= "${CARGO_HOME}/bitbake"
-
-CARGO_RUST_TARGET_CCLD ?= "${RUST_TARGET_CCLD}"
-cargo_common_do_configure () {
-	mkdir -p ${CARGO_HOME}/bitbake
-
-	cat <<- EOF > ${CARGO_HOME}/config
-	# EXTRA_OECARGO_PATHS
-	paths = [
-	$(for p in ${EXTRA_OECARGO_PATHS}; do echo \"$p\",; done)
-	]
-	EOF
-
-	cat <<- EOF >> ${CARGO_HOME}/config
-
-	# Local mirror vendored by bitbake
-	[source.bitbake]
-	directory = "${CARGO_VENDORING_DIRECTORY}"
-	EOF
-
-	if [ -z "${EXTERNALSRC}" ] && [ ${CARGO_DISABLE_BITBAKE_VENDORING} = "0" ]; then
-		cat <<- EOF >> ${CARGO_HOME}/config
-
-		[source.crates-io]
-		replace-with = "bitbake"
-		local-registry = "/nonexistant"
-		EOF
-	fi
-
-	cat <<- EOF >> ${CARGO_HOME}/config
-
-	[http]
-	# Multiplexing can't be enabled because http2 can't be enabled
-	# in curl-native without dependency loops
-	multiplexing = false
-
-	# Ignore the hard coded and incorrect path to certificates
-	cainfo = "${STAGING_ETCDIR_NATIVE}/ssl/certs/ca-certificates.crt"
-
-	EOF
-
-	if [ -n "${http_proxy}" ]; then
-		echo "proxy = \"${http_proxy}\"" >> ${CARGO_HOME}/config
-	fi
-
-	cat <<- EOF >> ${CARGO_HOME}/config
-
-	# HOST_SYS
-	[target.${HOST_SYS}]
-	linker = "${CARGO_RUST_TARGET_CCLD}"
-	EOF
-
-	if [ "${HOST_SYS}" != "${BUILD_SYS}" ]; then
-		cat <<- EOF >> ${CARGO_HOME}/config
-
-		# BUILD_SYS
-		[target.${BUILD_SYS}]
-		linker = "${RUST_BUILD_CCLD}"
-		EOF
-	fi
-
-	# Put build output in build directory preferred by bitbake instead of
-	# inside source directory unless they are the same
-	if [ "${B}" != "${S}" ]; then
-		cat <<- EOF >> ${CARGO_HOME}/config
-
-		[build]
-		# Use out of tree build destination to avoid poluting the source tree
-		target-dir = "${B}/target"
-		EOF
-	fi
-
-	cat <<- EOF >> ${CARGO_HOME}/config
-
-	[term]
-	progress.when = 'always'
-	progress.width = 80
-	EOF
-}
-
-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_CXXFLAGS="${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-bin.bbclass

@@ -1,8 +1,10 @@
 inherit rust
 
-RDEPENDS:${PN}:append:class-target = " ${RUSTLIB_DEP}"
+DEPENDS_append = " patchelf-native"
+RDEPENDS_${PN} += "${RUSTLIB_DEP}"
 
-RUSTC_ARCHFLAGS += "-C opt-level=3 -g -L ${STAGING_DIR_HOST}/${rustlibdir} -C linker=${RUST_TARGET_CCLD}"
+RUSTFLAGS += "-C crate_hash=${BB_TASKHASH}"
+RUSTC_ARCHFLAGS += "-C opt-level=3 -g -L ${STAGING_DIR_HOST}/${rustlibdir}"
 EXTRA_OEMAKE += 'RUSTC_ARCHFLAGS="${RUSTC_ARCHFLAGS}"'
 
 # Some libraries alias with the standard library but libstd is configured to
@@ -15,9 +17,9 @@ OVERLAP_LIBS = "\
     rand \
 "
 def get_overlap_deps(d):
-    deps = d.getVar("DEPENDS").split()
+    deps = d.getVar("DEPENDS", True).split()
     overlap_deps = []
-    for o in d.getVar("OVERLAP_LIBS").split():
+    for o in d.getVar("OVERLAP_LIBS", True).split():
         l = len([o for dep in deps if (o + '-rs' in dep)])
         if l > 0:
             overlap_deps.append(o)
@@ -29,51 +31,13 @@ OVERLAP_DEPS = "${@get_overlap_deps(d)}"
 RUSTC_PREFER_DYNAMIC = "-C prefer-dynamic"
 RUSTC_FLAGS += "${RUSTC_PREFER_DYNAMIC}"
 
-CRATE_NAME ?= "${@d.getVar('BPN').replace('-rs', '').replace('-', '_')}"
+CRATE_NAME ?= "${@d.getVar('BPN', True).replace('-rs', '').replace('-', '_')}"
 BINNAME ?= "${BPN}"
 LIBNAME ?= "lib${CRATE_NAME}-rs"
 CRATE_TYPE ?= "dylib"
 BIN_SRC ?= "${S}/src/main.rs"
 LIB_SRC ?= "${S}/src/lib.rs"
 
-rustbindest ?= "${bindir}"
-rustlibdest ?= "${rustlibdir}"
-RUST_RPATH_ABS ?= "${rustlibdir}:${rustlib}"
-
-def relative_rpaths(paths, base):
-    relpaths = set()
-    for p in paths.split(':'):
-        if p == base:
-            relpaths.add('$ORIGIN')
-            continue
-        relpaths.add(os.path.join('$ORIGIN', os.path.relpath(p, base)))
-    return '-rpath=' + ':'.join(relpaths) if len(relpaths) else ''
-
-RUST_LIB_RPATH_FLAGS ?= "${@relative_rpaths(d.getVar('RUST_RPATH_ABS', True), d.getVar('rustlibdest', True))}"
-RUST_BIN_RPATH_FLAGS ?= "${@relative_rpaths(d.getVar('RUST_RPATH_ABS', True), d.getVar('rustbindest', True))}"
-
-def libfilename(d):
-    if d.getVar('CRATE_TYPE', True) == 'dylib':
-        return d.getVar('LIBNAME', True) + '.so'
-    else:
-        return d.getVar('LIBNAME', True) + '.rlib'
-
-def link_args(d, bin):
-    linkargs = []
-    if bin:
-        rpaths = d.getVar('RUST_BIN_RPATH_FLAGS', False)
-    else:
-        rpaths = d.getVar('RUST_LIB_RPATH_FLAGS', False)
-        if d.getVar('CRATE_TYPE', True) == 'dylib':
-            linkargs.append('-soname')
-            linkargs.append(libfilename(d))
-    if len(rpaths):
-        linkargs.append(rpaths)
-    if len(linkargs):
-        return ' '.join(['-Wl,' + arg for arg in linkargs])
-    else:
-        return ''
-
 get_overlap_externs () {
     externs=
     for dep in ${OVERLAP_DEPS}; do
@@ -93,22 +57,22 @@ do_configure () {
 }
 
 oe_runrustc () {
-	export RUST_TARGET_PATH="${RUST_TARGET_PATH}"
 	bbnote ${RUSTC} ${RUSTC_ARCHFLAGS} ${RUSTC_FLAGS} "$@"
 	"${RUSTC}" ${RUSTC_ARCHFLAGS} ${RUSTC_FLAGS} "$@"
 }
 
 oe_compile_rust_lib () {
+    [ "${CRATE_TYPE}" == "dylib" ] && suffix=so || suffix=rlib
     rm -rf ${LIBNAME}.{rlib,so}
     local -a link_args
-    if [ -n '${@link_args(d, False)}' ]; then
-        link_args[0]='-C'
-        link_args[1]='link-args=${@link_args(d, False)}'
+    if [ "${CRATE_TYPE}" == "dylib" ]; then
+        link_args[0]="-C"
+        link_args[1]="link-args=-Wl,-soname -Wl,${LIBNAME}.$suffix"
     fi
     oe_runrustc $(get_overlap_externs) \
         "${link_args[@]}" \
         ${LIB_SRC} \
-        -o ${@libfilename(d)} \
+        -o ${LIBNAME}.$suffix \
         --crate-name=${CRATE_NAME} --crate-type=${CRATE_TYPE} \
         "$@"
 }
@@ -116,27 +80,20 @@ oe_compile_rust_lib[vardeps] += "get_overlap_externs"
 
 oe_compile_rust_bin () {
     rm -rf ${BINNAME}
-    local -a link_args
-    if [ -n '${@link_args(d, True)}' ]; then
-        link_args[0]='-C'
-        link_args[1]='link-args=${@link_args(d, True)}'
-    fi
-    oe_runrustc $(get_overlap_externs) \
-        "${link_args[@]}" \
-        ${BIN_SRC} -o ${BINNAME} "$@"
+    oe_runrustc $(get_overlap_externs) ${BIN_SRC} -o ${BINNAME} "$@"
 }
 oe_compile_rust_bin[vardeps] += "get_overlap_externs"
 
 oe_install_rust_lib () {
     for lib in $(ls ${LIBNAME}.{so,rlib} 2>/dev/null); do
         echo Installing $lib
-        install -D -m 755 $lib ${D}/${rustlibdest}/$lib
+        install -D -m 755 $lib ${D}/${rustlibdir}/$lib
     done
 }
 
 oe_install_rust_bin () {
     echo Installing ${BINNAME}
-    install -D -m 755 ${BINNAME} ${D}/${rustbindest}/${BINNAME}
+    install -D -m 755 ${BINNAME} ${D}/${bindir}/${BINNAME}
 }
 
 do_rust_bin_fixups() {
@@ -144,6 +101,13 @@ do_rust_bin_fixups() {
         echo "Strip rust note: $f"
         ${OBJCOPY} -R .note.rustc $f $f
     done
+
+    for f in `find ${PKGD}`; do
+        file "$f" | grep -q ELF || continue
+        readelf -d "$f" | grep RUNPATH | grep -q rustlib || continue
+        echo "Set rpath:" "$f"
+        patchelf --set-rpath '$ORIGIN:'${rustlibdir}:${rustlib} "$f"
+    done
 }
 PACKAGE_PREPROCESS_FUNCS += "do_rust_bin_fixups"
 

classes/rust-common.bbclass

@@ -1,55 +1,15 @@
 # Common variables used by all Rust builds
 export rustlibdir = "${libdir}/rust"
-FILES:${PN} += "${rustlibdir}/*.so"
-FILES:${PN}-dev += "${rustlibdir}/*.rlib ${rustlibdir}/*.rmeta"
-FILES:${PN}-dbg += "${rustlibdir}/.debug"
+FILES_${PN} += "${rustlibdir}/*.so"
+FILES_${PN}-dev += "${rustlibdir}/*.rlib"
+FILES_${PN}-dbg += "${rustlibdir}/.debug"
 
 RUSTLIB = "-L ${STAGING_LIBDIR}/rust"
-RUST_DEBUG_REMAP = "--remap-path-prefix=${WORKDIR}=/usr/src/debug/${PN}/${EXTENDPE}${PV}-${PR}"
-RUSTFLAGS += "${RUSTLIB} ${RUST_DEBUG_REMAP}"
+RUSTFLAGS += "-C rpath ${RUSTLIB}"
 RUSTLIB_DEP ?= "libstd-rs"
-RUST_TARGET_PATH = "${STAGING_LIBDIR_NATIVE}/rustlib"
-RUST_PANIC_STRATEGY ?= "unwind"
-
-# Native builds are not effected by TCLIBC. Without this, rust-native
-# thinks it's "target" (i.e. x86_64-linux) is a musl target.
-RUST_LIBC = "${TCLIBC}"
-RUST_LIBC:class-native = "glibc"
-
-def determine_libc(d, thing):
-    '''Determine which libc something should target'''
-
-    # BUILD is never musl, TARGET may be musl or glibc,
-    # HOST could be musl, but only if a compiler is built to be run on
-    # target in which case HOST_SYS != BUILD_SYS.
-    if thing == 'TARGET':
-        libc = d.getVar('RUST_LIBC')
-    elif thing == 'BUILD' and (d.getVar('HOST_SYS') != d.getVar('BUILD_SYS')):
-        libc = d.getVar('RUST_LIBC')
-    else:
-        libc = d.getVar('RUST_LIBC:class-native')
-
-    return libc
-
-def target_is_armv7(d):
-    '''Determine if target is armv7'''
-    # TUNE_FEATURES may include arm* even if the target is not arm
-    # in the case of *-native packages
-    if d.getVar('TARGET_ARCH') != 'arm':
-        return False
-
-    feat = d.getVar('TUNE_FEATURES')
-    feat = frozenset(feat.split())
-    mach_overrides = d.getVar('MACHINEOVERRIDES')
-    mach_overrides = frozenset(mach_overrides.split(':'))
-
-    v7=frozenset(['armv7a', 'armv7r', 'armv7m', 'armv7ve'])
-    if mach_overrides.isdisjoint(v7) and feat.isdisjoint(v7):
-        return False
-    else:
-        return True
 
 # Responsible for taking Yocto triples and converting it to Rust triples
+
 def rust_base_triple(d, thing):
     '''
     Mangle bitbake's *_SYS into something that rust might support (see
@@ -58,16 +18,11 @@ def rust_base_triple(d, thing):
     Note that os is assumed to be some linux form
     '''
 
-    # The llvm-target for armv7 is armv7-unknown-linux-gnueabihf
-    if thing == "TARGET" and target_is_armv7(d):
-        arch = "armv7"
-    else:
-        arch = d.getVar('{}_ARCH'.format(thing))
-
+    arch = d.getVar('{}_ARCH'.format(thing), True)
     # All the Yocto targets are Linux and are 'unknown'
     vendor = "-unknown"
-    os = d.getVar('{}_OS'.format(thing))
-    libc = determine_libc(d, thing)
+    os = d.getVar('{}_OS'.format(thing), True)
+    libc = d.getVar('TCLIBC', True)
 
     # Prefix with a dash and convert glibc -> gnu
     if libc == "glibc":
@@ -103,7 +58,7 @@ def rust_base_triple(d, thing):
 #
 # Rust additionally will use two additional cases:
 # - undecorated (e.g. CC) - equivalent to TARGET
-# - triple suffix (e.g. CC:x86_64_unknown_linux_gnu) - both
+# - triple suffix (e.g. CC_x86_64_unknown_linux_gnu) - both
 #   see: https://github.com/alexcrichton/gcc-rs
 # The way that Rust's internal triples and Yocto triples are mapped together
 # its likely best to not use the triple suffix due to potential confusion.
@@ -119,11 +74,9 @@ RUST_TARGET_SYS = "${@rust_base_triple(d, 'TARGET')}"
 # use those commands based on the prefix.
 WRAPPER_DIR = "${WORKDIR}/wrapper"
 RUST_BUILD_CC = "${WRAPPER_DIR}/build-rust-cc"
-RUST_BUILD_CXX = "${WRAPPER_DIR}/build-rust-cxx"
 RUST_BUILD_CCLD = "${WRAPPER_DIR}/build-rust-ccld"
 RUST_BUILD_AR = "${WRAPPER_DIR}/build-rust-ar"
 RUST_TARGET_CC = "${WRAPPER_DIR}/target-rust-cc"
-RUST_TARGET_CXX = "${WRAPPER_DIR}/target-rust-cxx"
 RUST_TARGET_CCLD = "${WRAPPER_DIR}/target-rust-ccld"
 RUST_TARGET_AR = "${WRAPPER_DIR}/target-rust-ar"
 
@@ -133,41 +86,30 @@ create_wrapper () {
 
 	cat <<- EOF > "${file}"
 	#!/bin/sh
-	exec $@ "\$@"
+	$@ "\$@"
 	EOF
 	chmod +x "${file}"
 }
 
-export WRAPPER_TARGET_CC = "${CC}"
-export WRAPPER_TARGET_CXX = "${CXX}"
-export WRAPPER_TARGET_CCLD = "${CCLD}"
-export WRAPPER_TARGET_LDFLAGS = "${LDFLAGS}"
-export WRAPPER_TARGET_AR = "${AR}"
-
 # compiler is used by gcc-rs
 # linker is used by rustc/cargo
 # archiver is used by the build of libstd-rs
 do_rust_create_wrappers () {
 	mkdir -p "${WRAPPER_DIR}"
 
-	# Yocto Build / Rust Host C compiler
+	# Yocto Build / Rust Host compiler
 	create_wrapper "${RUST_BUILD_CC}" "${BUILD_CC}"
-	# Yocto Build / Rust Host C++ compiler
-	create_wrapper "${RUST_BUILD_CXX}" "${BUILD_CXX}"
 	# Yocto Build / Rust Host linker
 	create_wrapper "${RUST_BUILD_CCLD}" "${BUILD_CCLD}" "${BUILD_LDFLAGS}"
 	# Yocto Build / Rust Host archiver
 	create_wrapper "${RUST_BUILD_AR}" "${BUILD_AR}"
 
-	# Yocto Target / Rust Target C compiler
-	create_wrapper "${RUST_TARGET_CC}" "${WRAPPER_TARGET_CC}"
-	# Yocto Target / Rust Target C++ compiler
-	create_wrapper "${RUST_TARGET_CXX}" "${WRAPPER_TARGET_CXX}"
+	# Yocto Target / Rust Target compiler
+	create_wrapper "${RUST_TARGET_CC}" "${CC}"
 	# Yocto Target / Rust Target linker
-	create_wrapper "${RUST_TARGET_CCLD}" "${WRAPPER_TARGET_CCLD}" "${WRAPPER_TARGET_LDFLAGS}"
+	create_wrapper "${RUST_TARGET_CCLD}" "${CCLD}" "${LDFLAGS}"
 	# Yocto Target / Rust Target archiver
-	create_wrapper "${RUST_TARGET_AR}" "${WRAPPER_TARGET_AR}"
-
+	create_wrapper "${RUST_TARGET_AR}" "${AR}"
 }
 
 addtask rust_create_wrappers before do_configure after do_patch

classes/rust.bbclass

@@ -8,14 +8,14 @@ def rust_base_dep(d):
     # Taken from meta/classes/base.bbclass `base_dep_prepend` and modified to
     # use rust instead of gcc
     deps = ""
-    if not d.getVar('INHIBIT_DEFAULT_RUST_DEPS'):
-        if (d.getVar('HOST_SYS') != d.getVar('BUILD_SYS')):
+    if not d.getVar('INHIBIT_DEFAULT_RUST_DEPS', True):
+        if (d.getVar('HOST_SYS', True) != d.getVar('BUILD_SYS', True)):
             deps += " virtual/${TARGET_PREFIX}rust ${RUSTLIB_DEP}"
         else:
             deps += " rust-native"
     return deps
 
-DEPENDS:append = " ${@rust_base_dep(d)}"
+DEPENDS_append = " ${@rust_base_dep(d)}"
 
 # BUILD_LDFLAGS
 # 	${STAGING_LIBDIR_NATIVE}
@@ -42,4 +42,3 @@ rustlib_suffix="${TUNE_ARCH}${TARGET_VENDOR}-${TARGET_OS}/rustlib/${HOST_SYS}/li
 rustlib_src="${prefix}/lib/${rustlib_suffix}"
 # Host sysroot standard library path
 rustlib="${libdir}/${rustlib_suffix}"
-rustlib:class-native="${libdir}/rustlib/${BUILD_SYS}/lib"

conf/bblayers.conf.sample

@@ -8,11 +8,12 @@ BBFILES ?= ""
 BBLAYERS ?= " \
   ##OEROOT##/meta-rust \
   ##OEROOT##/meta \
-  ##OEROOT##/meta-poky \
+  ##OEROOT##/meta-yocto \
   ##OEROOT##/meta-yocto-bsp \
   ##OEROOT##/meta-openembedded/meta-oe \
   ##OEROOT##/meta-openembedded/meta-networking \
   ##OEROOT##/meta-openembedded/meta-python \
+  ##OEROOT##/meta-openembedded/meta-ruby \
   "
 BBLAYERS_NON_REMOVABLE ?= " \
   ##OEROOT##/meta \

conf/distro/include/rust_security_flags.inc

@@ -1,7 +1,7 @@
 # Build errors with PIE options enabled
-SECURITY_CFLAGS:pn-rust-native = "${SECURITY_NO_PIE_CFLAGS}"
-SECURITY_CFLAGS:pn-rust-cross-${TARGET_ARCH} = "${SECURITY_NO_PIE_CFLAGS}"
-SECURITY_CFLAGS:pn-rust = "${SECURITY_NO_PIE_CFLAGS}"
-SECURITY_CFLAGS:pn-rust-llvm = "${SECURITY_NO_PIE_CFLAGS}"
+SECURITY_CFLAGS_pn-rust-native = "${SECURITY_NO_PIE_CFLAGS}"
+SECURITY_CFLAGS_pn-rust-cross-${TARGET_ARCH} = "${SECURITY_NO_PIE_CFLAGS}"
+SECURITY_CFLAGS_pn-rust = "${SECURITY_NO_PIE_CFLAGS}"
+SECURITY_CFLAGS_pn-rust-llvm = "${SECURITY_NO_PIE_CFLAGS}"
 
-SECURITY_LDFLAGS:pn-rust-cross-arm = " -lssp_nonshared -lssp"
+SECURITY_LDFLAGS_pn-rust-cross-arm = " -lssp_nonshared -lssp"

conf/distro/include/rust_versions.inc

@@ -1,13 +0,0 @@
-# include this in your distribution to easily switch between versions
-# just by changing RUST_VERSION variable
-
-RUST_VERSION ?= "1.51.0"
-
-PREFERRED_VERSION_cargo ?= "${RUST_VERSION}"
-PREFERRED_VERSION_cargo-native ?= "${RUST_VERSION}"
-PREFERRED_VERSION_libstd-rs ?= "${RUST_VERSION}"
-PREFERRED_VERSION_rust ?= "${RUST_VERSION}"
-PREFERRED_VERSION_rust-cross-${TARGET_ARCH} ?= "${RUST_VERSION}"
-PREFERRED_VERSION_rust-llvm ?= "${RUST_VERSION}"
-PREFERRED_VERSION_rust-llvm-native ?= "${RUST_VERSION}"
-PREFERRED_VERSION_rust-native ?= "${RUST_VERSION}"

conf/layer.conf

@@ -8,8 +8,5 @@ BBFILE_COLLECTIONS += "rust-layer"
 BBFILE_PATTERN_rust-layer := "^${LAYERDIR}/"
 BBFILE_PRIORITY_rust-layer = "7"
 
-LAYERDEPENDS_rust-layer = "core openembedded-layer"
-LAYERSERIES_COMPAT_rust-layer = "dunfell gatesgarth hardknott honister kirkstone"
-
 # Override security flags
 require conf/distro/include/rust_security_flags.inc

conf/local.conf.sample

@@ -220,7 +220,7 @@ BB_DISKMON_DIRS = "\
 #file://.* http://someserver.tld/share/sstate/PATH;downloadfilename=PATH \n \
 #file://.* file:///some/local/dir/sstate/PATH"
 
-SSTATE_MIRRORS ?= "file://.* http://build-cache.asterius.io/master/sstate-cache/PATH;downloadfilename=PATH \n"
+SSTATE_MIRRORS ?= "file://.* http://build-cache.asterius.io/morty/sstate-cache/PATH;downloadfilename=PATH \n"
 
 SOURCE_MIRROR_URL ?= "http://build-cache.asterius.io/downloads/"
 INHERIT += "own-mirrors rm_work"
@@ -232,8 +232,8 @@ INHERIT += "own-mirrors rm_work"
 # seen. The two lines below enable the SDL backend too. By default libsdl-native will
 # be built, if you want to use your host's libSDL instead of the minimal libsdl built
 # by libsdl-native then uncomment the ASSUME_PROVIDED line below.
-PACKAGECONFIG:append:pn-qemu-native = " sdl"
-PACKAGECONFIG:append:pn-nativesdk-qemu = " sdl"
+PACKAGECONFIG_append_pn-qemu-native = " sdl"
+PACKAGECONFIG_append_pn-nativesdk-qemu = " sdl"
 #ASSUME_PROVIDED += "libsdl-native"
 
 # CONF_VERSION is increased each time build/conf/ changes incompatibly and is used to

lib/crate.py

@@ -107,7 +107,7 @@ class Crate(Wget):
         save_cwd = os.getcwd()
         os.chdir(rootdir)
 
-        pn = d.getVar('BPN')
+        pn = d.getVar('BPN', True)
         if pn == ud.parm.get('name'):
             cmd = "tar -xz --no-same-owner -f %s" % thefile
         else:
@@ -127,7 +127,7 @@ class Crate(Wget):
             metadata['package'] = tarhash
 
         # path it
-        path = d.getVar('PATH')
+        path = d.getVar('PATH', True)
         if path:
             cmd = "PATH=\"%s\" %s" % (path, cmd)
         bb.note("Unpacking %s to %s/" % (thefile, os.getcwd()))

recipes-core/aho-corasick/aho-corasick-rs_0.2.1.bb

@@ -0,0 +1,20 @@
+DESCRIPTION = "Fast multiple substring searching with finite state machines."
+HOMEPAGE = "https://github.com/BurntSushi/aho-corasick"
+LICENSE = "MIT"
+LIC_FILES_CHKSUM = "file://LICENSE-MIT;md5=8d0d0aa488af0ab9aafa3b85a7fc8e12"
+DEPENDS = "memchr-rs"
+
+inherit rust-bin
+
+SRC_URI = "git://github.com/BurntSushi/aho-corasick.git;protocol=https"
+SRCREV = "e1bca33dcc060d587e802320a79cbb035f37f8fa"
+
+S = "${WORKDIR}/git"
+
+do_compile () {
+	oe_compile_rust_lib
+}
+
+do_install () {
+	oe_install_rust_lib
+}

recipes-core/bitflags/bitflags_0.5.0.bb

@@ -0,0 +1,24 @@
+DESCRIPTION = "A macro to generate structures which behave like bitflags."
+HOMEPAGE = "https://github.com/rust-lang-nursery/bitflags"
+LICENSE = "MIT | Apache-2.0"
+LIC_FILES_CHKSUM = "\
+	file://LICENSE-MIT;md5=362255802eb5aa87810d12ddf3cfedb4 \
+	file://LICENSE-APACHE;md5=1836efb2eb779966696f473ee8540542 \
+"
+
+inherit rust-bin
+
+SRC_URI = "git://github.com/rust-lang-nursery/bitflags.git;protocol=https"
+SRCREV = "41aa413a7c30d70b93b44ab5447276c381ef249e"
+
+S = "${WORKDIR}/git"
+
+LIB_SRC = "${S}/src/lib.rs"
+
+do_compile () {
+	oe_compile_rust_lib
+}
+
+do_install () {
+	oe_install_rust_lib
+}

recipes-core/crypto/crypto-rs_0.2.31.bb

@@ -0,0 +1,28 @@
+DESCRIPTION = "A (mostly) pure-Rust implementation of various common cryptographic algorithms."
+HOMEPAGE = "https://github.com/DaGenix/rust-crypto/"
+LICENSE = "MIT | Apache-2.0"
+LIC_FILES_CHKSUM = "\
+	file://LICENSE-MIT;md5=4311034aa04489226c1fc3f816dbfb5a \
+	file://LICENSE-APACHE;md5=a02fef6dccf840318474c108a8281b77 \
+"
+DEPENDS = "\
+	libc-rs \
+	time-rs \
+	rand-rs \
+	rustc-serialize-rs \
+"
+
+inherit rust-bin
+
+SRC_URI = "git://github.com/DaGenix/rust-crypto.git;protocol=https"
+SRCREV = "5571cb41690b9cee12025192393ea7df0eddc21b"
+
+S = "${WORKDIR}/git"
+
+do_compile () {
+	oe_compile_rust_lib
+}
+
+do_install () {
+	oe_install_rust_lib
+}

recipes-core/dbus/dbus-rs_0.1.0.bb

@@ -0,0 +1,20 @@
+DESCRIPTION = "DBus binding for rust"
+HOMEPAGE = "https://github.com/diwic/dbus-rs"
+LICENSE = "Apache-2.0"
+LIC_FILES_CHKSUM = "file://LICENSE;md5=d2794c0df5b907fdace235a619d80314"
+DEPENDS = "libc-rs dbus"
+
+inherit rust-bin
+
+SRC_URI = "git://github.com/diwic/dbus-rs.git;protocol=https"
+SRCREV = "d23c8b7fecd5a8e82131893250a5ac376799faff"
+
+S = "${WORKDIR}/git"
+
+do_compile () {
+	oe_compile_rust_lib
+}
+
+do_install () {
+	oe_install_rust_lib
+}

recipes-core/debug-builders/debug-builders-rs_0.1.0.bb

@@ -0,0 +1,19 @@
+DESCRIPTION = "A copy of libstd's debug builders for use before they stabilize"
+HOMEPAGE = "https://github.com/sfackler/rust-debug-builders"
+LICENSE = "MIT | Apache-2.0"
+LIC_FILES_CHKSUM = "file://Cargo.toml;md5=97a131dc4ae910d242387f2c9d1a2ce8"
+
+inherit rust-bin
+
+SRC_URI = "git://github.com/sfackler/rust-debug-builders.git;protocol=https"
+SRCREV = "c6943b72c7808ddaa151d08b824525cc7420cb9b"
+
+S = "${WORKDIR}/git"
+
+do_compile () {
+	oe_compile_rust_lib
+}
+
+do_install () {
+	oe_install_rust_lib
+}

recipes-core/getopts/getopts-rs_0.2.11.bb

@@ -0,0 +1,23 @@
+DESCRIPTION = "getopts-like option parsing"
+HOMEPAGE = "https://github.com/rust-lang/getopts"
+LICENSE = "MIT | Apache-2.0"
+LIC_FILES_CHKSUM = "\
+	file://LICENSE-MIT;md5=362255802eb5aa87810d12ddf3cfedb4 \
+	file://LICENSE-APACHE;md5=1836efb2eb779966696f473ee8540542 \
+"
+DEPENDS = "log-rs"
+
+inherit rust-bin
+
+SRC_URI = "git://github.com/rust-lang/getopts.git;protocol=https"
+SRCREV = "a13c62b7d860b6d370129ebb972bf5e0373c5be7"
+
+S = "${WORKDIR}/git"
+
+do_compile () {
+	oe_compile_rust_lib
+}
+
+do_install () {
+	oe_install_rust_lib
+}

recipes-core/lazy-static/lazy-static_0.2.1.bb

@@ -0,0 +1,23 @@
+DESCRIPTION = "A macro for declaring lazily evaluated statics in Rust."
+HOMEPAGE = "https://github.com/rust-lang-nursery/lazy-static.rs"
+LICENSE = "MIT"
+LIC_FILES_CHKSUM = "\
+	file://LICENSE;md5=5795ddb4df1d696d439b6667081cffc9 \
+"
+
+inherit rust-bin
+
+SRC_URI = "git://github.com/rust-lang-nursery/lazy-static.rs.git;protocol=https"
+SRCREV = "ffe65c818474f863945ca535c0e53f3b8b848ff7"
+
+S = "${WORKDIR}/git"
+
+LIB_SRC = "${S}/src/lib.rs"
+
+do_compile () {
+	oe_compile_rust_lib
+}
+
+do_install () {
+	oe_install_rust_lib
+}

recipes-core/libc/libc-rs_0.2.5.bb

@@ -0,0 +1,24 @@
+DESCRIPTION = "A Rust library with native bindings to the types and functions commonly found on various systems, including libc."
+HOMEPAGE = "https://github.com/rust-lang/libc"
+LICENSE = "MIT | Apache-2.0"
+LIC_FILES_CHKSUM = "\
+	file://LICENSE-MIT;md5=362255802eb5aa87810d12ddf3cfedb4 \
+	file://LICENSE-APACHE;md5=1836efb2eb779966696f473ee8540542 \
+"
+
+inherit rust-bin
+
+SRC_URI = "git://github.com/rust-lang/libc.git;protocol=https"
+SRCREV = "f54b9c90ee68889181472d4d4a5dd9e43d0e5318"
+
+S = "${WORKDIR}/git"
+
+LIB_SRC = "${S}/src/lib.rs"
+
+do_compile () {
+	oe_compile_rust_lib --cfg feature='"cargo-build"'
+}
+
+do_install () {
+	oe_install_rust_lib
+}

recipes-core/log/env-logger-rs_0.3.1.bb

@@ -0,0 +1,6 @@
+DESCRIPTION = "An logging implementation for `log` which is configured via an environment variable"
+DEPENDS = "regex-rs log-rs"
+
+require log.inc
+
+LIB_SRC = "${S}/env/src/lib.rs"

recipes-core/log/log-rs.bb

@@ -0,0 +1,4 @@
+DESCRIPTION = "A Rust library providing a lightweight logging facade"
+DEPENDS = "libc-rs"
+
+require log.inc

recipes-core/log/log.inc

@@ -0,0 +1,22 @@
+HOMEPAGE = "https://github.com/rust-lang/log"
+LICENSE = "MIT | Apache-2.0"
+LIC_FILES_CHKSUM = "\
+	file://LICENSE-MIT;md5=362255802eb5aa87810d12ddf3cfedb4 \
+	file://LICENSE-APACHE;md5=1836efb2eb779966696f473ee8540542 \
+"
+
+inherit rust-bin
+
+SRC_URI = "git://github.com/rust-lang/log.git;protocol=https"
+SRCREV = "5453e16166ec451afc9738978ca01f162127ebbe"
+PV = "0.3.1"
+
+S = "${WORKDIR}/git"
+
+do_compile () {
+	oe_compile_rust_lib
+}
+
+do_install () {
+	oe_install_rust_lib
+}

recipes-core/memchr/memchr-rs_0.1.11.bb

@@ -0,0 +1,20 @@
+DESCRIPTION = "Safe interface to memchr"
+HOMEPAGE = "https://github.com/BurntSushi/rust-memchr"
+LICENSE = "MIT"
+LIC_FILES_CHKSUM = "file://LICENSE-MIT;md5=8d0d0aa488af0ab9aafa3b85a7fc8e12"
+DEPENDS = "libc-rs"
+
+inherit rust-bin
+
+SRC_URI = "git://github.com/BurntSushi/rust-memchr.git;protocol=https"
+SRCREV = "4f9a13f95e6e00f2847c093c56b41b9c1d58d3c4"
+
+S = "${WORKDIR}/git"
+
+do_compile () {
+	oe_compile_rust_lib
+}
+
+do_install () {
+	oe_install_rust_lib
+}

recipes-core/num/num-integer_0.1.34.bb

@@ -0,0 +1,5 @@
+require num.inc
+
+DEPENDS += "num-traits"
+
+LIB_SRC = "${S}/integer/src/lib.rs"

recipes-core/num/num-iter_0.1.34.bb

@@ -0,0 +1,6 @@
+require num.inc
+
+DEPENDS += "num-traits"
+DEPENDS += "num-integer"
+
+LIB_SRC = "${S}/iter/src/lib.rs"

recipes-core/num/num-traits_0.1.34.bb

@@ -0,0 +1,3 @@
+require num.inc
+
+LIB_SRC = "${S}/traits/src/lib.rs"

recipes-core/num/num.inc

@@ -0,0 +1,22 @@
+DESCRIPTION = "A collection of numeric types and traits for Rust, including bigint, complex, rational, range iterators, generic integers, and more!"
+HOMEPAGE = "https://github.com/rust-num/num"
+LICENSE = "MIT | Apache-2.0"
+LIC_FILES_CHKSUM = "\
+	file://LICENSE-MIT;md5=362255802eb5aa87810d12ddf3cfedb4 \
+	file://LICENSE-APACHE;md5=1836efb2eb779966696f473ee8540542 \
+"
+
+inherit rust-bin
+
+SRC_URI = "git://github.com/rust-num/num.git;protocol=https"
+SRCREV = "d9f08cb148cc686ec407c1e42fbd4536cde6ac82"
+
+S = "${WORKDIR}/git"
+
+do_compile () {
+	oe_compile_rust_lib
+}
+
+do_install () {
+	oe_install_rust_lib
+}

recipes-core/num/num_0.1.34.bb

@@ -0,0 +1,9 @@
+require num.inc
+
+DEPENDS += "\
+	num-traits \
+	num-integer \
+	num-iter \
+	"
+
+LIB_SRC = "${S}/src/lib.rs"

recipes-core/packagegroups/packagegroup-rust-cross-canadian.bb

@@ -1,18 +0,0 @@
-SUMMARY = "Host SDK package for Rust cross canadian toolchain"
-PN = "packagegroup-rust-cross-canadian-${MACHINE}"
-
-inherit cross-canadian packagegroup
-
-PACKAGEGROUP_DISABLE_COMPLEMENTARY = "1"
-
-RUST="rust-cross-canadian-${TRANSLATED_TARGET_ARCH}"
-CARGO="cargo-cross-canadian-${TRANSLATED_TARGET_ARCH}"
-RUST_TOOLS="rust-tools-cross-canadian-${TRANSLATED_TARGET_ARCH}"
-
-RDEPENDS:${PN} = " \
-    ${@all_multilib_tune_values(d, 'RUST')} \
-    ${@all_multilib_tune_values(d, 'CARGO')} \
-    rust-cross-canadian-src \
-    ${@all_multilib_tune_values(d, 'RUST_TOOLS')} \
-"
-

recipes-core/rand/rand-rs_0.3.14.bb

@@ -0,0 +1,23 @@
+DESCRIPTION = "Random number generators and other randomness functionality."
+HOMEPAGE = "https://github.com/rust-lang/rand"
+LICENSE = "MIT | Apache-2.0"
+LIC_FILES_CHKSUM = "\
+	file://LICENSE-MIT;md5=362255802eb5aa87810d12ddf3cfedb4 \
+	file://LICENSE-APACHE;md5=1836efb2eb779966696f473ee8540542 \
+"
+DEPENDS = "libc-rs"
+
+inherit rust-bin
+
+SRC_URI = "git://github.com/rust-lang/rand.git;protocol=https"
+SRCREV = "f872fda5fb8fb899a837ee9eee0332076a8f5300"
+
+S = "${WORKDIR}/git"
+
+do_compile () {
+	oe_compile_rust_lib
+}
+
+do_install () {
+	oe_install_rust_lib
+}

recipes-core/regex/regex-rs.bb

@@ -0,0 +1,10 @@
+DESCRIPTION = "An implementation of regular expressions for Rust"
+DEPENDS = "\
+	aho-corasick-rs \
+	memchr-rs \
+	regex-syntax-rs \
+"
+
+require regex.inc
+
+S = "${WORKDIR}/git"

recipes-core/regex/regex-syntax-rs.bb

@@ -0,0 +1,5 @@
+DESCRIPTION = "A regular expression parser"
+
+require regex.inc
+
+LIB_SRC = "${S}/regex-syntax/src/lib.rs"

recipes-core/regex/regex.inc

@@ -0,0 +1,22 @@
+HOMEPAGE = "https://github.com/rust-lang/regex"
+LICENSE = "MIT | Apache-2.0"
+LIC_FILES_CHKSUM = "\
+	file://LICENSE-MIT;md5=362255802eb5aa87810d12ddf3cfedb4 \
+	file://LICENSE-APACHE;md5=1836efb2eb779966696f473ee8540542 \
+"
+
+SRC_URI = "git://github.com/rust-lang/regex.git;protocol=https"
+SRCREV = "c9e6781a6845478aa2d8ebc86972755f854fdbe0"
+PV = "0.1.38"
+
+inherit rust-bin
+
+S = "${WORKDIR}/git"
+
+do_compile () {
+	oe_compile_rust_lib
+}
+
+do_install () {
+	oe_install_rust_lib
+}

recipes-core/rustc-serialize/rustc-serialize-rs_0.3.19.bb

@@ -0,0 +1,22 @@
+DESCRIPTION = "Generic serialization/deserialization support"
+HOMEPAGE = "https://github.com/rust-lang/rustc-serialize"
+LICENSE = "MIT | Apache-2.0"
+LIC_FILES_CHKSUM = "\
+	file://LICENSE-MIT;md5=362255802eb5aa87810d12ddf3cfedb4 \
+	file://LICENSE-APACHE;md5=1836efb2eb779966696f473ee8540542 \
+"
+
+inherit rust-bin
+
+SRC_URI = "git://github.com/rust-lang/rustc-serialize.git;protocol=https"
+SRCREV = "64b38a1f31a9af6eabf2894437aa5ccc3e457e68"
+
+S = "${WORKDIR}/git"
+
+do_compile () {
+	oe_compile_rust_lib
+}
+
+do_install () {
+	oe_install_rust_lib
+}

recipes-core/time/time-rs_0.1.26.bb

@@ -0,0 +1,26 @@
+DESCRIPTION = "Utilities for working with time-related functions in Rust"
+HOMEPAGE = "https://github.com/rust-lang/time"
+LICENSE = "MIT | Apache-2.0"
+LIC_FILES_CHKSUM = "\
+	file://LICENSE-MIT;md5=362255802eb5aa87810d12ddf3cfedb4 \
+	file://LICENSE-APACHE;md5=1836efb2eb779966696f473ee8540542 \
+"
+DEPENDS = "libc-rs"
+
+inherit rust-bin
+
+SRC_URI = "git://github.com/rust-lang/time.git;protocol=https"
+SRCREV = "32b212b877b836dbfdc97af5674d91672e70ecbd"
+
+S = "${WORKDIR}/git"
+
+do_compile () {
+	rm -rf time_helpers.o libtimehelpers.a
+	${CC} ${S}/src/time_helpers.c -fPIC -c -o time_helpers.o
+	${AR} rcs libtime_helpers.a time_helpers.o
+	oe_compile_rust_lib -L native=$PWD -l static=time_helpers
+}
+
+do_install () {
+	oe_install_rust_lib
+}

recipes-core/udev/libudev-rs_0.1.0.bb

@@ -0,0 +1,20 @@
+DESCRIPTION = "FFI bindings to libudev"
+HOMEPAGE = "https://github.com/dcuddeback/libudev-sys"
+LICENSE = "MIT"
+LIC_FILES_CHKSUM = "file://LICENSE;md5=bbd2acd29c4ba5d4591b03e2757c04a3"
+DEPENDS = "libudev-sys-rs"
+
+inherit rust-bin
+
+SRC_URI = "git://github.com/dcuddeback/libudev-rs.git;protocol=https"
+SRCREV = "d55763c626790e2e8724947503238731843a969a"
+
+S = "${WORKDIR}/git"
+
+do_compile () {
+	oe_compile_rust_lib
+}
+
+do_install () {
+	oe_install_rust_lib
+}

recipes-core/udev/libudev-rs_0.1.2.bb

@@ -0,0 +1,22 @@
+DESCRIPTION = "FFI bindings to libudev"
+HOMEPAGE = "https://github.com/dcuddeback/libudev-sys"
+LICENSE = "MIT"
+LIC_FILES_CHKSUM = "file://LICENSE;md5=bbd2acd29c4ba5d4591b03e2757c04a3"
+
+DEPENDS += "libudev-sys-rs"
+DEPENDS += "libc-rs"
+
+inherit rust-bin
+
+SRC_URI = "git://github.com/dcuddeback/libudev-rs.git;protocol=https"
+SRCREV = "3da791245f206d0cf5a856531c574b8646b0f059"
+
+S = "${WORKDIR}/git"
+
+do_compile () {
+	oe_compile_rust_lib
+}
+
+do_install () {
+	oe_install_rust_lib
+}

recipes-core/udev/libudev-sys-rs_0.1.1.bb

@@ -0,0 +1,22 @@
+DESCRIPTION = "FFI bindings to libudev"
+HOMEPAGE = "https://github.com/dcuddeback/libudev-sys"
+LICENSE = "MIT"
+LIC_FILES_CHKSUM = "file://LICENSE;md5=bbd2acd29c4ba5d4591b03e2757c04a3"
+DEPENDS = "libc-rs udev"
+
+inherit rust-bin
+
+SRC_URI = "git://github.com/dcuddeback/libudev-sys.git;protocol=https"
+SRCREV = "14c24afc61e3315dffddab2c7f36999a16a002d8"
+
+S = "${WORKDIR}/git"
+
+RUSTC_FLAGS += "-ludev"
+
+do_compile () {
+	oe_compile_rust_lib
+}
+
+do_install () {
+	oe_install_rust_lib
+}

recipes-core/udev/libudev-sys-rs_0.1.3.bb

@@ -0,0 +1,22 @@
+DESCRIPTION = "FFI bindings to libudev"
+HOMEPAGE = "https://github.com/dcuddeback/libudev-sys"
+LICENSE = "MIT"
+LIC_FILES_CHKSUM = "file://LICENSE;md5=bbd2acd29c4ba5d4591b03e2757c04a3"
+DEPENDS = "libc-rs udev"
+
+inherit rust-bin
+
+SRC_URI = "git://github.com/dcuddeback/libudev-sys.git;protocol=https"
+SRCREV = "c49163f87d4d109ec21bcf8f8c51db560ed31b22"
+
+S = "${WORKDIR}/git"
+
+RUSTC_FLAGS += "-ludev"
+
+do_compile () {
+	oe_compile_rust_lib
+}
+
+do_install () {
+	oe_install_rust_lib
+}

recipes-core/unix-socket/unix-socket-rs_0.4.3.bb

@@ -0,0 +1,20 @@
+DESCRIPTION = "Unix domain socket bindings for Rust"
+HOMEPAGE = "https://github.com/sfackler/rust-unix-socket"
+LICENSE = "MIT"
+LIC_FILES_CHKSUM = "file://LICENSE;md5=bde86283c1fd74e84ebc3cf6dd7011d0"
+DEPENDS = "libc-rs debug-builders-rs"
+
+inherit rust-bin
+
+SRC_URI = "git://github.com/sfackler/rust-unix-socket.git;protocol=https"
+SRCREV = "d0f47ae888267a718072c3be5eed42ba1f637097"
+
+S = "${WORKDIR}/git"
+
+do_compile () {
+	oe_compile_rust_lib
+}
+
+do_install () {
+	oe_install_rust_lib
+}

recipes-devtools/cargo/cargo-cross-canadian.inc

@@ -1,74 +0,0 @@
-SUMMARY = "Cargo, a package manager for Rust cross canadian flavor."
-
-RUST_ALTERNATE_EXE_PATH = "${STAGING_LIBDIR_NATIVE}/llvm-rust/bin/llvm-config"
-
-HOST_SYS = "${HOST_ARCH}-unknown-linux-gnu"
-CARGO_RUST_TARGET_CCLD = "${RUST_BUILD_CCLD}"
-
-require recipes-devtools/rust/rust-common.inc
-require cargo.inc
-
-CARGO = "${WORKDIR}/${CARGO_SNAPSHOT}/bin/cargo"
-BASEDEPENDS:remove = "cargo-native"
-
-export RUST_TARGET_PATH="${WORKDIR}/targets/"
-
-RUSTLIB = " \
-	-L ${STAGING_DIR_NATIVE}/${SDKPATHNATIVE}/usr/lib/${TARGET_SYS}/rustlib/${HOST_SYS}/lib \
-"
-
-DEPENDS += "rust-native \
-            rust-cross-canadian-${TRANSLATED_TARGET_ARCH} \
-            virtual/nativesdk-${HOST_PREFIX}compilerlibs \
-            nativesdk-openssl nativesdk-zlib \
-            virtual/nativesdk-libc \
-"
-
-inherit cross-canadian
-
-PN = "cargo-cross-canadian-${TRANSLATED_TARGET_ARCH}"
-
-LLVM_TARGET[x86_64] = "${RUST_HOST_SYS}"
-
-python do_rust_gen_targets () {
-    wd = d.getVar('WORKDIR') + '/targets/'
-
-    rust_gen_target(d, 'BUILD', wd, "", "generic", d.getVar('BUILD_ARCH'))
-    rust_gen_target(d, 'HOST', wd, "", "generic", d.getVar('HOST_ARCH'))
-}
-
-do_compile:prepend () {
-	PKG_CONFIG_PATH="${RECIPE_SYSROOT_NATIVE}/usr/lib/pkgconfig:${PKG_CONFIG_PATH}"
-}
-
-do_install () {
-    SYS_BINDIR=$(dirname ${D}${bindir})
-    install -d "${SYS_BINDIR}"
-    install -m 755 "${B}/target/${CARGO_TARGET_SUBDIR}/cargo" "${SYS_BINDIR}"
-    for i in ${SYS_BINDIR}/*; do
-	chrpath -r "\$ORIGIN/../lib" ${i}
-    done
-
-    ENV_SETUP_DIR=${D}${base_prefix}/environment-setup.d
-    mkdir "${ENV_SETUP_DIR}"
-    ENV_SETUP_SH="${ENV_SETUP_DIR}/cargo.sh"
-    cat <<- EOF > "${ENV_SETUP_SH}"
-	export CARGO_HOME="\$OECORE_TARGET_SYSROOT/home/cargo"
-	mkdir -p "\$CARGO_HOME"
-        # Init the default target once, it might be otherwise user modified.
-	if [ ! -f "\$CARGO_HOME/config" ]; then
-		touch "\$CARGO_HOME/config"
-		echo "[build]" >> "\$CARGO_HOME/config"
-		echo 'target = "'${TARGET_SYS}'"' >> "\$CARGO_HOME/config"
-        fi
-
-	# Keep the below off as long as HTTP/2 is disabled.
-	export CARGO_HTTP_MULTIPLEXING=false
-
-	export CARGO_HTTP_CAINFO="\$OECORE_NATIVE_SYSROOT/etc/ssl/certs/ca-certificates.crt"
-	EOF
-}
-
-PKG_SYS_BINDIR = "${SDKPATHNATIVE}/usr/bin"
-FILES:${PN} += "${base_prefix}/environment-setup.d ${PKG_SYS_BINDIR}"
-

recipes-devtools/cargo/cargo-cross-canadian_1.61.0.bb

@@ -1,6 +0,0 @@
-require recipes-devtools/rust/rust-source-${PV}.inc
-require recipes-devtools/rust/rust-snapshot-${PV}.inc
-
-FILESEXTRAPATHS:prepend := "${THISDIR}/cargo-${PV}:"
-
-require cargo-cross-canadian.inc

recipes-devtools/cargo/cargo-cross-canadian_1.64.0.bb

@@ -1,6 +0,0 @@
-require recipes-devtools/rust/rust-source-${PV}.inc
-require recipes-devtools/rust/rust-snapshot-${PV}.inc
-
-FILESEXTRAPATHS:prepend := "${THISDIR}/cargo-${PV}:"
-
-require cargo-cross-canadian.inc

recipes-devtools/cargo/cargo-snapshot.inc

@@ -0,0 +1,4 @@
+
+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,56 +1,56 @@
-SUMMARY ?= "Cargo, a package manager for Rust."
-HOMEPAGE = "https://crates.io"
-LICENSE = "MIT | Apache-2.0"
+inherit cargo
+inherit patch
+
+SUMMARY = "Cargo downloads your Rust project's dependencies and builds your project"
+HOMEPAGE = "http://crates.io"
 SECTION = "devel"
+LICENSE = "MIT | Apache-2.0"
 
-DEPENDS = "openssl zlib curl ca-certificates libssh2"
+DEPENDS = "openssl zlib libgit2 curl ca-certificates libssh2"
 
-LIC_FILES_CHKSUM = " \
-    file://LICENSE-MIT;md5=b377b220f43d747efdec40d69fcaa69d \
-    file://LICENSE-APACHE;md5=71b224ca933f0676e26d5c2e2271331c \
-    file://LICENSE-THIRD-PARTY;md5=f257ad009884cb88a3a87d6920e7180a \
+SRC_URI = "\
+	http://static-rust-lang-org.s3.amazonaws.com/cargo-dist/${CARGO_SNAPSHOT} \
 "
 
+B = "${S}"
 
-S = "${RUSTSRC}/src/tools/cargo"
-CARGO_VENDORING_DIRECTORY = "${RUSTSRC}/vendor"
-EXCLUDE_FROM_WORLD = "1"
+# Used in libgit2-sys's build.rs, needed for pkg-config to be used
+export LIBGIT2_SYS_USE_PKG_CONFIG = "1"
 
-inherit cargo pkgconfig
+# cargo's configure doesn't recognize --disable-static, so remove it.
+DISABLE_STATIC = ""
 
-do_cargo_setup_snapshot () {
-	${WORKDIR}/rust-snapshot-components/${CARGO_SNAPSHOT}/install.sh --prefix="${WORKDIR}/${CARGO_SNAPSHOT}" --disable-ldconfig
-	# Need to use uninative's loader if enabled/present since the library paths
-	# are used internally by rust and result in symbol mismatches if we don't
-	if [ ! -z "${UNINATIVE_LOADER}" -a -e "${UNINATIVE_LOADER}" ]; then
-		patchelf-uninative ${WORKDIR}/${CARGO_SNAPSHOT}/bin/cargo --set-interpreter ${UNINATIVE_LOADER}
-	fi
+do_configure () {
+	"${S}/configure" \
+		"--prefix=${prefix}"			\
+		"--build=${BUILD_SYS}"			\
+		"--host=${HOST_SYS}"			\
+		"--target=${TARGET_SYS}"		\
+		"--localstatedir=${localstatedir}"	\
+		"--sysconfdir=${sysconfdir}"		\
+		"--datadir=${datadir}"			\
+		"--infodir=${infodir}"			\
+		"--mandir=${mandir}"			\
+		"--libdir=${libdir}"			\
+		"--disable-verify-install"		\
+		${EXTRA_OECONF} \
+		|| die "Could not configure cargo"
+
+	cargo_do_configure
 }
 
-addtask cargo_setup_snapshot after do_unpack before do_configure
-do_cargo_setup_snapshot[dirs] += "${WORKDIR}/${CARGO_SNAPSHOT}"
-do_cargo_setup_snapshot[vardepsexclude] += "UNINATIVE_LOADER"
+do_compile () {
+	oe_cargo_fix_env
 
+	rm -rf target/snapshot
+	mkdir -p target
+	cp -R ${WORKDIR}/cargo-nightly-x86_64-unknown-linux-gnu/cargo target/snapshot
 
-do_compile:prepend () {
-	export RUSTC_BOOTSTRAP="1"
+	oe_runmake VERBOSE=1
 }
 
 do_install () {
-	install -d "${D}${bindir}"
-	install -m 755 "${B}/target/${CARGO_TARGET_SUBDIR}/cargo" "${D}${bindir}"
+	oe_runmake prepare-image-${TARGET_SYS} IMGDIR_${TARGET_SYS}="${D}${prefix}"
 }
 
-# Disabled due to incompatibility with libgit2 0.28.x (https://github.com/rust-lang/git2-rs/issues/458, https://bugs.gentoo.org/707746#c1)
-# as shipped by Yocto Dunfell.
-# According to https://github.com/rust-lang/git2-rs/issues/458#issuecomment-522567539, there are no compatibility guarantees between
-# libgit2-sys and arbitrary system libgit2 versions, so better keep this turned off.
-#export LIBGIT2_SYS_USE_PKG_CONFIG = "1"
-
-# Needed for pkg-config to be used
-export LIBSSH2_SYS_USE_PKG_CONFIG = "1"
-
-# When building cargo-native we don't have cargo-native to use and depend on,
-# so we must use the locally set up snapshot to bootstrap the build.
-BASEDEPENDS:remove:class-native = "cargo-native"
-CARGO:class-native = "${WORKDIR}/${CARGO_SNAPSHOT}/bin/cargo"
+BBCLASSEXTEND = "native"

recipes-devtools/cargo/cargo_0.13.0.bb

@@ -0,0 +1,86 @@
+require cargo-snapshot.inc
+require cargo.inc
+
+SRC_URI += " \
+	git://github.com/rust-lang/cargo.git;protocol=https;name=cargo \
+	crate://crates.io/advapi32-sys/0.2.0 \
+	crate://crates.io/aho-corasick/0.5.2 \
+	crate://crates.io/bitflags/0.1.1 \
+	crate://crates.io/bitflags/0.7.0 \
+	crate://crates.io/bufstream/0.1.2 \
+	crate://crates.io/cfg-if/0.1.0 \
+	crate://crates.io/cmake/0.1.17 \
+	crate://crates.io/crossbeam/0.2.9 \
+	crate://crates.io/curl-sys/0.2.1 \
+	crate://crates.io/curl/0.3.2 \
+	crate://crates.io/docopt/0.6.82 \
+	crate://crates.io/env_logger/0.3.4 \
+	crate://crates.io/filetime/0.1.10 \
+	crate://crates.io/flate2/0.2.14 \
+	crate://crates.io/fs2/0.2.5 \
+	crate://crates.io/gcc/0.3.32 \
+	crate://crates.io/gdi32-sys/0.2.0 \
+	crate://crates.io/git2-curl/0.5.0 \
+	crate://crates.io/git2/0.4.4 \
+	crate://crates.io/glob/0.2.11 \
+	crate://crates.io/hamcrest/0.1.0 \
+	crate://crates.io/idna/0.1.0 \
+	crate://crates.io/kernel32-sys/0.2.2 \
+	crate://crates.io/lazy_static/0.2.1 \
+	crate://crates.io/libc/0.2.15 \
+	crate://crates.io/libgit2-sys/0.4.5 \
+	crate://crates.io/libressl-pnacl-sys/2.1.6 \
+	crate://crates.io/libssh2-sys/0.1.38 \
+	crate://crates.io/libz-sys/1.0.5 \
+	crate://crates.io/log/0.3.6 \
+	crate://crates.io/matches/0.1.2 \
+	crate://crates.io/memchr/0.1.11 \
+	crate://crates.io/miniz-sys/0.1.7 \
+	crate://crates.io/miow/0.1.3 \
+	crate://crates.io/net2/0.2.26 \
+	crate://crates.io/nom/1.2.4 \
+	crate://crates.io/num-bigint/0.1.33 \
+	crate://crates.io/num-complex/0.1.33 \
+	crate://crates.io/num-integer/0.1.32 \
+	crate://crates.io/num-iter/0.1.32 \
+	crate://crates.io/num-rational/0.1.32 \
+	crate://crates.io/num-traits/0.1.34 \
+	crate://crates.io/num/0.1.34 \
+	crate://crates.io/num_cpus/1.0.0 \
+	crate://crates.io/openssl-sys-extras/0.7.14 \
+	crate://crates.io/openssl-sys/0.7.14 \
+	crate://crates.io/openssl/0.7.14 \
+	crate://crates.io/pkg-config/0.3.8 \
+	crate://crates.io/pnacl-build-helper/1.4.10 \
+	crate://crates.io/rand/0.3.14 \
+	crate://crates.io/regex-syntax/0.3.4 \
+	crate://crates.io/regex/0.1.73 \
+	crate://crates.io/rustc-serialize/0.3.19 \
+	crate://crates.io/semver/0.2.3 \
+	crate://crates.io/strsim/0.3.0 \
+	crate://crates.io/tar/0.4.8 \
+	crate://crates.io/tempdir/0.3.5 \
+	crate://crates.io/term/0.4.4 \
+	crate://crates.io/thread-id/2.0.0 \
+	crate://crates.io/thread_local/0.2.6 \
+	crate://crates.io/toml/0.2.0 \
+	crate://crates.io/unicode-bidi/0.2.3 \
+	crate://crates.io/unicode-normalization/0.1.2 \
+	crate://crates.io/url/1.2.0 \
+	crate://crates.io/user32-sys/0.2.0 \
+	crate://crates.io/utf8-ranges/0.1.3 \
+	crate://crates.io/winapi-build/0.1.1 \
+	crate://crates.io/winapi/0.2.8 \
+	crate://crates.io/ws2_32-sys/0.2.1 \
+"
+# Compatible with Rust 1.12.1
+# https://static.rust-lang.org/dist/channel-rust-1.12.1.toml
+SRCREV_cargo = "109cb7c33d426044d141457049bd0fffaca1327c"
+
+S = "${WORKDIR}/git"
+
+LIC_FILES_CHKSUM ="\
+	file://LICENSE-MIT;md5=362255802eb5aa87810d12ddf3cfedb4 \
+	file://LICENSE-APACHE;md5=1836efb2eb779966696f473ee8540542 \
+	file://LICENSE-THIRD-PARTY;md5=892ea68b169e69cfe75097fc38a15b56 \
+"

recipes-devtools/cargo/cargo_0.16.0.bb

@@ -0,0 +1,85 @@
+require cargo-snapshot.inc
+require cargo.inc
+
+EXTRA_OECONF += "--cargo=${WORKDIR}/cargo-nightly-x86_64-unknown-linux-gnu/cargo/bin/cargo"
+
+SRC_URI += " \
+    git://github.com/rust-lang/cargo.git;protocol=https;name=cargo;branch=rust-1.15.1 \
+    crate://crates.io/advapi32-sys/0.2.0 \
+    crate://crates.io/aho-corasick/0.5.3 \
+    crate://crates.io/bitflags/0.7.0 \
+    crate://crates.io/bufstream/0.1.2 \
+    crate://crates.io/cfg-if/0.1.0 \
+    crate://crates.io/cmake/0.1.19 \
+    crate://crates.io/crossbeam/0.2.10 \
+    crate://crates.io/curl-sys/0.3.6 \
+    crate://crates.io/curl/0.4.1 \
+    crate://crates.io/docopt/0.6.86 \
+    crate://crates.io/env_logger/0.3.5 \
+    crate://crates.io/filetime/0.1.10 \
+    crate://crates.io/flate2/0.2.14 \
+    crate://crates.io/fs2/0.3.0 \
+    crate://crates.io/gcc/0.3.39 \
+    crate://crates.io/gdi32-sys/0.2.0 \
+    crate://crates.io/git2-curl/0.7.0 \
+    crate://crates.io/git2/0.6.3 \
+    crate://crates.io/glob/0.2.11 \
+    crate://crates.io/hamcrest/0.1.1 \
+    crate://crates.io/idna/0.1.0 \
+    crate://crates.io/kernel32-sys/0.2.2 \
+    crate://crates.io/lazy_static/0.2.2 \
+    crate://crates.io/libc/0.2.18 \
+    crate://crates.io/libgit2-sys/0.6.5 \
+    crate://crates.io/libssh2-sys/0.2.4 \
+    crate://crates.io/libz-sys/1.0.10 \
+    crate://crates.io/log/0.3.6 \
+    crate://crates.io/matches/0.1.4 \
+    crate://crates.io/memchr/0.1.11 \
+    crate://crates.io/miniz-sys/0.1.7 \
+    crate://crates.io/miow/0.1.3 \
+    crate://crates.io/net2/0.2.26 \
+    crate://crates.io/num-bigint/0.1.35 \
+    crate://crates.io/num-complex/0.1.35 \
+    crate://crates.io/num-integer/0.1.32 \
+    crate://crates.io/num-iter/0.1.32 \
+    crate://crates.io/num-rational/0.1.35 \
+    crate://crates.io/num-traits/0.1.36 \
+    crate://crates.io/num/0.1.36 \
+    crate://crates.io/num_cpus/1.1.0 \
+    crate://crates.io/openssl-probe/0.1.0 \
+    crate://crates.io/openssl-sys/0.9.1 \
+    crate://crates.io/openssl/0.9.1 \
+    crate://crates.io/pkg-config/0.3.8 \
+    crate://crates.io/psapi-sys/0.1.0 \
+    crate://crates.io/rand/0.3.14 \
+    crate://crates.io/regex-syntax/0.3.9 \
+    crate://crates.io/regex/0.1.80 \
+    crate://crates.io/rustc-serialize/0.3.21 \
+    crate://crates.io/semver-parser/0.6.1 \
+    crate://crates.io/semver/0.5.1 \
+    crate://crates.io/strsim/0.5.1 \
+    crate://crates.io/tar/0.4.9 \
+    crate://crates.io/tempdir/0.3.5 \
+    crate://crates.io/term/0.4.4 \
+    crate://crates.io/thread-id/2.0.0 \
+    crate://crates.io/thread_local/0.2.7 \
+    crate://crates.io/toml/0.2.1 \
+    crate://crates.io/unicode-bidi/0.2.3 \
+    crate://crates.io/unicode-normalization/0.1.2 \
+    crate://crates.io/url/1.2.3 \
+    crate://crates.io/user32-sys/0.2.0 \
+    crate://crates.io/utf8-ranges/0.1.3 \
+    crate://crates.io/winapi-build/0.1.1 \
+    crate://crates.io/winapi/0.2.8 \
+    crate://crates.io/ws2_32-sys/0.2.1 \
+"
+
+SRCREV_cargo = "6e0c18cccc8b0c06fba8a8d76486f81a792fb420"
+
+S = "${WORKDIR}/git"
+
+LIC_FILES_CHKSUM=" \
+    file://LICENSE-MIT;md5=362255802eb5aa87810d12ddf3cfedb4 \
+    file://LICENSE-APACHE;md5=1836efb2eb779966696f473ee8540542 \
+    file://LICENSE-THIRD-PARTY;md5=892ea68b169e69cfe75097fc38a15b56 \
+"

recipes-devtools/cargo/cargo_1.61.0.bb

@@ -1,4 +0,0 @@
-require recipes-devtools/rust/rust-source-${PV}.inc
-require recipes-devtools/rust/rust-snapshot-${PV}.inc
-require cargo.inc
-BBCLASSEXTEND = "native nativesdk"

recipes-devtools/cargo/cargo_1.64.0.bb

@@ -1,4 +0,0 @@
-require recipes-devtools/rust/rust-source-${PV}.inc
-require recipes-devtools/rust/rust-snapshot-${PV}.inc
-require cargo.inc
-BBCLASSEXTEND = "native nativesdk"

recipes-devtools/rust/compiler-rt.inc

@@ -0,0 +1,28 @@
+SUMMARY = "Rust compiler run-time"
+HOMEPAGE = "http://www.rust-lang.org"
+SECTION = "devel"
+LICENSE = "MIT"
+LIC_FILES_CHKSUM = "file://src/compiler-rt/LICENSE.TXT;md5=bf24bca27049b52e9738451aa55771d4"
+
+require rust.inc
+ALLOW_EMPTY_${PN} = "1"
+
+DEPENDS += "rust-llvm-native (=${PV})"
+# dev and staticdev should NOT depend on the binary package
+RDEPENDS_${PN}-dev = ""
+INSANE_SKIP_${PN}-dev = "staticdev"
+
+DISABLE_STATIC = ""
+INHIBIT_DEFAULT_RUST_DEPS = "1"
+
+do_compile () {
+	oe_runmake ${TARGET_SYS}/rt/libcompiler-rt.a
+}
+
+do_install () {
+	mkdir -p ${D}${libdir}
+	cp ${TARGET_SYS}/rt/libcompiler-rt.a ${D}${libdir}/libcompiler-rt.a
+}
+
+FILES_${PN}-dev = ""
+FILES_${PN}-staticdev = "${libdir}/*.a"

recipes-devtools/rust/compiler-rt_1.12.1.bb

@@ -0,0 +1,2 @@
+require compiler-rt.inc
+require rust-source-${PV}.inc

recipes-devtools/rust/files/rust-1.12.1/0001-Target-add-default-target.json-path-libdir-rust-targ.patch

@@ -0,0 +1,107 @@
+From bb2d8649b2b344e0bb4b1cf94135378831735557 Mon Sep 17 00:00:00 2001
+From: Cody P Schafer <dev@codyps.com>
+Date: Tue, 18 Nov 2014 01:40:21 -0500
+Subject: [PATCH 01/10] Target: add default target.json path:
+ $libdir/rust/targets
+
+---
+ src/librustc/session/config.rs  |  6 +++---
+ src/librustc/session/mod.rs     |  8 ++++++--
+ src/librustc_back/target/mod.rs | 13 +++++++++++--
+ 3 files changed, 20 insertions(+), 7 deletions(-)
+
+diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs
+index e988ddc..563f3ac 100644
+--- a/src/librustc/session/config.rs
++++ b/src/librustc/session/config.rs
+@@ -42,7 +42,7 @@ use std::env;
+ use std::fmt;
+ use std::hash::{Hasher, SipHasher};
+ use std::iter::FromIterator;
+-use std::path::PathBuf;
++use std::path::{Path, PathBuf};
+ 
+ pub struct Config {
+     pub target: Target,
+@@ -1011,8 +1011,8 @@ pub fn build_configuration(sess: &Session,
+     v
+ }
+ 
+-pub fn build_target_config(opts: &Options, sp: &Handler) -> Config {
+-    let target = match Target::search(&opts.target_triple) {
++pub fn build_target_config(sysroot: &Path, opts: &Options, sp: &Handler) -> Config {
++    let target = match Target::search(sysroot, &opts.target_triple[..]) {
+         Ok(t) => t,
+         Err(e) => {
+             sp.struct_fatal(&format!("Error loading target specification: {}", e))
+diff --git a/src/librustc/session/mod.rs b/src/librustc/session/mod.rs
+index c71253a..13b4e05 100644
+--- a/src/librustc/session/mod.rs
++++ b/src/librustc/session/mod.rs
+@@ -395,13 +395,17 @@ pub fn build_session_(sopts: config::Options,
+                       codemap: Rc<codemap::CodeMap>,
+                       cstore: Rc<for<'a> CrateStore<'a>>)
+                       -> Session {
+-    let host = match Target::search(config::host_triple()) {
++    let sysroot = match sopts.maybe_sysroot {
++        Some(ref x) => PathBuf::from(x),
++        None => filesearch::get_or_default_sysroot()
++    };
++    let host = match Target::search(&sysroot, config::host_triple()) {
+         Ok(t) => t,
+         Err(e) => {
+             panic!(span_diagnostic.fatal(&format!("Error loading host specification: {}", e)));
+     }
+     };
+-    let target_cfg = config::build_target_config(&sopts, &span_diagnostic);
++    let target_cfg = config::build_target_config(&sysroot, &sopts, &span_diagnostic);
+     let p_s = parse::ParseSess::with_span_handler(span_diagnostic, codemap);
+     let default_sysroot = match sopts.maybe_sysroot {
+         Some(_) => None,
+diff --git a/src/librustc_back/target/mod.rs b/src/librustc_back/target/mod.rs
+index 18686e3..d439b59 100644
+--- a/src/librustc_back/target/mod.rs
++++ b/src/librustc_back/target/mod.rs
+@@ -49,6 +49,8 @@ use std::collections::BTreeMap;
+ use std::default::Default;
+ use std::io::prelude::*;
+ use syntax::abi::Abi;
++use std::borrow::ToOwned;
++use std::path::Path;
+ 
+ mod android_base;
+ mod apple_base;
+@@ -541,12 +543,13 @@ impl Target {
+     ///
+     /// The error string could come from any of the APIs called, including
+     /// filesystem access and JSON decoding.
+-    pub fn search(target: &str) -> Result<Target, String> {
++    pub fn search(sysroot: &Path, target: &str) -> Result<Target, String> {
+         use std::env;
+         use std::ffi::OsString;
+         use std::fs::File;
+         use std::path::{Path, PathBuf};
+         use serialize::json;
++        use std::iter::IntoIterator;
+ 
+         fn load_file(path: &Path) -> Result<Target, String> {
+             let mut f = File::open(path).map_err(|e| e.to_string())?;
+@@ -577,8 +580,14 @@ impl Target {
+                               .unwrap_or(OsString::new());
+ 
+         // FIXME 16351: add a sane default search path?
++        let mut default_path = sysroot.to_owned();
++        default_path.push(env!("CFG_LIBDIR_RELATIVE"));
++        default_path.push("rustlib");
+ 
+-        for dir in env::split_paths(&target_path) {
++        let paths = env::split_paths(&target_path)
++            .chain(Some(default_path).into_iter());
++
++        for dir in paths {
+             let p =  dir.join(&path);
+             if p.is_file() {
+                 return load_file(&p);
+-- 
+2.10.0
+

recipes-devtools/rust/files/rust-1.12.1/0002-mk-for-stage0-use-RUSTFLAGS-to-override-target-libs-.patch

@@ -0,0 +1,73 @@
+From 0829743c109a147213d06d38052662a5f2b0dd9b Mon Sep 17 00:00:00 2001
+From: Cody P Schafer <dev@codyps.com>
+Date: Tue, 18 Nov 2014 14:52:56 -0500
+Subject: [PATCH 02/10] mk: for stage0, use RUSTFLAGS to override target libs
+ dir
+
+Setting HLIB specially for stage0 (and even more specially for windows)
+also affects the location we place TLIB. To keep the TLIBs we build in
+the place requested by configure, use '-L' and '--sysroot' to point
+stage0-rustc at the appropriate location.
+---
+ mk/main.mk | 29 ++++++++++++-----------------
+ 1 file changed, 12 insertions(+), 17 deletions(-)
+
+diff --git a/mk/main.mk b/mk/main.mk
+index 90d3563..cdcbdf2 100644
+--- a/mk/main.mk
++++ b/mk/main.mk
+@@ -420,32 +420,26 @@ define SREQ
+ HROOT$(1)_H_$(3) = $(3)/stage$(1)
+ HBIN$(1)_H_$(3) = $$(HROOT$(1)_H_$(3))/bin
+ 
+-ifeq ($$(CFG_WINDOWSY_$(3)),1)
+-# On Windows we always store host runtime libraries in the 'bin' directory because
+-# there's no rpath. Target libraries go under $CFG_LIBDIR_RELATIVE (usually 'lib').
+-HLIB_RELATIVE$(1)_H_$(3) = bin
+-TROOT$(1)_T_$(2)_H_$(3) = $$(HROOT$(1)_H_$(3))/$$(CFG_LIBDIR_RELATIVE)/rustlib/$(2)
+-# Remove the next 3 lines after a snapshot
+-ifeq ($(1),0)
+-RUSTFLAGS_STAGE0 += -L $$(TROOT$(1)_T_$(2)_H_$(3))/lib
+-endif
+-
+-else
+-
+-ifeq ($(1),0)
+-HLIB_RELATIVE$(1)_H_$(3) = lib
+-else
+ HLIB_RELATIVE$(1)_H_$(3) = $$(CFG_LIBDIR_RELATIVE)
+-endif
++
+ TROOT$(1)_T_$(2)_H_$(3) = $$(HLIB$(1)_H_$(3))/rustlib/$(2)
+ 
+-endif
+ HLIB$(1)_H_$(3) = $$(HROOT$(1)_H_$(3))/$$(HLIB_RELATIVE$(1)_H_$(3))
+ 
+ # Destinations of artifacts for target architectures
+ TBIN$(1)_T_$(2)_H_$(3) = $$(TROOT$(1)_T_$(2)_H_$(3))/bin
+ TLIB$(1)_T_$(2)_H_$(3) = $$(TROOT$(1)_T_$(2)_H_$(3))/lib
+ 
++# Don't trust stage0, be explicit about libraries
++# TODO: rather than specifying sysroot, we really want to tell which libdir to
++#       use (ie: the dir containing 'rustlib'). This would allow us to avoid
++#       passing the '-L' options.
++ifeq ($(1),0)
++RUSTFLAGS_S_$(1)_T_$(2)_H_$(3) += --sysroot "$$(HROOT$(1)_H_$(3))" \
++				  -L "$$(TLIB$(1)_T_$(2)_H_$(3))"
++endif
++
++
+ # Preqrequisites for using the stageN compiler
+ ifeq ($(1),0)
+ HSREQ$(1)_H_$(3) = $$(HBIN$(1)_H_$(3))/rustc$$(X_$(3))
+@@ -558,6 +552,7 @@ STAGE$(1)_T_$(2)_H_$(3) := \
+ 		$$(HBIN$(1)_H_$(3))/rustc$$(X_$(3)) \
+ 		--cfg $$(CFGFLAG$(1)_T_$(2)_H_$(3)) \
+ 		$$(CFG_RUSTC_FLAGS) $$(EXTRAFLAGS_STAGE$(1)) --target=$(2)) \
++		$$(RUSTFLAGS_S_$(1)_T_$(2)_H_$(3)) \
+                 $$(RUSTC_FLAGS_$(2))
+ 
+ endef
+-- 
+2.10.0
+

recipes-devtools/rust/files/rust-1.12.1/0003-mk-add-missing-CFG_LIBDIR_RELATIVE.patch

@@ -0,0 +1,27 @@
+From 128503bf447e82b9e99bea8ef83294a6446036b5 Mon Sep 17 00:00:00 2001
+From: Cody P Schafer <dev@codyps.com>
+Date: Tue, 18 Nov 2014 13:48:14 -0500
+Subject: [PATCH 03/10] mk: add missing CFG_LIBDIR_RELATIVE
+
+---
+ mk/grammar.mk | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+diff --git a/mk/grammar.mk b/mk/grammar.mk
+index 0d527bd..926f247 100644
+--- a/mk/grammar.mk
++++ b/mk/grammar.mk
+@@ -11,8 +11,8 @@
+ BG = $(CFG_BUILD_DIR)/grammar/
+ SG = $(S)src/grammar/
+ B = $(CFG_BUILD_DIR)/$(CFG_BUILD)/stage2/
+-L = $(B)lib/rustlib/$(CFG_BUILD)/lib
+-LD = $(CFG_BUILD)/stage2/lib/rustlib/$(CFG_BUILD)/lib/
++L = $(B)$(CFG_LIBDIR_RELATIVE)/rustlib/$(CFG_BUILD)/lib
++LD = $(CFG_BUILD)/stage2/$(CFG_LIBDIR_RELATIVE)/rustlib/$(CFG_BUILD)/lib/
+ RUSTC = $(STAGE2_T_$(CFG_BUILD)_H_$(CFG_BUILD))
+ ifeq ($(CFG_OSTYPE),apple-darwin)
+ 	FLEX_LDFLAGS=-ll
+-- 
+2.10.0
+

recipes-devtools/rust/files/rust-1.12.1/0005-std-thread_local-workaround-for-NULL-__dso_handle.patch

@@ -0,0 +1,25 @@
+From d73ce5d99346812fcf063a87b4efac54c263737d Mon Sep 17 00:00:00 2001
+From: Cody P Schafer <dev@codyps.com>
+Date: Wed, 3 Dec 2014 19:15:19 -0500
+Subject: [PATCH 05/10] std/thread_local: workaround for NULL __dso_handle
+
+---
+ src/libstd/thread/local.rs | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/src/libstd/thread/local.rs b/src/libstd/thread/local.rs
+index 152b977..3c62862 100644
+--- a/src/libstd/thread/local.rs
++++ b/src/libstd/thread/local.rs
+@@ -380,7 +380,7 @@ pub mod elf {
+             #[linkage = "extern_weak"]
+             static __cxa_thread_atexit_impl: *const libc::c_void;
+         }
+-        if !__cxa_thread_atexit_impl.is_null() {
++        if !__cxa_thread_atexit_impl.is_null() && !__dso_handle.is_null() {
+             type F = unsafe extern fn(dtor: unsafe extern fn(*mut u8),
+                                       arg: *mut u8,
+                                       dso_handle: *mut u8) -> libc::c_int;
+-- 
+2.10.0
+

recipes-devtools/rust/files/rust-1.12.1/0006-mk-install-use-disable-rewrite-paths.patch

@@ -0,0 +1,30 @@
+From f8d4b1ea925789bca1aa6261017d63f5efa95c0f Mon Sep 17 00:00:00 2001
+From: Cody P Schafer <dev@codyps.com>
+Date: Mon, 2 Mar 2015 13:34:59 -0500
+Subject: [PATCH 06/10] mk/install: use disable-rewrite-paths
+
+This stops the install scripts from doing work we've already handled.
+
+Path rewriting is only useful for prepackaged binary installers.
+---
+ mk/install.mk | 4 +++-
+ 1 file changed, 3 insertions(+), 1 deletion(-)
+
+diff --git a/mk/install.mk b/mk/install.mk
+index d2e5449..e67650b 100644
+--- a/mk/install.mk
++++ b/mk/install.mk
+@@ -12,7 +12,9 @@ RUN_INSTALLER = cd tmp/empty_dir && \
+ 	sh ../../tmp/dist/$(1)/install.sh \
+ 		--prefix="$(DESTDIR)$(CFG_PREFIX)" \
+ 		--libdir="$(DESTDIR)$(CFG_LIBDIR)" \
+-		--mandir="$(DESTDIR)$(CFG_MANDIR)"
++		--mandir="$(DESTDIR)$(CFG_MANDIR)" \
++		"$(MAYBE_DISABLE_VERIFY)" \
++		--disable-rewrite-paths
+ 
+ install:
+ ifeq (root user, $(USER) $(patsubst %,user,$(SUDO_USER)))
+-- 
+2.10.0
+

recipes-devtools/rust/files/rust-1.12.1/0007-Allow-overriding-crate_hash-with-C-crate_hash.patch

@@ -0,0 +1,65 @@
+From 2a42d59c3671f3ab68d8ff49c46240842aff6eb6 Mon Sep 17 00:00:00 2001
+From: Steven Walter <swalter@lexmark.com>
+Date: Wed, 18 Nov 2015 08:33:26 -0500
+Subject: [PATCH 07/10] Allow overriding crate_hash with -C crate_hash
+
+The current crate hash is not stable from run-to-run.  This causes
+problems with bitbake; it needs a guarantee that every build with the
+same input will generate compatible output, otherwise sstate won't work.
+Using -C crate_hash, we can do that by using the bitbake input hash to
+determine the crate hash; the bitbake input hash will be stable, but
+still different for different rust recipes.
+
+Upstream-Status: not-appropriate
+
+Upstream wants to fix it's actual object generation here. See
+https://github.com/rust-lang/rust/issues/34902 (and others) for details.
+---
+ src/librustc/session/config.rs  |  2 ++
+ src/librustc_trans/back/link.rs | 12 +++++++++++-
+ 2 files changed, 13 insertions(+), 1 deletion(-)
+
+diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs
+index 563f3ac..52a5130 100644
+--- a/src/librustc/session/config.rs
++++ b/src/librustc/session/config.rs
+@@ -804,6 +804,8 @@ options! {CodegenOptions, CodegenSetter, basic_codegen_options,
+          "choose the code model to use (rustc --print code-models for details)"),
+     metadata: Vec<String> = (Vec::new(), parse_list, [TRACKED],
+          "metadata to mangle symbol names with"),
++    crate_hash: String = ("".to_string(), parse_string, [TRACKED],
++         "override crate hash with given value"),
+     extra_filename: String = ("".to_string(), parse_string, [UNTRACKED],
+          "extra data to put in each output filename"),
+     codegen_units: usize = (1, parse_uint, [UNTRACKED],
+diff --git a/src/librustc_trans/back/link.rs b/src/librustc_trans/back/link.rs
+index 3cf2500..0e48063 100644
+--- a/src/librustc_trans/back/link.rs
++++ b/src/librustc_trans/back/link.rs
+@@ -125,12 +125,22 @@ pub fn find_crate_name(sess: Option<&Session>,
+ 
+ }
+ 
++use std::hash::{Hasher, SipHasher};
++use rustc::hir::svh::Svh;
++
+ pub fn build_link_meta<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
+                                  name: &str)
+                                  -> LinkMeta {
++    let crate_hash = if tcx.sess.opts.cg.crate_hash != "" {
++        let mut state = SipHasher::new();
++        state.write(tcx.sess.opts.cg.crate_hash.as_bytes());
++        Svh::new(state.finish())
++    } else {
++        tcx.calculate_krate_hash()
++    };
+     let r = LinkMeta {
+         crate_name: name.to_owned(),
+-        crate_hash: tcx.calculate_krate_hash(),
++        crate_hash: crate_hash,
+     };
+     info!("{:?}", r);
+     return r;
+-- 
+2.10.0
+

recipes-devtools/rust/files/rust-1.12.1/0008-mk-platform.mk-pass-C-crate_hash-to-builds.patch

@@ -0,0 +1,27 @@
+From 174ae38bcc197658dd0ad6bcdae2bb06112e68a2 Mon Sep 17 00:00:00 2001
+From: Steven Walter <swalter@lexmark.com>
+Date: Wed, 18 Nov 2015 08:41:17 -0500
+Subject: [PATCH 08/10] mk/platform.mk: pass -C crate_hash to builds
+
+bitbake recipe will export FORCE_CRATE_HASH
+
+Upstream-Status: not-appropriate
+---
+ mk/platform.mk | 1 +
+ 1 file changed, 1 insertion(+)
+
+diff --git a/mk/platform.mk b/mk/platform.mk
+index d601cab..0b5e9f2 100644
+--- a/mk/platform.mk
++++ b/mk/platform.mk
+@@ -181,6 +181,7 @@ define CFG_MAKE_TOOLCHAIN
+        AR_$(1)=$(CROSS_PREFIX_$(1))$(AR_$(1))
+        LINK_$(1)=$(CROSS_PREFIX_$(1))$(LINK_$(1))
+        RUSTC_CROSS_FLAGS_$(1)=-C linker=$$(call FIND_COMPILER,$$(LINK_$(1))) \
++           -C crate_hash=$(FORCE_CRATE_HASH) \
+            -C ar=$$(call FIND_COMPILER,$$(AR_$(1))) $(RUSTC_CROSS_FLAGS_$(1))
+ 
+        RUSTC_FLAGS_$(1)=$$(RUSTC_CROSS_FLAGS_$(1)) $(RUSTC_FLAGS_$(1))
+-- 
+2.10.0
+

recipes-devtools/rust/files/rust-1.15.1/0001-Target-add-default-target.json-path-libdir-rust-targ.patch

@@ -0,0 +1,106 @@
+From e9c6cf5d1a9bb7f50c5e98a660217062b510928b Mon Sep 17 00:00:00 2001
+From: Cody P Schafer <dev@codyps.com>
+Date: Tue, 18 Nov 2014 01:40:21 -0500
+Subject: [PATCH 1/3] Target: add default target.json path:
+ $libdir/rust/targets
+
+---
+ src/librustc/session/config.rs  |  6 +++---
+ src/librustc/session/mod.rs     |  8 ++++++--
+ src/librustc_back/target/mod.rs | 12 ++++++++++--
+ 3 files changed, 19 insertions(+), 7 deletions(-)
+
+diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs
+index 5e3c8bc..15fd763 100644
+--- a/src/librustc/session/config.rs
++++ b/src/librustc/session/config.rs
+@@ -42,7 +42,7 @@ use std::hash::Hasher;
+ use std::collections::hash_map::DefaultHasher;
+ use std::collections::HashSet;
+ use std::iter::FromIterator;
+-use std::path::PathBuf;
++use std::path::{Path, PathBuf};
+ 
+ pub struct Config {
+     pub target: Target,
+@@ -1001,8 +1001,8 @@ pub fn build_configuration(sess: &Session,
+     user_cfg
+ }
+ 
+-pub fn build_target_config(opts: &Options, sp: &Handler) -> Config {
+-    let target = match Target::search(&opts.target_triple) {
++pub fn build_target_config(sysroot: &Path, opts: &Options, sp: &Handler) -> Config {
++    let target = match Target::search(sysroot, &opts.target_triple[..]) {
+         Ok(t) => t,
+         Err(e) => {
+             sp.struct_fatal(&format!("Error loading target specification: {}", e))
+diff --git a/src/librustc/session/mod.rs b/src/librustc/session/mod.rs
+index 91765e6..29e5e5d 100644
+--- a/src/librustc/session/mod.rs
++++ b/src/librustc/session/mod.rs
+@@ -575,13 +575,17 @@ pub fn build_session_(sopts: config::Options,
+                       codemap: Rc<codemap::CodeMap>,
+                       cstore: Rc<for<'a> CrateStore<'a>>)
+                       -> Session {
+-    let host = match Target::search(config::host_triple()) {
++    let sysroot = match sopts.maybe_sysroot {
++        Some(ref x) => PathBuf::from(x),
++        None => filesearch::get_or_default_sysroot()
++    };
++    let host = match Target::search(&sysroot, config::host_triple()) {
+         Ok(t) => t,
+         Err(e) => {
+             panic!(span_diagnostic.fatal(&format!("Error loading host specification: {}", e)));
+     }
+     };
+-    let target_cfg = config::build_target_config(&sopts, &span_diagnostic);
++    let target_cfg = config::build_target_config(&sysroot, &sopts, &span_diagnostic);
+     let p_s = parse::ParseSess::with_span_handler(span_diagnostic, codemap);
+     let default_sysroot = match sopts.maybe_sysroot {
+         Some(_) => None,
+diff --git a/src/librustc_back/target/mod.rs b/src/librustc_back/target/mod.rs
+index 351d469..3282dbd 100644
+--- a/src/librustc_back/target/mod.rs
++++ b/src/librustc_back/target/mod.rs
+@@ -51,6 +51,7 @@ use std::io::prelude::*;
+ use syntax::abi::{Abi, lookup as lookup_abi};
+ 
+ use PanicStrategy;
++use std::path::Path;
+ 
+ mod android_base;
+ mod apple_base;
+@@ -625,12 +626,13 @@ impl Target {
+     ///
+     /// The error string could come from any of the APIs called, including
+     /// filesystem access and JSON decoding.
+-    pub fn search(target: &str) -> Result<Target, String> {
++    pub fn search(sysroot: &Path, target: &str) -> Result<Target, String> {
+         use std::env;
+         use std::ffi::OsString;
+         use std::fs::File;
+         use std::path::{Path, PathBuf};
+         use serialize::json;
++        use std::iter::IntoIterator;
+ 
+         fn load_file(path: &Path) -> Result<Target, String> {
+             let mut f = File::open(path).map_err(|e| e.to_string())?;
+@@ -661,8 +663,14 @@ impl Target {
+                               .unwrap_or(OsString::new());
+ 
+         // FIXME 16351: add a sane default search path?
++        let mut default_path = sysroot.to_owned();
++        default_path.push(env!("CFG_LIBDIR_RELATIVE"));
++        default_path.push("rustlib");
+ 
+-        for dir in env::split_paths(&target_path) {
++        let paths = env::split_paths(&target_path)
++            .chain(Some(default_path).into_iter());
++
++        for dir in paths {
+             let p =  dir.join(&path);
+             if p.is_file() {
+                 return load_file(&p);
+-- 
+2.10.1 (Apple Git-78)
+

recipes-devtools/rust/files/rust-1.15.1/0003-std-thread_local-workaround-for-NULL-__dso_handle.patch

@@ -0,0 +1,25 @@
+From bff536002eba2ed322d329d9022ccdc77da458a3 Mon Sep 17 00:00:00 2001
+From: Cody P Schafer <dev@codyps.com>
+Date: Wed, 3 Dec 2014 19:15:19 -0500
+Subject: [PATCH 3/3] std/thread_local: workaround for NULL __dso_handle
+
+---
+ src/libstd/sys/unix/fast_thread_local.rs | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/src/libstd/sys/unix/fast_thread_local.rs b/src/libstd/sys/unix/fast_thread_local.rs
+index 0c625e7..31e7146 100644
+--- a/src/libstd/sys/unix/fast_thread_local.rs
++++ b/src/libstd/sys/unix/fast_thread_local.rs
+@@ -110,7 +110,7 @@ unsafe fn register_dtor(t: *mut u8, dtor: unsafe extern fn(*mut u8)) {
+         #[linkage = "extern_weak"]
+         static __cxa_thread_atexit_impl: *const libc::c_void;
+     }
+-    if !__cxa_thread_atexit_impl.is_null() {
++    if !__cxa_thread_atexit_impl.is_null() && !__dso_handle.is_null() {
+         type F = unsafe extern fn(dtor: unsafe extern fn(*mut u8),
+                                   arg: *mut u8,
+                                   dso_handle: *mut u8) -> libc::c_int;
+-- 
+2.10.1 (Apple Git-78)
+

recipes-devtools/rust/files/rust-installer-1.12.1/0001-add-option-to-disable-rewriting-of-install-paths.patch

@@ -0,0 +1,58 @@
+From c7daec775a917d9e3017bc35ea7d88cc9418f181 Mon Sep 17 00:00:00 2001
+From: Cody P Schafer <dev@codyps.com>
+Date: Mon, 2 Mar 2015 13:27:49 -0500
+Subject: [PATCH] add option to disable rewriting of install paths
+
+This is intended for use by rust & cargo's `make install`, as in that
+case:
+
+ - these paths are typically built into the pre-install layout already
+ - attempting to do the replacement will be incorrect subdirectory
+   cases (ie: libdir=lib/foo)
+---
+ install-template.sh | 21 ++++++++++++---------
+ 1 file changed, 12 insertions(+), 9 deletions(-)
+
+diff --git a/install-template.sh b/install-template.sh
+index 042b955..4ecf430 100644
+--- a/install-template.sh
++++ b/install-template.sh
+@@ -618,16 +618,18 @@ install_components() {
+ 	    # Decide the destination of the file
+ 	    local _file_install_path="$_dest_prefix/$_file"
+ 
+-	    if echo "$_file" | grep "^lib/" > /dev/null
+-	    then
+-		local _f="$(echo "$_file" | sed 's/^lib\///')"
+-		_file_install_path="$CFG_LIBDIR/$_f"
+-	    fi
++	    if [ -n "${CFG_REWRITE_PATHS-}" ]; then
++		if echo "$_file" | grep "^lib/" > /dev/null
++		then
++		    local _f="$(echo "$_file" | sed 's/^lib\///')"
++		    _file_install_path="$CFG_LIBDIR/$_f"
++		fi
+ 
+-	    if echo "$_file" | grep "^share/man/" > /dev/null
+-	    then
+-		local _f="$(echo "$_file" | sed 's/^share\/man\///')"
+-		_file_install_path="$CFG_MANDIR/$_f"
++		if echo "$_file" | grep "^share/man/" > /dev/null
++		then
++		    local _f="$(echo "$_file" | sed 's/^share\/man\///')"
++		    _file_install_path="$CFG_MANDIR/$_f"
++		fi
+ 	    fi
+ 
+ 	    # Make sure there's a directory for it
+@@ -810,6 +812,7 @@ valopt mandir "$CFG_DESTDIR_PREFIX/share/man" "install man pages in PATH"
+ opt ldconfig 1 "run ldconfig after installation (Linux only)"
+ opt verify 1 "obsolete"
+ flag verbose "run with verbose output"
++opt rewrite-paths 1 "rewrite install paths for libdir & mandir"
+ 
+ if [ $HELP -eq 1 ]
+ then
+-- 
+2.4.1
+

recipes-devtools/rust/libstd-rs-1.61.0/0001-Add-400-series-syscalls-to-musl-riscv64-definitions.patch

@@ -1,44 +0,0 @@
-From 7b3bc1de0c79a1b410105ce36bbe9f774438d263 Mon Sep 17 00:00:00 2001
-From: Ross Schulman <ross@rbs.io>
-Date: Tue, 1 Feb 2022 09:13:16 -0500
-Subject: [PATCH] Add 400-series syscalls to musl riscv64 definitions
-
-Upstream-Status: Backport [https://github.com/rust-lang/libc/commit/7b3bc1de0c79a1b410105ce36bbe9f774438d263]
-Signed-off-by: Khem Raj <raj.khem@gmail.com>
----
- .../linux_like/linux/musl/b64/riscv64/mod.rs  | 19 +++++++++++++++++++
- 1 file changed, 19 insertions(+)
-
-diff --git a/vendor/libc-0.2.116/src/unix/linux_like/linux/musl/b64/riscv64/mod.rs b/vendor/libc-0.2.116/src/unix/linux_like/linux/musl/b64/riscv64/mod.rs
-index 6b17621c7..2036583d5 100644
---- a/vendor/libc-0.2.116/src/unix/linux_like/linux/musl/b64/riscv64/mod.rs
-+++ b/vendor/libc-0.2.116/src/unix/linux_like/linux/musl/b64/riscv64/mod.rs
-@@ -465,6 +465,25 @@ pub const SYS_pkey_mprotect: ::c_long = 288;
- pub const SYS_pkey_alloc: ::c_long = 289;
- pub const SYS_pkey_free: ::c_long = 290;
- pub const SYS_statx: ::c_long = 291;
-+pub const SYS_pidfd_send_signal: ::c_long = 424;
-+pub const SYS_io_uring_setup: ::c_long = 425;
-+pub const SYS_io_uring_enter: ::c_long = 426;
-+pub const SYS_io_uring_register: ::c_long = 427;
-+pub const SYS_open_tree: ::c_long = 428;
-+pub const SYS_move_mount: ::c_long = 429;
-+pub const SYS_fsopen: ::c_long = 430;
-+pub const SYS_fsconfig: ::c_long = 431;
-+pub const SYS_fsmount: ::c_long = 432;
-+pub const SYS_fspick: ::c_long = 433;
-+pub const SYS_pidfd_open: ::c_long = 434;
-+pub const SYS_clone3: ::c_long = 435;
-+pub const SYS_close_range: ::c_long = 436;
-+pub const SYS_openat2: ::c_long = 437;
-+pub const SYS_pidfd_getfd: ::c_long = 438;
-+pub const SYS_faccessat2: ::c_long = 439;
-+pub const SYS_process_madvise: ::c_long = 440;
-+pub const SYS_epoll_pwait2: ::c_long = 441;
-+pub const SYS_mount_setattr: ::c_long = 442;
- 
- pub const O_APPEND: ::c_int = 1024;
- pub const O_DIRECT: ::c_int = 0x4000;
--- 
-2.35.1
-

recipes-devtools/rust/libstd-rs.inc

@@ -2,39 +2,24 @@ SUMMARY = "Rust standard libaries"
 HOMEPAGE = "http://www.rust-lang.org"
 SECTION = "devel"
 LICENSE = "MIT | Apache-2.0"
-LIC_FILES_CHKSUM = "file://../../COPYRIGHT;md5=93a95682d51b4cb0a633a97046940ef0"
+LIC_FILES_CHKSUM ="file://COPYRIGHT;md5=43e1f1fb9c0ee3af66693d8c4fecafa8"
 
 RUSTLIB_DEP = ""
 inherit cargo
 
-DEPENDS:append:libc-musl = " libunwind"
-# rv32 does not have libunwind ported yet
-DEPENDS:remove:riscv32 = "libunwind"
-DEPENDS:remove:riscv64 = "libunwind"
-
-# Embed bitcode in order to allow compiling both with and without LTO
-RUSTFLAGS += "-Cembed-bitcode=yes"
 # Needed so cargo can find libbacktrace
-RUSTFLAGS += "-L ${STAGING_LIBDIR} -C link-arg=-Wl,-soname,libstd.so"
+RUSTFLAGS += "-L ${STAGING_LIBDIR}"
 
-S = "${RUSTSRC}/src/libstd"
-
-CARGO_FEATURES ?= "panic-unwind backtrace"
-CARGO_BUILD_FLAGS += "--features '${CARGO_FEATURES}'"
-CARGO_VENDORING_DIRECTORY = "${RUSTSRC}/vendor"
-
-do_compile:prepend () {
+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}
-
-    # With the incremental build support added in 1.24, the libstd deps directory also includes dependency
-    # files that get installed. Those are really only needed to incrementally rebuild the libstd library
-    # itself and don't need to be installed.
-    rm -f ${B}/${TARGET_SYS}/${BUILD_DIR}/deps/*.d
-    cp ${B}/${TARGET_SYS}/${BUILD_DIR}/deps/* ${D}${rustlibdir}
+    cp ${B}/${TARGET_SYS}/release/deps/* ${D}${rustlibdir}
 }

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

@@ -0,0 +1,11 @@
+require rust-source-${PV}.inc
+require libstd-rs.inc
+
+SRC_URI += "\
+	crate://crates.io/gcc/0.3.27 \
+"
+
+# not necessary from Rust 1.15.x and newer as its built
+# as a cargo crate with libstd
+DEPENDS += "compiler-rt (=${PV})"
+

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

@@ -0,0 +1,19 @@
+require rust-source-${PV}.inc
+require libstd-rs.inc
+
+EXTRA_OECONF = "--disable-rustbuild"
+
+CARGO_BUILD_FLAGS += "--features 'jemalloc panic-unwind'"
+
+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 \
+"

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

@@ -1,11 +0,0 @@
-require rust-source-${PV}.inc
-require libstd-rs.inc
-
-# Check if libc crate is >= 0.2.117 before dropping this patch
-SRC_URI += " \
-    file://0001-Add-400-series-syscalls-to-musl-riscv64-definitions.patch;patchdir=../../ \
-    file://0001-Update-checksums-for-modified-vendored-libc.patch;patchdir=../../ \
-"
-
-# libstd moved from src/libstd to library/std in 1.47+
-S = "${RUSTSRC}/library/std"

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

@@ -1,5 +0,0 @@
-require rust-source-${PV}.inc
-require libstd-rs.inc
-
-# libstd moved from src/libstd to library/std in 1.47+
-S = "${RUSTSRC}/library/std"

recipes-devtools/rust/rust-common.inc

@@ -1,369 +0,0 @@
-
-# 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).
-# Note that TUNE_FEATURES is _always_ refering to the target, so we really
-# don't want to use this for the host/build.
-def llvm_features_from_tune(d):
-    f = []
-    feat = d.getVar('TUNE_FEATURES')
-    if not feat:
-        return []
-    feat = frozenset(feat.split())
-
-    mach_overrides = d.getVar('MACHINEOVERRIDES')
-    mach_overrides = frozenset(mach_overrides.split(':'))
-
-    if 'vfpv4' in feat:
-        f.append("+vfp4")
-    if 'vfpv3' in feat:
-        f.append("+vfp3")
-    if 'vfpv3d16' in feat:
-        f.append("+d16")
-
-    if 'vfpv2' in feat or 'vfp' in feat:
-        f.append("+vfp2")
-
-    if 'neon' in feat:
-        f.append("+neon")
-
-    if 'mips32' in feat:
-        f.append("+mips32")
-
-    if 'mips32r2' in feat:
-        f.append("+mips32r2")
-
-    if target_is_armv7(d):
-        f.append('+v7')
-
-    if ('armv6' in mach_overrides) or ('armv6' in feat):
-        f.append("+v6")
-    if 'armv5te' in feat:
-        f.append("+strict-align")
-        f.append("+v5te")
-    elif 'armv5' in feat:
-        f.append("+strict-align")
-        f.append("+v5")
-
-    if ('armv4' in mach_overrides) or ('armv4' in feat):
-        f.append("+strict-align")
-
-    if 'dsp' in feat:
-        f.append("+dsp")
-
-    if 'thumb' in feat:
-        if d.getVar('ARM_THUMB_OPT') == "thumb":
-            if target_is_armv7(d):
-                f.append('+thumb2')
-            f.append("+thumb-mode")
-
-    if 'cortexa5' in feat:
-        f.append("+a5")
-    if 'cortexa7' in feat:
-        f.append("+a7")
-    if 'cortexa9' in feat:
-        f.append("+a9")
-    if 'cortexa15' in feat:
-        f.append("+a15")
-    if 'cortexa17' in feat:
-        f.append("+a17")
-    if ('riscv64' in feat) or ('riscv32' in feat):
-        f.append("+a,+c,+d,+f,+m")
-    return f
-llvm_features_from_tune[vardepvalue] = "${@llvm_features_from_tune(d)}"
-
-# TARGET_CC_ARCH changes from build/cross/target so it'll do the right thing
-# this should go away when https://github.com/rust-lang/rust/pull/31709 is
-# stable (1.9.0?)
-def llvm_features_from_cc_arch(d):
-    f = []
-    feat = d.getVar('TARGET_CC_ARCH')
-    if not feat:
-        return []
-    feat = frozenset(feat.split())
-
-    if '-mmmx' in feat:
-        f.append("+mmx")
-    if '-msse' in feat:
-        f.append("+sse")
-    if '-msse2' in feat:
-        f.append("+sse2")
-    if '-msse3' in feat:
-        f.append("+sse3")
-    if '-mssse3' in feat:
-        f.append("+ssse3")
-    if '-msse4.1' in feat:
-        f.append("+sse4.1")
-    if '-msse4.2' in feat:
-        f.append("+sse4.2")
-    if '-msse4a' in feat:
-        f.append("+sse4a")
-    if '-mavx' in feat:
-        f.append("+avx")
-    if '-mavx2' in feat:
-        f.append("+avx2")
-
-    return f
-
-def llvm_features_from_target_fpu(d):
-    # TARGET_FPU can be hard or soft. +soft-float tell llvm to use soft float
-    # ABI. There is no option for hard.
-
-    fpu = d.getVar('TARGET_FPU', True)
-    return ["+soft-float"] if fpu == "soft" else []
-
-def llvm_features(d):
-    return ','.join(llvm_features_from_tune(d) +
-                    llvm_features_from_cc_arch(d) +
-                    llvm_features_from_target_fpu(d))
-
-
-## arm-unknown-linux-gnueabihf
-DATA_LAYOUT[arm-eabi] = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
-LLVM_TARGET[arm-eabi] = "${RUST_TARGET_SYS}"
-TARGET_ENDIAN[arm-eabi] = "little"
-TARGET_POINTER_WIDTH[arm-eabi] = "32"
-TARGET_C_INT_WIDTH[arm-eabi] = "32"
-MAX_ATOMIC_WIDTH[arm-eabi] = "64"
-FEATURES[arm-eabi] = "+v6,+vfp2"
-
-## armv7-unknown-linux-gnueabihf
-DATA_LAYOUT[armv7-eabi] = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
-LLVM_TARGET[armv7-eabi] = "${RUST_TARGET_SYS}"
-TARGET_ENDIAN[armv7-eabi] = "little"
-TARGET_POINTER_WIDTH[armv7-eabi] = "32"
-TARGET_C_INT_WIDTH[armv7-eabi] = "32"
-MAX_ATOMIC_WIDTH[armv7-eabi] = "64"
-FEATURES[armv7-eabi] = "+v7,+vfp2,+thumb2"
-
-## aarch64-unknown-linux-{gnu, musl}
-DATA_LAYOUT[aarch64] = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
-LLVM_TARGET[aarch64] = "${RUST_TARGET_SYS}"
-TARGET_ENDIAN[aarch64] = "little"
-TARGET_POINTER_WIDTH[aarch64] = "64"
-TARGET_C_INT_WIDTH[aarch64] = "32"
-MAX_ATOMIC_WIDTH[aarch64] = "128"
-
-## x86_64-unknown-linux-{gnu, musl}
-DATA_LAYOUT[x86_64] = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-LLVM_TARGET[x86_64] = "${RUST_TARGET_SYS}"
-TARGET_ENDIAN[x86_64] = "little"
-TARGET_POINTER_WIDTH[x86_64] = "64"
-TARGET_C_INT_WIDTH[x86_64] = "32"
-MAX_ATOMIC_WIDTH[x86_64] = "64"
-
-## x86_64-unknown-linux-gnux32
-DATA_LAYOUT[x86_64-x32] = "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
-LLVM_TARGET[x86_64-x32] = "${RUST_TARGET_SYS}"
-TARGET_ENDIAN[x86_64-x32] = "little"
-TARGET_POINTER_WIDTH[x86_64-x32] = "32"
-TARGET_C_INT_WIDTH[x86_64-x32] = "32"
-MAX_ATOMIC_WIDTH[x86_64-x32] = "64"
-
-## i686-unknown-linux-{gnu, musl}
-DATA_LAYOUT[i686] = "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128"
-LLVM_TARGET[i686] = "${RUST_TARGET_SYS}"
-TARGET_ENDIAN[i686] = "little"
-TARGET_POINTER_WIDTH[i686] = "32"
-TARGET_C_INT_WIDTH[i686] = "32"
-MAX_ATOMIC_WIDTH[i686] = "64"
-
-## XXX: a bit of a hack so qemux86 builds, clone of i686-unknown-linux-{gnu, musl} above
-DATA_LAYOUT[i586] = "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128"
-LLVM_TARGET[i586] = "${RUST_TARGET_SYS}"
-TARGET_ENDIAN[i586] = "little"
-TARGET_POINTER_WIDTH[i586] = "32"
-TARGET_C_INT_WIDTH[i586] = "32"
-MAX_ATOMIC_WIDTH[i586] = "64"
-
-## mips-unknown-linux-{gnu, musl}
-DATA_LAYOUT[mips] = "E-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64"
-LLVM_TARGET[mips] = "${RUST_TARGET_SYS}"
-TARGET_ENDIAN[mips] = "big"
-TARGET_POINTER_WIDTH[mips] = "32"
-TARGET_C_INT_WIDTH[mips] = "32"
-MAX_ATOMIC_WIDTH[mips] = "32"
-
-## mipsel-unknown-linux-{gnu, musl}
-DATA_LAYOUT[mipsel] = "e-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64"
-LLVM_TARGET[mipsel] = "${RUST_TARGET_SYS}"
-TARGET_ENDIAN[mipsel] = "little"
-TARGET_POINTER_WIDTH[mipsel] = "32"
-TARGET_C_INT_WIDTH[mipsel] = "32"
-MAX_ATOMIC_WIDTH[mipsel] = "32"
-
-## mips64-unknown-linux-{gnu, musl}
-DATA_LAYOUT[mips64] = "E-m:e-i8:8:32-i16:16:32-i64:64-n32:64-S128"
-LLVM_TARGET[mips64] = "${RUST_TARGET_SYS}"
-TARGET_ENDIAN[mips64] = "big"
-TARGET_POINTER_WIDTH[mips64] = "64"
-TARGET_C_INT_WIDTH[mips64] = "64"
-MAX_ATOMIC_WIDTH[mips64] = "64"
-
-## mips64el-unknown-linux-{gnu, musl}
-DATA_LAYOUT[mips64el] = "e-m:e-i8:8:32-i16:16:32-i64:64-n32:64-S128"
-LLVM_TARGET[mips64el] = "${RUST_TARGET_SYS}"
-TARGET_ENDIAN[mips64el] = "little"
-TARGET_POINTER_WIDTH[mips64el] = "64"
-TARGET_C_INT_WIDTH[mips64el] = "64"
-MAX_ATOMIC_WIDTH[mips64el] = "64"
-
-## powerpc-unknown-linux-{gnu, musl}
-DATA_LAYOUT[powerpc] = "E-m:e-p:32:32-i64:64-n32"
-LLVM_TARGET[powerpc] = "${RUST_TARGET_SYS}"
-TARGET_ENDIAN[powerpc] = "big"
-TARGET_POINTER_WIDTH[powerpc] = "32"
-TARGET_C_INT_WIDTH[powerpc] = "32"
-MAX_ATOMIC_WIDTH[powerpc] = "32"
-
-## powerpc64-unknown-linux-{gnu, musl}
-DATA_LAYOUT[powerpc64] = "E-m:e-i64:64-n32:64-S128-v256:256:256-v512:512:512"
-LLVM_TARGET[powerpc64] = "${RUST_TARGET_SYS}"
-TARGET_ENDIAN[powerpc64] = "big"
-TARGET_POINTER_WIDTH[powerpc64] = "64"
-TARGET_C_INT_WIDTH[powerpc64] = "64"
-MAX_ATOMIC_WIDTH[powerpc64] = "64"
-
-## powerpc64le-unknown-linux-{gnu, musl}
-DATA_LAYOUT[powerpc64le] = "e-m:e-i64:64-n32:64-v256:256:256-v512:512:512"
-LLVM_TARGET[powerpc64le] = "${RUST_TARGET_SYS}"
-TARGET_ENDIAN[powerpc64le] = "little"
-TARGET_POINTER_WIDTH[powerpc64le] = "64"
-TARGET_C_INT_WIDTH[powerpc64le] = "64"
-MAX_ATOMIC_WIDTH[powerpc64le] = "64"
-
-## riscv32-unknown-linux-{gnu, musl}
-DATA_LAYOUT[riscv32] = "e-m:e-p:32:32-i64:64-n32-S128"
-LLVM_TARGET[riscv32] = "${RUST_TARGET_SYS}"
-TARGET_ENDIAN[riscv32] = "little"
-TARGET_POINTER_WIDTH[riscv32] = "32"
-TARGET_C_INT_WIDTH[riscv32] = "32"
-MAX_ATOMIC_WIDTH[riscv32] = "32"
-
-## riscv64-unknown-linux-{gnu, musl}
-DATA_LAYOUT[riscv64] = "e-m:e-p:64:64-i64:64-i128:128-n64-S128"
-LLVM_TARGET[riscv64] = "${RUST_TARGET_SYS}"
-TARGET_ENDIAN[riscv64] = "little"
-TARGET_POINTER_WIDTH[riscv64] = "64"
-TARGET_C_INT_WIDTH[riscv64] = "64"
-MAX_ATOMIC_WIDTH[riscv64] = "64"
-
-def sys_for(d, thing):
-    return d.getVar('{}_SYS'.format(thing))
-
-def prefix_for(d, thing):
-    return d.getVar('{}_PREFIX'.format(thing))
-
-# 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):
-    if arch == "i586" or arch == "i686":
-        return "x86"
-    elif arch == "mipsel":
-        return "mips"
-    elif arch == "mip64sel":
-        return "mips64"
-    elif arch == "armv7":
-        return "arm"
-    elif arch == "powerpc64le":
-        return "powerpc64"
-    else:
-        return arch
-
-# generates our target CPU value
-def llvm_cpu(d):
-    cpu = d.getVar('PACKAGE_ARCH')
-    target = d.getVar('TRANSLATED_TARGET_ARCH')
-
-    trans = {}
-    trans['corei7-64'] = "corei7"
-    trans['core2-32'] = "core2"
-    trans['x86-64'] = "x86-64"
-    trans['i686'] = "i686"
-    trans['i586'] = "i586"
-    trans['powerpc'] = "powerpc"
-    trans['mips64'] = "mips64"
-    trans['mips64el'] = "mips64"
-    trans['riscv64'] = "generic-rv64"
-    trans['riscv32'] = "generic-rv32"
-
-    if target in ["mips", "mipsel"]:
-        feat = frozenset(d.getVar('TUNE_FEATURES').split())
-        if "mips32r2" in feat:
-            trans['mipsel'] = "mips32r2"
-            trans['mips'] = "mips32r2"
-        elif "mips32" in feat:
-            trans['mipsel'] = "mips32"
-            trans['mips'] = "mips32"
-
-    try:
-        return trans[cpu]
-    except:
-        return trans.get(target, "generic")
-
-TARGET_LLVM_CPU="${@llvm_cpu(d)}"
-TARGET_LLVM_FEATURES = "${@llvm_features(d)}"
-
-# class-native implies TARGET=HOST, and TUNE_FEATURES only describes the real
-# (original) target.
-TARGET_LLVM_FEATURES:class-native = "${@','.join(llvm_features_from_cc_arch(d))}"
-
-def rust_gen_target(d, thing, wd, features, cpu, arch, abi=""):
-    import json
-    sys = sys_for(d, thing)
-    prefix = prefix_for(d, thing)
-
-    if abi:
-        arch_abi = "{}-{}".format(arch, abi)
-    else:
-        arch_abi = arch
-
-    features = features or d.getVarFlag('FEATURES', arch_abi) or ""
-    features = features.strip()
-
-    # build tspec
-    tspec = {}
-    tspec['llvm-target'] = d.getVarFlag('LLVM_TARGET', arch_abi)
-    tspec['data-layout'] = d.getVarFlag('DATA_LAYOUT', arch_abi)
-    tspec['max-atomic-width'] = int(d.getVarFlag('MAX_ATOMIC_WIDTH', arch_abi))
-    tspec['target-pointer-width'] = d.getVarFlag('TARGET_POINTER_WIDTH', arch_abi)
-    tspec['target-c-int-width'] = d.getVarFlag('TARGET_C_INT_WIDTH', arch_abi)
-    tspec['target-endian'] = d.getVarFlag('TARGET_ENDIAN', arch_abi)
-    tspec['arch'] = arch_to_rust_target_arch(arch)
-    tspec['os'] = "linux"
-    if "musl" in tspec['llvm-target']:
-        tspec['env'] = "musl"
-    else:
-        tspec['env'] = "gnu"
-    if "riscv64" in tspec['llvm-target']:
-        tspec['llvm-abiname'] = "lp64d"
-    if "riscv32" in tspec['llvm-target']:
-        tspec['llvm-abiname'] = "ilp32d"
-    tspec['vendor'] = "unknown"
-    tspec['target-family'] = "unix"
-    tspec['linker'] = "{}{}gcc".format(d.getVar('CCACHE'), prefix)
-    tspec['cpu'] = cpu
-    if features != "":
-        tspec['features'] = features
-    tspec['dynamic-linking'] = True
-    tspec['executables'] = True
-    tspec['linker-is-gnu'] = True
-    tspec['linker-flavor'] = "gcc"
-    tspec['has-rpath'] = True
-    tspec['has-elf-tls'] = True
-    tspec['position-independent-executables'] = True
-    tspec['panic-strategy'] = d.getVar("RUST_PANIC_STRATEGY")
-
-    # write out the target spec json file
-    with open(wd + sys + '.json', 'w') as f:
-        json.dump(tspec, f, indent=4)
-
-python do_rust_gen_targets () {
-    wd = d.getVar('WORKDIR') + '/targets/'
-    build_arch = d.getVar('BUILD_ARCH')
-    rust_gen_target(d, 'BUILD', wd, "", "generic", build_arch)
-}
-
-addtask rust_gen_targets after do_patch before do_compile
-do_rust_gen_targets[dirs] += "${WORKDIR}/targets"
-

recipes-devtools/rust/rust-cross-canadian-common.inc

@@ -1,55 +0,0 @@
-
-RUST_ALTERNATE_EXE_PATH = "${STAGING_LIBDIR_NATIVE}/llvm-rust/bin/llvm-config"
-
-require rust.inc
-
-DEPENDS += "rust-llvm (=${PV})"
-
-inherit cross-canadian
-
-DEPENDS += "  \
-            virtual/${HOST_PREFIX}gcc-crosssdk \
-            virtual/nativesdk-libc rust-llvm-native \
-            virtual/${TARGET_PREFIX}compilerlibs \
-            virtual/nativesdk-${HOST_PREFIX}compilerlibs \
-            gcc-cross-${TARGET_ARCH} \
-           "
-
-# The host tools are likely not to be able to do the necessary operation on
-# the target architecturea. Alternatively one could check compatibility
-# between host/target.
-EXCLUDE_FROM_SHLIBS_${RUSTLIB_TARGET_PN} = "1"
-
-DEBUG_PREFIX_MAP = "-fdebug-prefix-map=${WORKDIR}=/usr/src/debug/${PN}/${EXTENDPE}${PV}-${PR} \
-                    -fdebug-prefix-map=${STAGING_DIR_HOST}= \
-                    -fdebug-prefix-map=${STAGING_DIR_NATIVE}= \
-                    "
-
-LLVM_TARGET[x86_64] = "${RUST_HOST_SYS}"
-python do_rust_gen_targets () {
-    wd = d.getVar('WORKDIR') + '/targets/'
-    rust_gen_target(d, 'TARGET', wd, d.getVar('TARGET_LLVM_FEATURES') or "", d.getVar('TARGET_LLVM_CPU'), d.getVar('TARGET_ARCH'))
-    rust_gen_target(d, 'HOST', wd, "", "generic", d.getVar('HOST_ARCH'))
-    rust_gen_target(d, 'BUILD', wd, "", "generic", d.getVar('BUILD_ARCH'))
-}
-
-INHIBIT_DEFAULT_RUST_DEPS = "1"
-
-export WRAPPER_TARGET_CC = "${CCACHE}${TARGET_PREFIX}gcc --sysroot=${STAGING_DIR_TARGET} ${TARGET_CC_ARCH} ${SECURITY_NOPIE_CFLAGS}"
-export WRAPPER_TARGET_CXX = "${CCACHE}${TARGET_PREFIX}g++ --sysroot=${STAGING_DIR_TARGET} ${TARGET_CC_ARCH} ${SECURITY_NOPIE_CFLAGS}"
-export WRAPPER_TARGET_CCLD = "${TARGET_PREFIX}gcc --sysroot=${STAGING_DIR_TARGET} ${TARGET_CC_ARCH} ${SECURITY_NOPIE_CFLAGS}"
-export WRAPPER_TARGET_LDFLAGS = "${TARGET_LDFLAGS}"
-export WRAPPER_TARGET_AR = "${TARGET_PREFIX}ar"
-
-python do_configure:prepend() {
-    targets = [d.getVar("TARGET_SYS", True), "{}-unknown-linux-gnu".format(d.getVar("HOST_ARCH", True))]
-    hosts = ["{}-unknown-linux-gnu".format(d.getVar("HOST_ARCH", True))]
-}
-
-INSANE_SKIP:${RUSTLIB_TARGET_PN} = "file-rdeps arch ldflags"
-SKIP_FILEDEPS:${RUSTLIB_TARGET_PN} = "1"
-
-INHIBIT_PACKAGE_DEBUG_SPLIT = "1"
-INHIBIT_PACKAGE_STRIP = "1"
-INHIBIT_SYSROOT_STRIP = "1"
-

recipes-devtools/rust/rust-cross-canadian.inc

@@ -1,78 +0,0 @@
-
-require rust-cross-canadian-common.inc
-
-RUSTLIB_TARGET_PN = "rust-cross-canadian-rustlib-target-${TRANSLATED_TARGET_ARCH}"
-RUSTLIB_HOST_PN = "rust-cross-canadian-rustlib-host-${TRANSLATED_TARGET_ARCH}"
-RUSTLIB_SRC_PN = "rust-cross-canadian-src"
-RUSTLIB_PKGS = "${RUSTLIB_SRC_PN} ${RUSTLIB_TARGET_PN} ${RUSTLIB_HOST_PN}"
-PN = "rust-cross-canadian-${TRANSLATED_TARGET_ARCH}"
-
-PACKAGES = "${RUSTLIB_PKGS} ${PN}"
-RDEPENDS:${PN} += "${RUSTLIB_PKGS}"
-
-# The default behaviour of x.py changed in 1.47+ so now we need to
-# explicitly ask for the stage 2 compiler to be assembled.
-do_compile () {
-    rust_runx build --stage 2
-}
-
-do_install () {
-    # Rust requires /usr/lib to contain the libs.
-    # Similar story is with /usr/bin ruquiring  `lib` to be at the same level.
-    # The required structure is retained for simplicity.
-    SYS_LIBDIR=$(dirname ${D}${libdir})
-    SYS_BINDIR=$(dirname ${D}${bindir})
-    RUSTLIB_DIR=${SYS_LIBDIR}/${TARGET_SYS}/rustlib
-
-    install -d "${SYS_BINDIR}"
-    cp build/${SNAPSHOT_BUILD_SYS}/stage2/bin/* ${SYS_BINDIR}
-    for i in ${SYS_BINDIR}/*; do
-	chrpath -r "\$ORIGIN/../lib" ${i}
-    done
-
-    install -d "${D}${libdir}"
-    cp -pRd build/${SNAPSHOT_BUILD_SYS}/stage2/lib/${TARGET_SYS}/*.so ${SYS_LIBDIR}
-    cp -pRd build/${SNAPSHOT_BUILD_SYS}/stage2/lib/${TARGET_SYS}/rustlib ${RUSTLIB_DIR}
-
-    for i in ${SYS_LIBDIR}/*.so; do
-	chrpath -r "\$ORIGIN/../lib" ${i}
-    done
-    for i in ${RUSTLIB_DIR}/*/lib/*.so; do
-	chrpath -d ${i}
-    done
-
-    install -m 0644 "${WORKDIR}/targets/${TARGET_SYS}.json" "${RUSTLIB_DIR}"
-
-    SRC_DIR=${RUSTLIB_DIR}/src/rust
-    install -d ${SRC_DIR}/src/llvm-project
-    cp -R --no-dereference build/${SNAPSHOT_BUILD_SYS}/stage2/lib/rustlib/src/rust/src/llvm-project/libunwind ${SRC_DIR}/src/llvm-project
-    cp -R --no-dereference build/${SNAPSHOT_BUILD_SYS}/stage2/lib/rustlib/src/rust/library ${SRC_DIR}
-    cp --no-dereference build/${SNAPSHOT_BUILD_SYS}/stage2/lib/rustlib/src/rust/Cargo.lock ${SRC_DIR}
-    # Remove executable bit from any files so then SDK doesn't try to relocate.
-    chmod -R -x+X ${SRC_DIR}
-
-    ENV_SETUP_DIR=${D}${base_prefix}/environment-setup.d
-    mkdir "${ENV_SETUP_DIR}"
-    ENV_SETUP_SH="${ENV_SETUP_DIR}/rust.sh"
-
-    cat <<- EOF > "${ENV_SETUP_SH}"
-	export RUSTFLAGS="--sysroot=\$OECORE_NATIVE_SYSROOT/usr -C link-arg=--sysroot=\$OECORE_TARGET_SYSROOT -L\$OECORE_NATIVE_SYSROOT/usr/lib/${TARGET_SYS}/rustlib/${TARGET_SYS}/lib"
-	export RUST_TARGET_PATH="\$OECORE_NATIVE_SYSROOT/usr/lib/${TARGET_SYS}/rustlib"
-	EOF
-
-    chown -R root.root ${D}
-}
-
-PKG_SYS_LIBDIR = "${SDKPATHNATIVE}/usr/lib"
-PKG_SYS_BINDIR = "${SDKPATHNATIVE}/usr/bin"
-PKG_RUSTLIB_DIR = "${PKG_SYS_LIBDIR}/${TARGET_SYS}/rustlib"
-FILES:${PN} = "${PKG_SYS_LIBDIR}/*.so ${PKG_SYS_BINDIR} ${base_prefix}/environment-setup.d"
-FILES:${RUSTLIB_TARGET_PN} = "${PKG_RUSTLIB_DIR}/${TARGET_SYS} ${PKG_RUSTLIB_DIR}/${TARGET_SYS}.json"
-FILES:${RUSTLIB_HOST_PN} = "${PKG_RUSTLIB_DIR}/${BUILD_ARCH}-unknown-linux-gnu"
-FILES:${RUSTLIB_SRC_PN} = "${PKG_RUSTLIB_DIR}/src"
-
-SUMMARY:${RUSTLIB_TARGET_PN} = "Rust cross canadian libaries for ${TARGET_SYS}"
-SUMMARY:${RUSTLIB_HOST_PN} = "Rust cross canadian libaries for ${HOST_SYS}"
-SUMMARY:${RUSTLIB_SRC_PN} = "Rust standard library sources for cross canadian toolchain"
-SUMMARY:${PN} = "Rust crost canadian compiler"
-

recipes-devtools/rust/rust-cross-canadian_1.61.0.bb

@@ -1,6 +0,0 @@
-require rust-cross-canadian.inc
-require rust-source-${PV}.inc
-require rust-snapshot-${PV}.inc
-
-FILESEXTRAPATHS:prepend := "${THISDIR}/rust:"
-

recipes-devtools/rust/rust-cross-canadian_1.64.0.bb

@@ -1,6 +0,0 @@
-require rust-cross-canadian.inc
-require rust-source-${PV}.inc
-require rust-snapshot-${PV}.inc
-
-FILESEXTRAPATHS:prepend := "${THISDIR}/rust:"
-

recipes-devtools/rust/rust-cross.inc

@@ -1,27 +1,6 @@
 require rust.inc
 inherit cross
 
-python do_rust_gen_targets () {
-    wd = d.getVar('WORKDIR') + '/targets/'
-    # It is important 'TARGET' is last here so that it overrides our less
-    # informed choices for BUILD & HOST if TARGET happens to be the same as
-    # either of them.
-    for thing in ['BUILD', 'HOST', 'TARGET']:
-        bb.debug(1, "rust_gen_target for " + thing)
-        features = ""
-        cpu = "generic"
-        arch = d.getVar('{}_ARCH'.format(thing))
-        abi = ""
-        if thing is "TARGET":
-            abi = d.getVar('ABIEXTENSION')
-            # arm and armv7 have different targets in llvm
-            if arch == "arm" and target_is_armv7(d):
-                arch = 'armv7'
-            features = d.getVar('TARGET_LLVM_FEATURES') or ""
-            cpu = d.getVar('TARGET_LLVM_CPU')
-        rust_gen_target(d, thing, wd, features, cpu, arch, abi)
-}
-
 # Otherwise we'll depend on what we provide
 INHIBIT_DEFAULT_RUST_DEPS = "1"
 
@@ -34,7 +13,7 @@ DEPENDS += "virtual/${TARGET_PREFIX}gcc virtual/${TARGET_PREFIX}compilerlibs vir
 DEPENDS += "rust-native"
 
 PROVIDES = "virtual/${TARGET_PREFIX}rust"
-PN = "rust-cross-${TUNE_PKGARCH}-${TCLIBC}"
+PN = "rust-cross-${TARGET_ARCH}"
 
 # In the cross compilation case, rustc doesn't seem to get the rpath quite
 # right. It manages to include '../../lib/${TARGET_PREFIX}', but doesn't
@@ -47,14 +26,11 @@ PN = "rust-cross-${TUNE_PKGARCH}-${TCLIBC}"
 # FIXME: this should really be fixed in rust itself.
 # FIXME: using hard-coded relative paths is wrong, we should ask bitbake for
 #        the relative path between 2 of it's vars.
-HOST_POST_LINK_ARGS:append = " -Wl,-rpath=../../lib"
-BUILD_POST_LINK_ARGS:append = " -Wl,-rpath=../../lib"
+HOST_POST_LINK_ARGS_append = " -Wl,-rpath=../../lib"
+BUILD_POST_LINK_ARGS_append = " -Wl,-rpath=../../lib"
 
 # We need the same thing for the calls to the compiler when building the runtime crap
-TARGET_CC_ARCH:append = " --sysroot=${STAGING_DIR_TARGET}"
-
-do_rust_setup_snapshot () {
-}
+TARGET_CC_ARCH_append = " --sysroot=${STAGING_DIR_TARGET}"
 
 do_configure () {
 }

recipes-devtools/rust/rust-llvm.inc

@@ -1,72 +1,115 @@
 SUMMARY = "LLVM compiler framework (packaged with rust)"
-LICENSE ?= "Apache-2.0-with-LLVM-exception"
-HOMEPAGE = "http://www.rust-lang.org"
+LICENSE = "NCSA"
 
-SRC_URI += "file://0002-llvm-allow-env-override-of-exe-path.patch;striplevel=2 \
-            file://0001-AsmMatcherEmitter-sort-ClassInfo-lists-by-name-as-we.patch;striplevel=2 \
-            file://0003-llvm-fix-include-benchmarks.patch;striplevel=2 \
-            "
+S = "${RUSTSRC}/src/llvm"
 
-S = "${RUSTSRC}/src/llvm-project/llvm"
+LIC_FILES_CHKSUM = "file://LICENSE.TXT;md5=b99eb43c934ceebecab85c6b9b1a08be"
 
-LIC_FILES_CHKSUM = "file://LICENSE.TXT;md5=8a15a0759ef07f2682d2ba4b893c9afe"
-
-inherit cmake python3native
-
-DEPENDS += "ninja-native rust-llvm-native"
-
-ARM_INSTRUCTION_SET:armv5 = "arm"
-ARM_INSTRUCTION_SET:armv4t = "arm"
-
-# rustc_llvm with debug info is not recognized as a valid crate that's
-# generated by rust-llvm-native.
-CFLAGS:remove = "-g"
-CXXFLAGS:remove = "-g"
-
-LLVM_DIR = "llvm${LLVM_RELEASE}"
+inherit cmake pythonnative
 
 EXTRA_OECMAKE = " \
-    -DCMAKE_BUILD_TYPE=Release \
-    -DLLVM_TARGETS_TO_BUILD='ARM;AArch64;Mips;PowerPC;RISCV;X86' \
+    -DLLVM_TARGETS_TO_BUILD='X86;ARM;AArch64;PowerPC' \
+    -DLLVM_ENABLE_ASSERTIONS=OFF \
     -DLLVM_BUILD_DOCS=OFF \
     -DLLVM_ENABLE_TERMINFO=OFF \
     -DLLVM_ENABLE_ZLIB=OFF \
-    -DLLVM_ENABLE_LIBXML2=OFF \
     -DLLVM_ENABLE_FFI=OFF \
     -DLLVM_INSTALL_UTILS=ON \
+    -DLLVM_BUILD_TOOLS=ON \
     -DLLVM_BUILD_EXAMPLES=OFF \
     -DLLVM_INCLUDE_EXAMPLES=OFF \
     -DLLVM_BUILD_TESTS=OFF \
     -DLLVM_INCLUDE_TESTS=OFF \
     -DLLVM_TARGET_ARCH=${TARGET_ARCH} \
-    -DCMAKE_INSTALL_PREFIX:PATH=${libdir}/llvm-rust \
-"
-EXTRA_OECMAKE:append:class-target = "\
-    -DCMAKE_CROSSCOMPILING:BOOL=ON \
-    -DLLVM_BUILD_TOOLS=OFF \
-    -DLLVM_TABLEGEN=${STAGING_LIBDIR_NATIVE}/llvm-rust/bin/llvm-tblgen \
-    -DLLVM_CONFIG_PATH=${STAGING_LIBDIR_NATIVE}/llvm-rust/bin/llvm-config \
 "
 
 # The debug symbols are huge here (>2GB) so suppress them since they
 # provide almost no value. If you really need them then override this
 INHIBIT_PACKAGE_DEBUG_SPLIT = "1"
 
-export YOCTO_ALTERNATE_EXE_PATH = "${STAGING_LIBDIR}/llvm-rust/bin/llvm-config"
+EXTRA_OECMAKE_append_class-target = "\
+  -DCROSS_TOOLCHAIN_FLAGS_NATIVE='-DCMAKE_TOOLCHAIN_FILE=${WORKDIR}/native_toolchain.cmake' \
+"
 
-do_install:append () {
-    # we don't need any of this stuff to build Rust
-    rm -rf "${D}/usr/lib/cmake"
+do_generate_native_toolchain_file() {
+        cat > ${WORKDIR}/native_toolchain.cmake <<EOF
+set( CMAKE_SYSTEM_NAME `echo ${BUILD_OS} | sed -e 's/^./\u&/' -e 's/^\(Linux\).*/\1/'` )
+set( CMAKE_SYSTEM_PROCESSOR ${BUILD_ARCH} )
+set( CMAKE_C_COMPILER ${BUILD_CC} )
+set( CMAKE_CXX_COMPILER ${BUILD_CXX} )
+set( CMAKE_ASM_COMPILER ${BUILD_AS} )
+set( CMAKE_AR ${BUILD_AR} CACHE FILEPATH "Archiver" )
+set( CMAKE_C_FLAGS "${BUILD_CC_ARCH} ${BUILD_CFLAGS}" CACHE STRING "CFLAGS" )
+set( CMAKE_CXX_FLAGS "${BUILD_CC_ARCH} ${BUILD_CXXFLAGS}" CACHE STRING "CXXFLAGS" )
+set( CMAKE_ASM_FLAGS "${BUILD_CC_ARCH} ${BUILD_CFLAGS}" CACHE STRING "ASM FLAGS" )
+set( CMAKE_C_FLAGS_RELEASE "${SELECTED_OPTIMIZATION} ${BUILD_CFLAGS} -DNDEBUG" CACHE STRING "CFLAGS for release" )
+set( CMAKE_CXX_FLAGS_RELEASE "${SELECTED_OPTIMIZATION} ${BUILD_CXXFLAGS} -DNDEBUG" CACHE STRING "CXXFLAGS for release" )
+set( CMAKE_ASM_FLAGS_RELEASE "${SELECTED_OPTIMIZATION} ${BUILD_CFLAGS} -DNDEBUG" CACHE STRING "ASM FLAGS for release" )
+set( CMAKE_C_LINK_FLAGS "${BUILD_CC_ARCH} ${BUILD_CPPFLAGS} ${BUILD_LDFLAGS}" CACHE STRING "LDFLAGS" )
+set( CMAKE_CXX_LINK_FLAGS "${BUILD_CC_ARCH} ${BUILD_CXXFLAGS} ${BUILD_LDFLAGS}" CACHE STRING "LDFLAGS" )
+
+# only search in the paths provided so cmake doesnt pick
+# up libraries and tools from the native build machine
+set( CMAKE_FIND_ROOT_PATH ${STAGING_DIR_HOST} ${STAGING_DIR_NATIVE} ${CROSS_DIR} ${OECMAKE_PERLNATIVE_DIR} ${OECMAKE_EXTRA_ROOT_PATH} ${EXTERNAL_TOOLCHAIN})
+set( CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY )
+set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY )
+set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY )
+
+# Use native cmake modules
+set( CMAKE_MODULE_PATH ${STAGING_DATADIR}/cmake/Modules/ )
+
+# add for non /usr/lib libdir, e.g. /usr/lib64
+set( CMAKE_LIBRARY_PATH ${libdir} ${base_libdir})
+
+EOF
+}
+
+addtask generate_native_toolchain_file after do_patch before do_configure
+
+do_configure_prepend_class-native() {
+    # Use host paths for native tools
+    sed -i -e '/CMAKE_FIND_ROOT_PATH_MODE/d' ${WORKDIR}/toolchain.cmake
+}
+
+do_compile_prepend_class-target() {
+    # Fix paths in llvm-config
+    sed -i "s|sys::path::parent_path(CurrentPath))\.str()|sys::path::parent_path(sys::path::parent_path(CurrentPath))).str()|g" ${S}/tools/llvm-config/llvm-config.cpp
+
+    # Fix the hardcoded libdir in llvm-config
+    sed -i 's:/lib\>:/${baselib}:g' ${S}/tools/llvm-config/llvm-config.cpp
+}
+
+do_compile() {
+    oe_runmake NATIVE_LIB_LLVMTABLEGEN
+    oe_runmake NativeLLVMConfig
+    oe_runmake
+}
+
+do_install_append_class-target() {
+    # Disable checks on the native tools, since these should came from the native recipe
+    sed -i -e 's/\(.*APPEND.*_IMPORT_CHECK_FILES_FOR_.*{_IMPORT_PREFIX}\/bin\/.*\)/#\1/' ${D}/usr/share/llvm/cmake/LLVMExports-noconfig.cmake
+}
+
+SYSROOT_PREPROCESS_FUNCS_append_class-target = " llvm_sysroot_preprocess"
+SYSROOT_PREPROCESS_FUNCS_append_class-native = " llvm_native_sysroot_preprocess"
+
+llvm_sysroot_preprocess() {
+    install -d ${SYSROOT_DESTDIR}${bindir}
+    cp ${B}/NATIVE/bin/llvm-config ${SYSROOT_DESTDIR}/${bindir} || bbfatal "missing llvm-config"
+    cp ${B}/NATIVE/bin/llvm-tblgen ${SYSROOT_DESTDIR}/${bindir} || bbfatal "missing llvm-tblgen"
+}
+
+llvm_native_sysroot_preprocess() {
+    sysroot_stage_dir ${D}${STAGING_DIR_NATIVE}/usr/libexec ${SYSROOT_DESTDIR}${bindir}
 }
 
 PACKAGES =+ "${PN}-bugpointpasses ${PN}-llvmhello ${PN}-liblto"
 
 # Add the extra locations to avoid the complaints about unpackaged files
-FILES:${PN}-bugpointpasses = "${libdir}/llvm-rust/lib/BugpointPasses.so"
-FILES:${PN}-llvmhello = "${libdir}/llvm-rust/lib/LLVMHello.so"
-FILES:${PN}-liblto = "${libdir}/llvm-rust/lib/libLTO.so.*"
-FILES:${PN}-staticdev =+ "${libdir}/llvm-rust/*/*.a"
-FILES:${PN} += "${libdir}/libLLVM*.so.* ${libdir}/llvm-rust/lib/*.so.* ${libdir}/llvm-rust/bin"
-FILES:${PN}-dev += "${datadir}/llvm ${libdir}/llvm-rust/lib/*.so ${libdir}/llvm-rust/include ${libdir}/llvm-rust/share ${libdir}/llvm-rust/lib/cmake"
+FILES_${PN} += "${libdir}/libLLVM*.so"
+FILES_${PN}-dev += "${datadir}/llvm"
+FILES_${PN}-bugpointpasses = "${libdir}/BugpointPasses.so"
+FILES_${PN}-llvmhello = "${libdir}/LLVMHello.so"
+FILES_${PN}-liblto = "${libdir}/libLTO.so"
 
 BBCLASSEXTEND = "native"

recipes-devtools/rust/rust-llvm/0001-AsmMatcherEmitter-sort-ClassInfo-lists-by-name-as-we.patch

@@ -1,31 +0,0 @@
-From 86940d87026432683fb6741cd8a34d3b9b18e40d Mon Sep 17 00:00:00 2001
-From: Alexander Kanavin <alex.kanavin@gmail.com>
-Date: Fri, 27 Nov 2020 10:11:08 +0000
-Subject: [PATCH] AsmMatcherEmitter: sort ClassInfo lists by name as well
-
-Otherwise, there are instances which are identical in
-every other field and therefore sort non-reproducibly
-(which breaks binary and source reproducibiliy).
-
-Upstream-Status: Submitted [https://reviews.llvm.org/D97477]
-Signed-off-by: Alexander Kanavin <alex.kanavin@gmail.com>
----
- llvm/utils/TableGen/AsmMatcherEmitter.cpp | 5 ++++-
- 1 file changed, 4 insertions(+), 1 deletion(-)
-
-diff --git a/llvm/utils/TableGen/AsmMatcherEmitter.cpp b/llvm/utils/TableGen/AsmMatcherEmitter.cpp
-index ccf0959389b..1f801e83b7d 100644
---- a/llvm/utils/TableGen/AsmMatcherEmitter.cpp
-+++ b/llvm/utils/TableGen/AsmMatcherEmitter.cpp
-@@ -359,7 +359,10 @@ public:
-     // name of a class shouldn't be significant. However, some of the backends
-     // accidentally rely on this behaviour, so it will have to stay like this
-     // until they are fixed.
--    return ValueName < RHS.ValueName;
-+    if (ValueName != RHS.ValueName)
-+        return ValueName < RHS.ValueName;
-+    // All else being equal, we should sort by name, for source and binary reproducibility
-+    return Name < RHS.Name;
-   }
- };
- 

recipes-devtools/rust/rust-llvm/0002-llvm-allow-env-override-of-exe-path.patch

@@ -1,33 +0,0 @@
-From 7111770e8290082530d920e120995bf81431b0aa Mon Sep 17 00:00:00 2001
-From: Martin Kelly <mkelly@xevo.com>
-Date: Fri, 19 May 2017 00:22:57 -0700
-Subject: [PATCH 12/18] llvm: allow env override of exe path
-
-When using a native llvm-config from inside a sysroot, we need llvm-config to
-return the libraries, include directories, etc. from inside the sysroot rather
-than from the native sysroot. Thus provide an env override for calling
-llvm-config from a target sysroot.
-
-Upstream-Status: Inappropriate [oe-core specific]
-Signed-off-by: Martin Kelly <mkelly@xevo.com>
-Signed-off-by: Khem Raj <raj.khem@gmail.com>
----
- llvm/tools/llvm-config/llvm-config.cpp | 7 +++++++
- 1 file changed, 7 insertions(+)
-
---- a/llvm/tools/llvm-config/llvm-config.cpp
-+++ b/llvm/tools/llvm-config/llvm-config.cpp
-@@ -226,6 +226,13 @@ Typical components:\n\
- 
- /// Compute the path to the main executable.
- std::string GetExecutablePath(const char *Argv0) {
-+  // Hack for Yocto: we need to override the root path when we are using
-+  // llvm-config from within a target sysroot.
-+  const char *Sysroot = std::getenv("YOCTO_ALTERNATE_EXE_PATH");
-+  if (Sysroot != nullptr) {
-+    return Sysroot;
-+  }
-+
-   // This just needs to be some symbol in the binary; C++ doesn't
-   // allow taking the address of ::main however.
-   void *P = (void *)(intptr_t)GetExecutablePath;

recipes-devtools/rust/rust-llvm/0003-llvm-fix-include-benchmarks.patch

@@ -1,25 +0,0 @@
-Subject: LLVM_INCLUDE_BENCHMARKS with llvm 14.0.1 failing to build
-
-https://github.com/llvm/llvm-project/issues/54941
-
-The LLVM_INCLUDE_BENCHMARKS is turned OFF to fix the build error as
-per the discussions in the above link. We will work on the issue and
-replace the workaround with actual fix once committed in LLVM.
-
-Please refer the following link for more discussions on the issue:-
-https://github.com/rust-lang/rust/issues/96054
-
-Upstream-Status: Pending
-Signed-off-by: Pgowda <pgowda.cve@gmail.com>
-
---- a/llvm/CMakeLists.txt	2022-04-22 00:45:30.543445478 -0700
-+++ b/llvm/CMakeLists.txt	2022-04-22 00:45:42.095232974 -0700
-@@ -615,7 +615,7 @@ option(LLVM_INCLUDE_GO_TESTS "Include th
- 
- option(LLVM_BUILD_BENCHMARKS "Add LLVM benchmark targets to the list of default
- targets. If OFF, benchmarks still could be built using Benchmarks target." OFF)
--option(LLVM_INCLUDE_BENCHMARKS "Generate benchmark targets. If OFF, benchmarks can't be built." ON)
-+option(LLVM_INCLUDE_BENCHMARKS "Generate benchmark targets. If OFF, benchmarks can't be built." OFF)
- 
- option (LLVM_BUILD_DOCS "Build the llvm documentation." OFF)
- option (LLVM_INCLUDE_DOCS "Generate build targets for llvm documentation." ON)

recipes-devtools/rust/rust-llvm_1.12.1.bb

@@ -0,0 +1,16 @@
+require rust-source-${PV}.inc
+require rust-llvm.inc
+
+LIC_FILES_CHKSUM = "file://LICENSE.TXT;md5=43fdaa303c1c5589ad60f4ffc6a0b9ce"
+
+do_install_prepend () {
+	# the install does a sed on this without installing the file
+	# we don't need it for anything
+	mkdir -p "${D}/usr/share/llvm/cmake"
+	touch "${D}/usr/share/llvm/cmake/LLVMExports-noconfig.cmake"
+}
+
+do_install_append () {
+	# we don't need any of this stuff to build Rust
+	rm -rf "${D}/usr/lib/cmake"
+}

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

@@ -0,0 +1,14 @@
+require rust-source-${PV}.inc
+require rust-llvm.inc
+
+do_install_prepend () {
+	# the install does a sed on this without installing the file
+	# we don't need it for anything
+	mkdir -p "${D}/usr/share/llvm/cmake"
+	touch "${D}/usr/share/llvm/cmake/LLVMExports-noconfig.cmake"
+}
+
+do_install_append () {
+	# we don't need any of this stuff to build Rust
+	rm -rf "${D}/usr/lib/cmake"
+}

recipes-devtools/rust/rust-llvm_1.61.0.bb

@@ -1,5 +0,0 @@
-# check src/llvm-project/llvm/CMakeLists.txt for llvm version in use
-#
-LLVM_RELEASE = "14.0.0"
-require rust-source-${PV}.inc
-require rust-llvm.inc

recipes-devtools/rust/rust-llvm_1.64.0.bb

@@ -1,5 +0,0 @@
-# check src/llvm-project/llvm/CMakeLists.txt for llvm version in use
-#
-LLVM_RELEASE = "14.0.6"
-require rust-source-${PV}.inc
-require rust-llvm.inc

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

@@ -1,25 +0,0 @@
-## 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.60.0"
-CARGO_VERSION = "1.60.0"
-
-# TODO: Add hashes for other architecture toolchains as well. Make a script?
-SRC_URI[rust-std-snapshot-x86_64.sha256sum] = "6fb8ee3650beb10836ae48a9aaa535473e64eaca20695b88113267aea3c7557f"
-SRC_URI[rustc-snapshot-x86_64.sha256sum] = "fc0b41c15e348ad0eeb7a6c015a922a2ac95e9577e531635558b26d99399f315"
-SRC_URI[cargo-snapshot-x86_64.sha256sum] = "48edb2eb51d7c56ef9a3130f0b331e83f139559161f6f93b9588d28cf72610f3"
-
-SRC_URI[rust-std-snapshot-aarch64.sha256sum] = "fbc39c2ba2eee9bad7305d73d02a63ada651961be8fd9e0dae520bda5d715c6e"
-SRC_URI[rustc-snapshot-aarch64.sha256sum] = "f5b24f2bc30db4b8efb7eba7db86fd5db0bc283631b4c918794e9217fca32822"
-SRC_URI[cargo-snapshot-aarch64.sha256sum] = "36030f5cede7971eaed45284b5243b4103184a663ad934124de8a530e0e6d993"
-
-SRC_URI += " \
-    https://static.rust-lang.org/dist/${RUST_STD_SNAPSHOT}.tar.xz;name=rust-std-snapshot-${BUILD_ARCH};subdir=rust-snapshot-components \
-    https://static.rust-lang.org/dist/${RUSTC_SNAPSHOT}.tar.xz;name=rustc-snapshot-${BUILD_ARCH};subdir=rust-snapshot-components \
-    https://static.rust-lang.org/dist/${CARGO_SNAPSHOT}.tar.xz;name=cargo-snapshot-${BUILD_ARCH};subdir=rust-snapshot-components \
-"
-
-RUST_STD_SNAPSHOT = "rust-std-${RS_VERSION}-${BUILD_ARCH}-unknown-linux-gnu"
-RUSTC_SNAPSHOT = "rustc-${RS_VERSION}-${BUILD_ARCH}-unknown-linux-gnu"
-CARGO_SNAPSHOT = "cargo-${CARGO_VERSION}-${BUILD_ARCH}-unknown-linux-gnu"

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

@@ -1,25 +0,0 @@
-## This is information on the rust-snapshot (binary) used to build our current release.
-## snapshot info is taken from rust/src/stage0.json
-## TODO: find a way to add additional SRC_URIs based on the contents of an
-##       earlier SRC_URI.
-RS_VERSION = "1.63.0"
-CARGO_VERSION = "1.63.0"
-
-# TODO: Add hashes for other architecture toolchains as well. Make a script?
-SRC_URI[rust-std-snapshot-x86_64.sha256sum] = "993c2c17bf76ac626bfb5b17bddce65fbdfc14f70d183f33773de0cd12df46d2"
-SRC_URI[rustc-snapshot-x86_64.sha256sum] = "bdab9d9afa5c329c40f9ba568364815237fab8426477c12bfabad35ffc484ab5"
-SRC_URI[cargo-snapshot-x86_64.sha256sum] = "f370d12e4c11f0c835becb738bcf00d363f29b76f8b424b4dcb005abcf15fc9a"
-
-SRC_URI[rust-std-snapshot-aarch64.sha256sum] = "f1d93b3d48258f701687c63ef9b226c07329fb92c2c5559283258687f958e9d0"
-SRC_URI[rustc-snapshot-aarch64.sha256sum] = "d78799bb8f4177877f97b9051c9cba1fd85173f2e9cecab9486388fc6fa66259"
-SRC_URI[cargo-snapshot-aarch64.sha256sum] = "4313ab44dccba4faed20db4aacc16def405773d1676e79d3e65ced4b99d710d4"
-
-SRC_URI += " \
-    https://static.rust-lang.org/dist/${RUST_STD_SNAPSHOT}.tar.xz;name=rust-std-snapshot-${BUILD_ARCH};subdir=rust-snapshot-components \
-    https://static.rust-lang.org/dist/${RUSTC_SNAPSHOT}.tar.xz;name=rustc-snapshot-${BUILD_ARCH};subdir=rust-snapshot-components \
-    https://static.rust-lang.org/dist/${CARGO_SNAPSHOT}.tar.xz;name=cargo-snapshot-${BUILD_ARCH};subdir=rust-snapshot-components \
-"
-
-RUST_STD_SNAPSHOT = "rust-std-${RS_VERSION}-${BUILD_ARCH}-unknown-linux-gnu"
-RUSTC_SNAPSHOT = "rustc-${RS_VERSION}-${BUILD_ARCH}-unknown-linux-gnu"
-CARGO_SNAPSHOT = "cargo-${CARGO_VERSION}-${BUILD_ARCH}-unknown-linux-gnu"

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

@@ -0,0 +1,25 @@
+# Specifics for Rust 1.12.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.11.0"
+RS_KEY = "5c6cf767"
+
+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] = "b83d7a1a90c2d80bef97a518022948c8"
+SRC_URI[rust-snapshot.sha256sum] = "e9d27a72900da33c1bbd0e59dd42fd6414c6bcdfa33593fb7c7360068406394a"
+
+SRC_URI += "\
+	https://static.rust-lang.org/dist/rustc-${PV}-src.tar.gz;name=rust \
+    "
+SRC_URI[rust.md5sum] = "82db5a9cb9a051bf8ece2f5174cb273b"
+SRC_URI[rust.sha256sum] = "97913ae4cb255618aaacd1a534b11f343634b040b32656250d09d8d9ec02d3dc"
+
+# later versions of rust change the directory that they unextract to
+RUSTSRC = "${WORKDIR}/rustc-${PV}"
+# set this as our default
+S = "${RUSTSRC}"

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

@@ -0,0 +1,24 @@
+# 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 \
+    "
+SRC_URI[rust.md5sum] = "5bbfff5ef8857a73d120616546a7fd29"
+SRC_URI[rust.sha256sum] = "2e7daad418a830b45b977cd7ecf181b65f30f73df63ff36e124ea5fe5d1af327"
+
+# later versions of rust change the directory that they unextract to
+RUSTSRC = "${WORKDIR}/rustc-${PV}-src"
+# set this as our default
+S = "${RUSTSRC}"

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

@@ -1,7 +0,0 @@
-SRC_URI += "https://static.rust-lang.org/dist/rustc-${PV}-src.tar.xz;name=rust"
-SRC_URI[rust.sha256sum] = "a63305a3ad734f170746b337a5e3d07ccaa7aa8f253dc52336b44c0a3b549d7b"
-
-RUSTSRC = "${WORKDIR}/rustc-${PV}-src"
-
-UPSTREAM_CHECK_URI = "https://forge.rust-lang.org/infra/other-installation-methods.html"
-UPSTREAM_CHECK_REGEX = "rustc-(?P<pver>\d+(\.\d+)+)-src"

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

@@ -1,7 +0,0 @@
-SRC_URI += "https://static.rust-lang.org/dist/rustc-${PV}-src.tar.xz;name=rust"
-SRC_URI[rust.sha256sum] = "e8170d318fac9d2fc17d5c3e648e7068f56e8db8d233d864aeffbef7c6542eac"
-
-RUSTSRC = "${WORKDIR}/rustc-${PV}-src"
-
-UPSTREAM_CHECK_URI = "https://forge.rust-lang.org/infra/other-installation-methods.html"
-UPSTREAM_CHECK_REGEX = "rustc-(?P<pver>\d+(\.\d+)+)-src"

recipes-devtools/rust/rust-target.inc

@@ -1,10 +0,0 @@
-require rust.inc
-
-DEPENDS += "rust-llvm (=${PV})"
-
-# Otherwise we'll depend on what we provide
-INHIBIT_DEFAULT_RUST_DEPS:class-native = "1"
-# We don't need to depend on gcc-native because yocto assumes it exists
-PROVIDES:class-native = "virtual/${TARGET_PREFIX}rust"
-
-BBCLASSEXTEND = "native"

recipes-devtools/rust/rust-tools-cross-canadian.inc

@@ -1,38 +0,0 @@
-
-require rust-cross-canadian-common.inc
-
-RUST_TOOLS_CLIPPY_PN = "rust-tools-clippy-cross-canadian-${TRANSLATED_TARGET_ARCH}"
-RUST_TOOLS_RUSTFMT_PN = "rust-tools-rustfmt-cross-canadian-${TRANSLATED_TARGET_ARCH}"
-RUST_TOOLS_PKGS = "${RUST_TOOLS_CLIPPY_PN} ${RUST_TOOLS_RUSTFMT_PN}"
-PN = "rust-tools-cross-canadian-${TRANSLATED_TARGET_ARCH}"
-
-PACKAGES = "${RUST_TOOLS_CLIPPY_PN} ${RUST_TOOLS_RUSTFMT_PN} ${PN}"
-RDEPENDS:${PN} += "${RUST_TOOLS_PKGS}"
-
-do_compile () {
-    rust_runx build --stage 2 src/tools/clippy
-    rust_runx build --stage 2 src/tools/rustfmt
-}
-
-do_install () {
-    SYS_BINDIR=$(dirname ${D}${bindir})
-
-    install -d "${SYS_BINDIR}"
-    cp build/${SNAPSHOT_BUILD_SYS}/stage2-tools-bin/* ${SYS_BINDIR}
-    for i in ${SYS_BINDIR}/*; do
-	chrpath -r "\$ORIGIN/../lib" ${i}
-    done
-
-    chown -R root.root ${D}
-}
-
-ALLOW_EMPTY:${PN} = "1"
-
-PKG_SYS_BINDIR = "${SDKPATHNATIVE}/usr/bin"
-FILES:${RUST_TOOLS_CLIPPY_PN} = "${PKG_SYS_BINDIR}/cargo-clippy ${PKG_SYS_BINDIR}/clippy-driver"
-FILES:${RUST_TOOLS_RUSTFMT_PN} = "${PKG_SYS_BINDIR}/rustfmt"
-
-SUMMARY:${PN} = "Rust helper tools"
-SUMMARY:${RUST_TOOLS_CLIPPY_PN} = "A collection of lints to catch common mistakes and improve your Rust code"
-SUMMARY:${RUST_TOOLS_RUSTFMT_PN} = "A tool for formatting Rust code according to style guidelines"
-

recipes-devtools/rust/rust-tools-cross-canadian_1.61.0.bb

@@ -1,6 +0,0 @@
-require rust-tools-cross-canadian.inc
-require rust-source-${PV}.inc
-require rust-snapshot-${PV}.inc
-
-FILESEXTRAPATHS:prepend := "${THISDIR}/rust:"
-

recipes-devtools/rust/rust-tools-cross-canadian_1.64.0.bb

@@ -1,6 +0,0 @@
-require rust-tools-cross-canadian.inc
-require rust-source-${PV}.inc
-require rust-snapshot-${PV}.inc
-
-FILESEXTRAPATHS:prepend := "${THISDIR}/rust:"
-

recipes-devtools/rust/rust.inc

@@ -2,159 +2,378 @@ SUMMARY = "Rust compiler and runtime libaries"
 HOMEPAGE = "http://www.rust-lang.org"
 SECTION = "devel"
 LICENSE = "MIT | Apache-2.0"
-LIC_FILES_CHKSUM = "file://COPYRIGHT;md5=93a95682d51b4cb0a633a97046940ef0"
+LIC_FILES_CHKSUM ="file://COPYRIGHT;md5=43e1f1fb9c0ee3af66693d8c4fecafa8"
 
 inherit rust
-inherit cargo_common
 
-DEPENDS += "file-native python3-native"
-DEPENDS:append:class-native = " rust-llvm-native"
+SRC_URI = "\
+	https://static.rust-lang.org/dist/${RUST_SNAPSHOT}.tar.gz;name=rust-snapshot \
+    "
 
-S = "${RUSTSRC}"
+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}"
 
-RUST_ALTERNATE_EXE_PATH ?= "${STAGING_LIBDIR}/llvm-rust/bin/llvm-config"
-export YOCTO_ALTERNATE_EXE_PATH = "${RUST_ALTERNATE_EXE_PATH}"
-export YOCTO_ALTERNATE_MULTILIB_NAME = "/${BASELIB}"
+# 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).
+# Note that TUNE_FEATURES is _always_ refering to the target, so we really
+# don't want to use this for the host/build.
+def llvm_features_from_tune(d):
+    f = []
+    feat = d.getVar('TUNE_FEATURES', True)
+    if not feat:
+        return ""
+    feat = frozenset(feat.split())
 
-# We don't want to use bitbakes vendoring because the rust sources do their
-# own vendoring.
-CARGO_DISABLE_BITBAKE_VENDORING = "1"
+    if 'vfpv4' in feat:
+        f.append("+vfp4")
+    if 'vfpv3' in feat:
+        f.append("+vfp3")
+    if 'vfpv3d16' in feat:
+        f.append("+d16")
 
-# We can't use RUST_BUILD_SYS here because that may be "musl" if
-# TCLIBC="musl". Snapshots are always -unknown-linux-gnu
-SNAPSHOT_BUILD_SYS = "${BUILD_ARCH}-unknown-linux-gnu"
-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
+    if 'vfpv2' in feat or 'vfp' in feat:
+        f.append("+vfp2")
 
-    printf '[target.%s]\n' "${SNAPSHOT_BUILD_SYS}" >> ${CARGO_HOME}/config
-    printf "linker = '%s'\n" "${RUST_BUILD_CCLD}" >> ${CARGO_HOME}/config
-}
+    if 'neon' in feat:
+        f.append("+neon")
 
-include rust-common.inc
+    if 'aarch64' in feat:
+        f.append("+v8")
 
-do_rust_setup_snapshot () {
-    for installer in "${WORKDIR}/rust-snapshot-components/"*"/install.sh"; do
-        "${installer}" --prefix="${WORKDIR}/rust-snapshot" --disable-ldconfig
-    done
+    v7=frozenset(['armv7a', 'armv7r', 'armv7m', 'armv7ve'])
+    if not feat.isdisjoint(v7):
+        f.append("+v7")
+    if 'armv6' in feat:
+        f.append("+v6")
 
-    # Some versions of rust (e.g. 1.18.0) tries to find cargo in stage0/bin/cargo
-    # and fail without it there.
-    mkdir -p ${RUSTSRC}/build/${BUILD_SYS}
-    ln -sf ${WORKDIR}/rust-snapshot/ ${RUSTSRC}/build/${BUILD_SYS}/stage0
+    if 'dsp' in feat:
+        f.append("+dsp")
 
-    # Need to use uninative's loader if enabled/present since the library paths
-    # are used internally by rust and result in symbol mismatches if we don't
-    if [ ! -z "${UNINATIVE_LOADER}" -a -e "${UNINATIVE_LOADER}" ]; then
-        for bin in cargo rustc rustdoc; do
-            patchelf-uninative ${WORKDIR}/rust-snapshot/bin/$bin --set-interpreter ${UNINATIVE_LOADER}
-        done
-    fi
-}
-addtask rust_setup_snapshot after do_unpack before do_configure
-do_rust_setup_snapshot[dirs] += "${WORKDIR}/rust-snapshot"
-do_rust_setup_snapshot[vardepsexclude] += "UNINATIVE_LOADER"
+    if d.getVar('ARM_THUMB_OPT', True) is "thumb":
+        if not feat.isdisjoint(v7):
+            f.append("+thumb2")
+        f.append("+thumb-mode")
+
+    if 'cortexa5' in feat:
+        f.append("+a5")
+    if 'cortexa7' in feat:
+        f.append("+a7")
+    if 'cortexa9' in feat:
+        f.append("+a9")
+    if 'cortexa15' in feat:
+        f.append("+a15")
+    if 'cortexa17' in feat:
+        f.append("+a17")
+
+    # Seems like it could be infered by the lack of vfp options, but we'll
+    # include it anyhow
+    if 'soft' in feat:
+        f.append("+soft-float")
+
+    return ','.join(f)
+
+# TARGET_CC_ARCH changes from build/cross/target so it'll do the right thing
+# this should go away when https://github.com/rust-lang/rust/pull/31709 is
+# stable (1.9.0?)
+def llvm_features_from_cc_arch(d):
+    f = []
+    feat = d.getVar('TARGET_CC_ARCH', True)
+    if not feat:
+        return ""
+    feat = frozenset(feat.split())
+
+    if '-mmmx' in feat:
+        f.append("+mmx")
+    if '-msse' in feat:
+        f.append("+sse")
+    if '-msse2' in feat:
+        f.append("+sse2")
+    if '-msse3' in feat:
+        f.append("+sse3")
+    if '-mssse3' in feat:
+        f.append("+ssse3")
+    if '-msse4.1' in feat:
+        f.append("+sse4.1")
+    if '-msse4.2' in feat:
+        f.append("+sse4.2")
+    if '-msse4a' in feat:
+        f.append("+sse4a")
+    if '-mavx' in feat:
+        f.append("+avx")
+    if '-mavx2' in feat:
+        f.append("+avx2")
+
+    return ','.join(f)
+
+## arm-unknown-linux-gnueabihf
+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"
+FEATURES[arm] = "+v6,+vfp2"
+
+## aarch64-unknown-linux-gnu
+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"
+
+## 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"
+
+## 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"
+
+## 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"
+
+def arch_for(d, thing):
+    return d.getVar('{}_ARCH'.format(thing), True)
+
+def sys_for(d, thing):
+    return d.getVar('{}_SYS'.format(thing), True)
+
+def prefix_for(d, thing):
+    return d.getVar('{}_PREFIX'.format(thing), True)
+
+## 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), True) or ""
+    flags = d.getVar('{}_CFLAGS'.format(thing), True) or ""
+    tc = d.getVar('TOOLCHAIN_OPTIONS', True) or ""
+    return ' '.join([cc_arch, flags, tc])
+
+def cxxflags_for(d, thing):
+    cc_arch = d.getVar('{}_CC_ARCH'.format(thing), True) or ""
+    flags = d.getVar('{}_CXXFLAGS'.format(thing), True) or ""
+    tc = d.getVar('TOOLCHAIN_OPTIONS', True) 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):
+    if arch == "i586" or arch == "i686":
+        return "x86"
+    else:
+        return arch
+
+# generates our target CPU value
+def llvm_cpu(d):
+    cpu = d.getVar('PACKAGE_ARCH', True)
+    target = d.getVar('TRANSLATED_TARGET_ARCH', True)
+
+    trans = {}
+    trans['corei7-64'] = "corei7"
+    trans['core2-32'] = "core2"
+    trans['x86-64'] = "x86-64"
+    trans['i686'] = "i686"
+    trans['i586'] = "i586"
 
-python do_configure() {
-    import json
     try:
-        import configparser
-    except ImportError:
-        import ConfigParser as configparser
+        return trans[cpu]
+    except:
+        return trans.get(target, "generic")
 
-    # toml is rather similar to standard ini like format except it likes values
-    # that look more JSON like. So for our purposes simply escaping all values
-    # as JSON seem to work fine.
+TARGET_LLVM_CPU="${@llvm_cpu(d)}"
+TARGET_LLVM_FEATURES = "${@llvm_features_from_tune(d)} ${@llvm_features_from_cc_arch(d)}"
 
-    e = lambda s: json.dumps(s)
+# class-native implies TARGET=HOST, and TUNE_FEATURES only describes the real
+# (original) target.
+TARGET_LLVM_FEATURES_class-native = "${@llvm_features_from_cc_arch(d)}"
 
-    config = configparser.RawConfigParser()
+def rust_gen_target(d, thing, wd):
+    import json
+    arch = arch_for(d, thing)
+    sys = sys_for(d, thing)
+    prefix = prefix_for(d, thing)
 
-    # [target.ARCH-poky-linux]
-    target_section = "target.{}".format(d.getVar('TARGET_SYS', True))
-    config.add_section(target_section)
+    features = ""
+    cpu = "generic"
+    if thing is "TARGET":
+        features = d.getVar('TARGET_LLVM_FEATURES', True) or ""
+        cpu = d.getVar('TARGET_LLVM_CPU', True)
+    features = features or d.getVarFlag('FEATURES', arch, True) or ""
+    features = features.strip()
 
-    llvm_config = d.expand("${YOCTO_ALTERNATE_EXE_PATH}")
-    config.set(target_section, "llvm-config", e(llvm_config))
+    # build tspec
+    tspec = {}
+    tspec['llvm-target'] = d.getVarFlag('LLVM_TARGET', arch, True)
+    tspec['data-layout'] = d.getVarFlag('DATA_LAYOUT', arch, True)
+    tspec['target-pointer-width'] = d.getVarFlag('TARGET_POINTER_WIDTH', arch, True)
+    tspec['target-word-size'] = tspec['target-pointer-width']
+    tspec['target-endian'] = d.getVarFlag('TARGET_ENDIAN', arch, True)
+    tspec['arch'] = arch_to_rust_target_arch(arch)
+    tspec['os'] = "linux"
+    tspec['env'] = "gnu"
+    tspec['linker'] = "{}{}gcc".format(d.getVar('CCACHE', True), 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['has-rpath'] = True
+    tspec['has-elf-tls'] = True
+    tspec['position-independent-executables'] = True
 
-    config.set(target_section, "cxx", e(d.expand("${RUST_TARGET_CXX}")))
-    config.set(target_section, "cc", e(d.expand("${RUST_TARGET_CC}")))
+    # write out the target spec json file
+    with open(wd + sys + '.json', 'w') as f:
+        json.dump(tspec, f)
 
-    # If we don't do this rust-native will compile it's own llvm for BUILD.
-    # [target.${BUILD_ARCH}-unknown-linux-gnu]
-    target_section = "target.{}".format(d.getVar('SNAPSHOT_BUILD_SYS', True))
-    config.add_section(target_section)
 
-    config.set(target_section, "llvm-config", e(llvm_config))
+python do_rust_gen_targets () {
+    wd = d.getVar('WORKDIR', True) + '/targets/'
+    # It is important 'TARGET' is last here so that it overrides our less
+    # informed choices for BUILD & HOST if TARGET happens to be the same as
+    # either of them.
+    for thing in ['BUILD', 'HOST', 'TARGET']:
+        bb.debug(1, "rust_gen_target for " + thing)
+        rust_gen_target(d, thing, wd)
+}
+addtask rust_gen_targets after do_patch before do_compile
+do_rust_gen_targets[dirs] += "${WORKDIR}/targets"
 
-    config.set(target_section, "cxx", e(d.expand("${RUST_BUILD_CXX}")))
-    config.set(target_section, "cc", e(d.expand("${RUST_BUILD_CC}")))
+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
 
-    # [rust]
-    config.add_section("rust")
-    config.set("rust", "rpath", e(True))
-    config.set("rust", "channel", e("stable"))
+    This generates a new #1 for the given 'thing' (one of HOST, TARGET, BUILD)
+    using a "similar" config that rust already supplies as a template.
 
-    # Whether or not to optimize the compiler and standard library
-    config.set("rust", "optimize", e(True))
+    Note that the configure process also depends on the existence of #1, so we
+    have to run this before do_configure
+    '''
+    import os
+    import subprocess
 
-    # [build]
-    config.add_section("build")
-    config.set("build", "submodules", e(False))
-    config.set("build", "docs", e(False))
+    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, True)
+    ldflags = d.getVar('LDFLAGS', True) + d.getVar('HOST_CC_ARCH', True) + d.getVar('TOOLCHAIN_OPTIONS', True)
 
-    rustc = d.expand("${WORKDIR}/rust-snapshot/bin/rustc")
-    config.set("build", "rustc", e(rustc))
+    b = os.path.join(d.getVar('S', True), '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')
 
-    # Support for the profiler runtime to generate e.g. coverage report,
-    # PGO etc.
-    config.set("build", "profiler", e(True))
+    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)//',
 
-    cargo = d.expand("${WORKDIR}/rust-snapshot/bin/cargo")
-    config.set("build", "cargo", e(cargo))
+        # update all triplets to the new one
+        '-e', 's/{}/{}/g'.format(rust_base_sys, sys),
 
-    config.set("build", "vendor", e(True))
+        # 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),
 
-    if not "targets" in locals():
-        targets = [d.getVar("TARGET_SYS", True)]
-    config.set("build", "target", e(targets))
+        # 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),
 
-    if not "hosts" in locals():
-        hosts = [d.getVar("HOST_SYS", True)]
-    config.set("build", "host", e(hosts))
+        # 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),
 
-    # We can't use BUILD_SYS since that is something the rust snapshot knows
-    # nothing about when trying to build some stage0 tools (like fabricate)
-    config.set("build", "build", e(d.getVar("SNAPSHOT_BUILD_SYS", True)))
+        # 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()
 
-    # [install]
-    config.add_section("install")
-    # ./x.py install doesn't have any notion of "destdir"
-    # but we can prepend ${D} to all the directories instead
-    config.set("install", "prefix",  e(d.getVar("D", True) + d.getVar("prefix", True)))
-    config.set("install", "bindir",  e(d.getVar("D", True) + d.getVar("bindir", True)))
-    config.set("install", "libdir",  e(d.getVar("D", True) + d.getVar("libdir", True)))
-    config.set("install", "datadir", e(d.getVar("D", True) + d.getVar("datadir", True)))
-    config.set("install", "mandir",  e(d.getVar("D", True) + d.getVar("mandir", True)))
+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
+do_rust_arch_fixup[dirs] += "${S}/mk/cfg"
 
-    with open("config.toml", "w") as f:
-        f.write('changelog-seen = 2\n\n')
-        config.write(f)
+# prevent the rust-installer scripts from calling ldconfig
+export CFG_DISABLE_LDCONFIG="notempty"
 
-    # set up ${WORKDIR}/cargo_home
-    bb.build.exec_func("setup_cargo_environment", d)
+# rust's configure doesn't recognize --disable-static, so remove it.
+DISABLE_STATIC = ""
+
+do_configure () {
+    # FIXME: target_prefix vs prefix, see cross.bbclass
+
+    # - rpath is required otherwise rustc fails to resolve symbols
+    # - submodule management is done by bitbake's fetching
+    ${S}/configure                          \
+        "--enable-rpath"                    \
+        "--disable-docs"                    \
+        "--disable-manage-submodules"       \
+        "--disable-debug"                   \
+        "--enable-optimize"                 \
+        "--enable-optimize-cxx"             \
+        "--disable-llvm-version-check"      \
+        "--llvm-root=${STAGING_DIR_NATIVE}/${prefix_native}" \
+        "--enable-optimize-tests"           \
+        "--release-channel=stable"          \
+        "--prefix=${prefix}"                \
+        "--target=${TARGET_SYS}"            \
+        "--host=${HOST_SYS}"                \
+        "--build=${BUILD_SYS}"              \
+        "--localstatedir=${localstatedir}"  \
+        "--sysconfdir=${sysconfdir}"        \
+        "--datadir=${datadir}"              \
+        "--infodir=${infodir}"              \
+        "--mandir=${mandir}"                \
+        "--libdir=${libdir}"                \
+        "--enable-local-rust"               \
+        "--local-rust-root=${WORKDIR}/${RUST_SNAPSHOT}/rustc" \
+        ${EXTRA_OECONF}
 }
 
-
-rust_runx () {
+rust_runmake () {
     echo "COMPILE ${PN}" "$@"
 
     # CFLAGS, LDFLAGS, CXXFLAGS, CPPFLAGS are used by rust's build for a
@@ -165,38 +384,35 @@ rust_runx () {
     unset CXXFLAGS
     unset CPPFLAGS
 
-    oe_cargo_fix_env
-
-    python3 src/bootstrap/bootstrap.py ${@oe.utils.parallel_make_argument(d, '-j %d')} "$@" --verbose
+    oe_runmake "VERBOSE=1" "$@"
 }
-rust_runx[vardepsexclude] += "PARALLEL_MAKE"
 
 do_compile () {
-    rust_runx build
+    rust_runmake
 }
 
 rust_do_install () {
-    mkdir -p ${D}${bindir}
-    cp build/${HOST_SYS}/stage2/bin/* ${D}${bindir}
+    rust_runmake DESTDIR="${D}" install
 
-    mkdir -p ${D}${libdir}/rustlib
-    cp -pRd build/${HOST_SYS}/stage2/lib/* ${D}${libdir}
-    # Remove absolute symlink so bitbake doesn't complain
-    rm -f ${D}${libdir}/rustlib/src/rust
-}
-
-rust_install_targets() {
     # Install our custom target.json files
     local td="${D}${libdir}/rustlib/"
     install -d "$td"
     for tgt in "${WORKDIR}/targets/"* ; do
         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
+    rm ${D}/${libdir}/rustlib/uninstall.sh
+    rm ${D}/${libdir}/rustlib/components
+}
 
 do_install () {
     rust_do_install
-    rust_install_targets
 }
 # ex: sts=4 et sw=4 ts=8

recipes-devtools/rust/rust_1.12.1.bb

@@ -0,0 +1,27 @@
+require rust.inc
+require rust-source-${PV}.inc
+
+# the configure script always requires cmake so despite
+# rust not needing this (only rust-llvm needs it) we must
+# have it for the configure script to succeed.
+DEPENDS += "cmake-native"
+
+SRC_URI += " \
+        file://rust-${PV}/0001-Target-add-default-target.json-path-libdir-rust-targ.patch \
+        file://rust-${PV}/0002-mk-for-stage0-use-RUSTFLAGS-to-override-target-libs-.patch \
+        file://rust-${PV}/0003-mk-add-missing-CFG_LIBDIR_RELATIVE.patch \
+        file://rust-${PV}/0005-std-thread_local-workaround-for-NULL-__dso_handle.patch \
+        file://rust-${PV}/0006-mk-install-use-disable-rewrite-paths.patch \
+        file://rust-${PV}/0007-Allow-overriding-crate_hash-with-C-crate_hash.patch \
+        file://rust-${PV}/0008-mk-platform.mk-pass-C-crate_hash-to-builds.patch \
+        file://rust-installer-${PV}/0001-add-option-to-disable-rewriting-of-install-paths.patch;patchdir=src/rust-installer \
+        "
+
+DEPENDS += "rust-llvm (=${PV})"
+
+# Otherwise we'll depend on what we provide
+INHIBIT_DEFAULT_RUST_DEPS_class-native = "1"
+# We don't need to depend on gcc-native because yocto assumes it exists
+PROVIDES_class-native = "virtual/${TARGET_PREFIX}rust"
+
+BBCLASSEXTEND = "native"

recipes-devtools/rust/rust_1.15.1.bb

@@ -0,0 +1,18 @@
+require rust.inc
+require rust-source-${PV}.inc
+
+EXTRA_OECONF = "--disable-rustbuild"
+
+SRC_URI += " \
+        file://rust-${PV}/0001-Target-add-default-target.json-path-libdir-rust-targ.patch \
+        file://rust-${PV}/0003-std-thread_local-workaround-for-NULL-__dso_handle.patch \
+        "
+
+DEPENDS += "rust-llvm (=${PV})"
+
+# Otherwise we'll depend on what we provide
+INHIBIT_DEFAULT_RUST_DEPS_class-native = "1"
+# We don't need to depend on gcc-native because yocto assumes it exists
+PROVIDES_class-native = "virtual/${TARGET_PREFIX}rust"
+
+BBCLASSEXTEND = "native"