banan-os/toolchain/build.sh

#!/bin/bash
set -e

BINUTILS_VERSION="binutils-2.45"
BINUTILS_TAR="$BINUTILS_VERSION.tar.xz"
BINUTILS_URL="https://ftpmirror.gnu.org/gnu/binutils/$BINUTILS_TAR"

GCC_VERSION="gcc-15.2.0"
GCC_TAR="$GCC_VERSION.tar.xz"
GCC_URL="https://ftpmirror.gnu.org/gnu/gcc/$GCC_VERSION/$GCC_TAR"

GRUB_VERSION="grub-2.06"
GRUB_TAR="$GRUB_VERSION.tar.xz"
GRUB_URL="https://ftpmirror.gnu.org/gnu/grub/$GRUB_TAR"

CMAKE_VERSION="cmake-3.26.6-linux-x86_64"
CMAKE_TAR="$CMAKE_VERSION.tar.gz"
CMAKE_URL="https://cmake.org/files/v3.26/$CMAKE_TAR"

MESON_VERSION="meson-1.10.0"
MESON_TAR="$MESON_VERSION.tar.gz"
MESON_URL="https://github.com/mesonbuild/meson/releases/download/1.10.0/$MESON_TAR"

if [[ -z $BANAN_SYSROOT ]]; then
	echo "You must set the BANAN_SYSROOT environment variable" >&2
	exit 1
fi

if [[ -z $BANAN_ROOT_DIR ]]; then
	echo "You must set the BANAN_ROOT_DIR environment variable" >&2
	exit 1
fi

if [[ -z $BANAN_BUILD_DIR ]]; then
	echo "You must set the BANAN_BUILD_DIR environment variable" >&2
	exit 1
fi

if [[ -z $BANAN_SCRIPT_DIR ]]; then
	echo "You must set the BANAN_SCRIPT_DIR environment variable" >&2
	exit 1
fi

if [[ -z $BANAN_TOOLCHAIN_DIR ]]; then
	echo "You must set the BANAN_TOOLCHAIN_DIR environment variable" >&2
	exit 1
fi

if [[ -z $BANAN_TOOLCHAIN_PREFIX ]]; then
	echo "You must set the BANAN_TOOLCHAIN_PREFIX environment variable" >&2
	exit 1
fi

if [[ -z $BANAN_TOOLCHAIN_TRIPLE ]]; then
	echo "You must set the BANAN_TOOLCHAIN_TRIPLE environment variable" >&2
	exit 1
fi

if [[ -z $BANAN_ARCH ]]; then
	echo  "You must set the BANAN_ARCH environment variable" >&2
	exit 1
fi

if [[ -z ${MAKE_JOBS:x} ]]; then
	MAKE_JOBS="-j$(nproc)"
fi

enter_clean_build () {
	rm -rf build-$BANAN_ARCH
	mkdir build-$BANAN_ARCH
	cd build-$BANAN_ARCH
}

build_binutils () {
	cd $BANAN_BUILD_DIR/toolchain

	if [ ! -d $BINUTILS_VERSION ]; then
		if [ ! -f $BINUTILS_TAR ]; then
			echo "Downloading ${BINUTILS_TAR}"
			wget $BINUTILS_URL
		fi
		echo "Unpacking ${BINUTILS_TAR}"
		tar xf $BINUTILS_TAR
		patch -ruN -p1 -d "$BINUTILS_VERSION" < "$BANAN_TOOLCHAIN_DIR/$BINUTILS_VERSION.patch"
	fi

	cd $BANAN_BUILD_DIR/toolchain/$BINUTILS_VERSION
	enter_clean_build

	echo "Building ${BINUTILS_VERSION}"

	../configure \
		--target="$BANAN_TOOLCHAIN_TRIPLE" \
		--prefix="$BANAN_TOOLCHAIN_PREFIX" \
		--with-sysroot="$BANAN_SYSROOT" \
		--enable-initfini-array \
		--enable-shared \
		--enable-lto \
		--disable-nls \
		--disable-werror

	make $MAKE_JOBS
	make install-strip
}

