Merge branch 'gcc-bootstrap' into 'master'

Draft: Bootstrap GCC prefix using cookbook

See merge request redox-os/redox!1787

mk/config.mk

@@ -54,7 +54,8 @@ SCCACHE_BUILD?=$(shell [ -f /run/.containerenv ] && echo 1 || echo 0)
 CONTAINERFILE?=podman/redox-base-containerfile
 
 # Per host variables
-export NPROC=nproc
+NPROC=nproc
+SED=sed
 
 ifneq ($(PODMAN_BUILD),1)
 FSTOOLS_IN_PODMAN=0
@@ -101,7 +102,8 @@ endif
 UNAME := $(shell uname)
 ifeq ($(UNAME),Darwin)
 	FUMOUNT=umount
-	export NPROC=sysctl -n hw.ncpu
+	NPROC=sysctl -n hw.ncpu
+	SED=gsed
 	VB_AUDIO=coreaudio
 	VBM=/Applications/VirtualBox.app/Contents/MacOS/VBoxManage
 else ifeq ($(UNAME),FreeBSD)

mk/prefix.mk

@@ -4,76 +4,41 @@ PREFIX=prefix/$(TARGET)
 
 PREFIX_INSTALL=$(PREFIX)/sysroot/
 PREFIX_PATH=$(ROOT)/$(PREFIX_INSTALL)/bin
-RELIBC_SOURCE=recipes/core/relibc/source
+BINUTILS_TARGET=recipes/dev/binutils-gdb/target/$(HOST_TARGET)/$(TARGET)
+LIBTOOL_TARGET=recipes/dev/libtool/target/$(HOST_TARGET)
+GCC_TARGET=recipes/dev/gcc13/target/$(HOST_TARGET)/$(TARGET)
+LIBSTDCXX_TARGET=recipes/libs/libstdcxx-v3/target/$(TARGET)/$(HOST_TARGET)
+RELIBC_FREESTANDING_TARGET=recipes/core/relibc/target/$(TARGET)/$(HOST_TARGET)
+RELIBC_TARGET=recipes/core/relibc/target/$(TARGET)
 
-BINUTILS_BRANCH=redox-2.43.1
-GCC_BRANCH=redox-13.2.0
-LIBTOOL_VERSION=2.5.4
 # official RISC-V support introduced in newer version
-UPSTREAM_RUSTC_VERSION="2025-11-15"
+UPSTREAM_RUSTC_VERSION=2025-11-15
 
 export PREFIX_RUSTFLAGS=-L $(ROOT)/$(PREFIX_INSTALL)/$(TARGET)/lib
 export RUSTUP_TOOLCHAIN=$(ROOT)/$(PREFIX_INSTALL)
 export REDOXER_TOOLCHAIN=$(RUSTUP_TOOLCHAIN)
 
-export CC=
-export CXX=
-
-ifeq ($(TARGET),riscv64gc-unknown-redox)
-	GCC_ARCH?=--with-arch=rv64gc --with-abi=lp64d
-else
-	GCC_ARCH?=
-endif
-
-# TODO(andypython): Upstream libtool patches to remove the need to locally build libtool.
-# Cannot be CI built, i.e. be a part of relibc-install.tar.gz, as the prefix has to be correctly
-# set while building. Otherwise aclocal will not be able to find libtool's files. Furthermore, doing
-# so would break non-podman builds (not sure if they are still supported though).
 prefix: $(PREFIX)/sysroot
 
 # Update relibc used for compiling and clean all statically linked recipes
 prefix_clean: | $(FSTOOLS_TAG)
-	rm -rf $(PREFIX)/relibc $(PREFIX)/sysroot $(REPO_TAG)
+	rm -rf $(PREFIX)/relibc-install $(PREFIX)/sysroot $(REPO_TAG)
 	$(MAKE) c.base,base-initfs,extrautils,kernel,ion,pkgutils,redoxfs,relibc
 
-PREFIX_STRIP=\
-	mkdir -p bin libexec "$(GCC_TARGET)/bin" && \
-	find bin libexec "$(GCC_TARGET)/bin" "$(GCC_TARGET)/lib" \
-		-type f \
-		-exec strip --strip-unneeded {} ';' \
-		2> /dev/null
-
-$(RELIBC_SOURCE): | $(FSTOOLS_TAG)
-ifeq ($(PODMAN_BUILD),1)
-	$(PODMAN_RUN) make $@
-else
-	./target/release/repo fetch relibc
-	touch $(RELIBC_SOURCE)
-endif
-
-$(PREFIX)/relibc: | $(RELIBC_SOURCE)
-	mkdir -p "$(@D)"
-	rm -rf "$@.partial" "$@"
-	cp -r "$(RELIBC_SOURCE)" "$@.partial"
-	touch "$@.partial"
-	mv "$@.partial" "$@"
-
-$(PREFIX)/relibc-install: $(PREFIX)/relibc | $(PREFIX)/rust-install $(CONTAINER_TAG)
+$(PREFIX)/relibc-install: $(PREFIX)/rust-install | $(FSTOOLS_TAG) $(CONTAINER_TAG)
 ifeq ($(PODMAN_BUILD),1)
 	$(PODMAN_RUN) make $@
 else
+	@echo "\033[1;36;49mBuilding relibc-install\033[0m"
 	rm -rf "$@.partial" "$@"
 	cp -r "$(PREFIX)/rust-install" "$@.partial"
 	rm -rf "$@.partial/$(TARGET)/include/"*
 	cp -r "$(PREFIX)/rust-install/$(GNU_TARGET)/include/c++" "$@.partial/$(GNU_TARGET)/include/c++"
 	cp -r "$(PREFIX)/rust-install/lib/rustlib/$(HOST_TARGET)/lib/" "$@.partial/lib/rustlib/$(HOST_TARGET)/"
-	cd "$<" && \
 	export PATH="$(ROOT)/$@.partial/bin:$$PATH" && \
-	export CARGO="env -u CARGO cargo" && \
-	$(MAKE) clean && \
-	$(MAKE) -j `$(NPROC)` all && \
-	$(MAKE) -j `$(NPROC)` install DESTDIR="$(ROOT)/$@.partial/$(GNU_TARGET)"
-	cd "$@.partial" && $(PREFIX_STRIP)
+	export CARGO="env -u CARGO cargo" CI=1 && \
+	./target/release/repo cook relibc
+	cp -r "$(RELIBC_TARGET)/stage/usr/". "$@.partial/$(GNU_TARGET)"
 	touch "$@.partial"
 	mv "$@.partial" "$@"
 endif
@@ -86,60 +51,30 @@ $(PREFIX)/relibc-install.tar.gz: $(PREFIX)/relibc-install
 		--directory="$<" \
 		.
 
