mirrors/meta-rust
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Switch to rustbuild

Browse Source 
Switch the build process to using Rust's new build system called
rustbuild. At the same time stop using jemalloc on all platforms and
switch to the system allocator since that was simplier to do.
This commit is contained in:
Johan Anderholm
2017-03-12 20:03:38 +01:00
committed by Doug Goldstein
parent 1ff41650d5
commit a4fe235317
10 changed files with 178 additions and 177 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
classes/rust-common.bbclass
View File

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

8
recipes-devtools/cargo/cargo-0.16.0.inc
View File

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

8
recipes-devtools/cargo/cargo.inc
View File

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

8
recipes-devtools/rust/libstd-rs.inc
View File

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

6
recipes-devtools/rust/libstd-rs_1.15.1.bb
View File

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

1
recipes-devtools/rust/rust-cross_1.15.1.bb
View File

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

30
recipes-devtools/rust/rust-snapshot-1.15.1.inc Normal file
View File

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

12
recipes-devtools/rust/rust-source-1.15.1.inc
View File

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

263
recipes-devtools/rust/rust.inc
View File

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

17
recipes-devtools/rust/rust_1.15.1.bb
View File

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