Rewrite build script

build.sh

@@ -1,10 +1,10 @@
 #!/bin/bash
 # PROJECT:     XTchain
 # LICENSE:     See the COPYING.md in the top level directory
-# FILE:        build-linux.sh
+# FILE:        build.sh
-# DESCRIPTION: Toolchain building and assembly script
+# DESCRIPTION: Toolchain crosscompilation and assembly script
 # DEVELOPERS:  Rafal Kupiec <belliash@codingworkshop.eu.org>
-
+#              Aiken Harris <harraiken91@gmail.com>
 
 # Working Directories
 BINDIR="$(pwd)/binaries"
@@ -16,6 +16,14 @@ WRKDIR="$(pwd)"
 ARCHS="aarch64 armv7 i686 x86_64"
 GENERIC="generic-w64-mingw32"
 
+# Default Configuration
+BUILD_JOBS=0
+CLEAN_BUILD=0
+ENABLE_LLVM_ASSEMBLY=0
+LLVM_DYNAMIC_LINK=ON
+SYSTEM_NAME=Linux
+TARGET_SYSTEM=linux
+
 # CMake Settings
 CMAKEDIR="${SRCDIR}/cmake"
 CMAKETAG="v3.31.3"
@@ -23,21 +31,9 @@ CMAKEVCS="https://gitlab.kitware.com/cmake/cmake.git"
 
 # LLVM Settings
 LLVMDIR="${SRCDIR}/llvm"
-LLVMTAG="llvmorg-19.1.6"
+LLVMTAG="llvmorg-20.1.7"
 LLVMVCS="https://github.com/llvm/llvm-project.git"
 
-# Make Settings
-MAKEDIR="${SRCDIR}/make"
-MAKETAG="4.4.1"
-MAKEVCS="git://git.savannah.gnu.org/make"
-
-# Mingw-w64 Settings
-MINGWDIR="${SRCDIR}/mingw-w64"
-MINGWLIB="ucrt"
-MINGWTAG="master"
-MINGWNTV="0x601"
-MINGWVCS="https://github.com/mirror/mingw-w64.git"
-
 # Ninja Settings
 NINJADIR="${SRCDIR}/ninja"
 NINJATAG="v1.12.1"
@@ -45,10 +41,11 @@ NINJAVCS="https://github.com/ninja-build/ninja.git"
 
 # Wine Settings
 WINEDIR="${SRCDIR}/wine"
-WINETAG="wine-9.8"
+WINETAG="wine-10.11"
 WINEVCS="https://github.com/wine-mirror/wine.git"
 
 
+
 # This function applies a patches to the 3rd party project
 apply_patches()
 {
@@ -77,16 +74,33 @@ apply_patches()
 # This function compiles and installs CMAKE
 cmake_build()
 {
+    local CMAKE_PARAMETERS=""
+
+    # Clean old build if necessary
+    [ "${CLEAN_BUILD}" -eq 1 ] && rm -rf ${WINEDIR}/build-${GENERIC}
+
+    # Additional, target-specific configuration options
+    case "${SYSTEM_NAME}" in
+        Windows)
+            CMAKE_PARAMETERS="${CMAKE_PARAMETERS} -DCMAKE_C_COMPILER=${SYSTEM_HOST}-gcc -DCMAKE_CXX_COMPILER=${SYSTEM_HOST}-g++"
+            CMAKE_PARAMETERS="${CMAKE_PARAMETERS} -DCMAKE_RC_COMPILER=${SYSTEM_HOST}-windres"
+            ;;
+    esac
+
+        # Build CMake
     echo ">>> Building CMAKE ..."
-    [ -z ${CLEAN} ] || rm -rf ${CMAKEDIR}/build-${GENERIC}
     mkdir -p ${CMAKEDIR}/build-${GENERIC}
     cd ${CMAKEDIR}/build-${GENERIC}
-    ../bootstrap \
+    cmake \
-        --prefix=${BINDIR} \
+        -DCMAKE_BUILD_TYPE=Release \
-        --parallel=${CORES} \
+        -DCMAKE_FIND_ROOT_PATH_MODE_INCLUDE=ONLY \
-        -- -DCMAKE_USE_OPENSSL=OFF
+        -DCMAKE_FIND_ROOT_PATH_MODE_LIBRARY=ONLY \
-    make -j${CORES}
+        -DCMAKE_FIND_ROOT_PATH_MODE_PROGRAM=NEVER \
-    make install
+        -DCMAKE_SYSTEM_NAME=${SYSTEM_NAME} \
+        -DCMAKE_USE_OPENSSL=OFF \
+        ${CMAKE_PARAMETERS} \
+        ..
+    cmake --build .
     cd ${WRKDIR}
 }
 