-$(PREFIX)/libtool: | $(CONTAINER_TAG)
+# TODO: move this behind PREFIX_BINARY=0 when compiled prefix has it
+$(PREFIX)/libtool-install: | $(FSTOOLS_TAG) $(CONTAINER_TAG)
 ifeq ($(PODMAN_BUILD),1)
 	$(PODMAN_RUN) make $@
 else
+	@echo "\033[1;36;49mBuilding libtool-install\033[0m"
 	rm -rf "$@.partial" "$@"
 	mkdir -p "$@.partial"
-
-	git clone \
-		--recurse-submodules \
-		--shallow-submodules \
-		"https://gitlab.redox-os.org/redox-os/libtool/" \
-		--branch "v$(LIBTOOL_VERSION)-redox" \
-		--depth 2 \
-		"$@.partial"
-
-	touch "$@.partial"
-	echo $(LIBTOOL_VERSION) > $@.partial/.tarball-version
-	mv "$@.partial" "$@"
-endif
-
-$(PREFIX)/libtool-build: $(PREFIX)/libtool $(PREFIX)/rust-install $(CONTAINER_TAG)
-ifeq ($(PODMAN_BUILD),1)
-	$(PODMAN_RUN) make $@
-else
-	rm -rf "$@.partial" "$@"
-	mkdir -p "$@.partial"
-	PATH="$(ROOT)/$(PREFIX)/rust-install/bin:$$PATH" && \
-	cd "$<" && \
-		./bootstrap \
-			--skip-po \
-			--force \
-			--gnulib-srcdir=./gnulib
-	PATH="$(ROOT)/$(PREFIX)/rust-install/bin:$$PATH" && \
-	cd "$@.partial" && \
-		cp -r $(abspath $<)/. ./ && \
-		"$(ROOT)/$</configure" \
-			--target="$(TARGET)" \
-			--prefix=$(abspath $(PREFIX)/sysroot) && \
-		$(MAKE) -j `$(NPROC)`
-
+	export CI=1 COOKBOOK_CLEAN_BUILD=true COOKBOOK_HOST_SYSROOT=/usr && \
+	./target/release/repo cook host:libtool
+	cp -r "$(LIBTOOL_TARGET)/stage/usr/". "$@.partial"
 	touch "$@.partial"
 	mv "$@.partial" "$@"
 endif
 
-$(PREFIX)/sysroot: $(PREFIX)/relibc-install $(PREFIX)/libtool-build $(CONTAINER_TAG)
+$(PREFIX)/sysroot: $(PREFIX)/relibc-install $(PREFIX)/libtool-install $(CONTAINER_TAG)
 ifeq ($(PODMAN_BUILD),1)
 	$(PODMAN_RUN) make $@
 else
 	rm -rf "$@"
 	cp -r "$(PREFIX)/relibc-install/" "$@"
-	PATH="$(ROOT)/$(PREFIX)/rust-install/bin:$$PATH" && \
-	cd "$(PREFIX)/libtool-build" && \
-		$(MAKE) install -j `$(NPROC)`
-	cd "$@" && $(PREFIX_STRIP)
+	cp -r "$(PREFIX)/libtool-install/". "$@"
+# adapt path for libtoolize
+	$(SED) -i 's|/usr/share|$(ROOT)/$@/share|g' "$@/bin/libtoolize"
 	touch "$@"
 endif
 
@@ -170,152 +105,97 @@ endif
 else
 
 # BUILD GCC ---------------------------------------------------
-PREFIX_FREESTANDING_INSTALL=$(PREFIX)/gcc-freestanding-install
-PREFIX_FREESTANDING_PATH=$(ROOT)/$(PREFIX_FREESTANDING_INSTALL)/bin
-
-$(PREFIX)/binutils-$(BINUTILS_BRANCH).tar.bz2:
-	mkdir -p "$(@D)"
-	rm -fv $(PREFIX)/binutils*.tar.bz2*
-	wget -O $@.partial "https://gitlab.redox-os.org/redox-os/binutils-gdb/-/archive/$(BINUTILS_BRANCH)/binutils-gdb-$(BINUTILS_BRANCH).tar.bz2"
-	mv $@.partial $@
-
-$(PREFIX)/binutils: $(PREFIX)/binutils-$(BINUTILS_BRANCH).tar.bz2
+$(PREFIX)/binutils-install: | $(FSTOOLS_TAG) $(CONTAINER_TAG)
 ifeq ($(PODMAN_BUILD),1)
 	$(PODMAN_RUN) make $@
 else
+	@echo "\033[1;36;49mBuilding binutils-install\033[0m"
 	rm -rf "$@.partial" "$@"
 	mkdir -p "$@.partial"
-	tar --extract --file "$<" --directory "$@.partial" --no-same-owner --strip-components=1
+	export CI=1 COOKBOOK_CLEAN_BUILD=true COOKBOOK_HOST_SYSROOT=/usr COOKBOOK_CROSS_TARGET=$(TARGET) COOKBOOK_CROSS_GNU_TARGET=$(GNU_TARGET) && \
+	./target/release/repo cook host:binutils-gdb 
+	cp -r "$(BINUTILS_TARGET)/stage/usr/". "$@.partial"
 	touch "$@.partial"
 	mv "$@.partial" "$@"
 endif
 
-$(PREFIX)/binutils-install: $(PREFIX)/binutils $(CONTAINER_TAG)
+$(PREFIX)/gcc-freestanding-install: $(PREFIX)/binutils-install | $(FSTOOLS_TAG) $(CONTAINER_TAG)
 ifeq ($(PODMAN_BUILD),1)
 	$(PODMAN_RUN) make $@
 else
-	rm -rf "$<-build" "$@.partial" "$@"
-	mkdir -p "$<-build" "$@.partial"
-	cd "$<-build" && \
-	"$(ROOT)/$</configure" \
-		--target="$(GNU_TARGET)" \
-		$(GCC_ARCH) \
-		--program-prefix="$(GNU_TARGET)-" \
-		--prefix="" \
-		--disable-werror \
-		--enable-default-hash-style=gnu \
-		&& \
-	$(MAKE) -j `$(NPROC)` all && \
-	$(MAKE) -j `$(NPROC)` install DESTDIR="$(ROOT)/$@.partial"
-	rm -rf "$<-build"
-	cd "$@.partial" && $(PREFIX_STRIP)
+	@echo "\033[1;36;49mBuilding gcc-freestanding-install\033[0m"
+	rm -rf "$@.partial" "$@" $(PREFIX)/relibc-freestanding-install $(PREFIX)/sysroot
+	mkdir -p "$@.partial" $(PREFIX)/relibc-freestanding-install/$(GNU_TARGET)/include
+	export CI=1 PATH="$(ROOT)/$(PREFIX)/binutils-install/bin:$$PATH" \
+		COOKBOOK_CLEAN_BUILD=true COOKBOOK_CROSS_TARGET=$(TARGET) COOKBOOK_CROSS_GNU_TARGET=$(GNU_TARGET) \
+		COOKBOOK_HOST_SYSROOT=/usr COOKBOOK_CROSS_SYSROOT=$(ROOT)/$(PREFIX)/relibc-freestanding-install/$(GNU_TARGET) && \
+	./target/release/repo cook host:gcc13
+	cp -r "$(GCC_TARGET)/stage/usr/". "$@.partial"
+	cp -r "$(GCC_TARGET)/stage.cxx/usr/". "$@.partial"
+	cp -r "$(PREFIX)/binutils-install/". "$@.partial"
+	rm -rf $(PREFIX)/relibc-freestanding-install
 	touch "$@.partial"
 	mv "$@.partial" "$@"
 endif
 
