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,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=\
+$(PREFIX)/relibc-install: $(PREFIX)/rust-install | $(FSTOOLS_TAG) $(CONTAINER_TAG)
-	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)
 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" && \
+	export CARGO="env -u CARGO cargo" CI=1 && \
-	$(MAKE) clean && \
+	./target/release/repo cook relibc
-	$(MAKE) -j `$(NPROC)` all && \
+	cp -r "$(RELIBC_TARGET)/stage/usr/". "$@.partial/$(GNU_TARGET)"
-	$(MAKE) -j `$(NPROC)` install DESTDIR="$(ROOT)/$@.partial/$(GNU_TARGET)"
-	cd "$@.partial" && $(PREFIX_STRIP)
 	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"
-
+	export CI=1 COOKBOOK_CLEAN_BUILD=true COOKBOOK_HOST_SYSROOT=/usr && \
-	git clone \
+	./target/release/repo cook host:libtool
-		--recurse-submodules \
+	cp -r "$(LIBTOOL_TARGET)/stage/usr/". "$@.partial"
-		--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)`
-
 	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" && \
+	cp -r "$(PREFIX)/libtool-install/". "$@"
-	cd "$(PREFIX)/libtool-build" && \
+# adapt path for libtoolize
-		$(MAKE) install -j `$(NPROC)`
+	$(SED) -i 's|/usr/share|$(ROOT)/$@/share|g' "$@/bin/libtoolize"
-	cd "$@" && $(PREFIX_STRIP)
 	touch "$@"
 endif
 
@@ -170,152 +105,97 @@ endif
 else
 
 # BUILD GCC ---------------------------------------------------
-PREFIX_FREESTANDING_INSTALL=$(PREFIX)/gcc-freestanding-install
+$(PREFIX)/binutils-install: | $(FSTOOLS_TAG) $(CONTAINER_TAG)
-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
 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" "$@"
+	@echo "\033[1;36;49mBuilding gcc-freestanding-install\033[0m"
-	mkdir -p "$<-build" "$@.partial"
+	rm -rf "$@.partial" "$@" $(PREFIX)/relibc-freestanding-install $(PREFIX)/sysroot
-	cd "$<-build" && \
+	mkdir -p "$@.partial" $(PREFIX)/relibc-freestanding-install/$(GNU_TARGET)/include
-	"$(ROOT)/$</configure" \
+	export CI=1 PATH="$(ROOT)/$(PREFIX)/binutils-install/bin:$$PATH" \
-		--target="$(GNU_TARGET)" \
+		COOKBOOK_CLEAN_BUILD=true COOKBOOK_CROSS_TARGET=$(TARGET) COOKBOOK_CROSS_GNU_TARGET=$(GNU_TARGET) \
-		$(GCC_ARCH) \
+		COOKBOOK_HOST_SYSROOT=/usr COOKBOOK_CROSS_SYSROOT=$(ROOT)/$(PREFIX)/relibc-freestanding-install/$(GNU_TARGET) && \
-		--program-prefix="$(GNU_TARGET)-" \
+	./target/release/repo cook host:gcc13
-		--prefix="" \
+	cp -r "$(GCC_TARGET)/stage/usr/". "$@.partial"
-		--disable-werror \
+	cp -r "$(GCC_TARGET)/stage.cxx/usr/". "$@.partial"
-		--enable-default-hash-style=gnu \
+	cp -r "$(PREFIX)/binutils-install/". "$@.partial"
-		&& \
+	rm -rf $(PREFIX)/relibc-freestanding-install
-	$(MAKE) -j `$(NPROC)` all && \
-	$(MAKE) -j `$(NPROC)` install DESTDIR="$(ROOT)/$@.partial"
-	rm -rf "$<-build"
-	cd "$@.partial" && $(PREFIX_STRIP)
 	touch "$@.partial"
 	mv "$@.partial" "$@"
 endif
 
-$(PREFIX)/gcc-$(GCC_BRANCH).tar.bz2:
+$(PREFIX)/relibc-freestanding-install: $(PREFIX)/gcc-freestanding-install | $(FSTOOLS_TAG) $(CONTAINER_TAG)
-	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)
 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" && \
+	export PATH="$(ROOT)/$(PREFIX)/gcc-freestanding-install/bin:$$PATH" && \
-	$(MAKE) clean && \
+	export CC_$(subst -,_,$(TARGET))="$(GNU_TARGET)-gcc -isystem $(ROOT)/$@.partial/$(GNU_TARGET)/include" LINKFLAGS="" && \
-	$(MAKE) -j 1 all && \
+	export CI=1 COOKBOOK_CLEAN_BUILD=true COOKBOOK_HOST_SYSROOT=/usr COOKBOOK_CROSS_TARGET=$(HOST_TARGET) && \
-	$(MAKE) -j 1 install DESTDIR="$(ROOT)/$@.partial/$(GNU_TARGET)"
+	./target/release/repo cook relibc
-	cd "$@.partial" && $(PREFIX_STRIP)
+	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" "$@"
+	@echo "\033[1;36;49mBuilding gcc-install\033[0m"
-	mkdir -p "$<-build"
+	rm -rf "$@.partial" "$@-build.partial" "$@"
-	cp -r "$(PREFIX)/binutils-install" "$@.partial"
+	if [ ! -d "$(ROOT)/$(GCC_TARGET)" ]; then \
-	cd "$<-build" && \
+		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" \
+	$(MAKE) -C "$(ROOT)/$(GCC_TARGET)/build" all-target-libgcc all-target-libstdc++-v3 && \
-		--target="$(GNU_TARGET)" \
+	$(MAKE) -C "$(ROOT)/$(GCC_TARGET)/build" install-target-libgcc install-target-libstdc++-v3 DESTDIR="$(ROOT)/$@-build.partial/usr"
-		$(GCC_ARCH) \
+	cp -r "$@-build.partial/usr/". "$@.partial"
-		--program-prefix="$(GNU_TARGET)-" \
+	@#TODO: in riscv64gc libgcc_s.so is a GNU ld script
-		--prefix="" \
+	rm -f "$@.partial"/$(GNU_TARGET)/lib/libgcc_s.so
-		--with-sysroot \
+	ln -s libgcc_s.so.1 "$@.partial"/$(GNU_TARGET)/lib/libgcc_s.so
-		--with-build-sysroot="$(ROOT)/$(PREFIX)/relibc-freestanding-install/$(GNU_TARGET)" \
+	@#TODO: generates wrong lib path for libtool
-		--with-native-system-header-dir="/include" \
+	rm -f "$@.partial"/$(GNU_TARGET)/lib/libstdc++.la
-		--disable-multilib \
+	rm -f "$@.partial"/$(GNU_TARGET)/lib/libsupc++.la
-		--disable-nls \
+# fully featured libstdcxx, not supported for targets only supporting static linking
-		--disable-werror \
+ifneq ($(TARGET),riscv64gc-unknown-redox)
-		--enable-languages=c,c++ \
+ifneq ($(TARGET),i586-unknown-redox)
-		--enable-shared \
+	export PATH="$(ROOT)/$@.partial/bin:$$PATH" && \
-		--enable-threads=posix \
+	export CI=1 COOKBOOK_CLEAN_BUILD=true "COOKBOOK_HOST_SYSROOT=$(ROOT)/$@.partial" COOKBOOK_CROSS_TARGET=$(HOST_TARGET) && \
-		--with-linker-hash-style=gnu \
+	rm -rf "$(LIBSTDCXX_TARGET)/stage" && ./target/release/repo cook libstdcxx-v3
-		&& \
+	cp -r "$(LIBSTDCXX_TARGET)/stage/usr/". "$@.partial/$(GNU_TARGET)"
-	$(MAKE) -j `$(NPROC)` all-gcc all-target-libgcc all-target-libstdc++-v3 && \
+endif
-	$(MAKE) -j `$(NPROC)` install-gcc install-target-libgcc install-target-libstdc++-v3 DESTDIR="$(ROOT)/$@.partial"
+endif
-	rm $(ROOT)/$@.partial/$(GNU_TARGET)/lib/*.la
+	rm -rf "$@-build.partial"
-	rm -rf "$<-build"
-	cd "$@.partial" && $(PREFIX_STRIP)
 	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}/usr" \
-    DESTDIR="${COOKBOOK_STAGE}" \
     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"
+if [ "${COOKBOOK_HOST_SYSROOT}" = "/usr" ]; then
-ln -sf "${COOKBOOK_SYSROOT}/include" "${COOKBOOK_SYSROOT}/usr/include"
+# not specifying --enable-shared as it will link shared deps
-ln -sf "${COOKBOOK_SYSROOT}/lib" "${COOKBOOK_SYSROOT}/usr/lib"
+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}"
+    --target="${CROSS_GNU_TARGET}"
-    --with-sysroot=/
+    --with-build-sysroot="${COOKBOOK_CROSS_SYSROOT:-$COOKBOOK_SYSROOT}"
-    --with-build-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}" -j "${COOKBOOK_MAKE_JOBS}" all-gcc
-"${COOKBOOK_MAKE}" install-gcc install-target-libgcc install-target-libstdc++-v3 DESTDIR="${COOKBOOK_STAGE}"
+"${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/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"

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(
+    let (recipe_list, recipe_map) = Package::new_recursive_nonstop(target_packages, WALK_DEPTH);
-        &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,
-    );
 
     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 = get_build_dir(target_dir);
-        let build_dir = target_dir.join("build");
+        if clean_build || !build_dir.is_dir() {
-        if !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/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 entry = head_str["ref: ".len()..].trim_end();
-        let ref_str = fs::read_to_string(&git_ref)
+        let git_ref = dir.join(".git").join(entry);
-            .map_err(|e| format!("unable to read {path}: {e}", path = git_ref.display()))?;
+        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!(
+    Err(format!("Could not find a rev for {}", entry))
-        "Could not find a rev tag for {}",
-        expected_comment_part
-    ))
 }
 
 /// 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(