@@ -105,9 +119,13 @@ cmake_fetch()
 # This function compiles and install LLVM
 llvm_build()
 {
-    echo ">>> Building LLVM ..."
+    local CMAKE_PARAMETERS=""
-    [ -z ${CLEAN} ] || rm -rf ${LLVMDIR}/llvm/build
+    local LLVM_ARCHS=()
-    LLVM_ARCHS=()
+
+    # Clean old build if necessary
+    [ "${CLEAN_BUILD}" -eq 1 ] && rm -rf ${LLVMDIR}/llvm/build
+
+    # Set supported architectures
     for ARCH in ${ARCHS}; do
         case ${ARCH} in
             "aarch64")
@@ -122,6 +140,25 @@ llvm_build()
         esac
     done
     LLVM_ARCHS=( $(for ARCH in ${LLVM_ARCHS[@]}; do echo ${ARCH}; done | sort -u) )
+
+    # Disable LLVM assembly files (like BLAKE3 support) if not specified otherwise
+    if [ "${ENABLE_LLVM_ASSEMBLY}" -ne 1 ]; then
+        CMAKE_PARAMETERS="${CMAKE_PARAMETERS} -DLLVM_DISABLE_ASSEMBLY_FILES=ON"
+    fi
+
+    # Additional, target-specific configuration options
+    case "${SYSTEM_NAME}" in
+        Windows)
+            CMAKE_PARAMETERS="${CMAKE_PARAMETERS} -DCMAKE_EXE_LINKER_FLAGS=-lpthread -DCMAKE_SHARED_LINKER_FLAGS=-lpthread"
+            CMAKE_PARAMETERS="${CMAKE_PARAMETERS} -DCMAKE_C_COMPILER_TARGET=${SYSTEM_HOST} -DCMAKE_CXX_COMPILER_TARGET=${SYSTEM_HOST}"
+            CMAKE_PARAMETERS="${CMAKE_PARAMETERS} -DCMAKE_RC_COMPILER=${SYSTEM_HOST}-windres -DLLVM_HOST_TRIPLE=${SYSTEM_HOST}"
+            CMAKE_PARAMETERS="${CMAKE_PARAMETERS} -DCMAKE_FIND_ROOT=$(dirname $(readlink -f $(command -v ${SYSTEM_HOST}-windres)))/../${SYSTEM_HOST}"
+            CMAKE_PARAMETERS="${CMAKE_PARAMETERS} -DCMAKE_CXX_FLAGS=-femulated-tls"
+            ;;
+    esac
+
+    # Build LLVM
+    echo ">>> Building LLVM ..."
     cd ${LLVMDIR}/llvm/tools
     for UTIL in clang lld; do
         if [ ! -e ${UTIL} ]; then
@@ -132,101 +169,32 @@ llvm_build()
     cd ${LLVMDIR}/llvm/build
     cmake -G Ninja \
         -DCMAKE_BUILD_TYPE="Release" \
+        -DCMAKE_C_COMPILER=clang \
+        -DCMAKE_CXX_COMPILER=clang++ \
+        -DCMAKE_FIND_ROOT_PATH_MODE_INCLUDE=ONLY \
+        -DCMAKE_FIND_ROOT_PATH_MODE_LIBRARY=ONLY \
+        -DCMAKE_FIND_ROOT_PATH_MODE_PACKAGE=ONLY \
+        -DCMAKE_FIND_ROOT_PATH_MODE_PROGRAM=NEVER \
         -DCMAKE_INSTALL_PREFIX=${BINDIR} \
-        -DLLDB_INCLUDE_TESTS=FALSE \
+        -DCMAKE_SYSTEM_NAME="${SYSTEM_NAME}" \
-        -DLLVM_ENABLE_ASSERTIONS=FALSE \
+        -DLLDB_INCLUDE_TESTS=OFF \
+        -DLLVM_ENABLE_ASSERTIONS=OFF \
         -DLLVM_ENABLE_PROJECTS="clang;clang-tools-extra;lld;lldb" \
         -DLLVM_INSTALL_TOOLCHAIN_ONLY=ON \