-$(PREFIX)/gcc-$(GCC_BRANCH).tar.bz2:
-	mkdir -p "$(@D)"
-	rm -fv $(PREFIX)/gcc*.tar.bz2*
-	wget -O $@.partial "https://gitlab.redox-os.org/redox-os/gcc/-/archive/$(GCC_BRANCH)/gcc-$(GCC_BRANCH).tar.bz2"
-	mv "$@.partial" "$@"
-
-$(PREFIX)/gcc: $(PREFIX)/gcc-$(GCC_BRANCH).tar.bz2
-ifeq ($(PODMAN_BUILD),1)
-	$(PODMAN_RUN) make $@
-else
-	mkdir -p "$@.partial"
-	tar --extract --file "$<" --directory "$@.partial" --no-same-owner --strip-components=1
-	cd "$@.partial" && ./contrib/download_prerequisites
-	touch "$@.partial"
-	mv "$@.partial" "$@"
-endif
-
-$(PREFIX)/gcc-freestanding-install: $(PREFIX)/gcc | $(PREFIX)/binutils-install $(CONTAINER_TAG)
-ifeq ($(PODMAN_BUILD),1)
-	$(PODMAN_RUN) make $@
-else
-	rm -rf "$<-freestanding-build" "$@.partial" "$@"
-	mkdir -p "$<-freestanding-build"
-	cp -r "$(PREFIX)/binutils-install" "$@.partial"
-	cd "$<-freestanding-build" && \
-	export PATH="$(ROOT)/$@.partial/bin:$$PATH" && \
-	"$(ROOT)/$</configure" \
-		--target="$(GNU_TARGET)" \
-		$(GCC_ARCH) \
-		--program-prefix="$(GNU_TARGET)-" \
-		--prefix="" \
-		--disable-nls \
-		--disable-shared \
-		--enable-languages=c,c++ \
-		--without-headers \
-		--with-linker-hash-style=gnu \
-		&& \
-	$(MAKE) -j `$(NPROC)` all-gcc all-target-libgcc && \
-	$(MAKE) -j `$(NPROC)` install-gcc install-target-libgcc DESTDIR="$(ROOT)/$@.partial"
-	rm -rf "$<-freestanding-build"
-	cd "$@.partial" && $(PREFIX_STRIP)
-	touch "$@.partial"
-	mv "$@.partial" "$@"
-endif
-
-$(PREFIX)/relibc-freestanding: | $(RELIBC_SOURCE)
-	mkdir -p "$(@D)"
-	rm -rf "$@.partial" "$@"
-	cp -r "$(RELIBC_SOURCE)" "$@.partial"
-	touch "$@.partial"
-	mv "$@.partial" "$@"
-
-
-$(PREFIX)/relibc-freestanding-install: $(PREFIX)/relibc-freestanding | $(PREFIX_FREESTANDING_INSTALL) $(CONTAINER_TAG)
+$(PREFIX)/relibc-freestanding-install: $(PREFIX)/gcc-freestanding-install | $(FSTOOLS_TAG) $(CONTAINER_TAG)
 ifeq ($(PODMAN_BUILD),1)
 	$(PODMAN_RUN) make $@
 else
+	@echo "\033[1;36;49mBuilding relibc-freestanding-install\033[0m"
 	rm -rf "$@.partial" "$@"
 	mkdir -p "$@.partial"
-	cd "$<" && \
-	export PATH="$(PREFIX_FREESTANDING_PATH):$$PATH" && \
 	export CARGO="env -u CARGO -u RUSTUP_TOOLCHAIN cargo" && \
-	export CC_$(subst -,_,$(TARGET))="$(GNU_TARGET)-gcc -isystem $(ROOT)/$@.partial/$(GNU_TARGET)/include" && \
-	$(MAKE) clean && \
-	$(MAKE) -j 1 all && \
-	$(MAKE) -j 1 install DESTDIR="$(ROOT)/$@.partial/$(GNU_TARGET)"
-	cd "$@.partial" && $(PREFIX_STRIP)
+	export PATH="$(ROOT)/$(PREFIX)/gcc-freestanding-install/bin:$$PATH" && \
+	export CC_$(subst -,_,$(TARGET))="$(GNU_TARGET)-gcc -isystem $(ROOT)/$@.partial/$(GNU_TARGET)/include" LINKFLAGS="" && \
+	export CI=1 COOKBOOK_CLEAN_BUILD=true COOKBOOK_HOST_SYSROOT=/usr COOKBOOK_CROSS_TARGET=$(HOST_TARGET) && \
+	./target/release/repo cook relibc
+	cp -r "$(RELIBC_FREESTANDING_TARGET)/stage/usr/". "$@.partial/$(GNU_TARGET)"
 	touch "$@.partial"
 	mv "$@.partial" "$@"
 endif
 
-$(PREFIX)/gcc-install: $(PREFIX)/gcc | $(PREFIX)/relibc-freestanding-install $(CONTAINER_TAG)
+$(PREFIX)/gcc-install: $(PREFIX)/relibc-freestanding-install $(PREFIX)/libtool-install | $(FSTOOLS_TAG) $(CONTAINER_TAG)
 ifeq ($(PODMAN_BUILD),1)
 	$(PODMAN_RUN) make $@
 else
-	rm -rf "$<-build" "$@.partial" "$@"
-	mkdir -p "$<-build"
-	cp -r "$(PREFIX)/binutils-install" "$@.partial"
-	cd "$<-build" && \
+	@echo "\033[1;36;49mBuilding gcc-install\033[0m"
+	rm -rf "$@.partial" "$@-build.partial" "$@"
+	if [ ! -d "$(ROOT)/$(GCC_TARGET)" ]; then \
+		echo "\033[1;38;5;196m Incomplete build stages. Please re-run the build\033[0m"; \
+		rm -rf "$(PREFIX)"/gcc-freestanding-install && "$(PREFIX)"/relibc-freestanding-install && \
+		exit 1; fi
+	mkdir -p "$@.partial" "$@-build.partial"
+	cp -r "$(PREFIX)/gcc-freestanding-install/". "$@.partial"
+	cp -r "$(PREFIX)/relibc-freestanding-install/". "$@.partial"
+	cp -r "$(PREFIX)/libtool-install/". "$@.partial"
+	@#TODO: how to make this not conflict with libc?
+	rm -f "$@.partial/lib/gcc/$(GNU_TARGET)/13.2.0/include/limits.h"
+# libgcc and bare features of libstdcxx
 	export PATH="$(ROOT)/$@.partial/bin:$$PATH" && \
