Bootstrap GCC prefix using cookbook

2026-06-17 15:34:18 +08:00 · 2025-12-25 11:02:11 +07:00 · 2025-12-25 11:02:11 +07:00 · eb2a7d7413
commit eb2a7d7413
parent fe9e3f9567
14 changed files with 239 additions and 241 deletions
--- a/mk/config.mk
+++ b/mk/config.mk
@ -54,11 +54,13 @@ 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
 HOST_TARGET := $(shell env -u RUSTUP_TOOLCHAIN rustc -vV | grep host | cut -d: -f2 | tr -d " ")
+HOST_GNU_TARGET := $(shell gcc -dumpmachine)
 # x86_64 linux hosts have all toolchains
 ifneq ($(HOST_TARGET),x86_64-unknown-linux-gnu)
 	ifeq ($(ARCH),aarch64)
@ -101,7 +103,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)
--- a/mk/prefix.mk
+++ b/mk/prefix.mk
@ -4,11 +4,13 @@ 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

@ -16,64 +18,27 @@ 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 | $(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/". "$@.partial"
+# adapt path for libtoolize
+	$(SED) -i 's|/usr/share|$(ROOT)/$@/share|g' "$@/bin/libtoolize"
 	touch "$@"
 endif

@ -170,152 +105,90 @@ 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/$(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/$(TARGET) && \
+	./target/release/repo cook host:gcc13
+	cp -r "$(GCC_TARGET)/stage/usr/". "$@.partial"
+	cp -r "$(GCC_TARGET)/stage.cxx/usr/". "$@.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
+$(PREFIX)/relibc-freestanding-install: $(PREFIX)/gcc-freestanding-install $(PREFIX)/binutils-install | $(FSTOOLS_TAG) $(CONTAINER_TAG)
 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)"
+	@echo "\033[1;36;49mBuilding relibc-freestanding-install\033[0m"
 	rm -rf "$@.partial" "$@"
-	cp -r "$(RELIBC_SOURCE)" "$@.partial"
-	touch "$@.partial"
-	mv "$@.partial" "$@"
-
-
-$(PREFIX)/relibc-freestanding-install: $(PREFIX)/relibc-freestanding | $(PREFIX_FREESTANDING_INSTALL) $(CONTAINER_TAG)
-ifeq ($(PODMAN_BUILD),1)
-	$(PODMAN_RUN) make $@
-else
-	rm -rf "$@.partial" "$@"
-	mkdir -p "$@.partial"
-	cd "$<" && \
-	export PATH="$(PREFIX_FREESTANDING_PATH):$$PATH" && \
+	mkdir -p "$@.partial/$(TARGET)"
 	export CARGO="env -u CARGO -u RUSTUP_TOOLCHAIN cargo" && \
+	export PATH="$(ROOT)/$(PREFIX)/gcc-freestanding-install/bin:$(ROOT)/$(PREFIX)/binutils-install/bin:$$PATH" && \
 	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 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/$(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)/binutils-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)/binutils-install/". "$@.partial"
+	cp -r "$(PREFIX)/libtool-install/". "$@.partial"
+# libgcc
 	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 && \
+	$(MAKE) -C "$(ROOT)/$(GCC_TARGET)/build" install-target-libgcc DESTDIR="$(ROOT)/$@-build.partial/usr"
+	cp -r "$@-build.partial/usr/". "$@.partial"
+# libstdcxx, bare features
+	export PATH="$(ROOT)/$@.partial/bin:$$PATH" && \
+	export CI=1 COOKBOOK_CLEAN_BUILD=true "COOKBOOK_HOST_SYSROOT=$(ROOT)/$@.partial" COOKBOOK_CROSS_TARGET=$(HOST_TARGET) COOKBOOK_CROSS_GNU_TARGET=$(HOST_GNU_TARGET) && \
+	./target/release/repo cook libstdcxx-v3
+	cp -r "$(LIBSTDCXX_TARGET)/stage/usr/". "$@.partial"
+# libstdcxx, full features
+	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)"
+	rm -rf "$@-build.partial"
 	touch "$@.partial"
 	mv "$@.partial" "$@"
+# no longer needed, delete 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 +243,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 +269,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"
--- a/podman/redox-base-containerfile
+++ b/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 \
--- a/recipes/core/relibc/recipe.toml
+++ b/recipes/core/relibc/recipe.toml
@ -1,13 +1,13 @@
-[source]
-git = "https://gitlab.redox-os.org/redox-os/relibc.git"
+# [source]
+# 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
 """
--- a/recipes/dev/binutils-gdb/recipe.toml
+++ b/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
+"""
--- a/recipes/dev/gcc13/recipe.toml
+++ b/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)"
@ -16,29 +18,61 @@ dependencies = [
 ]
 script = """
 DYNAMIC_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-sysroot
+)
+else
+COOKBOOK_CONFIGURE_FLAGS+=(
+    --with-sysroot=/usr
+    --prefix="/usr"
+)
+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-native-system-header-dir="/include"
+    --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
    --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]
--- a/recipes/wip/libs/other/libtool/recipe.toml
+++ b/recipes/wip/libs/other/libtool/recipe.toml
@ -8,6 +8,10 @@ shallow_clone = true
 template = "custom"
 script = """
 DYNAMIC_INIT
+
+# libtool saves absolute path to sysroot which contains nothing
+unset CFLAGS
+
 rsync -av --delete "${COOKBOOK_SOURCE}/" ./
 ./bootstrap \
    --skip-po \
--- a/recipes/libs/libstdcxx-v3/recipe.toml
+++ b/recipes/libs/libstdcxx-v3/recipe.toml
@ -11,6 +11,18 @@ dependencies = [
 ]
 script = """
 DYNAMIC_INIT
+
+# this results C++ missing nice stuff like mutex
+# our prefix workaround this by compiling twice
+if [ ! -z "${COOKBOOK_CROSS_GNU_TARGET}" ]; then
+COOKBOOK_STAGE+="/usr"
+COOKBOOK_CONFIGURE_FLAGS=(
+    --prefix=""
+    --host="${GNU_TARGET}"
+    --disable-hosted-libstdcxx
+)
+fi
+
 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"
--- a/src/bin/repo.rs
+++ b/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,
    )
--- a/src/bin/repo_builder.rs
+++ b/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
--- a/src/config.rs
+++ b/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
--- a/src/cook/cook_build.rs
+++ b/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,
--- a/src/cook/fs.rs
+++ b/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
--- a/src/cook/package.rs
+++ b/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(