-        -DLLVM_LINK_LLVM_DYLIB=ON \
+        -DLLVM_BUILD_INSTRUMENTED=OFF \
+        -DLLVM_LINK_LLVM_DYLIB=${LLVM_DYNAMIC_LINK} \
         -DLLVM_TARGETS_TO_BUILD="$(echo ${LLVM_ARCHS[@]} | tr ' ' ';')" \
-        -DLLVM_TOOLCHAIN_TOOLS="llvm-addr2line;llvm-ar;llvm-as;llvm-cov;llvm-cvtres;llvm-dlltool;llvm-lib;llvm-ml;llvm-nm;llvm-objdump;llvm-objcopy;llvm-pdbutil;llvm-profdata;llvm-ranlib;llvm-rc;llvm-readelf;llvm-readobj;llvm-strings;llvm-strip;llvm-symbolizer;llvm-windres" \
+        -DLLVM_TOOLCHAIN_TOOLS="llvm-addr2line;llvm-ar;llvm-as;llvm-cov;llvm-cvtres;llvm-cxxfilt;llvm-dlltool;llvm-lib;llvm-ml;llvm-nm;llvm-objdump;llvm-objcopy;llvm-pdbutil;llvm-profdata;llvm-ranlib;llvm-rc;llvm-readelf;llvm-readobj;llvm-size;llvm-strings;llvm-strip;llvm-symbolizer;llvm-windres" \
+        -DLLVM_USE_LINKER=lld \
+        -DLLDB_ENABLE_PYTHON=OFF \
+        ${CMAKE_PARAMETERS} \
         ..
     ninja install/strip
     cd ${WRKDIR}
+#-DLLVM_NATIVE_TOOL_DIR=/usr/sbin
 }
 