build_gcc () {
	cd $BANAN_BUILD_DIR/toolchain

	if [ ! -d $GCC_VERSION ]; then
		if [ ! -f $GCC_TAR ]; then
			echo "Downloading ${GCC_TAR}"
			wget $GCC_URL
		fi
		echo "Unpacking ${GCC_TAR}"
		tar xf $GCC_TAR
		patch -ruN -p1 -d "$GCC_VERSION" < "$BANAN_TOOLCHAIN_DIR/$GCC_VERSION.patch"
	fi

	cd $BANAN_BUILD_DIR/toolchain/$GCC_VERSION
	enter_clean_build

	echo "Building ${GCC_VERSION}"

	../configure \
		--target="$BANAN_TOOLCHAIN_TRIPLE" \
		--prefix="$BANAN_TOOLCHAIN_PREFIX" \
		--with-sysroot="$BANAN_SYSROOT" \
		--enable-initfini-array \
		--enable-threads=posix \
		--enable-shared \
		--enable-lto \
		--disable-nls \
		--enable-languages=c,c++

	XCFLAGS=""
	if [ $BANAN_ARCH = "x86_64" ]; then
		XCFLAGS="-mcmodel=large -mno-red-zone"
	fi

	make $MAKE_JOBS all-gcc
	make $MAKE_JOBS all-target-libgcc CFLAGS_FOR_TARGET="$XCFLAGS"
	make install-strip-gcc
	make install-strip-target-libgcc
}

build_libstdcpp () {
	if ! [[ -d $BANAN_BUILD_DIR/toolchain/$GCC_VERSION/build-$BANAN_ARCH ]]; then
		echo "You have to build gcc first"
		exit 1
	fi

	cd $BANAN_BUILD_DIR/toolchain/$GCC_VERSION/build-$BANAN_ARCH
	make $MAKE_JOBS all-target-libstdc++-v3
	make install-strip-target-libstdc++-v3
}

build_grub () {
	cd $BANAN_BUILD_DIR/toolchain

	if [ ! -d $GRUB_VERSION ]; then
		if [ ! -f $GRUB_TAR ]; then
			echo "Downloading ${GRUB_TAR}"
			wget $GRUB_URL
		fi
		echo "Unpacking ${GRUB_TAR}"
		tar xvf $GRUB_TAR
	fi

	cd $GRUB_VERSION
	enter_clean_build

	echo "Building ${GRUB_VERSION}"

	../configure \
		--target="$BANAN_ARCH" \
		--prefix="$BANAN_TOOLCHAIN_PREFIX" \
		--with-platform="efi" \
		--disable-werror \
		CFLAGS=--std=gnu11

	make $MAKE_JOBS
	make install
}