-	"$(ROOT)/$</configure" \
-		--target="$(GNU_TARGET)" \
-		$(GCC_ARCH) \
-		--program-prefix="$(GNU_TARGET)-" \
-		--prefix="" \
-		--with-sysroot \
-		--with-build-sysroot="$(ROOT)/$(PREFIX)/relibc-freestanding-install/$(GNU_TARGET)" \
-		--with-native-system-header-dir="/include" \
-		--disable-multilib \
-		--disable-nls \
-		--disable-werror \
-		--enable-languages=c,c++ \
-		--enable-shared \
-		--enable-threads=posix \
-		--with-linker-hash-style=gnu \
-		&& \
-	$(MAKE) -j `$(NPROC)` all-gcc all-target-libgcc all-target-libstdc++-v3 && \
-	$(MAKE) -j `$(NPROC)` install-gcc install-target-libgcc install-target-libstdc++-v3 DESTDIR="$(ROOT)/$@.partial"
-	rm $(ROOT)/$@.partial/$(GNU_TARGET)/lib/*.la
-	rm -rf "$<-build"
-	cd "$@.partial" && $(PREFIX_STRIP)
+	$(MAKE) -C "$(ROOT)/$(GCC_TARGET)/build" all-target-libgcc all-target-libstdc++-v3 && \
+	$(MAKE) -C "$(ROOT)/$(GCC_TARGET)/build" install-target-libgcc install-target-libstdc++-v3 DESTDIR="$(ROOT)/$@-build.partial/usr"
+	cp -r "$@-build.partial/usr/". "$@.partial"
+	@#TODO: in riscv64gc libgcc_s.so is a GNU ld script
+	rm -f "$@.partial"/$(GNU_TARGET)/lib/libgcc_s.so
+	ln -s libgcc_s.so.1 "$@.partial"/$(GNU_TARGET)/lib/libgcc_s.so
+	@#TODO: generates wrong lib path for libtool
+	rm -f "$@.partial"/$(GNU_TARGET)/lib/libstdc++.la
+	rm -f "$@.partial"/$(GNU_TARGET)/lib/libsupc++.la
+# fully featured libstdcxx, not supported for targets only supporting static linking
+ifneq ($(TARGET),riscv64gc-unknown-redox)
+ifneq ($(TARGET),i586-unknown-redox)
+	export PATH="$(ROOT)/$@.partial/bin:$$PATH" && \
+	export CI=1 COOKBOOK_CLEAN_BUILD=true "COOKBOOK_HOST_SYSROOT=$(ROOT)/$@.partial" COOKBOOK_CROSS_TARGET=$(HOST_TARGET) && \
+	rm -rf "$(LIBSTDCXX_TARGET)/stage" && ./target/release/repo cook libstdcxx-v3
+	cp -r "$(LIBSTDCXX_TARGET)/stage/usr/". "$@.partial/$(GNU_TARGET)"
+endif
+endif
+	rm -rf "$@-build.partial"
 	touch "$@.partial"
 	mv "$@.partial" "$@"
+# no longer needed, delete build files to save disk space
+	rm -rf $(BINUTILS_TARGET) $(LIBTOOL_TARGET) $(GCC_TARGET) $(LIBSTDCXX_TARGET) $(RELIBC_FREESTANDING_TARGET)
 endif
 
 $(PREFIX)/gcc-install.tar.gz: $(PREFIX)/gcc-install
@@ -370,6 +250,7 @@ $(PREFIX)/rust-src-install.tar.xz: | $(PREFIX_RUST_VERSION_TAG)
 	mv $@.partial $@
 
 $(PREFIX)/rust-install: $(PREFIX)/gcc-install $(PREFIX)/rustc-install.tar.xz $(PREFIX)/cargo-install.tar.xz $(PREFIX)/rust-std-host-install.tar.xz $(PREFIX)/rust-std-target-install.tar.xz $(PREFIX)/rust-src-install.tar.xz
+	@echo "\033[1;36;49mBuilding rust-install\033[0m"
 	rm -rf "$@.partial" "$@"
 	mkdir -p "$@.partial"
 	cp -r "$(PREFIX)/gcc-install/". "$@.partial"
@@ -395,6 +276,7 @@ $(PREFIX)/rust-install: $(ROOT)/rust/configure | $(PREFIX)/gcc-install $(PREFIX)
 ifeq ($(PODMAN_BUILD),1)
 	$(PODMAN_RUN) make $@
 else
+	@echo "\033[1;36;49mBuilding rust-install\033[0m"
 	rm -rf "$(PREFIX)/rust-build" "$@.partial" "$@"
 	mkdir -p "$(PREFIX)/rust-build"
 	cp -r "$(PREFIX)/gcc-install" "$@.partial"

podman/redox-base-containerfile

@@ -44,6 +44,7 @@ RUN apt-get update \
         libgmp-dev \
         libhtml-parser-perl \
         libjpeg-dev \
+        libmpc-dev \
         libmpfr-dev \
         libparse-yapp-perl \
         libpng-dev \

recipes/core/relibc/recipe.toml

@@ -4,10 +4,10 @@ git = "https://gitlab.redox-os.org/redox-os/relibc.git"
 [build]
 template = "custom"
 script = """
+export CARGO=${CARGO:-env -u CARGO cargo}
 "${COOKBOOK_MAKE}" \
     -C "${COOKBOOK_SOURCE}" \
     -j"$($NPROC)" \
-    CARGO="env -u CARGO cargo" \
-    DESTDIR="${COOKBOOK_STAGE}" \
+    DESTDIR="${COOKBOOK_STAGE}/usr" \
     install
 """

recipes/dev/binutils-gdb/recipe.toml

@@ -0,0 +1,22 @@
+[source]
+git = "https://gitlab.redox-os.org/redox-os/binutils-gdb"
+branch = "redox-2.43.1"
+
+[build]
+template = "custom"
+script = """
+DYNAMIC_INIT
+
+if [ "${COOKBOOK_HOST_SYSROOT}" = "/usr" ]; then
+# not specifying --enable-shared as it will link shared deps
+COOKBOOK_CONFIGURE_FLAGS=( --prefix=/usr --host="${GNU_TARGET}" --program-prefix="${COOKBOOK_CROSS_GNU_TARGET:-$GNU_TARGET}-" )
+fi
+
+COOKBOOK_CONFIGURE_FLAGS+=(
+    --target="${COOKBOOK_CROSS_GNU_TARGET:-$GNU_TARGET}"
+    --enable-default-hash-style=gnu
+    --disable-werror
+)
+
+cookbook_configure
+"""

recipes/dev/gcc13/recipe.toml

@@ -1,5 +1,7 @@
 [source]
-tar = "https://gitlab.redox-os.org/redox-os/gcc/-/archive/redox-13.2.0/gcc-redox-13.2.0.tar.gz"
+git = "https://gitlab.redox-os.org/redox-os/gcc"
+branch = "redox-13.2.0"
+shallow_clone = true
 script = """
 DYNAMIC_INIT
 COOKBOOK_AUTORECONF=autoreconf2.69 autotools_recursive_regenerate -I"$(realpath ./config)"
@@ -15,30 +17,63 @@ dependencies = [
     "zlib"
 ]
 script = """
-DYNAMIC_INIT
+DYNAMIC_STATIC_INIT
+CROSS_GNU_TARGET=${COOKBOOK_CROSS_GNU_TARGET:-$GNU_TARGET}
 
-mkdir -p "${COOKBOOK_SYSROOT}/usr"
-ln -sf "${COOKBOOK_SYSROOT}/include" "${COOKBOOK_SYSROOT}/usr/include"
-ln -sf "${COOKBOOK_SYSROOT}/lib" "${COOKBOOK_SYSROOT}/usr/lib"
+if [ "${COOKBOOK_HOST_SYSROOT}" = "/usr" ]; then
+# not specifying --enable-shared as it will link shared deps
+COOKBOOK_STAGE+="/usr"
+COOKBOOK_CONFIGURE_FLAGS=(
+    --prefix=""
+    --host="${GNU_TARGET}"
+    --program-prefix="${CROSS_GNU_TARGET}-"
+    --with-native-system-header-dir="/include"
+    --disable-hosted-libstdcxx
+    --with-sysroot
+)
+else
+COOKBOOK_CONFIGURE_FLAGS+=(
+    --with-sysroot=/
+)
+fi
+
+if [ "${CROSS_GNU_TARGET}" = "riscv64gc-unknown-redox" ]; then
+COOKBOOK_CONFIGURE_FLAGS+=(
+    --with-arch=rv64gc
+    --with-abi=lp64d
+)
+fi
 
 COOKBOOK_CONFIGURE_FLAGS+=(
-    --target="${GNU_TARGET}"
-    --with-sysroot=/
-    --with-build-sysroot="${COOKBOOK_SYSROOT}"
+    --target="${CROSS_GNU_TARGET}"
+    --with-build-sysroot="${COOKBOOK_CROSS_SYSROOT:-$COOKBOOK_SYSROOT}"
+    --with-linker-hash-style=gnu
     --enable-languages=c,c++,lto
     --enable-initfini-array
+    --disable-nls
     --disable-multilib
     --with-system-zlib
     --enable-host-shared
+    --enable-threads=posix
+    --enable-frame-pointer
+    --enable-libstdcxx-threads
     --with-bugurl="https://gitlab.redox-os.org/redox-os/gcc/-/issues"
 )
 
 "${COOKBOOK_CONFIGURE}" "${COOKBOOK_CONFIGURE_FLAGS[@]}"
-"${COOKBOOK_MAKE}" -j "${COOKBOOK_MAKE_JOBS}" all-gcc all-target-libgcc all-target-libstdc++-v3
-"${COOKBOOK_MAKE}" install-gcc install-target-libgcc install-target-libstdc++-v3 DESTDIR="${COOKBOOK_STAGE}"
+"${COOKBOOK_MAKE}" -j "${COOKBOOK_MAKE_JOBS}" all-gcc
+"${COOKBOOK_MAKE}" install-gcc DESTDIR="${COOKBOOK_STAGE}"
+
+# requires relibc which is not available on bootstrapping
+if [ "${COOKBOOK_HOST_SYSROOT}" != "/usr" ]; then
+
+"${COOKBOOK_MAKE}" -j "${COOKBOOK_MAKE_JOBS}" all-target-libgcc all-target-libstdc++-v3
+"${COOKBOOK_MAKE}" install-target-libgcc install-target-libstdc++-v3 DESTDIR="${COOKBOOK_STAGE}"
 ln -s "gcc" "${COOKBOOK_STAGE}/usr/bin/cc"
 # Avoid conflict with libgcc & libstdcxx
 rm -f "${COOKBOOK_STAGE}"/usr/lib/libgcc_s.so* "${COOKBOOK_STAGE}"/usr/lib/libstdc++.so*
+
+fi
 """
 
 [package]

recipes/dev/libtool/recipe.toml

@@ -8,7 +8,11 @@ shallow_clone = true
 template = "custom"
 script = """
 DYNAMIC_INIT
-rsync -av --delete "${COOKBOOK_SOURCE}/" ./
+
+# libtool saves absolute path to sysroot which contains nothing
+unset CFLAGS
+
+cp -r "${COOKBOOK_SOURCE}"/. ./
 ./bootstrap \
     --skip-po \
     --force \

recipes/games/openttd/recipe.toml

@@ -1,6 +1,7 @@
 [source]
 git = "https://github.com/OpenTTD/OpenTTD.git"
-branch = "release/1.8"
+#TODO: fix issues with this: branch = "release/1.8"
+rev = "231402fb4bea0a0d6a16cef90764d9e7aa699c53"
 shallow_clone = true
 patches = ["redox.patch"]
 
@@ -41,4 +42,4 @@ if [ -d "${COOKBOOK_STAGE}/usr/bin" ]
 then
     find "${COOKBOOK_STAGE}/usr/bin" -type f -exec "${TARGET}-strip" -v {} ';'
 fi
-"""
+"""

recipes/libs/libstdcxx-v3/recipe.toml

@@ -3,14 +3,14 @@ same_as = "../../dev/gcc13"
 
 [build]
 template = "custom"
-dependencies = [
-    "libgmp",
-    "libmpfr",
-    "mpc",
-    "zlib"
-]
 script = """
-DYNAMIC_INIT
+DYNAMIC_STATIC_INIT
+
+COOKBOOK_CONFIGURE_FLAGS+=(
+    --enable-threads=posix
+    --enable-libstdcxx-threads
+)
+
 CPPINCLUDE="${COOKBOOK_HOST_SYSROOT}/$TARGET/include/c++/13.2.0"
 export CPPFLAGS+=" -I${CPPINCLUDE} -I${CPPINCLUDE}/$TARGET/bits"
 COOKBOOK_CONFIGURE="${COOKBOOK_SOURCE}/libstdc++-v3/configure"

recipes/libs/utf8proc/recipe.toml

@@ -3,21 +3,4 @@ tar = "https://github.com/JuliaStrings/utf8proc/archive/refs/tags/v2.10.0.tar.gz
 blake3 = "6f675db5d1ae55ad0825351ba9c58a5b5c24c862f559cc7bfed1cb63c1185594"
 
 [build]
-template = "custom"
-script = """
-DYNAMIC_INIT
-COOKBOOK_CONFIGURE="cmake"
-COOKBOOK_CONFIGURE_FLAGS=(
-    -DCMAKE_BUILD_TYPE=Release
-    -DCMAKE_CROSSCOMPILING=True
-    -DCMAKE_CXX_COMPILER="${TARGET}-g++"
-    -DCMAKE_C_COMPILER="${TARGET}-gcc"
-    -DCMAKE_INSTALL_PREFIX="/"
-    -DCMAKE_PREFIX_PATH="${COOKBOOK_SYSROOT}"
-    -DCMAKE_SYSTEM_NAME=Generic
-    -DCMAKE_SYSTEM_PROCESSOR="$(echo "${TARGET}" | cut -d - -f1)"
-    -DCMAKE_VERBOSE_MAKEFILE=On
-"${COOKBOOK_SOURCE}"
-)
-cookbook_configure
-"""
+template = "cmake"

recipes/wip/dev/lang/zig/recipe.toml

@@ -1,22 +1,59 @@
 #TODO compiling, not tested further
 [source]
 git = "https://github.com/willnode/zig"
-branch = "zig-0.15-redox"
+branch = "zig-0.15.2-redox"
 
 [build]
 template = "custom"
+dependencies = [
+  "llvm21",
+  "zstd"
+]
+
+dev-dependencies = [
+  "llvm21.dev",
+  "llvm21.runtime",
+  "llvm21.clang",
+  "llvm21.clang-dev",
+  "llvm21.lld-dev",
+  "llvm21.lld",
+  "host:libarchive",
+  "host:zig",
+]
+
 script = """
 DYNAMIC_INIT
-rsync -av --delete "${COOKBOOK_SOURCE}"/* ./
+export PATH="${COOKBOOK_BUILD}:${PATH}"
 
-export ZIG_HOST_TARGET_CFLAGS="$CFLAGS"
-export ZIG_HOST_TARGET_LDFLAGS="$LDFLAGS"
-export ZIG_HOST_TARGET_CC="${TARGET}-gcc"
-export ZIG_HOST_TARGET_TRIPLE="${TARGET%%-*}-redox"
-unset AR AS CC CXX LD LDFLAGS NM OBJCOPY OBJDUMP RANLIB READELF RUSTFLAGS STRIP
-cc bootstrap.c -o ./bootstrap
-./bootstrap
+mkdir -p "${COOKBOOK_STAGE}"/usr/lib/zig  "${COOKBOOK_STAGE}"/usr/bin
+ln -s "../lib/zig/bin/zig" "${COOKBOOK_STAGE}"/usr/bin/zig
 
-mkdir -p "${COOKBOOK_STAGE}"/usr/bin
-cp ./zig2 "${COOKBOOK_STAGE}"/usr/bin/zig
+if [ "$TARGET" != "$COOKBOOK_HOST_TARGET" ]; then
+
+ARCH="${GNU_TARGET%%-*}"
+OS=$(echo "${TARGET}" | cut -d - -f3-4)
+rsync -a "${COOKBOOK_SOURCE}"/* ./
+
+zig build \
+  --prefix "${COOKBOOK_STAGE}/usr/lib/zig" \
+  --search-prefix "${COOKBOOK_SYSROOT}/usr" \
+  -Dflat \
+  -Dstatic-llvm \
+  -Doptimize=ReleaseFast \
+  -Dstrip \
+  -Dforce-link-libc \
+  -Dtarget="$ARCH-$OS" \
+  -Dcpu="baseline" \
+  -Dversion-string="0.15.2" \
+  -Duse-zig-libcxx \
+  -Dno-langref \
+  -Dno-test
+
+else 
+
+COOKBOOK_SOURCE="${COOKBOOK_BUILD}"
+COOKBOOK_STAGE="${COOKBOOK_STAGE}/usr/lib/zig"
+cookbook_cmake -DCMAKE_INSTALL_PREFIX=/ -DZIG_NO_TEST=On
+
+fi
 """

recipes/wip/libs/lua/lpeg/recipe.toml

@@ -1,5 +1,6 @@
 [source]
 tar = "https://www.inf.puc-rio.br/~roberto/lpeg/lpeg-1.1.0.tar.gz"
+blake3 = "69fc6eaa1a1749937b7216e3d655cf47a7802ffe407f8f857664e999a7b7377b"
 
 [build]
 template = "custom"

recipes/wip/libs/other/tree-sitter/recipe.toml

@@ -1,5 +1,6 @@
 [source]
 tar = "https://github.com/tree-sitter/tree-sitter/archive/refs/tags/v0.25.8.tar.gz"
+blake3 = "a9bce1e3c610441dc9d7dcc3d7d38e6a74e0b06d6b7d40e22982d927006dbfc4"
 patches = [
     "redox.patch"
 ]

recipes/wip/text/neovim/recipe.toml

@@ -1,6 +1,8 @@
 #TODO mostly work, kinda slow, can't quit (signal issues?)
 [source]
-tar = "https://github.com/neovim/neovim/archive/refs/tags/v0.11.3.tar.gz"
+git = "https://github.com/neovim/neovim"
+rev = "v0.11.5"
+shallow_clone = true
 patches = [
   "redox.patch"
 ]
@@ -8,7 +10,6 @@ patches = [
 [build]
 template = "custom"
 dependencies = [
-    "luajit",
     "libiconv",
     "libuv",
     "luv",
@@ -18,10 +19,32 @@ dependencies = [
     "unibilium",
     "utf8proc",
 ]
+dev-dependencies = [
+  "host:luajit",
+  "host:neovim",
+]
 script = """
 DYNAMIC_INIT
-cookbook_cmake \
-  -DLUA_GEN_PRG=luajit
+
+# the only official way to cross compile in future is via zig
+# https://github.com/neovim/neovim/issues/19579
+# the code path below is very hacky, and our zig support is poor yet
+
+COOKBOOK_CMAKE_FLAGS+=(-DLUA_GEN_PRG=luajit)
+export DEPS_BUILD_DIR=$COOKBOOK_SYSROOT/usr
+if [ "$TARGET" = "$COOKBOOK_HOST_TARGET" ]; then
+cookbook_cmake
+
+# needed to workaround bootstrapping process
+cp ./lib/libnlua0.so ${COOKBOOK_STAGE}/usr/lib/nvim/
+
+else
+
+# this is a very ugly workaround
+cookbook_cmake || true
+cp ${COOKBOOK_TOOLCHAIN}/usr/lib/nvim/libnlua0.so ./lib/libnlua0.so
+cookbook_cmake
+fi
 
 # Lpeg is absolute path https://github.com/neovim/neovim/issues/23395
 patchelf --replace-needed \

recipes/wip/text/neovim/redox.patch

@@ -67,33 +67,6 @@ diff -ruwN source/runtime/CMakeLists.txt source-new/runtime/CMakeLists.txt
    FILES ${GENERATED_SYN_VIM}
    DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/nvim/runtime/syntax/vim)
  
-diff -ruwN source/src/nvim/channel.c source-new/src/nvim/channel.c
---- source/src/nvim/channel.c	2025-07-13 01:34:12.000000000 +0700
-+++ source-new/src/nvim/channel.c	2025-09-16 13:41:27.109978099 +0700
-@@ -547,8 +547,23 @@
-     // Redirect stdout/stdin (the UI channel) to stderr. Use fnctl(F_DUPFD_CLOEXEC) instead of dup()
-     // to prevent child processes from inheriting the file descriptors, which are used by UIs to
-     // detect when Nvim exits.
-+    #ifdef __redox__
-+    int new_stdin_fd = dup(STDIN_FILENO);
-+    if (new_stdin_fd >= 0) {
-+      fcntl(new_stdin_fd, F_SETFD, FD_CLOEXEC);
-+    }
-+    stdin_dup_fd = new_stdin_fd;
-+
-+    // 2. Duplicate STDOUT and set CLOEXEC flag
-+    int new_stdout_fd = dup(STDOUT_FILENO);
-+    if (new_stdout_fd >= 0) {
-+      fcntl(new_stdout_fd, F_SETFD, FD_CLOEXEC);
-+    }
-+    stdout_dup_fd = new_stdout_fd;
-+    #else
-     stdin_dup_fd = fcntl(STDIN_FILENO, F_DUPFD_CLOEXEC, STDERR_FILENO + 1);
-     stdout_dup_fd = fcntl(STDOUT_FILENO, F_DUPFD_CLOEXEC, STDERR_FILENO + 1);
-+    #endif // __redox__
-     dup2(STDERR_FILENO, STDOUT_FILENO);
-     dup2(STDERR_FILENO, STDIN_FILENO);
-   }
 diff -ruwN source/src/nvim/CMakeLists.txt source-new/src/nvim/CMakeLists.txt
 --- source/src/nvim/CMakeLists.txt	2025-07-13 01:34:12.000000000 +0700
 +++ source-new/src/nvim/CMakeLists.txt	2025-09-16 16:07:40.327319085 +0700

src/bin/repo.rs

@@ -69,6 +69,7 @@ const REPO_HELP_STR: &str = r#"
                                         ignored when command "fetch" is used
         COOKBOOK_NONSTOP=false     pkeep running even a recipe build failed
         COOKBOOK_VERBOSE=true      print success/error on each recipe
+        COOKBOOK_CLEAN_BUILD=false remove build directory before building
         COOKBOOK_MAKE_JOBS=        override build jobs count from nproc
 "#;
 
@@ -577,6 +578,7 @@ fn handle_cook(
         &recipe.name,
         &recipe.recipe,
         config.cook.offline,
+        config.cook.clean_build,
         !is_deps,
         logger,
     )

src/bin/repo_builder.rs

@@ -59,21 +59,29 @@ fn publish_packages(config: &CliConfig) -> anyhow::Result<()> {
         fs::create_dir_all(repo_path)?;
     }
 
+    // Don't publish host packages
+    let target_packages = &config
+        .recipe_list
+        .iter()
+        .map(PackageName::new)
+        .filter(|pkg| pkg.as_ref().is_ok_and(|p| !p.is_host()))
+        .collect::<Result<Vec<_>, _>>()?;
+
+    if target_packages.len() == 0 {
+        return Ok(());
+    }
+
+    // TODO: publish cross target builds?
+    if std::env::var("COOKBOOK_CROSS_TARGET").is_ok_and(|x| !x.is_empty()) {
+        return Ok(());
+    }
+
     // Runtime dependencies include both `[package.dependencies]` and dynamically
     // linked packages discovered by auto_deps.
     //
     // The following adds the package dependencies of the recipes to the repo as
     // well.
-    let (recipe_list, recipe_map) = Package::new_recursive_nonstop(
-        &config
-            .recipe_list
-            .iter()
-            .map(PackageName::new)
-            // Don't publish host packages
-            .filter(|pkg| pkg.as_ref().is_ok_and(|p| !p.is_host()))
-            .collect::<Result<Vec<_>, _>>()?,
-        WALK_DEPTH,
-    );
+    let (recipe_list, recipe_map) = Package::new_recursive_nonstop(target_packages, WALK_DEPTH);
 
     if recipe_list.len() == 0 {
         // Fail-Safe

src/config.rs

@@ -19,6 +19,8 @@ pub struct CookConfigOpt {
     /// whether to print verbose logs to certain commands
     /// build failure still be printed anyway
     pub verbose: Option<bool>,
+    /// whether to always clean the build directory
+    pub clean_build: Option<bool>,
 }
 
 #[derive(Debug, Default, Clone, Deserialize, PartialEq, Serialize)]
@@ -29,6 +31,7 @@ pub struct CookConfig {
     pub logs: bool,
     pub nonstop: bool,
     pub verbose: bool,
+    pub clean_build: bool,
 }
 
 impl From<CookConfigOpt> for CookConfig {
@@ -40,6 +43,7 @@ impl From<CookConfigOpt> for CookConfig {
             logs: value.logs.unwrap(),
             nonstop: value.nonstop.unwrap(),
             verbose: value.verbose.unwrap(),
+            clean_build: value.clean_build.unwrap(),
         }
     }
 }
@@ -91,6 +95,9 @@ pub fn init_config() {
     if config.cook_opt.nonstop.is_none() {
         config.cook_opt.nonstop = Some(extract_env("COOKBOOK_NONSTOP", false));
     }
+    if config.cook_opt.clean_build.is_none() {
+        config.cook_opt.clean_build = Some(extract_env("COOKBOOK_CLEAN_BUILD", false));
+    }
     if config.mirrors.len() == 0 {
         // The GNU FTP mirror below is automatically inserted for convenience
         // You can choose other mirrors by setting it on cookbook.toml

src/cook/cook_build.rs

@@ -174,6 +174,7 @@ pub fn build(
     recipe: &Recipe,
     offline_mode: bool,
     check_source: bool,
+    clean_build: bool,
     logger: &PtyOut,
 ) -> Result<(Vec<PathBuf>, BTreeSet<PackageName>), String> {
     let sysroot_dir = target_dir.join("sysroot");
@@ -276,9 +277,8 @@ pub fn build(
         create_dir_clean(&stage_dir_tmp)?;
 
         // Create build, if it does not exist
-        //TODO: flag for clean builds where build is wiped out
-        let build_dir = target_dir.join("build");
-        if !build_dir.is_dir() {
+        let build_dir = get_build_dir(target_dir);
+        if clean_build || !build_dir.is_dir() {
             create_dir_clean(&build_dir)?;
         }
 
@@ -428,15 +428,33 @@ pub fn remove_stage_dir(stage_dir: &PathBuf) -> Result<(), String> {
 }
 
 pub fn get_stage_dirs(features: &Vec<OptionalPackageRecipe>, target_dir: &Path) -> Vec<PathBuf> {
+    let mut target_dir = target_dir.to_path_buf();
+    if let Some(cross_target) = std::env::var("COOKBOOK_CROSS_TARGET").ok() {
+        if cross_target != "" {
+            // TODO: automatically pass COOKBOOK_CROSS_GNU_TARGET?
+            target_dir = target_dir.join(cross_target)
+        }
+    }
     let mut v = Vec::new();
     for f in features {
         v.push(target_dir.join(format!("stage.{}", f.name)));
     }
     // intentionally added last as it contains leftover files from package features
-    v.push(target_dir.join(format!("stage")));
+    v.push(target_dir.join("stage"));
     v
 }
 
+pub fn get_build_dir(target_dir: &Path) -> PathBuf {
+    let mut target_dir = target_dir.to_path_buf();
+    if let Some(cross_target) = std::env::var("COOKBOOK_CROSS_TARGET").ok() {
+        if cross_target != "" {
+            // TODO: automatically pass COOKBOOK_CROSS_GNU_TARGET?
+            target_dir = target_dir.join(cross_target)
+        }
+    }
+    target_dir.join("build")
+}
+
 fn build_deps_dir(
     logger: &PtyOut,
     deps_dir: &PathBuf,

src/cook/fetch.rs

@@ -228,7 +228,15 @@ pub fn fetch(recipe: &CookRecipe, logger: &PtyOut) -> Result<PathBuf, String> {
                     let (_, remote_branch, remote_name, remote_url) =
                         get_git_remote_tracking(&source_dir)?;
                     // TODO: how to get default branch and compare it here?
-                    if remote_name == "origin" && &remote_url == chop_dot_git(git) {
+                    if let Some(branch) = branch
+                        && branch != &remote_branch
+                    {
+                        false
+                    } else if remote_name != "origin" {
+                        false
+                    } else if &remote_url != chop_dot_git(git) {
+                        false
+                    } else {
                         match get_git_fetch_rev(&source_dir, &remote_url, &remote_branch) {
                             Ok(fetch_rev) => fetch_rev == head_rev,
                             Err(e) => {
@@ -236,8 +244,6 @@ pub fn fetch(recipe: &CookRecipe, logger: &PtyOut) -> Result<PathBuf, String> {
                                 false
                             }
                         }
-                    } else {
-                        false
                     }
                 }
             };

src/cook/fs.rs

@@ -33,7 +33,8 @@ pub fn create_dir_clean(dir: &Path) -> Result<(), String> {
     if dir.is_dir() {
         remove_all(dir)?;
     }
-    create_dir(dir)
+    fs::create_dir_all(dir)
+        .map_err(|err| format!("failed to create '{}': {}\n{:?}", dir.display(), err, err))
 }
 
 pub fn create_target_dir(recipe_dir: &Path, target: &'static str) -> Result<PathBuf, String> {
@@ -292,9 +293,14 @@ pub fn get_git_head_rev(dir: &PathBuf) -> Result<(String, bool), String> {
     let head_str = fs::read_to_string(&git_head)
         .map_err(|e| format!("unable to read {path}: {e}", path = git_head.display()))?;
     if head_str.starts_with("ref: ") {
-        let git_ref = dir.join(".git").join(head_str["ref: ".len()..].trim_end());
-        let ref_str = fs::read_to_string(&git_ref)
-            .map_err(|e| format!("unable to read {path}: {e}", path = git_ref.display()))?;
+        let entry = head_str["ref: ".len()..].trim_end();
+        let git_ref = dir.join(".git").join(entry);
+        let ref_str = if git_ref.is_file() {
+            fs::read_to_string(&git_ref)
+                .map_err(|e| format!("unable to read {path}: {e}", path = git_ref.display()))?
+        } else {
+            get_git_ref_entry(dir, entry)?
+        };
         Ok((ref_str.trim().to_string(), false))
     } else {
         Ok((head_str.trim().to_string(), true))
@@ -306,12 +312,14 @@ pub fn get_git_tag_rev(dir: &PathBuf, tag: &str) -> Result<String, String> {
     if tag.len() == 40 && tag.chars().all(|f| f.is_ascii_hexdigit()) {
         return Ok(tag.to_string());
     }
+    get_git_ref_entry(dir, &format!("refs/tags/{tag}"))
+}
+pub fn get_git_ref_entry(dir: &PathBuf, entry: &str) -> Result<String, String> {
     let git_refs = dir.join(".git/packed-refs");
     let refs_str = fs::read_to_string(&git_refs)
         .map_err(|e| format!("unable to read {path}: {e}", path = git_refs.display()))?;
-    let expected_comment_part = format!("refs/tags/{tag}");
     for line in refs_str.lines() {
-        if line.contains(&expected_comment_part) {
+        if line.contains(entry) {
             let sha = line
                 .split_whitespace()
                 .next()
@@ -321,10 +329,7 @@ pub fn get_git_tag_rev(dir: &PathBuf, tag: &str) -> Result<String, String> {
         }
     }
 
-    Err(format!(
-        "Could not find a rev tag for {}",
-        expected_comment_part
-    ))
+    Err(format!("Could not find a rev for {}", entry))
 }
 
 /// get commit rev after fetch

src/cook/package.rs

@@ -194,7 +194,14 @@ pub fn package_stage_paths(
     package: Option<&OptionalPackageRecipe>,
     target_dir: &Path,
 ) -> (PathBuf, PathBuf, PathBuf) {
-    package_name_paths(package, target_dir, "stage")
+    let mut target_dir = target_dir.to_path_buf();
+    if let Some(cross_target) = std::env::var("COOKBOOK_CROSS_TARGET").ok() {
+        if cross_target != "" {
+            // TODO: automatically pass COOKBOOK_CROSS_GNU_TARGET?
+            target_dir = target_dir.join(cross_target)
+        }
+    }
+    package_name_paths(package, &target_dir, "stage")
 }
 
 pub fn package_source_paths(