-# This function compiles and install LIBCXX & LIBUNWIND
+ # This function downloads LLVM from VCS
-llvm_build_libs()
-{
-    echo ">>> Building LLVM libraries (libcxx) ..."
-    for ARCH in ${ARCHS}; do
-        [ -z ${CLEAN} ] || rm -rf ${LLVMDIR}/runtimes/build-${ARCH}
-        mkdir -p ${LLVMDIR}/runtimes/build-${ARCH}
-        cd ${LLVMDIR}/runtimes/build-${ARCH}
-        cmake -G Ninja \
-            -DCMAKE_BUILD_TYPE="Release" \
-            -DCMAKE_INSTALL_PREFIX="${BINDIR}/${ARCH}-w64-mingw32" \
-            -DCMAKE_AR="${BINDIR}/bin/llvm-ar" \
-            -DCMAKE_C_COMPILER="${BINDIR}/bin/${ARCH}-w64-mingw32-clang" \
-            -DCMAKE_C_COMPILER_WORKS=1 \
-            -DCMAKE_C_FLAGS_INIT=-mguard=cf \
-            -DCMAKE_CXX_COMPILER="${BINDIR}/bin/${ARCH}-w64-mingw32-clang++" \
-            -DCMAKE_CXX_COMPILER_TARGET=${ARCH}-w64-windows-gnu \
-            -DCMAKE_CXX_COMPILER_WORKS=1 \
-            -DCMAKE_CXX_FLAGS_INIT=-mguard=cf \
-            -DCMAKE_CROSSCOMPILING=TRUE \
-            -DCMAKE_RANLIB="${BINDIR}/bin/llvm-ranlib" \
-            -DCMAKE_SYSTEM_NAME="Windows" \
-            -DLLVM_PATH="${LLVMDIR}/llvm" \
-            -DLLVM_ENABLE_RUNTIMES="libunwind;libcxxabi;libcxx" \
-            -DLIBUNWIND_USE_COMPILER_RT=TRUE \
-            -DLIBUNWIND_ENABLE_SHARED=TRUE \
-            -DLIBUNWIND_ENABLE_STATIC=TRUE \
-            -DLIBCXX_USE_COMPILER_RT=ON \
-            -DLIBCXX_ENABLE_SHARED=TRUE \
-            -DLIBCXX_ENABLE_STATIC=TRUE \
-            -DLIBCXX_ENABLE_EXPERIMENTAL_LIBRARY=OFF \
-            -DLIBCXX_ENABLE_STATIC_ABI_LIBRARY=TRUE \
-            -DLIBCXX_CXX_ABI="libcxxabi" \
-            -DLIBCXX_LIBDIR_SUFFIX="" \
-            -DLIBCXX_INCLUDE_TESTS=FALSE \
-            -DLIBCXX_ENABLE_ABI_LINKER_SCRIPT=FALSE \
-            -DLIBCXXABI_USE_COMPILER_RT=ON \
-            -DLIBCXXABI_ENABLE_SHARED=OFF \
-            -DLIBCXXABI_LIBDIR_SUFFIX="" \
-            -DLIBCXXABI_USE_LLVM_UNWINDER=ON \
-            ..
-        ninja
-        ninja install
-    done
-    cd ${WRKDIR}
-}
-
-# This function compiles and install LLVM runtime
-llvm_build_runtime()
-{
-    echo ">>> Building LLVM compiler runtime ..."
-    for ARCH in ${ARCHS}; do
-        [ -z ${CLEAN} ] || rm -rf ${LLVMDIR}/compiler-rt/build-${ARCH}
-        mkdir -p ${LLVMDIR}/compiler-rt/build-${ARCH}
-        cd ${LLVMDIR}/compiler-rt/build-${ARCH}
-        cmake -G Ninja \
-            -DCMAKE_BUILD_TYPE="Release" \
-            -DCMAKE_AR="${BINDIR}/bin/llvm-ar" \
-            -DCMAKE_C_COMPILER="${BINDIR}/bin/${ARCH}-w64-mingw32-clang" \
-            -DCMAKE_C_COMPILER_TARGET="${ARCH}-windows-gnu" \
-            -DCMAKE_C_FLAGS_INIT="-mguard=cf" \
-            -DCMAKE_CXX_COMPILER="${BINDIR}/bin/${ARCH}-w64-mingw32-clang++" \
-            -DCMAKE_CXX_FLAGS_INIT="-mguard=cf" \
-            -DCMAKE_FIND_ROOT_PATH="${BINDIR}/${ARCH}-w64-mingw32" \
-            -DCMAKE_FIND_ROOT_PATH_MODE_INCLUDE=ONLY \
-            -DCMAKE_FIND_ROOT_PATH_MODE_PACKAGE=ONLY \
-            -DCMAKE_INSTALL_PREFIX=$(${BINDIR}/bin/${ARCH}-w64-mingw32-clang --print-resource-dir) \
-            -DCMAKE_RANLIB="${BINDIR}/bin/llvm-ranlib" \
-            -DCMAKE_SYSTEM_NAME="Windows" \
-            -DCOMPILER_RT_BUILD_BUILTINS=TRUE \
-            -DCOMPILER_RT_DEFAULT_TARGET_ONLY=TRUE \
-            -DCOMPILER_RT_USE_BUILTINS_LIBRARY=TRUE \
-            -DLLVM_CONFIG_PATH="" \
-            -DSANITIZER_CXX_ABI="libc++" \
-            ../lib/builtins
-            ninja
-            ninja install
-    done
-    cd ${WRKDIR}
-}
-
-# This function downloads LLVM from VCS
 llvm_fetch()
 {
     if [ ! -d ${LLVMDIR} ]; then
@@ -238,170 +206,31 @@ llvm_fetch()
     fi
 }
 
