automation: build python targets in pipeline ci-cd

done using a 2d matrix involving the build type (regular or with python)

.github/workflows/pr-pipeline.yaml

@@ -0,0 +1,25 @@
+name: gdb-static-pr-pipeline
+
+on:
+  pull_request:
+    branches:
+      - '*'
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        build_type: ["build", "build-with-python"]
+        architecture: ["x86_64", "arm", "aarch64", "powerpc", "mips", "mipsel"]
+
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        submodules: recursive
+
+    - name: Install dependencies
+      run: sudo apt-get install -y wget
+
+    - name: Build
+      run: make ${{ matrix.build_type }}-${{ matrix.architecture }} -j$((`nproc`+1))

.github/workflows/release-pipeline.yaml

@@ -0,0 +1,30 @@
+name: gdb-static-release-pipeline
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+# Use a non-parallel single job pipeline because artifacts weigh too much. Instead,
+# simply build the files in the same job they are released.
+jobs:
+  build_and_publish:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        submodules: recursive
+
+    - name: Install dependencies
+      run: sudo apt-get install -y wget
+
+    - name: Build
+      run: make build -j$((`nproc`+1))
+
+    - name: Pack
+      run: make pack
+
+    - name: Publish release
+      uses: softprops/action-gh-release@v2
+      with:
+        files: build/artifacts/gdb-static*.tar.gz

.gitignore

@@ -0,0 +1,6 @@
+# IDE Folders
+.idea/
+.vscode/
+
+# Build folders
+build/

.gitmodules

@@ -0,0 +1,8 @@
+[submodule "cpython-static"]
+	path = src/submodule_packages/cpython-static
+	url = git@github.com:guyush1/cpython-static.git
+	branch = python3.12-static
+[submodule "binutils-gdb-static"]
+	path = src/submodule_packages/binutils-gdb
+	url = git@github.com:guyush1/binutils-gdb.git
+	branch = gdb-static

Dockerfile

@@ -0,0 +1,32 @@
+FROM ubuntu:24.04
+
+# Install dependencies
+RUN apt update && apt install -y \
+    bison \
+    file \
+    flex \
+    g++ \
+    g++-aarch64-linux-gnu \
+    g++-arm-linux-gnueabi \
+    g++-mips-linux-gnu \
+    g++-mipsel-linux-gnu \
+    g++-powerpc-linux-gnu \
+    gcc \
+    gcc-aarch64-linux-gnu \
+    gcc-arm-linux-gnueabi \
+    gcc-mips-linux-gnu \
+    gcc-mipsel-linux-gnu \
+    gcc-powerpc-linux-gnu \
+    git \
+    libncurses-dev \
+    m4  \
+    make \
+    patch \
+    pkg-config \
+    python3.12 \
+    libpython3-dev \
+    texinfo \
+    wget \
+    xz-utils
+
+WORKDIR /app/gdb

Makefile

