forge/pmaports
1
0
Fork 0
Code Issues 2 Pull requests Projects Releases Packages Wiki Activity Actions
pmaports/cross/crossdirect/APKBUILD

89 lines
3.1 KiB
Text
Raw Normal View History

cross/crossdirect: partially use sccache for rust (MR 4310) Wrap rustc commands with sccache when building native build scripts. More interesting will be using sscache for compiling for the target architecture, but sccache currently refuses to cache with --sysroot. This can be optimized further later on, get some initial support for sccache in here first. While at it, tweak the -vV logic to also support -V, start using semver with this and add myself as maintainer of the package. [ci:skip-build]: already built successfully in CI
2023-08-06 12:08:21 +00:00
# Maintainer: Oliver Smith <ollieparanoid@postmarketos.org>
# https://wiki.postmarketos.org/wiki/Pmbootstrap:_Cross_Compiling
#
cross: add crossdirect package (!222) A set of wrapper executables that launch native cross compilers inside foreign chroots. Speeds up cross compilation a lot, compared to the distcc-sshd method.
2019-02-16 05:20:14 +00:00
# Wrapper for the "crossdirect" compilation method.
# pmbootstrap mounts the native chroot in the foreign arch (e.g. armhf) chroot
# as /native. This package gets installed into the native chroot, and creates
# wrappers like:
#
# /native/usr/lib/crossdirect/armhf/gcc
# -> /native/usr/bin/armv6-alpine-linux-muslgnueabihf-gcc
cross/crossdirect: support rust (!845) Use the native rustc cross compiler where possible, and fall back to the qemu rustc if necessary. This should improve speed and reliability. Without this patch, building squeekbox 1.4.0 for aarch64 with the pmbootstrap stack just hangs forever. Related: pmbootstrap#1861
2020-01-02 15:16:20 +00:00
# /native/usr/lib/crossdirect/armhf/rustc
# -> /native/usr/bin/rustc --target=armv6-alpine-linux-musleabihf ...
cross: add crossdirect package (!222) A set of wrapper executables that launch native cross compilers inside foreign chroots. Speeds up cross compilation a lot, compared to the distcc-sshd method.
2019-02-16 05:20:14 +00:00
#
# When building packages in the armhf chroot, PATH will get prepended with
# "/native/usr/lib/crossdirect/armhf". The end game is of course invoking the
# cross compiler from the native chroot, running at native speed, whenever
# calling the compiler from the foreign arch chroot. See crossdirect.c for
cross/crossdirect: support rust (!845) Use the native rustc cross compiler where possible, and fall back to the qemu rustc if necessary. This should improve speed and reliability. Without this patch, building squeekbox 1.4.0 for aarch64 with the pmbootstrap stack just hangs forever. Related: pmbootstrap#1861
2020-01-02 15:16:20 +00:00
# implementation details of the C version (llvm, fakeroot, rpath). The rust
# version is implemented as simple shell wrappers.
cross: add crossdirect package (!222) A set of wrapper executables that launch native cross compilers inside foreign chroots. Speeds up cross compilation a lot, compared to the distcc-sshd method.
2019-02-16 05:20:14 +00:00
pkgname=crossdirect
cross/crossdirect: partially use sccache for rust (MR 4310) Wrap rustc commands with sccache when building native build scripts. More interesting will be using sscache for compiling for the target architecture, but sccache currently refuses to cache with --sysroot. This can be optimized further later on, get some initial support for sccache in here first. While at it, tweak the -vV logic to also support -V, start using semver with this and add myself as maintainer of the package. [ci:skip-build]: already built successfully in CI
2023-08-06 12:08:21 +00:00
pkgver=5.1.0
cross/crossdirect: improve rust handling (MR 4234) Add a cargo wrapper which appends a --target argument to the command line. This makes cargo pass the --target argument to rustc for crates being built for the target architecture, even if the target is the same as the host. It will omit the --target argument for build scripts and crates used in macros. Check for this --target argument in the rustc wrapper and adjust the library paths depending on its presence. The fallback that runs rustc under qemu is no longer needed because macros are now built for the native architecture and can be loaded into the native compiler without any problems. Also check if the arguments passed to rustc are "-vV". If this is the case, we still need to fall back to the target rustc because the native rustc will return the wrong architecture. If the wrong host architecture is passed to a build script, it might try to look for a cross-compiler or do something else that doesn't work. [ci:skip-build]: already built successfully in CI
2023-07-06 08:20:23 +00:00
pkgrel=0
cross: add crossdirect package (!222) A set of wrapper executables that launch native cross compilers inside foreign chroots. Speeds up cross compilation a lot, compared to the distcc-sshd method.
2019-02-16 05:20:14 +00:00
pkgdesc="Wrappers to launch native cross compilers in foreign chroots"
url="https://postmarketOS.org"
arch="all"
license="MIT"
cross/crossdirect: support rust (!845) Use the native rustc cross compiler where possible, and fall back to the qemu rustc if necessary. This should improve speed and reliability. Without this patch, building squeekbox 1.4.0 for aarch64 with the pmbootstrap stack just hangs forever. Related: pmbootstrap#1861
2020-01-02 15:16:20 +00:00
options="!check"
cross/crossdirect: improve rust handling (MR 4234) Add a cargo wrapper which appends a --target argument to the command line. This makes cargo pass the --target argument to rustc for crates being built for the target architecture, even if the target is the same as the host. It will omit the --target argument for build scripts and crates used in macros. Check for this --target argument in the rustc wrapper and adjust the library paths depending on its presence. The fallback that runs rustc under qemu is no longer needed because macros are now built for the native architecture and can be loaded into the native compiler without any problems. Also check if the arguments passed to rustc are "-vV". If this is the case, we still need to fall back to the target rustc because the native rustc will return the wrong architecture. If the wrong host architecture is passed to a build script, it might try to look for a cross-compiler or do something else that doesn't work. [ci:skip-build]: already built successfully in CI
2023-07-06 08:20:23 +00:00
source="cargo.sh crossdirect.c rustc.sh rust-qemu-linker.sh"
cross: add crossdirect package (!222) A set of wrapper executables that launch native cross compilers inside foreign chroots. Speeds up cross compilation a lot, compared to the distcc-sshd method.
2019-02-16 05:20:14 +00:00
build() {
cd "$srcdir"
# Architectures and binaries
_archs="x86_64 armhf armv7 aarch64"
for _arch in $_archs; do
[ "$_arch" == "$CARCH" ] && continue
_hostspec="$(arch_to_hostspec $_arch)"
cross/crossdirect: use ccache, execve, -Werror (!299) Instead of running compilers directly, let them go through the native ccache binary. Note that it will still use the foreign arches cache dir because the native cache dir would be at /native/home/pmos/.ccache. Use execve instead of setenv and execv, because that didn't work with LD_LIBRARY_PATH (ccache was complaining that it couldn't load zlib). Enable -Werror, because we are maintaining this program and it helps us catching bugs early.
2019-04-03 18:45:16 +00:00
# Build with -Werror, because we maintain this short program. (If
# upstream is elsewhere, having -Werror is usually not desired.)
$CC -o "crossdirect-$_arch" \
-static \
-Werror \
-DHOSTSPEC="\"$_hostspec\"" \
cross: add crossdirect package (!222) A set of wrapper executables that launch native cross compilers inside foreign chroots. Speeds up cross compilation a lot, compared to the distcc-sshd method.
2019-02-16 05:20:14 +00:00
crossdirect.c
done
}
package() {
# Architectures and binaries
_archs="x86_64 armhf armv7 aarch64"
_bins="c++ cc cpp g++ gcc clang clang++"
cross/crossdirect: improve rust handling (MR 4234) Add a cargo wrapper which appends a --target argument to the command line. This makes cargo pass the --target argument to rustc for crates being built for the target architecture, even if the target is the same as the host. It will omit the --target argument for build scripts and crates used in macros. Check for this --target argument in the rustc wrapper and adjust the library paths depending on its presence. The fallback that runs rustc under qemu is no longer needed because macros are now built for the native architecture and can be loaded into the native compiler without any problems. Also check if the arguments passed to rustc are "-vV". If this is the case, we still need to fall back to the target rustc because the native rustc will return the wrong architecture. If the wrong host architecture is passed to a build script, it might try to look for a cross-compiler or do something else that doesn't work. [ci:skip-build]: already built successfully in CI
2023-07-06 08:20:23 +00:00
# Rust wrappers
cross/crossdirect: support rust (!845) Use the native rustc cross compiler where possible, and fall back to the qemu rustc if necessary. This should improve speed and reliability. Without this patch, building squeekbox 1.4.0 for aarch64 with the pmbootstrap stack just hangs forever. Related: pmbootstrap#1861
2020-01-02 15:16:20 +00:00
install -Dm755 "$srcdir/rust-qemu-linker.sh" \
"$pkgdir/usr/lib/crossdirect/rust-qemu-linker"
cross/crossdirect: improve rust handling (MR 4234) Add a cargo wrapper which appends a --target argument to the command line. This makes cargo pass the --target argument to rustc for crates being built for the target architecture, even if the target is the same as the host. It will omit the --target argument for build scripts and crates used in macros. Check for this --target argument in the rustc wrapper and adjust the library paths depending on its presence. The fallback that runs rustc under qemu is no longer needed because macros are now built for the native architecture and can be loaded into the native compiler without any problems. Also check if the arguments passed to rustc are "-vV". If this is the case, we still need to fall back to the target rustc because the native rustc will return the wrong architecture. If the wrong host architecture is passed to a build script, it might try to look for a cross-compiler or do something else that doesn't work. [ci:skip-build]: already built successfully in CI
2023-07-06 08:20:23 +00:00
install -Dm755 "$srcdir/cargo.sh" "$pkgdir/usr/lib/crossdirect/cargo.sh"
install -Dm755 "$srcdir/rustc.sh" "$pkgdir/usr/lib/crossdirect/rustc.sh"
cross/crossdirect: support rust (!845) Use the native rustc cross compiler where possible, and fall back to the qemu rustc if necessary. This should improve speed and reliability. Without this patch, building squeekbox 1.4.0 for aarch64 with the pmbootstrap stack just hangs forever. Related: pmbootstrap#1861
2020-01-02 15:16:20 +00:00
cross: add crossdirect package (!222) A set of wrapper executables that launch native cross compilers inside foreign chroots. Speeds up cross compilation a lot, compared to the distcc-sshd method.
2019-02-16 05:20:14 +00:00
# Iterate over architectures
for _arch in $_archs; do
[ "$_arch" == "$CARCH" ] && continue
cross/crossdirect: support rust (!845) Use the native rustc cross compiler where possible, and fall back to the qemu rustc if necessary. This should improve speed and reliability. Without this patch, building squeekbox 1.4.0 for aarch64 with the pmbootstrap stack just hangs forever. Related: pmbootstrap#1861
2020-01-02 15:16:20 +00:00
# GCC: put arch-specific crossdirect wrapper in arch-specific
# bin folder
cross: add crossdirect package (!222) A set of wrapper executables that launch native cross compilers inside foreign chroots. Speeds up cross compilation a lot, compared to the distcc-sshd method.
2019-02-16 05:20:14 +00:00
_bindir="$pkgdir/usr/lib/crossdirect/$_arch"
_hostspec="$(arch_to_hostspec $_arch)"
mkdir -p "$_bindir"
cd "$_bindir"
cp "$srcdir/crossdirect-$_arch" "./"
cross/crossdirect: support rust (!845) Use the native rustc cross compiler where possible, and fall back to the qemu rustc if necessary. This should improve speed and reliability. Without this patch, building squeekbox 1.4.0 for aarch64 with the pmbootstrap stack just hangs forever. Related: pmbootstrap#1861
2020-01-02 15:16:20 +00:00
# GCC: create compiler symlinks
cross: add crossdirect package (!222) A set of wrapper executables that launch native cross compilers inside foreign chroots. Speeds up cross compilation a lot, compared to the distcc-sshd method.
2019-02-16 05:20:14 +00:00
for _bin in $_bins; do
ln -s "crossdirect-$_arch" "$_bin"
ln -s "crossdirect-$_arch" "$_hostspec-$_bin"
done
cross/crossdirect: support rust (!845) Use the native rustc cross compiler where possible, and fall back to the qemu rustc if necessary. This should improve speed and reliability. Without this patch, building squeekbox 1.4.0 for aarch64 with the pmbootstrap stack just hangs forever. Related: pmbootstrap#1861
2020-01-02 15:16:20 +00:00
cross/crossdirect: improve rust handling (MR 4234) Add a cargo wrapper which appends a --target argument to the command line. This makes cargo pass the --target argument to rustc for crates being built for the target architecture, even if the target is the same as the host. It will omit the --target argument for build scripts and crates used in macros. Check for this --target argument in the rustc wrapper and adjust the library paths depending on its presence. The fallback that runs rustc under qemu is no longer needed because macros are now built for the native architecture and can be loaded into the native compiler without any problems. Also check if the arguments passed to rustc are "-vV". If this is the case, we still need to fall back to the target rustc because the native rustc will return the wrong architecture. If the wrong host architecture is passed to a build script, it might try to look for a cross-compiler or do something else that doesn't work. [ci:skip-build]: already built successfully in CI
2023-07-06 08:20:23 +00:00
ln -s ../cargo.sh cargo
ln -s ../rustc.sh rustc
cross: add crossdirect package (!222) A set of wrapper executables that launch native cross compilers inside foreign chroots. Speeds up cross compilation a lot, compared to the distcc-sshd method.
2019-02-16 05:20:14 +00:00
done
}
cross/crossdirect: partially use sccache for rust (MR 4310) Wrap rustc commands with sccache when building native build scripts. More interesting will be using sscache for compiling for the target architecture, but sccache currently refuses to cache with --sysroot. This can be optimized further later on, get some initial support for sccache in here first. While at it, tweak the -vV logic to also support -V, start using semver with this and add myself as maintainer of the package. [ci:skip-build]: already built successfully in CI
2023-08-06 12:08:21 +00:00
cross/crossdirect: improve rust handling (MR 4234) Add a cargo wrapper which appends a --target argument to the command line. This makes cargo pass the --target argument to rustc for crates being built for the target architecture, even if the target is the same as the host. It will omit the --target argument for build scripts and crates used in macros. Check for this --target argument in the rustc wrapper and adjust the library paths depending on its presence. The fallback that runs rustc under qemu is no longer needed because macros are now built for the native architecture and can be loaded into the native compiler without any problems. Also check if the arguments passed to rustc are "-vV". If this is the case, we still need to fall back to the target rustc because the native rustc will return the wrong architecture. If the wrong host architecture is passed to a build script, it might try to look for a cross-compiler or do something else that doesn't work. [ci:skip-build]: already built successfully in CI
2023-07-06 08:20:23 +00:00
sha512sums="
0f4b48f250425dc57f63955fc8b38477d23db793bee367c3fbe03c3d2a559ba576434d07518310db4cae9d90d501af4051b80038b10fae94b980e537fc9374ad cargo.sh
500107e5aff8b34e74b54982ebcd447fc41bc8283956d506561b031a055cb30ec12698047c2604918b4b6d8560fe03db427a63dff2b83c907e8494b7f5233f29 crossdirect.c
cross/crossdirect: partially use sccache for rust (MR 4310) Wrap rustc commands with sccache when building native build scripts. More interesting will be using sscache for compiling for the target architecture, but sccache currently refuses to cache with --sysroot. This can be optimized further later on, get some initial support for sccache in here first. While at it, tweak the -vV logic to also support -V, start using semver with this and add myself as maintainer of the package. [ci:skip-build]: already built successfully in CI
2023-08-06 12:08:21 +00:00
de2aa6929bbff5db9132673e667f4525b333d062cb1f7a0597dd924de9e5c7215a9f8e2e6263b6fb5ace06f2c4b64f4ebfd0ede9b78add07c2cd08ec8613e98f rustc.sh
cross/crossdirect: improve rust handling (MR 4234) Add a cargo wrapper which appends a --target argument to the command line. This makes cargo pass the --target argument to rustc for crates being built for the target architecture, even if the target is the same as the host. It will omit the --target argument for build scripts and crates used in macros. Check for this --target argument in the rustc wrapper and adjust the library paths depending on its presence. The fallback that runs rustc under qemu is no longer needed because macros are now built for the native architecture and can be loaded into the native compiler without any problems. Also check if the arguments passed to rustc are "-vV". If this is the case, we still need to fall back to the target rustc because the native rustc will return the wrong architecture. If the wrong host architecture is passed to a build script, it might try to look for a cross-compiler or do something else that doesn't work. [ci:skip-build]: already built successfully in CI
2023-07-06 08:20:23 +00:00
ea9bf8db3810d03d0a7395057f3d6e57f7127d87c55deaedc171c255288f5f3cc6fbcc680a5a1b92786cf573875d5dc22521173799fe2639acc97d0715ff905b rust-qemu-linker.sh
"
Reference in a new issue Copy permalink