-# This function compiles and install MAKE
-make_build()
-{
-    echo ">>> Building Make ..."
-    [ -z ${CLEAN} ] || rm -rf ${MAKEDIR}/build
-    cd ${MAKEDIR}
-    ./bootstrap
-    sed -i "s/-Werror//" maintMakefile
-    mkdir -p ${MAKEDIR}/build
-    cd ${MAKEDIR}/build
-    ../configure \
-        --prefix=${BINDIR} \
-        --disable-dependency-tracking \
-        --disable-silent-rules \
-        --program-prefix=g \
-        --without-guile
-    make -j${CORES}
-    make install
-    if [ ! -e ${BINDIR}/bin/make ]; then
-        ln -sf gmake ${BINDIR}/bin/make
-    fi
-    cd ${WRKDIR}
-}
-
-# This function downloads MAKE from VCS
-make_fetch()
-{
-    if [ ! -d ${MAKEDIR} ]; then
-        echo ">>> Downloading Make ..."
-        git clone --depth 1 --branch ${MAKETAG} ${MAKEVCS} ${MAKEDIR}
-        cd ${MAKEDIR}
-        apply_patches ${MAKEDIR##*/} ${MAKETAG}
-        cd ${WRKDIR}
-    fi
-}
-
-# This function compiles and installs MINGW CRT
-mingw_build_crt()
-{
-    for ARCH in ${ARCHS}; do
-        echo ">>> Building Mingw-W64 (CRT) for ${ARCH} ..."
-        [ -z ${CLEAN} ] || rm -rf ${MINGWDIR}/mingw-w64-crt/build-${ARCH}
-        mkdir -p ${MINGWDIR}/mingw-w64-crt/build-${ARCH}
-        cd ${MINGWDIR}/mingw-w64-crt/build-${ARCH}
-        case ${ARCH} in
-            "aarch64")
-                FLAGS="--disable-lib32 --disable-lib64 --enable-libarm64"
-                ;;
-            "armv7")
-                FLAGS="--disable-lib32 --disable-lib64 --enable-libarm32"
-                ;;
-            "i686")
-                FLAGS="--enable-lib32 --disable-lib64"
-                ;;
-            "x86_64")
-                FLAGS="--disable-lib32 --enable-lib64"
-                ;;
-        esac
-        ORIGPATH="${PATH}"
-        PATH="${BINDIR}/bin:${PATH}"
-        ../configure \
-            --host=${ARCH}-w64-mingw32 \
-            --prefix=${BINDIR}/${ARCH}-w64-mingw32 \
-            --with-sysroot=${BINDIR} \
-            --with-default-msvcrt=${MINGWLIB} \
-            --enable-cfguard \
-            ${FLAGS}
-        make -j${CORES}
-        make install
-        PATH="${ORIGPATH}"
-    done
-    cd ${WRKDIR}
-}
-
-# This function compiles and installs MINGW headers
-mingw_build_headers()
-{
-    echo ">>> Building Mingw-W64 (headers) ..."
-    [ -z ${CLEAN} ] || rm -rf ${MINGWDIR}/mingw-w64-headers/build-${GENERIC}
-    mkdir -p ${MINGWDIR}/mingw-w64-headers/build-${GENERIC}
-    cd ${MINGWDIR}/mingw-w64-headers/build-${GENERIC}
-    ../configure \
-        --prefix=${BINDIR}/${GENERIC} \
-        --enable-idl \
-        --with-default-msvcrt=${MINGWLIB} \
-        --with-default-win32-winnt=${MINGWNTV}
-    make -j${CORES}
-    make install
-    for ARCH in ${ARCHS}; do
-        mkdir -p ${BINDIR}/${ARCH}-w64-mingw32
-        if [ ! -e ${BINDIR}/${ARCH}-w64-mingw32/include ]; then
-            ln -sfn ../${GENERIC}/include ${BINDIR}/${ARCH}-w64-mingw32/include
-        fi
-    done
-    cd ${WRKDIR}
-}
-
-# This function compiles and install MINGW libraries
-mingw_build_libs()
-{
-    for LIB in libmangle winpthreads winstorecompat; do
-        echo ">>> Building Mingw-w64 (libs) for ${ARCH} ..."
-        for ARCH in ${ARCHS}; do
-            [ -z ${CLEAN} ] || rm -rf ${MINGWDIR}/mingw-w64-libraries/${LIB}/build-${ARCH}
-            mkdir -p ${MINGWDIR}/mingw-w64-libraries/${LIB}/build-${ARCH}
-            cd ${MINGWDIR}/mingw-w64-libraries/${LIB}/build-${ARCH}
-            ORIGPATH="${PATH}"
-            PATH="${BINDIR}/bin:${PATH}"
-            ../configure \
-                --host=${ARCH}-w64-mingw32 \
-                --prefix=${BINDIR}/${ARCH}-w64-mingw32 \
-                --libdir=${BINDIR}/${ARCH}-w64-mingw32/lib \
-                CFLAGS="-O2 -mguard=cf" \
-                CXXFLAGS="-O2 -mguard=cf"
-            make -j${CORES}
-            make install
-            PATH="${ORIGPATH}"
-        done
-    done
-    cd ${WRKDIR}
-}
-
-# This function compiles and installs MINGW tools
-mingw_build_tools()
-{
-    for TOOL in gendef genidl genpeimg widl; do
-        for ARCH in ${ARCHS}; do
-            echo ">>> Building Mingw-w64 (tools) for ${ARCH} ..."
-            [ -z ${CLEAN} ] || rm -rf ${MINGWDIR}/mingw-w64-tools/${TOOL}/build-${ARCH}
-            mkdir -p ${MINGWDIR}/mingw-w64-tools/${TOOL}/build-${ARCH}
-            cd ${MINGWDIR}/mingw-w64-tools/${TOOL}/build-${ARCH}
-            ../configure \
-                --target=${ARCH}-w64-mingw32 \
-                --prefix=${BINDIR}
-            make -j${CORES}
-            make install
-            if [ -e ${BINDIR}/bin/${TOOL} ]; then
-                mv ${BINDIR}/bin/${TOOL} ${BINDIR}/bin/${ARCH}-w64-mingw32-${TOOL}
-            fi
-        done
-    done
-    cd ${WRKDIR}
-}
-
-# This function downloads MINGW from VCS
-mingw_fetch()
-{
-    if [ ! -d ${MINGWDIR} ]; then
-        echo ">>> Downloading MinGW-w64 ..."
-        git clone --depth 1 --branch ${MINGWTAG} ${MINGWVCS} ${MINGWDIR}
-        cd ${MINGWDIR}
-        apply_patches ${MINGWDIR##*/} ${MINGWTAG}
-        cd ${WRKDIR}
-    fi
-}
-
 # This function compiles and installs NINJA
 ninja_build()
 {
+    local NINJA_CXX_COMPILER=""
+    local NINJA_PLATFORM=""
+
+    # Clean old build if necessary
+    [ "${CLEAN_BUILD}" -eq 1 ] && rm -rf ${NINJADIR}/build-${GENERIC}
+
+    # Additional, target-specific configuration options
+    case "${SYSTEM_NAME}" in
+        Windows)
+            NINJA_CXX_COMPILER="${SYSTEM_HOST}-g++"
+            NINJA_PLATFORM="mingw"
+            ;;
+        *)
+            NINJA_PLATFORM="linux"
+            ;;
+    esac
+
+    # Build Ninja
     echo ">>> Building NINJA ..."