@@ -0,0 +1,84 @@
+ARCHS := x86_64 arm aarch64 powerpc mips mipsel
+
+TARGETS := $(addprefix build-, $(ARCHS))
+PYTHON_TARGETS := $(addprefix build-with-python-, $(ARCHS))
+ALL_TARGETS := $(TARGETS) $(PYTHON_TARGETS)
+
+PACK_TARGETS := $(addprefix pack-, $(ARCHS))
+PYTHON_PACK_TARGETS := $(addprefix pack-with-python-, $(ARCHS))
+ALL_PACK_TARGETS := $(PACK_TARGETS) $(PYTHON_PACK_TARGETS)
+
+SUBMODULE_PACKAGES := $(wildcard src/submodule_packages/*)
+BUILD_PACKAGES_DIR := "build/packages"
+
+.PHONY: clean help download_packages build build-docker-image $(ALL_TARGETS) $(ALL_PACK_TARGETS)
+
+help:
+	@echo "Usage:"
+	@echo "  make build"
+	@echo ""
+
+	@for target in $(ALL_TARGETS); do \
+		echo "  $$target"; \
+	done
+
+	@echo ""
+	@echo "  make clean"
+
+build/build-docker-image.stamp: Dockerfile
+	mkdir -p build
+	docker buildx build --tag gdb-static .
+	touch build/build-docker-image.stamp
+
+build-docker-image: build/build-docker-image.stamp
+
+build/download-packages.stamp: build/build-docker-image.stamp src/compilation/download_packages.sh
+	mkdir -p $(BUILD_PACKAGES_DIR)
+	docker run --user $(shell id -u):$(shell id -g) \
+		--rm --volume .:/app/gdb gdb-static env TERM=xterm-256color \
+		/app/gdb/src/compilation/download_packages.sh /app/gdb/$(BUILD_PACKAGES_DIR)/
+	touch build/download-packages.stamp
+
+build/symlink-git-packages.stamp: $(SUBMODULE_PACKAGES)
+	mkdir -p $(BUILD_PACKAGES_DIR)
+	ln -sf $(addprefix /app/gdb/, $(SUBMODULE_PACKAGES)) $(BUILD_PACKAGES_DIR)/
+
+symlink-git-packages: build/symlink-git-packages.stamp
+
+download-packages: build/download-packages.stamp
+
+build: $(ALL_TARGETS)
+
+$(TARGETS): build-%:
+	@$(MAKE) _build-$*
+
+$(PYTHON_TARGETS): build-with-python-%:
+	@WITH_PYTHON="--with-python" $(MAKE) _build-$*
+
+_build-%: symlink-git-packages download-packages build-docker-image
+	mkdir -p build
+	docker run --user $(shell id -u):$(shell id -g) \
+		--rm --volume .:/app/gdb gdb-static env TERM=xterm-256color \
+		/app/gdb/src/compilation/build.sh $* /app/gdb/build/ /app/gdb/src $(WITH_PYTHON)
+
+pack: $(ALL_PACK_TARGETS)
+
+$(PACK_TARGETS): pack-%:
+	@$(MAKE) _pack-$*
+
+$(PYTHON_PACK_TARGETS): pack-with-python-%:
+	@TAR_EXT="with-python-" ARTIFACT_EXT="_with_python" $(MAKE) _pack-$*
+
+_pack-%: build-%
+	if [ ! -f "build/artifacts/gdb-static-$(TAR_EXT)$*.tar.gz" ]; then \
+		tar -czf "build/artifacts/gdb-static-$(TAR_EXT)$*.tar.gz" -C "build/artifacts/$*$(ARTIFACT_EXT)" .; \
+	fi
+
+clean-git-packages:
+	git submodule foreach '[[ ! "$$sm_path" == src/submodule_packages/* ]] || git clean -xffd'
+
+clean: clean-git-packages
+	rm -rf build
+# Kill and remove all containers of image gdb-static
+	docker ps -a | grep -P "^[a-f0-9]+\s+gdb-static\s+" | awk '{print $$1}' | xargs docker rm -f 2>/dev/null || true
+	docker rmi -f gdb-static 2>/dev/null || true

README.md

@@ -1,93 +1,54 @@
 # Repository of static gdb and gdbserver
 
-The statically compiled gdb / gdbserver binaries are avaliable to download under github releases! 
+## **The statically compiled gdb / gdbserver binaries are avaliable to download under github releases!**
 
-# Notes about this file - read before proceeding!
+link: [gdb-static github releases](https://github.com/guyush1/gdb-static/releases)
 
-While i already provided the gdb/gdbserver-15 statically compiled binaries handed out to you, some people might want to compile it to a different architecture, or compile a newer version of gdb in the future :). This rest of the file contains my compilation documentation so that you could save yourself some time and do it yourself, if you wish.
+## For manual gdb/gdbserver compilation instructions, have a look at the compilation.md file
 
-## <VARAIBLES> in the script
+## Compiling gdb using docker
 
-When specifying the compilation dir throughout the compilation process (specified as <COMPILATION_DIR_PATH> in this file), DO NOT use relative pathing, or bash characters such as `~`. They will not get parsed correctly! Instead, use absolute paths only.
+This repository contains a dockerfile and build scripts to compile gdb and gdbserver statically for multiple architectures.
+Currently, the supported architectures are:
+- x86_64
+- arm
+- aarch64
+- powerpc (32bit)
+You can easily expand it to support more architectures by adding the appropriate cross compilers to the dockerfile, and other build scripts.
 
-Examples to the <VARIABLES> throughout the script:
+NOTE: You don't need to interact with the dockerfile directly, as the Makefile will take care of everything for you.
-<CROSS_COMPILER_C> - arm-linux-gnueabi-gcc
-<CROSS_COMPILER_CPP> - arm-linux-gnueabi-g++
-<HOST_NAME> - arm-linux-gnueabi
-<COMPILATION_DIR_PATH> - /home/username/projects/libgmp-x.y.z/build-arm/
 
-Environment info:
+### Building for a specific architecture
-- glibc version: 2.39-0ubuntu8.3 (NOTE: When i compiled gdb-15 using an older glibc, such as the one i had in my ubuntu-20.04 machine, i received a segfault in gdb...).
 
-# Compiling gdb statically to the host platform
+To build for a specific architecture, you can use the following command:
+```bash
+make build-<ARCH>
+```
 
-## 1) Compiling iconv
+For example, to build for arm:
+```bash
+make build-arm
+```
 
-While compiling iconv is not a must, the libc-provided iconv (a utility to convert between encodings) may fail on different architectures,
+The resulting binaries will be placed under the `build/artifacts/` directory.
-at least in my experiance. Thus, I recommended using a custom libiconv and compiling it into gdb.
+Each architecture will have its own directory under `build/artifacts/`. For example, the arm architecture will have the following directory structure:
+```
+build/
+    artifacts/
+        arm/
+            ...
+```
 
-Download the source from https://github.com/roboticslibrary/libiconv.git
+### Building for all architectures
-Make sure to check out to a stable tag (in my case - v1.17).
 
-Work according to the following steps:
+To build for all architectures, you can use the following command:
-I) run `./gitsub.sh pull`
+```bash
-II) run `./autogen.sh` to create the configure script from configure.sh.
+make build
-III) create a build dir (e.g build), and then cd into it.
+```
-IV) run `../configure --enable-static`
-V) run `cp -r ./include ./lib/.libs/`
-VI) run `mkdir ./lib/.libs/lib/`
-VII) run `cp ./lib/.libs/libiconv.a ./lib/.libs/lib/`
 
-## 2) Compiling gdb
+### Cleaning the build
 
-Clone gdb from sourceware - https://sourceware.org/git/binutils-gdb.git.
+To clean the build, you can use the following command:
-I checked out to the 15.1 tag.
+```bash
-
+make clean
-Work according to the following steps:
+```
-I) Apply my patches - if you are not on the exact tag i used (15.1) - you might need to apply them manually.
-II) create a build dir.
-III) run `../configure --enable-static --with-static-standard-libraries --disable-tui --disable-inprocess-agent --with-libiconv-prefix=<COMPILATION_DIR_PATH>/lib/.libs/ --with-libiconv-type=static`
-IV) run `make all-gdb -j$(nproc)` - for gdbserver, run `make all-gdbserver -j$(nproc)`.
-
-gdb will sit under gdb/gdb.
-gdbserver will sit under gdbserver/gdbserver.
-
-# Cross compiling gdb statically to other architectures.
-
-Cross compiling gdb statically is a bit more complicated then regular static compilation. In order to cross compile gdb statically, we will need to compile libgmp and libmpfr as well as iconv.
-
-## 1) Compiling iconv
-
-Work according to the same process as described under the compilation to the host platform, aside from the configure script:
-IV) run `../configure --enable-static CC=<CROSS_COMPILER_C> CXX=<CROSS_COMPILER_CPP> --host=<HOST_NAME>`
-
-## 2) Compiling libgmp
-
-Download and extract the latest edition from https://gmplib.org/.
-I used the 6.3.0 edition.
-
-Work according to the following steps:
-I) Create a build dir and cd into it.
-II) run `../configure CC=<CROSS_COMPILER_C> CXX=<CROSS_COMPILER_CPP> --enable-static --host=<HOST_NAME>`
-III) run `make -j$(nproc)`
-IV) run `mkdir ./.libs/include/`
-V) run `cp gmp.h ./.libs/include/`
-VI) run `mkdir ./.libs/lib`
-VII) run `cp ./.libs/libgmp.a ./.libs/lib`
-
-## 3) Compiling libmpfr
-
-Download and extract the latest edition from https://www.mpfr.org/.
-I used the 4.2.1 edition.
-
-Work according to the following steps:
-I) Create a build dir and cd into it.
-II) run `../configure CC=<CROSS_COMPILER_C> CXX=<CROSS_COMPILER_CPP> --enable-static --with-gmp-build=<COMPILATION_DIR_PATH> --host=<HOST_NAME>`
-III) run `make -j$(nproc)`
-IV) run `mkdir ./src/.libs/lib`
-V) run `cp ./src/.libs/libmpfr.a ./src/.libs/lib`
-
-## 4) Compiling gdb
-
-Work according to the same process as described under the compilation to the host platform, aside from the configure script:
-III) run `../configure --enable-static --with-static-standard-libraries --disable-tui --disable-inprocess-agent --with-libiconv-prefix=<COMPILATION_DIR_PATH>/lib/.libs/ --with-libiconv-type=static --with-gmp=<COMPILATION_DIR_PATH>/.libs/ --with-mpfr=<COMPILATION_DIR_PATH>/src/.libs/ CC=<CROSS_COMPILER_C> CXX=<CROSS_COMPILER_CPP> --host=<HOST_NAME>`

compilation.md

@@ -0,0 +1,91 @@
+# Notes about this file - read before proceeding!
+
+While i have already provided the gdb/gdbserver-15 statically compiled binaries for you, some people might want to compile it to a different architecture (without our build scripts), or compile a newer version of gdb in the future :). The rest of the file contains a documentation of the compilation process, in order to help you out.
+
+## <VARAIBLES> in the script
+
+When specifying the compilation dir throughout the compilation process (specified as <COMPILATION_DIR_PATH> in this file), DO NOT use relative pathing, or bash characters such as `~`. They will not get parsed correctly! Instead, use absolute paths only.
+
+Examples to the <VARIABLES> throughout the script:
+<CROSS_COMPILER_C> - arm-linux-gnueabi-gcc
+<CROSS_COMPILER_CPP> - arm-linux-gnueabi-g++
+<HOST_NAME> - arm-linux-gnueabi
+<COMPILATION_DIR_PATH> - /home/username/projects/libgmp-x.y.z/build-arm/
+
+Environment info:
+- glibc version: 2.39-0ubuntu8.3 (NOTE: When i compiled gdb-15 using an older glibc, such as the one i had in my ubuntu-20.04 machine, i received a segfault in gdb...).
+
+# Compiling gdb statically to the host platform
+
+## 1) Compiling iconv
+
+While compiling iconv is not a must, the libc-provided iconv (a utility to convert between encodings) may fail on different architectures,
+at least in my experiance. Thus, I recommended using a custom libiconv and compiling it into gdb.
+
+Download the source from https://github.com/roboticslibrary/libiconv.git
+Make sure to check out to a stable tag (in my case - v1.17).
+
+Work according to the following steps:
+I) run `./gitsub.sh pull`
+II) run `./autogen.sh` to create the configure script from configure.sh.
+III) create a build dir (e.g build), and then cd into it.
+IV) run `../configure --enable-static`
+V) run `cp -r ./include ./lib/.libs/`
+VI) run `mkdir ./lib/.libs/lib/`
+VII) run `cp ./lib/.libs/libiconv.a ./lib/.libs/lib/`
+
+## 2) Compiling gdb
+
+Clone gdb from sourceware - https://sourceware.org/git/binutils-gdb.git.
+I checked out to the 15.2 tag.
+
+Work according to the following steps:
+I) Apply my patches (gdb_static.patch). If you are not on the exact tag i used (15.2) - you might need to apply them manually, and change some stuff.
+II) create a build dir.
+III) run `../configure --enable-static --with-static-standard-libraries --disable-tui --disable-inprocess-agent --with-libiconv-prefix=<COMPILATION_DIR_PATH>/lib/.libs/ --with-libiconv-type=static`
+IV) run `make all-gdb -j$(nproc)` - for gdbserver, run `make all-gdbserver -j$(nproc)`.
+
+gdb will sit under gdb/gdb.
+gdbserver will sit under gdbserver/gdbserver.
+
+# Cross compiling gdb statically to other architectures.
+
+Cross compiling gdb statically is a bit more complicated then regular static compilation. In order to cross compile gdb statically, we will need to compile libgmp and libmpfr as well as iconv.
+
+## 1) Compiling iconv
+
+Work according to the same process as described under the compilation to the host platform, aside from the configure script:
+IV) run `../configure --enable-static CC=<CROSS_COMPILER_C> CXX=<CROSS_COMPILER_CPP> --host=<HOST_NAME>`
+
+## 2) Compiling libgmp
+
+Download and extract the latest edition from https://gmplib.org/.
+I used the 6.3.0 edition.
+
+Work according to the following steps:
+I) Create a build dir and cd into it.
+II) run `../configure CC=<CROSS_COMPILER_C> CXX=<CROSS_COMPILER_CPP> --enable-static --host=<HOST_NAME>`
+III) run `make -j$(nproc)`
+IV) run `mkdir ./.libs/include/`
+V) run `cp gmp.h ./.libs/include/`
+VI) run `mkdir ./.libs/lib`
+VII) run `cp ./.libs/libgmp.a ./.libs/lib`
+
+## 3) Compiling libmpfr
+
+Download and extract the latest edition from https://www.mpfr.org/.
+I used the 4.2.1 edition.
+
+Work according to the following steps:
+I) Create a build dir and cd into it.
+II) run `../configure CC=<CROSS_COMPILER_C> CXX=<CROSS_COMPILER_CPP> --enable-static --with-gmp-build=<COMPILATION_DIR_PATH> --host=<HOST_NAME>`
+III) run `make -j$(nproc)`
+IV) run `mkdir ./src/.libs/lib`
+V) run `cp ./src/.libs/libmpfr.a ./src/.libs/lib`
+VI) run `mkdir ./src/.libs/include`
+VII) run `cp ../src/mpfr.h ./src/.libs/include/`
+
+## 4) Compiling gdb
+
+Work according to the same process as described under the compilation to the host platform, aside from the configure script:
+III) run `../configure --enable-static --with-static-standard-libraries --disable-tui --disable-inprocess-agent --with-libiconv-prefix=<COMPILATION_DIR_PATH>/lib/.libs/ --with-libiconv-type=static --with-gmp=<COMPILATION_DIR_PATH>/.libs/ --with-mpfr=<COMPILATION_DIR_PATH>/src/.libs/ CC=<CROSS_COMPILER_C> CXX=<CROSS_COMPILER_CPP> --host=<HOST_NAME>`

src/compilation/build.sh

@@ -0,0 +1,557 @@
+#!/bin/bash
+
+# Include utils library
+script_dir=$(dirname "$0")
+source "$script_dir/utils.sh"
+
+# Don't want random unknown things to fail in the build procecss!
+set -e
+
+function set_compliation_variables() {
+    # Set compilation variables such as which compiler to use.
+    #
+    # Parameters:
+    # $1: target architecture
+    #
+    # Returns:
+    # 0: success
+    # 1: failure
+    supported_archs=("arm" "aarch64" "powerpc" "x86_64" "mips" "mipsel")
+
+    local target_arch="$1"
+
+    if [[ ! " ${supported_archs[@]} " =~ " ${target_arch} " ]]; then
+        >&2 echo "Error: unsupported target architecture: $target_arch"
+        return 1
+    fi
+
+    >&2 fancy_title "Setting compilation variables for $target_arch"
+
+    if [[ "$target_arch" == "arm" ]]; then
+        CROSS=arm-linux-gnueabi-
+        export HOST=arm-linux-gnueabi
+    elif [[ "$target_arch" == "aarch64" ]]; then
+        CROSS=aarch64-linux-gnu-
+        export HOST=aarch64-linux-gnu
+    elif [[ "$target_arch" == "powerpc" ]]; then
+        CROSS=powerpc-linux-gnu-
+        export HOST=powerpc-linux-gnu
+    elif [[ "$target_arch" == "mips" ]]; then
+        CROSS=mips-linux-gnu-
+        export HOST=mips-linux-gnu
+    elif [[ "$target_arch" == "mipsel" ]]; then
+        CROSS=mipsel-linux-gnu-
+        export HOST=mipsel-linux-gnu
+    elif [[ "$target_arch" == "x86_64" ]]; then
+        CROSS=x86_64-linux-gnu-
+        export HOST=x86_64-linux-gnu
+    fi
+
+    export CC="${CROSS}gcc"
+    export CXX="${CROSS}g++"
+
+    export CFLAGS="-O2"
+    export CXXFLAGS="-O2"
+
+    # Strip the binary to reduce it's size.
+    export LDFLAGS="-s"
+}
+
+function set_ncurses_link_variables() {
+    # Set up ncurses library link variables
+    #
+    # Parameters:
+    # $1: ncursesw build dir
+    local ncursesw_build_dir="$1"
+
+    # Allow tui mode by adding our custom built static ncursesw library to the linker search path.
+    export LDFLAGS="-L$ncursesw_build_dir/lib $LDFLAGS"
+}
+
+function build_iconv() {
+    # Build libiconv.
+    #
+    # Parameters:
+    # $1: iconv package directory
+    # $2: target architecture
+    #
+    # Echoes:
+    # The libiconv build directory
+    #
+    # Returns:
+    # 0: success
+    # 1: failure
+
+    local iconv_dir="$1"
+    local target_arch="$2"
+    local iconv_build_dir="$(realpath "$iconv_dir/build-$target_arch")"
+
+    echo "$iconv_build_dir"
+    mkdir -p "$iconv_build_dir"
+
+    if [[ -f "$iconv_build_dir/lib/.libs/libiconv.a" ]]; then
+        >&2 echo "Skipping build: iconv already built for $target_arch"
+        return 0
+    fi
+
+    pushd "$iconv_build_dir" > /dev/null
+
+    >&2 fancy_title "Building libiconv for $target_arch"
+
+    ../configure --enable-static "CC=$CC" "CXX=$CXX" "--host=$HOST" \
+        "CFLAGS=$CFLAGS" "CXXFLAGS=$CXXFLAGS" 1>&2
+    if [[ $? -ne 0 ]]; then
+        return 1
+    fi
+
+    make -j$(nproc) 1>&2
+    if [[ $? -ne 0 ]]; then
+        return 1
+    fi
+
+    cp -r ./include ./lib/.libs/
+    mkdir -p ./lib/.libs/lib/
+    cp ./lib/.libs/libiconv.a ./lib/.libs/lib/
+
+    >&2 fancy_title "Finished building libiconv for $target_arch"
+
+    popd > /dev/null
+}
+
+function build_libgmp() {
+    # Build libgmp.
+    #
+    # Parameters:
+    # $1: libgmp package directory
+    # $2: target architecture
+    #
+    # Echoes:
+    # The libgmp build directory
+    #
+    # Returns:
+    # 0: success
+    # 1: failure
+
+    local gmp_dir="$1"
+    local target_arch="$2"
+    local gmp_build_dir="$(realpath "$gmp_dir/build-$target_arch")"
+
+    echo "$gmp_build_dir"
+    mkdir -p "$gmp_build_dir"
+
+    if [[ -f "$gmp_build_dir/.libs/lib/libgmp.a" ]]; then
+        >&2 echo "Skipping build: libgmp already built for $target_arch"
+        return 0
+    fi
+
+    pushd "$gmp_build_dir" > /dev/null
+
+    >&2 fancy_title "Building libgmp for $target_arch"
+
+    ../configure --enable-static "CC=$CC" "CXX=$CXX" "--host=$HOST" \
+        "CFLAGS=$CFLAGS" "CXXFLAGS=$CXXFLAGS" 1>&2
+    if [[ $? -ne 0 ]]; then
+        return 1
+    fi
+
+    make -j$(nproc) 1>&2
+    if [[ $? -ne 0 ]]; then
+        return 1
+    fi
+
+    mkdir -p ./.libs/include/
+    cp gmp.h ./.libs/include/
+    mkdir -p ./.libs/lib/
+    cp ./.libs/libgmp.a ./.libs/lib/
+
+    >&2 fancy_title "Finished building libgmp for $target_arch"
+
+    popd > /dev/null
+}
+
+function build_ncurses() {
+    # Build libncursesw.
+    #
+    # Parameters:
+    # $1: libncursesw package directory
+    # $2: target architecture
+    #
+    # Echoes:
+    # The libncursesw build directory
+    #
+    # Returns:
+    # 0: success
+    # 1: failure
+    local ncurses_dir="$1"
+    local target_arch="$2"
+    local ncurses_build_dir="$(realpath "$ncurses_dir/build-$target_arch")"
+
+    echo "$ncurses_build_dir"
+    mkdir -p "$ncurses_build_dir"
+
+    if [[ -f "$ncurses_build_dir/lib/libncursesw.a" ]]; then
+        >&2 echo "Skipping build: libncursesw already built for $target_arch"
+        return 0
+    fi
+
+    pushd "$ncurses_build_dir" > /dev/null
+
+    >&2 fancy_title "Building libncursesw for $target_arch"
+
+    ../configure --enable-static "CC=$CC" "CXX=$CXX" "--host=$HOST" \
+        "CFLAGS=$CFLAGS" "CXXFLAGS=$CXXFLAGS" "--enable-widec" 1>&2
+    if [[ $? -ne 0 ]]; then
+        return 1
+    fi
+
+    make -j$(nproc) 1>&2
+    if [[ $? -ne 0 ]]; then
+        return 1
+    fi
+
+    >&2 fancy_title "Finished building libncursesw for $target_arch"
+
+    popd > /dev/null
+}
+
+function build_python() {
+    # Build python.
+    #
+    # Parameters:
+    # $1: python package directory
+    # $2: target architecture
+    #
+    # Echoes:
+    # The python build directory
+    #
+    # Returns:
+    # 0: success
+    # 1: failure
+    local python_dir="$1"
+    local target_arch="$2"
+    local python_lib_dir="$(realpath "$python_dir/build-$target_arch")"
+
+    echo "$python_lib_dir"
+    mkdir -p "$python_lib_dir"
+
+    # Having a python-config file is an indication that we successfully built python.
+    if [[ -f "$python_lib_dir/python-config" ]]; then
+        >&2 echo "Skipping build: libpython already built for $target_arch"
+        return 0
+    fi
+
+    pushd "$python_lib_dir" > /dev/null
+    >&2 fancy_title "Building python for $target_arch"
+
+    export LINKFORSHARED=" "
+    export MODULE_BUILDTYPE="static"
+    export CONFIG_SITE="$python_dir/config.site-static"
+    >&2 CFLAGS="-static" LDFLAGS="-static" ../configure \
+        --prefix=$(realpath .) \
+        --disable-test-modules \
+        --with-ensurepip=no \
+        --without-decimal-contextvar \
+        --build=x86_64-pc-linux-gnu \
+        --host=$HOST \
+        --with-build-python=/usr/bin/python3.12 \
+        --disable-ipv6 \
+        --disable-shared
+
+    >&2 make -j $(nproc)
+    if [[ $? -ne 0 ]]; then
+        return 1
+    fi
+
+    # Install python (in build dir using the prefix set above), in order to have a bash (for cross-compilation) python3-config that works.
+    >&2 make install
+    if [[ $? -ne 0 ]]; then
+        return 1
+    fi
+
+    >&2 fancy_title "Finished building python for $target_arch"
+    popd > /dev/null
+}
+
+function build_libmpfr() {
+    # Build libmpfr.
+    #
+    # Parameters:
+    # $1: mpfr package directory
+    # $2: libgmp build directory
+    # $3: target architecture
+    #
+    # Echoes:
+    # The libmpfr build directory
+    #
+    # Returns:
+    # 0: success
+    # 1: failure
+
+    local mpfr_dir="$1"
+    local libgmp_build_dir="$2"
+    local target_arch="$3"
+    local mpfr_build_dir="$(realpath "$mpfr_dir/build-$target_arch")"
+
+    mkdir -p "$mpfr_build_dir"
+    echo "$mpfr_build_dir"
+
+    if [[ -f "$mpfr_build_dir/src/.libs/lib/libmpfr.a" ]]; then
+        >&2 echo "Skipping build: libmpfr already built for $target_arch"
+        return 0
+    fi
+
+    pushd "$mpfr_dir/build-$target_arch" > /dev/null
+
+    >&2 fancy_title "Building libmpfr for $target_arch"
+
+    ../configure --enable-static "--with-gmp-build=$libgmp_build_dir" \
+        "CC=$CC" "CXX=$CXX" "--host=$HOST" \
+        "CFLAGS=$CFLAGS" "CXXFLAGS=$CXXFLAGS" 1>&2
+    if [[ $? -ne 0 ]]; then
+        return 1
+    fi
+
+    make -j$(nproc) 1>&2
+    if [[ $? -ne 0 ]]; then
+        return 1
+    fi
+
+    mkdir -p ./src/.libs/include
+    cp ../src/mpfr.h ./src/.libs/include/
+    mkdir -p ./src/.libs/lib
+    cp ./src/.libs/libmpfr.a ./src/.libs/lib/
+
+    >&2 fancy_title "Finished building libmpfr for $target_arch"
+
+    popd > /dev/null
+}
+
+function build_gdb() {
+    # Configure and build gdb.
+    #
+    # Parameters:
+    # $1: gdb directory
+    # $2: target architecture
+    # $3: libiconv prefix
+    # $4: libgmp prefix
+    # $5: libmpfr prefix
+    # $6: whether to build with python or not
+    #
+    # Echoes:
+    # The gdb build directory
+    #
+    # Returns:
+    # 0: success
+    # 1: failure
+
+    local gdb_dir="$1"
+    local target_arch="$2"
+    local libiconv_prefix="$3"
+    local libgmp_prefix="$4"
+    local libmpfr_prefix="$5"
+    local with_python="$6"
+
+    if [[ "$with_python" == "yes" ]]; then
+        local python_flag="--with-python=/app/gdb/build/packages/cpython-static/build-$target_arch/bin/python3-config"
+        local gdb_build_dir="$(realpath "$gdb_dir/build-${target_arch}_with_python")"
+    else
+        local python_flag="--without-python"
+        local gdb_build_dir="$(realpath "$gdb_dir/build-${target_arch}")"
+    fi
+
+    echo "$gdb_build_dir"
+    mkdir -p "$gdb_build_dir"
+
+    if [[ -f "$gdb_build_dir/gdb/gdb" ]]; then
+        >&2 echo "Skipping build: gdb already built for $target_arch"
+        return 0
+    fi
+
+    pushd "$gdb_build_dir" > /dev/null
+
+    >&2 fancy_title "Building gdb for $target_arch"
+
+    ../configure -C --enable-static --with-static-standard-libraries --disable-inprocess-agent \
+                 --enable-tui "$python_flag" \
+                 "--with-libiconv-prefix=$libiconv_prefix" --with-libiconv-type=static \
+                 "--with-gmp=$libgmp_prefix" \
+                 "--with-mpfr=$libmpfr_prefix" \
+                 "CC=$CC" "CXX=$CXX" "--host=$HOST" \
+                 "CFLAGS=$CFLAGS" "CXXFLAGS=$CXXFLAGS" 1>&2
+    if [[ $? -ne 0 ]]; then
+        return 1
+    fi
+
+    make -j$(nproc) 1>&2
+    if [[ $? -ne 0 ]]; then
+        return 1
+    fi
+
+    >&2 fancy_title "Finished building gdb for $target_arch"
+
+    popd > /dev/null
+}
+
+function install_gdb() {
+    # Install gdb binaries to an artifacts directory.
+    #
+    # Parameters:
+    # $1: gdb build directory
+    # $2: artifacts directory
+    # $3: target architecture
+    # $4: whether gdb was built with or without python
+    #
+    # Returns:
+    # 0: success
+    # 1: failure
+
+    local gdb_build_dir="$1"
+    local artifacts_dir="$2"
+    local target_arch="$3"
+    local with_python="$4"
+
+    if [[ "$with_python" == "yes" ]]; then
+        local artifacts_location="$artifacts_dir/${target_arch}_with_python"
+    else
+        local artifacts_location="$artifacts_dir/${target_arch}"
+    fi
+
+    if [[ -d "$artifacts_location" && -n "$(ls -A "$artifacts_location")" ]]; then
+        >&2 echo "Skipping install: gdb already installed for $target_arch"
+        return 0
+    fi
+
+    temp_artifacts_dir="$(mktemp -d)"
+
+    mkdir -p "$artifacts_location"
+
+    make -C "$gdb_build_dir" install "DESTDIR=$temp_artifacts_dir" 1>&2
+    if [[ $? -ne 0 ]]; then
+        rm -rf "$temp_artifacts_dir"
+        return 1
+    fi
+
+    while read file; do
+        cp "$file" "$artifacts_location/"
+    done < <(find "$temp_artifacts_dir/usr/local/bin" -type f -executable)
+
+    rm -rf "$temp_artifacts_dir"
+}
+
+function build_and_install_gdb() {
+    # Build gdb and install it to an artifacts directory.
+    #
+    # Parameters:
+    # $1: gdb package directory
+    # $2: libiconv prefix
+    # $3: libgmp prefix
+    # $4: libmpfr prefix
+    # $5: whether to build with python or not
+    # $6: install directory
+    # $7: target architecture
+    #
+    # Returns:
+    # 0: success
+    # 1: failure
+
+    local gdb_dir="$1"
+    local libiconv_prefix="$2"
+    local libgmp_prefix="$3"
+    local libmpfr_prefix="$4"
+    local with_python="$5"
+    local artifacts_dir="$6"
+    local target_arch="$7"
+
+    gdb_build_dir="$(build_gdb "$gdb_dir" "$target_arch" "$libiconv_prefix" "$libgmp_prefix" "$libmpfr_prefix" "$with_python")"
+    if [[ $? -ne 0 ]]; then
+        return 1
+    fi
+
+    install_gdb "$gdb_build_dir" "$artifacts_dir" "$target_arch" "$with_python"
+    if [[ $? -ne 0 ]]; then
+        return 1
+    fi
+}
+
+function build_gdb_with_dependencies() {
+    # Build gdb for a specific target architecture.
+    #
+    # Parameters:
+    # $1: target architecture
+    # $2: build directory
+    # $3: src directory
+    # $4: whether to build gdb with python or not
+
+    local target_arch="$1"
+    local build_dir="$2"
+    local source_dir="$3"
+    local with_python="$4"
+    local packages_dir="$build_dir/packages"
+    local artifacts_dir="$build_dir/artifacts"
+
+    set_compliation_variables "$target_arch"
+    if [[ $? -ne 0 ]]; then
+        return 1
+    fi
+
+    mkdir -p "$packages_dir"
+
+    iconv_build_dir="$(build_iconv "$packages_dir/libiconv" "$target_arch")"
+    if [[ $? -ne 0 ]]; then
+        return 1
+    fi
+
+    gmp_build_dir="$(build_libgmp "$packages_dir/gmp" "$target_arch")"
+    if [[ $? -ne 0 ]]; then
+        return 1
+    fi
+
+    mpfr_build_dir="$(build_libmpfr "$packages_dir/mpfr" "$gmp_build_dir" "$target_arch")"
+    if [[ $? -ne 0 ]]; then
+        return 1
+    fi
+
+    ncursesw_build_dir="$(build_ncurses "$packages_dir/ncurses" "$target_arch")"
+    if [[ $? -ne 0 ]]; then
+        return 1
+    fi
+    set_ncurses_link_variables "$ncursesw_build_dir"
+
+    if [[ "$with_python" == "yes" ]]; then
+        build_python "$packages_dir/cpython-static" "$target_arch"
+        if [[ $? -ne 0 ]]; then
+            return 1
+        fi
+    fi
+
+    build_and_install_gdb "$packages_dir/binutils-gdb" \
+                          "$iconv_build_dir/lib/.libs/" \
+                          "$gmp_build_dir/.libs/" \
+                          "$mpfr_build_dir/src/.libs/" \
+                          "$with_python" \
+                          "$artifacts_dir" \
+                          "$target_arch"
+    if [[ $? -ne 0 ]]; then
+        return 1
+    fi
+}
+
+function main() {
+    if [[ $# -lt 3 ]]; then
+        >&2 echo "Usage: $0 <target_arch> <build_dir> <src_dir> [--with-python]"
+        exit 1
+    fi
+
+    local with_python="no"
+    if [[ "$4" == "--with-python" ]]; then
+        with_python="yes"
+    fi
+
+    build_gdb_with_dependencies "$1" "$2" "$3" "$with_python"
+    if [[ $? -ne 0 ]]; then
+        >&2 echo "Error: failed to build gdb with dependencies"
+        exit 1
+    fi
+}
+
+main "$@"

src/compilation/download_packages.sh

@@ -0,0 +1,221 @@
+#!/bin/bash
+
+# Include utils library
+script_dir=$(dirname "$0")
+source "$script_dir/utils.sh"
+
+# List of package URLs to download
+SOURCE_URLS=(
+    "https://ftp.gnu.org/pub/gnu/libiconv/libiconv-1.17.tar.gz"
+    "https://ftp.gnu.org/pub/gnu/gmp/gmp-6.3.0.tar.xz"
+    "https://ftp.gnu.org/pub/gnu/mpfr/mpfr-4.2.1.tar.xz"
+    "https://ftp.gnu.org/pub/gnu/ncurses/ncurses-6.5.tar.gz"
+)
+
+function unpack_tarball() {
+    # Unpack a tarball based on its extension.
+    # Supported extensions: tar, gz, xz.
+    #
+    # Parameters:
+    # $1: tarball
+    #
+    # Returns:
+    # 0: success
+    # 1: failure
+
+    local tarball="$1"
+    local extension="${tarball##*.}"
+
+    if [[ ! -f "$tarball" ]]; then
+        >&2 echo "Error: $tarball does not exist"
+        return 1
+    fi
+
+    case "$extension" in
+        tar | xz)
+            tar xf "$tarball"
+            ;;
+        gz)
+            tar xzf "$tarball"
+            ;;
+        *)
+            >&2 echo "Error: unknown extension $extension"
+            return 1
+            ;;
+    esac
+
+    if [[ $? -ne 0 ]]; then
+        >&2 echo "Error: failed to unpack $tarball"
+        return 1
+    fi
+}
+
+function download_package() {
+    # Download a package. Will skip download if the output file already exists.
+    #
+    # Parameters:
+    # $1: URL of the package
+    # $2: output file
+    #
+    # Returns:
+    # 0: success
+    # 1: failure
+
+    local url="$1"
+    local output="$2"
+
+    if [[ -f "$output" ]]; then
+        >&2 echo "Skipping download: $output already exists"
+        return 0
+    fi
+
+    wget "$url" -O "$output"
+    if [[ $? -ne 0 ]]; then
+        >&2 echo "Error: failed to download $url"
+        return 1
+    fi
+}
+
+function extract_package() {
+    # Extract a package. Will skip extraction if the package directory already exists.
+    #
+    # Parameters:
+    # $1: package tarball
+    # $2: output directory
+    #
+    # Returns:
+    # 0: success
+    # 1: failure
+
+    local tarball="$1"
+    local output_dir="$2"
+    local package_dir="${tarball%.tar*}"
+    local tarball_realpath="$(realpath "$tarball")"
+    local temp_dir="$(mktemp -d)"
+
+    if [[ ! -f "$tarball" ]]; then
+        >&2 echo "Error: $tarball does not exist"
+        return 1
+    fi
+
+    if [[ -d "$output_dir" ]]; then
+        >&2 echo "Skipping extraction: $output_dir already exists"
+        return 0
+    fi
+
+    pushd "$temp_dir" > /dev/null
+
+    unpack_tarball "$tarball_realpath"
+    if [[ $? -ne 0 ]]; then
+        popd > /dev/null
+        return 1
+    fi
+
+    popd > /dev/null
+
+    mv "$temp_dir/$package_dir" "$output_dir"
+    if [[ $? -ne 0 ]]; then
+        return 1
+    fi
+
+    rm -rf "$temp_dir"
+}
+
+function download_and_extract_package() {
+    # Download and extract a package.
+    #
+    # Parameters:
+    # $1: URL of the package
+    # $2: output directory
+    #
+    # Returns:
+    # 0: success
+    # 1: failure
+
+    local url="$1"
+    local output_dir="$2"
+    local tarball=$(basename "$url")
+
+    download_package "$url" "$tarball"
+    if [[ $? -ne 0 ]]; then
+        return 1
+    fi
+
+    extract_package "$tarball" "$output_dir"
+    if [[ $? -ne 0 ]]; then
+        return 1
+    fi
+}
+
+function package_url_to_dir() {
+    # Convert a package URL to a directory name.
+    #
+    # Parameters:
+    # $1: package URL
+    #
+    # Echoes:
+    # The package directory name
+    #
+    # Returns:
+    # 0: success
+    # 1: failure
+
+    local url="$1"
+
+    # The name of the package is the basename of the URL without the version number.
+    local package_dir=$(basename "$url")
+    package_dir="${package_dir%%-*}"
+
+    echo "$package_dir"
+}
+
+function download_gdb_packages() {
+    # Download and extract all required packages for building GDB.
+    #
+    # Parameters:
+    # $1: packages directory
+    #
+    # Returns:
+    # 0: success
+    # 1: failure
+
+    local packages_dir="$1"
+    pushd "$packages_dir"
+
+    # Run downloads in parallel
+    download_pids=()
+
+    fancy_title "Starting download of GDB packages"
+
+    for url in "${SOURCE_URLS[@]}"; do
+        package_dir=$(package_url_to_dir "$url")
+        download_and_extract_package "$url" "$package_dir" &
+        download_pids+=($!)
+    done
+
+    for pid in "${download_pids[@]}"; do
+        wait "$pid"
+        if [[ $? -ne 0 ]]; then
+            popd
+            return 1
+        fi
+    done
+
+    fancy_title "Finished downloading GDB packages"
+    popd
+}
+
+function main() {
+    if [[ $# -ne 1 ]]; then
+        >&2 echo "Usage: $0 <packages_dir>"
+        exit 1
+    fi
+
+    download_gdb_packages "$1"
+    if [[ $? -ne 0 ]]; then
+        >&2 echo "Error: failed to download GDB packages"
+        exit 1
+    fi
+}
+
+main "$@"

src/compilation/utils.sh

@@ -0,0 +1,67 @@
+#!/bin/bash
+
+GREEN="\033[0;32m"
+BOLD="\033[1m"
+RESET="\033[0m"
+
+function print_centered() {
+    # Print a string centered in the terminal.
+    #
+    # Parameters:
+    # $1: string
+    # $2: line width
+    #
+    # Returns:
+    # 0: success
+
+    local string="$1"
+    local length=${#string}
+
+    printf "%*s\n" $((($2 + length) / 2)) "$string"
+}
+
+function fancy_title() {
+    # Print a fancy title.
+    # The title is centered and surrounded by a line of dashes.
+    #
+    # Parameters:
+    # $1: title
+    #
+    # Returns:
+    # 0: success
+
+    local title="$1"
+    local length=80
+    local maximum_title_length=60
+
+    # Set color to green and bold
+    tput setaf 2
+    tput bold
+
+    printf "%${length}s\n" | tr ' ' -
+
+    # Split the title into words and print them centered
+    IFS=' ' read -r -a words <<< "$title"
+
+    line=""
+    for word in "${words[@]}"; do
+        if [[ ${#line} -eq 0 ]]; then
+            line="$word"
+        elif [[ $(( ${#line} + ${#word} + 1 )) -gt $maximum_title_length ]]; then
+            print_centered "$line" "$length"
+            line="$word"
+        else
+            line="$line $word"
+        fi
+    done
+
+    # Print the last line
+    if [[ ${#line} -gt 0 ]]; then
+        print_centered "$line" "$length"
+    fi
+
+    printf "%${length}s\n" | tr ' ' -
+
+    # Reset color and style
+    tput sgr0
+}