build_cmake() {
	cd $BANAN_BUILD_DIR/toolchain

	if [ ! -d $CMAKE_VERSION ]; then
		if [ ! -f $CMAKE_TAR ]; then
			echo "Downloading ${CMAKE_TAR}"
			wget $CMAKE_URL
		fi
		echo "Unpacking ${CMAKE_TAR}"
		tar xvf $CMAKE_TAR
	fi

	cd $CMAKE_VERSION

	echo "Building ${CMAKE_VERSION}"

	mkdir -p $BANAN_TOOLCHAIN_PREFIX/bin
	mkdir -p $BANAN_TOOLCHAIN_PREFIX/share

	cp -r ./bin/* $BANAN_TOOLCHAIN_PREFIX/bin/
	cp -r ./share/* $BANAN_TOOLCHAIN_PREFIX/share/

	cp $BANAN_TOOLCHAIN_DIR/cmake-platform/* $BANAN_TOOLCHAIN_PREFIX/share/cmake-3.26/Modules/Platform/
}

build_meson() {
	cd "$BANAN_BUILD_DIR/toolchain"

	if [ ! -d $MESON_VERSION ]; then
		if [ ! -f $MESON_TAR ]; then
			echo "Downloading ${MESON_TAR}"
			wget $MESON_URL
		fi
		echo "Unpacking ${MESON_TAR}"
		tar xvf $MESON_TAR
	fi

	cd $MESON_VERSION

	echo "Building ${MESON_VERSION}"

	mkdir -p "$BANAN_TOOLCHAIN_PREFIX/bin"

	./packaging/create_zipapp.py --outfile "$BANAN_TOOLCHAIN_PREFIX/bin/meson" --interpreter '/usr/bin/env python3'
}

BUILD_BINUTILS=1
if [[ -f $BANAN_TOOLCHAIN_PREFIX/bin/$BANAN_TOOLCHAIN_TRIPLE-ld ]]; then
	echo "You already seem to have a binutils installed."
	read -e -p "Do you want to rebuild it [y/N]? " choice
	if ! [[ "$choice" == [Yy]* ]]; then
		BUILD_BINUTILS=0
	fi
fi

BUILD_GCC=1
if [[ -f $BANAN_TOOLCHAIN_PREFIX/bin/$BANAN_TOOLCHAIN_TRIPLE-gcc ]]; then
	echo "You already seem to have a gcc installed."
	read -e -p "Do you want to rebuild it [y/N]? " choice
	if ! [[ "$choice" == [Yy]* ]]; then
		BUILD_GCC=0
	fi
fi

BUILD_LIBSTDCPP=$BUILD_GCC
if ! (($BUILD_LIBSTDCPP)); then
	read -e -p "Do you want to rebuild libstdc++ [y/N]? " choice
	if [[ "$choice" == [Yy]* ]]; then
		BUILD_LIBSTDCPP=1
	fi
fi

BUILD_GRUB=1
if [[ -f $BANAN_TOOLCHAIN_PREFIX/bin/grub-mkstandalone ]]; then
	echo "You already seem to have a grub installed."
	read -e -p "Do you want to rebuild it [y/N]? " choice
	if ! [[ "$choice" == [Yy]* ]]; then
		BUILD_GRUB=0
	fi
fi

BUILD_CMAKE=1
if [[ -f $BANAN_TOOLCHAIN_PREFIX/bin/cmake ]]; then
	echo "You already seem to have a cmake installed."
	read -e -p "Do you want to rebuild it [y/N]? " choice
	if ! [[ "$choice" == [Yy]* ]]; then
		BUILD_CMAKE=0
	fi
fi

BUILD_MESON=1
if [[ -f $BANAN_TOOLCHAIN_PREFIX/bin/meson ]]; then
	echo "You already seem to have a meson installed."
	read -e -p "Do you want to rebuild it [y/N]? " choice
	if ! [[ "$choice" == [Yy]* ]]; then
		BUILD_MESON=0
	fi
fi

# delete everything but toolchain
mkdir -p $BANAN_BUILD_DIR
find $BANAN_BUILD_DIR -mindepth 1 -maxdepth 1 ! -name toolchain -exec rm -r {} +

# NOTE: we have to manually create initial sysroot with libc headers
#       since cmake cannot be invoked yet
mkdir -p $BANAN_SYSROOT/usr
cp -r $BANAN_ROOT_DIR/userspace/libraries/LibC/include $BANAN_SYSROOT/usr/include

mkdir -p $BANAN_BUILD_DIR/toolchain

if (($BUILD_BINUTILS)); then
	build_binutils
fi

if (($BUILD_GCC)); then
	build_gcc
fi

if (($BUILD_GRUB)); then
	build_grub
fi

if (($BUILD_CMAKE)); then
	build_cmake
fi

if (($BUILD_MESON)); then
	build_meson
fi

if (($BUILD_LIBSTDCPP)); then
	# delete sysroot and install libc
	rm -r $BANAN_SYSROOT
	$BANAN_SCRIPT_DIR/build.sh libc-static
	$BANAN_SCRIPT_DIR/build.sh libc-shared
	$BANAN_SCRIPT_DIR/build.sh install

	build_libstdcpp
fi