-    [ -z ${CLEAN} ] || rm -rf ${NINJADIR}/build-${GENERIC}
     mkdir -p ${NINJADIR}/build-${GENERIC}
     cd ${NINJADIR}/build-${GENERIC}
-    ../configure.py --bootstrap
+    CXX=${NINJA_CXX_COMPILER} ../configure.py --platform=${NINJA_PLATFORM}
     install ninja ${BINDIR}/bin/
     cd ${WRKDIR}
 }
@@ -418,24 +247,84 @@ ninja_fetch()
     fi
 }
 
+# Performs requirements check and prepares environment
+prepare_environment()
+{
+    # Verify that the number of build jobs is a positive integer
+    if [ -z "${BUILD_JOBS##*[!0-9]*}" ]; then
+        echo "ERROR: Invalid number of jobs provided. Please enter a positive integer."
+        exit 1
+    fi
+
+    # Verify that all required tools are installed
+    for APP in {clang,clang++,cmake,lld,ninja,x86_64-w64-mingw32-windres}; do
+        which ${APP} &> /dev/null
+        if [ $? -ne 0 ]; then
+            echo "ERROR: ${APP} not found. Please install the required tool."
+            exit 2
+        fi
+    done
+
+    # Set target-specific options
+    case "${TARGET_SYSTEM}" in
+        windows|*-mingw32)
+            SYSTEM_NAME="Windows"
+            SYSTEM_HOST="x86_64-w64-mingw32"
+            ;;
+        linux|*-linux-*)
+            SYSTEM_NAME="Linux"
+            ;;
+        *)
+            echo "ERROR: Invalid target system specified. Please choose a valid target system."
+            exit 3
+            ;;
+    esac
+}
+
+# Prints usage help
+print_usage()
+{
+    echo "USAGE: ${0} [--clean] [--enable-llvm-assembly] [--jobs=N] [--static-llvm] [--target={linux,windows}]"
+    exit 1
+}
+
 # This function compiles and install WINE tools
 wine_build()
 {
+    local CONFIGURE_PARAMETERS=""
+
+    # Clean old build if necessary
+    [ "${CLEAN_BUILD}" -eq 1 ] && rm -rf ${WINEDIR}/{build-${GENERIC},build-tools}
+
+    # Additional, target-specific configuration options
+    case "${SYSTEM_NAME}" in
+        Windows)
+            CONFIGURE_PARAMETERS="${CONFIGURE_PARAMETERS} --host=${SYSTEM_HOST}"
+            ;;
+    esac
+
+    # Build Wine (first configuration builds makedep)
     echo ">>> Building Wine ..."
-    mkdir -p ${WINEDIR}/build
+    mkdir -p ${WINEDIR}/{build-${GENERIC},build-tools}
-    cd ${WINEDIR}/build
+    cd ${WINEDIR}/build-tools
     ../configure \
-        -enable-win64 \
         --without-freetype \
         --without-x
-    for TOOL in winedump wmc wrc; do
+    cd ${WINEDIR}/build-${GENERIC}
-        make -j${CORES} tools/${TOOL}/all
+    ../configure \
-        cp tools/${TOOL}/${TOOL} ${BINDIR}/bin/
+        --without-freetype \
-        for ARCH in ${ARCHS}; do
+        --without-x \
-            if [ ! -e ${BINDIR}/bin/${ARCH}-w64-mingw32-${TOOL} ]; then
+        --with-wine-tools=${WINEDIR}/build-tools \
-                ln -sf ${TOOL} ${BINDIR}/bin/${ARCH}-w64-mingw32-${TOOL}
+        --enable-tools \
-            fi
+        ${CONFIGURE_PARAMETERS}
-        done
+    for TOOL in widl wmc wrc; do
+        make -j20 tools/${TOOL}/all
+#        cp tools/${TOOL}/${TOOL} ${BINDIR}/bin/
+#        for ARCH in ${ARCHS}; do
+#            if [ ! -e ${BINDIR}/bin/${ARCH}-w64-mingw32-${TOOL} ]; then
+#                ln -sf ${TOOL} ${BINDIR}/bin/${ARCH}-w64-mingw32-${TOOL}
+#            fi
+#        done
     done
     cd ${WRKDIR}
 }
@@ -455,26 +344,27 @@ wine_fetch()
 # This function installs XTCHAIN scripts, wrappers and symlinks
 xtchain_build()
 {
+    # Build XTChain
     echo ">>> Building XTchain ..."
     mkdir -p ${BINDIR}/bin
     mkdir -p ${BINDIR}/lib/xtchain
     mkdir -p ${BINDIR}/${GENERIC}/bin
     cp ${WRKDIR}/scripts/*-wrapper ${BINDIR}/${GENERIC}/bin
     for ARCH in ${ARCHS}; do
-        for EXEC in c++ c11 c99 cc clang clang++ g++ gcc; do
+#        for EXEC in c++ c11 c99 cc clang clang++ g++ gcc; do
-            ln -sf ../${GENERIC}/bin/clang-target-wrapper ${BINDIR}/bin/${ARCH}-w64-mingw32-${EXEC}
+#            ln -sf ../${GENERIC}/bin/clang-target-wrapper ${BINDIR}/bin/${ARCH}-w64-mingw32-${EXEC}
-        done
+#        done
-        for EXEC in addr2line ar as nm objcopy pdbutil ranlib rc strings strip; do
+#        for EXEC in addr2line ar as nm objcopy pdbutil ranlib rc strings strip; do
-            ln -sf llvm-${EXEC} ${BINDIR}/bin/${ARCH}-w64-mingw32-${EXEC}
+#            ln -sf llvm-${EXEC} ${BINDIR}/bin/${ARCH}-w64-mingw32-${EXEC}
-        done
+#        done
-        for EXEC in dlltool ld objdump; do
+#        for EXEC in dlltool ld objdump; do
-            ln -sf ../${GENERIC}/bin/${EXEC}-wrapper ${BINDIR}/bin/${ARCH}-w64-mingw32-${EXEC}
+#            ln -sf ../${GENERIC}/bin/${EXEC}-wrapper ${BINDIR}/bin/${ARCH}-w64-mingw32-${EXEC}
-        done
+#        done
         for EXEC in bin2c exetool windres xtcspecc; do
             if [ ! -e ${BINDIR}/bin/${EXEC} ]; then
                 gcc ${WRKDIR}/tools/${EXEC}.c -o ${BINDIR}/bin/${EXEC}
             fi
-            ln -sf ${EXEC} ${BINDIR}/bin/${ARCH}-w64-mingw32-${EXEC}
+#            ln -sf ${EXEC} ${BINDIR}/bin/${ARCH}-w64-mingw32-${EXEC}
         done
     done
     cp ${WRKDIR}/scripts/xtclib ${BINDIR}/lib/xtchain/
@@ -482,85 +372,71 @@ xtchain_build()
 }
 
 
+
+# Parse all arguments provided to the script
+while [ $# -gt 0 ]; do
+    case "$1" in
+        --clean)
+            # Performs clean build
+            CLEAN_BUILD=1
+            ;;
+        --enable-llvm-assembly)
+            # Enables LLVM asembly files compilation (like BLAKE3)
+            ENABLE_LLVM_ASSEMBLY=1
+            ;;
+        --jobs=*)
+            # Sets number of CPU cores used for compilation
+            BUILD_JOBS="${1#*=}"
+            ;;
+        --static-llvm)
+            # Compiles LLVM statically
+            LLVM_DYNAMIC_LINK=OFF
+            ;;
+        --target=*)
+            # Sets the target system for built toolchain (Linux or Windows)
+            TARGET_SYSTEM="${1#*=}"
+            ;;
+        *)
+            # Prints help if any other parameter given
+            print_usage
+            ;;
+    esac
+    shift
+done
+
+# Prepare environment
+prepare_environment
+
 # Exit immediately on any failure
 set -e
 
 # Check number of CPU cores available
-if [[ ! -n ${CORES} ]]; then
+if [ ${BUILD_JOBS} -eq 0 ]; then
-	: ${CORES:=$(sysctl -n hw.ncpu 2>/dev/null)}
+    unset BUILD_JOBS
-	: ${CORES:=$(nproc 2>/dev/null)}
+    : ${BUILD_JOBS:=$(sysctl -n hw.ncpu 2>/dev/null)}
-	: ${CORES:=1}
+    : ${BUILD_JOBS:=$(nproc 2>/dev/null)}
+    : ${BUILD_JOBS:=1}
 fi
 
 # Create working directories
 mkdir -p ${BINDIR}
 mkdir -p ${SRCDIR}
 
-# XTchain
+# Download and build LLVM
-xtchain_build
+#llvm_fetch
+#llvm_build
 
-# Download LLVM
+# Download and build Wine tools
-llvm_fetch
+#wine_fetch
+#wine_build
 
-# Build and install LLVM
+# Download and build CMake
-llvm_build
+#cmake_fetch
+#cmake_build
 
-# Download Mingw-W64
+# Download and build Ninja
-mingw_fetch
+#ninja_fetch
+#ninja_build
 
-# Build and install Mingw-W64 headers
+# Build XTChain tools
-mingw_build_headers
+#xtchain_build
-
-# Build and install Mingw-W64 CRT
-mingw_build_crt
-
-# Build and install LLVM compiler runtime
-llvm_build_runtime
-
-# Build and install LLVM compiler libraries
-llvm_build_libs
-
-# Build and install Mingw-W64 libraries
-mingw_build_libs
-
-# Build and install Mingw-W64 tools
-mingw_build_tools
-
-# Download Wine
-wine_fetch
-
-# Build and install Wine tools
-wine_build
-
-# Download Make
-make_fetch
-
-# Build and install Make
-make_build
-
-# Download CMake
-cmake_fetch
-
-# Build and install CMake
-cmake_build
-
-# Download Ninja
-ninja_fetch
-
-# Build and install Ninja
-ninja_build
-
-# Remove unneeded files to save disk space
-echo ">>> Removing unneeded files to save disk space ..."
-rm -rf ${BINDIR}/{doc,include,share/{bash-completion,emacs,info,locale,man,vim}}
-rm -rf ${BINDIR}/bin/amdgpu-arch,{clang-{check,exdef-mapping,import-test,offload-*,rename,scan-deps},diagtool,hmaptool,ld64.lld,modularize,nxptx-arch,wasm-ld}
-
-# Save XT Toolchain version
-cd ${WRKDIR}
-: ${XTCVER:=$(git describe --exact-match --tags 2>/dev/null)}
-: ${XTCVER:=DEVEL}
-echo "${XTCVER}" > ${BINDIR}/Version
-
-# Prepare archive
-echo ">>> Creating toolchain archive ..."
-tar -I 'zstd -19' -cpf xtchain-${XTCVER}-linux.tar.zst -C ${BINDIR} .